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

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

@@ -22,11 +22,13 @@ from euporie.core.layout.containers import Window
 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
@@ -133,13 +135,14 @@ class Tab(metaclass=ABCMeta):
                 if not name.startswith("."):
                     name = f".{name}"
                 backup_path = parent / name
-                try:
-                    import shutil
+                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
+                        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:
@@ -179,6 +182,17 @@ class Tab(metaclass=ABCMeta):
             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."""
         return ([], [])
@@ -208,11 +222,11 @@ class Tab(metaclass=ABCMeta):
 
     @staticmethod
     @add_cmd(filter=tab_can_save, aliases=["w"])
-    def _save_file(event: KeyPressEvent) -> None:
+    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
 

euporie/core/tabs/kernel.py

@@ -6,11 +6,11 @@ import asyncio
 import logging
 from abc import ABCMeta
 from collections import deque
-from functools import partial
+from functools import lru_cache, partial
 from typing import TYPE_CHECKING
 from weakref import WeakKeyDictionary
 
-from prompt_toolkit.auto_suggest import DummyAutoSuggest
+from prompt_toolkit.auto_suggest import DummyAutoSuggest, DynamicAutoSuggest
 from prompt_toolkit.completion.base import (
     DynamicCompleter,
     _MergedCompleter,
@@ -30,8 +30,8 @@ from euporie.core.inspection import (
     KernelInspector,
     LspInspector,
 )
-from euporie.core.kernel.client import Kernel, MsgCallbacks
-from euporie.core.suggest import HistoryAutoSuggest
+from euporie.core.kernel import list_kernels
+from euporie.core.kernel.base import NoKernel
 from euporie.core.tabs.base import Tab
 
 if TYPE_CHECKING:
@@ -47,16 +47,33 @@ if TYPE_CHECKING:
     from euporie.core.comm.base import Comm
     from euporie.core.format import Formatter
     from euporie.core.inspection import Inspector
+    from euporie.core.kernel.base import BaseKernel, KernelFactory, MsgCallbacks
     from euporie.core.lsp import LspClient
     from euporie.core.widgets.inputs import KernelInput
 
 log = logging.getLogger(__name__)
 
 
+@lru_cache
+def autosuggest_factory(kind: str, history: History) -> AutoSuggest:
+    """Generate autosuggesters."""
+    if kind == "smart":
+        from euporie.core.suggest import SmartHistoryAutoSuggest
+
+        return SmartHistoryAutoSuggest(history)
+    elif kind == "simple":
+        from euporie.core.suggest import SimpleHistoryAutoSuggest
+
+        return SimpleHistoryAutoSuggest(history)
+    else:
+        from prompt_toolkit.auto_suggest import DummyAutoSuggest
+
+        return DummyAutoSuggest()
+
+
 class KernelTab(Tab, metaclass=ABCMeta):
     """A Tab which connects to a kernel."""
 
-    kernel: Kernel
     kernel_language: str
     _metadata: dict[str, Any]
     bg_init = False
@@ -68,7 +85,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
         self,
         app: BaseApp,
         path: Path | None = None,
-        kernel: Kernel | None = None,
+        kernel: BaseKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = False,
         connection_file: Path | None = None,
@@ -77,6 +94,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
         # Init tab
         super().__init__(app, path)
 
+        self.kernel: BaseKernel = NoKernel(self)
         self.lsps: list[LspClient] = []
         self.history: History = DummyHistory()
         self.inspectors: list[Inspector] = []
@@ -182,10 +200,12 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
     def post_init_kernel(self) -> None:
         """Run stuff after the kernel is loaded."""
+        if not isinstance(self.kernel, NoKernel):
+            self.metadata["kernelspec"] = self.kernel.spec
 
     def init_kernel(
         self,
-        kernel: Kernel | None = None,
+        kernel: BaseKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = False,
         connection_file: Path | None = None,
@@ -199,20 +219,47 @@ class KernelTab(Tab, metaclass=ABCMeta):
             self.kernel = kernel
             self.kernel.default_callbacks = self.default_callbacks
         else:
-            self.kernel = Kernel(
+            from euporie.core.kernel import list_kernels
+
+            kernel_infos = list_kernels()
+            kernel_name = self.kernel_name or self.app.config.kernel_name
+            for info in kernel_infos:
+                if info.name == kernel_name:
+                    factory = info.factory
+                    break
+            else:
+                msg = (
+                    f"Kernel '{self.kernel_display_name}' not found"
+                    if self.kernel_name
+                    else "No kernel selected"
+                )
+                self.change_kernel(msg=msg, startup=True)
+                return
+            self.kernel = factory(
                 kernel_tab=self,
                 allow_stdin=self.allow_stdin,
                 default_callbacks=self.default_callbacks,
-                connection_file=connection_file,
+                **(
+                    {"connection_file": connection_file}
+                    if connection_file is not None
+                    else {}
+                ),
             )
+
         self.comms = comms or {}  # The client-side comm states
-        self.completers.append(KernelCompleter(self.kernel))
-        self.inspectors.append(KernelInspector(self.kernel))
+        self.completers.append(KernelCompleter(lambda: self.kernel))
+        self.inspectors.append(KernelInspector(lambda: self.kernel))
         self.use_kernel_history = use_kernel_history
         self.history = (
-            KernelHistory(self.kernel) if use_kernel_history else InMemoryHistory()
+            KernelHistory(lambda: self.kernel)
+            if use_kernel_history
+            else InMemoryHistory()
         )
-        self.suggester = HistoryAutoSuggest(self.history)
+
+        def _get_suggester() -> AutoSuggest | None:
+            return autosuggest_factory(self.app.config.autosuggest, self.history)
+
+        self.suggester = DynamicAutoSuggest(_get_suggester)
 
         self.app.create_background_task(self.load_lsps())
 
@@ -220,7 +267,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
     def close(self, cb: Callable | None = None) -> None:
         """Shut down kernel when tab is closed."""
-        if hasattr(self, "kernel"):
+        if self.kernel is not None:
             self.kernel.shutdown()
         super().close(cb)
 
@@ -232,6 +279,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
         """Restart the current `Notebook`'s kernel."""
 
         def _cb(result: dict[str, Any]) -> None:
+            self.kernel_started()
             if callable(cb):
                 cb()
 
@@ -245,18 +293,8 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
     def kernel_started(self, result: dict[str, Any] | None = None) -> None:
         """Task to run when the kernel has started."""
-        # Check kernel has not failed
-        if not self.kernel_name or self.kernel.missing:
-            if not self.kernel_name:
-                msg = "No kernel selected"
-            else:
-                msg = f"Kernel '{self.kernel_display_name}' not installed"
-            self.change_kernel(
-                msg=msg,
-                startup=True,
-            )
-
-        elif self.kernel.status == "error":
+        # Set kernel spec in metadata
+        if self.kernel.status == "error":
             self.report_kernel_error(self.kernel.error)
 
         else:
@@ -300,9 +338,7 @@ class KernelTab(Tab, metaclass=ABCMeta):
     @property
     def kernel_name(self) -> str:
         """Return the name of the kernel defined in the notebook JSON."""
-        return self.metadata.get("kernelspec", {}).get(
-            "name", self.app.config.kernel_name
-        )
+        return self.metadata.get("kernelspec", {}).get("name", "")
 
     @kernel_name.setter
     def kernel_name(self, value: str) -> None:
@@ -337,22 +373,32 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
     def change_kernel(self, msg: str | None = None, startup: bool = False) -> None:
         """Prompt the user to select a new kernel."""
-        kernel_specs = self.kernel.specs
+        kernel_infos = list_kernels()
 
         # Warn the user if no kernels are installed
-        if not kernel_specs:
+        if not kernel_infos:
             if startup and "no-kernels" in self.app.dialogs:
                 self.app.dialogs["no-kernels"].show()
             return
 
         # Automatically select the only kernel if there is only one
-        if startup and len(kernel_specs) == 1:
-            self.kernel.change(next(iter(kernel_specs)))
+        if startup and len(kernel_infos) == 1:
+            self.switch_kernel(next(iter(kernel_infos)).factory)
             return
 
-        self.app.dialogs["change-kernel"].show(
-            tab=self, message=msg, kernel_specs=kernel_specs
+        # Prompt user to select a kernel
+        self.app.dialogs["change-kernel"].show(tab=self, message=msg)
+
+    def switch_kernel(self, factory: KernelFactory) -> None:
+        """Shut down the current kernel and change to another."""
+        if (old_kernel := self.kernel) is not None:
+            old_kernel.shutdown(wait=True)
+        kernel = factory(
+            kernel_tab=self,
+            default_callbacks=self.default_callbacks,
+            allow_stdin=self.allow_stdin,
         )
+        self.init_kernel(kernel)
 
     def comm_open(self, content: dict, buffers: Sequence[bytes]) -> None:
         """Register a new kernel Comm object in the notebook."""

euporie/core/tabs/notebook.py

@@ -12,10 +12,8 @@ import nbformat
 from prompt_toolkit.filters import Never
 
 from euporie.core.comm.registry import open_comm
-from euporie.core.commands import get_cmd
 from euporie.core.io import edit_in_editor
-from euporie.core.kernel.client import MsgCallbacks
-from euporie.core.path import UntitledPath
+from euporie.core.kernel.base import MsgCallbacks
 from euporie.core.tabs.kernel import KernelTab
 from euporie.core.widgets.cell import Cell, get_cell_id
 
@@ -27,15 +25,17 @@ except ModuleNotFoundError:
     from nbformat import write as write_nb
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from pathlib import Path
     from typing import Any, Callable
 
     from prompt_toolkit.filters import Filter
     from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.layout.controls import BufferControl
 
     from euporie.core.app.app import BaseApp
     from euporie.core.comm.base import Comm
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
     from euporie.core.lsp import LspClient
     from euporie.core.widgets.inputs import KernelInput
 
@@ -52,7 +52,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
         self,
         app: BaseApp,
         path: Path | None = None,
-        kernel: Kernel | None = None,
+        kernel: BaseKernel | None = None,
         comms: dict[str, Comm] | None = None,
         use_kernel_history: bool = False,
         json: dict[str, Any] | None = None,
@@ -92,6 +92,9 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
             app, path, kernel=kernel, comms=comms, use_kernel_history=use_kernel_history
         )
 
+        # Load notebook file
+        self.container = self.load_container()
+
     # Tab stuff
 
     def reset(self) -> None:
@@ -104,24 +107,10 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
 
     # KernelTab stuff
 
-    def pre_init_kernel(self) -> None:
-        """Run stuff before the kernel is loaded."""
-        super().pre_init_kernel()
-        # Load notebook file
-        self.load()
-
     def post_init_kernel(self) -> None:
         """Load the notebook container after the kernel has been loaded."""
         super().post_init_kernel()
 
-        # Replace the tab's container
-        prev = self.container
-        self.container = self.load_container()
-        self.loaded = True
-        # Update the focus if the old container had focus
-        if self.app.layout.has_focus(prev):
-            self.focus()
-
         # Load widgets
         self.load_widgets_from_metadata()
 
@@ -179,8 +168,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
 
     @abstractmethod
     def load_container(self) -> AnyContainer:
-        """Abcract method for loading the notebook's main container."""
-        ...
+        """Absract method for loading the notebook's main container."""
 
     @abstractproperty
     def cell(self) -> Cell:
@@ -270,7 +258,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
         if self.dirty and (unsaved := self.app.dialogs.get("unsaved")):
             unsaved.show(
                 tab=self,
-                cb=cb,
+                cb=partial(super().close, cb),
             )
         else:
             super().close(cb)
@@ -422,3 +410,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
     def lsp_update_diagnostics(self, lsp: LspClient) -> None:
         """Process a new diagnostic report from the LSP."""
         # Do nothing, these are handled by cells
+
+    def __pt_searchables__(self) -> Sequence[BufferControl]:
+        """Return list of cell input buffer controls for searching."""
+        return [cell.input_box.control for cell in self.rendered_cells()]

euporie/core/utils.py

@@ -1,4 +1,4 @@
-"""Miscellaneou utility classes."""
+"""Miscellaneous utility classes."""
 
 from __future__ import annotations
 

euporie/core/validation.py

@@ -9,29 +9,29 @@ from prompt_toolkit.validation import ValidationError, Validator
 if TYPE_CHECKING:
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
 
 
 class KernelValidator(Validator):
     """Validate kernel input using a kernel code completeness call."""
 
-    def __init__(self, kernel: Kernel) -> None:
+    def __init__(self, kernel: BaseKernel) -> None:
         """Initialize the validator."""
         self.kernel = kernel
 
     def validate(self, document: Document) -> None:
         """Validate the input synchronously."""
-        completeness_status = self.kernel.is_complete(
-            code=document.text, wait=True
-        ).get("status", "unknown")
+        completeness_status = self.kernel.is_complete(source=document.text).get(
+            "status", "unknown"
+        )
         if completeness_status == "incomplete":
             raise ValidationError
 
     async def validate_async(self, document: Document) -> None:
         """Return a `Future` which is set when the validation is ready."""
-        completeness_status = (await self.kernel.is_complete_(code=document.text)).get(
-            "status", "unknown"
-        )
+        completeness_status = (
+            await self.kernel.is_complete_async(source=document.text)
+        ).get("status", "unknown")
         if completeness_status == "incomplete":
             raise ValidationError
         return

euporie/core/widgets/_settings.py

@@ -22,6 +22,22 @@ add_setting(
     cmd_filter=~buffer_has_focus,
 )
 
+add_setting(
+    name="text_output_limit",
+    group="euporie.core.widgets.cell_outputs",
+    flags=["--text-output-limit"],
+    type_=int,
+    help_="Limit the amount of cell text output",
+    default=1_000_000,
+    schema={
+        "minimum": 0,
+    },
+    description="""
+        Limit the number of text characters in interactive cell text output to this value.
+        Use ``0`` to allow any amount of characters.
+    """,
+)
+
 # euporie,core.widgets.file_browser:FileBrowser
 
 add_setting(
@@ -86,9 +102,10 @@ add_setting(
     name="autosuggest",
     group="euporie.core.widgets.inputs",
     flags=["--autosuggest"],
-    type_=bool,
+    type_=str,
+    choices=["smart", "simple", "none"],
     help_="Provide line completion suggestions",
-    default=True,
+    default="smart",
     description="""
         Whether to automatically suggestion line content while typing in code cells.
     """,