@ai-ecoverse/wasix-python 3.14.2-22 → 3.14.2-24

package/README.md

@@ -4,12 +4,12 @@ CPython 3.14 for slicc WASIX (`commands` `python` / `python3`).
 
 ## Features
 
-- PIE dynamic-main (`dylink.0`) on wasix-sysroot 2025.9.30-28's `sysroot-ehpic` (legacy wasm EH), SOABI `cpython-314-wasm32-wasix`; native side modules (py-numpy, py-scipy, py-pandas, …) load by `dlopen`
+- PIE dynamic-main (`dylink.0`) on wasix-sysroot 2025.9.30-31's `sysroot-ehpic` (legacy wasm EH), SOABI `cpython-314-wasm32-wasix`; native side modules (py-numpy, py-scipy, py-pandas, …) load by `dlopen`
 - **File modes** (3.14.2-12, on slicc-kernel ≥ 1.35.1; older kernels keep the no-op modes): `os.umask`, `open()`/`os.mkdir` create modes, `os.chmod`, `tempfile.mkstemp` 600 / `mkdtemp` 700, pip console scripts 755
 - Built in: `ssl`/`hashlib` (OpenSSL 3.5.9, `@ai-ecoverse/wasix-openssl`), `zlib` 1.3.1, `bz2`, `lzma` (xz 5.8.4), `sqlite3` (3.54.0; FTS5, JSON, math, R*Tree; no WAL, no extensions), `readline` 8.3 (ncurses 6.5 terminfo compiled in: xterm, screen, tmux, vt100, linux), `ctypes` / `_ctypes` (wasix-org/libffi; needs slicc-kernel#306 step 1 for `call_dynamic` + `closure_{allocate,free}`), `mmap`, `fcntl`, `termios`, `resource`, `pwd`, `grp`, `select`
 - No `fork`/`vfork`; `subprocess` via `os.posix_spawn` (`proc_spawn2`/`3`)
 - `os.getuid()`/`getgid()`/`getgroups()` and `pwd`/`grp` come from slicc-kernel's process credentials and its `/etc/passwd`/`/etc/group` (3.14.2-13, wasix-sysroot -20; slicc-kernel ≥ 1.44.0, no fallback: ids are -1 on older kernels). Root is uid 0 with home `/root`.
-- Advisory file locks (`flock`, `fcntl` F_SETLK*, `lockf`) are no-ops (Emscripten parity)
+- Record locks (`fcntl` F_SETLK*, `lockf`) go through slicc-kernel (since -21, below); `flock` is a no-op
 - stdout is line-buffered unless it is a regular file, so output streams and survives crashes
 - `signal.alarm`/`setitimer` and `time.sleep` resuming after a signal (the sysroot's libc patches, `patches/`)
 - Bundled `pip` 25.3; `.pyc` are unchecked-hash
@@ -18,6 +18,49 @@ CPython 3.14 for slicc WASIX (`commands` `python` / `python3`).
 
 Since 3.14.2-12 the package is cross-built from source in CI (`build.sh`); see `THIRD-PARTY-NOTICES.md` for the statically linked libraries.
 
+Since 3.14.2-24 (wasix-sysroot -31):
+
+- `multiprocessing.Manager()` works: `dict`, `list`, `Queue`, `Namespace`,
+  `Value` and the other managed objects, also passed to spawned children,
+  over an AF_UNIX socket. Up to -23 the first proxy call raised
+  `TypeError: str, bytes or bytearray expected, not int`: WASIX's libc
+  returned family 0 and no path from `getsockname`, `getpeername` and
+  `accept` for every AF_UNIX socket (homescoop#515). `socket.getsockname()`
+  of a bound AF_UNIX socket now gives its path, and an unbound one `''`.
+- A Manager is what the -23 error for shared ctypes recommends, so that
+  advice holds now (homescoop#669). The error also names `Barrier`, which
+  keeps its state in shared memory too.
+- From the sysroot: `select.poll` reports `POLLHUP` for a registered fd with
+  no events whose peer closed, and `POLLERR` for a pipe write end whose
+  reader is gone; a process is no longer limited to 256 named semaphores.
+
+Since 3.14.2-23:
+
+- `multiprocessing.connection`'s `Listener` on an AF_UNIX path closes
+  cleanly on every kernel. slicc-kernel before 1.103.1 keeps socket paths out
+  of the filesystem (slicc-kernel#753), so the path it unlinks at close was
+  already gone, and up to -22 `close()` raised `FileNotFoundError` there. `multiprocessing.Manager()` also
+  needs WASIX's libc to return AF_UNIX addresses from `getsockname`, which
+  comes with wasix-sysroot -31 in the next release (homescoop#515).
+- `threading.get_native_id()` and `Thread.native_id` exist (WASIX's thread id;
+  homescoop#587). Up to -22 they were missing or `None`, and
+  `scipy.fft.set_backend`/`skip_backend` raised `AttributeError`.
+- **Shared memory fails loudly instead of silently** (homescoop#516).
+  Processes share no memory here, so nothing written into an `mp.Value`,
+  `mp.Array` (with or without a lock) or `SharedMemory` ever reached another
+  process, and up to -22 nothing said so.
+  - Passing a `Value`, `Array` or other shared ctypes object to a child
+    (`Process` arguments, `Pool` initargs) now raises `NotImplementedError` at
+    `start()`, naming a Queue, a Pipe or a Manager as the alternatives. Inside
+    one process (threads) they work as before.
+  - `multiprocessing.shared_memory` raises `ImportError` on import, as on
+    upstream WASI builds, and `multiprocessing.managers.HAS_SHMEM` is
+    `False`.
+  - `multiprocessing.get_all_start_methods()` is `['spawn']`, and
+    `get_context("fork")`/`("forkserver")` raise `ValueError`. Up to -22 they
+    listed `fork` and `forkserver`, and a fork `Process` failed at `start()`
+    with `AttributeError` (no `os.fork`, homescoop#357).
+
 Since 3.14.2-22 the `sqlite3` module uses SQLite's `unix` VFS, with `fcntl`
 locks, instead of SQLITE_WASI's default `unix-dotfile`, whose `.lock`
 directory no other program saw. Python and the sqlite3 CLI (or another
@@ -36,9 +79,10 @@ Since 3.14.2-21 (wasix-sysroot -30):
 - `multiprocessing` works with the `spawn` start method (the default):
   `Pool`, `Queue`, `Lock`, `Semaphore` and the other synchronisation
   primitives, across processes. Its named semaphores are kept by slicc-kernel
-  (≥ 1.99.0). `shared_memory` and shared ctypes (`Value`/`Array` with
-  `lock=False`) don't work, because processes don't share memory. There is
-  no `fork` start method (no `os.fork`).
+  (≥ 1.99.0). `shared_memory` and shared ctypes (`Value`/`Array`, whatever
+  their `lock`) aren't shared between processes, because processes don't
+  share memory (an error since -23). There is no `fork` start method (no
+  `os.fork`).
 - `fcntl.lockf`/`fcntl.fcntl` record locks and `os.lockf` go through the libc
   to slicc-kernel (slicc-kernel#722) and hold against other processes, such as
   a second python or the sqlite3 CLI on the same database. On an older kernel

package/THIRD-PARTY-NOTICES.md

@@ -13,7 +13,7 @@ bin/python.wasm statically links the components below. The table lists them; eac
 | GNU Readline | 8.3 | GPL-3.0-or-later | gnu.org/software/readline |
 | ncurses (tinfo) | 6.5 | X11 | invisible-island.net/ncurses |
 | libffi | 3.5.1 (wasix-org 09cbf7d + patches/libffi-wasix-varargs.patch) | MIT | github.com/wasix-org/libffi |
-| wasix-libc | wasix-sysroot 2025.9.30-30 | Apache-2.0 WITH LLVM-exception, MIT | @ai-ecoverse/wasix-sysroot |
+| wasix-libc | wasix-sysroot 2025.9.30-31 | Apache-2.0 WITH LLVM-exception, MIT | @ai-ecoverse/wasix-sysroot |
 | libc++, libc++abi, libunwind | wasix-libc v2026-07-03.1 sysroot-ehpic (LLVM 20.1) | Apache-2.0 WITH LLVM-exception | github.com/wasix-org/wasix-libc |
 
 GNU Readline is licensed under the GPL-3.0-or-later and is linked statically, so bin/python.wasm as a whole (a combined work with CPython, whose PSF-2.0 licence is GPL-compatible, and the other components above, all under GPL-compatible licences) is distributed under the terms of the GPL-3.0-or-later; hence the package licence PSF-2.0 AND GPL-3.0-or-later. Redistributors pass on its Corresponding Source: the homescoop repository (https://github.com/ai-ecoverse/homescoop) at the commit this release was built from, plus the sha256-pinned upstream archives and dev packages its recipe.yaml lists, which homescoop keeps available.
@@ -2022,7 +2022,7 @@ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## wasix-libc (@ai-ecoverse/wasix-sysroot 2025.9.30-30; files from tag v2025-09-02.1)
+## wasix-libc (@ai-ecoverse/wasix-sysroot 2025.9.30-31; files from tag v2025-09-02.1)
 
 ```text
 wasi-libc as a whole is multi-licensed under the

package/include/python3.14/pythread.h

@@ -42,7 +42,7 @@ PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void);
 #if (defined(__APPLE__) || defined(__linux__) || defined(_WIN32) \
      || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
      || defined(__OpenBSD__) || defined(__NetBSD__) \
-     || defined(__DragonFly__) || defined(_AIX))
+     || defined(__DragonFly__) || defined(_AIX) || defined(__wasi__))
 #define PY_HAVE_THREAD_NATIVE_ID
 PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void);
 #endif

package/lib/libpython3.14.a

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/lib/libpython3.14.a
-size: 59668280 bytes
-sha256: 48c633745276bc36c59b7b161b9e3e3d58e8fbffd689d466da59bddcb3076ab3
+size: 59670786 bytes
+sha256: c614008b169a505ef753438e52e6e65be14fecfa21454dcea57589d91504a5d5

package/lib/python3.14/multiprocessing/connection.py

@@ -634,7 +634,8 @@ class SocketListener(object):
         if family == 'AF_UNIX' and not util.is_abstract_socket_namespace(address):
             # Linux abstract socket namespaces do not need to be explicitly unlinked
             self._unlink = util.Finalize(
-                self, os.unlink, args=(address,), exitpriority=0
+                self, _unlink_socket if sys.platform == 'wasi' else os.unlink,
+                args=(address,), exitpriority=0
                 )
         else:
             self._unlink = None
@@ -654,6 +655,13 @@ class SocketListener(object):
                 unlink()
 
 
+def _unlink_socket(path):
+    try:
+        os.unlink(path)
+    except FileNotFoundError:
+        pass
+
+
 def SocketClient(address):
     '''
     Return a connection object connected to the socket given by `address`

package/lib/python3.14/multiprocessing/context.py

@@ -319,10 +319,13 @@ if sys.platform != 'win32':
         'spawn': SpawnContext(),
         'forkserver': ForkServerContext(),
     }
+    if sys.platform == 'wasi' and not hasattr(os, 'fork'):
+        del _concrete_contexts['fork'], _concrete_contexts['forkserver']
     # bpo-33725: running arbitrary code after fork() is no longer reliable
     # on macOS since macOS 10.14 (Mojave). Use spawn by default instead.
     # gh-84559: We changed everyones default to a thread safeish one in 3.14.
-    if reduction.HAVE_SEND_HANDLE and sys.platform != 'darwin':
+    if ('forkserver' in _concrete_contexts and reduction.HAVE_SEND_HANDLE
+            and sys.platform != 'darwin'):
         _default_context = DefaultContext(_concrete_contexts['forkserver'])
     else:
         _default_context = DefaultContext(_concrete_contexts['spawn'])

package/lib/python3.14/multiprocessing/heap.py

@@ -98,6 +98,12 @@ else:
             return util.get_temp_dir()
 
     def reduce_arena(a):
+        if sys.platform == 'wasi':
+            raise NotImplementedError(
+                'multiprocessing: Value, Array, Barrier and other objects '
+                'in shared memory cannot be shared with another process on '
+                'WASI, where processes share no memory; use a Queue, a Pipe '
+                'or a Manager')
         if a.fd == -1:
             raise ValueError('Arena is unpicklable because '
                              'forking was enabled when it was created')

package/lib/python3.14/multiprocessing/shared_memory.py

@@ -14,11 +14,16 @@ import os
 import errno
 import struct
 import secrets
+import sys
 import types
 
 if os.name == "nt":
     import _winapi
     _USE_POSIX = False
+elif sys.platform == "wasi":
+    raise ImportError(
+        "multiprocessing.shared_memory is not available on WASI: "
+        "processes share no memory")
 else:
     import _posixshmem
     _USE_POSIX = True

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/wasix-python",
-  "version": "3.14.2-22",
+  "version": "3.14.2-24",
   "description": "CPython 3.14 for slicc WASIX (commands python, python3; cross-built in CI on wasix-sysroot)",
   "license": "PSF-2.0 AND GPL-3.0-or-later",
   "engines": {