conkernelclient 0.0.18__tar.gz → 0.0.20__tar.gz

{conkernelclient-0.0.18/conkernelclient.egg-info → conkernelclient-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conkernelclient
-Version: 0.0.18
+Version: 0.0.20
 Summary: Concurrent-safe Jupyter KernelClient
 Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
 License: Apache-2.0
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jupyter_client
 Requires-Dist: fastcore>=2.1.17
-Requires-Dist: jupywire>=0.1.4
+Requires-Dist: jupywire>=0.1.5
 Provides-Extra: dev
 Requires-Dist: ipykernel; extra == "dev"
 Requires-Dist: ipymini>=0.1.17; extra == "dev"

conkernelclient-0.0.20/conkernelclient/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.20"
+from jupywire.route import JmsgQueues, DeadKernelError
+from .core import *
+from .ops import *

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/conkernelclient/_modidx.py

@@ -8,28 +8,32 @@ d = { 'settings': { 'branch': 'main',
   'syms': { 'conkernelclient.core': { 'conkernelclient.core.ConKernelClient': ('core.html#conkernelclient', 'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.__init__': ( 'core.html#conkernelclient.__init__',
                                                                                          'conkernelclient/core.py'),
-                                      'conkernelclient.core.ConKernelClient._async_recv_reply': ( 'core.html#conkernelclient._async_recv_reply',
-                                                                                                  'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient._check_alive': ( 'core.html#conkernelclient._check_alive',
                                                                                              'conkernelclient/core.py'),
-                                      'conkernelclient.core.ConKernelClient._fail_pending': ( 'core.html#conkernelclient._fail_pending',
-                                                                                              'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelClient._pump': ( 'core.html#conkernelclient._pump',
+                                                                                      'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelClient._route': ( 'core.html#conkernelclient._route',
+                                                                                       'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelClient._watch_hb': ( 'core.html#conkernelclient._watch_hb',
+                                                                                          'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.astop_channels': ( 'core.html#conkernelclient.astop_channels',
                                                                                                'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.execute': ( 'core.html#conkernelclient.execute',
                                                                                         'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelClient.send': ( 'core.html#conkernelclient.send',
+                                                                                     'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.start_channels': ( 'core.html#conkernelclient.start_channels',
                                                                                                'conkernelclient/core.py'),
-                                      'conkernelclient.core.ConKernelClient.stdin_send': ( 'core.html#conkernelclient.stdin_send',
-                                                                                           'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.stop_channels': ( 'core.html#conkernelclient.stop_channels',
                                                                                               'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelClient.wait_for_ready': ( 'core.html#conkernelclient.wait_for_ready',
                                                                                                'conkernelclient/core.py'),
                                       'conkernelclient.core.ConKernelManager': ('core.html#conkernelmanager', 'conkernelclient/core.py'),
+                                      'conkernelclient.core.ConKernelManager.__init__': ( 'core.html#conkernelmanager.__init__',
+                                                                                          '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._dead_status': ('core.html#_dead_status', 'conkernelclient/core.py'),
                                       'conkernelclient.core._send': ('core.html#_send', 'conkernelclient/core.py'),
                                       'conkernelclient.core.apply_session_patch': ( 'core.html#apply_session_patch',
                                                                                     'conkernelclient/core.py')},
@@ -40,14 +44,10 @@ d = { 'settings': { 'branch': 'main',
                                                                                               'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.ctl': ('ops.html#conkernelclient.ctl', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.dap': ('ops.html#conkernelclient.dap', 'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.ConKernelClient.eval_expr': ( 'ops.html#conkernelclient.eval_expr',
-                                                                                        'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.exec_drain': ( 'ops.html#conkernelclient.exec_drain',
                                                                                          'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.exec_ok': ( 'ops.html#conkernelclient.exec_ok',
                                                                                       'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.ConKernelClient.exec_outs': ( 'ops.html#conkernelclient.exec_outs',
-                                                                                        'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.input_reply': ( 'ops.html#conkernelclient.input_reply',
                                                                                           'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.interrupt': ( 'ops.html#conkernelclient.interrupt',
@@ -56,13 +56,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                           'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.iopub_flush': ( 'ops.html#conkernelclient.iopub_flush',
                                                                                           'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.ConKernelClient.reply': ( 'ops.html#conkernelclient.reply',
-                                                                                    'conkernelclient/ops.py'),
                                      'conkernelclient.ops.ConKernelClient.shell_request': ( 'ops.html#conkernelclient.shell_request',
                                                                                             'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.ConKernelClient.user_exprs': ( 'ops.html#conkernelclient.user_exprs',
-                                                                                         'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.EvalError': ('ops.html#evalerror', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops._DapProxy': ('ops.html#_dapproxy', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops._DapProxy.__getattr__': ( 'ops.html#_dapproxy.__getattr__',
                                                                                     'conkernelclient/ops.py'),
@@ -73,6 +68,5 @@ d = { 'settings': { 'branch': 'main',
                                      'conkernelclient.ops._ReqProxy.__init__': ('ops.html#_reqproxy.__init__', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops.iopub_streams': ('ops.html#iopub_streams', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops.iter_timeout': ('ops.html#iter_timeout', 'conkernelclient/ops.py'),
-                                     'conkernelclient.ops.parse_expr': ('ops.html#parse_expr', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops.reconnect': ('ops.html#reconnect', 'conkernelclient/ops.py'),
                                      'conkernelclient.ops.run_kernel': ('ops.html#run_kernel', 'conkernelclient/ops.py')}}}

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/conkernelclient/core.py

@@ -5,7 +5,7 @@ Docs: https://AnswerDotAI.github.io/conkernelclient/core.html.md"""
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_core.ipynb.
 
 # %% auto #0
-__all__ = ['DeadKernelError', 'apply_session_patch', 'ConKernelClient', 'ConKernelManager']
+__all__ = ['apply_session_patch', 'ConKernelClient', 'ConKernelManager']
 
 # %% ../nbs/00_core.ipynb #d3b521c0
 from jupyter_client import AsyncKernelClient, AsyncKernelManager
@@ -14,15 +14,13 @@ from zmq.error import ZMQError
 from traitlets import Type, default
 from fastcore.utils import patch
 from jupywire.ops import EvalOps
+from jupywire.route import RouterOps, DeadKernelError
 from queue import Empty
-import asyncio, zmq.asyncio, time, logging
+import asyncio, inspect, zmq.asyncio, time, logging
 
 # %% ../nbs/00_core.ipynb #737a0fc1
 _log = logging.getLogger(__name__)
 
-# %% ../nbs/00_core.ipynb #a093006c
-class DeadKernelError(Exception): pass
-
 # %% ../nbs/00_core.ipynb #374b75d0
 def _send(self, stream, msg_or_type, content=None, parent=None, ident=None,
     buffers=None, track=False, header=None, metadata=None):
@@ -48,7 +46,12 @@ def apply_session_patch():
     Session.send = _send
 
 # %% ../nbs/00_core.ipynb #d6a5fa6a
-class ConKernelClient(EvalOps, AsyncKernelClient):
+def _dead_status():
+    "The dead `status` rustygate broadcasts, synthesized client-side for zmq transport loss and heartbeat silence"
+    return dict(channel='iopub', msg_type='status', header={}, parent_header={}, content=dict(execution_state='dead'), buffers=[])
+
+
+class ConKernelClient(RouterOps, EvalOps, 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`
@@ -56,86 +59,81 @@ class ConKernelClient(EvalOps, AsyncKernelClient):
             if isinstance(kwargs.get(k), str): kwargs[k] = kwargs[k].encode()
         super().__init__(*args, **kwargs)
 
-    def _fail_pending(self, exc:Exception, skip=None):
-        for k,(q,_) in list(getattr(self, '_pending', {}).items()):
-            if k != skip:
-                try: q.put_nowait(exc)
-                except asyncio.QueueFull: pass
-
     def _check_alive(self):
         if not self.channels_running: raise RuntimeError("Channels not running")
-        tk = getattr(self, '_shell_reader_task', None)
-        return tk is not None and not tk.done()
-
-    async def start_channels(self, shell:bool=True, iopub:bool=True, stdin:bool=True, hb:bool=True, control:bool=True):
-        "Start channels, wait for ready, and launch background shell-reply reader"
-        super().start_channels(shell=shell, iopub=iopub, stdin=stdin, hb=hb, control=control)
-        await self.wait_for_ready()
-        self._pending = {}
-        _ready = asyncio.Event()
-        async def _reader():
-            _ready.set()
-            while True:
-                try: reply = await self.get_shell_msg(timeout=None)
-                except Exception as e:
-                    if isinstance(e, (AssertionError, OSError, ZMQError)): e = DeadKernelError(f"Kernel socket closed: {e}")
-                    self._fail_pending(e)
-                    _log.warning(f"_reader died, pending={list(self._pending)}: {e}")
-                    break
-                mid = reply["parent_header"].get("msg_id")
-                pend = self._pending.get(mid)
-                if pend:
-                    q, soe = pend
-                    try: q.put_nowait(reply)
-                    except asyncio.QueueFull: pass
-                cts = reply.get("content", {})
-                if cts.get("status") in ("error", "aborted") and pend and soe:
-                    exc = RuntimeError(f"Kernel error aborted: {cts.get('ename')}: {cts.get('evalue')}")
-                    self._fail_pending(exc, skip=mid)
-        self._shell_reader_task = asyncio.create_task(_reader())
-        await _ready.wait()
-        return self
-
-    def stop_channels(self):
-        "Stop channels and cancel the background shell-reply reader task"
-        self._fail_pending(RuntimeError("Shell channels stopped before reply"))
-        super().stop_channels()
-        if (tk := getattr(self, '_shell_reader_task', None)):
-            tk.cancel()
-            self._shell_reader_task = None
-
-    async def _async_recv_reply(self, msg_id, timeout=None, channel="shell"):
-        if channel == "control": return await self._async_get_control_msg(timeout=timeout)
-        q, _ = self._pending[msg_id]
-        try:
-            res = await asyncio.wait_for(q.get(), timeout)
-            if isinstance(res, Exception): raise res
-            return res
-        finally: self._pending.pop(msg_id, None)
-
-    def execute(self, code, user_expressions=None, allow_stdin=None, reply=False, subsh_id=None,
-        cts_typ='code', timeout=60, msg_id=None, stop_on_error=True, fail_pending=False, **kw):
-        "Send an execute request, returning a coroutine for the reply if `reply`, else the msg_id"
-        if not self._check_alive(): return asyncio.sleep(0) if reply else None
-        if user_expressions is None: user_expressions = {}
-        if allow_stdin is None: allow_stdin = self.allow_stdin
-        content = dict(user_expressions=user_expressions, allow_stdin=allow_stdin, subsh_id=subsh_id, stop_on_error=stop_on_error, **kw)
-        content[cts_typ] = code
-        msg = self.session.msg("execute_request", content)
-        if msg_id is not None: msg["header"]["msg_id"] = msg_id
-        if subsh_id is not None: msg["header"]["subshell_id"] = subsh_id
-        msg_id = msg["header"]["msg_id"]
-        if reply: self._pending[msg_id] = (asyncio.Queue(maxsize=1), stop_on_error if fail_pending is None else fail_pending)
-        try: self.shell_channel.send(msg)
-        except (AssertionError, OSError, ZMQError) as e: raise DeadKernelError(f"Kernel socket closed: {e}") from e
-        if not reply: return msg_id
-        return self._async_recv_reply(msg_id, timeout=timeout)
-
-    async def stdin_send(self, msg:dict):
-        "Send on `stdin_channel` then ping event loop"
-        try: self.stdin_channel.send(msg)
-        except (AssertionError, OSError, ZMQError) as e: raise DeadKernelError(f"Kernel socket closed: {e}") from e
-        await asyncio.sleep(0.01)
+        pumps = getattr(self, '_pumps', None)
+        if not pumps or any(t.done() for t in pumps): raise DeadKernelError('kernel died')
+
+# %% ../nbs/00_core.ipynb #fd6e6aa9
+@patch
+async def _route(self:ConKernelClient, msg):
+    r = self.route(msg)
+    if inspect.isawaitable(r): await r
+
+@patch
+async def _pump(self:ConKernelClient, name):
+    "Drain one zmq channel into the router; a socket error is transport loss, delivered as the dead status."
+    ch = getattr(self, f'{name}_channel')
+    try:
+        while True: await self._route(dict(await ch.get_msg(timeout=None), channel=name))
+    except asyncio.CancelledError: raise
+    except Exception as e:
+        _log.warning(f"{name} pump died: {e}")
+        await self._route(_dead_status())
+
+@patch
+async def _watch_hb(self:ConKernelClient):
+    "Declare death after three consecutive unanswered heartbeat echoes; the kernel echoes from a dedicated thread, so sustained silence means the process is gone."
+    misses = 0
+    while True:
+        await asyncio.sleep(self.hb_channel.time_to_dead)
+        misses = 0 if self.hb_channel.is_beating() else misses + 1
+        if misses >= 3: return await self._route(_dead_status())
+
+# %% ../nbs/00_core.ipynb #394db3b2
+@patch
+async def start_channels(self:ConKernelClient, shell:bool=True, iopub:bool=True, stdin:bool=True, hb:bool=True, control:bool=True):
+    "Start channels, wait for ready, then launch the router pumps and the heartbeat watcher"
+    super(ConKernelClient, self).start_channels(shell=shell, iopub=iopub, stdin=stdin, hb=hb, control=control)
+    await self.wait_for_ready()
+    self._init_router()
+    chans = [c for c, on in (('shell',shell), ('iopub',iopub), ('stdin',stdin), ('control',control)) if on]
+    self._pumps = [asyncio.create_task(self._pump(c)) for c in chans]
+    if hb: self._pumps.append(asyncio.create_task(self._watch_hb()))
+    return self
+
+@patch
+def stop_channels(self:ConKernelClient):
+    "Stop channels and cancel the router pumps"
+    if getattr(self, '_pumps', None): self.fail_waiters(RuntimeError("Channels stopped before reply"))
+    super(ConKernelClient, self).stop_channels()
+    for t in getattr(self, '_pumps', []): t.cancel()
+    self._pumps = []
+
+# %% ../nbs/00_core.ipynb #a930c688
+@patch
+def send(self:ConKernelClient, msg, channel):
+    "Transmit a built message dict on `channel` (buffers ride as extra frames); a closed socket raises `DeadKernelError`."
+    ch = getattr(self, f'{channel}_channel')
+    try:
+        if msg.get('buffers'): self.session.send(ch.socket, msg, buffers=msg['buffers'])
+        else: ch.send(msg)
+    except (AssertionError, OSError, ZMQError) as e: raise DeadKernelError(f"Kernel socket closed: {e}") from e
+
+@patch
+def execute(self:ConKernelClient, code, silent=False, store_history=True, user_expressions=None, allow_stdin=None, stop_on_error=True,
+    msg_id=None, metadata=None, subshell_id=None, buffers=None):
+    "Send an `execute_request`, fire-and-forget; returns its msg_id"
+    self._check_alive()
+    if user_expressions is None: user_expressions = {}
+    if allow_stdin is None: allow_stdin = self.allow_stdin
+    msg = self.session.msg("execute_request", dict(code=code, silent=silent, store_history=store_history,
+        user_expressions=user_expressions, allow_stdin=allow_stdin, stop_on_error=stop_on_error), metadata=metadata)
+    if buffers: msg["buffers"] = buffers
+    if msg_id is not None: msg["header"]["msg_id"] = msg_id
+    if subshell_id is not None: msg["header"]["subshell_id"] = subshell_id
+    self.send(msg, 'shell')
+    return msg["header"]["msg_id"]
 
 # %% ../nbs/00_core.ipynb #3771c654
 @patch
@@ -174,17 +172,20 @@ async def wait_for_ready(self:ConKernelClient, timeout=None):
 # %% ../nbs/00_core.ipynb #967c10a1
 @patch
 async def astop_channels(self:ConKernelClient):
-    "Stop channels and cancel the background shell-reply reader, awaiting its exit"
-    self._fail_pending(RuntimeError("Shell channels stopped before reply"))
-    if (tk := getattr(self, '_shell_reader_task', None)):
-        tk.cancel()
-        try: await tk
+    "Stop channels and cancel the router pumps, awaiting their exit"
+    if getattr(self, '_pumps', None): self.fail_waiters(RuntimeError("Channels stopped before reply"))
+    for t in getattr(self, '_pumps', []):
+        t.cancel()
+        try: await t
         except asyncio.CancelledError: pass
-        self._shell_reader_task = None
+    self._pumps = []
     super(ConKernelClient, self).stop_channels()
 
 # %% ../nbs/00_core.ipynb #b828c222
 class ConKernelManager(AsyncKernelManager):
     client_class,client_factory = ConKernelClient,Type(ConKernelClient)
+    def __init__(self, *args, kernel_spec=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if kernel_spec is not None: self._kernel_spec = kernel_spec
     @default('transport_encryption')
     def _transport_encryption_default(self): return 'auto'

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/conkernelclient/ops.py

@@ -5,20 +5,17 @@ Docs: https://AnswerDotAI.github.io/conkernelclient/ops.html.md"""
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_ops.ipynb.
 
 # %% auto #0
-__all__ = ['default_timeout', 'iter_timeout', 'iopub_streams', 'EvalError', 'parse_expr', 'run_kernel', 'reconnect', 'parent_id',
-           'iopub_msgs', 'output_types']
+__all__ = ['default_timeout', 'iter_timeout', 'iopub_streams', 'run_kernel', 'reconnect']
 
 # %% ../nbs/01_ops.ipynb #23936f1c
 from fastcore.utils import *
-from fastcore.ansi import strip_ansi
-from fastcore.nbio import msgs2outs, preferred_out
 from .core import ConKernelClient, ConKernelManager, DeadKernelError
-from jupywire.ops import parent_id, iopub_msgs, output_types
-_all_ = ['parent_id', 'iopub_msgs', 'output_types']
+from jupywire.ops import parent_id, iopub_msgs
+from jupyter_client.kernelspec import KernelSpec
 from contextlib import asynccontextmanager
-from ast import literal_eval
 from queue import Empty
-import asyncio, time
+import time
+
 
 # %% ../nbs/01_ops.ipynb #d62f6b51
 default_timeout = 10
@@ -30,11 +27,19 @@ def iter_timeout(timeout=None, default=default_timeout):
 
 # %% ../nbs/01_ops.ipynb #ad596b2b
 @patch
+async def exec_drain(self:ConKernelClient, code, timeout=default_timeout, **kw):
+    "Execute `code`; return `(reply, outputs)` where outputs are the request's iopub messages"
+    msgs = await self.run(code, timeout=timeout, **kw)
+    reply = next(m for m in msgs if m['msg_type'] == 'execute_reply')
+    return reply, [m for m in msgs if m['channel'] == 'iopub']
+
+# %% ../nbs/01_ops.ipynb #113e926f
+@patch
 async def iopub_drain(self:ConKernelClient, msg_id, timeout=default_timeout):
-    "Collect iopub messages parented to `msg_id` until its idle status arrives. Other requests' messages are discarded: one drain at a time"
+    "Collect unmatched iopub messages parented to `msg_id` from the attached `JmsgQueues` until its idle status arrives. Other requests' messages are discarded: one drain at a time"
     res = []
     for rem in iter_timeout(timeout):
-        try: msg = await self.get_iopub_msg(timeout=rem)
+        try: msg = await self.jmsgq.get('iopub', timeout=rem)
         except Empty: continue
         if parent_id(msg) != msg_id: continue
         res.append(msg)
@@ -44,9 +49,9 @@ async def iopub_drain(self:ConKernelClient, msg_id, timeout=default_timeout):
 # %% ../nbs/01_ops.ipynb #e705c283
 @patch
 async def iopub_flush(self:ConKernelClient, timeout=0.1):
-    "Discard all pending iopub messages, e.g. leftovers from fire-and-forget executes"
+    "Discard pending iopub messages from the attached `JmsgQueues`, e.g. leftovers from fire-and-forget executes"
     try:
-        while True: await self.get_iopub_msg(timeout=timeout)
+        while True: await self.jmsgq.get('iopub', timeout=timeout)
     except Empty: pass
 
 # %% ../nbs/01_ops.ipynb #ebdbd6eb
@@ -56,12 +61,6 @@ def iopub_streams(msgs, name=None):
     return streams if name is None else [m for m in streams if m['content'].get('name') == name]
 
 # %% ../nbs/01_ops.ipynb #52e7c8f1
-@patch
-async def exec_drain(self:ConKernelClient, code, timeout=default_timeout, **kw):
-    "Execute `code`; return `(reply, outputs)` where outputs are the request's iopub messages"
-    reply = await self.execute(code, reply=True, timeout=timeout, **kw)
-    return reply, await self.iopub_drain(parent_id(reply), timeout=timeout)
-
 @patch
 async def exec_ok(self:ConKernelClient, code, timeout=default_timeout, **kw):
     "`exec_drain`, asserting the reply status is ok"
@@ -69,49 +68,7 @@ async def exec_ok(self:ConKernelClient, code, timeout=default_timeout, **kw):
     assert reply['content']['status'] == 'ok', reply['content']
     return reply, outputs
 
-@patch
-async def exec_outs(self:ConKernelClient, code, timeout=default_timeout, **kw):
-    "Execute `code` and return just its nbformat-style outputs"
-    reply, outputs = await self.exec_drain(code, timeout=timeout, **kw)
-    return msgs2outs(outputs)
-
-# %% ../nbs/01_ops.ipynb #77ab9da4
-class EvalError(Exception):
-    "An `eval_expr` expression raised in the kernel"
-
-def parse_expr(s):
-    "The `literal_eval` of `s` when its form allows, else `s` unchanged"
-    try: return literal_eval(s)
-    except Exception: return s
-
-@patch
-async def user_exprs(self:ConKernelClient, exprs:dict, code:str='', timeout=default_timeout, **kw):
-    "Run `code` and evaluate each of the `exprs` expressions in the same round trip; returns the reply content (statuses and mimebundles unparsed)"
-    return (await self.execute(code, reply=True, timeout=timeout, user_expressions=exprs, store_history=False, **kw))['content']
-
-@patch
-async def eval_expr(self:ConKernelClient, expr:str, code:str='', timeout=default_timeout, **kw):
-    "Evaluate `expr` in the kernel (optionally after running `code`) and return its value: parsed via `literal_eval` when its repr allows, else the repr string. Raises `EvalError` if the kernel raises"
-    cts = await self.user_exprs({'_': expr}, code, timeout=timeout, **kw)
-    if cts['status'] != 'ok': raise EvalError(f"{cts.get('ename')}: {cts.get('evalue')}")
-    r = cts['user_expressions']['_']
-    if r.get('status') != 'ok': raise EvalError(f"{r.get('ename')}: {r.get('evalue')}")
-    return parse_expr(r['data']['text/plain'])
-
-# %% ../nbs/01_ops.ipynb #d9bbaa8d
-@patch
-def reply(self:ConKernelClient,
-    code, # A string of code in the kernel's language.
-    user_expressions:NoneType=None, # A dict mapping names to expressions to be evaluated in the user's dict
-    allow_stdin:NoneType=None, # Flag for whether the kernel can send stdin requests to frontends.
-    cts_typ:str='code', timeout:int=None, msg_id:NoneType=None, **kw
-):
-    return self.execute(code, user_expressions=user_expressions, allow_stdin=allow_stdin, reply=True,
-        cts_typ=cts_typ, timeout=timeout or getattr(self, 'default_timeout', default_timeout), msg_id=msg_id, **kw)
-
 # %% ../nbs/01_ops.ipynb #5de02acb
-from jupywire.ops import EvalOps, EvalException, try_eval
-
 @patch
 def _pre_ipy(self:ConKernelClient):
     if not self.shell_channel.is_alive(): raise DeadKernelError()
@@ -119,40 +76,21 @@ def _pre_ipy(self:ConKernelClient):
 
 # %% ../nbs/01_ops.ipynb #aafc1ab4
 @patch
-def shell_request(
-    self:ConKernelClient, msg_type, timeout=default_timeout, reply=True, buffers=None,
-    msg_id=None, # Override the auto-generated message id
-    subshell_id=None, # Route via this subshell (header field)
-    metadata=None, # Message metadata (e.g. ipywidgets control-comm version check)
-    **content
-):
-    "Send an arbitrary shell request, routed through the reply reader like `execute`. Returns a coroutine for the reply, or just the msg_id when `reply=False` (for fire-and-forget types like `comm_open` that never get replies)"
-    if not self._check_alive(): return asyncio.sleep(0) if reply else None
-    msg = self.session.msg(msg_type, content, metadata=metadata)
-    if msg_id is not None: msg['header']['msg_id'] = msg_id
-    if subshell_id is not None: msg['header']['subshell_id'] = subshell_id
-    mid = msg['header']['msg_id']
-    if reply: self._pending[mid] = (asyncio.Queue(maxsize=1), False)
-    if buffers: self.session.send(self.shell_channel.socket, msg, buffers=buffers)
-    else: self.shell_channel.send(msg)
-    return self._async_recv_reply(mid, timeout=timeout) if reply else mid
+def shell_request(self:ConKernelClient, msg_type, timeout=default_timeout, msg_id=None, subshell_id=None, metadata=None, buffers=None, **content):
+    "A named shell request, content as keyword arguments; returns an awaitable of its reply"
+    return self.request(msg_type, content, timeout=timeout, msg_id=msg_id, subshell_id=subshell_id, metadata=metadata, buffers=buffers)
 
 @patch
-async def control_request(self:ConKernelClient, msg_type, timeout=default_timeout, **content):
-    "Send a request on the control channel and await its matching reply"
-    msg = self.session.msg(msg_type, content)
-    self.control_channel.send(msg)
-    for rem in iter_timeout(timeout):
-        try: reply = await self.get_control_msg(timeout=rem)
-        except Empty: continue
-        if parent_id(reply) == msg['header']['msg_id']: return reply
-    raise TimeoutError(f"no reply to {msg_type}")
+def control_request(self:ConKernelClient, msg_type, timeout=default_timeout, **content):
+    "A named control request, content as keyword arguments; returns an awaitable of its reply"
+    return self.request(msg_type, content, channel='control', timeout=timeout)
 
 # %% ../nbs/01_ops.ipynb #4f01d2b6
 @patch
 async def input_reply(self:ConKernelClient, value:str):
     "Answer the kernel's pending input_request (from `input()` in an execute sent with `allow_stdin=True`)"
-    await self.stdin_send(self.session.msg('input_reply', dict(value=value)))
+    self.input(value)
+
 
 # %% ../nbs/01_ops.ipynb #97d75b1e
 class _ReqProxy:
@@ -202,12 +140,15 @@ async def interrupt(self:ConKernelClient, timeout=5):
 # %% ../nbs/01_ops.ipynb #edaf42c9
 @asynccontextmanager
 async def run_kernel(
-    kernel_name='python3', # Kernelspec name to launch
+    kernel_name='python3', # Kernelspec name to launch, or display name when `argv` is given
+    argv=None, # Kernel argv; bypasses kernelspec discovery when provided
     manager_cls=ConKernelManager, # Manager class, e.g. a subclass customizing launch
     **kwargs # Passed to `start_kernel` (e.g. `env`, `cwd`)
 ):
-    "Start a kernel, yield `(km, kc)` with channels running, and always shut both down"
-    km = manager_cls(kernel_name=kernel_name)
+    "Start a named or direct-argv kernel, yielding `(km, kc)`, and always shut it down"
+    manager_kwargs = dict(kernel_name=kernel_name)
+    if argv is not None: manager_kwargs['kernel_spec'] = KernelSpec(argv=argv, display_name=kernel_name)
+    km = manager_cls(**manager_kwargs)
     await km.start_kernel(**kwargs)
     kc = await km.client().start_channels()
     try: yield km, kc

{conkernelclient-0.0.18 → conkernelclient-0.0.20/conkernelclient.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conkernelclient
-Version: 0.0.18
+Version: 0.0.20
 Summary: Concurrent-safe Jupyter KernelClient
 Author-email: Jeremy Howard <github@jhoward.fastmail.fm>
 License: Apache-2.0
@@ -14,7 +14,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: jupyter_client
 Requires-Dist: fastcore>=2.1.17
-Requires-Dist: jupywire>=0.1.4
+Requires-Dist: jupywire>=0.1.5
 Provides-Extra: dev
 Requires-Dist: ipykernel; extra == "dev"
 Requires-Dist: ipymini>=0.1.17; extra == "dev"

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/conkernelclient.egg-info/requires.txt

@@ -1,6 +1,6 @@
 jupyter_client
 fastcore>=2.1.17
-jupywire>=0.1.4
+jupywire>=0.1.5
 
 [dev]
 ipykernel

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/pyproject.toml

@@ -18,7 +18,7 @@ classifiers = [
 dependencies = [
   'jupyter_client',
   'fastcore>=2.1.17',
-  'jupywire>=0.1.4',
+  'jupywire>=0.1.5',
 ]
 
 [project.optional-dependencies]

{conkernelclient-0.0.18 → conkernelclient-0.0.20}/tests/test_races.py

@@ -37,12 +37,11 @@ class LockedClient(ConKernelClient):
 class LockedKernelManager(ConKernelManager):
     client_class,client_factory = LockedClient,Type(LockedClient)
 
-
 def test_burst_replies_under_send_jitter():
     "20 pending replies at once, every send jittered: the reader must route each reply to its waiter."
     async def _run():
-        async with run_kernel(kernel_name="ipymini", manager_cls=LockedKernelManager) as (km, kc):
-            reps = [kc.execute(f"x{i} = {i}; x{i}", reply=True, timeout=30) for i in range(20)]
+        async with run_kernel("ipymini", ["ipymini", "-f", "{connection_file}"], manager_cls=LockedKernelManager) as (km, kc):
+            reps = [kc.reply(f"x{i} = {i}; x{i}", timeout=30) for i in range(20)]
             for i, r in enumerate(await asyncio.gather(*reps)): assert r["content"]["status"] == "ok", (i, r["content"])
     asyncio.run(_run())
 

conkernelclient-0.0.18/conkernelclient/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.0.18"
-from .core import *
-from .ops import *