pybinaryguard 1.0.0__py3-none-any.whl

pybinaryguard/frameworks/onnxruntime.py

@@ -0,0 +1,214 @@
+"""ONNX Runtime framework deep inspection.
+
+Validates ONNX Runtime execution providers, version compatibility,
+and hardware acceleration support.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional, Set
+
+from pybinaryguard.models.package import PackageBinaryInfo
+from pybinaryguard.models.system import SystemProfile
+
+
+def check_onnx_runtime_providers(
+    package: PackageBinaryInfo,
+    profile: SystemProfile
+) -> List[Dict[str, str]]:
+    """Check ONNX Runtime execution providers and compatibility.
+
+    Validates:
+    - Available execution providers (CUDA, TensorRT, OpenVINO, etc.)
+    - CUDA provider compatibility with system
+    - Missing hardware-specific providers
+
+    Args:
+        package: PackageBinaryInfo for onnxruntime package
+        profile: System profile
+
+    Returns:
+        List of compatibility issues and recommendations
+    """
+    issues: List[Dict[str, str]] = []
+
+    if not package.name.lower().startswith("onnxruntime"):
+        return issues
+
+    # Detect available execution providers
+    providers = detect_execution_providers(package)
+
+    # Check if GPU package on GPU system
+    has_gpu = profile.cuda_runtime_version is not None
+    has_cuda_provider = "CUDAExecutionProvider" in providers
+
+    if has_gpu and not has_cuda_provider:
+        issues.append({
+            "issue": "missing_cuda_provider",
+            "severity": "warning",
+            "message": "NVIDIA GPU detected but CUDA execution provider not available",
+            "recommendation": "Install onnxruntime-gpu instead of onnxruntime for GPU acceleration",
+        })
+
+    if has_cuda_provider and not has_gpu:
+        issues.append({
+            "issue": "cuda_provider_no_gpu",
+            "severity": "info",
+            "message": "CUDA execution provider available but no NVIDIA GPU detected",
+            "recommendation": "Install onnxruntime (CPU) to reduce package size",
+        })
+
+    # Check CUDA provider version compatibility
+    if has_cuda_provider and profile.cuda_runtime_version:
+        cuda_compat_issues = check_onnx_cuda_compatibility(
+            package.version,
+            profile.cuda_runtime_version
+        )
+        if cuda_compat_issues:
+            issues.append({
+                "issue": "onnx_cuda_version_mismatch",
+                "severity": "warning",
+                "message": cuda_compat_issues,
+                "recommendation": "Check ONNX Runtime CUDA compatibility matrix",
+            })
+
+    # Check for TensorRT provider on Jetson
+    if profile.board_name and "jetson" in profile.board_name.lower():
+        if "TensorrtExecutionProvider" not in providers:
+            issues.append({
+                "issue": "missing_tensorrt_provider_jetson",
+                "severity": "info",
+                "message": "TensorRT execution provider not detected on Jetson device",
+                "recommendation": "Build ONNX Runtime with TensorRT support for optimal performance",
+            })
+
+    return issues
+
+
+def detect_execution_providers(package: PackageBinaryInfo) -> Set[str]:
+    """Detect available ONNX Runtime execution providers.
+
+    Args:
+        package: PackageBinaryInfo for onnxruntime package
+
+    Returns:
+        Set of detected execution provider names
+    """
+    providers: Set[str] = set()
+
+    # Always has CPU provider
+    providers.add("CPUExecutionProvider")
+
+    for so in package.shared_objects:
+        if not so.path:
+            continue
+
+        path_lower = so.path.lower()
+
+        # CUDA provider
+        if "cuda" in path_lower:
+            providers.add("CUDAExecutionProvider")
+
+        # TensorRT provider
+        if "tensorrt" in path_lower:
+            providers.add("TensorrtExecutionProvider")
+
+        # OpenVINO provider
+        if "openvino" in path_lower:
+            providers.add("OpenVINOExecutionProvider")
+
+        # DirectML provider (Windows)
+        if "directml" in path_lower:
+            providers.add("DmlExecutionProvider")
+
+        # CoreML provider (macOS)
+        if "coreml" in path_lower:
+            providers.add("CoreMLExecutionProvider")
+
+    return providers
+
+
+def check_onnx_cuda_compatibility(
+    onnx_version: Optional[str],
+    cuda_version: Optional[str]
+) -> Optional[str]:
+    """Check ONNX Runtime GPU version compatibility with CUDA.
+
+    Args:
+        onnx_version: ONNX Runtime version (e.g., "1.16.0")
+        cuda_version: CUDA version (e.g., "12.1")
+
+    Returns:
+        Error message if incompatible, None if compatible
+    """
+    if not onnx_version or not cuda_version:
+        return None
+
+    # Compatibility matrix (ONNX Runtime -> CUDA versions)
+    compatibility_matrix = {
+        "1.16": ["11.8", "12.2"],
+        "1.15": ["11.8", "12.1"],
+        "1.14": ["11.6", "11.7", "11.8"],
+        "1.13": ["11.6", "11.7"],
+        "1.12": ["11.4", "11.6"],
+        "1.11": ["11.4"],
+    }
+
+    try:
+        onnx_major_minor = ".".join(onnx_version.split(".")[:2])
+        cuda_major_minor = ".".join(cuda_version.split(".")[:2])
+
+        supported_cuda = compatibility_matrix.get(onnx_major_minor, [])
+
+        if supported_cuda and cuda_major_minor not in supported_cuda:
+            return (
+                f"ONNX Runtime {onnx_major_minor} supports CUDA {', '.join(supported_cuda)}, "
+                f"but system has CUDA {cuda_version}"
+            )
+    except (ValueError, IndexError):
+        pass
+
+    return None
+
+
+def check_onnx_opset_compatibility(
+    model_opset: int,
+    onnxruntime_version: Optional[str]
+) -> Optional[str]:
+    """Check if ONNX model opset is supported by ONNX Runtime version.
+
+    Args:
+        model_opset: ONNX model opset version
+        onnxruntime_version: ONNX Runtime version
+
+    Returns:
+        Error message if incompatible, None if compatible
+    """
+    if not onnxruntime_version:
+        return None
+
+    # Maximum supported opset by ONNX Runtime version
+    max_opset_by_version = {
+        "1.16": 19,
+        "1.15": 18,
+        "1.14": 18,
+        "1.13": 17,
+        "1.12": 16,
+        "1.11": 15,
+        "1.10": 15,
+    }
+
+    try:
+        ort_major_minor = ".".join(onnxruntime_version.split(".")[:2])
+        max_opset = max_opset_by_version.get(ort_major_minor, 19)
+
+        if model_opset > max_opset:
+            return (
+                f"Model requires ONNX opset {model_opset}, "
+                f"but ONNX Runtime {ort_major_minor} only supports up to opset {max_opset}"
+            )
+    except (ValueError, IndexError):
+        pass
+
+    return None

pybinaryguard/frameworks/pytorch.py

@@ -0,0 +1,223 @@
+"""PyTorch framework deep inspection.
+
+Validates PyTorch CUDA ABI compatibility, build configuration, and
+version-specific requirements beyond generic binary checks.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional, Tuple
+
+from pybinaryguard.models.package import PackageBinaryInfo
+from pybinaryguard.models.system import SystemProfile
+
+
+def detect_pytorch_build(package: PackageBinaryInfo) -> Dict[str, Optional[str]]:
+    """Detect PyTorch build configuration from binary metadata.
+
+    Args:
+        package: PackageBinaryInfo for torch package
+
+    Returns:
+        Dictionary with detected build info:
+        - cuda_version: CUDA version (e.g., "11.8", "12.1")
+        - cxx11_abi: C++11 ABI status ("enabled", "disabled", "unknown")
+        - cpu_only: Whether this is CPU-only build
+        - rocm_version: ROCm version if AMD build
+    """
+    result: Dict[str, Optional[str]] = {
+        "cuda_version": None,
+        "cxx11_abi": None,
+        "cpu_only": False,
+        "rocm_version": None,
+    }
+
+    # Check package CUDA version from metadata
+    if package.cuda_version:
+        result["cuda_version"] = package.cuda_version
+
+    # Check for CPU-only build from package name patterns
+    if any(so.path and "cpu" in so.path.lower() for so in package.shared_objects):
+        result["cpu_only"] = True
+
+    # Check for ROCm (AMD GPU) build
+    for so in package.shared_objects:
+        if so.path and "rocm" in so.path.lower():
+            # Try to extract ROCm version
+            match = re.search(r"rocm[_-]?(\d+\.\d+)", so.path.lower())
+            if match:
+                result["rocm_version"] = match.group(1)
+
+    # Detect C++11 ABI from GLIBCXX symbols
+    # PyTorch with new ABI uses GLIBCXX_3.4.21+, old ABI uses GLIBCXX_3.4.19
+    max_glibcxx = None
+    for so in package.shared_objects:
+        for symbol in so.symbols:
+            if symbol.startswith("GLIBCXX_3.4."):
+                version_str = symbol.replace("GLIBCXX_3.4.", "")
+                try:
+                    version_num = int(version_str)
+                    if max_glibcxx is None or version_num > max_glibcxx:
+                        max_glibcxx = version_num
+                except ValueError:
+                    continue
+
+    if max_glibcxx is not None:
+        # GLIBCXX >= 3.4.21 indicates C++11 ABI
+        result["cxx11_abi"] = "enabled" if max_glibcxx >= 21 else "disabled"
+    else:
+        result["cxx11_abi"] = "unknown"
+
+    return result
+
+
+def check_pytorch_cuda_abi(
+    package: PackageBinaryInfo,
+    profile: SystemProfile
+) -> List[Dict[str, str]]:
+    """Check PyTorch CUDA ABI compatibility.
+
+    Validates:
+    - CUDA version matches system runtime
+    - C++11 ABI compatibility with system
+    - Compute capability support
+    - cuDNN version requirements
+
+    Args:
+        package: PackageBinaryInfo for torch package
+        profile: System profile
+
+    Returns:
+        List of compatibility issues found
+    """
+    issues: List[Dict[str, str]] = []
+
+    if package.name.lower() != "torch":
+        return issues
+
+    build_info = detect_pytorch_build(package)
+
+    # Check CUDA version compatibility
+    if build_info["cuda_version"] and profile.cuda_runtime_version:
+        pkg_cuda_major = int(build_info["cuda_version"].split(".")[0])
+        sys_cuda_major = int(profile.cuda_runtime_version.split(".")[0])
+
+        if pkg_cuda_major != sys_cuda_major:
+            issues.append({
+                "issue": "cuda_major_mismatch",
+                "severity": "critical",
+                "message": (
+                    f"PyTorch built for CUDA {build_info['cuda_version']} but "
+                    f"system has CUDA {profile.cuda_runtime_version}"
+                ),
+                "recommendation": f"Install PyTorch built for CUDA {sys_cuda_major}.x",
+            })
+
+    # Check for CPU-only PyTorch on GPU system
+    if build_info["cpu_only"] and profile.cuda_runtime_version:
+        issues.append({
+            "issue": "cpu_build_on_gpu_system",
+            "severity": "warning",
+            "message": "CPU-only PyTorch detected on system with NVIDIA GPU",
+            "recommendation": "Install GPU-enabled PyTorch to utilize available hardware",
+        })
+
+    # Check compute capability for PyTorch 2.x
+    if package.version and package.version.startswith("2."):
+        if profile.cuda_compute_capability:
+            compute_major = int(profile.cuda_compute_capability.split(".")[0])
+            # PyTorch 2.x requires compute capability >= 3.5
+            if compute_major < 3 or (compute_major == 3 and int(profile.cuda_compute_capability.split(".")[1]) < 5):
+                issues.append({
+                    "issue": "compute_capability_too_low",
+                    "severity": "critical",
+                    "message": (
+                        f"PyTorch 2.x requires compute capability >= 3.5, "
+                        f"but GPU has {profile.cuda_compute_capability}"
+                    ),
+                    "recommendation": "Downgrade to PyTorch 1.x or upgrade GPU hardware",
+                })
+
+    # Check C++11 ABI compatibility
+    if build_info["cxx11_abi"] == "disabled":
+        issues.append({
+            "issue": "old_cxx11_abi",
+            "severity": "info",
+            "message": "PyTorch built with old C++11 ABI (pre-GCC 5.1)",
+            "recommendation": (
+                "Consider rebuilding extensions with _GLIBCXX_USE_CXX11_ABI=0 "
+                "if encountering symbol errors"
+            ),
+        })
+
+    return issues
+
+
+def check_pytorch_torchvision_compatibility(
+    torch_version: Optional[str],
+    torchvision_version: Optional[str]
+) -> Optional[str]:
+    """Check if torchvision version is compatible with torch version.
+
+    Args:
+        torch_version: PyTorch version (e.g., "2.1.0")
+        torchvision_version: torchvision version (e.g., "0.16.0")
+
+    Returns:
+        Error message if incompatible, None if compatible
+    """
+    if not torch_version or not torchvision_version:
+        return None
+
+    # Compatibility matrix (PyTorch -> torchvision major.minor)
+    compatibility_matrix = {
+        "2.2": "0.17",
+        "2.1": "0.16",
+        "2.0": "0.15",
+        "1.13": "0.14",
+        "1.12": "0.13",
+        "1.11": "0.12",
+        "1.10": "0.11",
+    }
+
+    try:
+        torch_major_minor = ".".join(torch_version.split(".")[:2])
+        torchvision_major_minor = ".".join(torchvision_version.split(".")[:2])
+
+        expected_torchvision = compatibility_matrix.get(torch_major_minor)
+        if expected_torchvision and torchvision_major_minor != expected_torchvision:
+            return (
+                f"PyTorch {torch_major_minor} expects torchvision {expected_torchvision}.x, "
+                f"but found {torchvision_version}"
+            )
+    except (ValueError, IndexError):
+        pass
+
+    return None
+
+
+def detect_pytorch_distributed_backend(package: PackageBinaryInfo) -> List[str]:
+    """Detect available distributed training backends in PyTorch.
+
+    Args:
+        package: PackageBinaryInfo for torch package
+
+    Returns:
+        List of available backends: ["nccl", "gloo", "mpi"]
+    """
+    backends = []
+
+    for so in package.shared_objects:
+        if not so.path:
+            continue
+
+        path_lower = so.path.lower()
+        if "nccl" in path_lower:
+            backends.append("nccl")
+        elif "gloo" in path_lower:
+            backends.append("gloo")
+        elif "mpi" in path_lower:
+            backends.append("mpi")
+
+    return list(set(backends))  # Remove duplicates

pybinaryguard/frameworks/tensorflow.py

@@ -0,0 +1,266 @@
+"""TensorFlow framework deep inspection.
+
+Validates TensorFlow CUDA compatibility, compute capability requirements,
+and build configuration.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional
+
+from pybinaryguard.models.package import PackageBinaryInfo
+from pybinaryguard.models.system import SystemProfile
+
+
+def check_tensorflow_compute_capability(
+    package: PackageBinaryInfo,
+    profile: SystemProfile
+) -> List[Dict[str, str]]:
+    """Check TensorFlow compute capability requirements.
+
+    Validates:
+    - Minimum compute capability for TensorFlow version
+    - CUDA version compatibility
+    - cuDNN version requirements
+    - AVX instruction set availability
+
+    Args:
+        package: PackageBinaryInfo for tensorflow package
+        profile: System profile
+
+    Returns:
+        List of compatibility issues found
+    """
+    issues: List[Dict[str, str]] = []
+
+    if not package.name.lower().startswith("tensorflow"):
+        return issues
+
+    tf_version = package.version
+    if not tf_version:
+        return issues
+
+    # Check compute capability requirements
+    if profile.cuda_compute_capability:
+        min_compute = get_tensorflow_min_compute_capability(tf_version)
+
+        if min_compute:
+            try:
+                gpu_compute = float(profile.cuda_compute_capability)
+                if gpu_compute < min_compute:
+                    issues.append({
+                        "issue": "tensorflow_compute_capability_too_low",
+                        "severity": "critical",
+                        "message": (
+                            f"TensorFlow {tf_version} requires compute capability >= {min_compute}, "
+                            f"but GPU has {profile.cuda_compute_capability}"
+                        ),
+                        "recommendation": f"Upgrade GPU or use TensorFlow version supporting compute {gpu_compute}",
+                    })
+            except ValueError:
+                pass
+
+    # Check CUDA version for GPU builds
+    if profile.cuda_runtime_version and not is_tensorflow_cpu_only(package):
+        cuda_compat = check_tensorflow_cuda_compatibility(tf_version, profile.cuda_runtime_version)
+        if cuda_compat:
+            issues.append({
+                "issue": "tensorflow_cuda_mismatch",
+                "severity": "critical",
+                "message": cuda_compat,
+                "recommendation": "Install TensorFlow version compatible with your CUDA version",
+            })
+
+    # Check AVX instruction set (TensorFlow 1.6+ requires AVX)
+    if not profile.cpu_flags or "avx" not in profile.cpu_flags.lower():
+        major_version = int(tf_version.split(".")[0])
+        if major_version >= 1:
+            issues.append({
+                "issue": "tensorflow_missing_avx",
+                "severity": "critical",
+                "message": "TensorFlow requires AVX instruction set, but CPU doesn't support it",
+                "recommendation": "Build TensorFlow from source without AVX or upgrade CPU",
+            })
+
+    return issues
+
+
+def get_tensorflow_min_compute_capability(tf_version: str) -> Optional[float]:
+    """Get minimum compute capability required for TensorFlow version.
+
+    Args:
+        tf_version: TensorFlow version (e.g., "2.15.0")
+
+    Returns:
+        Minimum compute capability as float, or None if unknown
+    """
+    try:
+        major = int(tf_version.split(".")[0])
+        minor = int(tf_version.split(".")[1])
+
+        # TensorFlow 2.11+ requires compute capability >= 3.5
+        if major >= 2 and minor >= 11:
+            return 3.5
+
+        # TensorFlow 2.x requires compute capability >= 3.0
+        if major >= 2:
+            return 3.0
+
+        # TensorFlow 1.x requires compute capability >= 3.0
+        return 3.0
+    except (ValueError, IndexError):
+        return None
+
+
+def check_tensorflow_cuda_compatibility(
+    tf_version: str,
+    cuda_version: str
+) -> Optional[str]:
+    """Check TensorFlow and CUDA version compatibility.
+
+    Args:
+        tf_version: TensorFlow version (e.g., "2.15.0")
+        cuda_version: CUDA version (e.g., "12.2")
+
+    Returns:
+        Error message if incompatible, None if compatible
+    """
+    # Compatibility matrix (TensorFlow -> CUDA versions)
+    compatibility_matrix = {
+        "2.15": ["12.2"],
+        "2.14": ["11.8"],
+        "2.13": ["11.8"],
+        "2.12": ["11.8"],
+        "2.11": ["11.2"],
+        "2.10": ["11.2"],
+        "2.9": ["11.2"],
+        "2.8": ["11.2"],
+        "2.7": ["11.2"],
+        "2.6": ["11.2"],
+        "2.5": ["11.2"],
+        "2.4": ["11.0"],
+        "2.3": ["10.1"],
+        "2.2": ["10.1"],
+        "2.1": ["10.0"],
+        "2.0": ["10.0"],
+    }
+
+    try:
+        tf_major_minor = ".".join(tf_version.split(".")[:2])
+        cuda_major_minor = ".".join(cuda_version.split(".")[:2])
+
+        supported_cuda = compatibility_matrix.get(tf_major_minor, [])
+
+        if supported_cuda and cuda_major_minor not in supported_cuda:
+            return (
+                f"TensorFlow {tf_major_minor} requires CUDA {', '.join(supported_cuda)}, "
+                f"but system has CUDA {cuda_version}"
+            )
+    except (ValueError, IndexError):
+        pass
+
+    return None
+
+
+def is_tensorflow_cpu_only(package: PackageBinaryInfo) -> bool:
+    """Detect if TensorFlow is CPU-only build.
+
+    Args:
+        package: PackageBinaryInfo for tensorflow package
+
+    Returns:
+        True if CPU-only build
+    """
+    # Check package name
+    if "cpu" in package.name.lower():
+        return True
+
+    # Check for CUDA-related shared objects
+    for so in package.shared_objects:
+        if so.path and "cuda" in so.path.lower():
+            return False
+
+    return True
+
+
+def detect_tensorflow_gpu_support(package: PackageBinaryInfo) -> Dict[str, bool]:
+    """Detect TensorFlow GPU support features.
+
+    Args:
+        package: PackageBinaryInfo for tensorflow package
+
+    Returns:
+        Dictionary with GPU support flags
+    """
+    support = {
+        "cuda": False,
+        "tensorrt": False,
+        "rocm": False,
+        "xla": False,
+    }
+
+    for so in package.shared_objects:
+        if not so.path:
+            continue
+
+        path_lower = so.path.lower()
+
+        if "cuda" in path_lower:
+            support["cuda"] = True
+        if "tensorrt" in path_lower:
+            support["tensorrt"] = True
+        if "rocm" in path_lower:
+            support["rocm"] = True
+        if "xla" in path_lower:
+            support["xla"] = True
+
+    return support
+
+
+def check_tensorflow_lite_compatibility(
+    tflite_model_schema: int,
+    tflite_runtime_version: Optional[str]
+) -> Optional[str]:
+    """Check TFLite model schema compatibility with runtime.
+
+    Args:
+        tflite_model_schema: TFLite model schema version
+        tflite_runtime_version: TFLite runtime version
+
+    Returns:
+        Error message if incompatible, None if compatible
+    """
+    if not tflite_runtime_version:
+        return None
+
+    # TFLite schema version by TensorFlow version
+    schema_by_version = {
+        "2.15": 3,
+        "2.14": 3,
+        "2.13": 3,
+        "2.12": 3,
+        "2.11": 3,
+        "2.10": 3,
+        "2.9": 3,
+        "2.8": 3,
+        "2.7": 3,
+        "2.6": 3,
+        "2.5": 3,
+        "2.4": 3,
+        "2.3": 3,
+    }
+
+    try:
+        tflite_major_minor = ".".join(tflite_runtime_version.split(".")[:2])
+        max_schema = schema_by_version.get(tflite_major_minor, 3)
+
+        if tflite_model_schema > max_schema:
+            return (
+                f"TFLite model schema version {tflite_model_schema} is newer than "
+                f"runtime version {tflite_runtime_version} (max schema: {max_schema})"
+            )
+    except (ValueError, IndexError):
+        pass
+
+    return None