scootcli 0.6.0__tar.gz → 0.8.0__tar.gz

{scootcli-0.6.0/src/scootcli.egg-info → scootcli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.6.0
+Version: 0.8.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -116,6 +116,7 @@ scoot --model auto "..."             # pick a model per prompt from the live lis
 ```
 
 Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
 
 ### Routing
 
@@ -219,6 +220,7 @@ Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
+Resizing the window or zooming the font (also under tmux) repaints the dock at once: the transcript stays where it was, the input keeps its place and the bar is redrawn, at the prompt and while a turn runs.
 Under tmux, ESC reaches scoot only after tmux's `escape-time` has passed, so with the default 500 ms the interrupt feels delayed; `set -sg escape-time 10` in `~/.tmux.conf` makes it immediate.
 For clipboard copy through tmux, `set -g set-clipboard on` (or `external`) lets the OSC-52 escape reach the outer terminal.
 Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
@@ -259,12 +261,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -276,14 +279,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
-**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
-`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release exists
+```
+
+With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 

{scootcli-0.6.0 → scootcli-0.8.0}/README.md

@@ -91,6 +91,7 @@ scoot --model auto "..."             # pick a model per prompt from the live lis
 ```
 
 Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
 
 ### Routing
 
@@ -194,6 +195,7 @@ Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
+Resizing the window or zooming the font (also under tmux) repaints the dock at once: the transcript stays where it was, the input keeps its place and the bar is redrawn, at the prompt and while a turn runs.
 Under tmux, ESC reaches scoot only after tmux's `escape-time` has passed, so with the default 500 ms the interrupt feels delayed; `set -sg escape-time 10` in `~/.tmux.conf` makes it immediate.
 For clipboard copy through tmux, `set -g set-clipboard on` (or `external`) lets the OSC-52 escape reach the outer terminal.
 Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
@@ -234,12 +236,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -251,14 +254,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
-**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
-`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release exists
+```
+
+With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/__init__.py

@@ -1,4 +1,4 @@
 """scoot: a tiny coding agent that goes where you point it."""
 
-__version__ = "0.6.0"
+__version__ = "0.8.0"
 

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/agent.py

@@ -219,8 +219,10 @@ class Agent:
             return "", ""
         from .hooks import tool_kind
 
+        from .hooks import tool_alias
+
         payload = hooks.payload(session, "PreToolUse", tool_name=tool.name, tool_input=args,
-                                tool_kind=tool_kind(tool))
+                                tool_kind=tool_kind(tool), tool_alias=tool_alias(tool.name))
         decision = hooks.run("PreToolUse", payload, cancel_event)
         return decision.action, decision.reason
 
@@ -232,9 +234,11 @@ class Agent:
 
         response = {"ok": result.ok, "summary": result.summary or "", "error": result.error or "",
                     "content": (result.content or "")[:4000]}
+        from .hooks import tool_alias
+
         hooks.run("PostToolUse", hooks.payload(session, "PostToolUse", tool_name=tool.name,
                                                tool_input=args, tool_kind=tool_kind(tool),
-                                               tool_response=response))
+                                               tool_alias=tool_alias(tool.name), tool_response=response))
 
     @staticmethod
     def _last_user_text(session) -> str:

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/cli.py

@@ -194,6 +194,7 @@ def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, re
             "content": outcome.content,
             "error": outcome.error,
             "usage": session.last_usage,
+            "cost": session.session_cost(),
         }, indent=2))
         return 0 if outcome.status == "done" else 1
 
@@ -224,11 +225,21 @@ def _cmd_auth(config: Config, pool: ProviderPool, words: List[str]) -> int:
     return 0
 
 
-def _interactive(pool: ProviderPool, resume=None) -> int:
-    """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands)."""
+def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str] = None) -> int:
+    """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands).
+
+    ``remember_model`` is the model named on the command line (``--model``), if any. Launching the REPL
+    with it counts as choosing it, exactly like ``/model`` inside the REPL, so it is saved as the
+    preference and a plain ``scoot`` next time starts on the same model. One-shot prompts and headless
+    runs do not save it: a flag on a single command is not a choice for the next session.
+    """
     from .repl import Repl
 
     config = pool.config
+    if remember_model and remember_model.strip():
+        from .preferences import set_model
+
+        set_model(remember_model.strip())
     # resume=auto (SCOOT_RESUME / --resume-last): reload the latest session for this directory
     # unless the user already picked one explicitly via --resume/--continue.
     if resume is None and getattr(config, "resume", "hint") == "auto":
@@ -308,7 +319,7 @@ def main(argv: Optional[List[str]] = None) -> int:
             return run_headless(config.override(panel=False, dock=False, logo=False), pool, resume=resume)
         if prompt is not None:
             return _run_once(config, pool, prompt, args.json, resume=resume)
-        return _interactive(pool, resume=resume)
+        return _interactive(pool, resume=resume, remember_model=args.model)
     except ScootError as exc:
         eprint(color(f"⚠ {redact(str(exc))}", "red"))
         return 1

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/headless.py

@@ -285,6 +285,7 @@ class Headless:
         self.cancel = threading.Event()
         self.ui.cancel_event = self.cancel
         self.session.last_error = ""
+        before = self._session_cost()
         try:
             with redirect_stdout(sys.stderr):  # any stray print from a tool or command stays off the protocol
                 try:
@@ -303,6 +304,7 @@ class Headless:
                 self.writer.emit("error", message=outcome.error, kind="turn")
             self.writer.emit("turn_end", turn=self._turn, status=outcome.status, steps=outcome.steps,
                              model=self.session.active_model, usage=self.session.last_usage,
+                             cost=self._turn_cost(before), cost_session=self._session_cost(),
                              content=outcome.content, error=outcome.error)
         except ScootError as exc:
             self.writer.emit("error", message=str(exc), hint=getattr(exc, "hint", ""), kind="turn")
@@ -313,6 +315,19 @@ class Headless:
             self.cancel = None
             self.ui.cancel_event = None
 
+    def _session_cost(self):
+        fn = getattr(self.session, "session_cost", None)
+        try:
+            return fn() if callable(fn) else None
+        except Exception:
+            return None
+
+    def _turn_cost(self, before):
+        after = self._session_cost()
+        if after is None or before is None:
+            return None
+        return round(after - before, 6)
+
     def _command(self, msg: dict) -> None:
         from . import commands
         import io

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/hooks.py

@@ -36,6 +36,12 @@ EVENTS = ("SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop
 DEFAULT_TIMEOUT = 60
 _MAX_CAPTURE = 16_000
 _TOOL_KINDS = {"read": "read", "write": "write", "shell": "shell"}
+# Claude Code's names for the same jobs, so a hooks.json written for it ("matcher": "Bash|Write|Edit")
+# fires for scoot's tools too, and a shared script can switch on ``tool_alias``.
+TOOL_ALIASES = {
+    "read_file": "Read", "list_dir": "LS", "search": "Grep", "write_file": "Write", "edit_file": "Edit",
+    "run_shell": "Bash", "open_editor": "Open", "update_plan": "TodoWrite",
+}
 
 
 @dataclass
@@ -96,6 +102,19 @@ def tool_kind(tool) -> str:
     return _TOOL_KINDS.get(getattr(tool, "risk", ""), "read")
 
 
+def tool_alias(name: str) -> str:
+    return TOOL_ALIASES.get(name, name)
+
+
+def matcher_hits(matcher: str, tool_name: str) -> bool:
+    """A matcher regex matches scoot's tool name or its Claude Code alias."""
+    try:
+        rx = re.compile(str(matcher))
+    except re.error:
+        return False
+    return bool(rx.search(tool_name) or rx.search(tool_alias(tool_name)))
+
+
 class Hooks:
     """The merged hook configuration for one workspace, plus a record of what ran."""
 
@@ -149,10 +168,7 @@ class Hooks:
         for entry in self.config.get(event, []):
             matcher = entry.get("matcher")
             if matcher and event in ("PreToolUse", "PostToolUse"):
-                try:
-                    if not re.search(str(matcher), tool_name):
-                        continue
-                except re.error:
+                if not matcher_hits(matcher, tool_name):
                     continue
             for hook in entry.get("hooks", []):
                 if not isinstance(hook, dict) or hook.get("type", "command") != "command":
@@ -212,7 +228,21 @@ class Hooks:
     @staticmethod
     def _interpret(event: str, data: dict) -> Decision:
         reason = str(data.get("reason") or "")
-        perm = str(data.get("permissionDecision") or "").lower()
+        # Claude Code nests a hook's decision under "hookSpecificOutput" (with the reason as
+        # "permissionDecisionReason" and extra context as "additionalContext"); scoot's own flat
+        # shape puts the same keys at the top level. Read both, nested first.
+        hso = data.get("hookSpecificOutput")
+        if isinstance(hso, dict):
+            if not reason:
+                reason = str(hso.get("permissionDecisionReason") or hso.get("reason") or "")
+            perm_src = hso.get("permissionDecision")
+            context_src = hso.get("additionalContext")
+        else:
+            perm_src = data.get("permissionDecision")
+            context_src = None
+        perm = str(perm_src or "").lower()
+        if perm == "approve":
+            perm = "allow"  # Claude Code's older synonym
         if event == "PreToolUse" and perm in ("allow", "deny", "ask"):
             return Decision(action=perm, reason=reason)
         raw = str(data.get("decision") or "").lower()
@@ -220,7 +250,7 @@ class Hooks:
             return Decision(action="deny" if event == "PreToolUse" else "block", reason=reason)
         if raw == "approve" and event == "PreToolUse":
             return Decision(action="allow", reason=reason)
-        context = data.get("additionalContext") or data.get("context") or ""
+        context = context_src or data.get("additionalContext") or data.get("context") or ""
         return Decision(context=str(context) if context else "")
 
     def _record(self, event: str, command: str, outcome: str, detail: str, started: float) -> None:

{scootcli-0.6.0 → scootcli-0.8.0}/src/scootcli/keys.py

@@ -6,13 +6,19 @@ the in-flight request (and, later, tool) immediately.
 
 Line editing for typing prompts happens in normal cooked mode (plain ``input()``); raw mode is only
 active *while the agent works*, so we never interfere with the user typing.
+
+While a section is active it is the only reader of stdin, so it also relays the terminal's answer to
+a cursor-position request (``ESC[6n`` → ``ESC[row;colR``); :func:`query_cursor` is how the REPL finds
+out where output is after a resize that happened mid-turn.
 """
 
 from __future__ import annotations
 
 import os
+import re
 import sys
 import threading
+from typing import Optional, Tuple
 
 try:
     import termios
@@ -25,6 +31,35 @@ except ImportError:  # pragma: no cover - non-POSIX
 
 ESC = "\x1b"
 NOTE_KEY = b"\x0e"  # Ctrl-N: ask for a note at the next model call
+_CURSOR_REPORT = re.compile(rb"\x1b\[(\d+);(\d+)R")  # the terminal's answer to ESC[6n
+
+_active_section: "Optional[InterruptibleSection]" = None  # the section currently reading stdin
+
+
+def parse_cursor_report(data: bytes) -> Optional[Tuple[int, int]]:
+    """``(row, col)`` from a byte stream holding ``ESC[row;colR``, or ``None``."""
+    m = _CURSOR_REPORT.search(data)
+    return (int(m.group(1)), int(m.group(2))) if m else None
+
+
+def query_cursor(timeout: float = 0.2) -> Optional[Tuple[int, int]]:
+    """Ask the terminal where the cursor is, while a section's listener can read the answer.
+
+    Returns ``(row, col)`` (1-based) or ``None`` when no section is active (so nothing would read the
+    reply and it would leak into the next prompt) or the terminal did not answer in time.
+    """
+    section = _active_section
+    if section is None or not section.enabled:
+        return None
+    from .resize import CURSOR_REPORT
+
+    section.cursor_event.clear()
+    section.cursor_report = None
+    sys.stdout.write(CURSOR_REPORT)
+    sys.stdout.flush()
+    if section.cursor_event.wait(timeout):
+        return section.cursor_report
+    return None
 
 
 def read_key() -> str:
@@ -63,8 +98,11 @@ class InterruptibleSection:
         self._old_attrs = None
         self._thread = None
         self._stop = threading.Event()
+        self.cursor_report: Optional[Tuple[int, int]] = None  # last ESC[row;colR seen (see query_cursor)
+        self.cursor_event = threading.Event()
 
     def __enter__(self) -> "InterruptibleSection":
+        global _active_section
         if not self.enabled:
             return self
         try:
@@ -76,6 +114,7 @@ class InterruptibleSection:
             return self
         self._thread = threading.Thread(target=self._listen, daemon=True)
         self._thread.start()
+        _active_section = self
         return self
 
     def _listen(self) -> None:
@@ -102,17 +141,27 @@ class InterruptibleSection:
                 except (OSError, ValueError):
                     more = None
                 if more:
+                    seq = bytearray(ch)
                     try:
                         while select.select([sys.stdin], [], [], 0)[0]:
-                            if not os.read(self._fd, 1):
+                            byte = os.read(self._fd, 1)
+                            if not byte:
                                 break
+                            seq += byte
                     except (OSError, ValueError):
                         pass
+                    report = parse_cursor_report(bytes(seq))
+                    if report is not None:  # the terminal answering query_cursor
+                        self.cursor_report = report
+                        self.cursor_event.set()
                     continue
                 self.cancel_event.set()
                 break
 
     def __exit__(self, *exc) -> None:
+        global _active_section
+        if _active_section is self:
+            _active_section = None
         self._stop.set()
         if self._thread is not None:
             self._thread.join(timeout=0.3)