pixi-ros 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/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/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/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/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.2.0.dist-info → pixi_ros-0.3.0.dist-info}/METADATA

@@ -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.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+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,,

pixi_ros-0.2.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-pixi_ros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pixi_ros/cli.py,sha256=ifctksMHxa6NlCimnnovYe7HEz-0YUcZ-UHvVPiZCc0,4337
-pixi_ros/config.py,sha256=JevtFXh96UJj7aMUWp18J1xcPeQPoLzh3hdiu5uPR0s,834
-pixi_ros/init.py,sha256=oqpgt-yEywDxQ410kpka5VTsmHalTHxoUyBrCMEj5YA,28507
-pixi_ros/mappings.py,sha256=3wr4uPlGBtc8BO-06RZEpZZzxkiGxd9zxNfV3OzAoxI,10344
-pixi_ros/package_xml.py,sha256=a1_zJVc73eMOt67BIk2ITnxLPN1RIUOs0oL42q6CLvI,6279
-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=O3r31jNNU-lPCgvFlmhytTp_R1UMgIBRwDaeSebI7wI,18900
-pixi_ros-0.2.0.dist-info/METADATA,sha256=H3IAkgh95uynWynNrOZrXGn6GzOZaYj41yMMlAdakT0,9436
-pixi_ros-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pixi_ros-0.2.0.dist-info/entry_points.txt,sha256=DpBwU4Djcej8gT42q8Ccuv-R9pdmGHyFV5p57_ogqfQ,47
-pixi_ros-0.2.0.dist-info/licenses/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
-pixi_ros-0.2.0.dist-info/RECORD,,