iCode-TUI 0.29.1__py3-none-any.whl

chrys/foundation/patches/textual_timer_skip.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2021 Will McGugan
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+# Contains code adapted from Textual (MIT License; see NOTICE).
+
+"""Patch: a late Textual timer tick skips only the ticks that have passed.
+
+Problem
+-------
+When a repeating timer wakes after its next tick is already due, Textual 8.2.7's ``Timer._run``
+skips ahead with ``count = int((now - start) / interval + 1)``, which counts one boundary too
+many: the next tick lands an extra interval later than the first one still ahead. Every
+screen's refresh timer (``Screen._update_timer``, 1/60 s) hits this after each idle pause and
+after every frame that overruns its interval, so a busy streaming transcript paints at half the
+rate its frames would allow.
+
+Solution
+--------
+Skip to the last tick that has passed, so the next tick is the first one still ahead
+(``count + 1`` keeps the loop advancing if float rounding lands on a passed tick). One-shot
+timers keep ``textual_one_shot_timer``'s ``skip=False``.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from chrys.foundation.patches.patcher import FilePatch, register
+from chrys.foundation.patches.staged_members import install_patched_members
+
+_RUNTIME_PATCH_MARKER = "_chrys_timer_skips_passed_ticks"
+_RUNTIME_PATCH_TEXTUAL_VERSION = "8.2.7"
+logger = logging.getLogger(__name__)
+
+_OLD = """\
+            if self._skip and next_timer < now:
+                count = int((now - start) / _interval + 1)
+                continue"""
+
+_NEW = """\
+            if self._skip and next_timer < now:
+                # Skip the ticks whose time has passed; the next tick is the first one still ahead.
+                # (`count + 1` keeps the loop advancing if float rounding lands on a passed tick.)
+                count = max(count + 1, int((now - start) / _interval))
+                continue"""
+
+_PATCH = FilePatch(
+    package="textual",
+    module_file="timer.py",
+    old_fragment=_OLD,
+    new_fragment=_NEW,
+    description="Skip only the timer ticks that have passed",
+)
+
+register(_PATCH)
+
+
+def apply_runtime_patch() -> None:
+    """Install the patched ``Timer._run`` in the current process."""
+    try:
+        import textual
+        import textual.timer as timer_mod
+    except ImportError:
+        return
+    if textual.__version__ != _RUNTIME_PATCH_TEXTUAL_VERSION:
+        logger.warning(
+            "Skipping Textual timer runtime patch: loaded Textual is not the pinned %s that the patch targets.",
+            _RUNTIME_PATCH_TEXTUAL_VERSION,
+        )
+        return
+    install_patched_members(timer_mod, [_PATCH], {"Timer": ["_run"]}, marker=_RUNTIME_PATCH_MARKER, label="timer")

chrys/foundation/patches/textual_utf8_decoder.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2021 Will McGugan
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+# Contains code adapted from Textual (MIT License; see NOTICE).
+
+"""Patch: use ``errors="replace"`` for UTF-8 incremental decoders in Textual drivers.
+
+Problem
+-------
+The input threads in ``LinuxDriver``, ``LinuxInlineDriver``, and
+``WebDriver`` create a strict UTF-8 decoder (the default).  If any
+invalid byte sequence arrives from the terminal (e.g. a locale mismatch,
+raw binary leaking into stdin, or a broken paste), the decoder raises
+``UnicodeDecodeError`` and crashes the input thread, killing all
+keyboard/mouse handling.
+
+Solution
+--------
+Pass ``errors="replace"`` so invalid bytes are replaced with U+FFFD
+instead of raising.  The application stays responsive; garbled input is
+visibly wrong but non-fatal.
+
+If a launcher has already imported a driver, its input method still has the old
+code. Update that module's decoder factory too. This also reaches an input
+method captured by a Thread before startup without replacing driver classes.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from codecs import IncrementalDecoder, getincrementaldecoder
+from encodings.utf_8 import IncrementalDecoder as Utf8IncrementalDecoder
+from typing import Protocol
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_RUNTIME_PATCH_TEXTUAL_VERSION = "8.2.7"
+_DRIVER_MODULES = (
+    "textual.drivers.linux_driver",
+    "textual.drivers.linux_inline_driver",
+    "textual.drivers.web_driver",
+)
+logger = logging.getLogger(__name__)
+
+
+class _IncrementalDecoderFactory(Protocol):
+    """Codec factory accepting the stdlib's optional error policy."""
+
+    def __call__(self, errors: str = ...) -> IncrementalDecoder: ...
+
+
+class _TerminalUTF8Decoder(Utf8IncrementalDecoder):
+    """Use replacement by default while retaining explicit error policies."""
+
+    def __init__(self, errors: str = "replace") -> None:
+        super().__init__(errors)
+
+
+def _terminal_decoder_factory(encoding: str) -> _IncrementalDecoderFactory:
+    decoder = getincrementaldecoder(encoding)
+    return _TerminalUTF8Decoder if decoder is Utf8IncrementalDecoder else decoder
+
+
+def apply_runtime_patch() -> None:
+    """Repair preloaded drivers without importing POSIX modules on Windows."""
+    try:
+        import textual
+    except ImportError:
+        return
+    if textual.__version__ != _RUNTIME_PATCH_TEXTUAL_VERSION:
+        logger.warning("Skipping UTF-8 decoder patch for unsupported Textual %s", textual.__version__)
+        return
+    # Future imports use the file patch; preloaded functions resolve this live
+    # module global. The stdlib codec registry and other encodings stay intact.
+    for module_name in _DRIVER_MODULES:
+        module = sys.modules.get(module_name)
+        if module is not None:
+            module.getincrementaldecoder = _terminal_decoder_factory
+
+
+_OLD = 'utf8_decoder = getincrementaldecoder("utf-8")().decode'
+_NEW = 'utf8_decoder = getincrementaldecoder("utf-8")(errors="replace").decode'
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="drivers/linux_driver.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Use errors='replace' for UTF-8 decoder in LinuxDriver",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="drivers/linux_inline_driver.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Use errors='replace' for UTF-8 decoder in LinuxInlineDriver",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="drivers/web_driver.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Use errors='replace' for UTF-8 decoder in WebDriver",
+    ),
+)

chrys/foundation/patches/textual_win_sleep.py

@@ -0,0 +1,167 @@
+# Copyright (c) 2021 Will McGugan
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+# Contains code adapted from Textual (MIT License; see NOTICE).
+
+"""Sleep Textual's Windows timers on the event loop's completion port, not on executor threads.
+
+Textual 8.2.7 sleeps every timer tick in ``run_in_executor(None, WaitForMultipleObjects)``:
+each armed timer pins a default-executor thread for the length of its sleep and every tick
+is a thread hop each way. A screen with a handful of animations fills the small default
+pool (``min(32, cpus + 4)`` threads), so ``to_thread`` work queues behind sleeping timers
+and the loop thread stalls in ``Thread.start`` growing the pool. Its cancellation also
+closes the timer handles without joining the native wait.
+
+Keep Textual's high-resolution waitable timer for its accuracy, but register it with the
+``ProactorEventLoop``'s I/O completion port — the wait asyncio itself uses for subprocess
+exit. A kernel wait thread posts to the port when the timer fires, the loop completes the
+future itself, and no Python thread sleeps. Cancellation re-arms the timer to fire at once,
+so the registered wait completes and unregisters itself before the handle closes; a port
+that stops delivering gets the wait unregistered after a short bound instead of wedging
+the cancellation. A loop without a completion port sleeps on the loop's own clock. Both Textual entry points are
+replaced, including the alias already imported by ``textual._time``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import ctypes
+import logging
+from collections.abc import Callable
+from ctypes.wintypes import LARGE_INTEGER
+from typing import Any
+
+from chrys.foundation.platform import get_platform
+
+_RUNTIME_PATCH_TEXTUAL_VERSION = "8.2.7"
+_RUNTIME_PATCH_MARKER = "_chrys_registers_windows_timer_wait"
+_CREATE_WAITABLE_TIMER_MANUAL_RESET = 0x00000001
+_CREATE_WAITABLE_TIMER_HIGH_RESOLUTION = 0x00000002
+_TIMER_ALL_ACCESS = 0x1F0003
+# Negative due times are relative, in 100 ns units.
+_FIRE_AT_ONCE = LARGE_INTEGER(-1)
+# A re-armed timer reaches the port within microseconds; a wait still pending after
+# this bound sits on a port that no longer delivers, and cancellation must not hang on it.
+_REARM_SETTLE_SECONDS = 1.0
+logger = logging.getLogger(__name__)
+
+type HandleWait = Callable[[int], asyncio.Future[bool]]
+
+
+def _completion_port_wait(loop: asyncio.AbstractEventLoop) -> HandleWait | None:
+    """The loop's registered-handle wait, when the loop runs on an I/O completion port.
+
+    ``ProactorEventLoop`` exposes it as ``IocpProactor.wait_for_handle``: the kernel's
+    wait threads post to the port when the handle is signalled and the loop completes
+    the returned future itself, with no thread of ours blocked.
+    """
+    proactor = getattr(loop, "_proactor", None)
+    wait_for_handle = getattr(proactor, "wait_for_handle", None)
+    return wait_for_handle if callable(wait_for_handle) else None
+
+
+async def _await_timer(timer: int, wait_for_handle: HandleWait, *, kernel32: Any) -> bool:
+    """Await the timer through the completion port; return whether that wait completed.
+
+    A cancelled caller re-arms the timer to fire at once: the registered wait then
+    completes through the port and unregisters itself, and only after that does the
+    caller close the handle. A failed re-arm, or a port that never delivers the
+    re-armed timer, falls back to unregistering the pending wait, which the proactor
+    does synchronously in ``cancel()``.
+    """
+    try:
+        waiter = wait_for_handle(timer)
+    except OSError:
+        return False
+    try:
+        await asyncio.shield(waiter)
+    except asyncio.CancelledError:
+        if not waiter.done():
+            if kernel32.SetWaitableTimer(timer, ctypes.byref(_FIRE_AT_ONCE), 0, None, None, 0):
+                await _settle_registered_wait(waiter)
+            else:
+                waiter.cancel()
+        raise
+    except OSError:
+        return False
+    return True
+
+
+async def _settle_registered_wait(waiter: asyncio.Future[bool]) -> None:
+    """Let the re-armed timer complete its registered wait, unregistering it past the bound."""
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + _REARM_SETTLE_SECONDS
+    while not waiter.done():
+        remaining = deadline - loop.time()
+        if remaining <= 0:
+            waiter.cancel()
+            return
+        # Further cancellation of the caller changes nothing: the handle stays open
+        # until the wait is off the port, so keep waiting out the same bound.
+        with contextlib.suppress(asyncio.CancelledError):
+            await asyncio.wait({waiter}, timeout=remaining)
+
+
+async def _sleep(secs: float, *, kernel32: Any) -> None:
+    """Sleep on a native high-resolution timer whose handle is owned by this coroutine."""
+    # Keep the timing compensation of pinned Textual 8.2.7.
+    sleep_for = max(0, secs - 0.001)
+    if sleep_for < 0.0005:
+        return
+    wait_for_handle = _completion_port_wait(asyncio.get_running_loop())
+    if wait_for_handle is None:
+        await asyncio.sleep(sleep_for)
+        return
+
+    # Manual reset: a completed wait leaves the timer signalled, which the port's
+    # post-wait poll expects of a handle (a synchronization timer reads as never fired).
+    timer = kernel32.CreateWaitableTimerExW(
+        None,
+        None,
+        _CREATE_WAITABLE_TIMER_MANUAL_RESET | _CREATE_WAITABLE_TIMER_HIGH_RESOLUTION,
+        _TIMER_ALL_ACCESS,
+    )
+    if not timer:
+        await asyncio.sleep(sleep_for)
+        return
+    fired = False
+    try:
+        due = LARGE_INTEGER(int(sleep_for * -10_000_000))
+        if kernel32.SetWaitableTimer(timer, ctypes.byref(due), 0, None, None, 0):
+            fired = await _await_timer(timer, wait_for_handle, kernel32=kernel32)
+    finally:
+        # The registered wait has completed or been unregistered, so nothing waits on the
+        # handle any more. Allocation happens after coroutine entry, so cancellation before
+        # the task starts leaks nothing.
+        kernel32.CloseHandle(timer)
+    if not fired:
+        await asyncio.sleep(sleep_for)
+
+
+def apply_runtime_patch() -> None:
+    """Patch the Windows timer before any Textual timers start."""
+    if not get_platform().is_windows:
+        return
+    try:
+        import textual
+        import textual._time as time_mod
+        import textual._win_sleep as win_sleep_mod
+    except ImportError:
+        return
+    if textual.__version__ != _RUNTIME_PATCH_TEXTUAL_VERSION:
+        logger.warning("Skipping Windows timer patch for unsupported Textual %s", textual.__version__)
+        return
+    if not hasattr(win_sleep_mod, "kernel32"):
+        # Textual itself falls back to asyncio.sleep when Win32 is unavailable.
+        return
+    if getattr(win_sleep_mod.sleep, _RUNTIME_PATCH_MARKER, False):
+        time_mod.win_sleep = win_sleep_mod.sleep
+        return
+    kernel32 = win_sleep_mod.kernel32
+
+    async def sleep(secs: float) -> None:
+        await _sleep(secs, kernel32=kernel32)
+
+    setattr(sleep, _RUNTIME_PATCH_MARKER, True)
+    win_sleep_mod.sleep = sleep
+    time_mod.win_sleep = sleep

chrys/foundation/patches/watchdog_fsevents.py

@@ -0,0 +1,70 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Let a stopped macOS watchdog emitter be collected.
+
+watchdog 6.0.0's FSEvents extension takes a reference to the callback given to
+``add_watch`` and never drops it: the stream context it creates has no release
+callback. The callback is the emitter's bound ``events_callback``, so every
+emitter ever started stays alive, and so does everything its thread object
+holds: ``Thread.__init__`` keeps the ``sys.stderr`` of that moment, which under
+a running Textual App is the App's print capture, and through it the App.
+Hand the extension a forwarder that reaches the emitter through a weak
+reference, so what it keeps is only that forwarder.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+import weakref
+from collections.abc import Callable
+from typing import Any
+
+from chrys.foundation.platform import get_platform
+
+_RUNTIME_PATCH_WATCHDOG_VERSION = "6.0.0"
+_RUNTIME_PATCH_MARKER = "_chrys_passes_a_weak_events_callback"
+logger = logging.getLogger(__name__)
+
+
+def apply_runtime_patch() -> None:
+    """Patch the pinned macOS emitter without importing FSEvents on other OSes."""
+    if not get_platform().is_macos:
+        return
+    try:
+        from watchdog.version import VERSION_STRING
+    except ImportError:
+        return
+    if VERSION_STRING != _RUNTIME_PATCH_WATCHDOG_VERSION:
+        logger.warning("Skipping FSEvents callback patch for unsupported watchdog %s", VERSION_STRING)
+        return
+
+    from watchdog.observers import fsevents
+
+    emitter_type = fsevents.FSEventsEmitter
+    if getattr(emitter_type.run, _RUNTIME_PATCH_MARKER, False):
+        return
+
+    # watchdog 6.0.0's run(), passing the forwarder in place of the bound method.
+    def run(self: Any) -> None:
+        self.pathnames = [self.watch.path]
+        self._start_time = time.monotonic()
+        try:
+            fsevents._fsevents.add_watch(self, self.watch, _weak_events_callback(self), self.pathnames)
+            fsevents._fsevents.read_events(self)
+        except Exception:
+            fsevents.logger.exception("Unhandled exception in FSEventsEmitter")
+
+    setattr(run, _RUNTIME_PATCH_MARKER, True)
+    emitter_type.run = run
+
+
+def _weak_events_callback(emitter: Any) -> Callable[[list[bytes], list[int], list[int], list[int]], None]:
+    events_callback = weakref.WeakMethod(emitter.events_callback)
+
+    def forward(paths: list[bytes], inodes: list[int], flags: list[int], ids: list[int]) -> None:
+        callback = events_callback()
+        if callback is not None:
+            callback(paths, inodes, flags, ids)
+
+    return forward

chrys/foundation/patches/watchdog_windows.py

@@ -0,0 +1,52 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Release each Windows watchdog directory handle only once.
+
+watchdog 6.0.0 leaves the closed handle on its emitter. Both the observer and
+the emitter itself can stop it, so a later stop may close an unrelated handle
+that Windows has allocated with the same integer value. See watchdog #1132.
+Detach ownership under a separate lock before calling the native close: the
+emitter's own lock is already held when a deleted directory stops itself.
+"""
+
+from __future__ import annotations
+
+import logging
+from threading import Lock
+from typing import Any
+
+from chrys.foundation.platform import get_platform
+
+_RUNTIME_PATCH_WATCHDOG_VERSION = "6.0.0"
+_RUNTIME_PATCH_MARKER = "_chrys_closes_directory_handle_once"
+logger = logging.getLogger(__name__)
+
+
+def apply_runtime_patch() -> None:
+    """Guard the pinned Windows emitter without importing Win32 on other OSes."""
+    if not get_platform().is_windows:
+        return
+    try:
+        from watchdog.version import VERSION_STRING
+    except ImportError:
+        return
+    if VERSION_STRING != _RUNTIME_PATCH_WATCHDOG_VERSION:
+        logger.warning("Skipping Windows directory handle patch for unsupported watchdog %s", VERSION_STRING)
+        return
+
+    from watchdog.observers import read_directory_changes
+
+    emitter_type = read_directory_changes.WindowsApiEmitter
+    if getattr(emitter_type.on_thread_stop, _RUNTIME_PATCH_MARKER, False):
+        return
+    ownership_lock = Lock()
+
+    def on_thread_stop(self: Any) -> None:
+        with ownership_lock:
+            handle = self._whandle
+            self._whandle = None
+        if handle:
+            read_directory_changes.close_directory_handle(handle)
+
+    setattr(on_thread_stop, _RUNTIME_PATCH_MARKER, True)
+    emitter_type.on_thread_stop = on_thread_stop