Get the account details.
327923
def get_account_details(account):
    
    result = []
    for datastore in _get_datastores():
        value = datastore.get_account_details(account)
        value['datastore'] = datastore.config['DESCRIPTION']
        result.append(value)
    return result
580738
@Override
  public Account getAccountInfo() throws DigitalOceanException, RequestUnsuccessfulException {
    return (Account) perform(new ApiRequest(ApiAction.GET_ACCOUNT_INFO)).getData();
  }
580180
def account(self):
        
        data = self.query(Account.key)
        return Account(self, data)
432756
def params(self):
        
        params = {}
        params["access_token"] = self.access_token
        params["account_id"] = self.account_id
        return params
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)
1266312
function getSettings(account, callback) {
  validate.address(account);

  this.remote.requestAccountInfo({account: account}, function(error, info) {
    if (error) {
      return callback(error);
    }

    var data = info.account_data;
    var settings = {
      account: data.Account,
      transfer_rate: '0'
    };

    // Attach account flags
    _.extend(settings, TxToRestConverter.parseFlagsFromResponse(data.Flags,
      constants.AccountRootFlags));

    // Attach account fields
    _.extend(settings, parseFieldsFromResponse(data,
      constants.AccountRootFields));

    settings.transaction_sequence = String(settings.transaction_sequence);

    callback(null, {settings: settings});
  });
}
386397
def get(self):
    """"""
    client_customer_id = self.request.get('clientCustomerId')

    template_values = {
        'back_url': '/showAccounts',
        'back_msg': 'View Accounts.',
        'ccid': client_customer_id,
        'logout_url': users.create_logout_url('/'),
        'user_nickname': users.get_current_user().nickname()
    }

    try:
      try:
        app_user = InitUser()

        # Load Client instance.
        handler = APIHandler(app_user.client_id,
                             app_user.client_secret,
                             app_user.refresh_token,
                             app_user.adwords_manager_cid,
                             app_user.developer_token)

        campaigns = handler.GetCampaigns(client_customer_id)
      except Exception, e:
        template_values['error'] = str(e)
    finally:
      # Use template to write output to the page.
      template_values['campaigns'] = campaigns
      path = os.path.join(os.path.dirname(__file__),
                          '../templates/show_campaigns.html')
      self.response.out.write(template.render(path, template_values))
272784
def get_details(self, jobname, jobkey):
        """"""
        fullkey = JobDetails.make_fullkey(jobname, jobkey)
        return self._cache[fullkey]
205472
function getAccountDetail (queryOptions, { accountId, key, writerId }) {
  return sendQuery(
    queryOptions,
    queryHelper.addQuery(
      queryHelper.emptyQuery(),
      'getAccountDetail',
      {
        accountId
      }
    ),
    (resolve, reject, responseName, response) => {
      if (responseName !== 'ACCOUNT_DETAIL_RESPONSE') {
        const error = JSON.stringify(response.toObject().errorResponse)
        return reject(new Error(`Query response error: expected=ACCOUNT_DETAIL_RESPONSE, actual=${responseName}\nReason: ${error}`))
      }

      const transactions = JSON.parse(response.getAccountDetailResponse().toObject().detail)
      resolve(transactions)
    }
  )
}
280981
public function getAccountInfo()
    {
        $response     = $this->makeRequest(Client::HEAD);
        $nbContainers = 0;
        $totalSize    = 0;
        $metadata     = array();

        foreach ($response['headers'] as $name => $value) {
            $name = strtolower($name);

            if (0 === strcmp($name, 'x-account-container-count')) {
                $nbContainers = intval($value);
            } elseif (0 === strcmp($name, 'x-account-bytes-used')) {
                $totalSize = intval($value);
            } elseif (0 === strpos($name, 'x-account-meta-')) {
                $metadata[substr($name, 15)] = $value;
            }
        }

        return array(
            $nbContainers,
            $totalSize,
            $metadata
        );
    }
867953
public AccountInfo getAccountInfo() throws Exception {

        final JSONObject jsonObject = toJSONObject(client.get(getUri(), null));


        return new AccountInfo(client, jsonObject);
    }
801794
def get_balance(self, acc_id, site='Pro'):
        
        assert site in ['Pro', 'HADAX']
        path = f'/v1{"/" if site == "Pro" else "/hadax/"}account/accounts/{acc_id}/balance'
        # params = {'account-id': self.acct_id}
        params = {}

        def _wrapper(_func):
            @wraps(_func)
            def handle():
                _func(api_key_get(params, path))

            return handle

        return _wrapper
596018
def get_account(self, name, **kwargs):
        
        if len(name.split(".")) == 3:
            return self.get_objects([name])[0]
        else:
            return self.get_account_by_name(name, **kwargs)
527750
def get_account_from_name(self, name):
        
        for account in self.accounts:
            if account.get_name() == name:
                return account
        return None
85295
def get_info(self, account, params={}):
        
        res = self.invoke(zconstant.NS_ZIMBRA_ADMIN_URL,
                          sconstant.GetInfoRequest,
                          params)

        return res
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
855067
def get(self):
        """"""
        _, accounts = BaseAccount.search()

        if ROLE_ADMIN not in session['user'].roles:
            accounts = list(filter(lambda acct: acct.account_id in session['accounts'], accounts))

        if accounts:
            return self.make_response({
                'message': None,
                'accounts': [x.to_json(is_admin=ROLE_ADMIN in session['user'].roles or False) for x in accounts]
            })
        else:
            return self.make_response({
                'message': 'Unable to find any accounts',
                'accounts': None
            }, HTTP.NOT_FOUND)