simfix 0.1.4__tar.gz → 0.1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simfix
-Version: 0.1.4
+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.4 → simfix-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simfix"
-version = "0.1.4"
+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.4 → simfix-0.1.5}/simfix/__init__.py

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

{simfix-0.1.4 → 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.4 → simfix-0.1.5}/simfix/cli.py

@@ -214,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")
@@ -224,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")

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/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

simfix-0.1.5/simfix/install_commands.py

@@ -0,0 +1,163 @@
+"""Actionable install command generation for SimFix."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from simfix.repo import RepoAnalysis
+
+
+@dataclass(frozen=True)
+class CommandGroup:
+    """A group of related install commands."""
+
+    title: str
+    commands: tuple[str, ...]
+    note: str | None = None
+
+
+def generate_install_command_groups(analysis: RepoAnalysis) -> list[CommandGroup]:
+    """Generate actionable install commands from detected repository metadata.
+
+    The logic is generic and based on detected ecosystems/files, not repository names.
+    """
+    command_groups: list[CommandGroup] = []
+
+    if analysis.has_dockerfile:
+        command_groups.append(_docker_commands())
+
+    if analysis.has_package_xml:
+        command_groups.append(_ros_commands(analysis))
+
+    if analysis.has_requirements_txt:
+        command_groups.append(_python_requirements_commands())
+
+    if analysis.has_pyproject_toml or analysis.has_setup_py:
+        command_groups.append(_python_project_commands())
+
+    if analysis.has_environment_yml:
+        command_groups.append(_conda_commands())
+
+    if analysis.has_cmake and not analysis.has_package_xml:
+        command_groups.append(_cmake_commands())
+
+    if not command_groups:
+        command_groups.append(
+            CommandGroup(
+                title="Manual inspection",
+                commands=(
+                    "Read the project README installation section.",
+                    "Check for install scripts such as install.sh, setup.sh, or Docker instructions.",
+                    "Run project examples/tests after installing dependencies.",
+                ),
+                note="No common dependency files were detected.",
+            )
+        )
+
+    return command_groups
+
+
+def _docker_commands() -> CommandGroup:
+    return CommandGroup(
+        title="Docker workflow",
+        commands=(
+            "docker build -t simfix-workspace .",
+            "./run_simfix_docker.sh",
+        ),
+        note=(
+            "Use this when Dockerfile/run_simfix_docker.sh exists. "
+            "For GPU projects, the host must have working NVIDIA Docker support."
+        ),
+    )
+
+
+def _ros_commands(analysis: RepoAnalysis) -> CommandGroup:
+    build_system = analysis.ros_package_info.build_system.lower()
+
+    if build_system == "catkin":
+        return CommandGroup(
+            title="ROS 1 / catkin workflow",
+            commands=(
+                "rosdep update",
+                "rosdep install --from-paths . --ignore-src -r -y",
+                "catkin build",
+                "source devel/setup.bash",
+            ),
+            note=(
+                "Run these inside a ROS 1 workspace or inside the generated ROS Noetic Docker container."
+            ),
+        )
+
+    if build_system in {"ament_cmake", "ament_python", "ament"}:
+        return CommandGroup(
+            title="ROS 2 / colcon workflow",
+            commands=(
+                "rosdep update",
+                "rosdep install --from-paths . --ignore-src -r -y",
+                "colcon build",
+                "source install/setup.bash",
+            ),
+            note=(
+                "Run these inside a ROS 2 workspace or inside a matching ROS 2 Docker container."
+            ),
+        )
+
+    return CommandGroup(
+        title="ROS workflow",
+        commands=(
+            "rosdep update",
+            "rosdep install --from-paths . --ignore-src -r -y",
+            "Build with catkin build or colcon build depending on the ROS package type.",
+            "Source the generated setup file.",
+        ),
+        note="ROS package files were detected, but the build style was not classified.",
+    )
+
+
+def _python_requirements_commands() -> CommandGroup:
+    return CommandGroup(
+        title="Python requirements workflow",
+        commands=(
+            "python -m venv .venv",
+            "source .venv/bin/activate",
+            "python -m pip install --upgrade pip",
+            "python -m pip install -r requirements.txt",
+        ),
+        note="Use this for repositories with requirements.txt.",
+    )
+
+
+def _python_project_commands() -> CommandGroup:
+    return CommandGroup(
+        title="Python editable install workflow",
+        commands=(
+            "python -m pip install -e .",
+            "python -m pip install -e . --no-deps  # use only if vendor/manual dependencies block normal install",
+        ),
+        note=(
+            "Use --no-deps only after installing normal requirements or when vendor dependencies "
+            "must be installed manually."
+        ),
+    )
+
+
+def _conda_commands() -> CommandGroup:
+    return CommandGroup(
+        title="Conda environment workflow",
+        commands=(
+            "conda env create -f environment.yml",
+            "conda activate <environment-name>",
+        ),
+        note="Replace <environment-name> with the name defined inside environment.yml.",
+    )
+
+
+def _cmake_commands() -> CommandGroup:
+    return CommandGroup(
+        title="CMake workflow",
+        commands=(
+            "cmake -S . -B build",
+            "cmake --build build",
+        ),
+        note="Use this for non-ROS CMake/C++ projects.",
+    )

{simfix-0.1.4 → simfix-0.1.5}/simfix/recommendations.py

@@ -50,42 +50,6 @@ def generate_recommendations(
         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(

{simfix-0.1.4 → simfix-0.1.5}/simfix/ros_environment.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
+from simfix.dependency_discovery import discover_dependency_files
 
 
 @dataclass(frozen=True)
@@ -21,25 +22,30 @@ 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.
+    names. It supports both root-level ROS packages and nested ROS workspaces.
+    It does not install ROS or modify files.
     """
-    package_xml = repo_path / "package.xml"
-    cmake_lists = repo_path / "CMakeLists.txt"
+    discovered_files = discover_dependency_files(repo_path)
 
-    package_text = _read_file(package_xml)
-    cmake_text = _read_file(cmake_lists)
-    combined_text = f"{package_text}\n{cmake_text}".lower()
+    package_xml_files = discovered_files.package_xml_files
+    cmake_lists_files = discovered_files.cmake_lists_files
 
-    if not combined_text.strip():
+    if not package_xml_files and not cmake_lists_files:
         return None
 
+    package_text = "\n".join(_read_file(path) for path in package_xml_files)
+    cmake_text = "\n".join(_read_file(path) for path in cmake_lists_files)
+    combined_text = f"{package_text}\n{cmake_text}".lower()
+
+    source = _source_label(*package_xml_files, *cmake_lists_files)
+
     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),
+            source=source,
         )
 
     if _looks_like_ros1(combined_text):
@@ -48,19 +54,16 @@ def detect_ros_environment_info(repo_path: Path) -> RosEnvironmentInfo | None:
             recommended_distribution="Noetic",
             recommended_ubuntu="Ubuntu 20.04",
             recommended_docker_image="osrf/ros:noetic-desktop-full",
-            source=_source_label(package_xml, cmake_lists),
+            source=source,
         )
 
-    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
+    return RosEnvironmentInfo(
+        project_type="ROS project",
+        recommended_distribution=None,
+        recommended_ubuntu=None,
+        recommended_docker_image=None,
+        source=source,
+    )
 
 
 def _looks_like_ros2(text: str) -> bool:
@@ -97,10 +100,36 @@ def _read_file(path: Path) -> str:
     return path.read_text(encoding="utf-8")
 
 
+def _pluralize(count: int, singular: str, plural: str) -> str:
+    if count == 1:
+        return f"1 {singular}"
+
+    return f"{count} {plural}"
+
+
 def _source_label(*paths: Path) -> str:
-    existing_paths = [path.name for path in paths if path.exists()]
+    existing_paths = [path for path in paths if path.exists()]
 
     if not existing_paths:
         return "ROS project files"
 
-    return ", ".join(existing_paths)
+    package_xml_count = sum(path.name == "package.xml" for path in existing_paths)
+    cmake_count = sum(path.name == "CMakeLists.txt" for path in existing_paths)
+
+    labels: list[str] = []
+
+    if package_xml_count:
+        labels.append(
+            _pluralize(package_xml_count, "package.xml file", "package.xml files")
+        )
+
+    if cmake_count:
+        labels.append(
+            _pluralize(cmake_count, "CMakeLists.txt file", "CMakeLists.txt files")
+        )
+
+    if labels:
+        return " and ".join(labels)
+
+    unique_names = sorted({path.name for path in existing_paths})
+    return ", ".join(unique_names)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simfix
-Version: 0.1.4
+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.4 → simfix-0.1.5}/simfix.egg-info/SOURCES.txt

@@ -11,10 +11,12 @@ simfix/conda_environment.py
 simfix/conda_fixer.py
 simfix/cuda.py
 simfix/cuda_docker.py
+simfix/dependency_discovery.py
 simfix/docker_runner.py
 simfix/dockerfile.py
 simfix/fixer.py
 simfix/git_assets.py
+simfix/install_commands.py
 simfix/planner.py
 simfix/pypi.py
 simfix/pyproject.py

{simfix-0.1.4 → simfix-0.1.5}/simfix.egg-info/requires.txt

@@ -5,6 +5,9 @@ packaging
 pyyaml
 uv
 
+[:python_version < "3.11"]
+tomli
+
 [dev]
 pytest
 pre-commit

{simfix-0.1.4 → simfix-0.1.5}/tests/test_basic.py

@@ -58,7 +58,7 @@ from simfix.system import (
 
 
 def test_version() -> None:
-    assert __version__ == "0.1.4"
+    assert __version__ == "0.1.5"
 
 
 def test_analyze_python_repo(tmp_path: Path) -> None:
@@ -639,8 +639,9 @@ def test_create_python_command_plan(tmp_path: Path) -> None:
     analysis = analyze_repo(tmp_path)
     command_plan = create_command_plan(analysis)
 
-    assert command_plan.title == "Python installation commands"
+    assert command_plan.title == "Suggested installation commands"
     assert "python -m venv .venv" in command_plan.commands
+    assert "source .venv/bin/activate" in command_plan.commands
     assert "python -m pip install -r requirements.txt" in command_plan.commands
 
 
@@ -650,8 +651,13 @@ def test_create_docker_command_plan(tmp_path: Path) -> None:
     analysis = analyze_repo(tmp_path)
     command_plan = create_command_plan(analysis)
 
-    assert command_plan.title == "Docker installation commands"
-    assert any("docker build" in command for command in command_plan.commands)
+    assert command_plan.title == "Suggested installation commands"
+    assert any(
+        command.startswith("docker build -t ") for command in command_plan.commands
+    )
+    assert any(
+        command.startswith("docker run --rm -it ") for command in command_plan.commands
+    )
 
 
 def test_fix_requirements_with_uv_returns_none_without_requirements(
@@ -1203,7 +1209,15 @@ def test_recommendations_command_detects_isaacgym(tmp_path: Path) -> None:
     result = runner.invoke(app, ["recommendations", str(repo)])
 
     assert result.exit_code == 0
-    assert "isaacgym" in result.output.lower()
+    assert "SimFix Recommendations" in result.output
+
+
+def test_vendor_dependency_recommendations_detect_isaacgym() -> None:
+    recommendations = detect_vendor_dependency_recommendations(["isaacgym"])
+
+    titles = [recommendation.title for recommendation in recommendations]
+
+    assert "NVIDIA Isaac Gym required" in titles
 
 
 def test_doctor_shows_recommendations_hint_for_vendor_dependency(
@@ -1423,14 +1437,6 @@ def test_recommendations_include_ros_environment_info() -> None:
     assert "ROS 1 / catkin environment detected" in titles
 
 
-def test_vendor_dependency_recommendations_detect_isaacgym() -> None:
-    recommendations = detect_vendor_dependency_recommendations(["isaacgym"])
-
-    titles = [recommendation.title for recommendation in recommendations]
-
-    assert "NVIDIA Isaac Gym required" in titles
-
-
 def test_vendor_dependency_recommendations_detect_mujoco_py() -> None:
     recommendations = detect_vendor_dependency_recommendations(["mujoco-py"])
 
@@ -1451,3 +1457,31 @@ def test_vendor_dependency_recommendations_ignore_normal_python_packages() -> No
     recommendations = detect_vendor_dependency_recommendations(["numpy", "matplotlib"])
 
     assert recommendations == []
+
+
+def test_detect_ros_environment_info_from_nested_workspace(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    package = repo / "planner_gazebo_sim"
+    package.mkdir(parents=True)
+
+    (package / "package.xml").write_text(
+        """
+        <package format="2">
+          <name>planner_gazebo_sim</name>
+          <buildtool_depend>catkin</buildtool_depend>
+          <depend>roscpp</depend>
+        </package>
+        """,
+        encoding="utf-8",
+    )
+    (package / "CMakeLists.txt").write_text(
+        "find_package(catkin REQUIRED)",
+        encoding="utf-8",
+    )
+
+    info = detect_ros_environment_info(repo)
+
+    assert info is not None
+    assert info.project_type == "ROS 1 / catkin"
+    assert info.recommended_distribution == "Noetic"
+    assert info.recommended_ubuntu == "Ubuntu 20.04"

simfix-0.1.4/simfix/commands.py

@@ -1,91 +0,0 @@
-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.",
-        ],
-    )