simfix 0.1.0__py3-none-any.whl

simfix/pypi.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+import requests
+
+
+@dataclass(frozen=True)
+class PyPIPackageInfo:
+    """Basic package information from PyPI."""
+
+    name: str
+    exists: bool
+    latest_version: str | None = None
+    error: str | None = None
+
+
+def normalize_requirement_name(requirement: str) -> str:
+    """Extract package name from a requirement string.
+
+    Examples:
+        numpy>=1.26 -> numpy
+        matplotlib==3.8.0 -> matplotlib
+        scipy[dev]>=1.11 -> scipy
+    """
+    requirement = requirement.strip()
+
+    match = re.match(r"^[A-Za-z0-9_.-]+", requirement)
+
+    if match is None:
+        return requirement
+
+    name = match.group(0)
+
+    if "[" in name:
+        name = name.split("[", maxsplit=1)[0]
+
+    return name
+
+
+def check_pypi_package(package_name: str, timeout: float = 5.0) -> PyPIPackageInfo:
+    """Check whether a package exists on PyPI."""
+    url = f"https://pypi.org/pypi/{package_name}/json"
+
+    try:
+        response = requests.get(url, timeout=timeout)
+    except requests.RequestException as exc:
+        return PyPIPackageInfo(
+            name=package_name,
+            exists=False,
+            error=str(exc),
+        )
+
+    if response.status_code == 404:
+        return PyPIPackageInfo(name=package_name, exists=False)
+
+    if response.status_code != 200:
+        return PyPIPackageInfo(
+            name=package_name,
+            exists=False,
+            error=f"HTTP {response.status_code}",
+        )
+
+    data = response.json()
+    latest_version = data.get("info", {}).get("version")
+
+    return PyPIPackageInfo(
+        name=package_name,
+        exists=True,
+        latest_version=latest_version,
+    )
+
+
+def check_pypi_packages(requirements: list[str]) -> list[PyPIPackageInfo]:
+    """Check multiple requirement strings against PyPI."""
+    results: list[PyPIPackageInfo] = []
+
+    for requirement in requirements:
+        package_name = normalize_requirement_name(requirement)
+        results.append(check_pypi_package(package_name))
+
+    return results

simfix/pyproject.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib
+
+
+@dataclass(frozen=True)
+class PyProjectInfo:
+    """Basic information extracted from pyproject.toml."""
+
+    project_name: str | None
+    dependencies: list[str]
+    optional_dependencies: dict[str, list[str]]
+    build_system_requires: list[str]
+
+
+def _as_string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+
+    return [item for item in value if isinstance(item, str)]
+
+
+def parse_pyproject(path: str | Path) -> PyProjectInfo | None:
+    """Parse pyproject.toml and extract common dependency fields."""
+    pyproject_path = Path(path).expanduser().resolve()
+
+    if not pyproject_path.exists():
+        return None
+
+    data = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+
+    project = data.get("project", {})
+    build_system = data.get("build-system", {})
+    tool = data.get("tool", {})
+    poetry = tool.get("poetry", {}) if isinstance(tool, dict) else {}
+
+    project_name = None
+    dependencies: list[str] = []
+    optional_dependencies: dict[str, list[str]] = {}
+    build_system_requires: list[str] = []
+
+    if isinstance(project, dict):
+        name = project.get("name")
+        if isinstance(name, str):
+            project_name = name
+
+        dependencies.extend(_as_string_list(project.get("dependencies")))
+
+        raw_optional = project.get("optional-dependencies", {})
+        if isinstance(raw_optional, dict):
+            for group_name, group_deps in raw_optional.items():
+                if isinstance(group_name, str):
+                    optional_dependencies[group_name] = _as_string_list(group_deps)
+
+    if isinstance(build_system, dict):
+        build_system_requires = _as_string_list(build_system.get("requires"))
+
+    if isinstance(poetry, dict):
+        poetry_name = poetry.get("name")
+        if project_name is None and isinstance(poetry_name, str):
+            project_name = poetry_name
+
+        poetry_dependencies = poetry.get("dependencies", {})
+        if isinstance(poetry_dependencies, dict):
+            for name, requirement in poetry_dependencies.items():
+                if name == "python":
+                    continue
+
+                if isinstance(requirement, str):
+                    dependencies.append(f"{name}{requirement}")
+                else:
+                    dependencies.append(str(name))
+
+        poetry_groups = poetry.get("group", {})
+        if isinstance(poetry_groups, dict):
+            for group_name, group_data in poetry_groups.items():
+                if not isinstance(group_name, str) or not isinstance(group_data, dict):
+                    continue
+
+                group_dependencies = group_data.get("dependencies", {})
+                if not isinstance(group_dependencies, dict):
+                    continue
+
+                optional_dependencies[group_name] = [
+                    f"{name}{requirement}"
+                    if isinstance(requirement, str)
+                    else str(name)
+                    for name, requirement in group_dependencies.items()
+                ]
+
+    return PyProjectInfo(
+        project_name=project_name,
+        dependencies=list(dict.fromkeys(dependencies)),
+        optional_dependencies=optional_dependencies,
+        build_system_requires=build_system_requires,
+    )

simfix/python_requirements.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def parse_requirements_file(path: str | Path) -> list[str]:
+    """Parse a requirements.txt file and return dependency lines.
+
+    This parser keeps version specifiers but ignores comments, empty lines,
+    editable installs, recursive requirement files, and pip options.
+    """
+    requirements_path = Path(path).expanduser().resolve()
+
+    if not requirements_path.exists():
+        return []
+
+    dependencies: list[str] = []
+
+    for line in requirements_path.read_text(encoding="utf-8").splitlines():
+        clean_line = line.strip()
+
+        if not clean_line:
+            continue
+
+        if clean_line.startswith("#"):
+            continue
+
+        if clean_line.startswith(("-r", "--requirement")):
+            continue
+
+        if clean_line.startswith(("-e", "--editable")):
+            continue
+
+        if clean_line.startswith(("-", "--")):
+            continue
+
+        if " #" in clean_line:
+            clean_line = clean_line.split(" #", maxsplit=1)[0].strip()
+
+        dependencies.append(clean_line)
+
+    return dependencies

simfix/repo.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+def is_git_url(value: str) -> bool:
+    """Return True if the value looks like a GitHub/GitLab repository URL."""
+    parsed = urlparse(value)
+
+    return parsed.scheme in {"http", "https", "git"} and parsed.netloc != ""
+
+
+def repo_name_from_url(repo_url: str) -> str:
+    """Extract a clean repository name from a Git URL."""
+    path = urlparse(repo_url).path.rstrip("/")
+    name = Path(path).name
+
+    if name.endswith(".git"):
+        name = name.removesuffix(".git")
+
+    if not name:
+        raise ValueError(f"Could not determine repository name from URL: {repo_url}")
+
+    return name
+
+
+def clone_repo(repo_url: str, workspace: str | Path = "workspace") -> Path:
+    """Clone a repository into the workspace folder and return its local path."""
+    workspace_path = Path(workspace).expanduser().resolve()
+    workspace_path.mkdir(parents=True, exist_ok=True)
+
+    repo_name = repo_name_from_url(repo_url)
+    destination = workspace_path / repo_name
+
+    if destination.exists():
+        shutil.rmtree(destination)
+
+    subprocess.run(
+        ["git", "clone", "--depth", "1", repo_url, str(destination)],
+        check=True,
+    )
+
+    return destination

simfix/report.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from simfix.analyzer import RepoAnalysis
+from simfix.compatibility import generate_compatibility_warnings
+from simfix.planner import InstallPlan
+from simfix.system import SystemInfo
+
+
+def _yes_no(value: bool) -> str:
+    return "yes" if value else "no"
+
+
+def generate_markdown_report(
+    analysis: RepoAnalysis,
+    install_plan: InstallPlan,
+    system_info: SystemInfo,
+) -> str:
+    """Generate a Markdown report from SimFix analysis results."""
+    warnings = generate_compatibility_warnings(analysis, system_info)
+
+    lines: list[str] = [
+        "# SimFix Report",
+        "",
+        "## Repository",
+        "",
+        f"- Path: `{analysis.repo_path}`",
+        f"- Detected ecosystem(s): `{', '.join(analysis.detected_ecosystems)}`",
+        "",
+        "## Detected dependency files",
+        "",
+        f"- `requirements.txt`: {_yes_no(analysis.has_requirements_txt)}",
+        f"- `pyproject.toml`: {_yes_no(analysis.has_pyproject_toml)}",
+        f"- `environment.yml`: {_yes_no(analysis.has_environment_yml)}",
+        f"- `Dockerfile`: {_yes_no(analysis.has_dockerfile)}",
+        f"- `package.xml`: {_yes_no(analysis.has_package_xml)}",
+        f"- `CMakeLists.txt`: {_yes_no(analysis.has_cmake)}",
+        f"- `setup.py`: {_yes_no(analysis.has_setup_py)}",
+        "",
+        "## System",
+        "",
+        f"- OS: `{system_info.os_name}`",
+        f"- OS version: `{system_info.os_version}`",
+        f"- Linux distro: `{system_info.linux_distro or '-'}`",
+        f"- Linux version: `{system_info.linux_version or '-'}`",
+        f"- WSL: `{_yes_no(system_info.is_wsl)}`",
+        f"- Architecture: `{system_info.architecture}`",
+        f"- Python: `{system_info.python_version}`",
+        f"- Git: `{_yes_no(system_info.git_available)}`",
+        f"- Docker: `{_yes_no(system_info.docker_available)}`",
+        f"- NVIDIA GPU: `{_yes_no(system_info.nvidia_gpu_available)}`",
+        f"- NVIDIA driver: `{system_info.nvidia_driver_version or '-'}`",
+        f"- NVIDIA CUDA: `{system_info.nvidia_cuda_version or '-'}`",
+        f"- CUDA toolkit: `{system_info.cuda_toolkit_version or '-'}`",
+        f"- Pip: `{_yes_no(system_info.pip_available)}`",
+        f"- Uv: `{_yes_no(system_info.uv_available)}`",
+        f"- Conda: `{_yes_no(system_info.conda_available)}`",
+        f"- Mamba: `{_yes_no(system_info.mamba_available)}`",
+        "",
+        "## Install plan",
+        "",
+        f"- Recommended mode: `{install_plan.recommended_mode}`",
+        f"- Reason: {install_plan.reason}",
+        "",
+        "### Steps",
+        "",
+    ]
+
+    lines.extend(f"{index}. {step}" for index, step in enumerate(install_plan.steps, 1))
+
+    python_dependencies = analysis.all_python_dependencies
+
+    if python_dependencies:
+        lines.extend(
+            [
+                "",
+                "## Python requirements",
+                "",
+            ]
+        )
+        lines.extend(f"- `{dependency}`" for dependency in python_dependencies)
+
+    if analysis.pyproject_info is not None:
+        pyproject_info = analysis.pyproject_info
+        lines.extend(
+            [
+                "",
+                "## PyProject",
+                "",
+                f"- Project name: `{pyproject_info.project_name or '-'}`",
+                "",
+                "### Dependencies",
+                "",
+            ]
+        )
+        lines.extend(f"- `{dependency}`" for dependency in python_dependencies)
+
+        lines.extend(["", "### Build system requires", ""])
+        lines.extend(
+            f"- `{dependency}`" for dependency in pyproject_info.build_system_requires
+        )
+
+        if pyproject_info.optional_dependencies:
+            lines.extend(["", "### Optional dependencies", ""])
+            for group, dependencies in pyproject_info.optional_dependencies.items():
+                lines.append(f"- `{group}`: {', '.join(dependencies)}")
+
+    if analysis.conda_environment is not None:
+        conda_env = analysis.conda_environment
+        lines.extend(
+            [
+                "",
+                "## Conda environment",
+                "",
+                f"- Name: `{conda_env.name or '-'}`",
+                "",
+                "### Conda packages",
+                "",
+            ]
+        )
+        lines.extend(f"- `{dependency}`" for dependency in conda_env.conda_dependencies)
+        lines.extend(["", "### Pip packages", ""])
+        lines.extend(f"- `{dependency}`" for dependency in conda_env.pip_dependencies)
+
+    if analysis.dockerfile_info is not None:
+        docker_info = analysis.dockerfile_info
+        lines.extend(
+            [
+                "",
+                "## Dockerfile",
+                "",
+                "### Base images",
+                "",
+            ]
+        )
+        lines.extend(f"- `{image}`" for image in docker_info.base_images)
+        lines.extend(["", "### Apt packages", ""])
+        lines.extend(f"- `{package}`" for package in docker_info.apt_packages)
+        lines.extend(["", "### Pip packages", ""])
+        lines.extend(f"- `{package}`" for package in docker_info.pip_packages)
+
+    if analysis.ros_package_info is not None:
+        ros_info = analysis.ros_package_info
+        lines.extend(
+            [
+                "",
+                "## ROS package",
+                "",
+                f"- Name: `{ros_info.name or '-'}`",
+                f"- Build system: `{ros_info.build_system or '-'}`",
+                "",
+                "### Dependencies",
+                "",
+            ]
+        )
+        lines.extend(f"- `{dependency}`" for dependency in ros_info.all_dependencies)
+
+    if analysis.cmake_info is not None:
+        cmake_info = analysis.cmake_info
+        lines.extend(
+            [
+                "",
+                "## CMake",
+                "",
+                f"- Project name: `{cmake_info.project_name or '-'}`",
+                f"- Minimum version: `{cmake_info.minimum_version or '-'}`",
+                "",
+                "### Found packages",
+                "",
+            ]
+        )
+        lines.extend(f"- `{package}`" for package in cmake_info.found_packages)
+
+    if warnings:
+        lines.extend(["", "## Compatibility warnings", ""])
+        lines.extend(f"- {warning}" for warning in warnings)
+
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def write_markdown_report(
+    report_text: str,
+    output_path: str | Path = "simfix_report.md",
+) -> Path:
+    """Write a Markdown report to disk."""
+    path = Path(output_path).expanduser().resolve()
+    path.write_text(report_text, encoding="utf-8")
+    return path

simfix/ros_docker.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from simfix.analyzer import analyze_repo
+
+
+@dataclass(frozen=True)
+class RosDockerFixResult:
+    """Result of creating a ROS Dockerfile."""
+
+    file_path: Path
+    changed: bool
+    message: str
+
+
+def _ros1_dockerfile() -> str:
+    """Return a Dockerfile for ROS 1 catkin projects."""
+    return """FROM osrf/ros:noetic-desktop-full
+
+SHELL ["/bin/bash", "-c"]
+
+RUN apt-get update && apt-get install -y \\
+    python3-pip \\
+    python3-rosdep \\
+    python3-catkin-tools \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+
+COPY . /workspace/src/simfix_project
+
+RUN rosdep update || true
+RUN rosdep install --from-paths /workspace/src --ignore-src -r -y || true
+
+WORKDIR /workspace
+
+RUN source /opt/ros/noetic/setup.bash && \\
+    catkin build
+"""
+
+
+def _ros2_dockerfile() -> str:
+    """Return a Dockerfile for ROS 2 ament projects."""
+    return """FROM osrf/ros:humble-desktop
+
+SHELL ["/bin/bash", "-c"]
+
+RUN apt-get update && apt-get install -y \\
+    python3-pip \\
+    python3-rosdep \\
+    python3-colcon-common-extensions \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+
+COPY . /workspace/src/simfix_project
+
+RUN rosdep update || true
+RUN rosdep install --from-paths /workspace/src --ignore-src -r -y || true
+
+WORKDIR /workspace
+
+RUN source /opt/ros/humble/setup.bash && \\
+    colcon build
+"""
+
+
+def create_ros_dockerfile(repo_path: str | Path) -> RosDockerFixResult | None:
+    """Create a Dockerfile for ROS projects.
+
+    This creates Dockerfile only when package.xml exists and Dockerfile does not.
+    """
+    path = Path(repo_path).expanduser().resolve()
+    analysis = analyze_repo(path)
+
+    if not analysis.has_package_xml:
+        return None
+
+    dockerfile_path = path / "Dockerfile"
+
+    if dockerfile_path.exists():
+        return RosDockerFixResult(
+            file_path=dockerfile_path,
+            changed=False,
+            message="Dockerfile already exists. SimFix did not overwrite it.",
+        )
+
+    build_system = None
+
+    if analysis.ros_package_info is not None:
+        build_system = analysis.ros_package_info.build_system
+
+    if build_system == "ament":
+        dockerfile_text = _ros2_dockerfile()
+        message = "Created ROS 2 Humble Dockerfile."
+    else:
+        dockerfile_text = _ros1_dockerfile()
+        message = "Created ROS 1 Noetic Dockerfile."
+
+    dockerfile_path.write_text(dockerfile_text, encoding="utf-8")
+
+    return RosDockerFixResult(
+        file_path=dockerfile_path,
+        changed=True,
+        message=message,
+    )

simfix/ros_package.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def _detect_build_system(build_tool_dependencies: list[str]) -> str | None:
+    """Detect ROS build system from build tool dependencies."""
+    dependency_set = set(build_tool_dependencies)
+
+    if "catkin" in dependency_set:
+        return "catkin"
+
+    if "ament_cmake" in dependency_set or "ament_python" in dependency_set:
+        return "ament"
+
+    return None
+
+
+@dataclass(frozen=True)
+class ROSPackageInfo:
+    """Basic information extracted from a ROS package.xml file."""
+
+    name: str | None
+    build_system: str | None
+    build_tool_dependencies: list[str]
+    build_dependencies: list[str]
+    execution_dependencies: list[str]
+    test_dependencies: list[str]
+
+    @property
+    def all_dependencies(self) -> list[str]:
+        """Return all dependency names without duplicates."""
+        dependencies = (
+            self.build_tool_dependencies
+            + self.build_dependencies
+            + self.execution_dependencies
+            + self.test_dependencies
+        )
+
+        return list(dict.fromkeys(dependencies))
+
+
+def _find_text(root: ET.Element, tag: str) -> str | None:
+    element = root.find(tag)
+
+    if element is None or element.text is None:
+        return None
+
+    return element.text.strip()
+
+
+def _find_all_text(root: ET.Element, tags: list[str]) -> list[str]:
+    values: list[str] = []
+
+    for tag in tags:
+        for element in root.findall(tag):
+            if element.text is not None:
+                values.append(element.text.strip())
+
+    return values
+
+
+def parse_ros_package(path: str | Path) -> ROSPackageInfo | None:
+    """Parse a ROS package.xml file."""
+    package_path = Path(path).expanduser().resolve()
+
+    if not package_path.exists():
+        return None
+
+    try:
+        tree = ET.parse(package_path)
+    except ET.ParseError:
+        return None
+
+    root = tree.getroot()
+
+    build_tool_dependencies = _find_all_text(root, ["buildtool_depend"])
+
+    return ROSPackageInfo(
+        name=_find_text(root, "name"),
+        build_system=_detect_build_system(build_tool_dependencies),
+        build_tool_dependencies=build_tool_dependencies,
+        build_dependencies=_find_all_text(
+            root,
+            ["build_depend", "depend"],
+        ),
+        execution_dependencies=_find_all_text(
+            root,
+            ["exec_depend", "run_depend", "depend"],
+        ),
+        test_dependencies=_find_all_text(root, ["test_depend"]),
+    )