Remove a user from your team
        :param user_id: Id of user
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()
1281222
def remove_user(uid):
    
    try:
        acl_url = urljoin(_acl_url(), 'users/{}'.format(uid))
        r = http.delete(acl_url)
        assert r.status_code == 204
    except DCOSHTTPException as e:
        # doesn't exist
        if e.response.status_code != 400:
            raise
524924
public function removeTeamMember($id_or_email)
    {
        $key = strpos($id_or_email, '@') ? 'email_address' : 'account_id';

        $response = $this->rest->post(
            static::TEAM_REMOVE_MEMBER_PATH,
            array($key => $id_or_email)
        );

        $this->checkResponse($response);

        return new Team($response);
    }
27138
def revoke_user(self, user_id):
        

        uri = 'openstack/users/%s' % user_id
        try:
            resp = self.delete(uri)
        except AttributeError:
            # note: this breaks. stacktask returns a string, not json.
            return
        self.expected_success(200, resp.status)
        return rest_client.ResponseBody(resp, None)
1153062
def task_remove_user(self, *args, **kwargs):
        
        if not self.cur_task:
            return
        i = self.task_user_tablev.currentIndex()
        item = i.internalPointer()
        if item:
            user = item.internal_data()
            self.cur_task.users.remove(user)
            item.set_parent(None)
1016400
def RemoveUser(self, user):
    
    self.logger.info('Removing user %s.', user)
    if self.remove:
      command = self.userdel_cmd.format(user=user)
      try:
        subprocess.check_call(command.split(' '))
      except subprocess.CalledProcessError as e:
        self.logger.warning('Could not remove user %s. %s.', user, str(e))
      else:
        self.logger.info('Removed user account %s.', user)
    self._RemoveAuthorizedKeys(user)
    self._UpdateSudoer(user, sudoer=False)
1258236
def remove(self, steamid):
        
        if isinstance(steamid, SteamUser):
            steamid = steamid.steam_id

        self._steam.send(MsgProto(EMsg.ClientRemoveFriend), {'friendid': steamid})
244465
def delete_user(self, id):
        
        self.assert_has_permission('scim.write')

        uri = self.uri + '/Users/%s' % id
        headers = self._get_headers()

        logging.debug("URI=" + str(uri))
        logging.debug("HEADERS=" + str(headers))

        response = self.session.delete(uri, headers=headers)
        logging.debug("STATUS=" + str(response.status_code))
        if response.status_code == 200:
            return response
        else:
            logging.error(response.content)
            response.raise_for_status()
1315279
def remove_user(config, group, username):
        """"""
        client = Client()
        client.prepare_connection()
        group_api = API(client)
        try:
            group_api.remove_user(group, username)
        except ldap_tools.exceptions.NoGroupsFound:  # pragma: no cover
            print("Group ({}) not found".format(group))
        except ldap_tools.exceptions.TooManyResults:  # pragma: no cover
            print("Query for group ({}) returned multiple results.".format(
                group))
        except ldap3.NO_SUCH_ATTRIBUTE:  # pragma: no cover
            print("{} does not exist in {}".format(username, group))
990722
def delete_user(self, user_id, **kwargs):
        
        return DeleteUser(settings=self.settings, **kwargs).call(user_id=user_id, **kwargs)
1015531
def remove_from_user(self, name, *args):
        
        user = self.get_user(name=name)
        attrs_ = user['user']
        for a in args:
            del attrs_[a]
406801
public synchronized USER remove(final ID sessionId)
	{
		final USER user = getUser(sessionId);
		if (user != null)
		{
			usersOnline.remove(user);
		}
		sessionIdToUser.remove(sessionId);
		return user;
	}
218023
def remove_user_from_group(self, username, groupname):
        
        url = self._options['server'] + '/rest/api/latest/group/user'
        x = {'groupname': groupname,
             'username': username}

        self._session.delete(url, params=x)

        return True
48898
def remove_user_from_group(self, group_name, user_name):
        
        params = {'GroupName' : group_name,
                  'UserName' : user_name}
        return self.get_response('RemoveUserFromGroup', params)
1280913
def delete_user(self, user):
        
        self.service.delete_user(
            user, self.url_prefix, self.auth, self.session, self.session_send_opts)
449481
def delete_user(self, name):
        
        self._api_delete('/api/users/{0}'.format(
            urllib.parse.quote_plus(name)
        ))
409981
def revoke_user_token(self, user_id):
        
        user = self.get(user_id)
        user._token = None
        self.save(user)