pixi-ros 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pixi_ros/mappings.py

@@ -103,7 +103,11 @@ def reload_mappings():
 
 
 def map_ros_to_conda(
-    ros_package: str, distro: str = "humble", platform_override: str | None = None
+    ros_package: str,
+    distro: str = "humble",
+    platform_override: str | None = None,
+    validator=None,
+    workspace_packages: set[str] | None = None,
 ) -> list[str]:
     """
     Map a ROS package name to its conda package names.
@@ -116,6 +120,8 @@ def map_ros_to_conda(
         ros_package: The ROS package name (e.g., "rclcpp", "udev", "opengl")
         distro: The ROS distribution (e.g., "humble", "iron", "jazzy")
         platform_override: Override platform detection (for testing)
+        validator: Optional RosDistroValidator instance for validation
+        workspace_packages: Optional set of workspace package names
 
     Returns:
         List of conda package names, which may include placeholder strings
@@ -130,6 +136,30 @@ def map_ros_to_conda(
         >>> map_ros_to_conda("opengl", "humble")  # doctest: +SKIP
         ['REQUIRE_OPENGL']  # placeholder from mapping file
     """
+    # If validator is provided, use full validation logic
+    if validator is not None:
+        mappings = get_mappings()
+        ws_packages = workspace_packages or set()
+
+        # Determine the platform to use for validation
+        if platform_override:
+            # Convert mapping platform to pixi platform for validator
+            mapping_to_pixi = {
+                "linux": "linux-64",
+                "osx": "osx-64",
+                "win64": "win-64",
+            }
+            platform = mapping_to_pixi.get(platform_override, "linux-64")
+        else:
+            # Use current platform
+            platform = str(Platform.current())
+
+        result = validator.validate_package(
+            ros_package, ws_packages, mappings, platform
+        )
+        return result.conda_packages
+
+    # Legacy behavior (backward compatibility)
     mappings = get_mappings()
     current_platform = platform_override or _detect_platform()
 
@@ -257,42 +287,25 @@ def is_system_package(package_name: str) -> bool:
 
 def get_platforms() -> list[str]:
     """
-    Get list of supported pixi platforms based on mapping files.
-
-    Extracts platform names from the mapping data and converts them to
-    standard pixi platform names.
-
-    Mapping files use: linux, osx, win64
-    Pixi uses: linux-64, osx-64, osx-arm64, win-64
+    Get list of supported pixi platforms, including current platform.
 
     Returns:
         List of pixi platform names
     """
-    mappings = get_mappings()
-    mapping_platforms = set()
 
-    # Iterate through mappings to find all platform keys
-    for package_mappings in mappings.values():
-        for channel_mapping in package_mappings.values():
-            if isinstance(channel_mapping, dict):
-                # This is a platform-specific mapping
-                mapping_platforms.update(channel_mapping.keys())
+    # Hardcoded supported platforms, as a hint for the user.
+    pixi_platforms = ["linux-64", "linux-aarch64", "osx-64", "osx-arm64", "win-64"]
 
-    # Convert mapping platforms to pixi platforms
-    pixi_platforms = []
-    if "linux" in mapping_platforms:
-        pixi_platforms.append("linux-64")
-    if "osx" in mapping_platforms:
-        pixi_platforms.extend(["osx-64", "osx-arm64"])
-    if "win64" in mapping_platforms or "win" in mapping_platforms:
-        pixi_platforms.append("win-64")
+    platform_str = str(Platform.current())
+    if not any(platform_str in p for p in pixi_platforms):
+        pixi_platforms.append(platform_str)
 
-    return pixi_platforms if pixi_platforms else ["linux-64", "osx-64", "osx-arm64", "win-64"]
+    return pixi_platforms
 
 
 def get_ros_distros() -> list[str]:
     """
-    Get list of supported ROS distributions.
+    Get list of known ROS distributions.
 
     Returns:
         List of ROS distro names

pixi_ros/package_xml.py

@@ -33,6 +33,11 @@ class PackageXML:
     # Generic depends (shorthand for build, export, and exec)
     depends: list[str] = field(default_factory=list)
 
+    # Version constraints for dependencies
+    # Maps package name to version constraint string
+    # (e.g., ">=3.12.4", ">=1.8.0,<2.0.0")
+    dependency_versions: dict[str, str] = field(default_factory=dict)
+
     @classmethod
     def from_file(cls, path: Path) -> "PackageXML":
         """
@@ -90,6 +95,36 @@ class PackageXML:
                 build_type = build_type_elem.text
 
         # Extract dependencies
+        def parse_version_constraint(elem) -> str | None:
+            """
+            Parse version constraint attributes from a dependency element.
+
+            Converts ROS package.xml version attributes to conda/pixi constraint syntax:
+            - version_lt="X" → <X
+            - version_lte="X" → <=X
+            - version_eq="X" → ==X
+            - version_gte="X" → >=X
+            - version_gt="X" → >X
+
+            Multiple constraints are combined with commas.
+            """
+            constraints = []
+
+            version_attrs = [
+                ("version_lt", "<"),
+                ("version_lte", "<="),
+                ("version_eq", "=="),
+                ("version_gte", ">="),
+                ("version_gt", ">"),
+            ]
+
+            for attr, op in version_attrs:
+                value = elem.get(attr)
+                if value:
+                    constraints.append(f"{op}{value}")
+
+            return ",".join(constraints) if constraints else None
+
         def get_deps(tag: str) -> list[str]:
             """Extract all dependencies with the given tag."""
             deps = []
@@ -98,16 +133,41 @@ class PackageXML:
                     deps.append(elem.text.strip())
             return deps
 
-        # Parse all dependency types
-        buildtool_depends = get_deps("buildtool_depend")
-        build_depends = get_deps("build_depend")
-        build_export_depends = get_deps("build_export_depend")
-        exec_depends = get_deps("exec_depend")
-        test_depends = get_deps("test_depend")
-        depends = get_deps("depend")
+        def get_deps_with_versions(tag: str, version_map: dict[str, str]) -> list[str]:
+            """Extract dependencies and populate version constraints."""
+            deps = []
+            for elem in root.findall(tag):
+                if elem.text:
+                    pkg_name = elem.text.strip()
+                    deps.append(pkg_name)
+
+                    # Parse version constraint if present
+                    constraint = parse_version_constraint(elem)
+                    if constraint:
+                        # If package already has a constraint, combine them
+                        if pkg_name in version_map:
+                            version_map[pkg_name] = (
+                                f"{version_map[pkg_name]},{constraint}"
+                            )
+                        else:
+                            version_map[pkg_name] = constraint
+            return deps
+
+        # Parse all dependency types and collect version constraints
+        dependency_versions: dict[str, str] = {}
+        buildtool_depends = get_deps_with_versions(
+            "buildtool_depend", dependency_versions
+        )
+        build_depends = get_deps_with_versions("build_depend", dependency_versions)
+        build_export_depends = get_deps_with_versions(
+            "build_export_depend", dependency_versions
+        )
+        exec_depends = get_deps_with_versions("exec_depend", dependency_versions)
+        test_depends = get_deps_with_versions("test_depend", dependency_versions)
+        depends = get_deps_with_versions("depend", dependency_versions)
 
         # Format 2 compatibility
-        run_depends = get_deps("run_depend")
+        run_depends = get_deps_with_versions("run_depend", dependency_versions)
 
         return cls(
             name=name_elem.text.strip(),
@@ -126,6 +186,7 @@ class PackageXML:
             test_depends=test_depends,
             run_depends=run_depends,
             depends=depends,
+            dependency_versions=dependency_versions,
         )
 
     def get_all_build_dependencies(self) -> list[str]:

pixi_ros/validator.py

@@ -0,0 +1,245 @@
+"""ROS package validation logic."""
+
+import asyncio
+from dataclasses import dataclass
+from enum import Enum
+
+from rattler import Channel, Gateway, Platform
+from rosdistro import get_cached_distribution, get_index, get_index_url
+
+
+class PackageSource(Enum):
+    """Source of a package."""
+
+    WORKSPACE = "workspace"
+    MAPPING = "mapping"
+    ROS_DISTRO = "ros_distro"
+    CONDA_FORGE = "conda_forge"
+    NOT_FOUND = "not_found"
+
+
+@dataclass
+class PackageValidationResult:
+    """Result of package validation."""
+
+    package_name: str
+    source: PackageSource
+    conda_packages: list[str]
+    error: str | None = None
+
+
+class RosDistroValidator:
+    """Validator for ROS packages using rosdistro."""
+
+    def __init__(self, distro_name: str):
+        """
+        Initialize validator with ROS distribution.
+
+        Args:
+            distro_name: ROS distribution name (e.g., "humble", "jazzy")
+        """
+        self.distro_name = distro_name
+        self._distro = None
+        self._init_error = None
+        self._conda_forge_cache = {}
+
+        try:
+            index = get_index(get_index_url())
+            self._distro = get_cached_distribution(index, distro_name)
+        except Exception as e:
+            self._init_error = str(e)
+
+    def has_package(self, package_name: str) -> bool:
+        """
+        Check if package exists in ROS distribution.
+
+        Args:
+            package_name: ROS package name
+
+        Returns:
+            True if package exists in distribution
+        """
+        if self._distro is None:
+            return False
+        return package_name in self._distro.release_packages
+
+    def check_package_availability(
+        self, package_name: str, platform: str, channel_url: str
+    ) -> bool:
+        """
+        Check if package is available in the specified channel.
+
+        Args:
+            package_name: Conda package name
+            platform: Platform string (e.g., "linux-64", "osx-arm64")
+            channel_url: Channel URL to check (e.g., "https://prefix.dev/conda-forge")
+
+        Returns:
+            True if package is available in the channel
+        """
+        # Check cache first
+        cache_key = (package_name, platform, channel_url)
+        if cache_key in self._conda_forge_cache:
+            return self._conda_forge_cache[cache_key]
+
+        try:
+            gateway = Gateway()
+            channel = Channel(channel_url)
+            platform_obj = Platform(platform)
+            noarch_obj = Platform("noarch")
+
+            # Query with 10 second timeout, check both platform and noarch
+            repo_data = asyncio.wait_for(
+                gateway.query(
+                    [channel],
+                    [platform_obj, noarch_obj],
+                    specs=[package_name],
+                    recursive=False,
+                ),
+                timeout=10.0,
+            )
+
+            # Check if any records match
+            results = asyncio.run(repo_data)
+            for channel_records in results:
+                for record in channel_records:
+                    if record.name.normalized == package_name.lower():
+                        self._conda_forge_cache[cache_key] = True
+                        return True
+
+            self._conda_forge_cache[cache_key] = False
+            return False
+        except (asyncio.TimeoutError, Exception):
+            # On error or timeout, assume not available
+            self._conda_forge_cache[cache_key] = False
+            return False
+
+    def check_conda_forge_availability(self, package_name: str, platform: str) -> bool:
+        """
+        Check if package is available on conda-forge.
+
+        Args:
+            package_name: Conda package name
+            platform: Platform string (e.g., "linux-64", "osx-arm64")
+
+        Returns:
+            True if package is available on conda-forge
+        """
+        return self.check_package_availability(
+            package_name, platform, "https://prefix.dev/conda-forge"
+        )
+
+    def validate_package(
+        self,
+        package_name: str,
+        workspace_packages: set[str],
+        mappings: dict[str, dict[str, list[str] | dict[str, list[str]]]],
+        platform: str = "linux-64",
+    ) -> PackageValidationResult:
+        """
+        Validate a ROS package and determine its source.
+
+        Process:
+        1. Determine source (workspace/mapping/ros_distro/conda_forge/not_found)
+        2. Validate that packages actually exist in their expected channels
+
+        Args:
+            package_name: ROS package name
+            workspace_packages: Set of package names in the workspace
+            mappings: Package mappings from mapping files
+            platform: Target platform (default: "linux-64")
+
+        Returns:
+            PackageValidationResult with source and conda package names
+        """
+        # Step 1: Determine source without validation
+        source = None
+        conda_packages = []
+
+        # 1. Check if it's a workspace package
+        if package_name in workspace_packages:
+            return PackageValidationResult(
+                package_name=package_name,
+                source=PackageSource.WORKSPACE,
+                conda_packages=[],
+            )
+
+        # 2. Check if it's in the mapping file
+        if package_name in mappings:
+            channels = mappings[package_name]
+            if channels:
+                channel_mapping = next(iter(channels.values()))
+                if isinstance(channel_mapping, dict):
+                    # Platform-specific mapping
+                    pixi_to_mapping = {
+                        "linux-64": "linux",
+                        "linux-aarch64": "linux",
+                        "osx-64": "osx",
+                        "osx-arm64": "osx",
+                        "win-64": "win64",
+                    }
+                    mapping_platform = pixi_to_mapping.get(platform, "linux")
+                    packages = channel_mapping.get(mapping_platform, [])
+                    source = PackageSource.MAPPING
+                    conda_packages = packages if packages else []
+                elif isinstance(channel_mapping, list):
+                    source = PackageSource.MAPPING
+                    conda_packages = channel_mapping
+
+        # 3. Check if it's in ROS distro
+        if source is None and self.has_package(package_name):
+            conda_name = package_name.replace("_", "-")
+            source = PackageSource.ROS_DISTRO
+            conda_packages = [f"ros-{self.distro_name}-{conda_name}"]
+
+        # 4. Check if it's available on conda-forge (without ros-distro prefix)
+        if source is None:
+            conda_name = package_name.replace("_", "-")
+            if self.check_conda_forge_availability(conda_name, platform):
+                source = PackageSource.CONDA_FORGE
+                conda_packages = [conda_name]
+
+        # 5. Not found
+        if source is None:
+            print(
+                f"Package '{package_name}' not found in workspace, mappings, "
+                f"ROS distro, or conda-forge."
+            )
+            return PackageValidationResult(
+                package_name=package_name,
+                source=PackageSource.NOT_FOUND,
+                conda_packages=[],
+                error=f"Package '{package_name}' not found in any source",
+            )
+
+        # Step 2: Validate packages exist in their expected channels
+        # Note: We don't validate mapped packages - we trust the mappings
+        if source == PackageSource.ROS_DISTRO:
+            # Validate ROS package exists in robostack channel
+            robostack_channel = f"https://prefix.dev/robostack-{self.distro_name}"
+            ros_conda_name = conda_packages[0]
+
+            if not self.check_package_availability(
+                ros_conda_name, platform, robostack_channel
+            ):
+                print(
+                    f"Package '{package_name}' found in ROS {self.distro_name} "
+                    f"distro index but '{ros_conda_name}' not available in "
+                    f"robostack-{self.distro_name}."
+                )
+                # Keep the conda package name so we can show it in NOT_FOUND
+                return PackageValidationResult(
+                    package_name=package_name,
+                    source=PackageSource.NOT_FOUND,
+                    conda_packages=[ros_conda_name],
+                    error=(
+                        f"ROS package not available in robostack-{self.distro_name}"
+                    ),
+                )
+
+        # Source determined and validated
+        return PackageValidationResult(
+            package_name=package_name,
+            source=source,
+            conda_packages=conda_packages,
+        )

{pixi_ros-0.2.0.dist-info → pixi_ros-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixi-ros
-Version: 0.2.0
+Version: 0.4.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
@@ -13,6 +13,7 @@ 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: rosdistro>=0.9.0
 Requires-Dist: tomlkit>=0.12.0
 Requires-Dist: typer>=0.12.0
 Description-Content-Type: text/markdown
@@ -63,10 +64,16 @@ 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
+3. **Validate and resolve** each dependency using the priority system:
+   - Skip workspace packages (built locally)
+   - Use custom mappings from YAML files
+   - Query ROS distro index for ROS packages
+   - Auto-detect packages on conda-forge
+   - Flag packages that can't be found
 4. Generate/update `pixi.toml` with proper channels and dependencies
-5. Check package availability and warn about missing packages
+5. Check package availability in conda channels for each platform
 6. Create helpful build/test/clean tasks
+7. Display detailed validation results with source information
 
 ### Install and Build
 
@@ -88,26 +95,66 @@ pixi shell
 
 ## How It Works
 
-### Dependency Mapping
+### Dependency Mapping & Validation
 
-`pixi-ros` reads all dependency types from `package.xml` files.
-It then does a best effort mapping of ROS package names to conda packages.
+`pixi-ros` reads all dependency types from `package.xml` files and intelligently resolves them to conda packages using a **priority-based validation system**.
 
-- **ROS packages**: `ros-{distro}-{package}` from robostack channels (e.g., `ros-humble-rclcpp`)
-- **System packages**: Mapped to conda-forge equivalents (e.g., `cmake`, `eigen`)
-- **Platform-specific packages**: Different mappings per platform (e.g., OpenGL → `libgl-devel` on Linux, X11 packages on macOS)
+#### Validation Priority Order
+
+When resolving a ROS package dependency, `pixi-ros` checks sources in this order:
+
+1. **Workspace packages** (local source) → Skipped, won't be added to dependencies
+2. **Mapping files** → Use custom conda package mappings from the embedded mapping.
+3. **ROS distribution** → Query the official ROS distro index for `ros-{distro}-{package}` packages
+4. **conda-forge** (auto-detection) → Search conda-forge for packages without ros-distro prefix
+5. **NOT FOUND** → Mark as unavailable and comment out in `pixi.toml`
+
+#### Package Sources
+
+The dependency tables show where each package comes from:
+
+- **ROS {distro}**: Official ROS distribution packages from robostack (e.g., `ros-humble-rclcpp`)
+- **Mapping**: Custom mappings from YAML files (e.g., `cmake` → `cmake`, `udev` → `libusb + libudev`)
+- **conda-forge**: Auto-detected packages available directly on conda-forge
+- **Workspace**: Local packages in your workspace (skipped from dependencies)
+- **NOT FOUND**: Packages that couldn't be resolved (commented out in `pixi.toml`)
 
 The mapping rules are defined in YAML files (see `src/pixi_ros/data/conda-forge.yaml`) and can be customized by placing your own mapping files in `pixi-ros/*.yaml` or `~/.pixi-ros/*.yaml`.
 
-After the mapping, it validates package availability in the configured channels for each target platform. This starts a connection with `https://prefix.dev` to check if packages exist.
+After dependency resolution, `pixi-ros` validates package availability in the configured channels for each target platform by connecting to `https://prefix.dev`.
+
+### Example Output
 
-### Example
+When you run `pixi-ros init --distro humble`, you'll see validation results:
+
+```
+Found 2 package(s): my_package, other_package
+Initializing ROS humble distribution validator...
+
+╭─────────────────── Package: my_package ───────────────────╮
+│ ROS Dependency │ Type    │ Conda Packages          │ Source       │
+├────────────────┼─────────┼─────────────────────────┼──────────────┤
+│ rclcpp         │ Build   │ ros-humble-rclcpp       │ ROS humble   │
+│ std_msgs       │ Runtime │ ros-humble-std-msgs     │ ROS humble   │
+│ cmake          │ Build   │ cmake                   │ Mapping      │
+│ eigen          │ Build   │ eigen                   │ conda-forge  │
+╰────────────────┴─────────┴─────────────────────────┴──────────────╯
+
+Validation Summary:
+  ✓ 2 workspace packages (skipped)
+  ✓ 1 packages from mappings
+  ✓ 5 packages from ROS humble distro
+  ✓ 1 packages from conda-forge (auto-detected)
+
+  Total external dependencies: 7
+```
 
 Given a `package.xml` with:
 
 ```xml
 <depend>rclcpp</depend>
 <build_depend>ament_cmake</build_depend>
+<build_depend>cmake</build_depend>
 <exec_depend>std_msgs</exec_depend>
 ```
 
@@ -115,17 +162,57 @@ Given a `package.xml` with:
 
 ```toml
 [dependencies]
-ros-humble-ament-cmake = "*"
-ros-humble-rclcpp = "*"
-ros-humble-std-msgs = "*"
+# Base ROS dependencies
+ros-humble-ros-base = "*"
+pkg-config = "*"
+compilers = "*"
+make = "*"
+ninja = "*"
+
+# Build tools
+colcon-common-extensions = "*"
+
+# Workspace dependencies
+cmake = "*"                      # From mapping
+ros-humble-ament-cmake = "*"    # From ROS humble
+ros-humble-rclcpp = "*"         # From ROS humble
+ros-humble-std-msgs = "*"       # From ROS humble
 ```
 
-## Supported ROS Distributions
+### Version Constraints
+
+`pixi-ros` supports version constraints from `package.xml` files and automatically applies them to the generated `pixi.toml`.
+
+#### Supported Version Attributes
 
-- 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
+You can specify version requirements in your `package.xml` using standard ROS version attributes:
+
+| package.xml attribute | pixi.toml constraint | Description |
+|----------------------|----------------------|-------------|
+| `version_eq="X.Y.Z"` | `==X.Y.Z` | Exactly version X.Y.Z |
+| `version_gte="X.Y.Z"` | `>=X.Y.Z` | Version X.Y.Z or newer |
+| `version_gt="X.Y.Z"` | `>X.Y.Z` | Newer than version X.Y.Z |
+| `version_lte="X.Y.Z"` | `<=X.Y.Z` | Version X.Y.Z or older |
+| `version_lt="X.Y.Z"` | `<X.Y.Z` | Older than version X.Y.Z |
+
+Multiple constraints can be combined on the same dependency and will be joined with commas in the output.
+
+Given a `package.xml` with version constraints:
+
+```xml
+<depend version_gte="3.12.4">cmake</depend>
+<build_depend version_gte="3.3.0" version_lt="4.0.0">eigen</build_depend>
+<exec_depend version_eq="1.2.3">boost</exec_depend>
+```
+
+`pixi-ros init` generates:
+
+```toml
+[dependencies]
+cmake = ">=3.12.4"
+eigen = ">=3.3.0,<4.0.0"
+boost = "==1.2.3"
+```
 
 ## Command Reference
 
@@ -147,13 +234,16 @@ pixi-ros init
 
 **What it does:**
 - Scans workspace for `package.xml` files
-- Reads all dependency types (build, exec, test)
+- Reads all dependency types (build, exec, test) and version constraints
+- **Validates dependencies** using the priority-based system (workspace → mapping → ROS distro → conda-forge)
 - Maps ROS dependencies to conda packages for each platform
+- Applies version constraints from package.xml to pixi.toml dependencies
 - Configures robostack channels
 - Checks package availability per platform
 - Creates build tasks using colcon
 - Generates helpful `README_PIXI.md`
 - Sets up platform-specific dependencies in `pixi.toml`
+- **Displays validation results** showing where each dependency was found
 
 **Running multiple times:**
 The command is idempotent - you can run it multiple times to update dependencies as your workspace changes.
@@ -261,12 +351,15 @@ workspace/
 
 ### Package Not Found
 
-If pixi-ros marks packages as "NOT FOUND":
+If pixi-ros marks packages as "NOT FOUND" (shown in red in the validation output):
+
+1. **Check the ROS distro**: Verify the package exists in robostack: https://prefix.dev/channels/robostack-{distro}
+2. **Check for typos**: Review your `package.xml` for spelling errors
+3. **Check conda-forge**: Some packages may be available directly on conda-forge without the `ros-distro-` prefix
+4. **Create a mapping**: Add a custom mapping in `pixi-ros/*.yaml` if the package has a different conda name
+5. **Add to workspace**: Consider including the package source in your workspace instead of depending on it
 
-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
+The validation table shows exactly where each dependency was checked, making it easier to diagnose issues.
 
 ### Different Package Names