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

{async_kernel-0.13.3 → async_kernel-0.15.0}/.github/workflows/ci.yml

@@ -38,8 +38,7 @@ jobs:
           - "3.11"
           - "3.12"
           - "3.13"
-          - "3.14"
-          # - "3.14t" #  re-enabled when free-threading becomes more widely supported.
+          - "3.14t"
     steps:
       - name: Checkout
         uses: actions/checkout@v6
@@ -54,6 +53,10 @@ jobs:
       - name: Install the project
         run: uv sync --locked --dev
 
+      - if: ${{ startsWith(matrix.os, 'windows') && !endsWith(matrix.python-version, 't')}}
+        # Pyside does not have free-threaded binary
+        run: uv sync --locked --dev --group gui
+
       - name: Run tests
         timeout-minutes: 5
         run: uv run pytest -vvl --maxfail=1 --reruns 1
@@ -75,7 +78,10 @@ jobs:
 
       - name: Run tests with coverage
         timeout-minutes: 5
-        run: uv run pytest --cov --cov-report=xml --junitxml=junit.xml -o junit_family=legacy  --cov-fail-under=100 --cov-report markdown-append:$GITHUB_STEP_SUMMARY
+        run: |
+          uv sync --locked --dev
+          uv pip install orjson>=3.10.16
+          uv run pytest --cov --cov-report=xml --junitxml=junit.xml -o junit_family=legacy  --cov-fail-under=100 --cov-report markdown-append:$GITHUB_STEP_SUMMARY
 
       - name: Upload coverage reports to Codecov
         if: ${{ !cancelled() }}

{async_kernel-0.13.3 → async_kernel-0.15.0}/.github/workflows/enforce-label.yml

@@ -1,12 +1,9 @@
 name: Enforce PR label
 
-concurrency:
-  group: label-${{ github.ref }}
-  cancel-in-progress: true
-
 on:
   pull_request:
     types: [labeled, unlabeled, opened, edited, synchronize]
+
 jobs:
   enforce-label:
     runs-on: ubuntu-latest

{async_kernel-0.13.3 → async_kernel-0.15.0}/.vscode/launch.json

@@ -26,6 +26,36 @@
       },
       "justMyCode": true,
       "args": ["-X dev", "Wd"]
+    },
+    {
+      "name": "Jupyterlab",
+      "type": "debugpy",
+      "request": "launch",
+      "args": [
+        "--notebook-dir=docs/notebooks",
+        "--no-browser",
+        "--ServerApp.token=''",
+        "--port=9991"
+      ],
+      "cwd": "${workspaceFolder}",
+      "justMyCode": false,
+      "module": "jupyterlab",
+      "presentation": {
+        "hidden": false
+      }
+    },
+    {
+      "name": "Editor Browser",
+      "type": "editor-browser",
+      "request": "launch",
+      "url": "http://localhost:9991",
+      "webRoot": "${workspaceFolder}"
+    }
+  ],
+  "compounds": [
+    {
+      "name": "Python and Jupyterlab",
+      "configurations": ["Jupyterlab", "Editor Browser"]
     }
   ]
 }

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

@@ -5,6 +5,68 @@ 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.15.0] - 2026-03-30
+
+### <!-- 0 --> 🏗️ Breaking changes
+
+- Provide cancellation in Pending by default [#386](https://github.com/fleming79/async-kernel/pull/386)
+
+- Use a standard dict for the user_ns (remove LastUpdatedDict) [#380](https://github.com/fleming79/async-kernel/pull/380)
+
+### <!-- 1 --> 🚀 Features
+
+- Replace aiologic.Lock with aiologic.lowlevel.create_thread_oncelock for improved performance [#389](https://github.com/fleming79/async-kernel/pull/389)
+
+- Convert Pending._done_callbacks from deque to list [#383](https://github.com/fleming79/async-kernel/pull/383)
+
+- Free-threading preliminary support. [#379](https://github.com/fleming79/async-kernel/pull/379)
+
+### <!-- 5 --> 📝 Documentation
+
+- Update docstrings [#384](https://github.com/fleming79/async-kernel/pull/384)
+
+- Add thread_safety.md [#381](https://github.com/fleming79/async-kernel/pull/381)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Change Pending.wait_sync signature to be the same as Pending.wait [#393](https://github.com/fleming79/async-kernel/pull/393)
+
+- Tidy up [#391](https://github.com/fleming79/async-kernel/pull/391)
+
+- Pending refactoring. [#390](https://github.com/fleming79/async-kernel/pull/390)
+
+- Use aiologic.lowlevel.create_async_waiter instead of Event for better performance. [#388](https://github.com/fleming79/async-kernel/pull/388)
+
+- Pending refactoring [#385](https://github.com/fleming79/async-kernel/pull/385)
+
+- Caller.queue_call optimizations [#382](https://github.com/fleming79/async-kernel/pull/382)
+
+- Add Kernel.run and refactor the interfaces. [#378](https://github.com/fleming79/async-kernel/pull/378)
+
+- Use Kernel._get_run_mode for all message types. [#377](https://github.com/fleming79/async-kernel/pull/377)
+
+- Add a VS Code launch config for to launch Jupyterlab [#376](https://github.com/fleming79/async-kernel/pull/376)
+
+- Upgrade uv.lock and run gui tests using windows. [#375](https://github.com/fleming79/async-kernel/pull/375)
+
+- Update uv.lock [#374](https://github.com/fleming79/async-kernel/pull/374)
+
+## [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)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Prepare for release v0.14.0 [#373](https://github.com/fleming79/async-kernel/pull/373)
+
 ## [0.13.3] - 2026-03-23
 
 ### <!-- 0 --> 🏗️ Breaking changes
@@ -15,6 +77,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 +1087,8 @@ 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.15.0]: https://github.com/fleming79/async-kernel/compare/v0.14.0..v0.15.0
+[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.15.0}/CONTRIBUTING.md

@@ -208,3 +208,14 @@ uv run mkdocs build -s
     tests can still fail for another os or python version.
 
 [^test-pypi]: This workflow also runs on push to the main branch, but will instead publish to [TestPyPI](https://test.pypi.org/project/async-kernel/).
+
+## VS code development
+
+Debug configurations are included to support debugging with VS Code.
+
+- Python: Debug Tests: This config is for attaching a debugger when launching tests.
+  The recommended way to debug tests.
+- Python and Jupyterlab (Requires VS Code >1.112.0): This provides a compound launch configuration
+  which starts Jupyterlab and Python. The built in browser launches attaches to the Jupyter session
+  (refresh may be required after the server has started). The advantage of this configuration
+  is that all Python processes are attached to the debugger whenever a kernel is opened.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.13.3
+Version: 0.15.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
@@ -29,6 +29,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 1 - Unstable
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: aiologic>=0.16.0
@@ -38,7 +39,7 @@ Requires-Dist: ipython>=9.0
 Requires-Dist: jupyter-client>=8.8; sys_platform != 'emscripten'
 Requires-Dist: jupyter-core>=5.9.1
 Requires-Dist: matplotlib-inline>0.1
-Requires-Dist: orjson>=3.10.16
+Requires-Dist: orjson>=3.10.16; sys_platform == 'emscripten'
 Requires-Dist: outcome; sys_platform != 'emscripten'
 Requires-Dist: pyzmq>=27.0; sys_platform != 'emscripten'
 Requires-Dist: sniffio>=1.3.0; sys_platform != 'emscripten'
@@ -65,12 +66,13 @@ that provides concurrent message handling via an asynchronous backend (asyncio o
 
 The kernel provides two external interfaces:
 
-1. Direct ZMQ socket messaging via a configuration file and kernel spec - (Jupyter, VScode, etc).
+1. Direct ZMQ socket messaging via a configuration file and kernel spec - (Jupyter, VS Code, etc).
 2. An experimental callback style interface (Jupyterlite).
 
 ## 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 +87,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 +106,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 +182,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,15 +194,25 @@ 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/).
 
+## Faster data serialization
+
+[orjson](https://github.com/ijl/orjson) (a fast JSON library) is supported and will be used by default if it has been installed.
+
+## Free-threading support
+
+async-kernel's Caller's are _thread-local_ and it's methods are _internally synchronised_[^4].
+
+[^4]: [free threading terminology](https://py-free-threading.github.io/documentation-principles/#free-threading-terminology)
+
 ## Origin
 
 async-kernel started as a [fork](https://github.com/ipython/ipykernel/commit/8322a7684b004ee95f07b2f86f61e28146a5996d)

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

@@ -16,12 +16,13 @@ that provides concurrent message handling via an asynchronous backend (asyncio o
 
 The kernel provides two external interfaces:
 
-1. Direct ZMQ socket messaging via a configuration file and kernel spec - (Jupyter, VScode, etc).
+1. Direct ZMQ socket messaging via a configuration file and kernel spec - (Jupyter, VS Code, etc).
 2. An experimental callback style interface (Jupyterlite).
 
 ## 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,15 +144,25 @@ 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/).
 
+## Faster data serialization
+
+[orjson](https://github.com/ijl/orjson) (a fast JSON library) is supported and will be used by default if it has been installed.
+
+## Free-threading support
+
+async-kernel's Caller's are _thread-local_ and it's methods are _internally synchronised_[^4].
+
+[^4]: [free threading terminology](https://py-free-threading.github.io/documentation-principles/#free-threading-terminology)
+
 ## Origin
 
 async-kernel started as a [fork](https://github.com/ipython/ipykernel/commit/8322a7684b004ee95f07b2f86f61e28146a5996d)

async_kernel-0.15.0/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.15.0'
+__version_tuple__ = version_tuple = (0, 15, 0)
+
+__commit_id__ = commit_id = None

{async_kernel-0.13.3 → async_kernel-0.15.0}/docs/notebooks/caller.ipynb

@@ -15,7 +15,7 @@
     "\n",
     "_This notebook has the Python dependencies: `trio`, `matplotlib`_\n",
     "\n",
-    "`Caller` is a class that enables standard functions and coroutines to be called in the event loop of a `asyncio` or `trio` backend. Scheduling is thread-safe, methods that return `Pending` are thread-safe cancellable and awaitable."
+    "`Caller` is a thread-local class that coordinates the execution of functions and coroutines in the event loop of a `asyncio` or `trio` backend."
    ]
   },
   {
@@ -35,6 +35,7 @@
    "metadata": {},
    "source": [
     "A `Caller` instance can be started with one gui as a host to one backend started as a guest. \n",
+    "\n",
     "A second backend can also be started in the same thread with or without a host gui event loop.\n",
     "Potentially the same thread could have up to:\n",
     "\n",
@@ -77,11 +78,10 @@
    "id": "5",
    "metadata": {},
    "source": [
-    "There are three caller instances associated with the Kernel:\n",
+    "There are two caller instances associated with the Kernel:\n",
     "\n",
     "- Shell: The caller for the shell channel (normally the MainThread).\n",
-    "- Control: The caller for the control channel (a child of the shell).\n",
-    "- Shell thread_queue: A separate thread to handle shell messages in a separate thread (queued by message type and subshell_id)."
+    "- Control: The caller for the control channel (a child of the shell)."
    ]
   },
   {
@@ -89,7 +89,9 @@
    "id": "6",
    "metadata": {},
    "source": [
-    "Calling `Caller()` with no arguments will return the caller for the current thread (context in Pyodide). A runtime error will occur if when there is no backend running in the current thread (in Pyodide the main caller is always available)."
+    "Calling `Caller()` with no arguments will return the caller for the current thread (or context in Pyodide). \n",
+    "\n",
+    "A runtime error will occur if there is no event loop (backend) running in the current thread (unlikely in Pyodide which provides a running event loop)."
    ]
   },
   {
@@ -111,7 +113,7 @@
    "source": [
     "## Modifiers\n",
     "\n",
-    "There are four modifiers that determine the instance returned when calling `Caller`.\n",
+    "There are four modifiers that determine which instance is returned when calling `Caller`.\n",
     "\n",
     "- `CurrentThread` (default): Access the caller that belongs to the current thread (or context with Pyodide).\n",
     "- `MainThread`: Access main thread for the Caller.\n",
@@ -285,7 +287,9 @@
    "source": [
     "### Caller.call_using_backend\n",
     "\n",
-    "This method calls functions and coroutines using a specific asynchronous backend in the same thread. When the backend does not match the callers backend, it is run with the backend running as a guest."
+    "This method calls functions and coroutines using a specific asynchronous backend in the same thread. \n",
+    "\n",
+    "When the backend does not match the callers backend, it is run with the backend running as a guest."
    ]
   },
   {
@@ -490,10 +494,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import anyio\n",
+    "\n",
     "async with caller.create_pending_group() as pg:\n",
-    "    caller.call_soon(asyncio.sleep, 0.01)\n",
-    "    caller.call_later(0, asyncio.sleep, 0)\n",
-    "    caller.to_thread(asyncio.sleep, 0.01)\n",
+    "    caller.call_soon(anyio.sleep, 0.01)\n",
+    "    caller.call_later(0, anyio.sleep, 0)\n",
+    "    caller.to_thread(anyio.sleep, 0.01)\n",
+    "    caller.call_using_backend(\"asyncio\", asyncio.sleep, 0.01)\n",
     "    caller.call_using_backend(\"trio\", trio.sleep, 0.01)\n",
     "    print(\"In context pending=\", len(pg.pending))\n",
     "\n",

async_kernel-0.15.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.15.0}/docs/reference/index.md

@@ -12,6 +12,6 @@ The reference section provides documentation for each module in async-kernel.
 ## Highlights
 
 - [Kernel][async_kernel.kernel.Kernel] - The kernel.
-- [Caller][async_kernel.caller.Caller] - Simplifies event loop management and call scheduling (thread-safe).
-- [Pending][async_kernel.pending.Pending] - Represents a pending result that can be set, awaited and cancelled (thread-safe).
+- [Caller][async_kernel.caller.Caller] - Simplifies event loop management and call scheduling.
+- [Pending][async_kernel.pending.Pending] - Represents a pending result (like an [asyncio.Future][] that can be awaited anywhere).
 - [command_line][async_kernel.command.command_line] - The command line interface.

async_kernel-0.15.0/docs/thread_safety.md

@@ -0,0 +1,40 @@
+# Thread Safety of Built-in Types
+
+- [Terminology](https://py-free-threading.github.io/documentation-principles/#free-threading-terminology)
+
+_aync-kernel_ utilises [aiologic](https://aiologic.readthedocs.io/latest/index.html) for its _thread-safe_ primitives.
+
+## [async_kernel.pending.Pending][]
+
+### Guarantees
+
+- **Internally synchronised**
+    - All Public methods can be safely called from any thread.
+    - Instance are sync/async awaitable from any thread with any backend.
+
+- **Limitations**
+
+    [add_done_callback][async_kernel.pending.Pending.add_done_callback]: The callback is called from the thread in which it is set
+    so should provide it's own synchronisation as needed.
+
+## [async_kernel.caller.Caller][]
+
+`Caller` is thread-local in CPython and context-local in Pyodide.
+
+### Guarantees
+
+- **Internally synchronised**
+
+- **Limitations**
+    - [queue_call][async_kernel.caller.Caller.queue_call] is internally synchronised per-function after
+      the first call (per-function) has returned.
+
+## [async_kernel.common.Fixed][]
+
+### Guarantees
+
+- **Internally synchronised**
+
+### Other classes
+
+TODO