nbxtensor 0.0.4__tar.gz → 0.0.5__tar.gz

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

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.5] - 2026-11-07
+
+### Fixed
+- **The library runs on Windows**: weights are read at their offset without `os.preadv` (Windows' `ReadFile` with an
+  OVERLAPPED offset), the BLAS's thread control is found beside numpy (`numpy.libs`) instead of through /proc, and the
+  GPU libraries are opened by their Windows names (nvcuda.dll, cudart64_12.dll from the runtime wheel's `bin`, nvml.dll,
+  amdhip64_6.dll, ze_loader.dll, OpenCL.dll). Written and tested with Windows simulated: the project has no Windows
+  machine yet.
+- **`python -m nbxtensor doctor` on a Mac without Triton exits 1**: it named the fix and exited 0, so a script could
+  not tell that nothing could run yet.
+- **The library imports on Windows**: its page size came from `os.sysconf`, which Windows does not have; and the code
+  generator's identity now reads a backend's files as `/` paths with its `.pyd` and `.dll` binaries, so the same code
+  has the same identity on every system.
+- **A certified setting that is not served says why**: where the directory holds a key proven under another code
+  generator than the running one, the line named a memory class that matched ("certified for 18 GB, this card is
+  18 GB, not served"); it now names both generators and the re-proof command. A setting proven on another memory class
+  is still said as such.
+
 ## [0.0.4] - 2026-11-07
 
 ### Added
@@ -162,7 +180,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.4...HEAD
+[Unreleased]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.5...HEAD
+[0.0.5]: https://github.com/NeuroBrix/nbxtensor/compare/v0.0.4...v0.0.5
 [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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nbxtensor
-Version: 0.0.4
+Version: 0.0.5
 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
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 
 Run AI models without PyTorch, on any GPU Triton supports: tensors, Triton kernels, planned memory and certified tuning.
 
-Runs wherever Triton runs — NVIDIA, AMD, Intel and Apple Silicon GPUs. Inference first; training is not in this
+Runs wherever Triton runs — NVIDIA, AMD, Intel and Apple Silicon GPUs, on Linux, Windows and macOS. Inference first; training is not in this
 release. Found a bug on your hardware? [Open an issue](https://github.com/NeuroBrix/nbxtensor/issues) — we fix fast.
 
 [![PyPI](https://img.shields.io/pypi/v/nbxtensor)](https://pypi.org/project/nbxtensor/)
@@ -156,10 +156,10 @@ 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. `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
+**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS. `install-metal` installs NeuroBrix's Triton
+build for Apple GPUs, [NeuroBrix/triton-ext](https://github.com/NeuroBrix/triton-ext) (Triton built with
+`TRITON_EXT_ENABLED=1` and the `nbx-triton-apple` backend; upstream:
+[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):
 
 ```
@@ -500,7 +500,7 @@ with the tensor class (API.md §4).
 
 ## Versions
 
-The first publication was **0.0.1**; this is **0.0.4**. Each fix published after it increments the number (0.0.5,
+The first publication was **0.0.1**; this is **0.0.5**. Each fix published after it increments the number (0.0.6,
 …), 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.4 → nbxtensor-0.0.5}/README.md

@@ -4,7 +4,7 @@
 
 Run AI models without PyTorch, on any GPU Triton supports: tensors, Triton kernels, planned memory and certified tuning.
 
-Runs wherever Triton runs — NVIDIA, AMD, Intel and Apple Silicon GPUs. Inference first; training is not in this
+Runs wherever Triton runs — NVIDIA, AMD, Intel and Apple Silicon GPUs, on Linux, Windows and macOS. Inference first; training is not in this
 release. Found a bug on your hardware? [Open an issue](https://github.com/NeuroBrix/nbxtensor/issues) — we fix fast.
 
 [![PyPI](https://img.shields.io/pypi/v/nbxtensor)](https://pypi.org/project/nbxtensor/)
@@ -135,10 +135,10 @@ 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. `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
+**macOS, Apple silicon (Metal).** PyPI publishes no Triton for macOS. `install-metal` installs NeuroBrix's Triton
+build for Apple GPUs, [NeuroBrix/triton-ext](https://github.com/NeuroBrix/triton-ext) (Triton built with
+`TRITON_EXT_ENABLED=1` and the `nbx-triton-apple` backend; upstream:
+[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):
 
 ```
@@ -479,7 +479,7 @@ with the tensor class (API.md §4).
 
 ## Versions
 
-The first publication was **0.0.1**; this is **0.0.4**. Each fix published after it increments the number (0.0.5,
+The first publication was **0.0.1**; this is **0.0.5**. Each fix published after it increments the number (0.0.6,
 …), 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.4 → nbxtensor-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nbxtensor"
-version = "0.0.4"
+version = "0.0.5"
 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" }

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/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.4"
+__version__ = "0.0.5"
 __all__: list = []

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

@@ -11,7 +11,7 @@ def doctor() -> int:
     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
+        return 1                     # nothing can run yet: a script reads it from the exit status
     try:
         backend = runtime.gpu_backend()
         print(f"backend in force: {backend}" + (" (the Apple GPU, through Metal)" if backend == "metal" else ""))

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/backend/cpu/blas.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import ctypes
 import functools
 import platform
+import sys
 from pathlib import Path
 from typing import Optional, Tuple
 
@@ -33,6 +34,16 @@ _OPENBLAS_GET = ("scipy_openblas_get_num_threads64_", "scipy_openblas_get_num_th
 
 
 def _loaded_openblas() -> Optional[str]:
+    if sys.platform == "win32":
+        # no /proc on Windows: numpy's wheel ships its OpenBLAS beside the package (`numpy.libs`, older wheels
+        # `numpy/.libs`), loaded with numpy; ctypes opening the same path returns the module already in the process
+        import numpy
+        root = Path(numpy.__file__).resolve().parent
+        for d in (root.parent / "numpy.libs", root / ".libs"):
+            hits = sorted(d.glob("*openblas*.dll")) if d.is_dir() else []
+            if hits:
+                return str(hits[0])
+        return None
     maps = Path("/proc/self/maps")
     if not maps.is_file():
         return None

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/backend/launcher.py

@@ -488,14 +488,15 @@ class CudaDriver(_ModuleDriver):
 
     def __init__(self) -> None:
         lib = None
-        for name in ("libcuda.so.1", "libcuda.so"):
+        from nbxtensor.backend.libnames import CUDA_DRIVER
+        for name in CUDA_DRIVER:
             try:
                 lib = ctypes.CDLL(name)
                 break
             except OSError:
                 continue
         if lib is None:
-            raise RuntimeError("NeuroBrix launcher: libcuda not found")
+            raise RuntimeError(f"NeuroBrix launcher: the CUDA driver library not found (tried {CUDA_DRIVER})")
         self.lib = lib
         self._check(lib.cuInit(0), "cuInit")
         # ctypes infers the type of every argument at every call unless the signature is

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/backend/level_zero.py

@@ -27,7 +27,7 @@ import threading
 from typing import Dict, Optional, Tuple
 
 #: the Level Zero loader (`libze1` on Ubuntu), tried in order
-LIBS = ["libze_loader.so.1", "libze_loader.so"]
+from nbxtensor.backend.libnames import LEVEL_ZERO as LIBS   # noqa: E402
 
 # ZE_STRUCTURE_TYPE_* (ze.py)
 _ST_DRIVER_PROPERTIES, _ST_DEVICE_COMPUTE, _ST_QUEUE_GROUP, _ST_DEVICE_MEMORY = 0x1, 0x4, 0x6, 0x7
@@ -558,7 +558,7 @@ def runtime() -> LevelZeroRuntime:
 
 
 #: the OpenCL ICD loader (`ocl-icd-libopencl1`; Intel's runtime registers itself in it with intel-opencl-icd)
-OPENCL_LIBS = ["libOpenCL.so.1", "libOpenCL.so"]
+from nbxtensor.backend.libnames import OPENCL as OPENCL_LIBS   # noqa: E402
 _CL_DEVICE_TYPE_GPU, _CL_DEVICE_VENDOR_ID, _CL_DEVICE_EXTENSIONS, _CL_DEVICE_ID_INTEL = 4, 0x1001, 0x1030, 0x4251
 
 #: target facts Intel's compiler reads (intel/backend/compiler.py `parse_target`) -> the OpenCL extension that states

nbxtensor-0.0.5/src/nbxtensor/backend/libnames.py

@@ -0,0 +1,26 @@
+"""The vendor libraries the backends open through ctypes, named as each system names them: a shared object on Linux
+(`libcuda.so.1`), a DLL on Windows (`nvcuda.dll`). Read by the backend tables (`backend.runtime`), the launch driver
+(`backend.launcher`), the graph replay (`backend.replay_graph`), the expandable pool (`memory.vmm`) and Level Zero
+(`backend.level_zero`). Windows' names are the vendors' (NVIDIA: nvcuda.dll in System32 with the driver, cudart64_12.dll
+in the CUDA runtime wheel's `bin`, nvml.dll; AMD HIP SDK: amdhip64_6.dll; Intel: ze_loader.dll, OpenCL.dll).
+"""
+from __future__ import annotations
+
+import sys
+
+WINDOWS = sys.platform == "win32"
+
+#: the CUDA runtime, after the one the environment's wheel carries (`runtime._environment_runtime_libs`)
+CUDA_RUNTIME = ["cudart64_12.dll", "cudart64_110.dll"] if WINDOWS else ["libcudart.so", "libcudart.so.12", "libcudart.so.11.0"]
+#: the CUDA runtime file inside the nvidia-cuda-runtime wheel, and the wheel's directory that holds it
+CUDA_RUNTIME_IN_WHEEL = ("bin", "cudart64_12.dll") if WINDOWS else ("lib", "libcudart.so.12")
+#: the CUDA driver API
+CUDA_DRIVER = ["nvcuda.dll"] if WINDOWS else ["libcuda.so.1", "libcuda.so"]
+#: NVIDIA's management library
+NVML = ["nvml.dll"] if WINDOWS else ["libnvidia-ml.so.1", "libnvidia-ml.so"]
+#: the HIP runtime
+HIP_RUNTIME = ["amdhip64_6.dll", "amdhip64.dll"] if WINDOWS else ["libamdhip64.so", "libamdhip64.so.5"]
+#: the Level Zero loader
+LEVEL_ZERO = ["ze_loader.dll"] if WINDOWS else ["libze_loader.so.1", "libze_loader.so"]
+#: the OpenCL ICD loader
+OPENCL = ["OpenCL.dll"] if WINDOWS else ["libOpenCL.so.1", "libOpenCL.so"]

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/backend/replay_graph.py

@@ -70,7 +70,8 @@ class _CudaGraphAPI:
     _inst = None
 
     def __init__(self) -> None:
-        lib = ctypes.CDLL("libcuda.so.1")
+        from nbxtensor.backend.libnames import CUDA_DRIVER
+        lib = ctypes.CDLL(CUDA_DRIVER[0])
 
         def bind(name, argtypes):
             fn = getattr(lib, name)

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/backend/runtime.py

@@ -39,23 +39,26 @@ def _environment_runtime_libs(package: str, names) -> list:
         return []
     import os
     root = list(spec.submodule_search_locations)[0]
+    from nbxtensor.backend.libnames import CUDA_RUNTIME_IN_WHEEL, WINDOWS
     out = []
     for n in names:
-        cand = os.path.join(root, "lib", n)
+        cand = os.path.join(root, CUDA_RUNTIME_IN_WHEEL[0], n)
         if os.path.exists(cand):
             out.append(cand)
+            if WINDOWS:                   # the DLL's own directory searched for what it loads
+                os.add_dll_directory(os.path.dirname(cand))
     return out
 
 
 # Runtime API mapping per backend
+from nbxtensor.backend import libnames as _LIB    # noqa: E402  the libraries as this system names them
 _GPU_BACKENDS = {
     "cuda": {
-        "rt_libs": _environment_runtime_libs("nvidia.cuda_runtime", ["libcudart.so.12"])
-                   + ["libcudart.so", "libcudart.so.12", "libcudart.so.11.0"],
+        "rt_libs": _environment_runtime_libs("nvidia.cuda_runtime", [_LIB.CUDA_RUNTIME_IN_WHEEL[1]]) + _LIB.CUDA_RUNTIME,
         # the driver API's library: the virtual memory primitives of the expandable pool (`memory.vmm`, R16)
-        "driver_libs": ["libcuda.so.1", "libcuda.so"],
+        "driver_libs": _LIB.CUDA_DRIVER,
         # the management library: what the driver attributes to THIS process on a device (`backend.process_memory`)
-        "management_libs": ["libnvidia-ml.so.1", "libnvidia-ml.so"],
+        "management_libs": _LIB.NVML,
         "pci_bus_id": "cudaDeviceGetPCIBusId",
         "malloc": "cudaMalloc", "free": "cudaFree",
         "memcpy": "cudaMemcpy", "memset": "cudaMemset",
@@ -100,7 +103,7 @@ _GPU_BACKENDS = {
         "device_enable_peer_access": "cudaDeviceEnablePeerAccess",
     },
     "hip": {
-        "rt_libs": ["libamdhip64.so", "libamdhip64.so.5"],
+        "rt_libs": _LIB.HIP_RUNTIME,
         # the same three facts as cuda's, declared ABSENT: the expandable pool speaks the CUDA driver's VMM calls only
         # (`memory.vmm`; HIP's hipMemCreate family is not wired), so a HIP device keeps its driver segments; and no
         # per-process accounting is read on ROCm (`backend.process_memory` answers None, the runtime's growth is not

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/io/read_rate.py

@@ -11,7 +11,8 @@ import time
 from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, List, Optional, Sequence
 
-__all__ = ["PIECE", "WITNESS_BYTES", "START_BYTES", "mount_of", "pieces", "trial", "choose", "measure", "workers_for"]
+__all__ = ["PIECE", "WITNESS_BYTES", "START_BYTES", "mount_of", "pieces", "trial", "choose", "measure", "workers_for",
+           "can_bypass_the_cache"]
 
 PIECE = 16 << 20                       # the loaders' read piece
 
@@ -63,14 +64,21 @@ def pieces(files, max_bytes: int):
     return out, total
 
 
+def can_bypass_the_cache() -> bool:
+    """Whether this system lets a measure read past its page cache (macOS F_NOCACHE + msync, Linux posix_fadvise);
+    Windows offers neither through Python, and a rate read from the cache is not the storage's."""
+    return sys.platform == "darwin" or hasattr(os, "posix_fadvise")
+
+
 def trial(pieces, workers: int) -> float:
     """Bytes per second reading `pieces` with `workers` threads, the cache bypassed."""
+    from nbxtensor.io.safetensors import _read_at
     for path in {p for p, _, _ in pieces}:
         _evict(path, os.path.getsize(path))
     fds = {}
     for path, _, _ in pieces:
         if path not in fds:
-            fd = os.open(path, os.O_RDONLY)
+            fd = os.open(path, os.O_RDONLY | getattr(os, "O_BINARY", 0))
             _no_cache(fd)
             fds[path] = fd
     bufs = [bytearray(PIECE) for _ in range(workers)]
@@ -80,7 +88,7 @@ def trial(pieces, workers: int) -> float:
         buf = memoryview(bufs[i % workers])[:n]
         got = 0
         while got < n:
-            got += os.preadv(fds[path], [buf[got:]], off + got)
+            got += _read_at(fds[path], buf[got:], off + got)
         return n
 
     t = time.perf_counter()
@@ -146,6 +154,9 @@ def workers_for(directory, witness_dir=None, max_workers: Optional[int] = None,
     up to everything the files hold. When no size gives a stable measure, refused by name: never a silent None, never
     a default."""
     from pathlib import Path
+    if not can_bypass_the_cache():
+        raise RuntimeError(f"ZERO FALLBACK: no uncached read-rate measure on this system ({sys.platform}: no way to "
+                           f"read past the page cache) — no worker count is assumed")
     root = Path(directory)
     max_workers = max_workers or os.cpu_count() or 1
     files = [str(p) for p in sorted(root.glob(pattern), key=lambda p: -p.stat().st_size)[:4]]

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/io/safetensors.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import ctypes
 import math
+import mmap
 import os
 from typing import Optional
 
@@ -23,7 +24,7 @@ from nbxtensor.dtype.convert import bf16_bits_to_f16, f32_to_bf16_bits
 from nbxtensor.shape import contiguous_strides
 from nbxtensor.memory.memory_pool import ComponentArena, HostPinnedArena
 
-PAGE = os.sysconf("SC_PAGE_SIZE")
+PAGE = mmap.PAGESIZE      # os.sysconf does not exist on Windows (its import stopped every plan there)
 
 
 def spans(n: int, unit: int, align: int, workers: int):
@@ -36,6 +37,38 @@ def spans(n: int, unit: int, align: int, workers: int):
     return [(a, min(a + step, n)) for a in range(0, n, step)]
 
 
+def _read_at(fd: int, view: memoryview, offset: int) -> int:
+    """Read into `view` from the file's byte `offset`, at that offset and never through a shared file position (the
+    workers read one file at once): `os.preadv` where the system has it (Linux, macOS); on Windows, which has neither
+    preadv nor pread, `ReadFile` with an OVERLAPPED offset on the descriptor's handle — a positioned read. Returns the
+    bytes read (0 at the end of the file)."""
+    if hasattr(os, "preadv"):
+        return os.preadv(fd, [view], offset)
+    if hasattr(os, "pread"):
+        data = os.pread(fd, len(view), offset)
+        view[:len(data)] = data
+        return len(data)
+    import msvcrt
+    from ctypes import wintypes
+
+    class _Overlapped(ctypes.Structure):
+        _fields_ = [("Internal", ctypes.c_void_p), ("InternalHigh", ctypes.c_void_p), ("Offset", wintypes.DWORD),
+                    ("OffsetHigh", wintypes.DWORD), ("hEvent", wintypes.HANDLE)]
+
+    n = min(len(view), 0x7FFFFFFF)                   # one ReadFile reads at most a DWORD's worth
+    ov = _Overlapped(0, 0, offset & 0xFFFFFFFF, offset >> 32, None)
+    got = wintypes.DWORD(0)
+    buf = (ctypes.c_char * n).from_buffer(view)
+    ok = ctypes.windll.kernel32.ReadFile(wintypes.HANDLE(msvcrt.get_osfhandle(fd)), buf, n, ctypes.byref(got),
+                                         ctypes.byref(ov))
+    if not ok:
+        err = ctypes.windll.kernel32.GetLastError()
+        if err == 38:                                # ERROR_HANDLE_EOF: a read at or past the end
+            return 0
+        raise OSError(err, f"ReadFile at offset {offset} of fd {fd}")
+    return int(got.value)
+
+
 def read_bytes(fd: int, offset: int, nbytes: int, io) -> np.ndarray:
     """nbytes of the file at offset, read by the loader's workers into one buffer (page-aligned
     spans; `preadv` may return short, so each span reads until it is full)."""
@@ -45,7 +78,7 @@ def read_bytes(fd: int, offset: int, nbytes: int, io) -> np.ndarray:
     def _one(span):
         a, b = span
         while a < b:
-            got = os.preadv(fd, [view[a:b]], offset + a)
+            got = _read_at(fd, view[a:b], offset + a)
             if got <= 0:
                 raise RuntimeError(f"weight read: {nbytes} bytes at offset {offset} of fd {fd} ended "
                                    f"{b - a} bytes short (file truncated?)")

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/src/nbxtensor/ops/autotune_certified.py

@@ -444,13 +444,13 @@ def _backend_content_hash(backend) -> str:
     h = hashlib.sha256()
     for name in getattr(type(backend), "CODEGEN_ENV", ()) or ():
         h.update(f"{name}={name in os.environ}:{os.environ.get(name, '')}".encode())
-    files = sorted(f for f in pkg.rglob("*") if f.is_file() and f.suffix in (".py", ".so", ".dylib")
+    files = sorted(f for f in pkg.rglob("*") if f.is_file() and f.suffix in (".py", ".so", ".dylib", ".pyd", ".dll")
                    and "__pycache__" not in f.parts) if pkg.is_dir() else []
     plugin = getattr(mod, "PLUGIN_LIBRARY", None)
     if plugin is not None and Path(plugin).is_file() and Path(plugin) not in files:
         files.append(Path(plugin))
     for f in files:
-        h.update(str(f.relative_to(pkg) if pkg in f.parents else f.name).encode())
+        h.update((f.relative_to(pkg).as_posix() if pkg in f.parents else f.name).encode())   # "/" on every OS
         h.update(hashlib.sha256(f.read_bytes()).digest())
     return f"content-{h.hexdigest()[:16]}"
 
@@ -1115,6 +1115,20 @@ def _explain_miss(kernel_qual: str, key: tuple, memory_gb: Optional[int]) -> str
         return f" (the application's explanation of the miss failed: {type(exc).__name__}: {exc})."
 
 
+def _not_served_because(raw: Dict[str, Any], here: Optional[int]) -> str:
+    """Why an entry the directory holds for this key is not served here: proven under another code generator than the
+    running one (for this card's memory class), or on another memory class (register 56). The Mac's new-user run on the
+    published Metal wheels (2026-11-07): every Apple entry carried the dev environment's generator and the line said
+    "certified for 18 GB, this card is 18 GB, not served" — a memory class that matched, the cause unnamed."""
+    covered = sorted(covered_memory_gbs(raw))
+    gens, gen = sorted(proof_backends(raw)), running_generator()
+    if here is not None and here in covered and gen is not None and gen not in gens:
+        return (f"certified for this card's {here} GB under {', '.join(gens) or 'no named generator'}, and this machine "
+                f"runs {gen}: not served — re-proven under it by `neurobrix autotune certify --reprove-generator`")
+    return (f"certified for {', '.join(f'{c} GB' for c in covered) or 'no known memory class'}, this card is "
+            f"{f'{here} GB' if here is not None else 'of unknown memory'}, not served (register 56)")
+
+
 def refuse_missing(kernel_qual: str, tuner, key: tuple) -> None:
     """The certified-only answer to a miss: raised before any bench, naming the key, the profile,
     why a directory entry (if any) is not served, and what the census says."""
@@ -1129,9 +1143,7 @@ def refuse_missing(kernel_qual: str, tuner, key: tuple) -> None:
     try:
         raw = lookup(kernel_qual, tuner, key, ignore_switch=True, any_class=True)
         if raw is not None:
-            covered = sorted(covered_memory_gbs(raw))
-            why = (f"; the directory certifies it for {', '.join(f'{c} GB' for c in covered) or 'no known memory class'} "
-                   f"and this card is {f'{here} GB' if here is not None else 'of unknown memory'} (register 56)")
+            why = f"; the directory holds it: {_not_served_because(raw, here)}"
     except Exception as exc:  # noqa: BLE001 — the reason failed to compute: said, the refusal stands
         why = f"; (could not read what the directory holds for it: {exc})"
     raise KeyNotCertified(
@@ -1159,10 +1171,8 @@ def announce_missing(kernel_qual: str, tuner, key: tuple) -> None:
     try:
         raw = lookup(kernel_qual, tuner, key, ignore_switch=True, any_class=True)
         if raw is not None:
-            covered = sorted(covered_memory_gbs(raw))
             here = executing_memory_gb(list((getattr(tuner, "nargs", None) or {}).values()) or None)
-            why = (f" — certified for {', '.join(f'{c} GB' for c in covered) or 'no known memory class'}, "
-                   f"this card is {f'{here} GB' if here is not None else 'of unknown memory'}, not served (register 56)")
+            why = f" — {_not_served_because(raw, here)}"
     except Exception as exc:                # the reason failed to compute: say that, never an empty reason
         why = f" — (could not read what the directory holds for it: {exc})"
     print(f"[autotune] no certified setting for {kernel_short(kernel_qual)} {output_dtype(tuner, key)} "

nbxtensor-0.0.5/tests/test_a_setting_not_served_says_why.py

@@ -0,0 +1,32 @@
+"""A certified setting the directory holds but does not serve says why: proven under another code generator than the
+running one, or on another memory class. The Mac's new-user run on the published Metal wheels (2026-11-07): every Apple
+entry was proven under the development environment's generator, none was served, and the line said "certified for
+18 GB, this card is 18 GB, not served (register 56)" — the memory class matched and the cause was not named.
+
+What this test would do if the code were wrong: a generator mismatch reported as a memory class (red), a memory-class
+miss reported as a generator (red)."""
+from __future__ import annotations
+
+from nbxtensor.ops import autotune_certified as C
+
+
+def _entry(gen_version: str, memory_mb: int):
+    return {"proof": {"backend": {"triton": gen_version, "name": "metal"},
+                      "machine": {"device": {"memory_mb": memory_mb}}}}
+
+
+def test_a_generator_mismatch_on_the_right_memory_class_names_the_generators(monkeypatch):
+    monkeypatch.setattr(C, "running_generator", lambda: "triton 3.8.0+git4a15f415.nbx1 metal")
+    raw = _entry("3.8.0+git4a15f415", 18432)
+    gens = sorted(C.proof_backends(raw))
+    why = C._not_served_because(raw, 18)
+    assert why.startswith("certified for this card's 18 GB under "), why
+    assert gens[0] in why and "triton 3.8.0+git4a15f415.nbx1 metal" in why and "--reprove-generator" in why, why
+    assert "register 56" not in why
+
+
+def test_another_memory_class_is_said_as_such(monkeypatch):
+    raw = _entry("3.8.0", 32768)
+    monkeypatch.setattr(C, "running_generator", lambda: sorted(C.proof_backends(raw))[0])
+    why = C._not_served_because(raw, 16)
+    assert "certified for 32 GB, this card is 16 GB, not served (register 56)" == why, why

{nbxtensor-0.0.4 → nbxtensor-0.0.5}/tests/test_install_metal_fetches_only_what_it_names.py

@@ -94,7 +94,7 @@ def test_doctor_on_a_mac_without_triton_names_the_command(monkeypatch, capsys):
     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 main_mod.main(["doctor"]) == 1        # nothing can run yet: said by the exit status too (the Mac, 04:21)
     assert capsys.readouterr().out.strip() == (
         "Apple GPU found; Triton for Metal not installed — run: python -m nbxtensor install-metal")