uv-upx 0.2.0__py3-none-any.whl

uv_upx/__init__.py

@@ -0,0 +1,5 @@
+from .main import main
+
+__all__ = [
+    "main",
+]

uv_upx/__main__.py

@@ -0,0 +1,4 @@
+from uv_upx.main import main
+
+if __name__ == "__main__":
+    main()

uv_upx/cli/main.py

@@ -0,0 +1,37 @@
+import pathlib  # noqa: TC003
+from typing import Annotated
+
+import typer
+
+from uv_upx.services.normalize_and_check_path_to_pyproject import normalize_and_check_path_to_project_root
+from uv_upx.services.run_updater import run_updater
+
+app = typer.Typer(
+    pretty_exceptions_enable=False,
+)
+
+
+@app.command()
+def run(
+    *,
+    project_root_path: Annotated[
+        pathlib.Path | None,
+        typer.Option(
+            "--project",
+            "-p",
+            help="Path to project root directory. Use current working directory if not specified.",
+        ),
+    ] = None,
+    #
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show changes without writing file")] = False,
+    #
+    verbose: Annotated[bool, typer.Option("--verbose", help="Show more output")] = False,
+) -> None:
+    """Update pyproject.toml dependencies to latest PyPI releases."""
+    path = normalize_and_check_path_to_project_root(project_root_path)
+
+    run_updater(
+        project_root_path=path,
+        dry_run=dry_run,
+        verbose=verbose,
+    )

uv_upx/logging_custom/__init__.py

@@ -0,0 +1,5 @@
+from .init_logging import init_logging
+
+__all__ = [
+    "init_logging",
+]

uv_upx/logging_custom/init_logging.py

@@ -0,0 +1,8 @@
+import logging
+
+
+def init_logging() -> None:
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )

uv_upx/main.py

@@ -0,0 +1,7 @@
+from uv_upx.cli.main import app
+from uv_upx.logging_custom import init_logging
+
+
+def main() -> None:
+    init_logging()
+    app()

uv_upx/models/dependency_parsed.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+
+from uv_upx.services.get_deps_from_project import DependencyName
+
+
+class VersionConstraint(BaseModel):
+    operator: str
+    version: str
+
+
+class DependencyParsed(BaseModel):
+    # https://peps.python.org/pep-0508/
+
+    dependency_name: DependencyName
+    """Dependency name (e.g., requests)"""
+
+    extras: list[str] | None
+    """Extras (e.g., [dev])"""
+
+    version_constraints: list[VersionConstraint]
+    """Version constraints (e.g., >=1.2.3, ==4.5.6)"""
+
+    marker: str | None
+    """Environment marker (after ;)"""
+
+    def get_full_spec(self) -> str:
+        parts: list[str] = [self.dependency_name]
+        if self.extras:
+            extras_str = ",".join(self.extras)
+            parts.append(f"[{extras_str}]")
+        if self.version_constraints:
+            vc_strs = [f"{vc.operator}{vc.version}" for vc in self.version_constraints]
+            parts.append(",".join(vc_strs))
+        if self.marker:
+            parts.append(f"; {self.marker}")
+        return "".join(parts)

uv_upx/services/get_all_pyprojects.py

@@ -0,0 +1,62 @@
+import pathlib
+from typing import Any, cast
+
+from pydantic import BaseModel, ConfigDict
+from tomlkit import TOMLDocument
+
+from uv_upx.services.get_pyproject_paths_by_globs import get_pyproject_paths_by_globs
+from uv_upx.services.normalize_and_check_path_to_pyproject import get_and_check_path_to_pyproject
+from uv_upx.services.save_load_toml import load_toml
+
+
+class PyProjectWrapper(BaseModel):
+    path: pathlib.Path
+    data: TOMLDocument
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+
+class PyProjectsRegistry(BaseModel):
+    items: list[PyProjectWrapper]
+
+
+def get_all_pyprojects(
+    project_root_path: pathlib.Path,
+) -> PyProjectsRegistry:
+    """Find all pyproject.toml files in the project tree.
+
+    Use `workspaces` from uv.
+    """
+    items: list[PyProjectWrapper] = []
+
+    root_pyproject_path = get_and_check_path_to_pyproject(project_root_path)
+    root_pyproject_data = load_toml(root_pyproject_path)
+    items.append(PyProjectWrapper(path=root_pyproject_path, data=root_pyproject_data))
+
+    # Get workspaces_config
+    # https://docs.astral.sh/uv/concepts/projects/workspaces/
+
+    # Example:
+    # [tool.uv.workspace]
+    # members = ["packages/*"]
+    # exclude = ["packages/seeds"]
+
+    # TODO: (?) Improve this place for efficiency
+
+    workspaces_config: dict[str, Any] = root_pyproject_data.get("tool", {}).get("uv", {}).get("workspace", {})  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+    members_i_relative_glob_based: list[str] = cast("list[str]", workspaces_config.get("members", []))  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+    exclude_i_relative_glob_based: list[str] = cast("list[str]", workspaces_config.get("exclude", []))  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    # Use glob-based pattern matching to find all pyproject.toml files in the workspace
+    members_paths_set = get_pyproject_paths_by_globs(project_root_path, members_i_relative_glob_based)
+    exclude_paths_set = get_pyproject_paths_by_globs(project_root_path, exclude_i_relative_glob_based)
+
+    result_paths_set = members_paths_set - exclude_paths_set
+
+    for path in result_paths_set:
+        data = load_toml(path)
+        items.append(PyProjectWrapper(path=path, data=data))
+
+    return PyProjectsRegistry(items=items)

uv_upx/services/get_deps_from_project.py

@@ -0,0 +1,141 @@
+import subprocess
+from typing import TYPE_CHECKING, NewType
+
+from uv_upx.services.normalize_and_check_path_to_pyproject import get_and_check_path_to_uv_lock
+from uv_upx.services.save_load_toml import load_toml
+
+if TYPE_CHECKING:
+    import pathlib
+
+DependencyName = NewType("DependencyName", str)
+Version = NewType("Version", str)
+
+type DependenciesRegistry = dict[DependencyName, Version]
+
+
+def parse_from_pip(
+    workdir: pathlib.Path,
+) -> DependenciesRegistry:
+    data = subprocess.run(
+        # uv pip list --outdated
+        ["uv", "pip", "list", "--outdated"],  # noqa: S607
+        check=True,
+        cwd=workdir,
+        capture_output=True,
+        text=True,
+    )
+
+    # Note: It doesn't provide all necessary dependencies.
+
+    # Example output:
+    # Package        Version Latest Type
+    # -------------- ------- ------ -----
+    # anyio          4.11.0  4.12.0 wheel
+    # basedpyright   1.34.0  1.35.0 wheel
+    # beautifulsoup4 4.14.2  4.14.3 wheel
+
+    dependencies: DependenciesRegistry = {}
+    # Note: skip the header line
+    for line in data.stdout.splitlines()[2:]:
+        package, _current_version, latest, _type = line.split()
+        dependencies[DependencyName(package)] = Version(latest)
+
+    return dependencies
+
+
+def parse_from_uv_tree(
+    workdir: pathlib.Path,
+) -> DependenciesRegistry:
+    # Note: use this because it has better checks for outdated.
+    # For example, `uv pip list --outdated` may miss some packages.
+    # But we need extra parsing.
+
+    data = subprocess.run(
+        # uv tree --outdated --depth 1 --color never
+        [  # noqa: S607
+            "uv",
+            "tree",
+            "--outdated",
+            "--depth",
+            "1",
+            "--color",
+            "never",
+        ],
+        check=True,
+        cwd=workdir,
+        capture_output=True,
+        text=True,
+    )
+
+    # Example output:
+    # Resolved 129 packages in 0.61ms
+    # python-lab v0.1.0
+    # ├── jupyter v1.0.0 (latest: v1.1.1)
+    # ├── matplotlib v3.10.7
+    # ├── pydantic v2.12.5
+    # └── pytest v9.0.2 (group: dev)
+
+    # Parse
+
+    dependencies: DependenciesRegistry = {}
+    for line in data.stdout.splitlines():
+        line = line.strip()  # noqa: PLW2901
+        if not line:
+            continue
+
+        if line[0].isalpha():
+            # Skip the root package line
+            continue
+
+        parts = line.split(maxsplit=3)
+        # Skip decorative prefix
+        parts.pop(0)
+
+        dependency_name = DependencyName(parts.pop(0))
+
+        # Get version
+        version_candidate = parts.pop(0)
+
+        if len(parts) == 1:
+            version_parts = parts.pop(0).split(") (")
+
+            # Check another version with the "latest:" marker
+            for part in version_parts:
+                part = part.strip("(").rstrip(")")  # noqa: PLW2901
+
+                sub_parts = part.split(":", 1)
+
+                if len(sub_parts) == 2 and sub_parts[0] == "latest":  # noqa: PLR2004
+                    version_candidate = sub_parts[1]
+
+        elif len(parts) > 1:
+            msg = f"Unexpected line format: {line}"
+            raise ValueError(msg)
+
+        # Strip "v" prefix
+        version_candidate = version_candidate.strip().lstrip("v")
+
+        dependencies[dependency_name] = Version(version_candidate)
+
+    return dependencies
+
+
+def parse_from_uv_lock(
+    workdir: pathlib.Path,
+) -> DependenciesRegistry:
+    uv_lock_path = get_and_check_path_to_uv_lock(workdir)
+
+    data = load_toml(uv_lock_path)
+
+    dependencies: DependenciesRegistry = {}
+    for package in data.get("package", []):  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        dependencies[DependencyName(package["name"])] = Version(package["version"])  # pyright: ignore[reportUnknownArgumentType] # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+
+    return dependencies
+
+
+def get_deps_from_project(
+    workdir: pathlib.Path,
+) -> DependenciesRegistry:
+    """Get dependencies info."""
+    return parse_from_uv_lock(workdir=workdir)

uv_upx/services/get_pyproject_paths_by_globs.py

@@ -0,0 +1,32 @@
+import logging
+from typing import TYPE_CHECKING
+
+from uv_upx.services.normalize_and_check_path_to_pyproject import NAME_OF_PYPROJECT_FILE
+
+if TYPE_CHECKING:
+    import pathlib
+
+
+def get_pyproject_paths_by_globs(
+    base_path: pathlib.Path,
+    patterns: list[str],
+) -> set[pathlib.Path]:
+    paths: set[pathlib.Path] = set()
+
+    logger = logging.getLogger(__name__)
+
+    for pattern in patterns:
+        for path in base_path.glob(pattern):
+            if path.is_file():
+                if path.name == NAME_OF_PYPROJECT_FILE:
+                    paths.add(path)
+            elif path.is_dir():
+                path_candidate = path / NAME_OF_PYPROJECT_FILE
+                if path_candidate.exists():
+                    paths.add(path_candidate)
+            else:
+                # sourcery skip: remove-redundant-pass
+                # Explicit skip for other cases
+                logger.warning(f"Skipping {path.as_uri()}: not a file or directory.")
+
+    return paths

uv_upx/services/handle_groups.py

@@ -0,0 +1,189 @@
+import logging
+from typing import TYPE_CHECKING, Any
+
+from uv_upx.services.save_load_toml import save_toml
+from uv_upx.services.update_dependencies import ChangesList, IncludedDependencyGroup, update_dependencies
+
+if TYPE_CHECKING:
+    from tomlkit import TOMLDocument
+
+    from uv_upx.services.get_all_pyprojects import PyProjectsRegistry, PyProjectWrapper
+    from uv_upx.services.get_deps_from_project import DependenciesRegistry
+
+
+# https://docs.astral.sh/uv/concepts/projects/dependencies/
+
+
+def handle_main_dependency_group(
+    *,
+    data: TOMLDocument,
+    dependencies_registry: DependenciesRegistry,
+    verbose: bool = False,
+) -> ChangesList:
+    """Check the main dependencies group."""
+    logger = logging.getLogger(__name__)
+
+    project: dict[Any, Any] = data.get("project", {})  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+    if not isinstance(project, dict):
+        logger.warning("No [project] table found in pyproject.toml")
+        return []
+
+    dependencies: list[str] = project.get("dependencies", [])  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+    if not isinstance(dependencies, list):
+        logger.warning("No [project].dependencies found in pyproject.toml")
+        return []
+
+    return update_dependencies(
+        deps_sequence_from_config=dependencies,  # pyright: ignore[reportUnknownArgumentType]
+        dependencies_registry=dependencies_registry,
+        verbose=verbose,
+    )
+
+
+def handle_dependency_groups(
+    *,
+    data: TOMLDocument,
+    dependencies_registry: DependenciesRegistry,
+    verbose: bool = False,
+) -> ChangesList:
+    """Check the dependency-groups table.
+
+    https://docs.astral.sh/uv/concepts/projects/dependencies/#development-dependencies
+    """
+    return handle_dependency_groups_inner(
+        groups=data.get("dependency-groups", {}),  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        dependencies_registry=dependencies_registry,
+        verbose=verbose,
+    )
+
+
+def handle_optional_dependencies(
+    *,
+    data: TOMLDocument,
+    dependencies_registry: DependenciesRegistry,
+    verbose: bool = False,
+) -> ChangesList:
+    """Check the project.optional-dependencies table.
+
+    https://docs.astral.sh/uv/concepts/projects/dependencies/#optional-dependencies
+    """
+    return handle_dependency_groups_inner(
+        groups=data.get("project", {}).get("optional-dependencies", {}),  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        dependencies_registry=dependencies_registry,
+        verbose=verbose,
+    )
+
+
+def handle_dependency_groups_inner(
+    *,
+    groups: Any,  # noqa: ANN401
+    dependencies_registry: DependenciesRegistry,
+    verbose: bool = False,
+) -> ChangesList:
+    """Check the dependency-groups table.
+
+    https://docs.astral.sh/uv/concepts/projects/dependencies/#development-dependencies
+
+    https://docs.astral.sh/uv/concepts/projects/dependencies/#optional-dependencies
+    """
+    logger = logging.getLogger(__name__)
+
+    if not isinstance(groups, dict):
+        return []
+
+    dependency_groups: dict[str, Any] = groups  # pyright: ignore[reportUnknownVariableType]
+
+    changes: ChangesList = []
+    for _group_name, _group_val in dependency_groups.items():
+        if verbose:
+            logger.info(f"Checking group: {_group_name}")
+
+        if not isinstance(_group_val, list):
+            continue
+
+        group_val: list[str | IncludedDependencyGroup] = _group_val  # pyright: ignore[reportUnknownVariableType]
+
+        changes_local = update_dependencies(
+            deps_sequence_from_config=group_val,
+            dependencies_registry=dependencies_registry,
+            verbose=verbose,
+        )
+        changes.extend(changes_local)
+
+    return changes
+
+
+def handle_py_project(
+    *,
+    dependencies_registry: DependenciesRegistry,
+    pyproject_wrapper: PyProjectWrapper,
+    #
+    dry_run: bool,
+    verbose: bool,
+) -> ChangesList:
+    """Handle a single pyproject.toml file."""
+    logger = logging.getLogger(__name__)
+
+    data = pyproject_wrapper.data
+
+    changes: ChangesList = []
+
+    changes.extend(
+        handle_main_dependency_group(
+            data=data,
+            dependencies_registry=dependencies_registry,
+            verbose=verbose,
+        ),
+    )
+
+    changes.extend(
+        handle_dependency_groups(
+            data=data,
+            dependencies_registry=dependencies_registry,
+            verbose=verbose,
+        ),
+    )
+
+    changes.extend(
+        handle_optional_dependencies(
+            data=data,
+            dependencies_registry=dependencies_registry,
+            verbose=verbose,
+        ),
+    )
+
+    if changes:
+        if dry_run:
+            logger.info(f"[Dry Run] Changes detected in {pyproject_wrapper.path.as_uri()}, but not saving.")
+        else:
+            save_toml(pyproject_wrapper.path, data)
+            logger.info(f"Saved changes to {pyproject_wrapper.path.as_uri()}")
+
+            for change in changes:
+                logger.info(f"  {change}")
+
+    return changes
+
+
+def handle_py_projects(
+    *,
+    dependencies_registry: DependenciesRegistry,
+    py_projects: PyProjectsRegistry,
+    #
+    dry_run: bool,
+    verbose: bool,
+) -> ChangesList:
+    """Handle multiple pyproject.toml files."""
+    changes: ChangesList = []
+    for py_project in py_projects.items:
+        changes_local = handle_py_project(
+            dependencies_registry=dependencies_registry,
+            pyproject_wrapper=py_project,
+            #
+            dry_run=dry_run,
+            verbose=verbose,
+        )
+
+        changes.extend(changes_local)
+
+    return changes

uv_upx/services/normalize_and_check_path_to_pyproject.py

@@ -0,0 +1,41 @@
+import pathlib
+from typing import Final
+
+NAME_OF_PYPROJECT_FILE: Final[str] = "pyproject.toml"
+
+NAME_OF_UV_LOCK_FILE: Final[str] = "uv.lock"
+
+
+def normalize_and_check_path_to_project_root(path: pathlib.Path | None) -> pathlib.Path:
+    if path is None:
+        path = pathlib.Path.cwd()
+
+    if not path.is_dir():
+        msg = f"Path {path} is not a directory."
+        raise NotADirectoryError(msg)
+
+    if not path.exists():
+        msg = f"Path {path} does not exist."
+        raise FileNotFoundError(msg)
+
+    return path
+
+
+def get_and_check_path_to_pyproject(path: pathlib.Path) -> pathlib.Path:
+    path = path / NAME_OF_PYPROJECT_FILE
+
+    if not path.exists():
+        msg = f"Path {path} does not exist."
+        raise FileNotFoundError(msg)
+
+    return path
+
+
+def get_and_check_path_to_uv_lock(path: pathlib.Path) -> pathlib.Path:
+    path = path / NAME_OF_UV_LOCK_FILE
+
+    if not path.exists():
+        msg = f"Path {path} does not exist."
+        raise FileNotFoundError(msg)
+
+    return path

uv_upx/services/parse_dependency.py

@@ -0,0 +1,89 @@
+from uv_upx.models.dependency_parsed import DependencyParsed, VersionConstraint
+from uv_upx.services.get_deps_from_project import DependencyName
+
+
+def parse_dependency(  # noqa: C901, PLR0912, PLR0915
+    dependency_string: str,
+) -> DependencyParsed:  # sourcery skip: low-code-quality
+    dependency_string = dependency_string.strip()
+    if not dependency_string:
+        msg = "Empty dependency string"
+        raise ValueError(msg)
+
+    # split off environment marker (after ';')
+    parts = dependency_string.split(";", 1)
+    main = parts[0].strip()
+    marker = parts[1].strip() if len(parts) > 1 else None
+
+    # parse name and extras
+    name = main
+    extras: list[str] | None = None
+    version_part = ""
+
+    if "[" in main:
+        i = main.find("[")
+        j = main.find("]", i)
+        if j == -1:
+            msg = f"Invalid dependency string: {main}"
+            raise ValueError(msg)
+        name = main[:i].strip()
+        extras_str = main[i + 1 : j].strip()
+        extras = [e.strip() for e in extras_str.split(",") if e.strip()] or None
+        version_part = main[j + 1 :].strip()
+    else:
+        # try to locate the start of version/operator tokens
+        ops = ["===", "==", "~=", "!=", "<=", ">=", "<", ">", "@"]
+        first_pos = None
+        for op in ops:
+            idx = main.find(op)
+            if idx != -1 and (first_pos is None or idx < first_pos):
+                first_pos = idx
+        if first_pos is not None:
+            name = main[:first_pos].strip()
+            version_part = main[first_pos:].strip()
+        else:
+            name = main.strip()
+            version_part = ""
+
+    if not name:
+        msg = f"Invalid dependency string: {main}"
+        raise ValueError(msg)
+
+    # parse version constraints (comma separated)
+    version_constraints: list[VersionConstraint] = []
+    if version_part:
+        # do not attempt to parse direct URL / VCS refs (start with '@')
+        if version_part.startswith("@"):
+            msg = f"Invalid dependency string: {main}"
+            raise ValueError(msg)
+
+        raw_parts = [p.strip() for p in version_part.split(",") if p.strip()]
+        op_candidates = ["===", "==", "~=", "!=", "<=", ">=", "<", ">"]
+        for rp in raw_parts:
+            token = rp.lstrip()
+            matched = False
+            for op in op_candidates:
+                if token.startswith(op):
+                    ver = token[len(op) :].strip().strip("\"'")
+                    version_constraints.append(VersionConstraint(operator=op, version=ver))
+                    matched = True
+                    break
+            if not matched:
+                # allow a bit of tolerance for leading space before the operator
+                stripped = token.lstrip()
+                for op in op_candidates:
+                    if stripped.startswith(op):
+                        ver = stripped[len(op) :].strip().strip("\"'")
+                        version_constraints.append(VersionConstraint(operator=op, version=ver))
+                        matched = True
+                        break
+            if not matched:
+                msg = f"Invalid dependency string: {main}"
+                raise ValueError(msg)
+
+    return DependencyParsed(
+        dependency_name=DependencyName(name),
+        extras=extras,
+        version_constraints=version_constraints,
+        marker=marker,
+    )

uv_upx/services/rollback_updater.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+
+from uv_upx.services.run_uv_lock import run_uv_sync_frozen
+from uv_upx.services.save_load_toml import save_toml
+
+if TYPE_CHECKING:
+    import pathlib
+
+    from tomlkit import TOMLDocument
+
+    from uv_upx.services.get_all_pyprojects import PyProjectsRegistry
+
+
+def rollback_updater(
+    *,
+    uv_lock_path: pathlib.Path,
+    uv_lock_data: TOMLDocument,
+    #
+    py_projects: PyProjectsRegistry,
+) -> None:
+    save_toml(uv_lock_path, uv_lock_data)
+    for py_project in py_projects.items:
+        save_toml(py_project.path, py_project.data)
+
+    run_uv_sync_frozen(workdir=uv_lock_path.parent)

uv_upx/services/run_updater.py

@@ -0,0 +1,93 @@
+import copy
+import logging
+from typing import TYPE_CHECKING
+
+from uv_upx.services.get_all_pyprojects import get_all_pyprojects
+from uv_upx.services.get_deps_from_project import get_deps_from_project
+from uv_upx.services.handle_groups import handle_py_projects
+from uv_upx.services.normalize_and_check_path_to_pyproject import (
+    get_and_check_path_to_uv_lock,
+)
+from uv_upx.services.rollback_updater import rollback_updater
+from uv_upx.services.run_uv_lock import (
+    run_uv_sync,
+    run_uv_sync_upgrade,
+)
+from uv_upx.services.save_load_toml import load_toml
+
+if TYPE_CHECKING:
+    import pathlib
+
+
+def run_updater(
+    *,
+    project_root_path: pathlib.Path,
+    dry_run: bool = False,
+    verbose: bool = False,
+) -> None:
+    logger = logging.getLogger(__name__)
+
+    uv_lock_path = get_and_check_path_to_uv_lock(project_root_path)
+    uv_lock_data = load_toml(uv_lock_path)
+    uv_lock_data_copy = copy.deepcopy(uv_lock_data)
+
+    py_projects = get_all_pyprojects(project_root_path)
+    if verbose:
+        logger.info(f"Found {len(py_projects.items)} pyproject.toml files in the workspace.")
+        for py_project in py_projects.items:
+            logger.info(f"  {py_project.path.as_uri()}")
+
+    py_projects_copy = copy.deepcopy(py_projects)
+
+    is_rollback_needed = dry_run
+    rollback_message = "Rolling back to previous state because dry run is enabled."
+
+    try:
+        # Because we want to check build problems also.
+        run_uv_sync_upgrade(workdir=project_root_path)
+
+        dependencies_registry = get_deps_from_project(workdir=project_root_path)
+
+        if handle_py_projects(
+            py_projects=py_projects,
+            dependencies_registry=dependencies_registry,
+            #
+            dry_run=dry_run,
+            verbose=verbose,
+        ):
+            logger.info("Updated pyproject.toml files successfully.")
+
+            if dry_run:
+                logger.info("Dry run. No changes were made.")
+            else:
+                # run_uv_lock(workdir=project_root_path)
+                # logger.info("Updated dependencies successfully.")
+
+                # Because we want to re-check that all is ok.
+                run_uv_sync(workdir=project_root_path)
+                logger.info("Synced dependencies successfully.")
+
+        else:
+            msg = "No important changes detected. Rolling back to previous state."
+            logger.info(msg)
+            is_rollback_needed = True
+            rollback_message = msg
+
+    except Exception as e:  # noqa: BLE001
+        msg = f"Failed to update dependencies: '{e}' Rolling back to previous state."
+        logger.error(msg)  # noqa: TRY400
+        is_rollback_needed = True
+        rollback_message = msg
+
+    try:
+        if is_rollback_needed:
+            rollback_updater(
+                uv_lock_path=uv_lock_path,
+                uv_lock_data=uv_lock_data_copy,
+                #
+                py_projects=py_projects_copy,
+            )
+            logger.info(rollback_message)
+    except Exception as e:  # noqa: BLE001
+        msg = f"Failed to rollback: '{e}'"
+        logger.error(msg)  # noqa: TRY400

uv_upx/services/run_uv_lock.py

@@ -0,0 +1,86 @@
+import subprocess
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pathlib
+
+
+class UnresolvedDependencyError(Exception):
+    pass
+
+
+def run_uv_lock_upgrade(workdir: pathlib.Path) -> None:
+    try:
+        subprocess.run(
+            # uv lock --upgrade
+            ["uv", "lock", "--upgrade"],  # noqa: S607
+            check=True,
+            cwd=workdir,
+        )
+    except subprocess.CalledProcessError as e:
+        msg = "Failed to resolve dependencies with 'uv lock'. Please check your dependency specifications."
+        raise UnresolvedDependencyError(
+            msg,
+        ) from e
+
+
+def run_uv_lock(workdir: pathlib.Path) -> None:
+    try:
+        subprocess.run(
+            # uv lock
+            ["uv", "lock"],  # noqa: S607
+            check=True,
+            cwd=workdir,
+        )
+    except subprocess.CalledProcessError as e:
+        msg = "Failed to resolve dependencies with 'uv lock'. Please check your dependency specifications."
+        raise UnresolvedDependencyError(
+            msg,
+        ) from e
+
+
+def run_uv_sync(workdir: pathlib.Path) -> None:
+    try:
+        subprocess.run(
+            # uv sync --all-groups --all-extras --all-packages
+            ["uv", "sync", "--all-groups", "--all-extras", "--all-packages"],  # noqa: S607
+            check=True,
+            cwd=workdir,
+        )
+    except subprocess.CalledProcessError as e:
+        msg = "Failed to sync dependencies with 'uv sync'. Please check your dependency specifications."
+        raise UnresolvedDependencyError(
+            msg,
+        ) from e
+
+
+def run_uv_sync_upgrade(workdir: pathlib.Path) -> None:
+    # Note: Better to use this for new dependencies.
+    # Because it uses a better resolver for conflicts.
+    try:
+        subprocess.run(
+            # uv sync --all-groups --all-extras --all-packages --upgrade
+            ["uv", "sync", "--all-groups", "--all-extras", "--all-packages", "--upgrade"],  # noqa: S607
+            check=True,
+            cwd=workdir,
+        )
+    except subprocess.CalledProcessError as e:
+        msg = "Failed to sync dependencies with 'uv sync'. Please check your dependency specifications."
+        raise UnresolvedDependencyError(
+            msg,
+        ) from e
+
+
+def run_uv_sync_frozen(workdir: pathlib.Path) -> None:
+    try:
+        subprocess.run(
+            # uv sync --all-groups --all-extras --all-packages --frozen
+            ["uv", "sync", "--all-groups", "--all-extras", "--all-packages", "--frozen"],  # noqa: S607
+            check=True,
+            cwd=workdir,
+        )
+    except subprocess.CalledProcessError as e:
+        msg = "Failed to sync dependencies with 'uv sync'. Please check your dependency specifications."
+        raise UnresolvedDependencyError(
+            msg,
+        ) from e

uv_upx/services/save_load_toml.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING
+
+import tomlkit
+from tomlkit import TOMLDocument
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# TODO: (?) Use also "https://github.com/galactixx/tomlkit-extras"
+
+
+def load_toml(path: Path) -> TOMLDocument:
+    return tomlkit.parse(path.read_text(encoding="utf-8"))
+
+
+def save_toml(path: Path, data: TOMLDocument) -> None:
+    text = tomlkit.dumps(data)  # pyright: ignore[reportUnknownMemberType]
+    path.write_text(text, encoding="utf-8")

uv_upx/services/update_dependencies.py

@@ -0,0 +1,92 @@
+import copy
+import logging
+from typing import TYPE_CHECKING, Final
+
+from pydantic import BaseModel
+
+from uv_upx.models.dependency_parsed import DependencyParsed
+from uv_upx.services.parse_dependency import parse_dependency
+
+if TYPE_CHECKING:
+    from uv_upx.services.get_deps_from_project import DependenciesRegistry
+
+type IncludedDependencyGroup = dict[str, str]
+
+
+class ChangesItem(BaseModel):
+    from_item: DependencyParsed
+    to_item: DependencyParsed
+
+    def __str__(self) -> str:
+        return f"{self.from_item.get_full_spec()} -> {self.to_item.get_full_spec()}"
+
+
+type ChangesList = list[ChangesItem]
+
+VERSION_OPERATORS_I_PUT_IF_DIFFERENT: Final[set[str]] = {">="}
+
+VERSION_OPERATORS_I_EXPLICIT_IGNORE: Final[set[str]] = {"=="}
+
+
+def update_dependencies(  # noqa: C901, PLR0912
+    *,
+    deps_sequence_from_config: list[str] | list[str | IncludedDependencyGroup],
+    dependencies_registry: DependenciesRegistry,
+    verbose: bool = False,
+) -> ChangesList:
+    """Update the list of dependencies.
+
+    Update it in-place.
+    Because we want to preserve the comments.
+    """
+    logger = logging.getLogger(__name__)
+
+    changes: ChangesList = []
+    for _index, dep in enumerate(deps_sequence_from_config):
+        if verbose:
+            logger.info(f"Parsing dependency: {dep}")
+
+        if not isinstance(dep, str):
+            if verbose:
+                # https://docs.astral.sh/uv/concepts/projects/dependencies/#nesting-groups
+                logger.warning(f"Skipping non-string dependency: {dep}")
+            continue
+
+        parsed = parse_dependency(dep)
+
+        if verbose:
+            logger.info(f"Parsed dependency: {parsed}")
+
+        try:
+            version_new = dependencies_registry[parsed.dependency_name]
+        except KeyError as e:
+            # Note: raise error, because it now we have all the dependencies in the registry.
+            msg = f"Dependency not found in the registry: {parsed.dependency_name}"
+            raise ValueError(msg) from e
+
+        parsed_original = copy.deepcopy(parsed)
+
+        is_has_changes = False
+        for version_constraint in parsed.version_constraints:
+            if version_constraint.operator in VERSION_OPERATORS_I_PUT_IF_DIFFERENT:
+                # TODO: (?) Implement better version comparison logic here
+                if version_new != version_constraint.version:
+                    version_constraint.version = version_new
+                    is_has_changes = True
+
+            elif version_constraint.operator in VERSION_OPERATORS_I_EXPLICIT_IGNORE:
+                if verbose:
+                    msg = f"Explicitly ignoring version constraint {version_constraint}. Dependency: {dep}"
+                    logger.info(msg)
+            else:
+                if verbose:
+                    msg = f"Operator {version_constraint.operator} is not supported yet. Skip. Dependency: {dep}"
+                    logger.warning(msg)
+
+                continue
+
+        if is_has_changes:
+            deps_sequence_from_config[_index] = parsed.get_full_spec()
+            changes.append(ChangesItem(from_item=parsed_original, to_item=parsed))
+
+    return changes

uv_upx-0.2.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.3
+Name: uv-upx
+Version: 0.2.0
+Summary: Upgrade versions of dependencies in pyproject.toml files in uv-managed projects.
+Keywords: uv,upgrade,dependencies,pyproject.toml,automation,cli
+Author: Alirex
+Author-email: Alirex <alirex.prime@gmail.com>
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: tomlkit>=0.13.3
+Requires-Dist: typer>=0.20.0
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/Alirex/uv_upgrade
+Description-Content-Type: text/markdown
+
+# Uv upgrade
+
+Upgrade dependencies in `pyproject.toml` files with `uv`.
+
+---
+
+# Install
+
+For end-users.
+
+Note: For developers, see the [dev](docs_extra/dev.md) section.
+
+## Uv install or update
+
+You need this for both usage and development.
+
+https://docs.astral.sh/uv/getting-started/installation/
+
+On Windows it can be better to use `Git Bash` terminal.
+
+```bash
+if ! command -v uv &> /dev/null; then
+    curl -LsSf https://astral.sh/uv/install.sh | sh;
+else
+    uv self update;
+fi
+
+uv --version
+```
+
+## Install or update a project for system-wide usage
+
+Run it from any directory, except the project directory.
+
+```shell
+if ! command -v uv-upgrade &> /dev/null; then
+    uv tool install git+https://github.com/Alirex/uv_upgrade
+else
+    uv tool upgrade uv-upx
+fi
+```
+
+Or run with uvx:
+
+```shell
+uvx uv-upx
+```
+
+Dev installation: [see here](docs_extra/dev.md#install-app-system-wide-in-development-mode)
+
+## Check that project in the list
+
+```shell
+uv tool list --show-python
+```
+
+## Remove the project with all data
+
+If you need to remove the project with all data, run this command from the project directory:
+
+```shell
+uv tool uninstall uv-upx
+```
+
+---
+
+# Usage
+
+## Run the tool in the folder with the pyproject.toml
+
+After installation, you can run the tool from any directory.
+
+```shell
+uv-upgrade
+```
+
+Also, you can run it with the `--help` flag with more details.
+
+## Notes
+
+### Uv as a source of truth
+
+Run `uv sync --all-groups --all-extras --all-packages --upgrade`.
+
+Get dependencies versions from `uv.lock`.
+
+Put them in `pyproject.toml` files in related groups.
+
+So, the main responsibility for dependencies resolution is on `uv`.
+
+### Workspace support
+
+It works with workspaces. At least for some basic cases.
+
+### Updates simple dependencies
+
+Updates `>=` dependencies. Like `bla>=2.0.0`.
+
+### Skip pinned versions
+
+It doesn't touch pinned versions. Like `bla==2.0.0`.
+
+### Respect simple ranges
+
+It respects simple dependency ranges. Like `bla>=1.0.0,<2.0.0`.
+
+It moves the lower bound to the new version.
+
+### Respect extras
+
+It respects extras. Like `bla[dev]>=1.0.0;python_version>="3.14"`.
+
+### Skip unhandled constraints
+
+It skips unhandled and complex constraints. Like:
+
+- `bla<=1.0.0`
+- `bla>=2.0.0,!=1.5.0,<3.0.0`
+
+### Style preservation
+
+It preserves comments in the `pyproject.toml` file. Like here:
+
+```toml
+dependencies = [
+    # Better classes and data validation
+    "pydantic>=2.12.5",
+    # TOML parser and writer with preserved formatting
+    "tomlkit>=0.13.3",
+    # CLI app framework
+    "typer>=0.20.0",
+]
+```
+
+### Rollback
+
+If something goes wrong, it rolls back the changes to the `pyproject.toml` and `uv.lock` files.
+
+### Why?
+
+I needed this for my own projects.
+
+I know these issues:
+
+- [Upgrade dependencies in pyproject.toml (uv upgrade)](https://github.com/astral-sh/uv/issues/6692)
+- [What is the intended workflow for updating dependencies with uv?](ttps://github.com/astral-sh/uv/issues/6794)
+
+But I didn't see enough progress.
+
+So, I implemented this tool for my own usage.
+
+Maybe it will be useful for someone else.
+
+### Why not in Rust?
+
+Because it's a temporary Proof-of-Concept.
+
+Maybe it will be replaced by Rust in the future.
+
+It uses type annotations anyway. For simpler migration.
+
+---
+
+# Dev
+
+[Dev](docs_extra/dev.md)
+
+---
+
+# Other similar tools comparison
+
+[Other similar tools comparison](docs_extra/other_similar_tools_comparison.md)

uv_upx-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+uv_upx/__init__.py,sha256=rbBerQaGd0D2iPapShvgQ6lQlt88AQ872iv4obRBOi8,50
+uv_upx/__main__.py,sha256=-BgNoaEyq21dKa_PHEODSvEnAq-IRAexGZR-xehbQNU,68
+uv_upx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uv_upx/cli/main.py,sha256=DGpfzBxi9CP7J9VfnZcX4bg1Ol4H7aT25r7RHKlehg0,1044
+uv_upx/logging_custom/__init__.py,sha256=IF9q4lMvyP24yXnj30ivZzX5RIw48RBRxhcWcQpmin4,74
+uv_upx/logging_custom/init_logging.py,sha256=VlLhtOHd3YxfuDkWIptUYOlcfiyEW877yjqIA3xik60,176
+uv_upx/main.py,sha256=eRHt38xqNaaWWYq-AAy3FXLq7pQF7PeFEjizWzZnVrw,130
+uv_upx/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uv_upx/models/dependency_parsed.py,sha256=z0jiVn_0FLxyjbcvBy1lmbmqcAWyPNk5LWkE-uTnkqQ,1026
+uv_upx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uv_upx/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uv_upx/services/get_all_pyprojects.py,sha256=vwHEKrQ1-QrgQL4L0Mr3BEOaY-BychbLxBhDPT2QHtQ,2346
+uv_upx/services/get_deps_from_project.py,sha256=B5Fx0N2u7tGn-9Zt8qD4MIAdzeDLjQeSMeFJm2aiKuc,4057
+uv_upx/services/get_pyproject_paths_by_globs.py,sha256=Es0rETkVZQUyB5P2SVFRKOll1mp_XOLN9dKvRfi-q44,977
+uv_upx/services/handle_groups.py,sha256=EpRbK2rDo_CN0KS68_k_deLGS8Qhns6uo-9kwUilhpw,5647
+uv_upx/services/normalize_and_check_path_to_pyproject.py,sha256=7VXmR1Sq9I5sTQdRV9pP82nHshqj6vfQTLCLsJWncvA,1007
+uv_upx/services/parse_dependency.py,sha256=_Xgrys9oSyHPgGG3dV0tRWL7ihno1KTnCWkdCB_mpKA,3374
+uv_upx/services/rollback_updater.py,sha256=0kl7uIt16NtYoOv86tmFyFzaaTAU9PlJKOIuKG-2SqE,630
+uv_upx/services/run_updater.py,sha256=dLknXdYqXSaTEAQ2_DHtGTGz2KLUdyNbPjpNvwUCbRQ,3117
+uv_upx/services/run_uv_lock.py,sha256=tPIjOEfYkpBb9RToNn2HHy4ozU0dg-z_Gw8joil6MNM,2786
+uv_upx/services/save_load_toml.py,sha256=5GK0_CsqxAC8uSmqd-hkQGZnHYhuKeZNPi5JeJWgLgY,478
+uv_upx/services/update_dependencies.py,sha256=yM_8mccwiQ42uLlfrgehSO7ROAnWWWTcs1aXTFm-r34,3150
+uv_upx-0.2.0.dist-info/WHEEL,sha256=xDCZ-UyfvkGuEHPeI7BcJzYKIZzdqN8A8o1M5Om8IyA,79
+uv_upx-0.2.0.dist-info/entry_points.txt,sha256=9zUzK7AuGeOfnZbapni_IeaqbXn6c3RfFDE9MHe4HFo,44
+uv_upx-0.2.0.dist-info/METADATA,sha256=-R5INUX-wHGUtFUzir-rLA_PEO3Y5w5Bdh1E2LLLGLQ,3880
+uv_upx-0.2.0.dist-info/RECORD,,

uv_upx-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.17
+Root-Is-Purelib: true
+Tag: py3-none-any

uv_upx-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+uv-upgrade = uv_upx:main
+