Remove the authenticated user's ID from the request.
429105
def logout():
    
    from uliweb import request

    delete_user_session()
    request.session.delete()
    request.user = None
    return True
380737
def delete(self, account_id, user_id):
        
        return self.connection.delete('account/access', account_id=account_id, user_id=user_id)
338859
def logout_user(self):
        

        for key in ('identity.name', 'identity.auth_type'):
            session.pop(key, None)
        _logout_user()
        identity_changed.send(app._get_current_object(),
                              identity=AnonymousIdentity())
969803
private void removeEntryFromAuthCacheForUser(HttpServletRequest req, HttpServletResponse res) {
        getAuthCacheService();
        if (authCacheService == null) {
            return;
        }
        String user = req.getRemoteUser();
        if (user == null) {
            Principal p = req.getUserPrincipal();
            if (p != null)
                user = p.getName();
        }
        if (user != null) {
            if (collabUtils != null) {
                String realm = collabUtils.getUserRegistryRealm(securityServiceRef);
                if (!user.contains(realm + ":")) {
                    user = realm + ":" + user;
                }
            }
            authCacheService.remove(user);
        }
    }
1194894
def delete(self) :
        """"""
        if not self.URL :
            raise CreationError("Please save user first", None, None)

        r = self.connection.session.delete(self.URL)
        if r.status_code < 200 or r.status_code > 202 :
            raise DeletionError("Unable to delete user, url: %s, status: %s" %(r.url, r.status_code), r.content )

        self.URL = None
1178379
def clear(self):
        """"""

        r = self._h._http_resource(
            method='DELETE',
            resource=('user', 'keys'),
        )

        return r.ok
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
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
558741
def remove(self, username, user_api, filename=None, force=False):
        """"""
        self.keys = API.__get_keys(filename)
        self.username = username
        user = user_api.find(username)[0]

        if not force:  # pragma: no cover
            self.__confirm()

        for key in self.__delete_keys():
            operation = {'sshPublicKey': [(ldap3.MODIFY_DELETE, [key])]}
            self.client.modify(user.entry_dn, operation)
1240539
def remove(id, auth_ids)
      params = {
        id: id,
        auth_ids: auth_ids
      }
      requires params
      DataSift.request(:PUT, 'source/auth/remove', @config, params)
    end
658917
def authenticated_userid(request):
    
    user = getattr(request, 'user', None)
    key = user.pk_field()
    return getattr(user, key)
917406
def delete_user_login(self, id, user_id):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - user_id
        """ID"""
        path["user_id"] = user_id

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        self.logger.debug("DELETE /api/v1/users/{user_id}/logins/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/users/{user_id}/logins/{id}".format(**path), data=data, params=params, no_data=True)
12231
public synchronized ID removeOnline(final USER user)
	{
		final ID sessionId = usersOnline.remove(user);
		if (sessionId != null)
		{
			sessionIdToUser.remove(sessionId);
		}
		return sessionId;
	}
16784
def clear_authentication(self):
        
        self._authentication = None
        self.access_token = None
        self.refresh_token = None
        self.http.cookies.clear()
        self.user = None
343671
def remove(self):
        

        xmlrpc = XMLRPCConnection()
        try:
            xmlrpc.connection.remove_vrf(
                {
                    'vrf': { 'id': self.id },
                    'auth': self._auth_opts.options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        if self.id in _cache['VRF']:
            del(_cache['VRF'][self.id])
625029
def delete(*args)
      raise_authentication_error unless authenticated?
      arguments(args, required: [:id])

      delete_request("/authorizations/#{arguments.id}", arguments.params)
    end
205662
def remove_vip(self, vip_request_ids):
        
        uri = 'api/v3/vip-request/deploy/%s/' % vip_request_ids

        return super(ApiVipRequest, self).delete(uri)