Disconnect current account from the application
        :return:
422824
def disconnect_account(self):
        
        url = self.disconnect_url
        result = self.get(url)
        return result
380737
def delete(self, account_id, user_id):
        
        return self.connection.delete('account/access', account_id=account_id, user_id=user_id)
39206
def disconnect(self, client):
        
        self.clients.remove(client)
        del self.connect_args[client]
        client.disconnect()
715423
def close(self):
        """"""

        if hasattr(self, "conn"):
            self.conn.close()
            del self.conn
        if hasattr(self, "user"):
            del self.user
312143
def deactivate(self, address):
        
        with self.lock:
            try:
                connections = self.connections[address]
            except KeyError: # already removed from the connection pool
                return
            for conn in list(connections):
                if not conn.in_use:
                    connections.remove(conn)
                    try:
                        conn.close()
                    except IOError:
                        pass
            if not connections:
                self.remove(address)
825240
def disconnect(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/disconnect/')
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])
19094
def unlink(self):
        
        if self._closed:
            self._raise_closed()
        self._accessor.unlink(self)
582378
def remove_connection(self, interface1, interface2):
        """"""

        uri = "api/interface/disconnect/%s/%s/" % (interface1, interface2)

        return self.delete(uri)
768078
def disconnect(self, connection):
        
        self.log.debug("Disconnecting %s" % connection)
        if connection in self._pending:
            pending_frame = self._pending[connection]
            self.store.requeue(pending_frame.headers.get(
                'destination'), pending_frame)
            del self._pending[connection]

        for dest in list(self._queues.keys()):
            if connection in self._queues[dest]:
                self._queues[dest].remove(connection)
            if not self._queues[dest]:
                # This won't trigger RuntimeError, since we're using keys()
                del self._queues[dest]
813537
def eject(self, auth_no_user_interaction=None):
        """"""
        return self._assocdrive._M.Drive.Eject(
            '(a{sv})',
            filter_opt({
                'auth.no_user_interaction': ('b', auth_no_user_interaction),
            })
        )
178994
def disconnect(self):
        
        if self._loop.is_running():
            return self._disconnect_coro()
        else:
            self._loop.run_until_complete(self._disconnect_coro())
1017507
def disconnect(remote_app):
    
    if remote_app not in current_oauthclient.disconnect_handlers:
        return abort(404)

    ret = current_oauthclient.disconnect_handlers[remote_app]()
    db.session.commit()
    return ret
54695
def disconnect(self):
        
        if self.con is not None:
            self.con.close()
            log.debug('Closed connection with with set-top box at %s:%s.',
                      self.ip, self.port)
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()
575324
def disconnect(self, slot):
        """"""
        if self.is_connected(slot):
            self.slots.remove(slot)
803914
def disconnect(self, receipt=None, headers=None, **keyword_headers):
        
        Protocol12.disconnect(self, receipt, headers, **keyword_headers)
        self.transport.stop()