textual-drivers 0.1.0__tar.gz

textual_drivers-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.3
+Name: textual-drivers
+Version: 0.1.0
+Summary: Drop-in Textual drivers with lock_stdin, register_event_handler, and kitty DnD support
+Author: NSPC911
+Author-email: NSPC911 <87571998+NSPC911@users.noreply.github.com>
+Requires-Dist: textual>=8.2.7
+Requires-Dist: wrapt>=2.2.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# textual-drivers
+
+Drop-in subclasses of Textual's built-in terminal drivers with two extra capabilities:
+
+- **`lock_stdin`** — pause the driver's stdin thread and silence terminal events so you can run terminal queries or subprocesses without interference
+- **`register_event_handler`** — bind a pattern against raw stdin; when it matches, a `Message` is posted into Textual's event system
+
+A higher-level **`DNDApp`** base class builds on these to implement the full kitty drag-and-drop protocol (drag-in and drag-out).
+
+## Installation
+
+```
+uv add textual-drivers
+```
+
+## Quick start
+
+```python
+from textual_drivers import DrivenApp
+
+class MyApp(DrivenApp):
+    ...
+
+MyApp().run()
+```
+
+`DrivenApp` picks the right platform driver automatically.
+
+## Documentation
+
+Full docs are on the [wiki](../../wiki):
+
+- [Drivers](../../wiki/drivers) — driver classes, `DrivenApp`, and mixin usage
+- [lock_stdin](../../wiki/lock-stdin) — exclusive stdin ownership for terminal queries and subprocesses
+- [register_event_handler](../../wiki/register-event-handler) — pattern-based raw stdin → Textual message routing
+- [DnD](../../wiki/dnd) — kitty drag-and-drop protocol via `DNDApp`
+
+The `docs/` folder in this repo mirrors the wiki and can be pushed to it with:
+
+```
+./sync-wiki.sh
+```

textual_drivers-0.1.0/README.md

@@ -0,0 +1,42 @@
+# textual-drivers
+
+Drop-in subclasses of Textual's built-in terminal drivers with two extra capabilities:
+
+- **`lock_stdin`** — pause the driver's stdin thread and silence terminal events so you can run terminal queries or subprocesses without interference
+- **`register_event_handler`** — bind a pattern against raw stdin; when it matches, a `Message` is posted into Textual's event system
+
+A higher-level **`DNDApp`** base class builds on these to implement the full kitty drag-and-drop protocol (drag-in and drag-out).
+
+## Installation
+
+```
+uv add textual-drivers
+```
+
+## Quick start
+
+```python
+from textual_drivers import DrivenApp
+
+class MyApp(DrivenApp):
+    ...
+
+MyApp().run()
+```
+
+`DrivenApp` picks the right platform driver automatically.
+
+## Documentation
+
+Full docs are on the [wiki](../../wiki):
+
+- [Drivers](../../wiki/drivers) — driver classes, `DrivenApp`, and mixin usage
+- [lock_stdin](../../wiki/lock-stdin) — exclusive stdin ownership for terminal queries and subprocesses
+- [register_event_handler](../../wiki/register-event-handler) — pattern-based raw stdin → Textual message routing
+- [DnD](../../wiki/dnd) — kitty drag-and-drop protocol via `DNDApp`
+
+The `docs/` folder in this repo mirrors the wiki and can be pushed to it with:
+
+```
+./sync-wiki.sh
+```

textual_drivers-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[project]
+name = "textual-drivers"
+version = "0.1.0"
+description = "Drop-in Textual drivers with lock_stdin, register_event_handler, and kitty DnD support"
+readme = "README.md"
+authors = [
+    { name = "NSPC911", email = "87571998+NSPC911@users.noreply.github.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "textual>=8.2.7",
+    "wrapt>=2.2.1",
+]
+
+[project.scripts]
+textual-drivers = "textual_drivers:main"
+
+[build-system]
+requires = ["uv_build>=0.11.16,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.15",
+    "textual-dev>=1.8.0",
+    "ty==0.0.32",
+]
+
+[tool.ruff]
+force-exclude = true
+exclude = []
+
+[tool.ruff.lint]
+select = [
+  "ASYNC220",
+  "ASYNC221",
+  "ASYNC251",
+  "ANN",
+  "COM819",
+  "C400",
+  "DOC",
+  "D404",
+  "E",
+  "F",
+  "I",
+  "N801", "N802", "N805",
+  "PLE1142",
+  "Q",
+  "SIM",
+  "TD",
+  "W",
+]
+ignore = ["W505", "E501", "ANN002", "ANN003", "TD002", "TD003", "ANN401"]
+preview = true
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
+preview = true
+
+[tool.ty.rules]
+# possibly-missing-import = "ignore"
+unresolved-reference = "ignore" # handled by ruff
+unresolved-attribute = "ignore"
+no-matching-overload = "ignore" # not that accurate
+possibly-missing-attribute = "ignore" # no it is not missing
+invalid-assignment = "warn" # probably already but warn for future
+unused-ignore-comment = "ignore"

textual_drivers-0.1.0/src/textual_drivers/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from textual.app import App
+from textual.types import CSSPathType
+
+from textual_drivers._mixin import BoundedPattern, CustomDriverMixin, EventHandlerMixin, LockStdinMixin, Pattern
+from textual_drivers.headless_driver import CustomHeadlessDriver
+
+
+class DrivenApp(App):
+    def __init__(self, css_path: CSSPathType | None = None, watch_css: bool = False, ansi_color: bool | None = None) -> None:
+        import sys
+        if sys.platform == "win32":
+            from textual_drivers.windows_driver import CustomWindowsDriver as _Driver
+        else:
+            from textual_drivers.linux_driver import CustomLinuxDriver as _Driver
+        super().__init__(driver_class=_Driver, css_path=css_path, watch_css=watch_css, ansi_color=ansi_color)
+        self._driver: _Driver
+
+
+__all__ = [
+    "DrivenApp",
+    "BoundedPattern",
+    "Pattern",
+    "CustomDriverMixin",
+    "EventHandlerMixin",
+    "LockStdinMixin",
+    "CustomHeadlessDriver",
+]

textual_drivers-0.1.0/src/textual_drivers/_dnd_app.py

@@ -0,0 +1,293 @@
+"""Base app with kitty drag-in and drag-out protocol support."""
+
+from __future__ import annotations
+
+import base64
+import re
+from typing import Literal, NamedTuple
+
+from textual.message import Message
+
+from textual_drivers import BoundedPattern, DrivenApp
+from textual_drivers._utils import b64encode, safe
+
+_OSC = "\x1b]"
+_ST = "\x1b\\"
+
+
+def _osc72(meta: str, payload: str = "") -> str:
+    if payload:
+        return f"{_OSC}72;{meta};{payload}{_ST}"
+    return f"{_OSC}72;{meta}{_ST}"
+
+
+# -- Internal messages ---------------------------------------------------------
+
+
+class DNDDragIn(Message):
+    """Kitty reports a drag is hovering over the app.
+
+    Handler: on_dnddrag_in (DNDApp internal — calls dnd_drag_in_operation).
+    pos is (-1, -1) when the drag leaves the window.
+    """
+
+    def __init__(self, data: str) -> None:
+        super().__init__()
+        m = re.search(
+            r"t=m:x=(?P<x>-?\d+):y=(?P<y>-?\d+)"
+            r"(?::X=(?P<X>-?\d+):Y=(?P<Y>-?\d+):o=(?P<o>\d+)[^;]*;(?P<mimes>[^\x1b]*))?",
+            data,
+        )
+        if not m:
+            raise ValueError(f"Invalid t=m: {data!r}")
+        self.pos: tuple[int, int] = (int(m.group("x")), int(m.group("y")))
+        o = int(m.group("o")) if m.group("o") else 0
+        self.op: Literal["copy", "move", "either"] = (
+            "copy" if o == 1 else "move" if o == 2 else "either"
+        )
+        self.mimes: list[str] = m.group("mimes").split() if m.group("mimes") else []
+
+
+class DragOut(Message):
+    """Kitty reports the user started a drag-out gesture.
+
+    Handler: on_drag_out (DNDApp internal — calls dnd_drag_out_operation).
+    """
+
+    def __init__(self, data: str) -> None:
+        super().__init__()
+        m = re.search(r"t=o:x=(?P<x>-?\d+):y=(?P<y>-?\d+)", data)
+        if not m:
+            raise ValueError(f"Invalid t=o gesture: {data!r}")
+        self.pos: tuple[int, int] = (int(m.group("x")), int(m.group("y")))
+
+
+class DNDDropData(Message):
+    """One t=r data chunk from kitty. Internal — accumulated by on_dnddrop_data."""
+
+    def __init__(self, data: str) -> None:
+        super().__init__()
+        m = re.search(
+            r"t=r:x=(?P<idx>\d+):m=(?P<more>[01]);(?P<b64>[^\x1b]*)",
+            data,
+        )
+        if not m:
+            raise ValueError(f"Invalid t=r chunk: {data!r}")
+        self.idx: int = int(m.group("idx"))
+        self.more: bool = m.group("more") == "1"
+        b64 = m.group("b64")
+        b64 += "=" * (-len(b64) % 4)
+        self.chunk: bytes = base64.b64decode(b64.encode())
+
+
+# -- User-facing messages ------------------------------------------------------
+
+
+class Drop(Message):
+    """Posted when the user drops content onto the terminal window.
+
+    Call request_data(event, index) from on_drop to fetch the actual content.
+    index is 0-based into event.mimes.
+    """
+
+    def __init__(self, data: str) -> None:
+        super().__init__()
+        m = re.search(
+            r"t=M:x=(?P<x>\d+):y=(?P<y>\d+):X=(?P<X>\d+):Y=(?P<Y>\d+)"
+            r":o=(?P<o>\d+)[^;]*;(?P<mimes>[^\x1b]*)",
+            data,
+        )
+        if not m:
+            raise ValueError(f"Invalid t=M: {data!r}")
+        self.pos: tuple[int, int] = (int(m.group("x")), int(m.group("y")))
+        o = int(m.group("o"))
+        self.op: Literal["copy", "move"] = "copy" if o == 1 else "move"
+        self.mimes: list[str] = m.group("mimes").split() if m.group("mimes") else []
+
+
+class DropData(Message):
+    """Posted once all requested MIME data has been received and assembled.
+
+    data is list[str] (URI entries) when the requested MIME is text/uri-list,
+    bytes for everything else.
+    """
+
+    def __init__(self, drop_event: Drop, data: list[str] | bytes) -> None:
+        super().__init__()
+        self.drop_event = drop_event
+        self.data = data
+
+
+class DragOutFinished(Message):
+    """Posted when a drag-out operation fully completes or is cancelled."""
+
+    def __init__(self, cancelled: bool) -> None:
+        super().__init__()
+        self.cancelled = cancelled
+
+
+# -- Return Types --------------------------------------------------------------
+
+
+class DragOutOperation(NamedTuple):
+    uris: list[str]
+    """URIs to offer for dragging out. Must be file://"""
+    op: Literal["copy", "move"]
+    popup_text: str
+    """Text to show in the drag icon popup. Should be short and descriptive."""
+    popup_size: int = 3
+    """Size of the popup text. The popup text's size is inversely proportional to this value."""
+
+
+# -- App -----------------------------------------------------------------------
+
+
+class DNDApp(DrivenApp):
+    """DrivenApp subclass with kitty drag-in and drag-out support.
+
+    Override dnd_drag_out_operation and dnd_drag_in_operation to customise
+    behaviour. Handle Drop, DropData, and DragOutFinished messages for events.
+    """
+
+    def on_mount(self) -> None:
+        driver = self._driver
+        driver.register_event_handler(
+            BoundedPattern(start="\x1b]72;t=m:", end=_ST), safe(DNDDragIn)
+        )
+        driver.register_event_handler(
+            BoundedPattern(start="\x1b]72;t=o:", end=_ST), safe(DragOut)
+        )
+        driver.register_event_handler(
+            BoundedPattern(start="\x1b]72;t=M:", end=_ST), safe(Drop)
+        )
+        driver.register_event_handler(
+            BoundedPattern(start="\x1b]72;t=r:", end=_ST), safe(DNDDropData)
+        )
+        driver.register_event_handler(
+            BoundedPattern(start="\x1b]72;t=e:", end=_ST), self._handle_drag_progress
+        )
+        self._drag_active: bool = False
+        self._drag_uris: list[str] = []
+        self._drag_op: Literal["copy", "move"] = "copy"
+        self._current_drop: Drop | None = None
+        self._data_buf: bytes = b""
+        self._data_mime_idx: int = 0
+        self._write(_osc72("t=o:x=1"))
+        self._write(_osc72("t=a", "*/*"))
+
+    # -- Internal handlers -----------------------------------------------------
+
+    def on_dnddrag_in(self, event: DNDDragIn) -> None:
+        x, y = event.pos
+        if x == -1 and y == -1:
+            self._write(_osc72("t=m:o=0"))
+            return
+        if not self.dnd_drag_in_operation(event):
+            self._write(_osc72("t=m:o=0"))
+            return
+        op_int = 1 if event.op in ("copy", "either") else 2
+        self._write(_osc72(f"t=m:o={op_int}", " ".join(event.mimes)))
+
+    def on_drag_out(self, event: DragOut) -> None:
+        result = self.dnd_drag_out_operation(event.pos)
+        if result is None:
+            self._write(_osc72("t=E:y=-1"))
+            return
+        self._drag_uris = result.uris
+        self._drag_op = result.op
+        self._drag_active = True
+        op_int = 1 if result.op == "copy" else 2
+        self._write(_osc72(f"t=o:o={op_int}", "text/uri-list text/plain"))
+        uri_list = "\r\n".join(result.uris) + "\r\n"
+        self._write(_osc72("t=p:x=0", b64encode(uri_list)))
+        plain = "\n".join(u.removeprefix("file://") for u in result.uris) + "\n"
+        self._write(_osc72("t=p:x=1", b64encode(plain)))
+        self._write(
+            _osc72(
+                f"t=p:x=-1:y=0:X={len(result.popup_text)}:Y={result.popup_size}:o=0",
+                b64encode(result.popup_text),
+            )
+        )
+        self._write(_osc72("t=P:x=-1"))
+
+    def on_dnddrop_data(self, event: DNDDropData) -> None:
+        if event.idx != self._data_mime_idx + 1:  # ignore unrequested MIMEs
+            return
+        self._data_buf += event.chunk
+        if event.more:
+            return
+        if self._current_drop is None:
+            self._data_buf = b""
+            return
+        mime = self._current_drop.mimes[self._data_mime_idx]
+        assembled: list[str] | bytes
+        if mime == "text/uri-list":
+            assembled = [
+                line
+                for line in self._data_buf.decode().splitlines()
+                if line and not line.startswith("#")
+            ]
+        else:
+            assembled = self._data_buf
+        self.post_message(DropData(self._current_drop, assembled))
+        self._data_buf = b""
+        self._write(_osc72("t=r:o=1"))
+
+    def _handle_drag_progress(self, data: str) -> None:
+        m = re.search(r"t=e:x=(?P<code>\d+)(?::y=(?P<y>-?\d+))?", data)
+        if not m:
+            return
+        code = int(m.group("code"))
+        if code == 4:
+            self._drag_active = False
+            self._drag_uris = []
+            self.post_message(DragOutFinished(cancelled=m.group("y") == "1"))
+        elif code == 5:
+            y = m.group("y")
+            if y is not None:
+                self._send_drag_data(int(y))
+
+    def _send_drag_data(self, idx: int) -> None:
+        if idx == 0:
+            self._write(
+                _osc72("t=e:y=0:m=0", b64encode("\r\n".join(self._drag_uris) + "\r\n"))
+            )
+        elif idx == 1:
+            plain = "\n".join(u.removeprefix("file://") for u in self._drag_uris) + "\n"
+            self._write(_osc72("t=e:y=1:m=0", b64encode(plain)))
+
+    # -- User-facing stubs -----------------------------------------------------
+
+    def on_drop(self, event: Drop) -> None: ...
+
+    def on_drag_out_finished(self, event: DragOutFinished) -> None: ...
+
+    # -- User override methods -------------------------------------------------
+
+    def dnd_drag_out_operation(self, pos: tuple[int, int]) -> DragOutOperation | None:
+        """Return DragOutOperation to start a drag-out, or None to cancel."""
+        return None
+
+    def dnd_drag_in_operation(self, event: DNDDragIn) -> bool:
+        """Return True to accept the incoming drag, False to reject."""
+        return True
+
+    def request_data(self, event: Drop, index: int) -> None:
+        """Request MIME data for a drop. index is 0-based into event.mimes."""
+        self._current_drop = event
+        self._data_mime_idx = index
+        self._data_buf = b""
+        self._write(_osc72(f"t=r:x={index + 1}"))
+
+    async def action_quit(self) -> None:
+        if self._drag_active:
+            self._write(_osc72("t=E:y=-1"))
+        self._write(_osc72("t=o:x=2"))
+        self._write(_osc72("t=a"))
+        await super().action_quit()
+
+    # -- Helpers ---------------------------------------------------------------
+
+    def _write(self, seq: str) -> None:
+        self._driver.write(seq)
+        self._driver.flush()

textual_drivers-0.1.0/src/textual_drivers/_mixin.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import fnmatch
+import re
+import threading
+import time
+from contextlib import contextmanager
+from typing import Any, Callable, Generator, NamedTuple, TypeAlias
+
+from textual.message import Message
+
+# Every terminal event mode Textual enables on start-up that can be toggled:
+#   mouse (1000/1002/1003/1006), focus tracking (1004),
+#   kitty key protocol (>1u), bracketed paste (2004).
+# Plain key events have no toggle - see LockStdinMixin.lock_stdin docstring.
+_EVENTS_DISABLE = (
+    "\x1b[?1003l"  # mouse: all-motion off
+    "\x1b[?1002l"  # mouse: drag off
+    "\x1b[?1000l"  # mouse: button off
+    "\x1b[?1006l"  # mouse: SGR extension off
+    "\x1b[?1004l"  # focus tracking off
+    "\x1b[>0u"     # kitty key protocol: reset to legacy encoding
+    "\x1b[?2004l"  # bracketed paste off
+)
+_EVENTS_ENABLE = (
+    "\x1b[?1000h"
+    "\x1b[?1002h"
+    "\x1b[?1003h"
+    "\x1b[?1006h"
+    "\x1b[?1004h"
+    "\x1b[>1u"
+    "\x1b[?2004h"
+)
+
+
+class LockStdinMixin:
+    """Mixin that adds lock_stdin to Textual drivers.
+
+    Provides cooperative stdin thread pausing and automatic terminal event
+    management.  Mix in before the driver class in the MRO and call
+    self._stdin_pause_point() at the top of the input-thread loop.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._pause_cond: threading.Condition = threading.Condition()
+        self._pause_lock_count: int = 0
+        self._stdin_is_paused: bool = False
+
+    @contextmanager
+    def lock_stdin(self) -> Generator[None, None, None]:
+        """Pause the stdin input thread and disable terminal event reporting.
+
+        The input thread voluntarily stops at its next pause point (at most one
+        read cycle, ≤ ~100 ms) and confirms via _stdin_is_paused before this
+        yields.  All terminal event modes Textual enables (mouse, focus tracking,
+        kitty key protocol, bracketed paste) are disabled for the duration so
+        that no unsolicited escape sequences can arrive in stdin.  A 50 ms settle
+        delay after disabling gives any already-in-transit events time to arrive
+        before the caller drains the buffer.
+
+        Plain key events cannot be disabled via escape sequences; drain stdin
+        after entering the context to discard any buffered keypresses.
+
+        Nesting multiple concurrent lock_stdin() calls is supported; event
+        reporting is disabled once on the outermost entry and re-enabled once on
+        the outermost exit.
+        """
+        with self._pause_cond:
+            is_outermost = self._pause_lock_count == 0
+            self._pause_lock_count += 1
+            # Wait for the input thread to reach the pause point and acknowledge.
+            # Timeout guards against callers that run before the thread starts.
+            self._pause_cond.wait_for(lambda: self._stdin_is_paused, timeout=0.5)
+
+        if is_outermost:
+            self.write(_EVENTS_DISABLE)  # type: ignore[attr-defined]
+            self.flush()  # type: ignore[attr-defined]
+            # Give any in-transit events time to arrive so the caller can drain them.
+            time.sleep(0.05)
+
+        try:
+            yield
+        finally:
+            with self._pause_cond:
+                self._pause_lock_count -= 1
+                outermost_releasing = self._pause_lock_count == 0
+                if outermost_releasing:
+                    self._pause_cond.notify_all()
+
+            if outermost_releasing:
+                self.write(_EVENTS_ENABLE)  # type: ignore[attr-defined]
+                self.flush()  # type: ignore[attr-defined]
+
+    def _stdin_pause_point(self) -> None:
+        """Call at the start of each input-thread loop iteration.
+
+        Blocks the input thread while any lock_stdin() context is active, then
+        resumes when all callers have exited.
+        """
+        with self._pause_cond:
+            if self._pause_lock_count > 0:
+                self._stdin_is_paused = True
+                self._pause_cond.notify_all()
+                while self._pause_lock_count > 0:
+                    self._pause_cond.wait(timeout=0.05)
+                    exit_event: threading.Event | None = getattr(
+                        self, "exit_event", None
+                    )
+                    if exit_event is not None and exit_event.is_set():
+                        break
+                self._stdin_is_paused = False
+
+
+class BoundedPattern(NamedTuple):
+    """Match raw stdin data that contains a substring starting with *start* and ending with *end*.
+
+    Useful for terminal sequences with known delimiters, e.g.
+    ``BoundedPattern(start="\\x1b]72;t=o:", end="\\x1b\\\\")``.
+    All non-overlapping matches within the incoming data chunk are dispatched.
+    """
+
+    start: str
+    end: str
+
+
+# Pattern accepted by register_event_handler:
+#   str            – glob matched against tokenised stdin chunks (fnmatch)
+#   BoundedPattern – greedy scan for start/end-delimited substrings
+#   re.Pattern     – finditer over the raw data string
+Pattern: TypeAlias = str | BoundedPattern | re.Pattern[str]
+
+
+def _find_bounded(data: str, start: str, end: str) -> list[str]:
+    """Return all non-overlapping substrings of *data* delimited by *start*…*end*."""
+    results: list[str] = []
+    pos = 0
+    while True:
+        s = data.find(start, pos)
+        if s == -1:
+            break
+        e = data.find(end, s + len(start))
+        if e == -1:
+            break
+        results.append(data[s : e + len(end)])
+        pos = e + len(end)
+    return results
+
+
+class EventHandlerMixin:
+    """Mixin that adds register_event_handler to Textual drivers.
+
+    Provides glob-pattern matching against raw stdin chunks and posting of
+    matched events into Textual's event system.  Mix in before the driver
+    class in the MRO and call self._dispatch_custom_handlers(data) for each
+    decoded stdin chunk in the input-thread loop.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._event_handlers: list[tuple[Pattern, Callable[[str], object]]] = []
+
+    def register_event_handler(
+        self, pattern: Pattern, event_constructor: Callable[[str], Message | Any]
+    ) -> None:
+        """Register a handler fired when raw stdin input matches *pattern*.
+
+        Args:
+            pattern: One of three forms —
+                ``str``: glob matched against tokenised stdin chunks (fnmatch);
+                ``BoundedPattern(start, end)``: fires for every non-overlapping
+                substring in the chunk that begins with *start* and ends with *end*;
+                ``re.Pattern``: fires for every match of ``pattern.finditer(data)``.
+            event_constructor: Called with the matched data string; if the
+                result is a Message instance it is posted to the app.
+        """
+        self._event_handlers.append((pattern, event_constructor))
+
+    def _dispatch_custom_handlers(self, data: str) -> None:
+        for pattern, constructor in self._event_handlers:
+            if isinstance(pattern, BoundedPattern):
+                chunks = _find_bounded(data, pattern.start, pattern.end)
+            elif isinstance(pattern, re.Pattern):
+                chunks = [m.group() for m in pattern.finditer(data)]
+            else:
+                # str glob: split on ESC so each escape sequence is checked individually
+                chunks = []
+                for part in data.split("\x1b"):
+                    if not part:
+                        continue
+                    chunks.append("\x1b" + part)
+
+            for chunk in chunks:
+                if isinstance(pattern, str) and not fnmatch.fnmatch(chunk, pattern):
+                    continue
+                event = constructor(chunk)
+                if isinstance(event, Message):
+                    event.set_sender(self._app)  # type: ignore[attr-defined]
+                    self.send_message(event)  # type: ignore[attr-defined]
+
+
+class CustomDriverMixin(LockStdinMixin, EventHandlerMixin):
+    """Convenience mixin combining LockStdinMixin and EventHandlerMixin.
+
+    Equivalent to subclassing both individually.  Use the individual mixins
+    if you only need one of the two features.
+    """