Fetch a CompositionSettingsInstance

        :returns: Fetched CompositionSettingsInstance
        :rtype: twilio.rest.video.v1.composition_settings.CompositionSettingsInstance
425639
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return CompositionSettingsInstance(self._version, payload, )
872929
def get_composition(source, *fxns):
  """"""
  val = source
  for fxn in fxns:
    val = fxn(val)
  return val
945595
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return PublishedTrackInstance(
            self._version,
            payload,
            room_sid=self._solution['room_sid'],
            participant_sid=self._solution['participant_sid'],
            sid=self._solution['sid'],
        )
323019
function processCompositions( topPage, pageRef ) {

      return processNestedCompositions( topPage, pageRef, null, [] );

      function processNestedCompositions( page, pageRef, instanceId, compositionChain ) {

         page.debugInfo = {
            id: instanceId,
            name: page.name,
            path: page.path,
            //validate: validators.features.pages[ page.name ],
            compositions: [],
            [ FLAT ]: page.definition,
            [ COMPACT ]: deepClone( page.definition )
         };

         let promise = Promise.resolve();

         forEachArea( page, (items, areaName) => {
            items.slice().reverse().forEach( (item, index) => {
               if( item.enabled === false ) {
                  return;
               }
               ensureItemHasId( item );
               if( !has( item, 'composition' ) ) {
                  return;
               }

               const compositionRef = item.composition;
               if( compositionChain.indexOf( compositionRef ) !== -1 ) {
                  const chainString = compositionChain.concat( [ compositionRef ] ).join( ' -> ' );
                  const message = `Cycle in compositions detected: ${chainString}`;
                  throw formatError( topPage, message );
               }

               const itemPointer = `/areas/${areaName}/${items.length - index - 1}`;

               // Compositions must be loaded sequentially, because replacing the widgets in the page needs to
               // take place in order. Otherwise the order of widgets could be messed up.
               promise = promise
                  .then( () => prefixCompositionIds( lookup( compositionRef ), item ) )
                  .then( composition =>
                     processCompositionExpressions( composition, item, itemPointer, pageRef )
                  )
                  .then( composition => {
                     const chain = compositionChain.concat( composition.name );
                     return processNestedCompositions( composition, compositionRef, item.id, chain );
                  } )
                  .then( composition => {
                     page.debugInfo.compositions.push( composition.debugInfo );
                     mergeCompositionAreasWithPageAreas( composition, page.definition, items, item );
                     validateWidgetItems( composition, compositionRef );
                  } );
            } );
         } );

         return promise
            .then( () => page );
      }
   }
1351937
def get_video_image_storage():
    
    if hasattr(settings, 'VIDEO_IMAGE_SETTINGS'):
        return get_storage_class(
            settings.VIDEO_IMAGE_SETTINGS.get('STORAGE_CLASS'),
        )(**settings.VIDEO_IMAGE_SETTINGS.get('STORAGE_KWARGS', {}))
    else:
        # during edx-platform loading this method gets called but settings are not ready yet
        # so in that case we will return default(FileSystemStorage) storage class instance
        return get_storage_class()()
760021
def use_comparative_composition_view(self):
        """"""
        self._object_views['composition'] = COMPARATIVE
        # self._get_provider_session('composition_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_composition_view()
            except AttributeError:
                pass
718218
def get(self, sid):
        
        return RecordingContext(self._version, account_sid=self._solution['account_sid'], sid=sid, )
766764
def get_transcript_preferences(course_id):
    
    try:
        transcript_preference = TranscriptPreference.objects.get(course_id=course_id)
    except TranscriptPreference.DoesNotExist:
        return

    return TranscriptPreferenceSerializer(transcript_preference).data
955256
def get_config(self):
        
        config = {
            'location': self.location,
            'language': self.language,
            'topic': self.topic,
        }
        return config
1119959
def settings_system(self):
        
        response = self._get(url.settings_system)
        self._check_response(response, 200)
        return self._create_response(response)
1078938
def get_configuration(self, uri):
        '''
        
        '''

        req_headers = {
            'Accept': 'application/vnd.onshape.v1+json',
            'Content-Type': 'application/json'
        }
        return self._api.request('get', '/api/partstudios/d/' + uri["did"] + '/' + uri["wvm_type"] + '/' + uri["wvm"] + '/e/' + uri["eid"] + '/configuration', headers=req_headers)
1233815
def use_plenary_composition_view(self):
        """"""
        self._object_views['composition'] = PLENARY
        # self._get_provider_session('composition_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_plenary_composition_view()
            except AttributeError:
                pass
799765
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return EngagementContextInstance(
            self._version,
            payload,
            flow_sid=self._solution['flow_sid'],
            engagement_sid=self._solution['engagement_sid'],
        )
842346
def _get_composition_collection(self, composition_id):
        """"""
        collection = JSONClientValidated('repository',
                                         collection='Composition',
                                         runtime=self._runtime)
        composition_map = collection.find_one({'_id': ObjectId(composition_id.get_identifier())})
        if 'assetIds' not in composition_map:
            raise errors.NotFound('no Assets are assigned to this Composition')
        return composition_map, collection
184892
def get_settings(self, service_id, version_number):
		""""""
		content = self._fetch("/service/%s/version/%d/settings" % (service_id, version_number))
		return FastlySettings(self, content)
1037041
def get_settings(self):
        
        response = self._send(http_method='GET',
                              location_id='cbe076d8-2803-45ff-8d8d-44653686ea2a',
                              version='5.0-preview.1')
        return self._deserialize('NotificationAdminSettings', response)
1093784
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return SyncMapItemInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            map_sid=self._solution['map_sid'],
            key=self._solution['key'],
        )