pqx 0.1.0__py3-none-any.whl

pqx/__init__.py

@@ -0,0 +1,6 @@
+"""pqx — a fast, friendly terminal explorer for Parquet files."""
+
+try:  # written by setuptools-scm from the git tags at build/install time
+    from pqx._version import version as __version__
+except ImportError:  # a source checkout that was never built or installed
+    __version__ = "0.0.0.dev0"

pqx/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

pqx/_terminal.py

@@ -0,0 +1,122 @@
+"""Work-arounds for terminals and multiplexers that speak older mouse protocols.
+
+pqx asks for SGR mouse reporting (mode 1006), like every Textual app. Some
+multiplexers (GNU screen 4.x in particular) don't support SGR and hand the app
+X10-encoded events instead -- ``ESC [ M`` followed by three raw bytes -- or
+urxvt-encoded ones (``ESC [ b;x;y M``). Textual (as of 8.x) has two problems
+with that:
+
+* it only parses SGR mouse events, so X10/urxvt clicks are silently dropped;
+* it decodes terminal input as strict UTF-8, and an X10 coordinate above 95
+  is a byte > 127 that is not valid UTF-8: the input thread dies with
+  ``UnicodeDecodeError`` while the app keeps drawing -- it looks frozen.
+
+:func:`install` makes input decoding lenient (an invalid byte becomes the
+character with that code, which is exactly what an X10 coordinate means) and
+translates X10/urxvt mouse events into SGR before Textual parses them.
+
+It also keeps mouse coordinates in character cells. When a terminal says it
+supports in-band resize reports (mode 2048), Textual switches the mouse to
+pixel coordinates (mode 1016) and relies on those reports to convert back to
+cells. iTerm2 accepts 1016 but doesn't send the reports, so every click lands
+at a pixel position far off-screen and does nothing. Textual guards against
+this only when ``TERM_PROGRAM``/``LC_TERMINAL`` name iTerm, which they don't
+over ssh. pqx never needs sub-cell mouse precision, so pixel mode stays off.
+
+Finally, quitting always leaves a clean terminal. Textual draws on the
+alternate screen (mode 1049) and switches back on exit, which restores the
+shell's previous contents. Where the alternate screen is unavailable (some
+ssh/container setups, or a terminal or tmux with it turned off), pqx would
+have drawn over the normal screen and left its last frame behind, with the
+prompt in the middle of it. pqx clears the screen just before switching
+back: invisible when the alternate screen works, a clean screen when not.
+"""
+from __future__ import annotations
+
+import codecs
+import functools
+import re
+
+_ERRORS = "pqx-bytes"
+_X10 = re.compile(r"\x1b\[M(.)(.)(.)\Z", re.S)
+_URXVT = re.compile(r"\x1b\[(\d+);(\d+);(\d+)M\Z")
+_installed = False
+
+
+def _bytes_as_chars(err: UnicodeDecodeError):
+    return "".join(chr(b) for b in err.object[err.start:err.end]), err.end
+
+
+def x10_to_sgr(code: str, last_button: int = 0) -> tuple[str, int] | None:
+    """Translate an X10 or urxvt mouse sequence to SGR. Returns (sgr, last_button)."""
+    m = _X10.match(code)
+    if m:
+        b, x, y = (ord(c) - 32 for c in m.groups())
+    else:
+        m = _URXVT.match(code)
+        if not m:
+            return None
+        b, x, y = int(m.group(1)) - 32, int(m.group(2)), int(m.group(3))
+    if x < 1 or y < 1:
+        return None
+    if b & 64 or b & 32:  # wheel, or motion (with or without a button held)
+        return f"\x1b[<{b};{x};{y}M", last_button
+    if b & 3 == 3:  # X10 release doesn't say which button: use the one pressed last
+        return f"\x1b[<{last_button | (b & ~3)};{x};{y}m", last_button
+    return f"\x1b[<{b};{x};{y}M", b & 3
+
+
+def install() -> None:
+    """Patch Textual's input path (idempotent)."""
+    global _installed
+    if _installed:
+        return
+    _installed = True
+    try:
+        codecs.lookup_error(_ERRORS)
+    except LookupError:
+        codecs.register_error(_ERRORS, _bytes_as_chars)
+
+    try:
+        from textual.drivers import linux_driver
+
+        real = codecs.getincrementaldecoder
+
+        def lenient(encoding: str):
+            return functools.partial(real(encoding), errors=_ERRORS)
+
+        linux_driver.getincrementaldecoder = lenient
+    except Exception:  # pragma: no cover - other platforms / Textual versions
+        pass
+
+    try:
+        from textual.drivers.linux_driver import LinuxDriver
+
+        LinuxDriver._enable_mouse_pixels = lambda self: None  # cells, always (see above)
+
+        stop = LinuxDriver.stop_application_mode
+
+        @functools.wraps(stop)
+        def stop_application_mode(self):
+            self.write("\x1b[0m\x1b[H\x1b[2J")  # reset attributes, home, clear: before leaving 1049
+            stop(self)
+
+        LinuxDriver.stop_application_mode = stop_application_mode
+    except Exception:  # pragma: no cover
+        pass
+
+    try:
+        from textual._xterm_parser import XTermParser
+
+        original = XTermParser.parse_mouse_code
+
+        @functools.wraps(original)
+        def parse_mouse_code(self, code: str):
+            translated = x10_to_sgr(code, getattr(self, "_pqx_last_button", 0))
+            if translated is not None:
+                code, self._pqx_last_button = translated
+            return original(self, code)
+
+        XTermParser.parse_mouse_code = parse_mouse_code
+    except Exception:  # pragma: no cover
+        pass

pqx/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'g006519c4f'