hatch-ziglang 0.1.0__py3-none-any.whl

hatch_ziglang/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from hatch_ziglang.plugin import ZigBuildHook
+
+__all__ = ["ZigBuildHook"]

hatch_ziglang/hooks.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from hatchling.plugin import hookimpl
+
+from hatch_ziglang.plugin import ZigBuildHook
+
+
+@hookimpl
+def hatch_register_build_hook() -> type[ZigBuildHook]:
+    return ZigBuildHook

hatch_ziglang/plugin.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# cibuildwheel builds every macOS wheel on the arm64 runner and asks for a
+# specific arch through ARCHFLAGS; translate it into a Zig cross-compile target
+# so the produced `.so` matches the wheel tag delocate enforces.
+_MACOS_ZIG_ARCH = {"arm64": "aarch64-macos", "x86_64": "x86_64-macos"}
+
+
+def _zig_target_args() -> list[str]:
+    archflags = os.environ.get("ARCHFLAGS", "")
+    arches = archflags.split()[1::2]  # "-arch x86_64 -arch arm64" -> ["x86_64", "arm64"]
+    if len(arches) != 1 or sys.platform != "darwin":
+        return []
+    arch = _MACOS_ZIG_ARCH.get(arches[0])
+    if not arch:
+        return []
+    # Pin the binary's minimum macOS to MACOSX_DEPLOYMENT_TARGET (set by
+    # cibuildwheel) so the wheel tag and the `.so`'s required OS version agree
+    # and delocate accepts the repaired wheel.
+    min_version = os.environ.get("MACOSX_DEPLOYMENT_TARGET")
+    target = f"{arch}.{min_version}" if min_version else arch
+    return [f"-Dtarget={target}"]
+
+
+def _zig_command() -> list[str]:
+    """Resolve how to invoke Zig: a `zig` on PATH, else the `ziglang` pip package.
+
+    The pip fallback (`python -m ziglang`) works identically on the host and inside
+    cibuildwheel's manylinux containers, where a host-installed `zig` isn't visible.
+    """
+    if shutil.which("zig"):
+        return ["zig"]
+    try:
+        import ziglang  # type: ignore[import-not-found]  # noqa: F401
+    except ImportError:
+        raise RuntimeError(
+            "Zig toolchain not found: install Zig and put it on PATH, or `pip install ziglang`."
+        ) from None
+    return [sys.executable, "-m", "ziglang"]
+
+
+class ZigBuildHook(BuildHookInterface[Any]):
+    """Compile a Zig extension against the building interpreter during the wheel build.
+
+    This makes `uv build` / `pip wheel` / cibuildwheel produce a correct, platform-tagged
+    wheel with no out-of-band step: the `.so` is built here, against `sys.executable`, and
+    `build.zig` installs it into `<package>/` as `_<package><EXT_SUFFIX>`.
+
+    Configured in `[tool.hatch.build.targets.wheel.hooks.zig]`:
+
+        package   the import package directory; the artifact is `<package>/_<package><EXT_SUFFIX>`
+        optimize  Zig `-Doptimize` mode (default ReleaseFast); overridable via HATCH_ZIG_BUILD_MODE
+
+    `build.zig` receives the interpreter paths through `HATCH_ZIG_PYTHON_INCLUDE` and
+    `HATCH_ZIG_EXT_SUFFIX`.
+    """
+
+    PLUGIN_NAME = "zig"
+
+    @property
+    def _package(self) -> str:
+        package = self.config.get("package")
+        if not package:
+            raise ValueError("hatch-zig requires `package` in [tool.hatch.build.targets.wheel.hooks.zig]")
+        return str(package)
+
+    @property
+    def _optimize(self) -> str:
+        return os.environ.get("HATCH_ZIG_BUILD_MODE", str(self.config.get("optimize", "ReleaseFast")))
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        if self.target_name != "wheel":
+            return
+
+        root = Path(self.root)
+        include = sysconfig.get_path("platinclude")
+        ext_suffix = sysconfig.get_config_var("EXT_SUFFIX")
+        if not include or not ext_suffix:
+            raise RuntimeError("could not resolve platinclude / EXT_SUFFIX from the building interpreter")
+
+        env = {**os.environ, "HATCH_ZIG_PYTHON_INCLUDE": include, "HATCH_ZIG_EXT_SUFFIX": ext_suffix}
+        subprocess.run(
+            [*_zig_command(), "build", f"-Doptimize={self._optimize}", *_zig_target_args()],
+            cwd=root,
+            env=env,
+            check=True,
+        )
+
+        artifact = f"{self._package}/_{self._package}{ext_suffix}"
+        if not (root / artifact).exists():
+            raise RuntimeError(f"zig build did not produce {artifact}")
+
+        # Tag the wheel for this interpreter + platform rather than py3-none-any.
+        build_data["pure_python"] = False
+        build_data["infer_tag"] = True
+        build_data["artifacts"].append(artifact)
+
+    def clean(self, versions: list[str]) -> None:
+        root = Path(self.root)
+        for suffix in ("so", "pyd"):
+            for path in root.glob(f"{self._package}/_{self._package}*.{suffix}"):
+                path.unlink()
+        print(f"removed compiled extensions; building Zig core via {sys.executable}", file=sys.stderr)

hatch_ziglang-0.1.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: hatch-ziglang
+Version: 0.1.0
+Summary: A Hatch build hook that compiles a Zig extension into the wheel.
+Author-email: Marcelo Trylesinski <marcelotryle@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Hatch
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Zig
+Requires-Python: >=3.10
+Requires-Dist: hatchling
+Description-Content-Type: text/markdown
+
+# hatch-ziglang
+
+A [Hatch](https://hatch.pypa.io/) build hook that compiles a [Zig](https://ziglang.org/) extension
+into the wheel, against the building interpreter, with no out-of-band step.
+
+`uv build` / `pip wheel` / cibuildwheel produce a correct, platform-tagged wheel: the `.so` is built
+during the wheel build against `sys.executable`, and your `build.zig` installs it into the package as
+`_<package><EXT_SUFFIX>`.
+
+## Usage
+
+Add the build requirement and configure the hook in `pyproject.toml`:
+
+```toml
+[build-system]
+requires = ["hatchling", "hatch-ziglang", "ziglang==0.16.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel.hooks.zig]
+package = "yourpkg"
+optimize = "ReleaseFast"  # optional; Zig -Doptimize mode (default ReleaseFast)
+```
+
+| key        | required | description                                                                |
+| ---------- | -------- | -------------------------------------------------------------------------- |
+| `package`  | yes      | the import package directory; artifact is `<package>/_<package><EXT_SUFFIX>` |
+| `optimize` | no       | Zig `-Doptimize` mode (default `ReleaseFast`)                               |
+
+`HATCH_ZIG_BUILD_MODE` overrides `optimize` at build time.
+
+## What `build.zig` receives
+
+The hook runs `zig build -Doptimize=<mode> [-Dtarget=...]` and passes the interpreter paths through
+two environment variables your `build.zig` reads:
+
+- `HATCH_ZIG_PYTHON_INCLUDE` - the building interpreter's `platinclude`
+- `HATCH_ZIG_EXT_SUFFIX` - the building interpreter's `EXT_SUFFIX` (e.g. `.cpython-312-darwin.so`)
+
+On macOS under cibuildwheel, the hook reads `ARCHFLAGS` and `MACOSX_DEPLOYMENT_TARGET` to emit a
+matching `-Dtarget=<arch>-macos[.<min>]`, so the compiled `.so` and the wheel tag agree and delocate
+accepts the repaired wheel.
+
+Zig is resolved from a `zig` on `PATH`, falling back to the `ziglang` pip package (`python -m ziglang`),
+which works inside cibuildwheel's manylinux containers.

hatch_ziglang-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+hatch_ziglang/__init__.py,sha256=qz4ZKjWmBW8Pf2P3CQDDGgG4uNy6MH4E1L_UMzyuHuo,110
+hatch_ziglang/hooks.py,sha256=yXuaQjSsogyHjncTVHN0KUoy-CqDRbIOpFQXgF0T44Y,212
+hatch_ziglang/plugin.py,sha256=QXCmteW_aQNqrLEJqTHLbMRPkBRZ5-N-kNtQ7pOevsI,4503
+hatch_ziglang/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hatch_ziglang-0.1.0.dist-info/METADATA,sha256=k6xlkfxOhfEMifdnuCCQrNHIL-55u9aQuHHHtr81wzU,2486
+hatch_ziglang-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+hatch_ziglang-0.1.0.dist-info/entry_points.txt,sha256=Af31AaHRsiqgKnMGc8XBKzVGBX2S4jE3rnlopcZDkQE,34
+hatch_ziglang-0.1.0.dist-info/licenses/LICENSE,sha256=kc2txe_3vm9n3Rz-GRj36CvCVyLpZD9WHaOEUtL2PPg,1506
+hatch_ziglang-0.1.0.dist-info/RECORD,,

hatch_ziglang-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

hatch_ziglang-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hatch]
+zig = hatch_ziglang.hooks

hatch_ziglang-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Marcelo Trylesinski
+
+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.