textual-drivers 0.1.0__py3-none-any.whl

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/_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/_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.
+    """

textual_drivers/_utils.py

@@ -0,0 +1,119 @@
+import time
+from collections.abc import Callable
+from functools import wraps
+from inspect import isawaitable, iscoroutinefunction
+from typing import Any, Protocol
+
+from textual.dom import DOMNode
+from textual.message import Message
+
+
+def throttle(delay: float) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Leading-edge throttle with trailing-edge debounce for Textual message handlers.
+
+    The first event in a burst passes immediately. Events within `delay` seconds
+    are blocked. The last blocked event fires after `delay` seconds from the last allowed event.
+
+    Returns:
+        A decorator that wraps a Textual message handler (sync or async) with debounce logic.
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        attr_last = f"_deb_last_{func.__name__}"
+        attr_timer = f"_deb_timer_{func.__name__}"
+
+        if iscoroutinefunction(func):
+            @wraps(func)
+            async def wrapper(self: DOMNode, event: Message, *args, **kwargs) -> None:
+                now = time.monotonic()
+                last_passed = getattr(self, attr_last, 0.0)
+                trailing_timer = getattr(self, attr_timer, None)
+
+                if now - last_passed >= delay:
+                    # run func
+                    if trailing_timer is not None:
+                        trailing_timer.stop()
+                        setattr(self, attr_timer, None)
+                    setattr(self, attr_last, now)
+                    # not sure how workers are handled
+                    obj = func(self, event, *args, **kwargs)
+                    if isawaitable(obj):
+                        await obj
+                else:
+                    if trailing_timer is not None:
+                        trailing_timer.stop()
+
+                    captured = event
+
+                    async def trailing() -> None:
+                        setattr(self, attr_timer, None)
+                        setattr(self, attr_last, time.monotonic())
+                        await func(self, captured, *args, **kwargs)
+
+                    # Calculate remaining time until next allowed event
+                    time_since_last = now - last_passed
+                    remaining_delay = delay - time_since_last
+                    setattr(self, attr_timer, self.set_timer(remaining_delay, trailing))
+
+            return wrapper
+        else:
+            @wraps(func)
+            def wrapper(self: DOMNode, event: Message, *args, **kwargs) -> None:
+                now = time.monotonic()
+                last_passed = getattr(self, attr_last, 0.0)
+                trailing_timer = getattr(self, attr_timer, None)
+
+                if now - last_passed >= delay:
+                    # run func
+                    if trailing_timer is not None:
+                        trailing_timer.stop()
+                        setattr(self, attr_timer, None)
+                    setattr(self, attr_last, now)
+                    func(self, event, *args, **kwargs)
+                else:
+                    if trailing_timer is not None:
+                        trailing_timer.stop()
+
+                    captured = event
+
+                    def trailing() -> None:
+                        setattr(self, attr_timer, None)
+                        setattr(self, attr_last, time.monotonic())
+                        func(self, captured, *args, **kwargs)
+
+                    # Calculate remaining time until next allowed event
+                    time_since_last = now - last_passed
+                    remaining_delay = delay - time_since_last
+                    setattr(self, attr_timer, self.set_timer(remaining_delay, trailing))
+
+            return wrapper
+
+    return decorator
+
+
+class MessageLike(Protocol):
+    def __init__(self, data: str) -> None: ...
+
+
+def safe(cls: type[MessageLike]) -> Callable[[str], Message | None]:
+    def factory(data: str) -> Message | None:
+        try:
+            return cls(data)
+        except (ValueError, NotImplementedError):
+            return None
+    return factory
+
+
+def b64decode(data: str | bytes) -> str:
+    import base64
+    if isinstance(data, str):
+        data = data.encode()
+    data += b"=" * (-len(data) % 4)
+    return base64.b64decode(data).decode()
+
+
+def b64encode(data: str | bytes) -> str:
+    import base64
+    if isinstance(data, str):
+        data = data.encode()
+    return base64.b64encode(data).decode()

textual_drivers/demo/__main__.py

@@ -0,0 +1,33 @@
+import argparse
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Textual Drivers Demo")
+    parser.add_argument(
+        "--demo",
+        choices=["check_image_support", "try_both", "kitty_drag_out", "kitty_drag_in"],
+        default="check_image_support",
+        help="Choose a demo to run",
+    )
+    args = parser.parse_args()
+
+    if args.demo == "check_image_support":
+        from .capability_check_app import CapabilityCheckApp
+
+        CapabilityCheckApp().run()
+    elif args.demo == "try_both":
+        from .test_app import DriverTestApp
+
+        DriverTestApp().run()
+    elif args.demo == "kitty_drag_out":
+        from .drag_out import DragOutApp
+
+        DragOutApp().run()
+    elif args.demo == "kitty_drag_in":
+        from .drag_in import DragInApp
+
+        DragInApp().run()
+
+
+if __name__ == "__main__":
+    main()