Logout (removes all persistent data)
552851
final public function logout()
    {
        $this->deleteAllPersistentData();
        $this->access_token  = null;
        $this->user          = null;
        $this->id_token      = null;
        $this->refresh_token = null;
    }
565719
def logout(self):
        
        # Remove token from local cache
        # MAINT: need to expire token on server
        data = self._read_uaa_cache()
        if self.uri in data:
            for client in data[self.uri]:
                if client['id'] == self.client['id']:
                    data[self.uri].remove(client)

        with open(self._cache_path, 'w') as output:
            output.write(json.dumps(data, sort_keys=True, indent=4))
1020141
public function logout()
    {
        $this->execute($this->httpClient->setEndPoint(self::ENDPOINT.'logout/'));

        self::$appKey = null;
        self::$sessionToken = null;
        self::$lastLogin = null;
    }
629331
def logout(self):
        """"""
        self._master_token = None
        self._auth_token = None
        self._email = None
        self._android_id = None
238372
public function logout() {
        $this->debug('logout', $this->Cookie, $this->Auth->user());
        $this->delete();
    }
614327
def logout(self):
        """"""
        if self.cache(CONST.ACCESS_TOKEN):
            # No explicit logout call as it doesn't seem to matter
            # if a logout happens without registering the app which
            # we aren't currently doing.
            self._session = requests.session()
            self._devices = None

            self.update_cache({CONST.ACCESS_TOKEN: None})

        return True
405632
def logout(self):
        
        self.client.write('exit\r\n')
        self.client.read_all()
        self.client.close()
322649
def disconnect(self):
        
        if self.r_session:
            self.session_logout()

        self.r_session = None
        self.clear()
1170463
public function logout()
	{
		$acct = $this->acct();

		// If we have an event dispatcher instance, we can fire off the logout event
		// so any further processing can be done. This allows the developer to be
		// listening for anytime a acct signs out of this application manually.
		$this->clearAcctDataFromStorage();

		if ( !is_null( $this->acct ) )
			$this->refreshRememberToken( $acct );

		Hooks::trigger( 'acct.logout', compact( 'acct' ) );

		// Once we have fired the logout event we will clear the accts out of memory
		// so they are no longer available as the acct is no longer considered as
		// being signed into this application and should not be available here.
		$this->acct = null;
		$this->loggedOut = true;
	}
853291
public function logout(): bool
    {
        //remove login data from session
        unset($this->session->login, $this->session->loginTime);

        //regenerate session id
        $this->session->regenerate();
        $this->logged = false;

        return true;
    }
601961
public function logout()
    {
        setcookie($this->config->getCookieName(), '', time() - 3600); // Remove client-side cookie.
        unlink($this->config->getSessionFileName()); // Delete session file.
    }
635291
public function logout()
    {
        try {
            SecurityUtils::getSecurityManager()->logout($this);
        } catch (\Exception $ex) {
            $this->_principals    = null;
            $this->_authenticated = false;
            $this->_session       = null;
        }

    }
150380
def logout_user():
    

    for key in ('identity.name', 'identity.auth_type'):
        session.pop(key, None)
    identity_changed.send(current_app._get_current_object(),
                          identity=AnonymousIdentity())
    _logout_user()
1178379
def clear(self):
        """"""

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

        return r.ok
587277
def logout(self):
        """"""
        warnings.warn("Database.logout() is deprecated",
                      DeprecationWarning, stacklevel=2)

        # Sockets will be deauthenticated as they are used.
        self.client._purge_credentials(self.name)
1328017
def logout(self):
        
        resp = super(CookieSession, self).request('DELETE', self._session_url)
        resp.raise_for_status()
578479
function(req, res) {
      waterlock.logger.debug('user logout');
      delete(req.session.user);

      if (req.session.authenticated) {
        this.logoutSuccess(req, res);
      } else {
        this.logoutFailure(req, res);
      }
    }