close the console
766599
def close(self):
        ''''''
        self.close_event.set()
        if self.is_alive():
            self.child.join(2)
1361368
def close(self):
        
        self.run_info['end'] = datetime.now()
        self._p.stdin.close()
        for line in self._p.stdout:
            if line.startswith('NOTE: tsdb run:'):
                self._read_run_info(line)
            else:
                logging.debug('ACE cleanup: {}'.format(line.rstrip()))
        retval = self._p.wait()
        return retval
78537
def close(self):
        
        if self.device:
            usb.util.dispose_resources(self.device)
        self.device = None
1246718
def abort!
      console = Console.new
      console.log(messages.shift) until messages.empty?
    end
28284
def close(self):
        
        if self.parent:
            self.parent.update(self.parent.offset + self.offset)
            return
        self.output.write("\n")
        self.output.flush()
420430
def close(self):
        """"""
        with self.lock:
            if self.device is not None:
                try:
                    self.device.close()
                except IOError:
                    pass
                self.device = None
370475
def close(self):
        

        if self._closed:
            return False

        log.info("{module}: '{name}' [{id}]: is closing".format(module=self.manager.module_name,
                                                                name=self.name,
                                                                id=self.id))

        if self._console:
            self._manager.port_manager.release_tcp_port(self._console, self._project)
            self._console = None
        if self._wrap_console:
            self._manager.port_manager.release_tcp_port(self._internal_console_port, self._project)
            self._internal_console_port = None

        if self._aux:
            self._manager.port_manager.release_tcp_port(self._aux, self._project)
            self._aux = None

        self._closed = True
        return True
1336920
def close(self):
        
        _vv and IOLOG.debug('%r.close()', self)
        self.context.send(
            Message.dead(
                reason=self.explicit_close_msg,
                handle=self.dst_handle
            )
        )
478795
def close(self):
        """"""
        if self._proc is not None:
            self._proc.stdin.close()
            self._proc.wait()
930787
@Override
    public void close() {
        if (!this.closed) {
            try {
                Future<String> closeTask = threadpool.submit(() -> {
                    commandWriter.println("exit");
                    p.waitFor();
                    return "OK";
                });
                if (!closeAndWait(closeTask) && this.pid > 0) {
                    //If it can be closed, force kill the process
                    Logger.getLogger(PowerShell.class.getName()).log(Level.INFO,
                            "Forcing PowerShell to close. PID: " + this.pid);
                    try {
                        Runtime.getRuntime().exec("taskkill.exe /PID " + pid + " /F /T");
                        this.closed = true;
                    } catch (IOException e) {
                        Logger.getLogger(PowerShell.class.getName()).log(Level.SEVERE,
                                "Unexpected error while killing powershell process", e);
                    }
                }
            } catch (InterruptedException | ExecutionException ex) {
                logger.log(Level.SEVERE,
                        "Unexpected error when when closing PowerShell", ex);
            } finally {
                commandWriter.close();
                try {
                    if (p.isAlive()) {
                        p.getInputStream().close();
                    }
                } catch (IOException ex) {
                    logger.log(Level.SEVERE,
                            "Unexpected error when when closing streams", ex);
                }
                if (this.threadpool != null) {
                    try {
                        this.threadpool.shutdownNow();
                        this.threadpool.awaitTermination(5, TimeUnit.SECONDS);
                    } catch (InterruptedException ex) {
                        logger.log(Level.SEVERE,
                                "Unexpected error when when shutting down thread pool", ex);
                    }

                }
                this.closed = true;
            }
        }
    }
878875
def close(self):
        """"""
        close_command = StandardSend(self._address,
                                     COMMAND_LIGHT_OFF_0X13_0X00)
        self._send_method(close_command, self._closed_message_received)
105158
def closeEvent(self, e):
        """"""
        self.emit('close_widget')
        super(DockWidget, self).closeEvent(e)
40833
def close(self):
        ''''''
        if self.handle is not None:
            self.close_handle(self.nsdk, self.handle)
            self.handle = None
87428
function _close()
    {
        switch ($this->mode) {
            case self::MODE_SSH2:
                $this->ssh->_close_channel(SSH2::CHANNEL_EXEC, true);
                break;
            case self::MODE_SSH1:
                $this->ssh->disconnect();
        }
    }
1031828
def close(self):
        """"""
        try:
            self._socket.sendall('quit\r\n')
        except socket.error:
            pass
        try:
            self._socket.close()
        except socket.error:
            pass
965862
def quit(self):
        """"""
        sys.stdout = self._oldstdout
        sys.stderr = self._oldstderr
        self.destroy()
116713
def close(self) -> None:
        
        self.__data_channel_buffer.stop()
        self.__data_channel_buffer.close()
        self.__data_channel_buffer = None
        if not self.__was_playing:
            self.__hardware_source.stop_playing()