simfix 0.1.0__py3-none-any.whl

simfix/setup_py.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+def parse_setup_py_dependencies(setup_py_path: str | Path) -> list[str]:
+    """Parse simple install_requires dependencies from setup.py."""
+    path = Path(setup_py_path).expanduser().resolve()
+
+    if not path.exists():
+        return []
+
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+    except SyntaxError:
+        return []
+
+    dependencies: list[str] = []
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+
+        for keyword in node.keywords:
+            if keyword.arg != "install_requires":
+                continue
+
+            dependencies.extend(_parse_dependency_list(keyword.value))
+
+    return dependencies
+
+
+def _parse_dependency_list(node: ast.AST) -> list[str]:
+    """Parse dependency list values from an AST node."""
+    if not isinstance(node, ast.List | ast.Tuple):
+        return []
+
+    dependencies: list[str] = []
+
+    for element in node.elts:
+        if isinstance(element, ast.Constant) and isinstance(element.value, str):
+            dependencies.append(element.value)
+
+    return dependencies

simfix/system.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def get_linux_os_release() -> tuple[str | None, str | None]:
+    """Return Linux distribution name and version from /etc/os-release."""
+    os_release_path = Path("/etc/os-release")
+
+    if not os_release_path.exists():
+        return None, None
+
+    values: dict[str, str] = {}
+
+    for line in os_release_path.read_text(encoding="utf-8").splitlines():
+        if "=" not in line:
+            continue
+
+        key, value = line.split("=", maxsplit=1)
+        values[key] = value.strip().strip('"')
+
+    distro = values.get("NAME")
+    version = values.get("VERSION_ID")
+
+    return distro, version
+
+
+def is_windows_subsystem_for_linux() -> bool:
+    """Return True if running inside Windows Subsystem for Linux."""
+    version_path = Path("/proc/version")
+
+    if not version_path.exists():
+        return False
+
+    text = version_path.read_text(encoding="utf-8").lower()
+
+    return "microsoft" in text or "wsl" in text
+
+
+def get_nvidia_smi_field(field: str) -> str | None:
+    """Return a single field from nvidia-smi query output."""
+    if not command_exists("nvidia-smi"):
+        return None
+
+    result = subprocess.run(
+        [
+            "nvidia-smi",
+            f"--query-gpu={field}",
+            "--format=csv,noheader",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        return None
+
+    first_line = result.stdout.strip().splitlines()[0] if result.stdout.strip() else ""
+
+    return first_line.strip() or None
+
+
+def get_cuda_toolkit_version() -> str | None:
+    """Return CUDA toolkit version from nvcc if available."""
+    if not command_exists("nvcc"):
+        return None
+
+    result = subprocess.run(
+        ["nvcc", "--version"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        return None
+
+    for line in result.stdout.splitlines():
+        if "release" in line:
+            return line.strip()
+
+    return result.stdout.strip() or None
+
+
+@dataclass(frozen=True)
+class SystemInfo:
+    """Basic system information relevant for simulator installation."""
+
+    os_name: str
+    os_version: str
+    architecture: str
+    python_version: str
+    linux_distro: str | None
+    linux_version: str | None
+    is_wsl: bool
+    git_available: bool
+    docker_available: bool
+    nvidia_gpu_available: bool
+    nvidia_driver_version: str | None
+    nvidia_cuda_version: str | None
+    cuda_toolkit_version: str | None
+    pip_available: bool
+    uv_available: bool
+    conda_available: bool
+    mamba_available: bool
+
+
+def command_exists(command: str) -> bool:
+    """Return True if a command exists on PATH."""
+    return shutil.which(command) is not None
+
+
+def has_nvidia_gpu() -> bool:
+    """Return True if nvidia-smi is available and runs successfully."""
+    if not command_exists("nvidia-smi"):
+        return False
+
+    result = subprocess.run(
+        ["nvidia-smi"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+    return result.returncode == 0
+
+
+def get_system_info() -> SystemInfo:
+    """Collect basic system information."""
+    linux_distro, linux_version = get_linux_os_release()
+    return SystemInfo(
+        os_name=platform.system(),
+        os_version=platform.release(),
+        architecture=platform.machine(),
+        python_version=platform.python_version(),
+        linux_distro=linux_distro,
+        linux_version=linux_version,
+        is_wsl=is_windows_subsystem_for_linux(),
+        git_available=command_exists("git"),
+        docker_available=command_exists("docker"),
+        nvidia_gpu_available=has_nvidia_gpu(),
+        nvidia_driver_version=get_nvidia_smi_field("driver_version"),
+        nvidia_cuda_version=get_nvidia_smi_field("cuda_version"),
+        cuda_toolkit_version=get_cuda_toolkit_version(),
+        pip_available=command_exists("pip") or command_exists("pip3"),
+        uv_available=command_exists("uv"),
+        conda_available=command_exists("conda"),
+        mamba_available=command_exists("mamba"),
+    )

simfix/system_docker.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+COMMON_SIMULATOR_APT_PACKAGES = [
+    "build-essential",
+    "cmake",
+    "git",
+    "pkg-config",
+    "python3",
+    "python3-pip",
+    "libgl1",
+    "libglib2.0-0",
+    "libx11-6",
+    "libxext6",
+    "libxrender1",
+    "libsm6",
+    "libice6",
+    "libeigen3-dev",
+    "libboost-all-dev",
+]
+
+
+SYSTEM_KEYWORDS = {
+    "cmake",
+    "find_package",
+    "opengl",
+    "glfw",
+    "glew",
+    "eigen",
+    "boost",
+    "sdl",
+    "opencv",
+    "libgl",
+    "build-essential",
+}
+
+
+@dataclass(frozen=True)
+class SystemDockerFixResult:
+    """Result of creating or updating a system dependency 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 detect_system_dependency_project(repo_path: str | Path) -> bool:
+    """Detect whether a repository likely needs Linux system packages."""
+    path = Path(repo_path).expanduser().resolve()
+
+    searchable_text = "\n".join(
+        [
+            _read_text_if_exists(path / "CMakeLists.txt"),
+            _read_text_if_exists(path / "README.md"),
+            _read_text_if_exists(path / "readme.md"),
+            _read_text_if_exists(path / "Dockerfile"),
+            _read_text_if_exists(path / "setup.py"),
+            _read_text_if_exists(path / "pyproject.toml"),
+        ]
+    ).lower()
+
+    if any(keyword in searchable_text for keyword in SYSTEM_KEYWORDS):
+        return True
+
+    cpp_suffixes = {".cpp", ".cc", ".cxx", ".c", ".hpp", ".h"}
+
+    for file_path in path.rglob("*"):
+        if ".git" in file_path.parts:
+            continue
+
+        if file_path.is_file() and file_path.suffix.lower() in cpp_suffixes:
+            return True
+
+    return False
+
+
+def _ubuntu_dockerfile() -> str:
+    """Return a Dockerfile with common simulator system packages."""
+    packages = " \\\n    ".join(COMMON_SIMULATOR_APT_PACKAGES)
+
+    return f"""FROM ubuntu:22.04
+
+SHELL ["/bin/bash", "-c"]
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \\
+    {packages} \\
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /workspace
+
+COPY . /workspace
+
+CMD ["/bin/bash"]
+"""
+
+
+def _extract_existing_apt_packages(dockerfile_text: str) -> set[str]:
+    """Extract simple package names already present in a Dockerfile."""
+    existing_packages: set[str] = set()
+
+    for package in COMMON_SIMULATOR_APT_PACKAGES:
+        if package in dockerfile_text:
+            existing_packages.add(package)
+
+    return existing_packages
+
+
+def _append_apt_install_block(dockerfile_text: str, packages: list[str]) -> str:
+    """Append an apt-get install block to an existing Dockerfile."""
+    package_lines = " \\\n    ".join(packages)
+
+    block = f"""
+
+# Added by SimFix: common simulator system dependencies
+RUN apt-get update && apt-get install -y \\
+    {package_lines} \\
+    && rm -rf /var/lib/apt/lists/*
+"""
+
+    return dockerfile_text.rstrip() + block + "\n"
+
+
+def fix_system_dockerfile(repo_path: str | Path) -> SystemDockerFixResult | None:
+    """Create or update Dockerfile with common simulator system packages."""
+    path = Path(repo_path).expanduser().resolve()
+
+    if not detect_system_dependency_project(path):
+        return None
+
+    dockerfile_path = path / "Dockerfile"
+
+    if not dockerfile_path.exists():
+        dockerfile_path.write_text(_ubuntu_dockerfile(), encoding="utf-8")
+
+        return SystemDockerFixResult(
+            file_path=dockerfile_path,
+            changed=True,
+            message="Created Dockerfile with common simulator system packages.",
+        )
+
+    old_text = dockerfile_path.read_text(encoding="utf-8")
+    existing_packages = _extract_existing_apt_packages(old_text)
+    missing_packages = [
+        package
+        for package in COMMON_SIMULATOR_APT_PACKAGES
+        if package not in existing_packages
+    ]
+
+    if not missing_packages:
+        return SystemDockerFixResult(
+            file_path=dockerfile_path,
+            changed=False,
+            message="Dockerfile already contains common simulator system packages.",
+        )
+
+    new_text = _append_apt_install_block(old_text, missing_packages)
+    dockerfile_path.write_text(new_text, encoding="utf-8")
+
+    return SystemDockerFixResult(
+        file_path=dockerfile_path,
+        changed=True,
+        message="Updated Dockerfile with missing simulator system packages.",
+    )

simfix-0.1.0.dist-info/METADATA

@@ -0,0 +1,286 @@
+Metadata-Version: 2.4
+Name: simfix
+Version: 0.1.0
+Summary: A dependency checker and installation assistant for simulator repositories.
+Author-email: Habib ur Rehmaan <h.rehmaan96@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hrehmaan/simfix
+Project-URL: Repository, https://github.com/hrehmaan/simfix
+Project-URL: Issues, https://github.com/hrehmaan/simfix/issues
+Keywords: simulator,dependencies,installation,docker,cuda,ros
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: typer
+Requires-Dist: requests
+Requires-Dist: packaging
+Requires-Dist: pyyaml
+Requires-Dist: uv
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# SimFix
+
+SimFix is a dependency checker and installation assistant for simulator repositories.
+
+It helps users diagnose common installation problems by inspecting repository files, detecting dependency systems, checking Python packages, identifying system requirements, and suggesting a safe installation plan.
+
+SimFix is designed for simulator projects where installation can fail because of missing dependencies, version conflicts, GPU/CUDA requirements, ROS dependencies, Docker setup issues, or unclear setup instructions.
+
+## Features
+
+SimFix can analyze both local repositories and remote GitHub/GitLab repositories.
+
+It currently supports:
+
+* Local repository analysis
+* GitHub/GitLab repository analysis by cloning into a local workspace
+* Dependency file detection
+* Python dependency parsing
+* PyPI package checks
+* Basic installation planning
+* System diagnostics
+* Safe dependency fixes for selected file types
+* Docker helper generation for supported simulator projects
+
+## Supported dependency files
+
+SimFix can detect and inspect:
+
+* `requirements.txt`
+* `setup.py`
+* `pyproject.toml`
+* `environment.yml` / `environment.yaml`
+* `Dockerfile`
+* `package.xml`
+* `CMakeLists.txt`
+
+## System diagnostics
+
+SimFix can report:
+
+* Operating system
+* CPU architecture
+* Python version
+* Git availability
+* Docker availability
+* Conda/mamba availability
+* NVIDIA GPU availability
+* NVIDIA driver information
+* CUDA toolkit availability
+
+## Automatic fixes
+
+The `simfix fix` command currently supports:
+
+* Resolving `requirements.txt` with `uv`
+* Normalizing invalid pip syntax such as `package=version` to `package==version`
+* Repairing clear resolver conflicts by removing direct conflicting pins and letting `uv` choose compatible versions
+* Cleaning duplicate dependencies in `environment.yml`
+* Creating CUDA/GPU Dockerfiles for GPU-based simulator projects
+* Creating ROS Dockerfiles from `package.xml`
+* Creating general system dependency Dockerfiles for CMake/C++ simulator projects
+* Initializing Git submodules
+* Pulling Git LFS assets when Git LFS is available
+* Creating a Docker run helper script
+
+For GPU projects, SimFix can create a CUDA-based Dockerfile. The host machine still needs a working NVIDIA driver and NVIDIA Container Toolkit to run GPU containers.
+
+SimFix does not automatically install vendor software such as NVIDIA Isaac Gym, Isaac Sim, CUDA drivers, or system-level GPU drivers. These dependencies must be installed manually.
+
+## Installation for development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/hrehmaan/simfix.git
+cd simfix
+```
+
+Install in editable mode with development dependencies:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+Install pre-commit hooks:
+
+```bash
+pre-commit install
+```
+
+## Usage
+
+Check your system:
+
+```bash
+simfix system
+```
+
+Analyze a repository:
+
+```bash
+simfix doctor <repo>
+```
+
+Example:
+
+```bash
+simfix doctor ../simfix_test
+```
+
+Analyze a repository and show detected metadata:
+
+```bash
+simfix analyze <repo>
+```
+
+Generate an installation plan:
+
+```bash
+simfix plan <repo>
+```
+
+Generate a Markdown report:
+
+```bash
+simfix doctor <repo> --report
+```
+
+Show suggested installation commands without running them:
+
+```bash
+simfix commands <repo>
+```
+
+Apply supported automatic fixes:
+
+```bash
+simfix fix <repo>
+```
+
+Analyze a remote GitHub repository:
+
+```bash
+simfix doctor https://github.com/hrehmaan/simfix.git
+```
+
+Show the installed SimFix version:
+
+```bash
+simfix version
+```
+
+## Main commands
+
+```text
+simfix system
+simfix doctor <repo>
+simfix doctor <repo> --report
+simfix analyze <repo>
+simfix plan <repo>
+simfix commands <repo>
+simfix fix <repo>
+simfix version
+```
+
+## Example output
+
+```text
+SimFix Doctor
+Repository: /path/to/repository
+
+Detected dependency files
+requirements.txt: yes
+setup.py: yes
+pyproject.toml: no
+environment.yml: no
+Dockerfile: no
+package.xml / ROS: no
+CMakeLists.txt: no
+
+Detected ecosystem(s): python
+
+Python packages
+- numpy
+- matplotlib
+
+PyPI check
+- numpy: found
+- matplotlib: found
+
+Install plan
+Recommended mode: python
+Reason: Python dependency files were found.
+
+Recommendation:
+Python environment installation is possible.
+```
+
+## Example: fixing a Python dependency conflict
+
+If a repository contains conflicting Python requirements such as:
+
+```text
+urdfpy==0.0.22
+networkx==3.1
+```
+
+and the resolver reports that `urdfpy==0.0.22` requires `networkx==2.2`, SimFix does not blindly choose a version itself.
+
+Instead, SimFix removes the direct conflicting pin and lets `uv` resolve the compatible version.
+
+This keeps the resolver as the authority and avoids hard-coding risky downgrades.
+
+## Example: vendor dependency detection
+
+Some simulator dependencies are not available on PyPI. For example, NVIDIA Isaac Gym is a vendor dependency and cannot be installed with:
+
+```bash
+python -m pip install isaacgym
+```
+
+In such cases, SimFix reports the missing package and indicates that manual installation is required.
+
+For these projects, the correct setup may require:
+
+* Linux
+* NVIDIA GPU
+* NVIDIA driver
+* CUDA support
+* Vendor SDK installation
+
+## Development checks
+
+Run tests:
+
+```bash
+pytest
+```
+
+Run pre-commit:
+
+```bash
+pre-commit run --all-files
+```
+
+## Project status
+
+SimFix is in early development.
+
+The current focus is safe repository analysis, dependency diagnosis, installation planning, and targeted automatic fixes for common simulator setup problems.
+
+The long-term goal is to make simulator setup easier by combining repository analysis, system diagnostics, dependency checks, resolver-based repair, Docker guidance, and clear manual-install warnings for vendor dependencies.

simfix-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+simfix/__init__.py,sha256=8k1mftlTzNljZZcb91RxvL7xfWram4WcyZKeVLYPxt0,45
+simfix/analyzer.py,sha256=WMlekYc0wVGJOgmiwsduQqit9pL6vqdRt8ClOl_KlQk,4272
+simfix/cli.py,sha256=4qBwz6TuLmMOfNyvDLQnqpJtRFAYGcxrUx8A64-B3yw,14706
+simfix/cmake.py,sha256=VZvOR9YCexAFJJ-bx7QtZ5Q9BVoO7Fu_hcKotbNbLrc,1553
+simfix/commands.py,sha256=MmGKK_Cvw7eZZD-u6IQPSmeJbWhX7mLIYzY22yY0nE8,2734
+simfix/compatibility.py,sha256=vDZCHRY80fkTxpiNY_8VuOD_yJgefphrnyHreCn_6-I,2929
+simfix/conda_environment.py,sha256=gfUEEb5LZxvkxs_J_5h444go7ZJKIMObayqBSiRMPKc,1662
+simfix/conda_fixer.py,sha256=9Qey77bFq3KHTSSVfsNm75E_o_JJxXoP37UfoASu-Nk,4370
+simfix/cuda_docker.py,sha256=yZzyE_eWAFmJ6rJr954xjvx5b0uT09K0C_OqGV_r_LY,4203
+simfix/docker_runner.py,sha256=XV0olJov9d-c6KHOmIbukTC7qAxOx7U2i61HXoxvd6c,1780
+simfix/dockerfile.py,sha256=2tcPdy7FvwyuiQgy0Q71cXTni6FcakG8Fq_cy9tTbzU,3292
+simfix/fixer.py,sha256=5IDzcZ_7mn2z7wXk4E1ofEvKIVUEOJbhY2X2mnGi5Lg,10379
+simfix/git_assets.py,sha256=HUn_74zQ3mXH_YkCGLGE9HQIgjXZnvn3z39A3f022dA,3052
+simfix/planner.py,sha256=kR3q8FFgyvyhphPKHToJh1P-MwAX3tbb743WgsKCOiA,3038
+simfix/pypi.py,sha256=IWfS_6CKmEOh9poocjMErMt-iyw6uVeynkgRk6lMeo0,2062
+simfix/pyproject.py,sha256=5711LTNXK2stUy-pbxhyqLXN69u-lwZjWnVKCm-0s1U,3477
+simfix/python_requirements.py,sha256=d5bIvrvTBV-zwCLJe1SvPvhx-8EZb-iRv-4m4r2ApgE,1111
+simfix/repo.py,sha256=93-Dzk0yor6AUii7fvjzFr-xAM7WXDMicm6cHgIj3L0,1294
+simfix/report.py,sha256=IhaESMkHKo_2Kghm73JKTbnt9NoRAWZ_kws_fH3MIOw,6639
+simfix/ros_docker.py,sha256=aHOq227zSHUzXfUt1kw4jQiEysVJG3oDcotkS0ANQbo,2648
+simfix/ros_package.py,sha256=FGiYZAdBTjbpPlI0YePbbtW06Yd8b7wFyUmMaNqEFr8,2553
+simfix/setup_py.py,sha256=axRXcyBfD6gXUMCLhbaUyCCRv0XPfESduFq65aCs0LY,1169
+simfix/system.py,sha256=Altbdp5e206xqDjoW3gDGTOm-mMtCMQ0DGNYZmMi1wM,4194
+simfix/system_docker.py,sha256=_R4s2rolP0mFnvOsa6c1hopEMVG9-FRjuRGs7O_pqtM,4566
+simfix-0.1.0.dist-info/licenses/LICENSE,sha256=BckJViUgN8-Q78X2YBxAh4R7oAUJN8jNf2sVQGpeyUg,1073
+simfix-0.1.0.dist-info/METADATA,sha256=YwmbPDCsy-kcqkYxf5nS_uRwZdL8j7GYO07KHcxar6c,6882
+simfix-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simfix-0.1.0.dist-info/entry_points.txt,sha256=O5Co5CiVZD80Sl-YeWhyeeZh9xEmOa2BoHKcpGfGtcU,42
+simfix-0.1.0.dist-info/top_level.txt,sha256=8Z9xmi4Ty3l4xHmbebT6jnGG8W2VIj5kfw-N4OBwsUA,7
+simfix-0.1.0.dist-info/RECORD,,

simfix-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simfix-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simfix = simfix.cli:app