Get asset ids of all coins present in the wallet.

        Returns:
            list: of UInt256 asset id's.
540103
def GetCoinAssets(self):
        
        assets = set()
        for coin in self.GetCoins():
            assets.add(coin.Output.AssetId)
        return list(assets)
307731
def get_assets():
    
    args = []
    query = dict()
    args.append(query)
    asset_with_id = dao.get_all_listed_assets()
    asset_ids = [a['id'] for a in asset_with_id]
    resp_body = dict({'ids': asset_ids})
    return Response(_sanitize_record(resp_body), 200, content_type='application/json')
1077316
async def get_wallets(self, *args, **kwargs):
		
		logging.debug("\n [+] -- Get wallets debugging.")
		if kwargs.get("message"):
			kwargs = json.loads(kwargs.get("message"))
		logging.debug(kwargs)
		uid = kwargs.get("uid",0)
		address = kwargs.get("address")
		coinid = kwargs.get("coinid")

		try:
			coinid = coinid.replace("TEST", "")
		except:
			pass

		try:
			uid = int(uid)
		except:
			return await self.error_400("User id must be integer. ")

		if not uid and address:
			uid = await self.get_uid_by_address(address=address, coinid=coinid)
			if isinstance(uid, dict):
				return uid

		wallets = [i async for i in self.collect_wallets(uid)]

		return {"wallets":wallets}
791345
def tohu_id(self):
        
        myhash = hashlib.md5(str(id(self)).encode()).hexdigest()
        return myhash[:12]
607569
def get_uids(self, filename=None):
        
        self._update()
        return [Abook._gen_uid(self._book[entry]) for entry in self._book.sections()]
1255517
def transaction_id(self):
        
        if not self._transaction_id:
            self._transaction_id = random.randint(0, 10000000000 - 1)
        return self._transaction_id
1328082
def get_list(self, ids: List[str]) -> List[Account]:
        
        query = (
            self.query
            .filter(Account.guid.in_(ids))
        )
        return query.all()
760804
def get_assets(self):
        '''
        
        '''
        return sum([
            [self.prefix_asset(viewer, relpath) for relpath in viewer.assets]
            for viewer in self.viewers
        ], [])
1338389
def _get_sg_ids(self):
        
        try:
            lambda_extras = self.settings['security_groups']['lambda_extras']
        except KeyError:
            lambda_extras = []

        security_groups = [self.app_name] + lambda_extras
        sg_ids = []
        for security_group in security_groups:
            sg_id = get_security_group_id(name=security_group, env=self.env, region=self.region)
            sg_ids.append(sg_id)
        return sg_ids
438699
def get_asset_contents(self):
        
        # Implemented from template for osid.repository.Asset.get_asset_contents_template
        return AssetContentList(
            self._my_map['assetContents'],
            runtime=self._runtime,
            proxy=self._proxy)
891445
def list_address(self):
        """"""
        result = []
        for addrStr in self.wallet.Addresses:
            addr = self.wallet.GetAddress(addrStr)
            result.append({
                "address": addrStr,
                "haskey": not addr.IsWatchOnly,
                "label": None,
                "watchonly": addr.IsWatchOnly,
            })
        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
438286
def get_wallets(self, fetch=False):
        """"""
        return Wallets(
            self.resource.wallets, self.client, populate=fetch, application=self)
392841
def get_vaults_by_ids(self, *args, **kwargs):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.BinLookupSession.get_bins_by_ids
        catalogs = self._get_provider_session('vault_lookup_session').get_vaults_by_ids(*args, **kwargs)
        cat_list = []
        for cat in catalogs:
            cat_list.append(Vault(self._provider_manager, cat, self._runtime, self._proxy))
        return VaultList(cat_list)
877482
def get_uids(self, filename=None):
        
        self._update()

        if filename:
            if filename not in self._reminders:
                return []
            return self._reminders[filename].keys()
        return [uid for uids in self._reminders.values() for uid in uids]
254332
def lookup_asset_types(self, sids):
        
        found = {}
        missing = set()

        for sid in sids:
            try:
                found[sid] = self._asset_type_cache[sid]
            except KeyError:
                missing.add(sid)

        if not missing:
            return found

        router_cols = self.asset_router.c

        for assets in group_into_chunks(missing):
            query = sa.select((router_cols.sid, router_cols.asset_type)).where(
                self.asset_router.c.sid.in_(map(int, assets))
            )
            for sid, type_ in query.execute().fetchall():
                missing.remove(sid)
                found[sid] = self._asset_type_cache[sid] = type_

            for sid in missing:
                found[sid] = self._asset_type_cache[sid] = None

        return found
1105139
def items(self):
        ''' 
        '''
        if type(self.transaction['items']['item']) == list:
            return self.transaction['items']['item']
        else:
            return [self.transaction['items']['item'],]