concurrent-c-node 0.22.1__tar.gz → 0.23.0__tar.gz

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.22.1
+Version: 0.23.0
 Summary: JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime.
 License: MIT
 Project-URL: Repository, https://github.com/sreekotay/concurrent-c
@@ -62,8 +62,9 @@ measurable wire. N domains = N processes.
   in the child. No `{ async: true }`.
 - Scalars / `None` materialize; empty `{}` stays a handle; everything
   else is a `JsHandle` until `str()` / attrs / a call.
-- `%load_ext cc_node` then `%%js` — one kernel domain
-  (`cc_node.kernel()`), not a child per cell.
+- `import cc_node` then `%%js` or `cc_node.get()` — one session, not a
+  child per cell. `%load_ext` still works (idempotent).
+- `cc_node.require('path')` is `get().require('path')`.
 - `eval()` is one RTT, no extra globals. `%%js` / `eval_cell` install
   cwd `require` once.
 - `--bind` is `Object.assign(globalThis, …)` of names you name (wire
@@ -84,36 +85,45 @@ python -m cc_node.benchmarks.vs_alts          # vs DIY node / pythonmonkey / min
 
 Colab and the usual Jupyter kernel are **Python** — this package. Same
 calling convention as a script: a cell blocks until Node answers;
-thenables wait in the child. Magics share **one** domain for the
-kernel, not a spawn per cell (~28ms).
+thenables wait in the child. Magics and `get()` share **one** session
+for the kernel, not a spawn per cell (~28ms). Child `console.log`
+lands in the cell (inherited stdio, line-buffered).
 
 ```python
 %pip install concurrent-c-node
 # if `node` is missing (typical Colab):
 !apt-get install -y nodejs
-%load_ext cc_node
 
+import cc_node                 # magics register; no %load_ext
+path = cc_node.require('path')
+path.join('a', 'b')            # 'a/b'
+```
+
+```python
 %%js
-const path = require('path')
-path.join('a', 'b')          // last expression comes back as Python
+console.log('hi')              # shows in the cell
+require('path').join('a', 'b') # last expression comes back as Python
 ```
 
 ```python
 xs = [1, 2, 3, 4]
 
 %%js -b xs -t chunks
-xs.map(x => x * 2)           // wire types only; no pickle fallback
+xs.map(x => x * 2)             # wire types only; no pickle fallback
 ```
 
 | | |
 |---|---|
-| `%load_ext cc_node` | register magics; does **not** spawn until first `%%js` |
-| `%js 1+1` / `%%js` | eval on `cc_node.kernel()`; last expression is the result |
+| `import cc_node` | registers magics; does **not** spawn until first `%%js` / `get()` / `require()` |
+| `%load_ext cc_node` | same, idempotent |
+| `%js 1+1` / `%%js` | eval on `cc_node.get()`; last expression is the result |
 | `-b xs` / `--bind xs,n` | publish those Python names on `globalThis` for the cell |
 | `-t chunks` / `--to` | store the result in the notebook namespace |
 | `%js_stats` | handle-table size (spawns if needed) |
-| `%js_reset` | `destroy()` the kernel child; next `%%js` spawns again |
-| `cc_node.kernel()` | the same domain the magics use; `create()` is still a private child |
+| `%js_reset` / `cc_node.reset()` | `destroy()` the session child; `%reset` does this too |
+| `cc_node.get()` | the session the magics use; `create()` is still a private child |
+| `cc_node.kernel()` | alias of `get()` |
+| `cc_node.require('fs')` | `get().require('fs')` |
 | `JsHandle` display | cheap `JsHandle #3` — repr does not cross the wire |
 
 `eval()` is unchanged (one RTT, no extra globals). `%%js` / `eval_cell`
@@ -184,6 +194,7 @@ vs pymport / ncp / pythonia.
   `destroy()`; afterwards: `bridge is closed`.
 - `eval_cell(src, bindings=)` is the notebook door (`%%js`): cwd
   `require` once, optional `globalThis` binds; `eval()` stays one RTT.
+  `get()` / `require()` / `eval()` at module level share that session.
 - Crash isolation, not a sandbox. `destroy()` is cooperative; an
   in-flight CPU-bound call finishes or you kill the child
   ([`bridge_stress.md`](https://github.com/sreekotay/concurrent-c/blob/main/stress/bridge/bridge_stress.md)).
@@ -282,7 +293,7 @@ Both bridges (npm OIDC + PyPI OIDC):
 
 Examples: `use_node`, `bench_wire`, `benchmarks.multi_domain`,
 `benchmarks.vs_alts`.
-Jupyter: `%load_ext cc_node`.
+Jupyter: `import cc_node` then `%%js` (or `%load_ext cc_node`).
 Stress: [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge).  
 Own hot path in C/CC → native module (40–90ns) —
 [JS / Python interop](https://github.com/sreekotay/concurrent-c/blob/main/docs/js-py-modules.md).

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/README.md

@@ -47,8 +47,9 @@ measurable wire. N domains = N processes.
   in the child. No `{ async: true }`.
 - Scalars / `None` materialize; empty `{}` stays a handle; everything
   else is a `JsHandle` until `str()` / attrs / a call.
-- `%load_ext cc_node` then `%%js` — one kernel domain
-  (`cc_node.kernel()`), not a child per cell.
+- `import cc_node` then `%%js` or `cc_node.get()` — one session, not a
+  child per cell. `%load_ext` still works (idempotent).
+- `cc_node.require('path')` is `get().require('path')`.
 - `eval()` is one RTT, no extra globals. `%%js` / `eval_cell` install
   cwd `require` once.
 - `--bind` is `Object.assign(globalThis, …)` of names you name (wire
@@ -69,36 +70,45 @@ python -m cc_node.benchmarks.vs_alts          # vs DIY node / pythonmonkey / min
 
 Colab and the usual Jupyter kernel are **Python** — this package. Same
 calling convention as a script: a cell blocks until Node answers;
-thenables wait in the child. Magics share **one** domain for the
-kernel, not a spawn per cell (~28ms).
+thenables wait in the child. Magics and `get()` share **one** session
+for the kernel, not a spawn per cell (~28ms). Child `console.log`
+lands in the cell (inherited stdio, line-buffered).
 
 ```python
 %pip install concurrent-c-node
 # if `node` is missing (typical Colab):
 !apt-get install -y nodejs
-%load_ext cc_node
 
+import cc_node                 # magics register; no %load_ext
+path = cc_node.require('path')
+path.join('a', 'b')            # 'a/b'
+```
+
+```python
 %%js
-const path = require('path')
-path.join('a', 'b')          // last expression comes back as Python
+console.log('hi')              # shows in the cell
+require('path').join('a', 'b') # last expression comes back as Python
 ```
 
 ```python
 xs = [1, 2, 3, 4]
 
 %%js -b xs -t chunks
-xs.map(x => x * 2)           // wire types only; no pickle fallback
+xs.map(x => x * 2)             # wire types only; no pickle fallback
 ```
 
 | | |
 |---|---|
-| `%load_ext cc_node` | register magics; does **not** spawn until first `%%js` |
-| `%js 1+1` / `%%js` | eval on `cc_node.kernel()`; last expression is the result |
+| `import cc_node` | registers magics; does **not** spawn until first `%%js` / `get()` / `require()` |
+| `%load_ext cc_node` | same, idempotent |
+| `%js 1+1` / `%%js` | eval on `cc_node.get()`; last expression is the result |
 | `-b xs` / `--bind xs,n` | publish those Python names on `globalThis` for the cell |
 | `-t chunks` / `--to` | store the result in the notebook namespace |
 | `%js_stats` | handle-table size (spawns if needed) |
-| `%js_reset` | `destroy()` the kernel child; next `%%js` spawns again |
-| `cc_node.kernel()` | the same domain the magics use; `create()` is still a private child |
+| `%js_reset` / `cc_node.reset()` | `destroy()` the session child; `%reset` does this too |
+| `cc_node.get()` | the session the magics use; `create()` is still a private child |
+| `cc_node.kernel()` | alias of `get()` |
+| `cc_node.require('fs')` | `get().require('fs')` |
 | `JsHandle` display | cheap `JsHandle #3` — repr does not cross the wire |
 
 `eval()` is unchanged (one RTT, no extra globals). `%%js` / `eval_cell`
@@ -169,6 +179,7 @@ vs pymport / ncp / pythonia.
   `destroy()`; afterwards: `bridge is closed`.
 - `eval_cell(src, bindings=)` is the notebook door (`%%js`): cwd
   `require` once, optional `globalThis` binds; `eval()` stays one RTT.
+  `get()` / `require()` / `eval()` at module level share that session.
 - Crash isolation, not a sandbox. `destroy()` is cooperative; an
   in-flight CPU-bound call finishes or you kill the child
   ([`bridge_stress.md`](https://github.com/sreekotay/concurrent-c/blob/main/stress/bridge/bridge_stress.md)).
@@ -267,7 +278,7 @@ Both bridges (npm OIDC + PyPI OIDC):
 
 Examples: `use_node`, `bench_wire`, `benchmarks.multi_domain`,
 `benchmarks.vs_alts`.
-Jupyter: `%load_ext cc_node`.
+Jupyter: `import cc_node` then `%%js` (or `%load_ext cc_node`).
 Stress: [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge).  
 Own hot path in C/CC → native module (40–90ns) —
 [JS / Python interop](https://github.com/sreekotay/concurrent-c/blob/main/docs/js-py-modules.md).

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/cc_node/__init__.py

@@ -19,8 +19,8 @@ Handles never cross domains; every door after destroy() answers
 articulately; destroy is idempotent and `with cc_node.create() as js:`
 scopes it.
 
-Notebooks (Jupyter / Colab): `%load_ext cc_node` then `%%js` — one
-kernel-scoped domain (`cc_node.kernel()`), same calling convention.
+Notebooks (Jupyter / Colab): `import cc_node` then `%%js` or
+`cc_node.get()` — one session domain, same calling convention.
 """
 import array
 import atexit
@@ -36,10 +36,12 @@ import sys
 import tempfile
 
 __all__ = [
-    "create", "kernel", "reset_kernel", "JsError", "JsHandle",
+    "create", "get", "reset", "kernel", "reset_kernel",
+    "require", "eval", "eval_cell", "import_module", "stats",
+    "JsError", "JsHandle",
     "load_ipython_extension", "unload_ipython_extension", "__version__",
 ]
-__version__ = "0.22.1"
+__version__ = "0.23.0"
 
 _NO_NODE = (
     "cc-node: no node executable (install Node, or set CC_NODE_BIN). "
@@ -161,12 +163,14 @@ class Bridge:
         # numbers in the child, so the broker learns them from the env.
         req_r, req_w = os.pipe()
         resp_r, resp_w = os.pipe()
+        preload = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                               "stdio_line.cjs")
         env = dict(os.environ,
                    CC_WIRE_IN=str(req_r), CC_WIRE_OUT=str(resp_w),
                    CC_NODE_SHM_DIR=self._shm_dir)
         try:
             self._p = subprocess.Popen(
-                [node, broker],
+                [node, "-r", preload, broker],
                 pass_fds=(req_r, resp_w),
                 env=env,
                 cwd=os.getcwd(),
@@ -645,19 +649,19 @@ def create(node=None):
     return Bridge(node=node)
 
 
-_kernel = None
+_session = None
 
 
-def kernel(node=None):
-    """Process-wide domain for notebooks. Lazy; magics share it.
-    Scripts that want a private child still call `create()`."""
-    global _kernel
-    b = _kernel
+def get(node=None):
+    """Session domain: one child for this process (the Jupyter kernel).
+    Lazy. Magics share it. `create()` is still a private child."""
+    global _session
+    b = _session
     if b is not None and not b.closed:
         if node is not None and node != b._node_bin:
             raise JsError(
-                "cc-node: kernel() already live with a different node; "
-                "reset_kernel() / %js_reset first")
+                "cc-node: get() already live with a different node; "
+                "reset() / %js_reset first")
         return b
     b = create(node=node)
     try:
@@ -665,15 +669,15 @@ def kernel(node=None):
     except Exception:
         b.destroy()
         raise
-    _kernel = b
+    _session = b
     return b
 
 
-def reset_kernel():
-    """Destroy the kernel-scoped domain. Next `kernel()` / `%%js` spawns."""
-    global _kernel
-    b = _kernel
-    _kernel = None
+def reset():
+    """Destroy the session domain. Next get() / %%js spawns."""
+    global _session
+    b = _session
+    _session = None
     if b is not None:
         try:
             b.destroy()
@@ -681,10 +685,61 @@ def reset_kernel():
             pass
 
 
+kernel = get
+reset_kernel = reset
+
+
+def require(name):
+    return get().require(name)
+
+
+def eval(src):  # noqa: A001 — session eval, pythonia-shaped
+    return get().eval(src)
+
+
+def eval_cell(src, bindings=None):
+    return get().eval_cell(src, bindings)
+
+
+def import_module(name):
+    return get().import_module(name)
+
+
+def stats():
+    return get().stats()
+
+
 def load_ipython_extension(ip):
     from .magics import load_ipython_extension as _load
     _load(ip)
+    if getattr(ip, "_cc_node_lifecycle", False):
+        return
+    ip._cc_node_lifecycle = True
+    orig = getattr(ip, "reset", None)
+    if orig is not None:
+        def _reset(*args, **kwargs):
+            reset()
+            return orig(*args, **kwargs)
+        ip.reset = _reset
 
 
 def unload_ipython_extension(ip):
-    reset_kernel()
+    reset()
+
+
+def _boot_ipython():
+    # Already in a kernel: IPython is in sys.modules. Do not import it
+    # just because the extra is installed — scripts stay spawn-free.
+    if "IPython" not in sys.modules:
+        return
+    try:
+        from IPython import get_ipython
+    except ImportError:
+        return
+    ip = get_ipython()
+    if ip is None:
+        return
+    load_ipython_extension(ip)
+
+
+_boot_ipython()

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/cc_node/magics.py

@@ -2,7 +2,7 @@
 from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class
 from IPython.core.magic_arguments import argument, magic_arguments, parse_argstring
 
-from . import JsError, kernel, reset_kernel
+from . import JsError, get, reset
 
 
 def _bind_map(names, ns):
@@ -30,7 +30,7 @@ class CcNodeMagics(Magics):
     @argument("code", nargs="*", help="JS source (line magic)")
     @line_cell_magic
     def js(self, line, cell=None):
-        """Eval JavaScript on the kernel-scoped domain.
+        """Eval JavaScript on the session domain (`cc_node.get()`).
 
         Line:  %js 1 + 1
         Cell:  %%js   then a body; last expression is the result.
@@ -45,20 +45,20 @@ class CcNodeMagics(Magics):
             raise JsError("cc-node: empty %js / %%js")
         ns = self.shell.user_ns
         bindings = _bind_map(args.bind, ns)
-        result = kernel().eval_cell(src, bindings or None)
+        result = get().eval_cell(src, bindings or None)
         if args.to:
             ns[args.to] = result
         return result
 
     @line_magic
     def js_reset(self, line):
-        """Destroy the kernel-scoped Node child. Next %%js spawns again."""
-        reset_kernel()
+        """Destroy the session Node child. Next %%js / get() spawns again."""
+        reset()
 
     @line_magic
     def js_stats(self, line):
-        """Handle-table size of the kernel domain (spawns if needed)."""
-        return kernel().stats()
+        """Handle-table size of the session domain (spawns if needed)."""
+        return get().stats()
 
 
 def load_ipython_extension(ip):

concurrent_c_node-0.23.0/cc_node/stdio_line.cjs

@@ -0,0 +1,13 @@
+'use strict';
+/* Long-lived child: inherited stdout is often a pipe (Jupyter, nohup).
+ * Node then block-buffers console.log until the buffer fills or exit.
+ * Blocking writes make print land in the cell as it happens. TTY is
+ * already blocking — this is a no-op there. */
+function block(s) {
+  try {
+    if (s && s._handle && typeof s._handle.setBlocking === 'function')
+      s._handle.setBlocking(true);
+  } catch (e) { /* ignore */ }
+}
+block(process.stdout);
+block(process.stderr);

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/concurrent_c_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.22.1
+Version: 0.23.0
 Summary: JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime.
 License: MIT
 Project-URL: Repository, https://github.com/sreekotay/concurrent-c
@@ -62,8 +62,9 @@ measurable wire. N domains = N processes.
   in the child. No `{ async: true }`.
 - Scalars / `None` materialize; empty `{}` stays a handle; everything
   else is a `JsHandle` until `str()` / attrs / a call.
-- `%load_ext cc_node` then `%%js` — one kernel domain
-  (`cc_node.kernel()`), not a child per cell.
+- `import cc_node` then `%%js` or `cc_node.get()` — one session, not a
+  child per cell. `%load_ext` still works (idempotent).
+- `cc_node.require('path')` is `get().require('path')`.
 - `eval()` is one RTT, no extra globals. `%%js` / `eval_cell` install
   cwd `require` once.
 - `--bind` is `Object.assign(globalThis, …)` of names you name (wire
@@ -84,36 +85,45 @@ python -m cc_node.benchmarks.vs_alts          # vs DIY node / pythonmonkey / min
 
 Colab and the usual Jupyter kernel are **Python** — this package. Same
 calling convention as a script: a cell blocks until Node answers;
-thenables wait in the child. Magics share **one** domain for the
-kernel, not a spawn per cell (~28ms).
+thenables wait in the child. Magics and `get()` share **one** session
+for the kernel, not a spawn per cell (~28ms). Child `console.log`
+lands in the cell (inherited stdio, line-buffered).
 
 ```python
 %pip install concurrent-c-node
 # if `node` is missing (typical Colab):
 !apt-get install -y nodejs
-%load_ext cc_node
 
+import cc_node                 # magics register; no %load_ext
+path = cc_node.require('path')
+path.join('a', 'b')            # 'a/b'
+```
+
+```python
 %%js
-const path = require('path')
-path.join('a', 'b')          // last expression comes back as Python
+console.log('hi')              # shows in the cell
+require('path').join('a', 'b') # last expression comes back as Python
 ```
 
 ```python
 xs = [1, 2, 3, 4]
 
 %%js -b xs -t chunks
-xs.map(x => x * 2)           // wire types only; no pickle fallback
+xs.map(x => x * 2)             # wire types only; no pickle fallback
 ```
 
 | | |
 |---|---|
-| `%load_ext cc_node` | register magics; does **not** spawn until first `%%js` |
-| `%js 1+1` / `%%js` | eval on `cc_node.kernel()`; last expression is the result |
+| `import cc_node` | registers magics; does **not** spawn until first `%%js` / `get()` / `require()` |
+| `%load_ext cc_node` | same, idempotent |
+| `%js 1+1` / `%%js` | eval on `cc_node.get()`; last expression is the result |
 | `-b xs` / `--bind xs,n` | publish those Python names on `globalThis` for the cell |
 | `-t chunks` / `--to` | store the result in the notebook namespace |
 | `%js_stats` | handle-table size (spawns if needed) |
-| `%js_reset` | `destroy()` the kernel child; next `%%js` spawns again |
-| `cc_node.kernel()` | the same domain the magics use; `create()` is still a private child |
+| `%js_reset` / `cc_node.reset()` | `destroy()` the session child; `%reset` does this too |
+| `cc_node.get()` | the session the magics use; `create()` is still a private child |
+| `cc_node.kernel()` | alias of `get()` |
+| `cc_node.require('fs')` | `get().require('fs')` |
 | `JsHandle` display | cheap `JsHandle #3` — repr does not cross the wire |
 
 `eval()` is unchanged (one RTT, no extra globals). `%%js` / `eval_cell`
@@ -184,6 +194,7 @@ vs pymport / ncp / pythonia.
   `destroy()`; afterwards: `bridge is closed`.
 - `eval_cell(src, bindings=)` is the notebook door (`%%js`): cwd
   `require` once, optional `globalThis` binds; `eval()` stays one RTT.
+  `get()` / `require()` / `eval()` at module level share that session.
 - Crash isolation, not a sandbox. `destroy()` is cooperative; an
   in-flight CPU-bound call finishes or you kill the child
   ([`bridge_stress.md`](https://github.com/sreekotay/concurrent-c/blob/main/stress/bridge/bridge_stress.md)).
@@ -282,7 +293,7 @@ Both bridges (npm OIDC + PyPI OIDC):
 
 Examples: `use_node`, `bench_wire`, `benchmarks.multi_domain`,
 `benchmarks.vs_alts`.
-Jupyter: `%load_ext cc_node`.
+Jupyter: `import cc_node` then `%%js` (or `%load_ext cc_node`).
 Stress: [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge).  
 Own hot path in C/CC → native module (40–90ns) —
 [JS / Python interop](https://github.com/sreekotay/concurrent-c/blob/main/docs/js-py-modules.md).

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/concurrent_c_node.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 cc_node/__init__.py
 cc_node/broker.cjs
 cc_node/magics.py
+cc_node/stdio_line.cjs
 cc_node/benchmarks/__init__.py
 cc_node/benchmarks/multi_domain.py
 cc_node/benchmarks/vs_alts.py

{concurrent_c_node-0.22.1 → concurrent_c_node-0.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "concurrent-c-node"
-version = "0.22.1"
+version = "0.23.0"
 description = "JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -26,6 +26,6 @@ Documentation = "https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-nod
 packages = ["cc_node", "cc_node.examples", "cc_node.benchmarks"]
 
 [tool.setuptools.package-data]
-cc_node = ["broker.cjs"]
+cc_node = ["broker.cjs", "stdio_line.cjs"]
 "cc_node.examples" = ["*.py"]
 "cc_node.benchmarks" = ["*.py"]