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

euporie/core/layout/containers.py

@@ -3,35 +3,50 @@
 from __future__ import annotations
 
 import logging
-from functools import lru_cache, partial
+from functools import partial
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application.current import get_app
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.data_structures import Point
-from prompt_toolkit.layout import containers
-from prompt_toolkit.layout.containers import WindowAlign, WindowRenderInfo
+from prompt_toolkit.layout import containers as ptk_containers
+from prompt_toolkit.layout.containers import (
+    Container,
+    HorizontalAlign,
+    VerticalAlign,
+    WindowAlign,
+    WindowRenderInfo,
+)
+from prompt_toolkit.layout.controls import DummyControl as PtkDummyControl
 from prompt_toolkit.layout.controls import (
     FormattedTextControl,
     UIContent,
     fragment_list_width,
     to_formatted_text,
 )
-from prompt_toolkit.layout.dimension import sum_layout_dimensions
+from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import _CHAR_CACHE
 from prompt_toolkit.layout.utils import explode_text_fragments
-from prompt_toolkit.mouse_events import MouseEvent
-from prompt_toolkit.utils import get_cwidth, take_using_weights, to_str
+from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
+from prompt_toolkit.utils import get_cwidth, to_str
 
 from euporie.core.data_structures import DiInt
+from euporie.core.layout.controls import DummyControl
 from euporie.core.layout.screen import BoundedWritePosition
 
 if TYPE_CHECKING:
-    from typing import Callable
+    from typing import Any, Callable, Sequence
 
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
-    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
-    from prompt_toolkit.layout.containers import Float
-    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.layout.containers import (
+        AnyContainer,
+        AnyDimension,
+        Float,
+    )
     from prompt_toolkit.layout.margins import Margin
     from prompt_toolkit.layout.mouse_handlers import MouseHandlers
     from prompt_toolkit.layout.screen import Screen, WritePosition
@@ -40,9 +55,49 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
-class HSplit(containers.HSplit):
+class HSplit(ptk_containers.HSplit):
     """Several layouts, one stacked above/under the other."""
 
+    _pad_window: Window
+
+    def __init__(
+        self,
+        children: Sequence[AnyContainer],
+        window_too_small: Container | None = None,
+        align: VerticalAlign = VerticalAlign.JUSTIFY,
+        padding: AnyDimension = 0,
+        padding_char: str | None = None,
+        padding_style: str = "",
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        z_index: int | None = None,
+        modal: bool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        style: str | Callable[[], str] = "",
+    ) -> None:
+        """Initialize the HSplit with a cache."""
+        super().__init__(
+            children=children,
+            window_too_small=window_too_small,
+            align=align,
+            padding=padding,
+            padding_char=padding_char,
+            padding_style=padding_style,
+            width=width,
+            height=height,
+            z_index=z_index,
+            modal=modal,
+            key_bindings=key_bindings,
+            style=style,
+        )
+        _split_cache_getter = super()._divide_heights
+        self._split_cache: FastDictCache[
+            tuple[int, WritePosition], list[int] | None
+        ] = FastDictCache(lambda rc, wp: _split_cache_getter(wp), size=100)
+
+    def _divide_heights(self, write_position: WritePosition) -> list[int] | None:
+        return self._split_cache[get_app().render_counter, write_position]
+
     def write_to_screen(
         self,
         screen: Screen,
@@ -132,68 +187,85 @@ class HSplit(containers.HSplit):
                     z_index,
                 )
 
-    def _divide_heights(self, write_position: WritePosition) -> list[int] | None:
-        """Return the heights for all rows, or None when there is not enough space."""
-        if not self.children:
-            return []
-
-        # Calculate heights.
-        width = write_position.width
-        height = write_position.height
-
-        return _get_divided_heights(
-            width,
-            height,
-            tuple(c.preferred_height(width, height) for c in self._all_children),
-        )
-
-
-@lru_cache(maxsize=2048)
-def _get_divided_heights(
-    width: int, height: int, dimensions: tuple[Dimension, ...]
-) -> list[int] | None:
-    # Sum dimensions
-    sum_dimensions = sum_layout_dimensions(list(dimensions))
-
-    # If there is not enough space for both.
-    # Don't do anything.
-    if sum_dimensions.min > height:
-        return None
-
-    # Find optimal sizes. (Start with minimal size, increase until we cover
-    # the whole height.)
-    sizes = [d.min for d in dimensions]
-
-    child_generator = take_using_weights(
-        items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]
-    )
-
-    i = next(child_generator)
-
-    # Increase until we meet at least the 'preferred' size.
-    preferred_stop = min(height, sum_dimensions.preferred)
-    preferred_dimensions = [d.preferred for d in dimensions]
+    @property
+    def pad_window(self) -> Window:
+        """Create a single instance of the padding window."""
+        try:
+            return self._pad_window
+        except AttributeError:
+            self._pad_window = Window(
+                height=self.padding,
+                char=self.padding_char,
+                style=self.padding_style,
+            )
+            return self._pad_window
+
+    @property
+    def _all_children(self) -> list[Container]:
+        """List of child objects, including padding."""
+
+        def get() -> list[Container]:
+            result: list[Container] = []
+            # Padding Top.
+            if self.align in (VerticalAlign.CENTER, VerticalAlign.BOTTOM):
+                result.append(Window(width=Dimension(preferred=0)))
+            # The children with padding.
+            for child in self.children:
+                result.append(child)
+                result.append(self.pad_window)
+            if result:
+                result.pop()
+            # Padding right.
+            if self.align in (VerticalAlign.CENTER, VerticalAlign.TOP):
+                result.append(Window(width=Dimension(preferred=0)))
+            return result
 
-    while sum(sizes) < preferred_stop:
-        if sizes[i] < preferred_dimensions[i]:
-            sizes[i] += 1
-        i = next(child_generator)
+        return self._children_cache.get(tuple(self.children), get)
 
-    # Increase until we use all the available space. (or until "max")
-    if not get_app().is_done:
-        max_stop = min(height, sum_dimensions.max)
-        max_dimensions = [d.max for d in dimensions]
 
-        while sum(sizes) < max_stop:
-            if sizes[i] < max_dimensions[i]:
-                sizes[i] += 1
-            i = next(child_generator)
+class VSplit(ptk_containers.VSplit):
+    """Several layouts, one stacked left/right of the other."""
 
-    return sizes
+    _pad_window: Window
 
+    def __init__(
+        self,
+        children: Sequence[AnyContainer],
+        window_too_small: Container | None = None,
+        align: HorizontalAlign = HorizontalAlign.JUSTIFY,
+        padding: AnyDimension = 0,
+        padding_char: str | None = None,
+        padding_style: str = "",
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        z_index: int | None = None,
+        modal: bool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        style: str | Callable[[], str] = "",
+    ) -> None:
+        """Initialize the VSplit with a cache."""
+        super().__init__(
+            children=children,
+            window_too_small=window_too_small,
+            align=align,
+            padding=padding,
+            padding_char=padding_char,
+            padding_style=padding_style,
+            width=width,
+            height=height,
+            z_index=z_index,
+            modal=modal,
+            key_bindings=key_bindings,
+            style=style,
+        )
+        _split_cache_getter = super()._divide_widths
+        self._split_cache: FastDictCache[tuple[int, int], list[int] | None] = (
+            FastDictCache(lambda rc, w: _split_cache_getter(w), size=100)
+        )
 
-class VSplit(containers.VSplit):
-    """Several layouts, one stacked left/right of the other."""
+    def _divide_widths(self, width: int) -> list[int] | None:
+        """Calculate and cache widths for all columns."""
+        return self._split_cache[get_app().render_counter, width]
 
     def write_to_screen(
         self,
@@ -294,10 +366,53 @@ class VSplit(containers.VSplit):
                 z_index,
             )
 
+    @property
+    def pad_window(self) -> Window:
+        """Create a single instance of the padding window."""
+        try:
+            return self._pad_window
+        except AttributeError:
+            self._pad_window = Window(
+                width=self.padding,
+                char=self.padding_char,
+                style=self.padding_style,
+            )
+            return self._pad_window
+
+    @property
+    def _all_children(self) -> list[Container]:
+        """List of child objects, including padding."""
+
+        def get() -> list[Container]:
+            result: list[Container] = []
+
+            # Padding left.
+            if self.align in (HorizontalAlign.CENTER, HorizontalAlign.RIGHT):
+                result.append(Window(width=Dimension(preferred=0)))
+            # The children with padding.
+            for child in self.children:
+                result.append(child)
+                result.append(self.pad_window)
+            if result:
+                result.pop()
+            # Padding right.
+            if self.align in (HorizontalAlign.CENTER, HorizontalAlign.LEFT):
+                result.append(Window(width=Dimension(preferred=0)))
+
+            return result
 
-class Window(containers.Window):
+        return self._children_cache.get(tuple(self.children), get)
+
+
+class Window(ptk_containers.Window):
     """Container that holds a control."""
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize `Windows`, updating the default control for empty windows."""
+        super().__init__(*args, **kwargs)
+        if isinstance(self.content, PtkDummyControl):
+            self.content = DummyControl()
+
     def write_to_screen(
         self,
         screen: Screen,
@@ -856,8 +971,55 @@ class Window(containers.Window):
         else:
             new_screen.fill_area(write_position, "class:last-line", after=True)
 
+    def _mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Mouse handler. Called when the UI control doesn't handle this particular event.
+
+        Return `NotImplemented` if nothing was done as a consequence of this
+        key binding (no UI invalidate required in that case).
+        """
+        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+            return self._scroll_down()
+        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+            return self._scroll_up()
+
+        return NotImplemented
+
+    def _scroll_down(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window down."""
+        info = self.render_info
+
+        if info is None:
+            return NotImplemented
+
+        if self.vertical_scroll < info.content_height - info.window_height:
+            if info.cursor_position.y <= info.configured_scroll_offsets.top:
+                self.content.move_cursor_down()
+            self.vertical_scroll += 1
+            return None
+
+        return NotImplemented
+
+    def _scroll_up(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window up."""
+        info = self.render_info
+
+        if info is None:
+            return NotImplemented
+
+        if info.vertical_scroll > 0:
+            # TODO: not entirely correct yet in case of line wrapping and long lines.
+            if (
+                info.cursor_position.y
+                >= info.window_height - 1 - info.configured_scroll_offsets.bottom
+            ):
+                self.content.move_cursor_up()
+            self.vertical_scroll -= 1
+            return None
+
+        return NotImplemented
+
 
-class FloatContainer(containers.FloatContainer):
+class FloatContainer(ptk_containers.FloatContainer):
     """A `FloatContainer` which uses :py`BoundedWritePosition`s."""
 
     def _draw_float(
@@ -1005,7 +1167,7 @@ class FloatContainer(containers.FloatContainer):
                 )
 
 
-containers.HSplit = HSplit  # type: ignore[misc]
-containers.VSplit = VSplit  # type: ignore[misc]
-containers.Window = Window  # type: ignore[misc]
-containers.FloatContainer = FloatContainer  # type: ignore[misc]
+ptk_containers.HSplit = HSplit  # type: ignore[misc]
+ptk_containers.VSplit = VSplit  # type: ignore[misc]
+ptk_containers.Window = Window  # type: ignore[misc]
+ptk_containers.FloatContainer = FloatContainer  # type: ignore[misc]

euporie/core/layout/decor.py

@@ -280,9 +280,9 @@ class FocusedStyle(Container):
 
                 return wrapped_mouse_handler
 
-            mouse_handler_wrappers: FastDictCache[
-                tuple[Callable], MouseHandler
-            ] = FastDictCache(get_value=_wrap_mouse_handler)
+            mouse_handler_wrappers: FastDictCache[tuple[Callable], MouseHandler] = (
+                FastDictCache(get_value=_wrap_mouse_handler)
+            )
             for y in range(y_min, y_max):
                 row = mouse_handlers.mouse_handlers[y]
                 for x in range(x_min, x_max):

euporie/core/layout/print.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
+from prompt_toolkit.application.current import get_app
 from prompt_toolkit.layout.containers import (
     Container,
     Window,
@@ -42,8 +43,9 @@ class PrintingContainer(Container):
     ) -> None:
         """Initiate the container."""
         self.width = width
-        self.rendered = False
         self._children = children
+        self._render_count = -1
+        self._cached_children: Sequence[AnyContainer] | None = None
         self.key_bindings = key_bindings
 
     def get_key_bindings(self) -> KeyBindingsBase | None:
@@ -53,7 +55,17 @@ class PrintingContainer(Container):
     @property
     def children(self) -> Sequence[AnyContainer]:
         """Return the container's children."""
-        children = self._children() if callable(self._children) else self._children
+        # Only load the children from a callable once per render cycle
+        if callable(self._children):
+            if (
+                self._cached_children is None
+                or self._render_count != get_app().render_counter
+            ):
+                self._cached_children = self._children()
+                self._render_count = get_app().render_counter
+            children = self._cached_children
+        else:
+            children = self._children
         return children or [Window()]
 
     def get_children(self) -> list[Container]:

euporie/core/layout/scroll.py

@@ -284,25 +284,19 @@ class ScrollingContainer(Container):
         def wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
             response: NotImplementedOrNone = NotImplemented
 
-            if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-                response = self.scroll(-1)
-            elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-                response = self.scroll(1)
-            elif callable(handler):
+            if callable(handler):
                 response = handler(mouse_event)
 
+            if response is NotImplemented:
+                if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+                    response = self.scroll(-1)
+                elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+                    response = self.scroll(1)
+
             # Refresh the child if there was a response
             if response is None:
                 return response
 
-            # This relies on windows returning NotImplemented when scrolled
-            # to the start or end
-            # if response is NotImplemented:
-            #     if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
-            #         response = self.scroll(-1)
-            #     elif mouse_event.event_type == MouseEventType.SCROLL_UP:
-            #         response = self.scroll(1)
-
             # Select the clicked child if clicked
             if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
                 if child:
@@ -480,10 +474,10 @@ class ScrollingContainer(Container):
                 )
                 for y in range(ypos + line, ypos + available_height):
                     for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][
-                            x
-                        ] = self._mouse_handler_wrapper(
-                            mouse_handlers.mouse_handlers[y][x]
+                        mouse_handlers.mouse_handlers[y][x] = (
+                            self._mouse_handler_wrapper(
+                                mouse_handlers.mouse_handlers[y][x]
+                            )
                         )
         # Blit children above the selected that are on screen
         line = self.selected_child_position
@@ -525,10 +519,10 @@ class ScrollingContainer(Container):
                 )
                 for y in range(ypos, ypos + line):
                     for x in range(xpos, xpos + available_width):
-                        mouse_handlers.mouse_handlers[y][
-                            x
-                        ] = self._mouse_handler_wrapper(
-                            mouse_handlers.mouse_handlers[y][x]
+                        mouse_handlers.mouse_handlers[y][x] = (
+                            self._mouse_handler_wrapper(
+                                mouse_handlers.mouse_handlers[y][x]
+                            )
                         )
 
         # Dont bother drawing floats