conkernelclient 0.0.14__tar.gz → 0.0.16__tar.gz

conkernelclient-0.0.16/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: conkernelclient
+Version: 0.0.16
+Summary: Concurrent-safe Jupyter KernelClient
+Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/conkernelclient
+Project-URL: Documentation, https://AnswerDotAI.github.io/conkernelclient/
+Keywords: nbdev
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jupyter_client
+Requires-Dist: fastcore
+Provides-Extra: dev
+Requires-Dist: ipykernel; extra == "dev"
+Dynamic: license-file
+
+# conkernelclient
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+## Background
+
+Jupyter’s `KernelClient` is designed around a simple request-reply pattern: you send one message on the shell channel, wait for its reply, then send the next. This works fine for a single-threaded notebook, but falls apart when you need concurrent execution. For instance, running multiple cells in parallel, or letting an LLM tool loop fire off code while a long-running computation is still in flight. The underlying ZMQ socket isn’t safe to share across tasks, and there’s no built-in mechanism to route replies back to the correct caller when multiple requests are outstanding.
+
+*conkernelclient* solves this with [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), a drop-in replacement for `AsyncKernelClient` that makes concurrent `execute()` calls safe. It patches `Session.send` to synchronise with the ZMQ I/O thread (preventing a race where two sends interleave), and spins up a dedicated reader task on the shell channel that demultiplexes incoming replies by message ID. Each `execute(..., reply=True)` call gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), so multiple coroutines can `await` their replies independently without interfering with each other.
+
+## Installation
+
+Install from [pypi](https://pypi.org/project/conkernelclient/)
+
+``` sh
+$ pip install conkernelclient
+```
+
+## How to use
+
+``` python
+from conkernelclient import *
+```
+
+The main entry point is [`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager), a drop-in replacement for `AsyncKernelManager` that creates [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient) instances. Start a kernel and connect a client in the usual way:
+
+``` python
+import asyncio
+from jupyter_client.session import Session
+```
+
+``` python
+km = ConKernelManager(session=Session(key=b'x'))
+await km.start_kernel()
+kc = await km.client().start_channels()
+await kc.is_alive()
+```
+
+    True
+
+Once connected, `execute()` works like the standard client. Pass `reply=True` to await the shell reply, or `reply=False` (the default) to fire-and-forget and collect results later via `get_pubs`:
+
+``` python
+r = await kc.execute('2+1', timeout=1, reply=True)
+r['content']['status']
+```
+
+    'ok'
+
+The key feature is safe concurrent execution. Multiple `execute(..., reply=True)` calls can be outstanding simultaneously — each gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), and a background reader task routes replies by message ID:
+
+``` python
+from fastcore.test import test_eq
+```
+
+``` python
+a = kc.execute('x=2', reply=True)
+b = kc.execute('y=3', reply=True)
+r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
+test_eq(len(r), 2)
+r[0]['parent_header']['msg_id']
+```
+
+    '8c84fe1c-20242a1940eecfc5a1a31500_61486_3'
+
+Both replies arrive independently, each routed to the correct caller. Without [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), the second `execute` would either block waiting for the first to finish, or the replies would get crossed.
+
+As usual, we clean up when we’re done:
+
+``` python
+if await km.is_alive():
+    kc.stop_channels()
+    await km.shutdown_kernel()
+```

conkernelclient-0.0.16/README.md

@@ -0,0 +1,75 @@
+# conkernelclient
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+## Background
+
+Jupyter’s `KernelClient` is designed around a simple request-reply pattern: you send one message on the shell channel, wait for its reply, then send the next. This works fine for a single-threaded notebook, but falls apart when you need concurrent execution. For instance, running multiple cells in parallel, or letting an LLM tool loop fire off code while a long-running computation is still in flight. The underlying ZMQ socket isn’t safe to share across tasks, and there’s no built-in mechanism to route replies back to the correct caller when multiple requests are outstanding.
+
+*conkernelclient* solves this with [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), a drop-in replacement for `AsyncKernelClient` that makes concurrent `execute()` calls safe. It patches `Session.send` to synchronise with the ZMQ I/O thread (preventing a race where two sends interleave), and spins up a dedicated reader task on the shell channel that demultiplexes incoming replies by message ID. Each `execute(..., reply=True)` call gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), so multiple coroutines can `await` their replies independently without interfering with each other.
+
+## Installation
+
+Install from [pypi](https://pypi.org/project/conkernelclient/)
+
+``` sh
+$ pip install conkernelclient
+```
+
+## How to use
+
+``` python
+from conkernelclient import *
+```
+
+The main entry point is [`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager), a drop-in replacement for `AsyncKernelManager` that creates [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient) instances. Start a kernel and connect a client in the usual way:
+
+``` python
+import asyncio
+from jupyter_client.session import Session
+```
+
+``` python
+km = ConKernelManager(session=Session(key=b'x'))
+await km.start_kernel()
+kc = await km.client().start_channels()
+await kc.is_alive()
+```
+
+    True
+
+Once connected, `execute()` works like the standard client. Pass `reply=True` to await the shell reply, or `reply=False` (the default) to fire-and-forget and collect results later via `get_pubs`:
+
+``` python
+r = await kc.execute('2+1', timeout=1, reply=True)
+r['content']['status']
+```
+
+    'ok'
+
+The key feature is safe concurrent execution. Multiple `execute(..., reply=True)` calls can be outstanding simultaneously — each gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), and a background reader task routes replies by message ID:
+
+``` python
+from fastcore.test import test_eq
+```
+
+``` python
+a = kc.execute('x=2', reply=True)
+b = kc.execute('y=3', reply=True)
+r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
+test_eq(len(r), 2)
+r[0]['parent_header']['msg_id']
+```
+
+    '8c84fe1c-20242a1940eecfc5a1a31500_61486_3'
+
+Both replies arrive independently, each routed to the correct caller. Without [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), the second `execute` would either block waiting for the first to finish, or the replies would get crossed.
+
+As usual, we clean up when we’re done:
+
+``` python
+if await km.is_alive():
+    kc.stop_channels()
+    await km.shutdown_kernel()
+```

{conkernelclient-0.0.14 → conkernelclient-0.0.16}/conkernelclient/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.0.14"
+__version__ = "0.0.16"
 from .core import *
 from .ops import *

{conkernelclient-0.0.14 → conkernelclient-0.0.16}/conkernelclient/_modidx.py

@@ -23,6 +23,8 @@ d = { 'settings': { 'branch': 'main',
                                       'conkernelclient.core.ConKernelClient.stop_channels': ( 'core.html#conkernelclient.stop_channels',
                                                                                               'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelManager': ('core.html#conkernelmanager', 'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelManager._transport_encryption_default': ( 'core.html#conkernelmanager._transport_encryption_default',
+                                                                                                               'conkernelclient/core.py'),
                                       'conkernelclient.core.DeadKernelError': ('core.html#deadkernelerror', 'conkernelclient/core.py'),
                                       'conkernelclient.core._send': ('core.html#_send', 'conkernelclient/core.py'),
                                       'conkernelclient.core.apply_session_patch': ( 'core.html#apply_session_patch',

{conkernelclient-0.0.14 → conkernelclient-0.0.16}/conkernelclient/core.py

@@ -11,7 +11,7 @@ __all__ = ['DeadKernelError', 'apply_session_patch', 'ConKernelClient', 'ConKern
 from jupyter_client import AsyncKernelClient, AsyncKernelManager
 from jupyter_client.session import Session
 from zmq.error import ZMQError
-from traitlets import Type
+from traitlets import Type, default
 import asyncio, zmq.asyncio, time, logging
 
 # %% ../nbs/00_core.ipynb #737a0fc1
@@ -48,6 +48,9 @@ def apply_session_patch():
 class ConKernelClient(AsyncKernelClient):
     def __init__(self, *args, **kwargs):
         apply_session_patch()
+        # jupyter_client's `get_connection_info` returns curve keys as str, but the client traits are `Bytes`
+        for k in ('curve_publickey','curve_secretkey'):
+            if isinstance(kwargs.get(k), str): kwargs[k] = kwargs[k].encode()
         super().__init__(*args, **kwargs)
 
     def _fail_pending(self, exc:Exception, skip=None):
@@ -134,4 +137,7 @@ class ConKernelClient(AsyncKernelClient):
         await asyncio.sleep(0.01)
 
 # %% ../nbs/00_core.ipynb #b828c222
-class ConKernelManager(AsyncKernelManager): client_class,client_factory = ConKernelClient,Type(ConKernelClient)
+class ConKernelManager(AsyncKernelManager):
+    client_class,client_factory = ConKernelClient,Type(ConKernelClient)
+    @default('transport_encryption')
+    def _transport_encryption_default(self): return 'auto'

conkernelclient-0.0.16/conkernelclient.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: conkernelclient
+Version: 0.0.16
+Summary: Concurrent-safe Jupyter KernelClient
+Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/conkernelclient
+Project-URL: Documentation, https://AnswerDotAI.github.io/conkernelclient/
+Keywords: nbdev
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jupyter_client
+Requires-Dist: fastcore
+Provides-Extra: dev
+Requires-Dist: ipykernel; extra == "dev"
+Dynamic: license-file
+
+# conkernelclient
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+## Background
+
+Jupyter’s `KernelClient` is designed around a simple request-reply pattern: you send one message on the shell channel, wait for its reply, then send the next. This works fine for a single-threaded notebook, but falls apart when you need concurrent execution. For instance, running multiple cells in parallel, or letting an LLM tool loop fire off code while a long-running computation is still in flight. The underlying ZMQ socket isn’t safe to share across tasks, and there’s no built-in mechanism to route replies back to the correct caller when multiple requests are outstanding.
+
+*conkernelclient* solves this with [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), a drop-in replacement for `AsyncKernelClient` that makes concurrent `execute()` calls safe. It patches `Session.send` to synchronise with the ZMQ I/O thread (preventing a race where two sends interleave), and spins up a dedicated reader task on the shell channel that demultiplexes incoming replies by message ID. Each `execute(..., reply=True)` call gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), so multiple coroutines can `await` their replies independently without interfering with each other.
+
+## Installation
+
+Install from [pypi](https://pypi.org/project/conkernelclient/)
+
+``` sh
+$ pip install conkernelclient
+```
+
+## How to use
+
+``` python
+from conkernelclient import *
+```
+
+The main entry point is [`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager), a drop-in replacement for `AsyncKernelManager` that creates [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient) instances. Start a kernel and connect a client in the usual way:
+
+``` python
+import asyncio
+from jupyter_client.session import Session
+```
+
+``` python
+km = ConKernelManager(session=Session(key=b'x'))
+await km.start_kernel()
+kc = await km.client().start_channels()
+await kc.is_alive()
+```
+
+    True
+
+Once connected, `execute()` works like the standard client. Pass `reply=True` to await the shell reply, or `reply=False` (the default) to fire-and-forget and collect results later via `get_pubs`:
+
+``` python
+r = await kc.execute('2+1', timeout=1, reply=True)
+r['content']['status']
+```
+
+    'ok'
+
+The key feature is safe concurrent execution. Multiple `execute(..., reply=True)` calls can be outstanding simultaneously — each gets its own [`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue), and a background reader task routes replies by message ID:
+
+``` python
+from fastcore.test import test_eq
+```
+
+``` python
+a = kc.execute('x=2', reply=True)
+b = kc.execute('y=3', reply=True)
+r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
+test_eq(len(r), 2)
+r[0]['parent_header']['msg_id']
+```
+
+    '8c84fe1c-20242a1940eecfc5a1a31500_61486_3'
+
+Both replies arrive independently, each routed to the correct caller. Without [`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient), the second `execute` would either block waiting for the first to finish, or the replies would get crossed.
+
+As usual, we clean up when we’re done:
+
+``` python
+if await km.is_alive():
+    kc.stop_channels()
+    await km.shutdown_kernel()
+```

conkernelclient-0.0.14/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.4
-Name: conkernelclient
-Version: 0.0.14
-Summary: Concurrent-safe Jupyter KernelClient
-Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
-License: Apache-2.0
-Project-URL: Repository, https://github.com/AnswerDotAI/conkernelclient
-Project-URL: Documentation, https://AnswerDotAI.github.io/conkernelclient/
-Keywords: nbdev
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jupyter_client
-Requires-Dist: fastcore
-Provides-Extra: dev
-Requires-Dist: ipykernel; extra == "dev"
-Dynamic: license-file
-
-# conkernelclient
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-## Background
-
-Jupyter’s `KernelClient` is designed around a simple request-reply
-pattern: you send one message on the shell channel, wait for its reply,
-then send the next. This works fine for a single-threaded notebook, but
-falls apart when you need concurrent execution. For instance, running
-multiple cells in parallel, or letting an LLM tool loop fire off code
-while a long-running computation is still in flight. The underlying ZMQ
-socket isn’t safe to share across tasks, and there’s no built-in
-mechanism to route replies back to the correct caller when multiple
-requests are outstanding.
-
-*conkernelclient* solves this with
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-a drop-in replacement for `AsyncKernelClient` that makes concurrent
-`execute()` calls safe. It patches `Session.send` to synchronise with
-the ZMQ I/O thread (preventing a race where two sends interleave), and
-spins up a dedicated reader task on the shell channel that demultiplexes
-incoming replies by message ID. Each `execute(..., reply=True)` call
-gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-so multiple coroutines can `await` their replies independently without
-interfering with each other.
-
-## Installation
-
-Install from [pypi](https://pypi.org/project/conkernelclient/)
-
-``` sh
-$ pip install conkernelclient
-```
-
-## How to use
-
-``` python
-from conkernelclient import *
-```
-
-The main entry point is
-[`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager),
-a drop-in replacement for `AsyncKernelManager` that creates
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient)
-instances. Start a kernel and connect a client in the usual way:
-
-``` python
-import asyncio
-from jupyter_client.session import Session
-```
-
-``` python
-km = ConKernelManager(session=Session(key=b'x'))
-await km.start_kernel()
-kc = await km.client().start_channels()
-await kc.is_alive()
-```
-
-    True
-
-Once connected, `execute()` works like the standard client. Pass
-`reply=True` to await the shell reply, or `reply=False` (the default) to
-fire-and-forget and collect results later via `get_pubs`:
-
-``` python
-r = await kc.execute('2+1', timeout=1, reply=True)
-r['content']['status']
-```
-
-    'ok'
-
-The key feature is safe concurrent execution. Multiple
-`execute(..., reply=True)` calls can be outstanding simultaneously —
-each gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-and a background reader task routes replies by message ID:
-
-``` python
-from fastcore.test import test_eq
-```
-
-``` python
-a = kc.execute('x=2', reply=True)
-b = kc.execute('y=3', reply=True)
-r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
-test_eq(len(r), 2)
-r[0]['parent_header']['msg_id']
-```
-
-    'dab23f68-96c28dd9c776844176afdff1_66028_2'
-
-Both replies arrive independently, each routed to the correct caller.
-Without
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-the second `execute` would either block waiting for the first to finish,
-or the replies would get crossed.
-
-As usual, we clean up when we’re done:
-
-``` python
-if await km.is_alive():
-    kc.stop_channels()
-    await km.shutdown_kernel()
-```
-

conkernelclient-0.0.14/README.md

@@ -1,108 +0,0 @@
-# conkernelclient
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-## Background
-
-Jupyter’s `KernelClient` is designed around a simple request-reply
-pattern: you send one message on the shell channel, wait for its reply,
-then send the next. This works fine for a single-threaded notebook, but
-falls apart when you need concurrent execution. For instance, running
-multiple cells in parallel, or letting an LLM tool loop fire off code
-while a long-running computation is still in flight. The underlying ZMQ
-socket isn’t safe to share across tasks, and there’s no built-in
-mechanism to route replies back to the correct caller when multiple
-requests are outstanding.
-
-*conkernelclient* solves this with
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-a drop-in replacement for `AsyncKernelClient` that makes concurrent
-`execute()` calls safe. It patches `Session.send` to synchronise with
-the ZMQ I/O thread (preventing a race where two sends interleave), and
-spins up a dedicated reader task on the shell channel that demultiplexes
-incoming replies by message ID. Each `execute(..., reply=True)` call
-gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-so multiple coroutines can `await` their replies independently without
-interfering with each other.
-
-## Installation
-
-Install from [pypi](https://pypi.org/project/conkernelclient/)
-
-``` sh
-$ pip install conkernelclient
-```
-
-## How to use
-
-``` python
-from conkernelclient import *
-```
-
-The main entry point is
-[`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager),
-a drop-in replacement for `AsyncKernelManager` that creates
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient)
-instances. Start a kernel and connect a client in the usual way:
-
-``` python
-import asyncio
-from jupyter_client.session import Session
-```
-
-``` python
-km = ConKernelManager(session=Session(key=b'x'))
-await km.start_kernel()
-kc = await km.client().start_channels()
-await kc.is_alive()
-```
-
-    True
-
-Once connected, `execute()` works like the standard client. Pass
-`reply=True` to await the shell reply, or `reply=False` (the default) to
-fire-and-forget and collect results later via `get_pubs`:
-
-``` python
-r = await kc.execute('2+1', timeout=1, reply=True)
-r['content']['status']
-```
-
-    'ok'
-
-The key feature is safe concurrent execution. Multiple
-`execute(..., reply=True)` calls can be outstanding simultaneously —
-each gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-and a background reader task routes replies by message ID:
-
-``` python
-from fastcore.test import test_eq
-```
-
-``` python
-a = kc.execute('x=2', reply=True)
-b = kc.execute('y=3', reply=True)
-r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
-test_eq(len(r), 2)
-r[0]['parent_header']['msg_id']
-```
-
-    'dab23f68-96c28dd9c776844176afdff1_66028_2'
-
-Both replies arrive independently, each routed to the correct caller.
-Without
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-the second `execute` would either block waiting for the first to finish,
-or the replies would get crossed.
-
-As usual, we clean up when we’re done:
-
-``` python
-if await km.is_alive():
-    kc.stop_channels()
-    await km.shutdown_kernel()
-```
-

conkernelclient-0.0.14/conkernelclient.egg-info/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.4
-Name: conkernelclient
-Version: 0.0.14
-Summary: Concurrent-safe Jupyter KernelClient
-Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
-License: Apache-2.0
-Project-URL: Repository, https://github.com/AnswerDotAI/conkernelclient
-Project-URL: Documentation, https://AnswerDotAI.github.io/conkernelclient/
-Keywords: nbdev
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jupyter_client
-Requires-Dist: fastcore
-Provides-Extra: dev
-Requires-Dist: ipykernel; extra == "dev"
-Dynamic: license-file
-
-# conkernelclient
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-## Background
-
-Jupyter’s `KernelClient` is designed around a simple request-reply
-pattern: you send one message on the shell channel, wait for its reply,
-then send the next. This works fine for a single-threaded notebook, but
-falls apart when you need concurrent execution. For instance, running
-multiple cells in parallel, or letting an LLM tool loop fire off code
-while a long-running computation is still in flight. The underlying ZMQ
-socket isn’t safe to share across tasks, and there’s no built-in
-mechanism to route replies back to the correct caller when multiple
-requests are outstanding.
-
-*conkernelclient* solves this with
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-a drop-in replacement for `AsyncKernelClient` that makes concurrent
-`execute()` calls safe. It patches `Session.send` to synchronise with
-the ZMQ I/O thread (preventing a race where two sends interleave), and
-spins up a dedicated reader task on the shell channel that demultiplexes
-incoming replies by message ID. Each `execute(..., reply=True)` call
-gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-so multiple coroutines can `await` their replies independently without
-interfering with each other.
-
-## Installation
-
-Install from [pypi](https://pypi.org/project/conkernelclient/)
-
-``` sh
-$ pip install conkernelclient
-```
-
-## How to use
-
-``` python
-from conkernelclient import *
-```
-
-The main entry point is
-[`ConKernelManager`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelmanager),
-a drop-in replacement for `AsyncKernelManager` that creates
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient)
-instances. Start a kernel and connect a client in the usual way:
-
-``` python
-import asyncio
-from jupyter_client.session import Session
-```
-
-``` python
-km = ConKernelManager(session=Session(key=b'x'))
-await km.start_kernel()
-kc = await km.client().start_channels()
-await kc.is_alive()
-```
-
-    True
-
-Once connected, `execute()` works like the standard client. Pass
-`reply=True` to await the shell reply, or `reply=False` (the default) to
-fire-and-forget and collect results later via `get_pubs`:
-
-``` python
-r = await kc.execute('2+1', timeout=1, reply=True)
-r['content']['status']
-```
-
-    'ok'
-
-The key feature is safe concurrent execution. Multiple
-`execute(..., reply=True)` calls can be outstanding simultaneously —
-each gets its own
-[`asyncio.Queue`](https://docs.python.org/3/library/asyncio-queue.html#asyncio.Queue),
-and a background reader task routes replies by message ID:
-
-``` python
-from fastcore.test import test_eq
-```
-
-``` python
-a = kc.execute('x=2', reply=True)
-b = kc.execute('y=3', reply=True)
-r = await asyncio.wait_for(asyncio.gather(a, b), timeout=2)
-test_eq(len(r), 2)
-r[0]['parent_header']['msg_id']
-```
-
-    'dab23f68-96c28dd9c776844176afdff1_66028_2'
-
-Both replies arrive independently, each routed to the correct caller.
-Without
-[`ConKernelClient`](https://AnswerDotAI.github.io/conkernelclient/core.html#conkernelclient),
-the second `execute` would either block waiting for the first to finish,
-or the replies would get crossed.
-
-As usual, we clean up when we’re done:
-
-``` python
-if await km.is_alive():
-    kc.stop_channels()
-    await km.shutdown_kernel()
-```
-