pact-python-ffi 0.0.0__tar.gz → 0.4.22.0__tar.gz

pact_python_ffi-0.4.22.0/.gitignore

@@ -0,0 +1,2 @@
+src/pact_ffi/data
+src/pact_ffi/__version__.py

pact_python_ffi-0.4.22.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pact Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pact_python_ffi-0.4.22.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: pact-python-ffi
+Version: 0.4.22.0
+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
+Project-URL: Documentation, https://docs.pact.io
+Project-URL: Homepage, https://pact.io
+Project-URL: Repository, https://github.com/pact-foundation/pact-python
+Author-email: Joshua Ellis <josh@jpellis.me>
+Maintainer-email: Joshua Ellis <josh@jpellis.me>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: contract-testing,ffi,pact,pact-python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: cffi~=1.0
+Provides-Extra: devel
+Requires-Dist: mypy==1.17.0; extra == 'devel'
+Requires-Dist: pytest-cov~=6.0; extra == 'devel'
+Requires-Dist: pytest-mock~=3.0; extra == 'devel'
+Requires-Dist: pytest~=8.0; extra == 'devel'
+Requires-Dist: ruff==0.12.4; extra == 'devel'
+Provides-Extra: devel-test
+Requires-Dist: pytest-cov~=6.0; extra == 'devel-test'
+Requires-Dist: pytest-mock~=3.0; extra == 'devel-test'
+Requires-Dist: pytest~=8.0; extra == 'devel-test'
+Provides-Extra: devel-types
+Requires-Dist: mypy==1.17.0; extra == 'devel-types'
+Description-Content-Type: text/markdown
+
+# Pact Python FFI
+
+> [!NOTE]
+>
+> This package provides direct access to the Pact Foreign Function Interface (FFI) with minimal abstraction. It is intended for advanced users who need low-level control over Pact operations in Python.
+
+---
+
+This sub-package is part of the [Pact Python](https://github.com/pact-foundation/pact-python) project and exists to expose the [Pact FFI](https://github.com/pact-foundation/pact-reference) directly to Python. If you are looking for the main Pact Python library for contract testing, please see the [root package](https://github.com/pact-foundation/pact-python#pact-python).
+
+## Overview
+
+-   The module provides a thin Python wrapper around the Pact FFI (C API).
+-   Most classes correspond directly to structs from the FFI, and are designed to wrap the underlying C pointers.
+-   Many classes implement the `__del__` method to ensure memory allocated by the Rust library is freed when the Python object is destroyed, preventing memory leaks.
+-   Functions from the FFI are exposed directly: if a function `foo` exists in the FFI, it is accessible as `pact_ffi.foo(...)`.
+-   The API is not guaranteed to be stable and is intended for use by advanced users or for building higher-level libraries. For typical contract testing, use the main Pact Python client library.
+
+## Installation
+
+You can install this package via pip:
+
+```console
+pip install pact-python-ffi
+```
+
+## Usage
+
+This package exposes the raw FFI bindings for Pact. It is suitable for advanced use cases, custom integrations, or for building higher-level libraries. For typical contract testing, prefer using the main Pact Python library.
+
+## Contributing
+
+As this is a relatively thin wrapper around the Pact FFI, the code is unlikely to change frequently; however, contributions to improve the coverage of the FFI bindings or to improve existing functionality are welcome. See the [main contributing guide](https://github.com/pact-foundation/pact-python/blob/main/CONTRIBUTING.md) for details.
+
+To release a new version of `pact-python-ffi`, simply push a tag in the format `pact-python-ffi/x.y.z.w`. This will automatically trigger a release process, pulling in version `x.y.z` of the underlying Pact FFI. Before creating and pushing such a tag, please ensure that the Python wrapper has been updated to reflect any changes or updates in the corresponding FFI version.
+
+Higher-level abstractions or utilities should be implemented in separate libraries (such as [`pact-python`](https://github.com/pact-foundation/pact-python)).
+
+---
+
+For questions or support, please visit the [Pact Foundation Slack](https://slack.pact.io) or [GitHub Discussions](https://github.com/pact-foundation/pact-python/discussions)
+
+---

pact_python_ffi-0.4.22.0/README.md

@@ -0,0 +1,43 @@
+# Pact Python FFI
+
+> [!NOTE]
+>
+> This package provides direct access to the Pact Foreign Function Interface (FFI) with minimal abstraction. It is intended for advanced users who need low-level control over Pact operations in Python.
+
+---
+
+This sub-package is part of the [Pact Python](https://github.com/pact-foundation/pact-python) project and exists to expose the [Pact FFI](https://github.com/pact-foundation/pact-reference) directly to Python. If you are looking for the main Pact Python library for contract testing, please see the [root package](https://github.com/pact-foundation/pact-python#pact-python).
+
+## Overview
+
+-   The module provides a thin Python wrapper around the Pact FFI (C API).
+-   Most classes correspond directly to structs from the FFI, and are designed to wrap the underlying C pointers.
+-   Many classes implement the `__del__` method to ensure memory allocated by the Rust library is freed when the Python object is destroyed, preventing memory leaks.
+-   Functions from the FFI are exposed directly: if a function `foo` exists in the FFI, it is accessible as `pact_ffi.foo(...)`.
+-   The API is not guaranteed to be stable and is intended for use by advanced users or for building higher-level libraries. For typical contract testing, use the main Pact Python client library.
+
+## Installation
+
+You can install this package via pip:
+
+```console
+pip install pact-python-ffi
+```
+
+## Usage
+
+This package exposes the raw FFI bindings for Pact. It is suitable for advanced use cases, custom integrations, or for building higher-level libraries. For typical contract testing, prefer using the main Pact Python library.
+
+## Contributing
+
+As this is a relatively thin wrapper around the Pact FFI, the code is unlikely to change frequently; however, contributions to improve the coverage of the FFI bindings or to improve existing functionality are welcome. See the [main contributing guide](https://github.com/pact-foundation/pact-python/blob/main/CONTRIBUTING.md) for details.
+
+To release a new version of `pact-python-ffi`, simply push a tag in the format `pact-python-ffi/x.y.z.w`. This will automatically trigger a release process, pulling in version `x.y.z` of the underlying Pact FFI. Before creating and pushing such a tag, please ensure that the Python wrapper has been updated to reflect any changes or updates in the corresponding FFI version.
+
+Higher-level abstractions or utilities should be implemented in separate libraries (such as [`pact-python`](https://github.com/pact-foundation/pact-python)).
+
+---
+
+For questions or support, please visit the [Pact Foundation Slack](https://slack.pact.io) or [GitHub Discussions](https://github.com/pact-foundation/pact-python/discussions)
+
+---

pact_python_ffi-0.4.22.0/cliff.toml

@@ -0,0 +1,113 @@
+#:schema https://json.schemastore.org/any.json
+# git-cliff configuration file
+# https://git-cliff.org/docs/configuration
+
+[changelog]
+# template for the changelog header
+header = """
+# Pact Python FFI Changelog
+
+All notable changes to this project will be documented in this file.
+
+Note that this _only_ includes changes to the Python FFI interface. For changes to the Pact FFI itself, see the [Pact FFI changelog](https://github.com/pact-foundation/pact-reference/blob/master/rust/pact_ffi/CHANGELOG.md).
+
+<!-- markdownlint-disable no-duplicate-heading -->
+<!-- markdownlint-disable emph-style -->
+<!-- markdownlint-disable strong-style -->
+
+"""
+
+# template for the changelog body
+# https://keats.github.io/tera/docs/#introduction
+body = """
+{% if version %}\
+    ## [{{ version | trim_start_matches(pat="v") }}] _{{ timestamp | date(format="%Y-%m-%d") }}_
+{% else %}\
+    ## [unreleased]
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits %}
+        -   {% if commit.scope %}_({{ commit.scope }})_ {% endif %}\
+            {% if commit.breaking %}[**breaking**] {% endif %}\
+            {{ commit.message | upper_first }}\
+                {% if commit.breaking and commit.breaking_description %}
+                    {{ "    " }}\
+                    > {{
+                        commit.breaking_description
+                        | split(pat="\n")
+                        | join(sep=" ")
+                        | replace(from="  ", to=" ")
+                        | replace(from="  ", to=" ")
+                        | replace(from="  ", to=" ")
+                        | upper_first
+                    }}\
+                {% endif %}\
+    {% endfor %}
+{% endfor %}
+{% if github.contributors %}\
+    ### Contributors
+    {% for contributor in github.contributors %}\
+        {% if contributor.username and contributor.username is ending_with("[bot]") %}{% continue %}{% endif %}
+        -   @{{ contributor.username }}\
+    {% endfor %}
+{% endif %}
+
+"""
+
+# template for the changelog footer
+footer = """\
+<!-- generated by git-cliff on {{ now() | date(format="%Y-%m-%d") }}-->
+"""
+
+# remove the leading and trailing s
+trim = true
+# postprocessors
+postprocessors = []
+# render body even when there are no releases to process
+# render_always = true
+# output file path
+output = "CHANGELOG.md"
+
+[git]
+tag_pattern = "pact-python-ffi/.*"
+# parse the commits based on https://www.conventionalcommits.org
+conventional_commits = true
+# filter out the commits that are not conventional
+filter_unconventional = true
+# process each line of a commit as an individual commit
+split_commits = false
+# regex for preprocessing the commit messages
+commit_preprocessors = [
+  # Remove the PR number added by GitHub when merging PR in UI
+  { pattern = '\s*\(#([0-9]+)\)$', replace = "" },
+  # Check spelling of the commit with https://github.com/crate-ci/typos
+  { pattern = '.*', replace_command = 'typos --write-changes -' },
+]
+# regex for parsing and grouping commits
+commit_parsers = [
+  # Ignore deps commits from the changelog
+  { message = "^(chore|fix)\\(deps.*\\)", skip = true },
+  { message = "^chore: update changelog.*", skip = true },
+  # Group commits by type
+  { group = "<!-- 00 -->🚀 Features", message = "^feat" },
+  { group = "<!-- 01 -->🐛 Bug Fixes", message = "^fix" },
+  { group = "<!-- 50 -->🚜 Refactor", message = "^refactor" },
+  { group = "<!-- 51 -->⚡ Performance", message = "^perf" },
+  { group = "<!-- 52 -->🎨 Styling", message = "^style" },
+  { group = "<!-- 60 -->📚 Documentation", message = "^docs" },
+  { group = "<!-- 80 -->🧪 Testing", message = "^test" },
+  { group = "<!-- 98 -->◀️ Revert", message = "^revert" },
+  { group = "<!-- 99 -->⚙️ Miscellaneous Tasks", message = "^chore" },
+  { group = "<!-- 99 -->� Other", message = ".*" },
+]
+# filter out the commits that are not matched by commit parsers
+filter_commits = false
+# sort the tags topologically
+topo_order = false
+# sort the commits inside sections by oldest/newest order
+sort_commits = "oldest"
+
+[remote.github]
+owner = "pact-foundation"
+repo  = "pact-python"

pact_python_ffi-0.4.22.0/hatch_build.py

@@ -0,0 +1,354 @@
+"""
+Hatchling build hook for binary downloads.
+
+Pact Python is built on top of the Ruby Pact binaries and the Rust Pact library.
+This build script downloads the binaries and library for the current platform
+and installs them in the `pact` directory under `/bin` and `/lib`.
+
+The version of the binaries and library can be controlled with the
+`PACT_BIN_VERSION` and `PACT_LIB_VERSION` environment variables. If these are
+not set, a pinned version will be used instead.
+"""
+
+from __future__ import annotations
+
+import gzip
+import os
+import shutil
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import cffi
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+from packaging.tags import sys_tags
+
+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}"
+
+
+class UnsupportedPlatformError(RuntimeError):
+    """Raised when the current platform is not supported."""
+
+    def __init__(self, platform: str) -> None:
+        """
+        Initialize the exception.
+
+        Args:
+            platform: The unsupported platform.
+        """
+        self.platform = platform
+        super().__init__(f"Unsupported platform {platform}")
+
+
+class PactBuildHook(BuildHookInterface[Any]):
+    """Custom hook to download Pact binaries."""
+
+    PLUGIN_NAME = "pact-ffi"
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+        """
+        Initialize the build hook.
+
+        For this hook, we additionally define the lib extension based on the
+        current platform.
+        """
+        super().__init__(*args, **kwargs)
+        self.tmpdir = Path(tempfile.TemporaryDirectory().name)
+        self.tmpdir.mkdir(parents=True, exist_ok=True)
+
+    def clean(self, versions: list[str]) -> None:  # noqa: ARG002
+        """Clean up any files created by the build hook."""
+        for ffi in (PKG_DIR / "v3").glob("__init__.*"):
+            if ffi.suffix in (".so", ".dylib", ".dll", ".a", ".pyd"):
+                ffi.unlink()
+
+    def initialize(
+        self,
+        version: str,  # noqa: ARG002
+        build_data: dict[str, Any],
+    ) -> None:
+        """Hook into Hatchling's build process."""
+        ffi_version = ".".join(self.metadata.version.split(".")[:3])
+        if not ffi_version:
+            self.app.display_error("Failed to determine Pact FFI version.")
+
+        try:
+            build_data["force_include"] = self._install(ffi_version)
+        except UnsupportedPlatformError as err:
+            msg = f"Pact FFI library is not available for {err.platform}"
+            self.app.display_error(msg)
+
+        self.app.display_debug(f"Wheel artifacts: {build_data['force_include']}")
+        build_data["tag"] = self._infer_tag()
+
+    def _sys_tag_platform(self) -> str:
+        """
+        Get the platform tag from the current system tags.
+
+        This is used to determine the target platform for the Pact library.
+        """
+        return next(t.platform for t in sys_tags())
+
+    def _install(self, version: str) -> dict[str, str]:
+        """
+        Install the Pact library binary.
+
+        This will download the Pact library binary for the current platform and
+        build the CFFI bindings for it.
+
+        Args:
+            version: The Pact version to install.
+        """
+        # 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"))
+            )
+        else:
+            dll_lib = None
+
+        # Compile the FFI extension
+        extension = self._compile(lib, header)
+
+        # Copy into the package directory, using the ABI3 marking for broad
+        # compatibility.
+        # NOTE: Windows does _not_ use the version infixation
+        extension_name, _, suffix = extension.name.split(".")
+        infix = ".abi3" if os.name != "nt" else ""
+        extension_dest = f"{extension_name}{infix}.{suffix}"
+        shutil.copy(extension, PKG_DIR / extension_dest)
+
+        if pact_lib_dir := os.getenv("PACT_LIB_DIR"):
+            # Copy the library to make it available by other processes (such as
+            # the wheel repair).
+            dir_path = Path(pact_lib_dir)
+            dir_path.mkdir(parents=True, exist_ok=True)
+            self.app.display_debug(f"Copying {lib.name} into {dir_path}")
+            shutil.copy(lib, dir_path / lib.name)
+            if dll_lib:
+                self.app.display_debug(f"Copying {dll_lib.name} into {dir_path}")
+                shutil.copy(dll_lib, dir_path / dll_lib.name)
+
+        return {str(extension): f"pact_ffi/{extension_dest}"}
+
+    def _lib_url(self, version: str) -> str:  # noqa: C901, PLR0912
+        """
+        Generate the download URL for the Pact library.
+
+        Args:
+            version: The upstream Pact version.
+
+        Returns:
+            The URL to download the Pact library from.
+
+        Raises:
+            UnsupportedPlatformError:
+                If the current platform is not supported.
+        """
+        wheel_platform = self._sys_tag_platform()
+
+        aarch64 = ("_arm64", "_aarch64")
+        x86_64 = ("_x86_64", "_amd64")
+
+        # 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)
+
+        else:
+            raise UnsupportedPlatformError(wheel_platform)
+
+        return PACT_LIB_URL.format(
+            version=version,
+            prefix=prefix,
+            os=os,
+            platform=platform,
+            suffix=suffix,
+            ext=ext,
+        )
+
+    def _extract_lib(self, artifact: Path) -> Path:
+        """
+        Extract the Pact library.
+
+        Args:
+            artifact: The URL to download the Pact binaries from.
+        """
+        target = PKG_DIR / (artifact.name.split("-")[0] + artifact.suffixes[-2])
+        with (
+            gzip.open(artifact, "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}")
+        return target
+
+    def _compile(self, lib: Path, header: Path) -> Path:
+        """
+        Build the CFFI bindings for the Pact library.
+
+        Args:
+            lib:
+                The path to the Pact library binary.
+
+            header:
+                The path to the Pact library header file.
+        """
+        if os.name == "nt":
+            extra_libs = [
+                "advapi32",
+                "bcrypt",
+                "crypt32",
+                "iphlpapi",
+                "ncrypt",
+                "netapi32",
+                "ntdll",
+                "ole32",
+                "oleaut32",
+                "pdh",
+                "powrprof",
+                "psapi",
+                "secur32",
+                "shell32",
+                "user32",
+                "userenv",
+                "ws2_32",
+            ]
+        else:
+            extra_libs = []
+
+        ffibuilder = cffi.FFI()
+        ffibuilder.cdef(
+            "\n".join(
+                line
+                for line in header.read_text().splitlines()
+                if not line.strip().startswith("#")
+            )
+        )
+
+        linker_args: list[str] = []
+        if os.name == "posix":
+            linker_args.append(f"-Wl,-rpath,{lib.parent}")
+        elif os.name == "nt":
+            # Windows has no equivalent to rpath, instead, the end-user must
+            # ensure that the PATH environment variable is updated to include
+            # the directory containing the Pact library.
+            self.app.display_warning(
+                "On Windows, ensure that the PATH environment variable includes "
+                f"{lib.parent} to load the Pact library at runtime."
+            )
+
+        ffibuilder.set_source(
+            "ffi",
+            header.read_text(),
+            libraries=["pact_ffi", *extra_libs],
+            library_dirs=[str(lib.parent)],
+            extra_link_args=linker_args,
+        )
+        extension = Path(ffibuilder.compile(verbose=True, tmpdir=str(self.tmpdir)))
+        self.app.display_debug(f"Compiled CFFI bindings to {extension}")
+        return extension
+
+    def _download(self, url: str) -> Path:
+        """
+        Download the target URL.
+
+        This will download the target URL to the `pact/data` directory. If the
+        download artifact is already present, its path will be returned.
+
+        If `extract` is True, the downloaded artifact will be extracted and the
+        path to the extract file will be returned instead.
+
+        Args:
+            url: The URL to download
+            extract: Whether to extract the downloaded artifact.
+
+        Return:
+            The path to the downloaded artifact.
+        """
+        filename = url.split("/")[-1]
+        artifact = PKG_DIR / "data" / filename
+        artifact.parent.mkdir(parents=True, exist_ok=True)
+
+        if not artifact.exists():
+            self.app.display_debug(f"Downloading {url} to {artifact}")
+            urllib.request.urlretrieve(url, artifact)  # noqa: S310
+        else:
+            self.app.display_debug(f"Using cached artifact {artifact}")
+
+        return artifact
+
+    def _infer_tag(self) -> str:
+        """
+        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 `py3-abi3-{platform}` tags for
+        the wheels.
+        """
+        python_version = f"{sys.version_info.major}{sys.version_info.minor}"
+
+        platform = self._sys_tag_platform()
+
+        # On macOS, the version needs to be set based on the deployment target
+        # (i.e., the version of the system libraries).
+        if sys.platform == "darwin" and (
+            deployment_target := os.getenv("MACOSX_DEPLOYMENT_TARGET")
+        ):
+            target = deployment_target.replace(".", "_")
+            if platform.endswith("_arm64"):
+                platform = f"macosx_{target}_arm64"
+            elif platform.endswith("_x86_64"):
+                platform = f"macosx_{target}_x86_64"
+            else:
+                raise UnsupportedPlatformError(platform)
+
+        return f"cp{python_version}-abi3-{platform}"