pact-python-ffi 0.5.10.0__tar.gz → 0.5.12.1__tar.gz

{pact_python_ffi-0.5.10.0 → pact_python_ffi-0.5.12.1}/.gitignore

@@ -1,3 +1,4 @@
+src/pact_ffi/__version__.py
 src/pact_ffi/data
 src/pact_ffi/*.pyd
 src/pact_ffi/*.so

{pact_python_ffi-0.5.10.0 → pact_python_ffi-0.5.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pact-python-ffi
-Version: 0.5.10.0
+Version: 0.5.12.1
 Summary: Python bindings for the Pact FFI library
 Project-URL: Bug Tracker, https://github.com/pact-foundation/pact-python/issues
 Project-URL: Changelog, https://github.com/pact-foundation/pact-python/blob/main/pact-python-ffi/CHANGELOG.md
@@ -28,6 +28,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.11
+Requires-Dist: cffi>=2.1.1; python_version >= '3.15'
 Requires-Dist: cffi~=2.0
 Description-Content-Type: text/markdown
 

{pact_python_ffi-0.5.10.0 → pact_python_ffi-0.5.12.1}/hatch_build.py

@@ -7,13 +7,16 @@ CFFI bindings for it.
 
 from __future__ import annotations
 
-import gzip
+import hashlib
 import os
 import shutil
 import subprocess
 import sys
+import sysconfig
+import tarfile
 import tempfile
 import urllib.request
+import zipfile
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -25,7 +28,22 @@ if TYPE_CHECKING:
     from collections.abc import Mapping, MutableMapping, Sequence
 
 PKG_DIR = Path(__file__).parent.resolve() / "src" / "pact_ffi"
-PACT_LIB_URL = "https://github.com/pact-foundation/pact-reference/releases/download/libpact_ffi-v{version}/{prefix}pact_ffi-{os}-{platform}{suffix}.{ext}"
+PACT_RELEASE_URL = "https://github.com/pact-foundation/pact-reference/releases/download/pact_ffi-v{version}"
+
+
+def _stable_abi() -> str:
+    """
+    Determine the stable ABI targeted by the current interpreter.
+
+    CFFI compiles against `abi3t` on free-threaded CPython 3.15+ and against
+    `abi3` otherwise. Free-threaded interpreters do not load `abi3` extensions.
+
+    Returns:
+        Either `abi3` or `abi3t`.
+    """
+    if sysconfig.get_config_var("Py_GIL_DISABLED"):
+        return "abi3t"
+    return "abi3"
 
 
 class UnsupportedPlatformError(RuntimeError):
@@ -169,25 +187,40 @@ class PactBuildHook(BuildHookInterface[Any]):
             `dst` is the corresponding path within the wheel.
         """
         # Download the Pact library binary and header file
-        lib_url = self._lib_url(version)
-        header = self._download(lib_url.rsplit("/", 1)[0] + "/pact.h")
-        lib = self._extract_lib(self._download(lib_url))
-        if lib.suffix == ".dll":
-            dll_lib = self._extract_lib(
-                self._download(lib_url.replace(".dll.gz", ".dll.lib.gz"))
-            )
+        release_url = PACT_RELEASE_URL.format(version=version)
+        target = self._target()
+        header = self._download(f"{release_url}/pact.h")
+        if "windows" in target:
+            archive_url = f"{release_url}/pact_ffi-{target}.zip"
+        else:
+            archive_url = f"{release_url}/pact_ffi-{target}.tar.xz"
+        archive = self._download(archive_url)
+        self._verify(archive, self._download(f"{archive_url}.sha256"))
+
+        dll_lib: Path | None = None
+        if "windows" in target:
+            lib = self._extract_lib(archive, "pact_ffi.dll", "pact_ffi.dll")
+            # MSVC resolves `pact_ffi` to `pact_ffi.lib`. The archive's own
+            # `pact_ffi.lib` is the static library, so the import library
+            # takes its name.
+            dll_lib = self._extract_lib(archive, "pact_ffi.dll.lib", "pact_ffi.lib")
+        elif "darwin" in target:
+            lib = self._extract_lib(archive, "libpact_ffi.dylib", "libpact_ffi.dylib")
+        elif "musl" in target:
+            # MUSL uses static library
+            lib = self._extract_lib(archive, "libpact_ffi.a", "libpact_ffi.a")
         else:
-            dll_lib = None
+            lib = self._extract_lib(archive, "libpact_ffi.so", "libpact_ffi.so")
 
         # Compile the FFI extension
         extension = self._compile(lib, header)
 
-        # Copy into the package directory, using the ABI3 marking for broad
-        # compatibility.
+        # Copy into the package directory, using the stable ABI marking for
+        # broad compatibility.
         # NOTE: Windows does _not_ use the version infixation
         name = extension.name.split(".")[0]
         suffix = extension.suffix
-        infix = ".abi3" if os.name != "nt" else ""
+        infix = f".{_stable_abi()}" if os.name != "nt" else ""
         extension_dest = f"{name}{infix}{suffix}"
         shutil.copy(extension, PKG_DIR / extension_dest)
 
@@ -204,16 +237,12 @@ class PactBuildHook(BuildHookInterface[Any]):
 
         return {str(extension): f"pact_ffi/{extension_dest}"}
 
-    def _lib_url(self, version: str) -> str:  # noqa: C901, PLR0912
+    def _target(self) -> str:
         """
-        Generate the download URL for the Pact library.
-
-        Args:
-            version:
-                The upstream Pact version.
+        Determine the Rust target triple matching the wheel platform.
 
         Returns:
-            The URL to download the Pact library from.
+            The Rust target triple of the upstream Pact library archive.
 
         Raises:
             UnsupportedPlatformError:
@@ -221,83 +250,96 @@ class PactBuildHook(BuildHookInterface[Any]):
         """
         wheel_platform = self._sys_tag_platform()
 
-        aarch64 = ("_arm64", "_aarch64")
-        x86_64 = ("_x86_64", "_amd64")
+        if wheel_platform.endswith(("_arm64", "_aarch64")):
+            arch = "aarch64"
+        elif wheel_platform.endswith(("_x86_64", "_amd64")):
+            arch = "x86_64"
+        else:
+            raise UnsupportedPlatformError(wheel_platform)
 
-        # Simplified platform and architecture detection
         if wheel_platform.startswith("macosx"):
-            os, ext = "macos", "dylib.gz"
-            prefix = "lib"
-            suffix = ""
-            if wheel_platform.endswith(aarch64):
-                platform = "aarch64"
-            elif wheel_platform.endswith(x86_64):
-                platform = "x86_64"
-            else:
-                raise UnsupportedPlatformError(wheel_platform)
-
-        elif wheel_platform.startswith("musllinux"):
-            os, ext = "linux", "a.gz"  # MUSL uses static library
-            prefix = "lib"
-            suffix = "-musl"
-            if wheel_platform.endswith(aarch64):
-                platform = "aarch64"
-            elif wheel_platform.endswith(x86_64):
-                platform = "x86_64"
-            else:
-                raise UnsupportedPlatformError(wheel_platform)
-
-        elif wheel_platform.startswith("manylinux"):
-            os, ext = "linux", "so.gz"
-            prefix = "lib"
-            suffix = ""
-            if wheel_platform.endswith(aarch64):
-                platform = "aarch64"
-            elif wheel_platform.endswith(x86_64):
-                platform = "x86_64"
-            else:
-                raise UnsupportedPlatformError(wheel_platform)
-
-        elif wheel_platform.startswith("win"):
-            # TODO: Switch to using `dll.gz`
-            # https://github.com/python-cffi/cffi/issues/182
-            os, ext = "windows", "dll.gz"
-            prefix = ""
-            suffix = ""
-            if wheel_platform.endswith(aarch64):
-                platform = "aarch64"
-            elif wheel_platform.endswith(x86_64):
-                platform = "x86_64"
-            else:
-                raise UnsupportedPlatformError(wheel_platform)
+            return f"{arch}-apple-darwin"
+        if wheel_platform.startswith("musllinux"):
+            return f"{arch}-unknown-linux-musl"
+        if wheel_platform.startswith("manylinux"):
+            return f"{arch}-unknown-linux-gnu"
+        if wheel_platform.startswith("win"):
+            return f"{arch}-pc-windows-msvc"
+        raise UnsupportedPlatformError(wheel_platform)
+
+    def _verify(self, artefact: Path, checksum: Path) -> None:
+        """
+        Verify an artefact against its SHA-256 checksum file.
 
-        else:
-            raise UnsupportedPlatformError(wheel_platform)
+        A mismatched artefact is removed so that the next build downloads it
+        again.
 
-        return PACT_LIB_URL.format(
-            version=version,
-            prefix=prefix,
-            os=os,
-            platform=platform,
-            suffix=suffix,
-            ext=ext,
-        )
+        Args:
+            artefact:
+                The path to the downloaded artefact.
+
+            checksum:
+                The path to the checksum file, in the `sha256sum` format
+                `<hex> *<filename>`.
 
-    def _extract_lib(self, artefact: Path) -> Path:
+        Raises:
+            ValueError:
+                If the checksum does not match.
         """
-        Extract the Pact library.
+        expected = checksum.read_text().split()[0].lower()
+        digest = hashlib.sha256()
+        with artefact.open("rb") as f:
+            for chunk in iter(lambda: f.read(1 << 20), b""):
+                digest.update(chunk)
+        if digest.hexdigest() != expected:
+            artefact.unlink()
+            checksum.unlink()
+            msg = (
+                f"Checksum mismatch for {artefact.name}: "
+                f"expected {expected}, got {digest.hexdigest()}"
+            )
+            self.app.display_error(msg)
+            raise ValueError(msg)
+        self.app.display_debug(f"Verified checksum of {artefact.name}")
+
+    def _extract_lib(self, archive: Path, member: str, name: str) -> Path:
+        """
+        Extract a file from the Pact library archive.
+
+        The `.tar.xz` archives nest their files under a `pact_ffi-<target>`
+        directory, while the `.zip` archives keep them at the root.
 
         Args:
-            artefact:
-                The URL to download the Pact binaries from.
+            archive:
+                The path to the downloaded archive.
+
+            member:
+                The file name within the archive.
+
+            name:
+                The file name to extract to within the package directory.
+
+        Returns:
+            The path to the extracted file.
         """
-        target = PKG_DIR / (artefact.name.split("-")[0] + artefact.suffixes[-2])
-        with (
-            gzip.open(artefact, "rb") as f_in,
-            target.open("wb") as f_out,
-        ):
-            shutil.copyfileobj(f_in, f_out)
-        self.app.display_debug(f"Extracted Pact library to {target}")
+        target = PKG_DIR / name
+        if archive.suffix == ".zip":
+            with (
+                zipfile.ZipFile(archive) as zf,
+                zf.open(member) as f_in,
+                target.open("wb") as f_out,
+            ):
+                shutil.copyfileobj(f_in, f_out)
+        else:
+            prefix = archive.name.removesuffix(".tar.xz")
+            with tarfile.open(archive, "r:xz") as tf:
+                f_tar = tf.extractfile(f"{prefix}/{member}")
+                if f_tar is None:
+                    msg = f"{member} in {archive.name} is not a regular file"
+                    raise ValueError(msg)
+                with f_tar, target.open("wb") as f_out:
+                    shutil.copyfileobj(f_tar, f_out)
+        self.app.display_debug(f"Extracted {member} from {archive.name} to {target}")
         return target
 
     def _compile(self, lib: Path, header: Path) -> Path:
@@ -386,46 +428,36 @@ class PactBuildHook(BuildHookInterface[Any]):
         """
         Patch the upstream header so that CFFI can compile it.
 
-        The upstream `pact.h` emits the callback parameters of
-        `pactffi_register_plugin_log_callback` and
-        `pactffi_register_log_callback` as opaque structs passed by value, which
-        cannot be compiled. The Rust signatures are `Option<extern "C" fn(...)>`,
-        whose ABI is a nullable function pointer. See
-        https://github.com/pact-foundation/pact-reference/issues/544.
+        The upstream `pact.h` emits the callback parameter of
+        `pactffi_register_log_callback` as an opaque struct passed by value,
+        which cannot be compiled. The Rust signature is
+        `Option<extern "C" fn(...)>`, whose ABI is a nullable function pointer.
+        See https://github.com/pact-foundation/pact-reference/issues/544.
 
         Args:
             source:
                 The contents of the upstream `pact.h`.
 
         Returns:
-            The header contents with the callbacks declared as function
-            pointers.
+            The header contents with the callback declared as a function
+            pointer.
         """
-        for callback, register, first_arg in (
-            (
-                "PluginLogCallback",
-                "pactffi_register_plugin_log_callback",
-                "plugin_instance_id",
-            ),
-            ("LogCallback", "pactffi_register_log_callback", "log_id"),
-        ):
-            opaque = f"typedef struct Option_{callback} Option_{callback};"
-            if opaque not in source:
-                continue
-            self.app.display_debug(f"Patching Option_{callback} in pact.h")
-            source = source.replace(
-                opaque,
-                f"typedef void (*{callback})("
-                f"const char *{first_arg}, "
-                "const char *test_run_id, "
-                "const char *level, "
-                "const char *target, "
-                "const char *message);",
-            ).replace(
-                f"void {register}(struct Option_{callback} callback);",
-                f"void {register}({callback} callback);",
-            )
-        return source
+        opaque = "typedef struct Option_LogCallback Option_LogCallback;"
+        if opaque not in source:
+            return source
+        self.app.display_debug("Patching Option_LogCallback in pact.h")
+        return source.replace(
+            opaque,
+            "typedef void (*LogCallback)("
+            "const char *log_id, "
+            "const char *test_run_id, "
+            "const char *level, "
+            "const char *target, "
+            "const char *message);",
+        ).replace(
+            "void pactffi_register_log_callback(struct Option_LogCallback callback);",
+            "void pactffi_register_log_callback(LogCallback callback);",
+        )
 
     def _download(self, url: str) -> Path:
         """
@@ -458,13 +490,17 @@ class PactBuildHook(BuildHookInterface[Any]):
         """
         Infer the tag for the current build.
 
-        The bindings are built to target ABI3, which is compatible with multiple
-        Python versions. As a result, we generate `py{version}-abi3-{platform}`
-        tags for the wheels.
+        The bindings are built to target the stable ABI, which is compatible
+        with multiple Python versions. As a result, we generate
+        `cp{version}-abi3-{platform}` tags for the wheels.
 
         While the ABI3 interface was introduced in Python 3.2, we target the
         earliest supported version of Python in the Python wrapper.
 
+        A free-threaded build targets `abi3t`, which requires Python 3.15. Its
+        wheel takes the `cp{version}-abi3.abi3t-{platform}` tag, as the
+        extension also loads on GIL-enabled builds.
+
         Returns:
             The tag for the current build.
         """
@@ -485,4 +521,5 @@ class PactBuildHook(BuildHookInterface[Any]):
             else:
                 raise UnsupportedPlatformError(platform)
 
-        return f"cp{python_version}-abi3-{platform}"
+        abi = "abi3.abi3t" if _stable_abi() == "abi3t" else "abi3"
+        return f"cp{python_version}-{abi}-{platform}"