Unlock the account.

        :param account: Account
        :return:
126
def unlock_account(account):
        
        return Web3Provider.get_web3().personal.unlockAccount(account.address, account.password)
1059039
def get_account(self, account):
        
        selector = account.to_selector()
        resp = self.request_single('GetAccount', {'account': selector})
        return zobjects.Account.from_dict(resp)
1241953
def get_account_authToken(self, account=None, account_name=''):
        
        if account is None:
            account = self.get_account(zobjects.Account(name=account_name))
        selector = account.to_selector()

        resp = self.request('DelegateAuth', {'account': selector})

        authToken = resp['authToken']
        lifetime = int(resp['lifetime'])

        return authToken, lifetime
241823
def account_unblock(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}/unblock'.format(str(id))
        return self.__api_request('POST', url)
1360822
def release_accounts(self, owner):
        
        with self.unlock_cond:
            for account in self.owner2account[owner]:
                self.account2owner.pop(account)
                account.release(False)
                self.unlocked_accounts.append(account)
            self.owner2account.pop(owner)
            self.unlock_cond.notify_all()
380737
def delete(self, account_id, user_id):
        
        return self.connection.delete('account/access', account_id=account_id, user_id=user_id)
237443
def init_hold_with_account(self):
        

        return self.init_hold.reset_index().assign(
            account_cookie=self.account_cookie
        ).set_index(['code',
                     'account_cookie'])
616523
def push_account_task(obj_id):
    
    lock_id = "%s-push-account-%s" % (settings.ENV_PREFIX, obj_id)
    acquire_lock = lambda: cache.add(lock_id, "true", LOCK_EXPIRE)  # noqa: E731
    release_lock = lambda: cache.delete(lock_id)  # noqa: E731
    if acquire_lock():
        UserModel = get_user_model()
        try:
            upload_intercom_user(obj_id)
        except UserModel.DoesNotExist:
            #  seems like account was removed before it was pushed
            release_lock()

        release_lock()
410371
def lock_reward(self, agreement_id, amount, account):
        
        return self._keeper.lock_reward_condition.fulfill(
            agreement_id, self._keeper.escrow_reward_condition.address, amount, account
        )
814137
def unlock!(token = nil)
      token ||= jid

      Scripts.call(
        :unlock,
        redis_pool,
        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
        argv: [token, ttl, lock_type],
      )
    end
991221
def lock_account(self, minutes=30):
        
        period = datetime.timedelta(minutes=minutes)
        self.locked_until = datetime.datetime.utcnow() + period
964478
def get_account_details(self, account):
        
        result = self.get_user(account.username)
        if result is None:
            result = {}
        return result
430220
def account(self):
        
        if self._account is None:
            self._account = AccountContext(self, self.domain.twilio.account_sid)
        return self._account
820958
def unlock(path, body, initheader = nil)
      request(Unlock.new(path, initheader), body)
    end
616471
def accounts():
    
    import yaml

    for path in account_files:
        try:

            c_dir = os.path.dirname(path)

            if not os.path.exists(c_dir):
                os.makedirs(c_dir)

            with open(path, 'rb') as f:
                return yaml.load(f)['accounts']

        except (OSError, IOError) as e:
            pass

    return {}
1303044
def account_unmute(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}/unmute'.format(str(id))
        return self.__api_request('POST', url)
580180
def account(self):
        
        data = self.query(Account.key)
        return Account(self, data)