concurrent-c-node 0.2.0__tar.gz → 0.3.0__tar.gz

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.2.0
+Version: 0.3.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
@@ -40,9 +40,11 @@ array in **9ms** where the same values as a JSON list take 583ms.
 
 ```
 pip install concurrent-c-node   # needs node on PATH (or point at one)
+python -m cc_node.examples.use_node
+python -m cc_node.examples.bench_wire
 ```
 
-Import stays `import cc_node`. The mirror of
+Import stays `import cc_node`. Examples ship in the wheel. The mirror of
 [`concurrent-c-python`](https://github.com/sreekotay/concurrent-c/tree/main/npm/cc-python)
 — same domain model, same materialization rules, pointed the other way:
 
@@ -117,11 +119,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
-From [`examples/bench_wire.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/bench_wire.py)
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+From `python -m cc_node.examples.bench_wire` (sources under
+[`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -138,7 +151,12 @@ future work.
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-[`examples/use_node.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/use_node.py).
+`python -m cc_node.examples.use_node`.
+
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
 
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/README.md

@@ -29,9 +29,11 @@ array in **9ms** where the same values as a JSON list take 583ms.
 
 ```
 pip install concurrent-c-node   # needs node on PATH (or point at one)
+python -m cc_node.examples.use_node
+python -m cc_node.examples.bench_wire
 ```
 
-Import stays `import cc_node`. The mirror of
+Import stays `import cc_node`. Examples ship in the wheel. The mirror of
 [`concurrent-c-python`](https://github.com/sreekotay/concurrent-c/tree/main/npm/cc-python)
 — same domain model, same materialization rules, pointed the other way:
 
@@ -106,11 +108,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
-From [`examples/bench_wire.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/bench_wire.py)
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+From `python -m cc_node.examples.bench_wire` (sources under
+[`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -127,7 +140,12 @@ future work.
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-[`examples/use_node.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/use_node.py).
+`python -m cc_node.examples.use_node`.
+
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
 
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/cc_node/__init__.py

@@ -107,9 +107,11 @@ class JsHandle:
                                      " (closed)" if self._d.closed else "")
 
     def __del__(self):
+        # Never nest a sync wire op from GC into an in-flight _req — that
+        # steals the outer reply (e.g. returning a callback arg handle).
         try:
             if not self._d.closed:
-                self._d._req("release", h=self._h)
+                self._d._queue_release(self._h)
         except Exception:
             pass
 
@@ -137,6 +139,11 @@ class Bridge:
         self._cbs = {}
         self._ncb = 1
         self._shm_out = []
+        self._depth = 0
+        self._parked = {}
+        self._pending_release = []
+        self._close_pending = False
+        self._destroy_done = False
         _live.append(self)
 
     # ---- wire ----
@@ -146,6 +153,56 @@ class Bridge:
         self._p.stdin.write(line.encode("utf-8"))
         self._p.stdin.flush()
 
+    def _queue_release(self, hid):
+        self._pending_release.append(hid)
+        if self._depth == 0:
+            self._flush_releases()
+
+    def _flush_releases(self):
+        while self._pending_release and not self.closed:
+            hid = self._pending_release.pop(0)
+            try:
+                self._req("release", h=hid)
+            except Exception:
+                pass
+
+    def _flush_shm(self):
+        # The child unlinks spill files as it decodes; this sweep only
+        # matters when it died first (ENOENT is the normal case).
+        for path in self._shm_out:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+        del self._shm_out[:]
+
+    def _take_reply(self, msg):
+        if "e" in msg:
+            raise JsError(msg["e"])
+        return self._decode_result(msg)
+
+    def _wait_reply(self, rid):
+        parked = self._parked.pop(rid, None)
+        if parked is not None:
+            return self._take_reply(parked)
+        while True:
+            line = self._p.stdout.readline()
+            if not line:
+                self.closed = True
+                raise JsError("cc-node: the node child exited")
+            msg = json.loads(line)
+            if "cb" in msg:
+                self._serve_callback(msg)
+                continue
+            mid = msg.get("id")
+            if mid == rid:
+                return self._take_reply(msg)
+            if mid is not None:
+                # Nested _req (GC release, etc.) can overtake; park by id.
+                self._parked[mid] = msg
+                continue
+            raise JsError("cc-node: protocol violation (unexpected reply)")
+
     def _req(self, op, **kw):
         if self.closed:
             raise JsError("cc-node: bridge is closed")
@@ -153,35 +210,22 @@ class Bridge:
         self._nid += 1
         kw["id"] = rid
         kw["op"] = op
+        self._depth += 1
         try:
-            self._send(kw)
-        except (BrokenPipeError, ValueError):
-            self.closed = True
-            raise JsError("cc-node: the node child exited") from None
-        try:
-            while True:
-                line = self._p.stdout.readline()
-                if not line:
-                    self.closed = True
-                    raise JsError("cc-node: the node child exited")
-                msg = json.loads(line)
-                if "cb" in msg:
-                    self._serve_callback(msg)
-                    continue
-                if msg.get("id") == rid:
-                    if "e" in msg:
-                        raise JsError(msg["e"])
-                    return self._decode_result(msg)
-                raise JsError("cc-node: protocol violation (unexpected reply)")
+            try:
+                self._send(kw)
+            except (BrokenPipeError, ValueError):
+                self.closed = True
+                raise JsError("cc-node: the node child exited") from None
+            return self._wait_reply(rid)
         finally:
-            # The child unlinks spill files as it decodes; this sweep only
-            # matters when it died first (ENOENT is the normal case).
-            for path in self._shm_out:
-                try:
-                    os.unlink(path)
-                except OSError:
-                    pass
-            del self._shm_out[:]
+            self._depth -= 1
+            if self._depth == 0:
+                self._flush_shm()
+                if self._close_pending:
+                    self._finish_destroy()
+                else:
+                    self._flush_releases()
 
     def _serve_callback(self, msg):
         fn = self._cbs.get(msg["cb"])
@@ -309,13 +353,32 @@ class Bridge:
         return self._req("stats")
 
     def destroy(self):
-        if self.closed:
+        """Idempotent teardown.  Nested destroy (e.g. from a Python
+        callback while the broker waits on cbr) defers the farewell
+        close until the in-flight wire op unwinds — nesting close into
+        the cbr slot hangs the child."""
+        if self._destroy_done:
+            return
+        if self._depth > 0:
+            self.closed = True
+            self._close_pending = True
+            return
+        self._finish_destroy()
+
+    def _finish_destroy(self):
+        if self._destroy_done:
             return
+        self._destroy_done = True
+        self._close_pending = False
+        self.closed = True
         try:
-            self._req("close")
-        except JsError:
+            if self._p.poll() is None and self._p.stdin \
+                    and not self._p.stdin.closed:
+                rid = self._nid
+                self._nid += 1
+                self._send({"id": rid, "op": "close"})
+        except Exception:
             pass
-        self.closed = True
         try:
             self._p.stdin.close()
         except Exception:
@@ -323,7 +386,10 @@ class Bridge:
         try:
             self._p.wait(timeout=5)
         except Exception:
-            self._p.kill()
+            try:
+                self._p.kill()
+            except Exception:
+                pass
         if self in _live:
             _live.remove(self)
 

concurrent_c_node-0.3.0/cc_node/examples/bench_wire.py

@@ -0,0 +1,47 @@
+"""The cc-node wire, measured.  RESULT lines are machine-comparable.
+
+    python -m cc_node.examples.bench_wire
+"""
+import array
+import time
+
+import cc_node
+
+t0 = time.perf_counter()
+js = cc_node.create()
+js.eval("1")
+print("RESULT spawn_ms %d" % round((time.perf_counter() - t0) * 1000))
+
+f = js.eval("(x) => x")
+f(1)
+t0 = time.perf_counter()
+for i in range(500):
+    f(i)
+print("RESULT rtt_us %d" % round((time.perf_counter() - t0) / 500 * 1e6))
+
+g = js.eval("(cb) => cb(21) * 2")
+g(lambda x: x + 1)
+t0 = time.perf_counter()
+for _ in range(200):
+    g(lambda x: x + 1)
+print("RESULT callback_roundtrip_us %d"
+      % round((time.perf_counter() - t0) / 200 * 1e6))
+
+big = array.array("d", [float(i % 97) for i in range(1 << 20)])  # 8MB
+ln = js.eval("(a) => a.length")
+ln(big)
+t0 = time.perf_counter()
+for _ in range(10):
+    ln(big)
+print("RESULT bulk_8mb_shm_ms %.1f" % ((time.perf_counter() - t0) / 10 * 1000))
+
+biglist = [float(i % 97) for i in range(1 << 20)]
+ln(biglist)
+t0 = time.perf_counter()
+for _ in range(3):
+    ln(biglist)
+print("RESULT bulk_8mb_json_list_ms %d"
+      % round((time.perf_counter() - t0) / 3 * 1000))
+
+js.destroy()
+print("done")

concurrent_c_node-0.3.0/cc_node/examples/use_node.py

@@ -0,0 +1,32 @@
+"""cc-node in one sitting: builtin Node modules (no npm install needed),
+chains, callbacks both ways, and async-for-free.
+
+    python -m cc_node.examples.use_node
+"""
+import cc_node
+
+with cc_node.create() as js:
+    # Builtin modules: attribute access is property lookup, calls are calls.
+    path = js.require("path")
+    print("join      :", path.join("a", "b", "c.txt"))
+
+    crypto = js.require("crypto")
+    print("sha256    :", crypto.createHash("sha256")
+                               .update("cc-node").digest("hex")[:16], "...")
+
+    # eval for a quick lambda; a Python callable crosses as a JS function
+    # (JS conventions apply: Array.map passes value, index, array).
+    mapped = js.eval("(f) => [1, 2, 3].map(f)")(lambda x, *rest: x * 10)
+    print("callback  :", mapped)
+
+    # Async is free: thenables are awaited in the child before the reply.
+    fetchish = js.eval("async (x) => { return { doubled: x * 2 } }")
+    print("thenable  :", fetchish(21))
+
+    # Typed buffers cross as typed arrays (big ones via shared memory);
+    # results come back as numpy arrays when numpy is installed.
+    total = js.eval("(a) => a.reduce((s, x) => s + x, 0)")
+    import array
+    print("buffer sum:", total(array.array("d", [1.5, 2.5, 3.0])))
+
+    print("handles   :", js.stats())

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/concurrent_c_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.2.0
+Version: 0.3.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
@@ -40,9 +40,11 @@ array in **9ms** where the same values as a JSON list take 583ms.
 
 ```
 pip install concurrent-c-node   # needs node on PATH (or point at one)
+python -m cc_node.examples.use_node
+python -m cc_node.examples.bench_wire
 ```
 
-Import stays `import cc_node`. The mirror of
+Import stays `import cc_node`. Examples ship in the wheel. The mirror of
 [`concurrent-c-python`](https://github.com/sreekotay/concurrent-c/tree/main/npm/cc-python)
 — same domain model, same materialization rules, pointed the other way:
 
@@ -117,11 +119,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
-From [`examples/bench_wire.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/bench_wire.py)
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+From `python -m cc_node.examples.bench_wire` (sources under
+[`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -138,7 +151,12 @@ future work.
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-[`examples/use_node.py`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/examples/use_node.py).
+`python -m cc_node.examples.use_node`.
+
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
 
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/concurrent_c_node.egg-info/SOURCES.txt

@@ -2,6 +2,9 @@ README.md
 pyproject.toml
 cc_node/__init__.py
 cc_node/broker.cjs
+cc_node/examples/__init__.py
+cc_node/examples/bench_wire.py
+cc_node/examples/use_node.py
 concurrent_c_node.egg-info/PKG-INFO
 concurrent_c_node.egg-info/SOURCES.txt
 concurrent_c_node.egg-info/dependency_links.txt

{concurrent_c_node-0.2.0 → concurrent_c_node-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "concurrent-c-node"
-version = "0.2.0"
+version = "0.3.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"
@@ -16,7 +16,8 @@ Repository = "https://github.com/sreekotay/concurrent-c"
 Documentation = "https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/README.md"
 
 [tool.setuptools]
-packages = ["cc_node"]
+packages = ["cc_node", "cc_node.examples"]
 
 [tool.setuptools.package-data]
 cc_node = ["broker.cjs"]
+"cc_node.examples" = ["*.py"]