omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev495__py3-none-any.whl

omdev/tui/textual/debug/dominfo.py

@@ -0,0 +1,151 @@
+"""
+TODO:
+ - walk textual.styles.RulesMap lol
+"""
+import typing as ta
+
+from textual.dom import DOMNode
+from textual.widget import Widget
+
+from omlish import dataclasses as dc
+
+from ..types import trbl_to_dict
+
+
+##
+
+
+@dc.dataclass()
+class DomNodeInfo:
+    """Representation of a Textual DOM node for debugging."""
+
+    # Identity
+    oid: int
+    oidx: str
+    type: str
+    dom_id: str | None
+
+    # CSS / Styling
+    classes: list[str]
+    pseudo_classes: list[str]
+    # 'styles' contains the computed values relevant to layout (margin, padding, etc)
+    styles: dict[str, ta.Any]
+
+    # Geometry
+    # Region: The actual screen space allocated (x, y, w, h)
+    region: dict[str, int] | None
+    # Virtual Size: The size the widget 'wants' to be (scrollable area)
+    virtual_size: dict[str, int] | None
+    # Content Size: The size of the content inside the padding
+    content_size: dict[str, int] | None
+
+    # Hierarchy
+    children: list['DomNodeInfo'] = dc.field(default_factory=list)
+
+
+def inspect_dom_node(node: DOMNode) -> DomNodeInfo:
+    """
+    Recursively builds a tree of DomNodeInfo objects from a Textual DOM node.
+
+    Args:
+        node: The root node to inspect (usually app.screen or a specific widget).
+
+    Returns:
+        DomNodeInfo: The root of the inspected tree.
+    """
+
+    # 1. Identity
+
+    oid = id(node)
+    oidx = f'{id(node):x}'
+    node_type = f'{type(node).__module__}.{type(node).__qualname__}'
+    dom_id = node.id
+
+    # 2. Styles
+
+    # We extract specific computed styles relevant to positioning debugging. Textual 'styles' property usually returns
+    # the computed/effective style.
+    styles_info: dict[str, ta.Any] = {}
+
+    # Extract only if the node supports styles (Most DOMNodes are Widgets, but check just in case)
+    if isinstance(node, Widget):
+        s = node.styles
+
+        # Layout Rules
+        styles_info['display'] = str(s.display)
+        styles_info['position'] = str(s.position)  # relative, absolute
+        styles_info['dock'] = str(s.dock)
+        styles_info['layer'] = s.layer
+
+        # Sizing Rules (The 'constraints' set in CSS)
+        styles_info['width_rule'] = str(s.width)   # e.g. '100%', 'auto', '10'
+        styles_info['height_rule'] = str(s.height)
+        styles_info['min_width'] = str(s.min_width)
+        styles_info['max_width'] = str(s.max_width)
+        styles_info['box_sizing'] = str(s.box_sizing)  # border-box vs content-box
+
+        # Spacing (Critical for debugging gaps)
+        styles_info['margin'] = trbl_to_dict(s.margin)
+        styles_info['padding'] = trbl_to_dict(s.padding)
+        styles_info['border'] = trbl_to_dict(s.border)
+
+        # Alignment
+        styles_info['align'] = f'{s.align_horizontal} {s.align_vertical}'
+
+    # 3. Geometry
+
+    # Region is the absolute coordinates on the screen (or relative to parent layer). This is "What it was forced into".
+    region_info: dict[str, int] | None = None
+    if (region := getattr(node, 'region', None)) is not None:
+        region_info = {
+            'x': region.x,
+            'y': region.y,
+            'width': region.width,
+            'height': region.height,
+        }
+
+    # Virtual size is the scrollable area. This is often "What it wants to be" (if larger than region).
+    virtual_info: dict[str, int] | None = None
+    if (virtual_size := getattr(node, 'virtual_size', None)) is not None:
+        virtual_info = {
+            'width': virtual_size.width,
+            'height': virtual_size.height,
+        }
+
+    content_info: dict | None = None
+    if isinstance(node, Widget):
+        # Content region is inner size (region - padding - border)
+        content_info = {
+            'width': node.content_region.width,
+            'height': node.content_region.height,
+        }
+
+    # 4. Recursion & Sorting
+
+    # Sort by Y position first, then X position
+    sorted_children = sorted(
+        node.children,
+        key=lambda n: (n.region.y, n.region.x),
+    )
+
+    child_nodes = [
+        inspect_dom_node(child)
+        for child in sorted_children
+    ]
+
+    return DomNodeInfo(
+        oid=oid,
+        oidx=oidx,
+        type=node_type,
+        dom_id=dom_id,
+
+        classes=list(node.classes),
+        pseudo_classes=list(node.pseudo_classes),
+        styles=styles_info,
+
+        region=region_info,
+        virtual_size=virtual_info,
+        content_size=content_info,
+
+        children=child_nodes,
+    )

omdev/tui/textual/debug/screen.py

@@ -0,0 +1,24 @@
+from textual.geometry import Region
+from textual.screen import Screen
+from textual.widget import Widget
+
+
+##
+
+
+def get_screen_zbuffer(screen: Screen) -> list[list[list[tuple[Widget, Region]] | None]]:
+    width, height = screen.size
+
+    zbuffer: list[list[list[tuple[Widget, Region]] | None]] = [
+        [None for _ in range(width)]
+        for _ in range(height)
+    ]
+
+    for y in range(height):
+        for x in range(width):
+            try:
+                zbuffer[y][x] = list(screen.get_widgets_at(x, y))
+            except Exception:  # noqa
+                pass
+
+    return zbuffer

omdev/tui/textual/devtools.py

@@ -0,0 +1,187 @@
+# ruff: noqa: UP037 UP045
+import inspect
+import logging
+import typing as ta
+
+import textual.constants
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .logging2 import translate_log_level
+
+
+with lang.auto_proxy_import(globals()):
+    from textual_dev import client as tx_dev_client
+    from textual_dev import redirect_output as tx_dev_redirect_output
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DevtoolsConfig:
+    host: str = '127.0.0.1'
+
+    # https://github.com/Textualize/textual/blob/676045381b7178c3bc94b86901f20764e08aca49/src/textual/constants.py#L125
+    port: int = 8081
+
+    @classmethod
+    def from_env(cls) -> 'DevtoolsConfig':
+        return cls(
+            host=textual.constants.DEVTOOLS_HOST,
+            port=textual.constants.DEVTOOLS_PORT,
+        )
+
+
+async def connect_devtools(config: DevtoolsConfig) -> ta.Optional['tx_dev_client.DevtoolsClient']:
+    try:
+        from textual_dev.client import DevtoolsClient  # noqa
+    except ImportError:
+        # Dev dependencies not installed
+        return None
+
+    devtools = DevtoolsClient(
+        config.host,
+        config.port,
+    )
+
+    from textual_dev.client import DevtoolsConnectionError
+
+    try:
+        await devtools.connect()
+    except DevtoolsConnectionError as e:  # noqa
+        return None
+
+    return devtools
+
+
+##
+
+
+class DevtoolsAppMixin:
+    _skip_devtools_management: bool = False
+
+    def _install_devtools(self, devtools: 'tx_dev_client.DevtoolsClient') -> None:
+        check.none(getattr(self, 'devtools', None))
+        check.none(getattr(self, '_devtools_redirector', None))
+
+        # https://github.com/Textualize/textual/blob/676045381b7178c3bc94b86901f20764e08aca49/src/textual/app.py#L730-L741
+        setattr(self, 'devtools', devtools)
+        setattr(self, '_devtools_redirector', tx_dev_redirect_output.StdoutRedirector(devtools))
+
+        self._skip_devtools_management = True
+
+    async def _init_devtools(self) -> None:
+        if self._skip_devtools_management:
+            return
+
+        await super()._init_devtools()  # type: ignore  # noqa
+
+    async def _disconnect_devtools(self) -> None:
+        if self._skip_devtools_management:
+            return
+
+        await super()._disconnect_devtools()  # type: ignore  # noqa
+
+
+##
+
+
+class DevtoolsSetup(lang.Func1[DevtoolsAppMixin, None]):
+    pass
+
+
+class DevtoolsManager:
+    def __init__(
+            self,
+            config: DevtoolsConfig = DevtoolsConfig(),
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._devtools: ta.Optional['tx_dev_client.DevtoolsClient'] = None
+        self._setup: DevtoolsSetup | None = None
+
+    async def get_setup(self) -> DevtoolsSetup:
+        if self._setup is None:
+            check.none(self._devtools)
+
+            self._devtools = await connect_devtools(self._config)
+
+            self._setup = DevtoolsSetup(self._setup_app_dev_tools)
+
+        return self._setup
+
+    def _setup_app_dev_tools(self, app: DevtoolsAppMixin) -> None:
+        if (devtools := self._devtools) is None:
+            return
+
+        check.isinstance(app, DevtoolsAppMixin)._install_devtools(devtools)  # noqa
+
+    async def aclose(self) -> None:
+        if (devtools := self._devtools) is not None and devtools.is_connected:
+            await devtools.disconnect()
+
+
+##
+
+
+class DevtoolsLoggingHandler(logging.Handler):
+    """
+    TODO:
+     - reify caller from LogContextInfos
+     - queue worker, this blocks the asyncio thread lol
+    """
+
+    def __init__(
+            self,
+            devtools: ta.Optional['tx_dev_client.DevtoolsClient'],
+            prototype_handler: logging.Handler | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._devtools = devtools
+
+        if prototype_handler is not None:
+            self.setFormatter(prototype_handler.formatter)
+            for lf in prototype_handler.filters:
+                self.addFilter(lf)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if (devtools := self._devtools) is None or not devtools.is_connected:
+            return
+
+        msg = self.format(record)
+
+        caller = inspect.Traceback(
+            filename=record.filename,
+            lineno=record.lineno,
+            function=record.funcName,
+            code_context=None,
+            index=None,
+        )
+
+        group, verbosity = translate_log_level(record.levelno)
+
+        devtools.log(
+            tx_dev_client.DevtoolsLog(
+                msg,
+                caller=caller,
+            ),
+            group=group,
+            verbosity=verbosity,
+        )
+
+
+def set_root_logger_to_devtools(devtools: ta.Optional['tx_dev_client.DevtoolsClient']) -> None:
+    from omlish.logs.std.standard import _locking_logging_module_lock  # noqa
+    from omlish.logs.std.standard import StandardConfiguredLoggingHandler
+
+    with _locking_logging_module_lock():
+        std_handler = next((h for h in logging.root.handlers if isinstance(h, StandardConfiguredLoggingHandler)), None)
+
+        dt_handler = DevtoolsLoggingHandler(devtools, std_handler)
+
+        logging.root.handlers = [dt_handler]

omdev/tui/textual/drivers2.py

@@ -0,0 +1,55 @@
+import threading
+import typing as ta
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    from textual.driver import Driver
+
+
+##
+
+
+class PendingWritesDriverMixin:
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._pending_primary_buffer_writes: list[str] = []
+
+    def queue_primary_buffer_write(self, *s: str) -> None:
+        self._pending_primary_buffer_writes.extend(s)
+
+    def write(self, data: str) -> None:
+        if (pw := self._pending_primary_buffer_writes):
+            data = ''.join([*pw, data])
+            pw.clear()
+        super().write(data)  # type: ignore
+
+
+_PENDING_WRITES_DRIVER_CLASSES_LOCK = threading.RLock()
+_PENDING_WRITES_DRIVER_CLASSES: dict[type['Driver'], type['Driver']] = {}
+
+
+def get_pending_writes_driver_class(cls: type['Driver']) -> type['Driver']:
+    if issubclass(cls, PendingWritesDriverMixin):
+        return cls  # noqa
+
+    try:
+        return _PENDING_WRITES_DRIVER_CLASSES[cls]
+    except KeyError:
+        pass
+
+    with _PENDING_WRITES_DRIVER_CLASSES_LOCK:
+        try:
+            return _PENDING_WRITES_DRIVER_CLASSES[cls]
+        except KeyError:
+            pass
+
+        cls = _PENDING_WRITES_DRIVER_CLASSES[cls] = lang.new_type(  # noqa
+            f'PendingWrites{cls.__name__}',
+            (PendingWritesDriverMixin, cls),
+            {},
+        )
+
+    return cls  # noqa

omdev/tui/textual/logging2.py

@@ -0,0 +1,20 @@
+import logging
+
+from textual import LogGroup  # noqa
+from textual import LogVerbosity  # noqa
+
+
+##
+
+
+def translate_log_level(level: int) -> tuple[LogGroup, LogVerbosity]:
+    if level >= logging.ERROR:
+        return (LogGroup.ERROR, LogVerbosity.HIGH)
+    elif level >= logging.WARNING:
+        return (LogGroup.ERROR, LogVerbosity.HIGH)
+    elif level >= logging.INFO:
+        return (LogGroup.INFO, LogVerbosity.NORMAL)
+    elif level >= logging.DEBUG:
+        return (LogGroup.DEBUG, LogVerbosity.NORMAL)
+    else:
+        return (LogGroup.UNDEFINED, LogVerbosity.NORMAL)

omdev/tui/textual/types.py

@@ -0,0 +1,45 @@
+import typing as ta
+
+from textual.geometry import Spacing
+
+
+##
+
+
+class TopRightBottomLeft(ta.Protocol):
+    """
+    A ducktype for at least the following:
+     - textual.geometry.Spacing - margin, padding
+     - textual.css._style_properties.Edges - border
+    """
+
+    @property
+    def top(self) -> ta.Any: ...
+
+    @property
+    def right(self) -> ta.Any: ...
+
+    @property
+    def bottom(self) -> ta.Any: ...
+
+    @property
+    def left(self) -> ta.Any: ...
+
+
+@ta.overload
+def trbl_to_dict(trbl: Spacing) -> dict[str, int]:
+    ...
+
+
+@ta.overload
+def trbl_to_dict(trbl: TopRightBottomLeft) -> dict[str, ta.Any]:
+    ...
+
+
+def trbl_to_dict(trbl):
+    return {
+        'top': trbl.top,
+        'right': trbl.right,
+        'bottom': trbl.bottom,
+        'left': trbl.left,
+    }

{omdev-0.0.0.dev440.dist-info → omdev-0.0.0.dev495.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev440
+Version: 0.0.0.dev495
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,21 +14,24 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev440
+Requires-Dist: omlish==0.0.0.dev495
 Provides-Extra: all
-Requires-Dist: black~=25.1; extra == "all"
+Requires-Dist: black~=25.12; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"
 Requires-Dist: pcpp~=1.30; extra == "all"
 Requires-Dist: docutils~=0.22; extra == "all"
 Requires-Dist: markdown-it-py~=4.0; extra == "all"
 Requires-Dist: mdit-py-plugins~=0.5; extra == "all"
 Requires-Dist: pygments~=2.19; extra == "all"
-Requires-Dist: mypy~=1.18; extra == "all"
+Requires-Dist: mypy~=1.19; extra == "all"
 Requires-Dist: gprof2dot~=2025.4; extra == "all"
-Requires-Dist: prompt-toolkit~=3.0; extra == "all"
 Requires-Dist: segno~=1.6; extra == "all"
+Requires-Dist: rich~=14.2; extra == "all"
+Requires-Dist: textual~=6.11; extra == "all"
+Requires-Dist: textual-dev~=1.8; extra == "all"
+Requires-Dist: textual-speedups~=0.2; extra == "all"
 Provides-Extra: black
-Requires-Dist: black~=25.1; extra == "black"
+Requires-Dist: black~=25.12; extra == "black"
 Provides-Extra: c
 Requires-Dist: pycparser~=2.23; extra == "c"
 Requires-Dist: pcpp~=1.30; extra == "c"
@@ -38,13 +41,16 @@ Requires-Dist: markdown-it-py~=4.0; extra == "doc"
 Requires-Dist: mdit-py-plugins~=0.5; extra == "doc"
 Requires-Dist: pygments~=2.19; extra == "doc"
 Provides-Extra: mypy
-Requires-Dist: mypy~=1.18; extra == "mypy"
+Requires-Dist: mypy~=1.19; extra == "mypy"
 Provides-Extra: prof
 Requires-Dist: gprof2dot~=2025.4; extra == "prof"
-Provides-Extra: ptk
-Requires-Dist: prompt-toolkit~=3.0; extra == "ptk"
 Provides-Extra: qr
 Requires-Dist: segno~=1.6; extra == "qr"
+Provides-Extra: tui
+Requires-Dist: rich~=14.2; extra == "tui"
+Requires-Dist: textual~=6.11; extra == "tui"
+Requires-Dist: textual-dev~=1.8; extra == "tui"
+Requires-Dist: textual-speedups~=0.2; extra == "tui"
 Dynamic: license-file
 
 # Overview