a3s-code 8.0.4__tar.gz → 8.2.0__tar.gz

{a3s_code-8.0.4 → a3s_code-8.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: a3s-code
-Version: 8.0.4
+Version: 8.2.0
 Summary: A3S Code Python SDK — pure-Python bootstrap that fetches the native wheel from GitHub Releases
 Author: A3S Lab
 License: MIT
@@ -29,17 +29,23 @@ platform from the project's
 the wheel's sha256 against the release manifest, extracts the compiled
 extension into a per-user cache, and exposes the normal `a3s_code` API.
 
-The v8.0.3 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
+The v8.2.0 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
 platform. That wheel is installable by CPython 3.10, 3.11, 3.12, 3.13, and
-3.14. The published `v8.0.2` assets predate this workflow and still use exact
-CPython 3.10–3.13 wheel names; upgrade the bootstrap to v8.0.3 for Python
-3.14. The loader falls back to the exact per-minor names used by older
-releases, so upgrading the bootstrap does not invalidate an older release
-asset.
+3.14. Supported native targets are macOS arm64/x86_64, Linux glibc 2.28+
+arm64/x86_64, and Windows arm64/x86_64. Every supported wheel contains its
+target Moli sidecar and provenance record. Linux musl is intentionally omitted
+because upstream Moli publishes no musl asset; use a system/explicit browser
+or another backend there. The loader still falls back to exact per-minor names
+when reading older release manifests.
 
 Subsequent imports use the cached extension. Cache lives under a
 platform-specific directory, `~/.cache/a3s-code/<version>/<platform-tag>/`
 (or `$A3S_CODE_CACHE_DIR/<version>/<platform-tag>/` when overridden).
+The extracted Moli executable is placed in the same version/target cache and
+is selected through `A3S_CODE_MOLI_EXECUTABLE`; atomic extraction and the
+bootstrap's cross-process installer lock make concurrent first imports
+single-flight. Rust, Node.js, and Go use the Core-managed Moli cache when they
+are not using a package-local sidecar.
 
 ## Why
 
@@ -53,8 +59,8 @@ through PyPI.
 
 - macOS arm64 (Apple Silicon, macOS 11+)
 - macOS x86_64 (Intel, macOS 12+)
-- Linux x86_64 (glibc 2.28+)
-- Windows x86_64
+- Linux x86_64 and arm64 (glibc 2.28+)
+- Windows x86_64 and arm64
 
 CPython 3.10, 3.11, 3.12, 3.13, and 3.14.
 
@@ -74,6 +80,9 @@ python3.14 -m pip install a3s-code
 | `A3S_CODE_CACHE_DIR` | Cache root (defaults to `$XDG_CACHE_HOME/a3s-code` or `~/.cache/a3s-code`) |
 | `A3S_CODE_RELEASES_BASE_URL` | Override the release base URL — useful for air-gapped mirrors |
 | `A3S_CODE_SKIP_HASH_CHECK` | `1` skips sha256 verification (do not use in production) |
+| `A3S_CODE_MOLI_EXECUTABLE` | Explicit verified Moli executable; skips package discovery |
+| `A3S_CODE_MOLI_CACHE_DIR` | Core-managed shared Moli cache root (the bootstrap uses its version/target cache for a bundled sidecar) |
+| `A3S_CODE_MOLI_RELEASE_BASE_URL` | HTTPS mirror for the pinned Moli release |
 
 ## Manual install
 

{a3s_code-8.0.4 → a3s_code-8.2.0}/README.md

@@ -7,17 +7,23 @@ platform from the project's
 the wheel's sha256 against the release manifest, extracts the compiled
 extension into a per-user cache, and exposes the normal `a3s_code` API.
 
-The v8.0.3 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
+The v8.2.0 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
 platform. That wheel is installable by CPython 3.10, 3.11, 3.12, 3.13, and
-3.14. The published `v8.0.2` assets predate this workflow and still use exact
-CPython 3.10–3.13 wheel names; upgrade the bootstrap to v8.0.3 for Python
-3.14. The loader falls back to the exact per-minor names used by older
-releases, so upgrading the bootstrap does not invalidate an older release
-asset.
+3.14. Supported native targets are macOS arm64/x86_64, Linux glibc 2.28+
+arm64/x86_64, and Windows arm64/x86_64. Every supported wheel contains its
+target Moli sidecar and provenance record. Linux musl is intentionally omitted
+because upstream Moli publishes no musl asset; use a system/explicit browser
+or another backend there. The loader still falls back to exact per-minor names
+when reading older release manifests.
 
 Subsequent imports use the cached extension. Cache lives under a
 platform-specific directory, `~/.cache/a3s-code/<version>/<platform-tag>/`
 (or `$A3S_CODE_CACHE_DIR/<version>/<platform-tag>/` when overridden).
+The extracted Moli executable is placed in the same version/target cache and
+is selected through `A3S_CODE_MOLI_EXECUTABLE`; atomic extraction and the
+bootstrap's cross-process installer lock make concurrent first imports
+single-flight. Rust, Node.js, and Go use the Core-managed Moli cache when they
+are not using a package-local sidecar.
 
 ## Why
 
@@ -31,8 +37,8 @@ through PyPI.
 
 - macOS arm64 (Apple Silicon, macOS 11+)
 - macOS x86_64 (Intel, macOS 12+)
-- Linux x86_64 (glibc 2.28+)
-- Windows x86_64
+- Linux x86_64 and arm64 (glibc 2.28+)
+- Windows x86_64 and arm64
 
 CPython 3.10, 3.11, 3.12, 3.13, and 3.14.
 
@@ -52,6 +58,9 @@ python3.14 -m pip install a3s-code
 | `A3S_CODE_CACHE_DIR` | Cache root (defaults to `$XDG_CACHE_HOME/a3s-code` or `~/.cache/a3s-code`) |
 | `A3S_CODE_RELEASES_BASE_URL` | Override the release base URL — useful for air-gapped mirrors |
 | `A3S_CODE_SKIP_HASH_CHECK` | `1` skips sha256 verification (do not use in production) |
+| `A3S_CODE_MOLI_EXECUTABLE` | Explicit verified Moli executable; skips package discovery |
+| `A3S_CODE_MOLI_CACHE_DIR` | Core-managed shared Moli cache root (the bootstrap uses its version/target cache for a bundled sidecar) |
+| `A3S_CODE_MOLI_RELEASE_BASE_URL` | HTTPS mirror for the pinned Moli release |
 
 ## Manual install
 

{a3s_code-8.0.4 → a3s_code-8.2.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "a3s-code"
 # Keep in sync with crates/code core release. The bootstrap loader fetches
 # the matching native wheel from `https://github.com/A3S-Lab/Code/releases/tag/v<version>`
 # at import time.
-version = "8.0.4"
+version = "8.2.0"
 description = "A3S Code Python SDK — pure-Python bootstrap that fetches the native wheel from GitHub Releases"
 readme = "README.md"
 license = {text = "MIT"}

{a3s_code-8.0.4 → a3s_code-8.2.0}/src/a3s_code/_bootstrap.py

@@ -6,7 +6,9 @@ wheel for the current platform, downloads it from the project's GitHub
 Releases, verifies the wheel's sha256 against the
 release manifest, extracts the compiled `_native` extension into a
 per-user cache, and registers it explicitly as `a3s_code._native` because it
-lives outside the installed package directory.
+lives outside the installed package directory. A cross-process advisory lock
+keeps the first download and sidecar extraction single-flight for applications
+sharing that cache.
 
 Override the cache location via `A3S_CODE_CACHE_DIR`. Override the
 release source via `A3S_CODE_RELEASES_BASE_URL` (default points at the
@@ -16,28 +18,36 @@ GitHub Releases page for `A3S-Lab/Code`). Skip the integrity check via
 
 from __future__ import annotations
 
+import errno
 import hashlib
 import io
 import json
 import os
 import platform
+import stat
 import sys
 import threading
+import time
 import urllib.error
 import urllib.request
 import zipfile
+from contextlib import contextmanager
 from pathlib import Path
-from typing import Optional
+from typing import Iterator, Optional
 
 # Version is the bootstrap's own version, which equals the matching native
 # wheel version on GH Releases. Bumped by the release workflow.
-__version__ = "8.0.4"
+__version__ = "8.2.0"
 
 _DEFAULT_BASE_URL = "https://github.com/A3S-Lab/Code/releases/download"
 _REQUEST_TIMEOUT_S = 120
 _USER_AGENT = f"a3s-code-bootstrap/{__version__}"
 _MIN_PYTHON = (3, 10)
+_MAX_WHEEL_BYTES = 512 * 1024 * 1024
+_MAX_MEMBER_BYTES = 256 * 1024 * 1024
 _ABI3_PYTHON_TAG = "cp310-abi3"
+_INSTALL_LOCK_TIMEOUT_S = _REQUEST_TIMEOUT_S + 30
+_INSTALL_LOCK_POLL_S = 0.05
 _LOAD_LOCK = threading.Lock()
 _LOADED = False
 
@@ -55,6 +65,91 @@ class BootstrapHttpError(BootstrapError):
         super().__init__(f"GET {url} failed: HTTP {status_code}")
 
 
+def _lock_contention(error: OSError) -> bool:
+    """Return whether an advisory-lock failure means another process owns it."""
+
+    # POSIX flock reports EACCES/EAGAIN. Windows msvcrt.locking commonly uses
+    # errno 13 (permission denied) for the same contention condition.
+    return isinstance(error, BlockingIOError) or getattr(error, "errno", None) in {
+        errno.EAGAIN,
+        errno.EACCES,  # Windows sharing violation uses the same value
+        35,  # EAGAIN on macOS
+        36,  # EAGAIN on some BSDs
+    }
+
+
+@contextmanager
+def _install_lock(
+    cache_dir: Path, timeout_s: float = _INSTALL_LOCK_TIMEOUT_S
+) -> Iterator[None]:
+    """Acquire a cross-process lock for native wheel and Moli extraction.
+
+    The lock is advisory and released by the operating system if a bootstrap
+    process exits unexpectedly. Keeping it in the same platform/version cache
+    means independent Python applications perform one download and one atomic
+    extraction, while the in-process ``_LOAD_LOCK`` still protects module
+    registration.
+    """
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    lock_path = cache_dir / ".install.lock"
+    try:
+        handle = lock_path.open("a+b")
+    except OSError as exc:
+        raise BootstrapError(f"could not open bootstrap install lock {lock_path}: {exc}") from exc
+
+    locked = False
+    try:
+        # Windows locking operates on a byte range and requires at least one
+        # byte in the file. The write is harmless on POSIX and races are safe.
+        handle.seek(0, os.SEEK_END)
+        if handle.tell() == 0:
+            handle.write(b"\0")
+            handle.flush()
+        deadline = time.monotonic() + timeout_s
+        while True:
+            try:
+                handle.seek(0)
+                if os.name == "nt":
+                    import msvcrt
+
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+                else:
+                    import fcntl
+
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                locked = True
+                break
+            except OSError as exc:
+                if not _lock_contention(exc):
+                    raise BootstrapError(
+                        f"could not acquire bootstrap install lock {lock_path}: {exc}"
+                    ) from exc
+                if time.monotonic() >= deadline:
+                    raise BootstrapError(
+                        f"timed out waiting for bootstrap install lock {lock_path}"
+                    ) from exc
+                time.sleep(_INSTALL_LOCK_POLL_S)
+        yield
+    finally:
+        if locked:
+            try:
+                handle.seek(0)
+                if os.name == "nt":
+                    import msvcrt
+
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+                else:
+                    import fcntl
+
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            except OSError:
+                # Closing the descriptor also releases the advisory lock. Do
+                # not hide the caller's extraction/import exception here.
+                pass
+        handle.close()
+
+
 def _base_url() -> str:
     return os.environ.get("A3S_CODE_RELEASES_BASE_URL", _DEFAULT_BASE_URL).rstrip("/")
 
@@ -95,13 +190,17 @@ def _platform_tag() -> str:
     elif sys_plat == "linux":
         if machine in ("x86_64", "amd64"):
             return "manylinux_2_28_x86_64"
+        if machine in ("arm64", "aarch64"):
+            return "manylinux_2_28_aarch64"
     elif sys_plat == "win32":
         if machine in ("amd64", "x86_64"):
             return "win_amd64"
+        if machine in ("arm64", "aarch64"):
+            return "win_arm64"
     raise BootstrapError(
         f"a3s-code: no native wheel published for {sys_plat}/{machine}. "
         "Supported platforms: macOS arm64 (11+), macOS Intel (12+), "
-        "Linux x86_64 (glibc 2.28+), Windows x86_64."
+        "Linux x86_64/arm64 (glibc 2.28+), Windows x86_64/arm64."
     )
 
 
@@ -207,24 +306,117 @@ def _download_wheel(version: str) -> tuple[str, bytes]:
     )
 
 
+def _safe_wheel_member(name: str) -> tuple[str, ...]:
+    """Validate and split a wheel member before reading it.
+
+    Wheels are ZIP files supplied by a remote release.  Do not allow an
+    archive entry to escape the cache through absolute paths, parent
+    components, or Windows separators (which are accepted by some extraction
+    tools even on POSIX).
+    """
+    if not name or "\\" in name or name.startswith("/"):
+        raise BootstrapError(f"downloaded wheel contains an unsafe member path: {name!r}")
+    parts = tuple(part for part in name.split("/") if part)
+    if not parts or any(part in {".", ".."} for part in parts):
+        raise BootstrapError(f"downloaded wheel contains an unsafe member path: {name!r}")
+    return parts
+
+
+def _write_wheel_member(zf: zipfile.ZipFile, info: zipfile.ZipInfo, destination: Path) -> None:
+    """Write one regular, bounded wheel member atomically."""
+    mode = (info.external_attr >> 16) & 0o170000
+    if mode == stat.S_IFLNK:
+        raise BootstrapError(f"downloaded wheel contains a symlink member: {info.filename!r}")
+    if info.is_dir() or info.file_size > _MAX_MEMBER_BYTES:
+        raise BootstrapError(f"downloaded wheel member is too large or not a file: {info.filename!r}")
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.part-{os.getpid()}-{threading.get_ident()}")
+    try:
+        with zf.open(info) as source, temporary.open("xb") as target:
+            remaining = _MAX_MEMBER_BYTES + 1
+            while remaining:
+                chunk = source.read(min(1024 * 1024, remaining))
+                if not chunk:
+                    break
+                target.write(chunk)
+                remaining -= len(chunk)
+            if remaining == 0:
+                raise BootstrapError(f"downloaded wheel member is too large: {info.filename!r}")
+            target.flush()
+            os.fsync(target.fileno())
+        os.replace(temporary, destination)
+    finally:
+        try:
+            temporary.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def _configure_cached_moli(cache_dir: Path) -> None:
+    """Expose a wheel-bundled Moli executable to the Rust core.
+
+    The bootstrap package and the native wheel are separate distributions.
+    Without copying this sidecar into the bootstrap cache, a normal
+    ``pip install a3s-code`` would silently discard the bundled browser and
+    force every process to download it again.  An operator-supplied override
+    always wins.
+    """
+    if os.environ.get("A3S_CODE_MOLI_EXECUTABLE"):
+        return
+    executable = "moli.exe" if os.name == "nt" else "moli"
+    candidate = cache_dir / "moli" / executable
+    try:
+        if candidate.is_file() and (os.name == "nt" or os.access(candidate, os.X_OK)):
+            os.environ["A3S_CODE_MOLI_EXECUTABLE"] = str(candidate)
+            os.environ.setdefault("A3S_CODE_MOLI_DIR", str(candidate.parent))
+    except OSError:
+        return
+
+
 def _extract_native(wheel_bytes: bytes, target_dir: Path) -> Path:
-    """Extract the compiled `_native.*` extension from `wheel_bytes` into
-    `target_dir`. Returns the path to the extracted file.
+    """Extract the native extension and bundled Moli sidecar.
+
+    Returns the path to the extracted extension.  The sidecar is placed under
+    ``target_dir/moli`` and is selected by :func:`_configure_cached_moli`.
     """
+    if len(wheel_bytes) > _MAX_WHEEL_BYTES:
+        raise BootstrapError("downloaded wheel exceeds the bootstrap size limit")
     target_dir.mkdir(parents=True, exist_ok=True)
+    native_path: Optional[Path] = None
+    moli_path: Optional[Path] = None
     with zipfile.ZipFile(io.BytesIO(wheel_bytes)) as zf:
-        for name in zf.namelist():
-            base = Path(name).name
-            # match _native.<abi>.{so,pyd,dylib}
+        for info in zf.infolist():
+            parts = _safe_wheel_member(info.filename)
+            base = parts[-1]
+            # Match _native.<abi>.{so,pyd,dylib}; ignore metadata files.
             if base.startswith("_native.") and not base.endswith(".dist-info"):
-                out_path = target_dir / base
-                with zf.open(name) as src, out_path.open("wb") as dst:
-                    dst.write(src.read())
-                return out_path
-    raise BootstrapError(
-        "downloaded wheel did not contain a _native extension; "
-        "the release artifact appears to be corrupt"
-    )
+                if native_path is not None:
+                    raise BootstrapError("downloaded wheel contains multiple native extensions")
+                native_path = target_dir / base
+                _write_wheel_member(zf, info, native_path)
+                continue
+
+            # Maturin places the packaged browser under a3s_code/moli/. Keep
+            # the match strict so an unrelated file named `moli` is not run.
+            if base in {"moli", "moli.exe"} and len(parts) >= 3 and parts[-3:-1] == ("a3s_code", "moli"):
+                if moli_path is not None:
+                    raise BootstrapError("downloaded wheel contains multiple Moli executables")
+                moli_path = target_dir / "moli" / base
+                _write_wheel_member(zf, info, moli_path)
+
+    if native_path is None:
+        raise BootstrapError(
+            "downloaded wheel did not contain a _native extension; "
+            "the release artifact appears to be corrupt"
+        )
+    if moli_path is not None and os.name != "nt":
+        try:
+            moli_path.chmod(0o755)
+        except OSError as exc:
+            raise BootstrapError(f"could not mark bundled Moli executable: {exc}") from exc
+    _configure_cached_moli(target_dir)
+    return native_path
 
 
 def _find_cached_native(cache_dir: Path) -> Optional[Path]:
@@ -288,24 +480,35 @@ def ensure_native_loaded(version: str = __version__) -> Path:
 
         native = _find_cached_native(cache)
         if native is None:
-            wheel_name, wheel_bytes = _download_wheel(version)
-            url = _release_url(wheel_name, version)
-            sys.stderr.write(
-                f"a3s-code: fetching native wheel {wheel_name} "
-                f"from {url} (first import only)...\n"
-            )
-
-            if os.environ.get("A3S_CODE_SKIP_HASH_CHECK") != "1":
-                expected = _expected_sha256(wheel_name, version)
-                if expected is not None:
-                    actual = hashlib.sha256(wheel_bytes).hexdigest()
-                    if actual != expected:
-                        raise BootstrapError(
-                            f"sha256 mismatch for {wheel_name}: "
-                            f"expected {expected}, got {actual}"
-                        )
-
-            native = _extract_native(wheel_bytes, cache)
+            # Re-check after taking the process lock: another independent
+            # Python application may have completed the download while this
+            # process was starting. This keeps both the extension and bundled
+            # Moli sidecar single-flight across processes.
+            with _install_lock(cache):
+                native = _find_cached_native(cache)
+                if native is None:
+                    wheel_name, wheel_bytes = _download_wheel(version)
+                    url = _release_url(wheel_name, version)
+                    sys.stderr.write(
+                        f"a3s-code: fetching native wheel {wheel_name} "
+                        f"from {url} (first import only)...\n"
+                    )
+
+                    if os.environ.get("A3S_CODE_SKIP_HASH_CHECK") != "1":
+                        expected = _expected_sha256(wheel_name, version)
+                        if expected is not None:
+                            actual = hashlib.sha256(wheel_bytes).hexdigest()
+                            if actual != expected:
+                                raise BootstrapError(
+                                    f"sha256 mismatch for {wheel_name}: "
+                                    f"expected {expected}, got {actual}"
+                                )
+
+                    native = _extract_native(wheel_bytes, cache)
+                else:
+                    _configure_cached_moli(cache)
+        else:
+            _configure_cached_moli(cache)
 
         _register_native(native)
         _LOADED = True

{a3s_code-8.0.4 → a3s_code-8.2.0}/src/a3s_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: a3s-code
-Version: 8.0.4
+Version: 8.2.0
 Summary: A3S Code Python SDK — pure-Python bootstrap that fetches the native wheel from GitHub Releases
 Author: A3S Lab
 License: MIT
@@ -29,17 +29,23 @@ platform from the project's
 the wheel's sha256 against the release manifest, extracts the compiled
 extension into a per-user cache, and exposes the normal `a3s_code` API.
 
-The v8.0.3 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
+The v8.2.0 release uses one CPython 3.10 stable-ABI (`cp310-abi3`) wheel per
 platform. That wheel is installable by CPython 3.10, 3.11, 3.12, 3.13, and
-3.14. The published `v8.0.2` assets predate this workflow and still use exact
-CPython 3.10–3.13 wheel names; upgrade the bootstrap to v8.0.3 for Python
-3.14. The loader falls back to the exact per-minor names used by older
-releases, so upgrading the bootstrap does not invalidate an older release
-asset.
+3.14. Supported native targets are macOS arm64/x86_64, Linux glibc 2.28+
+arm64/x86_64, and Windows arm64/x86_64. Every supported wheel contains its
+target Moli sidecar and provenance record. Linux musl is intentionally omitted
+because upstream Moli publishes no musl asset; use a system/explicit browser
+or another backend there. The loader still falls back to exact per-minor names
+when reading older release manifests.
 
 Subsequent imports use the cached extension. Cache lives under a
 platform-specific directory, `~/.cache/a3s-code/<version>/<platform-tag>/`
 (or `$A3S_CODE_CACHE_DIR/<version>/<platform-tag>/` when overridden).
+The extracted Moli executable is placed in the same version/target cache and
+is selected through `A3S_CODE_MOLI_EXECUTABLE`; atomic extraction and the
+bootstrap's cross-process installer lock make concurrent first imports
+single-flight. Rust, Node.js, and Go use the Core-managed Moli cache when they
+are not using a package-local sidecar.
 
 ## Why
 
@@ -53,8 +59,8 @@ through PyPI.
 
 - macOS arm64 (Apple Silicon, macOS 11+)
 - macOS x86_64 (Intel, macOS 12+)
-- Linux x86_64 (glibc 2.28+)
-- Windows x86_64
+- Linux x86_64 and arm64 (glibc 2.28+)
+- Windows x86_64 and arm64
 
 CPython 3.10, 3.11, 3.12, 3.13, and 3.14.
 
@@ -74,6 +80,9 @@ python3.14 -m pip install a3s-code
 | `A3S_CODE_CACHE_DIR` | Cache root (defaults to `$XDG_CACHE_HOME/a3s-code` or `~/.cache/a3s-code`) |
 | `A3S_CODE_RELEASES_BASE_URL` | Override the release base URL — useful for air-gapped mirrors |
 | `A3S_CODE_SKIP_HASH_CHECK` | `1` skips sha256 verification (do not use in production) |
+| `A3S_CODE_MOLI_EXECUTABLE` | Explicit verified Moli executable; skips package discovery |
+| `A3S_CODE_MOLI_CACHE_DIR` | Core-managed shared Moli cache root (the bootstrap uses its version/target cache for a bundled sidecar) |
+| `A3S_CODE_MOLI_RELEASE_BASE_URL` | HTTPS mirror for the pinned Moli release |
 
 ## Manual install
 

{a3s_code-8.0.4 → a3s_code-8.2.0}/tests/test_bootstrap.py

@@ -13,8 +13,10 @@ import io
 import json
 import os
 import shutil
+import subprocess
 import sys
 import tempfile
+import time
 import unittest
 import unittest.mock as mock
 import zipfile
@@ -32,12 +34,16 @@ _bootstrap = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_bootstrap)
 
 
-def _make_wheel(native_blob: bytes = b"fake-extension-blob") -> bytes:
-    """Build a minimal in-memory wheel containing _native.something.so."""
+def _make_wheel(
+    native_blob: bytes = b"fake-extension-blob", *, include_moli: bool = False
+) -> bytes:
+    """Build a minimal in-memory wheel containing a native extension."""
     buf = io.BytesIO()
     with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
         zf.writestr("a3s_code/__init__.py", "from ._native import *\n")
         zf.writestr("a3s_code/_native.cpython-312-x86_64-linux-gnu.so", native_blob)
+        if include_moli:
+            zf.writestr("a3s_code/moli/moli", b"#!/bin/sh\nexit 0\n")
         zf.writestr("a3s_code-3.2.1.dist-info/METADATA", "Metadata-Version: 2.1\n")
         zf.writestr("a3s_code-3.2.1.dist-info/WHEEL", "Wheel-Version: 1.0\n")
     return buf.getvalue()
@@ -69,6 +75,12 @@ class WheelFilenameTests(unittest.TestCase):
             "a3s_code-3.2.1-cp312-cp312-manylinux_2_28_x86_64.whl",
         )
 
+    def test_linux_arm64_cp312(self):
+        self.assertEqual(
+            self._filename_for("linux", "aarch64", 12),
+            "a3s_code-3.2.1-cp312-cp312-manylinux_2_28_aarch64.whl",
+        )
+
     def test_macos_arm64_cp311(self):
         self.assertEqual(
             self._filename_for("darwin", "arm64", 11),
@@ -136,6 +148,12 @@ class WheelFilenameTests(unittest.TestCase):
             "a3s_code-3.2.1-cp313-cp313-win_amd64.whl",
         )
 
+    def test_windows_arm64_cp313(self):
+        self.assertEqual(
+            self._filename_for("win32", "ARM64", 13),
+            "a3s_code-3.2.1-cp313-cp313-win_arm64.whl",
+        )
+
     def test_unsupported_platform_raises(self):
         with self.assertRaises(_bootstrap.BootstrapError) as cm:
             self._filename_for("freebsd", "x86_64", 12)
@@ -190,6 +208,56 @@ class CacheDirTests(unittest.TestCase):
         )
 
 
+class InstallLockTests(unittest.TestCase):
+    def test_lock_releases_for_another_import(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            cache = Path(tmp) / "cache"
+            with _bootstrap._install_lock(cache):
+                self.assertTrue((cache / ".install.lock").is_file())
+            # A normal close must release the advisory lock, not merely leave
+            # an apparently reusable lock file behind.
+            with _bootstrap._install_lock(cache, timeout_s=0.2):
+                self.assertTrue((cache / ".install.lock").is_file())
+
+    def test_lock_serializes_independent_processes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            cache = Path(tmp) / "cache"
+            ready = Path(tmp) / "ready"
+            module_path = str(_BOOTSTRAP_PATH)
+            child_code = """
+import importlib.util
+import pathlib
+import sys
+import time
+
+module_path, cache_path, ready_path = sys.argv[1:]
+spec = importlib.util.spec_from_file_location('_bootstrap_child', module_path)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+with module._install_lock(pathlib.Path(cache_path)):
+    pathlib.Path(ready_path).write_text('ready', encoding='utf-8')
+    time.sleep(0.35)
+"""
+            child = subprocess.Popen(
+                [sys.executable, "-c", child_code, module_path, str(cache), str(ready)],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            try:
+                deadline = time.monotonic() + 5
+                while not ready.exists() and time.monotonic() < deadline:
+                    time.sleep(0.01)
+                self.assertTrue(ready.exists(), "child did not acquire install lock")
+                started = time.monotonic()
+                with _bootstrap._install_lock(cache, timeout_s=2):
+                    waited = time.monotonic() - started
+                self.assertGreaterEqual(waited, 0.25)
+            finally:
+                stdout, stderr = child.communicate(timeout=5)
+                if child.returncode != 0:
+                    self.fail(f"lock child failed: {stdout}\n{stderr}")
+
 class ExtractNativeTests(unittest.TestCase):
     def test_extracts_native_extension(self):
         wheel_bytes = _make_wheel(b"native-bytes")
@@ -200,6 +268,27 @@ class ExtractNativeTests(unittest.TestCase):
             self.assertTrue(out.name.startswith("_native."))
             self.assertEqual(out.read_bytes(), b"native-bytes")
 
+    def test_extracts_and_configures_bundled_moli_sidecar(self):
+        wheel_bytes = _make_wheel(include_moli=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            target = Path(tmp) / "a3s_code"
+            with mock.patch.dict(os.environ, {}, clear=False):
+                os.environ.pop("A3S_CODE_MOLI_EXECUTABLE", None)
+                _bootstrap._extract_native(wheel_bytes, target)
+                moli = target / "moli" / "moli"
+                self.assertTrue(moli.is_file())
+                self.assertEqual(os.environ.get("A3S_CODE_MOLI_EXECUTABLE"), str(moli))
+                self.assertTrue(os.access(moli, os.X_OK))
+
+    def test_rejects_unsafe_wheel_member(self):
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w") as zf:
+            zf.writestr("../escape", b"bad")
+            zf.writestr("a3s_code/_native.so", b"native")
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(_bootstrap.BootstrapError):
+                _bootstrap._extract_native(buf.getvalue(), Path(tmp) / "pkg")
+
     def test_wheel_without_native_raises(self):
         buf = io.BytesIO()
         with zipfile.ZipFile(buf, "w") as zf: