pixi-ros 0.1.0__py3-none-any.whl

pixi_ros/mappings.py

@@ -0,0 +1,298 @@
+"""Mapping between ROS package names and conda package names."""
+
+from functools import lru_cache
+from pathlib import Path
+
+import yaml
+from rattler import Platform
+
+
+def _detect_platform() -> str:
+    """
+    Detect the current platform using rattler.
+
+    Returns:
+        Platform name: 'linux', 'osx', 'win64', etc.
+    """
+    current_platform = Platform.current()
+    platform_str = str(current_platform)
+
+    # Map rattler platform names to ROS platform names
+    if platform_str.startswith("osx"):
+        return "osx"
+    elif platform_str.startswith("win"):
+        return "win64"
+    elif platform_str.startswith("linux"):
+        return "linux"
+    else:
+        # Default to linux for unknown platforms
+        return "linux"
+
+
+@lru_cache(maxsize=1)
+def _load_channel_mappings() -> dict[str, dict[str, list[str] | dict[str, list[str]]]]:
+    """
+    Load ROS to conda package mappings from channel.yaml files.
+
+    The new format is:
+    ```yaml
+    package_name:
+      channel_name:
+        - simple_mapping
+      other_channel:
+        linux: [pkg1, pkg2]
+        osx: [pkg3]
+        win64: []
+    ```
+
+    Searches for *.yaml files in the following order:
+    1. Current workspace directory (./pixi-ros/*.yaml)
+    2. User config directory (~/.pixi-ros/*.yaml)
+    3. Built-in defaults (packaged with pixi-ros)
+
+    Returns:
+        Dictionary mapping ROS package names to channel/platform mappings
+    """
+    mappings: dict[str, dict[str, list[str] | dict[str, list[str]]]] = {}
+
+    # Search locations in priority order
+    search_dirs = [
+        Path.cwd() / "pixi-ros",
+        Path.home() / ".pixi-ros",
+        Path(__file__).parent / "data",
+    ]
+
+    for search_dir in search_dirs:
+        if not search_dir.exists():
+            continue
+
+        # Load all .yaml files in the directory
+        for yaml_file in search_dir.glob("*.yaml"):
+            try:
+                with open(yaml_file) as f:
+                    data = yaml.safe_load(f)
+                    if data:
+                        # Merge mappings, with earlier directories taking priority
+                        for package, channels in data.items():
+                            if package not in mappings:
+                                mappings[package] = channels
+            except Exception:
+                # Skip files that fail to parse
+                continue
+
+    return mappings
+
+
+def get_mappings() -> dict[str, dict[str, list[str] | dict[str, list[str]]]]:
+    """
+    Get the current ROS to conda package mappings.
+
+    Returns:
+        Dictionary mapping ROS package names to channel/platform mappings
+    """
+    return _load_channel_mappings()
+
+
+def reload_mappings():
+    """
+    Clear the cached mappings and force reload.
+
+    Useful for testing or when mapping files have been updated.
+    """
+    _load_channel_mappings.cache_clear()
+
+
+def map_ros_to_conda(
+    ros_package: str, distro: str = "humble", platform_override: str | None = None
+) -> list[str]:
+    """
+    Map a ROS package name to its conda package names.
+
+    Note: The returned list may contain special placeholders like REQUIRE_GL
+    or REQUIRE_OPENGL (from the mapping files). These should be expanded
+    using expand_gl_requirements().
+
+    Args:
+        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)
+
+    Returns:
+        List of conda package names, which may include placeholder strings
+        like REQUIRE_GL or REQUIRE_OPENGL that need expansion
+        (e.g., ["ros-humble-rclcpp"], ["libusb", "libudev"], or ["REQUIRE_OPENGL"])
+
+    Examples:
+        >>> map_ros_to_conda("udev", "humble")  # doctest: +SKIP
+        ['libusb', 'libudev']  # on linux
+        >>> map_ros_to_conda("uncrustify", "humble")
+        ['uncrustify']
+        >>> map_ros_to_conda("opengl", "humble")  # doctest: +SKIP
+        ['REQUIRE_OPENGL']  # placeholder from mapping file
+    """
+    mappings = get_mappings()
+    current_platform = platform_override or _detect_platform()
+
+    # Check if we have a mapping for this package
+    if ros_package in mappings:
+        channels = mappings[ros_package]
+
+        # Get the first channel's mapping (usually "pixi")
+        if channels:
+            # Take the first channel
+            channel_mapping = next(iter(channels.values()))
+
+            # Check if it's platform-specific or a simple list
+            if isinstance(channel_mapping, dict):
+                # Platform-specific mapping
+                packages = channel_mapping.get(current_platform, [])
+                return packages if packages else []
+            elif isinstance(channel_mapping, list):
+                # Simple list mapping
+                return channel_mapping
+
+    # Default mapping: convert underscores to dashes and prepend ros-distro
+    # This follows the robostack convention
+    conda_name = ros_package.replace("_", "-")
+    return [f"ros-{distro}-{conda_name}"]
+
+
+def expand_gl_requirements(
+    conda_packages: list[str], platform_override: str | None = None
+) -> list[str]:
+    """
+    Process special GL requirements in a list of conda packages.
+
+    Replaces REQUIRE_GL and REQUIRE_OPENGL placeholders with actual
+    platform-specific conda packages.
+
+    This is a duplication of the code in:
+    https://github.com/RoboStack/vinca/blob/7d3a05e01d6898201a66ba2cf6ea771250671f58/vinca/main.py#L562
+
+    Args:
+        conda_packages: List of conda package names (may contain REQUIRE_(OPEN)GL)
+        platform_override: Override platform detection (for testing)
+
+    Returns:
+        List of conda packages with GL requirements expanded
+
+    Examples:
+        >>> expand_gl_requirements(["cmake", "REQUIRE_GL"], platform_override="linux")
+        ['cmake', 'libgl-devel']
+        >>> expand_gl_requirements(["REQUIRE_GL"], platform_override="osx")
+        []
+    """
+    current_platform = platform_override or _detect_platform()
+    result = []
+    additional_packages = []
+
+    for pkg in conda_packages:
+        if pkg == "REQUIRE_GL":
+            # Replace REQUIRE_GL with platform-specific packages
+            if current_platform == "linux":
+                additional_packages.append("libgl-devel")
+            # On other platforms, just remove it (add nothing)
+        elif pkg == "REQUIRE_OPENGL":
+            # Replace REQUIRE_OPENGL with platform-specific packages
+            if current_platform == "linux":
+                # TODO: this should only go into the host dependencies
+                additional_packages.extend(["libgl-devel", "libopengl-devel"])
+            if current_platform in ["linux", "osx"]:
+                # TODO: force this into the run dependencies
+                additional_packages.extend(["xorg-libx11", "xorg-libxext"])
+            # On windows, just remove it (add nothing)
+        else:
+            # Regular package, keep it
+            result.append(pkg)
+
+    # Add the additional packages and deduplicate
+    result.extend(additional_packages)
+
+    # Remove duplicates while preserving order
+    seen = set()
+    deduplicated = []
+    for pkg in result:
+        if pkg not in seen:
+            seen.add(pkg)
+            deduplicated.append(pkg)
+
+    return deduplicated
+
+
+def is_system_package(package_name: str) -> bool:
+    """
+    Check if a package is a system/tool package rather than a ROS package.
+
+    System packages are those that have explicit mappings and don't use
+    the ros-distro prefix.
+
+    Args:
+        package_name: The package name to check
+
+    Returns:
+        True if it's a system package, False otherwise
+
+    Examples:
+        >>> is_system_package("cmake")
+        True
+        >>> is_system_package("rclcpp")
+        False
+    """
+    mappings = get_mappings()
+
+    # If package is in mappings, it's a system package
+    # (ROS packages without mappings will get ros-{distro}- prefix in fallback)
+    if package_name in mappings:
+        return True
+
+    # Known system packages not in mapping files
+    system_packages = {
+        "cmake",
+        "git",
+        "python",
+        "python3",
+    }
+    return package_name in system_packages
+
+
+def get_ros_distros() -> list[str]:
+    """
+    Get list of supported ROS distributions.
+
+    Returns:
+        List of ROS distro names
+    """
+    return ["foxy", "humble", "jazzy", "kilted"]
+
+
+def validate_distro(distro: str) -> bool:
+    """
+    Check if a ROS distro is supported.
+
+    Args:
+        distro: The ROS distribution name
+
+    Returns:
+        True if supported, False otherwise
+    """
+    return distro in get_ros_distros()
+
+
+def get_mapping_files_dir() -> Path:
+    """
+    Get the directory containing the currently active mapping files.
+
+    Returns:
+        Path to directory containing channel.yaml files
+    """
+    search_dirs = [
+        Path.cwd() / "pixi-ros",
+        Path.home() / ".pixi-ros",
+    ]
+
+    for search_dir in search_dirs:
+        if search_dir.exists() and any(search_dir.glob("*.yaml")):
+            return search_dir
+
+    # Return built-in default path
+    return Path(__file__).parent / "data"

pixi_ros/package_xml.py

@@ -0,0 +1,183 @@
+"""Parser for ROS package.xml files."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lxml import etree
+
+
+@dataclass
+class PackageXML:
+    """Represents a parsed ROS package.xml file."""
+
+    name: str
+    version: str
+    description: str
+    maintainer: str
+    maintainer_email: str
+    license: str
+    format_version: int
+    build_type: str | None = None
+    path: Path | None = None  # Path to the package.xml file
+
+    # Different dependency categories
+    buildtool_depends: list[str] = field(default_factory=list)
+    build_depends: list[str] = field(default_factory=list)
+    build_export_depends: list[str] = field(default_factory=list)
+    exec_depends: list[str] = field(default_factory=list)
+    test_depends: list[str] = field(default_factory=list)
+
+    # Format 2 compatibility (run_depend)
+    run_depends: list[str] = field(default_factory=list)
+
+    # Generic depends (shorthand for build, export, and exec)
+    depends: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_file(cls, path: Path) -> "PackageXML":
+        """
+        Parse a package.xml file.
+
+        Args:
+            path: Path to the package.xml file
+
+        Returns:
+            PackageXML object with parsed data
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            ValueError: If the XML is malformed or missing required fields
+        """
+        if not path.exists():
+            raise FileNotFoundError(f"package.xml not found at {path}")
+
+        try:
+            tree = etree.parse(str(path))
+            root = tree.getroot()
+        except etree.XMLSyntaxError as e:
+            raise ValueError(f"Invalid XML in {path}: {e}") from e
+
+        # Get format version (defaults to 1 if not specified)
+        format_version = int(root.get("format", "1"))
+
+        # Extract required fields
+        name_elem = root.find("name")
+        version_elem = root.find("version")
+        description_elem = root.find("description")
+        maintainer_elem = root.find("maintainer")
+        license_elem = root.find("license")
+
+        if name_elem is None or name_elem.text is None:
+            raise ValueError(f"Missing required 'name' field in {path}")
+        if version_elem is None or version_elem.text is None:
+            raise ValueError(f"Missing required 'version' field in {path}")
+        if description_elem is None or description_elem.text is None:
+            raise ValueError(f"Missing required 'description' field in {path}")
+        if maintainer_elem is None or maintainer_elem.text is None:
+            raise ValueError(f"Missing required 'maintainer' field in {path}")
+        if license_elem is None or license_elem.text is None:
+            raise ValueError(f"Missing required 'license' field in {path}")
+
+        # Extract maintainer email
+        maintainer_email = maintainer_elem.get("email", "")
+
+        # Extract build type from export section
+        build_type = None
+        export_elem = root.find("export")
+        if export_elem is not None:
+            build_type_elem = export_elem.find("build_type")
+            if build_type_elem is not None and build_type_elem.text:
+                build_type = build_type_elem.text
+
+        # Extract dependencies
+        def get_deps(tag: str) -> list[str]:
+            """Extract all dependencies with the given tag."""
+            deps = []
+            for elem in root.findall(tag):
+                if elem.text:
+                    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")
+
+        # Format 2 compatibility
+        run_depends = get_deps("run_depend")
+
+        return cls(
+            name=name_elem.text.strip(),
+            version=version_elem.text.strip(),
+            description=description_elem.text.strip(),
+            maintainer=maintainer_elem.text.strip(),
+            maintainer_email=maintainer_email,
+            license=license_elem.text.strip(),
+            format_version=format_version,
+            build_type=build_type,
+            path=path,
+            buildtool_depends=buildtool_depends,
+            build_depends=build_depends,
+            build_export_depends=build_export_depends,
+            exec_depends=exec_depends,
+            test_depends=test_depends,
+            run_depends=run_depends,
+            depends=depends,
+        )
+
+    def get_all_build_dependencies(self) -> list[str]:
+        """
+        Get all dependencies needed at build time.
+
+        Returns:
+            Combined list of buildtool, build, and generic depends
+        """
+        deps = set()
+        deps.update(self.buildtool_depends)
+        deps.update(self.build_depends)
+        deps.update(self.depends)
+        return sorted(deps)
+
+    def get_all_runtime_dependencies(self) -> list[str]:
+        """
+        Get all dependencies needed at runtime.
+
+        Handles both format 2 (run_depend) and format 3 (exec_depend).
+
+        Returns:
+            Combined list of exec, run, and generic depends
+        """
+        deps = set()
+        deps.update(self.exec_depends)
+        deps.update(self.run_depends)  # Format 2 compatibility
+        deps.update(self.depends)
+        return sorted(deps)
+
+    def get_all_test_dependencies(self) -> list[str]:
+        """
+        Get all dependencies needed for testing.
+
+        Returns:
+            List of test depends
+        """
+        return sorted(set(self.test_depends))
+
+    def get_all_dependencies(self) -> list[str]:
+        """
+        Get all unique dependencies across all categories.
+
+        Returns:
+            Combined, deduplicated list of all dependencies
+        """
+        deps = set()
+        deps.update(self.buildtool_depends)
+        deps.update(self.build_depends)
+        deps.update(self.build_export_depends)
+        deps.update(self.exec_depends)
+        deps.update(self.run_depends)
+        deps.update(self.depends)
+        deps.update(self.test_depends)
+        return sorted(deps)

pixi_ros/utils.py

@@ -0,0 +1,80 @@
+"""Shared utility functions for pixi-ros."""
+
+import re
+from pathlib import Path
+
+from rattler import Version, VersionSpec
+
+
+def detect_cmake_version_requirement(package_path: Path) -> str | None:
+    """
+    Detect cmake version requirement from CMakeLists.txt.
+
+    Args:
+        package_path: Path to the package directory
+
+    Returns:
+        Version constraint for cmake, or None if not applicable
+    """
+    cmake_file = package_path / "CMakeLists.txt"
+    if not cmake_file.exists():
+        return None
+
+    try:
+        content = cmake_file.read_text()
+        # Look for cmake_minimum_required(VERSION x.y)
+        match = re.search(
+            r"cmake_minimum_required\s*\(\s*VERSION\s+([\d.]+)",
+            content,
+            re.IGNORECASE,
+        )
+        if match:
+            version_str = match.group(1)
+            # Parse the detected version
+            detected_version = Version(version_str)
+
+            # Check if version is less than 3.10
+            threshold_spec = VersionSpec("<3.10")
+            if threshold_spec.matches(detected_version):
+                # CMake versions < 3.10 require cmake <4
+                return "<4"
+
+    except Exception:
+        # If we can't read or parse the file, skip it
+        pass
+
+    return None
+
+
+def is_valid_ros_package_name(name: str) -> bool:
+    """
+    Check if a package name follows ROS naming conventions.
+
+    ROS package names should:
+    - Only contain lowercase letters, numbers, and underscores
+    - Start with a letter
+    - Not contain consecutive underscores
+
+    Args:
+        name: Package name to validate
+
+    Returns:
+        True if name is valid, False otherwise
+    """
+    if not name:
+        return False
+
+    # Must start with a letter
+    if not name[0].isalpha():
+        return False
+
+    # Check each character
+    for char in name:
+        if not (char.islower() or char.isdigit() or char == "_"):
+            return False
+
+    # No consecutive underscores
+    if "__" in name:
+        return False
+
+    return True