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

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

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from importlib import import_module
+from pkgutil import resolve_name
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -23,13 +23,21 @@ class TabRegistryEntry:
     @property
     def tab_class(self) -> type[Tab]:
         """Import and return the tab class."""
-        module_path, _, attribute = self.path.partition(":")
-        module = import_module(module_path)
-        return getattr(module, attribute)
+        return resolve_name(self.path)
 
     def __lt__(self, other: TabRegistryEntry) -> bool:
         """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] = []

euporie/core/tabs/_commands.py

@@ -0,0 +1,76 @@
+"""Contains commands for tabs."""
+
+from __future__ import annotations
+
+import logging
+
+from euporie.core.commands import add_cmd
+from euporie.core.filters import tab_can_save, tab_has_focus
+
+log = logging.getLogger(__name__)
+
+
+@add_cmd(filter=tab_can_save, aliases=["w"])
+def _save_file(path: str = "") -> None:
+    """Save the current file."""
+    from euporie.core.app.current import get_app
+
+    if (tab := get_app().tab) is not None:
+        from upath import UPath
+
+        try:
+            tab._save(UPath(path) if path else None)
+        except NotImplementedError:
+            pass
+
+
+@add_cmd(aliases=["wq", "x"])
+def _save_and_quit(path: str = "") -> None:
+    """Save the current tab then quits euporie."""
+    from euporie.core.app.current import get_app
+
+    app = get_app()
+    if (tab := app.tab) is not None:
+        from upath import UPath
+
+        try:
+            tab.save(UPath(path) if path else None)
+        except NotImplementedError:
+            pass
+
+    app.exit()
+
+
+@add_cmd(
+    menu_title="Save As…",
+    filter=tab_can_save,
+)
+def _save_as(path: str = "") -> None:
+    """Save the current file at a new location."""
+    if path:
+        _save_file(path)
+    else:
+        from euporie.core.app.current import get_app
+
+        app = get_app()
+        if dialog := app.dialogs.get("save-as"):
+            dialog.show(tab=app.tab)
+
+
+@add_cmd(filter=tab_has_focus, title="Refresh the current tab")
+def _refresh_tab() -> None:
+    """Reload the tab contents and reset the tab."""
+    from euporie.core.app.current import get_app
+
+    if (tab := get_app().tab) is not None:
+        tab.reset()
+
+
+# Depreciated v2.5.0
+@add_cmd(filter=tab_has_focus, title="Reset the current tab")
+def _reset_tab() -> None:
+    log.warning(
+        "The `reset-tab` command was been renamed to `refresh-tab` in v2.5.0,"
+        " and will be removed in a future version"
+    )
+    _refresh_tab()

euporie/core/tabs/_settings.py

@@ -4,6 +4,22 @@ from prompt_toolkit.filters import buffer_has_focus
 
 from euporie.core.config import add_setting
 
+add_setting(
+    name="backup_on_save",
+    group="euporie.core.tabs.base",
+    flags=["--backup-on-save"],
+    type_=bool,
+    help_="Create backups before saving files",
+    default=False,
+    description="""
+        Determines whether a backup file should be created before saving a file.
+
+        If set to ``True``, the original file will be copied to a new file with the
+        same name but prefixed with ``.`` and suffixed with ``.bak`` before writing the
+        updated contents.
+    """,
+)
+
 add_setting(
     name="kernel_name",
     group="euporie.core.tabs.kernel",

euporie/core/tabs/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABCMeta
 from typing import TYPE_CHECKING, ClassVar
@@ -13,20 +14,21 @@ from upath import UPath
 
 from euporie.core.app.current import get_app
 from euporie.core.commands import add_cmd
-from euporie.core.filters import tab_has_focus
+from euporie.core.filters import tab_can_save, tab_has_focus
 from euporie.core.key_binding.registry import (
     register_bindings,
 )
 from euporie.core.layout.containers import Window
-from euporie.core.path import parse_path
-from euporie.core.utils import run_in_thread_with_context
+from euporie.core.path import UntitledPath, parse_path
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from pathlib import Path
     from typing import Any, Callable
 
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.controls import BufferControl
 
     from euporie.core.app.app import BaseApp
     from euporie.core.bars.status import StatusBarFields
@@ -107,11 +109,89 @@ class Tab(metaclass=ABCMeta):
                 cb()
             self.after_save.fire()
 
-        run_in_thread_with_context(self.save, path, _wrapped_cb)
+        self.app.create_background_task(asyncio.to_thread(self.save, path, _wrapped_cb))
 
     def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
-        """Save the current tab."""
-        raise NotImplementedError
+        """Save the current file."""
+        if path is not None:
+            self.path = path
+
+        if (self.path is None or isinstance(self.path, UntitledPath)) and (
+            dialog := self.app.dialogs.get("save-as")
+        ):
+            dialog.show(tab=self, cb=cb)
+            return
+
+        path = self.path
+        try:
+            # Ensure parent path exists
+            parent = path.parent
+            parent.mkdir(exist_ok=True, parents=True)
+
+            # Create backup if original file exists
+            backup_path: Path | None = None
+            if path.exists():
+                name = f"{path.name}.bak"
+                if not name.startswith("."):
+                    name = f".{name}"
+                backup_path = parent / name
+                if self.app.config.backup_on_save:
+                    try:
+                        import shutil
+
+                        shutil.copy2(path, backup_path)
+                    except Exception as e:
+                        log.error("Failed to create backup: %s", e)
+                        raise
+
+            # Write new content directly to original file
+            try:
+                self.write_file(path)
+            except Exception as e:
+                log.error("Failed to write file: %s", e)
+                # Restore from backup if it exists
+                if backup_path is not None:
+                    log.info("Restoring backup")
+                    backup_path.replace(path)
+                raise
+
+            self.dirty = False
+            self.saving = False
+            self.app.invalidate()
+            log.debug("File saved successfully")
+
+            # Run the callback
+            if callable(cb):
+                cb()
+
+        except Exception:
+            log.exception("An error occurred while saving the file")
+            if dialog := self.app.dialogs.get("save-as"):
+                dialog.show(tab=self, cb=cb)
+
+    def write_file(self, path: Path) -> None:
+        """Write the tab's data to a path.
+
+        Not implement in the base tab.
+
+        Args:
+            path: An path at which to save the file
+
+        """
+        raise NotImplementedError(
+            f"File saving not implement for `{self.__class__.__name__}` tab"
+        )
+
+    def __pt_searchables__(self) -> Sequence[BufferControl]:
+        """Return a list of searchable buffer controls for this tab.
+
+        Returns:
+            A list of searchable buffer controls
+
+        Raises:
+            NotImplementedError: If the tab does not provide searchable buffers
+        """
+        raise NotImplementedError()
 
     def __pt_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""
@@ -141,12 +221,12 @@ class Tab(metaclass=ABCMeta):
         Tab._refresh_tab()
 
     @staticmethod
-    @add_cmd(filter=tab_has_focus, aliases=["w"])
-    def _save_file(event: KeyPressEvent) -> None:
+    @add_cmd(filter=tab_can_save, aliases=["w"])
+    def _save_file(event: KeyPressEvent, path: str = "") -> None:
         """Save the current file."""
         if (tab := get_app().tab) is not None:
             try:
-                tab._save(UPath(event._arg) if event._arg else None)
+                tab._save(UPath(path) if path else None)
             except NotImplementedError:
                 pass