Upgrade all dependencies to their latest version using uv

upgrade.py

#!/usr/bin/env python
# https://gist.github.com/yhoiseth/c80c1e44a7036307e424fce616eed25e
from typing import Any
from re import match, Match
import toml
import subprocess


def main() -> None:
    with open("pyproject.toml", "r") as file:
        pyproject: dict[str, Any] = toml.load(file)
    dependencies: list[str] = pyproject["project"]["dependencies"]
    package_name_pattern = r"^[a-zA-Z0-9\-]+"
    for dependency in dependencies:
        package_match = match(package_name_pattern, dependency)
        assert isinstance(package_match, Match)
        package = package_match.group(0)
        uv("remove", package)
        uv("add", package)


def uv(command: str, package: str) -> None:
    subprocess.run(["uv", command, package])


if __name__ == "__main__":
    main()

I wrote a command-line program using typer.
It can update the version in pyproject.toml while preserving the original order.

# ruff: noqa: S603
import functools
import subprocess  # noqa: S404
import tomllib
from dataclasses import dataclass
from pathlib import Path
from typing import Annotated, Literal, Self

import tomlkit
import typer
from tomlkit.items import Array as TomlArray

type DependencyMap = dict[str | None, list[str]]  # [GroupName, Dependencies]


@dataclass
class PackageSpec:
    name: str
    extras: str | None

    @classmethod
    def from_dependency(cls, dependency: str) -> Self:
        """parse package spec from dependency string

        examples:
        - requests>=1.0
        - fastapi[all]>=0.115.4
        - pandas[excel,plot]>=2.2.2
        - sqlacodegen==3.0.0rc5
        """

        for separator in (">=", "==", "<=", "~=", ">", "<", "!="):
            if separator in dependency:
                name_part = dependency.split(separator)[0].strip()
                break
        else:
            name_part = dependency.strip()

        if "[" in name_part:
            name, extras = name_part.split("[", 1)
            extras = f"[{extras}"
        else:
            name = name_part
            extras = None

        return cls(name=name, extras=extras)

    def __str__(self) -> str:
        """convert to dependency string"""
        return f"{self.name}{self.extras or ''}"


def get_original_order(pyproject_path: Path) -> DependencyMap:
    with pyproject_path.open("rb") as f:
        pyproject = tomllib.load(f)

    return {
        None: pyproject["project"]["dependencies"],
        **pyproject.get("dependency-groups", {}),
    }


def restore_order(pyproject_path: Path, original_orders: DependencyMap) -> None:
    """restore the order of dependencies in pyproject.toml"""

    def create_toml_array(dependencies: list[str]) -> TomlArray:
        array = tomlkit.array()
        array.multiline(True)
        array.extend(dependencies)
        return array

    with pyproject_path.open("rb") as updated_file:
        updated_data = tomllib.load(updated_file)

    with pyproject_path.open("r", encoding="utf-8") as f:
        doc = tomlkit.load(f)

    # update main dependencies
    updated_deps = {
        PackageSpec.from_dependency(dep).name: dep
        for dep in updated_data["project"]["dependencies"]
    }

    new_deps = create_toml_array(
        [
            updated_deps[PackageSpec.from_dependency(orig_dep).name]
            for orig_dep in original_orders[None]
            if PackageSpec.from_dependency(orig_dep).name in updated_deps
        ]
    )

    doc["project"]["dependencies"] = new_deps  # type: ignore[index]

    # update dependency groups
    if "dependency-groups" in updated_data:
        for group, orig_deps in original_orders.items():
            if group is None or group not in updated_data["dependency-groups"]:
                continue

            updated_group_deps = {
                PackageSpec.from_dependency(dep).name: dep
                for dep in updated_data["dependency-groups"][group]
            }

            new_group_deps = create_toml_array(
                [
                    updated_group_deps[PackageSpec.from_dependency(orig_dep).name]
                    for orig_dep in orig_deps
                    if PackageSpec.from_dependency(orig_dep).name in updated_group_deps
                ]
            )

            doc["dependency-groups"][group] = new_group_deps  # type: ignore[index]

    with pyproject_path.open("w", encoding="utf-8") as f:
        tomlkit.dump(doc, f)


def print_format_command(command: list[str]) -> None:
    cmd = command.copy()

    cmd[0] = typer.style(cmd[0], fg=typer.colors.GREEN)  # uv
    cmd[1] = typer.style(cmd[1], fg=typer.colors.YELLOW)  # action

    flag_idx = next((i for i, v in enumerate(cmd) if v.startswith("--")), len(cmd))

    # package name
    cmd[2:flag_idx] = [typer.style(t, bold=True) for t in cmd[2:flag_idx]]

    # action options
    cmd[flag_idx:] = [typer.style(t, fg=typer.colors.CYAN) for t in cmd[flag_idx:]]

    print(" ".join(cmd))


def uv_action(
    action: Literal["add", "remove", "sync", "lock"],
    verbose: bool = False,
    *,
    package_spec: list[PackageSpec] | None = None,
    group: str | None = None,
) -> None:
    if action == "sync":
        command = ["uv", "sync", "--all-groups"]
        print("=" * 40)
    elif action == "lock":
        command = ["uv", "lock", "--upgrade"]
    else:
        if package_spec is None:
            raise ValueError("package_spec is required")
        packages = [str(pkg) if action == "add" else pkg.name for pkg in package_spec]
        group_arg = ["--group", group] if group else []
        command = ["uv", action, *packages, "--no-sync", *group_arg]

    if verbose:
        print_format_command(command)
        subprocess.check_call(command)
    elif action in {"sync", "lock"}:
        subprocess.check_call(command)
    else:
        subprocess.check_call(command, stderr=subprocess.DEVNULL)


def run_uv_command(all_dependencies: DependencyMap, verbose: bool = False) -> None:
    run_uv_action = functools.partial(uv_action, verbose=verbose)

    run_uv_action("lock")

    for group, dependencies in all_dependencies.items():
        # filter out packages with pinned versions
        packages = [
            PackageSpec.from_dependency(dep) for dep in dependencies if "==" not in dep
        ]

        run_uv_action("remove", package_spec=packages, group=group)
        run_uv_action("add", package_spec=packages, group=group)

    run_uv_action("sync")


def main(
    path: Annotated[Path, typer.Argument()] = Path("./pyproject.toml"),
    sort_deps: Annotated[
        bool,
        typer.Option("--sort", "-S", help="sort dependencies in pyproject.toml"),
    ] = False,
    verbose: Annotated[bool, typer.Option("--verbose", "-V")] = False,
) -> None:
    if path.name != "pyproject.toml":
        raise typer.BadParameter("file must be pyproject.toml")

    original_orders = get_original_order(path)
    run_uv_command(original_orders, verbose)
    if not sort_deps:
        restore_order(path, original_orders)


if __name__ == "__main__":
    typer.run(main)

Great!!

After trying these and similar commands, I've returned to Renovate Bot to upgrade my packages. Bot does it in more configurable way, even if I run it locally

Thank you @gbaian10, your script worked perfectly for me.

Perhaps you can consider adding the requirements at the top to make it possible to run without a venv with uv:

#! /usr/bin/env -S uv run --script
#
# Source:
# https://gist.github.com/yhoiseth/c80c1e44a7036307e424fce616eed25e?permalink_comment_id=5387642#gistcomment-5387642
#
# /// script
# requires-python = ">=3.12"
# dependencies = [
#   "typer>=0.15.3",
#   "tomlkit>=0.13.2",
# ]
# ///

Thank you @gbaian10, your script worked perfectly for me.

Perhaps you can consider adding the requirements at the top to make it possible to run without a venv with uv:

#! /usr/bin/env -S uv run --script
#
# Source:
# https://gist.github.com/yhoiseth/c80c1e44a7036307e424fce616eed25e?permalink_comment_id=5387642#gistcomment-5387642
#
# /// script
# requires-python = ">=3.12"
# dependencies = [
#   "typer>=0.15.3",
#   "tomlkit>=0.13.2",
# ]
# ///

Thanks. I think this script is still quite rough — it mostly just handles cases where your package uses >= or ==.
Later, I realized it doesn't account for situations without any symbol (with use [tool.uv.sources]), and maybe such cases should also be skipped.