Returns a new AccountProxy that acquires the account with the
        given hash, if such an account is known to the account manager.
        It is an error if the account manager does not have such an
        account.
335579
def for_account_hash(parent, account_hash):
        
        account = AccountProxy(parent)
        account.account_hash = account_hash
        if account.acquire():
            return account
        return None
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
418168
def accounts(self, id=None):
        
        return Account.load(self, id) if id else Account.all(self)
617015
protected function proxy() {
        if (!$this->context) {
            $this->context = new AccountContext($this->version, $this->solution['sid']);
        }

        return $this->context;
    }
445088
def Account(self):
		

		return(clc.v2.Account(alias=self.alias,session=self.session))
1059039
def get_account(self, account):
        
        selector = account.to_selector()
        resp = self.request_single('GetAccount', {'account': selector})
        return zobjects.Account.from_dict(resp)
279934
def add(username, password)
      CredentialsManager::AccountManager.new(
        user: username,
        password: password
      ).add_to_keychain
    end
540261
def get_by_name_from(self, root: Account, name: str) -> List[Account]:
        
        result = []

        if root.name == name:
            result.append(root)

        for child in root.children:
            child_results = self.get_by_name_from(child, name)
            result += child_results

        return result
1163721
def get_account_by_ont_id(self, ont_id: str, password: str) -> Account:
        
        WalletManager.__check_ont_id(ont_id)
        for identity in self.wallet_in_mem.identities:
            if identity.ont_id == ont_id:
                addr = identity.ont_id.replace(DID_ONT, "")
                key = identity.controls[0].key
                salt = base64.b64decode(identity.controls[0].salt)
                n = self.wallet_in_mem.scrypt.n
                private_key = Account.get_gcm_decoded_private_key(key, password, addr, salt, n, self.scheme)
                return Account(private_key, self.scheme)
        raise SDKException(ErrorCode.other_error(f'Get account {ont_id} failed.'))
403796
def get_account_item(address, param)
      address = Utils.normalize_address address, allow_blank: true
      return @caches[param][address] if @caches[param].has_key?(address)

      account = get_account address
      v = account.send param
      @caches[param][address] = v
      v
    end
915787
def blank_account(cls, db, addr, initial_nonce=0):
        
        db.put(BLANK_HASH, b"")
        o = cls(initial_nonce, 0, trie.BLANK_ROOT, BLANK_HASH, db, addr)
        o.existent_at_start = False
        return o
708122
def get_account(self, username):
        
        try:
            account = self.model.objects.get(
                **self._filter_user_by(username)
            )
        except self.model.DoesNotExist:
            return None
        return 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)
893849
public Account getAccount() throws HelloSignException {
        return new Account(httpClient.withAuth(auth).get(BASE_URI + ACCOUNT_URI).asJson());
    }
1218585
def get_external_account(resource_root, name, view=None):
  
  return call(resource_root.get,
      EXTERNAL_ACCOUNT_FETCH_PATH % ("account", name,),
      ApiExternalAccount, False, params=view and dict(view=view) or None)
1295433
def get_hash(name)
      if (item = dynamo_get_item(name))
        JSON.parse(item)
      else
        ::Hash.new
      end
    end
827524
def copy(newname)
            raise "Not all necessary api methods are defined to process this action!" unless api_methods[:copy]
            entry = self.class.find_one(name)
            if entry
                self.class.in_transaction(true) do |token|
                    entryid = self.class.make_call(api_methods[:handle],name,token)
                    self.class.make_call(api_methods[:copy],entryid,newname,token)
                end
            end
        end