concurrent-c-node 0.14.0__tar.gz → 0.15.0__tar.gz

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.14.0
+Version: 0.15.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,6 +62,7 @@ event-loop or GIL between them.
 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
+python -m cc_node.benchmarks.multi_domain   # N children, thread-fanned
 ```
 
 ## Measured (separate-process wire)
@@ -186,7 +187,9 @@ JS Promise you must await.
 **Wire cost vs tiny work.** Round trip is ~100µs class; a one-line JS
 helper on three numbers loses to pure Python. Prefer Python (or a native
 CC module) for small/hot work; use the bridge when Node/npm owns the
-kernel (crypto, parsers, large buffers via shm).
+kernel (crypto, parsers, large buffers via shm). Multi-core: fan across
+`create()` handles from threads —
+`python -m cc_node.benchmarks.multi_domain` (~2.8× on 3 domains here).
 
 **Crash isolation, not a sandbox.** The child inherits your environment
 and privileges — do not evaluate untrusted JavaScript. `destroy()` is
@@ -214,16 +217,37 @@ speaks, from CC.
 
 ## Publishing
 
-From the Concurrent-C repo root (packs this wheel and the npm sibling):
+**Preferred — PyPI Trusted Publishing (OIDC) from CI** (no API token):
+
+1. One-time on
+   [Publishing settings](https://pypi.org/manage/project/concurrent-c-node/settings/publishing/):
+   - Owner `sreekotay`, repository `concurrent-c`
+   - Workflow name `publish-cc-node.yml`
+   - Environment name `pypi`
+2. Create a GitHub Environment named `pypi` (optional reviewers encouraged).
+3. Bump `version` in `pyproject.toml`, commit + push, then:
+
+```
+gh workflow run publish-cc-node.yml
+# or: git tag cc-node-vX.Y.Z && git push --tags
+```
+
+Local pack / npm sibling (PyPI defaults to CI OIDC after npm):
 
 ```
-./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
-./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+./scripts/publish_bridges.sh --publish --minor
+# npm is live; then commit+push bumps and:
+gh workflow run publish-cc-node.yml
+
+# local twine fallback:
+./scripts/publish_bridges.sh --publish --minor --pypi-twine
 ```
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-`python -m cc_node.examples.use_node`.
+`python -m cc_node.examples.use_node`. Wire RTT / shm:
+`python -m cc_node.examples.bench_wire`. Multi-core domains (threads):
+`python -m cc_node.benchmarks.multi_domain`.
 
 Adversarial multi-child storm (escaped closures, cooperative
 fanout-destroy, abort inject, handle-leak / RSS soaks):

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/README.md

@@ -51,6 +51,7 @@ event-loop or GIL between them.
 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
+python -m cc_node.benchmarks.multi_domain   # N children, thread-fanned
 ```
 
 ## Measured (separate-process wire)
@@ -175,7 +176,9 @@ JS Promise you must await.
 **Wire cost vs tiny work.** Round trip is ~100µs class; a one-line JS
 helper on three numbers loses to pure Python. Prefer Python (or a native
 CC module) for small/hot work; use the bridge when Node/npm owns the
-kernel (crypto, parsers, large buffers via shm).
+kernel (crypto, parsers, large buffers via shm). Multi-core: fan across
+`create()` handles from threads —
+`python -m cc_node.benchmarks.multi_domain` (~2.8× on 3 domains here).
 
 **Crash isolation, not a sandbox.** The child inherits your environment
 and privileges — do not evaluate untrusted JavaScript. `destroy()` is
@@ -203,16 +206,37 @@ speaks, from CC.
 
 ## Publishing
 
-From the Concurrent-C repo root (packs this wheel and the npm sibling):
+**Preferred — PyPI Trusted Publishing (OIDC) from CI** (no API token):
+
+1. One-time on
+   [Publishing settings](https://pypi.org/manage/project/concurrent-c-node/settings/publishing/):
+   - Owner `sreekotay`, repository `concurrent-c`
+   - Workflow name `publish-cc-node.yml`
+   - Environment name `pypi`
+2. Create a GitHub Environment named `pypi` (optional reviewers encouraged).
+3. Bump `version` in `pyproject.toml`, commit + push, then:
+
+```
+gh workflow run publish-cc-node.yml
+# or: git tag cc-node-vX.Y.Z && git push --tags
+```
+
+Local pack / npm sibling (PyPI defaults to CI OIDC after npm):
 
 ```
-./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
-./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+./scripts/publish_bridges.sh --publish --minor
+# npm is live; then commit+push bumps and:
+gh workflow run publish-cc-node.yml
+
+# local twine fallback:
+./scripts/publish_bridges.sh --publish --minor --pypi-twine
 ```
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-`python -m cc_node.examples.use_node`.
+`python -m cc_node.examples.use_node`. Wire RTT / shm:
+`python -m cc_node.examples.bench_wire`. Multi-core domains (threads):
+`python -m cc_node.benchmarks.multi_domain`.
 
 Adversarial multi-child storm (escaped closures, cooperative
 fanout-destroy, abort inject, handle-leak / RSS soaks):

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/cc_node/__init__.py

@@ -30,7 +30,7 @@ import subprocess
 import tempfile
 
 __all__ = ["create", "JsError", "JsHandle", "__version__"]
-__version__ = "0.12.1"
+__version__ = "0.13.0"
 
 # Typed buffers cross as typed arrays; big ones spill through shared
 # memory (tmpfs where available) — one memcpy per side, receiver

concurrent_c_node-0.15.0/cc_node/benchmarks/__init__.py

@@ -0,0 +1 @@
+# Measurement scripts for concurrent-c-node (RESULT lines, machine-comparable).

concurrent_c_node-0.15.0/cc_node/benchmarks/multi_domain.py

@@ -0,0 +1,60 @@
+"""N node children on N cores — measured with real overlap.
+
+    python -m cc_node.benchmarks.multi_domain
+
+Wire RTT / shm live in ``cc_node.examples.bench_wire``. This file only
+answers the multi-domain question: sequential calls on one child vs the
+same work fanned across threads into separate children.
+"""
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+import cc_node
+
+WORK = """
+(iterations) => {
+  let s = 0;
+  for (let i = 0; i < iterations; i++)
+    s += Math.sqrt(i) * Math.sin(i / 1000);
+  return s;
+}
+"""
+
+
+def main():
+    n_dom = 3
+    iters = 40_000_000
+
+    with cc_node.create() as js:
+        f = js.eval(WORK)
+        f(iters // 20)
+        t0 = time.perf_counter()
+        for _ in range(n_dom):
+            f(iters)
+        seq = time.perf_counter() - t0
+    print("RESULT seq_s %.3f" % seq)
+
+    domains = [cc_node.create() for _ in range(n_dom)]
+    try:
+        fns = [d.eval(WORK) for d in domains]
+        for f in fns:
+            f(iters // 20)
+
+        def run(f):
+            return f(iters)
+
+        t0 = time.perf_counter()
+        with ThreadPoolExecutor(max_workers=n_dom) as pool:
+            list(pool.map(run, fns))
+        par = time.perf_counter() - t0
+    finally:
+        for d in domains:
+            d.destroy()
+
+    print("RESULT par_s %.3f" % par)
+    print("RESULT speedup %.2f" % (seq / par if par else 0))
+    print("done")
+
+
+if __name__ == "__main__":
+    main()

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/concurrent_c_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.14.0
+Version: 0.15.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,6 +62,7 @@ event-loop or GIL between them.
 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
+python -m cc_node.benchmarks.multi_domain   # N children, thread-fanned
 ```
 
 ## Measured (separate-process wire)
@@ -186,7 +187,9 @@ JS Promise you must await.
 **Wire cost vs tiny work.** Round trip is ~100µs class; a one-line JS
 helper on three numbers loses to pure Python. Prefer Python (or a native
 CC module) for small/hot work; use the bridge when Node/npm owns the
-kernel (crypto, parsers, large buffers via shm).
+kernel (crypto, parsers, large buffers via shm). Multi-core: fan across
+`create()` handles from threads —
+`python -m cc_node.benchmarks.multi_domain` (~2.8× on 3 domains here).
 
 **Crash isolation, not a sandbox.** The child inherits your environment
 and privileges — do not evaluate untrusted JavaScript. `destroy()` is
@@ -214,16 +217,37 @@ speaks, from CC.
 
 ## Publishing
 
-From the Concurrent-C repo root (packs this wheel and the npm sibling):
+**Preferred — PyPI Trusted Publishing (OIDC) from CI** (no API token):
+
+1. One-time on
+   [Publishing settings](https://pypi.org/manage/project/concurrent-c-node/settings/publishing/):
+   - Owner `sreekotay`, repository `concurrent-c`
+   - Workflow name `publish-cc-node.yml`
+   - Environment name `pypi`
+2. Create a GitHub Environment named `pypi` (optional reviewers encouraged).
+3. Bump `version` in `pyproject.toml`, commit + push, then:
+
+```
+gh workflow run publish-cc-node.yml
+# or: git tag cc-node-vX.Y.Z && git push --tags
+```
+
+Local pack / npm sibling (PyPI defaults to CI OIDC after npm):
 
 ```
-./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
-./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+./scripts/publish_bridges.sh --publish --minor
+# npm is live; then commit+push bumps and:
+gh workflow run publish-cc-node.yml
+
+# local twine fallback:
+./scripts/publish_bridges.sh --publish --minor --pypi-twine
 ```
 
 A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
-`python -m cc_node.examples.use_node`.
+`python -m cc_node.examples.use_node`. Wire RTT / shm:
+`python -m cc_node.examples.bench_wire`. Multi-core domains (threads):
+`python -m cc_node.benchmarks.multi_domain`.
 
 Adversarial multi-child storm (escaped closures, cooperative
 fanout-destroy, abort inject, handle-leak / RSS soaks):

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/concurrent_c_node.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ README.md
 pyproject.toml
 cc_node/__init__.py
 cc_node/broker.cjs
+cc_node/benchmarks/__init__.py
+cc_node/benchmarks/multi_domain.py
 cc_node/examples/__init__.py
 cc_node/examples/bench_wire.py
 cc_node/examples/use_node.py

{concurrent_c_node-0.14.0 → concurrent_c_node-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "concurrent-c-node"
-version = "0.14.0"
+version = "0.15.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,8 +16,9 @@ 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", "cc_node.examples"]
+packages = ["cc_node", "cc_node.examples", "cc_node.benchmarks"]
 
 [tool.setuptools.package-data]
 cc_node = ["broker.cjs"]
 "cc_node.examples" = ["*.py"]
+"cc_node.benchmarks" = ["*.py"]