feat(ros): add dependency specs and ros distro mutex (#367)

Co-authored-by: Daniel Claes <dclaes@smart-robotics.nl>

Author: daenny

backends/pixi-build-ros/pixi.lock

@@ -8,6 +8,7 @@ preview = ["pixi-build"]
 
 [dependencies]
 pydantic = ">=2.8.2,<3"
+py_rattler = ">=0.15.0,<0.16"
 pixi-build-ros = { path = "." }
 
 [environments]
@@ -23,6 +24,7 @@ lint-mypy = "mypy"
 pixi-pycharm = ">=0.0.8,<0.1"
 pytest = "*"
 mypy = ">=1.18.2,<2"
+syrupy = ">=4.9.1,<5"
 types-pyyaml = "*"
 # You can skip this as it's a long build, uncomment this when developing only in this package
 #py-pixi-build-backend = "*"
@@ -55,6 +57,7 @@ python = ">=3.10"
 python = ">=3.10"
 rosdistro = "*"
 pydantic = ">=2.8.2,<3"
+py_rattler = ">=0.15.0,<0.16"
 catkin_pkg = "*"
 pyyaml = "*"
 pixi-build-api-version = ">=2,<3"

backends/pixi-build-ros/pixi.toml

@@ -6,6 +6,7 @@ dependencies = [
   "toml",
   "pyyaml",
   "pydantic",
+  "py_rattler",
   "py-pixi-build-backend",
 ]
 name = "pixi-build-ros"

backends/pixi-build-ros/pyproject.toml

@@ -4,6 +4,8 @@
 from pathlib import Path
 from typing import Any
 
+from pixi_build_ros.distro import Distro
+
 
 def _parse_str_as_abs_path(value: str | Path, manifest_root: Path) -> Path:
     """Parse a string as a Path."""
@@ -57,7 +59,7 @@ class ROSBackendConfig(pydantic.BaseModel, extra="forbid", arbitrary_types_allow
 
     # ROS distribution to use, e.g., "foxy", "galactic", "humble"
     # TODO: This should be figured out in some other way, not from the config.
-    distro: str
+    distro: Distro
 
     noarch: bool | None = None
     # Environment variables to set during the build
@@ -76,6 +78,14 @@ def is_noarch(self) -> bool:
         """Whether to build a noarch package or a platform-specific package."""
         return self.noarch is None or self.noarch
 
+    @pydantic.field_validator("distro", mode="before")
+    @classmethod
+    def _parse_distro(cls, value: str | Distro) -> Distro:
+        """Parse a distro string."""
+        if isinstance(value, str):
+            return Distro(value)
+        return value
+
     @pydantic.field_validator("debug_dir", mode="before")
     @classmethod
     def _parse_debug_dir(cls, value: Any, info: pydantic.ValidationInfo) -> Path | None:

backends/pixi-build-ros/src/pixi_build_ros/config.py

@@ -22,6 +22,10 @@ def name(self) -> str:
     def check_ros1(self) -> bool:
         return self._distribution_type == "ros1"
 
+    @property
+    def ros_distro_mutex_name(self) -> str:
+        return f"ros{'' if self.check_ros1() else '2'}-distro-mutex"
+
     def get_python_version(self) -> str:
         return self._python_version
 

backends/pixi-build-ros/src/pixi_build_ros/distro.py

@@ -3,7 +3,6 @@
 """
 
 from pixi_build_backend.types import MetadataProvider
-from pixi_build_ros.distro import Distro
 
 
 class MaintainerInfo:
@@ -30,6 +29,7 @@ def __init__(
         self.name = name
         self.version = version
         self.description = description
+        # TODO: this is currently unused
         self.maintainers = maintainers or []
         self.licenses = licenses or []
         self.homepage = homepage
@@ -91,10 +91,10 @@ def _package_xml_data(self) -> PackageData:
             repository = None
             for url in root.findall("url"):
                 url_type = url.get("type", "")
-                if url_type == "website" and not homepage:
-                    homepage = url.text.strip() if url.text else None
-                elif url_type == "repository" and not repository:
+                if url_type == "repository" and not repository:
                     repository = url.text.strip() if url.text else None
+                if url_type == "website" or not homepage:
+                    homepage = url.text.strip() if url.text else None
 
             self._package_data = PackageData(
                 name=name_elem.text.strip() if name_elem is not None and name_elem.text else None,
@@ -128,13 +128,16 @@ def homepage(self) -> str | None:
 
     def license(self) -> str | None:
         """Return the license from package.xml."""
-        # TODO: Handle License parsing to conform to SPDX standards,
         # ROS package.xml does not enforce SPDX as strictly as rattler-build
+        # So use LicenseRef for now
+        if len(self._package_xml_data.licenses) == 1:
+            return f"LicenseRef-{self._package_xml_data.licenses[0]}"
+        # TODO: Handle License parsing to conform to SPDX standards,
         return None
 
     def license_file(self) -> str | None:
-        """Return None as package.xml doesn't typically specify license files."""
-        return None
+        """Return package.xml as the license files."""
+        return "package.xml"
 
     def summary(self) -> str | None:
         """Return the description as summary from package.xml."""
@@ -169,7 +172,7 @@ class ROSPackageXmlMetadataProvider(PackageXmlMetadataProvider):
     as 'ros-<distro>-<package_name>' according to ROS conda packaging conventions.
     """
 
-    def __init__(self, package_xml_path: str, distro: Distro | None = None):
+    def __init__(self, package_xml_path: str, distro_name: str | None = None):
         """
         Initialize the ROS metadata provider.
 
@@ -178,20 +181,16 @@ def __init__(self, package_xml_path: str, distro: Distro | None = None):
             distro: ROS distro. If None, will use the base package name without distro prefix.
         """
         super().__init__(package_xml_path)
-        self._distro: Distro | None = distro
-
-    def _get_distro(self) -> Distro | None:
-        return self._distro
+        self._distro_name: str | None = distro_name
 
     def name(self) -> str | None:
         """Return the ROS-formatted package name (ros-<distro>-<name>)."""
         base_name = super().name()
         if base_name is None:
             return None
 
-        distro = self._get_distro()
-        if distro:
+        if self._distro_name:
             # Convert underscores to hyphens per ROS conda naming conventions
             formatted_name = base_name.replace("_", "-")
-            return f"ros-{distro.name}-{formatted_name}"
+            return f"ros-{self._distro_name}-{formatted_name}"
         return base_name

backends/pixi-build-ros/src/pixi_build_ros/metadata_provider.py

@@ -13,13 +13,12 @@
 from .metadata_provider import ROSPackageXmlMetadataProvider
 from pixi_build_backend.types.intermediate_recipe import Script, ConditionalRequirements
 
-from pixi_build_backend.types.item import ItemPackageDependency
+from pixi_build_backend.types.item import ItemPackageDependency, VecItemPackageDependency
 from pixi_build_backend.types.platform import Platform
 from pixi_build_backend.types.project_model import ProjectModelV1
 from pixi_build_backend.types.python_params import PythonParams
 
 from .build_script import BuildScriptContext, BuildPlatform
-from .distro import Distro
 from .utils import (
     get_build_input_globs,
     package_xml_to_conda_requirements,
@@ -46,13 +45,9 @@ def generate_recipe(
         backend_config: ROSBackendConfig = ROSBackendConfig.model_validate(
             config, context={"manifest_root": manifest_root}
         )
-
-        # Setup ROS distro first
-        distro = Distro(backend_config.distro)
-
         # Create metadata provider for package.xml
         package_xml_path = manifest_root / "package.xml"
-        metadata_provider = ROSPackageXmlMetadataProvider(str(package_xml_path), distro)
+        metadata_provider = ROSPackageXmlMetadataProvider(str(package_xml_path), backend_config.distro.name)
 
         # Create base recipe from model with metadata provider
         generated_recipe = GeneratedRecipe.from_model(model, metadata_provider)
@@ -75,7 +70,9 @@ def generate_recipe(
         )
 
         # Get requirements from package.xml
-        package_requirements = package_xml_to_conda_requirements(package_xml, distro, host_platform, package_map_data)
+        package_requirements = package_xml_to_conda_requirements(
+            package_xml, backend_config.distro, host_platform, package_map_data
+        )
 
         # Add standard dependencies
         build_deps = [
@@ -106,6 +103,10 @@ def generate_recipe(
         for dep in host_deps:
             package_requirements.host.append(ItemPackageDependency(name=dep))
 
+        # add a simple default host and run dependency on the ros{2}-distro-mutex
+        package_requirements.host.append(ItemPackageDependency(name=backend_config.distro.ros_distro_mutex_name))
+        package_requirements.run.append(ItemPackageDependency(name=backend_config.distro.ros_distro_mutex_name))
+
         # Merge package requirements into the model requirements
         requirements = merge_requirements(generated_recipe.recipe.requirements, package_requirements)
         generated_recipe.recipe.requirements = requirements
@@ -114,7 +115,9 @@ def generate_recipe(
         build_platform = BuildPlatform.current()
 
         # Generate build script
-        build_script_context = BuildScriptContext.load_from_template(package_xml, build_platform, manifest_root, distro)
+        build_script_context = BuildScriptContext.load_from_template(
+            package_xml, build_platform, manifest_root, backend_config.distro
+        )
         build_script_lines = build_script_context.render()
 
         generated_recipe.recipe.build.script = Script(
@@ -156,27 +159,60 @@ def merge_requirements(
     """Merge two sets of requirements."""
     merged = ConditionalRequirements()
 
-    # The model requirements are the base, coming from the pixi manifest
-    # We need to only add the names for non-existing dependencies
-    def merge_unique_items(
-        model: list[ItemPackageDependency],
-        package: list[ItemPackageDependency],
-    ) -> list[ItemPackageDependency]:
-        """Merge unique items from source into target."""
-        result = model
-
-        for item in package:
-            package_names = [i.concrete.package_name for i in model if i.concrete]
-
-            if item.concrete is not None and item.concrete.package_name not in package_names:
-                result.append(item)
-            if str(item.template) not in [str(i.template) for i in model]:
-                result.append(item)
-        return result
-
     merged.host = merge_unique_items(model_requirements.host, package_requirements.host)
     merged.build = merge_unique_items(model_requirements.build, package_requirements.build)
     merged.run = merge_unique_items(model_requirements.run, package_requirements.run)
 
     # If the dependency is of type Source in one of the requirements, we need to set them to Source for all variants
     return merged
+
+
+def merge_unique_items(
+    model: list[ItemPackageDependency] | VecItemPackageDependency,
+    package: list[ItemPackageDependency] | VecItemPackageDependency,
+) -> list[ItemPackageDependency]:
+    """Merge unique items from source into target."""
+
+    def _find_matching(list_to_find: list[ItemPackageDependency], name: str) -> ItemPackageDependency | None:
+        for dep in list_to_find:
+            if dep.concrete.package_name == name:
+                return dep
+        else:
+            return None
+
+    def _merge_specs(spec1: str, spec2: str, package_name: str) -> str:
+        # remove the package name
+        version_spec1 = spec1.removeprefix(package_name).strip()
+        version_spec2 = spec2.removeprefix(package_name).strip()
+
+        if " " in version_spec1 or " " in version_spec2:
+            raise ValueError(f"{version_spec1}, or {version_spec2} contains spaces, cannot merge specifiers.")
+
+        # early out with *, empty or ==
+        if version_spec1 in ["*", ""] or "==" in version_spec2 or version_spec1 == version_spec2:
+            return spec2
+        if version_spec2 in ["*", ""] or "==" in version_spec1:
+            return spec1
+        return package_name + " " + ",".join([version_spec1, version_spec2])
+
+    result: list[ItemPackageDependency] = []
+    templates_in_model = [str(i.template) for i in model]
+    for item in list(model) + list(package):
+        # It's concrete (i.e. no template)
+        if item.concrete is not None:
+            # It does not exist yet in model
+            item_in_result = _find_matching(result, item.concrete.package_name)
+            if not item_in_result:
+                result.append(item)
+            else:
+                new_dep = ItemPackageDependency(
+                    name=_merge_specs(
+                        item_in_result.concrete.binary_spec, item.concrete.binary_spec, item.concrete.package_name
+                    )
+                )
+                result.remove(item_in_result)
+                result.append(new_dep)
+
+        elif str(item.template) not in templates_in_model:
+            result.append(item)
+    return result