repld-tool 0.2.1__tar.gz → 0.2.2__tar.gz

{repld_tool-0.2.1 → repld_tool-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repld-tool
-Version: 0.2.1
+Version: 0.2.2
 Summary: Persistent Python runtime with MCP channel push. Dev shell and autonomous-agent substrate in one package.
 Keywords: repl,mcp,agent,browser
 Author: Fredrik Angelsen

{repld_tool-0.2.1 → repld_tool-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "repld-tool"
-version = "0.2.1"
+version = "0.2.2"
 description = "Persistent Python runtime with MCP channel push. Dev shell and autonomous-agent substrate in one package."
 readme = "README.md"
 authors = [

{repld_tool-0.2.1 → repld_tool-0.2.2}/src/repld/__init__.py

@@ -11,7 +11,9 @@ if TYPE_CHECKING:
     from typing import Any, Callable, Coroutine
 
     def notify(content: Any, **meta: Any) -> None: ...
-    def defer(coro: Coroutine, label: str | None = None) -> str: ...
+    def defer(
+        coro: Coroutine | Callable[[], Coroutine], label: str | None = None
+    ) -> str: ...
     def every(
         seconds: float, *, label: str | None = None, delay: float = 0.0
     ) -> Callable: ...

{repld_tool-0.2.1 → repld_tool-0.2.2}/src/repld/help.py

@@ -1113,6 +1113,9 @@ no_display(value) → value
 
 defer(coro, label=None) → task_id
   Fire-and-forget. Channel push on done. Visible to get_task/cancel.
+  coro can also be a zero-arg callable that builds the awaitable —
+  defer(lambda: asyncio.gather(a(), b())) — so gather()/create_task()
+  construct on the kernel's loop instead of a sync cell's own thread.
 
 every(seconds, label=, delay=0)(fn) → fn   periodic ticker; fn.cancel() stops
   delay= defers the first tick (default: tick now)
@@ -1466,6 +1469,14 @@ For intentionally long work, use defer():
 
   defer(download_all_invoices(), label="invoice sync")
 
+Fanning out with asyncio.gather()/create_task() inside defer() needs one
+more step: those reach for a running loop when *built*, not just when
+awaited, and a sync cell (no top-level await) runs in a worker thread with
+no loop of its own. Pass defer() a zero-arg callable instead of a
+pre-built awaitable, so the gather() call happens on the kernel's loop:
+
+  defer(lambda: asyncio.gather(one("a"), one("b"), return_exceptions=True))
+
 This returns the task_id immediately. The channel notification arrives
 when the coroutine completes (or fails).
 

{repld_tool-0.2.1 → repld_tool-0.2.2}/src/repld/kernel.py

@@ -487,14 +487,29 @@ async def _run_cell(task_id: str, src: str, n: int, *, wait_ready: bool = True)
             task["exception"] = type(exc).__name__
 
 
-async def _run_deferred(task_id: str, coro) -> None:
-    """Await a user-supplied coroutine within the task lifecycle.
-
-    Like _run_cell but skips compile/eval — just awaits the coroutine directly.
+async def _run_deferred(task_id: str, thunk) -> None:
+    """Build and await a user-supplied awaitable within the task lifecycle.
+
+    `thunk` is always a zero-arg callable — defer() wraps a coroutine object
+    passed directly as ``lambda: coro``, so this only has one code path.
+    Calling it here, inside a coroutine already scheduled on the kernel's
+    loop (`asyncio.run_coroutine_threadsafe`), is what lets a factory like
+    ``lambda: asyncio.gather(...)`` build its awaitable with a loop actually
+    running: `asyncio.gather()`/`create_task()`/`ensure_future()` all reach
+    for the *current thread's* loop at construction time, not just to await,
+    and a sync cell's body runs off-loop (`asyncio.to_thread`) to keep the
+    kernel responsive — so building one directly in the cell raises "no
+    current event loop" before defer() ever gets a look at it.
     """
     async with _task_scope(task_id) as task:
         try:
-            await coro
+            awaitable = thunk()
+            if not inspect.isawaitable(awaitable):
+                raise TypeError(
+                    "defer() factory must return an awaitable, got "
+                    f"{type(awaitable).__name__}"
+                )
+            await awaitable
         except asyncio.CancelledError:
             task["exception"] = "CancelledError"
         except BaseException as exc:
@@ -508,13 +523,32 @@ def _make_defer(loop: asyncio.AbstractEventLoop):
     def defer(coro, label: str | None = None) -> str:
         """Schedule a coroutine as a tracked task. Returns task_id immediately.
 
+        `coro` is normally a coroutine object (`defer(my_async_fn())`). It
+        may also be a zero-arg callable that *builds* one —
+        `defer(lambda: asyncio.gather(one(), two()))` — for constructs that
+        need a running loop to construct, not just to await. A sync cell's
+        body runs in a worker thread with no event loop set, so calling
+        `asyncio.gather(...)` there eagerly (as a `defer()` argument) fails
+        before `defer()` is even entered; wrapping it in a zero-arg callable
+        defers the call itself onto the kernel's loop, where it belongs.
+
         The task is visible to get_task and cancel. On completion, a task_done
         channel notification is pushed.
         """
-        if not inspect.iscoroutine(coro):
+        if inspect.iscoroutine(coro):
+            thunk = lambda c=coro: c  # noqa: E731
+        elif inspect.iscoroutinefunction(coro):
+            raise TypeError(
+                f"defer() expects a coroutine object, got the function "
+                f"{coro.__name__!r} itself. Call it as: defer({coro.__name__}())"
+            )
+        elif callable(coro):
+            thunk = coro
+        else:
             raise TypeError(
-                f"defer() expects a coroutine object, got {type(coro).__name__}. "
-                "Call it as: defer(my_async_fn())"
+                "defer() expects a coroutine object (or a zero-arg callable "
+                f"that builds one), got {type(coro).__name__}. Call it as: "
+                "defer(my_async_fn()) or defer(lambda: asyncio.gather(...))"
             )
         # Inherit the calling cell's originating session so a background task
         # reports back to whoever asked for it. defer() from an @every body or
@@ -527,7 +561,7 @@ def _make_defer(loop: asyncio.AbstractEventLoop):
             task["label"] = label
         src_label = label or "..."
         events.emit(CellStart(task_id, f"defer({src_label})", time.time()))
-        asyncio.run_coroutine_threadsafe(_run_deferred(task_id, coro), loop)
+        asyncio.run_coroutine_threadsafe(_run_deferred(task_id, thunk), loop)
         return task_id
 
     return defer

{repld_tool-0.2.1 → repld_tool-0.2.2}/src/repld/runtime.py

@@ -221,8 +221,16 @@ def _format_user_traceback(exc: BaseException) -> str:
             )
         elif "no current event loop" in msg or "no running event loop" in msg:
             formatted += (
-                "\nHint: this cell ran in a background thread "
-                "(no 'await' detected). Use defer() to schedule async work:\n"
-                "  defer(some_coroutine())\n"
+                "\nHint: this cell ran in a background thread (no top-level "
+                "'await' in the cell), so asyncio.gather()/create_task()/"
+                "ensure_future() had no loop to attach to — they reach for "
+                "one at construction, not just to await it. Build it inside "
+                "an async def instead:\n"
+                "  async def _run():\n"
+                "      return await asyncio.gather(a(), b())\n"
+                "  await _run()\n"
+                "or, if deferring it, pass defer() a zero-arg callable so it "
+                "builds on the kernel's loop rather than in this thread:\n"
+                "  defer(lambda: asyncio.gather(a(), b()))\n"
             )
     return formatted