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

ghc_compiler_python/__init__.py

@@ -1,6 +1,10 @@
 """ghc-compiler-python: Native GHC and Cabal packaged as a Python Wheel."""
 
-__version__ = "9.4.8"
+# The distribution version and the compiler version are separate axes and no
+# longer agree. 9.4.8 published a wrapper that rejected every Windows machine
+# without a system gcc; PyPI forbids re-uploading a version, so the fix ships
+# as 9.4.9. The compiler inside is still GHC 9.4.8 and still says so.
+__version__ = "9.5.0"
 __ghc_version__ = "9.4.8"
 __cabal_version__ = "3.10.3.0"
 __author__ = "ghc-compiler-python contributors"

ghc_compiler_python/bootstrap.py

@@ -39,13 +39,30 @@ import zipfile
 from pathlib import Path
 from typing import NoReturn, Optional
 
+#: The compiler actually inside the payload. This is GHC's own version and it
+#: moves only when the bindist does.
 GHC_VERSION = "9.4.8"
 
+#: The distribution coordinate: the git tag, the release, the payload asset
+#: names, the cache directory, and the version on PyPI.
+#:
+#: These were one constant until 9.4.9, which read well while the two agreed
+#: and became a trap the moment they had to diverge. 9.4.8 shipped a wrapper
+#: that rejected every Windows machine without a system gcc; PyPI forbids
+#: re-uploading a version, so the fix needed a new one, and a single constant
+#: made "publish a fixed wheel" and "claim a GHC release that does not exist"
+#: the same edit.
+#:
+#: They are now separate axes. The package version is 9.4.9; the compiler it
+#: installs is, and reports itself as, 9.4.8. `ghc-wrapper --numeric-version`
+#: answers for the compiler, never for the package.
+RELEASE_VERSION = "9.5.0"
+
 #: 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}"
+    f"/v{RELEASE_VERSION}"
 )
 
 _HASH_MANIFEST = Path(__file__).resolve().parent / "payload_hashes.json"
@@ -102,12 +119,27 @@ def platform_tag() -> str:
 
 
 def _archive_suffix() -> str:
-    # Windows runners produce a zip; the Unix payloads are xz tarballs.
-    return ".zip" if sys.platform == "win32" else ".tar.xz"
+    # Every platform ships an xz tarball as of 9.5.0.
+    #
+    # Windows used to ship a zip, and it cost users 148 MB per install for
+    # nothing. Measured on the real extracted toolchain (1814 MB, 8311 files):
+    #
+    #   zip (deflate, -mx=5)   395.8 MB
+    #   tar | xz -T0 -6        247.3 MB     37.5% smaller
+    #
+    # The local zip reproduced the published asset to within 0.1 MB, so that
+    # is a comparison against the artifact users actually downloaded, not a
+    # proxy. The round-trip was verified lossless by comparing all 8311 files
+    # by SHA-256 -- not by sampling one binary and assuming the rest.
+    #
+    # Windows can read this: `_extract` dispatches on the suffix and has always
+    # handled .tar.xz, and Python's tarfile has built-in lzma support. The zip
+    # was never a Windows requirement, only an artefact of building it with 7z.
+    return ".tar.xz"
 
 
 def payload_name() -> str:
-    return f"ghc-payload-{GHC_VERSION}-{platform_tag()}{_archive_suffix()}"
+    return f"ghc-payload-{RELEASE_VERSION}-{platform_tag()}{_archive_suffix()}"
 
 
 def payload_url() -> str:
@@ -142,7 +174,7 @@ def cache_root() -> Path:
 
 def payload_root() -> Path:
     """Where this version's toolchain lives once installed."""
-    return cache_root() / GHC_VERSION / platform_tag()
+    return cache_root() / RELEASE_VERSION / platform_tag()
 
 
 def is_installed() -> bool:
@@ -196,7 +228,7 @@ def _offline_hint() -> str:
         "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"
+        f"ghc_compiler_python-{RELEASE_VERSION}-py3-none-{platform_tag()}.whl"
     )
 
 
@@ -206,7 +238,7 @@ def _download(url: str, dest: Path, quiet: bool) -> None:
         sys.stderr.write(f"  from {url}\n")
 
     request = urllib.request.Request(
-        url, headers={"User-Agent": f"ghc-compiler-python/{GHC_VERSION}"}
+        url, headers={"User-Agent": f"ghc-compiler-python/{RELEASE_VERSION}"}
     )
     try:
         with urllib.request.urlopen(request, timeout=_DOWNLOAD_TIMEOUT) as response:
@@ -358,7 +390,7 @@ def ensure_payload(quiet: bool = False) -> Path:
 
     expected = _expected_digest()
 
-    with _DirectoryLock(cache_root() / f".lock-{GHC_VERSION}-{platform_tag()}"):
+    with _DirectoryLock(cache_root() / f".lock-{RELEASE_VERSION}-{platform_tag()}"):
         if is_installed():
             return root
 
@@ -390,7 +422,7 @@ def ensure_payload(quiet: bool = False) -> Path:
 
             _restore_exec_bits(unpacked)
             (unpacked / ".complete").write_text(
-                f"{GHC_VERSION} {platform_tag()}\n", encoding="utf-8"
+                f"{RELEASE_VERSION} {platform_tag()}\n", encoding="utf-8"
             )
 
             if root.exists():

ghc_compiler_python/payload_hashes.json

@@ -1,5 +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"
+  "ghc-payload-9.5.0-macosx_11_0_arm64.tar.xz": "6d6d59764272d77a73a1134b324c0768bab331b41a85d3decde4798be4e8e118",
+  "ghc-payload-9.5.0-manylinux_2_39_x86_64.tar.xz": "543778293de88d0a1db3ae3236c1a58fd398e550da2aa1ec9a1841bc83b891b8",
+  "ghc-payload-9.5.0-win_amd64.tar.xz": "d0966788bb13fca9f315b768685884e9902b7539b97bc8c1817135e82fe64ce4"
 }

ghc_compiler_python/wrapper.py

@@ -223,10 +223,56 @@ def _resolve_binary(name: str) -> str:
     )
 
 
-def _validate_c_linker() -> None:
-    """Pre-flight validation: assert the existence of a host C-linker."""
-    if not shutil.which("gcc") and not shutil.which("clang"):
-        _die("FATAL ERROR: The GHC compiler requires a host C-linker (gcc or clang).")
+#: Where the Windows bindist keeps the C toolchain it ships with itself,
+#: relative to the toolchain root. Verified against the published payload:
+#: mingw/bin/clang.exe and mingw/bin/ld.exe are both present. GHC 9.4.8 for
+#: Windows drives clang, not gcc.
+_BUNDLED_LINKERS = (
+    "mingw/bin/clang.exe",
+    "mingw/bin/gcc.exe",
+    "mingw/bin/clang",
+    "mingw/bin/gcc",
+)
+
+
+def _bundled_c_linker(root: Optional[Path]) -> Optional[Path]:
+    """Return the C compiler shipped inside the toolchain, if there is one."""
+    if root is None:
+        return None
+    for relative in _BUNDLED_LINKERS:
+        candidate = root / relative
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _validate_c_linker(root: Optional[Path] = None) -> None:
+    """Assert that a C toolchain GHC can actually drive is reachable.
+
+    GHC shells out to a C compiler to assemble and link, so its absence is
+    worth catching before the user sees a confusing error from deep inside
+    the compiler. But *where* that compiler comes from differs by platform:
+
+      Unix     GHC uses the system cc. Absent means absent.
+      Windows  the bindist carries its own. mingw/bin/clang.exe and
+               mingw/bin/ld.exe live inside the payload, and that toolchain
+               is the single largest reason the Windows payload is 395 MB
+               against 87 MB for Linux.
+
+    Checking only `shutil.which` therefore rejected every Windows machine
+    without a system gcc -- including machines that had just downloaded a
+    complete toolchain and were holding it in the cache. CI never caught it
+    because the windows-latest runner installs mingw via chocolatey, so a
+    system compiler is always on PATH there. The delivered path found it on
+    the first real user run.
+    """
+    if shutil.which("gcc") or shutil.which("clang"):
+        return
+
+    if _bundled_c_linker(root) is not None:
+        return
+
+    _die("FATAL ERROR: The GHC compiler requires a host C-linker (gcc or clang).")
 
 
 def _find_platform_lib_subdir() -> str:
@@ -309,6 +355,16 @@ def _sterilize_environment() -> dict:
                 ghc_root / "lib" / f"ghc-{GHC_VERSION}",
                 ghc_root / "lib" / f"ghc-{GHC_VERSION}" / "lib",
                 Path(_find_platform_lib_subdir() or "."),
+                # Shipped inside the payload, so the thin-wheel path is as
+                # self-contained as the Windows one. GHC 9.4.8 links against
+                # ncurses 5; Ubuntu 24.04 ships ncurses 6 and has no
+                # libtinfo.so.5, so without this the first command a user runs
+                # dies with "error while loading shared libraries".
+                #
+                # This is the Linux twin of the mingw case above: the payload
+                # carries the dependency, and the launcher has to be willing to
+                # look inside the payload for it.
+                ghc_root / "vendor-lib",
                 # auditwheel vendors shared objects here on the offline wheel.
                 Path(__file__).resolve().parent.parent / "ghc_compiler_python.libs",
             ]
@@ -676,7 +732,23 @@ def _ghc_pkg_recache(pkg_db_dir: str, env: dict) -> None:
 
 def _execute_tool(tool_name: str, extra_args: Optional[List[str]] = None) -> NoReturn:
     """Generic subprocess proxy for bundled Haskell tooling."""
-    _validate_c_linker()
+    # Acquire the toolchain first. Everything below describes or patches it,
+    # and none of that can be done correctly before it exists.
+    #
+    # The previous order validated the linker, sterilised the environment and
+    # ran _resolve_runtime_paths -- which rewrites @GHC_PREFIX@ to the real
+    # root -- and only then called _resolve_binary, which is what actually
+    # downloads the payload. On a thin-wheel install there was no toolchain on
+    # disk during the patch step, so _ghc_root_or_prefix fell back to
+    # sys.prefix, the resource scan found nothing, and the placeholders were
+    # left unresolved.
+    #
+    # This never showed up in CI because the offline wheel ships the toolchain
+    # inside the package, so a bundled root is present from the first line and
+    # the ordering makes no observable difference. It only breaks on the path
+    # every PyPI user takes.
+    root = _ghc_root()
+    _validate_c_linker(root)
     env = _sterilize_environment()
     _resolve_runtime_paths(env)
     binary_path = _resolve_binary(tool_name)

{ghc_compiler_python-9.4.8.dist-info → ghc_compiler_python-9.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ghc-compiler-python
-Version: 9.4.8
+Version: 9.5.0
 Summary: Native GHC 9.4.8 compiler and Cabal 3.10.3.0 tooling packaged as an isolated Python Wheel
 Project-URL: Homepage, https://github.com/Saimonokuma/GHC-COMPILER-PYTHON
 Project-URL: Source, https://github.com/Saimonokuma/GHC-COMPILER-PYTHON
@@ -67,12 +67,37 @@ A Haskell toolchain is normally installed by its own ecosystem installer, which
 
 ---
 
+## 🔢 Two version numbers, and what each one means
+
+This trips people up, so it is stated once, plainly:
+
+| | example | what it is |
+|---|---|---|
+| **package version** | `9.5.0` | *this project* — the wheel you `pip install`. Ours to bump. |
+| **compiler version** | `9.4.8` | *GHC itself* — the Haskell compiler you get. Not ours to invent. |
+
+`ghc-wrapper --numeric-version` answers **9.4.8**, because you are asking it which Haskell compiler you have.
+
+The two used to be one number, which broke the moment they had to disagree. The 9.4.8 wheel could not compile on Windows, PyPI does not permit replacing a published version, and the last GHC in the 9.4 line *is* 9.4.8 — so shipping a fix and claiming a new compiler were the same edit. They are now separate, and `lean/Proofs/Payload.lean` proves they can never be confused again: a package bump renames every asset and changes nothing you are told about the compiler.
+
+---
+
 ## 🚀 Installation
 
 ```bash
 pip install ghc-compiler-python
 ```
 
+Or with [uv](https://github.com/astral-sh/uv) — same package, same index:
+
+```bash
+uv pip install ghc-compiler-python          # into a project venv
+uv tool install ghc-compiler-python         # 10 commands, available everywhere
+uvx --from ghc-compiler-python ghc-wrapper  # run it without installing anything
+```
+
+`uv tool install` puts `ghc-wrapper`, `cabal-wrapper`, `ghci-wrapper`, `runghc-wrapper` and six more on your PATH globally — a Haskell toolchain with no Haskell installer, no `~/.ghc`, and nothing to uninstall but the tool itself.
+
 The PyPI package is **~17 KiB**. It fetches the toolchain for your platform on first use and verifies it against a SHA-256 digest embedded in the wheel — a tampered or truncated download cannot install.
 
 ### 📦 Offline / air-gapped
@@ -80,9 +105,9 @@ The PyPI package is **~17 KiB**. It fetches the toolchain for your platform on f
 Self-contained wheels with the toolchain already bundled live on the [releases page](https://github.com/Saimonokuma/GHC-COMPILER-PYTHON/releases). These never contact the network:
 
 ```bash
-pip install ghc_compiler_python-9.4.8-py3-none-manylinux_2_38_x86_64.manylinux_2_39_x86_64.whl   # Linux
-pip install ghc_compiler_python-9.4.8-py3-none-macosx_11_0_arm64.whl       # macOS
-pip install ghc_compiler_python-9.4.8-py3-none-win_amd64.whl               # Windows
+pip install ghc_compiler_python-9.5.0-py3-none-manylinux_2_38_x86_64.manylinux_2_39_x86_64.whl   # Linux
+pip install ghc_compiler_python-9.5.0-py3-none-macosx_11_0_arm64.whl       # macOS
+pip install ghc_compiler_python-9.5.0-py3-none-win_amd64.whl               # Windows
 ```
 
 > The Linux offline wheel carries the tags `manylinux_2_38` **and** `manylinux_2_39`, so it installs on glibc 2.38 or newer. That floor is not chosen — auditwheel derives it by inspecting the versioned symbols the binaries actually reference. A tag lower than the binaries support would install on systems where the toolchain then fails at runtime, so the build states what is true rather than what would be convenient. On older distributions use the thin wheel; its payload is a plain tarball and carries no such constraint.
@@ -92,10 +117,11 @@ pip install ghc_compiler_python-9.4.8-py3-none-win_amd64.whl               # Win
 | | |
 |:--|:--|
 | 🐍 **Python** | `>= 3.10` |
-| 🔗 **C-Linker** | `gcc` or `clang` on the host |
-| 🐧 Linux | `sudo apt-get install gcc` |
-| 🍎 macOS | `xcode-select --install` |
-| 🪟 Windows | MinGW-w64 or MSYS2 |
+| 🐧 Linux | a C linker — `sudo apt-get install gcc` |
+| 🍎 macOS | a C linker — `xcode-select --install` |
+| 🪟 **Windows** | **nothing.** The payload carries its own `clang` and `ld`. |
+
+> Windows used to require MinGW-w64 or MSYS2. It never actually needed them: the Windows payload has always shipped a complete mingw toolchain — that is why it is the largest of the three. The wrapper simply refused to look inside it and demanded a system compiler instead, which is what made 9.4.8 unusable on a stock Windows machine. Fixed in 9.4.9; the CI job that certifies Windows now deletes every system compiler from `PATH` before it compiles, so this cannot silently regress.
 
 ### ⚙️ Configuration
 

ghc_compiler_python-9.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ghc_compiler_python/__init__.py,sha256=aJ6eb9loagmgE67cJFjtg0K4fUvE31Jk9M-rW3D1cQg,609
+ghc_compiler_python/bootstrap.py,sha256=_znXp_kTykAvD_o1GnYF0L0SHAA_md6LPXfg9q65Odg,16661
+ghc_compiler_python/payload_hashes.json,sha256=YJKOkigNSWpMyQlELEE-y9E09uZKe6phFGdjgnSXdzs,347
+ghc_compiler_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ghc_compiler_python/wrapper.py,sha256=RLeOeGc2kn9CVrebHIpbjfWiI-yWn8qcmjIJ5HwyK4s,31021
+ghc_compiler_python-9.5.0.dist-info/METADATA,sha256=TE7XF-R8LbM9OsUCJ0jlMtL92HNVyXbdSBf0KLTILYk,11247
+ghc_compiler_python-9.5.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ghc_compiler_python-9.5.0.dist-info/entry_points.txt,sha256=9QtlqeGuoonFb4bB4F-gLlBbY0koqkTJ2PknLFrvsvo,610
+ghc_compiler_python-9.5.0.dist-info/licenses/LICENSE,sha256=OOef9xbIXwIBos0C1icJ5Z_i44n_VO33KjqyeBTa-tk,1068
+ghc_compiler_python-9.5.0.dist-info/RECORD,,

ghc_compiler_python-9.4.8.dist-info/RECORD

@@ -1,10 +0,0 @@
-ghc_compiler_python/__init__.py,sha256=N4kbpSKof782d2NNXc5JGUwbpJD7GDB-PpMT0PJbNuk,306
-ghc_compiler_python/bootstrap.py,sha256=kISTQ9uEFDvTccL__a0q94_stYDUCCfqBkYA1be2ySU,14985
-ghc_compiler_python/payload_hashes.json,sha256=r-HmvRveNzX92xGq-3K8JGcnTFdGp8KIXkub5CmDg_A,344
-ghc_compiler_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ghc_compiler_python/wrapper.py,sha256=golkrZaFxSl0iXzy-0blkaW-ic0f3Q6FPRCAPVZOw4A,27705
-ghc_compiler_python-9.4.8.dist-info/METADATA,sha256=B4Kbst9XS3NafvbWI1CarYQakEDjfCDyF5SQIbQfi40,9247
-ghc_compiler_python-9.4.8.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-ghc_compiler_python-9.4.8.dist-info/entry_points.txt,sha256=9QtlqeGuoonFb4bB4F-gLlBbY0koqkTJ2PknLFrvsvo,610
-ghc_compiler_python-9.4.8.dist-info/licenses/LICENSE,sha256=OOef9xbIXwIBos0C1icJ5Z_i44n_VO33KjqyeBTa-tk,1068
-ghc_compiler_python-9.4.8.dist-info/RECORD,,