ghc-compiler-python 9.4.8__py3-none-any.whl → 9.4.9__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.4.9"
 __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.4.9"
+
 #: 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"
@@ -107,7 +124,7 @@ def _archive_suffix() -> str:
 
 
 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 +159,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 +213,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 +223,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 +375,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 +407,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.4.9-macosx_11_0_arm64.tar.xz": "6cc3d01e5e69524001d9211138382093c41d09da852aeee7f871b0d563afb31c",
+  "ghc-payload-9.4.9-manylinux_2_39_x86_64.tar.xz": "13dc0b399796c6a2fadeb1f11154cfa9e7698507fb9ba07cf0e5aa7a2024293a",
+  "ghc-payload-9.4.9-win_amd64.zip": "4ff104a37873757d7c2f4414360a08c3f07ccb49aa018c8b29a70c7cb4989e14"
 }

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.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ghc-compiler-python
-Version: 9.4.8
+Version: 9.4.9
 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
@@ -80,9 +80,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.4.9-py3-none-manylinux_2_38_x86_64.manylinux_2_39_x86_64.whl   # Linux
+pip install ghc_compiler_python-9.4.9-py3-none-macosx_11_0_arm64.whl       # macOS
+pip install ghc_compiler_python-9.4.9-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.

ghc_compiler_python-9.4.9.dist-info/RECORD

@@ -0,0 +1,10 @@
+ghc_compiler_python/__init__.py,sha256=EQl3IbIry2EdSHPHCO3qj5PgXEDzKOUlpGcqf6lc_m8,609
+ghc_compiler_python/bootstrap.py,sha256=eDe0uRaIFhDWfEjntQP9F043PiHvWljmVnL9Xqix3Bo,15902
+ghc_compiler_python/payload_hashes.json,sha256=_fyFJqESXvFLgVyulav8Pk8M-3mhYekegxGAoRU5s_Q,344
+ghc_compiler_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ghc_compiler_python/wrapper.py,sha256=RLeOeGc2kn9CVrebHIpbjfWiI-yWn8qcmjIJ5HwyK4s,31021
+ghc_compiler_python-9.4.9.dist-info/METADATA,sha256=wlN_tefM9ZittG3MKTrmOsSUwBBpFMmw6KO6y503xrA,9247
+ghc_compiler_python-9.4.9.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ghc_compiler_python-9.4.9.dist-info/entry_points.txt,sha256=9QtlqeGuoonFb4bB4F-gLlBbY0koqkTJ2PknLFrvsvo,610
+ghc_compiler_python-9.4.9.dist-info/licenses/LICENSE,sha256=OOef9xbIXwIBos0C1icJ5Z_i44n_VO33KjqyeBTa-tk,1068
+ghc_compiler_python-9.4.9.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,,