Disconnect from a connected device.

        See :meth:`AbstractDeviceAdapter.disconnect`.
187215
async def disconnect(self, conn_id):
        

        adapter_id = self._get_property(conn_id, 'adapter')
        await self.adapters[adapter_id].disconnect(conn_id)

        self._teardown_connection(conn_id)
425442
async def disconnect(self, expected=True):
        
        if self.connected:
            # Unschedule ping checker.
            if self._ping_checker_handle:
                self._ping_checker_handle.cancel()

            # Schedule disconnect.
            await self._disconnect(expected)
400521
def disconnect(self):
        ""
        self._checkpid()
        all_conns = chain(self._available_connections,
                          self._in_use_connections)
        for connection in all_conns:
            connection.disconnect()
261031
def disconnect(self):
        
        try: # connection may already be disconnected, so catch exceptions
            self.socket.shutdown(socket.SHUT_RDWR) # a proper disconnect
        except socket.error:
            pass
        self.socket.close()
        self.connected = False
895880
def disconnect(self):
        

        if self.client is None:
            return

        try:
            self.client.disconnect()
        except operationError as exc:
            raise InternalError("Could not disconnect from AWS IOT", message=exc.message)
755083
def disconnect(self):
        
        if self.connected:
            try:
                self._smtp.close()
                self._connected = False
                result = True
            except Exception:  # noqa
                self._logger.exception('Something went wrong!')
                result = False
            return result
93916
def disconnect_from(callback, signals):
    
    # Support for lists of signals
    if not isinstance(signals, (list, tuple)):
        signals = [signals]

    # Remove callback from receiver list if it responds to the signal
    for signal in signals:
        if responds_to(callback, signal):
            receivers[signal].remove(callback)
178994
def disconnect(self):
        
        if self._loop.is_running():
            return self._disconnect_coro()
        else:
            self._loop.run_until_complete(self._disconnect_coro())
1045531
async def disconnect(self, *, force=False):
        
        if not force and not self.is_connected():
            return

        self.stop()
        self._connected.clear()

        try:
            if self.ws:
                await self.ws.close()

            await self.terminate_handshake(remove=True)
        finally:
            if self.socket:
                self.socket.close()
1144835
def on_disconnect(self):
        ""
        self._sock = None
        if self._buffer is not None:
            self._buffer.close()
            self._buffer = None
        self.encoder = None
322649
def disconnect(self):
        
        if self.r_session:
            self.session_logout()

        self.r_session = None
        self.clear()
350245
def disconnect(self):
        
        self._parser.on_disconnect()
        if self._sock is None:
            return
        try:
            self._sock.shutdown(socket.SHUT_RDWR)
            self._sock.close()
        except socket.error:
            pass
        self._sock = None
149134
public function disconnect(): void
    {
        if ($this->socket) {
            stream_socket_shutdown($this->socket, STREAM_SHUT_RDWR);
        }
        $this->socket = null;
        $this->connected = false;
    }
551312
async def disconnect(self):
        """"""
        self._data = await self._handler.disconnect(
            system_id=self.node.system_id, id=self.id)
1371522
public synchronized void disconnect() {
    if (mConnected) {
      Preconditions.checkNotNull(mChannel, PreconditionMessage.CHANNEL_NULL_WHEN_CONNECTED);
      LOG.debug("Disconnecting from the {} @ {}", getServiceName(), mAddress);
      beforeDisconnect();
      mChannel.shutdown();
      mConnected = false;
      afterDisconnect();
    }
  }
321514
def disconnect(self):
        

        for name, wire in self.wires():
            self.cut(name, disconnect=True)
967772
def do_disconnect(self, arg):
        '''  '''
        if not self.arm.is_connected():
            print(self.style.error('Error: ', 'Arm is already disconnected.'))
        else:
            self.arm.disconnect()
            print(self.style.success('Success: ', 'Disconnected.'))