colcon-uv 0.0.1__py2.py3-none-any.whl

colcon_uv/__init__.py

@@ -0,0 +1,3 @@
+"""Colcon extension for UV-based Python packages."""
+
+__version__ = "0.0.1"

colcon_uv/cli.py

@@ -0,0 +1,102 @@
+"""Command-line interface for colcon-uv."""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from colcon_core.plugin_system import satisfies_version
+from colcon_core.verb import VerbExtensionPoint
+
+from .dependencies.install import discover_packages, install_dependencies
+
+
+class UvVerb(VerbExtensionPoint):
+    """UV command for colcon."""
+
+    def __init__(self):  # noqa: D107
+        super().__init__()
+        satisfies_version(VerbExtensionPoint.EXTENSION_POINT_VERSION, "^1.0")
+
+    def add_arguments(self, *, parser):  # noqa: D102
+        subparsers = parser.add_subparsers(dest="uv_command", help="UV commands")
+
+        # Install subcommand
+        install_parser = subparsers.add_parser(
+            "install", help="Install dependencies for UV-based packages"
+        )
+        install_parser.add_argument(
+            "--base-paths",
+            nargs="*",
+            help="The base paths to recursively crawl for packages",
+        )
+        install_parser.add_argument(
+            "--uv-args", nargs="*", help="Additional arguments to pass to UV"
+        )
+
+    def main(self, *, context):  # noqa: D102
+        args = context.args
+        logger = logging.getLogger("colcon.uv.cli")
+
+        if not hasattr(args, "uv_command") or args.uv_command != "install":
+            logger.error("Usage: colcon uv install [options]")
+            return 1
+
+        # Get base paths
+        base_paths = args.base_paths
+        if not base_paths:
+            base_paths = [Path(".")]
+        else:
+            base_paths = [Path(p) for p in base_paths]
+
+        # Discover UV packages using the install.py logic
+        try:
+            packages = discover_packages(base_paths)
+        except SystemExit:
+            logger.warning("No UV packages found")
+            return 0
+
+        # Install dependencies for each package using install.py logic
+        install_base = Path("install")  # Default install base
+        merge_install = False  # Default to separate installs
+
+        for package in packages:
+            try:
+                install_dependencies(package, install_base, merge_install)
+            except Exception as e:
+                logger.error(
+                    f"Failed to install dependencies for '{package.name}': {e}"
+                )
+                return 1
+
+        return 0
+
+
+def main():
+    """Run the CLI."""
+    parser = argparse.ArgumentParser(
+        description="Install dependencies for UV-based packages"
+    )
+    parser.add_argument(
+        "--base-paths",
+        nargs="*",
+        help="The base paths to recursively crawl for packages",
+    )
+    parser.add_argument(
+        "--uv-args", nargs="*", help="Additional arguments to pass to UV"
+    )
+
+    args = parser.parse_args()
+
+    # Set up logging
+    logging.basicConfig(
+        level=logging.INFO, format="%(levelname)s:%(name)s: %(message)s"
+    )
+
+    # Run the UV verb
+    verb = UvVerb()
+    return verb.main(context=argparse.Namespace(args=args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

colcon_uv/dependencies/install.py

@@ -0,0 +1,187 @@
+"""Install dependencies for UV packages."""
+
+import argparse
+import logging
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+import tomli
+
+logger = logging.getLogger("colcon.uv.dependencies")
+
+
+class NotAUvPackageError(Exception):
+    """Raised when a directory is not a UV package."""
+
+    pass
+
+
+class UvPackage:
+    """Represents a UV package."""
+
+    def __init__(self, path: Path, logger=None):
+        """Initialize UV package."""
+        self.path = path
+        self.logger = logger or logging.getLogger(__name__)
+
+        self.pyproject_file = path / "pyproject.toml"
+        if not self.pyproject_file.exists():
+            raise NotAUvPackageError(f"No pyproject.toml found in {path}")
+
+        # Load pyproject.toml
+        with open(self.pyproject_file, "rb") as f:
+            self.pyproject_data = tomli.load(f)
+
+        # Check if it's a UV package
+        if (
+            "tool" not in self.pyproject_data
+            or "colcon-uv-ros" not in self.pyproject_data["tool"]
+        ):
+            raise NotAUvPackageError(
+                f"No [tool.colcon-uv-ros] section found in {self.pyproject_file}"
+            )
+
+        # Get package name
+        if (
+            "project" in self.pyproject_data
+            and "name" in self.pyproject_data["project"]
+        ):
+            self.name = self.pyproject_data["project"]["name"]
+        else:
+            self.name = path.name
+
+
+def main():
+    """Main entry point for UV dependency installation."""
+    args = _parse_args()
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(levelname)s:%(name)s: %(message)s",
+    )
+
+    for project in discover_packages(args.base_paths):
+        logger.info(f"Installing dependencies for {project.path.name}...")
+        install_dependencies(project, args.install_base, args.merge_install)
+
+    logger.info("Dependencies installed!")
+
+
+def discover_packages(base_paths: List[Path]) -> List[UvPackage]:
+    """Discover UV packages in the given base paths."""
+    projects: List[UvPackage] = []
+
+    potential_packages = []
+    for path in base_paths:
+        potential_packages += list(path.glob("*"))
+
+    for path in potential_packages:
+        if path.is_dir():
+            try:
+                project = UvPackage(path)
+            except NotAUvPackageError:
+                continue
+            else:
+                projects.append(project)
+
+    if len(projects) == 0:
+        base_paths_str = ", ".join([str(p) for p in base_paths])
+        logger.error(
+            f"No UV packages were found in the following paths: {base_paths_str}"
+        )
+        sys.exit(1)
+
+    return projects
+
+
+def install_dependencies(
+    project: UvPackage, install_base: Path, merge_install: bool
+) -> None:
+    """Install dependencies for a UV package using UV."""
+    # Handle both contexts:
+    # 1. Direct install: install_base = /install, need to add package name
+    # 2. Build task: install_base = /install/package_name, already included
+
+    if not merge_install:
+        # Check if install_base already ends with the package name
+        if install_base.name != project.name:
+            install_base /= project.name
+
+    # Create the install directory first
+    install_base.mkdir(parents=True, exist_ok=True)
+
+    # Venv path - this should be /install/PACKAGE_NAME/venv/
+    venv_path = install_base / "venv"
+
+    # Create virtual environment at the target location with system packages access
+    # --system-site-packages is needed because ROS 2 packages like rclpy are installed
+    # system-wide (not available on PyPI) and our nodes need access to them
+    subprocess.run(["uv", "venv", "--system-site-packages", str(venv_path)], check=True)
+
+    # Install dependencies and the package itself to the target venv
+    # Use --python to specify the target venv's python
+    python_exe = venv_path / "bin" / "python"
+    subprocess.run(
+        ["uv", "pip", "install", "--python", str(python_exe), "-e", str(project.path)],
+        check=True,
+    )
+
+
+def install_dependencies_from_descriptor(
+    pkg_descriptor, install_base: Path, merge_install: bool
+):
+    """Install dependencies from a PackageDescriptor object.
+
+    This is a convenience function for use by colcon build tasks.
+    """
+    try:
+        uv_package = UvPackage(pkg_descriptor.path)
+        install_dependencies(uv_package, install_base, merge_install)
+    except NotAUvPackageError as e:
+        # Skip packages that aren't UV packages
+        logger.debug(f"Skipping non-UV package {pkg_descriptor.name}: {e}")
+        return
+
+
+def _parse_args() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Searches for UV packages and installs their dependencies "
+        "to a configurable install base"
+    )
+
+    parser.add_argument(
+        "--base-paths",
+        nargs="+",
+        type=Path,
+        default=[Path.cwd()],
+        help="The paths to start looking for UV projects in. Defaults to the "
+        "current directory.",
+    )
+
+    parser.add_argument(
+        "--install-base",
+        type=Path,
+        default=Path("install"),
+        help="The base path for all install prefixes (default: install)",
+    )
+
+    parser.add_argument(
+        "--merge-install",
+        action="store_true",
+        help="Merge all install prefixes into a single location",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="If provided, debug logs will be printed",
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

colcon_uv/package_augmentation/__init__.py

@@ -0,0 +1,5 @@
+"""Package augmentation for UV-based Python packages."""
+
+from colcon_uv.package_augmentation.uv import UvPackageAugmentation
+
+__all__ = ["UvPackageAugmentation"]

colcon_uv/package_augmentation/uv.py

@@ -0,0 +1,122 @@
+"""Augment packages that use UV for Python dependency management."""
+
+import logging
+import shutil
+from pathlib import Path
+
+from colcon_core.package_augmentation import PackageAugmentationExtensionPoint
+from colcon_core.package_augmentation.python import create_dependency_descriptor
+from colcon_core.package_descriptor import PackageDescriptor
+from colcon_core.plugin_system import satisfies_version
+
+logger = logging.getLogger("colcon.uv.package_augmentation")
+
+
+class UvPackageAugmentation(PackageAugmentationExtensionPoint):
+    """Augment packages that use UV for Python dependency management."""
+
+    _TOOL_SECTION = "tool"
+    _COLCON_UV_ROS_SECTION = "colcon-uv-ros"
+    _DEPENDENCIES_SECTION = "dependencies"
+    _DATA_FILES_SECTION = "data-files"
+    _DEPEND_LIST = "depend"
+    _BUILD_DEPEND_LIST = "build_depend"
+    _EXEC_DEPEND_LIST = "exec_depend"
+    _TEST_DEPEND_LIST = "test_depend"
+    _PACKAGE_BUILD_CATEGORY = "build"
+    _PACKAGE_EXEC_CATEGORY = "run"
+    _PACKAGE_TEST_CATEGORY = "test"
+
+    def __init__(self):  # noqa: D107
+        super().__init__()
+        satisfies_version(
+            PackageAugmentationExtensionPoint.EXTENSION_POINT_VERSION, "^1.0"
+        )
+
+    def augment_package(
+        self, desc: PackageDescriptor, *, additional_argument_names=None
+    ):  # noqa: D102
+        if desc.type != "uv":
+            return
+
+        # Read pyproject.toml to get package metadata
+        pyproject_toml = desc.path / "pyproject.toml"
+        if not pyproject_toml.exists():
+            return
+
+        try:
+            import tomli
+
+            with open(pyproject_toml, "rb") as f:
+                data = tomli.load(f)
+                if (
+                    self._TOOL_SECTION in data
+                    and self._COLCON_UV_ROS_SECTION in data[self._TOOL_SECTION]
+                ):
+                    uv_config = data[self._TOOL_SECTION][self._COLCON_UV_ROS_SECTION]
+
+                    # Set package name if not already set
+                    if not desc.name and "name" in uv_config:
+                        desc.name = uv_config["name"]
+
+                    # Handle dependencies
+                    if self._DEPENDENCIES_SECTION in uv_config:
+                        deps = uv_config[self._DEPENDENCIES_SECTION]
+
+                        # Build dependencies
+                        if self._BUILD_DEPEND_LIST in deps:
+                            build_deps = set(deps[self._BUILD_DEPEND_LIST])
+                        else:
+                            build_deps = set()
+
+                        # Exec dependencies
+                        if self._EXEC_DEPEND_LIST in deps:
+                            exec_deps = set(deps[self._EXEC_DEPEND_LIST])
+                        else:
+                            exec_deps = set()
+
+                        # Test dependencies
+                        if self._TEST_DEPEND_LIST in deps:
+                            test_deps = set(deps[self._TEST_DEPEND_LIST])
+                        else:
+                            test_deps = set()
+
+                        # Handle general dependencies (add to both build and exec)
+                        if self._DEPEND_LIST in deps:
+                            depends = deps[self._DEPEND_LIST]
+                            build_deps.update(depends)
+                            exec_deps.update(depends)
+
+                        # Set dependencies in descriptor
+                        desc.dependencies[self._PACKAGE_BUILD_CATEGORY] = {
+                            create_dependency_descriptor(dep) for dep in build_deps
+                        }
+                        desc.dependencies[self._PACKAGE_EXEC_CATEGORY] = {
+                            create_dependency_descriptor(dep) for dep in exec_deps
+                        }
+                        desc.dependencies[self._PACKAGE_TEST_CATEGORY] = {
+                            create_dependency_descriptor(dep) for dep in test_deps
+                        }
+
+                    # Handle data files
+                    if self._DATA_FILES_SECTION in uv_config:
+                        data_files = uv_config[self._DATA_FILES_SECTION]
+                        for dest_dir, files in data_files.items():
+                            # Create destination directory if it doesn't exist
+                            dest_path = Path(dest_dir)
+                            dest_path.mkdir(parents=True, exist_ok=True)
+
+                            # Copy each file
+                            for file in files:
+                                src_path = desc.path / file
+                                if src_path.is_file():
+                                    shutil.copy2(src_path, dest_path / src_path.name)
+                                elif src_path.is_dir():
+                                    shutil.copytree(
+                                        src_path,
+                                        dest_path / src_path.name,
+                                        dirs_exist_ok=True,
+                                    )
+        except ImportError:
+            # If tomli is not available, we'll just use basic metadata
+            pass

colcon_uv/package_identification/__init__.py

@@ -0,0 +1,5 @@
+"""Package identification for UV-based Python packages."""
+
+from colcon_uv.package_identification.uv import UvPackageIdentification
+
+__all__ = ["UvPackageIdentification"]

colcon_uv/package_identification/uv.py

@@ -0,0 +1,53 @@
+"""Identify packages that use UV for Python dependency management."""
+
+import logging
+import os
+
+from colcon_core.package_identification import PackageIdentificationExtensionPoint
+from colcon_core.plugin_system import satisfies_version
+
+logger = logging.getLogger("colcon.uv.package_identification")
+
+
+class UvPackageIdentification(PackageIdentificationExtensionPoint):
+    """Identify packages that use UV for Python dependency management."""
+
+    # High priority to supersede other identifiers like ament_python
+    PRIORITY = 200
+
+    def __init__(self):  # noqa: D107
+        super().__init__()
+        satisfies_version(
+            PackageIdentificationExtensionPoint.EXTENSION_POINT_VERSION, "^1.0"
+        )
+
+    def identify(self, desc):  # noqa: D102
+        if desc.type is not None and desc.type != "uv.python":
+            return
+
+        pyproject_toml = desc.path / "pyproject.toml"
+        if not pyproject_toml.exists():
+            return
+
+        # Check if it's a UV package by looking for our custom section
+        try:
+            import tomli
+
+            with open(pyproject_toml, "rb") as f:
+                data = tomli.load(f)
+                if "tool" in data and "colcon-uv-ros" in data["tool"]:
+                    desc.type = "uv.python"
+                    # Get name from pyproject.toml if available, otherwise use directory name
+                    if "project" in data and "name" in data["project"]:
+                        desc.name = data["project"]["name"]
+                    else:
+                        desc.name = os.path.basename(desc.path)
+                    return
+        except ImportError:
+            # If tomli is not available, we'll just check for the string
+            with open(pyproject_toml) as f:
+                content = f.read()
+                if "[tool.colcon-uv-ros]" in content:
+                    desc.type = "uv.python"
+                    desc.name = os.path.basename(desc.path)
+                    return

colcon_uv/task/__init__.py

@@ -0,0 +1,6 @@
+"""Tasks for UV-based Python packages."""
+
+from colcon_uv.task.uv.build import UvBuildTask
+from colcon_uv.task.uv.test import UvTestTask
+
+__all__ = ["UvBuildTask", "UvTestTask"]

colcon_uv/task/uv/__init__.py

@@ -0,0 +1,6 @@
+"""UV-specific tasks for colcon."""
+
+from colcon_uv.task.uv.build import UvBuildTask
+from colcon_uv.task.uv.test import UvTestTask
+
+__all__ = ["UvBuildTask", "UvTestTask"]

colcon_uv/task/uv/build.py

@@ -0,0 +1,170 @@
+"""Build task for UV-based Python packages."""
+
+import shutil
+from pathlib import Path
+
+from colcon_core.logging import colcon_logger
+from colcon_core.plugin_system import satisfies_version
+from colcon_core.task import TaskExtensionPoint
+
+from colcon_uv.dependencies.install import install_dependencies_from_descriptor
+
+logger = colcon_logger.getChild("colcon.uv.task.build")
+
+
+class UvBuildTask(TaskExtensionPoint):
+    """Build task for UV-based Python packages."""
+
+    def __init__(self):  # noqa: D107
+        super().__init__()
+        satisfies_version(TaskExtensionPoint.EXTENSION_POINT_VERSION, "^1.0")
+
+    def add_arguments(self, *, parser):  # noqa: D102
+        parser.add_argument(
+            "--uv-args",
+            nargs="*",
+            metavar="*",
+            type=str.lstrip,
+            help="Pass arguments to UV. "
+            "Arguments matching other options must be prefixed by a space,\n"
+            'e.g. --uv-args " --help"',
+        )
+
+    async def build(self, *, additional_hooks=None):
+        pkg = self.context.pkg
+        args = self.context.args
+
+        # UV sync handles EVERYTHING - deps + package installation
+        logger.info("Syncing dependencies and installing package...")
+        install_dependencies_from_descriptor(pkg, Path(args.install_base), False)
+
+        # Handle ROS-specific stuff (data files, environment hooks, etc.)
+        return_code = await self._add_data_files()
+        if return_code != 0:
+            return return_code
+
+        # Create executable symlinks for ROS 2
+        self._create_executable_symlinks()
+
+        # Add environment hooks for ROS
+        self._create_environment_hooks()
+
+    async def _add_data_files(self) -> int:
+        """Install data files based on the [tool.colcon-uv-ros.data-files] table."""
+        pkg = self.context.pkg
+        args = self.context.args
+
+        pyproject_toml = pkg.path / "pyproject.toml"
+
+        try:
+            import tomli
+
+            with open(pyproject_toml, "rb") as f:
+                data = tomli.load(f)
+
+            if "tool" not in data or "colcon-uv-ros" not in data["tool"]:
+                return 0
+
+            uv_config = data["tool"]["colcon-uv-ros"]
+            if "data-files" not in uv_config:
+                return 0
+
+            data_files = uv_config["data-files"]
+        except (ImportError, FileNotFoundError, KeyError):
+            return 0
+
+        if not isinstance(data_files, dict):
+            logger.error("data-files must be a table")
+            return 1
+
+        for destination, sources in data_files.items():
+            if not isinstance(sources, list):
+                logger.error(f"Field '{destination}' in data-files must be an array")
+                return 1
+
+            dest_path = Path(args.install_base) / destination
+            dest_path.mkdir(parents=True, exist_ok=True)
+
+            for source in sources:
+                source_path = pkg.path / Path(source)
+                if source_path.exists():
+                    if source_path.is_dir():
+                        shutil.copytree(
+                            source_path,
+                            dest_path / source_path.name,
+                            dirs_exist_ok=True,
+                        )
+                    else:
+                        shutil.copy2(source_path, dest_path)
+
+        return 0
+
+    def _create_executable_symlinks(self):
+        """Create symlinks for executables in the standard ROS 2 location."""
+        pkg = self.context.pkg
+        args = self.context.args
+
+        # Read pyproject.toml to get executable entry points
+        pyproject_toml = pkg.path / "pyproject.toml"
+        if not pyproject_toml.exists():
+            return
+
+        try:
+            import tomli
+
+            with open(pyproject_toml, "rb") as f:
+                data = tomli.load(f)
+
+            if "project" not in data or "scripts" not in data["project"]:
+                return
+
+            scripts = data["project"]["scripts"]
+        except (ImportError, FileNotFoundError, KeyError):
+            return
+
+        # Create lib/package_name directory for executables
+        lib_dir = Path(args.install_base) / "lib" / pkg.name
+        lib_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create symlinks for each executable
+        venv_bin = Path(args.install_base) / "venv" / "bin"
+
+        for script_name, _entry_point in scripts.items():
+            venv_executable = venv_bin / script_name
+            ros_executable = lib_dir / script_name
+
+            if venv_executable.exists():
+                # Remove existing symlink if it exists
+                if ros_executable.exists() or ros_executable.is_symlink():
+                    ros_executable.unlink()
+
+                # Create symlink
+                ros_executable.symlink_to(venv_executable)
+                logger.info(
+                    f"Created executable symlink: {ros_executable} -> {venv_executable}"
+                )
+
+    def _create_environment_hooks(self):
+        """Create ROS environment hooks."""
+        from colcon_core.environment import (
+            create_environment_hooks,
+            create_environment_scripts,
+        )
+        from colcon_core.shell import create_environment_hook
+
+        pkg = self.context.pkg
+        args = self.context.args
+
+        additional_hooks = create_environment_hook(
+            "ament_prefix_path",
+            Path(args.install_base) / pkg.name,
+            pkg.name,
+            "AMENT_PREFIX_PATH",
+            "",
+            mode="prepend",
+        )
+
+        hooks = create_environment_hooks(Path(args.install_base) / pkg.name, pkg.name)
+        create_environment_scripts(
+            pkg, args, default_hooks=list(hooks), additional_hooks=additional_hooks
+        )

colcon_uv/task/uv/test.py

@@ -0,0 +1,47 @@
+"""Test task for UV-based Python packages."""
+
+import subprocess
+from pathlib import Path
+
+from colcon_core.logging import colcon_logger
+from colcon_core.plugin_system import satisfies_version
+from colcon_core.task import TaskExtensionPoint
+
+logger = colcon_logger.getChild("colcon.uv.task.test")
+
+
+class UvTestTask(TaskExtensionPoint):
+    """Test task for UV-based Python packages."""
+
+    def __init__(self):  # noqa: D107
+        super().__init__()
+        satisfies_version(TaskExtensionPoint.EXTENSION_POINT_VERSION, "^1.0")
+
+    def add_arguments(self, *, parser):  # noqa: D102
+        parser.add_argument(
+            "--uv-args",
+            nargs="*",
+            metavar="*",
+            type=str.lstrip,
+            help="Pass arguments to UV. "
+            "Arguments matching other options must be prefixed by a space,\n"
+            'e.g. --uv-args " --help"',
+        )
+
+    async def test(self, *, additional_hooks=None):  # noqa: D102
+        pkg = self.context.pkg
+        args = self.context.args
+
+        logger.info("Testing UV package in '{args.path}'".format_map(locals()))
+
+        # Get virtual environment path
+        venv_path = Path(args.build_base) / "venv"
+        if not venv_path.exists():
+            logger.error(
+                "Virtual environment not found. Please build the package first."
+            )
+            return
+
+        # Run tests using pytest
+        logger.info("Running tests...")
+        subprocess.run([str(venv_path / "bin" / "pytest"), str(pkg.path)], check=True)

colcon_uv-0.0.1.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: colcon-uv
+Version: 0.0.1
+Summary: A Colcon extension providing support for Python projects that use UV
+Project-URL: Homepage, https://github.com/nzlz/colcon-uv
+Author-email: Nestor Gonzalez <nestor94gonzalez@gmail.com>
+Maintainer-email: Nestor Gonzalez <nestor94gonzalez@gmail.com>
+License: BSD-3-Clause
+Keywords: colcon
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Dist: colcon-core~=0.6
+Requires-Dist: tomli>=1.2.0
+Description-Content-Type: text/markdown
+
+# colcon-uv
+
+[![CI](https://github.com/nzlz/colcon-uv/actions/workflows/ci.yml/badge.svg)](https://github.com/nzlz/colcon-uv/actions/workflows/ci.yml)
+
+A **colcon extension** for building and testing Python packages that use **[uv](https://github.com/astral-sh/uv)** for dependency management.
+
+## Features
+
+- **Fast Dependency Management**: Leverages UV's lightning-fast dependency resolution and installation
+- **Modern Python Packaging**: Support for `pyproject.toml`-based packages following PEP 517/518 standards
+- **ROS Integration**: Seamless integration with colcon build system and ROS package management
+- **Dependency Isolation**: Prevents dependency conflicts between packages
+
+## Installation
+
+```bash
+pip install colcon-uv
+```
+
+## Configuration
+
+### Data Files
+
+Similar to [colcon-poetry-ros](https://github.com/UrbanMachine/colcon-poetry-ros), you can specify data files using the `[tool.colcon-uv-ros.data-files]` section:
+
+```toml
+[tool.colcon-uv-ros.data-files]
+"share/ament_index/resource_index/packages" = ["resource/{package_name}"]
+"share/{package_name}" = ["package.xml", "launch/", "config/"]
+"lib/{package_name}" = ["scripts/"]
+```
+
+**Required entries** for all ROS packages:
+
+```toml
+[tool.colcon-uv-ros.data-files]
+"share/ament_index/resource_index/packages" = ["resource/{package_name}"]
+"share/{package_name}" = ["package.xml"]
+```
+
+### Package Dependencies
+
+Specify package dependencies for build ordering and to use system libraries (fetched from system paths, not installed in virtual environment):
+
+```toml
+[tool.colcon-uv-ros.dependencies]
+depend = ["rclpy", "geometry_msgs"]  # System packages (adds to both build_depend and exec_depend)
+build_depend = ["bar_package"]       # Build-time only dependency
+exec_depend = ["std_msgs"]           # Runtime system library
+test_depend = ["qux_package"]        # Test-time only dependency
+```
+
+**Important**: ROS system libraries like `rclpy`, `geometry_msgs`, `std_msgs`, etc. should be listed here so they are resolved from the system installation rather than being installed into the virtual environment.

colcon_uv-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+colcon_uv/__init__.py,sha256=8KK-O_XfVuu9Ubj2TcQft9hNogiJQ40U-Iip8vbu_pE,76
+colcon_uv/cli.py,sha256=TX4_FP1FKDpR0pGkiiKc0-OQThQoYtqEs0EK-gpaJiE,3033
+colcon_uv/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+colcon_uv/dependencies/install.py,sha256=v9oNIX8JhQtgus3coxu1oshWps7gupqTVRXSMwD_NMM,5637
+colcon_uv/package_augmentation/__init__.py,sha256=_Z2QV8zXzG_8SfobclzxMrlLr0AvYuoMksEXwJEVl8Y,163
+colcon_uv/package_augmentation/uv.py,sha256=WuE76pJ1OXqrKNh2__KE9NMQMlK6eQg6Cb-6YK6jQT0,5132
+colcon_uv/package_identification/__init__.py,sha256=uLfNAqg-obGtQoLrwyUGtzTxT_dqLe9KsBfl-eTMjIc,171
+colcon_uv/package_identification/uv.py,sha256=H1snv1YG349Jmxz0E8_Kh50UDSVOwngUirkd_9Y-iws,1978
+colcon_uv/task/__init__.py,sha256=A09krWgApqaeh_YPpzURMSloItEz3SCMkd-pDmnozb4,178
+colcon_uv/task/uv/__init__.py,sha256=1htbhWTxp42siw-xHbRrcRQCSuK6zIp6N_nOgYcf1_g,172
+colcon_uv/task/uv/build.py,sha256=GalspkAe4FhuSkMf-cvj8-8_ySVVkbykeuSr3eeZ3_0,5756
+colcon_uv/task/uv/test.py,sha256=1CAiHzJJIgFEOHJKesOV-xJGlsFA7V1iI247-zSENhM,1526
+colcon_uv-0.0.1.dist-info/METADATA,sha256=PWuc7QI1Jlsdo0w5qDpurXKnsiQxGcn3nJRqsRTqL2g,2809
+colcon_uv-0.0.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+colcon_uv-0.0.1.dist-info/entry_points.txt,sha256=c3r5DG7L2VfygiA4QDIr4qQXkb3nEIwC05hycOY6L84,390
+colcon_uv-0.0.1.dist-info/RECORD,,

colcon_uv-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

colcon_uv-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,14 @@
+[colcon_core.package_augmentation]
+uv = colcon_uv.package_augmentation.uv:UvPackageAugmentation
+
+[colcon_core.package_identification]
+uv = colcon_uv.package_identification.uv:UvPackageIdentification
+
+[colcon_core.task.build]
+uv.python = colcon_uv.task.uv.build:UvBuildTask
+
+[colcon_core.task.test]
+uv.python = colcon_uv.task.uv.test:UvTestTask
+
+[colcon_core.verb]
+uv = colcon_uv.cli:UvVerb