simfix 0.1.0__py3-none-any.whl

simfix/__init__.py

@@ -0,0 +1,3 @@
+"""SimFix package."""
+
+__version__ = "0.1.0"

simfix/analyzer.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from simfix.cmake import CMakeInfo, parse_cmake_file
+from simfix.conda_environment import CondaEnvironment, parse_conda_environment
+from simfix.dockerfile import DockerfileInfo, parse_dockerfile
+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.setup_py import parse_setup_py_dependencies
+
+
+@dataclass(frozen=True)
+class RepoAnalysis:
+    """Basic analysis result for a simulator repository."""
+
+    repo_path: Path
+    has_requirements_txt: bool
+    has_pyproject_toml: bool
+    has_environment_yml: bool
+    has_dockerfile: bool
+    has_package_xml: bool
+    has_cmake: bool
+    has_setup_py: bool
+    setup_py_dependencies: list[str]
+    python_requirements: list[str]
+    conda_environment: CondaEnvironment | None
+    dockerfile_info: DockerfileInfo | None
+    ros_package_info: ROSPackageInfo | None
+    cmake_info: CMakeInfo | None
+    pyproject_info: PyProjectInfo | None
+
+    @property
+    def all_python_dependencies(self) -> list[str]:
+        """Return all Python dependencies from supported dependency files."""
+        dependencies = list(self.python_requirements)
+
+        if self.pyproject_info is not None:
+            dependencies.extend(self.pyproject_info.dependencies)
+
+        dependencies.extend(self.setup_py_dependencies)
+
+        unique_dependencies: dict[str, str] = {}
+
+        for dependency in dependencies:
+            package_name = normalize_requirement_name(dependency).lower()
+
+            if package_name not in unique_dependencies:
+                unique_dependencies[package_name] = dependency
+
+        return list(unique_dependencies.values())
+
+    @property
+    def detected_ecosystems(self) -> list[str]:
+        """Return detected project ecosystems."""
+        ecosystems: list[str] = []
+
+        if self.has_requirements_txt or self.has_pyproject_toml:
+            ecosystems.append("python")
+
+        if self.has_environment_yml:
+            ecosystems.append("conda")
+
+        if self.has_dockerfile:
+            ecosystems.append("docker")
+
+        if self.has_package_xml:
+            ecosystems.append("ros")
+
+        if self.has_cmake:
+            ecosystems.append("cmake/c++")
+
+        if not ecosystems:
+            ecosystems.append("unknown")
+
+        return ecosystems
+
+
+def analyze_repo(repo_path: str | Path) -> RepoAnalysis:
+    """Analyze a local repository path and detect common dependency files."""
+    path = Path(repo_path).expanduser().resolve()
+
+    if not path.exists():
+        raise FileNotFoundError(f"Repository path does not exist: {path}")
+
+    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"
+
+    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(),
+        python_requirements=parse_requirements_file(requirements_path),
+        conda_environment=parse_conda_environment(environment_path),
+        has_dockerfile=dockerfile_path.exists(),
+        dockerfile_info=parse_dockerfile(dockerfile_path),
+        has_package_xml=package_xml_path.exists(),
+        ros_package_info=parse_ros_package(package_xml_path),
+        has_cmake=cmake_path.exists(),
+        cmake_info=parse_cmake_file(cmake_path),
+        has_pyproject_toml=pyproject_path.exists(),
+        pyproject_info=parse_pyproject(pyproject_path),
+        has_setup_py=setup_py_path.exists(),
+        setup_py_dependencies=setup_py_dependencies,
+    )

simfix/cli.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from simfix import __version__
+from simfix.analyzer import analyze_repo
+from simfix.commands import create_command_plan
+from simfix.compatibility import generate_compatibility_warnings
+from simfix.fixer import fix_repo
+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 import get_system_info
+
+
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    """Show SimFix version and exit."""
+    if value:
+        typer.echo(f"simfix {__version__}")
+        raise typer.Exit
+
+
+app = typer.Typer(
+    help="SimFix: dependency checker and installer assistant for simulator repositories.",
+)
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Show SimFix version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """SimFix command-line interface."""
+
+
+console = Console()
+
+
+def _resolve_repo_path(repo: str) -> Path:
+    """Resolve a local path or clone a Git repository URL."""
+    if is_git_url(repo):
+        console.print("[bold blue]Cloning repository...[/bold blue]")
+        return clone_repo(repo)
+
+    return Path(repo)
+
+
+@app.command()
+def analyze(repo: str) -> None:
+    """Analyze repository dependency files without system diagnostics."""
+    repo_path = _resolve_repo_path(repo)
+    analysis = analyze_repo(repo_path)
+
+    console.print("[bold green]SimFix Analyze[/bold green]")
+    console.print(f"Repository: {analysis.repo_path}")
+
+    table = Table(title="Detected dependency files")
+    table.add_column("File/type", style="cyan")
+    table.add_column("Detected", style="green")
+
+    table.add_row("requirements.txt", "yes" if analysis.has_requirements_txt else "no")
+    table.add_row("pyproject.toml", "yes" if analysis.has_pyproject_toml else "no")
+    table.add_row("environment.yml", "yes" if analysis.has_environment_yml else "no")
+    table.add_row("Dockerfile", "yes" if analysis.has_dockerfile else "no")
+    table.add_row("package.xml / ROS", "yes" if analysis.has_package_xml else "no")
+    table.add_row("CMakeLists.txt", "yes" if analysis.has_cmake else "no")
+
+    console.print(table)
+
+    ecosystems = ", ".join(analysis.detected_ecosystems)
+    console.print(f"[bold]Detected ecosystem(s):[/bold] {ecosystems}")
+
+
+@app.command()
+def plan(repo: str) -> None:
+    """Generate a recommended installation plan for a repository."""
+    repo_path = _resolve_repo_path(repo)
+    analysis = analyze_repo(repo_path)
+    install_plan = create_install_plan(analysis)
+
+    console.print("[bold green]SimFix Plan[/bold green]")
+    console.print(f"Repository: {analysis.repo_path}")
+
+    ecosystems = ", ".join(analysis.detected_ecosystems)
+    console.print(f"[bold]Detected ecosystem(s):[/bold] {ecosystems}")
+
+    plan_table = Table(title="Install plan")
+    plan_table.add_column("Field", style="cyan")
+    plan_table.add_column("Value", style="green")
+
+    plan_table.add_row("Recommended mode", install_plan.recommended_mode)
+    plan_table.add_row("Reason", install_plan.reason)
+    plan_table.add_row("Steps", "\n".join(install_plan.steps))
+
+    console.print(plan_table)
+
+
+@app.command()
+def commands(repo: str) -> None:
+    """Show suggested installation commands without running them."""
+    repo_path = _resolve_repo_path(repo)
+    analysis = analyze_repo(repo_path)
+    command_plan = create_command_plan(analysis)
+
+    console.print("[bold green]SimFix Commands[/bold green]")
+    console.print(f"Repository: {analysis.repo_path}")
+
+    table = Table(title=command_plan.title)
+    table.add_column("#", style="cyan")
+    table.add_column("Command", style="green")
+
+    for index, command in enumerate(command_plan.commands, start=1):
+        table.add_row(str(index), command)
+
+    console.print(table)
+
+
+@app.command()
+def doctor(
+    repo: str,
+    report: bool = typer.Option(
+        False,
+        "--report",
+        help="Write a Markdown SimFix report to simfix_report.md.",
+    ),
+) -> None:
+    """Analyze a local path or Git repository URL."""
+    repo_path = _resolve_repo_path(repo)
+
+    analysis = analyze_repo(repo_path)
+    system_info = get_system_info()
+
+    console.print("[bold green]SimFix Doctor[/bold green]")
+    console.print(f"Repository: {analysis.repo_path}")
+
+    table = Table(title="Detected dependency files")
+    table.add_column("File/type", style="cyan")
+    table.add_column("Detected", style="green")
+
+    table.add_row("requirements.txt", "yes" if analysis.has_requirements_txt else "no")
+    table.add_row("pyproject.toml", "yes" if analysis.has_pyproject_toml else "no")
+    table.add_row("environment.yml", "yes" if analysis.has_environment_yml else "no")
+    table.add_row("Dockerfile", "yes" if analysis.has_dockerfile else "no")
+    table.add_row("package.xml / ROS", "yes" if analysis.has_package_xml else "no")
+    table.add_row("CMakeLists.txt", "yes" if analysis.has_cmake else "no")
+    table.add_row("setup.py", "yes" if analysis.has_setup_py else "no")
+
+    console.print(table)
+
+    ecosystems = ", ".join(analysis.detected_ecosystems)
+    console.print(f"[bold]Detected ecosystem(s):[/bold] {ecosystems}")
+
+    python_dependencies = analysis.all_python_dependencies
+
+    if python_dependencies:
+        deps_table = Table(title="Python packages")
+        deps_table.add_column("Dependency", style="cyan")
+
+        for dependency in python_dependencies:
+            deps_table.add_row(dependency)
+
+        console.print(deps_table)
+
+        pypi_results = check_pypi_packages(python_dependencies)
+
+        pypi_table = Table(title="PyPI check")
+        pypi_table.add_column("Package", style="cyan")
+        pypi_table.add_column("Status", style="green")
+        pypi_table.add_column("Latest version", style="yellow")
+
+        for package in pypi_results:
+            status = "found" if package.exists else "not found"
+            latest_version = package.latest_version or "-"
+
+            pypi_table.add_row(package.name, status, latest_version)
+
+        console.print(pypi_table)
+
+    if analysis.pyproject_info is not None:
+        pyproject_info = analysis.pyproject_info
+
+        pyproject_table = Table(title="PyProject info")
+        pyproject_table.add_column("Field", style="cyan")
+        pyproject_table.add_column("Value", style="green")
+
+        pyproject_table.add_row("Project name", pyproject_info.project_name or "-")
+        pyproject_table.add_row(
+            "Dependencies",
+            "\n".join(pyproject_info.dependencies) or "-",
+        )
+        pyproject_table.add_row(
+            "Build system requires",
+            "\n".join(pyproject_info.build_system_requires) or "-",
+        )
+
+        if pyproject_info.optional_dependencies:
+            optional_text = "\n".join(
+                f"{group}: {', '.join(deps)}"
+                for group, deps in pyproject_info.optional_dependencies.items()
+            )
+        else:
+            optional_text = "-"
+
+        pyproject_table.add_row("Optional dependencies", optional_text)
+
+        console.print(pyproject_table)
+
+    if analysis.conda_environment is not None:
+        conda_env = analysis.conda_environment
+
+        conda_table = Table(title="Conda environment")
+        conda_table.add_column("Field", style="cyan")
+        conda_table.add_column("Value", style="green")
+
+        conda_table.add_row("Name", conda_env.name or "-")
+        conda_table.add_row(
+            "Conda packages",
+            "\n".join(conda_env.conda_dependencies) or "-",
+        )
+        conda_table.add_row(
+            "Pip packages",
+            "\n".join(conda_env.pip_dependencies) or "-",
+        )
+
+        console.print(conda_table)
+
+    if analysis.dockerfile_info is not None:
+        docker_info = analysis.dockerfile_info
+
+        docker_table = Table(title="Dockerfile info")
+        docker_table.add_column("Field", style="cyan")
+        docker_table.add_column("Value", style="green")
+
+        docker_table.add_row(
+            "Base image",
+            "\n".join(docker_info.base_images) or "-",
+        )
+        docker_table.add_row(
+            "Apt packages",
+            "\n".join(docker_info.apt_packages) or "-",
+        )
+        docker_table.add_row(
+            "Pip packages",
+            "\n".join(docker_info.pip_packages) or "-",
+        )
+
+        console.print(docker_table)
+
+    if analysis.ros_package_info is not None:
+        ros_info = analysis.ros_package_info
+
+        ros_table = Table(title="ROS package info")
+        ros_table.add_column("Field", style="cyan")
+        ros_table.add_column("Value", style="green")
+
+        ros_table.add_row("Package name", ros_info.name or "-")
+        ros_table.add_row("Build system", ros_info.build_system or "-")
+        ros_table.add_row(
+            "Build tool dependencies",
+            "\n".join(ros_info.build_tool_dependencies) or "-",
+        )
+        ros_table.add_row(
+            "Build dependencies",
+            "\n".join(ros_info.build_dependencies) or "-",
+        )
+        ros_table.add_row(
+            "Execution dependencies",
+            "\n".join(ros_info.execution_dependencies) or "-",
+        )
+        ros_table.add_row(
+            "Test dependencies",
+            "\n".join(ros_info.test_dependencies) or "-",
+        )
+
+        console.print(ros_table)
+
+    if analysis.cmake_info is not None:
+        cmake_info = analysis.cmake_info
+
+        cmake_table = Table(title="CMake info")
+        cmake_table.add_column("Field", style="cyan")
+        cmake_table.add_column("Value", style="green")
+
+        cmake_table.add_row("Project name", cmake_info.project_name or "-")
+        cmake_table.add_row("Minimum version", cmake_info.minimum_version or "-")
+        cmake_table.add_row(
+            "Found packages",
+            "\n".join(cmake_info.found_packages) or "-",
+        )
+
+        console.print(cmake_table)
+
+    install_plan = create_install_plan(analysis)
+
+    plan_table = Table(title="Install plan")
+    plan_table.add_column("Field", style="cyan")
+    plan_table.add_column("Value", style="green")
+
+    plan_table.add_row("Recommended mode", install_plan.recommended_mode)
+    plan_table.add_row("Reason", install_plan.reason)
+    plan_table.add_row("Steps", "\n".join(install_plan.steps))
+
+    console.print(plan_table)
+
+    missing_pypi_packages = [
+        result.name for result in pypi_results if not result.exists
+    ]
+
+    if "docker" in analysis.detected_ecosystems:
+        console.print(
+            "[yellow]Recommendation:[/yellow] "
+            "Docker-based installation may be the safest option."
+        )
+    elif "ros" in analysis.detected_ecosystems:
+        console.print(
+            "[yellow]Recommendation:[/yellow] "
+            "ROS workspace installation is required."
+        )
+    elif "python" in analysis.detected_ecosystems:
+        if missing_pypi_packages:
+            console.print(
+                "[yellow]Recommendation:[/yellow] "
+                "Python dependencies were found, but some packages are not "
+                "available on PyPI. Manual/vendor installation may be required."
+            )
+            console.print(
+                "[yellow]Missing from PyPI:[/yellow] "
+                + ", ".join(missing_pypi_packages)
+            )
+        else:
+            console.print(
+                "[yellow]Recommendation:[/yellow] "
+                "Python environment installation is possible."
+            )
+    else:
+        console.print("[yellow]Recommendation:[/yellow] Manual inspection is needed.")
+    warnings = generate_compatibility_warnings(analysis, system_info)
+
+    if warnings:
+        warning_table = Table(title="Compatibility warnings")
+        warning_table.add_column("Warning", style="yellow")
+
+        for warning in warnings:
+            warning_table.add_row(warning)
+
+        console.print(warning_table)
+
+    if report:
+        report_text = generate_markdown_report(
+            analysis=analysis,
+            install_plan=install_plan,
+            system_info=system_info,
+        )
+        report_path = write_markdown_report(report_text)
+        console.print(f"[bold green]Report written to:[/bold green] {report_path}")
+
+
+@app.command()
+def fix(repo: str) -> None:
+    """Fix supported dependency/environment files in place."""
+    repo_path = _resolve_repo_path(repo)
+    result = fix_repo(repo_path)
+
+    console.print("[bold green]SimFix Fix[/bold green]")
+    console.print(f"Repository: {Path(repo_path).resolve()}")
+
+    for message in result.messages:
+        console.print(f"- {message}")
+
+    if result.changed_files:
+        table = Table(title="Changed files")
+        table.add_column("File", style="cyan")
+
+        for file_path in result.changed_files:
+            table.add_row(str(file_path))
+
+        console.print(table)
+    else:
+        console.print("[yellow]No files changed.[/yellow]")
+
+    console.print("[yellow]Review changes with git diff before committing.[/yellow]")
+
+
+@app.command()
+def system() -> None:
+    """Show basic system diagnostics."""
+    info = get_system_info()
+
+    table = Table(title="System check")
+    table.add_column("Item", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("OS", info.os_name)
+    table.add_row("OS version", info.os_version)
+    table.add_row("Linux distro", info.linux_distro or "-")
+    table.add_row("Linux version", info.linux_version or "-")
+    table.add_row("WSL", "yes" if info.is_wsl else "no")
+    table.add_row("Architecture", info.architecture)
+    table.add_row("Python", info.python_version)
+    table.add_row("Pip", "found" if info.pip_available else "not found")
+    table.add_row("Uv", "found" if info.uv_available else "not found")
+    table.add_row("Conda", "found" if info.conda_available else "not found")
+    table.add_row("Mamba", "found" if info.mamba_available else "not found")
+    table.add_row("Git", "found" if info.git_available else "not found")
+    table.add_row("Docker", "found" if info.docker_available else "not found")
+    table.add_row(
+        "NVIDIA GPU",
+        "detected" if info.nvidia_gpu_available else "not detected",
+    )
+    table.add_row("NVIDIA driver", info.nvidia_driver_version or "-")
+    table.add_row("NVIDIA CUDA", info.nvidia_cuda_version or "-")
+    table.add_row("CUDA toolkit", info.cuda_toolkit_version or "-")
+
+    console.print(table)
+
+
+@app.command()
+def version() -> None:
+    """Show SimFix version."""
+    console.print(f"simfix {__version__}")

simfix/cmake.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class CMakeInfo:
+    """Basic information extracted from CMakeLists.txt."""
+
+    minimum_version: str | None
+    project_name: str | None
+    found_packages: list[str]
+
+
+def _remove_comments(text: str) -> str:
+    """Remove simple CMake line comments."""
+    lines: list[str] = []
+
+    for line in text.splitlines():
+        clean_line = line.split("#", maxsplit=1)[0]
+        lines.append(clean_line)
+
+    return "\n".join(lines)
+
+
+def parse_cmake_file(path: str | Path) -> CMakeInfo | None:
+    """Parse a CMakeLists.txt file and extract basic information."""
+    cmake_path = Path(path).expanduser().resolve()
+
+    if not cmake_path.exists():
+        return None
+
+    text = _remove_comments(cmake_path.read_text(encoding="utf-8"))
+
+    minimum_version_match = re.search(
+        r"cmake_minimum_required\s*\(\s*VERSION\s+([^) \n]+)",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    project_match = re.search(
+        r"project\s*\(\s*([A-Za-z0-9_.-]+)",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    found_packages = re.findall(
+        r"find_package\s*\(\s*([A-Za-z0-9_.-]+)",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    return CMakeInfo(
+        minimum_version=(
+            minimum_version_match.group(1) if minimum_version_match else None
+        ),
+        project_name=project_match.group(1) if project_match else None,
+        found_packages=list(dict.fromkeys(found_packages)),
+    )