euporie 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

euporie/core/path.py

@@ -2,14 +2,11 @@
 
 from __future__ import annotations
 
-import base64
-import binascii
 import contextlib
-import io
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, overload
-from urllib.parse import unquote, urljoin, urlunsplit
+from typing import TYPE_CHECKING
+from urllib.parse import urljoin, urlunsplit
 
 import upath
 from aiohttp.client_reqrep import ClientResponse
@@ -19,39 +16,20 @@ from fsspec.registry import register_implementation as fs_register_implementatio
 from upath import UPath
 from upath.implementations.http import HTTPPath as _HTTPPath
 from upath.implementations.http import _HTTPAccessor
-from upath.registry import _registry
+from upath.registry import register_implementation
 
 if TYPE_CHECKING:
-    from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
     from os import PathLike
-    from typing import IO, Any, BinaryIO, Literal
+    from typing import Any
     from urllib.parse import SplitResult
 
-    from _typeshed import (
-        OpenBinaryMode,
-        OpenBinaryModeReading,
-        OpenBinaryModeUpdating,
-        OpenBinaryModeWriting,
-        OpenTextMode,
-    )
     from upath.core import PT
 
 
 log = logging.getLogger(__name__)
 
 
-def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
-    """Parse and resolve a path."""
-    if not isinstance(path, Path):
-        path = UPath(path)
-    with contextlib.suppress(NotImplementedError):
-        path = path.expanduser()
-    if resolve:
-        try:
-            path = path.resolve()
-        except (AttributeError, NotImplementedError, Exception):
-            log.info("Path %s not resolvable", path)
-    return path
+# Monkey-patch `aiohttp` to not raise exceptions on non-200 responses
 
 
 def _raise_for_status(self: ClientResponse) -> None:
@@ -61,148 +39,21 @@ def _raise_for_status(self: ClientResponse) -> None:
 setattr(ClientResponse, "raise_for_status", _raise_for_status)  # noqa B010
 
 
-class DataPath(upath.core.UPath):
-    """A :py:class:`pathlib` compatible class for reading data URIs."""
+# Define and register non-raising HTTP filesystem implementation for fsspec
+
+
+class HTTPFileSystem(FsHTTPFileSystem):
+    """A :py:class:`HTTPFileSystem` which does not raise exceptions on 404 errors."""
+
+    def _raise_not_found_for_status(self, response: ClientResponse, url: str) -> None:
+        """Do not raise an exception for 404 errors."""
+
+
+fs_register_implementation("http", HTTPFileSystem, clobber=True)
+fs_register_implementation("https", HTTPFileSystem, clobber=True)
+
 
-    @overload
-    def open(
-        self,
-        mode: OpenTextMode = "r",
-        buffering: int = -1,
-        encoding: str | None = None,
-        errors: str | None = None,
-        newline: str | None = None,
-    ) -> TextIOWrapper:
-        ...
-
-    # Unbuffered binary mode: returns a FileIO
-    @overload
-    def open(
-        self,
-        mode: OpenBinaryMode,
-        buffering: Literal[0],
-        encoding: None = None,
-        errors: None = None,
-        newline: None = None,
-    ) -> FileIO:
-        ...
-
-    # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
-    @overload
-    def open(
-        self,
-        mode: OpenBinaryModeUpdating,
-        buffering: Literal[-1, 1] = -1,
-        encoding: None = None,
-        errors: None = None,
-        newline: None = None,
-    ) -> BufferedRandom:
-        ...
-
-    @overload
-    def open(
-        self,
-        mode: OpenBinaryModeWriting,
-        buffering: Literal[-1, 1] = -1,
-        encoding: None = None,
-        errors: None = None,
-        newline: None = None,
-    ) -> BufferedWriter:
-        ...
-
-    @overload
-    def open(
-        self,
-        mode: OpenBinaryModeReading,
-        buffering: Literal[-1, 1] = -1,
-        encoding: None = None,
-        errors: None = None,
-        newline: None = None,
-    ) -> BufferedReader:
-        ...
-
-    # Buffering cannot be determined: fall back to BinaryIO
-    @overload
-    def open(
-        self,
-        mode: OpenBinaryMode,
-        buffering: int = -1,
-        encoding: None = None,
-        errors: None = None,
-        newline: None = None,
-    ) -> BinaryIO:
-        ...
-
-    # Fallback if mode is not specified
-    @overload
-    def open(
-        self,
-        mode: str,
-        buffering: int = -1,
-        encoding: str | None = None,
-        errors: str | None = None,
-        newline: str | None = None,
-    ) -> IO[Any]:
-        ...
-
-    def open(
-        self,
-        mode: OpenTextMode
-        | OpenBinaryMode
-        | OpenBinaryModeReading
-        | OpenBinaryModeWriting
-        | OpenBinaryModeUpdating
-        | str = "r",
-        buffering: Literal[-1, 0, 1] | int = -1,
-        encoding: str | None = None,
-        errors: str | None = None,
-        newline: str | None = None,
-    ) -> IO[Any]:
-        """Return an io object for the data in the URI."""
-        assert self._url is not None
-        data_format, _, encoded_data = self._url.path.partition(",")
-        _mime, *params = data_format.split(";")
-
-        data_bytes = None
-        data_str = None
-
-        if "base64" in params:
-            try:
-                data_bytes = base64.b64decode(encoded_data)
-            except binascii.Error:
-                log.warning("Failed to decode base64 encoded data")
-                data_bytes = b""
-        else:
-            data_str = unquote(encoded_data)
-
-        if "b" in mode:
-            if data_bytes is None:
-                assert data_str is not None
-                data_bytes = data_str.encode()
-            return io.BytesIO(data_bytes)
-        else:
-            if data_str is None:
-                assert data_bytes is not None
-                # decode_kwargs: dict[str, str] = {}
-                # if encoding is not None:  #:= kwargs.get("encoding"):
-                # decode_kwargs["encoding"] = str(encoding)
-                data_str = data_bytes.decode()  # **decode_kwargs)
-            return io.StringIO(data_str)
-
-    def exists(self, **kwargs: Any) -> bool:
-        """Affirm that data URIs always exist."""
-        return True
-
-    @property
-    def _mime(self) -> str:
-        """Return the media type of the data URI."""
-        assert self._url is not None
-        data_format, _, _encoded_data = self._url.path.partition(",")
-        mime, *params = data_format.split(";")
-        return mime
-
-
-_registry.known_implementations["data"] = "euporie.core.path.DataPath"
+# Define custom universal_pathlib path implementations
 
 
 class CachingHTTPAccessor(_HTTPAccessor):
@@ -256,16 +107,32 @@ class HTTPPath(_HTTPPath):
             return self._hash
 
 
-_registry.known_implementations["http"] = "euporie.core.path.HTTPPath"
-_registry.known_implementations["https"] = "euporie.core.path.HTTPPath"
+class _DataAccessor(upath.core._FSSpecAccessor):
+    def _format_path(self, path: upath.core.UPath) -> str:
+        """Return the full URI as a string."""
+        return str(path)
 
 
-class HTTPFileSystem(FsHTTPFileSystem):
-    """A :py:class:`HTTPFileSystem` which does not raise exceptions on 404 errors."""
+class DataPath(upath.core.UPath):
+    """A :py:class:`pathlib` compatible class for reading data URIs."""
 
-    def _raise_not_found_for_status(self, response: ClientResponse, url: str) -> None:
-        """Do not raise an exception for 404 errors."""
+    _default_accessor = _DataAccessor
 
 
-fs_register_implementation("http", HTTPFileSystem, clobber=True)
-fs_register_implementation("https", HTTPFileSystem, clobber=True)
+register_implementation("data", DataPath, clobber=True)
+register_implementation("http", HTTPPath, clobber=True)
+register_implementation("https", HTTPPath, clobber=True)
+
+
+def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
+    """Parse and resolve a path."""
+    if not isinstance(path, Path):
+        path = UPath(path)
+    with contextlib.suppress(NotImplementedError):
+        path = path.expanduser()
+    if resolve:
+        try:
+            path = path.resolve()
+        except (AttributeError, NotImplementedError, Exception):
+            log.info("Path %s not resolvable", path)
+    return path

euporie/core/renderer.py

@@ -8,11 +8,11 @@ from typing import TYPE_CHECKING
 from prompt_toolkit.data_structures import Point, Size
 from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
-from prompt_toolkit.layout.screen import Char, Screen, WritePosition
 from prompt_toolkit.renderer import Renderer as PtkRenderer
 from prompt_toolkit.renderer import _StyleStringHasStyleCache, _StyleStringToAttrsCache
 
 from euporie.core.io import Vt100_Output
+from euporie.core.layout.screen import BoundedWritePosition, Screen
 
 if TYPE_CHECKING:
     from typing import Any, Callable
@@ -20,6 +20,8 @@ if TYPE_CHECKING:
     from prompt_toolkit.application import Application
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.layout.layout import Layout
+    from prompt_toolkit.layout.screen import Char
+    from prompt_toolkit.layout.screen import Screen as PtkScreen
     from prompt_toolkit.output import ColorDepth, Output
     from prompt_toolkit.styles import BaseStyle
 
@@ -32,10 +34,10 @@ log = logging.getLogger(__name__)
 def _output_screen_diff(
     app: Application[Any],
     output: Output,
-    screen: Screen,
+    screen: PtkScreen,
     current_pos: Point,
     color_depth: ColorDepth,
-    previous_screen: Screen | None,
+    previous_screen: PtkScreen | None,
     last_style: str | None,
     is_done: bool,  # XXX: drop is_done
     full_screen: bool,
@@ -123,7 +125,9 @@ def _output_screen_diff(
                 for index, cell in row.items()
                 if cell.char != " " or style_string_has_style[cell.style]
             }
-            | zwe_row.keys()
+            # Lag ZWE indices by one, as one could exist after the last line character
+            # but we don't want that to count towards the line width
+            | {x - 1 for x in zwe_row}
             | {0}
         )
 
@@ -148,6 +152,7 @@ def _output_screen_diff(
         output.erase_down()
 
         previous_screen = Screen()
+    assert previous_screen is not None
 
     # Get height of the screen.
     # (height changes as we loop over data_buffer, so remember the current value.)
@@ -174,7 +179,8 @@ def _output_screen_diff(
 
         prev_diff_char = False
 
-        # We might have a ZWE sequence just beyond the end of the line
+        # Loop just beyond the line length to check for ZWE sequences right at the end
+        # of the line
         while c <= new_max_line_len + 1:
             new_char = new_row[c]
             old_char = previous_row[c]
@@ -268,16 +274,21 @@ class Renderer(PtkRenderer):
             style, output, full_screen, mouse_support, cpr_not_supported_callback
         )
         self._extended_keys_enabled = False
+        self._private_sixel_colors_enabled = False
         self.extend_height = to_filter(extend_height)
         self.extend_width = to_filter(extend_width)
 
     def reset(self, _scroll: bool = False, leave_alternate_screen: bool = True) -> None:
-        """Disable extended keys before resetting the output."""
-        # Disable extended keys
+        """Reset the output."""
         if isinstance(self.output, Vt100_Output):
+            # Disable extended keys before resetting the output
             self.output.disable_extended_keys()
             self._extended_keys_enabled = False
 
+            # Disable private sixel colors before resetting the output
+            self.output.disable_private_sixel_colors()
+            self._private_sixel_colors_enabled = False
+
         super().reset(_scroll, leave_alternate_screen)
 
     def render(
@@ -318,6 +329,13 @@ class Renderer(PtkRenderer):
             self.output.enable_extended_keys()
             self._extended_keys_enabled = True
 
+        # Ensable private sixel graphic color registers
+        if not self._private_sixel_colors_enabled and isinstance(
+            self.output, Vt100_Output
+        ):
+            self.output.enable_private_sixel_colors()
+            self._private_sixel_colors_enabled = True
+
         # Create screen and write layout to it.
         size = output.get_size()
         screen = Screen()
@@ -376,7 +394,12 @@ class Renderer(PtkRenderer):
         layout.container.write_to_screen(
             screen,
             mouse_handlers,
-            WritePosition(xpos=0, ypos=0, width=size.columns, height=height),
+            BoundedWritePosition(
+                xpos=0,
+                ypos=0,
+                width=size.columns,
+                height=height,
+            ),
             parent_style="",
             erase_bg=False,
             z_index=None,

euporie/core/style.py

@@ -424,6 +424,8 @@ def build_style(
         # status of cursor-line.
         **dict(default_ui_style().style_rules),
         "default": f"fg:{cp.bg.base} bg:{cp.bg.base}",
+        # Remove non-breaking space style from PTK
+        "nbsp": "nounderline fg:default",
         # Logo
         "logo": "fg:#dd0000",
         # Pattern

euporie/core/tabs/base.py

@@ -10,7 +10,7 @@ from functools import partial
 from typing import TYPE_CHECKING, ClassVar
 
 from prompt_toolkit.history import InMemoryHistory
-from prompt_toolkit.layout.containers import Window, WindowAlign
+from prompt_toolkit.layout.containers import WindowAlign
 from prompt_toolkit.layout.controls import FormattedTextControl
 
 from euporie.core.comm.registry import open_comm
@@ -24,6 +24,7 @@ from euporie.core.kernel import Kernel, MsgCallbacks
 from euporie.core.key_binding.registry import (
     register_bindings,
 )
+from euporie.core.layout.containers import Window
 from euporie.core.suggest import HistoryAutoSuggest
 from euporie.core.utils import run_in_thread_with_context
 

euporie/core/terminal.py

@@ -14,7 +14,6 @@ from functools import lru_cache
 from typing import TYPE_CHECKING, ClassVar
 
 from aenum import extend_enum
-from prompt_toolkit.application.current import get_app
 from prompt_toolkit.application.run_in_terminal import run_in_terminal
 from prompt_toolkit.key_binding.key_processor import KeyProcessor, _Flush
 from prompt_toolkit.keys import Keys
@@ -22,7 +21,8 @@ from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.utils import Event
 
 from euporie.core.commands import add_cmd
-from euporie.core.filters import in_tmux
+from euporie.core.current import get_app
+from euporie.core.filters import in_screen, in_tmux
 from euporie.core.key_binding.registry import register_bindings
 from euporie.core.style import DEFAULT_COLORS
 
@@ -50,11 +50,17 @@ def _have_termios_tty_fcntl() -> bool:
         return True
 
 
-def tmuxify(cmd: str) -> str:
-    """Wrap an escape sequence for tmux passthrough."""
-    if in_tmux():
-        cmd = cmd.replace("\x1b", "\x1b\x1b")
-        cmd = f"\x1bPtmux;{cmd}\033\\"
+def passthrough(cmd: str) -> str:
+    """Wrap an escape sequence for terminal passthrough."""
+    if get_app().config.multiplexer_passthrough:
+        if in_tmux():
+            cmd = cmd.replace("\x1b", "\x1b\x1b")
+            cmd = f"\x1bPtmux;{cmd}\x1b\\"
+        elif in_screen():
+            # Screen limits escape sequences to 768 bytes, so we have to chunk it
+            cmd = "".join(
+                f"\x1bP{cmd[i: i+764]}\x1b\\" for i in range(0, len(cmd), 764)
+            )
     return cmd
 
 
@@ -198,7 +204,7 @@ class Colors(TerminalQuery):
     )
 
     def _cmd(self) -> str:
-        return tmuxify(self.cmd)
+        return passthrough(self.cmd)
 
     def verify(self, data: str) -> dict[str, str]:
         """Verify the response contains a colour."""
@@ -247,7 +253,7 @@ class KittyGraphicsStatus(TerminalQuery):
 
     def _cmd(self) -> str:
         """Hide the command in case the terminal does not support this sequence."""
-        return "\x1b[s" + tmuxify(self.cmd) + "\x1b[u\x1b[2K"
+        return "\x1b[s" + passthrough(self.cmd) + "\x1b[u\x1b[2K"
 
     def verify(self, data: str) -> bool:
         """Verify the terminal response means kitty graphics are supported."""
@@ -269,10 +275,7 @@ class SixelGraphicsStatus(TerminalQuery):
     pattern = re.compile(r"^\x1b\[\?(?:\d+;)*(?P<sixel>4)(?:;\d+)*c\Z")
 
     def _cmd(self) -> str:
-        if self.config.tmux_graphics:
-            return tmuxify(self.cmd)
-        else:
-            return self.cmd
+        return passthrough(self.cmd)
 
     def verify(self, data: str) -> bool:
         """Verify the terminal response means sixel graphics are supported."""
@@ -294,10 +297,7 @@ class ItermGraphicsStatus(TerminalQuery):
     pattern = re.compile(r"^\x1bP>\|(?P<term>[^\x1b]+)\x1b\\")
 
     def _cmd(self) -> str:
-        if self.config.tmux_graphics:
-            return tmuxify(self.cmd)
-        else:
-            return self.cmd
+        return passthrough(self.cmd)
 
     def verify(self, data: str) -> bool:
         """Verify iterm graphics are supported by the terminal."""
@@ -345,13 +345,11 @@ class SgrPixelStatus(TerminalQuery):
 
     def verify(self, data: str) -> bool:
         """Verify the terminal response means SGR pixel-mode is supported."""
-        if (
+        return bool(
             (match := self.pattern.match(data))
             and (values := match.groupdict())
             and (values.get("Pm") in {"1", "3"})
-        ):
-            return True
-        return False
+        )
 
 
 class CsiUStatus(TerminalQuery):

euporie/core/widgets/cell.py

@@ -15,9 +15,6 @@ from prompt_toolkit.filters import Condition
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     Container,
-    HSplit,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
@@ -30,6 +27,7 @@ from euporie.core.config import add_setting
 from euporie.core.current import get_app
 from euporie.core.filters import multiple_cells_selected
 from euporie.core.format import format_code
+from euporie.core.layout.containers import HSplit, VSplit, Window
 from euporie.core.utils import on_click
 from euporie.core.widgets.cell_outputs import CellOutputArea
 from euporie.core.widgets.inputs import KernelInput, StdInput
@@ -442,7 +440,7 @@ class Cell:
                 self.rendered = False
             if position is not None:
                 self.input_box.buffer.cursor_position = position % (
-                    len(self.input_box.buffer.text) or 1
+                    len(self.input_box.buffer.text) + 1
                 )
         else:
             to_focus = self.kernel_tab.cell.control

euporie/core/widgets/cell_outputs.py

@@ -11,10 +11,8 @@ from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.filters import buffer_has_focus
 from prompt_toolkit.layout.containers import (
     DynamicContainer,
-    HSplit,
     to_container,
 )
-from prompt_toolkit.widgets.base import Box
 
 from euporie.core.config import add_setting
 from euporie.core.convert.datum import Datum
@@ -22,7 +20,9 @@ from euporie.core.convert.formats import BASE64_FORMATS
 from euporie.core.convert.mime import MIME_FORMATS
 from euporie.core.convert.registry import find_route
 from euporie.core.current import get_app
+from euporie.core.layout.containers import HSplit
 from euporie.core.widgets.display import Display
+from euporie.core.widgets.layout import Box
 from euporie.core.widgets.tree import JsonView
 
 if TYPE_CHECKING: