ghc-compiler-python 9.4.8__py3-none-any.whl

ghc_compiler_python/__init__.py

@@ -0,0 +1,13 @@
+"""ghc-compiler-python: Native GHC and Cabal packaged as a Python Wheel."""
+
+__version__ = "9.4.8"
+__ghc_version__ = "9.4.8"
+__cabal_version__ = "3.10.3.0"
+__author__ = "ghc-compiler-python contributors"
+__license__ = "MIT"
+
+__all__ = [
+    "__version__",
+    "__ghc_version__",
+    "__cabal_version__",
+]

ghc_compiler_python/bootstrap.py

@@ -0,0 +1,417 @@
+# ghc_compiler_python/bootstrap.py
+"""
+First-run acquisition of the native GHC/Cabal payload.
+
+This package ships in two tiers:
+
+  * **thin**   — the PyPI wheel (``py3-none-any``). Pure Python; the native
+    toolchain is absent and is fetched from GitHub Releases on first use.
+  * **offline** — the platform-tagged wheels published on GitHub Releases.
+    The toolchain is bundled; this module is never invoked.
+
+The tier is not recorded anywhere: it is *observed*. If a bundled toolchain is
+present the wrapper uses it, otherwise it asks this module for a payload root.
+
+Design constraints, in order of precedence:
+
+  1. Never half-install. Download, hash-verify, and extract happen out of line
+     and are promoted into place with a single atomic rename. A cache directory
+     that exists is a cache directory that is complete.
+  2. Never silently substitute. A payload whose SHA-256 does not match the
+     manifest shipped in this wheel is a hard failure, not a warning.
+  3. Never leave the user guessing. Failures name the offline wheel that would
+     have made the network unnecessary.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import sys
+import tarfile
+import tempfile
+import time
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import NoReturn, Optional
+
+GHC_VERSION = "9.4.8"
+
+#: Release assets are addressed by tag, so a wheel always fetches the payload
+#: built alongside it rather than whatever happens to be newest.
+_RELEASE_BASE = (
+    "https://github.com/Saimonokuma/GHC-COMPILER-PYTHON/releases/download"
+    f"/v{GHC_VERSION}"
+)
+
+_HASH_MANIFEST = Path(__file__).resolve().parent / "payload_hashes.json"
+
+_ENV_HOME = "GHC_COMPILER_PYTHON_HOME"
+_ENV_OFFLINE = "GHC_COMPILER_PYTHON_OFFLINE"
+
+_DOWNLOAD_TIMEOUT = 60
+_LOCK_TIMEOUT = 900
+_CHUNK = 1 << 20
+
+
+class BootstrapError(RuntimeError):
+    """Raised when the native payload cannot be made available."""
+
+
+def _die(msg: str) -> NoReturn:
+    raise BootstrapError(msg)
+
+
+# --------------------------------------------------------------------------
+# platform identity
+# --------------------------------------------------------------------------
+
+def platform_tag() -> str:
+    """Return the payload tag for the running interpreter.
+
+    These strings are the *payload* identifiers and deliberately mirror the
+    wheel platform tags used for the offline tier, so a user who hits a network
+    failure can map the error message straight onto a release asset.
+    """
+    machine = (os.uname().machine if hasattr(os, "uname") else os.environ.get(
+        "PROCESSOR_ARCHITECTURE", "AMD64")).lower()
+
+    if sys.platform.startswith("linux"):
+        if machine in ("x86_64", "amd64"):
+            return "manylinux_2_39_x86_64"
+        if machine in ("aarch64", "arm64"):
+            return "manylinux_2_39_aarch64"
+    elif sys.platform == "darwin":
+        if machine in ("arm64", "aarch64"):
+            return "macosx_11_0_arm64"
+        if machine == "x86_64":
+            return "macosx_10_9_x86_64"
+    elif sys.platform == "win32":
+        if machine in ("amd64", "x86_64"):
+            return "win_amd64"
+
+    _die(
+        f"Unsupported platform: {sys.platform}/{machine}. "
+        f"GHC {GHC_VERSION} payloads are published for Linux x86_64, "
+        "macOS arm64/x86_64 and Windows x86_64."
+    )
+
+
+def _archive_suffix() -> str:
+    # Windows runners produce a zip; the Unix payloads are xz tarballs.
+    return ".zip" if sys.platform == "win32" else ".tar.xz"
+
+
+def payload_name() -> str:
+    return f"ghc-payload-{GHC_VERSION}-{platform_tag()}{_archive_suffix()}"
+
+
+def payload_url() -> str:
+    return f"{_RELEASE_BASE}/{payload_name()}"
+
+
+# --------------------------------------------------------------------------
+# cache location
+# --------------------------------------------------------------------------
+
+def cache_root() -> Path:
+    """Directory holding extracted payloads, one subdirectory per version.
+
+    ``GHC_COMPILER_PYTHON_HOME`` overrides the default for users who cannot
+    write to the standard location (CI images, locked-down hosts, or anyone who
+    simply wants the toolchain on a different volume).
+    """
+    override = os.environ.get(_ENV_HOME)
+    if override:
+        return Path(override).expanduser().resolve()
+
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
+        return Path(base) / "ghc-compiler-python" / "Cache"
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Caches" / "ghc-compiler-python"
+
+    xdg = os.environ.get("XDG_CACHE_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".cache"
+    return base / "ghc-compiler-python"
+
+
+def payload_root() -> Path:
+    """Where this version's toolchain lives once installed."""
+    return cache_root() / GHC_VERSION / platform_tag()
+
+
+def is_installed() -> bool:
+    """True when a complete payload is present.
+
+    Completion is signalled by a stamp written *after* the atomic rename, so a
+    directory that exists without a stamp is treated as absent and replaced.
+    """
+    return (payload_root() / ".complete").is_file()
+
+
+# --------------------------------------------------------------------------
+# integrity
+# --------------------------------------------------------------------------
+
+def _expected_digest() -> str:
+    if not _HASH_MANIFEST.is_file():
+        _die(
+            "Payload hash manifest is missing from the installed package "
+            f"({_HASH_MANIFEST}). This wheel was built incorrectly; reinstall "
+            "from PyPI or use an offline wheel from the releases page."
+        )
+    try:
+        manifest = json.loads(_HASH_MANIFEST.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        _die(f"Payload hash manifest is unreadable: {exc}")
+
+    digest = manifest.get(payload_name())
+    if not digest:
+        _die(
+            f"No SHA-256 recorded for {payload_name()} in the hash manifest. "
+            "This platform was not published for this version."
+        )
+    return str(digest).lower()
+
+
+def _digest_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        for block in iter(lambda: fh.read(_CHUNK), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+# --------------------------------------------------------------------------
+# acquisition
+# --------------------------------------------------------------------------
+
+def _offline_hint() -> str:
+    return (
+        "If this machine has no network access, install the self-contained "
+        "wheel instead — it bundles the toolchain and never downloads:\n"
+        f"    {_RELEASE_BASE}/"
+        f"ghc_compiler_python-{GHC_VERSION}-py3-none-{platform_tag()}.whl"
+    )
+
+
+def _download(url: str, dest: Path, quiet: bool) -> None:
+    if not quiet:
+        sys.stderr.write(f"Fetching GHC {GHC_VERSION} payload ({platform_tag()})\n")
+        sys.stderr.write(f"  from {url}\n")
+
+    request = urllib.request.Request(
+        url, headers={"User-Agent": f"ghc-compiler-python/{GHC_VERSION}"}
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=_DOWNLOAD_TIMEOUT) as response:
+            total = int(response.headers.get("Content-Length") or 0)
+            seen = 0
+            last = 0.0
+            with dest.open("wb") as out:
+                while True:
+                    chunk = response.read(_CHUNK)
+                    if not chunk:
+                        break
+                    out.write(chunk)
+                    seen += len(chunk)
+                    now = time.monotonic()
+                    if not quiet and total and now - last > 0.5:
+                        last = now
+                        pct = seen * 100 // total
+                        sys.stderr.write(
+                            f"\r  {pct:3d}%  {seen >> 20} / {total >> 20} MiB"
+                        )
+                        sys.stderr.flush()
+            if not quiet and total:
+                sys.stderr.write("\r  100%  done                    \n")
+    except urllib.error.HTTPError as exc:
+        _die(
+            f"Download failed with HTTP {exc.code} for {url}\n"
+            f"{_offline_hint()}"
+        )
+    except (urllib.error.URLError, OSError, TimeoutError) as exc:
+        _die(f"Download failed: {exc}\n{_offline_hint()}")
+
+
+def _is_within(base: Path, target: Path) -> bool:
+    try:
+        target.resolve().relative_to(base.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def _extract(archive: Path, dest: Path) -> None:
+    """Extract the payload, refusing entries that escape the destination.
+
+    Release assets are our own, but an archive member is still untrusted input:
+    a traversal entry would write outside the cache. Python 3.12 grew a
+    ``filter`` argument for exactly this; older interpreters are checked by hand
+    so the guarantee does not depend on the runtime version.
+    """
+    dest.mkdir(parents=True, exist_ok=True)
+
+    if archive.suffix == ".zip":
+        with zipfile.ZipFile(archive) as zf:
+            for member in zf.namelist():
+                if not _is_within(dest, dest / member):
+                    _die(f"Refusing archive entry outside destination: {member}")
+            zf.extractall(dest)
+        return
+
+    with tarfile.open(archive, "r:xz") as tf:
+        if hasattr(tarfile, "data_filter"):
+            tf.extractall(dest, filter="data")
+        else:
+            for member in tf.getmembers():
+                if member.issym() or member.islnk():
+                    link = dest / Path(member.name).parent / member.linkname
+                    if not _is_within(dest, link):
+                        _die(f"Refusing link escaping destination: {member.name}")
+                elif not _is_within(dest, dest / member.name):
+                    _die(f"Refusing archive entry outside destination: {member.name}")
+            tf.extractall(dest)
+
+
+def _restore_exec_bits(root: Path) -> None:
+    """Re-assert the executable bit on ``bin/`` after extraction.
+
+    Zip carries no POSIX mode, and a payload unpacked from one on a Unix host
+    would otherwise yield a toolchain that cannot be run.
+    """
+    if sys.platform == "win32":
+        return
+    for directory in (root / "bin", root / "lib"):
+        if not directory.is_dir():
+            continue
+        for path in directory.rglob("*"):
+            if path.is_file() and not path.is_symlink():
+                mode = path.stat().st_mode
+                if mode & 0o111 or path.suffix in ("", ".so"):
+                    path.chmod(mode | 0o755)
+
+
+class _DirectoryLock:
+    """Cross-process lock built on atomic ``mkdir``.
+
+    Two interpreters importing the package at once must not both download
+    350 MB. ``mkdir`` is atomic on every filesystem we target, which makes it a
+    more portable primitive here than ``fcntl`` or ``msvcrt`` locking.
+    """
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._held = False
+
+    def __enter__(self) -> "_DirectoryLock":
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        deadline = time.monotonic() + _LOCK_TIMEOUT
+        announced = False
+        while True:
+            try:
+                self._path.mkdir()
+                self._held = True
+                return self
+            except FileExistsError:
+                if is_installed():
+                    # Whoever held the lock finished the job for us.
+                    return self
+                if time.monotonic() > deadline:
+                    _die(
+                        f"Timed out waiting for another process to finish the "
+                        f"GHC download (lock: {self._path}). If no other "
+                        "install is running, remove that directory and retry."
+                    )
+                if not announced:
+                    announced = True
+                    sys.stderr.write(
+                        "Waiting for a concurrent GHC installation to finish...\n"
+                    )
+                time.sleep(0.5)
+
+    def __exit__(self, *_exc: object) -> None:
+        if self._held:
+            shutil.rmtree(self._path, ignore_errors=True)
+
+
+def ensure_payload(quiet: bool = False) -> Path:
+    """Return the payload root, installing it first if necessary.
+
+    Idempotent and safe to call from every entry point on every invocation:
+    the fast path is a single ``stat`` of the completion stamp.
+    """
+    root = payload_root()
+    if is_installed():
+        return root
+
+    if os.environ.get(_ENV_OFFLINE, "").strip().lower() in ("1", "true", "yes"):
+        _die(
+            f"{_ENV_OFFLINE} is set and no toolchain is installed at {root}.\n"
+            f"{_offline_hint()}"
+        )
+
+    expected = _expected_digest()
+
+    with _DirectoryLock(cache_root() / f".lock-{GHC_VERSION}-{platform_tag()}"):
+        if is_installed():
+            return root
+
+        root.parent.mkdir(parents=True, exist_ok=True)
+        staging = Path(tempfile.mkdtemp(prefix=".ghc-staging-", dir=str(root.parent)))
+        archive = staging / payload_name()
+        try:
+            _download(payload_url(), archive, quiet)
+
+            actual = _digest_file(archive)
+            if actual != expected:
+                _die(
+                    "Payload integrity check FAILED — refusing to install.\n"
+                    f"  expected SHA-256: {expected}\n"
+                    f"  actual   SHA-256: {actual}\n"
+                    "The download was corrupted or the release asset was "
+                    "modified. Nothing has been installed."
+                )
+
+            unpacked = staging / "root"
+            _extract(archive, unpacked)
+            archive.unlink(missing_ok=True)
+
+            # GHC tarballs carry a single top-level directory; flatten it so the
+            # payload root always has bin/ and lib/ directly beneath it.
+            entries = [p for p in unpacked.iterdir()]
+            if len(entries) == 1 and entries[0].is_dir():
+                unpacked = entries[0]
+
+            _restore_exec_bits(unpacked)
+            (unpacked / ".complete").write_text(
+                f"{GHC_VERSION} {platform_tag()}\n", encoding="utf-8"
+            )
+
+            if root.exists():
+                shutil.rmtree(root, ignore_errors=True)
+            os.replace(unpacked, root)
+        finally:
+            shutil.rmtree(staging, ignore_errors=True)
+
+    if not quiet:
+        sys.stderr.write(f"GHC {GHC_VERSION} installed to {root}\n")
+    return root
+
+
+def find_installed_root() -> Optional[Path]:
+    """Return the cached payload root, or ``None`` — never downloads.
+
+    Used by the wrapper to decide whether a bundled toolchain or a previously
+    bootstrapped one should win, without triggering acquisition as a side
+    effect of merely asking.
+    """
+    try:
+        return payload_root() if is_installed() else None
+    except BootstrapError:
+        return None

ghc_compiler_python/payload_hashes.json

@@ -0,0 +1,5 @@
+{
+  "ghc-payload-9.4.8-macosx_11_0_arm64.tar.xz": "eb826736bb3fa238603183089872fced21231660bc5c1e74067c77a7a77965f9",
+  "ghc-payload-9.4.8-manylinux_2_39_x86_64.tar.xz": "09b4127c288f0c08f77ec4bfbcd2dbc4192566d84b0db4d7c16942dc53d7fd72",
+  "ghc-payload-9.4.8-win_amd64.zip": "31629e8a008d3adf83e0869463c1a3bdf696ae02bf5be51fa110cc8cba484d1d"
+}