pixi-ros 0.2.0__tar.gz → 0.3.0__tar.gz

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixi-ros
-Version: 0.2.0
+Version: 0.3.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
@@ -120,6 +120,41 @@ ros-humble-rclcpp = "*"
 ros-humble-std-msgs = "*"
 ```
 
+### Version Constraints
+
+`pixi-ros` supports version constraints from `package.xml` files and automatically applies them to the generated `pixi.toml`.
+
+#### Supported Version Attributes
+
+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"
+```
+
 ## Supported ROS Distributions
 
 - ROS 2 Humble: https://prefix.dev/robostack-humble
@@ -147,8 +182,9 @@ 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
 - 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

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/README.md

@@ -101,6 +101,41 @@ ros-humble-rclcpp = "*"
 ros-humble-std-msgs = "*"
 ```
 
+### Version Constraints
+
+`pixi-ros` supports version constraints from `package.xml` files and automatically applies them to the generated `pixi.toml`.
+
+#### Supported Version Attributes
+
+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"
+```
+
 ## Supported ROS Distributions
 
 - ROS 2 Humble: https://prefix.dev/robostack-humble
@@ -128,8 +163,9 @@ 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
 - 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

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/pixi.lock

@@ -1073,7 +1073,7 @@ packages:
   timestamp: 1769677743677
 - conda: .
   name: pixi-ros
-  version: 0.1.2
+  version: 0.3.0
   build: pyh4616a5c_0
   subdir: noarch
   variants:

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pixi-ros"
-version = "0.2.0"
+version = "0.3.0"
 description = "Pixi extension for ROS package management"
 authors = [
     { name = "Ruben Arts", email = "ruben@prefix.dev" }

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/src/pixi_ros/cli.py

@@ -32,7 +32,8 @@ def init(
         typer.Option(
             "--platform",
             "-p",
-            help="Target platforms (e.g., linux-64, osx-arm64, win-64). Can be specified multiple times.",
+            help="Target platforms (e.g., linux-64, osx-arm64, win-64)."
+            " Can be specified multiple times.",
         ),
     ] = None,
 ):
@@ -103,20 +104,19 @@ def init(
                     platforms.append(available_platforms[sel_num - 1])
                 else:
                     typer.echo(
-                        f"Error: Invalid selection {sel_num}. Please choose 1-{len(available_platforms)}",
+                        f"Error: Invalid selection {sel_num}."
+                        + f"Please choose 1-{len(available_platforms)}",
                         err=True,
                     )
                     raise typer.Exit(code=1)
-            except ValueError:
+            except ValueError as err:
                 # User entered a name instead of number
                 if sel in available_platforms:
                     platforms.append(sel)
                 else:
-                    typer.echo(
-                        f"Error: '{sel}' is not a valid platform", err=True
-                    )
+                    typer.echo(f"Error: '{sel}' is not a valid platform", err=True)
                     typer.echo(f"Available: {', '.join(available_platforms)}", err=True)
-                    raise typer.Exit(code=1)
+                    raise typer.Exit(code=1) from err
 
         if not platforms:
             typer.echo("Error: No platforms selected", err=True)

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/src/pixi_ros/data/conda-forge.yaml

@@ -792,6 +792,8 @@ python3-importlib-resources:
   pixi: [importlib_resources]
 python3-jinja2:
   pixi: [jinja2]
+python3-jsonschema:
+  pixi: [jsonschema]
 python3-kitchen:
   pixi: [kitchen]
 python3-lark-parser:

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/src/pixi_ros/init.py

@@ -254,8 +254,8 @@ def _ensure_workspace_section(
     if "channels" not in workspace:
         workspace["channels"] = []
 
-    # Set platforms if not present or if platforms were provided
-    if "platforms" not in workspace or platforms:
+    # Set or extend platforms
+    if "platforms" not in workspace:
         if platforms:
             # Platforms are already in pixi format (linux-64, osx-64, etc.)
             workspace["platforms"] = platforms
@@ -263,6 +263,18 @@ def _ensure_workspace_section(
             # Only add the current platform by default
             current_platform = str(Platform.current())
             workspace["platforms"] = [current_platform]
+    elif platforms:
+        # Extend existing platforms list with new ones (avoiding duplicates)
+        existing_platforms = workspace["platforms"]
+        if not isinstance(existing_platforms, list):
+            existing_platforms = [existing_platforms]
+
+        # Add new platforms that aren't already in the list
+        for platform in platforms:
+            if platform not in existing_platforms:
+                existing_platforms.append(platform)
+
+        workspace["platforms"] = existing_platforms
 
 
 def _ensure_channels(config: dict, distro: str):
@@ -365,6 +377,28 @@ def _ensure_dependencies(
         if cmake_version:
             dep_versions["cmake"] = cmake_version
 
+        # Collect version constraints from package.xml
+        for ros_dep, version_constraint in pkg.dependency_versions.items():
+            # Skip workspace packages
+            if ros_dep in workspace_pkg_names:
+                continue
+
+            # Map ROS package to conda packages
+            # Note: We use the first platform for mapping since version constraints
+            # should be the same across platforms for a given ROS package
+            conda_packages = map_ros_to_conda(ros_dep, distro)
+
+            # Apply version constraint to all mapped conda packages
+            for conda_dep in conda_packages:
+                if conda_dep and not conda_dep.startswith("REQUIRE_"):
+                    # If package already has a constraint, combine them
+                    if conda_dep in dep_versions:
+                        dep_versions[conda_dep] = (
+                            f"{dep_versions[conda_dep]},{version_constraint}"
+                        )
+                    else:
+                        dep_versions[conda_dep] = version_constraint
+
     # Platforms come from CLI as pixi platform names (linux-64, osx-64, etc.)
     # Map them to mapping platform names for querying the mapping files
     pixi_to_mapping = {
@@ -445,11 +479,15 @@ def _ensure_dependencies(
         common_deps = set(platform_deps[mapping_platform_list[0]].keys())
 
     # For backwards compatibility when single platform, use old behavior
-    dep_sources = platform_deps[mapping_platform_list[0]] if len(mapping_platform_list) == 1 else {
-        dep: platform_deps[mapping_platform_list[0]][dep]
-        for dep in common_deps
-        if dep in platform_deps[mapping_platform_list[0]]
-    }
+    dep_sources = (
+        platform_deps[mapping_platform_list[0]]
+        if len(mapping_platform_list) == 1
+        else {
+            dep: platform_deps[mapping_platform_list[0]][dep]
+            for dep in common_deps
+            if dep in platform_deps[mapping_platform_list[0]]
+        }
+    )
 
     # Create or get dependencies table
     if "dependencies" not in config:
@@ -497,7 +535,9 @@ def _ensure_dependencies(
     if dep_sources:
         dependencies.add(tomlkit.nl())
         if len(mapping_platform_list) > 1:
-            dependencies.add(tomlkit.comment("Workspace dependencies (common across platforms)"))
+            dependencies.add(
+                tomlkit.comment("Workspace dependencies (common across platforms)")
+            )
         else:
             dependencies.add(tomlkit.comment("Workspace dependencies"))
 
@@ -513,7 +553,9 @@ def _ensure_dependencies(
 
         availability = {}
         if channels and packages_to_check:
-            typer.echo(f"Checking common package availability for {first_pixi_platform}...")
+            typer.echo(
+                f"Checking common package availability for {first_pixi_platform}..."
+            )
             availability = _check_package_availability(
                 packages_to_check, channels, first_platform
             )
@@ -564,7 +606,9 @@ def _ensure_dependencies(
 
             # If we also have windows, only move to unix if NOT on windows
             if has_win:
-                win_deps = set(platform_deps.get("win64", {}).keys()) | set(platform_deps.get("win", {}).keys())
+                win_deps = set(platform_deps.get("win64", {}).keys()) | set(
+                    platform_deps.get("win", {}).keys()
+                )
                 unix_deps_keys = unix_candidates - win_deps
             else:
                 unix_deps_keys = unix_candidates
@@ -591,7 +635,9 @@ def _ensure_dependencies(
                 )
 
             # Check availability on linux platform as representative
-            representative_pixi_platform = platform_groups.get("linux", platform_groups.get("osx", platforms))[0]
+            representative_pixi_platform = platform_groups.get(
+                "linux", platform_groups.get("osx", platforms)
+            )[0]
             platform_obj = Platform(representative_pixi_platform)
             packages_to_check = list(unix_deps.keys())
 
@@ -651,7 +697,9 @@ def _ensure_dependencies(
                 # Add comment
                 if len(target_deps) == 0:
                     target_deps.add(
-                        tomlkit.comment(f"Platform-specific dependencies for {mapping_platform}")
+                        tomlkit.comment(
+                            f"Platform-specific dependencies for {mapping_platform}"
+                        )
                     )
 
                 # Check availability for this mapping platform
@@ -662,7 +710,9 @@ def _ensure_dependencies(
 
                 availability = {}
                 if channels and packages_to_check:
-                    typer.echo(f"Checking package availability for {mapping_platform}...")
+                    typer.echo(
+                        f"Checking package availability for {mapping_platform}..."
+                    )
                     availability = _check_package_availability(
                         packages_to_check, channels, platform_obj
                     )
@@ -700,14 +750,27 @@ def _ensure_tasks(config: dict):
 
     # Define common ROS tasks if not present
     default_tasks = {
-        "build": "colcon build",
-        "test": "colcon test",
-        "clean": "rm -rf build install log",
+        "build": {
+            "cmd": "colcon build",
+            "description": "Build the ROS workspace",
+        },
+        "test": {
+            "cmd": "colcon test",
+            "description": "Run tests for the workspace",
+        },
+        "clean": {
+            "cmd": "rm -rf build install log",
+            "description": "Clean build artifacts (build, install, log directories)",
+        },
     }
 
-    for task_name, task_cmd in default_tasks.items():
+    for task_name, task_config in default_tasks.items():
         if task_name not in tasks:
-            tasks[task_name] = task_cmd
+            # Create inline table for task configuration
+            task_table = tomlkit.inline_table()
+            task_table["cmd"] = task_config["cmd"]
+            task_table["description"] = task_config["description"]
+            tasks[task_name] = task_table
 
     config["tasks"] = tasks
 

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/src/pixi_ros/mappings.py

@@ -287,7 +287,11 @@ def get_platforms() -> list[str]:
     if "win64" in mapping_platforms or "win" in mapping_platforms:
         pixi_platforms.append("win-64")
 
-    return pixi_platforms if pixi_platforms else ["linux-64", "osx-64", "osx-arm64", "win-64"]
+    return (
+        pixi_platforms
+        if pixi_platforms
+        else ["linux-64", "osx-64", "osx-arm64", "win-64"]
+    )
 
 
 def get_ros_distros() -> list[str]:

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/src/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-0.3.0/tests/examples/ws1/README_PIXI.md

@@ -0,0 +1,125 @@
+# Pixi-ROS Workspace
+
+This ROS jazzy workspace is configured to use [Pixi](https://pixi.sh) for dependency management.
+
+## What is Pixi?
+
+Pixi is a modern package manager that uses conda packages. It provides:
+- Fast, reproducible dependency resolution
+- Automatic environment management
+- Reproducible with a lockfile
+- Cross-platform support (Linux, macOS, Windows)
+
+## Getting Started
+
+### 1. Install Dependencies
+
+```bash
+pixi install
+```
+
+This installs all dependencies specified in `pixi.toml` from the configured channels.
+
+### 2. Build the Workspace
+
+```bash
+pixi run build
+```
+
+This runs `colcon build` to compile your ROS packages.
+
+### 3. Run Tests
+
+```bash
+pixi run test
+```
+
+This runs `colcon test` to execute your test suite.
+
+### 4. Clean Build Artifacts
+
+```bash
+pixi run clean
+```
+
+Removes `build/`, `install/`, and `log/` directories.
+
+### 5. Add additional dependencies
+
+```bash
+pixi add <package-name>
+# or for packages you would install with pip/uv/poetry:
+pixi add --pypi <package-name>
+```
+
+This adds new dependencies to `pixi.toml` and installs them.
+
+## Environment Activation
+
+After the first build, pixi will automatically source the ROS setup script (`install/setup.bash`)
+when you enter the pixi environment. This means you don't need to manually source it!
+
+To activate the environment, run:
+
+```bash
+pixi shell
+```
+
+This starts a new shell with the ROS environment activated.
+
+The environment will also be automatically activated when you run commands with `pixi run <command>`.
+
+## Adding Dependencies
+
+### Add a Conda Package
+
+```bash
+pixi add <package-name>
+```
+
+### Add ROS Dependencies
+
+When you add dependencies to your `package.xml` files, run:
+
+```bash
+pixi ros init --distro jazzy
+```
+
+This will update `pixi.toml` with the new dependencies.
+
+## Unavailable Packages
+
+If you see commented-out packages in `pixi.toml` with `# NOT FOUND`, these packages
+were not found in the configured channels. You may need to:
+- Check if the package name is correct
+- Add additional channels with `pixi project channel add <channel-url>`
+- Install the package through pip: `pixi add --pypi <package-name>`
+- Add it to [conda-forge](https://github.com/conda-forge/staged-recipes) or [RoboStack](https://robostack.github.io/Contributing.html)
+
+## Common Issues
+
+### Build Fails
+
+If `pixi run build` fails:
+1. Make sure all dependencies are installed: `pixi install`
+2. Clean and rebuild: `pixi run clean && pixi run build`
+3. Validate the build task is correct for your workspace.
+
+### Environment Issues
+
+If `ros2` commands aren't found:
+1. Run commands through pixi: `pixi run <command>`
+2. Or use a pixi shell: `pixi shell`
+
+## Learn More
+
+- **Pixi Documentation**: https://pixi.sh
+- **RoboStack Documentation**: https://robostack.github.io/
+- **ROS jazzy Documentation**: https://docs.ros.org/en/jazzy/
+- **pixi-ros GitHub**: https://github.com/prefix-dev/pixi-ros
+
+## Channels
+
+This workspace uses the following channels:
+- `https://prefix.dev/robostack-jazzy` - ROS packages
+- `https://prefix.dev/conda-forge` - System dependencies

pixi_ros-0.3.0/tests/examples/ws1/pixi.toml

@@ -0,0 +1,38 @@
+[workspace]
+name = "ws1"
+channels = ["https://prefix.dev/robostack-jazzy", "https://prefix.dev/conda-forge"]
+platforms = ["linux-64"]
+
+[dependencies]
+# Base ROS dependencies
+ros-jazzy-ros-base = "*"
+pkg-config = "*"
+compilers = "*"
+make = "*"
+ninja = "*"
+ros-jazzy-ros2cli = "*"
+
+# Build tools
+colcon-common-extensions = "*"
+cmake = "<4"
+
+# Workspace dependencies
+numpy = "*"
+pytest = "*"
+ros-jazzy-ament-cmake = "*"
+ros-jazzy-ament-copyright = "*"
+ros-jazzy-ament-flake8 = "*"
+ros-jazzy-ament-lint-auto = ">=1.2.3,>=1.2.3"
+ros-jazzy-ament-lint-common = "==1.0.0,==1.0.0"
+ros-jazzy-ament-pep257 = "*"
+
+[tasks]
+build = {cmd = "colcon build", description = "Build the ROS workspace"}
+build-no-error = {cmd = "colcon build --continue-on-error --cmake-args -DCMAKE_CXX_FLAGS=\"-Wno-error\"", description = "Build the workspace ignoring errors and warnings"}
+test = {cmd = "colcon test", description = "Run tests for the workspace"}
+clean = {cmd = "rm -rf build install log", description = "Clean build artifacts (build, install, log directories)"}
+
+# Scripts to source on environment activation, found after first colcon build.
+
+[activation]
+scripts = ["install/setup.bash"]

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/tests/examples/ws1/src/package-a/package.xml

@@ -9,8 +9,8 @@
 
   <buildtool_depend>ament_cmake</buildtool_depend>
 
-  <test_depend>ament_lint_auto</test_depend>
-  <test_depend>ament_lint_common</test_depend>
+  <test_depend version_gte="1.2.3">ament_lint_auto</test_depend>
+  <test_depend version_eq="1.0.0">ament_lint_common</test_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/tests/examples/ws1/src/package-b/package.xml

@@ -14,6 +14,9 @@
   <test_depend>ament_pep257</test_depend>
   <test_depend>python3-pytest</test_depend>
 
+  <test_depend version_gte="1.2.3">ament_lint_auto</test_depend>
+  <test_depend version_eq="1.0.0">ament_lint_common</test_depend>
+
   <export>
     <build_type>ament_python</build_type>
   </export>

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/tests/test_init.py

@@ -364,3 +364,195 @@ def test_unix_target_for_linux_and_osx_deps():
             linux_deps = config["target"]["linux"]["dependencies"]
             # GL packages specific to Linux
             assert any("libgl-devel" in str(dep).lower() or "libopengl-devel" in str(dep).lower() for dep in linux_deps.keys())
+
+
+def test_tasks_have_descriptions():
+    """Test that generated tasks include descriptions."""
+    from pixi_ros.init import init_workspace
+
+    with TemporaryDirectory() as tmpdir:
+        workspace_path = Path(tmpdir)
+        src_dir = workspace_path / "src"
+        src_dir.mkdir()
+
+        # Create a simple package.xml
+        pkg_xml = src_dir / "package.xml"
+        pkg_xml.write_text("""<?xml version="1.0"?>
+<package format="2">
+    <name>test_pkg</name>
+    <version>0.0.1</version>
+    <description>Test</description>
+    <maintainer email="test@test.com">Test</maintainer>
+    <license>MIT</license>
+</package>
+""")
+
+        # Initialize workspace
+        init_workspace("humble", workspace_path, platforms=["linux-64"])
+
+        # Check pixi.toml was created
+        toml_path = workspace_path / "pixi.toml"
+        assert toml_path.exists()
+
+        # Parse and check tasks
+        import tomlkit
+        with open(toml_path) as f:
+            config = tomlkit.load(f)
+
+        assert "tasks" in config
+        tasks = config["tasks"]
+
+        # Check that expected tasks exist and have descriptions
+        expected_tasks = {
+            "build": {
+                "cmd": "colcon build",
+                "description": "Build the ROS workspace",
+            },
+            "test": {
+                "cmd": "colcon test",
+                "description": "Run tests for the workspace",
+            },
+            "clean": {
+                "cmd": "rm -rf build install log",
+                "description": "Clean build artifacts (build, install, log directories)",
+            },
+        }
+
+        for task_name, expected_config in expected_tasks.items():
+            assert task_name in tasks, f"Task '{task_name}' not found in pixi.toml"
+            task = tasks[task_name]
+
+            # Task should be a dict/table with cmd and description
+            assert isinstance(task, dict), f"Task '{task_name}' should be a dictionary"
+            assert "cmd" in task, f"Task '{task_name}' missing 'cmd' field"
+            assert "description" in task, f"Task '{task_name}' missing 'description' field"
+
+            # Verify the content matches
+            assert task["cmd"] == expected_config["cmd"], f"Task '{task_name}' has wrong command"
+            assert task["description"] == expected_config["description"], f"Task '{task_name}' has wrong description"
+
+
+def test_platforms_extended_not_overridden():
+    """Test that running init multiple times extends the platforms list instead of overriding it."""
+    from pixi_ros.init import init_workspace
+
+    with TemporaryDirectory() as tmpdir:
+        workspace_path = Path(tmpdir)
+        src_dir = workspace_path / "src"
+        src_dir.mkdir()
+
+        # Create a simple package.xml
+        pkg_xml = src_dir / "package.xml"
+        pkg_xml.write_text("""<?xml version="1.0"?>
+<package format="2">
+    <name>test_pkg</name>
+    <version>0.0.1</version>
+    <description>Test</description>
+    <maintainer email="test@test.com">Test</maintainer>
+    <license>MIT</license>
+</package>
+""")
+
+        # Initialize with single platform
+        init_workspace("humble", workspace_path, platforms=["linux-64"])
+
+        # Check pixi.toml was created with linux-64
+        toml_path = workspace_path / "pixi.toml"
+        assert toml_path.exists()
+
+        import tomlkit
+        with open(toml_path) as f:
+            config = tomlkit.load(f)
+
+        assert "workspace" in config
+        assert "platforms" in config["workspace"]
+        assert config["workspace"]["platforms"] == ["linux-64"]
+
+        # Initialize again with additional platforms
+        init_workspace("humble", workspace_path, platforms=["osx-arm64", "win-64"])
+
+        # Read updated config
+        with open(toml_path) as f:
+            config = tomlkit.load(f)
+
+        # Verify all platforms are present
+        platforms = config["workspace"]["platforms"]
+        assert "linux-64" in platforms, "Original platform should still be present"
+        assert "osx-arm64" in platforms, "New platform osx-arm64 should be added"
+        assert "win-64" in platforms, "New platform win-64 should be added"
+        assert len(platforms) == 3, "Should have exactly 3 platforms"
+
+        # Verify no duplicates if we run init again with overlapping platforms
+        init_workspace("humble", workspace_path, platforms=["linux-64", "osx-64"])
+
+        with open(toml_path) as f:
+            config = tomlkit.load(f)
+
+        platforms = config["workspace"]["platforms"]
+        # linux-64 should not be duplicated
+        assert platforms.count("linux-64") == 1, "linux-64 should not be duplicated"
+        # osx-64 should be added (new)
+        assert "osx-64" in platforms, "New platform osx-64 should be added"
+        # All previous platforms should still be there
+        assert "osx-arm64" in platforms
+        assert "win-64" in platforms
+
+
+def test_version_constraints_from_package_xml():
+    """Test that version constraints from package.xml are applied to pixi.toml dependencies."""
+    from pixi_ros.init import init_workspace
+
+    with TemporaryDirectory() as tmpdir:
+        workspace_path = Path(tmpdir)
+        src_dir = workspace_path / "src"
+        src_dir.mkdir()
+
+        # Create a package.xml with version-constrained dependencies
+        pkg_xml = src_dir / "package.xml"
+        pkg_xml.write_text("""<?xml version="1.0"?>
+<package format="2">
+    <name>test_pkg</name>
+    <version>0.0.1</version>
+    <description>Test</description>
+    <maintainer email="test@test.com">Test</maintainer>
+    <license>MIT</license>
+    <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>
+</package>
+""")
+
+        # Initialize workspace
+        init_workspace("humble", workspace_path, platforms=["linux-64"])
+
+        # Check pixi.toml was created
+        toml_path = workspace_path / "pixi.toml"
+        assert toml_path.exists()
+
+        # Parse and check dependencies
+        import tomlkit
+        with open(toml_path) as f:
+            config = tomlkit.load(f)
+
+        assert "dependencies" in config
+        dependencies = config["dependencies"]
+
+        # Check that cmake has the version constraint
+        # Note: cmake might already have a constraint from CMakeLists.txt detection
+        # so we just verify it has some constraint
+        if "cmake" in dependencies:
+            cmake_version = dependencies["cmake"]
+            assert cmake_version != "*", "cmake should have a version constraint"
+            assert ">=" in cmake_version or "<" in cmake_version, "cmake should have a version constraint operator"
+
+        # Check that eigen has the version constraint (>=3.3.0,<4.0.0)
+        if "eigen" in dependencies:
+            eigen_version = dependencies["eigen"]
+            assert eigen_version != "*", "eigen should have a version constraint"
+            assert ">=3.3.0" in eigen_version or ">=" in eigen_version, "eigen should have >= constraint"
+
+        # Check that boost has the exact version constraint (==1.2.3)
+        if "boost" in dependencies:
+            boost_version = dependencies["boost"]
+            assert boost_version != "*", "boost should have a version constraint"
+            assert "==" in boost_version or "1.2.3" in str(boost_version), "boost should have == constraint"

{pixi_ros-0.2.0 → pixi_ros-0.3.0}/tests/test_package_xml.py

@@ -236,3 +236,95 @@ def test_parse_missing_required_fields():
             PackageXML.from_file(temp_path)
     finally:
         temp_path.unlink()
+
+
+def test_parse_version_constraints():
+    """Test that version constraints are correctly parsed from package.xml."""
+    from tempfile import NamedTemporaryFile
+
+    with NamedTemporaryFile(mode="w", suffix=".xml", delete=False) as f:
+        f.write(
+            """<?xml version="1.0"?>
+        <package format="3">
+            <name>test_pkg</name>
+            <version>1.0.0</version>
+            <description>Test package</description>
+            <maintainer email="test@test.com">Test</maintainer>
+            <license>MIT</license>
+            <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>
+            <depend version_lte="2.0.0">pkg_without_constraint</depend>
+            <depend>pkg_without_any_version</depend>
+        </package>
+        """
+        )
+        f.flush()
+        temp_path = Path(f.name)
+
+    try:
+        pkg = PackageXML.from_file(temp_path)
+
+        # Check that version constraints are stored
+        assert "cmake" in pkg.dependency_versions
+        assert pkg.dependency_versions["cmake"] == ">=3.12.4"
+
+        assert "eigen" in pkg.dependency_versions
+        # Multiple constraints should be combined with comma
+        assert ">=3.3.0" in pkg.dependency_versions["eigen"]
+        assert "<4.0.0" in pkg.dependency_versions["eigen"]
+        assert "," in pkg.dependency_versions["eigen"]
+
+        assert "boost" in pkg.dependency_versions
+        assert pkg.dependency_versions["boost"] == "==1.2.3"
+
+        assert "pkg_without_constraint" in pkg.dependency_versions
+        assert pkg.dependency_versions["pkg_without_constraint"] == "<=2.0.0"
+
+        # Package without version constraint should not be in the map
+        assert "pkg_without_any_version" not in pkg.dependency_versions
+
+        # Check that packages are still in their respective dependency lists
+        assert "cmake" in pkg.depends
+        assert "eigen" in pkg.build_depends
+        assert "boost" in pkg.exec_depends
+        assert "pkg_without_constraint" in pkg.depends
+        assert "pkg_without_any_version" in pkg.depends
+    finally:
+        temp_path.unlink()
+
+
+def test_parse_all_version_constraint_types():
+    """Test parsing all types of version constraints."""
+    from tempfile import NamedTemporaryFile
+
+    with NamedTemporaryFile(mode="w", suffix=".xml", delete=False) as f:
+        f.write(
+            """<?xml version="1.0"?>
+        <package format="3">
+            <name>test_pkg</name>
+            <version>1.0.0</version>
+            <description>Test package</description>
+            <maintainer email="test@test.com">Test</maintainer>
+            <license>MIT</license>
+            <depend version_lt="2.0.0">pkg_lt</depend>
+            <depend version_lte="2.5.0">pkg_lte</depend>
+            <depend version_eq="1.2.3">pkg_eq</depend>
+            <depend version_gte="1.0.0">pkg_gte</depend>
+            <depend version_gt="0.5.0">pkg_gt</depend>
+        </package>
+        """
+        )
+        f.flush()
+        temp_path = Path(f.name)
+
+    try:
+        pkg = PackageXML.from_file(temp_path)
+
+        assert pkg.dependency_versions["pkg_lt"] == "<2.0.0"
+        assert pkg.dependency_versions["pkg_lte"] == "<=2.5.0"
+        assert pkg.dependency_versions["pkg_eq"] == "==1.2.3"
+        assert pkg.dependency_versions["pkg_gte"] == ">=1.0.0"
+        assert pkg.dependency_versions["pkg_gt"] == ">0.5.0"
+    finally:
+        temp_path.unlink()

pixi_ros-0.2.0/tests/examples/ws1/pixi.toml

@@ -1,39 +0,0 @@
-[workspace]
-name = "ws1"
-channels = ["https://prefix.dev/robostack-jazzy", "https://prefix.dev/conda-forge"]
-platforms = ["osx-arm64"]
-
-[dependencies]
-# Base ROS dependencies
-ros-jazzy-ros-base = "*"
-ros-jazzy-ros2cli = "*"
-
-# Build tools
-colcon-common-extensions = "*"
-cmake = "<4"
-
-# From package: package-a
-ros-jazzy-ament-cmake = "*"
-ros-jazzy-ament-lint-auto = "*"
-ros-jazzy-ament-lint-common = "*"
-
-# From package: package-b
-numpy = "*"
-pytest = "*"
-ros-jazzy-ament-copyright = "*"
-ros-jazzy-ament-flake8 = "*"
-ros-jazzy-ament-pep257 = "*"
-
-[tasks]
-build = "colcon build"
-test = "colcon test"
-clean = "rm -rf build install log"
-
-[tool.pytest.ini_options]
-python_files = ["test_*.py"]
-python_functions = ["test_*"]
-
-# Scripts to source on environment activation, found after first colcon build.
-
-[activation]
-scripts = ["install/setup.bash"]