Return the account for the given third-party.  Raise <something> if the third party doesn't belong to this bookset.
770844
def get_third_party(self, third_party):
        """"""
        actual_account = third_party.get_account()

        assert actual_account.get_bookset() == self.get_bookset()
        return ProjectAccount(actual_account, project=self, third_party=third_party)
1034326
function getAccount (queryOptions, { accountId }) {
  return sendQuery(
    queryOptions,
    queryHelper.addQuery(
      queryHelper.emptyQuery(),
      'getAccount',
      {
        accountId
      }
    ),
    (resolve, reject, responseName, response) => {
      if (responseName !== 'ACCOUNT_RESPONSE') {
        const error = JSON.stringify(response.toObject().errorResponse)
        return reject(new Error(`Query response error: expected=ACCOUNT_RESPONSE, actual=${responseName}\nReason: ${error}`))
      }

      const account = response.getAccountResponse().getAccount().toObject()
      resolve(account)
    }
  )
}
1225712
async def get(self, public_key):
		
		# Sign-verifying functional
		#super().verify()
		# Get coinid
		account = await self.account.getaccountdata(public_key=public_key)
		if "error" in account.keys():
			self.set_status(account["error"])
			self.write(account)
			raise tornado.web.Finish



		offers_collection = []
		for coinid in settings.AVAILABLE_COIN_ID:

			try:
				self.account.blockchain.setendpoint(settings.bridges[coinid])
			except:
				continue

			try:
				offers = await self.account.blockchain.getbuyeroffers( 
								buyer_address=self.account.validator[coinid](public_key))
				for offer in offers:
					offer["type"] = self.account.ident_offer[offer["type"]]
	
				storage_offers = await self.account.getoffers(coinid=coinid, 
																public_key=public_key)

			except:
				continue

			offers_collection.extend(offers + storage_offers)


		self.write(json.dumps(offers_collection))
386706
def balance(self, account: Address):
        
        return self.web3.eth.getBalance(to_checksum_address(account), 'pending')
1057241
def updateAccount(self, subject, person, vendorSpecific=None):
        
        response = self.updateAccountResponse(subject, person, vendorSpecific)
        return self._read_boolean_response(response)
174708
def external_accounts
      # When external_accounts come back in an include, the method still gets called, to return the object from the attributes.
      return attributes['external_accounts'] if attributes['external_accounts'].present?
      return [] unless respond_to? :external_account_ids
      ESP::ExternalAccount.where(id_in: external_account_ids)
    end
47722
def get_referenced_object(self):
        

        if self._Payment is not None:
            return self._Payment

        if self._PaymentBatch is not None:
            return self._PaymentBatch

        raise exception.BunqException(self._ERROR_NULL_FIELDS)
335108
def getbalance(self, account=None, minconf=6):
        """"""
        if account:
            return self.req("getbalance", [account, minconf])
        else:
            return self.req("getbalance")
779293
def get_account(self, address, token_type):
        
        cur = self.db.cursor()
        return namedb_get_account(cur, address, token_type)
527750
def get_account_from_name(self, name):
        
        for account in self.accounts:
            if account.get_name() == name:
                return account
        return None
965306
private Account findParent(Account parent, Account account) {
        if (parent == null || account == null)
            return null;

        // Does this parent contain the child account?
        if (parent.getChildren().contains(account))
            return parent;

        // Recurse through the children
        for (Account child : parent.getChildren()) {
            Account theOne = findParent(child, account);
            if (theOne != null)
                return theOne;
        }

        return null;
    }
959752
def get_account(self, account):
        '''
        
        '''
        try:
            return self.get_account_by_cookie(account.account_cookie)
        except:
            QA_util_log_info(
                'Can not find this account with cookies %s' %
                account.account_cookie
            )
            return None
692642
def get(self, accountId):
        """"""
        account = BaseAccount.get(accountId)
        if account:
            return self.make_response({
                'message': None,
                'account': account.to_json(is_admin=True)
            })
        else:
            return self.make_response({
                'message': 'Unable to find account',
                'account': None
            }, HTTP.NOT_FOUND)
913797
function accountOrIdStep(obj, name) {
    return function (accountOrId) {
        if (typeof accountOrId === 'string') {
            // W3C obfuscated id
            return idStep(obj, name)(accountOrId);
        } else {
            // accountOrId expected to be {type: 'github', id: 123456}
            var ctx = new obj();
            ctx.steps.push(name);
            ctx.steps.push("connected");
            ctx.steps.push(accountOrId.type);
            ctx.steps.push(accountOrId.id);
            return ctx;
        }
    };
}
819244
def account(self, id):
        """"""
        if self.parser.has_section(id):
            return self._section_to_account(id)
        return None
1037653
def get_deposit(self, account_id, deposit_id, **params):
        """"""
        response = self._get(
            'v2', 'accounts', account_id, 'deposits', deposit_id, params=params)
        return self._make_api_object(response, Deposit)
313293
def retrieve(cls, *args, **kwargs):
        """"""
        return super(BankAccount, cls).retrieve(*args, **kwargs)