euporie 2.8.5__py3-none-any.whl → 2.8.7__py3-none-any.whl

euporie/core/layout/scroll.py

@@ -1,18 +1,19 @@
-"""Contains containers which display children at full height vertially stacked."""
+"""Contains containers which display children at full height vertically stacked."""
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.application.current import get_app
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.filters import is_searching
 from prompt_toolkit.layout.containers import (
     Container,
     ScrollOffsets,
     Window,
     WindowRenderInfo,
-    to_container,
 )
 from prompt_toolkit.layout.controls import UIContent
 from prompt_toolkit.layout.dimension import Dimension, to_dimension
@@ -20,16 +21,12 @@ from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseModifie
 
 from euporie.core.layout.cache import CachedContainer
 from euporie.core.layout.screen import BoundedWritePosition
-from euporie.core.utils import run_in_thread_with_context
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from typing import Callable, Literal
 
-    from prompt_toolkit.key_binding.key_bindings import (
-        KeyBindingsBase,
-        NotImplementedOrNone,
-    )
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.dimension import AnyDimension
     from prompt_toolkit.layout.mouse_handlers import MouseHandlers
@@ -67,8 +64,11 @@ class ScrollingContainer(Container):
         self.children_func = _children_func
         self._child_cache: dict[int, CachedContainer] = {}
         self._children: list[CachedContainer] = []
+        self._known_sizes_cache: FastDictCache[tuple[int], list[int]] = FastDictCache(
+            self._known_sizes
+        )
         self.refresh_children = True
-        self.pre_rendered = 0.0
+        self.pre_rendered: float | None = None
 
         self._selected_slice = slice(
             0, 1
@@ -79,6 +79,7 @@ class ScrollingContainer(Container):
         self.index_positions: dict[int, int | None] = {}
 
         self.last_write_position: WritePosition = BoundedWritePosition(0, 0, 0, 0)
+        self.last_total_height = 0
 
         self.width = to_dimension(width).preferred
         self.height = to_dimension(height).preferred
@@ -92,23 +93,35 @@ class ScrollingContainer(Container):
 
     def pre_render_children(self, width: int, height: int) -> None:
         """Render all unrendered children in a background thread."""
+        children = self.all_children()
+        if not children:
+            return
+        self.pre_rendered = 0.0
+        incr = 1 / len(children)
+        app = get_app()
 
-        def _render_in_thread() -> None:
-            """Render children in  thread."""
-            children = self.all_children()
-            n_children = len(children)
-            app = get_app()
-            for i, child in enumerate(children):
-                if not app._is_running:
-                    return
-                if isinstance(child, CachedContainer):
-                    child.render(width, height)
-                self.pre_rendered = i / n_children
-                app.invalidate()
+        def _cb(task: asyncio.Task) -> None:
+            """Task callback to update pre-rendering percentage."""
+            assert isinstance(self.pre_rendered, float)
+            self.pre_rendered += incr
+            app.invalidate()
+
+        tasks = set()
+        for child in children:
+            if isinstance(child, CachedContainer):
+                task = app.create_background_task(
+                    asyncio.to_thread(child.render, width, height)
+                )
+                task.add_done_callback(_cb)
+                tasks.add(task)
+
+        async def _finish() -> None:
+            await asyncio.gather(*tasks)
             self.pre_rendered = 1.0
             app.invalidate()
+            # app.exit()
 
-        run_in_thread_with_context(_render_in_thread)
+        app.create_background_task(_finish())
 
     def reset(self) -> None:
         """Reset the state of this container and all the children."""
@@ -237,7 +250,6 @@ class ScrollingContainer(Container):
                 :py:const:`None`
 
         """
-        # self.refresh_children = True
         if n > 0:
             if (
                 min(self.visible_indices) == 0
@@ -353,6 +365,10 @@ class ScrollingContainer(Container):
                 their style down to the windows that they contain.
             z_index: Used for propagating z_index from parent to child.
         """
+        # Record where the container was last drawn so we can determine if cell outputs
+        # are partially obscured
+        self.last_write_position = write_position
+
         ypos = write_position.ypos
         xpos = write_position.xpos
 
@@ -365,9 +381,6 @@ class ScrollingContainer(Container):
         # Record children which are currently visible
         visible_indices = set()
 
-        # Ensure we have the right children
-        all_children = self.all_children()
-
         # Force the selected children to refresh
         selected_indices = self.selected_indices
         self._selected_children: list[CachedContainer] = []
@@ -409,12 +422,9 @@ class ScrollingContainer(Container):
             self.scroll_to_cursor = False
 
         # Adjust scrolling offset
-        if self.scrolling:
-            heights = [
-                # Ensure unrendered cells have at least some height
-                self.get_child(index).height or 1
-                for index in range(len(self._children))
-            ]
+        heights = self.known_sizes
+        total_height = sum(heights)
+        if self.scrolling or total_height != self.last_total_height:
             heights_above = sum(heights[: self._selected_slice.start])
             new_child_position = self.selected_child_position + self.scrolling
             # Do not allow scrolling if there is no overflow
@@ -436,6 +446,8 @@ class ScrollingContainer(Container):
                         self.scrolling = min(0, self.scrolling - underscroll)
             self.selected_child_position += self.scrolling
 
+        self.last_total_height = total_height
+
         # Blit first selected child and those below it that are on screen
         line = self.selected_child_position
         for i in range(self._selected_slice.start, len(self._children)):
@@ -545,23 +557,10 @@ class ScrollingContainer(Container):
 
         _walk(self)
 
-        # Record where the contain was last drawn so we can determine if cell outputs
-        # are partially obscured
-        self.last_write_position = write_position
-
-        # Calculate scrollbar info
-        sizes = self.known_sizes
-        avg_size = sum(sizes.values()) / len(sizes) if sizes else 0
-        n_children = len(all_children)
-        for i in range(n_children):
-            if i not in sizes:
-                sizes[i] = int(avg_size)
-        content_height = max(sum(sizes.values()), 1)
-
         # Mock up a WindowRenderInfo so we can draw a scrollbar margin
         self.render_info = WindowRenderInfo(
             window=cast("Window", self),
-            ui_content=UIContent(line_count=content_height),
+            ui_content=UIContent(line_count=max(sum(heights), 1)),
             horizontal_scroll=0,
             vertical_scroll=self.vertical_scroll,
             window_width=available_width,
@@ -577,14 +576,36 @@ class ScrollingContainer(Container):
         self.scrolling = 0
 
         # Trigger pre-rendering of children
-        if not self.pre_rendered:
+        if self.pre_rendered is None:
             self.pre_render_children(available_width, available_height)
 
+    @property
+    def known_sizes(self) -> list[int]:
+        """Map of child indices to height values."""
+        return self._known_sizes_cache[get_app().render_counter,]
+
+    def _known_sizes(self, render_counter: int) -> list[int]:
+        """Calculate sizes of children once per render cycle."""
+        sizes = {}
+        missing = set()
+        available_width = self.last_write_position.width
+        available_height = self.last_write_position.height
+        for i, child in enumerate(self._children):
+            if isinstance(child, CachedContainer) and child.height:
+                sizes[i] = child.preferred_height(
+                    available_width, available_height
+                ).preferred
+            else:
+                missing.add(i)
+        avg = int(sum(sizes.values()) / (len(sizes) or 1))
+        sizes.update(dict.fromkeys(missing, avg))
+        return [v for k, v in sorted(sizes.items())]
+
     @property
     def vertical_scroll(self) -> int:
         """The best guess at the absolute vertical scroll position."""
         return (
-            sum(list(self.known_sizes.values())[: self._selected_slice.start])
+            sum(self.known_sizes[: self._selected_slice.start])
             - self.selected_child_position
         )
 
@@ -592,7 +613,7 @@ class ScrollingContainer(Container):
     def vertical_scroll(self, value: int) -> None:
         """Set the absolute vertical scroll position."""
         self.selected_child_position = (
-            sum(list(self.known_sizes.values())[: self._selected_slice.start]) - value
+            sum(self.known_sizes[: self._selected_slice.start]) - value
         )
 
     def all_children(self) -> Sequence[Container]:
@@ -712,29 +733,6 @@ class ScrollingContainer(Container):
         else:
             self.selected_child_position = new_top
 
-        heights = [
-            self.get_child(index).height or 1 for index in range(len(self._children))
-        ]
-        # Do not allow bottom child to scroll above screen bottom
-        self.selected_child_position += max(
-            0,
-            self.last_write_position.height
-            - (self.selected_child_position + sum(heights[index:])),
-        )
-        # Do not allow top child to scroll below screen top
-        self.selected_child_position -= max(
-            0, self.selected_child_position - sum(heights[:index])
-        )
-
-    @property
-    def known_sizes(self) -> dict[int, int]:
-        """A dictionary mapping child indices to height values."""
-        sizes = {}
-        for i, child in enumerate(self._children):
-            if isinstance(child, CachedContainer) and child.height:
-                sizes[i] = child.height
-        return sizes
-
     def _scroll_up(self) -> None:
         """Scroll up one line: for compatibility with :py:class:`Window`."""
         self.scroll(1)
@@ -742,102 +740,3 @@ class ScrollingContainer(Container):
     def _scroll_down(self) -> None:
         """Scroll down one line: for compatibility with :py:class:`Window`."""
         self.scroll(-1)
-
-
-class PrintingContainer(Container):
-    """A container which displays all it's children in a vertical list."""
-
-    def __init__(
-        self,
-        children: Callable | Sequence[AnyContainer],
-        width: AnyDimension = None,
-        key_bindings: KeyBindingsBase | None = None,
-    ) -> None:
-        """Initiate the container."""
-        self.width = width
-        self.rendered = False
-        self._children = children
-        self.key_bindings = key_bindings
-
-    def get_key_bindings(self) -> KeyBindingsBase | None:
-        """Return the container's key bindings."""
-        return self.key_bindings
-
-    @property
-    def children(self) -> Sequence[AnyContainer]:
-        """Return the container's children."""
-        children = self._children() if callable(self._children) else self._children
-        return children or [Window()]
-
-    def get_children(self) -> list[Container]:
-        """Return a list of all child containers."""
-        return [to_container(child) for child in self.children]
-
-    def write_to_screen(
-        self,
-        screen: PtkScreen,
-        mouse_handlers: MouseHandlers,
-        write_position: WritePosition,
-        parent_style: str,
-        erase_bg: bool,
-        z_index: int | None,
-    ) -> None:
-        """Render the container to a `Screen` instance.
-
-        All children are rendered vertically in sequence.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        xpos = write_position.xpos
-        ypos = write_position.ypos
-
-        children = self.get_children()
-        for child in children:
-            height = child.preferred_height(write_position.width, 999999).preferred
-            child.write_to_screen(
-                screen,
-                mouse_handlers,
-                BoundedWritePosition(xpos, ypos, write_position.width, height),
-                parent_style,
-                erase_bg,
-                z_index,
-            )
-            ypos += height
-
-    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
-        """Return the preferred height, equal to the sum of the child heights."""
-        return Dimension(
-            min=1,
-            preferred=sum(
-                [
-                    c.preferred_height(width, max_available_height).preferred
-                    for c in self.get_children()
-                ]
-            ),
-        )
-
-    def preferred_width(self, max_available_width: int) -> Dimension:
-        """Calculate and returns the desired width for this container."""
-        if self.width is not None:
-            dim = to_dimension(self.width).preferred
-            return Dimension(max=dim, preferred=dim)
-        else:
-            return Dimension(max_available_width)
-
-    def reset(self) -> None:
-        """Reet the state of this container and all the children.
-
-        Does nothing as this container is used for dumping output.
-        """

euporie/core/log.py

@@ -340,7 +340,7 @@ class StdoutFormatter(FtFormatter):
 
 
 class stdout_to_log:
-    """A decorator which captures standard output and logs it."""
+    """A context manager which captures standard output and logs it."""
 
     def __init__(
         self, log: logging.Logger, output: str = "Literal['stdout','stderr']"
@@ -506,10 +506,7 @@ def setup_logs(config: Config | None = None) -> None:
 
         # Update log_config based on additional config dict provided
         if config.log_config:
-            import json
-
-            extra_config = json.loads(config.log_config)
-            dict_merge(log_config, extra_config)
+            dict_merge(log_config, config.log_config)
 
     # Configure the logger
     # Pytype used TypedDicts to validate the dictionary structure, but I cannot get

euporie/core/path.py

@@ -9,36 +9,72 @@ from typing import TYPE_CHECKING
 import upath
 from aiohttp.client_reqrep import ClientResponse
 from fsspec.implementations.http import HTTPFileSystem as FsHTTPFileSystem
+from fsspec.implementations.http import get_client
 from fsspec.registry import register_implementation as fs_register_implementation
 from upath import UPath
 
 if TYPE_CHECKING:
+    import asyncio
     from collections.abc import Mapping
     from os import PathLike
-    from typing import Any
+    from typing import Any, Callable
 
-
-log = logging.getLogger(__name__)
-
-
-# Monkey-patch `aiohttp` to not raise exceptions on non-200 responses
+    import aiohttp
 
 
-def _raise_for_status(self: ClientResponse) -> None:
-    """Monkey-patch :py:class:`aiohttp.ClientResponse` not to raise for any status."""
-
+log = logging.getLogger(__name__)
 
-setattr(ClientResponse, "raise_for_status", _raise_for_status)  # noqa B010
 
+class NoRaiseClientResponse(ClientResponse):
+    """An ``aiohttp`` client response which does not raise on >=400 status responses."""
 
-# Define and register non-raising HTTP filesystem implementation for fsspec
+    @property
+    def ok(self) -> bool:
+        """Returns ``True`` if ``status`` is probably renderable."""
+        return self.status not in {405}
 
 
 class HTTPFileSystem(FsHTTPFileSystem):
-    """A :py:class:`HTTPFileSystem` which does not raise exceptions on 404 errors."""
+    """A HTTP filesystem implementation which does not raise on errors."""
+
+    def __init__(
+        self,
+        simple_links: bool = True,
+        block_size: int | None = None,
+        same_scheme: bool = True,
+        size_policy: None = None,
+        cache_type: str = "bytes",
+        cache_options: dict[str, Any] | None = None,
+        asynchronous: bool = False,
+        loop: asyncio.AbstractEventLoop | None = None,
+        client_kwargs: dict[str, Any] | None = None,
+        get_client: Callable[..., aiohttp.ClientSession] = get_client,
+        encoded: bool = False,
+        **storage_options: Any,
+    ) -> None:
+        """Defaults to using :py:mod:`NoRaiseClientResponse` for responses."""
+        client_kwargs = {
+            "response_class": NoRaiseClientResponse,
+            **(client_kwargs or {}),
+        }
+        super().__init__(
+            simple_links=simple_links,
+            block_size=block_size,
+            same_scheme=same_scheme,
+            size_policy=size_policy,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            asynchronous=asynchronous,
+            loop=loop,
+            client_kwargs=client_kwargs,
+            get_client=get_client,
+            encoded=encoded,
+            **storage_options,
+        )
 
     def _raise_not_found_for_status(self, response: ClientResponse, url: str) -> None:
         """Do not raise an exception for 404 errors."""
+        response.raise_for_status()
 
 
 fs_register_implementation("http", HTTPFileSystem, clobber=True)
@@ -63,8 +99,15 @@ class UntitledPath(upath.core.UPath):
         return False
 
 
-def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
+def parse_path(path: str | PathLike, resolve: bool | None = None) -> Path:
     """Parse and resolve a path."""
+    if resolve is None:
+        from upath.implementations.http import HTTPPath
+
+        if isinstance(path, HTTPPath):
+            resolve = True
+        else:
+            resolve = False
     if not isinstance(path, Path):
         path = UPath(path)
     try:
@@ -76,4 +119,9 @@ def parse_path(path: str | PathLike, resolve: bool = True) -> Path:
             path = path.resolve()
         except (AttributeError, NotImplementedError, Exception):
             log.info("Path %s not resolvable", path)
+    else:
+        try:
+            path = path.absolute()
+        except NotImplementedError:
+            pass
     return path

euporie/core/style.py

@@ -141,6 +141,7 @@ IPYWIDGET_STYLE = [
     # ("ipywidget danger border right selection", "fg:ansibrightred"),
     # ("ipywidget danger border bottom selection", "fg:ansibrightred"),
     ("ipywidget text text-area", "fg:black bg:white"),
+    ("ipywidget text text-area disabled", "fg:#888888"),
     ("ipywidget text text-area focused", "fg:black bg:white"),
     ("ipywidget text placeholder", "fg:#AAAAAA bg:white"),
     ("ipywidget text border right", "fg:#E9E7E3"),
@@ -436,7 +437,7 @@ def build_style(
         # Logo
         "logo": "fg:#dd0000",
         # Pattern
-        "pattern": f"fg:{cp.bg.more(0.075)}",
+        "pattern": f"fg:{cp.bg.more(0.05)}",
         # Chrome
         "chrome": f"fg:{cp.fg.more(0.05)} bg:{cp.bg.more(0.05)}",
         "tab-padding": f"fg:{cp.bg.more(0.2)} bg:{cp.bg.base}",