refactor: replace torch_version with frameworks dict, drop unverifiable container identity

- Removed container_identity() probe — Pyxis/enroot stores zero provenance
  metadata inside containers (confirmed by inspection on ptyche GB200)
- Removed torch_version as a standalone field — torch version is now captured
  inside the frameworks dict alongside vllm, sglang, tensorrt_llm, dynamo
- frameworks dict only includes detected frameworks (sparse)
- Added model_identity() probe for HF repo/revision from download metadata
- Updated pip freeze to use python3 -m pip freeze for better container compat
- Updated all tests to use new schema

Author: alec-flowers

src/srtctl/core/fingerprint.py

@@ -117,8 +117,11 @@ class FingerprintDiff:
     # Core versions
     "python_version",
     "cuda_version",
-    "torch_version",
     "nccl_version",
+    # Frameworks (vllm, sglang, trtllm, dynamo, torch)
+    "frameworks",
+    # Model identity (HF repo, revision)
+    "model",
     # Full package list (always last)
     "pip_packages",
 ]
@@ -234,14 +237,6 @@ def probe_cuda_version() -> ProbeResult:
     return ProbeResult.failure("nvcc not found")
 
 
-def probe_torch_version() -> ProbeResult:
-    """Get PyTorch version."""
-    out = _run_cmd('python3 -c "import torch; print(torch.__version__)"')
-    if out:
-        return ProbeResult.success(out)
-    return ProbeResult.failure("torch not importable")
-
-
 def probe_nccl_version() -> ProbeResult:
     """Get NCCL version via PyTorch."""
     out = _run_cmd('python3 -c "import torch; print(torch.cuda.nccl.version())"')
@@ -250,9 +245,25 @@ def probe_nccl_version() -> ProbeResult:
     return ProbeResult.failure("nccl version unavailable")
 
 
+def probe_frameworks() -> ProbeResult:
+    """Get versions of inference frameworks (only detected ones)."""
+    versions: dict[str, str] = {}
+    for name, cmd in [
+        ("vllm", 'python3 -c "import vllm; print(vllm.__version__)"'),
+        ("sglang", 'python3 -c "import sglang; print(sglang.__version__)"'),
+        ("tensorrt_llm", 'python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"'),
+        ("dynamo", "python3 -c \"import importlib.metadata; print(importlib.metadata.version('ai-dynamo'))\""),
+        ("torch", 'python3 -c "import torch; print(torch.__version__)"'),
+    ]:
+        v = _run_cmd(cmd)
+        if v:
+            versions[name] = v
+    return ProbeResult.success(versions)
+
+
 def probe_pip_packages() -> ProbeResult:
     """Get installed pip packages, sorted alphabetically (case-insensitive)."""
-    out = _run_cmd("pip freeze")
+    out = _run_cmd("python3 -m pip freeze 2>/dev/null") or _run_cmd("pip freeze")
     if out is None:
         return ProbeResult.failure("pip freeze failed")
 
@@ -276,8 +287,8 @@ def probe_pip_packages() -> ProbeResult:
     "gpu": probe_gpu,
     "python_version": probe_python_version,
     "cuda_version": probe_cuda_version,
-    "torch_version": probe_torch_version,
     "nccl_version": probe_nccl_version,
+    "frameworks": probe_frameworks,
     "pip_packages": probe_pip_packages,
 }
 
@@ -348,7 +359,6 @@ def load_fingerprint(path: Path) -> dict[str, Any] | None:
     "os",
     "python_version",
     "cuda_version",
-    "torch_version",
     "nccl_version",
 ]
 
@@ -605,33 +615,17 @@ def framework_versions():
         ('vllm', 'python3 -c "import vllm; print(vllm.__version__)"'),
         ('sglang', 'python3 -c "import sglang; print(sglang.__version__)"'),
         ('tensorrt_llm', 'python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"'),
-        ('dynamo', 'python3 -c "import dynamo; print(dynamo.__version__)"'),
+        ('dynamo', 'python3 -c "import importlib.metadata; print(importlib.metadata.version(\\\"ai-dynamo\\\"))"'),
     ]:
         v = run(cmd)
         if v:
             versions[name] = v
+    # torch embeds a git hash in the version string (e.g. 2.10.0a0+b4e4ee81d3.nv25.12)
+    torch_v = run('python3 -c "import torch; print(torch.__version__)"')
+    if torch_v:
+        versions['torch'] = torch_v
     return versions
 
-def container_identity():
-    info = {{}}
-    # Pyxis/enroot: /etc/enroot stores import metadata
-    for p in ['/etc/enroot/image.env', '/etc/enroot/.env']:
-        if Path(p).exists():
-            for line in Path(p).read_text().splitlines():
-                if '=' in line:
-                    k, _, v = line.partition('=')
-                    info[k.strip()] = v.strip().strip('"')
-            break
-    # Docker: inspect labels via /proc/1/cpuset or /.dockerenv
-    if not info and Path('/.dockerenv').exists():
-        info['runtime'] = 'docker'
-    # OCI image digest from /etc/enroot/image-digest if available
-    for p in ['/etc/enroot/image-digest', '/etc/enroot/.image-digest']:
-        if Path(p).exists():
-            info['digest'] = Path(p).read_text().strip()
-            break
-    return info or None
-
 def model_identity(model_path):
     info = {{}}
     mp = Path(model_path) if model_path else None
@@ -672,10 +666,8 @@ def model_identity(model_path):
     'gpu': gpu_info(),
     'python_version': platform.python_version(),
     'cuda_version': run('nvcc --version 2>/dev/null | grep release') or 'unavailable',
-    'torch_version': run('python3 -c "import torch; print(torch.__version__)"') or 'unavailable',
     'nccl_version': run('python3 -c "import torch; print(torch.cuda.nccl.version())"') or 'unavailable',
     'frameworks': framework_versions(),
-    'container': container_identity(),
     'model': model_identity('/model'),
     'pip_packages': pip_pkgs(),
 }}

tests/test_fingerprint.py

@@ -52,8 +52,8 @@ def _make_fingerprint(**overrides) -> dict:
         "gpu": {"available": True, "driver": "570.86.15", "gpus": [{"name": "GB200", "driver": "570.86.15", "memory": "192 GiB"}]},
         "python_version": "3.11.9",
         "cuda_version": "12.8",
-        "torch_version": "2.6.0+cu128",
         "nccl_version": "2.25.1",
+        "frameworks": {"torch": "2.6.0+cu128", "sglang": "0.4.6.post1", "dynamo": "0.8.1"},
         "pip_packages": [
             "ai-dynamo==0.8.1",
             "numpy==1.26.4",
@@ -85,8 +85,8 @@ def test_field_order_is_canonical(self):
             "gpu": {},
             "os": "Ubuntu",
             "cuda_version": "12.8",
-            "torch_version": "2.6.0",
             "nccl_version": "2.25",
+            "frameworks": {"torch": "2.6.0"},
         }
         ordered = _ordered_fingerprint(data)
         keys = list(ordered.keys())
@@ -157,8 +157,8 @@ def test_capture_with_all_probes_mocked(self):
             "gpu": lambda: ProbeResult.success({"available": False}),
             "python_version": lambda: ProbeResult.success("3.11.9"),
             "cuda_version": lambda: ProbeResult.success("12.8"),
-            "torch_version": lambda: ProbeResult.success("2.6.0"),
             "nccl_version": lambda: ProbeResult.success("2.25.1"),
+            "frameworks": lambda: ProbeResult.success({"torch": "2.6.0", "dynamo": "0.8.1"}),
             "pip_packages": lambda: ProbeResult.success(["numpy==1.0", "torch==2.6.0"]),
         }
 
@@ -273,14 +273,14 @@ def test_identical_fingerprints(self):
         assert diff.packages_removed == 0
 
     def test_scalar_field_change(self):
-        """Changed torch version shows up in field_changes."""
-        a = _make_fingerprint(torch_version="2.6.0+cu128")
-        b = _make_fingerprint(torch_version="2.7.0+cu128")
+        """Changed CUDA version shows up in field_changes."""
+        a = _make_fingerprint(cuda_version="12.8")
+        b = _make_fingerprint(cuda_version="13.1")
 
         diff = diff_fingerprints(a, b)
 
-        assert "torch_version" in diff.field_changes
-        assert diff.field_changes["torch_version"] == ("2.6.0+cu128", "2.7.0+cu128")
+        assert "cuda_version" in diff.field_changes
+        assert diff.field_changes["cuda_version"] == ("12.8", "13.1")
 
     def test_gpu_driver_change(self):
         """GPU driver change detected from nested structure."""
@@ -372,17 +372,17 @@ def test_matching_environment(self):
         assert results == []
 
     def test_version_mismatch_reported(self):
-        """Torch version change appears in results."""
-        ref = _make_fingerprint(torch_version="2.6.0")
-        cur = _make_fingerprint(torch_version="2.7.0")
+        """CUDA version change appears in results."""
+        ref = _make_fingerprint(cuda_version="12.8")
+        cur = _make_fingerprint(cuda_version="13.1")
 
         results = check_against_fingerprint(ref, cur)
 
-        torch_results = [r for r in results if r.field == "torch_version"]
-        assert len(torch_results) == 1
-        assert torch_results[0].status == CheckStatus.MISMATCH
-        assert torch_results[0].expected == "2.6.0"
-        assert torch_results[0].actual == "2.7.0"
+        cuda_results = [r for r in results if r.field == "cuda_version"]
+        assert len(cuda_results) == 1
+        assert cuda_results[0].status == CheckStatus.MISMATCH
+        assert cuda_results[0].expected == "12.8"
+        assert cuda_results[0].actual == "13.1"
 
     def test_missing_package_reported(self):
         """Package in reference but not current is MISSING."""
@@ -429,8 +429,8 @@ def test_captures_fresh_if_current_is_none(self):
             "gpu": lambda: ProbeResult.success({"available": True, "driver": "570.86.15", "gpus": []}),
             "python_version": lambda: ProbeResult.success("3.11.9"),
             "cuda_version": lambda: ProbeResult.success("12.8"),
-            "torch_version": lambda: ProbeResult.success("2.6.0+cu128"),
             "nccl_version": lambda: ProbeResult.success("2.25.1"),
+            "frameworks": lambda: ProbeResult.success(ref["frameworks"]),
             "pip_packages": lambda: ProbeResult.success(ref["pip_packages"]),
         }
 
@@ -620,8 +620,8 @@ def test_format_diff_identical(self):
 
     def test_format_diff_with_changes(self):
         """Changes are clearly shown."""
-        a = _make_fingerprint(torch_version="2.6.0", pip_packages=["torch==2.6.0"])
-        b = _make_fingerprint(torch_version="2.7.0", pip_packages=["torch==2.7.0"])
+        a = _make_fingerprint(cuda_version="12.8", pip_packages=["torch==2.6.0"])
+        b = _make_fingerprint(cuda_version="13.1", pip_packages=["torch==2.7.0"])
 
         diff = diff_fingerprints(a, b)
         output = format_diff(diff)
@@ -664,11 +664,11 @@ def test_format_check_results_with_mismatches(self):
         """Mismatches are clearly reported."""
         results = [
             CheckResult(
-                field="torch_version",
+                field="cuda_version",
                 status=CheckStatus.MISMATCH,
-                message="torch_version: 2.6.0 -> 2.7.0",
-                expected="2.6.0",
-                actual="2.7.0",
+                message="cuda_version: 12.8 -> 13.1",
+                expected="12.8",
+                actual="13.1",
             ),
             CheckResult(
                 field="pip:sglang",
@@ -680,5 +680,5 @@ def test_format_check_results_with_mismatches(self):
         output = format_check_results(results)
 
         assert "2 mismatches" in output
-        assert "torch_version" in output
+        assert "cuda_version" in output
         assert "sglang" in output