Gets the branding asset ``Ids``.

        return: (osid.id.IdList) - a list of asset ``Ids``
        *compliance: mandatory -- This method must be implemented.*
437446
def get_branding_ids(self):
        
        from ..id.objects import IdList
        if 'brandingIds' not in self._my_map:
            return IdList([])
        id_list = []
        for idstr in self._my_map['brandingIds']:
            id_list.append(Id(idstr))
        return IdList(id_list)
1363237
def get_objects(self, ids, **args):
        
        args["ids"] = ",".join(ids)
        return self.request(self.version + "/", args)
731807
def get_asset_id(self, tx_id):
        
        tx = self.driver.instance.transactions.retrieve(txid=tx_id)
        assert tx is not None
        return tx['id'] if tx['operation'] == 'CREATE' else tx['asset']['id']
578365
public static List<Service> getServices(List<ServiceId> ids) {
        ProviderList list = Providers.getProviderList();
        return list.getServices(ids);
    }
903150
def restricted_brands(self):
        
        if self.api and self.restricted_brand_ids:
            return self.api._get_restricted_brands(self.restricted_brand_ids)
117204
def get_asset_ids(self):
        
        if not self.is_asset_based_activity():
            raise IllegalState()
        else:
            ids = []
            for i in self._my_map['assetIds']:
                ids.append(Id(i))
            return IdList(ids)
1171504
def get_class_by_id(self, ac_id: int) -> AssetClass:
        
        assert isinstance(ac_id, int)

        # iterate recursively
        for ac in self.asset_classes:
            if ac.id == ac_id:
                return ac
        # if nothing returned so far.
        return None
1278860
def get_sh_ids(self, identity, backend_name):
        
        # Convert the dict to tuple so it is hashable
        identity_tuple = tuple(identity.items())
        sh_ids = self.__get_sh_ids_cache(identity_tuple, backend_name)
        return sh_ids
747696
def getAttachmentUIDs(self):
        
        attachments = self.getAttachment()
        uids = [att.UID() for att in attachments]
        return uids
985627
def lookup(self, id_list, **kw):
        
        result_id_pack = ','.join([str(_id) for _id in id_list])
        if not result_id_pack:
            return []
        return self.twitter.statuses.lookup(_id=result_id_pack)
279962
def get(id)
      @brokers.each { |b| return b.identity if b.identity == id || b.alias == id }
      nil
    end
790335
def get_grade_ids(self):
        
        id_list = []
        for grade_map in self._my_map['grades']:
            id_list.append(Id(grade_map.id))
        if id_list == []:
            raise IllegalState()
        else:
            return IdList(id_list)
111439
def get_asset_classes_for_security(self, namespace: str, symbol: str) -> List[AssetClass]:
        
        full_symbol = symbol
        if namespace:
            full_symbol = f"{namespace}:{symbol}"

        result = (
            self.session.query(AssetClassStock)
            .filter(AssetClassStock.symbol == full_symbol)
            .all()
        )
        return result
1304469
def selected(self, ids):
        
        # Cleanup the ID list
        if self.get_field_name() == 'pk':
            ids = filter(lambda x: "{}".format(x).isdigit(), copy(ids))
        else:
            ids = filter(lambda x: len("{}".format(x)) > 0, copy(ids))
        # Prepare the QS
        # TODO: not contextually filtered, check if it's possible at some point
        qs = self.get_model_queryset().filter(
            **{'{}__in'.format(self.get_field_name()): ids})
        result = []
        for item in qs:
            item_repr = self.item(item)
            result.append(
                (item_repr['value'], item_repr['label'])
            )
        return result
725972
def fetch_list(cls, client, ids):
        
        results = []
        request_url = "https://api.robinhood.com/options/instruments/"

        for _ids in chunked_list(ids, 50):

            params = {"ids": ",".join(_ids)}
            data = client.get(request_url, params=params)
            partial_results = data["results"]

            while data["next"]:
                data = client.get(data["next"])
                partial_results.extend(data["results"])
            results.extend(partial_results)

        return results
219078
def get_brandings(self):
        
        connection = Connection(self.token)

        connection.set_url(self.production, self.BRANDINGS_URL)

        return connection.get_request()
33458
def asset_tags(asset_id)
      tag_summary = []
      asset_tag   = JSON.parse(AJAX.get(self, "/api/2.0/assets/#{asset_id}/tags", AJAX::CONTENT_TYPE::JSON, { per_page: 2_147_483_647 }))
      asset_tag['resources'].select { |r| r['asset_ids'].find { |i| i == asset_id } }.each do |json|
        tag_summary << TagSummary.parse(json)
      end
      tag_summary
    end