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

euporie/core/kernel/{client.py → jupyter.py}

@@ -3,23 +3,24 @@
 from __future__ import annotations
 
 import asyncio
-import concurrent.futures
 import logging
 import os
-import threading
 from collections import defaultdict
+from functools import partial
 from subprocess import PIPE, STDOUT  # S404 - Security implications considered
-from typing import TYPE_CHECKING, TypedDict
+from typing import TYPE_CHECKING, cast
 from uuid import uuid4
 
 from upath import UPath
 
+from euporie.core.kernel.base import BaseKernel, KernelInfo, MsgCallbacks
+
 if TYPE_CHECKING:
-    from collections.abc import Coroutine
     from pathlib import Path
-    from typing import Any, Callable
+    from typing import Any, Callable, Unpack
 
     from jupyter_client import KernelClient
+    from jupyter_client.kernelspec import KernelSpecManager
 
     from euporie.core.tabs.kernel import KernelTab
 
@@ -27,175 +28,112 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
-class MsgCallbacks(TypedDict, total=False):
-    """Typed dictionary for named message callbacks."""
-
-    get_input: Callable[[str, bool], None] | None
-    set_execution_count: Callable[[int], None] | None
-    add_output: Callable[[dict[str, Any], bool], None] | None
-    add_input: Callable[[dict[str, Any], bool], None] | None
-    clear_output: Callable[[bool], None] | None
-    done: Callable[[dict[str, Any]], None] | None
-    set_metadata: Callable[[tuple[str, ...], Any], None] | None
-    set_status: Callable[[str], None] | None
-    set_kernel_info: Callable[[dict[str, Any]], None] | None
-    completeness_status: Callable[[dict[str, Any]], None] | None
-    dead: Callable[[], None] | None
-    # Payloads
-    page: Callable[[list[dict], int], None] | None
-    set_next_input: Callable[[str, bool], None] | None
-    edit_magic: Callable[[str, int], None] | None
-    ask_exit: Callable[[bool], None] | None
-
-
-class Kernel:
+class JupyterKernel(BaseKernel):
     """Run a notebook kernel and communicates with it asynchronously.
 
     Has the ability to run itself in it's own thread.
     """
 
-    _CLIENT_ID = f"euporie-{os.getpid()}"
+    _client_id = f"euporie-{os.getpid()}"
+    _spec_manager: KernelSpecManager
+
+    @classmethod
+    def variants(cls) -> list[KernelInfo]:
+        """Return available kernel specifications."""
+        from jupyter_core.paths import jupyter_runtime_dir
+
+        try:
+            manager = cls._spec_manager
+        except AttributeError:
+            from jupyter_client.kernelspec import KernelSpecManager
+            from jupyter_core.paths import jupyter_path
+
+            manager = cls._spec_manager = KernelSpecManager()
+            # Set the kernel folder list to prevent the default method from running.
+            # This prevents the kernel spec manager from loading IPython, just for the
+            # purpose of adding the depreciated :file:`.ipython/kernels` folder to the list
+            # of kernel search paths. Without this, having IPython installed causes a
+            # import race condition error where IPython was imported in the main thread for
+            # displaying LaTeX and in the kernel thread to discover kernel paths.
+            # Also this speeds up launch since importing IPython is pretty slow.
+            manager.kernel_dirs = jupyter_path("kernels")
+
+        return [
+            KernelInfo(
+                name=name,
+                display_name=info.get("spec", {}).get("display_name", name),
+                factory=partial(cls, kernel_name=name),
+                kind="new",
+                type=cls,
+            )
+            for name, info in manager.get_all_specs().items()
+        ] + [
+            KernelInfo(
+                name=path.name,
+                display_name=path.name,
+                factory=partial(cls, connection_file=path),
+                kind="existing",
+                type=cls,
+            )
+            for path in UPath(jupyter_runtime_dir()).glob("kernel-*.json")
+        ]
 
     def __init__(
         self,
         kernel_tab: KernelTab,
-        threaded: bool = True,
-        allow_stdin: bool = False,
         default_callbacks: MsgCallbacks | None = None,
+        allow_stdin: bool = False,
+        *,
+        kernel_name: str | None = None,
         connection_file: Path | None = None,
+        **kwargs: Any,
     ) -> None:
-        """Call when the :py:class:`Kernel` is initialized.
+        """Initialize the JupyterKernel.
 
         Args:
             kernel_tab: The notebook this kernel belongs to
-            threaded: If :py:const:`True`, run kernel communication in a separate thread
             allow_stdin: Whether the kernel is allowed to request input
             default_callbacks: The default callbacks to use on receipt of a message
-            connection_file: Path to a file from which to load or to hwich to save
+            kernel_name: Name of the Jupyter kernel to launch
+            connection_file: Path to a file from which to load or to which to save
                 kernel connection information
-
+            kwargs: Additional key-word arguments
         """
-        from jupyter_core.paths import jupyter_path
+        super().__init__(
+            kernel_tab=kernel_tab,
+            allow_stdin=allow_stdin,
+            default_callbacks=default_callbacks,
+        )
 
-        from euporie.core.kernel.manager import (
+        from euporie.core.kernel.jupyter_manager import (
             EuporieKernelManager,
             set_default_provisioner,
         )
 
         set_default_provisioner()
 
-        self.threaded = threaded
-        if threaded:
-            self.loop = asyncio.new_event_loop()
-            self.thread = threading.Thread(target=self._setup_loop)
-            self.thread.daemon = True
-            self.thread.start()
-        else:
-            self.loop = asyncio.get_event_loop()
+        if kernel_name is None and connection_file is not None:
+            import json
+
+            try:
+                connection_info = json.loads(connection_file.read_text())
+            except json.decoder.JSONDecodeError:
+                connection_info = {}
+            kernel_name = connection_info.get("kernel_name", "python3")
 
-        self.allow_stdin = allow_stdin
+        if kernel_name is None and connection_file is None:
+            raise ValueError("Must provide `kernel_name` or `connection_file`")
 
-        self.kernel_tab = kernel_tab
         self.connection_file = connection_file
+        self.km = EuporieKernelManager(kernel_name=kernel_name)
         self.kc: KernelClient | None = None
-        self.km = EuporieKernelManager(
-            kernel_name=str(kernel_tab.kernel_name),
-        )
-        self._status = "stopped"
-        self.error: Exception | None = None
-        self.dead = False
         self.monitor_task: asyncio.Task | None = None
-
-        self.coros: dict[str, concurrent.futures.Future] = {}
         self.poll_tasks: list[asyncio.Task] = []
-
-        self.default_callbacks = MsgCallbacks(
-            {
-                "get_input": None,
-                "set_execution_count": None,
-                "add_output": None,
-                "clear_output": None,
-                "done": None,
-                "set_metadata": None,
-                "set_status": None,
-            }
-        )
-        if default_callbacks is not None:
-            self.default_callbacks.update(default_callbacks)
-
         self.msg_id_callbacks: dict[str, MsgCallbacks] = defaultdict(
             # Return a copy of the default callbacks
             lambda: MsgCallbacks(dict(self.default_callbacks))  # type: ignore # mypy #8890
         )
 
-        # Set the kernel folder list to prevent the default method from running.
-        # This prevents the kernel spec manager from loading IPython, just for the
-        # purpose of adding the depreciated :file:`.ipython/kernels` folder to the list
-        # of kernel search paths. Without this, having IPython installed causes a
-        # import race condition error where IPython was imported in the main thread for
-        # displaying LaTeX and in the kernel thread to discover kernel paths.
-        # Also this speeds up launch since importing IPython is pretty slow.
-        self.km.kernel_spec_manager.kernel_dirs = jupyter_path("kernels")
-
-    def _setup_loop(self) -> None:
-        """Set the current loop the the kernel's event loop.
-
-        This method is intended to be run in the kernel thread.
-        """
-        asyncio.set_event_loop(self.loop)
-        self.status_change_event = asyncio.Event()
-        self.loop.run_forever()
-
-    def _aodo(
-        self,
-        coro: Coroutine,
-        wait: bool = False,
-        callback: Callable | None = None,
-        timeout: int | float | None = None,
-        single: bool = False,
-    ) -> Any:
-        """Schedule a coroutine in the kernel's event loop.
-
-        Optionally waits for the results (blocking the main thread). Optionally
-        schedules a callback to run when the coroutine has completed or timed out.
-
-        Args:
-            coro: The coroutine to run
-            wait: If :py:const:`True`, block until the kernel has started
-            callback: A function to run when the coroutine completes. The result from
-                the coroutine will be passed as an argument
-            timeout: The number of seconds to allow the coroutine to run if waiting
-            single: If :py:const:`True`, any futures for previous instances of the
-                coroutine will be cancelled
-
-        Returns:
-            The result of the coroutine
-
-        """
-        future = asyncio.run_coroutine_threadsafe(coro, self.loop)
-
-        # Cancel previous future instances if required
-        if single and self.coros.get(coro.__name__):
-            self.coros[coro.__name__].cancel()
-        self.coros[coro.__name__] = future
-
-        if wait:
-            result = None
-            try:
-                result = future.result(timeout)
-            except concurrent.futures.TimeoutError:
-                log.error("Operation '%s' timed out", coro)
-                future.cancel()
-            finally:
-                if callable(callback):
-                    callback(result)
-            return result
-        else:
-            if callable(callback):
-                future.add_done_callback(lambda f: callback(f.result()))
-                return None
-            return None
-
     def _set_living_status(self, alive: bool) -> None:
         """Set the life status of the kernel."""
         if not alive:
@@ -214,7 +152,7 @@ class Kernel:
             await asyncio.sleep(1)
             # Check kernel is alive - use client rather than manager if we have one
             # as we could be connected to a kernel not started by the manager
-            if self.kc:
+            if self.kc and self.status != "starting":
                 alive = await self.kc._async_is_alive()
                 self._set_living_status(alive)
                 # Stop the timer if the kernel is dead
@@ -223,35 +161,6 @@ class Kernel:
             else:
                 break
 
-    @property
-    def status(self) -> str:
-        """Retrieve the current kernel status.
-
-        Returns:
-            The kernel status
-
-        """
-        return self._status
-
-    @status.setter
-    def status(self, value: str) -> None:
-        """Set the kernel status."""
-        self.status_change_event.set()
-        self._status = value
-        self.status_change_event.clear()
-
-    def wait_for_status(self, status: str = "idle") -> None:
-        """Block until the kernel reaches a given status value."""
-        if self.status != status:
-
-            async def _wait() -> None:
-                while self.status != status:
-                    await asyncio.wait_for(
-                        self.status_change_event.wait(), timeout=None
-                    )
-
-            self._aodo(_wait(), wait=True)
-
     @property
     def missing(self) -> bool:
         """Return True if the requested kernel is not found."""
@@ -272,12 +181,7 @@ class Kernel:
         else:
             return None
 
-    @property
-    def specs(self) -> dict[str, dict]:
-        """Return a list of available kernelspecs."""
-        return self.km.kernel_spec_manager.get_all_specs()
-
-    async def stop_(self, cb: Callable[[], Any] | None = None) -> None:
+    async def stop_async(self, cb: Callable[[], Any] | None = None) -> None:
         """Stop the kernel asynchronously."""
         for task in self.poll_tasks:
             task.cancel()
@@ -287,7 +191,7 @@ class Kernel:
             await self.km.shutdown_kernel()
         log.debug("Kernel %s shutdown", self.id)
 
-    async def start_(self) -> None:
+    async def start_async(self) -> None:
         """Start the kernel asynchronously and set its status."""
         from jupyter_core.paths import jupyter_runtime_dir
 
@@ -340,9 +244,19 @@ class Kernel:
                         self.kc = self.km.client()
                     break
 
-        await self.post_start_()
+        await self.post_start()
 
-    async def post_start_(self) -> None:
+    @property
+    def spec(self) -> dict[str, str]:
+        """The kernelspec metadata for the current kernel instance."""
+        assert self.km.kernel_spec is not None
+        return {
+            "name": self.km.kernel_name,
+            "display_name": self.km.kernel_spec.display_name,
+            "language": self.km.kernel_spec.language,
+        }
+
+    async def post_start(self) -> None:
         """Wait for the kernel to become ready."""
         from jupyter_client.kernelspec import NoSuchKernel
 
@@ -353,34 +267,30 @@ class Kernel:
             self.status = "error"
             log.error("Selected kernel '%s' not registered", self.km.kernel_name)
         else:
-            if ks is not None:
-                self.kernel_tab.metadata["kernelspec"] = {
-                    "name": self.km.kernel_name,
-                    "display_name": ks.display_name,
-                    "language": ks.language,
-                }
-
-                if self.kc is not None:
-                    log.debug("Waiting for kernel to become ready")
-                    try:
-                        await self.kc._async_wait_for_ready(timeout=10)
-                    except RuntimeError as e:
-                        log.error("Error connecting to kernel")
-                        self.error = e
-                        self.status = "error"
-                    else:
-                        log.debug("Kernel %s ready", self.id)
-                        self.status = "idle"
-                        self.error = None
-                        self.poll_tasks = [
-                            asyncio.create_task(self.poll("shell")),
-                            asyncio.create_task(self.poll("iopub")),
-                            asyncio.create_task(self.poll("stdin")),
-                        ]
-                        self.dead = False
-
-                    # Set username so we can identify our own messages
-                    self.kc.session.username = self._CLIENT_ID
+            if ks is not None and self.kc is not None:
+                log.debug("Waiting for kernel to become ready")
+                try:
+                    await self.kc._async_wait_for_ready(timeout=30)
+                except RuntimeError as e:
+                    log.error("Error connecting to kernel")
+                    self.error = e
+                    self.status = "error"
+                else:
+                    log.debug("Kernel %s ready", self.id)
+                    self.status = "idle"
+                    self.error = None
+                    self.poll_tasks = [
+                        asyncio.create_task(self.poll("shell")),
+                        asyncio.create_task(self.poll("iopub")),
+                        asyncio.create_task(self.poll("stdin")),
+                    ]
+                    self.dead = False
+
+                # Set username so we can identify our own messages
+                self.kc.session.username = self._client_id
+
+                # Send empty execution request to get current execution count
+                self.kc.execute("", store_history=False, silent=True, allow_stdin=False)
 
             # Start monitoring the kernel status
             if self.monitor_task is not None:
@@ -411,14 +321,7 @@ class Kernel:
                 log.debug("Imported `ipykernel` to prevent import deadlock")
             except ImportError:
                 pass
-
-        # Start the kernel
-        self._aodo(
-            self.start_(),
-            timeout=timeout,
-            wait=wait,
-            callback=cb,
-        )
+        super().start(cb, wait, timeout)
 
     async def poll(self, channel: str) -> None:
         """Poll for messages on a channel, and signal when they arrive.
@@ -434,7 +337,7 @@ class Kernel:
             rsp = await msg_getter_coro()
             # Run msg type handler
             msg_type = rsp.get("header", {}).get("msg_type")
-            own = rsp.get("parent_header", {}).get("username") == self._CLIENT_ID
+            own = rsp.get("parent_header", {}).get("username") == self._client_id
             if callable(handler := getattr(self, f"on_{channel}_{msg_type}", None)):
                 handler(rsp, own)
             else:
@@ -490,7 +393,9 @@ class Kernel:
                 rsp["header"]["date"].isoformat(),
             )
 
-        if (execution_count := content.get("execution_count")) and callable(
+        if (
+            (execution_count := content.get("execution_count")) is not None
+        ) and callable(
             set_execution_count := self.msg_id_callbacks[msg_id]["set_execution_count"]
         ):
             set_execution_count(execution_count)
@@ -573,6 +478,14 @@ class Kernel:
         ):
             completeness_status(rsp.get("content", {}))
 
+    def on_iopub_shutdown_reply(self, rsp: dict[str, Any], own: bool) -> None:
+        """Handle iopub shutdown reply messages."""
+        if not rsp.get("content", {}).get("restart"):
+            # Stop monitoring the kernel
+            if self.monitor_task is not None:
+                self.monitor_task.cancel()
+            self._set_living_status(False)
+
     def on_iopub_status(self, rsp: dict[str, Any], own: bool) -> None:
         """Call callbacks for an iopub status response."""
         msg_id = rsp.get("parent_header", {}).get("msg_id")
@@ -741,22 +654,10 @@ class Kernel:
             log.debug("Cannot run cell because kernel has not started")
             # TODO - queue cells for execution
         else:
-            self._aodo(
-                self.run_(source, **callbacks),
-                wait=wait,
-                callback=callback,
-            )
+            super().run(source, wait, callback, **callbacks)
 
-    async def run_(
-        self,
-        source: str,
-        get_input: Callable[[str, bool], None] | None = None,
-        set_execution_count: Callable[[int], None] | None = None,
-        add_output: Callable[[dict[str, Any], bool], None] | None = None,
-        clear_output: Callable[[bool], None] | None = None,
-        done: Callable[[dict[str, Any]], None] | None = None,
-        set_metadata: Callable[[tuple[str, ...], Any], None] | None = None,
-        set_status: Callable[[str], None] | None = None,
+    async def run_async(
+        self, source: str, **local_callbacks: Unpack[MsgCallbacks]
     ) -> None:
         """Run the code cell and and set the response callbacks, optionally waiting."""
         if self.kc is None:
@@ -768,25 +669,23 @@ class Kernel:
             allow_stdin=self.allow_stdin,
         )
 
-        def wrapped_done(content: dict[str, Any]) -> None:
-            """Set the event after the ``done`` callback has completed."""
-            # Run the original callback
-            if callable(done):
-                done(content)
-            # Set the event
-            event.set()
+        if done := local_callbacks.get("done"):
+
+            def wrapped_done(content: dict[str, Any]) -> None:
+                """Set the event after the ``done`` callback has completed."""
+                # Run the original callback
+                if callable(done):
+                    done(content)
+                # Set the event
+                event.set()
+
+            local_callbacks["done"] = wrapped_done
 
-        callbacks = {
-            "get_input": get_input,
-            "set_execution_count": set_execution_count,
-            "add_output": add_output,
-            "clear_output": clear_output,
-            "set_metadata": set_metadata,
-            "set_status": set_status,
-            "done": wrapped_done,
-        }
         self.msg_id_callbacks[msg_id].update(
-            MsgCallbacks(filter(lambda x: x[1] is not None, callbacks.items()))  # type: ignore # mypy #8890
+            cast(
+                "MsgCallbacks",
+                {k: v for k, v in local_callbacks.items() if v is not None},
+            )
         )
         # Wait for "done" callback to be called
         try:
@@ -827,8 +726,8 @@ class Kernel:
         if self.kc is not None:
             self.kc.comm_info(target_name=target_name)
 
-    async def complete_(
-        self, code: str, cursor_pos: int, timeout: int = 60
+    async def complete_async(
+        self, source: str, cursor_pos: int, timeout: int = 60
     ) -> list[dict]:
         """Request code completions from the kernel, asynchronously."""
         results: list[dict] = []
@@ -866,7 +765,7 @@ class Kernel:
                         )
                 event.set()
 
-        msg_id = self.kc.complete(code, cursor_pos)
+        msg_id = self.kc.complete(source, cursor_pos)
         self.msg_id_callbacks[msg_id].update({"done": process_complete_reply})
 
         try:
@@ -876,32 +775,12 @@ class Kernel:
 
         return results
 
-    def complete(self, code: str, cursor_pos: int) -> list[dict]:
-        """Request code completions from the kernel.
-
-        Args:
-            code: The code string to retrieve completions for
-            cursor_pos: The position of the cursor in the code string
-
-        Returns:
-            A list of dictionaries defining completion entries. The dictionaries
-            contain ``text`` (the completion text), ``start_position`` (the stating
-            position of the completion text), and optionally ``display_meta``
-            (a string containing additional data about the completion type)
-
-        """
-        return self._aodo(
-            self.complete_(code, cursor_pos),
-            wait=True,
-            single=True,
-        )
-
-    async def history_(
+    async def history_async(
         self,
         pattern: str = "",
         n: int = 1,
         hist_access_type: str = "search",
-        timeout: int = 1,
+        timeout: int = 60,
     ) -> list[tuple[int, int, str]] | None:
         """Retrieve history from the kernel asynchronously."""
         await asyncio.sleep(0.1)  # Add a tiny timeout so we don't spam the kernel
@@ -933,29 +812,9 @@ class Kernel:
 
         return results
 
-    def history(
-        self, pattern: str = "", n: int = 1, hist_access_type: str = "search"
-    ) -> list[tuple[int, int, str]] | None:
-        """Retrieve history from the kernel.
-
-        Args:
-            pattern: The pattern to search for
-            n: the number of history items to return
-            hist_access_type: How to access the history ('range', 'tail' or 'search')
-
-        Returns:
-            A list of history items, consisting of tuples (session, line_number, input)
-
-        """
-        return self._aodo(
-            self.history_(pattern, n, hist_access_type),
-            wait=True,
-            single=True,
-        )
-
-    async def inspect_(
+    async def inspect_async(
         self,
-        code: str,
+        source: str,
         cursor_pos: int,
         detail_level: int = 0,
         timeout: int = 2,
@@ -978,7 +837,9 @@ class Kernel:
                 event.set()
 
         log.debug("Requesting contextual help from the kernel")
-        msg_id = self.kc.inspect(code, cursor_pos=cursor_pos, detail_level=detail_level)
+        msg_id = self.kc.inspect(
+            source, cursor_pos=cursor_pos, detail_level=detail_level
+        )
         self.msg_id_callbacks[msg_id].update({"done": process_inspect_reply})
 
         try:
@@ -988,35 +849,9 @@ class Kernel:
 
         return result
 
-    def inspect(
+    async def is_complete_async(
         self,
-        code: str,
-        cursor_pos: int,
-        callback: Callable[[dict[str, Any]], None] | None = None,
-    ) -> str:
-        """Request code inspection from the kernel.
-
-        Args:
-            code: The code string to retrieve completions for
-            cursor_pos: The position of the cursor in the code string
-            callback: A function to run when the inspection result arrives. The result
-                is passed as an argument.
-
-        Returns:
-            A string containing useful information about the code at the current cursor
-            position
-
-        """
-        return self._aodo(
-            self.inspect_(code, cursor_pos),
-            wait=False,
-            callback=callback,
-            single=True,
-        )
-
-    async def is_complete_(
-        self,
-        code: str,
+        source: str,
         timeout: int | float = 0.1,
     ) -> dict[str, Any]:
         """Ask the kernel to determine if code is complete asynchronously."""
@@ -1032,7 +867,7 @@ class Kernel:
             result.update(content)
             event.set()
 
-        msg_id = self.kc.is_complete(code)
+        msg_id = self.kc.is_complete(source)
         self.msg_id_callbacks[msg_id].update(
             {"completeness_status": process_is_complete_reply}
         )
@@ -1044,31 +879,10 @@ class Kernel:
 
         return result
 
-    def is_complete(
-        self,
-        code: str,
-        timeout: int | float = 0.1,
-        wait: bool = False,
-        callback: Callable[[dict[str, Any]], None] | None = None,
-    ) -> dict[str, Any]:
-        """Request code completeness status from the kernel.
-
-        Args:
-            code: The code string to check the completeness status of
-            timeout: How long to wait for a kernel response
-            wait: Whether to wait for the response
-            callback: A function to run when the inspection result arrives. The result
-                is passed as an argument.
-
-        Returns:
-            A string describing the completeness status
-
-        """
-        return self._aodo(
-            self.is_complete_(code, timeout),
-            wait=wait,
-            callback=callback,
-        )
+    def input(self, text: str) -> None:
+        """Send input to the kernel."""
+        if self.kc:
+            self.kc.input(text)
 
     def interrupt(self) -> None:
         """Interrupt the kernel.
@@ -1083,63 +897,20 @@ class Kernel:
             log.debug("Interrupting kernel %s", self.id)
             KernelManager.interrupt_kernel(self.km)
 
-    async def restart_(self) -> None:
+    async def restart_async(self) -> None:
         """Restart the kernel asyncchronously."""
-        self.dead = True
         log.debug("Restarting kernel `%s`", self.id)
+        # Cancel polling tasks
+        for task in self.poll_tasks:
+            task.cancel()
         self.error = None
         self.status = "starting"
-        await self.km.restart_kernel(now=True)
+        try:
+            await self.km.restart_kernel(now=True)
+            await self.post_start()
+        except asyncio.exceptions.InvalidStateError:
+            await self.start_async()
         log.debug("Kernel %s restarted", self.id)
-        await self.post_start_()
-
-    def restart(self, wait: bool = False, cb: Callable | None = None) -> None:
-        """Restart the current kernel."""
-        self._aodo(
-            self.restart_(),
-            wait=wait,
-            callback=cb,
-        )
-
-    def change(
-        self,
-        name: str | None,
-        connection_file: Path | None = None,
-        cb: Callable | None = None,
-    ) -> None:
-        """Change the kernel.
-
-        Args:
-            name: The name of the kernel to change to
-            connection_file: The path to the connection file to use
-            cb: Callback to run once restarted
-
-        """
-        from euporie.core.kernel.manager import EuporieKernelManager
-
-        self.connection_file = connection_file
-        self.status = "starting"
-
-        # Update the tab's kernel spec
-        spec = self.specs.get(name or "", {}).get("spec", {})
-        self.kernel_tab.metadata["kernelspec"] = {
-            "name": name,
-            "display_name": spec.get("display_name", ""),
-            "language": spec.get("language", ""),
-        }
-
-        # Stop the old kernel
-        if self.km.has_kernel:
-            self.stop()
-
-        # Create a new kernel manager instance
-        del self.km
-        kwargs = {} if name is None else {"kernel_name": name}
-        self.km = EuporieKernelManager(**kwargs)
-        self.error = None
-
-        # Start the kernel
-        self.start(cb=cb)
 
     def stop(self, cb: Callable | None = None, wait: bool = False) -> None:
         """Stop the current kernel.
@@ -1155,17 +926,9 @@ class Kernel:
             if callable(cb):
                 cb()
         else:
-            log.debug("Stopping kernel %s (wait=%s)", self.id, wait)
-            # This helps us leave a little earlier
-            if not wait:
-                self.interrupt()
-            self._aodo(
-                self.stop_(),
-                callback=cb,
-                wait=wait,
-            )
+            super().stop(cb, wait)
 
-    async def shutdown_(self) -> None:
+    async def shutdown_async(self) -> None:
         """Shut down the kernel and close the event loop if running in a thread."""
         # Stop monitoring the kernel
         if self.monitor_task is not None:
@@ -1175,23 +938,3 @@ class Kernel:
         # Stop kernel
         if self.km.has_kernel:
             await self.km.shutdown_kernel(now=True)
-        # Stop event loop
-        if self.threaded:
-            self.loop.stop()
-
-    def shutdown(self, wait: bool = False) -> None:
-        """Shutdown the kernel and close the kernel's thread.
-
-        This is intended to be run when the notebook is closed: the
-        :py:class:`~euporie.core.tabs.notebook.Kernel` cannot be restarted after this.
-
-        Args:
-            wait: Whether to block until shutdown completes
-
-        """
-        self._aodo(
-            self.shutdown_(),
-            wait=wait,
-        )
-        if self.threaded:
-            self.thread.join(timeout=5)