:param account: an account object to be used as a selector
511008
def delete_account(self, account):
        
        self.request('DeleteAccount', {
            'id': self._get_or_fetch_id(account, self.get_account),
        })
121879
def get(account):
        
        account = Account.get(account)
        if not account:
            return None

        acct_type = AccountType.get(account.account_type_id).account_type
        account_class = get_plugin_by_name(PLUGIN_NAMESPACES['accounts'], acct_type)

        return account_class(account)
964478
def get_account_details(self, account):
        
        result = self.get_user(account.username)
        if result is None:
            result = {}
        return result
665711
def esr9_format_account_id(account_id)
      (pre, main, post) = account_id.split('-')

      sprintf('%02i%06i%1i', pre.to_i, main.to_i, post.to_i)
    end
229233
def account_activation(data = {})
      @data = {
          user: nil,
          client_ip: '0.0.0.0'
      }.merge(data || {})
      raise unless data[:user]
      mail to: data[:user].email, subject: 'Account activation'
    end
824528
def get_account_config(self, id_or_name):
        
        if id_or_name in self._config:
            return self._config[id_or_name]
        if id_or_name in self._acct_name_to_id:
            return self._config[self._acct_name_to_id[id_or_name]]
        raise RuntimeError('ERROR: Unknown account ID or name')
1141774
def account_overview(object):
    """"""
    return Layout(
        Container(
            Row(
                Column2(
                    Panel(
                        'Avatar',
                        Img(src="{}{}".format(settings.MEDIA_URL, object.avatar)),
                        collapse=True,
                    ),
                ),
                Column10(
                    Panel(
                        'Account information',
                        DescriptionList(
                            'email',
                            'first_name',
                            'last_name',
                        ),
                    )
                ),
            )
        )
    )
88122
def get_account_batch(account_ids)
      resp = request('/users/get_account_batch', account_ids: account_ids)
      resp.map { |a| BasicAccount.new(a) }
    end
903503
def _remove_account(self, accounts):
        
        for account in to_list(accounts):
            if account not in self.accounts:
                msg = 'attempt to remove unknown account %s' % account
                raise Exception(msg)
            if account not in self.unlocked_accounts:
                raise Exception('account %s should be unlocked' % account)
            account.acquired_event.disconnect(self._on_account_acquired)
            account.released_event.disconnect(self._on_account_released)
            self.accounts.remove(account)
            self.unlocked_accounts.remove(account)
752759
def vesting(ctx, account):
    
    account = Account(account, full=True)
    t = [["vesting_id", "claimable"]]
    for vest in account["vesting_balances"]:
        vesting = Vesting(vest)
        t.append([vesting["id"], str(vesting.claimable)])
    print_table(t)
618976
def create_account(cls, params):
        
        user_params = dictset(params).subset(
            ['username', 'email', 'password'])
        try:
            return cls.get_or_create(
                email=user_params['email'],
                defaults=user_params)
        except JHTTPBadRequest:
            raise JHTTPBadRequest('Failed to create account.')
418168
def accounts(self, id=None):
        
        return Account.load(self, id) if id else Account.all(self)
1194397
def account_info(self):
        
        response = self._post(self.apiurl + "/v2/account/info", data={'apikey': self.apikey})

        return self._raise_or_extract(response)
416179
def accounts(self):
        
        from ofxclient.account import Account
        client = self.client()
        query = client.account_list_query()
        resp = client.post(query)
        resp_handle = StringIO(resp)

        if IS_PYTHON_2:
            parsed = OfxParser.parse(resp_handle)
        else:
            parsed = OfxParser.parse(BytesIO(resp_handle.read().encode()))

        return [Account.from_ofxparse(a, institution=self)
                for a in parsed.accounts]
1136789
def create_account(self, email, password=None, attrs={}):
        
        attrs = [{'n': k, '_content': v} for k, v in attrs.items()]

        params = {'name': email, 'a': attrs}

        if password:
            params['password'] = password

        resp = self.request_single('CreateAccount', params)

        return zobjects.Account.from_dict(resp)
410394
def get_account_balance(self, account):
        
        balance = namedb_get_account_balance(account)
        assert isinstance(balance, (int,long)), 'BUG: account balance of {} is {} (type {})'.format(account['address'], balance, type(balance))
        return balance
1339197
function (account, cb) {

		Stripeaccount.findOrCreate(account.id, account)
	    .exec(function (err, foundAccount){
	      if (err) return cb(err);
	      Stripeaccount.update(foundAccount.id, account)
	      .exec(function(err, updatedAccounts){
	      	if (err) return cb(err);
	      	cb(null, updatedAccounts[0]);
	      });
	    });
	}