async-kernel 0.13.3__tar.gz → 0.14.0__tar.gz

{async_kernel-0.13.3 → async_kernel-0.14.0}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.14.0] - 2026-03-24
+
+### <!-- 0 --> 🏗️ Breaking changes
+
+- Rename loop to host and Loop to Hosts [#370](https://github.com/fleming79/async-kernel/pull/370)
+
+### <!-- 5 --> 📝 Documentation
+
+- Update event loop documentation. [#372](https://github.com/fleming79/async-kernel/pull/372)
+
+- Update readme [#371](https://github.com/fleming79/async-kernel/pull/371)
+
 ## [0.13.3] - 2026-03-23
 
 ### <!-- 0 --> 🏗️ Breaking changes
@@ -15,6 +27,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.13.3 [#369](https://github.com/fleming79/async-kernel/pull/369)
+
 - Minor SingleConsumerAsyncQueue optimization. [#368](https://github.com/fleming79/async-kernel/pull/368)
 
 - Fixtest_command_start_kernel_enable_matplotlib [#367](https://github.com/fleming79/async-kernel/pull/367)
@@ -1023,6 +1037,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Bump the actions group across 1 directory with 2 updates [#3](https://github.com/fleming79/async-kernel/pull/3)
 
+[0.14.0]: https://github.com/fleming79/async-kernel/compare/v0.13.3..v0.14.0
 [0.13.3]: https://github.com/fleming79/async-kernel/compare/v0.13.2..v0.13.3
 [0.13.2]: https://github.com/fleming79/async-kernel/compare/v0.13.1..v0.13.2
 [0.13.1]: https://github.com/fleming79/async-kernel/compare/v0.13.0..v0.13.1

{async_kernel-0.13.3 → async_kernel-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.13.3
+Version: 0.14.0
 Summary: A concurrent python kernel for Jupyter supporting AnyIO, AsyncIO and Trio.
 Project-URL: Homepage, https://fleming79.github.io/async-kernel
 Project-URL: Documentation, https://fleming79.github.io/async-kernel
@@ -71,6 +71,7 @@ The kernel provides two external interfaces:
 ## Highlights
 
 - [IPython shell](https://ipython.readthedocs.io/en/stable/overview.html#enhanced-interactive-python-shell)
+    - top-level await ('asyncio' or 'trio' backend) in cells
 - [anyio](https://pypi.org/project/anyio/) compatible asynchronous backend ([`asyncio`](https://docs.python.org/3/library/asyncio.html) (default) or [`trio`](https://pypi.org/project/trio/))
 - [aiologic](https://aiologic.readthedocs.io/latest/) thread-safe synchronisation primitives
 - [Backend agnostic multi-thread / multi-event loop management](https://fleming79.github.io/async-kernel/latest/reference/caller/#async_kernel.caller.Caller)
@@ -85,9 +86,8 @@ The kernel provides two external interfaces:
 - [Debugger client](https://jupyterlab.readthedocs.io/en/latest/user/debugger.html#debugger)
 
 [^1]:
-    A gui (_host_) enabled kernel runs a gui event loop with the asynchronous backend
-    running as guest. The host must be set before the kernel is started. This was a
-    deliberate design choice to to ensure good performance and reliability.
+    A gui (_host_) enabled kernel interface starts a gui's mainloop (host) which starts
+    the backend as a guest, then finally the Kernel is started.
 
 [^2]:
     The asyncio implementation of `start_guest_run` was written by
@@ -105,24 +105,40 @@ Another problem exists when an asynchronous execute request awaits a result that
 via a kernel message - this will cause a deadlock because the message will be stuck in the queue behind
 the _blocking_ execute request[^5].
 
-async-kernel handles messages according to the channel, message type and subshell id. So widget com message
+async-kernel handles messages according to the channel and message type. So widget com message
 will get processed in a separate queue to an execute request. Further detail is given in the [concurrency notebook](https://fleming79.github.io/async-kernel/latest/notebooks/concurrency/), a Jupyterlite version is available [here](https://fleming79.github.io/echo-kernel/).
 
 #### Example
 
-Try the following using a standard kernel and then try it with async-kernel.
+Make a blocking call in a Jupyter lab notebook or console.
 
 ```python
-# Make the shell thread busy
+# Make the shell's thread busy
 import time
 
 time.sleep(1e6)
 ```
 
-Try the following in another cell:
+While the above is _blocking_ (the kernel is _busy_).
 
-- code completion (`tab`)
-- docstring (`shift tab`)
+```python
+dir()  # try code completion (tab) or view the docstring (shift tab)
+```
+
+Interrupt the kernel.
+
+It also works for awaitables.
+
+```python
+import ipywidgets as ipw
+from aiologic import Event
+
+b = ipw.Button(description="Click me")
+event = Event()
+b.on_click(lambda _: event.set())
+display(b)
+await event
+```
 
 [^5]:
     IPyKernel _solves_ this issue specifically for widgets by using the concept of
@@ -165,11 +181,11 @@ The kernel can be started with a gui event loop as the _host_ and the _backend_
 
 ```bash
 # tk
-async-kernel -a async-tk --interface.loop=tk
+async-kernel -a async-tk --interface.host=tk
 
 # qt
 pip install PySide6-Essentials
-async-kernel -a async-qt --interface.loop=qt
+async-kernel -a async-qt --interface.host=qt
 ```
 
 #### trio backend
@@ -177,11 +193,11 @@ async-kernel -a async-qt --interface.loop=qt
 ```bash
 pip install trio
 # tk
-async-kernel -a async-tk --interface.loop=tk --interface.backend=trio
+async-kernel -a async-tk --interface.host=tk --interface.backend=trio
 
 # qt
 pip install PySide6-Essentials
-async-kernel -a async-qt --interface.loop=qt --interface.backend=trio
+async-kernel -a async-qt --interface.host=qt --interface.backend=trio
 ```
 
 For further detail about kernel spec customisation see [command line and kernel configuration](https://fleming79.github.io/async-kernel/latest/usage/commands/).

{async_kernel-0.13.3 → async_kernel-0.14.0}/README.md

@@ -22,6 +22,7 @@ The kernel provides two external interfaces:
 ## Highlights
 
 - [IPython shell](https://ipython.readthedocs.io/en/stable/overview.html#enhanced-interactive-python-shell)
+    - top-level await ('asyncio' or 'trio' backend) in cells
 - [anyio](https://pypi.org/project/anyio/) compatible asynchronous backend ([`asyncio`](https://docs.python.org/3/library/asyncio.html) (default) or [`trio`](https://pypi.org/project/trio/))
 - [aiologic](https://aiologic.readthedocs.io/latest/) thread-safe synchronisation primitives
 - [Backend agnostic multi-thread / multi-event loop management](https://fleming79.github.io/async-kernel/latest/reference/caller/#async_kernel.caller.Caller)
@@ -36,9 +37,8 @@ The kernel provides two external interfaces:
 - [Debugger client](https://jupyterlab.readthedocs.io/en/latest/user/debugger.html#debugger)
 
 [^1]:
-    A gui (_host_) enabled kernel runs a gui event loop with the asynchronous backend
-    running as guest. The host must be set before the kernel is started. This was a
-    deliberate design choice to to ensure good performance and reliability.
+    A gui (_host_) enabled kernel interface starts a gui's mainloop (host) which starts
+    the backend as a guest, then finally the Kernel is started.
 
 [^2]:
     The asyncio implementation of `start_guest_run` was written by
@@ -56,24 +56,40 @@ Another problem exists when an asynchronous execute request awaits a result that
 via a kernel message - this will cause a deadlock because the message will be stuck in the queue behind
 the _blocking_ execute request[^5].
 
-async-kernel handles messages according to the channel, message type and subshell id. So widget com message
+async-kernel handles messages according to the channel and message type. So widget com message
 will get processed in a separate queue to an execute request. Further detail is given in the [concurrency notebook](https://fleming79.github.io/async-kernel/latest/notebooks/concurrency/), a Jupyterlite version is available [here](https://fleming79.github.io/echo-kernel/).
 
 #### Example
 
-Try the following using a standard kernel and then try it with async-kernel.
+Make a blocking call in a Jupyter lab notebook or console.
 
 ```python
-# Make the shell thread busy
+# Make the shell's thread busy
 import time
 
 time.sleep(1e6)
 ```
 
-Try the following in another cell:
+While the above is _blocking_ (the kernel is _busy_).
 
-- code completion (`tab`)
-- docstring (`shift tab`)
+```python
+dir()  # try code completion (tab) or view the docstring (shift tab)
+```
+
+Interrupt the kernel.
+
+It also works for awaitables.
+
+```python
+import ipywidgets as ipw
+from aiologic import Event
+
+b = ipw.Button(description="Click me")
+event = Event()
+b.on_click(lambda _: event.set())
+display(b)
+await event
+```
 
 [^5]:
     IPyKernel _solves_ this issue specifically for widgets by using the concept of
@@ -116,11 +132,11 @@ The kernel can be started with a gui event loop as the _host_ and the _backend_
 
 ```bash
 # tk
-async-kernel -a async-tk --interface.loop=tk
+async-kernel -a async-tk --interface.host=tk
 
 # qt
 pip install PySide6-Essentials
-async-kernel -a async-qt --interface.loop=qt
+async-kernel -a async-qt --interface.host=qt
 ```
 
 #### trio backend
@@ -128,11 +144,11 @@ async-kernel -a async-qt --interface.loop=qt
 ```bash
 pip install trio
 # tk
-async-kernel -a async-tk --interface.loop=tk --interface.backend=trio
+async-kernel -a async-tk --interface.host=tk --interface.backend=trio
 
 # qt
 pip install PySide6-Essentials
-async-kernel -a async-qt --interface.loop=qt --interface.backend=trio
+async-kernel -a async-qt --interface.host=qt --interface.backend=trio
 ```
 
 For further detail about kernel spec customisation see [command line and kernel configuration](https://fleming79.github.io/async-kernel/latest/usage/commands/).

{async_kernel-0.13.3 → async_kernel-0.14.0}/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.3'
-__version_tuple__ = version_tuple = (0, 13, 3)
+__version__ = version = '0.14.0'
+__version_tuple__ = version_tuple = (0, 14, 0)
 
 __commit_id__ = commit_id = None

async_kernel-0.14.0/docs/reference/event_loop.md

@@ -0,0 +1,9 @@
+::: async_kernel.event_loop.run
+
+::: async_kernel.event_loop.tk_host.TkHost
+options:
+show_root_heading: true
+
+::: async_kernel.event_loop.qt_host.QtHost
+options:
+show_root_heading: true

{async_kernel-0.13.3 → async_kernel-0.14.0}/docs/usage/commands.md

@@ -31,7 +31,7 @@ The kernel spec looks like this:
         "--start_interface=async_kernel.interface.start_kernel_zmq_interface",
         "--kernel_name=async",
         "--backend=trio",
-        "--loop=tk"
+        "--host=tk"
     ],
     "env": {},
     "display_name": "Async python tk trio",
@@ -53,8 +53,8 @@ A single kernel spec is created in the folder `<sys.prefix>/share/jupyter/kernel
 - display_name: 'async'
 - backend: `asyncio`
 - backend_options: `{'use_uvloop':True}` if uvloop or winloop is installed
-- loop: `None`
-- loop_options: `None`
+- host: `None`
+- host_options: `None`
 
 The kernel spec can be updated by adding a kernel spec with the same name ('async').
 
@@ -63,8 +63,8 @@ The kernel spec can be updated by adding a kernel spec with the same name ('asyn
 There are two supported backends 'asyncio' and 'trio'.
 
 In CPython the [backend][async_kernel.typing.Backend] is started using [anyio.run][].
-The type of backend can be specified at the attribute [`interface.backend`][async_kernel.interface.BaseKernelInterface.backend].
-The backend_options can be specified at the attribute [`interface.backend_options'][async_kernel.interface.zmq.ZMQKernelInterface.backend_options].
+The type of backend can be specified at the attribute [interface.backend][async_kernel.interface.BaseKernelInterface.backend].
+The backend_options can be specified at the attribute [interface.backend_options][async_kernel.interface.zmq.ZMQKernelInterface.backend_options].
 Options can be written as a literal python string.
 
 ```console
@@ -78,7 +78,7 @@ searches for the kernel specs.
 
 The path where the kernel spec is installed/deleted can also be specified by either `prefix` or `folder`.
 
-**options**
+**Options**
 
 - prefix (optional): the prefix to use with `PREFIX/share/jupyter/kernels` (defaults is [sys.prefix][]).
 - folder (optional) the full path to the `kernels` folder.
@@ -110,39 +110,39 @@ Below are some example kernel specs for host and backend kernel specs.
 
 ```console
 # tk host asyncio backend
-async-kernel -a async-tk --interface.loop=tk
+async-kernel -a async-tk --interface.host=tk
 
 # tk host trio backend
-async-kernel -a async-tk --interface.loop=tk --backend=trio
+async-kernel -a async-tk --interface.host=tk --backend=trio
 ```
 
 ### qt
 
 ```console
 # qt host asyncio backend
-async-kernel -a async-qt --interface.loop=qt
+async-kernel -a async-qt --interface.host=qt
 
 # qt host trio backend
-async-kernel -a async-qt-trio --interface.loop=qt --interface.backend=trio
+async-kernel -a async-qt-trio --interface.host=qt --interface.backend=trio
 
-# PySide6 is default.  You can specify a different module via `loop_options`
-async-kernel -a async-qt --interface.loop=qt --interface.loop_options={'module':'PySide2'}
+# PySide6 is default.  You can specify a different module via `host_options`
+async-kernel -a async-qt --interface.host=qt --interface.host_options={'module':'PySide2'}
 ```
 
-## Loop options
+## Host options
 
-Options can be provided to configure how a loop loads. There are only a few options available
+Options can be provided to configure how a host loads. There are only a few options available
 at present.
 
 - `host_class' `[type[Host| str]]` : A customised subclass of a [Host][async_kernel.event_loop.run.Host]
   or a dotted import path to the customised Host.
-- `'module': The module name on which to base the event loop. (Only applies to 'qt').
+- `'module': The module name on which to base the event loop. (Only applies to [qt][async_kernel.event_loop.qt_host.QtHost]).
 
 ## Backend options
 
 Options can be provided for how the backend is started.
 
-- With a (gui) loop: Options for `start_guest_run`
+- With a (gui) host: Options for `start_guest_run`
     - [trio.lowlevel.start_guest_run][]
     - asyncio
         - host_uses_signal_set_wakeup_fd
@@ -151,11 +151,11 @@ Options can be provided for how the backend is started.
         - task_factory,
         - context,
         - debug,
-- Without a (gui) loop: `backend_options` in [anyio.run][]
+- Without a (gui) host: `backend_options` in [anyio.run][]
 
 ```console
 # If uvloop is installed it will be used by default. You can do this to disable it.
-async-kernel -a async "--interface.loop_options={'use_uvloop':False}"
+async-kernel -a async "--interface.host_options={'use_uvloop':False}"
 ```
 
 ### Custom arguments

{async_kernel-0.13.3 → async_kernel-0.14.0}/pyproject.toml

@@ -95,8 +95,8 @@ dev = [
   {include-group = "test"},
 ]
 gui = [
-    "matplotlib>=3.10.8",
     "pyside6-essentials>=6.10.2",
+    {include-group = "docs"},
 ]
 
 [tool.hatch.version]

{async_kernel-0.13.3 → async_kernel-0.14.0}/src/async_kernel/caller.py

@@ -30,7 +30,7 @@ from async_kernel import utils
 from async_kernel.common import Fixed
 from async_kernel.event_loop.run import Host, get_start_guest_run
 from async_kernel.pending import Pending, PendingCancelled, PendingGroup, PendingManager, PendingTracker
-from async_kernel.typing import Backend, CallerCreateOptions, CallerState, Loop, NoValue, RunSettings, T
+from async_kernel.typing import Backend, CallerCreateOptions, CallerState, Hosts, NoValue, RunSettings, T
 
 with contextlib.suppress(ImportError):
     # Monkey patch sniffio.current_async_library` with aiologic's version which does a better job.
@@ -211,8 +211,8 @@ class Caller(anyio.AsyncContextManagerMixin):
     _idle_time: float = 0.0
     _backend: Backend
     _backend_options: dict[str, Any] | None
-    _loop: Loop | None
-    _loop_options: dict[str, Any] | None
+    _host: Hosts | None
+    _host_options: dict[str, Any] | None
     _protected = False
     _use_safe_checkpoint = False
     _state: CallerState = CallerState.initial
@@ -270,14 +270,14 @@ class Caller(anyio.AsyncContextManagerMixin):
         return self._backend_options
 
     @property
-    def loop(self) -> Loop | None:
+    def host(self) -> Hosts | None:
         "The gui event loop if there is one."
-        return self._loop
+        return self._host
 
     @property
-    def loop_options(self) -> dict | None:
+    def host_options(self) -> dict | None:
         "Options used to create the gui event loop."
-        return self._loop_options
+        return self._host_options
 
     @property
     def protected(self) -> bool:
@@ -320,7 +320,7 @@ class Caller(anyio.AsyncContextManagerMixin):
         return {
             "name": self._name,
             "backend": str(self._backend),
-            "loop": self._loop,
+            "host": self._host,
             "thread": self._thread.name,
             "id": self._caller_id,
         }
@@ -393,9 +393,9 @@ class Caller(anyio.AsyncContextManagerMixin):
             inst = super().__new__(cls)
             inst._name = name
             inst._backend = Backend(backend or current_async_library())
-            inst._loop = Loop(loop) if (loop := kwargs.get("loop")) else None
+            inst._host = Hosts(loop) if (loop := kwargs.get("host")) else None
             inst._backend_options = kwargs.get("backend_options")
-            inst._loop_options = kwargs.get("loop_options")
+            inst._host_options = kwargs.get("host_options")
             inst._protected = kwargs.get("protected", False)
             inst._zmq_context = kwargs.get("zmq_context")
             inst.log = kwargs.get("log") or logging.LoggerAdapter(logging.getLogger())
@@ -454,9 +454,9 @@ class Caller(anyio.AsyncContextManagerMixin):
             name = self.name or "async_kernel_caller"
             settings = RunSettings(
                 backend=self.backend,
-                loop=self.loop,
+                host=self.host,
                 backend_options=self.backend_options,
-                loop_options=self.loop_options,
+                host_options=self.host_options,
             )
             args = [run_caller_in_context, (), settings]
             self._thread = threading.Thread(target=async_kernel.event_loop.run, args=args, name=name, daemon=True)
@@ -713,8 +713,8 @@ class Caller(anyio.AsyncContextManagerMixin):
                         if (backend := kwargs.get("backend")) and caller.backend != backend:
                             msg = f"Backend mismatch! {backend=} {caller.backend=}"
                             raise RuntimeError(msg)
-                        if (loop := kwargs.get("loop")) and caller.loop != loop:
-                            msg = f"Event loop mismatch! {loop=} {caller.loop=}"
+                        if (host := kwargs.get("host")) and caller.host != host:
+                            msg = f"Host mismatch! {host=} {caller.host=}"
                             raise RuntimeError(msg)
                         return caller
             if "backend" not in kwargs:

{async_kernel-0.13.3 → async_kernel-0.14.0}/src/async_kernel/event_loop/asyncio_guest.py

@@ -27,7 +27,7 @@ _MAXIMUM_SELECT_TIMEOUT = 24 * 60 * 60
 _THREAD_JOIN_TIMEOUT = 5 * 60
 
 GuestInfo = namedtuple("GuestInfo", [
-    "loop",
+    "host",
     "task",
 ])
 

{async_kernel-0.13.3 → async_kernel-0.14.0}/src/async_kernel/event_loop/qt_host.py

@@ -24,7 +24,7 @@ from typing import TYPE_CHECKING, Any, Literal
 from aiologic.meta import import_from
 from typing_extensions import override
 
-from async_kernel.typing import Loop, T
+from async_kernel.typing import Hosts, T
 
 from .run import Host
 
@@ -33,12 +33,14 @@ if TYPE_CHECKING:
 
     from PySide6 import QtCore, QtWidgets  # noqa: TC004
 
+__all__ = ["QtHost"]
+
 
 class QtHost(Host[T]):
-    LOOP = Loop.qt
+    HOST = Hosts.qt
     MATPLOTLIB_GUIS = ("qt",)
 
-    def __init__(self, module: str = "PySide6") -> None:
+    def __init__(self, module: Literal["PySide6", "PySide2", "PyQt5", "PyQt6"] = "PySide6") -> None:
         if threading.current_thread() is not threading.main_thread():
             msg = "QT can only be run in main thread!"
             raise RuntimeError(msg)

{async_kernel-0.13.3 → async_kernel-0.14.0}/src/async_kernel/event_loop/run.py

@@ -8,7 +8,7 @@ import anyio
 from wrapt import lazy_import
 
 from async_kernel.common import import_item
-from async_kernel.typing import Backend, Loop, RunSettings, T
+from async_kernel.typing import Backend, Hosts, RunSettings, T
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -39,13 +39,13 @@ def get_start_guest_run(backend: Backend):
 def run(func: Callable[..., CoroutineType[Any, Any, T]], args: tuple, settings: RunSettings, /) -> T:
     """
     Run `func` to completion asynchronously in the current thread using a [backend][async_kernel.typing.Backend]
-    with an optional gui event loop (_host_).
+    with an optional host (gui event loop).
 
     The default backend is ['asyncio'][async_kernel.typing.Backend.asyncio].
 
-    If [loop][async_kernel.typing.Loop] is specified in `settings`. A _host_ (gui) mainloop
+    If [host][async_kernel.typing.Hosts] is specified in `settings`. A _host_ (gui) mainloop
     will be started with the `backend` running as a guest (in the same thread). The `backend`
-    will execute `func` asynchronously to completion. Once completed the backend and host
+    will execute `func` asynchronously to completion. Once completed the `backend` and `host`
     are stopped and finally the result is returned.
 
     Args:
@@ -53,13 +53,12 @@ def run(func: Callable[..., CoroutineType[Any, Any, T]], args: tuple, settings:
         args: Args to use when calling func.
         settings: Settings to use when running func.
 
-    Custom loop:
-        A custom event loop can be used by subclassing [Host][].
-        The host can be specified in the settings as the option 'host_class'. The value
-        can be the class or a dotted path if it is importable.
+    Custom host:
+        A custom host can be started by subclassing [Host][] and passed as the 'host_class' as the
+        class or a dotted path if it is importable.
     """
-    if settings.get("loop"):
-        # A loop with the backend running as a guest.
+    if settings.get("host"):
+        # A gui with the backend running as a guest.
         return Host.run(func, args, settings)
     # backend only.
     return anyio.run(
@@ -79,12 +78,12 @@ def get_runtime_matplotlib_guis(thread: threading.Thread | None = None) -> tuple
 
 class Host(Generic[T]):
     """
-    A class that provides the necessary callbacks for `start_guest_run`.
+    A class that provides the necessary callbacks to run a gui event loop with a `backend` started using `start_guest_run`.
     """
 
-    LOOP: Loop
+    HOST: Hosts
     MATPLOTLIB_GUIS = ()
-    _subclasses: dict[Loop, type[Self]] = {}
+    _subclasses: dict[Hosts, type[Self]] = {}
     _instances: dict[threading.Thread, Host] = {}
 
     _outcome: Outcome[T] | None = None
@@ -92,8 +91,8 @@ class Host(Generic[T]):
     "A callback to start the guest. This must be called by a subclass."
 
     def __init_subclass__(cls) -> None:
-        if cls.LOOP is not Loop.custom:
-            cls._subclasses[cls.LOOP] = cls
+        if cls.HOST is not Hosts.custom:
+            cls._subclasses[cls.HOST] = cls
 
     @classmethod
     def current(cls, thread: threading.Thread | None = None) -> Host | None:
@@ -109,28 +108,28 @@ class Host(Generic[T]):
             msg = "A host is already running in this thread"
             raise RuntimeError(msg)
 
-        loop = Loop(settings.get("loop"))
+        host = Hosts(settings.get("host"))
         backend = Backend(settings.get("backend", "asyncio"))
         backend_options = settings.get("backend_options") or {}
-        loop_options = settings.get("loop_options") or {}
+        host_options = settings.get("host_options") or {}
 
-        if "host_class" in loop_options:
-            loop_options = loop_options.copy()
-            cls_ = loop_options.pop("host_class")
+        if "host_class" in host_options:
+            host_options = host_options.copy()
+            cls_ = host_options.pop("host_class")
             if isinstance(cls_, str):
                 cls_ = import_item(cls_)
             if not issubclass(cls_, cls):
                 msg = f"{cls_} is not a subclass of {cls}!"
                 raise TypeError(msg)
         else:
-            assert loop != backend
-            if loop not in cls._subclasses:
-                import_module(f"async_kernel.event_loop.{loop}_host")
-                assert loop in cls._subclasses, f"Host for {loop=} is not implemented correctly!"
-            cls_ = cls._subclasses[loop]
-        assert cls_.LOOP is loop
-
-        host = cls_(**loop_options)
+            assert host != backend
+            if host not in cls._subclasses:
+                import_module(f"async_kernel.event_loop.{host}_host")
+                assert host in cls._subclasses, f"Host for {host=} is not implemented correctly!"
+            cls_ = cls._subclasses[host]
+        assert cls_.HOST is host
+
+        host = cls_(**host_options)
         # set the `start_guest` function (runs once).
         backend_options.setdefault("host_uses_signal_set_wakeup_fd", host.host_uses_signal_set_wakeup_fd)
         start_guest_run = get_start_guest_run(backend)