pixi-ros 0.1.0__py3-none-any.whl

pixi_ros/workspace.py

@@ -0,0 +1,213 @@
+"""Workspace discovery and management for ROS packages."""
+
+from pathlib import Path
+
+import pathspec
+
+from pixi_ros.package_xml import PackageXML
+
+
+def load_gitignore_spec(workspace_root: Path) -> pathspec.PathSpec | None:
+    """
+    Load gitignore patterns from workspace root.
+
+    Args:
+        workspace_root: Root directory of the workspace
+
+    Returns:
+        PathSpec object with gitignore patterns, or None if no .gitignore exists
+    """
+    gitignore_path = workspace_root / ".gitignore"
+    if not gitignore_path.exists():
+        return None
+
+    try:
+        with open(gitignore_path) as f:
+            patterns = f.read().splitlines()
+        return pathspec.PathSpec.from_lines("gitignore", patterns)
+    except (OSError, ValueError):
+        return None
+
+
+def find_package_xml(start_path: Path | None = None) -> Path | None:
+    """
+    Find the nearest package.xml file by searching upward from start_path.
+
+    Args:
+        start_path: Starting directory for search (defaults to cwd)
+
+    Returns:
+        Path to package.xml if found, None otherwise
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+
+    current = start_path.resolve()
+
+    # Search upward until we hit the root
+    while True:
+        package_xml = current / "package.xml"
+        if package_xml.exists():
+            return package_xml
+
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+
+    return None
+
+
+def find_workspace_root(start_path: Path | None = None) -> Path | None:
+    """
+    Find the workspace root by looking for a directory with ROS package.xml files.
+
+    Searches recursively for package.xml files, excluding hidden directories and
+    build artifacts. Returns the directory containing packages, or the parent of
+    a 'src' directory if packages are organized in that structure.
+
+    Args:
+        start_path: Starting directory for search (defaults to cwd)
+
+    Returns:
+        Path to workspace root if found, None otherwise
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+
+    current = start_path.resolve()
+    skip_dirs = {"build", "install", "log", ".pixi"}
+
+    # Helper to check if a directory has package.xml files
+    def has_packages(path: Path) -> bool:
+        """Check if path contains any package.xml files (recursively)."""
+        # Load gitignore patterns if available
+        gitignore_spec = load_gitignore_spec(path)
+
+        for package_xml in path.rglob("package.xml"):
+            # Get relative path from workspace root
+            relative_path = package_xml.relative_to(path)
+            relative_parts = relative_path.parts
+
+            # Skip if any parent is hidden or in skip list
+            if any(
+                part.startswith(".") or part in skip_dirs for part in relative_parts
+            ):
+                continue
+
+            # Skip if matched by gitignore patterns
+            if gitignore_spec and gitignore_spec.match_file(str(relative_path)):
+                continue
+
+            return True
+        return False
+
+    # First, check if we're inside a package - search upward for package.xml
+    package_xml = find_package_xml(current)
+    if package_xml:
+        # We found a package.xml, so determine the workspace root
+        package_dir = package_xml.parent
+        potential_src = package_dir.parent
+
+        # Check if parent directory is named 'src'
+        if potential_src.name == "src":
+            # The workspace root is the parent of 'src'
+            return potential_src.parent
+
+        # Otherwise, return the parent of the package directory
+        return package_dir.parent
+
+    # Check if current directory has any packages
+    if has_packages(current):
+        # If the directory is named 'src', return its parent as the workspace root
+        if current.name == "src":
+            return current.parent
+        return current
+
+    # Search upward for a directory containing packages
+    while True:
+        if has_packages(current):
+            # If the directory is named 'src', return its parent as the workspace root
+            if current.name == "src":
+                return current.parent
+            return current
+
+        parent = current.parent
+        if parent == current:  # Reached root
+            break
+        current = parent
+
+    # If no packages found anywhere, return the starting directory
+    # This allows initializing a new workspace in an empty directory
+    return start_path.resolve()
+
+
+def discover_packages(workspace_root: Path) -> list[PackageXML]:
+    """
+    Discover all ROS packages in a workspace.
+
+    Recursively searches for all package.xml files in the workspace,
+    excluding hidden directories (those starting with a dot).
+
+    Args:
+        workspace_root: Root directory of the workspace
+
+    Returns:
+        List of parsed PackageXML objects
+
+    Raises:
+        ValueError: If workspace_root doesn't exist or isn't a directory
+    """
+    if not workspace_root.exists():
+        raise ValueError(f"Workspace root does not exist: {workspace_root}")
+
+    if not workspace_root.is_dir():
+        raise ValueError(f"Workspace root is not a directory: {workspace_root}")
+
+    packages = []
+
+    # Directories to skip during recursive search
+    skip_dirs = {"build", "install", "log", ".pixi", "tests", "test"}
+
+    # Load gitignore patterns if available
+    gitignore_spec = load_gitignore_spec(workspace_root)
+
+    # Recursively find all package.xml files
+    for package_xml_path in workspace_root.rglob("package.xml"):
+        # Get relative path from workspace root
+        relative_path = package_xml_path.relative_to(workspace_root)
+        relative_parts = relative_path.parts
+
+        # Skip if any parent directory is hidden (starts with .) or in skip list
+        if any(part.startswith(".") or part in skip_dirs for part in relative_parts):
+            continue
+
+        # Skip if matched by gitignore patterns
+        if gitignore_spec and gitignore_spec.match_file(str(relative_path)):
+            continue
+
+        try:
+            package = PackageXML.from_file(package_xml_path)
+            packages.append(package)
+        except (FileNotFoundError, ValueError) as e:
+            # Log warning but continue
+            print(f"Warning: Could not parse {package_xml_path}: {e}")
+
+    return packages
+
+
+def is_workspace_package(
+    package_name: str, workspace_packages: list[PackageXML]
+) -> bool:
+    """
+    Check if a package name refers to a package in the workspace.
+
+    Args:
+        package_name: Name of the package to check
+        workspace_packages: List of packages in the workspace
+
+    Returns:
+        True if package is in the workspace, False otherwise
+    """
+    workspace_names = {pkg.name for pkg in workspace_packages}
+    return package_name in workspace_names

pixi_ros-0.1.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: pixi-ros
+Version: 0.1.0
+Summary: Pixi extension for ROS package management
+Project-URL: Homepage, https://github.com/ruben-arts/pixi-ros
+Project-URL: Repository, https://github.com/ruben-arts/pixi-ros
+Author-email: Ruben Arts <ruben@prefix.dev>
+Requires-Python: >=3.10
+Requires-Dist: lxml>=5.0.0
+Requires-Dist: pathspec>=0.11.0
+Requires-Dist: py-rattler>=0.6.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tomlkit>=0.12.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+# pixi-ros
+
+**Bridge your ROS workspace to the modern conda/Pixi ecosystem**
+
+pixi-ros helps ROS developers transition from `rosdep` to [Pixi](https://pixi.sh) for package management.
+It automatically reads your ROS workspace's `package.xml` files and generates a `pixi.toml` manifest with all dependencies resolved from conda channels (primarily [robostack](https://robostack.org/)).
+
+## Why pixi-ros?
+
+If you're a ROS developer, you're probably familiar with `rosdep` managing dependencies.
+`pixi-ros` gives you access to a more modern package management ecosystem:
+
+- **Reproducible environments**: Lock files ensure everyone on your team has identical dependencies
+- **Cross-platform**: Works seamlessly on Linux, macOS, and Windows
+- **Fast and reliable**: Uses rattler (Rust implementation of conda) for speed
+- **No system dependencies**: Everything isolated in project environments
+
+## Quick Start
+
+### Installation
+
+Install pixi first if you haven't already:
+
+```bash
+curl -fsSL https://pixi.sh/install.sh | bash
+```
+
+Or follow instructions at https://pixi.sh/latest/installation/
+
+Install pixi-ros globally using pixi:
+
+```bash
+pixi global install pixi-ros
+```
+
+### Initialize Your ROS Workspace
+
+Navigate to your ROS workspace and run:
+
+```bash
+pixi-ros init --distro humble
+```
+
+This will:
+1. Discover all ROS packages in your workspace (by finding `package.xml` files)
+2. Read dependencies from each `package.xml`
+3. Map ROS package names to conda packages
+4. Generate/update `pixi.toml` with proper channels and dependencies
+5. Check package availability and warn about missing packages
+6. Create helpful build/test/clean tasks
+
+### Install and Build
+
+After initialization, use standard pixi commands:
+
+```bash
+# Install all dependencies
+pixi install
+
+# Build your workspace
+pixi run build
+
+# Run tests
+pixi run test
+
+# Activate environment for direct ROS commands
+pixi shell
+```
+
+## How It Works
+
+### Dependency Mapping
+
+`pixi-ros` reads all dependency types from `package.xml` files. 
+It then does a best effort mapping of ROS package names to conda packages.
+
+- **ROS packages**: `ros-{distro}-{package}` from robostack channels (e.g., `ros-humble-rclcpp`)
+- **System packages**: Mapped to conda-forge equivalents (e.g., `cmake`, `eigen`)
+
+After the mapping, it validates package availability in the configured channels. This starts a connection with `https://prefix.dev` to check if packages exist.
+
+### Example
+
+Given a `package.xml` with:
+
+```xml
+<depend>rclcpp</depend>
+<build_depend>ament_cmake</build_depend>
+<exec_depend>std_msgs</exec_depend>
+```
+
+`pixi-ros init --distro humble` generates a `pixi.toml` with:
+
+```toml
+[dependencies]
+ros-humble-ament-cmake = "*"
+ros-humble-rclcpp = "*"
+ros-humble-std-msgs = "*"
+```
+
+## Supported ROS Distributions
+
+- ROS 2 Humble: https://prefix.dev/robostack-humble
+- ROS 2 Iron: https://prefix.dev/robostack-iron
+- ROS 2 Jazzy: https://prefix.dev/robostack-jazzy
+- ROS 2 Rolling: https://prefix.dev/robostack-rolling
+
+## Command Reference
+
+### `pixi-ros init`
+
+Initialize or update a ROS workspace's `pixi.toml`.
+
+```bash
+pixi-ros init --distro <ros_distro>
+pixi-ros init
+```
+
+**Options:**
+- `--distro`, `-d`: ROS distribution (optional)
+
+**What it does:**
+- Scans workspace for `package.xml` files
+- Reads all dependency types (build, exec, test)
+- Maps ROS dependencies to conda packages
+- Configures robostack channels
+- Checks package availability
+- Creates build tasks using colcon
+- Generates helpful `README_PIXI.md`
+
+**Running multiple times:**
+The command is idempotent - you can run it multiple times to update dependencies as your workspace changes.
+
+## Philosophy
+
+`pixi-ros` aims to be a quick **gateway drug**. It:
+
+- Respects existing ROS conventions (package.xml as source of truth)
+- Uses standard ROS build tools (colcon)
+- Focuses only on dependency management and environment setup
+- Doesn't replace `ros2` CLI or other ROS tooling
+- Should eventually become unnecessary as the ecosystem matures
+
+Think of it as a "gateway" to help ROS developers benefit from modern package management while keeping familiar workflows.
+
+## Project Structure
+
+After initialization, your workspace will have:
+
+```
+workspace/
+├── src/                    # Your ROS packages
+│   └── my_package/
+│       ├── package.xml    # ROS package manifest (source of truth)
+│       └── ...
+├── pixi.toml              # Generated pixi manifest
+├── pixi.lock              # Locked dependencies (commit this!)
+└── README_PIXI.md         # Generated usage guide
+```
+
+## Troubleshooting
+
+### Package Not Found
+
+If pixi-ros marks packages as "NOT FOUND":
+
+1. Check if the package exists in robostack: https://prefix.dev/channels/robostack-{distro}
+2. Check for typos in `package.xml`
+3. Some packages may have different names - check mapping files
+4. Consider adding the package to your workspace instead of depending on it
+
+### Different Package Names
+
+pixi-ros includes mapping files for system packages (e.g., `cmake` → `cmake`, `eigen` → `eigen`). You can override mappings by creating `pixi-ros/*.yaml` files in your workspace or `~/.pixi-ros/`.
+
+### Platform-Specific Issues
+
+Some packages have platform-specific mappings. pixi-ros handles this automatically, but you can test different platforms using the internal API with `platform_override`.
+
+## Contributing
+
+Contributions welcome! Feel free to open issues or PRs on GitHub.
+
+## Learn More
+
+- **Pixi**: https://pixi.sh
+- **RoboStack**: https://robostack.org/
+- **Conda**: https://docs.conda.io/
+- **ROS 2**: https://docs.ros.org/
+
+## Disclaimer
+
+This tool is build with heavy use of AI assistance and is under active development. Please report issues or contribute on GitHub!
+
+I (Ruben) hope `pixi-ros` can die ASAP, as all of the workflows this tool provides should ideally be native to Pixi itself. But until then, I hope this initialization tool helps you get started!

pixi_ros-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pixi_ros/__init__.py,sha256=ovhhu7PJry3WtvhA2PgelrFWnWvrQkQKD798sW9GWjs,84
+pixi_ros/cli.py,sha256=eLT1GNfq3JY8yzJrxDkNjeUtKI5T8T_57XaDMw_XX-s,2145
+pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
+pixi_ros/init.py,sha256=Y4k2y_NZOwt0UQ4VMOIWr3Eyg3i2IPU83xtQPd1uW2U,19107
+pixi_ros/mappings.py,sha256=WCo1ftPe8knJROy2NyLuPtk0R-zDGWTgCcQnGp5LkFA,9139
+pixi_ros/package_xml.py,sha256=a1_zJVc73eMOt67BIk2ITnxLPN1RIUOs0oL42q6CLvI,6279
+pixi_ros/utils.py,sha256=uGgB8CYiM_3KfBtqvUKqkEXXTffv8FkkaIC230peHUY,2026
+pixi_ros/workspace.py,sha256=N5Aqcl77J8aLrEDr4T-XR9V5fBjZ1KQHXd4dkbgX8HU,6838
+pixi_ros/data/README.md,sha256=Tdc2sTUuvoyEaHYlmM_C1pf3qr0o0P5Lu2ZUQ88tUjI,1602
+pixi_ros/data/README_PIXI.md.template,sha256=q7g65oHmrEqKTtqOT7lgX6l9RI69w64B0DCLwhf8ocM,3076
+pixi_ros/data/conda-forge.yaml,sha256=O3r31jNNU-lPCgvFlmhytTp_R1UMgIBRwDaeSebI7wI,18900
+pixi_ros-0.1.0.dist-info/METADATA,sha256=L1MyvMRZKUZxx90hlCNgur5k9VDQy3_PBhfJtN2PWVw,6475
+pixi_ros-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pixi_ros-0.1.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
+pixi_ros-0.1.0.dist-info/RECORD,,

pixi_ros-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pixi_ros-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pixi-ros = pixi_ros.cli:main