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

euporie/core/suggest.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import logging
-from collections import deque
+from collections import defaultdict
+from difflib import SequenceMatcher
+from functools import lru_cache
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.auto_suggest import AutoSuggest, ConditionalAutoSuggest, Suggestion
@@ -15,7 +17,6 @@ if TYPE_CHECKING:
     from prompt_toolkit.filters import Filter
     from prompt_toolkit.history import History
 
-    from euporie.core.kernel import Kernel
 
 log = logging.getLogger(__name__)
 
@@ -23,99 +24,116 @@ log = logging.getLogger(__name__)
 class HistoryAutoSuggest(AutoSuggest):
     """Suggest line completions from a :class:`History` object."""
 
-    def __init__(self, history: History, cache_size: int = 100_000) -> None:
+    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.cache_size = cache_size
-        self.cache_keys: deque[str] = deque()
-        self.cache: dict[str, Suggestion] = {}
+        self.n_texts = 0
+        self.n_lines = 0
+        self.prefix_dict: dict[str, dict[str, list[dict[str, int]]]] = defaultdict(
+            lambda: defaultdict(list)
+        )
+
+    def process_history(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)
+
+    def _calculate_similarity(self, text_1: str, text_2: str) -> float:
+        """Calculate and cache the similarity between two texts."""
+        return SequenceMatcher(None, text_1, text_2).quick_ratio()
 
     def get_suggestion(self, buffer: Buffer, document: Document) -> Suggestion | None:
         """Get a line completion suggestion."""
-        result: Suggestion | None = None
+        self.process_history()
+
         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)
+        if not line:
+            return None
+
+        suffixes = self.prefix_dict[line]
+
+        texts = self.history._loaded_strings
+        n_lines = self.n_lines
+
+        best_score = 0.0
+        best_suffix = ""
+
+        # 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)
+                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
+                    # Recentness
+                    + 0.3 * instance["line"] / n_lines
+                    # Similarity of context to document
+                    + 0.4 * context_similarity
+                )
+                # log.debug("%s %r", score, suffix)
+                if score > 0.95:
+                    return Suggestion(suffix)
+                if score > best_score:
+                    best_score = score
+                    best_suffix = suffix
+        if best_suffix:
+            return Suggestion(best_suffix)
         return None
 
-    '''
-    def lookup_suggestion(self, line: "str") -> "Optional[Suggestion]":
-         ""Suggest most commonly used line."""
-        results = {}
-        pat = re.compile(f"^\\s*{re.escape(line)}(.*)$", re.MULTILINE)
-        for text in self.history.get_strings():
-            if line in text:
-                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) :]
-                        if suggestion not in results:
-                            results[suggestion] = 1
-                        else:
-                            results[suggestion] += 1
-        return Suggestion(
-            {b: a for a, b in results.items()}[max(results.values())]
-        )
-    '''
-
-
-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 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 ConditionalAutoSuggestAsync(ConditionalAutoSuggest):

euporie/core/tabs/__init__.py

@@ -1 +1,35 @@
 """Contain various application tab implementations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from euporie.core.tabs.base import Tab
+
+
+@dataclass
+class TabRegistryEntry:
+    """Class to store tab information."""
+
+    path: str
+    name: str
+    mime_types: set = field(default_factory=set)
+    file_extensions: dict[str, None] = field(default_factory=dict)
+    weight: int = 0
+
+    @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)
+
+    def __lt__(self, other: TabRegistryEntry) -> bool:
+        """Sort by weight."""
+        return self.weight < other.weight
+
+
+_TAB_REGISTRY: list[TabRegistryEntry] = []

euporie/core/tabs/_settings.py

@@ -0,0 +1,113 @@
+"""Defines tab settings."""
+
+from prompt_toolkit.filters import buffer_has_focus
+
+from euporie.core.config import add_setting
+
+add_setting(
+    name="kernel_name",
+    group="euporie.core.tabs.kernel",
+    flags=["--kernel-name", "--kernel"],
+    type_=str,
+    help_="The name of the kernel to start by default",
+    default="python3",
+    description="""
+        The name of the kernel selected automatically by the console app or in new
+        notebooks. If set to an empty string, the user will be asked which kernel
+        to launch.
+    """,
+)
+
+add_setting(
+    name="record_cell_timing",
+    group="euporie.core.tabs.kernel",
+    title="cell timing recording",
+    flags=["--record-cell-timing"],
+    type_=bool,
+    help_="Should timing data be recorded in cell metadata.",
+    default=False,
+    schema={
+        "type": "boolean",
+    },
+    description="""
+        When set, execution timing data will be recorded in cell metadata.
+    """,
+)
+
+add_setting(
+    name="show_remote_inputs",
+    group="euporie.core.tabs.kernel",
+    flags=["--show-remote-inputs"],
+    type_=bool,
+    help_="Display inputs sent to the kernel by other clients",
+    default=True,
+    description="""
+        If set to `True`, all code input sent to the kernel by any client will be
+        displayed.
+
+        If set to `False`, only inputs sent to the kernel by the current instance
+        of euporie will be displayed, and all other inputs will be ignored.
+
+    """,
+)
+
+add_setting(
+    name="show_remote_outputs",
+    group="euporie.core.tabs.kernel",
+    flags=["--show-remote-outputs"],
+    type_=bool,
+    help_="Display kernel outputs triggered by other clients",
+    default=True,
+    description="""
+        If set to `False`, only outputs generated by code input from the current
+        instance of euporie will be displayed, and all other outputs will be
+        ignored.
+
+        If set to `True`, all outputs generated by the kernel will be
+        displayed.
+    """,
+)
+
+# euporie.core.tabs.notebook
+
+add_setting(
+    name="save_widget_state",
+    group="euporie.core.tabs.notebook",
+    flags=["--save-widget-state"],
+    type_=bool,
+    help_="Save a notebook's widget state in the notebook metadata",
+    default=True,
+    description="""
+        When set to ``True``, the state of any widgets in the current notebook will
+        be saves in the notebook's metadata. This enables widgets to be displayed
+        when the notebook is re-opened without having to re-run the notebook.
+    """,
+)
+
+add_setting(
+    name="max_notebook_width",
+    group="euporie.core.tabs.notebook",
+    flags=["--max-notebook-width"],
+    type_=int,
+    help_="Maximum width of notebooks",
+    default=120,
+    schema={
+        "minimum": 1,
+    },
+    description="""
+        The maximum width at which to display a notebook.
+    """,
+)
+
+add_setting(
+    name="expand",
+    group="euporie.core.tabs.notebook",
+    flags=["--expand"],
+    type_=bool,
+    help_="Use the full width to display notebooks",
+    default=False,
+    description="""
+        Whether the notebook page should expand to fill the available width
+    """,
+    cmd_filter=~buffer_has_focus,
+)