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

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,10 +30,9 @@ 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
-from euporie.core.utils import run_in_thread_with_context
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -48,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
@@ -69,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,
@@ -78,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] = []
@@ -97,8 +114,8 @@ class KernelTab(Tab, metaclass=ABCMeta):
 
         if self.bg_init:
             # Load kernel in a background thread
-            run_in_thread_with_context(
-                partial(
+            app.create_background_task(
+                asyncio.to_thread(
                     self.init_kernel, kernel, comms, use_kernel_history, connection_file
                 )
             )
@@ -183,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,
@@ -200,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())
 
@@ -221,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)
 
@@ -233,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()
 
@@ -246,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:
@@ -301,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:
@@ -338,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,23 +258,20 @@ 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)
 
-    def save(self, path: Path | None = None, cb: Callable | None = None) -> None:
+    def write_file(self, path: Path) -> None:
         """Write the notebook's JSON to the current notebook's file.
 
         Additionally save the widget state to the notebook metadata.
 
         Args:
-            path: An optional new path at which to save the tab
-            cb: A callback to run if after saving the notebook.
+            path: An path at which to save the file
 
         """
-        if path is not None:
-            self.path = path
         if self.app.config.save_widget_state:
             self.json.setdefault("metadata", {})["widgets"] = {
                 "application/vnd.jupyter.widget-state+json": {
@@ -299,58 +284,21 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
                     },
                 }
             }
-        if self.path is None or isinstance(self.path, UntitledPath):
-            if dialog := self.app.dialogs.get("save-as"):
-                dialog.show(tab=self, cb=cb)
-        else:
-            log.debug("Saving notebook..")
-            self.saving = True
-            self.app.invalidate()
-            # Ensure parent path exists
-            parent = self.path.parent
-            parent.mkdir(exist_ok=True, parents=True)
-            # Save to a temp file, then replace the original
-            temp_path = parent / f".{self.path.stem}.tmp{self.path.suffix}"
-            log.debug("Using temporary file %s", temp_path.name)
+        with path.open("w") as open_file:
             try:
-                open_file = temp_path.open("w")
-            except NotImplementedError:
-                get_cmd("save-as").run()
-            else:
+                write_nb(nb=nbformat.from_dict(self.json), fp=open_file)
+            except AssertionError:
                 try:
-                    try:
-                        write_nb(nb=nbformat.from_dict(self.json), fp=open_file)
-                    except AssertionError:
-                        try:
-                            # Jupytext requires a filename if we don't give it a format
-                            write_nb(nb=nbformat.from_dict(self.json), fp=temp_path)
-                        except Exception:
-                            # Jupytext requires a format if the path has no extension
-                            # We just use ipynb as the default format
-                            write_nb(
-                                nb=nbformat.from_dict(self.json),
-                                fp=open_file,
-                                fmt="ipynb",
-                            )
+                    # Jupytext requires a filename if we don't give it a format
+                    write_nb(nb=nbformat.from_dict(self.json), fp=path)
                 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)
-                else:
-                    open_file.close()
-                    try:
-                        temp_path.rename(self.path)
-                    except Exception:
-                        if dialog := self.app.dialogs.get("save-as"):
-                            dialog.show(tab=self, cb=cb)
-                    else:
-                        self.dirty = False
-                        self.saving = False
-                        self.app.invalidate()
-                        log.debug("Notebook saved")
-            # Run the callback
-            if callable(cb):
-                cb()
+                    # Jupytext requires a format if the path has no extension
+                    # We just use ipynb as the default format
+                    write_nb(
+                        nb=nbformat.from_dict(self.json),
+                        fp=open_file,
+                        fmt="ipynb",
+                    )
 
     def run_cell(
         self,
@@ -462,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,12 +1,10 @@
-"""Miscellaneou utility classes."""
+"""Miscellaneous utility classes."""
 
 from __future__ import annotations
 
-import contextvars
 from collections.abc import Sequence
 from functools import cache
 from itertools import chain
-from threading import Thread
 from typing import TYPE_CHECKING, TypeVar, overload
 
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
@@ -14,7 +12,7 @@ from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from types import ModuleType
-    from typing import Any, Callable
+    from typing import Callable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.mouse_handlers import MouseHandler
@@ -78,21 +76,6 @@ def on_click(func: Callable) -> MouseHandler:
     return _mouse_handler
 
 
-def run_in_thread_with_context(
-    func: Callable, *args: Any, daemon: bool = True, **kwargs: Any
-) -> None:
-    """Run a function in an thread, but make sure it uses the same contextvars.
-
-    This is required so that the function will see the right application.
-    """
-    Thread(
-        target=contextvars.copy_context().run,
-        args=(func, *args),
-        kwargs=kwargs,
-        daemon=daemon,
-    ).start()
-
-
 @cache
 def root_module(name: str) -> ModuleType:
     """Find and load the root module of a given module name by traversing up the module hierarchy.

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

euporie/core/widgets/cell.py

@@ -6,7 +6,7 @@ import asyncio
 import logging
 import os
 import weakref
-from functools import partial
+from functools import lru_cache, partial
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 from weakref import WeakKeyDictionary
@@ -50,6 +50,7 @@ if TYPE_CHECKING:
     from prompt_toolkit.completion.base import Completer
     from prompt_toolkit.formatted_text.base import StyleAndTextTuples
 
+    from euporie.core.border import GridStyle
     from euporie.core.format import Formatter
     from euporie.core.inspection import Inspector
     from euporie.core.lsp import LspClient
@@ -79,6 +80,18 @@ def get_cell_id(cell_json: dict) -> str:
     return cell_id
 
 
+@lru_cache(maxsize=32)
+def _get_border_style(
+    selected: bool, focused: bool, show_borders: bool, multi_selected: bool
+) -> GridStyle:
+    """Get the border style grid based on cell state."""
+    if not (show_borders or selected):
+        return NoLine.grid
+    if focused and multi_selected:
+        return ThickLine.outer
+    return ThinLine.outer
+
+
 class Cell:
     """A kernel_tab cell element.
 
@@ -86,8 +99,6 @@ class Cell:
     focused.
     """
 
-    input_box: KernelInput
-
     def __init__(
         self, index: int, json: dict, kernel_tab: BaseNotebook, is_new: bool = False
     ) -> None:
@@ -158,6 +169,14 @@ class Cell:
             """Update cell json when the input buffer has been edited."""
             weak_self._set_input(buf.text)
             weak_self.kernel_tab.dirty = True
+            weak_self.on_change()
+            # Re-render markdown cells when edited outside of edit mode
+            if (
+                weak_self.cell_type == "markdown"
+                and not weak_self.kernel_tab.in_edit_mode()
+            ):
+                weak_self.output_area.json = weak_self.output_json
+                weak_self.refresh()
 
         def on_cursor_position_changed(buf: Buffer) -> None:
             """Respond to cursor movements."""
@@ -172,7 +191,7 @@ class Cell:
         # Now we generate the main container used to represent a kernel_tab cell
 
         source_hidden = Condition(
-            lambda: weak_self.json["metadata"]
+            lambda: weak_self.json.get("metadata", {})
             .get("jupyter", {})
             .get("source_hidden", False)
         )
@@ -199,42 +218,22 @@ class Cell:
         )
         self.input_box.buffer.name = self.cell_type
 
-        self.input_box.buffer.on_text_changed += lambda buf: weak_self.on_change()
-
         def border_char(name: str) -> Callable[..., str]:
             """Return a function which returns the cell border character to display."""
 
             def _inner() -> str:
-                grid = NoLine.grid
-                if weak_self and (
-                    weak_self.kernel_tab.app.config.show_cell_borders
-                    or weak_self.selected
-                ):
-                    if weak_self.focused and multiple_cells_selected():
-                        grid = ThickLine.outer
-                    else:
-                        grid = ThinLine.outer
+                if not weak_self:
+                    return " "
+                grid = _get_border_style(
+                    weak_self.selected,
+                    weak_self.focused,
+                    weak_self.kernel_tab.app.config.show_cell_borders,
+                    multiple_cells_selected(),
+                )
                 return getattr(grid, name.upper())
 
             return _inner
 
-        # @lru_cache(maxsize=None)
-        # def _cell_border_char(
-        #     name: str,
-        #     show_cell_borders: bool,
-        #     focused: bool,
-        #     selected: bool,
-        #     multiple_cells_selected: bool,
-        # ) -> str:
-        #     if show_cell_borders or selected:
-        #         if focused and multiple_cells_selected:
-        #             grid = ThickLine.outer
-        #         else:
-        #             grid = ThinLine.outer
-        #     else:
-        #         grid = NoLine.grid
-        #     return getattr(grid, name.upper())
-
         self.control = Window(
             FormattedTextControl(
                 border_char("TOP_LEFT"),
@@ -764,6 +763,7 @@ class Cell:
     def set_execution_count(self, n: int) -> None:
         """Set the execution count of the cell."""
         self.json["execution_count"] = n
+        self.refresh()
 
     def add_output(self, output_json: dict[str, Any], own: bool) -> None:
         """Add a new output to the cell."""