euporie 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

euporie/core/margins.py

@@ -35,7 +35,7 @@ if TYPE_CHECKING:
     class ScrollableContainer(Protocol):
         """Protocol for a scrollable container."""
 
-        render_info: WindowRenderInfo
+        render_info: WindowRenderInfo | None
         vertical_scroll: int
 
 
@@ -65,7 +65,7 @@ class MarginContainer(Window):
     def create_fragments(self) -> StyleAndTextTuples:
         """Generate text fragments to display."""
         return self.margin.create_margin(
-            self.target.render_info,
+            cast("WindowRenderInfo", self.target.render_info),  # Minor type hack
             self.write_position.width,
             self.write_position.height,
         )
@@ -75,7 +75,13 @@ class MarginContainer(Window):
 
     def preferred_width(self, max_available_width: int) -> Dimension:
         """Return a the desired width for this container."""
-        width = self.margin.get_width(lambda: self.target.render_info.ui_content)
+
+        def _get_ui_content() -> UIContent:
+            render_info = self.target.render_info
+            assert render_info is not None
+            return render_info.ui_content
+
+        width = self.margin.get_width(_get_ui_content)
         return Dimension(min=width, max=width)
 
     def preferred_height(self, width: int, max_available_height: int) -> Dimension:
@@ -186,7 +192,7 @@ class ScrollbarMargin(ClickableMargin):
         display_arrows: FilterOrBool = True,
         up_arrow_symbol: str = "▴",
         down_arrow_symbol: str = "▾",
-        autohide: FilterOrBool = True,
+        autohide: FilterOrBool = False,
         smooth: bool = True,
         style: str = "",
     ) -> None:
@@ -214,7 +220,7 @@ class ScrollbarMargin(ClickableMargin):
 
     def create_margin(
         self,
-        window_render_info: WindowRenderInfo,
+        window_render_info: WindowRenderInfo | None,
         width: int,
         height: int,
         margin_render_info: WindowRenderInfo | None = None,
@@ -225,22 +231,31 @@ class ScrollbarMargin(ClickableMargin):
         self.window_render_info = window_render_info
         self.margin_render_info = margin_render_info
 
-        if window_render_info is None or not width:
+        # If this is the first time the target is being drawn, it may not yet have a
+        # render_info yet. Thus, invalidate the app so we can immediately redraw the
+        # scroll-bar with the render_info
+        if window_render_info is None:
+            get_app().invalidate()
+
+        if not width:
             return result
 
         # Show we render the arrow buttons?
         display_arrows = self.display_arrows()
 
         # The height of the scrollbar, excluding the optional buttons
-        self.track_height = window_render_info.window_height
+        self.track_height = (
+            window_render_info.window_height if window_render_info else height
+        )
         if display_arrows:
             self.track_height -= 2
 
         # Height of all text in the output: If there is none, we cannot divide
         # by zero so we hide the thumb
-        content_height = window_render_info.content_height
-        if content_height == 0 or content_height <= len(
-            window_render_info.displayed_lines
+        if (
+            window_render_info is None
+            or (content_height := window_render_info.content_height) == 0
+            or content_height <= len(window_render_info.displayed_lines)
         ):
             self.thumb_size = 0
         else:
@@ -259,7 +274,9 @@ class ScrollbarMargin(ClickableMargin):
             self.thumb_size = int(self.thumb_size)
 
         # Calculate the position of the thumb
-        if content_height <= len(window_render_info.displayed_lines):
+        if window_render_info is None or content_height <= len(
+            window_render_info.displayed_lines
+        ):
             fraction_above = 0.0
         else:
             fraction_above = window_render_info.vertical_scroll / (
@@ -381,7 +398,8 @@ class ScrollbarMargin(ClickableMargin):
 
         """
         render_info = self.window_render_info
-        assert render_info is not None
+        if render_info is None:
+            return NotImplemented
 
         content_height = render_info.content_height
         if isinstance(mouse_event, MouseEvent):
@@ -410,9 +428,9 @@ class ScrollbarMargin(ClickableMargin):
 
             if isinstance(window, Window):
                 if delta < 0:
-                    func = window._scroll_up
-                else:
                     func = window._scroll_down
+                else:
+                    func = window._scroll_up
                 for _ in range(abs(delta)):
                     func()
             elif hasattr(window, "scrolling"):

euporie/core/path.py

@@ -0,0 +1,273 @@
+"""Responible for loading data from urls."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import io
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, overload
+from urllib.parse import unquote, urljoin, urlunsplit
+
+import upath
+from aiohttp.client_reqrep import ClientResponse
+from fsspec.implementations.cached import WholeFileCacheFileSystem
+from fsspec.implementations.http import HTTPFileSystem as FsHTTPFileSystem
+from fsspec.registry import register_implementation as fs_register_implementation
+from upath import UPath
+from upath.implementations.http import HTTPPath as _HTTPPath
+from upath.implementations.http import _HTTPAccessor
+from upath.registry import _registry
+
+if TYPE_CHECKING:
+    from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
+    from os import PathLike
+    from typing import IO, Any, BinaryIO, Literal
+    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) -> Path:
+    """Parse and resolve a path."""
+    if not isinstance(path, Path):
+        path = UPath(path)
+    try:
+        path = path.expanduser()
+    except NotImplementedError:
+        pass
+    try:
+        path = path.resolve()
+    except (AttributeError, NotImplementedError):
+        pass
+    return path
+
+
+def _raise_for_status(self: ClientResponse) -> None:
+    """Monkey-patch :py:class:`aiohttp.ClientResponse` not to raise for any status."""
+    pass
+
+
+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."""
+
+    @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 tat 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"
+
+
+class CachingHTTPAccessor(_HTTPAccessor):
+    """A :py:module:`universal_pathlib` accessor which caches content."""
+
+    def __init__(self, parsed_url: SplitResult | None, **kwargs: Any) -> None:
+        """Load a caching filesystem."""
+        cls = WholeFileCacheFileSystem
+        assert parsed_url is not None
+        url_kwargs = cls._get_kwargs_from_urls(urlunsplit(parsed_url))
+        url_kwargs.update(kwargs)
+        url_kwargs.setdefault("target_protocol", "http")
+        # url_kwargs.setdefault(
+        #     "cache_storage", str(Path(user_cache_dir("euporie")) / "web")
+        # )
+        self._fs = cls(**url_kwargs)
+
+    def _format_path(self, path: upath.UPath) -> str:
+        if (url := path._url) is not None:
+            return url.geturl()
+        return super()._format_path(path)
+
+
+class HTTPPath(_HTTPPath):
+    """An HTTP path which caches content."""
+
+    _hash: int
+    _default_accessor = CachingHTTPAccessor
+
+    def __truediv__(self: PT, key: str | PathLike) -> PT:
+        """Join a path to a HTTP URI."""
+        return self.__class__(urljoin(str(self), str(key)))
+
+    def __str__(self) -> str:
+        """Represent the path as a string."""
+        try:
+            return self._str
+        except AttributeError:
+            if url := self._url:
+                self._str = url.geturl()
+            else:
+                return super().__str__()
+            return self._str
+
+    def __hash__(self) -> int:
+        """Provide a unique hash of the path."""
+        try:
+            return self._hash
+        except AttributeError:
+            self._hash = hash(self._url)
+            return self._hash
+
+
+_registry.known_implementations["http"] = "euporie.core.path.HTTPPath"
+_registry.known_implementations["https"] = "euporie.core.path.HTTPPath"
+
+
+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."""
+        pass
+
+
+fs_register_implementation("http", HTTPFileSystem, clobber=True)
+fs_register_implementation("https", HTTPFileSystem, clobber=True)

euporie/core/processors.py

@@ -5,14 +5,18 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
+from prompt_toolkit.data_structures import Point
 from prompt_toolkit.layout.processors import (
     AppendAutoSuggestion,
     Processor,
     Transformation,
 )
 from prompt_toolkit.layout.utils import explode_text_fragments
+from prompt_toolkit.utils import get_cwidth
 
 if TYPE_CHECKING:
+    from typing import Callable
+
     from prompt_toolkit.layout.processors import TransformationInput
 
 
@@ -61,3 +65,34 @@ class ShowTrailingWhiteSpaceProcessor(Processor):
                 else:
                     break
         return Transformation(fragments)
+
+
+class CursorProcessor(Processor):
+    """Show a mouse cursor."""
+
+    def __init__(
+        self,
+        get_cursor_position: Callable[[], Point],
+        char: str = "🮰",
+        style: str = "class:mouse",
+    ) -> None:
+        """Create a new processor instance."""
+        self.char = char
+        self.style = style
+        self.get_cursor_position = get_cursor_position
+
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
+        """Replace character at the cursor position."""
+        pos = self.get_cursor_position()
+        fragments = ti.fragments
+        if ti.lineno == pos.y:
+            fragments = explode_text_fragments(fragments)
+            if (length := len(fragments)) < (x := pos.x):
+                fragments.append(("", " " * (x - length)))
+            frag = fragments[x]
+            char = self.char.ljust(get_cwidth(frag[1]))
+            fragments[x] = (
+                f"{frag[0]} {self.style}",
+                char,
+            )
+        return Transformation(fragments)

euporie/core/renderer.py

@@ -263,6 +263,7 @@ class Renderer(PtkRenderer):
         extend_width: FilterOrBool = False,
     ) -> None:
         """Create a new :py:class:`Renderer` instance."""
+        self.app: Application[Any] | None = None
         super().__init__(
             style, output, full_screen, mouse_support, cpr_not_supported_callback
         )
@@ -271,22 +272,37 @@ class Renderer(PtkRenderer):
 
     def reset(self, _scroll: bool = False, leave_alternate_screen: bool = True) -> None:
         """Disable extended keys before resetting the output."""
+        from euporie.core.app import BaseApp
+
+        super().reset(_scroll, leave_alternate_screen)
+
         output = self.output
 
         # Disable extended keys
-        if isinstance(output, Vt100_Output):
-            cast(Vt100_Output, self.output).disable_extended_keys()
-
-        super().reset(_scroll, leave_alternate_screen)
+        app = self.app
+        if (
+            app
+            and isinstance(app, BaseApp)
+            and app.term_info.csiu_status.value
+            and isinstance(output, Vt100_Output)
+        ):
+            cast("Vt100_Output", self.output).disable_extended_keys()
 
     def render(
         self, app: Application[Any], layout: Layout, is_done: bool = False
     ) -> None:
         """Render the current interface to the output."""
+        from euporie.core.app import BaseApp
+
         output = self.output
+        self.app = app
 
         # Enable extended keys
-        if isinstance(output, Vt100_Output):
+        if (
+            isinstance(app, BaseApp)
+            and app.term_info.csiu_status.value
+            and isinstance(output, Vt100_Output)
+        ):
             output.enable_extended_keys()
 
         # Enter alternate screen.

euporie/core/style.py

@@ -398,6 +398,8 @@ def build_style(
         "app-tab-bar tab active": "bold fg:default bg:default",
         "app-tab-bar tab active close": "fg:darkred",
         "app-tab-bar tab active border top": f"fg:{cp.hl} bg:{cp.bg.less(0.15)}",
+        # Tabs
+        "loading": "fg:#888888",
         # Buffer
         "line-number": f"fg:{cp.fg.more(0.5)} bg:{cp.bg.more(0.05)}",
         "line-number.current": f"bold orange bg:{cp.bg.more(0.1)}",
@@ -434,7 +436,7 @@ def build_style(
         # Scrollbars
         "scrollbar": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
         "scrollbar.background": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
-        "scrollbar.arrow": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.15)}",
+        "scrollbar.arrow": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.20)}",
         "scrollbar.start": "",
         # "scrollbar.start": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.25)}",
         "scrollbar.button": f"fg:{cp.bg.more(0.75)} bg:{cp.bg.more(0.75)}",
@@ -442,8 +444,7 @@ def build_style(
         # Overflow margin
         "overflow": f"fg:{cp.fg.more(0.5)}",
         # Dialogs
-        "dialog title": f"fg:white bg:{cp.hl.darker(0.25)} bold",
-        "dialog title border": "fg:ansired",
+        "dialog dialog-title": f"fg:white bg:{cp.hl.darker(0.25)} bold",
         "dialog": f"fg:{cp.fg.base} bg:{cp.bg.darker(0.1)}",
         "dialog text-area": f"bg:{cp.bg.lighter(0.05)}",
         "dialog input text text-area": f"fg:default bg:{cp.bg.less(0.1)}",
@@ -452,18 +453,22 @@ def build_style(
         # Horizontals rule
         "hr": "fg:ansired",
         # Completions menu
-        "completion-menu.completion.keyword": "fg:#d700af",
-        "completion-menu.completion.current.keyword": "fg:#fff bg:#d700ff",
-        "completion-menu.completion.function": "fg:#005faf",
-        "completion-menu.completion.current.function": "fg:#fff bg:#005fff",
-        "completion-menu.completion.class": "fg:#008700",
-        "completion-menu.completion.current.class": "fg:#fff bg:#00af00",
-        "completion-menu.completion.statement": "fg:#5f0000",
-        "completion-menu.completion.current.statement": "fg:#fff bg:#5f0000",
-        "completion-menu.completion.instance": "fg:#d75f00",
-        "completion-menu.completion.current.instance": "fg:#fff bg:#d78700",
-        "completion-menu.completion.module": "fg:#d70000",
-        "completion-menu.completion.current.module": "fg:#fff bg:#d70000",
+        "menu completion-keyword": "fg:#d700af",
+        "menu completion-function": "fg:#005faf",
+        "menu completion-class": "fg:#008700",
+        "menu completion-statement": "fg:#5f0000",
+        "menu completion-instance": "fg:#d75f00",
+        "menu completion-module": "fg:#d70000",
+        "menu completion-magic": "fg:#888888",
+        "menu completion-path": "fg:#aa8800",
+        "menu selection completion-keyword": f"fg:{ColorPaletteColor('#d700af').lighter(0.75)}",
+        "menu selection completion-function": f"fg:{ColorPaletteColor('#005faf').lighter(0.75)}",
+        "menu selection completion-class": f"fg:{ColorPaletteColor('#008700').lighter(0.75)}",
+        "menu selection completion-statement": f"fg:{ColorPaletteColor('#5f0000').lighter(0.75)}",
+        "menu selection completion-instance": f"fg:{ColorPaletteColor('#d75f00').lighter(0.75)}",
+        "menu selection completion-module": f"fg:{ColorPaletteColor('#d70000').lighter(0.75)}",
+        "menu selection completion-magic": f"fg:{ColorPaletteColor('#888888').lighter(0.75)}",
+        "menu selection completion-path": f"fg:{ColorPaletteColor('#aa8800').lighter(0.75)}",
         # Log
         "log.level.nonset": "fg:grey",
         "log.level.debug": "fg:green",
@@ -512,11 +517,21 @@ def build_style(
         "side_bar buttons separator selection before": f"fg:{cp.bg.less(0.15)} bg:{cp.hl}",
         "side_bar buttons separator selection after": f"fg:{cp.hl} bg:{cp.bg.less(0.15)}",
         # Tabbed split
-        "tabbed-split tab-bar tab inactive": f"fg:{cp.bg.more(0.1)}",
-        "tabbed-split tab-bar tab inactive border": f"fg:{cp.bg.more(0.15)}",
+        "tabbed-split border": f"fg:{cp.bg.more(0.2)}",
+        "tabbed-split border left": f"bg:{cp.bg.more(0.025)}",
+        "tabbed-split border right": f"bg:{cp.bg.more(0.025)}",
+        "tabbed-split border bottom left": f"bg:{cp.bg}",
+        "tabbed-split border bottom right": f"bg:{cp.bg}",
+        "tabbed-split page": f"bg:{cp.bg.more(0.025)}",
+        "dialog tabbed-split border bottom right": f"bg:{cp.bg.darker(0.1)}",
+        "dialog tabbed-split border bottom left": f"bg:{cp.bg.darker(0.1)}",
+        "tabbed-split tab-bar tab inactive": f"fg:{cp.bg.more(0.3)}",
+        "tabbed-split tab-bar tab inactive title": f"bg:{cp.bg.darker(0.05)}",
+        "tabbed-split tab-bar tab inactive border left": f"bg:{cp.bg.darker(0.05)}",
+        "tabbed-split tab-bar tab inactive border right": f"bg:{cp.bg.darker(0.05)}",
         "tabbed-split tab-bar tab active": f"bold fg:{cp.fg}",
+        "tabbed-split tab-bar tab active title": f"bg:{cp.bg.more(0.025)}",
         "tabbed-split tab-bar tab active close": "fg:darkred",
-        "tabbed-split border": f"fg:{cp.bg.more(0.2)}",
         # Ipywidgets
         "ipywidget focused": f"bg:{cp.bg.more(0.05)}",
         "ipywidget slider track": f"fg:{cp.fg.darker(0.5)}",
@@ -611,7 +626,7 @@ def build_style(
         "input inset border top selection focused": f"fg:{cp.hl.lighter(0.5)}",
         "input inset border left selection focused": f"fg:{cp.hl.lighter(0.5)}",
         "input text placeholder": f"fg:{cp.fg.more(0.6)}",
-        "input text text-area": f"bg:{cp.bg.lighter(0.1)}",
+        "input text text-area": f"fg:default bg:{cp.bg.lighter(0.1)}",
         "input text border top": f"fg:{cp.bg.darker(0.5)}",
         "input text border right": f"fg:{cp.bg.lighter(0.25)}",
         "input text border bottom": f"fg:{cp.bg.lighter(0.25)}",