nbxtensor 0.0.2__tar.gz → 0.0.4__tar.gz

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

@@ -7,6 +7,31 @@ 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
+- **The backend is the one whose card is on the machine**: nbxtensor depends on the CUDA runtime wheel on Linux, and a runtime library loads without its card — on an AMD or Intel machine 0.0.2 named the CUDA backend and never tried HIP or Level Zero. Detection now tries only the runtime libraries of the GPU vendors present on the PCI bus (all of them where the bus cannot be read). The CUDA runtime wheel stays a Linux dependency: without an NVIDIA card it is not used.
+- **The package summary says where it runs**: wherever Triton runs — NVIDIA, AMD, Intel and Apple GPUs (it still named NVIDIA and Apple only).
+
 ## [0.0.2] - 2026-11-06
 
 ### Added
@@ -137,6 +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.2...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.2 → nbxtensor-0.0.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: nbxtensor
-Version: 0.0.2
-Summary: Run AI models without PyTorch: tensors, Triton kernels, planned memory and certified tuning, on NVIDIA and Apple GPUs.
+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
 Project-URL: Issues, https://github.com/NeuroBrix/nbxtensor/issues
@@ -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.2**. Each fix published after it increments the number (0.0.3,
+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.2 → 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.2**. Each fix published after it increments the number (0.0.3,
+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.2 → nbxtensor-0.0.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nbxtensor"
-version = "0.0.2"
-description = "Run AI models without PyTorch: tensors, Triton kernels, planned memory and certified tuning, on NVIDIA and Apple GPUs."
+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" }
 requires-python = ">=3.10"
@@ -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.2 → 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.2"
+__version__ = "0.0.4"
 __all__: list = []

{nbxtensor-0.0.2 → 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.2 → 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.2 → nbxtensor-0.0.4}/src/nbxtensor/backend/runtime.py

@@ -141,6 +141,19 @@ _GPU_BACKENDS = {
 }
 
 
+#: the GPU vendor whose card each runtime-library backend drives (PCI vendor names, `backend.install_help`)
+_BACKEND_VENDOR = {"cuda": "nvidia", "hip": "amd"}
+
+
+def _on_this_machine(backends):
+    """The runtime-library backends whose vendor has a card on this machine's PCI bus, in table order — all of them
+    where the bus cannot be read (no sysfs). A runtime library loads without its card: the CUDA runtime wheel nbxtensor
+    depends on on Linux loaded on an AMD or Intel machine, named "cuda", and HIP / Level Zero were never tried."""
+    from nbxtensor.backend.install_help import pci_gpus
+    vendors = {v for v, _vid, _dev in pci_gpus()}
+    return [(n, b) for n, b in backends if not vendors or _BACKEND_VENDOR[n] in vendors]
+
+
 #: the backends found by asking for a DEVICE rather than by loading a runtime library, in order: (name, the probe's
 #: dotted path). Their runtime tables are not rows of `_GPU_BACKENDS` (another API than one C ABI): `_NATIVE_TABLES`.
 _DEVICE_PROBES = (("metal", "nbxtensor.backend.metal_device.metal_device_available"),
@@ -314,7 +327,7 @@ def gpu_backend() -> str:
         return _pin_triton_backend(forced)
     # The backend TABLE decides: the first vendor runtime the process can
     # load names the backend — adding a backend is adding a table entry.
-    for name, backend in _GPU_BACKENDS.items():
+    for name, backend in _on_this_machine(_GPU_BACKENDS.items()):
         for lib in backend["rt_libs"]:
             try:
                 ctypes.cdll.LoadLibrary(lib)

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

nbxtensor-0.0.4/tests/test_the_backend_is_the_card_on_the_machine.py

@@ -0,0 +1,19 @@
+"""The runtime-library backend is the one whose card is on the machine's PCI bus (`runtime._on_this_machine`).
+
+nbxtensor 0.0.2 depends on the CUDA runtime wheel on Linux, and a runtime library loads without its card: on an AMD or
+Intel machine `gpu_backend()` named "cuda" and HIP / Level Zero were never tried (the supervisor's reading of the 0.0.2
+metadata, 2026-11-06 18:25). What this test does if the code were wrong: "cuda" kept on a bus with only an AMD card, or
+a backend dropped where the bus cannot be read — red."""
+from nbxtensor.backend import install_help, runtime
+
+
+def test_only_the_backends_of_the_cards_present_are_tried(monkeypatch):
+    table = list(runtime._GPU_BACKENDS.items())
+    monkeypatch.setattr(install_help, "pci_gpus", lambda: [("amd", 0x1002, 0x744C)])
+    assert [n for n, _b in runtime._on_this_machine(table)] == ["hip"]
+    monkeypatch.setattr(install_help, "pci_gpus", lambda: [("intel", 0x8086, 0xE20B)])
+    assert runtime._on_this_machine(table) == []                     # Level Zero is probed for its device after
+    monkeypatch.setattr(install_help, "pci_gpus", lambda: [("nvidia", 0x10DE, 0x1DB1)])
+    assert [n for n, _b in runtime._on_this_machine(table)] == ["cuda"]
+    monkeypatch.setattr(install_help, "pci_gpus", lambda: [])      # no readable bus (macOS, a sandbox): as before
+    assert [n for n, _b in runtime._on_this_machine(table)] == ["cuda", "hip"]