inference-artifact-lab 0.1.0.dev0__py3-none-any.whl

inference_artifact_lab/__init__.py

@@ -0,0 +1,14 @@
+"""Inference Artifact Lab package."""
+
+from .gate import canonical_manifest_digest, current_environment, load_manifest, run_gate, run_gate_from_file, sha256_file
+from .adapters import OnnxRuntimeAdapter, RuntimeUnavailable, TensorRTAdapter
+from .models import ArtifactSpec, CheckResult, GateReport, GateStatus, Manifest, ManifestError, TensorSpec
+from .release import run_release_gate
+from .runtime import BenchmarkResult, benchmark, compare_outputs
+
+__all__ = [
+    "__version__", "ArtifactSpec", "CheckResult", "GateReport", "GateStatus", "Manifest", "ManifestError", "TensorSpec",
+    "canonical_manifest_digest", "current_environment", "load_manifest", "run_gate", "run_gate_from_file", "run_release_gate", "sha256_file",
+    "BenchmarkResult", "benchmark", "compare_outputs", "OnnxRuntimeAdapter", "TensorRTAdapter", "RuntimeUnavailable",
+]
+__version__ = "0.1.0.dev0"

inference_artifact_lab/__main__.py

@@ -0,0 +1,85 @@
+"""Command line entry point: ``python -m inference_artifact_lab``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from .gate import run_gate_from_file
+from .release import run_release_gate
+from .runtime import benchmark
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Run core Model Release Gate checks")
+    parser.add_argument("manifest", help="path to a JSON manifest")
+    parser.add_argument("--artifact", help="artifact path (defaults to manifest artifact.path)")
+    parser.add_argument("--observed-contract", help="JSON file containing observed inputs and outputs")
+    parser.add_argument("--environment", help="JSON file containing the observed environment fingerprint")
+    parser.add_argument("--reference-output", help="JSON file containing reference runtime output")
+    parser.add_argument("--target-output", help="JSON file containing target runtime output")
+    parser.add_argument("--benchmark-evidence", help="JSON file containing benchmark evidence")
+    parser.add_argument("--report", help="write the release report JSON to this path")
+    parser.add_argument("--runtime", choices=["onnx-cpu"], help="run a real package adapter before composing the release report")
+    parser.add_argument("--inputs-npy", help="NumPy .npy input for the selected runtime adapter")
+    args = parser.parse_args(argv)
+    observed = None
+    if args.observed_contract:
+        with open(args.observed_contract, encoding="utf-8") as handle:
+            observed = json.load(handle)
+    environment = None
+    if args.environment:
+        with open(args.environment, encoding="utf-8") as handle:
+            environment = json.load(handle)
+    def load_json(path: str | None):
+        if not path:
+            return None
+        with open(path, encoding="utf-8") as handle:
+            return json.load(handle)
+    try:
+        reference = load_json(args.reference_output)
+        target = load_json(args.target_output)
+        benchmark_evidence = load_json(args.benchmark_evidence)
+        if args.runtime:
+            if not args.inputs_npy or reference is None or environment is None:
+                raise ValueError("--runtime requires --inputs-npy, --reference-output, and --environment")
+            if args.runtime != "onnx-cpu":  # argparse currently prevents this; retain an explicit guard.
+                raise ValueError(f"unsupported runtime {args.runtime}")
+            import numpy as np
+            from .adapters import OnnxRuntimeAdapter
+            from .gate import load_manifest
+            manifest = load_manifest(args.manifest)
+            manifest_file = Path(args.manifest)
+            artifact = Path(args.artifact) if args.artifact else Path(manifest.artifact.path)
+            if not artifact.is_absolute():
+                artifact = Path(os.path.normpath(str(manifest_file.parent / artifact)))
+            values = np.load(args.inputs_npy, allow_pickle=False)
+            adapter = OnnxRuntimeAdapter(artifact, providers=["CPUExecutionProvider"])
+            output_name = adapter.contract()["outputs"][0]["name"]
+            input_name = adapter.contract()["inputs"][0]["name"]
+            target = adapter.run({input_name: values})[output_name]
+            reference_value = reference.get(output_name) if isinstance(reference, dict) else reference
+            measured = benchmark(lambda: adapter.run({input_name: values}), warmup_runs=1, measured_runs=5)
+            report = run_release_gate(manifest, artifact, observed_contract=adapter.contract(), observed_environment=environment, reference_outputs=reference_value, target_outputs=target, benchmark_evidence=measured.to_dict())
+        elif reference is not None or target is not None or benchmark_evidence is not None:
+            from .gate import load_manifest
+            manifest = load_manifest(args.manifest)
+            report = run_release_gate(manifest, args.artifact, observed_contract=observed, observed_environment=environment, reference_outputs=reference, target_outputs=target, benchmark_evidence=benchmark_evidence)
+        else:
+            report = run_gate_from_file(args.manifest, args.artifact, observed_contract=observed, observed_environment=environment)
+    except (OSError, ValueError) as exc:
+        print(json.dumps({"status": "fail", "error": str(exc)}), file=sys.stdout)
+        return 2
+    rendered = json.dumps(report.to_dict(), indent=2, sort_keys=True)
+    if args.report:
+        with open(args.report, "w", encoding="utf-8") as handle:
+            handle.write(rendered + "\n")
+    print(rendered)
+    return 0 if report.status.value == "pass" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

inference_artifact_lab/adapters.py

@@ -0,0 +1,296 @@
+"""Optional runtime adapters used by the Phase 1 evidence harness."""
+
+from __future__ import annotations
+
+import ctypes
+import platform
+from pathlib import Path
+from typing import Any, Mapping
+
+
+class RuntimeUnavailable(RuntimeError):
+    """Raised when a declared runtime dependency is not installed."""
+
+
+class OnnxRuntimeAdapter:
+    """Small ONNX Runtime adapter with no dependency on the gate domain."""
+
+    def __init__(self, artifact: str | Path, *, providers: list[str] | None = None) -> None:
+        try:
+            import onnxruntime as ort
+        except ImportError as exc:  # pragma: no cover - optional dependency
+            raise RuntimeUnavailable("install the runtime-cpu extra for ONNX Runtime") from exc
+        self._session = ort.InferenceSession(str(artifact), providers=providers)
+        self._ort_version = ort.__version__
+        self._requested_providers = tuple(providers) if providers is not None else None
+
+    def contract(self) -> dict[str, list[dict[str, Any]]]:
+        def describe(value: Any) -> dict[str, Any]:
+            return {"name": value.name, "dtype": value.type, "shape": list(value.shape)}
+
+        return {
+            "artifact_format": "onnx",
+            "inputs": [describe(value) for value in self._session.get_inputs()],
+            "outputs": [describe(value) for value in self._session.get_outputs()],
+        }
+
+    def runtime_info(self) -> dict[str, Any]:
+        """Return selected providers, including an explicit fallback provider."""
+
+        return {
+            "runtime": "onnxruntime",
+            "version": self._ort_version,
+            "requested_providers": list(self._requested_providers) if self._requested_providers is not None else None,
+            "providers": list(self._session.get_providers()),
+            "python": platform.python_version(),
+            "system": platform.system(),
+            "machine": platform.machine(),
+        }
+
+    def run(self, inputs: Mapping[str, Any]) -> dict[str, Any]:
+        values = self._session.run(None, dict(inputs))
+        return {
+            spec["name"]: value.tolist() if hasattr(value, "tolist") else value
+            for spec, value in zip(self.contract()["outputs"], values)
+        }
+
+
+class _CtypesCudaRuntime:
+    """Minimal libcudart binding used when the optional cuda-python is absent."""
+
+    binding_name = "ctypes-libcudart"
+
+    class _MemcpyKind:
+        cudaMemcpyHostToDevice = 1
+        cudaMemcpyDeviceToHost = 2
+
+    cudaMemcpyKind = _MemcpyKind
+
+    def __init__(self) -> None:
+        last_error: OSError | None = None
+        for name in ("libcudart.so", "libcudart.so.12", "cudart64_*.dll"):
+            try:
+                self._lib = ctypes.CDLL(name)
+                break
+            except OSError as exc:
+                last_error = exc
+        else:
+            raise RuntimeUnavailable("TensorRTAdapter requires libcudart or cuda-python") from last_error
+        self._configure()
+
+    def _configure(self) -> None:
+        ptr, size = ctypes.c_void_p, ctypes.c_size_t
+        self._lib.cudaStreamCreate.argtypes = [ctypes.POINTER(ptr)]
+        self._lib.cudaStreamCreate.restype = ctypes.c_int
+        self._lib.cudaStreamDestroy.argtypes = [ptr]
+        self._lib.cudaStreamDestroy.restype = ctypes.c_int
+        self._lib.cudaStreamSynchronize.argtypes = [ptr]
+        self._lib.cudaStreamSynchronize.restype = ctypes.c_int
+        self._lib.cudaMalloc.argtypes = [ctypes.POINTER(ptr), size]
+        self._lib.cudaMalloc.restype = ctypes.c_int
+        self._lib.cudaFree.argtypes = [ptr]
+        self._lib.cudaFree.restype = ctypes.c_int
+        self._lib.cudaMemcpyAsync.argtypes = [ptr, ptr, size, ctypes.c_int, ptr]
+        self._lib.cudaMemcpyAsync.restype = ctypes.c_int
+
+    def cudaStreamCreate(self) -> tuple[int, int | None]:
+        value = ctypes.c_void_p()
+        return self._lib.cudaStreamCreate(ctypes.byref(value)), value.value
+
+    def cudaStreamDestroy(self, stream: int | None) -> int:
+        return self._lib.cudaStreamDestroy(ctypes.c_void_p(stream))
+
+    def cudaStreamSynchronize(self, stream: int | None) -> int:
+        return self._lib.cudaStreamSynchronize(ctypes.c_void_p(stream))
+
+    def cudaMalloc(self, size: int) -> tuple[int, int | None]:
+        value = ctypes.c_void_p()
+        return self._lib.cudaMalloc(ctypes.byref(value), ctypes.c_size_t(size)), value.value
+
+    def cudaFree(self, device: int | None) -> int:
+        return self._lib.cudaFree(ctypes.c_void_p(device))
+
+    def cudaMemcpyAsync(self, destination: int, source: int, size: int, kind: int, stream: int | None) -> int:
+        return self._lib.cudaMemcpyAsync(ctypes.c_void_p(destination), ctypes.c_void_p(source), ctypes.c_size_t(size), int(kind), ctypes.c_void_p(stream))
+
+
+def _load_cuda_runtime() -> Any:
+    try:
+        from cuda import cudart  # type: ignore[import-not-found]
+    except ImportError:
+        return _CtypesCudaRuntime()
+    # Kept as evidence in runtime_info; provider selection is never implicit.
+    try:
+        cudart.binding_name = "cuda-python"  # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+    return cudart
+
+
+def _status_is_success(status: Any) -> bool:
+    value = getattr(status, "value", status)
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        return value == 0
+    name = str(getattr(status, "name", status)).lower()
+    return name in {"success", "cudasuccess", "cuda_success"}
+
+
+def _check_cuda(result: Any, operation: str) -> Any:
+    """Check cuda-python/libcudart status and return an optional payload."""
+
+    if isinstance(result, tuple):
+        status, payload = result[0], result[1] if len(result) > 1 else None
+    else:
+        status, payload = result, None
+    if not _status_is_success(status):
+        raise RuntimeError(f"{operation} failed with CUDA status {status!r}")
+    return payload
+
+
+class TensorRTAdapter:
+    """TensorRT engine adapter with explicit CUDA ownership and validation."""
+
+    def __init__(self, artifact: str | Path, *, trt_module: Any | None = None, cuda_runtime: Any | None = None, numpy_module: Any | None = None) -> None:
+        try:
+            trt = trt_module or __import__("tensorrt")
+            np = numpy_module or __import__("numpy")
+        except ImportError as exc:  # pragma: no cover - optional container dependency
+            raise RuntimeUnavailable("TensorRTAdapter requires the pinned NVIDIA TensorRT container") from exc
+        self._trt, self._np = trt, np
+        self._cuda = cuda_runtime or _load_cuda_runtime()
+        self._logger = trt.Logger(trt.Logger.ERROR)
+        with Path(artifact).open("rb") as handle:
+            self._runtime = trt.Runtime(self._logger)
+            self._engine = self._runtime.deserialize_cuda_engine(handle.read())
+        if self._engine is None:
+            raise RuntimeError("TensorRT engine deserialization failed")
+        self._context = self._engine.create_execution_context()
+        if self._context is None:
+            raise RuntimeError("TensorRT execution context creation failed")
+
+    @staticmethod
+    def _dtype_name(dtype: Any, *, np: Any, trt: Any) -> str:
+        try:
+            value = np.dtype(trt.nptype(dtype))
+        except (TypeError, ValueError, AttributeError) as exc:
+            raise RuntimeError(f"unsupported TensorRT tensor dtype {dtype!r}") from exc
+        names = {"float32": "float", "float16": "float16", "float64": "double", "int8": "int8", "int16": "int16", "int32": "int32", "int64": "int64", "uint8": "uint8", "uint16": "uint16", "uint32": "uint32", "uint64": "uint64", "bool": "bool"}
+        try:
+            return f"tensor({names[value.name]})"
+        except KeyError as exc:
+            raise RuntimeError(f"unsupported TensorRT tensor dtype {value}") from exc
+
+    def _tensor_shape(self, name: str) -> list[int | None]:
+        return [None if int(dimension) < 0 else int(dimension) for dimension in self._engine.get_tensor_shape(name)]
+
+    def contract(self) -> dict[str, list[dict[str, Any]]]:
+        inputs: list[dict[str, Any]] = []
+        outputs: list[dict[str, Any]] = []
+        for index in range(self._engine.num_io_tensors):
+            name = self._engine.get_tensor_name(index)
+            value = {"name": name, "dtype": self._dtype_name(self._engine.get_tensor_dtype(name), np=self._np, trt=self._trt), "shape": self._tensor_shape(name)}
+            target = inputs if self._engine.get_tensor_mode(name) == self._trt.TensorIOMode.INPUT else outputs
+            target.append(value)
+        return {"artifact_format": "tensorrt-engine", "inputs": inputs, "outputs": outputs}
+
+    def optimization_profiles(self) -> list[dict[str, Any]]:
+        """Return engine profile bounds without inventing a manifest schema."""
+        count = int(getattr(self._engine, "num_optimization_profiles", 0) or 0)
+        profiles: list[dict[str, Any]] = []
+        for profile_index in range(count):
+            tensors: dict[str, dict[str, list[int]]] = {}
+            for index in range(self._engine.num_io_tensors):
+                name = self._engine.get_tensor_name(index)
+                if self._engine.get_tensor_mode(name) != self._trt.TensorIOMode.INPUT:
+                    continue
+                try:
+                    minimum, optimum, maximum = self._engine.get_tensor_profile_shape(name, profile_index)
+                except (AttributeError, RuntimeError):
+                    continue
+                tensors[name] = {"min": list(minimum), "opt": list(optimum), "max": list(maximum)}
+            profiles.append({"index": profile_index, "inputs": tensors})
+        return profiles
+
+    def runtime_info(self) -> dict[str, Any]:
+        return {"runtime": "tensorrt", "tensorrt_version": getattr(self._trt, "__version__", None), "cuda_binding": getattr(self._cuda, "binding_name", type(self._cuda).__name__), "optimization_profiles": self.optimization_profiles(), "python": platform.python_version(), "system": platform.system(), "machine": platform.machine()}
+
+    def _names(self, mode: Any) -> list[str]:
+        return [self._engine.get_tensor_name(index) for index in range(self._engine.num_io_tensors) if self._engine.get_tensor_mode(self._engine.get_tensor_name(index)) == mode]
+
+    def run(self, inputs: Mapping[str, Any]) -> dict[str, Any]:
+        expected_inputs, expected_outputs = self._names(self._trt.TensorIOMode.INPUT), self._names(self._trt.TensorIOMode.OUTPUT)
+        missing, extra = [name for name in expected_inputs if name not in inputs], [name for name in inputs if name not in expected_inputs]
+        if missing or extra:
+            raise ValueError(f"TensorRT inputs do not match engine (missing={missing}, extra={extra})")
+        prepared: dict[str, Any] = {}
+        for name in expected_inputs:
+            value = self._np.asarray(inputs[name])
+            expected_dtype = self._np.dtype(self._trt.nptype(self._engine.get_tensor_dtype(name)))
+            if value.dtype != expected_dtype:
+                raise TypeError(f"input {name!r} has dtype {value.dtype}, expected {expected_dtype}")
+            if not value.flags.c_contiguous:
+                raise ValueError(f"input {name!r} must be C-contiguous")
+            engine_shape = self._engine.get_tensor_shape(name)
+            if len(value.shape) != len(engine_shape) or any(int(want) >= 0 and int(want) != got for want, got in zip(engine_shape, value.shape)):
+                raise ValueError(f"input {name!r} shape {tuple(value.shape)} does not satisfy engine shape {tuple(engine_shape)}")
+            prepared[name] = value
+            if self._context.set_input_shape(name, tuple(value.shape)) is False:
+                raise ValueError(f"TensorRT rejected input shape for {name!r}: {tuple(value.shape)}")
+
+        allocations: list[tuple[str, int, Any]] = []
+        stream: Any = None
+        synchronized, active_error = False, None
+        try:
+            stream = _check_cuda(self._cuda.cudaStreamCreate(), "cudaStreamCreate")
+            if stream is None:
+                raise RuntimeError("cudaStreamCreate returned a null stream")
+            for name in expected_inputs + expected_outputs:
+                if name in prepared:
+                    value = prepared[name]
+                else:
+                    shape = tuple(int(dimension) for dimension in self._context.get_tensor_shape(name))
+                    if any(dimension < 0 for dimension in shape):
+                        raise ValueError(f"TensorRT output {name!r} has unresolved dynamic shape {shape}")
+                    value = self._np.empty(shape, dtype=self._np.dtype(self._trt.nptype(self._engine.get_tensor_dtype(name))))
+                if value.nbytes <= 0:
+                    raise ValueError(f"TensorRT tensor {name!r} has an empty buffer")
+                device = _check_cuda(self._cuda.cudaMalloc(value.nbytes), f"cudaMalloc({name})")
+                if not device:
+                    raise RuntimeError(f"cudaMalloc({name}) returned a null pointer")
+                allocations.append((name, int(device), value))
+                self._context.set_tensor_address(name, int(device))
+                if name in prepared:
+                    _check_cuda(self._cuda.cudaMemcpyAsync(int(device), int(value.ctypes.data), value.nbytes, self._cuda.cudaMemcpyKind.cudaMemcpyHostToDevice, stream), f"cudaMemcpyAsync(HtoD:{name})")
+            if self._context.execute_async_v3(stream_handle=stream) is False:
+                raise RuntimeError("TensorRT execution failed")
+            for name, device, value in allocations:
+                if name not in expected_outputs:
+                    continue
+                _check_cuda(self._cuda.cudaMemcpyAsync(int(value.ctypes.data), device, value.nbytes, self._cuda.cudaMemcpyKind.cudaMemcpyDeviceToHost, stream), f"cudaMemcpyAsync(DtoH:{name})")
+            _check_cuda(self._cuda.cudaStreamSynchronize(stream), "cudaStreamSynchronize")
+            synchronized = True
+            return {name: value.tolist() for name, _, value in allocations if name in expected_outputs}
+        except BaseException as exc:
+            active_error = exc
+            raise
+        finally:
+            cleanup_errors: list[str] = []
+            if stream is not None and not synchronized:
+                try:
+                    _check_cuda(self._cuda.cudaStreamSynchronize(stream), "cudaStreamSynchronize(cleanup)")
+                except Exception as exc:
+                    cleanup_errors.append(str(exc))
+            for name, device, _ in reversed(allocations):
+                try:
+                    _check_cuda(self._cuda.cudaFree(device), f"cudaFree({name})")
+                except Exception as exc:
+                    cleanup_errors.append(str(exc))
+            if stream is not None:
+                try:
+                    _check_cuda(self._cuda.cudaStreamDestroy(stream), "cudaStreamDestroy")
+                except Exception as exc:
+                    cleanup_errors.append(str(exc))
+            if active_error is None and cleanup_errors:
+                raise RuntimeError("TensorRT CUDA cleanup failed: " + "; ".join(cleanup_errors))

inference_artifact_lab/gate.py

@@ -0,0 +1,163 @@
+"""Integrity and contract checks for Model Release Gate reports."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import platform
+from pathlib import Path
+from typing import Any, Mapping
+
+from .models import CheckResult, GateReport, GateStatus, Manifest, ManifestError, TensorSpec
+
+
+def canonical_manifest_digest(manifest: Manifest) -> str:
+    payload = json.dumps(manifest.to_dict(), sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def load_manifest(path: str | Path) -> Manifest:
+    manifest_path = Path(path)
+    try:
+        value = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ManifestError(f"unable to read manifest {manifest_path}: {exc}") from exc
+    return Manifest.from_dict(value)
+
+
+def sha256_file(path: str | Path, chunk_size: int = 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for chunk in iter(lambda: handle.read(chunk_size), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _integrity_checks(manifest: Manifest, artifact_path: Path) -> list[CheckResult]:
+    expected = manifest.artifact
+    if not artifact_path.exists():
+        return [CheckResult("artifact.exists", GateStatus.FAIL, "artifact file does not exist", {"path": str(artifact_path)})]
+    if not artifact_path.is_file():
+        return [CheckResult("artifact.exists", GateStatus.FAIL, "artifact path is not a regular file", {"path": str(artifact_path)})]
+    observed_size = artifact_path.stat().st_size
+    checks = [CheckResult("artifact.exists", GateStatus.PASS, "artifact file exists", {"path": str(artifact_path)})]
+    if expected.size_bytes is not None and observed_size != expected.size_bytes:
+        checks.append(CheckResult("artifact.size", GateStatus.FAIL, "artifact size does not match manifest", {"expected": expected.size_bytes, "observed": observed_size}))
+    else:
+        checks.append(CheckResult("artifact.size", GateStatus.PASS, "artifact size matches manifest", {"observed": observed_size}))
+    observed_digest = sha256_file(artifact_path)
+    if observed_digest != expected.sha256:
+        checks.append(CheckResult("artifact.sha256", GateStatus.FAIL, "artifact SHA-256 does not match manifest", {"expected": expected.sha256, "observed": observed_digest}))
+    else:
+        checks.append(CheckResult("artifact.sha256", GateStatus.PASS, "artifact SHA-256 matches manifest", {"sha256": observed_digest}))
+    return checks
+
+
+def _compare_tensor_specs(expected: tuple[TensorSpec, ...], observed: Any, direction: str) -> CheckResult:
+    if observed is None:
+        return CheckResult(f"contract.{direction}", GateStatus.BLOCKED, f"observed artifact {direction} contract is unavailable", {})
+    if not isinstance(observed, list):
+        return CheckResult(f"contract.{direction}", GateStatus.FAIL, f"observed artifact {direction} contract must be a list", {})
+    actual = []
+    try:
+        actual = [TensorSpec.from_dict(item, f"observed.{direction}[{i}]") for i, item in enumerate(observed)]
+    except ManifestError as exc:
+        return CheckResult(f"contract.{direction}", GateStatus.FAIL, str(exc), {})
+    if len(actual) != len(expected):
+        return CheckResult(f"contract.{direction}", GateStatus.FAIL, f"artifact {direction} count does not match manifest", {"expected": len(expected), "observed": len(actual)})
+    for index, (want, got) in enumerate(zip(expected, actual)):
+        if want != got:
+            return CheckResult(f"contract.{direction}", GateStatus.FAIL, f"artifact {direction} entry {index} does not match manifest", {"expected": want.to_dict(), "observed": got.to_dict()})
+    return CheckResult(f"contract.{direction}", GateStatus.PASS, f"artifact {direction} match manifest", {"count": len(expected)})
+
+
+def _environment_check(manifest: Manifest, observed: Mapping[str, Any] | None) -> CheckResult:
+    if not manifest.environment:
+        return CheckResult("environment.compatibility", GateStatus.NOT_VERIFIED, "manifest declares no environment compatibility scope", {})
+    if observed is None:
+        return CheckResult("environment.compatibility", GateStatus.BLOCKED, "declared environment was not tested", {"required": dict(manifest.environment)})
+    if not isinstance(observed, Mapping):
+        return CheckResult("environment.compatibility", GateStatus.FAIL, "observed environment must be an object", {})
+    mismatches = {key: {"expected": value, "observed": observed.get(key)} for key, value in manifest.environment.items() if observed.get(key) != value}
+    if mismatches:
+        return CheckResult("environment.compatibility", GateStatus.FAIL, "observed environment does not satisfy manifest", {"mismatches": mismatches})
+    return CheckResult("environment.compatibility", GateStatus.PASS, "observed environment satisfies manifest", {"observed": dict(observed)})
+
+
+def _profiles_check(manifest: Manifest, observed_contract: Mapping[str, Any]) -> CheckResult | None:
+    if not manifest.profiles:
+        return None
+    observed = observed_contract.get("profiles")
+    if observed is None:
+        return CheckResult("contract.profiles", GateStatus.BLOCKED, "observed artifact profiles are unavailable", {"required": list(manifest.profiles)})
+    if not isinstance(observed, list) or any(not isinstance(item, str) for item in observed):
+        return CheckResult("contract.profiles", GateStatus.FAIL, "observed artifact profiles must be a list of strings", {})
+    if set(observed) != set(manifest.profiles):
+        return CheckResult("contract.profiles", GateStatus.FAIL, "artifact profiles do not match manifest", {"expected": list(manifest.profiles), "observed": observed})
+    return CheckResult("contract.profiles", GateStatus.PASS, "artifact profiles match manifest", {"profiles": observed})
+
+
+def _format_check(manifest: Manifest, observed_contract: Mapping[str, Any]) -> CheckResult | None:
+    observed = observed_contract.get("artifact_format")
+    if observed is None:
+        return None
+    if observed != manifest.artifact.format:
+        return CheckResult("artifact.format", GateStatus.FAIL, "observed artifact format does not match manifest", {"expected": manifest.artifact.format, "observed": observed})
+    return CheckResult("artifact.format", GateStatus.PASS, "observed artifact format matches manifest", {"format": observed})
+
+
+def current_environment() -> dict[str, str]:
+    return {"python": platform.python_version(), "system": platform.system(), "machine": platform.machine()}
+
+
+def _aggregate(checks: list[CheckResult]) -> GateStatus:
+    statuses = {check.status for check in checks}
+    if GateStatus.FAIL in statuses:
+        return GateStatus.FAIL
+    if GateStatus.BLOCKED in statuses:
+        return GateStatus.BLOCKED
+    if GateStatus.NOT_VERIFIED in statuses:
+        return GateStatus.NOT_VERIFIED
+    return GateStatus.PASS
+
+
+def run_gate(
+    manifest: Manifest,
+    artifact_path: str | Path | None = None,
+    *,
+    observed_contract: Mapping[str, Any] | None = None,
+    observed_environment: Mapping[str, Any] | None = None,
+) -> GateReport:
+    """Run deterministic core checks and return a serializable report.
+
+    Runtime numerical checks and benchmarks are deliberately represented by
+    later checks; this core has no runtime dependency and reports unavailable
+    runtime evidence as ``blocked`` rather than guessing.
+    """
+    path = Path(artifact_path) if artifact_path is not None else Path(manifest.artifact.path)
+    checks = _integrity_checks(manifest, path)
+    if observed_contract is None:
+        observed_contract = {}
+    elif not isinstance(observed_contract, Mapping):
+        observed_contract = {"__invalid__": observed_contract}
+    checks.extend((_compare_tensor_specs(manifest.inputs, observed_contract.get("inputs"), "inputs"), _compare_tensor_specs(manifest.outputs, observed_contract.get("outputs"), "outputs")))
+    profiles_check = _profiles_check(manifest, observed_contract)
+    if profiles_check is not None:
+        checks.append(profiles_check)
+    format_check = _format_check(manifest, observed_contract)
+    if format_check is not None:
+        checks.append(format_check)
+    checks.append(_environment_check(manifest, observed_environment))
+    return GateReport(_aggregate(checks), canonical_manifest_digest(manifest), {**manifest.artifact.to_dict(), "path": str(path)}, tuple(checks), ("Runtime numerical equivalence and benchmarks are not implemented by the core gate.",))
+
+
+def run_gate_from_file(manifest_path: str | Path, artifact_path: str | Path | None = None, **kwargs: Any) -> GateReport:
+    manifest_file = Path(manifest_path)
+    manifest = load_manifest(manifest_file)
+    if artifact_path is None:
+        candidate = Path(manifest.artifact.path)
+        if not candidate.is_absolute():
+            candidate = manifest_file.parent / candidate
+        artifact_path = candidate
+    return run_gate(manifest, artifact_path, **kwargs)

inference_artifact_lab/models.py

@@ -0,0 +1,264 @@
+"""Public data structures for the Model Release Gate.
+
+The structures intentionally use plain JSON-compatible values.  This keeps a
+manifest and its resulting report portable between the CLI and other tools
+without making a model runtime a dependency of the gate core.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+import math
+from typing import Any, Mapping
+
+
+class GateStatus(StrEnum):
+    PASS = "pass"
+    FAIL = "fail"
+    BLOCKED = "blocked"
+    NOT_VERIFIED = "not_verified"
+
+
+class ManifestError(ValueError):
+    """Raised when a manifest is malformed or incomplete."""
+
+
+# These are the formats understood by the public P1 adapters and fixture
+# harness.  Rejecting arbitrary labels matters because ``format`` participates
+# in the release contract; a typo must not silently become a new format.
+SUPPORTED_ARTIFACT_FORMATS = frozenset({"fixture", "onnx", "tensorrt", "tensorrt-engine"})
+SUPPORTED_TENSOR_DTYPES = frozenset(
+    {
+        "bool",
+        "bfloat16",
+        "float16",
+        "float32",
+        "float64",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        "string",
+        "tensor(bool)",
+        "tensor(bfloat16)",
+        "tensor(float16)",
+        "tensor(float)",
+        "tensor(double)",
+        "tensor(int8)",
+        "tensor(int16)",
+        "tensor(int32)",
+        "tensor(int64)",
+        "tensor(uint8)",
+        "tensor(uint16)",
+        "tensor(uint32)",
+        "tensor(uint64)",
+        "tensor(string)",
+    }
+)
+
+
+def _required_string(value: Any, field_name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ManifestError(f"{field_name} must be a non-empty string")
+    return value
+
+
+@dataclass(frozen=True)
+class ArtifactSpec:
+    """Identity and integrity expectations for one artifact file."""
+
+    path: str
+    format: str
+    sha256: str
+    size_bytes: int | None = None
+    build_inputs: Mapping[str, Any] = field(default_factory=dict)
+    tools: Mapping[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any]) -> "ArtifactSpec":
+        if not isinstance(value, Mapping):
+            raise ManifestError("artifact must be an object")
+        path = _required_string(value.get("path"), "artifact.path")
+        fmt = _required_string(value.get("format"), "artifact.format")
+        if fmt not in SUPPORTED_ARTIFACT_FORMATS:
+            raise ManifestError(
+                f"artifact.format must be one of {sorted(SUPPORTED_ARTIFACT_FORMATS)}"
+            )
+        digest = _required_string(value.get("sha256"), "artifact.sha256").lower()
+        if len(digest) != 64 or any(c not in "0123456789abcdef" for c in digest):
+            raise ManifestError("artifact.sha256 must be a 64-character hexadecimal digest")
+        size = value.get("size_bytes")
+        if size is not None and (not isinstance(size, int) or isinstance(size, bool) or size < 0):
+            raise ManifestError("artifact.size_bytes must be a non-negative integer")
+        build_inputs = value.get("build_inputs", {})
+        tools = value.get("tools", {})
+        if not isinstance(build_inputs, Mapping) or not isinstance(tools, Mapping):
+            raise ManifestError("artifact.build_inputs and artifact.tools must be objects")
+        return cls(path=path, format=fmt, sha256=digest, size_bytes=size, build_inputs=dict(build_inputs), tools=dict(tools))
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"path": self.path, "format": self.format, "sha256": self.sha256}
+        if self.size_bytes is not None:
+            result["size_bytes"] = self.size_bytes
+        if self.build_inputs:
+            result["build_inputs"] = dict(self.build_inputs)
+        if self.tools:
+            result["tools"] = dict(self.tools)
+        return result
+
+
+@dataclass(frozen=True)
+class TensorSpec:
+    """A single input or output contract entry."""
+
+    name: str
+    dtype: str
+    shape: tuple[int | str | None, ...]
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any], field_name: str) -> "TensorSpec":
+        if not isinstance(value, Mapping):
+            raise ManifestError(f"{field_name} must be an object")
+        name = _required_string(value.get("name"), f"{field_name}.name")
+        dtype = _required_string(value.get("dtype"), f"{field_name}.dtype")
+        if dtype not in SUPPORTED_TENSOR_DTYPES:
+            raise ManifestError(
+                f"{field_name}.dtype must be a supported tensor dtype"
+            )
+        shape_value = value.get("shape")
+        if not isinstance(shape_value, list):
+            raise ManifestError(f"{field_name}.shape must be a list")
+        shape: list[int | str | None] = []
+        for index, dimension in enumerate(shape_value):
+            if dimension is None or isinstance(dimension, str):
+                if isinstance(dimension, str) and not dimension.strip():
+                    raise ManifestError(
+                        f"{field_name}.shape[{index}] must not be an empty dimension name"
+                    )
+                shape.append(dimension)
+            elif isinstance(dimension, int) and not isinstance(dimension, bool) and dimension >= 0:
+                shape.append(dimension)
+            else:
+                raise ManifestError(f"{field_name}.shape[{index}] must be a non-negative integer, string, or null")
+        return cls(name=name, dtype=dtype, shape=tuple(shape))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"name": self.name, "dtype": self.dtype, "shape": list(self.shape)}
+
+
+@dataclass(frozen=True)
+class Manifest:
+    """Versioned release contract used as the gate's source of truth."""
+
+    schema_version: str
+    model_name: str
+    model_version: str
+    source: str
+    artifact: ArtifactSpec
+    inputs: tuple[TensorSpec, ...]
+    outputs: tuple[TensorSpec, ...]
+    runtime: Mapping[str, Any] = field(default_factory=dict)
+    tolerances: Mapping[str, float] = field(default_factory=dict)
+    environment: Mapping[str, Any] = field(default_factory=dict)
+    profiles: tuple[str, ...] = ()
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any]) -> "Manifest":
+        if not isinstance(value, Mapping):
+            raise ManifestError("manifest must be a JSON object")
+        schema = _required_string(value.get("schema_version"), "schema_version")
+        if schema != "1":
+            raise ManifestError("schema_version must be '1'")
+        model = value.get("model")
+        if not isinstance(model, Mapping):
+            raise ManifestError("model must be an object")
+        model_name = _required_string(model.get("name"), "model.name")
+        model_version = _required_string(model.get("version"), "model.version")
+        source = _required_string(model.get("source"), "model.source")
+        artifact_value = value.get("artifact")
+        if not isinstance(artifact_value, Mapping):
+            raise ManifestError("artifact must be an object")
+        contract = value.get("contract")
+        if not isinstance(contract, Mapping):
+            raise ManifestError("contract must be an object")
+        inputs_value = contract.get("inputs")
+        outputs_value = contract.get("outputs")
+        if not isinstance(inputs_value, list) or not inputs_value:
+            raise ManifestError("contract.inputs must be a non-empty list")
+        if not isinstance(outputs_value, list) or not outputs_value:
+            raise ManifestError("contract.outputs must be a non-empty list")
+        inputs = tuple(TensorSpec.from_dict(item, f"contract.inputs[{i}]") for i, item in enumerate(inputs_value))
+        outputs = tuple(TensorSpec.from_dict(item, f"contract.outputs[{i}]") for i, item in enumerate(outputs_value))
+        for direction, tensors in (("inputs", inputs), ("outputs", outputs)):
+            names = [tensor.name for tensor in tensors]
+            if len(names) != len(set(names)):
+                raise ManifestError(f"contract.{direction} tensor names must be unique")
+        runtime = value.get("runtime", {})
+        tolerances = value.get("tolerances", {})
+        environment = value.get("environment", {})
+        profiles_value = contract.get("profiles", [])
+        for name, section in (("runtime", runtime), ("tolerances", tolerances), ("environment", environment)):
+            if not isinstance(section, Mapping):
+                raise ManifestError(f"{name} must be an object")
+        if not isinstance(profiles_value, list) or any(not isinstance(item, str) or not item.strip() for item in profiles_value):
+            raise ManifestError("contract.profiles must be a list of non-empty strings")
+        profiles = tuple(profiles_value)
+        if len(profiles) != len(set(profiles)):
+            raise ManifestError("contract.profiles must be unique")
+        parsed_tolerances: dict[str, float] = {}
+        for name, tolerance in tolerances.items():
+            if not isinstance(name, str) or not name.strip():
+                raise ManifestError("tolerance names must be non-empty strings")
+            if not isinstance(tolerance, (int, float)) or isinstance(tolerance, bool) or tolerance < 0:
+                raise ManifestError(f"tolerances.{name} must be a non-negative number")
+            if not math.isfinite(float(tolerance)):
+                raise ManifestError(f"tolerances.{name} must be finite")
+            parsed_tolerances[str(name)] = float(tolerance)
+        return cls(schema, model_name, model_version, source, ArtifactSpec.from_dict(artifact_value), inputs, outputs, dict(runtime), parsed_tolerances, dict(environment), profiles)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": self.schema_version,
+            "model": {"name": self.model_name, "version": self.model_version, "source": self.source},
+            "artifact": self.artifact.to_dict(),
+            "contract": {"inputs": [item.to_dict() for item in self.inputs], "outputs": [item.to_dict() for item in self.outputs], **({"profiles": list(self.profiles)} if self.profiles else {})},
+            "runtime": dict(self.runtime),
+            "tolerances": dict(self.tolerances),
+            "environment": dict(self.environment),
+        }
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    check_id: str
+    status: GateStatus
+    message: str
+    evidence: Mapping[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"id": self.check_id, "status": self.status.value, "message": self.message, "evidence": dict(self.evidence)}
+
+
+@dataclass(frozen=True)
+class GateReport:
+    status: GateStatus
+    manifest_digest: str | None
+    artifact: Mapping[str, Any]
+    checks: tuple[CheckResult, ...]
+    limitations: tuple[str, ...] = ()
+    schema_version: str = "1"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": self.schema_version,
+            "status": self.status.value,
+            "manifest_digest": self.manifest_digest,
+            "artifact": dict(self.artifact),
+            "checks": [check.to_dict() for check in self.checks],
+            "limitations": list(self.limitations),
+        }

inference_artifact_lab/release.py

@@ -0,0 +1,70 @@
+"""Full Phase 1 release decision composition."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+
+from .gate import run_gate
+from .models import CheckResult, GateReport, GateStatus, Manifest
+from .runtime import benchmark, compare_outputs
+
+
+def _aggregate(checks: list[CheckResult]) -> GateStatus:
+    statuses = {check.status for check in checks}
+    if GateStatus.FAIL in statuses:
+        return GateStatus.FAIL
+    if GateStatus.BLOCKED in statuses:
+        return GateStatus.BLOCKED
+    if GateStatus.NOT_VERIFIED in statuses:
+        return GateStatus.NOT_VERIFIED
+    return GateStatus.PASS
+
+
+def run_release_gate(
+    manifest: Manifest,
+    artifact_path: str | Path | None = None,
+    *,
+    observed_contract: Mapping[str, Any] | None = None,
+    observed_environment: Mapping[str, Any] | None = None,
+    reference_outputs: Any = None,
+    target_outputs: Any = None,
+    benchmark_call: Callable[[], Any] | None = None,
+    benchmark_evidence: Mapping[str, Any] | None = None,
+) -> GateReport:
+    """Run the complete Phase 1 decision for supplied adapter observations.
+
+    Runtime adapters remain outside the core package. They provide plain output
+    values and a callable workload; this function applies the same evidence and
+    status rules to those observations.
+    """
+
+    core = run_gate(
+        manifest,
+        artifact_path,
+        observed_contract=observed_contract,
+        observed_environment=observed_environment,
+    )
+    checks = list(core.checks)
+    core_failed = any(check.status is GateStatus.FAIL for check in checks)
+    if core_failed:
+        checks.append(CheckResult("runtime.equivalence", GateStatus.BLOCKED, "runtime verification skipped because an integrity, contract, or environment check failed", {}))
+        checks.append(CheckResult("benchmark.workload", GateStatus.BLOCKED, "benchmark skipped because an integrity, contract, or environment check failed", {}))
+        limitations = tuple(item for item in core.limitations if "not implemented" not in item)
+        return GateReport(_aggregate(checks), core.manifest_digest, core.artifact, tuple(checks), limitations)
+    if reference_outputs is None or target_outputs is None:
+        checks.append(CheckResult("runtime.equivalence", GateStatus.BLOCKED, "reference and target runtime outputs are required", {}))
+    else:
+        absolute = float(manifest.tolerances.get("absolute", 0.0))
+        relative = float(manifest.tolerances.get("relative", 0.0))
+        checks.append(compare_outputs(reference_outputs, target_outputs, absolute_tolerance=absolute, relative_tolerance=relative))
+    if benchmark_evidence is not None:
+        checks.append(CheckResult("benchmark.workload", GateStatus.PASS, "benchmark workload evidence supplied by the declared runtime harness", dict(benchmark_evidence)))
+    elif benchmark_call is None:
+        checks.append(CheckResult("benchmark.workload", GateStatus.BLOCKED, "benchmark workload evidence is required", {}))
+    else:
+        result = benchmark(benchmark_call)
+        checks.append(CheckResult("benchmark.workload", GateStatus.PASS, "benchmark workload completed", result.to_dict()))
+    limitations = tuple(item for item in core.limitations if "not implemented" not in item)
+    return GateReport(_aggregate(checks), core.manifest_digest, core.artifact, tuple(checks), limitations)

inference_artifact_lab/runtime.py

@@ -0,0 +1,177 @@
+"""Runtime-output comparison and bounded benchmark helpers.
+
+The gate core stays independent of ONNX/TensorRT. Adapters provide plain
+JSON-compatible outputs, allowing the same evidence rules to be tested without
+making a runtime dependency part of the package core.
+"""
+
+from __future__ import annotations
+
+import math
+import statistics
+import time
+import tracemalloc
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from .models import CheckResult, GateStatus
+
+
+def _json_value(value: Any) -> Any:
+    """Convert common array-like values without requiring NumPy."""
+    tolist = getattr(value, "tolist", None)
+    return tolist() if callable(tolist) else value
+
+
+def _structure(value: Any, path: str = "output") -> tuple[tuple[Any, ...], list[tuple[str, float]]]:
+    """Return a topology signature and numeric leaves for an output value.
+
+    Keeping the topology separate from flattened values prevents a ragged list,
+    reordered mapping, or scalar/list mismatch from passing merely because the
+    number of leaves happens to match.
+    """
+
+    value = _json_value(value)
+    if isinstance(value, Mapping):
+        keys = list(value.keys())
+        if any(not isinstance(key, str) for key in keys):
+            raise TypeError(f"{path} mapping keys must be strings")
+        if len(keys) != len(set(keys)):
+            raise TypeError(f"{path} mapping keys must be unique")
+        children = []
+        leaves: list[tuple[str, float]] = []
+        for key in sorted(keys):
+            child_shape, child_leaves = _structure(value[key], f"{path}.{key}")
+            children.append((key, child_shape))
+            leaves.extend(child_leaves)
+        return ("mapping", tuple(children)), leaves
+    if isinstance(value, (list, tuple)):
+        children = []
+        leaves = []
+        for index, item in enumerate(value):
+            child_shape, child_leaves = _structure(item, f"{path}[{index}]")
+            children.append(child_shape)
+            leaves.extend(child_leaves)
+        if children and any(child != children[0] for child in children[1:]):
+            raise TypeError(f"{path} contains a ragged sequence")
+        return ("sequence", tuple(children)), leaves
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise TypeError(f"{path} contains a non-numeric value")
+    return ("scalar",), [(path, float(value))]
+
+
+def compare_outputs(
+    expected: Any,
+    observed: Any,
+    *,
+    absolute_tolerance: float,
+    relative_tolerance: float = 0.0,
+) -> CheckResult:
+    """Compare finite numeric outputs under explicit absolute/relative tolerances."""
+
+    if (
+        isinstance(absolute_tolerance, bool)
+        or not isinstance(absolute_tolerance, (int, float))
+        or isinstance(relative_tolerance, bool)
+        or not isinstance(relative_tolerance, (int, float))
+        or not math.isfinite(float(absolute_tolerance))
+        or not math.isfinite(float(relative_tolerance))
+        or absolute_tolerance < 0
+        or relative_tolerance < 0
+    ):
+        return CheckResult("runtime.equivalence", GateStatus.FAIL, "tolerances must be finite non-negative numbers", {})
+    try:
+        expected_shape, expected_values = _structure(expected)
+        observed_shape, observed_values = _structure(observed)
+    except TypeError as exc:
+        return CheckResult("runtime.equivalence", GateStatus.FAIL, str(exc), {})
+    if expected_shape != observed_shape:
+        return CheckResult(
+            "runtime.equivalence",
+            GateStatus.FAIL,
+            "reference and target output shapes differ",
+            {"expected_shape": repr(expected_shape), "observed_shape": repr(observed_shape)},
+        )
+    if not expected_values:
+        return CheckResult("runtime.equivalence", GateStatus.FAIL, "reference and target outputs are empty", {})
+    if len(expected_values) != len(observed_values):
+        return CheckResult(
+            "runtime.equivalence",
+            GateStatus.FAIL,
+            "reference and target output sizes differ",
+            {"expected_values": len(expected_values), "observed_values": len(observed_values)},
+        )
+    max_error = 0.0
+    mismatches = 0
+    for (expected_path, expected_number), (_, observed_number) in zip(expected_values, observed_values):
+        if not math.isfinite(expected_number) or not math.isfinite(observed_number):
+            return CheckResult("runtime.equivalence", GateStatus.FAIL, "reference or target output contains a non-finite value", {"path": expected_path})
+        error = abs(expected_number - observed_number)
+        max_error = max(max_error, error)
+        if error > absolute_tolerance + relative_tolerance * abs(expected_number):
+            mismatches += 1
+    if mismatches:
+        return CheckResult("runtime.equivalence", GateStatus.FAIL, "target output exceeds declared tolerance", {"mismatches": mismatches, "max_absolute_error": max_error})
+    return CheckResult("runtime.equivalence", GateStatus.PASS, "target output is within declared tolerance", {"compared_values": len(expected_values), "max_absolute_error": max_error})
+
+
+@dataclass(frozen=True)
+class BenchmarkResult:
+    warmup_runs: int
+    measured_runs: int
+    latency_seconds: tuple[float, ...]
+    peak_bytes: int
+    memory_scope: str = "python_tracemalloc"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "warmup_runs": self.warmup_runs,
+            "measured_runs": self.measured_runs,
+            "latency_seconds": list(self.latency_seconds),
+            "peak_bytes": self.peak_bytes,
+            "latency_min_seconds": min(self.latency_seconds),
+            "latency_max_seconds": max(self.latency_seconds),
+            "latency_mean_seconds": statistics.fmean(self.latency_seconds),
+            "latency_median_seconds": statistics.median(self.latency_seconds),
+            "latency_p95_seconds": _percentile(self.latency_seconds, 0.95),
+            # Samples are sequential calls. Counting the run count again would
+            # overstate throughput by the number of samples.
+            "throughput_runs_per_second": 1.0 / statistics.fmean(self.latency_seconds),
+            "peak_memory_scope": self.memory_scope,
+        }
+
+
+def _percentile(values: tuple[float, ...], quantile: float) -> float:
+    """Linear-interpolated percentile with no external statistics dependency."""
+
+    if not values:
+        raise ValueError("cannot compute a percentile for no samples")
+    ordered = sorted(values)
+    position = (len(ordered) - 1) * quantile
+    lower = math.floor(position)
+    upper = math.ceil(position)
+    if lower == upper:
+        return ordered[lower]
+    fraction = position - lower
+    return ordered[lower] + (ordered[upper] - ordered[lower]) * fraction
+
+
+def benchmark(call: Callable[[], Any], *, warmup_runs: int = 1, measured_runs: int = 5) -> BenchmarkResult:
+    """Measure a bounded callable workload with an explicit sample count."""
+
+    if isinstance(warmup_runs, bool) or isinstance(measured_runs, bool) or warmup_runs < 0 or measured_runs <= 0:
+        raise ValueError("warmup_runs must be non-negative and measured_runs must be positive")
+    for _ in range(warmup_runs):
+        call()
+    tracemalloc.start()
+    samples: list[float] = []
+    try:
+        for _ in range(measured_runs):
+            started = time.perf_counter()
+            call()
+            samples.append(time.perf_counter() - started)
+        _, peak_bytes = tracemalloc.get_traced_memory()
+    finally:
+        tracemalloc.stop()
+    return BenchmarkResult(warmup_runs, measured_runs, tuple(samples), peak_bytes)

inference_artifact_lab-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: inference-artifact-lab
+Version: 0.1.0.dev0
+Summary: Reproducible validation gates for machine-learning inference artifacts
+Author: Ray Carter
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Provides-Extra: runtime-cpu
+Requires-Dist: numpy>=1.26; extra == "runtime-cpu"
+Requires-Dist: onnxruntime==1.30.0; extra == "runtime-cpu"
+Dynamic: license-file
+
+# Inference Artifact Lab
+
+Inference Artifact Lab is a clean-room, public-by-design project for validating
+machine-learning deployment artifacts before release. Its first product increment
+is the **Model Release Gate**: a reproducible gate for artifact integrity,
+input/output contracts, runtime correctness, and environment compatibility.
+
+The project uses public models, public datasets, and generated fixtures. It does
+not train models, provide a general model-serving gateway, or claim model quality
+beyond the declared validation evidence.
+
+## Current status
+
+Development preview: public SqueezeNet CPU and TensorRT smoke runs are recorded.
+Phase 1 acceptance remains incomplete; report delivery and clean reproduction
+need further work. See [publication review](docs/publication-review.md) for
+known limitations. The commands below are development examples, not a verified
+from-scratch reproduction procedure.
+
+## Planned flow
+
+```text
+public model
+  -> source and artifact manifest
+  -> export/build
+  -> integrity and contract checks
+  -> reference/runtime equivalence checks
+  -> environment compatibility checks
+  -> resource benchmark
+  -> machine-readable release report
+```
+
+Run the public-reference smoke gate with:
+
+```text
+uv run --with torch --with torchvision --with onnx --with onnxruntime python scripts/run_torchvision_gate.py
+```
+
+It writes `reports/phase-1/squeezenet11-torchvision-onnx-cpu.json`.
+
+Build and verify the TensorRT profile after pulling the pinned public image:
+
+```text
+pwsh scripts/build_tensorrt_engine.ps1
+pwsh scripts/benchmark_tensorrt_engine.ps1
+docker run --rm --gpus all -v "${PWD}:/workspace" -w /workspace `
+  -e MODEL_RELEASE_GATE_CONTAINER_DIGEST=sha256:814325e2b8a653f354c30bbcf5ecc8d4c780cf878a88a320ae648fbfdd9dd82d `
+  nvcr.io/nvidia/tensorrt:25.02-py3 bash -lc `
+  "python -m pip install --quiet --index-url https://pypi.org/simple cuda-python==12.8.0; `
+   PYTHONPATH=/workspace/src python scripts/run_tensorrt_in_container.py `
+   --engine artifacts/squeezenet1.1-fp32.engine `
+   --fixture artifacts/squeezenet11-fixture.npy `
+   --output artifacts/squeezenet11-tensorrt-output.json"
+uv run --with numpy==2.4.6 python scripts/compose_tensorrt_report.py `
+  --trtexec-log reports/phase-1/tensorrt-trtexec-benchmark.log
+```
+
+The generated TensorRT report includes the contract, engine digest, fixture
+equivalence, declared GPU/container fingerprint, and `trtexec` benchmark scope.
+
+Render any JSON report for review with:
+
+```text
+uv run python scripts/render_report.py reports/phase-1/squeezenet11-tensorrt.json
+```
+
+The report contract is defined by
+`schemas/release-report.schema.json`. A clean CPU reproduction starts with
+`pwsh scripts/clean_reproduction.ps1` in a fresh checkout.
+
+After generating the public fixture and reference output, the package CLI can
+execute the ONNX CPU adapter directly:
+
+```text
+python -m inference_artifact_lab examples/squeezenet11-torchvision.manifest.json `
+  --runtime onnx-cpu --inputs-npy artifacts/squeezenet11-fixture.npy `
+  --reference-output reference-output.json --environment environment.json `
+  --report reports/phase-1/cli-onnx-cpu.json
+```
+
+The authoritative development documentation follows the same phase/stage model
+used by the other portfolio repositories. Start at the [Codex document index](docs/codex/README.md), then read the [product contract](docs/codex/product-contract.md) and [Phase 1 plan](docs/codex/phases/phase-1-model-release-gate/README.md).
+
+For the human-readable brief and clean-room record, see [Product Requirements](docs/product-requirements.md), [Acceptance Contract](docs/acceptance-contract.md), and [Clean-room Record](docs/clean-room-record.md).

inference_artifact_lab-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,13 @@
+inference_artifact_lab/__init__.py,sha256=eq18fL3SPg0T1IcZAs3wTU1zpPdrqefm8OXLXNReZV4,873
+inference_artifact_lab/__main__.py,sha256=aish58BchefowXKIKisQp8kzGRK45saklUht6wkjvW8,4758
+inference_artifact_lab/adapters.py,sha256=0JK-NLMKSj_GeFlPWuvXnqAxOxZQcGyLyRt78Q0McdQ,15134
+inference_artifact_lab/gate.py,sha256=yyw3FRfdvqQMf5-TcWXHLbr4JipK3nlhb6YpBQ36xq4,9046
+inference_artifact_lab/models.py,sha256=lRa-_xsNIV9gknWNOfS10wmSLLMnFMqhLjggvhi6ig4,11276
+inference_artifact_lab/release.py,sha256=0Sleewk6nZEt6-jfL_Ng5HIGvXAlErkjXL3BrNF1HSw,3424
+inference_artifact_lab/runtime.py,sha256=ytr5P_Uw0MwFz0uDyIU_0cdxrGMsomen6QHypxIaXME,7630
+inference_artifact_lab-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=cZ7PD6Jl--JcP-KqFD6GXX56-dNsFlJKUADp7V1Nk8c,1067
+inference_artifact_lab-0.1.0.dev0.dist-info/METADATA,sha256=Dg7vaVwlctoBoSKP8HTzQ_ixASSlg-An495CJyfc72c,4279
+inference_artifact_lab-0.1.0.dev0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+inference_artifact_lab-0.1.0.dev0.dist-info/entry_points.txt,sha256=s-aVGFxwMi_Bzlsd4E6Lnr7fAST6Dmqeon6sZ_UhY2I,76
+inference_artifact_lab-0.1.0.dev0.dist-info/top_level.txt,sha256=Je03_0iKNirWu8359N9ttOtqfyGB4Xkhx17mGNkOkdA,23
+inference_artifact_lab-0.1.0.dev0.dist-info/RECORD,,

inference_artifact_lab-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

inference_artifact_lab-0.1.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+model-release-gate = inference_artifact_lab.__main__:main

inference_artifact_lab-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ray Carter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inference_artifact_lab-0.1.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+inference_artifact_lab