gpu-stack-inspector 0.1.0__py3-none-any.whl

gpu_stack_inspector/rules/interpreters.py

@@ -0,0 +1,422 @@
+"""Checks of each inspected interpreter: usable, the shell's own, its PyTorch."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from gpu_stack_inspector.models import (
+    Confidence,
+    Evidence,
+    FailureKind,
+    Finding,
+    InterpreterFacts,
+    Severity,
+    Snapshot,
+    Status,
+)
+from gpu_stack_inspector.rules.catalog import RULES
+from gpu_stack_inspector.rules.engine import RuleContext
+from gpu_stack_inspector.rules.torch_build import TorchBuildKind, classify_torch
+
+_CANNOT_START = frozenset({FailureKind.NOT_FOUND, FailureKind.PERMISSION_DENIED})
+
+
+def _usable(interpreter: InterpreterFacts) -> bool:
+    return interpreter.version is not None
+
+
+@RULES.rule("GSI-ENV-001", "The interpreter can be inspected")
+def interpreter_usable(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether each named interpreter started and answered the metadata probe.
+
+    "Cannot be started" (a wrong path, a deleted environment, no execute permission) is
+    told apart from "starts and crashes" (a broken environment, a damaged standard
+    library), because they need different fixes. An interpreter that answered only in
+    part passes with the problems listed as limitations.
+    """
+    for interpreter in snapshot.interpreters:
+        details = tuple(f.detail for f in interpreter.failures)
+        if _usable(interpreter):
+            kind = ", ".join(
+                part
+                for part in (
+                    interpreter.implementation,
+                    "conda env" if interpreter.conda else None,
+                    "venv" if interpreter.virtualenv else None,
+                )
+                if part
+            )
+            yield Finding(
+                id="GSI-ENV-001",
+                status=Status.PASS,
+                severity=Severity.INFO,
+                confidence=Confidence.HIGH if not details else Confidence.MEDIUM,
+                summary=f"Python {interpreter.version} ({kind or 'python'})",
+                reason=f"Inspected {interpreter.path}.",
+                subject=interpreter.label,
+                evidence=(Evidence("python-probe", "executable", interpreter.executable),),
+                limitations=details,
+            )
+            continue
+        cannot_start = any(f.kind in _CANNOT_START for f in interpreter.failures)
+        yield Finding(
+            id="GSI-ENV-001",
+            status=Status.FAIL,
+            severity=Severity.HIGH,
+            confidence=Confidence.HIGH,
+            summary=(
+                "The interpreter cannot be started"
+                if cannot_start
+                else "The interpreter started but did not answer"
+            ),
+            reason=details[0] if details else "No answer from the metadata probe.",
+            subject=interpreter.label,
+            evidence=tuple(Evidence("python-probe", "failure", detail) for detail in details),
+            recommended_action=(
+                "Check the path: the environment may have been moved or deleted."
+                if cannot_start
+                else "Run the interpreter by hand to see the whole error; a damaged "
+                "environment usually has to be recreated."
+            ),
+            verify_command=f"{interpreter.path} --version",
+        )
+
+
+def _environment_directory(path: str) -> str:
+    # Same directory means same environment: bin/python and bin/python3 of one venv match,
+    # two venvs do not. Symlinks are not followed, they would make every venv equal to
+    # its base interpreter, which is why this is absolute() and not resolve().
+    return str(Path(path).absolute().parent)
+
+
+@RULES.rule("GSI-ENV-002", "The interpreter is the one the shell runs")
+def shell_interpreter(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether an inspected interpreter is the python the user's shell would start.
+
+    A common source of confusion: the environment that was checked (or fixed) is not the
+    one a plain `python` command runs, for example because another venv or conda env is
+    active. Only checked when a single interpreter is inspected: naming several means
+    other environments are being compared on purpose. Interpreters count as the same when
+    they live in the same directory (symlinks are not followed), so two interpreters of
+    one environment in different directories are reported as different.
+    """
+    if context.shell_python is None or len(snapshot.interpreters) != 1:
+        return
+    shell_directory = _environment_directory(context.shell_python)
+    for interpreter in snapshot.interpreters:
+        if not _usable(interpreter):
+            continue
+        if _environment_directory(interpreter.path) == shell_directory:
+            continue
+        yield Finding(
+            id="GSI-ENV-002",
+            status=Status.WARN,
+            severity=Severity.LOW,
+            confidence=Confidence.MEDIUM,
+            summary="This is not the python your shell runs",
+            reason=(
+                f"Your shell runs {context.shell_python}. Results for {interpreter.path} do not "
+                "apply to programs started with a plain `python` command."
+            ),
+            subject=interpreter.label,
+            evidence=(Evidence("PATH", "python", context.shell_python),),
+            recommended_action=(
+                "Activate this environment before running your program, or start it with "
+                "this interpreter's full path."
+            ),
+            verify_command="which python",
+        )
+
+
+# Installed packages that cannot work without torch.
+TORCH_DEPENDENTS = frozenset(
+    {"torchvision", "torchaudio", "xformers", "flash-attn", "bitsandbytes", "accelerate",
+     "deepspeed", "vllm"}
+)  # fmt: skip
+
+
+@RULES.rule("GSI-TORCH-001", "PyTorch is installed")
+def torch_installed(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether the interpreter has PyTorch, and whether it needs it.
+
+    An environment without torch is only a problem when it contains packages that need
+    it (accelerate, bitsandbytes, torchvision…): then the environment is incomplete.
+    Otherwise the PyTorch checks do not apply to it.
+    """
+    for interpreter in snapshot.interpreters:
+        if not _usable(interpreter):
+            continue
+        if interpreter.torch is not None:
+            yield Finding(
+                id="GSI-TORCH-001",
+                status=Status.PASS,
+                severity=Severity.INFO,
+                confidence=Confidence.HIGH,
+                summary=f"torch {interpreter.torch.version} is installed",
+                reason=f"Found in {interpreter.torch.location or 'an unknown location'}.",
+                subject=interpreter.label,
+                evidence=(Evidence("python-metadata", "torch", interpreter.torch.version),),
+            )
+            continue
+        dependents = sorted(d.name for d in interpreter.distributions if d.name in TORCH_DEPENDENTS)
+        if dependents:
+            yield Finding(
+                id="GSI-TORCH-001",
+                status=Status.WARN,
+                severity=Severity.MEDIUM,
+                confidence=Confidence.HIGH,
+                summary="PyTorch is missing, but packages that need it are installed",
+                reason=f"{', '.join(dependents)} cannot work without torch.",
+                subject=interpreter.label,
+                evidence=tuple(
+                    Evidence("python-metadata", name, "installed") for name in dependents
+                ),
+                recommended_action=(
+                    "Install PyTorch with the selector at https://pytorch.org/get-started/locally/"
+                    ", choosing a CUDA version the driver supports."
+                ),
+                verify_command=f"gpu-stack-inspector inspect --python {interpreter.path}",
+            )
+        else:
+            yield Finding(
+                id="GSI-TORCH-001",
+                status=Status.NOT_APPLICABLE,
+                severity=Severity.INFO,
+                confidence=Confidence.HIGH,
+                summary="No PyTorch in this environment",
+                reason="Nothing installed here needs it, so the PyTorch checks do not apply.",
+                subject=interpreter.label,
+            )
+
+
+_SELECTOR = "https://pytorch.org/get-started/locally/"
+
+
+@RULES.rule("GSI-TORCH-002", "The PyTorch build supports CUDA", sources=(_SELECTOR,))
+def torch_build_supports_cuda(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether the installed PyTorch is a CUDA build, judged from static evidence only.
+
+    The evidence is the version tag, torch/version.py, the CUDA libraries in torch/lib,
+    the nvidia-* requirements and conda's package records; nothing is imported. A CPU-only
+    build where CUDA is expected is the most common reason for
+    `torch.cuda.is_available()` returning False. Conflicting evidence gives "unknown",
+    never a guess. ROCm builds are named but not judged: this tool checks NVIDIA CUDA.
+    """
+    max_cuda = snapshot.nvidia.max_cuda_version if snapshot.nvidia else None
+    for interpreter in snapshot.interpreters:
+        if not _usable(interpreter) or interpreter.torch is None:
+            continue
+        build = classify_torch(interpreter.torch)
+        subject, confidence, evidence = interpreter.label, build.confidence, build.evidence
+        if build.kind is TorchBuildKind.CUDA:
+            target = f"CUDA {build.cuda_version}" if build.cuda_version else "CUDA"
+            yield Finding(
+                id="GSI-TORCH-002",
+                status=Status.PASS,
+                severity=Severity.INFO,
+                summary=f"torch {interpreter.torch.version} is a {target} build",
+                reason="The metadata of this torch shows a CUDA build. Nothing was imported.",
+                limitations=build.conflicts,
+                subject=subject,
+                confidence=confidence,
+                evidence=evidence,
+            )
+        elif build.kind is TorchBuildKind.CPU:
+            choose = (
+                f"a CUDA version up to {max_cuda} (what this driver supports)"
+                if max_cuda
+                else "a CUDA version your NVIDIA driver supports"
+            )
+            yield Finding(
+                id="GSI-TORCH-002",
+                status=Status.FAIL if context.cuda_expected else Status.PASS,
+                severity=Severity.HIGH if context.cuda_expected else Severity.INFO,
+                summary=f"torch {interpreter.torch.version} is a CPU-only build",
+                reason=(
+                    "This build has no CUDA support, so torch.cuda.is_available() is False "
+                    "here whatever the driver can do."
+                ),
+                recommended_action=(
+                    f"Install a CUDA build with the selector at {_SELECTOR}, choosing {choose}."
+                ),
+                verify_command=f"gpu-stack-inspector inspect --python {interpreter.path}",
+                subject=subject,
+                confidence=confidence,
+                evidence=evidence,
+            )
+        elif build.kind is TorchBuildKind.ROCM:
+            yield Finding(
+                id="GSI-TORCH-002",
+                status=Status.NOT_APPLICABLE,
+                severity=Severity.INFO,
+                summary=f"torch {interpreter.torch.version} is a ROCm build",
+                reason="ROCm builds target AMD GPUs; this tool only checks NVIDIA CUDA.",
+                subject=subject,
+                confidence=confidence,
+                evidence=evidence,
+            )
+        else:
+            yield Finding(
+                id="GSI-TORCH-002",
+                status=Status.UNKNOWN,
+                severity=Severity.MEDIUM,
+                summary="The kind of PyTorch build could not be determined",
+                reason=(
+                    "; ".join(build.conflicts)
+                    if build.conflicts
+                    else "No tag, version file, library or package record says which build it is."
+                ),
+                recommended_action=(
+                    "The installation looks inconsistent; reinstalling torch in this "
+                    "environment usually fixes it."
+                    if build.conflicts
+                    else None
+                ),
+                subject=subject,
+                confidence=confidence,
+                evidence=evidence,
+            )
+
+
+def _unavailable_cause(snapshot: Snapshot, interpreter: InterpreterFacts) -> str | None:
+    """The finding that explains torch.cuda.is_available() being False, if one does."""
+    if classify_torch(interpreter.torch).kind is TorchBuildKind.CPU:
+        return "GSI-TORCH-002"
+    nvidia = snapshot.nvidia
+    if nvidia is not None and nvidia.smi_path is not None and nvidia.driver_version is None:
+        return "GSI-SYS-002"
+    if nvidia is not None and nvidia.driver_version is not None and not nvidia.gpus:
+        return "GSI-SYS-003"
+    hidden = next((v for v in snapshot.cuda_environment if v.name == "CUDA_VISIBLE_DEVICES"), None)
+    if hidden is not None and hidden.value.strip() in {"", "-1"}:
+        return "GSI-ENV-003"
+    return None
+
+
+@RULES.rule("GSI-TORCH-003", "CUDA works at runtime")
+def cuda_works(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether importing torch and running a tiny CUDA operation worked (probe --runtime).
+
+    The only check that proves CUDA works: it imports torch in the target interpreter,
+    asks torch.cuda.is_available(), lists the devices and runs a tensor operation on the
+    GPU. A failure names the step and the error. "No kernel image is available" means the
+    build has no code for this GPU's compute capability. When CUDA is unavailable, the
+    finding points at the check that explains why, if one does.
+    """
+    for interpreter in snapshot.interpreters:
+        runtime = interpreter.runtime
+        if runtime is None:
+            continue
+        check = f"gpu-stack-inspector probe --runtime --python {interpreter.path}"
+        failed = next((s for s in runtime.steps if not s.ok), None)
+        if runtime.failure is not None or (failed is not None and failed.step == "import torch"):
+            detail = runtime.failure.detail if runtime.failure else (failed.error if failed else "")
+            yield Finding(
+                id="GSI-TORCH-003",
+                status=Status.FAIL,
+                severity=Severity.HIGH,
+                confidence=Confidence.HIGH,
+                summary=(
+                    "import torch fails"
+                    if runtime.failure is None
+                    else "The interpreter did not survive using CUDA"
+                ),
+                reason=detail or "No detail was reported.",
+                recommended_action=(
+                    "Run `python -c \"import torch; print(torch.ones(1, device='cuda'))\"` in this "
+                    "environment to see the whole error; missing or mismatched CUDA libraries in "
+                    "the environment are the usual cause."
+                ),
+                evidence=tuple(Evidence("runtime", s.step, s.error or "ok") for s in runtime.steps),
+                subject=interpreter.label,
+                verify_command=check,
+            )
+        elif runtime.cuda_available is False:
+            yield Finding(
+                id="GSI-TORCH-003",
+                status=Status.FAIL if context.cuda_expected else Status.NOT_APPLICABLE,
+                severity=Severity.HIGH,
+                confidence=Confidence.HIGH,
+                summary="torch.cuda.is_available() is False",
+                reason=f"torch {runtime.torch_version or '?'} found no usable CUDA device.",
+                caused_by=_unavailable_cause(snapshot, interpreter),
+                evidence=(Evidence("runtime", "cuda available", "False"),),
+                subject=interpreter.label,
+                verify_command=check,
+            )
+        elif runtime.tensor_ok is False and failed is not None:
+            error = failed.error or ""
+            capability = runtime.devices[0].compute_capability if runtime.devices else None
+            no_kernels = "no kernel image" in error.lower()
+            yield Finding(
+                id="GSI-TORCH-003",
+                status=Status.FAIL,
+                severity=Severity.HIGH,
+                confidence=Confidence.HIGH,
+                summary="A CUDA operation failed",
+                reason=error,
+                recommended_action=(
+                    f"This torch build has no GPU code for compute capability "
+                    f"{capability or 'of this GPU'}; install a build that supports this GPU "
+                    "(see the PyTorch release notes)."
+                    if no_kernels
+                    else "Check the driver with `nvidia-smi`, then run the operation by hand "
+                    "to see the whole error."
+                ),
+                evidence=(Evidence("runtime", failed.step, error),),
+                subject=interpreter.label,
+                verify_command=check,
+            )
+        elif runtime.tensor_ok is True:
+            device = runtime.devices[0].name if runtime.devices else "the GPU"
+            seconds = next((s.seconds for s in runtime.steps if s.step == "tensor operation"), None)
+            yield Finding(
+                id="GSI-TORCH-003",
+                status=Status.PASS,
+                severity=Severity.INFO,
+                confidence=Confidence.HIGH,
+                summary=f"A CUDA operation ran on {device}",
+                reason=(
+                    f"torch {runtime.torch_version or '?'} with CUDA {runtime.cuda_version or '?'}"
+                    + (
+                        f"; the tensor operation took {seconds:.2f} s."
+                        if seconds is not None
+                        else "."
+                    )
+                ),
+                evidence=tuple(Evidence("runtime", s.step, "ok") for s in runtime.steps),
+                subject=interpreter.label,
+                verify_command=check,
+            )
+
+
+@RULES.rule("GSI-TORCH-004", "CUDA was exercised at runtime")
+def cuda_exercised(snapshot: Snapshot, context: RuleContext) -> Iterator[Finding]:
+    """Whether a CUDA build of torch was actually tried, not only read from metadata.
+
+    Metadata can show a CUDA build, but only importing torch and running an operation
+    proves it works: libraries can be missing, the driver can refuse, the build can lack
+    code for this GPU. Without probe --runtime this is "not tested", never a pass.
+    """
+    for interpreter in snapshot.interpreters:
+        if interpreter.version is None or interpreter.runtime is not None:
+            continue
+        if classify_torch(interpreter.torch).kind is not TorchBuildKind.CUDA:
+            continue
+        yield Finding(
+            id="GSI-TORCH-004",
+            status=Status.NOT_TESTED,
+            severity=Severity.LOW,
+            confidence=Confidence.HIGH,
+            summary="CUDA was not exercised; only metadata was read",
+            reason=(
+                "A CUDA build can still fail at runtime: missing libraries, a driver that "
+                "refuses, or no code for this GPU."
+            ),
+            subject=interpreter.label,
+            recommended_action=(
+                f"Run `gpu-stack-inspector probe --runtime --python {interpreter.path}` to import "
+                "torch and run a tiny CUDA operation (it uses a little GPU memory)."
+            ),
+        )

gpu_stack_inspector/rules/torch_build.py

@@ -0,0 +1,227 @@
+"""What kind of PyTorch build an interpreter has, from static evidence only.
+
+No single signal is reliable: PyPI's CUDA wheels have no ``+cu`` tag, conda's builds
+have neither a tag nor nvidia-* wheels, and a damaged install can have the metadata of
+one build and the files of another. Each signal votes; agreement gives confidence,
+disagreement between strong signals gives ``unknown`` with the conflict spelled out.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+
+from gpu_stack_inspector.models import Confidence, Evidence, TorchFacts
+
+
+class TorchBuildKind(StrEnum):
+    MISSING = "missing"
+    CUDA = "cuda"
+    CPU = "cpu"
+    ROCM = "rocm"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True, slots=True)
+class TorchBuild:
+    """The verdict, the CUDA version the build targets when known, and why."""
+
+    kind: TorchBuildKind
+    confidence: Confidence
+    cuda_version: str | None = None
+    evidence: tuple[Evidence, ...] = ()
+    conflicts: tuple[str, ...] = ()
+
+
+_TAG = re.compile(r"\+(?P<tag>[A-Za-z]+)(?P<number>[0-9.]*)")
+_CONDA_PYTORCH = re.compile(r"pytorch-(?P<version>[0-9][^-]*)-(?P<build>.+)")
+_CONDA_MUTEX = re.compile(r"pytorch-mutex-[0-9.]+-(?P<flavour>[A-Za-z]+)")
+_CONDA_PYTORCH_CUDA = re.compile(r"pytorch-cuda-(?P<version>[0-9]+\.[0-9]+)-")
+_CUDA_IN_BUILD = re.compile(r"cuda(?P<digits>[0-9]+)(?:\.(?P<minor>[0-9]+))?")
+
+# Which signal's CUDA version wins when several name one: the build's own record first.
+_VERSION_PY, _TAG_PRIORITY, _CONDA, _OTHER = 0, 1, 2, 9
+
+
+@dataclass(frozen=True, slots=True)
+class _Vote:
+    kind: TorchBuildKind
+    strong: bool
+    source: str
+    """Human description, used in conflict messages: "the version tag +cu128"."""
+    cuda_version: str | None = None
+    priority: int = _OTHER
+
+
+def classify_torch(torch: TorchFacts | None) -> TorchBuild:
+    """Classify the build from the evidence of the torch an interpreter would import."""
+    if torch is None:
+        return TorchBuild(
+            TorchBuildKind.MISSING,
+            Confidence.HIGH,
+            evidence=(Evidence("python-metadata", "torch", None),),
+        )
+    votes: list[_Vote] = []
+    evidence: list[Evidence] = [Evidence("torch-metadata", "version", torch.version)]
+    _version_tag(torch, votes)
+    _version_py(torch, votes, evidence)
+    _libraries(torch, votes, evidence)
+    _requirements(torch, votes, evidence)
+    _conda(torch, votes, evidence)
+    return _decide(votes, tuple(evidence))
+
+
+def cuda_from_digits(digits: str) -> str:
+    """``128`` → ``12.8``, ``92`` → ``9.2``: how PyTorch writes CUDA versions in tags."""
+    return f"{digits[:-1]}.{digits[-1]}" if len(digits) >= 2 else digits
+
+
+def _version_tag(torch: TorchFacts, votes: list[_Vote]) -> None:
+    match = _TAG.search(torch.version)
+    if match is None:
+        return  # PyPI's CUDA wheels and conda builds have no tag
+    tag, number = match["tag"].lower(), match["number"]
+    source = f"the version tag +{tag}{number}"
+    if tag == "cu" and number.isdigit():
+        votes.append(
+            _Vote(TorchBuildKind.CUDA, True, source, cuda_from_digits(number), _TAG_PRIORITY)
+        )
+    elif tag == "cpu":
+        votes.append(_Vote(TorchBuildKind.CPU, True, source))
+    elif tag == "rocm":
+        votes.append(_Vote(TorchBuildKind.ROCM, True, source))
+
+
+def _version_py(torch: TorchFacts, votes: list[_Vote], evidence: list[Evidence]) -> None:
+    if not torch.version_py_found:
+        evidence.append(Evidence("torch/version.py", "found", "no"))
+        return
+    evidence.append(Evidence("torch/version.py", "cuda", torch.built_cuda or "None"))
+    evidence.append(Evidence("torch/version.py", "hip", torch.built_hip or "None"))
+    if torch.built_hip:
+        votes.append(_Vote(TorchBuildKind.ROCM, True, f"torch/version.py (hip {torch.built_hip})"))
+    elif torch.built_cuda:
+        source = f"torch/version.py (cuda {torch.built_cuda})"
+        votes.append(_Vote(TorchBuildKind.CUDA, True, source, torch.built_cuda, _VERSION_PY))
+    else:
+        votes.append(_Vote(TorchBuildKind.CPU, True, "torch/version.py (cuda None)"))
+
+
+def _libraries(torch: TorchFacts, votes: list[_Vote], evidence: list[Evidence]) -> None:
+    for key, present in (("cuda_library", torch.cuda_library), ("hip_library", torch.hip_library)):
+        if present is not None:
+            evidence.append(Evidence("torch/lib", key, "present" if present else "absent"))
+    if torch.cuda_library:
+        votes.append(_Vote(TorchBuildKind.CUDA, True, "libtorch_cuda in torch/lib"))
+    elif torch.hip_library:
+        votes.append(_Vote(TorchBuildKind.ROCM, True, "libtorch_hip in torch/lib"))
+    elif torch.cuda_library is False and torch.hip_library is False:
+        # Weak: files can be missing from a damaged install of a GPU build.
+        votes.append(_Vote(TorchBuildKind.CPU, False, "no GPU library in torch/lib"))
+
+
+def _requirements(torch: TorchFacts, votes: list[_Vote], evidence: list[Evidence]) -> None:
+    if torch.requires_nvidia:
+        evidence.append(
+            Evidence("torch-metadata", "requires_nvidia", ", ".join(torch.requires_nvidia))
+        )
+        votes.append(_Vote(TorchBuildKind.CUDA, False, "its nvidia-* requirements"))
+
+
+def _conda(torch: TorchFacts, votes: list[_Vote], evidence: list[Evidence]) -> None:
+    for record in torch.conda_records or ():
+        if (match := _CONDA_PYTORCH.fullmatch(record)) is not None:
+            evidence.append(Evidence("conda-meta", "pytorch", record))
+            build = match["build"].lower()
+            source = f"conda's pytorch build {match['build']}"
+            if (cuda := _CUDA_IN_BUILD.search(build)) is not None:
+                version = (
+                    f"{cuda['digits']}.{cuda['minor']}"
+                    if cuda["minor"] is not None
+                    else cuda_from_digits(cuda["digits"])
+                )
+                votes.append(_Vote(TorchBuildKind.CUDA, True, source, version, _CONDA))
+            elif "cpu" in build:
+                votes.append(_Vote(TorchBuildKind.CPU, True, source))
+        elif (mutex := _CONDA_MUTEX.fullmatch(record)) is not None:
+            evidence.append(Evidence("conda-meta", "pytorch-mutex", record))
+            flavour = mutex["flavour"].lower()
+            kind = {"cuda": TorchBuildKind.CUDA, "cpu": TorchBuildKind.CPU}.get(flavour)
+            if kind is not None:
+                votes.append(_Vote(kind, False, f"conda's pytorch-mutex ({flavour})"))
+        elif (pytorch_cuda := _CONDA_PYTORCH_CUDA.match(record)) is not None:
+            evidence.append(Evidence("conda-meta", "pytorch-cuda", record))
+            votes.append(
+                _Vote(
+                    TorchBuildKind.CUDA,
+                    False,
+                    "conda's pytorch-cuda",
+                    pytorch_cuda["version"],
+                    _CONDA,
+                )
+            )
+
+
+_LOWER = {
+    Confidence.HIGH: Confidence.MEDIUM,
+    Confidence.MEDIUM: Confidence.LOW,
+    Confidence.LOW: Confidence.LOW,
+}
+
+
+def _decide(votes: list[_Vote], evidence: tuple[Evidence, ...]) -> TorchBuild:
+    if not votes:
+        return TorchBuild(TorchBuildKind.UNKNOWN, Confidence.LOW, evidence=evidence)
+    strong_kinds = {vote.kind for vote in votes if vote.strong}
+    if len(strong_kinds) > 1:
+        return TorchBuild(
+            TorchBuildKind.UNKNOWN,
+            Confidence.LOW,
+            evidence=evidence,
+            conflicts=tuple(_conflicts(votes)),
+        )
+    if strong_kinds:
+        kind = next(iter(strong_kinds))
+        agreeing_strong = sum(vote.strong for vote in votes)
+        confidence = Confidence.HIGH if agreeing_strong >= 2 else Confidence.MEDIUM
+    else:
+        weak_kinds = {vote.kind for vote in votes}
+        if len(weak_kinds) > 1:
+            return TorchBuild(
+                TorchBuildKind.UNKNOWN,
+                Confidence.LOW,
+                evidence=evidence,
+                conflicts=tuple(_conflicts(votes)),
+            )
+        kind = next(iter(weak_kinds))
+        confidence = Confidence.MEDIUM if len(votes) >= 2 else Confidence.LOW
+
+    conflicts = _conflicts(votes) if any(vote.kind is not kind for vote in votes) else []
+    cuda_version = None
+    if kind is TorchBuildKind.CUDA:
+        named = sorted((v for v in votes if v.cuda_version), key=lambda v: v.priority)
+        if named:
+            cuda_version = named[0].cuda_version
+            for other in named[1:]:
+                if other.cuda_version != cuda_version:
+                    conflicts.append(
+                        f"{named[0].source} says CUDA {cuda_version}, "
+                        f"but {other.source} says CUDA {other.cuda_version}"
+                    )
+    if conflicts:
+        confidence = _LOWER[confidence]
+    return TorchBuild(kind, confidence, cuda_version, evidence, tuple(conflicts))
+
+
+def _conflicts(votes: list[_Vote]) -> list[str]:
+    """One sentence per pair of disagreeing kinds, naming their strongest witnesses."""
+    witnesses: dict[TorchBuildKind, _Vote] = {}
+    for vote in sorted(votes, key=lambda v: not v.strong):
+        witnesses.setdefault(vote.kind, vote)
+    kinds = list(witnesses)
+    return [
+        f"{witnesses[a].source} says {a.value}, but {witnesses[b].source} says {b.value}"
+        for i, a in enumerate(kinds)
+        for b in kinds[i + 1 :]
+    ]