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

euporie/core/tabs/base.py

@@ -1,65 +1,35 @@
-"""Contain tab base classes."""
+"""Contain 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, ClassVar
-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 prompt_toolkit.layout.containers import WindowAlign
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.utils import Event
 from upath import UPath
 
-from euporie.core.comm.registry import open_comm
+from euporie.core.app.current import get_app
 from euporie.core.commands import add_cmd
-from euporie.core.completion import DeduplicateCompleter, KernelCompleter, LspCompleter
-from euporie.core.config import add_setting
-from euporie.core.current import get_app
-from euporie.core.diagnostics import Report
-from euporie.core.filters import kernel_tab_has_focus, 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 import Kernel, MsgCallbacks
+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.suggest import HistoryAutoSuggest
-from euporie.core.utils import run_in_thread_with_context
-from euporie.core.widgets.inputs import KernelInput
+from euporie.core.path import UntitledPath, parse_path
 
 if TYPE_CHECKING:
     from pathlib import Path
-    from typing import Any, Callable, Sequence
+    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 prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.containers import AnyContainer
 
-    from euporie.core.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.status import StatusBarFields
+    from euporie.core.app.app import BaseApp
+    from euporie.core.bars.status import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -137,11 +107,77 @@ 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 notebook."""
-        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
+                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_status__(self) -> StatusBarFields | None:
         """Return a list of statusbar field values shown then this tab is active."""
@@ -171,12 +207,12 @@ class Tab(metaclass=ABCMeta):
         Tab._refresh_tab()
 
     @staticmethod
-    @add_cmd(filter=tab_has_focus)
-    def _save_file() -> None:
+    @add_cmd(filter=tab_can_save, aliases=["w"])
+    def _save_file(event: KeyPressEvent) -> None:
         """Save the current file."""
         if (tab := get_app().tab) is not None:
             try:
-                tab._save()
+                tab._save(UPath(event._arg) if event._arg else None)
             except NotImplementedError:
                 pass
 
@@ -190,429 +226,3 @@ class Tab(metaclass=ABCMeta):
             }
         }
     )
-
-
-class KernelTab(Tab, metaclass=ABCMeta):
-    """A Tab which connects to a kernel."""
-
-    kernel: Kernel
-    kernel_language: str
-    _metadata: dict[str, Any]
-    bg_init = True
-
-    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."""
-        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()
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="kernel_name",
-        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",
-        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",
-        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",
-        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.
-        """,
-    )