Get account by address.

        :param address:
        :return:
199148
def _get_account(self, address):
        
        state = self._get_head_state()
        account_address = binascii.a2b_hex(utils.remove_0x_head(address))
        return state.get_and_cache_account(account_address)
891445
def list_address(self):
        """"""
        result = []
        for addrStr in self.wallet.Addresses:
            addr = self.wallet.GetAddress(addrStr)
            result.append({
                "address": addrStr,
                "haskey": not addr.IsWatchOnly,
                "label": None,
                "watchonly": addr.IsWatchOnly,
            })
        return result
1185917
def get_and_cache_account(self, addr):
        

        if addr in self.cache:
            return self.cache[addr]
        rlpdata = self.secure_trie.get(addr)
        if (
            rlpdata == trie.BLANK_NODE and len(addr) == 32
        ):  # support for hashed addresses
            rlpdata = self.trie.get(addr)

        if rlpdata != trie.BLANK_NODE:
            o = rlp.decode(rlpdata, Account, db=self.db, addr=addr)
        else:
            o = Account.blank_account(self.db, addr, 0)
        self.cache[addr] = o
        o._mutable = True
        o._cached_rlp = None
        return o
395038
def get_account_at(self, address, block_number):
        
        cur = self.db.cursor()
        return namedb_get_account_at(cur, address, block_number)
476014
def get_balance(self, address, block="latest"):
        
        response = self.make_request("eth_getBalance", [address, block])
        return int(response['result'], 16)
1144999
def account_is_empty(address)
      get_balance(address) == 0 && get_code(address) == Constant::BYTE_EMPTY && get_nonce(address) == 0
    end
381339
def parse_address(self, address_line):
        
        params = {"term": address_line}
        json = self._make_request('/address/getParsedAddress', params)
        if json is None:
            return None
        return Address.from_json(json)
321144
def get_ip(self, address):
        
        res = self.get_request('/ip_address/' + address)
        return IPAddress(cloud_manager=self, **res['ip_address'])
252836
def remove_account(self, address: str):
        
        account = self.get_account_by_b58_address(address)
        if account is None:
            raise SDKException(ErrorCode.get_account_by_address_err)
        self.accounts.remove(account)
733893
def parse_address(address: str) -> str:
    
    display_name, parsed_address = email.utils.parseaddr(address)

    return parsed_address or address
165560
def validateaddress(self, address: str) -> bool:
        ""

        try:
            Address.from_string(address, self.network_properties)
        except InvalidAddress:
            return False

        return True
1198572
def account(self, key=None, address=None, name=None):
        """"""
        if key:
            return self.client.account(key, wallet=self)
        if address:
            q = dict(address=address)
        elif name:
            q = dict(name=name)
        else:
            raise TypeError("Missing param: key, address, or name is required.")

        return Account(
            self.resource.account_query(q).get(), self.client, wallet=self)
64257
def transactions_by_address(address, options = {})
      agent.transactions_by_address(self['id'], address, options) do |data, resp|
        yield(data, resp) if block_given?
      end
    end
40803
def namedb_get_account_tokens(cur, address):
    
    sql = 'SELECT DISTINCT type FROM accounts WHERE address = ?;'
    args = (address,)

    rows = namedb_query_execute(cur, sql, args)
    ret = []
    for row in rows:
        ret.append(row['type'])

    return ret
1246754
def eth_getBalance(self, address):
        
        account = self.reader._get_account(address)
        return account.balance
319369
def parse_address(self, address, line_number=-1):
        
        return Address(address, self, line_number, self.logger)
731574
def get_proxy(self, proxy_address):
        
        if not proxy_address:
            return None
        hostport = extract_proxy_hostport(proxy_address)
        return self.proxies_by_hostport.get(hostport, None)