Disconnect from the arm.
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.'))
578070
def disconnect(self):
        
        self.connState = Client.DISCONNECTED
        if self.conn is not None:
            self._logger.info('Disconnecting')
            self.conn.disconnect()
            self.wrapper.connectionClosed()
            self.reset()
259573
def disconnect(self):
        
        try:
            self.socket.shutdown(1)

        # If its currently a socket, set it to None
        except AttributeError:
            self.socket = None
        except Exception:
            self.socket = None

        # Set the self.socket to None, no matter what.
        finally:
            self.socket = None
448519
def disconnect_async(self, conn_id, callback):
        """"""

        future = self._loop.launch_coroutine(self._adapter.disconnect(conn_id))
        future.add_done_callback(lambda x: self._callback_future(conn_id, x, callback))
1238337
def disconnect(self, driver):
        """"""
        self.log("SSH disconnect")
        try:
            self.device.ctrl.sendline('\x03')
            self.device.ctrl.sendline('\x04')
        except OSError:
            self.log("Protocol already disconnected")
1062916
public function disconnect()
    {
        $this->connection = null;

        foreach ($this->getSlaves() as $slave) {
            $slave->disconnect();
        }
    }
915629
def disconnect(self):
        """"""
        if self.pipeline:
            self._send(*self.pipeline)
        self.pipeline = None
322649
def disconnect(self):
        
        if self.r_session:
            self.session_logout()

        self.r_session = None
        self.clear()
1309752
def disconnect(self):
        """"""
        _LOGGING.debug('Disconnecting from stream: %s', self.name)
        self.kill_thrd.set()
        self.thrd.join()
        _LOGGING.debug('Event stream thread for %s is stopped', self.name)
        self.kill_thrd.clear()
86754
def disconnect(self):
        """"""
        self.logger.info("DISCONNECT")
        if self.sock == NC.INVALID_SOCKET:
            return NC.ERR_NO_CONN
        self.state = NC.CS_DISCONNECTING
        
        ret = self.send_disconnect()
        ret2, bytes_written = self.packet_write()

        self.socket_close()
        return ret
460227
function disconnect() {
  var force = arguments.length <= 0 || arguments[0] === undefined ? false : arguments[0];
  var cb = arguments.length <= 1 || arguments[1] === undefined ? undefined : arguments[1];

  console.log('Disconnecting client: ' + clientId);
  stopPub = true;
  client.end(force, cb);
}
316205
function disconnect () {
    _connectingMaster = null
    if (_socket) {
      _socket.close()
      _socket = null
      debug('disconnected')
      connection.emit('disconnect')
    }
    return connection
  }
1048046
def disconnect(self):
        """"""
        if self.connected and self.channel:
            logging.debug("Disconnecting KNX/IP tunnel...")

            frame = KNXIPFrame(KNXIPFrame.DISCONNECT_REQUEST)
            frame.body = self.hpai_body()

            # TODO: Glaube Sequence erhoehen ist nicht notwendig im Control
            # Tunnel beim Disconnect???
            if self.seq < 0xff:
                self.seq += 1
            else:
                self.seq = 0

            self.control_socket.sendto(
                bytes(frame.to_frame()), (self.remote_ip, self.remote_port))
            # TODO: Impelement the Disconnect_Response Handling from Gateway
            # Control Channel > Client Control Channel

        else:
            logging.debug("Disconnect - no connection, nothing to do")

        self.channel = None
        self.connected = False
1130944
def disconnect(self):
        """"""
        if self.pipeline:
            self._send(*self.pipeline)
        self.transport.close()
        self.transport = self.pipeline = None
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)
307387
def disconnect(self):
        """"""

        self._logger.info("iface '%s' disconnects", self.name())

        self._wifi_ctrl.disconnect(self._raw_obj)
1144835
def on_disconnect(self):
        ""
        self._sock = None
        if self._buffer is not None:
            self._buffer.close()
            self._buffer = None
        self.encoder = None