kernel

Classes:

KernelInterrupt –

Raised to interrupt the kernel.
Kernel –

A Jupyter kernel providing an IPython InteractiveShell.

KernelInterrupt ¶

Bases: InterruptedError

Raised to interrupt the kernel.

Referenced by:

Reference interface
- BaseKernelInterface interrupt
- BaseKernelInterface

Source code in src/async_kernel/common.py

class KernelInterrupt(InterruptedError):
    "Raised to interrupt the kernel."

Kernel ¶

Bases: HasTraits

A Jupyter kernel providing an IPython InteractiveShell.

Starting the kernel:

=== "From the shell"

    ``` shell
    async-kernel --kernel-name=async -f .
    ```

=== "Blocking"

    ```python
    import async_kernel.interface

    settings = {}  # Dotted name key/value pairs

    async_kernel.interface.start_kernel_zmq_interface(settings)
    ```

=== "Async"

    ```python
    settings = {}  # Dotted name key/value pairs
    async with Kernel(settings).interface:
        ...
    ```

Warning

Starting the kernel outside the main thread has the following implicatations: - Execute requests are run in the thread where the kernel is started. - The signal based kernel interrupt is not possible.

Origins

Referenced by:

Reference
- Reference Highlights
- asyncshell
  - AsyncInteractiveShell
  - asyncshell

Returned by:

Reference
- interface
  - BaseKernelInterface kernel
  - BaseKernelInterface kernel
- utils get_kernel

Used by:

Reference interface
- BaseKernelInterface kernel
- BaseKernelInterface kernel

Methods:

load_settings –

Load settings into the kernel.
load_connection_info –

Load connection info from a dict containing connection info.
do_shutdown –

Matches signature of ipykernel.kernelbase.Kernel.do_shutdown.
kernel_info_request –

Handle a kernel info request.
comm_info_request –

Handle a comm info request.
execute_request –

Handle a execute request.
complete_request –

Handle a completion request.
is_complete_request –

Handle a is_complete request.
inspect_request –

Handle a inspect request.
history_request –

Handle a history request.
comm_open –

Handle a comm open request.
comm_msg –

Handle a comm msg request.
comm_close –

Handle a comm close request.
interrupt_request –

Handle an interrupt request.
shutdown_request –

Handle a shutdown request.
debug_request –

Handle a debug request.
create_subshell_request –

Handle a create subshell request.
delete_subshell_request –

Handle a delete subshell request.
list_subshell_request –

Handle a list subshell request.
get_connection_info –

Return the connection info as a dict.
get_parent –

A convenience method to access the 'message' in the current context if there is one.
do_complete –

Matches signature of ipykernel.kernelbase.Kernel.do_complete.
do_inspect –

Matches signature of ipykernel.kernelbase.Kernel.do_inspect.
do_history –

Matches signature of ipykernel.kernelbase.Kernel.do_history.
do_execute –

Matches signature of ipykernel.kernelbase.Kernel.do_execute.
getpass –

Matches signature of ipykernel.kernelbase.Kernel.getpass.
raw_input –

Matches signature of ipykernel.kernelbase.Kernel.raw_input.

Attributes:

interface (Instance[BaseKernelInterface]) –

The abstraction to interface with the kernel.
subshell_manager –

Dedicated to management of sub shells.
quiet –

Only send stdout/stderr to output stream.
print_kernel_messages –

When enabled the kernel will print startup, shutdown and terminal errors.
connection_file (TraitType[Path, Path | str]) –

JSON file in which to store connection info.
kernel_name –

The kernels name - if it contains 'trio' a trio backend will be used instead of an asyncio backend.
help_links –

A list of links provided kernel info request.
supported_features –

A list of features supported by the kernel.
banner –

The banner to display in a console.
log –

The logging adapter.
main_shell (Fixed[Self, AsyncInteractiveShell]) –

The interactive shell.
comm_manager –

Creates async_kernel.comm.Comm instances and maintains a mapping to comm_id to Comm instances.
event_started –

An event that occurs when the kernel is started.
event_stopped –

An event that occurs when the kernel is stopped.
kernel_info (dict[str, Any]) –

Info provided to a kernel info request.
settings (dict[str, Any]) –

Settings that have been set to customise the behaviour of the kernel.
shell (AsyncInteractiveShell | AsyncInteractiveSubshell) –

The shell given the current context.
caller (Caller) –

The caller for the shell channel.

Source code in src/async_kernel/kernel.py

class Kernel(traitlets.HasTraits):
    """
    A Jupyter kernel providing an [IPython InteractiveShell][async_kernel.asyncshell.AsyncInteractiveShell].

    Starting the kernel:

        === "From the shell"

            ``` shell
            async-kernel --kernel-name=async -f .
            ```

        === "Blocking"

            ```python
            import async_kernel.interface

            settings = {}  # Dotted name key/value pairs

            async_kernel.interface.start_kernel_zmq_interface(settings)
            ```

        === "Async"

            ```python
            settings = {}  # Dotted name key/value pairs
            async with Kernel(settings).interface:
                ...
            ```

    Warning:
        Starting the kernel outside the main thread has the following implicatations:
            - Execute requests are run in the thread where the kernel is started.
            - The signal based kernel interrupt is not possible.

    Origins:
        - [IPyKernel Kernel][ipykernel.kernelbase.Kernel]
        - [IPyKernel IPKernelApp][ipykernel.kernelapp.IPKernelApp]
        - [IPyKernel IPythonKernel][ipykernel.ipkernel.IPythonKernel]
    """

    _instance: Self | None = None
    _initialised = False
    _restart = False

    _settings = Fixed(dict)

    interface: traitlets.Instance[BaseKernelInterface] = traitlets.Instance(BaseKernelInterface)
    "The abstraction to interface with the kernel."

    subshell_manager = SubshellManager
    "Dedicated to management of sub shells."

    quiet = traitlets.Bool(True)
    "Only send stdout/stderr to output stream."

    print_kernel_messages = traitlets.Bool(True)
    "When enabled the kernel will print startup, shutdown and terminal errors."

    connection_file: traitlets.TraitType[Path, Path | str] = traitlets.TraitType()
    """
    JSON file in which to store connection info.

    `"kernel-<pid>.json"`

    This file will contain the IP, ports, and authentication key needed to connect
    clients to this kernel. By default, this file will be created in the security dir
    of the current profile, but can be specified by absolute path.
    """

    kernel_name = traitlets.CUnicode()
    "The kernels name - if it contains 'trio' a trio backend will be used instead of an asyncio backend."

    help_links = traitlets.List(trait=traitlets.Dict())
    "A list of links provided kernel info request."

    supported_features = traitlets.List(traitlets.Unicode())
    "A list of features supported by the kernel."

    banner = traitlets.Unicode()
    "The banner to display in a console."

    log = traitlets.Instance(logging.LoggerAdapter)
    "The logging adapter."

    # Public fixed
    main_shell: Fixed[Self, AsyncInteractiveShell] = Fixed(AsyncInteractiveShell)
    "The interactive shell."

    comm_manager = Fixed(CommManager)
    "Creates [async_kernel.comm.Comm][] instances and maintains a mapping to `comm_id` to `Comm` instances."

    event_started = Fixed(Event)
    "An event that occurs when the kernel is started."

    event_stopped = Fixed(Event)
    "An event that occurs when the kernel is stopped."

    def __new__(cls, settings: dict | None = None, /) -> Self:  # noqa: ARG004
        #  There is only one instance (including subclasses).
        if not (instance := Kernel._instance):
            Kernel._instance = instance = super().__new__(cls)
        return instance  # pyright: ignore[reportReturnType]

    def __init__(self, settings: dict | None = None, /) -> None:
        if not self._initialised:
            self._initialised = True
            assert self.main_shell
            super().__init__()
            if not os.environ.get("MPLBACKEND"):
                os.environ["MPLBACKEND"] = "module://matplotlib_inline.backend_inline"
            if not os.environ.get("UV_PROJECT_ENVIRONMENT"):
                os.environ["UV_PROJECT_ENVIRONMENT"] = sys.prefix
        if settings:
            self.load_settings(settings)

    @override
    def __repr__(self) -> str:
        info = [f"{k}={v}" for k, v in self.settings.items()]
        return f"{self.__class__.__name__}<{', '.join(info)}>"

    @traitlets.default("log")
    def _default_log(self) -> LoggerAdapter[Logger]:
        return logging.LoggerAdapter(logging.getLogger(self.__class__.__name__))

    @traitlets.default("kernel_name")
    def _default_kernel_name(self) -> Literal["async-trio", "async"]:
        return "async-trio" if current_async_library(failsafe=True) == "trio" else "async"

    @traitlets.default("interface")
    def default_interface(self) -> ZMQKernelInterface:
        from async_kernel.interface.zmq import ZMQKernelInterface  # noqa: PLC0415

        return ZMQKernelInterface()

    @traitlets.default("connection_file")
    def _default_connection_file(self) -> Path:
        return Path(jupyter_runtime_dir()).joinpath(f"kernel-{uuid.uuid4()}.json")

    @traitlets.observe("connection_file")
    def _observe_connection_file(self, change) -> None:
        if not self.interface.callers and (path := self.connection_file).exists():
            self.log.debug("Loading connection file %s", path)
            self.load_connection_info(json.loads(path.read_bytes()))

    @traitlets.validate("connection_file")
    def _validate_connection_file(self, proposal) -> Path:
        return pathlib.Path(proposal.value).expanduser()

    @traitlets.default("help_links")
    def _default_help_links(self) -> tuple[dict[str, str], ...]:
        return (
            {
                "text": "Async Kernel Reference ",
                "url": "https://fleming79.github.io/async-kernel/",
            },
            {
                "text": "IPython Reference",
                "url": "https://ipython.readthedocs.io/en/stable/",
            },
            {
                "text": "IPython magic Reference",
                "url": "https://ipython.readthedocs.io/en/stable/interactive/magics.html",
            },
            {
                "text": "Matplotlib ipympl Reference",
                "url": "https://matplotlib.org/ipympl/",
            },
            {
                "text": "Matplotlib Reference",
                "url": "https://matplotlib.org/contents.html",
            },
        )

    @traitlets.default("supported_features")
    def _default_supported_features(self) -> list[str]:
        features = ["kernel subshells"]
        if self.interface.debugger:
            features.append("debugger")
        return features

    @traitlets.default("banner")
    def _default_banner(self) -> str:
        return self.main_shell.banner

    @property
    def kernel_info(self) -> dict[str, Any]:
        "Info provided to a kernel info request."

        return {
            "protocol_version": async_kernel.kernel_protocol_version,
            "implementation": async_kernel.distribution_name,
            "implementation_version": async_kernel.__version__,
            "language_info": async_kernel.kernel_protocol_version_info,
            "banner": self.banner,
            "help_links": self.help_links,
            "debugger": bool(self.interface.debugger),
            "kernel_name": self.kernel_name,
            "supported_features": self.supported_features,
        }

    @property
    def settings(self) -> dict[str, Any]:
        "Settings that have been set to customise the behaviour of the kernel."
        return {k: getattr(self, k) for k in ("kernel_name", "connection_file")} | self._settings

    @property
    def shell(self) -> AsyncInteractiveShell | AsyncInteractiveSubshell:
        """
        The shell given the current context.

        Notes:
            - The `subshell_id` of the main shell is `None`.
        """
        return self.subshell_manager.get_shell()

    @property
    def caller(self) -> Caller:
        "The caller for the shell channel."
        return self.interface.callers[Channel.shell]

    def load_settings(self, settings: dict[str, Any]) -> None:
        """
        Load settings into the kernel.

        Permitted until the kernel async context has been entered.

        Args:
            settings:
                key: dotted.path.of.attribute.
                value: The value to set.
        """
        if self.event_started:
            msg = "It is too late to load settings!"
            raise RuntimeError(msg)
        settings_ = self._settings or {"kernel_name": self.kernel_name}
        for k, v in settings.items():
            settings_ |= utils.setattr_nested(self, k, v)
        self._settings.update(settings_)

    def load_connection_info(self, info: dict[str, Any]) -> None:
        """
        Load connection info from a dict containing connection info.

        Typically this data comes from a connection file
        and is called by load_connection_file.

        Args:
            info: Dictionary containing connection_info. See the connection_file spec for details.
        """
        self.interface.load_connection_info(info)

    async def do_shutdown(self, restart: bool) -> None:
        "Matches signature of [ipykernel.kernelbase.Kernel.do_shutdown][]."
        assert self.event_stopped
        self.log.info("Kernel shutdown: %s", self)
        await anyio.sleep(0.1)
        self.shell.stop(force=True)
        for comm in tuple(self.comm_manager.comms.values()):
            comm.close(deleting=True)
        self.comm_manager.comms.clear()
        await anyio.sleep(0.1)
        CommManager._instance = None  # pyright: ignore[reportPrivateUsage]
        Kernel._instance = None
        self.log.info("Kernel shutdown complete: %s", self)

    async def kernel_info_request(self, job: Job[Content], /) -> Content:
        """Handle a [kernel info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-info)."""
        return self.kernel_info

    async def comm_info_request(self, job: Job[Content], /) -> Content:
        """Handle a [comm info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-info)."""
        c = job["msg"]["content"]
        target_name = c.get("target_name", None)
        comms = {
            k: {"target_name": v.target_name}
            for (k, v) in tuple(self.comm_manager.comms.items())
            if v.target_name == target_name or target_name is None
        }
        return {"comms": comms}

    async def execute_request(self, job: Job[ExecuteContent], /) -> Content:
        """Handle a [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
        return await self.shell.execute_request(
            cell_id=job["msg"]["metadata"].get("cellId"),
            received_time=job["received_time"],
            **job["msg"]["content"],  # pyright: ignore[reportArgumentType]
        )

    async def complete_request(self, job: Job[Content], /) -> Content:
        """Handle a [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
        return await self.shell.do_complete_request(
            code=job["msg"]["content"].get("code", ""), cursor_pos=job["msg"]["content"].get("cursor_pos", 0)
        )

    async def is_complete_request(self, job: Job[Content], /) -> Content:
        """Handle a [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
        return await self.shell.is_complete_request(job["msg"]["content"].get("code", ""))

    async def inspect_request(self, job: Job[Content], /) -> Content:
        """Handle a [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
        c = job["msg"]["content"]
        return await self.shell.inspect_request(
            code=c.get("code", ""),
            cursor_pos=c.get("cursor_pos", 0),
            detail_level=c.get("detail_level", 0),
        )

    async def history_request(self, job: Job[Content], /) -> Content:
        """Handle a [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
        return await self.shell.history_request(**job["msg"]["content"])

    async def comm_open(self, job: Job[Content], /) -> None:
        """Handle a [comm open request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#opening-a-comm)."""
        self.comm_manager.comm_open(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

    async def comm_msg(self, job: Job[Content], /) -> None:
        """Handle a [comm msg request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-messages)."""
        self.comm_manager.comm_msg(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

    async def comm_close(self, job: Job[Content], /) -> None:
        """Handle a [comm close request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#tearing-down-comms)."""
        self.comm_manager.comm_close(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

    async def interrupt_request(self, job: Job[Content], /) -> Content:
        """Handle an [interrupt request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-interrupt)."""
        self.interface.interrupt()
        return {}

    async def shutdown_request(self, job: Job[Content], /) -> Content:
        """Handle a [shutdown request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-shutdown)."""
        self._restart = job["msg"]["content"].get("restart", False)
        self.interface.stop()
        return {"restart": self._restart}

    async def debug_request(self, job: Job[Content], /) -> Content:
        """Handle a [debug request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#debug-request)."""
        return await self.interface.debugger.process_request(job["msg"]["content"])  # pyright: ignore[reportOptionalMemberAccess]

    async def create_subshell_request(self: Kernel, job: Job[Content], /) -> Content:
        """Handle a [create subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#create-subshell)."""

        return {"subshell_id": self.subshell_manager.create_subshell(protected=False).subshell_id}

    async def delete_subshell_request(self, job: Job[Content], /) -> Content:
        """Handle a [delete subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#delete-subshell)."""
        self.subshell_manager.delete_subshell(job["msg"]["content"]["subshell_id"])
        return {}

    async def list_subshell_request(self, job: Job[Content], /) -> Content:
        """Handle a [list subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#list-subshells)."""
        return {"subshell_id": list(self.subshell_manager.list_subshells())}

    def get_connection_info(self) -> dict[str, Any]:
        """Return the connection info as a dict."""
        return json.loads(self.connection_file.read_bytes())

    def get_parent(self) -> Message[dict[str, Any]] | None:
        """
        A convenience method to access the 'message' in the current context if there is one.

        'parent' is the parameter name used by [Session.send][jupyter_client.session.Session.send] to provide context when sending a reply.

        See also:
            - [ipywidgets.Output][ipywidgets.widgets.widget_output.Output]:
                Uses `get_ipython().kernel.get_parent()` to obtain the `msg_id` which
                is used to 'capture' output when its context has been acquired.
        """
        return utils.get_parent()

    async def do_complete(self, code: str, cursor_pos: int | None) -> Content:
        "Matches signature of [ipykernel.kernelbase.Kernel.do_complete][]."
        return await self.shell.do_complete_request(code=code, cursor_pos=cursor_pos)

    async def do_inspect(self, code: str, cursor_pos: int | None, detail_level=0, omit_sections=()) -> Content:
        "Matches signature of [ipykernel.kernelbase.Kernel.do_inspect][]."
        return await self.shell.inspect_request(code=code, cursor_pos=cursor_pos)  # pyright: ignore[reportArgumentType]

    async def do_history(
        self,
        hist_access_type,
        output,
        raw,
        session=None,
        start=None,
        stop=None,
        n=None,
        pattern=None,
        unique=False,
    ) -> Content:
        "Matches signature of [ipykernel.kernelbase.Kernel.do_history][]."
        return await self.shell.history_request(
            output=output,
            raw=raw,
            hist_access_type=hist_access_type,
            session=session,  # pyright: ignore[reportArgumentType]
            start=start,  # pyright: ignore[reportArgumentType]
            stop=stop,
        )

    async def do_execute(
        self,
        code: str,
        silent: bool,
        store_history: bool = True,
        user_expressions: dict | None = None,
        allow_stdin=False,
        *,
        cell_id: str | None = None,
        **_ignored,
    ) -> Content:
        "Matches signature of [ipykernel.kernelbase.Kernel.do_execute][]."
        content = ExecuteContent(
            code=code,
            silent=silent,
            store_history=store_history,
            user_expressions=user_expressions or {},
            allow_stdin=allow_stdin,
            stop_on_error=False,
        )
        msg = self.interface.msg("execute_request", content=content)  # pyright: ignore[reportArgumentType]
        job = Job(msg=msg, ident=[], received_time=time.monotonic())
        token = utils._job_var.set(job)  # pyright: ignore[reportPrivateUsage]
        try:
            return await self.shell.execute_request(
                code=code,
                silent=silent,
                store_history=store_history,
                user_expressions=user_expressions,
                allow_stdin=allow_stdin,
                cell_id=cell_id,
                received_time=job["received_time"],
            )
        finally:
            utils._job_var.reset(token)  # pyright: ignore[reportPrivateUsage]

    def getpass(self, prompt="", stream=None) -> str:
        "Matches signature of [ipykernel.kernelbase.Kernel.getpass][]."
        return self.interface.getpass(prompt)

    def raw_input(self, prompt="") -> str:
        "Matches signature of [ipykernel.kernelbase.Kernel.raw_input][]."
        return self.interface.raw_input(prompt)

interface `class-attribute` `instance-attribute` ¶

interface: Instance[BaseKernelInterface] = Instance(BaseKernelInterface)

The abstraction to interface with the kernel.

subshell_manager `class-attribute` `instance-attribute` ¶

subshell_manager = SubshellManager

Dedicated to management of sub shells.

quiet `class-attribute` `instance-attribute` ¶

quiet = Bool(True)

Only send stdout/stderr to output stream.

print_kernel_messages `class-attribute` `instance-attribute` ¶

print_kernel_messages = Bool(True)

When enabled the kernel will print startup, shutdown and terminal errors.

connection_file `class-attribute` `instance-attribute` ¶

connection_file: TraitType[Path, Path | str] = TraitType()

JSON file in which to store connection info.

"kernel-<pid>.json"

This file will contain the IP, ports, and authentication key needed to connect clients to this kernel. By default, this file will be created in the security dir of the current profile, but can be specified by absolute path.

kernel_name `class-attribute` `instance-attribute` ¶

kernel_name = CUnicode()

The kernels name - if it contains 'trio' a trio backend will be used instead of an asyncio backend.

help_links `class-attribute` `instance-attribute` ¶

help_links = List(trait=Dict())

A list of links provided kernel info request.

supported_features `class-attribute` `instance-attribute` ¶

supported_features = List(Unicode())

A list of features supported by the kernel.

banner `class-attribute` `instance-attribute` ¶

banner = Unicode()

The banner to display in a console.

log `class-attribute` `instance-attribute` ¶

log = Instance(LoggerAdapter)

The logging adapter.

main_shell `class-attribute` `instance-attribute` ¶

main_shell: Fixed[Self, AsyncInteractiveShell] = Fixed(AsyncInteractiveShell)

The interactive shell.

comm_manager `class-attribute` `instance-attribute` ¶

comm_manager = Fixed(CommManager)

Creates async_kernel.comm.Comm instances and maintains a mapping to comm_id to Comm instances.

event_started `class-attribute` `instance-attribute` ¶

event_started = Fixed(Event)

An event that occurs when the kernel is started.

event_stopped `class-attribute` `instance-attribute` ¶

event_stopped = Fixed(Event)

An event that occurs when the kernel is stopped.

kernel_info `property` ¶

kernel_info: dict[str, Any]

Info provided to a kernel info request.

settings `property` ¶

settings: dict[str, Any]

Settings that have been set to customise the behaviour of the kernel.

shell `property` ¶

shell: AsyncInteractiveShell | AsyncInteractiveSubshell

The shell given the current context.

Notes

The subshell_id of the main shell is None.

caller `property` ¶

caller: Caller

The caller for the shell channel.

load_settings ¶

load_settings(settings: dict[str, Any]) -> None

Load settings into the kernel.

Permitted until the kernel async context has been entered.

Parameters:

settings ¶
(dict[str, Any]) –

key: dotted.path.of.attribute. value: The value to set.

Source code in src/async_kernel/kernel.py

def load_settings(self, settings: dict[str, Any]) -> None:
    """
    Load settings into the kernel.

    Permitted until the kernel async context has been entered.

    Args:
        settings:
            key: dotted.path.of.attribute.
            value: The value to set.
    """
    if self.event_started:
        msg = "It is too late to load settings!"
        raise RuntimeError(msg)
    settings_ = self._settings or {"kernel_name": self.kernel_name}
    for k, v in settings.items():
        settings_ |= utils.setattr_nested(self, k, v)
    self._settings.update(settings_)

load_connection_info ¶

load_connection_info(info: dict[str, Any]) -> None

Load connection info from a dict containing connection info.

Typically this data comes from a connection file and is called by load_connection_file.

Parameters:

info ¶
(dict[str, Any]) –

Dictionary containing connection_info. See the connection_file spec for details.

Source code in src/async_kernel/kernel.py

def load_connection_info(self, info: dict[str, Any]) -> None:
    """
    Load connection info from a dict containing connection info.

    Typically this data comes from a connection file
    and is called by load_connection_file.

    Args:
        info: Dictionary containing connection_info. See the connection_file spec for details.
    """
    self.interface.load_connection_info(info)

do_shutdown `async` ¶

do_shutdown(restart: bool) -> None

Matches signature of ipykernel.kernelbase.Kernel.do_shutdown.

Source code in src/async_kernel/kernel.py

async def do_shutdown(self, restart: bool) -> None:
    "Matches signature of [ipykernel.kernelbase.Kernel.do_shutdown][]."
    assert self.event_stopped
    self.log.info("Kernel shutdown: %s", self)
    await anyio.sleep(0.1)
    self.shell.stop(force=True)
    for comm in tuple(self.comm_manager.comms.values()):
        comm.close(deleting=True)
    self.comm_manager.comms.clear()
    await anyio.sleep(0.1)
    CommManager._instance = None  # pyright: ignore[reportPrivateUsage]
    Kernel._instance = None
    self.log.info("Kernel shutdown complete: %s", self)

kernel_info_request `async` ¶

kernel_info_request(job: Job[Content]) -> Content

Handle a kernel info request.

Referenced by:

Reference typing MsgType kernel_info_request

Source code in src/async_kernel/kernel.py

async def kernel_info_request(self, job: Job[Content], /) -> Content:
    """Handle a [kernel info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-info)."""
    return self.kernel_info

comm_info_request `async` ¶

comm_info_request(job: Job[Content]) -> Content

Handle a comm info request.

Referenced by:

Reference typing MsgType comm_info_request

Source code in src/async_kernel/kernel.py

async def comm_info_request(self, job: Job[Content], /) -> Content:
    """Handle a [comm info request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-info)."""
    c = job["msg"]["content"]
    target_name = c.get("target_name", None)
    comms = {
        k: {"target_name": v.target_name}
        for (k, v) in tuple(self.comm_manager.comms.items())
        if v.target_name == target_name or target_name is None
    }
    return {"comms": comms}

execute_request `async` ¶

execute_request(job: Job[ExecuteContent]) -> Content

Handle a execute request.

Referenced by:

Reference typing MsgType execute_request

Source code in src/async_kernel/kernel.py

async def execute_request(self, job: Job[ExecuteContent], /) -> Content:
    """Handle a [execute request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#execute)."""
    return await self.shell.execute_request(
        cell_id=job["msg"]["metadata"].get("cellId"),
        received_time=job["received_time"],
        **job["msg"]["content"],  # pyright: ignore[reportArgumentType]
    )

complete_request `async` ¶

complete_request(job: Job[Content]) -> Content

Handle a completion request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def complete_request(self, job: Job[Content], /) -> Content:
    """Handle a [completion request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#completion)."""
    return await self.shell.do_complete_request(
        code=job["msg"]["content"].get("code", ""), cursor_pos=job["msg"]["content"].get("cursor_pos", 0)
    )

is_complete_request `async` ¶

is_complete_request(job: Job[Content]) -> Content

Handle a is_complete request.

Referenced by:

Reference typing MsgType is_complete_request

Source code in src/async_kernel/kernel.py

async def is_complete_request(self, job: Job[Content], /) -> Content:
    """Handle a [is_complete request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#code-completeness)."""
    return await self.shell.is_complete_request(job["msg"]["content"].get("code", ""))

inspect_request `async` ¶

inspect_request(job: Job[Content]) -> Content

Handle a inspect request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def inspect_request(self, job: Job[Content], /) -> Content:
    """Handle a [inspect request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#introspection)."""
    c = job["msg"]["content"]
    return await self.shell.inspect_request(
        code=c.get("code", ""),
        cursor_pos=c.get("cursor_pos", 0),
        detail_level=c.get("detail_level", 0),
    )

history_request `async` ¶

history_request(job: Job[Content]) -> Content

Handle a history request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def history_request(self, job: Job[Content], /) -> Content:
    """Handle a [history request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#history)."""
    return await self.shell.history_request(**job["msg"]["content"])

comm_open `async` ¶

comm_open(job: Job[Content]) -> None

Handle a comm open request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def comm_open(self, job: Job[Content], /) -> None:
    """Handle a [comm open request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#opening-a-comm)."""
    self.comm_manager.comm_open(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

comm_msg `async` ¶

comm_msg(job: Job[Content]) -> None

Handle a comm msg request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def comm_msg(self, job: Job[Content], /) -> None:
    """Handle a [comm msg request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#comm-messages)."""
    self.comm_manager.comm_msg(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

comm_close `async` ¶

comm_close(job: Job[Content]) -> None

Handle a comm close request.

Referenced by:

Reference typing MsgType comm_close

Source code in src/async_kernel/kernel.py

async def comm_close(self, job: Job[Content], /) -> None:
    """Handle a [comm close request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#tearing-down-comms)."""
    self.comm_manager.comm_close(stream=None, ident=None, msg=job["msg"])  # pyright: ignore[reportArgumentType]

interrupt_request `async` ¶

interrupt_request(job: Job[Content]) -> Content

Handle an interrupt request.

Referenced by:

Reference typing MsgType interrupt_request

Source code in src/async_kernel/kernel.py

async def interrupt_request(self, job: Job[Content], /) -> Content:
    """Handle an [interrupt request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-interrupt)."""
    self.interface.interrupt()
    return {}

shutdown_request `async` ¶

shutdown_request(job: Job[Content]) -> Content

Handle a shutdown request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def shutdown_request(self, job: Job[Content], /) -> Content:
    """Handle a [shutdown request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#kernel-shutdown)."""
    self._restart = job["msg"]["content"].get("restart", False)
    self.interface.stop()
    return {"restart": self._restart}

debug_request `async` ¶

debug_request(job: Job[Content]) -> Content

Handle a debug request.

Referenced by:

Reference typing MsgType

Source code in src/async_kernel/kernel.py

async def debug_request(self, job: Job[Content], /) -> Content:
    """Handle a [debug request](https://jupyter-client.readthedocs.io/en/stable/messaging.html#debug-request)."""
    return await self.interface.debugger.process_request(job["msg"]["content"])  # pyright: ignore[reportOptionalMemberAccess]

create_subshell_request `async` ¶

create_subshell_request(job: Job[Content]) -> Content

Handle a create subshell request.

Referenced by:

Reference typing MsgType create_subshell_request

Source code in src/async_kernel/kernel.py

async def create_subshell_request(self: Kernel, job: Job[Content], /) -> Content:
    """Handle a [create subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#create-subshell)."""

    return {"subshell_id": self.subshell_manager.create_subshell(protected=False).subshell_id}

delete_subshell_request `async` ¶

delete_subshell_request(job: Job[Content]) -> Content

Handle a delete subshell request.

Referenced by:

Reference typing MsgType delete_subshell_request

Source code in src/async_kernel/kernel.py

async def delete_subshell_request(self, job: Job[Content], /) -> Content:
    """Handle a [delete subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#delete-subshell)."""
    self.subshell_manager.delete_subshell(job["msg"]["content"]["subshell_id"])
    return {}

list_subshell_request `async` ¶

list_subshell_request(job: Job[Content]) -> Content

Handle a list subshell request.

Source code in src/async_kernel/kernel.py

async def list_subshell_request(self, job: Job[Content], /) -> Content:
    """Handle a [list subshell request](https://jupyter.org/enhancement-proposals/91-kernel-subshells/kernel-subshells.html#list-subshells)."""
    return {"subshell_id": list(self.subshell_manager.list_subshells())}

get_connection_info ¶

get_connection_info() -> dict[str, Any]

Return the connection info as a dict.

Source code in src/async_kernel/kernel.py

def get_connection_info(self) -> dict[str, Any]:
    """Return the connection info as a dict."""
    return json.loads(self.connection_file.read_bytes())

get_parent ¶

get_parent() -> Message[dict[str, Any]] | None

A convenience method to access the 'message' in the current context if there is one.

'parent' is the parameter name used by Session.send to provide context when sending a reply.

do_complete `async` ¶

do_complete(code: str, cursor_pos: int | None) -> Content

Matches signature of ipykernel.kernelbase.Kernel.do_complete.

Source code in src/async_kernel/kernel.py

async def do_complete(self, code: str, cursor_pos: int | None) -> Content:
    "Matches signature of [ipykernel.kernelbase.Kernel.do_complete][]."
    return await self.shell.do_complete_request(code=code, cursor_pos=cursor_pos)

do_inspect `async` ¶

do_inspect(
    code: str, cursor_pos: int | None, detail_level=0, omit_sections=()
) -> Content

Matches signature of ipykernel.kernelbase.Kernel.do_inspect.

Source code in src/async_kernel/kernel.py

async def do_inspect(self, code: str, cursor_pos: int | None, detail_level=0, omit_sections=()) -> Content:
    "Matches signature of [ipykernel.kernelbase.Kernel.do_inspect][]."
    return await self.shell.inspect_request(code=code, cursor_pos=cursor_pos)  # pyright: ignore[reportArgumentType]

do_history `async` ¶

do_history(
    hist_access_type,
    output,
    raw,
    session=None,
    start=None,
    stop=None,
    n=None,
    pattern=None,
    unique=False,
) -> Content

Matches signature of ipykernel.kernelbase.Kernel.do_history.

Source code in src/async_kernel/kernel.py

async def do_history(
    self,
    hist_access_type,
    output,
    raw,
    session=None,
    start=None,
    stop=None,
    n=None,
    pattern=None,
    unique=False,
) -> Content:
    "Matches signature of [ipykernel.kernelbase.Kernel.do_history][]."
    return await self.shell.history_request(
        output=output,
        raw=raw,
        hist_access_type=hist_access_type,
        session=session,  # pyright: ignore[reportArgumentType]
        start=start,  # pyright: ignore[reportArgumentType]
        stop=stop,
    )

do_execute `async` ¶

do_execute(
    code: str,
    silent: bool,
    store_history: bool = True,
    user_expressions: dict | None = None,
    allow_stdin=False,
    *,
    cell_id: str | None = None,
    **_ignored,
) -> Content

Matches signature of ipykernel.kernelbase.Kernel.do_execute.

Source code in src/async_kernel/kernel.py

async def do_execute(
    self,
    code: str,
    silent: bool,
    store_history: bool = True,
    user_expressions: dict | None = None,
    allow_stdin=False,
    *,
    cell_id: str | None = None,
    **_ignored,
) -> Content:
    "Matches signature of [ipykernel.kernelbase.Kernel.do_execute][]."
    content = ExecuteContent(
        code=code,
        silent=silent,
        store_history=store_history,
        user_expressions=user_expressions or {},
        allow_stdin=allow_stdin,
        stop_on_error=False,
    )
    msg = self.interface.msg("execute_request", content=content)  # pyright: ignore[reportArgumentType]
    job = Job(msg=msg, ident=[], received_time=time.monotonic())
    token = utils._job_var.set(job)  # pyright: ignore[reportPrivateUsage]
    try:
        return await self.shell.execute_request(
            code=code,
            silent=silent,
            store_history=store_history,
            user_expressions=user_expressions,
            allow_stdin=allow_stdin,
            cell_id=cell_id,
            received_time=job["received_time"],
        )
    finally:
        utils._job_var.reset(token)  # pyright: ignore[reportPrivateUsage]

getpass ¶

getpass(prompt='', stream=None) -> str

Matches signature of ipykernel.kernelbase.Kernel.getpass.

Source code in src/async_kernel/kernel.py

def getpass(self, prompt="", stream=None) -> str:
    "Matches signature of [ipykernel.kernelbase.Kernel.getpass][]."
    return self.interface.getpass(prompt)

raw_input ¶

raw_input(prompt='') -> str

Matches signature of ipykernel.kernelbase.Kernel.raw_input.

Source code in src/async_kernel/kernel.py

def raw_input(self, prompt="") -> str:
    "Matches signature of [ipykernel.kernelbase.Kernel.raw_input][]."
    return self.interface.raw_input(prompt)

kernel

KernelInterrupt ¶

Kernel ¶

interface class-attribute instance-attribute ¶

subshell_manager class-attribute instance-attribute ¶

quiet class-attribute instance-attribute ¶

print_kernel_messages class-attribute instance-attribute ¶

connection_file class-attribute instance-attribute ¶

kernel_name class-attribute instance-attribute ¶

help_links class-attribute instance-attribute ¶

supported_features class-attribute instance-attribute ¶

banner class-attribute instance-attribute ¶

log class-attribute instance-attribute ¶

main_shell class-attribute instance-attribute ¶

comm_manager class-attribute instance-attribute ¶

event_started class-attribute instance-attribute ¶

event_stopped class-attribute instance-attribute ¶

kernel_info property ¶

settings property ¶

shell property ¶

caller property ¶

load_settings ¶

settings ¶

load_connection_info ¶

info ¶

do_shutdown async ¶

kernel_info_request async ¶

comm_info_request async ¶

execute_request async ¶

complete_request async ¶

is_complete_request async ¶

inspect_request async ¶

history_request async ¶

comm_open async ¶

comm_msg async ¶

comm_close async ¶

interrupt_request async ¶

shutdown_request async ¶

debug_request async ¶

create_subshell_request async ¶

delete_subshell_request async ¶

list_subshell_request async ¶

get_connection_info ¶

get_parent ¶

do_complete async ¶

do_inspect async ¶

do_history async ¶

do_execute async ¶

getpass ¶

raw_input ¶

interface `class-attribute` `instance-attribute` ¶

subshell_manager `class-attribute` `instance-attribute` ¶

quiet `class-attribute` `instance-attribute` ¶

print_kernel_messages `class-attribute` `instance-attribute` ¶

connection_file `class-attribute` `instance-attribute` ¶

kernel_name `class-attribute` `instance-attribute` ¶

help_links `class-attribute` `instance-attribute` ¶

supported_features `class-attribute` `instance-attribute` ¶

banner `class-attribute` `instance-attribute` ¶

log `class-attribute` `instance-attribute` ¶

main_shell `class-attribute` `instance-attribute` ¶

comm_manager `class-attribute` `instance-attribute` ¶

event_started `class-attribute` `instance-attribute` ¶

event_stopped `class-attribute` `instance-attribute` ¶

kernel_info `property` ¶

settings `property` ¶

shell `property` ¶

caller `property` ¶

`settings` ¶

`info` ¶

do_shutdown `async` ¶

kernel_info_request `async` ¶

comm_info_request `async` ¶

execute_request `async` ¶

complete_request `async` ¶

is_complete_request `async` ¶

inspect_request `async` ¶

history_request `async` ¶

comm_open `async` ¶

comm_msg `async` ¶

comm_close `async` ¶

interrupt_request `async` ¶

shutdown_request `async` ¶

debug_request `async` ¶

create_subshell_request `async` ¶

delete_subshell_request `async` ¶

list_subshell_request `async` ¶

do_complete `async` ¶

do_inspect `async` ¶

do_history `async` ¶

do_execute `async` ¶