Locates the account by fullname
340356
def get_account_id_by_fullname(self, fullname: str) -> str:
        
        account = self.get_by_fullname(fullname)
        return account.guid
889581
def find_user(session, username):
    """"""
    resp = _make_request(session, FIND_USER_URL, username)
    if not resp:
        raise VooblyError('user not found')
    try:
        return int(resp[0]['uid'])
    except ValueError:
        raise VooblyError('user not found')
865206
def __get_by_fullname(self, asset_class, fullname: str):
        
        if asset_class.fullname == fullname:
            return asset_class

        if not hasattr(asset_class, "classes"):
            return None

        for child in asset_class.classes:
            found = self.__get_by_fullname(child, fullname)
            if found:
                return found

        return None
167646
def people_findByUsername(username):
    """"""
    method = 'flickr.people.findByUsername'
    data = _doget(method, username=username)
    user = User(data.rsp.user.id, username=data.rsp.user.username.text)
    return user
615595
def get_person_by_full_name(self, name):
        """"""
        return next((person for person in self.get_all_people()
                     if person.full_name.lower() == name.lower()), None)
935357
def _fullname(o):
    """"""
    return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
306735
def get_full_name(self):
        
        if self.is_tpl():
            return "tpl-%s/%s" % (getattr(self, 'host_name', 'XxX'), self.name)
        if hasattr(self, 'host_name') and hasattr(self, 'service_description'):
            return "%s/%s" % (self.host_name, self.service_description)
        return 'UNKNOWN-SERVICE'
579933
private function findName ($full_name)
	{
		$partsA = explode("/", $full_name);
		$partsB = explode(".", $partsA[count($partsA) - 1]); 
		$name = null;
		for ($i=0; $i < count($partsB) - 1; $i++) 
		{ 
			if ($i == 0) 
			{
				$name .= $partsB[$i];			
			} 
			else 
			{
				$name .= ".";			
				$name .= $partsB[$i];			
			}
		}
		$this->name = $name;
	}
901667
async def getaccountbywallet(**params):
	
	if params.get("message"):
		params = json.loads(params.get("message"))

	for coinid in coin_ids:

		database = client[coinid]
		wallet_collection = database[settings.WALLET]
		wallet = await wallet_collection.find_one({"wallet":params["wallet"]})
		if not wallet:
			continue
		else:
			database = client[settings.DBNAME]
			accounts_collection = database[settings.ACCOUNTS]
			account = await accounts_collection.find_one({"id":wallet["account_id"]})
			if not account:
				return {"error":404, "reason":"Account was not found"}
			return {i:account[i] for i in account if i != "_id"}
	else:
		return {"error":404, "reason":"Account was not found"}
273902
def get_all_accounts(self):
        """"""
        for address_hash, rlpdata in self.secure_trie.trie.iter_branch():
            if rlpdata != trie.BLANK_NODE:
                yield rlp.decode(rlpdata, Account, db=self.db, addr=address_hash)
1116378
def do_account_info(self):
        """"""
        s, metadata = self.n.getRegisterUserInfo()
        pprint.PrettyPrinter(indent=2).pprint(metadata)
1313750
def search(self, account_name):
        
        accounts = self.list()
        for a in accounts:
            if a['name'] == account_name:
                return a['id']
921817
def bank_name(self):
        """"""
        entry = registry.get('bic').get(self.compact)
        if entry:
            return entry.get('name')
477322
@RequestMapping(value = "/findByUsername", method = RequestMethod.GET)
	public @ResponseBody
	ResponseAccount findByUsername(
			@RequestParam(value = "username", required = true) String username) {
		logger.debug("Received request to get account by username");

		ResponseAccount acconut = accountService.getAccountByUsername(username);

		return acconut;

	}
434576
def show(self, username):
        """"""
        filter = ['(objectclass=posixAccount)', "(uid={})".format(username)]
        return self.client.search(filter)
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
392810
def get_by_aws_account_number(account_number, bucket, region='us-west-2', json_path='accounts.json'):
    """"""
    for account in get_all_accounts(bucket, region, json_path)['accounts']:
        if 'aws' in account['type']:
            if account['metadata']['account_number'] == account_number:
                return account