pyodide-pool 0.1.2__tar.gz → 0.2.0__tar.gz

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/.gitignore

@@ -6,7 +6,7 @@ _output/
 bench/results/node-smoke*
 playwright-report/
 .jupyterlite.doit.db
-demos/jupyterlite/files/assets/
+python/pyodide_pool/pyodide-pool.browser.js
 demos/jupyterlite/files/wheels/
 demos/jupyterlite/pypi/
 demos/jupyterlite/.cache/

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyodide-pool
-Version: 0.1.2
+Version: 0.2.0
 Summary: Run Python callables and dask graphs on a pool of Pyodide Web Workers (driver-side API)
 Project-URL: Homepage, https://github.com/fideus-labs/python-wasm-parallelism
 Project-URL: Demo, https://fideus-labs.github.io/python-wasm-parallelism/
@@ -60,8 +60,8 @@ value = await pyodide_pool.submit(fn, *args, **kwargs)  # one remote call
 total = await pyodide_pool.compute(dask.delayed(sum)([...]))  # dask collections
 ```
 
-`create_pool` loads the self-contained JS bundle from the JupyterLite site by
-default; pass `js_url=` to load it from elsewhere. A web app that embeds
+`create_pool` imports the self-contained JS bundle that ships inside the
+wheel; pass `js_url=` to load a hosted copy instead. A web app that embeds
 Pyodide can instead create the JS `PyodidePool` itself and register it with
 `pyodide.registerJsModule('js_pyodide_pool', { pool })`.
 

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/README.md

@@ -36,8 +36,8 @@ value = await pyodide_pool.submit(fn, *args, **kwargs)  # one remote call
 total = await pyodide_pool.compute(dask.delayed(sum)([...]))  # dask collections
 ```
 
-`create_pool` loads the self-contained JS bundle from the JupyterLite site by
-default; pass `js_url=` to load it from elsewhere. A web app that embeds
+`create_pool` imports the self-contained JS bundle that ships inside the
+wheel; pass `js_url=` to load a hosted copy instead. A web app that embeds
 Pyodide can instead create the JS `PyodidePool` itself and register it with
 `pyodide.registerJsModule('js_pyodide_pool', { pool })`.
 

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/pyodide_pool/__init__.py

@@ -40,7 +40,7 @@ from ._bridge import (
 )
 from ._packages import EXCLUDED_FROM_MIRROR, PackageSnapshot, snapshot_packages
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 __all__ = [
     "EXCLUDED_FROM_MIRROR",

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/pyodide_pool/_bridge.py

@@ -171,7 +171,10 @@ class WorkerPool:
 
         The call triple ships as a cloudpickle payload together with the
         driver's current package snapshot, so the worker mirrors the
-        driver's installed packages before executing.
+        driver's installed packages before executing. Where the runtime has
+        JSPI, the worker runs the call with stack switching: ``func`` may
+        block on an awaitable with ``pyodide.ffi.run_sync`` and may be a
+        coroutine function, whose awaited value is the result.
         """
         payload = _to_js_buffer(cloudpickle.dumps((func, args, kwargs)))
         packages, wheels = snapshot_packages()

pyodide_pool-0.2.0/pyodide_pool/loader.py

@@ -0,0 +1,70 @@
+"""Bootstrap the JS worker pool from inside a Pyodide kernel (JupyterLite).
+
+Runs in the MAIN Pyodide instance (the driver), like the rest of the
+package. An embedding web app wires the JS side itself (create a
+``PyodidePool``, ``pyodide.registerJsModule('js_pyodide_pool', { pool })``),
+but notebook code inside JupyterLite's Pyodide kernel has no JS embedder to
+lean on — the kernel itself runs in a Web Worker. :func:`create_pool` pulls
+the JS side in from Python instead: dynamically ``import()`` the
+self-contained browser bundle (``pyodide-pool.browser.js``, built by
+``npm run build`` and shipped inside this wheel), construct the JS
+``PyodidePool`` — its workers spawn as NESTED Web Workers from a Blob URL
+inlined in the bundle — and install the Python :class:`WorkerPool` wrapper
+as the default pool, so ``pyodide_pool.submit``/``compute`` work with no
+further setup.
+
+The vendored bundle is imported from a ``data:`` URL, so no host has to
+serve it; a page with a ``script-src`` CSP must allow ``data:`` (the nested
+workers already need ``blob:``).
+
+Environment requirements: nested-worker support (all Chromium-based
+browsers; Firefox and Safari in current versions) and network access to
+the Pyodide CDN. The pool is postMessage-based, so it does NOT need a
+cross-origin-isolated page — it runs on plain static hosts like GitHub
+Pages (verified by the Pages deployment of demos/jupyterlite). COOP/COEP
+headers (scripts/serve-lite.mjs sends them) only add SharedArrayBuffer
+extras such as the JupyterLite kernel's coincident transport.
+"""
+
+from __future__ import annotations
+
+from base64 import b64encode
+from importlib.resources import files
+
+from . import _bridge
+from ._bridge import WorkerPool
+
+__all__ = ["create_pool"]
+
+#: The browser bundle, copied next to this module by scripts/bundles.mjs and
+#: listed as a build artifact in pyproject.toml so the wheel carries it.
+_BUNDLE = "pyodide-pool.browser.js"
+
+
+async def create_pool(pool_size: int = 4, js_url: str | None = None) -> WorkerPool:
+    """Import the JS bundle, start a worker pool, and make it the default.
+
+    Parameters
+    ----------
+    pool_size:
+        Maximum number of concurrent workers, one Pyodide interpreter each.
+    js_url:
+        Load the bundle from this URL instead of the vendored copy. Must be
+        fully qualified (``https://``, or ``file://`` under Node): inside a
+        kernel worker, ``import()`` resolves a relative URL against the CDN
+        module evaluating it, not against the site.
+    """
+    from js import Object
+    from pyodide.code import run_js
+    from pyodide.ffi import to_js
+
+    if js_url is None:
+        # FileNotFoundError here means the wheel was built before the JS
+        # bundle (run `npm run build` first).
+        source = files(__package__).joinpath(_BUNDLE).read_bytes()
+        js_url = "data:text/javascript;base64," + b64encode(source).decode()
+    module = await run_js("(url) => import(url)")(js_url)
+    options = to_js({"poolSize": pool_size}, dict_converter=Object.fromEntries)
+    pool = WorkerPool(module.createPool(options))
+    _bridge.set_default_pool(pool)
+    return pool

{pyodide_pool-0.1.2 → pyodide_pool-0.2.0}/pyproject.toml

@@ -40,3 +40,7 @@ path = "pyodide_pool/__init__.py"
 
 [tool.hatch.build.targets.wheel]
 packages = ["pyodide_pool"]
+# Build output written by scripts/bundles.mjs and gitignored at the repo root.
+# Hatchling only reads a .gitignore inside this directory today, so the file
+# is included either way; naming it keeps the wheel whole if that changes.
+artifacts = ["pyodide_pool/pyodide-pool.browser.js"]

pyodide_pool-0.1.2/pyodide_pool/loader.py

@@ -1,99 +0,0 @@
-"""Bootstrap the JS worker pool from inside a Pyodide kernel (JupyterLite).
-
-Runs in the MAIN Pyodide instance (the driver), like the rest of the
-package. An embedding web app wires the JS side itself (create a
-``PyodidePool``, ``pyodide.registerJsModule('js_pyodide_pool', { pool })``),
-but notebook code inside JupyterLite's Pyodide kernel has no JS embedder to
-lean on — the kernel itself runs in a Web Worker. :func:`create_pool` pulls
-the JS side in from Python instead: dynamically ``import()`` the
-self-contained browser bundle (``pyodide-pool.browser.js``, built by
-``npm run build`` and copied into the site's ``files/assets/`` by
-``npm run build:lite``), construct the JS ``PyodidePool`` — its workers
-spawn as NESTED Web Workers from a Blob URL inlined in the bundle — and
-install the Python :class:`WorkerPool` wrapper as the default pool, so
-``pyodide_pool.submit``/``compute`` work with no further setup.
-
-Environment requirements: nested-worker support (all Chromium-based
-browsers; Firefox and Safari in current versions) and network access to
-the Pyodide CDN. The pool is postMessage-based, so it does NOT need a
-cross-origin-isolated page — it runs on plain static hosts like GitHub
-Pages (verified by the Pages deployment of demos/jupyterlite). COOP/COEP
-headers (scripts/serve-lite.mjs sends them) only add SharedArrayBuffer
-extras such as the JupyterLite kernel's coincident transport.
-"""
-
-from __future__ import annotations
-
-from . import _bridge
-from ._bridge import WorkerPool
-
-__all__ = ["DEFAULT_JS_URL", "create_pool"]
-
-#: Where the JupyterLite site serves the bundle, as a path RELATIVE to the
-#: deployment's base URL (``files/`` holds the site contents). It is resolved
-#: against the base URL derived from the kernel worker's ``location`` (see
-#: :data:`_IMPORT_JS`), so the default works whether the site is hosted at the
-#: origin root (scripts/serve-lite.mjs) or under a sub-path such as GitHub
-#: Pages (``/<repo>/``) — no explicit ``js_url`` needed either way.
-DEFAULT_JS_URL = "files/assets/pyodide-pool.browser.js"
-
-# JS that dynamically ``import()``s the browser bundle. Two wrinkles make a
-# plain ``import(url)`` wrong inside JupyterLite's Pyodide kernel:
-#   * ``import()`` resolves relative/path-absolute URLs against the REFERRER
-#     module — here pyodide.asm.js, loaded from the jsDelivr CDN — so a
-#     site-relative path would 404 on the CDN rather than the site.
-#   * A path-absolute ``/files/...`` resolved against the page origin drops
-#     any deployment sub-path, so GitHub Pages (``/<repo>/``) 404s on
-#     ``origin/files/...`` — the original symptom this bootstrap fixes.
-# The kernel worker is served from ``<baseUrl>extensions/.../<name>.worker.js``
-# (jupyterlite-pyodide-kernel's ``initWorker``), so everything up to the slash
-# before ``extensions/`` is the deployment base URL. Resolve the base-relative
-# bundle URL against that, falling back to the origin root. A fully-qualified
-# URL (http:, https:, file:, blob:, data:) and Node (no global ``location``)
-# are imported as given.
-_IMPORT_JS = r"""
-(async (u) => {
-  if (typeof location === 'undefined') return import(u);
-  if (/^[a-z][a-z0-9+.\-]*:/i.test(u)) return import(u);
-  const here = location.href;
-  const rel = u.replace(/^\/+/, '');
-  const ext = here.indexOf('/extensions/');
-  const base = ext === -1 ? new URL('/', here).href : here.slice(0, ext + 1);
-  const candidates = [...new Set([new URL(rel, base).href, new URL('/' + rel, here).href])];
-  let lastErr;
-  for (const c of candidates) {
-    try { return await import(c); } catch (e) { lastErr = e; }
-  }
-  throw lastErr;
-})
-""".strip()
-
-
-async def create_pool(pool_size: int = 4, js_url: str | None = None) -> WorkerPool:
-    """Import the JS bundle, start a worker pool, and make it the default.
-
-    Parameters
-    ----------
-    pool_size:
-        Maximum number of concurrent workers, one Pyodide interpreter each.
-    js_url:
-        URL of the self-contained browser bundle, defaulting to
-        :data:`DEFAULT_JS_URL`. A base-relative path (``files/...``) is
-        resolved against the JupyterLite deployment base URL; a full URL
-        (``http(s)://``, or a ``file://`` URL under Node) is used as-is.
-    """
-    from js import Object
-    from pyodide.code import run_js
-    from pyodide.ffi import to_js
-
-    url = DEFAULT_JS_URL if js_url is None else js_url
-    # Resolve and import the bundle against the deployment base URL; see
-    # _IMPORT_JS for why a plain import() / path-absolute URL is wrong here.
-    # repr(url) yields a JS-safe string literal (matching the old f-string's
-    # {url!r}); build the call by concatenation so the JS body's braces are
-    # not read as Python format fields.
-    module = await run_js(_IMPORT_JS + "(" + repr(url) + ")")
-    options = to_js({"poolSize": pool_size}, dict_converter=Object.fromEntries)
-    pool = WorkerPool(module.createPool(options))
-    _bridge.set_default_pool(pool)
-    return pool