async-kernel 0.22.1__tar.gz → 0.22.2__tar.gz

{async_kernel-0.22.1 → async_kernel-0.22.2}/CHANGELOG.md

@@ -5,7 +5,21 @@ 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.22.1] - 2026-08-18
+## [0.22.2] - 2026-08-21
+
+### <!-- 1 --> 🚀 Features
+
+- ZMQPoll._wake minor optimization. [#574](https://github.com/fleming79/async-kernel/pull/574)
+
+- Replace BinarySemaphore with threading.Lock for faster performance in heavily used places. [#571](https://github.com/fleming79/async-kernel/pull/571)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Tweak Interface startup sequence. [#573](https://github.com/fleming79/async-kernel/pull/573)
+
+- Alan Fleming Refactor ZMQConnection to send the welcome message directly. [#572](https://github.com/fleming79/async-kernel/pull/572)
+
+## [0.22.1] - 2026-08-19
 
 ### <!-- 0 --> 🏗️ Breaking changes
 
@@ -17,6 +31,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.22.1 [#570](https://github.com/fleming79/async-kernel/pull/570)
+
 - Refactor create_interface_messge_callback_handler to only use one connection [#569](https://github.com/fleming79/async-kernel/pull/569)
 
 ## [0.22.0] - 2026-08-17
@@ -1545,6 +1561,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.22.2]: https://github.com/fleming79/async-kernel/compare/v0.22.1..v0.22.2
 [0.22.1]: https://github.com/fleming79/async-kernel/compare/v0.22.0..v0.22.1
 [0.22.0]: https://github.com/fleming79/async-kernel/compare/v0.21.0..v0.22.0
 [0.21.0]: https://github.com/fleming79/async-kernel/compare/v0.20.2..v0.21.0

{async_kernel-0.22.1 → async_kernel-0.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: async-kernel
-Version: 0.22.1
+Version: 0.22.2
 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.22.1 → async_kernel-0.22.2}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.22.1'
-__version_tuple__ = version_tuple = (0, 22, 1)
+__version__ = version = '0.22.2'
+__version_tuple__ = version_tuple = (0, 22, 2)
 
 __commit_id__ = commit_id = None

{async_kernel-0.22.1 → async_kernel-0.22.2}/src/async_kernel/caller.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Concatenate, Generic, Literal,
 from weakref import ReferenceType
 
 import anyio
-from aiologic import BinarySemaphore, CountdownEvent
+from aiologic import CountdownEvent
 from aiologic.lowlevel import async_checkpoint, create_async_event, current_async_library
 from aiologic.meta import await_for, iscoroutinelike
 from typing_extensions import override
@@ -191,7 +191,7 @@ class Caller:
 
     _caller_token = contextvars.ContextVar("caller_tokens", default=CALLER_MAIN_THREAD_ID)
     _instances: ClassVar[weakref.WeakValueDictionary[int, Self]] = weakref.WeakValueDictionary()
-    _lock: ClassVar = BinarySemaphore()
+    _lock: ClassVar = threading.Lock()
 
     _thread: threading.Thread
     _caller_id: int
@@ -219,7 +219,7 @@ class Caller:
     _worker_pool: Fixed[Self, deque[Self]] = Fixed(deque)
 
     # Private
-    _inst_lock: BinarySemaphore
+    _inst_lock: threading.Lock
     _children: set[Self]
     _tasks: set[asyncio.Task]
     _queue_map: dict[int, Pending]
@@ -394,7 +394,7 @@ class Caller:
                 thread = threading.current_thread()
 
             # Add private objects
-            inst._inst_lock = BinarySemaphore()
+            inst._inst_lock = threading.Lock()
             inst._children = set()
             inst._tasks = set()
             inst._queue_map = {}

{async_kernel-0.22.1 → async_kernel-0.22.2}/src/async_kernel/event_loop/zmq_poll.py

@@ -41,7 +41,7 @@ class ZMQPollSocket(zmq.sugar.Socket[bytes]):
     """
 
     _zmq_poll_ref: weakref.ref[ZMQPoll]
-    lock: BinarySemaphore
+    lock: threading.Lock
 
     if TYPE_CHECKING:
         # magic attributes cannot be be stored in `__annotations__`.
@@ -68,7 +68,7 @@ class ZMQPollSocket(zmq.sugar.Socket[bytes]):
         zmq_poll: ZMQPoll,
         copy_threshold: int | None = None,
     ) -> None:
-        self.lock = BinarySemaphore()
+        self.lock = threading.Lock()
         self._zmq_poll_ref = weakref.ref(zmq_poll)
 
         if zmq_poll.stopped.done():
@@ -99,10 +99,13 @@ class ZMQPollSocket(zmq.sugar.Socket[bytes]):
         track: bool = False,
         **kwargs,
     ) -> MessageTracker | None:
-        with self.lock:
+        self.lock.acquire()
+        try:
             if self.closed:
                 return None
             return super().send_multipart(msg_parts, flags, copy, track)
+        finally:
+            self.lock.release()
 
     @override
     def close(self, linger=None) -> None:
@@ -189,7 +192,6 @@ class ZMQPoll:
         self._handlers: dict[T_key, Callable[[ZMQPollSocket, int], Any]] = {}
         self._count: dict[T_key, tuple[int, Callable[[], Any]] | None] = {}
         self._execute: deque[Pending] = deque[Pending[Any]]()
-        self._not_started = False
         self.log = logging.LoggerAdapter(logging.getLogger())
         self._cancellers = deque()
         self._ctx_count = 0
@@ -321,8 +323,9 @@ class ZMQPoll:
         send = started.wait_sync()
 
         def _wake(sock=send, lock=send.lock) -> None:
-            with lock:
-                sock.send(b"")
+            lock.acquire()
+            sock.send(b"")
+            lock.release()
 
         self._wake = _wake
         self.stopped.add_done_callback(lambda _: (self := ref()) and self._on_stopped())

{async_kernel-0.22.1 → async_kernel-0.22.2}/src/async_kernel/interface/base.py

@@ -12,7 +12,7 @@ import weakref
 from typing import TYPE_CHECKING, Any, Generic, Literal, Self, final
 
 from aiologic import BinarySemaphore
-from aiologic.lowlevel import AsyncLibraryNotFoundError, current_async_library
+from aiologic.lowlevel import AsyncLibraryNotFoundError, async_checkpoint, current_async_library
 from traitlets import import_item, traitlets
 from traitlets.config import Config, Configurable
 from traitlets.config.application import Application, ClassesType
@@ -395,19 +395,22 @@ class Interface(StartStopTask, Application, Generic[T_shell_co]):
             await self._pre_start()
             self.log.info("Interface started: %s", self.summary)
             started()
-            del started
+            # Allow connections to react to being started.
+            await async_checkpoint(force=True)
+            # Send iopub messages captured during startup.
+            del started, self.iopub_send
+            while self._iopub_cache:
+                self._iopub_cache.reverse()
+                args, kwargs = self._iopub_cache.pop()
+                self.iopub_send(*args, **kwargs)
             await stop
 
     async def _pre_start(self) -> None:
-        """Opens the kernel, starts autostart connections and releases iopub messages."""
+        """Perform tasks just prior to setting as started."""
+        # Autostart connections waiting until they have started.
         if pending := [import_item(pth)().start().started for pth in self.autostart_connections]:
             self.log.info("Waiting for connections to establish %d", len(pending))
-        await self.caller.wait(pending)
-        del self.iopub_send
-        while self._iopub_cache:
-            self._iopub_cache.reverse()
-            args, kwargs = self._iopub_cache.pop()
-            self.iopub_send(*args, **kwargs)
+            await self.caller.wait(pending)
 
     def update_connections(self, *new: Connection[Self]) -> None:
         """Update the list of connections.

{async_kernel-0.22.1 → async_kernel-0.22.2}/src/async_kernel/messaging/zmq.py

@@ -158,8 +158,8 @@ class ZMQConnection(ZMQMessage, Connection[T_interface_co], Generic[T_interface_
             msg = socket.recv()
             if msg[0] == 1:
                 ident = msg[1:]
-                # Note: The welcome message is cached until parent._started is called.
-                self.parent.iopub_send(MsgType.iopub_welcome, content={"subscription": ident.decode()}, ident=ident)
+                msg = self.msg(MsgType.iopub_welcome, {"subscription": ident.decode()}, Channel.iopub)
+                self.session.send(socket, msg, ident=[ident])  # pyright: ignore[reportArgumentType]
 
         def handler(sock, event, channel: Channel, recv=self.session.recv, handle_msg=self.handle_incoming_msg) -> None:
             # Thread: zmq_poll_thread
@@ -169,6 +169,9 @@ class ZMQConnection(ZMQMessage, Connection[T_interface_co], Generic[T_interface_
 
         with self.zmq_poll as zpoll:
             await self._bind_sockets()
+            self.parent.update_connections(self)
+            started()
+            await self.parent.started
             with (
                 zpoll.event_handler(self._sockets[Channel.control], partial(handler, channel=Channel.control)),
                 zpoll.event_handler(self._sockets[Channel.shell], functools.partial(handler, channel=Channel.shell)),
@@ -176,7 +179,8 @@ class ZMQConnection(ZMQMessage, Connection[T_interface_co], Generic[T_interface_
                 zpoll.event_handler(self._sockets[Channel.heartbeat], heartbeat_handler),
                 zpoll.event_handler(self._sockets[Channel.iopub], iopub_reg_handler),
             ):
-                await super().connection_task(started, stop)
+                await stop
+                self.parent.update_connections()
 
     async def _bind_sockets(self):
         """Create, configure and bind all sockets."""
@@ -395,7 +399,7 @@ class ZMQClient(BaseClient[T_interface_co], ZMQMessage, Generic[T_interface_co])
     @asynccontextmanager
     @override
     async def iopub_subscribe(
-        self, topic=b"", *, timeout: float | None = 1.0
+        self, topic=b"", *, timeout: float | None = 10.0
     ) -> AsyncGenerator[SingleAsyncQueue[Message]]:
 
         def forward_messages(sock: ZMQPollSocket, event: int) -> None:
@@ -414,10 +418,11 @@ class ZMQClient(BaseClient[T_interface_co], ZMQMessage, Generic[T_interface_co])
         iopub = await self._connect_socket(Channel.iopub)
         with iopub, self.zmq_poll.event_handler(iopub, forward_messages, canceller=canceller), scope:
             iopub.subscribe(topic)
-            self.log.debug("Waiting for welcome message.")
-            if await ready.with_(timeout=timeout):
-                self.log.debug("Welcome message received.")
-            else:
-                msg = f"Welcome message not received after {timeout:0.1f}s!"
-                raise TimeoutError(msg)
+            if timeout is not None:
+                self.log.debug("Waiting for welcome message.")
+                if await ready.with_(timeout=timeout):
+                    self.log.debug("Welcome message received.")
+                else:
+                    msg = f"Welcome message not received after {timeout:0.1f}s!"
+                    raise TimeoutError(msg)
             yield queue

{async_kernel-0.22.1 → async_kernel-0.22.2}/tests/utils.py

@@ -4,6 +4,7 @@ import importlib.util
 import os
 from typing import TYPE_CHECKING, Any
 
+import anyio
 import pytest
 
 import async_kernel.utils
@@ -66,8 +67,13 @@ async def read_until_msg_type(reader: AsyncGenerator, msg_type: IOPubMsgTypeAlia
     Args:
         reader: An async iterator for a queue returned from iopub subscribe.
         msg_type: The type of iopub message to wait for."""
-    while (msg := await anext(reader))["header"]["msg_type"] != msg_type:
-        continue
+    try:
+        with anyio.fail_after(TIMEOUT):
+            while (msg := await anext(reader))["header"]["msg_type"] != msg_type:
+                continue
+    except TimeoutError as e:
+        msg_ = f"Timeout waiting for {msg_type=} {content_checks=}"
+        raise TimeoutError(msg_) from e
     check_pub_message(msg, msg_type=msg_type, **content_checks)
     return msg