colcon-uv 0.0.1__tar.gz

colcon_uv-0.0.1/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# ROS specific
+install/
+build/
+log/
+devel/
+
+# Colcon specific
+.colcon_install_layout
+.colcon_build_layout
+
+# UV specific
+.uv/
+uv.lock
+
+# Docker
+.dockerignore
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db 
+
+# Github Actions
+act*

colcon_uv-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,53 @@
+# 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/colcon_uv/__init__.py

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

colcon_uv-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-0.0.1/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-0.0.1/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"]