efa 2026.7.18__tar.gz

efa-2026.7.18/CLAUDE.md

@@ -0,0 +1,61 @@
+# EFA Package Guide
+
+`efa` is a thin Cython wrapper over `libibverbs` and EFA's direct-verbs API.
+Keep the package low-level: one Python object per verbs resource, explicit
+state transitions, no hidden threads, no torch import, and no CUDA linkage.
+
+## Layout
+
+```text
+efa/
+  setup.py
+  pyproject.toml
+  src/efa/
+    _libefa.pxd
+    _efa.pyx
+    enums.py
+    helpers.py
+    cuda.py
+  tests/
+```
+
+## Build And Test
+
+```bash
+uv pip install --python .venv/bin/python -e . --no-build-isolation
+.venv/bin/python -m pytest -rs
+```
+
+Rebuild after changing `_efa.pyx` or `_libefa.pxd`. Generated C, extension,
+cache, wheel, and sdist files are ignored.
+
+## Binding Conventions
+
+- Resolve exported `ibv_*` and `efadv_*` symbols with `dlopen`/`dlsym`.
+- Call header-only provider dispatch functions directly from Cython.
+- Hold Python parent references for every live C resource.
+- Make `close()` idempotent and release resources in `__dealloc__`.
+- Convert Python values before entering `nogil`.
+- Preserve positive return-code errors; do not assume every failure uses
+  `errno`.
+- Convert immediate data to network byte order when posting and back to host
+  order on completion.
+- Treat optional EFA 1.3/1.4 entry points as optional symbols with clear
+  runtime errors.
+
+## EFA Details
+
+SRD uses `IBV_QPT_DRIVER` plus `EFADV_QP_DRIVER_TYPE_SRD`. It follows the UD
+RESET to INIT to RTR to RTS transitions, and each send supplies an AH, remote
+QPN, and qkey. One-sided operations also require the responder to have an AH
+for the requester; otherwise EFA reports vendor status `0x0e`.
+
+All EFA sends are signaled unless `sq_sig_all` was enabled. RDMA operations
+use the extended `ibv_wr_*` API. SEND size is bounded by
+`PortAttr.max_msg_sz`; RDMA size is bounded by
+`EfaDeviceAttr.max_rdma_size`.
+
+GPU registration prefers dma-buf and falls back to `nvidia_peermem`.
+Outbound CUDA work must complete before posting. Inbound data needs
+`cuFlushGPUDirectRDMAWrites` after the network completion or notification and
+before CUDA consumption.

efa-2026.7.18/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Tristan Rice
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

efa-2026.7.18/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md CLAUDE.md LICENSE MANIFEST.in pyproject.toml setup.py
+include src/efa/*.pyx src/efa/*.pxd
+recursive-include tests *.py

efa-2026.7.18/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: efa
+Version: 2026.7.18
+Summary: Low-level Pythonic bindings for AWS EFA (SRD RDMA via libibverbs/libefa), with GPUDirect support
+Author: Tristan Rice
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://d4l3k.github.io/rdma4py/efa/
+Project-URL: Homepage, https://github.com/d4l3k/rdma4py
+Project-URL: Repository, https://github.com/d4l3k/rdma4py
+Keywords: efa,srd,rdma,ibverbs,aws,gpudirect,networking
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: numpy; extra == "test"
+Provides-Extra: gpu
+Requires-Dist: torch; extra == "gpu"
+Dynamic: license-file
+
+# efa
+
+Low-level Python bindings for AWS Elastic Fabric Adapter (EFA), including
+Scalable Reliable Datagram (SRD), one-sided RDMA, and GPUDirect transfers
+to and from torch CUDA tensors.
+
+The package wraps `libibverbs` and EFA's `libefa` direct-verbs API in Cython.
+Its data path calls the provider's inline verbs directly, releases the GIL
+around blocking and posting operations, and does not import torch or link
+against CUDA.
+
+- No Python runtime dependencies.
+- SRD and UD queue pairs with SEND, RDMA read, and RDMA write operations.
+- Host buffers, CUDA device pointers, and dma-buf memory registration.
+- Classic and extended CQs, sender GID and unsolicited-write metadata, and
+  direct EFA CQ, SQ, RQ, MR, and AH queries.
+- One Linux `abi3` wheel for CPython 3.9 and newer.
+
+## Requirements
+
+- Linux on an AWS instance with one or more EFA devices attached.
+- `libibverbs.so.1` and `libefa.so.1` at runtime. The AWS EFA installer and
+  current `rdma-core` distributions provide both.
+- The EFA device nodes available inside the process or container, normally
+  `/dev/infiniband/uverbs*`.
+- A C compiler, Cython, and the `rdma-core` development headers only when
+  building from source.
+
+For GPUDirect, the EFA device and instance type must support RDMA read/write,
+and the NVIDIA driver must support dma-buf export or `nvidia_peermem`.
+
+## Install
+
+```bash
+pip install efa
+```
+
+To build from this checkout:
+
+```bash
+pip install "Cython>=3.0" "setuptools>=77" wheel
+pip install ./efa
+```
+
+## SRD Quickstart
+
+SRD is reliable and connectionless. Each process creates a ready-to-send QP,
+exchanges a 24-byte `EndpointInfo` out of band, and resolves the remote GID to
+an address handle:
+
+```python
+import numpy as np
+import efa
+
+dev = efa.get_efa_device_list()[0]
+ctx = dev.open()
+pd = ctx.alloc_pd()
+cq = ctx.create_cq(256)
+qp = pd.create_qp(
+    efa.QPInitAttr(send_cq=cq, recv_cq=cq)
+).prepare(qkey=0x1234)
+
+local_info = efa.local_endpoint_info(qp, qkey=0x1234)
+# Exchange local_info.to_bytes() with the other process.
+remote_info = efa.EndpointInfo.from_bytes(remote_bytes)
+peer = remote_info.peer(pd)
+
+buf = np.zeros(4096, dtype=np.uint8)
+access = (
+    efa.AccessFlags.LOCAL_WRITE
+    | efa.AccessFlags.REMOTE_WRITE
+    | efa.AccessFlags.REMOTE_READ
+)
+mr = efa.reg_tensor(pd, buf, access)
+
+qp.post_send(efa.SendWR(
+    wr_id=1,
+    sg_list=[mr.sge()],
+    opcode=efa.WROpcode.SEND,
+    send_flags=efa.SendFlags.SIGNALED,
+    dest=peer,
+))
+for wc in cq.poll(16):
+    wc.raise_for_status()
+```
+
+Every handle is an idempotent context manager. A QP retains its PD and CQs,
+an MR retains its PD and backing tensor, and an SGE retains the MR it addresses.
+
+### One-sided RDMA
+
+EFA requires the responder to have an address handle for the requester before
+it accepts RDMA reads or writes. Both processes should therefore resolve the
+other process's `EndpointInfo`, even if traffic is currently one-way. A
+missing reverse AH completes with `REM_OP_ERR` and EFA vendor status `0x0e`
+(`REMOTE_ERROR_UNKNOWN_PEER`).
+
+Large buffers can be split at the device's `max_rdma_size`:
+
+```python
+wrs = efa.write_wrs(local_mr, peer, remote_addr, remote_rkey)
+qp.post_send(wrs)
+```
+
+`read_wrs` provides the corresponding RDMA-read operation. Every generated WR
+is signaled, as required by EFA.
+
+## GPUDirect With Torch
+
+The optional `efa.cuda` module is torch-free and duck-types objects exposing
+`data_ptr()`, `numel()`, and `element_size()`. For torch's dma-buf path, enable
+VMM-backed allocations before CUDA initializes:
+
+```python
+import os
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+import torch
+import efa
+import efa.cuda
+
+src = torch.arange(1 << 20, dtype=torch.float32, device="cuda:0")
+dst = torch.zeros_like(src)
+
+src_mr = efa.cuda.register_tensor(pd, src, access)
+dst_mr = efa.cuda.register_tensor(pd, dst, access)
+
+torch.cuda.synchronize(src.device)
+qp.post_send(efa.SendWR(
+    wr_id=2,
+    sg_list=[src_mr.sge()],
+    opcode=efa.WROpcode.RDMA_WRITE,
+    send_flags=efa.SendFlags.SIGNALED,
+    remote_addr=remote_dst_addr,
+    rkey=remote_dst_rkey,
+    dest=peer,
+))
+```
+
+After the receiver observes a completion or protocol-level write
+notification, it must order inbound NIC writes before CUDA consumes the
+destination:
+
+```python
+with torch.cuda.device(dst.device):
+    efa.cuda.flush_gpudirect_writes()
+```
+
+`register_tensor` first exports a dma-buf fd and calls `ibv_reg_dmabuf_mr`.
+If that path is unavailable, it falls back to `ibv_reg_mr`, which requires
+`nvidia_peermem`. The returned `GpuMR` retains the tensor allocation and keeps
+the actual CUDA virtual address because `ibv_mr.addr` is not meaningful for a
+dma-buf MR.
+
+## Direct EFA API
+
+| Area | API |
+| --- | --- |
+| Device capabilities | `Context.query_efa_device` |
+| EFA CQ creation | `Context.create_cq_ex` |
+| Sender and unsolicited metadata | `CQEx.poll`, `WC.sgid`, `WC.unsolicited` |
+| CQ layout | `CQ.query_efa`, `CQEx.query_efa` |
+| SQ/RQ layout | `QP.query_wqs` |
+| MR interconnect IDs | `MR.query_efa` |
+| Address-handle number | `AH.ahn` |
+| SRD QP creation | `PD.create_qp` with `QPType.SRD` |
+
+When using unsolicited RDMA write-with-immediate completions, create every
+communicating QP with `QPInitAttr(..., unsolicited_write_recv=True)` and use an
+extended CQ created with `unsolicited=True`. EFA requires peers to negotiate
+the same QP feature set.
+
+The direct layout queries expose process-local addresses for advanced
+consumers. They do not transfer ownership of provider memory.
+
+## Testing
+
+```bash
+pip install -e "./efa[test,gpu]"
+cd efa
+pytest -rs
+```
+
+Tests marked `integration` exercise real EFA hardware. Tests marked `gpu`
+perform torch-verified GPU-to-GPU, GPU-to-host, and host-to-GPU transfers.
+Unavailable hardware capabilities are skipped explicitly.
+
+## License
+
+BSD-3-Clause. See `LICENSE`.

efa-2026.7.18/README.md

@@ -0,0 +1,190 @@
+# efa
+
+Low-level Python bindings for AWS Elastic Fabric Adapter (EFA), including
+Scalable Reliable Datagram (SRD), one-sided RDMA, and GPUDirect transfers
+to and from torch CUDA tensors.
+
+The package wraps `libibverbs` and EFA's `libefa` direct-verbs API in Cython.
+Its data path calls the provider's inline verbs directly, releases the GIL
+around blocking and posting operations, and does not import torch or link
+against CUDA.
+
+- No Python runtime dependencies.
+- SRD and UD queue pairs with SEND, RDMA read, and RDMA write operations.
+- Host buffers, CUDA device pointers, and dma-buf memory registration.
+- Classic and extended CQs, sender GID and unsolicited-write metadata, and
+  direct EFA CQ, SQ, RQ, MR, and AH queries.
+- One Linux `abi3` wheel for CPython 3.9 and newer.
+
+## Requirements
+
+- Linux on an AWS instance with one or more EFA devices attached.
+- `libibverbs.so.1` and `libefa.so.1` at runtime. The AWS EFA installer and
+  current `rdma-core` distributions provide both.
+- The EFA device nodes available inside the process or container, normally
+  `/dev/infiniband/uverbs*`.
+- A C compiler, Cython, and the `rdma-core` development headers only when
+  building from source.
+
+For GPUDirect, the EFA device and instance type must support RDMA read/write,
+and the NVIDIA driver must support dma-buf export or `nvidia_peermem`.
+
+## Install
+
+```bash
+pip install efa
+```
+
+To build from this checkout:
+
+```bash
+pip install "Cython>=3.0" "setuptools>=77" wheel
+pip install ./efa
+```
+
+## SRD Quickstart
+
+SRD is reliable and connectionless. Each process creates a ready-to-send QP,
+exchanges a 24-byte `EndpointInfo` out of band, and resolves the remote GID to
+an address handle:
+
+```python
+import numpy as np
+import efa
+
+dev = efa.get_efa_device_list()[0]
+ctx = dev.open()
+pd = ctx.alloc_pd()
+cq = ctx.create_cq(256)
+qp = pd.create_qp(
+    efa.QPInitAttr(send_cq=cq, recv_cq=cq)
+).prepare(qkey=0x1234)
+
+local_info = efa.local_endpoint_info(qp, qkey=0x1234)
+# Exchange local_info.to_bytes() with the other process.
+remote_info = efa.EndpointInfo.from_bytes(remote_bytes)
+peer = remote_info.peer(pd)
+
+buf = np.zeros(4096, dtype=np.uint8)
+access = (
+    efa.AccessFlags.LOCAL_WRITE
+    | efa.AccessFlags.REMOTE_WRITE
+    | efa.AccessFlags.REMOTE_READ
+)
+mr = efa.reg_tensor(pd, buf, access)
+
+qp.post_send(efa.SendWR(
+    wr_id=1,
+    sg_list=[mr.sge()],
+    opcode=efa.WROpcode.SEND,
+    send_flags=efa.SendFlags.SIGNALED,
+    dest=peer,
+))
+for wc in cq.poll(16):
+    wc.raise_for_status()
+```
+
+Every handle is an idempotent context manager. A QP retains its PD and CQs,
+an MR retains its PD and backing tensor, and an SGE retains the MR it addresses.
+
+### One-sided RDMA
+
+EFA requires the responder to have an address handle for the requester before
+it accepts RDMA reads or writes. Both processes should therefore resolve the
+other process's `EndpointInfo`, even if traffic is currently one-way. A
+missing reverse AH completes with `REM_OP_ERR` and EFA vendor status `0x0e`
+(`REMOTE_ERROR_UNKNOWN_PEER`).
+
+Large buffers can be split at the device's `max_rdma_size`:
+
+```python
+wrs = efa.write_wrs(local_mr, peer, remote_addr, remote_rkey)
+qp.post_send(wrs)
+```
+
+`read_wrs` provides the corresponding RDMA-read operation. Every generated WR
+is signaled, as required by EFA.
+
+## GPUDirect With Torch
+
+The optional `efa.cuda` module is torch-free and duck-types objects exposing
+`data_ptr()`, `numel()`, and `element_size()`. For torch's dma-buf path, enable
+VMM-backed allocations before CUDA initializes:
+
+```python
+import os
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+import torch
+import efa
+import efa.cuda
+
+src = torch.arange(1 << 20, dtype=torch.float32, device="cuda:0")
+dst = torch.zeros_like(src)
+
+src_mr = efa.cuda.register_tensor(pd, src, access)
+dst_mr = efa.cuda.register_tensor(pd, dst, access)
+
+torch.cuda.synchronize(src.device)
+qp.post_send(efa.SendWR(
+    wr_id=2,
+    sg_list=[src_mr.sge()],
+    opcode=efa.WROpcode.RDMA_WRITE,
+    send_flags=efa.SendFlags.SIGNALED,
+    remote_addr=remote_dst_addr,
+    rkey=remote_dst_rkey,
+    dest=peer,
+))
+```
+
+After the receiver observes a completion or protocol-level write
+notification, it must order inbound NIC writes before CUDA consumes the
+destination:
+
+```python
+with torch.cuda.device(dst.device):
+    efa.cuda.flush_gpudirect_writes()
+```
+
+`register_tensor` first exports a dma-buf fd and calls `ibv_reg_dmabuf_mr`.
+If that path is unavailable, it falls back to `ibv_reg_mr`, which requires
+`nvidia_peermem`. The returned `GpuMR` retains the tensor allocation and keeps
+the actual CUDA virtual address because `ibv_mr.addr` is not meaningful for a
+dma-buf MR.
+
+## Direct EFA API
+
+| Area | API |
+| --- | --- |
+| Device capabilities | `Context.query_efa_device` |
+| EFA CQ creation | `Context.create_cq_ex` |
+| Sender and unsolicited metadata | `CQEx.poll`, `WC.sgid`, `WC.unsolicited` |
+| CQ layout | `CQ.query_efa`, `CQEx.query_efa` |
+| SQ/RQ layout | `QP.query_wqs` |
+| MR interconnect IDs | `MR.query_efa` |
+| Address-handle number | `AH.ahn` |
+| SRD QP creation | `PD.create_qp` with `QPType.SRD` |
+
+When using unsolicited RDMA write-with-immediate completions, create every
+communicating QP with `QPInitAttr(..., unsolicited_write_recv=True)` and use an
+extended CQ created with `unsolicited=True`. EFA requires peers to negotiate
+the same QP feature set.
+
+The direct layout queries expose process-local addresses for advanced
+consumers. They do not transfer ownership of provider memory.
+
+## Testing
+
+```bash
+pip install -e "./efa[test,gpu]"
+cd efa
+pytest -rs
+```
+
+Tests marked `integration` exercise real EFA hardware. Tests marked `gpu`
+perform torch-verified GPU-to-GPU, GPU-to-host, and host-to-GPU transfers.
+Unavailable hardware capabilities are skipped explicitly.
+
+## License
+
+BSD-3-Clause. See `LICENSE`.

efa-2026.7.18/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=77", "Cython>=3.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "efa"
+dynamic = ["version"]
+description = "Low-level Pythonic bindings for AWS EFA (SRD RDMA via libibverbs/libefa), with GPUDirect support"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+authors = [{ name = "Tristan Rice" }]
+keywords = ["efa", "srd", "rdma", "ibverbs", "aws", "gpudirect", "networking"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Cython",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Networking",
+]
+# No runtime dependencies: the library only needs libibverbs + libefa at load time.
+dependencies = []
+
+[tool.setuptools.dynamic]
+version = { attr = "efa._version.__version__" }
+
+[project.optional-dependencies]
+test = ["pytest>=7", "numpy"]
+gpu = ["torch"]
+
+[project.urls]
+Documentation = "https://d4l3k.github.io/rdma4py/efa/"
+Homepage = "https://github.com/d4l3k/rdma4py"
+Repository = "https://github.com/d4l3k/rdma4py"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = false
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: exercises real EFA hardware (loopback / two-NIC)",
+    "gpu: requires a CUDA GPU and torch (GPUDirect)",
+]
+testpaths = ["tests"]
+
+# Single abi3 wheel per platform (works on CPython 3.9+). The extension is
+# built against rdma-core headers but dlopens libibverbs/libefa at runtime, so
+# the build image only needs the -devel headers; the wheel has no external
+# NEEDED library and is trivially manylinux-compliant.
+[tool.cibuildwheel]
+# cibuildwheel selects a CPython build environment; setup.py retags the
+# resulting extension as cp39-abi3 via Py_LIMITED_API.
+build = "cp39-*"
+build-frontend = "build"
+skip = ["*-musllinux*"]
+test-requires = ["pytest", "numpy"]
+# Hardware/GPU tests self-skip when no EFA NIC/CUDA is present in CI.
+test-command = "pytest -rs -m 'not gpu' {package}/tests"
+
+[tool.cibuildwheel.linux]
+# manylinux images are AlmaLinux-based (dnf/yum).
+before-all = "dnf install -y rdma-core-devel || yum install -y rdma-core-devel"

efa-2026.7.18/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

efa-2026.7.18/setup.py

@@ -0,0 +1,71 @@
+"""Build the efa Cython extension.
+
+The extension is compiled against the ``rdma-core`` headers (for struct layouts
+and the ``static inline`` data-path verbs / extended work-request API) but is
+**not** linked against ``libibverbs`` or ``libefa``: the exported symbols are
+resolved at import time with ``dlopen``/``dlsym`` (see ``_efa.pyx``). The
+header include path is discovered with ``pkg-config`` when available.
+
+It is built against the CPython **Limited API** (abi3), so a single wheel works
+across CPython 3.9+.
+"""
+
+from __future__ import annotations
+
+import shlex
+import subprocess
+
+from setuptools import Extension, setup
+
+try:
+    from Cython.Build import cythonize
+except ImportError as exc:  # pragma: no cover - build-time only
+    raise SystemExit(
+        "Cython is required to build efa. Install it with `pip install Cython`."
+    ) from exc
+
+# CPython Limited API floor == requires-python floor (3.9).
+LIMITED_API_VERSION = "0x03090000"
+
+
+def _pkg_config(*args: str) -> list[str]:
+    try:
+        out = subprocess.check_output(["pkg-config", *args], text=True)
+    except (OSError, subprocess.CalledProcessError):
+        return []
+    return shlex.split(out)
+
+
+def _include_dirs() -> list[str]:
+    dirs = []
+    for flag in _pkg_config("--cflags-only-I", "libefa", "libibverbs"):
+        if flag.startswith("-I") and flag[2:] not in dirs:
+            dirs.append(flag[2:])
+    return dirs
+
+
+extensions = [
+    Extension(
+        "efa._efa",
+        ["src/efa/_efa.pyx"],
+        include_dirs=_include_dirs(),
+        # No libibverbs/libefa link: they are dlopen'd at runtime. libdl
+        # provides dlopen/dlsym (a no-op stub on glibc >= 2.34).
+        libraries=["dl"],
+        define_macros=[("Py_LIMITED_API", LIMITED_API_VERSION)],
+        py_limited_api=True,
+    ),
+]
+
+setup(
+    ext_modules=cythonize(
+        extensions,
+        language_level="3",
+        compiler_directives={
+            "annotation_typing": False,
+            "embedsignature": True,
+            "binding": True,
+        },
+    ),
+    options={"bdist_wheel": {"py_limited_api": "cp39"}},
+)