nbxtensor 0.0.3__tar.gz → 0.0.4__tar.gz

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.4] - 2026-11-07
+
+### Added
+- **Triton for the Apple GPU in one command**: `python -m nbxtensor install-metal` installs the Metal wheels of the
+  project's fork NeuroBrix/triton-ext (Triton built with triton-ext, and imperatormk's AppleGPU backend as
+  `nbx-triton-apple`, triton-lang/triton-ext#126), each by the release URL and sha256 written in the library,
+  through pip with `--no-deps --require-hashes --no-index` — never an extra index nor a package name resolved on PyPI. The
+  wheels are for Python 3.12 and macOS 15 or later (release apple-v0.1.0+triton3.8.0); it refuses by name off an
+  Apple-silicon Mac, on another Python, or below the macOS the wheels are built for. `python -m nbxtensor doctor` on a Mac
+  without it says so and names the command; the Metal backend's refusal names it too. On a Mac, nbxtensor depends on
+  `pyobjc-framework-Metal`, through which it opens the Metal device; without it the run fell to a CPU profile and was
+  refused for triton-cpu, it is now refused by name with its install line.
+
+### Fixed
+- **nbxtensor installs on a Mac**: it depended on `triton` on every platform, and PyPI publishes no Triton for macOS, so
+  `pip install nbxtensor` — and with it the NeuroBrix engine, even its PyTorch engine on MPS — could not resolve on a
+  clean macOS environment. Triton is now a dependency where PyPI has it; on a Mac it is built from source with its Metal
+  backend (the README's install), and the library says by name what to build when it is absent.
+
 ## [0.0.3] - 2026-11-06
 
 ### Fixed
@@ -143,7 +162,8 @@ memory; the fix is in test).
 - **`flash_decode_split_kernel` and its route**: armed only by an environment switch (`NBX_FLASH_DECODE`, with `NBX_FD_BLOCK_N` and `NBX_FD_SEG`) and measured slower than the vector decode kernels; `flash_decode.py` keeps the fixed-order reduce they share.
 - **`conv1d_forward_kernel`**: launched by no route (a 1-D convolution runs through `conv2d`).
 
-[Unreleased]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.3...HEAD
+[Unreleased]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.4...HEAD
+[0.0.4]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.3...v0.0.4
 [0.0.3]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.2...v0.0.3
 [0.0.2]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.1...v0.0.2
 [0.0.1]: https://github.com/NeuroBrix/nbxtensor/releases/tag/v0.0.1

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nbxtensor
-Version: 0.0.3
+Version: 0.0.4
 Summary: Run AI models without PyTorch: tensors, Triton kernels, planned memory and certified tuning, wherever Triton runs — NVIDIA, AMD, Intel and Apple GPUs.
 Project-URL: Homepage, https://github.com/NeuroBrix/nbxtensor
 Project-URL: Source, https://github.com/NeuroBrix/nbxtensor
@@ -12,8 +12,9 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: numpy
 Requires-Dist: nvidia-cuda-runtime-cu12; platform_system == 'Linux'
+Requires-Dist: pyobjc-framework-metal; platform_system == 'Darwin'
 Requires-Dist: pyyaml
-Requires-Dist: triton
+Requires-Dist: triton; platform_system != 'Darwin'
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Description-Content-Type: text/markdown
@@ -137,7 +138,7 @@ What changed from one version to the next — added, changed, fixed, removed —
 nbxtensor never needs torch: it is not a dependency, not even an optional one, and the library and its kernels run in
 an environment where torch is not installed (proven on Metal, 2026-10-29: `tools/torch_free_proof.py` records every
 attempt to import torch, caught ones included, and recorded none). Python 3.10 or later; its dependencies are numpy,
-pyyaml and Triton.
+pyyaml and Triton (on a Mac, `pyobjc-framework-Metal` and the Triton `install-metal` brings).
 
 ```
 pip install nbxtensor
@@ -155,14 +156,21 @@ install commands when one is not.
 
 **From the NeuroBrix repository** (contributors): `pip install -e nbxtensor`.
 
-**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS, so Triton and its Metal backend are built from
-source, then nbxtensor is installed into that environment:
+**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS. `install-metal` installs it from the releases of
+the project's fork of triton-ext, [NeuroBrix/triton-ext](https://github.com/NeuroBrix/triton-ext): Triton built with
+`TRITON_EXT_ENABLED=1`, and the AppleGPU backend (the `nbx-triton-apple` wheel) written by imperatormk
+([triton-lang/triton-ext#126](https://github.com/triton-lang/triton-ext/pull/126)); each wheel is checked against the
+sha256 written in the library (Python 3.12, macOS 15 or later):
 
-1. Triton (github.com/triton-lang/triton) built with `TRITON_EXT_ENABLED=1`, which lets out-of-tree backends plug in;
-2. the AppleGPU backend of triton-ext (github.com/triton-lang/triton-ext, `backend/AppleGPU`), installed into the same
-   environment;
-3. `pyobjc-framework-Metal` (the library opens the Metal device through it);
-4. Xcode's Metal toolchain (`xcrun metal` must find the real compiler, not Xcode's placeholder: `TOOLCHAINS=Metal`).
+```
+pip install nbxtensor
+python -m nbxtensor install-metal
+```
+
+Xcode's Metal toolchain is the other requirement (`xcrun metal` must find the real compiler, not Xcode's placeholder:
+`TOOLCHAINS=Metal`); `python -m nbxtensor doctor` says what is missing. To build Triton and its Metal backend yourself
+instead: Triton (github.com/triton-lang/triton) built with `TRITON_EXT_ENABLED=1`, then triton-ext's `backend/AppleGPU`
+installed into the same environment.
 
 `nbxtensor.dtype` and `nbxtensor.shape` need neither a device nor Triton.
 
@@ -492,7 +500,7 @@ with the tensor class (API.md §4).
 
 ## Versions
 
-The first publication was **0.0.1**; this is **0.0.3**. Each fix published after it increments the number (0.0.4,
+The first publication was **0.0.1**; this is **0.0.4**. Each fix published after it increments the number (0.0.5,
 …), with no alpha or beta label. The rewrite of the core in Rust will be **2.0.0**. `nbxtensor.__version__` is the
 installed version.
 

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/README.md

@@ -117,7 +117,7 @@ What changed from one version to the next — added, changed, fixed, removed —
 nbxtensor never needs torch: it is not a dependency, not even an optional one, and the library and its kernels run in
 an environment where torch is not installed (proven on Metal, 2026-10-29: `tools/torch_free_proof.py` records every
 attempt to import torch, caught ones included, and recorded none). Python 3.10 or later; its dependencies are numpy,
-pyyaml and Triton.
+pyyaml and Triton (on a Mac, `pyobjc-framework-Metal` and the Triton `install-metal` brings).
 
 ```
 pip install nbxtensor
@@ -135,14 +135,21 @@ install commands when one is not.
 
 **From the NeuroBrix repository** (contributors): `pip install -e nbxtensor`.
 
-**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS, so Triton and its Metal backend are built from
-source, then nbxtensor is installed into that environment:
+**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS. `install-metal` installs it from the releases of
+the project's fork of triton-ext, [NeuroBrix/triton-ext](https://github.com/NeuroBrix/triton-ext): Triton built with
+`TRITON_EXT_ENABLED=1`, and the AppleGPU backend (the `nbx-triton-apple` wheel) written by imperatormk
+([triton-lang/triton-ext#126](https://github.com/triton-lang/triton-ext/pull/126)); each wheel is checked against the
+sha256 written in the library (Python 3.12, macOS 15 or later):
 
-1. Triton (github.com/triton-lang/triton) built with `TRITON_EXT_ENABLED=1`, which lets out-of-tree backends plug in;
-2. the AppleGPU backend of triton-ext (github.com/triton-lang/triton-ext, `backend/AppleGPU`), installed into the same
-   environment;
-3. `pyobjc-framework-Metal` (the library opens the Metal device through it);
-4. Xcode's Metal toolchain (`xcrun metal` must find the real compiler, not Xcode's placeholder: `TOOLCHAINS=Metal`).
+```
+pip install nbxtensor
+python -m nbxtensor install-metal
+```
+
+Xcode's Metal toolchain is the other requirement (`xcrun metal` must find the real compiler, not Xcode's placeholder:
+`TOOLCHAINS=Metal`); `python -m nbxtensor doctor` says what is missing. To build Triton and its Metal backend yourself
+instead: Triton (github.com/triton-lang/triton) built with `TRITON_EXT_ENABLED=1`, then triton-ext's `backend/AppleGPU`
+installed into the same environment.
 
 `nbxtensor.dtype` and `nbxtensor.shape` need neither a device nor Triton.
 
@@ -472,7 +479,7 @@ with the tensor class (API.md §4).
 
 ## Versions
 
-The first publication was **0.0.1**; this is **0.0.3**. Each fix published after it increments the number (0.0.4,
+The first publication was **0.0.1**; this is **0.0.4**. Each fix published after it increments the number (0.0.5,
 …), with no alpha or beta label. The rewrite of the core in Rust will be **2.0.0**. `nbxtensor.__version__` is the
 installed version.
 

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nbxtensor"
-version = "0.0.3"
+version = "0.0.4"
 description = "Run AI models without PyTorch: tensors, Triton kernels, planned memory and certified tuning, wherever Triton runs — NVIDIA, AMD, Intel and Apple GPUs."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -16,7 +16,11 @@ authors = [{ name = "NeuroBrix" }]
 # On Linux the CUDA runtime library its CUDA backend opens (libcudart.so.12), which the NVIDIA driver does not ship: a clean
 # machine with only the driver found no GPU runtime and the engine read the card as CPU-only (the stable's install test,
 # 2026-11-05). On a machine without an NVIDIA card it is a library nothing opens.
-dependencies = ["numpy", "triton", "pyyaml", "nvidia-cuda-runtime-cu12; platform_system == 'Linux'"]
+# Triton on every platform PyPI publishes it for; macOS has none (the Metal Triton is built from source, with triton-ext's
+# AppleGPU backend — the README's install), so a plain "triton" made the library uninstallable on a Mac (2026-11-06).
+# On a Mac the Metal device is opened through pyobjc's Metal framework; Triton for Metal comes from `install-metal`.
+dependencies = ["numpy", "triton; platform_system != 'Darwin'", "pyyaml", "nvidia-cuda-runtime-cu12; platform_system == 'Linux'",
+                "pyobjc-framework-Metal; platform_system == 'Darwin'"]
 
 [project.urls]
 Homepage = "https://github.com/NeuroBrix/nbxtensor"

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/src/nbxtensor/__init__.py

@@ -13,5 +13,5 @@ first publication is 0.0.1, each fix after it increments, the Rust rewrite is
 """
 
 #: the one version number; `pyproject.toml` states the same (tests/test_version.py)
-__version__ = "0.0.3"
+__version__ = "0.0.4"
 __all__: list = []

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/src/nbxtensor/__main__.py

@@ -1,11 +1,17 @@
 """`python -m nbxtensor doctor`: which GPU backend this machine runs, and for every NVIDIA, AMD or Intel GPU on its PCI
 bus whether the runtime library and the Triton backend it needs are installed — with the vendor's install steps when
-one is missing (`backend.install_help`)."""
+one is missing (`backend.install_help`); on an Apple-silicon Mac, whether Triton for Metal is installed.
+`python -m nbxtensor install-metal [--dry-run]`: install Triton for the Apple GPU from this version's release
+(`backend.install_metal`)."""
 import sys
 
 
 def doctor() -> int:
     from nbxtensor.backend import install_help, runtime
+    from nbxtensor.backend.metal_backend import is_apple_silicon, triton_metal_available
+    if is_apple_silicon() and not triton_metal_available():
+        print("Apple GPU found; Triton for Metal not installed — run: python -m nbxtensor install-metal")
+        return 0
     try:
         backend = runtime.gpu_backend()
         print(f"backend in force: {backend}" + (" (the Apple GPU, through Metal)" if backend == "metal" else ""))
@@ -19,10 +25,14 @@ def doctor() -> int:
 
 def main(argv=None) -> int:
     argv = sys.argv[1:] if argv is None else argv
-    if argv[:1] != ["doctor"]:
-        print("usage: python -m nbxtensor doctor", file=sys.stderr)
-        return 2
-    return doctor()
+    if argv[:1] == ["doctor"]:
+        return doctor()
+    if argv[:1] == ["install-metal"] and set(argv[1:]) <= {"--dry-run"}:
+        import nbxtensor
+        from nbxtensor.backend import install_metal
+        return install_metal.main(nbxtensor.__version__, dry_run="--dry-run" in argv[1:])
+    print("usage: python -m nbxtensor doctor | install-metal [--dry-run]", file=sys.stderr)
+    return 2
 
 
 if __name__ == "__main__":

nbxtensor-0.0.4/src/nbxtensor/backend/install_metal.py

@@ -0,0 +1,107 @@
+"""`python -m nbxtensor install-metal`: install Triton for the Apple GPU — the project's own wheels (Triton built with
+TRITON_EXT_ENABLED=1, and triton-ext's AppleGPU backend as `nbx-triton-apple`), downloaded from the release of the
+project's fork, github.com/NeuroBrix/triton-ext. The AppleGPU backend is imperatormk's (triton-lang/triton-ext#126).
+
+PyPI publishes no Triton for macOS, so a Mac has no Triton after `pip install nbxtensor`. The wheels are fetched from
+the URLs written below, each checked against the sha256 written beside it (`pip --require-hashes`), with `--no-deps`:
+never through an extra index and never by a package name pip would look up on PyPI — anyone can publish a package
+named "triton-apple-backend" there (dependency confusion). A machine other than an Apple-silicon Mac, or a Python the
+table does not cover, is refused by name.
+"""
+from __future__ import annotations
+
+import os
+import platform
+import re
+import subprocess
+import sys
+import tempfile
+from typing import List, Tuple
+
+#: the only place the wheels are fetched from: the releases of the project's fork of triton-ext
+RELEASES = "https://github.com/NeuroBrix/triton-ext/releases/download/"
+
+#: the Metal wheels per CPython tag: (URL of the release asset, sha256 of the file), Triton first; a tag absent here is
+#: refused by name. The fork's release apple-v0.1.0+triton3.8.0 (2026-11-07): Triton 3.8.0 (git 4a15f415) built with
+#: TRITON_EXT_ENABLED=1 and nbx-triton-apple 0.1.0, both macOS 15.0 arm64 (the prebuilt LLVM Triton links is minos 15.0);
+#: sha256 read on the downloaded assets.
+METAL_WHEELS: dict = {
+    "cp312": (
+        (RELEASES + "apple-v0.1.0%2Btriton3.8.0/triton-3.8.0%2Bgit4a15f415.nbx1-cp312-cp312-macosx_15_0_arm64.whl",
+         "b9084dc93ae7f1468062a03e713d49c9add9a1c9a609fae753a7b32a13b7a223"),
+        (RELEASES + "apple-v0.1.0%2Btriton3.8.0/nbx_triton_apple-0.1.0-cp312-cp312-macosx_15_0_arm64.whl",
+         "b9ed95c983b220b1fbf1300481b1e2f52a0435c10ee618ef7ccf60a132fe263c"),
+    ),
+}
+
+
+class InstallMetalRefused(RuntimeError):
+    """This machine or this Python has no Metal wheels in this version's table."""
+
+
+def _python_tag() -> str:
+    return f"cp{sys.version_info.major}{sys.version_info.minor}"
+
+
+def wheels(version: str) -> List[Tuple[str, str]]:
+    """[(url, sha256)] of the wheels this machine installs, or a named refusal."""
+    if not (platform.system() == "Darwin" and platform.machine() == "arm64"):
+        raise InstallMetalRefused(
+            f"install-metal installs Triton for the Apple GPU and runs on an Apple-silicon Mac only (this machine: "
+            f"{platform.system()} {platform.machine()}). Elsewhere Triton comes from PyPI with nbxtensor.")
+    tag = _python_tag()
+    if tag not in METAL_WHEELS:
+        covered = ", ".join(sorted(METAL_WHEELS)) or "none yet"
+        raise InstallMetalRefused(
+            f"nbxtensor {version} carries no Metal wheels for Python {sys.version_info.major}.{sys.version_info.minor} "
+            f"({tag}); covered: {covered}.")
+    entries = list(METAL_WHEELS[tag])
+    need = max(_min_macos(url) for url, _sha in entries)
+    have = _macos_version()
+    if have < need:
+        raise InstallMetalRefused(
+            f"macOS {'.'.join(map(str, need))} required for now: the Metal wheels of nbxtensor {version} are built for "
+            f"macOS {'.'.join(map(str, need))} and later (this Mac: macOS {'.'.join(map(str, have))}).")
+    return entries
+
+
+def _min_macos(url: str) -> Tuple[int, int]:
+    """The lowest macOS a wheel installs on, read from its platform tag (`macosx_15_0_arm64` -> (15, 0))."""
+    m = re.search(r"-macosx_(\d+)_(\d+)_arm64\.whl$", url)
+    if m is None:
+        raise InstallMetalRefused(f"not a macOS arm64 wheel: {url}")
+    return int(m.group(1)), int(m.group(2))
+
+
+def _macos_version() -> Tuple[int, int]:
+    parts = [int(p) for p in (platform.mac_ver()[0] or "0").split(".")[:2]]
+    return (parts + [0])[0], (parts + [0])[1]
+
+
+def pip_command(requirements: str) -> List[str]:
+    """pip on this interpreter, from a requirements file of URLs and hashes only: no index is read, nothing else."""
+    return [sys.executable, "-m", "pip", "install", "--no-deps", "--require-hashes", "--no-index", "-r", requirements]
+
+
+def requirements_text(entries: List[Tuple[str, str]]) -> str:
+    return "".join(f"{url} --hash=sha256:{sha}\n" for url, sha in entries)
+
+
+def main(version: str, dry_run: bool = False) -> int:
+    try:
+        entries = wheels(version)
+    except InstallMetalRefused as exc:
+        print(f"install-metal: {exc}", file=sys.stderr)
+        return 1
+    text = requirements_text(entries)
+    if dry_run:
+        print(text, end="")
+        print(" ".join(pip_command("<these lines>")))
+        return 0
+    fd, path = tempfile.mkstemp(prefix="nbxtensor-metal-", suffix=".txt")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(text)
+        return subprocess.call(pip_command(path))
+    finally:
+        os.unlink(path)

{nbxtensor-0.0.3 → nbxtensor-0.0.4}/src/nbxtensor/backend/metal_backend.py

@@ -139,6 +139,16 @@ class TritonMetalShaderCompilerMissingError(TritonMetalNotInstalledError):
     """
 
 
+class TritonMetalBindingMissingError(TritonMetalNotInstalledError):
+    """Raised when Triton for Metal is installed but pyobjc's Metal binding, through which the device is opened, is
+    not: the device cannot be opened, and the run would otherwise fall to a CPU profile."""
+
+
+def metal_binding_available() -> bool:
+    """pyobjc's Metal binding, through which the device is opened, is installed (asked without importing it)."""
+    return importlib.util.find_spec("Metal") is not None
+
+
 def is_apple_silicon() -> bool:
     """True on an Apple-Silicon Mac."""
     return platform.system() == "Darwin" and platform.machine() == "arm64"
@@ -573,27 +583,25 @@ def ensure_triton_metal_or_raise() -> None:
 
     if not triton_metal_available():
         raise TritonMetalNotInstalledError(
-            "The --triton engine needs a Triton backend that targets Metal, and "
-            "none is installed.\n"
-            "\n"
-            "Upstream Triton has no Apple GPU target. An out-of-tree backend "
-            "exists:\n"
-            "    pip install triton-msl        (MIT; needs Triton 3.7+ built "
-            "with TRITON_EXT_ENABLED=1)\n"
+            "The --triton engine needs Triton for the Apple GPU (Triton with "
+            "triton-ext's AppleGPU backend), and none is installed. PyPI publishes "
+            "no Triton for macOS; nbxtensor's release carries it:\n"
+            "    python -m nbxtensor install-metal\n"
             "\n"
-            "NeuroBrix does not install it for you: fetching a wheel at runtime "
-            "is a\n"
-            "supply-chain surface you did not consent to, and it fails "
-            "confusingly on\n"
-            "air-gapped machines.\n"
+            "A run does not install it for you: a download at run time is a "
+            "supply-chain surface you did not consent to.\n"
             "\n"
-            "Working alternative today: drop --triton. The default compiled "
-            "engine runs\n"
-            "on Apple GPUs through PyTorch MPS with no extra install.\n"
-            "\n"
-            "Status and known gaps: docs/internal/metal_adoption_plan_2026_09_03.md"
+            "Alternative: the PyTorch engine (--compiled) runs on the Apple GPU "
+            "through MPS (pip install torch \"neurobrix[pytorch]\")."
         )
 
+    if not metal_binding_available():
+        # the device is opened through pyobjc's Metal binding: without it the run found no device and fell to a CPU
+        # profile, refused there for triton-cpu with not a word about Metal (the Mac's clean venv, 2026-11-07 00:51)
+        raise TritonMetalBindingMissingError(
+            "The --triton engine opens the Apple GPU through pyobjc's Metal binding, and it is not installed:\n"
+            "    pip install pyobjc-framework-Metal")
+
     if not metal_shader_compiler_available():
         raise TritonMetalShaderCompilerMissingError(
             "A Triton Metal backend is installed, but Apple's offline shader "

nbxtensor-0.0.4/tests/test_install_metal_fetches_only_what_it_names.py

@@ -0,0 +1,117 @@
+"""`python -m nbxtensor install-metal` installs Triton for the Apple GPU from the release of the project's fork
+(github.com/NeuroBrix/triton-ext), each wheel by the URL and sha256 written in the code, through pip with --no-deps --require-hashes --no-index — never an extra index,
+never a package name pip would resolve on PyPI (anyone can publish "triton-apple-backend" there: dependency
+confusion). Off an Apple-silicon Mac, or on a Python the table does not cover, it refuses by name. `python -m nbxtensor
+doctor` on a Mac without Triton names the command (the owner via the supervisor, 2026-11-07 00:45).
+
+What this test would do if the code were wrong: a run on Linux that tries to install (red), a covered Python missing
+from the table that installs anyway (red), a pip command reading an index or resolving dependencies (red), an entry
+whose URL leaves the release or whose hash is not a sha256 (red), the table changed without this file (red)."""
+from __future__ import annotations
+
+import re
+import sys
+
+import pytest
+
+from nbxtensor.backend import install_metal as M
+
+#: the table as published — this file changes with it, by hand, from the files the release carries
+_R = "https://github.com/NeuroBrix/triton-ext/releases/download/apple-v0.1.0%2Btriton3.8.0/"
+EXPECTED_METAL_WHEELS: dict = {
+    "cp312": (
+        (_R + "triton-3.8.0%2Bgit4a15f415.nbx1-cp312-cp312-macosx_15_0_arm64.whl",
+         "b9084dc93ae7f1468062a03e713d49c9add9a1c9a609fae753a7b32a13b7a223"),
+        (_R + "nbx_triton_apple-0.1.0-cp312-cp312-macosx_15_0_arm64.whl",
+         "b9ed95c983b220b1fbf1300481b1e2f52a0435c10ee618ef7ccf60a132fe263c"),
+    ),
+}
+
+
+def _mac(monkeypatch, macos="15.4"):
+    monkeypatch.setattr(M.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(M.platform, "machine", lambda: "arm64")
+    monkeypatch.setattr(M.platform, "mac_ver", lambda: (macos, ("", "", ""), "arm64"))
+
+
+def test_the_table_is_the_published_one():
+    assert M.METAL_WHEELS == EXPECTED_METAL_WHEELS
+
+
+def test_every_entry_is_a_release_url_of_the_fork_with_a_sha256():
+    for tag, entries in M.METAL_WHEELS.items():
+        assert re.fullmatch(r"cp3\d+", tag), tag
+        names = [url.rsplit("/", 1)[1] for url, _ in entries]
+        assert [n.split("-")[0] for n in names] == ["triton", "nbx_triton_apple"], names   # Triton first, then the backend
+        for (url, sha), name in zip(entries, names):
+            assert url.startswith(M.RELEASES) and url.count("/") == M.RELEASES.count("/") + 1, url
+            assert re.fullmatch(r"[A-Za-z0-9_.]+-[^-]+-%s-%s-macosx_\d+_\d+_arm64\.whl" % (tag, tag), name), name
+            assert re.fullmatch(r"[0-9a-f]{64}", sha), (name, sha)
+
+
+@pytest.mark.parametrize("system, machine", [("Linux", "x86_64"), ("Darwin", "x86_64"), ("Windows", "AMD64")])
+def test_off_an_apple_silicon_mac_it_refuses_by_name(monkeypatch, system, machine):
+    monkeypatch.setattr(M.platform, "system", lambda: system)
+    monkeypatch.setattr(M.platform, "machine", lambda: machine)
+    with pytest.raises(M.InstallMetalRefused, match="Apple-silicon Mac only"):
+        M.wheels("0.0.4")
+    calls = []
+    monkeypatch.setattr(M.subprocess, "call", lambda *a, **k: calls.append(a) or 0)
+    assert M.main("0.0.4") == 1 and not calls
+
+
+def test_a_python_the_table_does_not_cover_is_refused_by_name(monkeypatch):
+    _mac(monkeypatch)
+    monkeypatch.setattr(M, "METAL_WHEELS", {"cp399": (("triton-3.8.0-cp399-cp399-macosx_15_0_arm64.whl", "0" * 64),)})
+    with pytest.raises(M.InstallMetalRefused, match=r"no Metal wheels for Python .*covered: cp399"):
+        M.wheels("0.0.4")
+
+
+def test_a_covered_python_installs_by_url_and_hash_only(monkeypatch):
+    _mac(monkeypatch)
+    tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
+    base = M.RELEASES + "apple-v0.1.0+triton3.8.0/"
+    t = f"{base}triton-3.8.0-{tag}-{tag}-macosx_15_0_arm64.whl"
+    b = f"{base}nbx_triton_apple-0.1.0-{tag}-{tag}-macosx_15_0_arm64.whl"
+    monkeypatch.setattr(M, "METAL_WHEELS", {tag: ((t, "a" * 64), (b, "b" * 64))})
+    seen = {}
+
+    def call(cmd):
+        seen["cmd"] = cmd
+        seen["req"] = open(cmd[-1]).read()
+        return 0
+    monkeypatch.setattr(M.subprocess, "call", call)
+    assert M.main("0.0.4") == 0
+    assert seen["req"] == f"{t} --hash=sha256:{'a' * 64}\n{b} --hash=sha256:{'b' * 64}\n"
+    cmd = seen["cmd"]
+    assert cmd[:4] == [sys.executable, "-m", "pip", "install"]
+    assert {"--no-deps", "--require-hashes", "--no-index"} <= set(cmd), cmd
+    assert not any(a.startswith(("--index-url", "--extra-index-url", "-i", "--find-links", "-f")) for a in cmd), cmd
+
+
+def test_doctor_on_a_mac_without_triton_names_the_command(monkeypatch, capsys):
+    import nbxtensor.__main__ as main_mod
+    from nbxtensor.backend import metal_backend
+    monkeypatch.setattr(metal_backend, "is_apple_silicon", lambda: True)
+    monkeypatch.setattr(metal_backend, "triton_metal_available", lambda: False)
+    assert main_mod.main(["doctor"]) == 0
+    assert capsys.readouterr().out.strip() == (
+        "Apple GPU found; Triton for Metal not installed — run: python -m nbxtensor install-metal")
+
+
+def test_the_command_line_names_install_metal(capsys):
+    import nbxtensor.__main__ as main_mod
+    assert main_mod.main(["nothing"]) == 2
+    assert "install-metal" in capsys.readouterr().err
+
+
+def test_a_mac_older_than_the_wheels_tag_is_refused_by_name(monkeypatch):
+    # the fork's first wheels were built for macOS 27 (macosx_27_0): pip refuses them on macOS 14-26 with no word of why
+    _mac(monkeypatch, macos="15.4")
+    tag = f"cp{sys.version_info.major}{sys.version_info.minor}"
+    url = f"{M.RELEASES}apple-v0.1.0+triton3.8.0/triton-3.8.0-{tag}-{tag}-macosx_27_0_arm64.whl"
+    monkeypatch.setattr(M, "METAL_WHEELS", {tag: ((url, "a" * 64),)})
+    with pytest.raises(M.InstallMetalRefused, match=r"macOS 27\.0 required for now.*this Mac: macOS 15\.4"):
+        M.wheels("0.0.4")
+    _mac(monkeypatch, macos="27.1")
+    assert M.wheels("0.0.4") == [(url, "a" * 64)]

nbxtensor-0.0.4/tests/test_it_installs_on_a_mac.py

@@ -0,0 +1,23 @@
+"""nbxtensor installs on a Mac. PyPI publishes no Triton for macOS (triton 3.8.0: two manylinux wheels, no sdist): the
+Metal Triton is built from source (Triton with TRITON_EXT_ENABLED=1 and triton-ext's AppleGPU backend), so a plain
+"triton" dependency made `pip install nbxtensor` — and `pip install "neurobrix[pytorch]"`, the PyTorch engine on MPS —
+ResolutionImpossible on a clean macOS venv (the Mac, 2026-11-06 23:03). The engine's own pyproject already carries the
+marker. Where Triton is absent the library refuses by name with what to build (backend/metal_backend).
+
+What this test would do if the packaging were wrong: a triton dependency that macOS must resolve from PyPI (red)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:          # python 3.10
+    import tomli as tomllib
+
+PYPROJECT = Path(__file__).resolve().parents[1] / "pyproject.toml"
+
+
+def test_triton_is_not_resolved_from_pypi_on_macos():
+    deps = tomllib.loads(PYPROJECT.read_text())["project"]["dependencies"]
+    triton = [d.replace(" ", "").replace('"', "'") for d in deps if d.split(";")[0].strip() == "triton"]
+    assert triton == ["triton;platform_system!='Darwin'"], triton