Remove a key/account from an account's permission
6175
def disallow(ctx, foreign_account, permission, threshold, account):
    
    print_tx(
        ctx.bitshares.disallow(
            foreign_account, account=account, permission=permission, threshold=threshold
        )
    )
1053171
def user_remove(username,
                user=None,
                host=None,
                port=None,
                maintenance_db=None,
                password=None,
                runas=None):
    '''
    
    '''
    return _role_remove(username,
                        user=user,
                        host=host,
                        port=port,
                        maintenance_db=maintenance_db,
                        password=password,
                        runas=runas)
1282941
def delete(self, key):
    '''
    '''
    key = self._service_key(key)
    self._service_ops['delete'](key)
786155
def _delete_account(self, account, username):
        

        # account deleted

        ds_user = self.get_user(username)
        if ds_user is not None:
            self._call(["grmuser", "-u", username], ignore_errors=[8])

        return
465421
def remove_user_setting(self, section, name, save=False):
    '''
    '''
    configfile = get_configfile_user()
    return _remove_setting(section, name, configfile, save)
118606
def unlock(user):
    '''
    
    '''

    cmd = 'chuser account_locked=false {0} | ' \
          'chsec -f /etc/security/lastlog -a "unsuccessful_login_count=0" -s {0}'.format(user)
    ret = __salt__['cmd.run_all'](cmd, output_loglevel='trace', python_shell=True)

    return ret
454926
def remove(config, username, filename, force):
        """"""
        client = Client()
        client.prepare_connection()
        user_api = UserApi(client)
        key_api = API(client)
        key_api.remove(username, user_api, filename, force)
992144
def delete_key(self):
        """"""
        print("This command will delete an API key.")
        apiKeyID = input("API Key ID: ")
        try:
            self._curl_bitmex("/apiKey/",
                              postdict={"apiKeyID": apiKeyID}, verb='DELETE')
            print("Key with ID %s disabled." % apiKeyID)
        except:
            print("Unable to delete key, please try again.")
            self.delete_key()
816389
def remove():
    
    if exists(env.venv_path):
        run("rm -rf %s" % env.venv_path)
    if exists(env.proj_path):
        run("rm -rf %s" % env.proj_path)
    for template in get_templates().values():
        remote_path = template["remote_path"]
        if exists(remote_path):
            sudo("rm %s" % remote_path)
    if exists(env.repo_path):
        run("rm -rf %s" % env.repo_path)
    sudo("supervisorctl update")
    psql("DROP DATABASE IF EXISTS %s;" % env.proj_name)
    psql("DROP USER IF EXISTS %s;" % env.proj_name)
449897
@DELETE
    @RequiresPermissions(I18nPermissions.KEY_DELETE)
    public Response deleteKey() {
        Key key = loadKeyIfExistsOrFail();
        keyRepository.remove(key);
        return Response.noContent().build();
    }
1269797
def _disable_access_key(self, force_disable_self=False):
        
        client = self.client
        if self.validate is True:
            return
        else:
            try:
                client.update_access_key(
                    UserName=self._search_user_for_key(),
                    AccessKeyId=self.access_key_id,
                    Status='Inactive'
                )
                logger.info(
                    "Access key {id} has "
                    "been disabled.".format(id=self.access_key_id)
                )
            except Exception as e:
                logger.info(
                    "Access key {id} could not "
                    "be disabled due to: {e}.".format(
                        e=e, id=self.access_key_id
                    )
                )
876626
def remove_permission(self, label, callback=None):
        
        return self.connection.remove_permission(self, label, callback=callback)
325269
public function removePermission(string $key) : self
    {
        $this->permission->get('removed')->push($key);

        return $this;
    }
773265
def remove_permission(payload, permission):
    """"""
    payload = copy.deepcopy(payload)

    for entity_type in ['users', 'groups']:
        for perm_type in ['add', 'remove']:
            for perms in payload.get(entity_type, {}).get(perm_type, {}).values():
                if permission in perms:
                    perms.remove(permission)

    for perm_type in ['add', 'remove']:
        perms = payload.get('public', {}).get(perm_type, [])
        if permission in perms:
            perms.remove(permission)

    return payload
175869
def delete_key(key, allow_secret = false)
      err = GPGME::gpgme_op_delete(self, key, allow_secret ? 1 : 0)
      exc = GPGME::error_to_exception(err)
      raise exc if exc
    end
380737
def delete(self, account_id, user_id):
        
        return self.connection.delete('account/access', account_id=account_id, user_id=user_id)
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)