uv-upsync 1.1.2__py3-none-any.whl

uv_upsync/__init__.py

@@ -0,0 +1,6 @@
+"""uv-upsync - is a tool for automated dependency updates and version bumping in pyproject.toml."""
+
+from __future__ import annotations
+
+
+__version__ = "1.1.2"

uv_upsync/__main__.py

@@ -0,0 +1,150 @@
+"""Module that contains the main entry point for the uv-upsync."""
+
+from __future__ import annotations
+
+import copy
+import pathlib
+
+import click
+import tomlkit
+
+from uv_upsync import commands
+from uv_upsync import logging
+from uv_upsync import parsers
+from uv_upsync import uv
+
+
+logger = logging.Logger()
+
+
+@click.command(cls=commands.Command)
+@click.option(
+    "-f",
+    "--filepath",
+    type=click.Path(exists=True, dir_okay=False, path_type=pathlib.Path),
+    default=pathlib.Path.cwd() / "pyproject.toml",
+    help=f"Filepath to the pyproject.toml file "
+    f"(default: {click.style('./pyproject.toml', fg='magenta')})",
+)
+@click.option(
+    "--exclude",
+    type=click.STRING,
+    multiple=True,
+    default=(),
+    help="Packages to exclude from updating "
+    f"({click.style('multiple values allowed', fg='magenta')})",
+)
+@click.option(
+    "--group",
+    type=click.STRING,
+    multiple=True,
+    default=(),
+    help="Specific dependency group(s) to update. Can be 'project', optional-dependencies names, "
+    f"or dependency-groups names ({click.style('multiple values allowed', fg='magenta')}). "
+    "If not specified, all groups are updated.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    type=click.BOOL,
+    default=False,
+    help="Preview changes without writing to pyproject.toml",
+)
+def main(  # noqa: C901, PLR0912, PLR0915
+    filepath: pathlib.Path,
+    exclude: tuple[str, ...],
+    group: tuple[str, ...],
+    *,
+    dry_run: bool,
+) -> None:
+    """uv-upsync - is a tool for automated dependency updates and version bumping in pyproject.toml."""  # noqa: E501
+    with filepath.open() as toml_file:
+        pyproject = tomlkit.load(toml_file)
+        bk_pyproject = copy.deepcopy(pyproject)
+
+    dependencies_groups = parsers.get_dependencies_groups(pyproject)
+
+    for group_name, dependency_group in dependencies_groups.items():
+        match group_name:
+            case "project":
+                match group:
+                    case () if not group:
+                        pass
+                    case _ if "project" in group:
+                        pass
+                    case _:
+                        logger.warning("Skipping 'project' dependencies")
+                        continue
+
+                updated_dependency_specifiers = parsers.update_dependency_specifiers(
+                    dependency_group,
+                    exclude,
+                )
+                dependency_specifiers = pyproject["project"]["dependencies"]  # type: ignore[index]
+                for index in range(len(dependency_specifiers)):  # type: ignore[arg-type]
+                    dependency_specifiers[index] = updated_dependency_specifiers[index]  # type: ignore[index]
+
+            case "optional-dependencies":
+                dependency_groups = pyproject["project"][group_name]  # type: ignore[index]
+                for subgroup_name, dependency_specifiers in dependency_groups.items():  # type: ignore[union-attr]
+                    match group:
+                        case () if not group:
+                            pass
+                        case _ if subgroup_name in group:
+                            pass
+                        case _:
+                            logger.warning(f"Skipping 'optional-dependencies.{subgroup_name}'")
+                            continue
+
+                    updated_dependency_specifiers = parsers.update_dependency_specifiers(
+                        dependency_specifiers,
+                        exclude,
+                    )
+                    for index in range(len(dependency_specifiers)):
+                        dependency_specifiers[index] = updated_dependency_specifiers[index]
+
+            case "dependency-groups":
+                dependency_groups = pyproject[group_name]
+                for subgroup_name, dependency_specifiers in dependency_groups.items():  # type: ignore[union-attr]
+                    match group:
+                        case () if not group:
+                            pass
+                        case _ if subgroup_name in group:
+                            pass
+                        case _:
+                            logger.warning(f"Skipping 'dependency-groups.{subgroup_name}'")
+                            continue
+
+                    updated_dependency_specifiers = parsers.update_dependency_specifiers(
+                        dependency_specifiers,
+                        exclude,
+                    )
+                    for index in range(len(dependency_specifiers)):
+                        dependency_specifiers[index] = updated_dependency_specifiers[index]
+            case _:
+                pass
+
+    match dry_run:
+        case True:
+            logger.warning(
+                "Dry run mode enabled, no changes will be made to the pyproject.toml file",
+            )
+        case False:
+            with filepath.open("w") as toml_file:
+                tomlkit.dump(pyproject, toml_file)
+
+            try:
+                logger.info("Resolving dependencies...")
+                uv.lock()
+                logger.info("Dependencies resolved")
+            except Exception as exception:
+                logger.exception(
+                    "Failed to lock the dependencies. Rolling back changes",
+                    exception,
+                )
+                with filepath.open("w") as toml_file:
+                    tomlkit.dump(bk_pyproject, toml_file)
+
+
+if __name__ == "__main__":
+    main()

uv_upsync/commands.py

@@ -0,0 +1,43 @@
+"""Module that contains custom implementation of the `click.Command` with enriched formatting."""
+
+from __future__ import annotations
+
+import click
+
+
+class HelpFormatter(click.HelpFormatter):
+    def write_usage(self, prog: str, args: str = "", prefix: str | None = None) -> None:
+        match prefix:
+            case None:
+                prefix = click.style("Usage: ", fg="green", bold=True)
+            case _:
+                pass
+        super().write_usage(prog, args, prefix)
+
+    def write_heading(self, heading: str) -> None:
+        self.write(click.style(f"{heading}:\n", fg="green", bold=True))
+
+    def write_dl(  # type: ignore[override]
+        self,
+        rows: list[tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
+        colored_rows = []
+        for option_name, help_text in rows:
+            colored_option = click.style(option_name, fg="magenta", bold=True)
+            colored_rows.append((colored_option, help_text))
+        super().write_dl(colored_rows, col_max, col_spacing)
+
+
+class Command(click.Command):
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        self.format_usage(ctx, formatter)
+        self.format_help_text(ctx, formatter)
+        self.format_options(ctx, formatter)
+        self.format_epilog(ctx, formatter)
+
+    def get_help(self, ctx: click.Context) -> str:
+        formatter = HelpFormatter(width=ctx.terminal_width, max_width=ctx.max_content_width)
+        self.format_help(ctx, formatter)
+        return formatter.getvalue()

uv_upsync/exceptions.py

@@ -0,0 +1,38 @@
+"""Module that contains implementation of the exceptions."""
+
+from __future__ import annotations
+
+
+class BaseError(Exception):
+    pass
+
+
+class InvalidDependencySpecifierError(BaseError):
+    def __init__(self, dependency_specifier: str) -> None:
+        super().__init__(f"Invalid dependency specifier: {dependency_specifier!r}")
+
+
+class NoOperatorFoundError(BaseError):
+    def __init__(self, dependency_specifier: str) -> None:
+        super().__init__(f"No operator found in dependency specifier: {dependency_specifier!r}")
+
+
+class MultipleOperatorsFoundError(BaseError):
+    def __init__(self, dependency_specifier: str) -> None:
+        super().__init__(
+            f"Multiple operators found in dependency specifier: {dependency_specifier!r}",
+        )
+
+
+class UVCommandError(BaseError):
+    def __init__(self, command: list[str], returncode: int, stdout: str, stderr: str) -> None:
+        message = f"Command {command!r} returned non-zero exit status {returncode}"
+        if stdout:
+            message += f"\n\nStdout:\n{stdout}"
+        if stderr:
+            message += f"\n\nStderr:\n{stderr}"
+        super().__init__(message)
+        self.command = command
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr

uv_upsync/logging.py

@@ -0,0 +1,34 @@
+"""Module that contains implementation of the logger based on the `click.echo`."""
+
+from __future__ import annotations
+
+import typing
+
+import click
+
+
+class SingletonMeta(type):
+    _instances: typing.ClassVar[dict[type, object]] = {}
+
+    def __call__(cls, *args: object, **kwargs: object) -> object:
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class Logger(metaclass=SingletonMeta):
+    def info(self, message: str) -> None:
+        self._log(click.style(message, fg="green"))
+
+    def warning(self, message: str) -> None:
+        self._log(click.style(message, fg="yellow", dim=True))
+
+    def exception(self, message: str, exception: Exception) -> None:
+        self._log(click.style(message, fg="red", bold=True))
+        self._log(click.style(str(exception), fg="red", dim=True))
+
+    def error(self, message: str) -> None:
+        self._log(click.style(message, fg="red", bold=True))
+
+    def _log(self, message: str) -> None:
+        click.echo(message)

uv_upsync/parsers.py

@@ -0,0 +1,142 @@
+"""Module that contains implementation of the TOML parsers."""
+
+from __future__ import annotations
+
+import re
+
+import tomlkit
+
+from uv_upsync import exceptions
+from uv_upsync import logging
+from uv_upsync import pypi
+
+
+logger = logging.Logger()
+
+
+def get_dependencies_groups(pyproject: tomlkit.TOMLDocument) -> dict[str, list]:  # type: ignore[type-arg]
+    dependencies_groups = {}
+
+    project_dependencies = list(pyproject["project"].get("dependencies", []))  # type: ignore[union-attr]
+    match project_dependencies:
+        case []:
+            pass
+        case _:
+            dependencies_groups.update({"project": project_dependencies})
+
+    optional_dependencies = dict(pyproject["project"].get("optional-dependencies", {}))  # type: ignore[union-attr]
+    match optional_dependencies:
+        case _ if optional_dependencies:
+            dependencies_groups.update({"optional-dependencies": optional_dependencies})  # type: ignore[dict-item]
+
+    dependency_groups = dict(pyproject.get("dependency-groups", {}))
+    match dependency_groups:
+        case _ if dependency_groups:
+            dependencies_groups.update({"dependency-groups": dependency_groups})  # type: ignore[dict-item]
+
+    return dependencies_groups
+
+
+def get_dependency_name_and_operator(dependency_specifier: str) -> tuple[str, str]:
+    valid_operators = ("===", "==", "~=", ">=", ">", "<=", "<")
+    invalid_operators = ("^", "/", ":", "@")
+
+    # Strip environment markers (everything after semicolon) before parsing
+    dependency_part = dependency_specifier.split(";")[0]
+
+    match any(operator in dependency_part for operator in invalid_operators):
+        case True:
+            raise exceptions.InvalidDependencySpecifierError(dependency_specifier)
+        case False:
+            pass
+
+    operators = re.findall("|".join(valid_operators), dependency_part)
+    match len(operators):
+        case 0:
+            raise exceptions.NoOperatorFoundError(dependency_specifier)
+        case 1:
+            operator, *_ = operators
+            dependency_name, *_ = dependency_part.replace(" ", "").split(operator)
+            return dependency_name.strip(), operator.strip()
+        case _:
+            raise exceptions.MultipleOperatorsFoundError(dependency_specifier)
+
+
+def update_dependency_specifier(dependency_specifier: str, exclude: tuple[str, ...]) -> str:
+    ignore_operators = ("==", "<=", "<")
+
+    dependency_name, operator = get_dependency_name_and_operator(dependency_specifier)
+    match dependency_name in exclude:
+        case True:
+            logger.warning(f"Excluding dependency {dependency_name!r}")
+            return dependency_specifier
+        case False:
+            pass
+
+    match operator in ignore_operators:
+        case True:
+            logger.warning(f"Excluding dependency {dependency_name!r}")
+            return dependency_specifier
+        case False:
+            pass
+
+    latest_dependency_version = pypi.fetch_latest_dependency_version(dependency_name)
+    match latest_dependency_version:
+        case None:
+            return dependency_specifier
+        case _:
+            match ";" in dependency_specifier:
+                case True:
+                    after_semi = "".join(dependency_specifier.split(";")[1:])
+                    updated_dependency_specifier = (
+                        f"{dependency_name}{operator}{latest_dependency_version};{after_semi}"
+                    )
+                case False:
+                    updated_dependency_specifier = (
+                        f"{dependency_name}{operator}{latest_dependency_version}"
+                    )
+
+    return updated_dependency_specifier
+
+
+def update_dependency_specifiers(
+    dependency_specifiers: list[str],
+    exclude: tuple[str, ...],
+) -> list[str]:
+    updated_dependency_specifiers = []
+    for dependency_specifier in dependency_specifiers:
+        match any(d_exclude in dependency_specifier for d_exclude in exclude):
+            case True:
+                logger.warning(f"Skipping {dependency_specifier!r} (excluded)")
+                updated_dependency_specifiers.append(dependency_specifier)
+                continue
+            case False:
+                pass
+
+        match isinstance(dependency_specifier, tomlkit.items.InlineTable):
+            case True:
+                logger.warning(f"Skipping inline table: {dependency_specifier!r}")
+                updated_dependency_specifiers.append(dependency_specifier)
+                continue
+            case False:
+                pass
+
+        try:
+            get_dependency_name_and_operator(dependency_specifier)
+        except exceptions.BaseError as exception:
+            logger.exception(f"Skipping inline table: {dependency_specifier!r}", exception)
+            updated_dependency_specifiers.append(dependency_specifier)
+            continue
+
+        updated_dependency_specifier = update_dependency_specifier(dependency_specifier, exclude)
+        match updated_dependency_specifier:
+            case _ if dependency_specifier != updated_dependency_specifier:
+                logger.info(
+                    f"Updating {dependency_specifier!r} to {updated_dependency_specifier!r}",
+                )
+                updated_dependency_specifiers.append(updated_dependency_specifier)
+            case _:
+                logger.warning(f"Skipping {dependency_specifier!r} (no new version available)")
+                updated_dependency_specifiers.append(dependency_specifier)
+
+    return updated_dependency_specifiers

uv_upsync/pypi.py

@@ -0,0 +1,33 @@
+"""Module that contains implementation of the Pypi API client."""
+
+from __future__ import annotations
+
+import re
+
+import httpx
+
+from uv_upsync import logging
+
+
+logger = logging.Logger()
+
+
+def get_dependency_base_name(dependency_name: str) -> str:
+    regex_match = re.match(r"^(.*?)\[", dependency_name)
+    match regex_match:
+        case None:
+            return dependency_name.strip()
+        case _:
+            return regex_match.group(1).strip()
+
+
+def fetch_latest_dependency_version(dependency_name: str) -> str | None:
+    dependency_base_name = get_dependency_base_name(dependency_name)
+    response = httpx.get(f"https://pypi.org/pypi/{dependency_base_name}/json")
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exception:
+        logger.exception(f"Failed to fetch latest version for {dependency_name!r}", exception)
+        return None
+
+    return response.json()["info"]["version"]  # type: ignore[no-any-return]

uv_upsync/uv.py

@@ -0,0 +1,24 @@
+"""Module that contains implementation of the uv commands."""
+
+from __future__ import annotations
+
+import subprocess
+
+from uv_upsync import exceptions
+
+
+def lock() -> None:
+    try:
+        subprocess.run(
+            ("uv", "lock"),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as exception:
+        raise exceptions.UVCommandError(
+            command=exception.cmd,
+            returncode=exception.returncode,
+            stdout=exception.stdout,
+            stderr=exception.stderr,
+        ) from exception

uv_upsync-1.1.2.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: uv-upsync
+Version: 1.1.2
+Summary: uv-upsync - is a tool for automated dependency updates and version bumping in pyproject.toml.
+Project-URL: Homepage, https://github.com/pivoshenko/uv-upsync
+Project-URL: Repository, https://github.com/pivoshenko/uv-upsync
+Author-email: Volodymyr Pivoshenko <volodymyr.pivoshenko@gmail.com>
+Maintainer-email: Volodymyr Pivoshenko <volodymyr.pivoshenko@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,cli-tool,cli-tools,cross-platform,dependencies,dependencies-management,dependencies-update,dependencies-upgrade,dependency,hacktoberfest,packaging,packaging-management,packaging-update,packaging-upgrade,plugin,plugins,pypi,python,uv,uv-plugin,uv-plugins
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.8
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: tomlkit>=0.13.3
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img alt="logo" src="https://github.com/pivoshenko/uv-upsync/blob/main/assets/logo.svg?raw=True" height=200>
+</div>
+
+<br>
+
+<p align="center">
+  <a href="https://opensource.org/licenses/MIT">
+    <img alt="License" src="https://img.shields.io/pypi/l/uv-upsync?style=flat-square&logo=opensourceinitiative&logoColor=white&color=0A6847&label=License">
+  </a>
+  <a href="https://pypi.org/project/uv-upsync">
+    <img alt="Python" src="https://img.shields.io/pypi/pyversions/uv-upsync?style=flat-square&logo=python&logoColor=white&color=4856CD&label=Python">
+  </a>
+  <a href="https://pypi.org/project/uv-upsync">
+    <img alt="PyPI" src="https://img.shields.io/pypi/v/uv-upsync?style=flat-square&logo=pypi&logoColor=white&color=4856CD&label=PyPI">
+  </a>
+  <a href="https://github.com/pivoshenko/uv-upsync/releases">
+    <img alt="Release" src="https://img.shields.io/github/v/release/pivoshenko/uv-upsync?style=flat-square&logo=github&logoColor=white&color=4856CD&label=Release">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://semantic-release.gitbook.io">
+    <img alt="Semantic_Release" src="https://img.shields.io/badge/Semantic_Release-angular-e10079?style=flat-square&logo=semanticrelease&logoColor=white&color=D83A56">
+  </a>
+  <a href="https://pycqa.github.io/isort">
+    <img alt="Imports" src="https://img.shields.io/badge/Imports-isort-black.svg?style=flat-square&logo=improvmx&logoColor=white&color=637A9F&">
+  </a>
+  <a href="https://docs.astral.sh/ruff">
+    <img alt="Ruff" src="https://img.shields.io/badge/Style-ruff-black.svg?style=flat-square&logo=ruff&logoColor=white&color=D7FF64">
+  </a>
+  <a href="https://mypy.readthedocs.io/en/stable/index.html">
+    <img alt="mypy" src="https://img.shields.io/badge/mypy-checked-success.svg?style=flat-square&logo=pypy&logoColor=white&color=0A6847">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/pivoshenko/uv-upsync/actions/workflows/tests.yaml">
+    <img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/pivoshenko/uv-upsync/tests.yaml?label=Tests&style=flat-square&logo=pytest&logoColor=white&color=0A6847">
+  </a>
+  <a href="https://github.com/pivoshenko/uv-upsync/actions/workflows/linters.yaml">
+    <img alt="Linters" src="https://img.shields.io/github/actions/workflow/status/pivoshenko/uv-upsync/linters.yaml?label=Linters&style=flat-square&logo=lintcode&logoColor=white&color=0A6847">
+  </a>
+  <a href="https://github.com/pivoshenko/uv-upsync/actions/workflows/release.yaml">
+    <img alt="Release" src="https://img.shields.io/github/actions/workflow/status/pivoshenko/uv-upsync/release.yaml?label=Release&style=flat-square&logo=pypi&logoColor=white&color=0A6847">
+  </a>
+  <a href="https://codecov.io/gh/pivoshenko/uv-upsync" >
+    <img alt="Codecov" src="https://img.shields.io/codecov/c/gh/pivoshenko/uv-upsync?token=cqRQxVnDR6&style=flat-square&logo=codecov&logoColor=white&color=0A6847&label=Coverage"/>
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/uv-upsync">
+    <img alt="Downloads" src="https://img.shields.io/pypi/dm/uv-upsync?style=flat-square&logo=pythonanywhere&logoColor=white&color=4856CD&label=Downloads">
+  </a>
+  <a href="https://github.com/pivoshenko/uv-upsync">
+    <img alt="Stars" src="https://img.shields.io/github/stars/pivoshenko/uv-upsync?style=flat-square&logo=apachespark&logoColor=white&color=4856CD&label=Stars">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://stand-with-ukraine.pp.ua">
+    <img alt="StandWithUkraine" src="https://img.shields.io/badge/Support-Ukraine-FFC93C?style=flat-square&labelColor=07689F">
+  </a>
+</p>
+
+- [Overview](#overview)
+  - [Features](#features)
+- [Installation](#installation)
+- [Usage and Configuration](#usage-and-configuration)
+  - [Command-line Options](#command-line-options)
+    - [`filepath`](#filepath)
+    - [`exclude`](#exclude)
+    - [`group`](#group)
+    - [`dry-run`](#dry-run)
+- [Examples](#examples)
+  - [Excluding specific packages](#excluding-specific-packages)
+  - [Updating specific dependency groups](#updating-specific-dependency-groups)
+
+## Overview
+
+`uv-upsync` - is a tool/plugin for automated dependency updates and version bumping in `pyproject.toml`.
+
+### Features
+
+- Fully type-safe
+- Automatically updates dependencies to their latest versions from PyPI
+- Multiple dependency groups support - handles `project.dependencies`, `project.optional-dependencies`, and `dependency-groups`
+- Selective group updates - target specific dependency groups for updates (e.g., only update project dependencies or specific optional-dependencies groups)
+- Selective package exclusion - exclude specific packages from being updated
+- Dry-run mode - preview changes without modifying files
+- Safe updates - automatically runs `uv lock` after updates and rolls back on failure
+
+## Installation
+
+Proceed by installing the tool and running it:
+
+```shell
+uvx uv-upsync
+```
+
+Alternatively, you can add it into your development dependencies:
+
+```shell
+uv add --dev uv-upsync
+# or
+uv add uv-upsync --group dev
+```
+
+## Usage and Configuration
+
+By default, `uv-upsync` updates all dependencies in the `pyproject.toml`:
+
+```shell
+uv-upsync
+```
+
+### Command-line Options
+
+#### `filepath`
+
+**Type**: `Path`
+
+**Default**: `./pyproject.toml`
+
+**Short flag**: `-f`
+
+Specifies the path to the `pyproject.toml` file. If your project file is located elsewhere or has a different name, you can set this parameter.
+
+#### `exclude`
+
+**Type**: `str`
+
+**Default**: `()`
+
+**Multiple values**: `allowed`
+
+Specifies packages to exclude from updating. You can provide multiple package names to prevent them from being updated.
+
+#### `group`
+
+**Type**: `str`
+
+**Default**: `()`
+
+**Multiple values**: `allowed`
+
+Specifies which dependency group(s) to update. You can target specific groups like `project` (for project.dependencies), optional-dependencies names, or dependency-groups names. If not specified, all groups are updated. This is useful when you want to update only certain parts of your dependencies.
+
+#### `dry-run`
+
+**Type**: `bool`
+
+**Default**: `false`
+
+Enables preview mode where changes are displayed without modifying the `pyproject.toml` file. This is useful for reviewing what would be updated before applying changes.
+
+## Examples
+
+### Excluding specific packages
+
+```shell
+uv-upsync --exclude click
+
+# Skipping 'click>=8.1.8' (excluded)
+# Skipping 'httpx>=0.28.1' (no new version available)
+# Skipping 'tomlkit>=0.13.3' (no new version available)
+# Updating dependencies in 'dependency-groups' group
+# Skipping 'python-semantic-release~=10.4.1' (no new version available)
+# Skipping 'poethepoet>=0.37.0' (no new version available)
+# Skipping 'pyupgrade>=3.21.0' (no new version available)
+# Skipping 'ruff>=0.14.0' (no new version available)
+# Skipping 'commitizen>=4.9.1' (no new version available)
+# Skipping 'mypy>=1.18.2' (no new version available)
+# Skipping 'ruff>=0.14.0' (no new version available)
+# Skipping 'coverage[toml]>=7.10.7' (no new version available)
+# Excluding dependency 'pytest'
+# Skipping 'pytest==7.4.4' (no new version available)
+# Skipping 'pytest-cov>=7.0.0' (no new version available)
+# Skipping 'pytest-lazy-fixture>=0.6.3' (no new version available)
+# Skipping 'pytest-mock>=3.15.1' (no new version available)
+# Skipping 'pytest-sugar>=1.1.1' (no new version available)
+# Skipping 'sh>=2.2.2' (no new version available)
+# Skipping 'xdoctest>=1.3.0' (no new version available)
+```
+
+### Updating specific dependency groups
+
+```shell
+# Update only project dependencies
+uv-upsync --group project
+
+# Update only dev dependencies (assuming you have a 'dev' group)
+uv-upsync --group dev
+
+# Update multiple specific groups
+uv-upsync --group project --group test
+
+# Skipping 'optional-dependencies.dev' (skipping because not in specified groups)
+# Skipping 'dependency-groups.test' (skipping because not in specified groups)
+# Updating dependencies in 'project' group
+# ...
+```

uv_upsync-1.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+uv_upsync/__init__.py,sha256=jfz1e99qR3cA8gq_kHhfBScA4OZ1hEP2pz7HVNd9iHA,160
+uv_upsync/__main__.py,sha256=2ixZJz7HHmk3MERUL-ZYSSbm49ePf1nZW4PEHbjTN-s,5457
+uv_upsync/commands.py,sha256=wH1v67vEGEZvrxt4ZCoPTClOIrEY5R52tDdQMXfNZxU,1565
+uv_upsync/exceptions.py,sha256=y-pXxnQvKUXVOrPeu00Qxj0EjuwRebee5ghyh6aCVsA,1270
+uv_upsync/logging.py,sha256=F-WD6SzkD8qenTBn3QlSq5JH3v6Ce1HUZU23Nj50R2U,1060
+uv_upsync/parsers.py,sha256=N-XelwagNbbGvqdayAJXXvEMQvUnKVd1HaWIFAyY-G0,5499
+uv_upsync/pypi.py,sha256=LZwRnFl4a017SzzbjSoM6TQvC5TEpCnja4vyv6s7Avo,961
+uv_upsync/uv.py,sha256=4qSOF_wM-rCf-E9v1Ah6ui2Th1EHqzNj1RhdaueH5iU,599
+uv_upsync-1.1.2.dist-info/METADATA,sha256=rMVGJB7AqeIXUEzTmBADhD6AWNaxXefm91MAOfOL1eA,9711
+uv_upsync-1.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uv_upsync-1.1.2.dist-info/entry_points.txt,sha256=hEEi7yw2CbJAsL0mRcsnxCqssWMNcFCKceqkOjXNgdQ,54
+uv_upsync-1.1.2.dist-info/licenses/LICENSE,sha256=Ea-0VtKpHnE8T-kZEGNNf-Yn3uB50_W4Cw_9k3dX6eQ,1077
+uv_upsync-1.1.2.dist-info/RECORD,,

uv_upsync-1.1.2.dist-info/WHEEL

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

uv_upsync-1.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uv-upsync = uv_upsync.__main__:main

uv_upsync-1.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Volodymyr Pivoshenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.