iCode-TUI 0.29.1__py3-none-any.whl

chrys/foundation/patches/textual_dispatch_cache.py

@@ -0,0 +1,150 @@
+# 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: cache ``MessagePump._get_dispatch_methods`` MRO walks.
+
+Problem
+-------
+Textual's ``MessagePump._get_dispatch_methods`` walks ``self.__class__.__mro__``
+on every dispatched message, performs ``cls.__dict__.get`` lookups for both
+``_decorated_handlers`` and convention-named handlers, and rebuilds a
+``methods_dispatched`` set each call.  During a chat-panel scroll on a widget
+tree with many subscribers, ~190 ``events.Callback`` messages are dispatched
+per frame, and ``_get_dispatch_methods`` accounts for ~2-3 ms/frame of pure
+re-walking of static class data.
+
+Solution
+--------
+Per ``(self_class, handler_name, message_class)`` triple, pre-compute the
+ordered sequence of ``(cls, unbound_method)`` groups that the original walk
+would yield, plus a flag noting whether any decorated handler with selectors
+is involved.
+
+On dispatch:
+
+* If the plan has no selector handlers, take a fast path that iterates the
+  cached groups and yields ``(cls, bound_method)`` pairs directly — no MRO
+  walk, no ``__dict__.get`` lookups, no dedup-set rebuild.  ``_no_default_action``
+  is still honored at class boundaries to match original semantics.
+* If the plan has any selector handlers (decorated with CSS-style selectors),
+  fall through to the original implementation.  Selector matching depends on
+  runtime widget tree state and isn't safely cacheable.
+
+The plan dict is keyed by ``(class, str, class)`` — class objects are immutable
+as far as ``_decorated_handlers`` is concerned (populated at class definition
+by the ``_MessagePumpMeta`` metaclass) and live for the process lifetime,
+so a plain dict is a safe long-lived cache.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+_RUNTIME_PATCH_MARKER = "_chrys_dispatch_cache_patched"
+
+
+@dataclass(frozen=True, slots=True)
+class _DispatchPlan:
+    """Pre-computed dispatch plan for one ``(self_cls, handler_name, message_cls)`` triple.
+
+    ``steps`` is the ordered list of MRO classes that contribute handlers,
+    each paired with its tuple of unbound methods to yield in order.  Empty
+    classes are omitted so the fast path doesn't pay for them.
+
+    ``has_selectors`` is True iff any decorated handler in the plan declared
+    a non-empty selectors dict.  Selector matching depends on the live widget
+    tree, so when this flag is set the patched ``_get_dispatch_methods`` falls
+    through to the original implementation instead of using the plan.
+    """
+
+    steps: tuple[tuple[type, tuple[Callable[..., Any], ...]], ...]
+    has_selectors: bool
+
+
+def _build_dispatch_plan(self_cls: type, method_name: str, message_cls: type) -> _DispatchPlan:
+    """Replicate the static portion of the original MRO walk and capture the result.
+
+    Mirrors ``MessagePump._get_dispatch_methods`` from Textual 8.2.7 — see
+    ``message_pump.py`` for the reference behavior.
+    """
+    from textual.message import Message
+
+    message_mro = [t for t in message_cls.__mro__ if issubclass(t, Message)]
+
+    methods_dispatched: set[Callable[..., Any]] = set()
+    has_selectors = False
+    steps: list[tuple[type, tuple[Callable[..., Any], ...]]] = []
+
+    for cls in self_cls.__mro__:
+        step_methods: list[Callable[..., Any]] = []
+
+        decorated_handlers = cls.__dict__.get("_decorated_handlers")
+        if decorated_handlers:
+            for msg_class in message_mro:
+                for method, selectors in decorated_handlers.get(msg_class, []):
+                    if method in methods_dispatched:
+                        continue
+                    if selectors:
+                        # Selector handlers depend on live ``message._sender`` /
+                        # widget tree state and can't be safely pre-resolved.
+                        has_selectors = True
+                    else:
+                        step_methods.append(method)
+                        methods_dispatched.add(method)
+
+        method = cls.__dict__.get(f"_{method_name}") or cls.__dict__.get(method_name)
+        if method is not None and not getattr(method, "_textual_on", None):
+            step_methods.append(method)
+
+        if step_methods:
+            steps.append((cls, tuple(step_methods)))
+
+    return _DispatchPlan(steps=tuple(steps), has_selectors=has_selectors)
+
+
+def apply_runtime_patch() -> None:
+    """Install the cached ``_get_dispatch_methods`` on ``MessagePump`` in this process."""
+    try:
+        from textual.message_pump import MessagePump
+    except ImportError:
+        return
+
+    existing = MessagePump._get_dispatch_methods
+    if getattr(existing, _RUNTIME_PATCH_MARKER, False):
+        return
+
+    original_get_dispatch_methods = existing
+    plan_cache: dict[tuple[type, str, type], _DispatchPlan] = {}
+
+    def _get_dispatch_methods(self: Any, method_name: str, message: Any) -> Any:
+        self_cls = type(self)
+        message_cls = type(message)
+        key = (self_cls, method_name, message_cls)
+
+        plan = plan_cache.get(key)
+        if plan is None:
+            plan = _build_dispatch_plan(self_cls, method_name, message_cls)
+            plan_cache[key] = plan
+
+        if plan.has_selectors:
+            yield from original_get_dispatch_methods(self, method_name, message)
+            return
+
+        for step_cls, unbound_methods in plan.steps:
+            if message._no_default_action:
+                return
+            for unbound in unbound_methods:
+                yield step_cls, unbound.__get__(self, step_cls)
+
+    setattr(_get_dispatch_methods, _RUNTIME_PATCH_MARKER, True)
+    # Expose the cache and builder for tests / introspection without leaking
+    # them into module-level state.  These attributes are part of the patch's
+    # observable surface — tests can clear ``_plan_cache`` between runs to
+    # exercise both cold and warm paths.
+    _get_dispatch_methods._plan_cache = plan_cache
+    _get_dispatch_methods._build_plan = _build_dispatch_plan
+    _get_dispatch_methods._original = original_get_dispatch_methods
+    MessagePump._get_dispatch_methods = _get_dispatch_methods

chrys/foundation/patches/textual_ime_cursor_anchor.py

@@ -0,0 +1,92 @@
+# 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: keep Textual's terminal cursor anchored to focused text inputs.
+
+Problem
+-------
+Textual uses ``App.cursor_position`` to place the hidden terminal cursor, which
+terminals use as the anchor for OS IME candidate windows. Textual's ``Input``
+and ``TextArea`` update that value when focus, selection, or scroll changes, but
+not when layout moves the focused widget without a cursor event. The visible
+Textual cursor can then be correct while the terminal cursor remains at an old
+screen coordinate, making IME candidate windows appear away from the typed text
+or jump during repeated layout changes.
+
+Solution
+--------
+Before each terminal update, refresh ``App.cursor_position`` from the focused
+widget's ``cursor_screen_offset`` when that focused widget exposes one. This
+runs after layout has resolved and covers both Textual ``Input`` and
+``TextArea`` without changing their editing behavior.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_OLD_BEGIN_UPDATE = """\
+    def _begin_update(self) -> None:
+        if self._sync_available and self._driver is not None:
+            self._driver.write(SYNC_START)"""
+
+_NEW_BEGIN_UPDATE = """\
+    def _sync_focused_widget_cursor_position(self) -> None:
+        \"\"\"Keep OS IME candidate windows anchored to the focused text cursor.\"\"\"
+        focused = self.focused
+        cursor_screen_offset = getattr(focused, "cursor_screen_offset", None) if focused is not None else None
+        if isinstance(cursor_screen_offset, Offset):
+            self.cursor_position = cursor_screen_offset
+
+    def _begin_update(self) -> None:
+        self._sync_focused_widget_cursor_position()
+        if self._sync_available and self._driver is not None:
+            self._driver.write(SYNC_START)"""
+
+_RUNTIME_PATCH_MARKER = "_chrys_ime_cursor_anchor"
+
+
+def _sync_focused_widget_cursor_position(app: Any) -> None:
+    from textual.geometry import Offset
+
+    focused = app.focused
+    cursor_screen_offset = getattr(focused, "cursor_screen_offset", None) if focused is not None else None
+    if isinstance(cursor_screen_offset, Offset):
+        app.cursor_position = cursor_screen_offset
+
+
+def apply_runtime_patch() -> None:
+    """Patch ``App._begin_update`` in the current process."""
+    try:
+        from textual.app import App
+    except ImportError:
+        return
+
+    if getattr(App._begin_update, _RUNTIME_PATCH_MARKER, False):
+        return
+    if getattr(App, "_sync_focused_widget_cursor_position", None) is not None:
+        return
+
+    original_begin_update = App._begin_update
+
+    def _begin_update(self: Any) -> None:
+        _sync_focused_widget_cursor_position(self)
+        original_begin_update(self)
+
+    setattr(_begin_update, _RUNTIME_PATCH_MARKER, True)
+    App._sync_focused_widget_cursor_position = _sync_focused_widget_cursor_position
+    App._begin_update = _begin_update
+
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="app.py",
+        old_fragment=_OLD_BEGIN_UPDATE,
+        new_fragment=_NEW_BEGIN_UPDATE,
+        description="Keep IME cursor anchor synced after focused text input layout shifts",
+    )
+)

chrys/foundation/patches/textual_kitty_keyboard.py

@@ -0,0 +1,268 @@
+# 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: keep Textual's Kitty keyboard input compatible with IMEs.
+
+Problem
+-------
+Some terminals send IME commits through the Kitty keyboard protocol as an
+associated-text field with colon-separated Unicode codepoints, for example
+``ESC [ 32 ; ; 24403:21069 u`` for ``当前``. Textual 8.2.7 only accepts a
+single numeric associated-text codepoint, so it treats the sequence as unknown
+and reissues the printable tail into focused inputs. Longer commits also exceed
+Textual's 32-character unknown-sequence search cap before the parser sees the
+final ``u``.
+
+Solution
+--------
+Accept colons in Kitty keyboard parameters and decode the associated-text field
+as one or more Unicode codepoints. The resulting ``Key.character`` is the
+committed text, so widgets receive the same text they would have received from a
+plain UTF-8 terminal input path. Raise the search cap enough for normal IME
+commit chunks to reach the final sequence byte.
+
+Some Chrys TUI modules import Textual before ``bootstrap_runtime()`` applies
+site-package patches, so this module also exposes an in-process monkey patch
+for the already-imported ``XTermParser`` class.
+
+iTerm 3.6.x has a separate upstream composition bug when Textual requests both
+``REPORT_ALL_KEYS`` and ``REPORT_ASSOCIATED_TEXT``. In that terminal/version
+combination an IME commit can be lost while its candidate-confirmation space is
+still reported. The runtime patch therefore leaves Kitty disambiguation enabled
+but removes those two progressive-enhancement flags for affected iTerm builds.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from collections.abc import Mapping
+from functools import lru_cache
+from typing import Any
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_OLD_SEARCH_THRESHOLD = "_MAX_SEQUENCE_SEARCH_THRESHOLD = 32"
+_NEW_SEARCH_THRESHOLD = "_MAX_SEQUENCE_SEARCH_THRESHOLD = 2048"
+
+_OLD_REGEX = """\
+_re_extended_key: Final[re.Pattern[str]] = re.compile(
+    r"\\x1b\\[((?:\\d*;?){2,3})([u~ABCDEFHPQRS])"
+)"""
+
+_NEW_REGEX = """\
+_re_extended_key: Final[re.Pattern[str]] = re.compile(
+    r"\\x1b\\[((?:\\d+(?::\\d+)*)?(?:;(?:\\d+(?::\\d+)*)?){0,2})([u~ABCDEFHPQRS])"
+)"""
+
+_OLD_PARSE = """\
+        codepoint = int(codepoint_str or "1")
+        modifiers = int(modifiers_str or "0")
+        text = chr(int(text_str)) if text_str else None"""
+
+_NEW_PARSE = """\
+        try:
+            codepoint = int(codepoint_str.partition(":")[0] or "1")
+            modifiers = int(modifiers_str.partition(":")[0] or "0")
+            text = "".join(chr(int(part)) for part in text_str.split(":")) if text_str else None
+        except ValueError:
+            return None"""
+
+_NEW_PARSE_WITH_RELEASE_GUARD = """\
+        try:
+            codepoint = int(codepoint_str.partition(":")[0] or "1")
+            modifiers = int(modifiers_str.partition(":")[0] or "0")
+            text = "".join(chr(int(part)) for part in text_str.split(":")) if text_str else None
+        except ValueError:
+            return None
+
+        event_type = modifiers_str.partition(":")[2].partition(":")[0]
+        if event_type == "3":
+            return events.Key(Keys.Ignore, sequence)"""
+
+_OLD_KEY = """\
+        if not (key := FUNCTIONAL_KEYS.get(f"{codepoint}{end}", "")):
+            key = _character_to_key(text if text else chr(codepoint))"""
+
+_EQUIVALENT_KEY = """\
+        if not (key := FUNCTIONAL_KEYS.get(f"{codepoint}{end}", "")):
+            if text and len(text) == 1:
+                key = _character_to_key(text)
+            elif text:
+                key = text
+            else:
+                key = _character_to_key(chr(codepoint))"""
+
+_NEW_KEY = """\
+        if not (key := FUNCTIONAL_KEYS.get(f"{codepoint}{end}", "")):
+            if text and len(text) == 1:
+                key = _character_to_key(text)
+            elif text:
+                # Multi-codepoint IME commit: use text as the key name; character drives input.
+                key = text
+            else:
+                key = _character_to_key(chr(codepoint))"""
+
+_RUNTIME_PATCH_MARKER = "_chrys_kitty_multi_codepoint_text"
+_RUNTIME_PATCH_TEXTUAL_VERSION = "8.2.7"
+_RUNTIME_EXTENDED_KEY_RE = re.compile(r"\x1b\[((?:\d+(?::\d+)*)?(?:;(?:\d+(?::\d+)*)?){0,2})([u~ABCDEFHPQRS])")
+_AFFECTED_ITERM_VERSION_RE = re.compile(r"^3\.6(?:\D|$)")
+logger = logging.getLogger(__name__)
+
+
+def _is_affected_iterm(env: Mapping[str, str]) -> bool:
+    """Return whether the terminal has iTerm's Kitty composition bug.
+
+    Remote and multiplexer sessions may omit or replace ``TERM_PROGRAM``. We
+    intentionally avoid guessing from ``TERM`` or process ancestry: failing to
+    detect iTerm only preserves Textual's normal flags, while a false positive
+    would unnecessarily degrade keyboard reporting in another terminal.
+    """
+    return env.get("TERM_PROGRAM") == "iTerm.app" and bool(
+        _AFFECTED_ITERM_VERSION_RE.match(env.get("TERM_PROGRAM_VERSION", ""))
+    )
+
+
+def _apply_iterm_kitty_flag_workaround(env: Mapping[str, str]) -> None:
+    """Keep only Kitty key disambiguation on affected iTerm versions."""
+    if not _is_affected_iterm(env):
+        return
+    try:
+        import textual.drivers.linux_driver as linux_driver
+    except ImportError:
+        return
+
+    linux_driver.KITTY_REPORT_ALL_KEYS = 0
+    linux_driver.KITTY_REPORT_ASSOCIATED_TEXT = 0
+
+
+def _decode_codepoint_text(text: str) -> str | None:
+    if not text:
+        return None
+    try:
+        return "".join(chr(int(part)) for part in text.split(":"))
+    except ValueError:
+        return None
+
+
+def apply_runtime_patch() -> None:
+    """Patch ``XTermParser._parse_extended_key`` in the current process."""
+    _apply_iterm_kitty_flag_workaround(os.environ)
+    try:
+        import textual
+        import textual._xterm_parser as xterm_parser
+        from textual import events
+        from textual._keyboard_protocol import FUNCTIONAL_KEYS, MODIFIER_FUNCTIONAL_KEYS
+        from textual.keys import _character_to_key
+    except ImportError:
+        return
+
+    if getattr(textual, "__version__", None) != _RUNTIME_PATCH_TEXTUAL_VERSION:
+        logger.warning(
+            "Skipping Textual Kitty keyboard runtime patch: loaded Textual is not the pinned %s that the patch targets.",
+            _RUNTIME_PATCH_TEXTUAL_VERSION,
+        )
+        return
+
+    XTermParser = xterm_parser.XTermParser
+    if getattr(XTermParser._parse_extended_key, _RUNTIME_PATCH_MARKER, False):
+        return
+
+    @lru_cache(maxsize=1024)
+    def _parse_extended_key(self: Any, sequence: str) -> Any:
+        """Parse a Kitty sequence."""
+        if (match := _RUNTIME_EXTENDED_KEY_RE.fullmatch(sequence)) is None:
+            return None
+
+        codes, end = match.groups(default="")
+        codepoint_str, modifiers_str, text_str, *_ = [*codes.split(";"), "", "", ""]
+        text = _decode_codepoint_text(text_str)
+        if text_str and text is None:
+            return None
+        try:
+            codepoint = int(codepoint_str.partition(":")[0] or "1")
+            modifiers = int(modifiers_str.partition(":")[0] or "0")
+        except ValueError:
+            return None
+
+        event_type = modifiers_str.partition(":")[2].partition(":")[0]
+        if event_type == "3":
+            from textual.keys import Keys
+
+            return events.Key(Keys.Ignore, sequence)
+
+        if not (key := FUNCTIONAL_KEYS.get(f"{codepoint}{end}", "")):
+            if text and len(text) == 1:
+                key = _character_to_key(text)
+            elif text:
+                # Multi-codepoint IME commit: use text as the key name; character drives input.
+                key = text
+            else:
+                key = _character_to_key(chr(codepoint))
+
+        key_tokens: list[str] = []
+        if modifiers and key not in MODIFIER_FUNCTIONAL_KEYS and text_str is not None:
+            modifier_bits = int(modifiers) - 1
+            modifiers_names = ("alt", "ctrl", "super", "hyper", "meta")
+            if modifier_bits & 1 and (text is None or text.isspace()):
+                key_tokens.append("shift")
+            for bit, modifier in enumerate(modifiers_names, 1):
+                if modifier == "alt" and text is not None:
+                    continue
+                if modifier_bits & (1 << bit):
+                    key_tokens.append(modifier)
+
+        key_tokens.sort()
+        if key is not None:
+            key_tokens.append(key)
+        return events.Key(
+            "+".join(key_tokens),
+            text or (None if modifiers else xterm_parser.SPECIAL_KEY_TO_CHARACTER.get(key, None)),
+        )
+
+    setattr(_parse_extended_key, _RUNTIME_PATCH_MARKER, True)
+    xterm_parser._MAX_SEQUENCE_SEARCH_THRESHOLD = 2048
+    xterm_parser._re_extended_key = _RUNTIME_EXTENDED_KEY_RE
+    XTermParser._parse_extended_key = _parse_extended_key
+
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="_xterm_parser.py",
+        old_fragment=_OLD_SEARCH_THRESHOLD,
+        new_fragment=_NEW_SEARCH_THRESHOLD,
+        description="Allow longer Kitty keyboard associated-text sequences",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="_xterm_parser.py",
+        old_fragment=_OLD_REGEX,
+        new_fragment=_NEW_REGEX,
+        description="Accept colon-separated Kitty keyboard text parameters",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="_xterm_parser.py",
+        old_fragment=_OLD_PARSE,
+        new_fragment=_NEW_PARSE,
+        description="Decode multi-codepoint Kitty keyboard associated text",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="_xterm_parser.py",
+        old_fragment=_NEW_PARSE,
+        new_fragment=_NEW_PARSE_WITH_RELEASE_GUARD,
+        description="Ignore Kitty keyboard release events after associated text decode",
+    ),
+    FilePatch(
+        package="textual",
+        module_file="_xterm_parser.py",
+        old_fragment=_OLD_KEY,
+        new_fragment=_NEW_KEY,
+        description="Guard multi-character Kitty keyboard text key conversion",
+        equivalent_fragments=(_EQUIVALENT_KEY,),
+    ),
+)