simfix 0.1.2__tar.gz → 0.1.4__tar.gz

{simfix-0.1.2/simfix.egg-info → simfix-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simfix
-Version: 0.1.2
+Version: 0.1.4
 Summary: A dependency checker and installation assistant for simulator repositories.
 Author-email: Habib ur Rehmaan <h.rehmaan96@gmail.com>
 License-Expression: MIT

{simfix-0.1.2 → simfix-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simfix"
-version = "0.1.2"
+version = "0.1.4"
 description = "A dependency checker and installation assistant for simulator repositories."
 readme = "README.md"
 requires-python = ">=3.10"

{simfix-0.1.2 → simfix-0.1.4}/simfix/__init__.py

@@ -1,3 +1,3 @@
 """SimFix package."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{simfix-0.1.2 → simfix-0.1.4}/simfix/cli.py

@@ -15,8 +15,11 @@ from simfix.planner import create_install_plan
 from simfix.pypi import check_pypi_packages
 from simfix.repo import clone_repo, is_git_url
 from simfix.report import generate_markdown_report, write_markdown_report
+from simfix.system_capabilities import detect_system_capabilities
 from simfix.system import get_system_info
 from simfix.recommendations import generate_recommendations
+from simfix.cuda import detect_cuda_version_info
+from simfix.ros_environment import detect_ros_environment_info
 
 console = Console()
 
@@ -120,6 +123,9 @@ def recommendations(repo: str) -> None:
     repo_recommendations = generate_recommendations(
         dependencies=analysis.all_python_dependencies,
         detected_ecosystems=analysis.detected_ecosystems,
+        system_capabilities=detect_system_capabilities(),
+        cuda_version_info=detect_cuda_version_info(repo_path),
+        ros_environment_info=detect_ros_environment_info(repo_path),
     )
 
     console.print("[bold]SimFix Recommendations[/bold]")
@@ -405,6 +411,9 @@ def doctor(
     repo_recommendations = generate_recommendations(
         dependencies=analysis.all_python_dependencies,
         detected_ecosystems=analysis.detected_ecosystems,
+        system_capabilities=detect_system_capabilities(),
+        cuda_version_info=detect_cuda_version_info(repo_path),
+        ros_environment_info=detect_ros_environment_info(repo_path),
     )
 
     if repo_recommendations:

simfix-0.1.4/simfix/cuda.py

@@ -0,0 +1,133 @@
+"""CUDA version detection helpers for SimFix recommendations."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class CudaVersionInfo:
+    """Detected CUDA version information."""
+
+    repo_cuda_version: tuple[int, int] | None
+    system_cuda_version: tuple[int, int] | None
+    repo_cuda_source: str | None
+
+
+def detect_cuda_version_info(repo_path: Path) -> CudaVersionInfo:
+    """Detect repository CUDA requirement and system CUDA capability."""
+    repo_cuda_version, repo_cuda_source = detect_repo_cuda_version(repo_path)
+    system_cuda_version = detect_system_cuda_version()
+
+    return CudaVersionInfo(
+        repo_cuda_version=repo_cuda_version,
+        system_cuda_version=system_cuda_version,
+        repo_cuda_source=repo_cuda_source,
+    )
+
+
+def detect_repo_cuda_version(
+    repo_path: Path,
+) -> tuple[tuple[int, int] | None, str | None]:
+    """Detect CUDA version requested by repository files.
+
+    This is intentionally generic. It checks common simulator/deep-learning
+    signals such as Docker base images and CUDA-specific dependency names.
+    """
+    dockerfile = repo_path / "Dockerfile"
+    if dockerfile.exists():
+        version = _detect_cuda_version_from_text(dockerfile.read_text(encoding="utf-8"))
+        if version is not None:
+            return version, "Dockerfile"
+
+    dependency_files = [
+        repo_path / "requirements.txt",
+        repo_path / "pyproject.toml",
+        repo_path / "setup.py",
+        repo_path / "environment.yml",
+        repo_path / "environment.yaml",
+    ]
+
+    for dependency_file in dependency_files:
+        if dependency_file.exists():
+            version = _detect_cuda_version_from_text(
+                dependency_file.read_text(encoding="utf-8")
+            )
+            if version is not None:
+                return version, dependency_file.name
+
+    return None, None
+
+
+def detect_system_cuda_version() -> tuple[int, int] | None:
+    """Detect CUDA version supported by the NVIDIA driver using nvidia-smi."""
+    try:
+        result = subprocess.run(
+            ["nvidia-smi"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+    return _parse_nvidia_smi_cuda_version(result.stdout + result.stderr)
+
+
+def is_cuda_version_mismatch(
+    repo_cuda_version: tuple[int, int] | None,
+    system_cuda_version: tuple[int, int] | None,
+) -> bool:
+    """Return True if the repo appears to require newer CUDA than the system."""
+    if repo_cuda_version is None or system_cuda_version is None:
+        return False
+
+    return repo_cuda_version > system_cuda_version
+
+
+def _detect_cuda_version_from_text(text: str) -> tuple[int, int] | None:
+    """Detect CUDA version from generic text."""
+    normalized = text.lower()
+
+    detected_versions: list[tuple[int, int]] = []
+
+    explicit_patterns = [
+        r"nvidia/cuda:(\d+)\.(\d+)",
+        r"cuda[-_]?(\d+)[\._-](\d+)",
+    ]
+
+    for pattern in explicit_patterns:
+        for match in re.finditer(pattern, normalized):
+            detected_versions.append((int(match.group(1)), int(match.group(2))))
+
+    for match in re.finditer(r"cuda[-_]?(\d+)x", normalized):
+        detected_versions.append((int(match.group(1)), 0))
+
+    for match in re.finditer(r"cu(\d{2,3})", normalized):
+        detected_versions.append(_parse_compact_cuda_version(match.group(1)))
+
+    if not detected_versions:
+        return None
+
+    return max(detected_versions)
+
+
+def _parse_nvidia_smi_cuda_version(text: str) -> tuple[int, int] | None:
+    """Parse CUDA version from nvidia-smi output."""
+    match = re.search(r"cuda version:\s*(\d+)\.(\d+)", text.lower())
+    if match is None:
+        return None
+
+    return int(match.group(1)), int(match.group(2))
+
+
+def _parse_compact_cuda_version(version: str) -> tuple[int, int]:
+    """Parse compact CUDA version strings such as cu118 or cu121."""
+    if len(version) == 2:
+        return int(version[0]), int(version[1])
+
+    return int(version[:-1]), int(version[-1])

simfix-0.1.4/simfix/recommendation_types.py

@@ -0,0 +1,16 @@
+"""Shared recommendation types used by SimFix."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Recommendation:
+    """A safe recommendation for system or vendor dependency guidance."""
+
+    category: str
+    title: str
+    status: str
+    reason: str
+    suggestion: str

simfix-0.1.4/simfix/recommendations.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+# from dataclasses import dataclass
+from simfix.system_capabilities import SystemCapabilities
+from simfix.cuda import CudaVersionInfo, is_cuda_version_mismatch
+from simfix.ros_environment import RosEnvironmentInfo
+from simfix.vendor_dependencies import detect_vendor_dependency_recommendations
+from simfix.recommendation_types import Recommendation
+import sys
+
+
+def generate_recommendations(
+    dependencies: list[str],
+    detected_ecosystems: list[str],
+    python_version: tuple[int, int] | None = None,
+    system_capabilities: SystemCapabilities | None = None,
+    cuda_version_info: CudaVersionInfo | None = None,
+    ros_environment_info: RosEnvironmentInfo | None = None,
+) -> list[Recommendation]:
+    """Generate safe system and vendor dependency recommendations.
+
+    This function does not install drivers, ROS, CUDA, or vendor tools.
+    It only detects likely requirements and returns guidance.
+    """
+    recommendations: list[Recommendation] = []
+
+    normalized_dependencies = [dependency.lower() for dependency in dependencies]
+    normalized_ecosystems = [ecosystem.lower() for ecosystem in detected_ecosystems]
+
+    if python_version is None:
+        python_version = sys.version_info[:2]
+
+    has_isaacgym = any(
+        "isaacgym" in dependency for dependency in normalized_dependencies
+    )
+    has_isaacsim = any(
+        "isaacsim" in dependency or "omni.isaac" in dependency
+        for dependency in normalized_dependencies
+    )
+    has_cuda_dependency = any(
+        _has_cuda_keyword(dependency) for dependency in normalized_dependencies
+    )
+    has_ros = "ros" in normalized_ecosystems
+
+    has_old_pinned_dependency = any(
+        _has_old_pinned_dependency(dependency) for dependency in normalized_dependencies
+    )
+
+    recommendations.extend(
+        detect_vendor_dependency_recommendations(normalized_dependencies)
+    )
+
+    if has_isaacgym:
+        recommendations.append(
+            Recommendation(
+                category="Vendor-managed dependency",
+                title="NVIDIA Isaac Gym required",
+                status="Manual installation required",
+                reason=(
+                    "The dependency 'isaacgym' was detected, but it is not "
+                    "available as a normal PyPI package."
+                ),
+                suggestion=(
+                    "Install NVIDIA Isaac Gym manually in a compatible Linux "
+                    "environment with NVIDIA GPU support. If the local machine "
+                    "is not suitable, use an HPC GPU node or cloud GPU instance."
+                ),
+            )
+        )
+
+    if has_isaacsim:
+        recommendations.append(
+            Recommendation(
+                category="Vendor-managed dependency",
+                title="NVIDIA Isaac Sim required",
+                status="Manual installation required",
+                reason=(
+                    "Isaac Sim or omni.isaac dependencies were detected. "
+                    "These are NVIDIA-managed dependencies."
+                ),
+                suggestion=(
+                    "Install Isaac Sim using NVIDIA's official installation "
+                    "method. Use a supported system with compatible NVIDIA GPU "
+                    "drivers."
+                ),
+            )
+        )
+
+    if has_isaacgym or has_isaacsim or has_cuda_dependency:
+        recommendations.append(
+            Recommendation(
+                category="GPU/CUDA",
+                title="CUDA-compatible environment recommended",
+                status="Check required",
+                reason=(
+                    "GPU/CUDA-related dependencies were detected in the " "repository."
+                ),
+                suggestion=(
+                    "Use a compatible Linux/NVIDIA GPU environment. If the "
+                    "local GPU is not CUDA-compatible, consider a Docker setup "
+                    "on a compatible machine, an HPC GPU node, a cloud GPU "
+                    "instance, or CPU-only mode if the simulator supports it."
+                ),
+            )
+        )
+
+    if ros_environment_info is not None:
+        if ros_environment_info.project_type in {"ROS 1 / catkin", "ROS 2 / ament"}:
+            recommendations.append(
+                Recommendation(
+                    category="ROS",
+                    title=f"{ros_environment_info.project_type} environment detected",
+                    status="Environment recommendation available",
+                    reason=(
+                        f"{ros_environment_info.project_type} signals were detected "
+                        f"from {ros_environment_info.source}."
+                    ),
+                    suggestion=(
+                        f"Use ROS {ros_environment_info.recommended_distribution} "
+                        f"with {ros_environment_info.recommended_ubuntu}, or use the "
+                        f"Docker image {ros_environment_info.recommended_docker_image}."
+                    ),
+                )
+            )
+        else:
+            recommendations.append(
+                Recommendation(
+                    category="ROS",
+                    title="ROS project detected",
+                    status="Manual environment check recommended",
+                    reason=(
+                        f"ROS package files were detected from "
+                        f"{ros_environment_info.source}, but the ROS build style "
+                        "could not be confidently classified."
+                    ),
+                    suggestion=(
+                        "Check the package.xml and build files to determine whether "
+                        "the project requires ROS 1/catkin or ROS 2/ament. Use a "
+                        "matching ROS Docker image or native ROS installation."
+                    ),
+                )
+            )
+    elif has_ros:
+        recommendations.append(
+            Recommendation(
+                category="ROS",
+                title="ROS environment required",
+                status="Manual installation required",
+                reason="ROS package files were detected in the repository.",
+                suggestion=(
+                    "Use a matching ROS Docker image or install the correct ROS "
+                    "distribution manually."
+                ),
+            )
+        )
+
+    if has_old_pinned_dependency and python_version >= (3, 13):
+        recommendations.append(
+            Recommendation(
+                category="Python environment",
+                title="Older pinned dependencies detected",
+                status="Python version compatibility check recommended",
+                reason=(
+                    "This repository contains older pinned dependencies that may "
+                    f"not install cleanly on Python {python_version[0]}.{python_version[1]}."
+                ),
+                suggestion=(
+                    "Use Python 3.10 or 3.11 in a virtual environment for better "
+                    "compatibility before installing the project dependencies."
+                ),
+            )
+        )
+
+    if has_cuda_dependency and system_capabilities is not None:
+        if (
+            system_capabilities.has_docker
+            and not system_capabilities.has_nvidia_container_runtime
+        ):
+            recommendations.append(
+                Recommendation(
+                    category="GPU containers",
+                    title="NVIDIA Docker support not detected",
+                    status="Configuration check recommended",
+                    reason=(
+                        "This repository appears to need GPU/CUDA support, and Docker "
+                        "is available, but NVIDIA container runtime support was not detected."
+                    ),
+                    suggestion=(
+                        "GPU containers may fail with '--gpus all'. Use a compatible "
+                        "Linux/NVIDIA environment with NVIDIA Container Toolkit configured, "
+                        "or use an HPC/cloud GPU environment."
+                    ),
+                )
+            )
+
+    if cuda_version_info is not None:
+        repo_cuda_version = cuda_version_info.repo_cuda_version
+        system_cuda_version = cuda_version_info.system_cuda_version
+
+        if repo_cuda_version is not None and system_cuda_version is None:
+            recommendations.append(
+                Recommendation(
+                    category="CUDA compatibility",
+                    title="System CUDA support not detected",
+                    status="Compatibility unknown",
+                    reason=(
+                        "The repository appears to require CUDA "
+                        f"{repo_cuda_version[0]}.{repo_cuda_version[1]} from "
+                        f"{cuda_version_info.repo_cuda_source}, but system CUDA support "
+                        "could not be detected with nvidia-smi."
+                    ),
+                    suggestion=(
+                        "Use a compatible Linux/NVIDIA GPU environment, a configured "
+                        "GPU Docker setup, an HPC GPU node, or a cloud GPU instance. "
+                        "If the simulator supports CPU-only mode, that may also be used "
+                        "for limited testing."
+                    ),
+                )
+            )
+
+        if is_cuda_version_mismatch(repo_cuda_version, system_cuda_version):
+            recommendations.append(
+                Recommendation(
+                    category="CUDA compatibility",
+                    title="CUDA version mismatch detected",
+                    status="Version mismatch",
+                    reason=(
+                        "The repository appears to require CUDA "
+                        f"{repo_cuda_version[0]}.{repo_cuda_version[1]} from "
+                        f"{cuda_version_info.repo_cuda_source}, but the NVIDIA driver "
+                        f"reports CUDA {system_cuda_version[0]}.{system_cuda_version[1]} support."
+                    ),
+                    suggestion=(
+                        "Use a CUDA version compatible with the installed NVIDIA driver, "
+                        "update the NVIDIA driver if appropriate, or run the simulator on "
+                        "an HPC/cloud GPU environment with compatible CUDA support."
+                    ),
+                )
+            )
+    return recommendations
+
+
+def _has_cuda_keyword(dependency: str) -> bool:
+    """Return True if a dependency suggests GPU/CUDA requirements."""
+    cuda_keywords = [
+        "cuda",
+        "cudnn",
+        "cupy",
+        "pytorch3d",
+        "onnxruntime-gpu",
+        "tensorflow-gpu",
+        "jax[cuda",
+        "numba.cuda",
+    ]
+
+    return any(keyword in dependency for keyword in cuda_keywords)
+
+
+def _has_old_pinned_dependency(dependency: str) -> bool:
+    """Return True when a dependency is pinned to an old version.
+
+    This is a conservative heuristic used for Python-version compatibility
+    recommendations. It does not modify dependencies.
+    """
+    normalized = dependency.lower().strip()
+
+    if "==" not in normalized:
+        return False
+
+    package_name, version = normalized.split("==", maxsplit=1)
+    package_name = package_name.strip()
+    version = version.strip()
+
+    old_version_thresholds = {
+        "numpy": (1, 24),
+        "scipy": (1, 10),
+        "networkx": (3, 0),
+        "pandas": (2, 0),
+        "matplotlib": (3, 7),
+        "gym": (1, 0),
+        "urdfpy": (0, 1),
+    }
+
+    if package_name not in old_version_thresholds:
+        return False
+
+    parsed_version = _parse_version_prefix(version)
+    if parsed_version is None:
+        return False
+
+    return parsed_version < old_version_thresholds[package_name]
+
+
+def _parse_version_prefix(version: str) -> tuple[int, ...] | None:
+    """Parse the numeric prefix of a dependency version.
+
+    Examples:
+        1.23.0 -> (1, 23, 0)
+        2.2 -> (2, 2)
+        0.0.22 -> (0, 0, 22)
+    """
+    parts: list[int] = []
+
+    for part in version.split("."):
+        number = ""
+        for character in part:
+            if character.isdigit():
+                number += character
+            else:
+                break
+
+        if not number:
+            break
+
+        parts.append(int(number))
+
+    if not parts:
+        return None
+
+    return tuple(parts)

simfix-0.1.4/simfix/ros_environment.py

@@ -0,0 +1,106 @@
+"""ROS environment detection helpers for SimFix recommendations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class RosEnvironmentInfo:
+    """Detected ROS environment information."""
+
+    project_type: str | None
+    recommended_distribution: str | None
+    recommended_ubuntu: str | None
+    recommended_docker_image: str | None
+    source: str | None
+
+
+def detect_ros_environment_info(repo_path: Path) -> RosEnvironmentInfo | None:
+    """Detect ROS project style and recommend a common compatible environment.
+
+    This detection is generic and based on build-system signals, not repository
+    names. It does not install ROS or modify files.
+    """
+    package_xml = repo_path / "package.xml"
+    cmake_lists = repo_path / "CMakeLists.txt"
+
+    package_text = _read_file(package_xml)
+    cmake_text = _read_file(cmake_lists)
+    combined_text = f"{package_text}\n{cmake_text}".lower()
+
+    if not combined_text.strip():
+        return None
+
+    if _looks_like_ros2(combined_text):
+        return RosEnvironmentInfo(
+            project_type="ROS 2 / ament",
+            recommended_distribution="Humble",
+            recommended_ubuntu="Ubuntu 22.04",
+            recommended_docker_image="osrf/ros:humble-desktop",
+            source=_source_label(package_xml, cmake_lists),
+        )
+
+    if _looks_like_ros1(combined_text):
+        return RosEnvironmentInfo(
+            project_type="ROS 1 / catkin",
+            recommended_distribution="Noetic",
+            recommended_ubuntu="Ubuntu 20.04",
+            recommended_docker_image="osrf/ros:noetic-desktop-full",
+            source=_source_label(package_xml, cmake_lists),
+        )
+
+    if package_xml.exists():
+        return RosEnvironmentInfo(
+            project_type="ROS project",
+            recommended_distribution=None,
+            recommended_ubuntu=None,
+            recommended_docker_image=None,
+            source="package.xml",
+        )
+
+    return None
+
+
+def _looks_like_ros2(text: str) -> bool:
+    ros2_markers = [
+        "ament_cmake",
+        "ament_python",
+        "ament_package",
+        "find_package(ament_cmake",
+        "<build_type>ament_cmake</build_type>",
+        "<build_type>ament_python</build_type>",
+        "rclpy",
+        "rclcpp",
+    ]
+    return any(marker in text for marker in ros2_markers)
+
+
+def _looks_like_ros1(text: str) -> bool:
+    ros1_markers = [
+        "catkin_package",
+        "find_package(catkin",
+        "<buildtool_depend>catkin</buildtool_depend>",
+        "<build_depend>catkin</build_depend>",
+        "<depend>roscpp</depend>",
+        "<depend>rospy</depend>",
+        "roslaunch",
+    ]
+    return any(marker in text for marker in ros1_markers)
+
+
+def _read_file(path: Path) -> str:
+    if not path.exists():
+        return ""
+
+    return path.read_text(encoding="utf-8")
+
+
+def _source_label(*paths: Path) -> str:
+    existing_paths = [path.name for path in paths if path.exists()]
+
+    if not existing_paths:
+        return "ROS project files"
+
+    return ", ".join(existing_paths)

simfix-0.1.4/simfix/system_capabilities.py

@@ -0,0 +1,46 @@
+"""System capability detection used by SimFix recommendations."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SystemCapabilities:
+    """Detected system capabilities relevant to simulator installation."""
+
+    has_docker: bool
+    has_nvidia_smi: bool
+    has_nvidia_container_runtime: bool
+
+
+def detect_system_capabilities() -> SystemCapabilities:
+    """Detect system capabilities without modifying the system."""
+    return SystemCapabilities(
+        has_docker=shutil.which("docker") is not None,
+        has_nvidia_smi=shutil.which("nvidia-smi") is not None,
+        has_nvidia_container_runtime=_has_nvidia_container_runtime(),
+    )
+
+
+def _has_nvidia_container_runtime() -> bool:
+    """Return True if Docker appears to support NVIDIA GPU containers."""
+    if shutil.which("docker") is None:
+        return False
+
+    try:
+        result = subprocess.run(
+            ["docker", "info", "--format", "{{json .Runtimes}}"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+    output = result.stdout.lower() + result.stderr.lower()
+
+    return "nvidia" in output