simfix 0.1.0__py3-none-any.whl

simfix/commands.py

@@ -0,0 +1,91 @@
+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()
+
+    if "docker" in ecosystems:
+        return CommandPlan(
+            title="Docker installation commands",
+            commands=[
+                f"docker build -t {repo_name} .",
+                f"docker run --rm -it {repo_name}",
+            ],
+        )
+
+    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
+
+        return CommandPlan(
+            title="Conda installation commands",
+            commands=[
+                "conda env create -f environment.yml",
+                f"conda activate {env_name}",
+            ],
+        )
+
+    if "ros" in ecosystems:
+        return CommandPlan(
+            title="ROS installation commands",
+            commands=[
+                "mkdir -p ~/simfix_ws/src",
+                "cd ~/simfix_ws/src",
+                "# Clone or copy the repository into this src folder",
+                "cd ~/simfix_ws",
+                "rosdep install --from-paths src --ignore-src -r -y",
+                "catkin build  # or: colcon build",
+                "source devel/setup.bash  # or: source install/setup.bash",
+            ],
+        )
+
+    if "python" in ecosystems:
+        commands = [
+            "python -m venv .venv",
+            "source .venv/bin/activate",
+        ]
+
+        if analysis.has_requirements_txt:
+            commands.append("python -m pip install -r requirements.txt")
+
+        if analysis.has_pyproject_toml:
+            commands.append("python -m pip install -e .")
+
+        return CommandPlan(
+            title="Python installation commands",
+            commands=commands,
+        )
+
+    if "cmake/c++" in ecosystems:
+        return CommandPlan(
+            title="CMake installation commands",
+            commands=[
+                "mkdir -p build",
+                "cd build",
+                "cmake ..",
+                "cmake --build . -j",
+            ],
+        )
+
+    return CommandPlan(
+        title="Manual installation commands",
+        commands=[
+            "# No common dependency file was detected.",
+            "# Read the README installation section manually.",
+        ],
+    )

simfix/compatibility.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from simfix.analyzer import RepoAnalysis
+from simfix.system import SystemInfo
+
+ROS_UBUNTU_HINTS = {
+    "melodic": "18.04",
+    "noetic": "20.04",
+    "humble": "22.04",
+    "jazzy": "24.04",
+}
+
+
+def _detect_ros_distro_hint(analysis: RepoAnalysis) -> str | None:
+    """Detect possible ROS distro hints from parsed dependency names."""
+    if analysis.ros_package_info is None:
+        return None
+
+    dependencies = [
+        dependency.lower() for dependency in analysis.ros_package_info.all_dependencies
+    ]
+
+    joined_dependencies = " ".join(dependencies)
+
+    for distro in ROS_UBUNTU_HINTS:
+        if distro in joined_dependencies:
+            return distro
+
+    ros_info = analysis.ros_package_info
+
+    if ros_info.build_system == "catkin":
+        return "noetic"
+
+    if ros_info.build_system == "ament":
+        return "humble"
+
+    return None
+
+
+def generate_compatibility_warnings(
+    analysis: RepoAnalysis,
+    system_info: SystemInfo,
+) -> list[str]:
+    """Generate compatibility warnings from repo analysis and system information."""
+    warnings: list[str] = []
+    ecosystems = analysis.detected_ecosystems
+
+    if "docker" in ecosystems and not system_info.docker_available:
+        warnings.append("Dockerfile detected, but Docker was not found on this system.")
+
+    if (
+        "conda" in ecosystems
+        and not system_info.conda_available
+        and not system_info.mamba_available
+    ):
+        warnings.append(
+            "Conda environment detected, but neither conda nor mamba was found."
+        )
+
+    if (
+        "python" in ecosystems
+        and not system_info.pip_available
+        and not system_info.uv_available
+    ):
+        warnings.append("Python project detected, but neither pip nor uv was found.")
+
+    if "ros" in ecosystems and system_info.os_name != "Linux":
+        warnings.append(
+            "ROS project detected, but the current system is not Linux. "
+            "Docker or a Linux machine may be needed."
+        )
+
+    ros_distro_hint = _detect_ros_distro_hint(analysis)
+
+    if (
+        ros_distro_hint is not None
+        and system_info.linux_version is not None
+        and ROS_UBUNTU_HINTS[ros_distro_hint] != system_info.linux_version
+    ):
+        warnings.append(
+            f"ROS {ros_distro_hint} project detected, which is commonly used with "
+            f"Ubuntu {ROS_UBUNTU_HINTS[ros_distro_hint]}, but this system appears "
+            f"to be Ubuntu {system_info.linux_version}."
+        )
+
+    if "cmake/c++" in ecosystems and system_info.os_name == "Darwin":
+        warnings.append(
+            "CMake/C++ project detected on macOS. Some simulator dependencies "
+            "may require Linux-specific packages."
+        )
+
+    if "unknown" in ecosystems:
+        warnings.append(
+            "No common dependency files were detected. Manual inspection is needed."
+        )
+
+    return warnings

simfix/conda_environment.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass(frozen=True)
+class CondaEnvironment:
+    """Parsed conda environment information."""
+
+    name: str | None
+    conda_dependencies: list[str]
+    pip_dependencies: list[str]
+
+
+def parse_conda_environment(path: str | Path) -> CondaEnvironment | None:
+    """Parse a conda environment.yml/environment.yaml file."""
+    environment_path = Path(path).expanduser().resolve()
+
+    if not environment_path.exists():
+        return None
+
+    data = yaml.safe_load(environment_path.read_text(encoding="utf-8"))
+
+    if not isinstance(data, dict):
+        return None
+
+    name = data.get("name")
+    raw_dependencies = data.get("dependencies", [])
+
+    conda_dependencies: list[str] = []
+    pip_dependencies: list[str] = []
+
+    if not isinstance(raw_dependencies, list):
+        return CondaEnvironment(
+            name=name if isinstance(name, str) else None,
+            conda_dependencies=[],
+            pip_dependencies=[],
+        )
+
+    for dependency in raw_dependencies:
+        if isinstance(dependency, str):
+            conda_dependencies.append(dependency)
+        elif isinstance(dependency, dict):
+            pip_entries: Any = dependency.get("pip")
+            if isinstance(pip_entries, list):
+                pip_dependencies.extend(
+                    item for item in pip_entries if isinstance(item, str)
+                )
+
+    return CondaEnvironment(
+        name=name if isinstance(name, str) else None,
+        conda_dependencies=conda_dependencies,
+        pip_dependencies=pip_dependencies,
+    )

simfix/conda_fixer.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from simfix.pypi import normalize_requirement_name
+
+
+@dataclass(frozen=True)
+class CondaFixResult:
+    """Result of fixing a conda environment file."""
+
+    file_path: Path
+    changed: bool
+    message: str
+
+
+def _dependency_name(dependency: str) -> str:
+    """Return normalized dependency name without version constraints."""
+    separators = ["==", ">=", "<=", "!=", "~=", "=", ">", "<"]
+
+    for separator in separators:
+        if separator in dependency:
+            return dependency.split(separator, maxsplit=1)[0].strip().lower()
+
+    return dependency.strip().lower()
+
+
+def _is_more_specific(new_dependency: str, old_dependency: str) -> bool:
+    """Return True if new dependency has more version information."""
+    version_symbols = ["==", ">=", "<=", "!=", "~=", "=", ">", "<"]
+
+    new_score = sum(symbol in new_dependency for symbol in version_symbols)
+    old_score = sum(symbol in old_dependency for symbol in version_symbols)
+
+    return new_score >= old_score
+
+
+def _deduplicate_dependencies(dependencies: list[str]) -> list[str]:
+    """Remove duplicate dependencies while keeping the more specific entry."""
+    normalized: dict[str, str] = {}
+
+    for dependency in dependencies:
+        name = _dependency_name(dependency)
+
+        if name not in normalized:
+            normalized[name] = dependency
+            continue
+
+        if _is_more_specific(dependency, normalized[name]):
+            normalized[name] = dependency
+
+    return list(normalized.values())
+
+
+def _deduplicate_pip_dependencies(dependencies: list[str]) -> list[str]:
+    """Remove duplicate pip dependencies while keeping the more specific entry."""
+    normalized: dict[str, str] = {}
+
+    for dependency in dependencies:
+        name = normalize_requirement_name(dependency).lower()
+
+        if name not in normalized:
+            normalized[name] = dependency
+            continue
+
+        if _is_more_specific(dependency, normalized[name]):
+            normalized[name] = dependency
+
+    return list(normalized.values())
+
+
+def fix_conda_environment_file(repo_path: str | Path) -> CondaFixResult | None:
+    """Fix environment.yml or environment.yaml in place."""
+    path = Path(repo_path).expanduser().resolve()
+
+    environment_path = path / "environment.yml"
+
+    if not environment_path.exists():
+        environment_path = path / "environment.yaml"
+
+    if not environment_path.exists():
+        return None
+
+    old_text = environment_path.read_text(encoding="utf-8")
+    data: dict[str, Any] = yaml.safe_load(old_text) or {}
+
+    dependencies = data.get("dependencies")
+
+    if not isinstance(dependencies, list):
+        return CondaFixResult(
+            file_path=environment_path,
+            changed=False,
+            message="environment.yml has no valid dependencies list.",
+        )
+
+    conda_dependencies: list[str] = []
+    pip_dependency_block: dict[str, list[str]] | None = None
+    other_entries: list[Any] = []
+
+    for dependency in dependencies:
+        if isinstance(dependency, str):
+            conda_dependencies.append(dependency)
+        elif isinstance(dependency, dict) and "pip" in dependency:
+            pip_values = dependency.get("pip", [])
+
+            if isinstance(pip_values, list):
+                pip_dependency_block = {
+                    "pip": _deduplicate_pip_dependencies(
+                        [str(value) for value in pip_values]
+                    )
+                }
+            else:
+                other_entries.append(dependency)
+        else:
+            other_entries.append(dependency)
+
+    fixed_dependencies: list[Any] = []
+    fixed_dependencies.extend(_deduplicate_dependencies(conda_dependencies))
+    fixed_dependencies.extend(other_entries)
+
+    if pip_dependency_block is not None:
+        fixed_dependencies.append(pip_dependency_block)
+
+    data["dependencies"] = fixed_dependencies
+
+    new_text = yaml.safe_dump(
+        data,
+        sort_keys=False,
+        default_flow_style=False,
+    )
+
+    changed = old_text != new_text
+
+    if changed:
+        environment_path.write_text(new_text, encoding="utf-8")
+
+    return CondaFixResult(
+        file_path=environment_path,
+        changed=changed,
+        message="environment.yml cleaned successfully.",
+    )

simfix/cuda_docker.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from simfix.system import get_system_info
+
+GPU_KEYWORDS = {
+    "cuda",
+    "cudnn",
+    "cupy",
+    "nvidia",
+    "nvcc",
+    "torch",
+    "tensorflow",
+    "numba.cuda",
+    "jax[cuda",
+    "onnxruntime-gpu",
+}
+
+
+@dataclass(frozen=True)
+class CudaDockerFixResult:
+    """Result of creating a CUDA Dockerfile."""
+
+    file_path: Path
+    changed: bool
+    message: str
+
+
+def _read_text_if_exists(path: Path) -> str:
+    """Read text from a file if it exists."""
+    if not path.exists():
+        return ""
+
+    return path.read_text(encoding="utf-8", errors="ignore")
+
+
+def _repo_has_cuda_files(repo_path: Path) -> bool:
+    """Return True if repository contains CUDA source files."""
+    cuda_suffixes = {".cu", ".cuh"}
+
+    for file_path in repo_path.rglob("*"):
+        if ".git" in file_path.parts:
+            continue
+
+        if file_path.is_file() and file_path.suffix.lower() in cuda_suffixes:
+            return True
+
+    return False
+
+
+def detect_gpu_project(repo_path: str | Path) -> bool:
+    """Detect whether a repository likely needs GPU/CUDA support."""
+    path = Path(repo_path).expanduser().resolve()
+
+    searchable_text = "\n".join(
+        [
+            _read_text_if_exists(path / "requirements.txt"),
+            _read_text_if_exists(path / "pyproject.toml"),
+            _read_text_if_exists(path / "environment.yml"),
+            _read_text_if_exists(path / "environment.yaml"),
+            _read_text_if_exists(path / "README.md"),
+            _read_text_if_exists(path / "readme.md"),
+            _read_text_if_exists(path / "CMakeLists.txt"),
+        ]
+    ).lower()
+
+    if any(keyword in searchable_text for keyword in GPU_KEYWORDS):
+        return True
+
+    return _repo_has_cuda_files(path)
+
+
+def _gpu_status_message() -> str:
+    """Return host GPU/driver status message."""
+    system_info = get_system_info()
+
+    if system_info.nvidia_gpu_available:
+        return (
+            " NVIDIA GPU detected"
+            f" with driver {system_info.nvidia_driver_version or 'unknown'}"
+            f" and CUDA {system_info.nvidia_cuda_version or 'unknown'}."
+        )
+
+    return (
+        " No NVIDIA GPU/driver was detected on this machine. "
+        "GPU containers will need a working NVIDIA driver and "
+        "NVIDIA Container Toolkit on the host."
+    )
+
+
+def _cuda_dockerfile(has_requirements: bool) -> str:
+    """Return a CUDA Dockerfile."""
+    install_requirements = ""
+
+    if has_requirements:
+        install_requirements = """
+
+COPY requirements.txt /workspace/requirements.txt
+RUN python3 -m pip install --upgrade pip && \\
+    python3 -m pip install -r /workspace/requirements.txt
+"""
+
+    return f"""FROM nvidia/cuda:12.4.1-cudnn-devel-ubuntu22.04
+
+SHELL ["/bin/bash", "-c"]
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \\
+    build-essential \\
+    cmake \\
+    git \\
+    python3 \\
+    python3-pip \\
+    python3-venv \\
+    libgl1 \\
+    libglib2.0-0 \\
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+{install_requirements}
+COPY . /workspace
+
+CMD ["/bin/bash"]
+"""
+
+
+def create_cuda_dockerfile(repo_path: str | Path) -> CudaDockerFixResult | None:
+    """Create a CUDA Dockerfile for GPU projects.
+
+    This creates Dockerfile only when GPU/CUDA clues exist and Dockerfile is missing.
+    """
+    path = Path(repo_path).expanduser().resolve()
+
+    if not detect_gpu_project(path):
+        return None
+
+    dockerfile_path = path / "Dockerfile"
+
+    if dockerfile_path.exists():
+        return CudaDockerFixResult(
+            file_path=dockerfile_path,
+            changed=False,
+            message=(
+                "Dockerfile already exists. SimFix did not overwrite it."
+                + _gpu_status_message()
+            ),
+        )
+
+    has_requirements = (path / "requirements.txt").exists()
+
+    dockerfile_path.write_text(
+        _cuda_dockerfile(has_requirements=has_requirements),
+        encoding="utf-8",
+    )
+
+    return CudaDockerFixResult(
+        file_path=dockerfile_path,
+        changed=True,
+        message="Created CUDA Dockerfile for GPU project." + _gpu_status_message(),
+    )

simfix/docker_runner.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from simfix.cuda_docker import detect_gpu_project
+
+
+@dataclass(frozen=True)
+class DockerRunFixResult:
+    """Result of creating a Docker run helper script."""
+
+    file_path: Path
+    changed: bool
+    message: str
+
+
+def _docker_run_script(image_name: str, use_gpu: bool) -> str:
+    """Return a Docker build/run helper script."""
+    gpu_flag = " --gpus all" if use_gpu else ""
+
+    return f"""#!/usr/bin/env bash
+set -e
+
+IMAGE_NAME="{image_name}"
+
+docker build -t "$IMAGE_NAME" .
+
+docker run --rm -it{gpu_flag} \\
+    -v "$PWD:/workspace" \\
+    -w /workspace \\
+    "$IMAGE_NAME"
+"""
+
+
+def create_docker_run_helper(repo_path: str | Path) -> DockerRunFixResult | None:
+    """Create a Docker build/run helper script when Dockerfile exists."""
+    path = Path(repo_path).expanduser().resolve()
+    dockerfile_path = path / "Dockerfile"
+
+    if not dockerfile_path.exists():
+        return None
+
+    script_path = path / "run_simfix_docker.sh"
+
+    if script_path.exists():
+        return DockerRunFixResult(
+            file_path=script_path,
+            changed=False,
+            message="Docker run helper already exists. SimFix did not overwrite it.",
+        )
+
+    image_name = f"simfix-{path.name}".lower().replace("_", "-")
+    use_gpu = detect_gpu_project(path)
+
+    script_path.write_text(
+        _docker_run_script(image_name=image_name, use_gpu=use_gpu),
+        encoding="utf-8",
+    )
+    script_path.chmod(0o755)
+
+    if use_gpu:
+        message = "Created Docker run helper with GPU support."
+    else:
+        message = "Created Docker run helper."
+
+    return DockerRunFixResult(
+        file_path=script_path,
+        changed=True,
+        message=message,
+    )