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

euporie/core/tabs/kernel.py

@@ -0,0 +1,420 @@
+"""Contain kernel tab base class."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from abc import ABCMeta
+from collections import deque
+from functools import partial
+from typing import TYPE_CHECKING
+from weakref import WeakKeyDictionary
+
+from prompt_toolkit.auto_suggest import DummyAutoSuggest
+from prompt_toolkit.completion.base import (
+    DynamicCompleter,
+    _MergedCompleter,
+)
+from prompt_toolkit.history import DummyHistory, InMemoryHistory
+
+from euporie.core.app.current import get_app
+from euporie.core.comm.registry import open_comm
+from euporie.core.commands import add_cmd
+from euporie.core.completion import DeduplicateCompleter, KernelCompleter, LspCompleter
+from euporie.core.diagnostics import Report
+from euporie.core.filters import kernel_tab_has_focus
+from euporie.core.format import LspFormatter
+from euporie.core.history import KernelHistory
+from euporie.core.inspection import (
+    FirstInspector,
+    KernelInspector,
+    LspInspector,
+)
+from euporie.core.kernel.client import Kernel, MsgCallbacks
+from euporie.core.suggest import HistoryAutoSuggest
+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
+    from pathlib import Path
+    from typing import Any, Callable
+
+    from prompt_toolkit.auto_suggest import AutoSuggest
+    from prompt_toolkit.completion.base import Completer
+    from prompt_toolkit.history import History
+
+    from euporie.core.app.app import BaseApp
+    from euporie.core.comm.base import Comm
+    from euporie.core.format import Formatter
+    from euporie.core.inspection import Inspector
+    from euporie.core.lsp import LspClient
+    from euporie.core.widgets.inputs import KernelInput
+
+log = logging.getLogger(__name__)
+
+
+class KernelTab(Tab, metaclass=ABCMeta):
+    """A Tab which connects to a kernel."""
+
+    kernel: Kernel
+    kernel_language: str
+    _metadata: dict[str, Any]
+    bg_init = False
+
+    default_callbacks: MsgCallbacks
+    allow_stdin: bool
+
+    def __init__(
+        self,
+        app: BaseApp,
+        path: Path | None = None,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Create a new instance of a tab with a kernel."""
+        # Init tab
+        super().__init__(app, path)
+
+        self.lsps: list[LspClient] = []
+        self.history: History = DummyHistory()
+        self.inspectors: list[Inspector] = []
+        self.inspector = FirstInspector(lambda: self.inspectors)
+        self.suggester: AutoSuggest = DummyAutoSuggest()
+        self.completers: list[Completer] = []
+        self.completer = DeduplicateCompleter(
+            DynamicCompleter(lambda: _MergedCompleter(self.completers))
+        )
+        self.formatters: list[Formatter] = self.app.formatters
+        self.reports: WeakKeyDictionary[LspClient, Report] = WeakKeyDictionary()
+
+        # The client-side comm states
+        self.comms: dict[str, Comm] = {}
+        # The current kernel input
+        self._current_input: KernelInput | None = None
+
+        if self.bg_init:
+            # Load kernel in a background thread
+            run_in_thread_with_context(
+                partial(
+                    self.init_kernel, kernel, comms, use_kernel_history, connection_file
+                )
+            )
+        else:
+            self.init_kernel(kernel, comms, use_kernel_history, connection_file)
+
+    async def load_lsps(self) -> None:
+        """Load the LSP clients."""
+        path = self.path
+
+        # Load list of LSP clients for the tab's language
+        self.lsps.extend(self.app.get_language_lsps(self.language))
+
+        # Wait for all lsps to be initialized, and setup hooks as they become ready
+        async def _await_load(lsp: LspClient) -> LspClient:
+            await lsp.initialized.wait()
+            return lsp
+
+        for ready in asyncio.as_completed([_await_load(lsp) for lsp in self.lsps]):
+            lsp = await ready
+            # Apply open, save, and close hooks to the tab
+            change_handler = partial(lambda lsp, tab: self.lsp_change_handler(lsp), lsp)
+            close_handler = partial(lambda lsp, tab: self.lsp_close_handler(lsp), lsp)
+            before_save_handler = partial(
+                lambda lsp, tab: self.lsp_before_save_handler(lsp), lsp
+            )
+            after_save_handler = partial(
+                lambda lsp, tab: self.lsp_after_save_handler(lsp), lsp
+            )
+
+            self.on_close += close_handler
+            self.on_change += change_handler
+            self.before_save += before_save_handler
+            self.after_save += after_save_handler
+
+            # Listen for LSP diagnostics
+            lsp.on_diagnostics += self.lsp_update_diagnostics
+
+            # Add completer
+            completer = LspCompleter(lsp=lsp, path=path)
+            self.completers.append(completer)
+
+            # Add inspector
+            inspector = LspInspector(lsp, path)
+            self.inspectors.append(inspector)
+
+            # Add formatter
+            formatter = LspFormatter(lsp, path)
+            self.formatters.append(formatter)
+
+            # Remove hooks if the LSP exits
+            def lsp_unload(lsp: LspClient) -> None:
+                self.on_change -= change_handler  # noqa: B023
+                self.before_save -= before_save_handler  # noqa: B023
+                self.after_save -= after_save_handler  # noqa: B023
+                self.on_close -= close_handler  # noqa: B023
+                if completer in self.completers:  # noqa: B023
+                    self.completers.remove(completer)  # noqa: B023
+                if inspector in self.completers:  # noqa: B023
+                    self.inspectors.remove(inspector)  # noqa: B023
+                if formatter in self.completers:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+                if completer in self.completers:  # noqa: B023
+                    self.completers.remove(completer)  # noqa: B023
+                if inspector in self.inspectors:  # noqa: B023
+                    self.inspectors.remove(inspector)  # noqa: B023
+                if formatter in self.formatters:  # noqa: B023
+                    self.formatters.remove(formatter)  # noqa: B023
+
+            lsp.on_exit += lsp_unload
+
+            # Remove the lsp exit handler if this tab closes
+            self.on_close += lambda tab: (
+                (lsp.on_exit.__isub__(lsp_unload) and None) or None  # noqa: B023
+            )  # Magical typing
+
+            # Tell the LSP we have an open file
+            self.lsp_open_handler(lsp)
+
+    def pre_init_kernel(self) -> None:
+        """Run stuff before the kernel is loaded."""
+
+    def post_init_kernel(self) -> None:
+        """Run stuff after the kernel is loaded."""
+
+    def init_kernel(
+        self,
+        kernel: Kernel | None = None,
+        comms: dict[str, Comm] | None = None,
+        use_kernel_history: bool = False,
+        connection_file: Path | None = None,
+    ) -> None:
+        """Set up the tab's kernel and related components."""
+        self.pre_init_kernel()
+
+        self.kernel_queue: deque[Callable] = deque()
+
+        if kernel:
+            self.kernel = kernel
+            self.kernel.default_callbacks = self.default_callbacks
+        else:
+            self.kernel = Kernel(
+                kernel_tab=self,
+                allow_stdin=self.allow_stdin,
+                default_callbacks=self.default_callbacks,
+                connection_file=connection_file,
+            )
+        self.comms = comms or {}  # The client-side comm states
+        self.completers.append(KernelCompleter(self.kernel))
+        self.inspectors.append(KernelInspector(self.kernel))
+        self.use_kernel_history = use_kernel_history
+        self.history = (
+            KernelHistory(self.kernel) if use_kernel_history else InMemoryHistory()
+        )
+        self.suggester = HistoryAutoSuggest(self.history)
+
+        self.app.create_background_task(self.load_lsps())
+
+        self.post_init_kernel()
+
+    def close(self, cb: Callable | None = None) -> None:
+        """Shut down kernel when tab is closed."""
+        if hasattr(self, "kernel"):
+            self.kernel.shutdown()
+        super().close(cb)
+
+    def interrupt_kernel(self) -> None:
+        """Interrupt the current `Notebook`'s kernel."""
+        self.kernel.interrupt()
+
+    def restart_kernel(self, cb: Callable | None = None) -> None:
+        """Restart the current `Notebook`'s kernel."""
+
+        def _cb(result: dict[str, Any]) -> None:
+            if callable(cb):
+                cb()
+
+        if confirm := self.app.dialogs.get("confirm"):
+            confirm.show(
+                message="Are you sure you want to restart the kernel?",
+                cb=partial(self.kernel.restart, cb=_cb),
+            )
+        else:
+            self.kernel.restart(cb=_cb)
+
+    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":
+            self.report_kernel_error(self.kernel.error)
+
+        else:
+            # Wait for an idle kernel
+            if self.kernel.status != "idle":
+                self.kernel.wait_for_status("idle")
+
+            # Load widget comm info
+            # self.kernel.comm_info(target_name="jupyter.widget")
+
+            # Load kernel info
+            self.kernel.info(set_kernel_info=self.set_kernel_info)
+
+            # Load kernel history
+            if self.use_kernel_history:
+                self.app.create_background_task(self.load_history())
+
+            # Run queued kernel tasks when the kernel is idle
+            log.debug("Running %d kernel tasks", len(self.kernel_queue))
+            while self.kernel_queue:
+                self.kernel_queue.popleft()()
+
+        self.app.invalidate()
+
+    def report_kernel_error(self, error: Exception | None) -> None:
+        """Report a kernel error to the user."""
+        log.debug("Kernel error", exc_info=error)
+
+    async def load_history(self) -> None:
+        """Load kernel history."""
+        try:
+            await self.history.load().__anext__()
+        except StopAsyncIteration:
+            pass
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        """Return a dictionary to hold notebook / kernel metadata."""
+        return self._metadata
+
+    @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
+        )
+
+    @kernel_name.setter
+    def kernel_name(self, value: str) -> None:
+        """Return the name of the kernel defined in the notebook JSON."""
+        self.metadata.setdefault("kernelspec", {})["name"] = value
+
+    @property
+    def language(self) -> str:
+        """Return the name of the kernel defined in the notebook JSON."""
+        return self.metadata.get("kernelspec", {}).get("language")
+
+    @property
+    def kernel_display_name(self) -> str:
+        """Return the display name of the kernel defined in the notebook JSON."""
+        return self.metadata.get("kernelspec", {}).get("display_name", self.kernel_name)
+
+    @property
+    def kernel_lang_file_ext(self) -> str:
+        """Return the display name of the kernel defined in the notebook JSON."""
+        return self.metadata.get("language_info", {}).get("file_extension", ".py")
+
+    @property
+    def current_input(self) -> KernelInput:
+        """Return the currently active kernel input, if any."""
+        from euporie.core.widgets.inputs import KernelInput
+
+        return self._current_input or KernelInput(self)
+
+    def set_kernel_info(self, info: dict) -> None:
+        """Handle kernel info requests."""
+        self.metadata["language_info"] = info.get("language_info", {})
+
+    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
+
+        # Warn the user if no kernels are installed
+        if not kernel_specs:
+            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)))
+            return
+
+        self.app.dialogs["change-kernel"].show(
+            tab=self, message=msg, kernel_specs=kernel_specs
+        )
+
+    def comm_open(self, content: dict, buffers: Sequence[bytes]) -> None:
+        """Register a new kernel Comm object in the notebook."""
+        comm_id = str(content.get("comm_id"))
+        self.comms[comm_id] = open_comm(
+            comm_container=self, content=content, buffers=buffers
+        )
+
+    def comm_msg(self, content: dict, buffers: Sequence[bytes]) -> None:
+        """Respond to a Comm message from the kernel."""
+        comm_id = str(content.get("comm_id"))
+        if comm := self.comms.get(comm_id):
+            comm.process_data(content.get("data", {}), buffers)
+
+    def comm_close(self, content: dict, buffers: Sequence[bytes]) -> None:
+        """Close a notebook Comm."""
+        comm_id = content.get("comm_id")
+        if comm_id in self.comms:
+            del self.comms[comm_id]
+
+    def lsp_open_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        lsp.open_doc(
+            path=self.path, language=self.language, text=self.current_input.buffer.text
+        )
+
+    def lsp_change_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP server a file has changed."""
+        lsp.change_doc(
+            path=self.path,
+            language=self.language,
+            text=self.current_input.buffer.text,
+        )
+
+    def lsp_before_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we are about to save a document."""
+        lsp.will_save_doc(self.path)
+
+    def lsp_after_save_handler(self, lsp: LspClient) -> None:
+        """Tell the the LSP we saved a document."""
+        lsp.save_doc(self.path, text=self.current_input.buffer.text)
+
+    def lsp_close_handler(self, lsp: LspClient) -> None:
+        """Tell the LSP we opened a file."""
+        lsp.close_doc(path=self.path)
+
+    def lsp_update_diagnostics(self, lsp: LspClient) -> None:
+        """Process a new diagnostic report from the LSP."""
+        if (diagnostics := lsp.reports.pop(self.path.as_uri(), None)) is not None:
+            self.reports[lsp] = Report.from_lsp(self.current_input.text, diagnostics)
+            self.app.invalidate()
+
+    def report(self) -> Report:
+        """Return the current diagnostic reports."""
+        return Report.from_reports(*self.reports.values())
+
+    # ################################### Commands ####################################
+
+    @staticmethod
+    @add_cmd(filter=kernel_tab_has_focus)
+    def _change_kernel() -> None:
+        """Change the notebook's kernel."""
+        if isinstance(kt := get_app().tab, KernelTab):
+            kt.change_kernel()

euporie/core/tabs/notebook.py

@@ -1,4 +1,4 @@
-"""Contain the main class for a notebook file."""
+"""Contain the base class for a notebook tabs."""
 
 from __future__ import annotations
 
@@ -9,15 +9,14 @@ from functools import partial
 from typing import TYPE_CHECKING
 
 import nbformat
-from prompt_toolkit.filters import Never, buffer_has_focus
+from prompt_toolkit.filters import Never
 
 from euporie.core.comm.registry import open_comm
 from euporie.core.commands import get_cmd
-from euporie.core.config import add_setting
-from euporie.core.kernel import MsgCallbacks
+from euporie.core.io import edit_in_editor
+from euporie.core.kernel.client import MsgCallbacks
 from euporie.core.path import UntitledPath
-from euporie.core.tabs.base import KernelTab
-from euporie.core.terminal import edit_in_editor
+from euporie.core.tabs.kernel import KernelTab
 from euporie.core.widgets.cell import Cell, get_cell_id
 
 try:
@@ -34,9 +33,9 @@ if TYPE_CHECKING:
     from prompt_toolkit.filters import Filter
     from prompt_toolkit.layout.containers import AnyContainer
 
-    from euporie.core.app import BaseApp
+    from euporie.core.app.app import BaseApp
     from euporie.core.comm.base import Comm
-    from euporie.core.kernel import Kernel
+    from euporie.core.kernel.client import Kernel
     from euporie.core.lsp import LspClient
     from euporie.core.widgets.inputs import KernelInput
 
@@ -75,7 +74,7 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
                     prompt, password
                 ),
                 "set_execution_count": lambda n: self.cell.set_execution_count(n),
-                "add_output": lambda output_json: self.cell.add_output(output_json),
+                "add_output": self.new_output_default,
                 "clear_output": lambda wait: self.cell.clear_output(wait),
                 "set_metadata": lambda path, data: self.cell.set_metadata(path, data),
                 "set_status": self.set_status,
@@ -107,21 +106,22 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
 
     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()
 
-        self.app.invalidate()
         # Load widgets
         self.load_widgets_from_metadata()
 
@@ -306,9 +306,11 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
             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 = self.path.parent / f".{self.path.stem}.tmp{self.path.suffix}"
+            temp_path = parent / f".{self.path.stem}.tmp{self.path.suffix}"
             log.debug("Using temporary file %s", temp_path.name)
             try:
                 open_file = temp_path.open("w")
@@ -385,6 +387,11 @@ class BaseNotebook(KernelTab, metaclass=ABCMeta):
                 done=cell.ran,
             )
 
+    def new_output_default(self, output_json: dict[str, Any], own: bool) -> None:
+        """Add a new output without a cell to the currently selected cell."""
+        if self.app.config.show_remote_outputs:
+            self.cell.add_output(output_json, own)
+
     def load_widgets_from_metadata(self) -> None:
         """Load widgets from state saved in notebook metadata."""
         for comm_id, comm_data in (
@@ -455,44 +462,3 @@ 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
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="save_widget_state",
-        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",
-        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",
-        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,
-    )

euporie/core/utils.py

@@ -3,14 +3,18 @@
 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, Sequence, TypeVar, overload
+from typing import TYPE_CHECKING, TypeVar, overload
 
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Iterable
+    from collections.abc import Iterable
+    from types import ModuleType
+    from typing import Any, Callable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.mouse_handlers import MouseHandler
@@ -32,12 +36,10 @@ class ChainedList(Sequence[T]):
         return list(chain.from_iterable(self.lists))
 
     @overload
-    def __getitem__(self, i: int) -> T:
-        ...
+    def __getitem__(self, i: int) -> T: ...
 
     @overload
-    def __getitem__(self, i: slice) -> list[T]:
-        ...
+    def __getitem__(self, i: slice) -> list[T]: ...
 
     def __getitem__(self, i):
         """Get an item from the chained lists."""
@@ -89,3 +91,93 @@ def run_in_thread_with_context(
         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.
+
+    This function walks up the module hierarchy until it finds the topmost parent module
+    that has a valid location. It uses Python's importlib machinery to inspect module
+    specifications and load modules.
+
+    Args:
+        name: The name of the module to find the root for (e.g., 'package.subpackage.module')
+
+    Returns:
+        The loaded root module object
+
+    Example:
+        >>> root = root_module("django.contrib.admin")
+        >>> print(root.__name__)
+        'django'
+
+    Note:
+        The function is cached using lru_cache to improve performance for repeated lookups.
+        The function handles both regular packages and frozen modules.
+    """
+    from importlib.util import find_spec, module_from_spec
+
+    if spec := find_spec(name):
+        while True:
+            if spec.name == spec.parent:
+                try:
+                    parent = find_spec("..", spec.parent)
+                except ImportError:
+                    break
+            elif spec.parent is not None:
+                parent = find_spec(spec.parent)
+            if (spec and not spec.parent) or (parent and not parent.has_location):
+                break
+            if parent:
+                spec = parent
+        if spec.loader:
+            module = module_from_spec(spec)
+            spec.loader.exec_module(module)
+            return module
+    raise ModuleNotFoundError(name=name)
+
+
+@cache
+def import_submodules(root: ModuleType, names: tuple[str]) -> list[ModuleType]:
+    """Import all submodules with a specific name within a root module's package hierarchy.
+
+    This function walks through all packages under the given root module and imports
+    any submodules that match the specified name. It handles various module types
+    including regular packages, single file modules, and frozen modules.
+
+    Args:
+        root: The root module object to search within
+        names: The specific submodule name to search for
+
+    Returns:
+        A list of imported module objects matching the specified name
+
+    Example:
+        >>> root = import_module("django")
+        >>> admin_modules = import_submodules(root, "admin")
+        >>> print([m.__name__ for m in admin_modules])
+        ['django.contrib.admin', 'django.contrib.gis.admin']
+
+    Note:
+        - The function is cached using lru_cache to improve performance for repeated imports
+        - For packages, it searches through __path__
+        - For single file modules, it uses __file__
+        - For frozen modules, it uses the module specification's origin
+    """
+    from importlib import import_module
+    from pkgutil import walk_packages
+
+    if hasattr(root, "__path__"):
+        path = root.__path__
+    elif hasattr(root, "__file__"):
+        path = [root.__file__] if root.__file__ else []
+    else:
+        # For frozen modules, we need to create a special path
+        spec = root.__spec__
+        path = [spec.origin] if spec and spec.origin else []
+    return [
+        import_module(module_name)
+        for _loader, module_name, _is_pkg in walk_packages(path, f"{root.__name__}.")
+        if module_name.rpartition(".")[2] in names
+    ]

euporie/core/validation.py

@@ -9,7 +9,7 @@ from prompt_toolkit.validation import ValidationError, Validator
 if TYPE_CHECKING:
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel import Kernel
+    from euporie.core.kernel.client import Kernel
 
 
 class KernelValidator(Validator):