merge branch develop

Author: deeleeramone

claude/scripts/build_distributions.py

@@ -121,9 +121,7 @@ def _build_cowork_plugin() -> Path:
     plugin = json.loads(plugin_json_path.read_text(encoding="utf-8"))
     if not plugin["description"].endswith(COWORK_DESCRIPTION_SUFFIX):
         plugin["description"] += COWORK_DESCRIPTION_SUFFIX
-    plugin_json_path.write_text(
-        json.dumps(plugin, indent=2) + "\n", encoding="utf-8"
-    )
+    plugin_json_path.write_text(json.dumps(plugin, indent=2) + "\n", encoding="utf-8")
 
     out = DIST / "pywry-cowork.plugin"
     _zip_directory(workdir, out)
@@ -140,9 +138,7 @@ def _build_desktop_extension() -> Path:
 def _summarize(path: Path) -> None:
     size = path.stat().st_size
     if size > SIZE_LIMIT_BYTES:
-        raise RuntimeError(
-            f"{path.name} is {size:,} bytes — exceeds the 50 MB limit"
-        )
+        raise RuntimeError(f"{path.name} is {size:,} bytes — exceeds the 50 MB limit")
     with zipfile.ZipFile(path) as zf:
         files = zf.namelist()
     rel = path.relative_to(REPO_ROOT)

pywry/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pywry"
-version = "2.0.2"
+version = "2.0.4"
 description = "A lightweight and blazingly fast, cross-platform, WebView rendering engine and desktop UI toolkit for Python. Batteries included."
 authors = [{ name = "PyWry", email = "pywry2@gmail.com" }]
 license = { text = "Apache 2.0" }

pywry/pywry/chat/providers/deepagent.py

@@ -161,65 +161,53 @@ def _step_in_call(self, ch: str) -> None:
                 self._in_string = False
                 self._escape = False
 
-    def _step_in_special(self, ch: str, out: list[str]) -> None:
-        """Advance the ``<|...|>`` state machine; recurse on tail after ``|>``."""
+    def _step_in_special(self, ch: str, _out: list[str]) -> None:
+        """Advance the ``<|...|>`` state machine; close when ``|>`` arrives.
+
+        Because ``feed()`` drives one character at a time and ``_in_special``
+        is entered with an empty buffer, the close marker is always at the
+        tail of the buffer — there is no trailing text to recurse on.
+        """
         self._buffer += ch
-        close_idx = self._buffer.find(self._SPECIAL_CLOSE)
-        if close_idx < 0:
+        if self._SPECIAL_CLOSE not in self._buffer:
             return
-        rest = self._buffer[close_idx + len(self._SPECIAL_CLOSE) :]
         self._buffer = ""
         self._in_special = False
-        if rest:
-            out.append(self.feed(rest))
 
-    def _try_open_call(self, out: list[str]) -> bool:
+    def _try_open_call(self, _out: list[str]) -> bool:
         """If a complete ``functions.<name>...{`` opener sits in buffer, enter call mode.
 
         Returns True if the buffer was consumed (caller skips other checks);
-        False if the marker isn't fully present yet — caller must NOT keep
-        scanning the buffer for ``<|`` (the ``functions.`` prefix already
-        committed us to wait).
+        False if the marker isn't fully present yet.  ``_flush_safe_prefix``
+        guarantees ``functions.`` always sits at the buffer head when it's
+        present, and char-by-char feeding means ``{`` is always the tail —
+        no leading prefix to emit and no trailing text to recurse on.
         """
-        call_idx = self._buffer.find(self._CALL_START)
-        if call_idx < 0:
+        if self._CALL_START not in self._buffer:
             return False
-        brace_idx = self._buffer.find("{", call_idx + len(self._CALL_START))
+        brace_idx = self._buffer.find("{", len(self._CALL_START))
         if brace_idx < 0:
             # Marker present but no ``{`` yet — keep buffering, do not
             # fall through to the ``<|`` check (it would never match
             # ``functions.`` and we'd over-emit).
             return True
-        if call_idx > 0:
-            out.append(self._buffer[:call_idx])
-        rest = self._buffer[brace_idx + 1 :]
         self._buffer = ""
         self._in_call = True
         self._depth = 1
         self._in_string = False
         self._escape = False
-        if rest:
-            out.append(self.feed(rest))
         return True
 
-    def _try_open_special(self, out: list[str]) -> bool:
-        """If a ``<|...|>`` token (or its open) is in buffer, drop it; return True."""
-        special_idx = self._buffer.find(self._SPECIAL_OPEN)
-        if special_idx < 0:
+    def _try_open_special(self, _out: list[str]) -> bool:
+        """If a ``<|`` opener sits in buffer, drop it and enter skip mode.
+
+        ``_flush_safe_prefix`` guarantees only ``<|`` itself (no trailing
+        text) ever reaches us, and the closing ``|>`` is consumed later
+        by ``_step_in_special`` — so we only need to handle the "open
+        seen, no close yet" case.
+        """
+        if self._SPECIAL_OPEN not in self._buffer:
             return False
-        close_idx = self._buffer.find(self._SPECIAL_CLOSE, special_idx + len(self._SPECIAL_OPEN))
-        if close_idx >= 0:
-            if special_idx > 0:
-                out.append(self._buffer[:special_idx])
-            rest = self._buffer[close_idx + len(self._SPECIAL_CLOSE) :]
-            self._buffer = ""
-            if rest:
-                out.append(self.feed(rest))
-            return True
-        # Open seen but no close yet — drop everything from ``<|`` on,
-        # emit the prefix, enter token-skip mode.
-        if special_idx > 0:
-            out.append(self._buffer[:special_idx])
         self._buffer = ""
         self._in_special = True
         return True

pywry/pywry/cli.py

@@ -447,9 +447,6 @@ def show_config_sources() -> int:
         if forced_status is True:
             status = "✓ Active"
             path_display = ""
-        elif forced_status is False:
-            status = "✗ Not found"
-            path_display = path_str
         # Check if file exists
         elif name == "Environment variables":
             import os

pywry/pywry/config.py

@@ -27,7 +27,7 @@
 
 if sys.version_info >= (3, 11):
     import tomllib
-else:
+else:  # pragma: no cover - python 3.10 fallback; cannot be exercised on 3.11+
     try:
         import tomli as tomllib
     except ImportError: