pyodide 0.20.0-alpha.1 → 0.20.0

package/api.ts

@@ -33,22 +33,22 @@ export let version: string = ""; // actually defined in loadPyodide (see pyodide
 
 let runPythonPositionalGlobalsDeprecationWarned = false;
 /**
- * Runs a string of Python code from JavaScript.
+ * Runs a string of Python code from JavaScript, using :any:`pyodide.eval_code`
+ * to evaluate the code. If the last statement in the Python code is an
+ * expression (and the code doesn't end with a semicolon), the value of the
+ * expression is returned.
  *
- * The last part of the string may be an expression, in which case, its value is
- * returned.
+ * .. admonition:: Positional globals argument
+ *    :class: warning
  *
- * .. admonition:: Positional globals argument :class: warning
- *
- *    In Pyodide v0.19, this function took the globals parameter as a
- *    positional argument rather than as a named argument. In v0.20 this will
- *    still work  but it is deprecated. It will be removed in v0.21.
+ *    In Pyodide v0.19, this function took the globals parameter as a positional
+ *    argument rather than as a named argument. In v0.20 this will still work
+ *    but it is deprecated. It will be removed in v0.21.
  *
  * @param code Python code to evaluate
  * @param options
  * @param options.globals An optional Python dictionary to use as the globals.
- *        Defaults to :any:`pyodide.globals`. Uses the Python API
- *        :any:`pyodide.eval_code` to evaluate the code.
+ *        Defaults to :any:`pyodide.globals`.
  * @returns The result of the Python code translated to JavaScript. See the
  *          documentation for :any:`pyodide.eval_code` for more info.
  */
@@ -60,7 +60,7 @@ export function runPython(
     options = { globals: options as PyProxy };
     if (!runPythonPositionalGlobalsDeprecationWarned) {
       console.warn(
-        "Passing a PyProxy as the second argument to runPython is deprecated. Use 'runPython(code, {globals : some_dict})' instead."
+        "Passing a PyProxy as the second argument to runPython is deprecated and will be removed in v0.21. Use 'runPython(code, {globals : some_dict})' instead."
       );
       runPythonPositionalGlobalsDeprecationWarned = true;
     }
@@ -122,8 +122,11 @@ export async function loadPackagesFromImports(
 }
 
 /**
- * Runs Python code using `PyCF_ALLOW_TOP_LEVEL_AWAIT
- * <https://docs.python.org/3/library/ast.html?highlight=pycf_allow_top_level_await#ast.PyCF_ALLOW_TOP_LEVEL_AWAIT>`_.
+ * Run a Python code string with top level await using
+ * :any:`pyodide.eval_code_async` to evaluate the code. Returns a promise which
+ * resolves when execution completes. If the last statement in the Python code
+ * is an expression (and the code doesn't end with a semicolon), the returned
+ * promise will resolve to the value of this expression.
  *
  * For example:
  *
@@ -138,13 +141,15 @@ export async function loadPackagesFromImports(
  *    `);
  *    console.log(result); // 79
  *
- * .. admonition:: Python imports :class: warning
+ * .. admonition:: Python imports
+ *    :class: warning
  *
  *    Since pyodide 0.18.0, you must call :js:func:`loadPackagesFromImports` to
  *    import any python packages referenced via `import` statements in your
  *    code. This function will no longer do it for you.
  *
- * .. admonition:: Positional globals argument :class: warning
+ * .. admonition:: Positional globals argument
+ *    :class: warning
  *
  *    In Pyodide v0.19, this function took the globals parameter as a
  *    positional argument rather than as a named argument. In v0.20 this will
@@ -153,8 +158,7 @@ export async function loadPackagesFromImports(
  * @param code Python code to evaluate
  * @param options
  * @param options.globals An optional Python dictionary to use as the globals.
- * Defaults to :any:`pyodide.globals`. Uses the Python API
- * :any:`pyodide.eval_code_async` to evaluate the code.
+ * Defaults to :any:`pyodide.globals`.
  * @returns The result of the Python code translated to JavaScript.
  * @async
  */
@@ -166,7 +170,7 @@ export async function runPythonAsync(
     options = { globals: options as PyProxy };
     if (!runPythonPositionalGlobalsDeprecationWarned) {
       console.warn(
-        "Passing a PyProxy as the second argument to runPython is deprecated. Use 'runPythonAsync(code, {globals : some_dict})' instead."
+        "Passing a PyProxy as the second argument to runPythonAsync is deprecated and will be removed in v0.21. Use 'runPythonAsync(code, {globals : some_dict})' instead."
       );
       runPythonPositionalGlobalsDeprecationWarned = true;
     }
@@ -322,25 +326,46 @@ export function pyimport(mod_name: string): PyProxy {
   return API.importlib.import_module(mod_name);
 }
 
+let unpackArchivePositionalExtractDirDeprecationWarned = false;
 /**
  * Unpack an archive into a target directory.
  *
+ * .. admonition:: Positional globals argument :class: warning
+ *
+ *    In Pyodide v0.19, this function took the extract_dir parameter as a
+ *    positional argument rather than as a named argument. In v0.20 this will
+ *    still work  but it is deprecated. It will be removed in v0.21.
+ *
  * @param buffer The archive as an ArrayBuffer or TypedArray.
- * @param format The format of the archive. Should be one of the formats recognized by `shutil.unpack_archive`.
- * By default the options are 'bztar', 'gztar', 'tar', 'zip', and 'wheel'. Several synonyms are accepted for each format, e.g.,
- * for 'gztar' any of '.gztar', '.tar.gz', '.tgz', 'tar.gz' or 'tgz' are considered to be synonyms.
+ * @param format The format of the archive. Should be one of the formats
+ * recognized by `shutil.unpack_archive`. By default the options are 'bztar',
+ * 'gztar', 'tar', 'zip', and 'wheel'. Several synonyms are accepted for each
+ * format, e.g., for 'gztar' any of '.gztar', '.tar.gz', '.tgz', 'tar.gz' or
+ * 'tgz' are considered to be synonyms.
  *
- * @param extract_dir The directory to unpack the archive into. Defaults to the working directory.
+ * @param options
+ * @param options.extractDir The directory to unpack the archive into. Defaults
+ * to the working directory.
  */
 export function unpackArchive(
   buffer: TypedArray,
   format: string,
-  extract_dir?: string
+  options: {
+    extractDir?: string;
+  } = {}
 ) {
-  if (!API._util_module) {
-    API._util_module = pyimport("pyodide._util");
+  if (typeof options === "string") {
+    if (!unpackArchivePositionalExtractDirDeprecationWarned) {
+      console.warn(
+        "Passing a string as the third argument to unpackArchive is deprecated and will be removed in v0.21. Instead use { extract_dir : 'some_path' }"
+      );
+      unpackArchivePositionalExtractDirDeprecationWarned = true;
+    }
+    options = { extractDir: options };
   }
-  API._util_module.unpack_buffer_archive.callKwargs(buffer, {
+  let extract_dir = options.extractDir;
+  API.package_loader.unpack_buffer.callKwargs({
+    buffer,
     format,
     extract_dir,
   });
@@ -357,15 +382,28 @@ API.saveState = () => API.pyodide_py._state.save_state();
 API.restoreState = (state: any) => API.pyodide_py._state.restore_state(state);
 
 /**
- * Sets the interrupt buffer to be `interrupt_buffer`. This is only useful when
- * Pyodide is used in a webworker. The buffer should be a `SharedArrayBuffer`
- * shared with the main browser thread (or another worker). To request an
- * interrupt, a `2` should be written into `interrupt_buffer` (2 is the posix
- * constant for SIGINT).
+ * Sets the interrupt buffer to be ``interrupt_buffer``. This is only useful
+ * when Pyodide is used in a webworker. The buffer should be a
+ * ``SharedArrayBuffer`` shared with the main browser thread (or another
+ * worker). In that case, signal ``signum`` may be sent by writing ``signum``
+ * into the interrupt buffer. If ``signum`` does not satisfy 0 < ``signum`` <
+ * ``NSIG`` it will be silently ignored. NSIG is 65 (internally signals are
+ * indicated by a bitflag).
+ *
+ * You can disable interrupts by calling `setInterruptBuffer(undefined)`.
+ *
+ * If you wish to trigger a ``KeyboardInterrupt``, write ``SIGINT`` (a 2), into
+ * the interrupt buffer.
+ *
+ * By default ``SIGINT`` raises a ``KeyboardInterrupt`` and all other signals
+ * are ignored. You can install custom signal handlers with the signal module.
+ * Even signals that normally have special meaning and can't be overridden like
+ * ``SIGKILL`` and ``SIGSEGV`` are ignored by default and can be used for any
+ * purpose you like.
  */
 export function setInterruptBuffer(interrupt_buffer: TypedArray) {
-  API.interrupt_buffer = interrupt_buffer;
-  Module._set_pyodide_callback(!!interrupt_buffer);
+  Module.HEAP8[Module._Py_EMSCRIPTEN_SIGNAL_HANDLING] = !!interrupt_buffer;
+  Module.Py_EmscriptenSignalBuffer = interrupt_buffer;
 }
 
 /**
@@ -377,10 +415,8 @@ export function setInterruptBuffer(interrupt_buffer: TypedArray) {
  * during execution of C code.
  */
 export function checkInterrupt() {
-  if (API.interrupt_buffer[0] === 2) {
-    API.interrupt_buffer[0] = 0;
-    Module._PyErr_SetInterrupt();
-    API.runPython("");
+  if (Module.__PyErr_CheckSignals()) {
+    Module._pythonexc2js();
   }
 }
 

package/error_handling.gen.ts

@@ -11,6 +11,38 @@ API.dump_traceback = function () {
   Module.__Py_DumpTraceback(fd_stdout, Module._PyGILState_GetThisThreadState());
 };
 
+function ensureCaughtObjectIsError(e: any) {
+  if (typeof e === "string") {
+    // Sometimes emscripten throws a raw string...
+    e = new Error(e);
+  } else if (
+    typeof e !== "object" ||
+    e === null ||
+    typeof e.stack !== "string" ||
+    typeof e.message !== "string"
+  ) {
+    // We caught something really weird. Be brave!
+    let msg = `A value of type ${typeof e} with tag ${Object.prototype.toString.call(
+      e
+    )} was thrown as an error!`;
+    try {
+      msg += `\nString interpolation of the thrown value gives """${e}""".`;
+    } catch (e) {
+      msg += `\nString interpolation of the thrown value fails.`;
+    }
+    try {
+      msg += `\nThe thrown value's toString method returns """${e.toString()}""".`;
+    } catch (e) {
+      msg += `\nThe thrown value's toString method fails.`;
+    }
+    e = new Error(msg);
+  }
+  // Post conditions:
+  // 1. typeof e is object
+  // 2. hiwire_is_error(e) returns true
+  return e;
+}
+
 let fatal_error_occurred = false;
 /**
  * Signal a fatal error.
@@ -25,7 +57,7 @@ let fatal_error_occurred = false;
  * @private
  */
 API.fatal_error = function (e: any) {
-  if (e.pyodide_fatal_error) {
+  if (e && e.pyodide_fatal_error) {
     return;
   }
   if (fatal_error_occurred) {
@@ -34,14 +66,10 @@ API.fatal_error = function (e: any) {
     return;
   }
   if (typeof e === "number") {
-    // A C++ exception. Have to do some conversion work.
+    // Hopefully a C++ exception? Have to do some conversion work.
     e = convertCppException(e);
-  } else if (typeof e === "string") {
-    e = new Error(e);
-  } else if (typeof e !== "object") {
-    e = new Error(
-      `An object of type ${typeof e} was thrown as an error. toString returns ${e.toString()}`
-    );
+  } else {
+    e = ensureCaughtObjectIsError(e);
   }
   // Mark e so we know not to handle it later in EM_JS wrappers
   e.pyodide_fatal_error = true;
@@ -193,7 +221,7 @@ function isErrorStart(frame: ErrorStackParser.StackFrame): boolean {
 }
 
 Module.handle_js_error = function (e: any) {
-  if (e.pyodide_fatal_error) {
+  if (e && e.pyodide_fatal_error) {
     throw e;
   }
   if (e instanceof Module._PropagatePythonError) {
@@ -207,6 +235,16 @@ Module.handle_js_error = function (e: any) {
     // Try to restore the original Python exception.
     restored_error = Module._restore_sys_last_exception(e.__error_address);
   }
+  let stack: any;
+  let weirdCatch;
+  try {
+    stack = ErrorStackParser.parse(e);
+  } catch (_) {
+    weirdCatch = true;
+  }
+  if (weirdCatch) {
+    e = ensureCaughtObjectIsError(e);
+  }
   if (!restored_error) {
     // Wrap the JavaScript error
     let eidx = Hiwire.new_value(e);
@@ -215,7 +253,10 @@ Module.handle_js_error = function (e: any) {
     Module._Py_DecRef(err);
     Hiwire.decref(eidx);
   }
-  let stack = ErrorStackParser.parse(e);
+  if (weirdCatch) {
+    // In this case we have no stack frames so we can quit
+    return;
+  }
   if (isErrorStart(stack[0])) {
     while (isPyodideFrame(stack[0])) {
       stack.shift();

package/index.test-d.ts

@@ -159,4 +159,9 @@ async function main() {
     expectAssignable<{ done?: any; value: any }>(px.next());
     expectAssignable<{ done?: any; value: any }>(px.next(22));
   }
+
+  pyodide.unpackArchive(new Uint8Array(40), "tar");
+  pyodide.unpackArchive(new Uint8Array(40), "tar", {
+    extractDir: "/some/path",
+  });
 }

package/load-package.ts

@@ -1,4 +1,4 @@
-import { Module, API } from "./module.js";
+import { Module, API, Tests } from "./module.js";
 import { IN_NODE, nodeFsPromisesMod, _loadBinaryFile } from "./compat.js";
 import { PyProxy, isPyProxy } from "./pyproxy.gen";
 
@@ -171,13 +171,14 @@ async function installPackage(name: string, buffer: Uint8Array) {
       imports: [] as string[],
     };
   }
-  const file_name = pkg.file_name;
+  const filename = pkg.file_name;
   // This Python helper function unpacks the buffer and lists out any so files therein.
-  const dynlibs = API.package_loader.unpack_buffer(
-    file_name,
+  const dynlibs = API.package_loader.unpack_buffer.callKwargs({
     buffer,
-    pkg.install_dir
-  );
+    filename,
+    target: pkg.install_dir,
+    calculate_dynlibs: true,
+  });
   for (const dynlib of dynlibs) {
     await loadDynlib(dynlib, pkg.shared_library);
   }
@@ -248,10 +249,19 @@ async function loadDynlib(lib: string, shared: boolean) {
         nodelete: true,
       });
     }
+  } catch (e) {
+    if (e.message.includes("need to see wasm magic number")) {
+      console.warn(
+        `Failed to load dynlib ${lib}. We probably just tried to load a linux .so file or something.`
+      );
+      return;
+    }
+    throw e;
   } finally {
     releaseDynlibLock();
   }
 }
+Tests.loadDynlib = loadDynlib;
 
 const acquirePackageLock = createLock();
 
@@ -353,6 +363,7 @@ export async function loadPackage(
           loadedPackages[name] = channel;
         })
         .catch((err) => {
+          console.warn(err);
           failed[name] = err;
         });
     }
@@ -366,6 +377,7 @@ export async function loadPackage(
           loadedPackages[name] = channel;
         })
         .catch((err) => {
+          console.warn(err);
           failed[name] = err;
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyodide",
-  "version": "0.20.0-alpha.1",
+  "version": "0.20.0",
   "description": "The Pyodide JavaScript package",
   "keywords": [
     "python",

package/pyproxy.gen.ts

@@ -21,6 +21,90 @@
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /**
  * Every public Python entrypoint goes through this file! The main entrypoint is
  * the callPyObject method, but of course one can also execute arbitrary code
@@ -289,7 +373,12 @@ Module.callPyObjectKwargs = function (ptrobj: number, ...jsargs: any) {
   if (idresult === 0) {
     Module._pythonexc2js();
   }
-  return Hiwire.pop_value(idresult);
+  let result = Hiwire.pop_value(idresult);
+  // Automatically schedule coroutines
+  if (result && result.type === "coroutine" && result._ensure_future) {
+    result._ensure_future();
+  }
+  return result;
 };
 Module.callPyObject = function (ptrobj: number, ...jsargs: any) {
   return Module.callPyObjectKwargs(ptrobj, ...jsargs, {});