simfix 0.1.3__tar.gz → 0.1.5__tar.gz

{simfix-0.1.3/simfix.egg-info → simfix-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simfix
-Version: 0.1.3
+Version: 0.1.5
 Summary: A dependency checker and installation assistant for simulator repositories.
 Author-email: Habib ur Rehmaan <h.rehmaan96@gmail.com>
 License-Expression: MIT
@@ -26,6 +26,7 @@ Requires-Dist: requests
 Requires-Dist: packaging
 Requires-Dist: pyyaml
 Requires-Dist: uv
+Requires-Dist: tomli; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"

{simfix-0.1.3 → simfix-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simfix"
-version = "0.1.3"
+version = "0.1.5"
 description = "A dependency checker and installation assistant for simulator repositories."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -39,6 +39,7 @@ dependencies = [
     "packaging",
     "pyyaml",
     "uv",
+    "tomli; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]

{simfix-0.1.3 → simfix-0.1.5}/simfix/__init__.py

@@ -1,3 +1,3 @@
 """SimFix package."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.5"

{simfix-0.1.3 → simfix-0.1.5}/simfix/analyzer.py

@@ -10,6 +10,7 @@ from simfix.pypi import normalize_requirement_name
 from simfix.pyproject import PyProjectInfo, parse_pyproject
 from simfix.python_requirements import parse_requirements_file
 from simfix.ros_package import ROSPackageInfo, parse_ros_package
+from simfix.dependency_discovery import discover_dependency_files
 from simfix.setup_py import parse_setup_py_dependencies
 
 
@@ -89,33 +90,60 @@ def analyze_repo(repo_path: str | Path) -> RepoAnalysis:
     if not path.is_dir():
         raise NotADirectoryError(f"Repository path is not a directory: {path}")
 
-    requirements_path = path / "requirements.txt"
-    environment_path = path / "environment.yml"
-    if not environment_path.exists():
-        environment_path = path / "environment.yaml"
+    discovered_files = discover_dependency_files(path)
+
+    requirements_path = (
+        discovered_files.requirements_txt[0]
+        if discovered_files.requirements_txt
+        else path / "requirements.txt"
+    )
+    environment_path = (
+        discovered_files.environment_files[0]
+        if discovered_files.environment_files
+        else path / "environment.yml"
+    )
+    dockerfile_path = (
+        discovered_files.dockerfiles[0]
+        if discovered_files.dockerfiles
+        else path / "Dockerfile"
+    )
+    package_xml_path = (
+        discovered_files.package_xml_files[0]
+        if discovered_files.package_xml_files
+        else path / "package.xml"
+    )
+    cmake_path = (
+        discovered_files.cmake_lists_files[0]
+        if discovered_files.cmake_lists_files
+        else path / "CMakeLists.txt"
+    )
+    pyproject_path = (
+        discovered_files.pyproject_toml[0]
+        if discovered_files.pyproject_toml
+        else path / "pyproject.toml"
+    )
+    setup_py_path = (
+        discovered_files.setup_py_files[0]
+        if discovered_files.setup_py_files
+        else path / "setup.py"
+    )
 
-    dockerfile_path = path / "Dockerfile"
-    package_xml_path = path / "package.xml"
-    cmake_path = path / "CMakeLists.txt"
-    pyproject_path = path / "pyproject.toml"
-    setup_py_path = path / "setup.py"
     setup_py_dependencies = parse_setup_py_dependencies(setup_py_path)
 
     return RepoAnalysis(
         repo_path=path,
-        has_requirements_txt=requirements_path.exists(),
-        has_environment_yml=(path / "environment.yml").exists()
-        or (path / "environment.yaml").exists(),
+        has_requirements_txt=discovered_files.has_requirements_txt,
+        has_environment_yml=discovered_files.has_environment_file,
         python_requirements=parse_requirements_file(requirements_path),
         conda_environment=parse_conda_environment(environment_path),
-        has_dockerfile=dockerfile_path.exists(),
+        has_dockerfile=discovered_files.has_dockerfile,
         dockerfile_info=parse_dockerfile(dockerfile_path),
-        has_package_xml=package_xml_path.exists(),
+        has_package_xml=discovered_files.has_ros_package,
         ros_package_info=parse_ros_package(package_xml_path),
-        has_cmake=cmake_path.exists(),
+        has_cmake=discovered_files.has_cmake_lists,
         cmake_info=parse_cmake_file(cmake_path),
-        has_pyproject_toml=pyproject_path.exists(),
+        has_pyproject_toml=discovered_files.has_pyproject_toml,
         pyproject_info=parse_pyproject(pyproject_path),
-        has_setup_py=setup_py_path.exists(),
+        has_setup_py=discovered_files.has_setup_py,
         setup_py_dependencies=setup_py_dependencies,
     )

{simfix-0.1.3 → simfix-0.1.5}/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]")
@@ -208,6 +214,7 @@ def doctor(
     console.print(f"[bold]Detected ecosystem(s):[/bold] {ecosystems}")
 
     python_dependencies = analysis.all_python_dependencies
+    pypi_results = []
 
     if python_dependencies:
         deps_table = Table(title="Python packages")
@@ -218,6 +225,15 @@ def doctor(
 
         console.print(deps_table)
 
+    pypi_table = Table(title="PyPI check")
+    pypi_table.add_column("Package", style="cyan")
+    pypi_table.add_column("Status")
+
+    for result in pypi_results:
+        status = "found" if result.exists else "not found"
+        pypi_table.add_row(result.name, status)
+
+        console.print(pypi_table)
         pypi_results = check_pypi_packages(python_dependencies)
 
         pypi_table = Table(title="PyPI check")
@@ -405,6 +421,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.5/simfix/commands.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from simfix.analyzer import RepoAnalysis
+
+
+@dataclass(frozen=True)
+class CommandPlan:
+    """Suggested shell commands for installing a repository."""
+
+    title: str
+    commands: list[str]
+
+
+def create_command_plan(analysis: RepoAnalysis) -> CommandPlan:
+    """Create suggested installation commands from repository analysis."""
+    ecosystems = analysis.detected_ecosystems
+    repo_name = analysis.repo_path.name.replace("_", "-").lower()
+    commands: list[str] = []
+
+    if "docker" in ecosystems:
+        commands.append(f"docker build -t {repo_name} .")
+
+        run_helper = analysis.repo_path / "run_simfix_docker.sh"
+        if run_helper.exists():
+            commands.append("./run_simfix_docker.sh")
+        else:
+            commands.append(f"docker run --rm -it {repo_name}")
+
+    if "ros" in ecosystems:
+        build_system = analysis.ros_package_info.build_system.lower()
+
+        commands.extend(
+            [
+                "rosdep update",
+                "rosdep install --from-paths . --ignore-src -r -y",
+            ]
+        )
+
+        if build_system == "catkin":
+            commands.extend(
+                [
+                    "catkin build",
+                    "source devel/setup.bash",
+                ]
+            )
+        elif build_system in {"ament", "ament_cmake", "ament_python"}:
+            commands.extend(
+                [
+                    "colcon build",
+                    "source install/setup.bash",
+                ]
+            )
+        else:
+            commands.extend(
+                [
+                    "catkin build  # or: colcon build, depending on the ROS package type",
+                    "source devel/setup.bash  # or: source install/setup.bash",
+                ]
+            )
+
+    if "conda" in ecosystems:
+        env_name = "simfix-env"
+        if analysis.conda_environment is not None and analysis.conda_environment.name:
+            env_name = analysis.conda_environment.name
+
+        commands.extend(
+            [
+                "conda env create -f environment.yml",
+                f"conda activate {env_name}",
+            ]
+        )
+
+    if "python" in ecosystems:
+        commands.extend(
+            [
+                "python -m venv .venv",
+                "source .venv/bin/activate",
+                "python -m pip install --upgrade pip",
+            ]
+        )
+
+        if analysis.has_requirements_txt:
+            commands.append("python -m pip install -r requirements.txt")
+
+        if analysis.has_pyproject_toml or analysis.has_setup_py:
+            commands.extend(
+                [
+                    "python -m pip install -e .",
+                    "python -m pip install -e . --no-deps  # use only if vendor/manual dependencies block normal install",
+                ]
+            )
+
+    if "cmake/c++" in ecosystems and "ros" not in ecosystems:
+        commands.extend(
+            [
+                "cmake -S . -B build",
+                "cmake --build build -j",
+            ]
+        )
+
+    if not commands:
+        commands.extend(
+            [
+                "# No common dependency file was detected.",
+                "# Read the README installation section manually.",
+                "# Check for install scripts such as install.sh or setup.sh.",
+            ]
+        )
+
+    return CommandPlan(
+        title="Suggested installation commands",
+        commands=_deduplicate_commands(commands),
+    )
+
+
+def _deduplicate_commands(commands: list[str]) -> list[str]:
+    """Return commands without duplicates while preserving order."""
+    seen: set[str] = set()
+    unique_commands: list[str] = []
+
+    for command in commands:
+        if command in seen:
+            continue
+
+        seen.add(command)
+        unique_commands.append(command)
+
+    return unique_commands

simfix-0.1.5/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.5/simfix/dependency_discovery.py

@@ -0,0 +1,139 @@
+"""Generic dependency-file discovery for simulator repositories."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+IGNORED_DIRECTORY_NAMES = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "venv",
+    "env",
+    "__pycache__",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pytest_cache",
+    "build",
+    "dist",
+    "install",
+    "log",
+    "node_modules",
+}
+
+
+DEPENDENCY_FILE_NAMES = {
+    "requirements.txt",
+    "pyproject.toml",
+    "environment.yml",
+    "environment.yaml",
+    "Dockerfile",
+    "package.xml",
+    "CMakeLists.txt",
+    "setup.py",
+}
+
+
+@dataclass(frozen=True)
+class DiscoveredDependencyFiles:
+    """Dependency files discovered in a repository."""
+
+    requirements_txt: tuple[Path, ...]
+    pyproject_toml: tuple[Path, ...]
+    environment_files: tuple[Path, ...]
+    dockerfiles: tuple[Path, ...]
+    package_xml_files: tuple[Path, ...]
+    cmake_lists_files: tuple[Path, ...]
+    setup_py_files: tuple[Path, ...]
+
+    @property
+    def has_requirements_txt(self) -> bool:
+        return bool(self.requirements_txt)
+
+    @property
+    def has_pyproject_toml(self) -> bool:
+        return bool(self.pyproject_toml)
+
+    @property
+    def has_environment_file(self) -> bool:
+        return bool(self.environment_files)
+
+    @property
+    def has_dockerfile(self) -> bool:
+        return bool(self.dockerfiles)
+
+    @property
+    def has_ros_package(self) -> bool:
+        return bool(self.package_xml_files)
+
+    @property
+    def has_cmake_lists(self) -> bool:
+        return bool(self.cmake_lists_files)
+
+    @property
+    def has_setup_py(self) -> bool:
+        return bool(self.setup_py_files)
+
+
+def discover_dependency_files(
+    repo_path: Path,
+    *,
+    max_depth: int = 4,
+) -> DiscoveredDependencyFiles:
+    """Discover dependency files in a repository up to a safe depth.
+
+    This is generic and does not assume a specific simulator layout.
+    It intentionally skips common build, cache, virtualenv, and VCS folders.
+    """
+    discovered_files = _walk_dependency_files(repo_path, max_depth=max_depth)
+
+    return DiscoveredDependencyFiles(
+        requirements_txt=_filter_by_name(discovered_files, "requirements.txt"),
+        pyproject_toml=_filter_by_name(discovered_files, "pyproject.toml"),
+        environment_files=tuple(
+            path
+            for path in discovered_files
+            if path.name in {"environment.yml", "environment.yaml"}
+        ),
+        dockerfiles=_filter_by_name(discovered_files, "Dockerfile"),
+        package_xml_files=_filter_by_name(discovered_files, "package.xml"),
+        cmake_lists_files=_filter_by_name(discovered_files, "CMakeLists.txt"),
+        setup_py_files=_filter_by_name(discovered_files, "setup.py"),
+    )
+
+
+def _walk_dependency_files(repo_path: Path, *, max_depth: int) -> tuple[Path, ...]:
+    repo_path = repo_path.resolve()
+    found: list[Path] = []
+
+    for path in repo_path.rglob("*"):
+        if not path.is_file():
+            continue
+
+        relative_path = path.relative_to(repo_path)
+
+        if _should_skip_path(relative_path):
+            continue
+
+        if _depth(relative_path) > max_depth:
+            continue
+
+        if path.name in DEPENDENCY_FILE_NAMES:
+            found.append(path)
+
+    return tuple(sorted(found))
+
+
+def _filter_by_name(paths: tuple[Path, ...], name: str) -> tuple[Path, ...]:
+    return tuple(path for path in paths if path.name == name)
+
+
+def _should_skip_path(relative_path: Path) -> bool:
+    return any(part in IGNORED_DIRECTORY_NAMES for part in relative_path.parts)
+
+
+def _depth(relative_path: Path) -> int:
+    return len(relative_path.parts) - 1