pixi-ros 0.3.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,46 +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/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.3.0.dist-info → pixi_ros-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixi-ros
-Version: 0.3.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
+
+When you run `pixi-ros init --distro humble`, you'll see validation results:
 
-### Example
+```
+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,9 +162,21 @@ 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
 ```
 
 ### Version Constraints
@@ -155,13 +214,6 @@ eigen = ">=3.3.0,<4.0.0"
 boost = "==1.2.3"
 ```
 
-## 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`
@@ -183,6 +235,7 @@ pixi-ros init
 **What it does:**
 - Scans workspace for `package.xml` files
 - 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
@@ -190,6 +243,7 @@ pixi-ros init
 - 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.
@@ -297,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
 

pixi_ros-0.4.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pixi_ros/cli.py,sha256=erbuzfPtDxE7q0iIgTGzndsT4xN8GjBxJ4x-WvoEE7A,4938
+pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
+pixi_ros/init.py,sha256=1x1v3xcyJq2oLjA4KQinOgFPjLEtMQMFivi0cWE2ZGI,36804
+pixi_ros/mappings.py,sha256=uTNGNEMUmTYpXeCFi6jJnqMNwoocyMc5p59UcKOH61I,10690
+pixi_ros/package_xml.py,sha256=XnDkKuccSar1ndmvACZMZ7c2yUNXz7CcfQRwluZolqQ,8815
+pixi_ros/utils.py,sha256=uGgB8CYiM_3KfBtqvUKqkEXXTffv8FkkaIC230peHUY,2026
+pixi_ros/validator.py,sha256=ZMIvwHgR7-4l9r_xVMXgLGTQXgCIMKVMR7qDcnU6bLI,8714
+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=AisPkGWbr2WqpNOE3cRUMbYp10AnjaKgH0lJDwCOSJA,19003
+pixi_ros-0.4.0.dist-info/METADATA,sha256=lPcZ0GQJEZMy8uvuiLhyhEkbAC0IVvITFT1uO92dXeE,13877
+pixi_ros-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pixi_ros-0.4.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
+pixi_ros-0.4.0.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
+pixi_ros-0.4.0.dist-info/RECORD,,

pixi_ros-0.3.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pixi_ros/cli.py,sha256=85lRSSsnSWAxqhkwjT0OiObYdTu84YBJXO576k0fOlY,4351
-pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
-pixi_ros/init.py,sha256=wX7VqJFuh0q3OGNZ7_BLVM3BYyTdbI7_BhzHJfJJLIw,30835
-pixi_ros/mappings.py,sha256=AlXT_VsPV7KeEQxHkbBrnc79LXwizrCk7oG9-fYX5MI,10376
-pixi_ros/package_xml.py,sha256=XnDkKuccSar1ndmvACZMZ7c2yUNXz7CcfQRwluZolqQ,8815
-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=DeMfdzEuFCFXLmceV6ENmGpSBo6tMZh-Gx-ZkEAakT8,18941
-pixi_ros-0.3.0.dist-info/METADATA,sha256=fDBOMPyY5DSt4N87s-pugMV0JVCmOOdDU76x8HyND0M,10714
-pixi_ros-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pixi_ros-0.3.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
-pixi_ros-0.3.0.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
-pixi_ros-0.3.0.dist-info/RECORD,,