DELETE /auth/<mount point>/users/<username>

        :param username:
        :type username:
        :param mount_point:
        :type mount_point:
        :return:
        :rtype:
179860
def delete_userpass(self, username, mount_point='userpass'):
        
        return self._adapter.delete('/v1/auth/{}/users/{}'.format(mount_point, username))
1264833
def delete(self, username, napp):
        
        api = self._config.get('napps', 'api')
        endpoint = os.path.join(api, 'napps', username, napp, '')
        content = {'token': self._config.get('auth', 'token')}
        response = self.make_request(endpoint, json=content, method='DELETE')
        response.raise_for_status()
912795
def delete_user(username,
                token_manager=None,
                app_url=defaults.APP_URL):
    
    account_id = get_account_id(username,
                                token_manager=token_manager,
                                app_url=app_url)

    headers = token_manager.get_access_token_headers()
    auth_url = environment.get_auth_url(app_url=app_url)
    url = "%s/api/v1/accounts/%s" % (auth_url, account_id)
    response = requests.delete(url, headers=headers)

    if response.status_code == 204:
        return response.text

    else:
        raise JutException('Error %s; %s' % (response.status_code, response.text))
1288841
def delete(config, username, type):
        """"""
        client = Client()
        client.prepare_connection()
        user_api = API(client)
        user_api.delete(username, type)
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)
600254
def auth_tls(self, mount_point='cert', use_token=True):
        
        return self.login('/v1/auth/{0}/login'.format(mount_point), use_token=use_token)
381458
def delete_member(self, user):
        
        if not self.email_enabled:
            raise EmailNotEnabledError("See settings.EMAIL_ENABLED")
        return requests.delete(
            f"{self.api_url}/{self.address}/members/{user.email}",
            auth=("api", self.api_key),
        )
674090
def delete_permission(self, vname, username):
        
        vname = quote(vname, '')
        path = Client.urls['vhost_permissions'] % (vname, username)
        return self._call(path, 'DELETE')
436323
def remove_user(self, user_id):
        

        url = self.TEAM_USERS_ID_URL % user_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.delete_request()
248720
def release_name(self, username):
        
        self.temp_names.append(username)
        if self.is_username_used(username):
            self.registered_names.remove(username)
722741
def delete_user(self, user):
        
        user_id = utils.get_id(user)
        uri = "users/%s" % user_id
        resp, resp_body = self.method_delete(uri)
        if resp.status_code == 404:
            raise exc.UserNotFound("User '%s' does not exist." % user)
        elif resp.status_code in (401, 403):
            raise exc.AuthorizationFailure("You are not authorized to delete "
                    "users.")
674629
def delete_user(self, user_id):
        
        api = self._get_api(iam.AccountAdminApi)
        api.delete_user(user_id)
        return
1353418
async def remove_user(self, username):
        
        client_facade = client.UserManagerFacade.from_connection(
            self.connection())
        user = tag.user(username)
        await client_facade.RemoveUser([client.Entity(user)])
1123575
def remove_user(self, user_name, role):
        
        role_uri = self._get_role_uri(role=role)
        return self.api.delete(path=role_uri, data={'username': user_name})
192382
def delete_ec2_role(self, role, mount_point='aws-ec2'):
        
        return self._adapter.delete('/v1/auth/{0}/role/{1}'.format(mount_point, role))
1342962
def delete(self, username, type):
        """"""
        self.client.delete(self.__distinguished_name(type, username=username))
292997
def delete_user(name, runas=None):
    '''
    
    '''
    if runas is None and not salt.utils.platform.is_windows():
        runas = salt.utils.user.get_user()
    res = __salt__['cmd.run_all'](
        [RABBITMQCTL, 'delete_user', name],
        reset_system_locale=False,
        python_shell=False,
        runas=runas)
    msg = 'Deleted'

    return _format_response(res, msg)