iCode-TUI 0.29.1__py3-none-any.whl

chrys/foundation/patches/staged_members.py

@@ -0,0 +1,205 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Install file-patched class members on classes that are already imported.
+
+A ``FilePatch`` rewrites the installed module for the next process, but classes imported before
+``apply_all()`` keep the members they were built with. Instead of duplicating each patched body,
+a runtime patch stages the same fragments on the installed source in memory, compiles only the
+members it names and sets them on the live classes, so imported aliases, subclasses and existing
+instances all see them, and the file and runtime paths share one source of truth.
+
+Members are compiled inside a same-named stand-in class, so decorators (``property`` and its
+setter) and class-level assignments stage as they do in the real class body. Their globals are
+the live module's, and a zero-argument ``super()`` is rebound to the live class. A class the
+patch adds to a module is compiled whole and set on the module.
+"""
+
+from __future__ import annotations
+import __future__
+
+import ast
+import logging
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from types import FunctionType, ModuleType
+
+from chrys.foundation.patches.patcher import FilePatch
+
+logger = logging.getLogger(__name__)
+
+
+class StagedSourceDriftError(Exception):
+    """The installed source no longer matches a fragment or a member the patch stages."""
+
+
+@dataclass(frozen=True, slots=True)
+class StagedMembers:
+    """Compiled members ready to be set on their live classes."""
+
+    replacements: tuple[tuple[type | ModuleType, str, object], ...]
+
+    def install(self, marker: str) -> None:
+        """Set every member on its live class, marking each compiled function with ``marker``.
+
+        Members are set one by one, with nothing to roll back: drift is found while staging, so
+        a caller that stages every module before installing any installs nothing on drift.
+
+        A plain value (a class-level default or counter, or a class added to a module) is only
+        added, never overwritten, so live state survives when the class or module already has it
+        (an already file-patched install). A patch therefore cannot change a plain value the
+        upstream class already defines: the file patch would write it, while the runtime install
+        keeps the upstream value. Such a patch adds a new name instead.
+        """
+        for target, name, value in self.replacements:
+            functions = _functions_of(value)
+            if not functions and name in vars(target):
+                continue
+            for function in functions:
+                setattr(function, marker, True)
+            setattr(target, name, value)
+
+
+def install_patched_members(
+    module: ModuleType,
+    patches: Sequence[FilePatch],
+    members: Mapping[str, Sequence[str]],
+    *,
+    marker: str,
+    label: str,
+) -> bool:
+    """Install ``members`` (class name → member names) of ``module`` from its patched source.
+
+    Every compiled function carries ``marker``, so repeated calls are no-ops. Returns whether the
+    members are installed. Drift is found while staging, before any member is set, so on drift
+    nothing is changed and a warning is logged.
+    """
+    if members_installed(module, members, marker):
+        return True
+    try:
+        staged = stage_members(module, patches, members, label=label)
+    except StagedSourceDriftError as exc:
+        logger.warning("Skipping Textual %s runtime patch: %s", label, exc)
+        return False
+    staged.install(marker)
+    return True
+
+
+def members_installed(module: ModuleType, members: Mapping[str, Sequence[str]], marker: str) -> bool:
+    """Whether every function-bearing member of ``members`` on ``module`` already carries ``marker``."""
+    functions: list[FunctionType] = []
+    for class_name, names in members.items():
+        live_class = vars(module).get(class_name)
+        if not isinstance(live_class, type):
+            return False
+        for name in names:
+            functions.extend(_functions_of(vars(live_class).get(name)))
+    return bool(functions) and all(vars(function).get(marker, False) for function in functions)
+
+
+def stage_members(
+    module: ModuleType,
+    patches: Sequence[FilePatch],
+    members: Mapping[str, Sequence[str]],
+    *,
+    label: str,
+    classes: Sequence[str] = (),
+) -> StagedMembers:
+    """Compile ``members`` of ``module`` from its installed source with ``patches`` applied.
+
+    ``classes`` names top-level classes the patches add to the module, compiled whole. Raises
+    ``StagedSourceDriftError`` when a fragment or member no longer matches; nothing is changed
+    until ``StagedMembers.install``, so a patch spanning modules can stage them all first.
+    """
+    source = stage_patched_source(module, patches)
+    return StagedMembers(tuple(_compile_members(module, source, members, label=label, classes=classes)))
+
+
+def stage_patched_source(module: ModuleType, patches: Sequence[FilePatch]) -> str:
+    """Return ``module``'s installed source with every fragment of ``patches`` applied."""
+    if module.__file__ is None:
+        raise StagedSourceDriftError(f"{module.__name__} has no source file")
+    source = Path(module.__file__).read_text(encoding="utf-8")
+    for patch in patches:
+        if patch.new_fragment in source or any(fragment in source for fragment in patch.equivalent_fragments):
+            continue
+        if patch.old_fragment not in source:
+            raise StagedSourceDriftError(f"fragment drifted: {patch.description}")
+        source = source.replace(patch.old_fragment, patch.new_fragment, 1)
+    return source
+
+
+def _member_name(node: ast.stmt) -> str | None:
+    if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+        return node.name
+    if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+        return node.targets[0].id
+    if isinstance(node, ast.AnnAssign) and node.value is not None and isinstance(node.target, ast.Name):
+        return node.target.id
+    return None
+
+
+def _compile_members(
+    module: ModuleType, source: str, members: Mapping[str, Sequence[str]], *, label: str, classes: Sequence[str]
+) -> list[tuple[type | ModuleType, str, object]]:
+    tree = ast.parse(source)
+    class_nodes = {node.name: node for node in tree.body if isinstance(node, ast.ClassDef)}
+    stand_ins: list[ast.stmt] = []
+    for class_name in classes:
+        class_node = class_nodes.get(class_name)
+        if class_node is None:
+            raise StagedSourceDriftError(f"class {class_name} is missing")
+        stand_ins.append(class_node)
+    for class_name, names in members.items():
+        class_node = class_nodes.get(class_name)
+        if class_node is None:
+            raise StagedSourceDriftError(f"class {class_name} is missing")
+        body = [node for node in class_node.body if _member_name(node) in names]
+        missing = set(names) - {_member_name(node) for node in body}
+        if missing:
+            raise StagedSourceDriftError(f"{class_name} is missing {sorted(missing)}")
+        stand_ins.append(ast.ClassDef(name=class_name, bases=[], keywords=[], body=body, decorator_list=[]))
+    code = compile(
+        ast.fix_missing_locations(ast.Module(body=stand_ins, type_ignores=[])),
+        f"<Chrys {label} patch: {module.__name__}>",
+        "exec",
+        flags=__future__.annotations.compiler_flag,
+        dont_inherit=True,
+    )
+    namespace: dict[str, object] = {}
+    # Globals stay bound to the live module; only the stand-in classes land in ``namespace``.
+    exec(code, vars(module), namespace)  # noqa: S102
+    replacements: list[tuple[type | ModuleType, str, object]] = [
+        (module, class_name, namespace[class_name]) for class_name in classes
+    ]
+    for class_name, names in members.items():
+        live_class = getattr(module, class_name)
+        stand_in = namespace[class_name]
+        if not isinstance(live_class, type) or not isinstance(stand_in, type):
+            raise StagedSourceDriftError(f"{class_name} is not a class")
+        for name in names:
+            value = vars(stand_in)[name]
+            for function in _functions_of(value):
+                _rebind_class_cell(function, live_class)
+            replacements.append((live_class, name, value))
+    return replacements
+
+
+def _functions_of(value: object) -> list[FunctionType]:
+    if isinstance(value, FunctionType):
+        return [value]
+    if isinstance(value, property):
+        return [function for function in (value.fget, value.fset, value.fdel) if isinstance(function, FunctionType)]
+    if isinstance(value, staticmethod | classmethod) and isinstance(value.__func__, FunctionType):
+        return [value.__func__]
+    if isinstance(value, cached_property) and isinstance(value.func, FunctionType):
+        return [value.func]
+    return []
+
+
+def _rebind_class_cell(function: FunctionType, live_class: type) -> None:
+    """Point a zero-argument ``super()`` (the ``__class__`` cell) at the live class."""
+    code = function.__code__
+    if "__class__" in code.co_freevars and function.__closure__ is not None:
+        function.__closure__[code.co_freevars.index("__class__")].cell_contents = live_class

chrys/foundation/patches/textual_block_border.py

@@ -0,0 +1,105 @@
+# 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 empty style for block border outer when parent bg is terminal default.
+
+Problem
+-------
+The ``block`` border type uses half-block characters (▄/▀) whose "other
+half" is rendered with the parent widget's background.  When the parent
+background is ``ansi_default``, Textual emits ``Style(bgcolor=default)``
+which Rich renders as ``\\x1b[49m`` (SGR default background).  Some
+terminals render this as opaque black instead of true transparent for
+half-block characters, creating visible black lines in block borders.
+
+Solution
+--------
+When ``base_background`` is ``ansi_default`` (ansi == -1) or fully
+transparent (a == 0), return an empty ``Style()`` for the outer style.
+An empty style has no bgcolor at all — Rich emits no background escape
+code, letting the terminal render its native background in those cells.
+
+Widget imports StylesCache before Chrys bootstrap. Replace the live cached
+method as well, so the first process does not retain the old method or results.
+
+The live method also fixes a retention: Textual caches ``get_inner_outer`` per
+instance, so its 1024-entry LRU keeps that many StylesCaches of removed widgets
+alive, each with its rendered lines. The result depends only on the colors, so
+the replacement caches on those alone.
+"""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from typing import Any
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_RUNTIME_PATCH_MARKER = "_chrys_transparent_block_border"
+_RUNTIME_PATCH_TEXTUAL_VERSION = "8.2.7"
+logger = logging.getLogger(__name__)
+
+
+def apply_runtime_patch() -> None:
+    """Update already-imported StylesCache classes and discard stale results."""
+    try:
+        import textual
+        from textual._styles_cache import StylesCache
+        from textual.style import Style
+    except ImportError:
+        return
+    if textual.__version__ != _RUNTIME_PATCH_TEXTUAL_VERSION:
+        logger.warning("Skipping block border patch for unsupported Textual %s", textual.__version__)
+        return
+    if getattr(StylesCache.get_inner_outer, _RUNTIME_PATCH_MARKER, False):
+        return
+
+    @lru_cache(1024)
+    def inner_outer(base_background: Any, background: Any) -> tuple[Any, Any]:
+        is_default = getattr(base_background, "ansi", None) == -1
+        outer = Style() if (is_default or base_background.a == 0) else Style(background=base_background)
+        return Style(background=base_background + background), outer
+
+    def get_inner_outer(self: Any, base_background: Any, background: Any) -> tuple[Any, Any]:
+        return inner_outer(base_background, background)
+
+    setattr(get_inner_outer, _RUNTIME_PATCH_MARKER, True)
+    StylesCache.get_inner_outer = get_inner_outer
+
+
+_OLD = """\
+    def get_inner_outer(
+        cls, base_background: Color, background: Color
+    ) -> tuple[Style, Style]:
+        \"\"\"Get inner and outer background colors.\"\"\"
+        return (
+            Style(background=base_background + background),
+            Style(background=base_background),
+        )"""
+
+_NEW = """\
+    def get_inner_outer(
+        cls, base_background: Color, background: Color
+    ) -> tuple[Style, Style]:
+        \"\"\"Get inner and outer background colors.\"\"\"
+        # --- Chrys patch: transparent parent → empty outer style ---
+        # When base_background is ansi_default or transparent, emit no
+        # bgcolor so the terminal renders its native background.
+        is_default = getattr(base_background, "ansi", None) == -1
+        outer = Style() if (is_default or base_background.a == 0) else Style(background=base_background)
+        return (
+            Style(background=base_background + background),
+            outer,
+        )"""
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="_styles_cache.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Use empty style for block border outer on transparent terminals",
+    ),
+)

chrys/foundation/patches/textual_button_ansi.py

@@ -0,0 +1,65 @@
+# 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: revert the textual 8.2.5 ansi-theme button DEFAULT_CSS block.
+
+Problem
+-------
+Textual 8.2.5 added a new ``Button:ansi.-style-flat, Button:ansi.-style-default``
+CSS block to ``Button.DEFAULT_CSS`` which retargets buttons under any
+``ansi=True`` theme (the new ``ansi-dark`` / ``ansi-light`` built-ins, as well
+as chrys' ``chrys-ansi``).  The new styling is visually inconsistent with the
+chrys ANSI palette.
+
+Solution
+--------
+Strip the new ansi-targeting block back out of ``Button.DEFAULT_CSS`` so
+buttons fall back to the original (pre-8.2.5) rules under ansi themes.
+
+Some Chrys TUI modules import ``textual.widgets.Button`` before
+``bootstrap_runtime()`` applies site-package patches, so this module also
+exposes an in-process monkey patch for the already-imported ``Button`` class.
+
+The exact 8.2.5 block (whitespace-significant) lives in
+``textual_button_ansi_old.txt`` next to this module, so trailing whitespace
+in the upstream CSS round-trips verbatim through the patcher's literal
+substring match.
+"""
+
+from pathlib import Path
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_OLD = (Path(__file__).parent / "textual_button_ansi_old.txt").read_text(encoding="utf-8")
+_NEW = 'DEFAULT_CSS = """\n    Button {'
+_RUNTIME_OLD = _OLD.removeprefix('DEFAULT_CSS = """')
+_RUNTIME_NEW = _NEW.removeprefix('DEFAULT_CSS = """')
+_RUNTIME_PATCH_MARKER = "_chrys_textual_button_ansi_css"
+
+
+def apply_runtime_patch() -> None:
+    """Patch ``Button.DEFAULT_CSS`` in the current process."""
+    try:
+        from textual.widgets import Button
+    except ImportError:
+        return
+
+    if getattr(Button, _RUNTIME_PATCH_MARKER, False):
+        return
+
+    if _RUNTIME_OLD in Button.DEFAULT_CSS:
+        Button.DEFAULT_CSS = Button.DEFAULT_CSS.replace(_RUNTIME_OLD, _RUNTIME_NEW, 1)
+
+    setattr(Button, _RUNTIME_PATCH_MARKER, True)
+
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="widgets/_button.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Revert 8.2.5 ansi-theme button styling block",
+    ),
+)

chrys/foundation/patches/textual_button_ansi_old.txt

@@ -0,0 +1,68 @@
+DEFAULT_CSS = """
+
+    Button:ansi.-style-flat, Button:ansi.-style-default {                
+        border: tall $border-blurred;
+        background: ansi_default;
+        
+
+        &:disabled {
+        
+            text-opacity: 1;
+            text-style: bold dim;
+            border: tall $border-blurred !important;
+            # color: initial;
+            background: ansi_default !important;
+            # text-style: dim;
+            pointer: not-allowed;
+            &:hover {
+                background: ansi_default;
+                
+            }
+        }
+
+        &:hover {
+            background: $ansi-background;
+            border: tall $border;               
+        }
+
+        &.-active {
+            background: $ansi-background !important;
+            border: blank $background !important;           
+            tint: transparent;
+        }
+                    
+        &.-primary {
+            color: $primary;
+            border: tall $primary;
+            background: ansi_default;
+            &:hover {
+                background: $ansi-background;
+            }                     
+        }
+        &.-success {              
+            color: $success;      
+            border: tall $success;
+            background: ansi_default;
+            &:hover {
+                background: $ansi-background;
+            }        
+        }
+        &.-warning {       
+            color: $warning;             
+            border: tall $warning;
+            background: ansi_default;
+            &:hover {
+                background: $ansi-background;
+            }
+        }
+        &.-error {         
+            color: $error;           
+            border: tall $error;
+            background: ansi_default;
+            &:hover {
+                background: $ansi-background;
+            }
+        }
+    }
+    
+    Button {

chrys/foundation/patches/textual_callback_cache.py

@@ -0,0 +1,248 @@
+# 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: avoid repeated ``inspect.signature`` calls for Textual callbacks.
+
+Textual wraps ``MessagePump.call_later`` / ``call_next`` callbacks in fresh
+``functools.partial`` objects.  Textual 8.2.7 tries to cache callback arity on
+the callable itself, but the partial branch calls ``_count_parameters`` on the
+wrapped function directly, bypassing the existing ``count_parameters`` cache.
+
+During chat-panel scrolling this repeatedly inspects signatures for the same
+callback functions.  Cache the underlying callable recursively and subtract the
+partial arguments from the cached value.
+"""
+
+from __future__ import annotations
+
+from contextlib import suppress
+from functools import partial
+from inspect import isawaitable
+from typing import Any
+
+from chrys.foundation.patches.patcher import FilePatch, register
+
+_RUNTIME_PATCH_MARKER = "_chrys_callback_cache_patched"
+
+# The runtime wrapper caches arity under its OWN attribute rather than Textual's
+# ``_param_count``.  When the wrapper is installed over the *unpatched* upstream
+# function (e.g. before the file patch lands, or in tests against vanilla
+# Textual), upstream may already have cached values with different semantics —
+# vanilla stores the post-subtraction *bound* count on the *unbound* function,
+# which the wrapper's bound-method branch would subtract from a second time.  A
+# private attribute keeps the two caches from ever reading each other.
+_PARAM_COUNT_ATTR = "_chrys_param_count"
+
+
+def apply_runtime_patch() -> None:
+    """Install the callback arity cache fix in the current process."""
+    try:
+        import textual._callback as callback_mod
+        import textual.reactive as reactive_mod
+    except ImportError:
+        return
+
+    existing_count_parameters = callback_mod.count_parameters
+    if not getattr(existing_count_parameters, _RUNTIME_PATCH_MARKER, False):
+        original_count_parameters = existing_count_parameters
+        raw_count_parameters = callback_mod._count_parameters
+
+        def count_parameters(func: Any) -> int:
+            """Count callback parameters while reusing cached underlying arity.
+
+            Caches under :data:`_PARAM_COUNT_ATTR` rather than Textual's
+            ``_param_count`` so this wrapper never trusts a value the unpatched
+            upstream cached with different semantics (see the constant's note).
+            """
+            cache_target = func
+            if isinstance(func, partial):
+                cached = getattr(func, _PARAM_COUNT_ATTR, None)
+                if cached is not None:
+                    return cached
+                keyword_count = len(func.keywords or {})
+                param_count = count_parameters(func.func) - (len(func.args) + keyword_count)
+            elif hasattr(func, "__self__") and hasattr(func, "__func__"):
+                cache_target = func.__func__
+                return count_parameters(cache_target) - 1
+            else:
+                cached = getattr(func, _PARAM_COUNT_ATTR, None)
+                if cached is not None:
+                    return cached
+                param_count = raw_count_parameters(func)
+
+            with suppress(AttributeError, TypeError):
+                setattr(cache_target, _PARAM_COUNT_ATTR, param_count)
+            return param_count
+
+        setattr(count_parameters, _RUNTIME_PATCH_MARKER, True)
+        count_parameters._original = original_count_parameters
+        callback_mod.count_parameters = count_parameters
+
+    # Reactive imported this function by value before bootstrap. Repair that
+    # consumer even on reapplication, when the defining module is already fixed.
+    reactive_mod.count_parameters = callback_mod.count_parameters
+
+    existing_invoke = callback_mod._invoke
+    if not getattr(existing_invoke, _RUNTIME_PATCH_MARKER, False):
+        original_invoke = existing_invoke
+
+        async def _invoke(callback: Any, *params: Any) -> Any:
+            """Invoke callbacks without arity introspection when no params are supplied."""
+            _rich_traceback_guard = True
+            if params:
+                parameter_count = callback_mod.count_parameters(callback)
+                result = callback(*params[:parameter_count])
+            else:
+                result = callback()
+            if isawaitable(result):
+                result = await result
+            return result
+
+        setattr(_invoke, _RUNTIME_PATCH_MARKER, True)
+        _invoke._original = original_invoke
+        callback_mod._invoke = _invoke
+
+
+_OLD = '''def count_parameters(func: Callable) -> int:
+    """Count the number of parameters in a callable"""
+    try:
+        return func._param_count
+    except AttributeError:
+        pass
+    if isinstance(func, partial):
+        param_count = _count_parameters(func.func) - (
+            len(func.args) + len(func.keywords)
+        )
+    elif hasattr(func, "__self__"):
+        # Bound method
+        func = func.__func__  # type: ignore
+        param_count = _count_parameters(func) - 1
+    else:
+        param_count = _count_parameters(func)
+    try:
+        func._param_count = param_count
+    except TypeError:
+        pass
+    return param_count
+'''
+
+_NEW = '''def count_parameters(func: Callable) -> int:
+    """Count the number of parameters in a callable"""
+    cache_target = func
+    if isinstance(func, partial):
+        try:
+            return func._param_count
+        except AttributeError:
+            pass
+        param_count = count_parameters(func.func) - (
+            len(func.args) + len(func.keywords or {})
+        )
+    elif hasattr(func, "__self__") and hasattr(func, "__func__"):
+        # Bound method
+        cache_target = func.__func__  # type: ignore
+        return count_parameters(cache_target) - 1
+    else:
+        try:
+            return func._param_count
+        except AttributeError:
+            pass
+        param_count = _count_parameters(func)
+    try:
+        cache_target._param_count = param_count
+    except (AttributeError, TypeError):
+        pass
+    return param_count
+'''
+
+_BUGGY_NEW = '''def count_parameters(func: Callable) -> int:
+    """Count the number of parameters in a callable"""
+    try:
+        return func._param_count
+    except AttributeError:
+        pass
+    cache_target = func
+    if isinstance(func, partial):
+        param_count = count_parameters(func.func) - (
+            len(func.args) + len(func.keywords or {})
+        )
+    elif hasattr(func, "__self__"):
+        # Bound method
+        cache_target = func.__func__  # type: ignore
+        param_count = count_parameters(cache_target) - 1
+    else:
+        param_count = _count_parameters(func)
+    try:
+        cache_target._param_count = param_count
+    except (AttributeError, TypeError):
+        pass
+    return param_count
+'''
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="_callback.py",
+        old_fragment=_OLD,
+        new_fragment=_NEW,
+        description="Cache Textual callback arity through partial and bound-method wrappers.",
+        equivalent_fragments=(_BUGGY_NEW,),
+    )
+)
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="_callback.py",
+        old_fragment=_BUGGY_NEW,
+        new_fragment=_NEW,
+        description="Upgrade Textual callback arity cache patch for bound methods.",
+    )
+)
+
+_OLD_INVOKE = '''async def _invoke(callback: Callable, *params: object) -> Any:
+    """Invoke a callback with an arbitrary number of parameters.
+
+    Args:
+        callback: The callable to be invoked.
+
+    Returns:
+        The return value of the invoked callable.
+    """
+    _rich_traceback_guard = True
+    parameter_count = count_parameters(callback)
+    result = callback(*params[:parameter_count])
+    if isawaitable(result):
+        result = await result
+    return result
+'''
+
+_NEW_INVOKE = '''async def _invoke(callback: Callable, *params: object) -> Any:
+    """Invoke a callback with an arbitrary number of parameters.
+
+    Args:
+        callback: The callable to be invoked.
+
+    Returns:
+        The return value of the invoked callable.
+    """
+    _rich_traceback_guard = True
+    if params:
+        parameter_count = count_parameters(callback)
+        result = callback(*params[:parameter_count])
+    else:
+        result = callback()
+    if isawaitable(result):
+        result = await result
+    return result
+'''
+
+register(
+    FilePatch(
+        package="textual",
+        module_file="_callback.py",
+        old_fragment=_OLD_INVOKE,
+        new_fragment=_NEW_INVOKE,
+        description="Skip Textual callback arity inspection when no params are supplied.",
+    )
+)