Get the account details
964478
def get_account_details(self, account):
        
        result = self.get_user(account.username)
        if result is None:
            result = {}
        return result
279007
def get_account_details(self):
        
        headers = self._manager.get_account_headers()
        acct_prefix = "x-account-"
        meta_prefix = ACCOUNT_META_PREFIX.lower()
        ret = {}
        for hkey, hval in list(headers.items()):
            lowkey = hkey.lower()
            if lowkey.startswith(acct_prefix):
                if not lowkey.startswith(meta_prefix):
                    cleaned = hkey.replace(acct_prefix, "").replace("-", "_")
                    try:
                        # Most values are ints
                        ret[cleaned] = int(hval)
                    except ValueError:
                        ret[cleaned] = hval
        return ret
705182
def get_default_account_data(self) -> AccountData:
        
        for acct in self.wallet_in_mem.accounts:
            if not isinstance(acct, AccountData):
                raise SDKException(ErrorCode.other_error('Invalid account data in memory.'))
            if acct.is_default:
                return acct
        raise SDKException(ErrorCode.get_default_account_err)
1315572
@Override
  public AccountInfo getAccountInfo() throws IOException {
    final RippleAccountBalances account = getRippleAccountBalances();
    final String username = exchange.getExchangeSpecification().getApiKey();
    return RippleAdapters.adaptAccountInfo(account, username);
  }
462934
def accountSummary(self, account: str = '') -> List[AccountValue]:
        
        if not self.wrapper.acctSummary:
            # loaded on demand since it takes ca. 250 ms
            self.reqAccountSummary()
        if account:
            return [v for v in self.wrapper.acctSummary.values()
                    if v.account == account]
        else:
            return list(self.wrapper.acctSummary.values())
564511
def record_get_details(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/getDetails' % object_id, input_params, always_retry=always_retry, **kwargs)
256417
def get_transactions(self, account_id, **params):
        """"""
        response = self._get('v2', 'accounts', account_id, 'transactions', params=params)
        return self._make_api_object(response, Transaction)
272784
def get_details(self, jobname, jobkey):
        """"""
        fullkey = JobDetails.make_fullkey(jobname, jobkey)
        return self._cache[fullkey]
272575
def get_details(self):
        
        strval = str(self.wrong_value)
        if len(strval) > self.__max_str_length_displayed__:
            return '(Actual value is too big to be printed in this message)'
        else:
            return 'Wrong value: [{}]'.format(self.wrong_value)
324090
async def get_details(self):
        
        data = await self._handler.details(system_id=self.system_id)
        return bson.decode_all(data)[0]
897698
private static void getAccountInfoBySettingClient() {
    try {
      Account response = Account.getter()
        .client(client)
        .get();
      System.out.println(response);
    } catch (PlivoRestException | IOException e) {
      e.printStackTrace();
    }
  }
1048269
def user_info(self):
        
        account_uri = self.uri.split('/api/v1')[0] + '/account'
        req = self.request(account_uri)
        account_info = req.get()
        user_data = HTMLParser(account_info.content)
        return user_data
1017991
def get_address(self, account_id, address_id, **params):
        """"""
        response = self._get('v2', 'accounts', account_id, 'addresses', address_id, params=params)
        return self._make_api_object(response, Address)
363850
def get_account_info(self):
        
        attrs = {sconstant.A_BY: sconstant.V_NAME}
        account = SOAPpy.Types.stringType(data=self.auth_token.account_name,
                                          attrs=attrs)

        params = {sconstant.E_ACCOUNT: account}

        res = self.invoke(zconstant.NS_ZIMBRA_ACC_URL,
                          sconstant.GetAccountInfoRequest,
                          params)

        info = AccountInfo()
        info.parse(res)

        return info
1136772
def get_user_details(self, response):
        
        result = {
            'id': response['id'],
            'username': response.get('username', None),
            'email': response.get('email', None),
            'first_name': response.get('first_name', None),
            'last_name': response.get('last_name', None)
        }
        if result['first_name'] and result['last_name']:
            result['fullname'] = result['first_name'] + \
                ' ' + result['last_name']
        return result
365260
def get_account_info(self):
        

        url = '{0}/v3/info'.format(self.host)
        return http._get_with_qiniu_mac(url, None, self.auth)
280437
def get_user_details(self, response):
        """"""

        account = response['account']
        metadata = json.loads(account.get('json_metadata') or '{}')
        account['json_metadata'] = metadata

        return {
            'id': account['id'],
            'username': account['name'],
            'name': metadata.get("profile", {}).get('name', ''),
            'account': account,
        }