Kill the current :class:`Window` object. ``$ tmux kill-window``.
12208
def kill_window(self):
        """"""

        proc = self.cmd(
            'kill-window',
            # '-t:%s' % self.id
            '-t%s:%s' % (self.get('session_id'), self.index),
        )

        if proc.stderr:
            raise exc.LibTmuxException(proc.stderr)

        self.server._update_windows()
425699
def _kill_process(self, pid, sig=signal.SIGKILL):
        """"""
        try:
            os.kill(pid, sig)
        except OSError as e:
            if e.errno == errno.ESRCH: # process itself returned and exited before killing
                logging.debug("Failure %s while killing process %s with signal %s: %s",
                              e.errno, pid, sig, e.strerror)
            else:
                logging.warning("Failure %s while killing process %s with signal %s: %s",
                                e.errno, pid, sig, e.strerror)
178475
def stop_process(self):
        
        if self.process is not None:
            self._user_stop = True
            self.process.kill()
            self.setReadOnly(True)
            self._running = False
953236
def kill_all():
    """"""
    for i in dispatchers.all_instances():
        try:
            os.kill(-i.pid, signal.SIGKILL)
        except OSError:
            # The process was already dead, no problem
            pass
392622
def kill_filler_process(self):
        
        if self.proc:
            if self.proc.is_alive():
                self.proc.terminate()
930044
def kill(self, sig):
        ''''''
        if self.is_alive() and self._loop:
            self._loop.call_soon_threadsafe(self._loop.stop)
382204
def kill(self, dwExitCode = 0):
        
        hThread = self.get_handle(win32.THREAD_TERMINATE)
        win32.TerminateThread(hThread, dwExitCode)

        # Ugliest hack ever, won't work if many pieces of code are injected.
        # Seriously, what was I thinking? Lame! :(
        if self.pInjectedMemory is not None:
            try:
                self.get_process().free(self.pInjectedMemory)
                self.pInjectedMemory = None
            except Exception:
##                raise           # XXX DEBUG
                pass
711930
protected function killCurrentTransport()
    {
        if ($transport = array_pop($this->transports)) {
            try {
                $transport->stop();
            } catch (Exception $e) {
            }
            $this->deadTransports[] = $transport;
        }
    }
1123343
def kill(self):
        

        for process in list(self.processes):
            process["subprocess"].send_signal(signal.SIGKILL)

        self.stop_watch()
241117
def stop(self):
        """"""
        logger.info("stopping process")
        self.watcher.stop()
        os.kill(self.child_pid, signal.SIGTERM)
1128994
def _process_kill(self):
        """"""
        if self._process.poll() is None:  # pragma: no cover
            self._process.kill()
            self._process.wait(timeout=5)
8541
public function kill()
    {
        $this->vars = null;
        $this->ip   = rcube_utils::remote_addr(); // update IP (might have changed)
        $this->destroy(session_id());
        rcube_utils::setcookie($this->cookiename, '-del-', time() - 60);
    }
1075551
def Kill(self):
    """"""
    try:
      if self.is_running:
        self.Detach()
      if self._Execute('__kill__') == '__kill_ack__':
        # acknowledged, let's give it some time to die in peace
        time.sleep(0.1)
    except (TimeoutError, ProxyError):
      logging.debug('Termination request not acknowledged, killing gdb.')
    if self.is_running:
      # death pill didn't seem to work. We don't want the inferior to get killed
      # the next time it hits a dangling breakpoint, so we send a SIGINT to gdb,
      # which makes it disable instruction breakpoints for the time being.
      os.kill(self._process.pid, signal.SIGINT)
      # Since SIGINT has higher priority (with signal number 2) than SIGTERM
      # (signal 15), SIGTERM cannot preempt the signal handler for SIGINT.
      self._process.terminate()
      self._process.wait()
    self._errfile_r.close()
    self._outfile_r.close()
730473
function signalKill(childProcess, callback) {
  childProcess.emit('signalKill');
  if (IS_WINDOWS) {
    const taskkill = spawn('taskkill', ['/F', '/T', '/PID', childProcess.pid]);
    taskkill.on('exit', (exitStatus) => {
      if (exitStatus) {
        return callback(
          new Error(`Unable to forcefully terminate process ${childProcess.pid}`)
        );
      }
      callback();
    });
  } else {
    childProcess.kill('SIGKILL');
    process.nextTick(callback);
  }
}
919827
def kill(self):
        ""
        if self.pid:
            try:
                os.kill(self.pid, signal.SIGTERM)
                # Raises an OSError for ESRCH when we've killed it.
                while True:
                    os.kill(self.pid, signal.SIGTERM)
                    time.sleep(0.01)
            except OSError:
                pass
            self.pid = None
11032
def terminate(self):
        
        try:
            self.send_signal(signal.SIGTERM)
        except pyuv.error.ProcessError as e:
            if e.args[0] != pyuv.errno.UV_ESRCH:
                raise
448840
def close(self):
        """"""
        if self._subprocess is not None:
            os.killpg(self._subprocess.pid, signal.SIGTERM)
            self._subprocess = None