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

euporie/core/layout/scroll.py

@@ -7,13 +7,13 @@ 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
@@ -26,10 +26,7 @@ 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,6 +64,9 @@ 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: float | None = None
 
@@ -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,8 +93,10 @@ 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()
+        if not children:
+            return
+        self.pre_rendered = 0.0
         incr = 1 / len(children)
         app = get_app()
 
@@ -264,8 +267,8 @@ class ScrollingContainer(Container):
                 if bottom_pos is not None:
                     n = max(
                         n,
-                        (bottom_pos + bottom_child.height + self.scrolling)
-                        - self.last_write_position.height,
+                        self.last_write_position.height
+                        - (bottom_pos + bottom_child.height + self.scrolling),
                     )
                     if (
                         bottom_pos + bottom_child.height + self.scrolling + n
@@ -362,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
 
@@ -415,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
@@ -442,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)):
@@ -551,14 +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
-
         # Mock up a WindowRenderInfo so we can draw a scrollbar margin
         self.render_info = WindowRenderInfo(
             window=cast("Window", self),
-            ui_content=UIContent(line_count=max(sum(self.known_sizes.values()), 1)),
+            ui_content=UIContent(line_count=max(sum(heights), 1)),
             horizontal_scroll=0,
             vertical_scroll=self.vertical_scroll,
             window_width=available_width,
@@ -577,11 +579,33 @@ class ScrollingContainer(Container):
         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
         )
 
@@ -589,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]:
@@ -709,34 +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 = {}
-        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:
         """Scroll up one line: for compatibility with :py:class:`Window`."""
         self.scroll(1)
@@ -744,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']"

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}",

euporie/core/suggest.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
-from collections import defaultdict
+from collections import defaultdict, deque
 from difflib import SequenceMatcher
-from functools import lru_cache
-from typing import TYPE_CHECKING
+from functools import lru_cache, partial
+from typing import TYPE_CHECKING, NamedTuple
 
 from prompt_toolkit.auto_suggest import AutoSuggest, ConditionalAutoSuggest, Suggestion
+from prompt_toolkit.cache import SimpleCache
 from prompt_toolkit.filters import to_filter
 
 if TYPE_CHECKING:
@@ -21,39 +23,86 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
-class HistoryAutoSuggest(AutoSuggest):
+class HistoryPosition(NamedTuple):
+    """Store position information for a history match."""
+
+    idx: int  # Index in history
+    context_start: int  # Position where context starts
+    context_end: int  # Position where context ends
+
+
+class SmartHistoryAutoSuggest(AutoSuggest):
     """Suggest line completions from a :class:`History` object."""
 
+    _context_lines = 10
+    _max_line_len = 200
+    _max_item_lines = 1000
+
     def __init__(self, history: History) -> None:
         """Set the kernel instance in initialization."""
         self.history = history
-        self.calculate_similarity = lru_cache(maxsize=1024)(self._calculate_similarity)
 
         self.n_texts = 0
-        self.n_lines = 0
-        self.prefix_dict: dict[str, dict[str, list[dict[str, int]]]] = defaultdict(
-            lambda: defaultdict(list)
+        self._processing_task: asyncio.Task | None = None
+        # Index storage
+        self.prefix_tree: dict[str, list[int]] = defaultdict(list)
+        self.suffix_data: list[tuple[str, HistoryPosition]] = []
+        # Caches
+        self.calculate_similarity = lru_cache(maxsize=128)(self._calculate_similarity)
+        self.match_cache: SimpleCache[tuple[str, int, int], Suggestion | None] = (
+            SimpleCache(maxsize=128)
         )
 
     def process_history(self) -> None:
+        """Schedule history processing if not already running."""
+        from euporie.notebook.current import get_app
+
+        if self._processing_task is not None and not self._processing_task.done():
+            return
+
+        # Schedule the actual processing to run when idle
+        self._processing_task = get_app().create_background_task(
+            self._process_history_async()
+        )
+
+    async def _process_history_async(self) -> None:
         """Process the entire history and store in prefix_dict."""
         texts = self.history._loaded_strings
-        if texts := texts[: len(texts) - self.n_texts]:
-            n_lines = self.n_lines
-            prefix_dict = self.prefix_dict
-            for i, text in enumerate(reversed(texts)):
-                for line in text.strip().splitlines():
-                    n_lines += 1
-                    line = line.strip()
-                    for j in range(1, len(line)):
-                        prefix, suffix = line[:j], line[j:]
-                        prefix_dict[prefix][suffix].append(
-                            {"index": -1 - i, "line": n_lines}
-                        )
-                        # for k in range(1, len(prefix)):
-                        #     prefix_dict[prefix[-k:]] = prefix_dict[prefix]
-            self.n_lines = n_lines
-            self.n_texts += len(texts)
+        # Only process new history items
+        if not (texts := texts[: -self.n_texts or None]):
+            return
+
+        prefix_tree = self.prefix_tree
+        suffix_data = self.suffix_data
+        context_lines = self._context_lines
+        max_item_lines = self._max_item_lines
+        max_line_len = self._max_line_len
+
+        for i, text in enumerate(texts):
+            # Add tiny sleep to prevent blocking
+            if i > 1:
+                await asyncio.sleep(0.001)
+
+            lines = text.splitlines(keepends=True)
+            # Calculate positions of newlines
+            line_pos = [0]
+            for line in lines:
+                line_pos.append(line_pos[-1] + len(line))
+            # Index each line
+            for j, line in enumerate(lines[:max_item_lines]):
+                context_start = line_pos[max(0, j - context_lines)]
+                context_end = line_pos[min(j + context_lines, len(lines))]
+                hist_pos = HistoryPosition(
+                    idx=i, context_start=context_start, context_end=context_end
+                )
+                line = line.strip()
+                # Create prefix/suffix combinations
+                for k in range(min(len(line), max_line_len)):
+                    prefix, suffix = line[:k], line[k:]
+                    prefix_tree[prefix].append(len(suffix_data))
+                    suffix_data.append((suffix, hist_pos))
+
+        self.n_texts += len(texts)
 
     def _calculate_similarity(self, text_1: str, text_2: str) -> float:
         """Calculate and cache the similarity between two texts."""
@@ -61,79 +110,111 @@ class HistoryAutoSuggest(AutoSuggest):
 
     def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
         """Get a line completion suggestion."""
-        self.process_history()
+        # Only return suggestions if cursor is at end of line
+        if not document.is_cursor_at_the_end_of_line:
+            return None
 
         line = document.current_line.lstrip()
-        if not line:
+
+        # Skip empty and very long lines
+        if not line or len(line) > self._max_line_len:
             return None
 
-        suffixes = self.prefix_dict[line]
+        # Schedule indexing any new history items
+        self.process_history()
 
-        texts = self.history._loaded_strings
-        n_lines = self.n_lines
+        # Find matches
+        key = line, hash(document.text), len(self.suffix_data)
+        return self.match_cache.get(key, partial(self._find_match, line, document.text))
 
+    def _find_match(self, line: str, document_text: str) -> Suggestion | None:
+        if not (suffix_indices := self.prefix_tree[line]):
+            return None
+
+        texts = self.history._loaded_strings
         best_score = 0.0
-        best_suffix = ""
+        best_suffix = None
 
         # Rank candidates
-        max_count = max([1, *(len(x) for x in suffixes.values())])
-        for suffix, instances in suffixes.items():
-            count = len(instances)
-            for instance in instances:
-                text = texts[instance["index"]]
-                context_similarity = self.calculate_similarity(document.text, text)
+        max_count = max(1, len(suffix_indices))
+        suffix_groups: dict[str, list[HistoryPosition]] = defaultdict(list)
+
+        # Group suffixes and their positions
+        for idx in suffix_indices:
+            suffix, pos = self.suffix_data[idx]
+            suffix_groups[suffix].append(pos)
+
+        # Evaluate each unique suffix
+        for suffix, positions in suffix_groups.items():
+            count = len(positions)
+            for pos in positions[:10]:
+                # Get the text using the stored positions
+                text = texts[pos.idx]
+                context = text[pos.context_start : pos.context_end]
+                context_similarity = self.calculate_similarity(document_text, context)
                 score = (
-                    0
-                    # Similarity of prefix to line
-                    # 0.333 * len(line) / len(match.group("prefix"))
-                    # NUmber of instances in history
-                    + 0.3 * count / max_count
+                    # Number of instances in history
+                    0.3 * count / max_count
                     # Recentness
-                    + 0.3 * instance["line"] / n_lines
+                    + 0.3 * pos.idx / len(texts)
                     # Similarity of context to document
                     + 0.4 * context_similarity
                 )
-                # log.debug("%s %r", score, suffix)
-                if score > 0.95:
+
+                if score > 0.9:
                     return Suggestion(suffix)
                 if score > best_score:
                     best_score = score
                     best_suffix = suffix
+
         if best_suffix:
             return Suggestion(best_suffix)
         return None
 
 
-# class KernelAutoSuggest(AutoSuggest):
-#     """Suggest line completions from kernel history."""
-
-#     def __init__(self, kernel: Kernel) -> None:
-#         """Set the kernel instance in initialization."""
-#         self.kernel = kernel
-
-#     def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
-#         """Doe nothing."""
-#         return None
-
-#     async def get_suggestion_async(
-#         self, buff: Buffer, document: Document
-#     ) -> Suggestion | None:
-#         """Return suggestions based on matching kernel history."""
-#         line = document.current_line.strip()
-#         if line:
-#             suggestions = await self.kernel.history_(f"*{line}*")
-#             log.debug("Suggestor got suggestions %s", suggestions)
-#             if suggestions:
-#                 _, _, text = suggestions[0]
-#                 # Find matching line
-#                 for hist_line in text.split("\n"):
-#                     hist_line = hist_line.strip()
-#                     if hist_line.startswith(line):
-#                         # Return from the match to end from the history line
-#                         suggestion = hist_line[len(line) :]
-#                         log.debug("Suggesting %s", suggestion)
-#                         return Suggestion(suggestion)
-#         return None
+class SimpleHistoryAutoSuggest(AutoSuggest):
+    """Suggest line completions from a :class:`History` object."""
+
+    def __init__(self, history: History, cache_size: int = 100_000) -> None:
+        """Set the kernel instance in initialization."""
+        self.history = history
+
+        self.cache_size = cache_size
+        self.cache_keys: deque[str] = deque()
+        self.cache: dict[str, Suggestion] = {}
+
+    def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
+        """Get a line completion suggestion."""
+        result: Suggestion | None = None
+        line = document.current_line.lstrip()
+        if line:
+            if line in self.cache:
+                result = self.cache[line]
+            else:
+                result = self.lookup_suggestion(line)
+                if result:
+                    if len(self.cache) > self.cache_size:
+                        key_to_remove = self.cache_keys.popleft()
+                        if key_to_remove in self.cache:
+                            del self.cache[key_to_remove]
+
+                    self.cache_keys.append(line)
+                    self.cache[line] = result
+        return result
+
+    def lookup_suggestion(self, line: str) -> Suggestion | None:
+        """Find the most recent matching line in the history."""
+        # Loop history, most recent item first
+        for text in self.history._loaded_strings:
+            if line in text:
+                # Loop over lines of item in reverse order
+                for hist_line in text.splitlines()[::-1]:
+                    hist_line = hist_line.strip()
+                    if hist_line.startswith(line):
+                        # Return from the match to end from the history line
+                        suggestion = hist_line[len(line) :]
+                        return Suggestion(suggestion)
+        return None
 
 
 class ConditionalAutoSuggestAsync(ConditionalAutoSuggest):

euporie/core/tabs/__init__.py

@@ -29,5 +29,15 @@ class TabRegistryEntry:
         """Sort by weight."""
         return self.weight < other.weight
 
+    def __hash__(self) -> int:
+        """Make the class hashable based on its path."""
+        return hash(self.path)
+
+    def __eq__(self, other: object) -> bool:
+        """Compare TabRegistryEntry objects based on their path."""
+        if not isinstance(other, TabRegistryEntry):
+            return NotImplemented
+        return self.path == other.path
+
 
 _TAB_REGISTRY: list[TabRegistryEntry] = []