async-kernel 0.20.2__tar.gz → 0.21.0__tar.gz

{async_kernel-0.20.2 → async_kernel-0.21.0}/.github/workflows/ci.yml

@@ -20,12 +20,12 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
 
       - name: Type checking with basedpyright
         run: |
           uv sync
-          uvx basedpyright@1.39.8
+          uvx basedpyright@1.39.9
 
   test:
     needs: type-checking
@@ -45,7 +45,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
           python-version: ${{ matrix.python-version }}
@@ -71,7 +71,7 @@ jobs:
         if: ${{runner.debug == '1'}}
         timeout-minutes: 3
         run: |
-          uv run pytest -vvl --override-ini=log_cli_level=DEBUG --override-ini=log_cli=true
+          uv run pytest -vvl --override-ini=log_cli_level=DEBUG
 
       - name: Run tests
         if: ${{runner.debug != '1'}}
@@ -87,7 +87,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
           python-version: "3.13"
@@ -116,7 +116,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.20.2 → async_kernel-0.21.0}/.github/workflows/new_release.yml

@@ -31,7 +31,7 @@ jobs:
           fetch-depth: 0
           ref: main
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.20.2 → async_kernel-0.21.0}/.github/workflows/publish-docs.yml

@@ -27,7 +27,7 @@ jobs:
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
 
       - name: Install uv
-        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+        uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.20.2 → async_kernel-0.21.0}/.github/workflows/publish-to-pypi.yml

@@ -31,7 +31,7 @@ jobs:
           # Fetch full history for setuptools-scm
           fetch-depth: 0
           ref: main
-      - uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+      - uses: astral-sh/setup-uv@d31148d669074a8d0a63714ba94f3201e7020bc3 # v8.3.0
         with:
           version-file: "pyproject.toml"
 

{async_kernel-0.20.2 → async_kernel-0.21.0}/.pre-commit-config.yaml

@@ -28,12 +28,12 @@ repos:
       - id: check-json5
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.37.3
+    rev: 0.37.4
     hooks:
       - id: check-github-workflows
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.8.4
+    rev: v3.9.5
     hooks:
       - id: prettier
         types_or: [yaml, html, json]
@@ -48,7 +48,7 @@ repos:
         additional_dependencies: [black==23.7.0]
 
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.3
     hooks:
       - id: codespell
         args: ["-L", "sur,nd"]
@@ -59,7 +59,7 @@ repos:
       - id: python-use-type-annotations
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.19
+    rev: v0.15.22
     hooks:
       - id: ruff-check
         types_or: [python, jupyter]

{async_kernel-0.20.2 → async_kernel-0.21.0}/CHANGELOG.md

@@ -5,7 +5,39 @@ 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.20.2] - 2026-06-29
+## [0.21.0] - 2026-07-18
+
+### <!-- 1 --> 🚀 Features
+
+- Add print_concat to concatenate print statements into a single string when 'file' is not specified. [#522](https://github.com/fleming79/async-kernel/pull/522)
+
+- Added PollZMQ - a thread based zmq poller callback registry. [#515](https://github.com/fleming79/async-kernel/pull/515)
+
+- Support loop_factory as an importable path. [#514](https://github.com/fleming79/async-kernel/pull/514)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Poll maintenance [#529](https://github.com/fleming79/async-kernel/pull/529)
+
+- Add threadsafe option to Poll.socket [#528](https://github.com/fleming79/async-kernel/pull/528)
+
+- Update lock files and pre-commit and basedpyright. [#527](https://github.com/fleming79/async-kernel/pull/527)
+
+- Kernel updates - handle external kernel interrupt. [#526](https://github.com/fleming79/async-kernel/pull/526)
+
+- Add docstrings for Poll [#525](https://github.com/fleming79/async-kernel/pull/525)
+
+- Bump astral-sh/setup-uv from 8.2.0 to 8.3.0 in the actions group [#518](https://github.com/fleming79/async-kernel/pull/518)
+
+- Change PollZMQ to Poll and move to event_loop/zmq_poll.py. [#524](https://github.com/fleming79/async-kernel/pull/524)
+
+- Add more log messages when running pytest from the command line. [#523](https://github.com/fleming79/async-kernel/pull/523)
+
+- Move OutStream from kernel.py to outstream.py [#521](https://github.com/fleming79/async-kernel/pull/521)
+
+- Refactor Caller. [#520](https://github.com/fleming79/async-kernel/pull/520)
+
+## [0.20.2] - 2026-06-30
 
 ### <!-- 5 --> 📝 Documentation
 
@@ -13,6 +45,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.20.2 [#512](https://github.com/fleming79/async-kernel/pull/512)
+
 - Avoid attribute error in Comm.publish_msg in case the parent is gc before the object. [#511](https://github.com/fleming79/async-kernel/pull/511)
 
 - Update uv.lock and pre-commit-config.yaml [#510](https://github.com/fleming79/async-kernel/pull/510)
@@ -1419,6 +1453,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.21.0]: https://github.com/fleming79/async-kernel/compare/v0.20.2..v0.21.0
 [0.20.2]: https://github.com/fleming79/async-kernel/compare/v0.20.1..v0.20.2
 [0.20.1]: https://github.com/fleming79/async-kernel/compare/v0.20.0..v0.20.1
 [0.20.0]: https://github.com/fleming79/async-kernel/compare/v0.19.2..v0.20.0

{async_kernel-0.20.2 → async_kernel-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.20.2
+Version: 0.21.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

{async_kernel-0.20.2 → async_kernel-0.21.0}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.20.2'
-__version_tuple__ = version_tuple = (0, 20, 2)
+__version__ = version = '0.21.0'
+__version_tuple__ = version_tuple = (0, 21, 0)
 
 __commit_id__ = commit_id = None

{async_kernel-0.20.2 → async_kernel-0.21.0}/docs/reference/event_loop.md

@@ -7,3 +7,5 @@ show_root_heading: true
 ::: async_kernel.event_loop.qt_host.QtHost
 options:
 show_root_heading: true
+
+::: async_kernel.event_loop.zmq_poll

{async_kernel-0.20.2 → async_kernel-0.21.0}/pyproject.toml

@@ -85,7 +85,7 @@ test = [
     "trio>=0.31.0",
 ]
 uvloop = ["uvloop; python_version <= '3.13' and sys_platform != 'win32' and implementation_name == 'cpython'",
-"winloop; sys_platform == 'win32' and implementation_name == 'cpython'"
+"winloop; sys_platform == 'win32' and implementation_name == 'cpython' and python_version <= '3.13'"
 ]    
 dev = [
   "matplotlib>=3.10.9; python_version < '3.15'",
@@ -248,7 +248,7 @@ reportUnusedParameter = false
 reportUnknownLambdaType = false
 
 [tool.uv]
-required-version = "==0.11.16"
+required-version = "==0.11.29"
 
 [tool.uv.sources]
 jupyter-client = { git = "https://github.com/jupyter/jupyter_client.git" }

{async_kernel-0.20.2 → async_kernel-0.21.0}/src/async_kernel/caller.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import atexit
 import contextlib
 import contextvars
 import inspect
@@ -18,12 +19,13 @@ from types import CoroutineType
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, Self, Unpack, final
 
 import anyio
-from aiologic import BinarySemaphore, Event
+from aiologic import BinarySemaphore, CountdownEvent
 from aiologic.lowlevel import create_async_event, current_async_library
 from aiologic.meta import await_for, iscoroutinelike
 from typing_extensions import override
 from wrapt import lazy_import
 
+import async_kernel.event_loop
 from async_kernel import utils
 from async_kernel.common import Fixed, KernelInterrupt, SingleAsyncQueue
 from async_kernel.event_loop.run import Host, get_start_guest_run
@@ -41,8 +43,6 @@ if TYPE_CHECKING:
     from types import CoroutineType
 
     import trio  # noqa: TC004
-    import zmq
-    from aiologic.lowlevel import AsyncEvent
 
     from async_kernel.typing import P
 
@@ -195,12 +195,9 @@ class Caller(anyio.AsyncContextManagerMixin):
         CallerState.stopping: "🏁 stopping",
         CallerState.stopped: "🏁 stopped",
     }
-    _zmq_context: zmq.Context[Any] | None = None
-
-    _parent_ref: weakref.ref[Self] | None = None
 
     # Fixed
-    _child_lock = Fixed(BinarySemaphore)
+    _inst_lock = Fixed(BinarySemaphore)
     _children: Fixed[Self, set[Self]] = Fixed(set)
     _tasks: Fixed[Self, set[asyncio.Task]] = Fixed(set)
     _worker_pool: Fixed[Self, deque[Self]] = Fixed(deque)
@@ -209,21 +206,18 @@ class Caller(anyio.AsyncContextManagerMixin):
         lambda c: SingleAsyncQueue(reject=c["owner"]._reject)
     )
     _guest_queues: Fixed[Self, dict[Backend, SingleAsyncQueue[Pending | tuple[Callable, tuple, dict]]]] = Fixed(dict)
-    _guest_done_events: Fixed[Any, set[AsyncEvent]] = Fixed(set)
+    _guest_done_event: Fixed[Any, CountdownEvent] = Fixed(CountdownEvent)
     _stopping = Fixed(Pending[None])
     "A pending that is set done the first time stop is called."
 
-    stopped = Fixed(Event)
-    "An event that is set when the caller has stopped."
+    stopped = Fixed(Pending)
+    "A pending that is done when the caller is stopped."
 
+    _children_countdown: CountdownEvent | None = None
     _pending_var: contextvars.ContextVar[Pending | None] = contextvars.ContextVar("_pending_var", default=None)
 
     log: logging.Logger | logging.LoggerAdapter
     ""
-    iopub_sockets: ClassVar[dict[int, zmq.Socket]] = {}
-    ""
-    iopub_url: ClassVar = "inproc://iopub"
-    ""
 
     @property
     def name(self) -> str:
@@ -260,11 +254,6 @@ class Caller(anyio.AsyncContextManagerMixin):
         "Returns `True` if the caller is protected from stopping."
         return self._protected
 
-    @property
-    def zmq_context(self) -> zmq.Context | None:
-        "A zmq socket, which if present indicates that an iopub socket is loaded."
-        return self._zmq_context
-
     @property
     def running(self) -> bool:
         "Returns `True` when the caller is available to run requests."
@@ -288,8 +277,9 @@ class Caller(anyio.AsyncContextManagerMixin):
     @property
     def parent(self) -> Self | None:
         "The parent caller if it exists."
-        if (ref := self._parent_ref) and (inst := ref()) and not inst.stopped:
-            return inst
+        return self._parent_ref()
+
+    def _parent_ref(self) -> Self | None:
         return None
 
     def _get_info(self) -> dict[str, Any]:
@@ -334,7 +324,6 @@ class Caller(anyio.AsyncContextManagerMixin):
                 - backend: The async backend to use.
                 - backend_options: Options for the backend.
                 - protected: Whether the Caller is protected.
-                - zmq_context: ZeroMQ context.
                 - log: Logger instance.
 
         Returns:
@@ -377,7 +366,6 @@ class Caller(anyio.AsyncContextManagerMixin):
             inst._backend_options = kwargs.get("backend_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())
             if (sys.platform == "emscripten") and (caller_id is None):
                 caller_id = id(inst)
@@ -390,6 +378,8 @@ class Caller(anyio.AsyncContextManagerMixin):
                 inst.start_sync(no_debug=kwargs.get("no_debug", False))
             assert inst._caller_id
             assert inst._caller_id not in cls._instances
+            atexit.register(inst.stop, force=True)
+            inst._stopping.add_done_callback(lambda _: atexit.unregister(inst.stop))
             cls._instances[inst._caller_id] = inst
         return inst
 
@@ -405,6 +395,10 @@ class Caller(anyio.AsyncContextManagerMixin):
         self._state = CallerState.start_sync
 
         async def run_caller_in_context() -> None:
+            if self._state in [CallerState.stopping, CallerState.stopped]:
+                return
+            if not self._name:
+                self._name = self._thread.name
             if self._state is CallerState.start_sync:
                 self._state = CallerState.initial
             if no_debug:
@@ -432,69 +426,74 @@ class Caller(anyio.AsyncContextManagerMixin):
                         if not "shutdown" not in str(e):
                             raise
 
-                threading.Thread(target=to_thread, daemon=False).start()
+                threading.Thread(target=to_thread).start()
         else:
 
             def async_kernel_caller() -> None:
                 self._thread, self._caller_id = threading.current_thread(), threading.get_ident()
+                settings = RunSettings(
+                    backend=self.backend,
+                    host=self.host,
+                    backend_options=self.backend_options,
+                    host_options=self.host_options,
+                )
                 try:
-                    if not self.host:
-                        # No gui (default)
-                        anyio.run(run_caller_in_context, backend=self.backend, backend_options=self.backend_options)
-                    else:
-                        # A gui with the backend running as a guest.
-                        settings = RunSettings(
-                            backend=self.backend,
-                            host=self.host,
-                            backend_options=self.backend_options,
-                            host_options=self.host_options,
-                        )
-                        Host.run(run_caller_in_context, (), settings)
+                    async_kernel.event_loop.run(run_caller_in_context, (), settings)
                 except Exception as e:
                     if not self._stopping.done():
-                        self.stop()
+                        self.stop(force=True)
                         self.log.exception("%s exited early", self, exc_info=e)
                         raise
 
-            thread = threading.Thread(target=async_kernel_caller, name=self.name or None)
+            thread = threading.Thread(target=async_kernel_caller, name=self._name or None)
             thread.start()
             assert thread.ident
             self._thread, self._caller_id = thread, thread.ident
 
-    def stop(self, *, force: bool = False) -> CallerState:
+    def stop(self, *, force: bool = False) -> None:
         """
         Stop the caller cancelling all incomplete tasks.
 
         Args:
             force: If the caller is protected the call is a no-op unless force=True.
+        Returns:
+            Event: If stopping is initiated or complete.
+            None: If stop is ignored when the caller is protected.
         """
-        if (self._protected and not force) or self._state is CallerState.stopped:
-            return self._state
-        state = self._state
-        self._state = CallerState.stopping
-        # Invoke stop callbacks
-        self._stopping.set_result(None)
-        if parent := self.parent:
-            try:
-                parent._worker_pool.remove(self)
-            except ValueError:
-                pass
-        for func in self._queue_map.copy():
-            self.queue_close(func)
-        if state is CallerState.initial and not self._children:
-            self._stop_finalize()
-        else:
-            for child in self.children:
+        if self._protected and not force:
+            self.log.warning("Non-force stop ignored for  %s", self)
+            return
+        with self._inst_lock:
+            if self._stopping.done():
+                return
+            state = self._state
+            self._state = CallerState.stopping
+            self._stopping.set_result(None)
+            self.log.debug("Stopping %s", self)
+            # Remove from worker pool
+            if (parent := self.parent) and (workers := parent._worker_pool):
+                with contextlib.suppress(ValueError):
+                    workers.remove(self)
+            # Invoke stop callbacks
+            for child in self._children.copy():
                 child.stop(force=True)
-        return self._state
+            # Shutdown queue_call
+            for func in self._queue_map.copy():
+                self.queue_close(func)
+        # Stop the children
+        if state in [CallerState.initial, CallerState.start_sync]:
+            self._stop_finalize()
 
     def _stop_finalize(self) -> None:
-        self._queue.stop()
-        self._state = CallerState.stopped
-        self._instances.pop(self._caller_id, None)
-        self.stopped.set()
-        if parent := self.parent:
-            parent._children.discard(self)
+        with self._inst_lock:
+            if not self.stopped.done():
+                if (countdown := self._children_countdown) is not None:
+                    countdown.wait()
+                self._instances.pop(self._caller_id)
+                self._queue.stop()
+                self._state = CallerState.stopped
+                self.stopped.set_result(None)
+                self.log.debug("Stopped %s", self)
 
     @asynccontextmanager
     async def __asynccontextmanager__(self) -> AsyncGenerator[Self]:
@@ -505,35 +504,25 @@ class Caller(anyio.AsyncContextManagerMixin):
         if self._state is CallerState.stopped:
             msg = f"Stopped: {self}"
             raise RuntimeError(msg)
-        socket = None
         try:
-            if self._zmq_context:
-                socket = self._zmq_context.socket(1)  # zmq.SocketType.PUB
-                socket.connect(self.iopub_url)
-                self.iopub_sockets[self._caller_id] = socket
             async with task_factory() as create_task:
+                create_task(contextvars.Context(), self._scheduler, self._queue)
                 try:
-                    create_task(contextvars.Context(), self._scheduler, self._queue)
                     with anyio.CancelScope() as scope:
                         self._stopping.add_done_callback(lambda _: self.call_direct(scope.cancel, "Stopping"))
                         self._state = CallerState.running
+                        self.log.debug("Started %s", self)
                         yield self
                 finally:
                     self.stop(force=True)
-                    for event in self._guest_done_events:
-                        await event  # Internally shielded from cancellation
-                    self._queue.stop()
-        finally:
-            while self._children:
-                try:
-                    if not (caller := self._children.pop()).stopped:
+                    if self._guest_done_event.value > 0:
+                        # Warning: `queue` must not be stopped until guests have been stopped.
+                        with anyio.CancelScope(shield=True):
+                            await self._guest_done_event
+                    if (countdown := self._children_countdown) is not None:
                         with anyio.CancelScope(shield=True):
-                            await caller.stopped
-                except KeyError:
-                    pass
-            if socket:
-                self.iopub_sockets.pop(self._caller_id, None)
-                socket.close(linger=0)
+                            await countdown
+        finally:
             self._stop_finalize()
 
     async def _scheduler(self, queue: SingleAsyncQueue) -> None:
@@ -630,7 +619,7 @@ class Caller(anyio.AsyncContextManagerMixin):
                         if worker._idle_time < cutoff:
                             with contextlib.suppress(IndexError):
                                 caller._worker_pool.remove(worker)
-                                worker.stop()
+                                worker.stop(force=True)
                 if n:
                     _cleanup_workers()
                 else:
@@ -689,29 +678,38 @@ class Caller(anyio.AsyncContextManagerMixin):
             - The returned caller is added to `children` and stopped with the caller.
             - If 'backend' or 'zmq_context' are not specified they are copied from the caller.
         """
-        if self._state in [CallerState.stopping, CallerState.stopped]:
-            msg = f"Caller is stopping or stopped {self}"
-            raise RuntimeError(msg)
-        with self._child_lock:
+
+        with self._inst_lock:
+            if self._stopping.done():
+                msg = f"Caller is stopping or stopped {self}"
+                raise RuntimeError(msg)
             if name := kwargs.get("name"):
-                for caller in self.children:
-                    if caller.name == name:
-                        if (backend := kwargs.get("backend")) and caller.backend != backend:
-                            msg = f"Backend mismatch! {backend=} {caller.backend=}"
+                for child in self._children:
+                    if child.name == name:
+                        if (backend := kwargs.get("backend")) and child.backend != backend:
+                            msg = f"Backend mismatch! {backend=} {child.backend=}"
                             raise RuntimeError(msg)
-                        if (host := kwargs.get("host")) and caller.host != host:
-                            msg = f"Host mismatch! {host=} {caller.host=}"
+                        if (host := kwargs.get("host")) and child.host != host:
+                            msg = f"Host mismatch! {host=} {child.host=}"
                             raise RuntimeError(msg)
-                        return caller
+                        return child
+
             if "backend" not in kwargs:
                 kwargs["backend"] = self._backend
                 kwargs["backend_options"] = self.backend_options
-            if "zmq_context" not in kwargs and self._zmq_context:
-                kwargs["zmq_context"] = self._zmq_context
-            caller = self.__class__("NewThread", **kwargs)
-            self._children.add(caller)
-            caller._parent_ref = weakref.ref(self)
-            return caller
+            child = self.__class__("NewThread", **kwargs)
+            child._parent_ref = weakref.ref(self)
+            if self._children_countdown is None:
+                self._children_countdown = CountdownEvent()
+            self._children.add(child)
+            self._children_countdown.up()
+
+            def on_child_stopped(_, children=self._children, done=self._children_countdown.down) -> None:
+                children.discard(child)
+                done()
+
+            child.stopped.add_done_callback(on_child_stopped)
+            return child
 
     def schedule_call(
         self,
@@ -745,7 +743,7 @@ class Caller(anyio.AsyncContextManagerMixin):
         if backend is NoValue or (backend := Backend(backend)) is self.backend:
             queue = self._queue
         elif not (queue := self._guest_queues.get(backend)):
-            with self._child_lock:
+            with self._inst_lock:
                 if backend is Backend.trio:
                     trio.sleep  # noqa: B018 # Check trio is available.
                 if not (queue := self._guest_queues.get(backend)):
@@ -753,20 +751,23 @@ class Caller(anyio.AsyncContextManagerMixin):
                     self._guest_queues[backend] = queue
                     self._stopping.add_done_callback(lambda _: queue.stop())
 
+                    def guest_done_callback(value: Any):
+                        self._guest_done_event.down()
+                        self._guest_queues.pop(backend)
+
                     def _start_guest() -> None:
                         "Start a guest event loop"
                         if self._state is CallerState.running:
-                            host = Host.current(self.thread)
-                            done = create_async_event(shield=True)
+                            host: Host[Any] | None = Host.current(self.thread)
                             get_start_guest_run(backend)(
                                 self._scheduler,
                                 queue,
-                                done_callback=lambda _: done.set(),
+                                done_callback=guest_done_callback,
                                 run_sync_soon_threadsafe=host.run_sync_soon_threadsafe if host else self.call_direct,
                                 run_sync_soon_not_threadsafe=host.run_sync_soon_not_threadsafe if host else None,
                                 host_uses_signal_set_wakeup_fd=host.host_uses_signal_set_wakeup_fd if host else True,
                             )
-                            self._guest_done_events.add(done)
+                            self._guest_done_event.up()
 
                     self.call_direct(_start_guest)
         queue.append(pen)
@@ -896,14 +897,14 @@ class Caller(anyio.AsyncContextManagerMixin):
         """
 
         def _to_thread_on_done(_) -> None:
-            if not caller.stopped and self.running:
-                with self._child_lock:
+            if not caller.stopped.done() and self.running:
+                with self._inst_lock:
                     if len(self._worker_pool) < self.MAX_IDLE_POOL_INSTANCES:
                         caller._idle_time = time.monotonic()
                         self._worker_pool.append(caller)
                         self._start_idle_worker_cleanup_thead()
                     else:
-                        caller.stop()
+                        caller.stop(force=True)
 
         try:
             caller = self._worker_pool.popleft()
@@ -950,7 +951,7 @@ class Caller(anyio.AsyncContextManagerMixin):
                 trackers and **not** PendingGroup.
         """
         if not (pen_ := self._queue_map.get(key := hash(func))):
-            with self._child_lock:
+            with self._inst_lock:
                 if not (pen_ := self._queue_map.get(key)):
                     queue = SingleAsyncQueue[tuple[Callable, tuple, dict]](reject=self._reject)
                     with contextlib.suppress(TypeError):
@@ -962,9 +963,10 @@ class Caller(anyio.AsyncContextManagerMixin):
                         try:
                             async for item in queue:
                                 try:
-                                    await item[0](*item[1], **item[2])
-                                except TypeError:
-                                    continue
+                                    result = item[0](*item[1], **item[2])
+                                    if iscoroutinelike(result):
+                                        await result
+                                    del result
                                 except (anyio.get_cancelled_exc_class(), Exception) as e:
                                     if pen.cancelled():
                                         raise