sandboxedjs 0.1.33 → 0.1.34

package/dist/index.cjs

@@ -18185,6 +18185,55 @@ def _install_processes():
 
 _install_processes()
 `;
+var ASYNCIO_PY = `
+import asyncio
+from pyodide.ffi import can_run_sync, run_sync
+
+_orig_run = asyncio.run
+
+
+def _run(main, *, debug=None, loop_factory=None):
+    if not asyncio.iscoroutine(main) and not asyncio.isfuture(main):
+        raise ValueError("a coroutine was expected, got {!r}".format(main))
+    if not can_run_sync():
+        # No stack switching: the original at least raises a comprehensible
+        # error rather than this shim inventing a new one.
+        return _orig_run(main, debug=debug, loop_factory=loop_factory)
+    return run_sync(main)
+
+
+def _run_until_complete(self, future):
+    if not can_run_sync():
+        raise RuntimeError(
+            "cannot wait for a coroutine on this host: WebAssembly stack "
+            "switching (JSPI) is unavailable."
+        )
+    return run_sync(future)
+
+
+async def _create_server(self, *args, **kwargs):
+    # Pyodide's loop raises a bare NotImplementedError from deep inside
+    # asyncio, which tells a reader nothing about why their server will not
+    # start. Naming the limit is the least this can do until the container can
+    # route connections to Python.
+    raise NotImplementedError(
+        "this container cannot yet accept network connections from Python: "
+        "asyncio's create_server is not implemented on Pyodide's event loop, "
+        "so an ASGI/WSGI server such as uvicorn will install and import but "
+        "not bind a port. Outbound requests do work."
+    )
+
+
+def _install_asyncio():
+    asyncio.run = _run
+    asyncio.runners.run = _run
+    loop_type = type(asyncio.get_event_loop())
+    loop_type.run_until_complete = _run_until_complete
+    loop_type.create_server = _create_server
+
+
+_install_asyncio()
+`;
 var NETWORK_PY = `
 import builtins, email.message, io, sys, urllib.error, urllib.request, urllib.response
 import _sbx_host as _host
@@ -18469,6 +18518,7 @@ function installSyscallBridge(py) {
   py.runPython(BRIDGE_PY);
   py.runPython(PROCESS_PY);
   py.runPython(NETWORK_PY);
+  py.runPython(ASYNCIO_PY);
 }
 function bindProgram(py, binding) {
   py.__sbxSlot.current = binding;
@@ -18742,6 +18792,67 @@ async function runCPythonRepl(ctx) {
   }
   return 0;
 }
+var PIP_PY = `
+import json, re
+
+import micropip
+
+_MISSING = re.compile(r"Can't find a pure Python 3 wheel for '([^']+)'")
+_EXTRAS = re.compile(r"^\\s*([A-Za-z0-9._-]+)\\s*\\[([^\\]]+)\\](.*)$")
+
+
+def _name_of(spec):
+    return re.split(r"[\\[<>=!~;\\s]", spec.strip(), 1)[0]
+
+
+def _installed_version(name):
+    try:
+        found = micropip.list()[name.replace("_", "-").lower()]
+        return getattr(found, "version", None)
+    except Exception:
+        return None
+
+
+async def _install_one(spec):
+    """Install one requirement, retrying without extras if they are impossible."""
+    attempt = spec
+    dropped = None
+    while True:
+        try:
+            await micropip.install(attempt)
+        except ValueError as error:
+            message = str(error)
+            missing = _MISSING.findall(message)
+            extras = _EXTRAS.match(attempt)
+            if missing and extras and dropped is None:
+                dropped = [e.strip() for e in extras.group(2).split(",")]
+                attempt = extras.group(1) + extras.group(3)
+                continue
+            return {
+                "spec": spec, "ok": False, "missing": missing,
+                "reason": message.strip().split("\\n")[0],
+            }
+        except Exception as error:
+            return {"spec": spec, "ok": False, "missing": [], "reason": str(error).strip().split("\\n")[0]}
+
+        name = _name_of(attempt)
+        return {
+            "spec": spec, "ok": True, "name": name,
+            "version": _installed_version(name), "dropped": dropped,
+        }
+
+
+async def __sbx_pip(specs_json):
+    results = []
+    for spec in json.loads(specs_json):
+        try:
+            results.append(await _install_one(spec))
+        except Exception as error:
+            results.append({"spec": spec, "ok": False, "missing": [], "reason": str(error)})
+    return json.dumps(results)
+
+__sbx_pip
+`;
 var micropip = defineCommand({
   name: "micropip",
   path: "/usr/bin/micropip",
@@ -18779,8 +18890,7 @@ var micropip = defineCommand({
       ctx.stderr.write("pip: no packages specified\n");
       return 1;
     }
-    const index = "https://pypi.org";
-    if (!ctx.kernel.net.outboundAllowed(index)) {
+    if (!ctx.kernel.net.outboundAllowed("https://pypi.org")) {
       ctx.stderr.write(
         "pip: outbound network access is disabled for this container (enable with network: { allowOutbound: true })\n"
       );
@@ -18793,22 +18903,42 @@ var micropip = defineCommand({
       ctx.stderr.write("pip: Pyodide is unavailable in this host\n");
       return 127;
     }
+    let outcomes;
     try {
       await py.loadPackage("micropip");
-      const micropipModule = py.pyimport("micropip");
-      for (const name of packages) {
-        ctx.line(`Collecting ${name}`);
-        await micropipModule.install(name);
-        ctx.line(`Successfully installed ${name}`);
-      }
-      return 0;
+      for (const name of packages) ctx.line(`Collecting ${name}`);
+      const install2 = py.runPython(PIP_PY);
+      outcomes = JSON.parse(String(await install2(JSON.stringify(packages))));
     } catch (error) {
       ctx.stderr.write(
-        `Package installation failed: ${error instanceof Error ? error.message : String(error)}
+        `pip: installation failed: ${error instanceof Error ? error.message : String(error)}
 `
       );
       return 1;
     }
+    const installed2 = [];
+    for (const outcome of outcomes) {
+      if (outcome.ok) {
+        installed2.push(
+          outcome.version ? `${outcome.name}-${outcome.version}` : String(outcome.name)
+        );
+        if (outcome.dropped?.length) {
+          ctx.stderr.write(
+            `  WARNING: ${outcome.name}: the ${outcome.dropped.map((extra) => `'${extra}'`).join(", ")} extra needs native code with no WebAssembly build; installed ${outcome.name} without it
+`
+          );
+        }
+        continue;
+      }
+      const missing = outcome.missing ?? [];
+      ctx.stderr.write(
+        missing.length > 0 ? `ERROR: could not install ${outcome.spec}: no WebAssembly build exists for ${missing.map((name) => name.split(/[<>=!~;\s]/)[0]).join(", ")}
+` : `ERROR: could not install ${outcome.spec}: ${outcome.reason ?? "unknown error"}
+`
+      );
+    }
+    if (installed2.length > 0) ctx.line(`Successfully installed ${installed2.join(" ")}`);
+    return outcomes.every((outcome) => outcome.ok) ? 0 : 1;
   }
 });