euporie 2.8.4__py3-none-any.whl → 2.8.6__py3-none-any.whl

euporie/core/layout/cache.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from functools import lru_cache
+from functools import cache
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.data_structures import Point
@@ -17,7 +17,7 @@ from prompt_toolkit.layout.layout import walk
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
 from prompt_toolkit.mouse_events import MouseEvent
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 from euporie.core.data_structures import DiInt
 from euporie.core.layout.screen import BoundedWritePosition, Screen
 
@@ -313,7 +313,7 @@ class CachedContainer(Container):
         screen.visible_windows_to_write_positions.update(new_wps)
         screen.height = max(screen.height, self.screen.height)
 
-        @lru_cache(maxsize=None)
+        @cache
         def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
             def _wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
                 # Modify mouse events to reflect position of content

euporie/core/layout/containers.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from functools import partial
+from functools import lru_cache, partial
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application.current import get_app
@@ -35,7 +35,8 @@ from euporie.core.layout.controls import DummyControl
 from euporie.core.layout.screen import BoundedWritePosition
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Sequence
+    from collections.abc import Sequence
+    from typing import Any, Callable
 
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
     from prompt_toolkit.key_binding.key_bindings import (
@@ -55,6 +56,42 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
+@lru_cache(maxsize=None)
+class DummyContainer(Container):
+    """Base class for user interface layout."""
+
+    def __init__(self, width: int = 0, height: int = 0) -> None:
+        """Define width and height if any."""
+        self.width = width
+        self.height = height
+
+    def reset(self) -> None:
+        """Reset the state of this container (does nothing)."""
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return a zero-width dimension."""
+        return Dimension.exact(self.width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return a zero-height dimension."""
+        return Dimension.exact(self.height)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Write the actual content to the screen. Does nothing."""
+
+    def get_children(self) -> list[Container]:
+        """Return an empty list of child :class:`.Container` objects."""
+        return []
+
+
 class HSplit(ptk_containers.HSplit):
     """Several layouts, one stacked above/under the other."""
 
@@ -76,6 +113,8 @@ class HSplit(ptk_containers.HSplit):
         style: str | Callable[[], str] = "",
     ) -> None:
         """Initialize the HSplit with a cache."""
+        if window_too_small is None:
+            window_too_small = DummyContainer()
         super().__init__(
             children=children,
             window_too_small=window_too_small,
@@ -244,6 +283,8 @@ class VSplit(ptk_containers.VSplit):
         style: str | Callable[[], str] = "",
     ) -> None:
         """Initialize the VSplit with a cache."""
+        if window_too_small is None:
+            window_too_small = DummyContainer()
         super().__init__(
             children=children,
             window_too_small=window_too_small,
@@ -423,17 +464,20 @@ class Window(ptk_containers.Window):
         z_index: int | None,
     ) -> None:
         """Write window to screen."""
-        assert isinstance(write_position, BoundedWritePosition)
         # If dont_extend_width/height was given, then reduce width/height in
         # WritePosition, if the parent wanted us to paint in a bigger area.
         # (This happens if this window is bundled with another window in a
         # HSplit/VSplit, but with different size requirements.)
+        if isinstance(write_position, BoundedWritePosition):
+            bbox = write_position.bbox
+        else:
+            bbox = DiInt(0, 0, 0, 0)
         write_position = BoundedWritePosition(
             xpos=write_position.xpos,
             ypos=write_position.ypos,
             width=write_position.width,
             height=write_position.height,
-            bbox=write_position.bbox,
+            bbox=bbox,
         )
 
         if self.dont_extend_width():

euporie/core/layout/decor.py

@@ -15,8 +15,8 @@ from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import Char, Screen, WritePosition
 from prompt_toolkit.mouse_events import MouseEventType
 
+from euporie.core.app.current import get_app
 from euporie.core.border import ThinLine
-from euporie.core.current import get_app
 from euporie.core.style import ColorPaletteColor
 
 if TYPE_CHECKING:
@@ -341,7 +341,7 @@ class DropShadow(Container):
     ) -> None:
         """Draw the wrapped container with the additional style."""
         attr_cache = self.renderer._attrs_for_style
-        if attr_cache is not None:
+        if attr_cache is not None and self.amount:
             ypos = write_position.ypos
             xpos = write_position.xpos
             amount = self.amount

euporie/core/layout/mouse.py

@@ -13,7 +13,7 @@ from prompt_toolkit.layout.containers import (
 )
 from prompt_toolkit.mouse_events import MouseEventType
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 
 if TYPE_CHECKING:
     from typing import Callable

euporie/core/layout/print.py

@@ -16,7 +16,8 @@ from prompt_toolkit.layout.dimension import Dimension, to_dimension
 from euporie.core.layout.screen import BoundedWritePosition
 
 if TYPE_CHECKING:
-    from typing import Callable, Sequence
+    from collections.abc import Sequence
+    from typing import Callable
 
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,

euporie/core/layout/scroll.py

@@ -1,7 +1,8 @@
-"""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
 
@@ -20,10 +21,10 @@ 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 typing import Callable, Literal, Sequence
+    from collections.abc import Sequence
+    from typing import Callable, Literal
 
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
@@ -43,6 +44,8 @@ log = logging.getLogger(__name__)
 class ScrollingContainer(Container):
     """A scrollable container which renders only the currently visible children."""
 
+    render_info: WindowRenderInfo | None
+
     def __init__(
         self,
         children: Callable[[], Sequence[AnyContainer]] | Sequence[AnyContainer],
@@ -65,7 +68,7 @@ class ScrollingContainer(Container):
         self._child_cache: dict[int, CachedContainer] = {}
         self._children: list[CachedContainer] = []
         self.refresh_children = True
-        self.pre_rendered = 0.0
+        self.pre_rendered: float | None = None
 
         self._selected_slice = slice(
             0, 1
@@ -89,23 +92,33 @@ class ScrollingContainer(Container):
 
     def pre_render_children(self, width: int, height: int) -> None:
         """Render all unrendered children in a background thread."""
+        self.pre_rendered = 0.0
+        children = self.all_children()
+        incr = 1 / len(children)
+        app = get_app()
+
+        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()
 
-        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()
+        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."""
@@ -234,7 +247,6 @@ class ScrollingContainer(Container):
                 :py:const:`None`
 
         """
-        # self.refresh_children = True
         if n > 0:
             if (
                 min(self.visible_indices) == 0
@@ -252,8 +264,8 @@ class ScrollingContainer(Container):
                 if bottom_pos is not None:
                     n = max(
                         n,
-                        self.last_write_position.height
-                        - (bottom_pos + bottom_child.height + self.scrolling),
+                        (bottom_pos + bottom_child.height + self.scrolling)
+                        - self.last_write_position.height,
                     )
                     if (
                         bottom_pos + bottom_child.height + self.scrolling + n
@@ -362,9 +374,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] = []
@@ -546,19 +555,10 @@ class ScrollingContainer(Container):
         # 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(self.known_sizes.values()), 1)),
             horizontal_scroll=0,
             vertical_scroll=self.vertical_scroll,
             window_width=available_width,
@@ -574,7 +574,7 @@ 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
@@ -727,9 +727,14 @@ class ScrollingContainer(Container):
     def known_sizes(self) -> dict[int, int]:
         """A dictionary mapping child indices to height values."""
         sizes = {}
+        missing = set()
         for i, child in enumerate(self._children):
             if isinstance(child, CachedContainer) and child.height:
                 sizes[i] = child.height
+            else:
+                missing.add(i)
+        avg = int(sum(sizes.values()) / len(sizes))
+        sizes.update(dict.fromkeys(missing, avg))
         return sizes
 
     def _scroll_up(self) -> None:

euporie/core/log.py

@@ -20,12 +20,10 @@ from prompt_toolkit.renderer import (
 from prompt_toolkit.shortcuts.utils import print_formatted_text
 from prompt_toolkit.styles.pygments import style_from_pygments_cls
 from prompt_toolkit.styles.style import Style, merge_styles
-from pygments.styles import get_style_by_name
 
-from euporie.core.config import add_setting
 from euporie.core.ft.utils import indent, lex, wrap
 from euporie.core.io import PseudoTTY
-from euporie.core.style import LOG_STYLE
+from euporie.core.style import LOG_STYLE, get_style_by_name
 from euporie.core.utils import dict_merge
 
 if TYPE_CHECKING:
@@ -42,6 +40,65 @@ log = logging.getLogger(__name__)
 LOG_QUEUE: deque = deque(maxlen=1000)
 
 
+class BufferedLogs(logging.Handler):
+    """A handler that collects log records and replays them on exit."""
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        """Initialize the collector.
+
+        Args:
+            logger: Logger to collect from and replay to. If None, uses root logger.
+        """
+        super().__init__()
+        self.records: list[logging.LogRecord] = []
+        self._logger = logger or logging.getLogger()
+        self._original_handlers: list[logging.Handler] = []
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Store the log record."""
+        self.records.append(record)
+
+    def replay(self) -> None:
+        """Replay collected logs through the original logger."""
+        for record in self.records:
+            if record.exc_info:
+                # Create a new record to avoid issues with stale exc_info
+                record = logging.LogRecord(
+                    record.name,
+                    record.levelno,
+                    record.pathname,
+                    record.lineno,
+                    record.msg,
+                    record.args,
+                    record.exc_info,
+                    record.funcName,
+                )
+            self._logger.handle(record)
+
+    def __enter__(self) -> BufferedLogs:
+        """Store and replace the log handlers."""
+        # Save and remove existing handlers
+        self._original_handlers = self._logger.handlers[:]
+        self._logger.handlers.clear()
+        # Add ourselves as the only handler
+        self._logger.addHandler(self)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        """Restore the original handlers."""
+        # Remove ourselves
+        self._logger.removeHandler(self)
+        # Restore original handlers
+        self._logger.handlers = self._original_handlers
+        # Replay collected records through original handlers
+        self.replay()
+
+
 class FtFormatter(logging.Formatter):
     """Base class for formatted text logging formatter."""
 
@@ -240,12 +297,17 @@ class StdoutFormatter(FtFormatter):
         msg_pad = len(date) + 10
         msg_pad_1st_line = msg_pad + 1 + len(ref)
 
-        msg_lines = textwrap.wrap(
-            record.message,
-            width=width,
-            initial_indent=" " * msg_pad_1st_line,
-            subsequent_indent=" " * msg_pad,
-        )
+        msg_lines = "\n".join(
+            textwrap.wrap(
+                record.message,
+                width=width,
+                initial_indent=" " * msg_pad_1st_line,
+                replace_whitespace=False,
+            )
+        ).split("\n")
+        subsequent_indent = " " * msg_pad
+        for i in range(1, len(msg_lines)):
+            msg_lines[i] = f"{subsequent_indent}{msg_lines[i]}"
 
         output: StyleAndTextTuples = [
             ("class:pygments.literal.date", date),
@@ -416,7 +478,7 @@ def setup_logs(config: Config | None = None) -> None:
     }
 
     if config is not None:
-        log_file = config.get("log_file", "")
+        log_file = config.log_file or ""
         log_file_is_stdout = log_file in {"-", "/dev/stdout"}
         log_level = config.log_level.upper()
 
@@ -433,25 +495,18 @@ def setup_logs(config: Config | None = None) -> None:
         # Configure stdout handler
         if log_file_is_stdout:
             stdout_level = log_level
-        elif (app_cls := config.app_cls) is not None and (
-            log_stdout_level := app_cls.log_stdout_level
-        ):
-            stdout_level = log_stdout_level.upper()
         else:
-            stdout_level = "CRITICAL"
+            stdout_level = config.log_level_stdout.upper()
         log_config["handlers"]["stdout"]["level"] = stdout_level
-        if syntax_theme := config.get("syntax_theme"):
+        if syntax_theme := config.syntax_theme:
             log_config["handlers"]["stdout"]["pygments_theme"] = syntax_theme
 
         # Configure euporie logger
-        log_config["loggers"]["euporie"]["level"] = config.log_level.upper()
+        log_config["loggers"]["euporie"]["level"] = log_level
 
         # 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
@@ -463,46 +518,3 @@ def setup_logs(config: Config | None = None) -> None:
 
     # Log uncaught exceptions
     sys.excepthook = handle_exception
-
-
-# ################################### Settings ########################################
-
-
-add_setting(
-    name="log_file",
-    flags=["--log-file"],
-    nargs="?",
-    default="",
-    type_=str,
-    title="the log file path",
-    help_="File path for logs",
-    description="""
-        When set to a file path, the log output will be written to the given path.
-        If no value is given output will be sent to the standard output.
-    """,
-)
-
-add_setting(
-    name="log_level",
-    flags=["--log-level"],
-    type_=str,
-    default="warning",
-    title="the log level",
-    help_="Set the log level",
-    choices=["debug", "info", "warning", "error", "critical"],
-    description="""
-        When set, logging events at the given level are emitted.
-    """,
-)
-
-add_setting(
-    name="log_config",
-    flags=["--log-config"],
-    type_=str,
-    default=None,
-    title="additional logging configuration",
-    help_="Additional logging configuration",
-    description="""
-        A JSON string specifying additional logging configuration.
-    """,
-)