feat: add automatic ROS distro detection from robostack channels (#425)

Author: ruben-arts

.github/workflows/ros-build.yml

@@ -35,12 +35,11 @@ jobs:
       - uses: prefix-dev/setup-pixi@28eb668aafebd9dede9d97c4ba1cd9989a4d0004 # v0.9.2
         with:
           manifest-path: backends/pixi-build-ros/pixi.toml
-          environments: test
       - name: Run mypy
         run: |
           cd backends/pixi-build-ros
-          pixi run -e test lint-mypy
+          pixi run lint
       - name: Run tests
         run: |
           cd backends/pixi-build-ros
-          pixi run -e test test --color=yes
+          pixi run test --color=yes

backends/pixi-build-ros/pixi.toml

@@ -9,6 +9,9 @@ preview = ["pixi-build"]
 [activation.env]
 CARGO_TARGET_DIR = "target/pixi"
 
+[tasks]
+lint.depends-on = ["fmt", "lint-ruff", "lint-mypy"]
+
 [target.linux-64.dependencies]
 clang = ">=21.1,<21.2"
 mold = ">=2.33.0,<3.0"

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

@@ -1,9 +1,11 @@
 import os
-import pydantic
-import yaml
+import re
 from pathlib import Path
 from typing import Any
 
+import pydantic
+import yaml
+
 from pixi_build_ros.distro import Distro
 
 
@@ -19,6 +21,34 @@ def _parse_str_as_abs_path(value: str | Path, manifest_root: Path) -> Path:
     return value
 
 
+def _extract_distro_from_channels_list(channels: list[str] | None) -> str | None:
+    """Extract ROS distro from a list of channel URLs/names.
+
+    Looks for channels matching the pattern 'robostack-<distro>' and returns
+    the first distro found.
+
+    Args:
+        channels: List of channel URLs or names
+
+    Returns:
+        The distro name if found, None otherwise
+    """
+    if not channels:
+        return None
+
+    # Pattern to match robostack-<distro> in channel URLs or names
+    robostack_pattern = re.compile(r".?robostack-(?!staging\b)(\w+)")
+
+    for channel in channels:
+        # Extract the last path component or the whole channel name if it's not a URL
+        # This handles both "robostack-humble" and "https://prefix.dev/robostack-humble"
+        channel_name = channel.rstrip("/").split("/")[-1]
+        match = robostack_pattern.search(channel_name)
+        if match:
+            return match.group(1)
+    return None
+
+
 PackageMapEntry = dict[str, list[str] | dict[str, list[str]]]
 
 
@@ -64,8 +94,8 @@ class ROSBackendConfig(pydantic.BaseModel, extra="forbid", arbitrary_types_allow
     """ROS backend configuration."""
 
     # ROS distribution to use, e.g., "foxy", "galactic", "humble"
-    # TODO: This should be figured out in some other way, not from the config.
-    distro: Distro
+    # Can be auto-detected from robostack- channel if not explicitly specified
+    distro_: Distro | None = pydantic.Field(default=None, alias="distro")
 
     noarch: bool | None = None
     # Environment variables to set during the build
@@ -94,13 +124,62 @@ def get_package_mapping_file_paths(self) -> list[Path]:
                 file_paths.append(source_file)
         return file_paths
 
-    @pydantic.field_validator("distro", mode="before")
+    @pydantic.field_validator("distro_", mode="before")
     @classmethod
-    def _parse_distro(cls, value: str | Distro) -> Distro:
+    def _parse_distro(cls, value: Any) -> Distro | None:
         """Parse a distro string."""
         if isinstance(value, str):
             return Distro(value)
-        return value
+        if isinstance(value, Distro):
+            return value
+        return None
+
+    def resolve_distro(
+        self,
+        channels: list[str] | None = None,
+    ) -> "ROSBackendConfig":
+        """Resolve the distro field, auto-detecting from channels if not explicitly set.
+
+        This should be called after config validation to fill in the distro if needed.
+
+        Args:
+            config: The config instance (possibly with distro=None)
+            channels: List of channel URLs from the build system
+
+        Returns:
+            Config with distro resolved
+
+        Raises:
+            ValueError: If distro cannot be determined
+        """
+        # If distro is already set, nothing to do
+        if self.distro_:
+            return self
+
+        # Try to auto-detect from channels
+        detected_distro_name = None
+        if channels:
+            detected_distro_name = _extract_distro_from_channels_list(channels)
+
+        if detected_distro_name:
+            self.distro_ = Distro(detected_distro_name)
+            return self
+
+        # If we couldn't detect a distro, raise an error
+        raise ValueError(
+            "ROS distro must be either explicitly configured or auto-detected from robostack channels."
+            f"A 'robostack-<distro>' channel (e.g. 'robostack-kilted') was not found in the provided channels: {channels}."
+        )
+
+    @pydantic.model_validator(mode="after")
+    def _ensure_distro(
+        self,
+        info: pydantic.ValidationInfo,
+    ) -> "ROSBackendConfig":
+        """Ensure distro is resolved after validation."""
+        context = info.context or {}
+        channels = context.get("channels")
+        return self.resolve_distro(channels=channels)
 
     @pydantic.field_validator("debug_dir", mode="before")
     @classmethod
@@ -121,6 +200,8 @@ def _parse_package_mappings(
         """Parse additional package mappings if set."""
         if input_value is None:
             return []
+
+        base_path = Path.cwd()
         if info.context and "manifest_root" in info.context:
             base_path = Path(info.context["manifest_root"])
 
@@ -139,11 +220,17 @@ def _parse_package_mappings(
                     entry = PackageMappingSource.from_mapping(mapping_value)
                 else:
                     entry = PackageMappingSource.from_mapping(raw_entry)
-            elif isinstance(raw_entry, str | Path):
+            elif isinstance(raw_entry, (str, Path)):
                 entry = PackageMappingSource.from_file(_parse_str_as_abs_path(raw_entry, base_path))
             else:
                 raise ValueError(
                     f"Unrecognized entry for extra-package-mappings: {raw_entry} of type {type(raw_entry)}."
                 )
             result.append(entry)
         return result
+
+    @property
+    def distro(self) -> Distro:
+        if not self.distro_:
+            raise ValueError("Distro could not be resolved from the channels or the `distro` build config.")
+        return self.distro_

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

@@ -42,12 +42,23 @@ def generate_recipe(
         manifest_path: str,
         host_platform: Platform,
         _python_params: PythonParams | None = None,
+        channels: list[str] | None = None,
     ) -> GeneratedRecipe:
         """Generate a recipe for a Python package."""
         manifest_root = Path(manifest_path)
         backend_config: ROSBackendConfig = ROSBackendConfig.model_validate(
-            config, context={"manifest_root": manifest_root}
+            config,
+            context={
+                "manifest_root": manifest_root,
+                "channels": channels,
+            },
         )
+        # Resolve distro after validation, using channels from build system
+        backend_config = ROSBackendConfig.resolve_distro(
+            backend_config,
+            channels=channels,
+        )
+
         # Create metadata provider for package.xml
         package_xml_path = manifest_root / "package.xml"
         # Get package mapping file paths to include in input globs

backends/pixi-build-ros/tests/test_distro_detection.py

@@ -0,0 +1,96 @@
+"""Tests for automatic distro detection from robostack channels."""
+
+import pytest
+
+from pixi_build_ros.config import ROSBackendConfig, _extract_distro_from_channels_list
+
+
+def test_extract_distro_from_full_url():
+    """Test extracting distro from full robostack URL."""
+    channels = [
+        "https://prefix.dev/pixi-build-backends",
+        "https://prefix.dev/robostack-jazzy",
+        "https://prefix.dev/conda-forge",
+    ]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro == "jazzy"
+
+
+def test_extract_distro_from_short_channel_name():
+    """Test extracting distro from short robostack channel name."""
+    channels = ["robostack-humble", "conda-forge"]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro == "humble"
+
+
+def test_dont_extract_from_staging():
+    """Test extracting distro from short robostack channel name."""
+    channels = ["robostack-staging", "conda-forge"]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro is None
+
+
+def test_extract_distro_with_trailing_slash():
+    """Test extracting distro from URL with trailing slash."""
+    channels = ["https://prefix.dev/robostack-noetic/"]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro == "noetic"
+
+
+def test_extract_distro_multiple_robostack_channels():
+    """Test that the first robostack channel is used when multiple exist."""
+    channels = [
+        "https://prefix.dev/robostack-humble",
+        "https://prefix.dev/robostack-jazzy",
+    ]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro == "humble"
+
+
+def test_extract_distro_no_robostack_channel():
+    """Test that None is returned when no robostack channel exists."""
+    channels = [
+        "https://prefix.dev/conda-forge",
+        "https://prefix.dev/some-other-channel",
+    ]
+
+    distro = _extract_distro_from_channels_list(channels)
+    assert distro is None
+
+
+def test_config_auto_detects_distro_from_channel():
+    """Test that ROSBackendConfig auto-detects distro from channel list provided by the caller."""
+    # Create config without distro specified
+    config = ROSBackendConfig.model_validate({}, context={"channels": ["https://prefix.dev/robostack-jazzy"]})
+
+    assert config.distro is not None
+    assert config.distro.name == "jazzy"
+
+
+def test_config_explicit_distro_overrides_channel():
+    """Test that explicit distro config takes precedence over channel detection."""
+    # Create config with explicit distro
+    config = ROSBackendConfig.model_validate(
+        {"distro": "humble"},
+        context={"channels": ["https://prefix.dev/robostack-jazzy"]},
+    )
+
+    assert config.distro is not None
+    assert config.distro.name == "humble"
+
+
+def test_config_fails_without_distro_or_channel():
+    """Test that config validation fails when distro cannot be determined."""
+    with pytest.raises(ValueError, match="ROS distro must be either"):
+        ROSBackendConfig.model_validate({}, context={"channels": ["conda-forge"]})
+
+
+def test_config_fails_without_channels_context():
+    """Test that config validation fails when no channels are provided."""
+    with pytest.raises(ValueError, match="ROS distro must be either"):
+        ROSBackendConfig.model_validate({})

crates/pixi-build-backend/src/generated_recipe.rs

@@ -1,7 +1,7 @@
 use miette::Diagnostic;
 use pixi_build_types::ProjectModelV1;
 use rattler_build::{NormalizedKey, recipe::variable::Variable};
-use rattler_conda_types::{Platform, Version};
+use rattler_conda_types::{ChannelUrl, Platform, Version};
 use recipe_stage0::recipe::{About, IntermediateRecipe, Package, Value};
 use serde::de::DeserializeOwned;
 use std::collections::HashSet;
@@ -50,6 +50,9 @@ pub trait GenerateRecipe {
     ///   be removed when profiles will be implemented.
     /// * `variants` - The variant names that are available to the recipe. This might
     ///   influence how the recipe is generated.
+    /// * `channels` - The channels that are being used for this build. This can be
+    ///   used for backend-specific logic that depends on which channels are available.
+    #[allow(clippy::too_many_arguments)]
     fn generate_recipe(
         &self,
         model: &ProjectModelV1,
@@ -58,6 +61,7 @@ pub trait GenerateRecipe {
         host_platform: Platform,
         python_params: Option<PythonParams>,
         variants: &HashSet<NormalizedKey>,
+        channels: Vec<ChannelUrl>,
     ) -> miette::Result<GeneratedRecipe>;
 
     /// Returns a list of globs that should be used to find the input files

crates/pixi-build-backend/src/intermediate_backend.rs

@@ -284,6 +284,7 @@ where
             params.host_platform,
             Some(PythonParams { editable: false }),
             &variant_config.variants.keys().cloned().collect(),
+            params.channels,
         )?;
 
         // Convert the recipe to source code.
@@ -542,6 +543,7 @@ where
                 editable: params.editable.unwrap_or_default(),
             }),
             &variants.keys().cloned().collect(),
+            params.channels,
         )?;
 
         // Convert the recipe to source code.

crates/pixi-build-backend/tests/integration/protocol.rs

@@ -16,6 +16,7 @@ mod imp {
     use pixi_build_backend::generated_recipe::{
         BackendConfig, DefaultMetadataProvider, GenerateRecipe, GeneratedRecipe, PythonParams,
     };
+    use rattler_conda_types::ChannelUrl;
     use serde::{Deserialize, Serialize};
     use std::{
         collections::HashSet,
@@ -61,6 +62,7 @@ mod imp {
             _host_platform: rattler_conda_types::Platform,
             _python_params: Option<PythonParams>,
             _variants: &HashSet<pixi_build_backend::variants::NormalizedKey>,
+            _channels: Vec<ChannelUrl>,
         ) -> miette::Result<GeneratedRecipe> {
             GeneratedRecipe::from_model(model.clone(), &mut DefaultMetadataProvider)
                 .into_diagnostic()