uv-lock-report 0.12.1__py3-none-any.whl

uv_lock_report/__init__.py

@@ -0,0 +1,32 @@
+"""
+uv-lock-report: Parses uv.lock changes and generates Markdown reports.
+"""
+
+from uv_lock_report.cli import main as cli_main
+from uv_lock_report.report import report
+from uv_lock_report.models import (
+    LockFile,
+    UvLockFile,
+    LockFileReporter,
+    LockfileChanges,
+    LockfilePackage,
+    UpdatedPackage,
+    OutputFormat,
+)
+
+__all__ = [
+    "cli_main",
+    "report",
+    "LockFile",
+    "UvLockFile",
+    "LockFileReporter",
+    "LockfileChanges",
+    "LockfilePackage",
+    "UpdatedPackage",
+    "OutputFormat",
+]
+
+try:
+    from uv_lock_report._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "0.0.0"

uv_lock_report/__main__.py

@@ -0,0 +1,11 @@
+"""
+Entry point for running uv_lock_report as a module.
+
+This allows the package to be executed with:
+    python -m uv_lock_report
+"""
+
+from uv_lock_report.cli import main
+
+if __name__ == "__main__":
+    main()

uv_lock_report/cli.py

@@ -0,0 +1,41 @@
+from argparse import ArgumentParser, Namespace
+
+from uv_lock_report.models import OutputFormat
+from uv_lock_report.report import report
+
+
+def parse_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("--base-sha", required=True)
+    parser.add_argument("--base-path", required=True)
+    parser.add_argument("--output-path", required=True)
+    parser.add_argument(
+        "--output-format",
+        choices=list(OutputFormat),
+        default=OutputFormat.TABLE.value,
+        required=False,
+    )
+    parser.add_argument(
+        "--show-learn-more-link",
+        choices=["true", "false"],
+        default="true",
+        required=False,
+        help='Whether to show a "Learn More" link in the report comment.',
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    print(args)
+    base_sha = args.base_sha
+    base_path = args.base_path
+    output_path = args.output_path
+    output_format = OutputFormat(args.output_format)
+    report(
+        base_sha=base_sha,
+        base_path=base_path,
+        output_path=output_path,
+        output_format=output_format,
+        show_learn_more_link=args.show_learn_more_link == "true",
+    )

uv_lock_report/models.py

@@ -0,0 +1,430 @@
+import re
+import tomllib
+from enum import IntEnum, StrEnum, auto
+from functools import cached_property
+
+from packaging.version import parse
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    computed_field,
+)
+
+
+class OutputFormat(StrEnum):
+    TABLE = auto()
+    SIMPLE = auto()
+
+
+class VersionChangeType(StrEnum):
+    UPGRADE = auto()
+    DOWNGRADE = auto()
+
+
+class VersionChangeLevel(IntEnum):
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 2
+    UNKNOWN = 10
+
+    @property
+    def gitmoji(self) -> str:
+        match self:
+            case VersionChangeLevel.MAJOR:
+                return ":collision:"
+            case VersionChangeLevel.MINOR:
+                return ":sparkles:"
+            case VersionChangeLevel.PATCH:
+                return ":hammer_and_wrench:"
+            case VersionChangeLevel.UNKNOWN:
+                return ":question:"
+            case _:
+                raise NotImplementedError()
+
+
+BASEVERSION = re.compile(
+    r"""[vV]?
+        (?P<major>0|[1-9]\d*)
+        (\.
+        (?P<minor>0|[1-9]\d*)
+        (\.
+        (?P<patch>0|[1-9]\d*)
+        )?
+        )?
+    """,
+    re.VERBOSE,
+)
+
+
+class LockfilePackage(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_by_name=True,
+        validate_by_alias=False,
+        populate_by_name=True,
+    )
+
+    name: str = Field(alias="Package")
+    version: str | None = Field(alias="Version", default=None)
+
+    def __str__(self) -> str:
+        return f"{self.name}: {self.version}"
+
+    def __eq__(self, other):
+        if not isinstance(other, LockfilePackage):
+            return NotImplemented
+        if self.version is None or other.version is None:
+            return self.name == other.name and self.version == other.version
+        return self.name == other.name and parse(self.version) == parse(other.version)
+
+    def markdown_row(self) -> str:
+        return f"| {self.name} | {self.version} |"
+
+    def markdown_simple(self) -> str:
+        return f"\\`{self.name}\\`: \\`{self.version}\\`"
+
+
+class UpdatedPackage(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_by_name=True,
+        validate_by_alias=False,
+        populate_by_name=True,
+    )
+
+    name: str = Field(alias="Package")
+    old_version: str = Field(alias="Old Version")
+    new_version: str = Field(alias="New Version")
+
+    def __str__(self) -> str:
+        return f"{self.name}: {self.old_version} -> {self.new_version}"
+
+    def change_type(self) -> VersionChangeType:
+        old_ver = parse(self.old_version)
+        new_ver = parse(self.new_version)
+        if new_ver > old_ver:
+            return VersionChangeType.UPGRADE
+        else:
+            return VersionChangeType.DOWNGRADE
+
+    def change_level(self) -> VersionChangeLevel:
+        old_version = parse(self.old_version)
+        new_version = parse(self.new_version)
+
+        if new_version.major != old_version.major:
+            return VersionChangeLevel.MAJOR
+        elif new_version.minor != old_version.minor:
+            return VersionChangeLevel.MINOR
+        elif new_version.micro != old_version.micro:
+            return VersionChangeLevel.PATCH
+
+        return VersionChangeLevel.UNKNOWN
+
+    def markdown_row(self) -> str:
+        return f"| {self.name} | {self.old_version} | {self.new_version} |"
+
+    def markdown_simple(self) -> str:
+        return f"{self.change_level().gitmoji} \\`{self.name}\\`: \\`{self.old_version}\\` -> \\`{self.new_version}\\`"
+
+
+class RequiresPythonChanges(BaseModel):
+    old: str | None
+    new: str | None
+
+    def has_changes(self) -> bool:
+        return self.old != self.new
+
+    def __str__(self) -> str:
+        return f"Requires-Python: {self.old} -> {self.new}"
+
+
+class LockfileChanges(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    requires_python: RequiresPythonChanges
+
+    added: list[LockfilePackage] = []
+    removed: list[LockfilePackage] = []
+    updated: list[UpdatedPackage] = []
+    output_format: OutputFormat
+    show_learn_more_link: bool
+
+    def __str__(self) -> str:
+        all = []
+        if self.requires_python.has_changes():
+            all.append("Python Constraint Changed:")
+            all.append(
+                f"\\`{self.requires_python.old}\\` -> \\`{self.requires_python.new}\\`"
+            )
+        if self.added:
+            all.append("Added:")
+            all.extend([str(e) for e in self.added])
+        if self.updated:
+            all.append("Updated:")
+            all.extend([str(e) for e in self.updated])
+        if self.removed:
+            all.append("Removed:")
+            all.extend([str(e) for e in self.removed])
+        return "\n".join(all)
+
+    @computed_field
+    @property
+    def items(self) -> int:
+        return len(self.added) + len(self.removed) + len(self.updated)
+
+    @computed_field
+    @property
+    def markdown(self) -> str:
+        match self.output_format:
+            case OutputFormat.TABLE:
+                return self.markdown_table
+            case OutputFormat.SIMPLE:
+                return self.markdown_simple
+            case _:
+                raise ValueError(f"Unknown format: {format}")
+
+    @computed_field
+    @property
+    def markdown_table(self) -> str:
+        title = "##"
+        sections = "###"
+
+        all = [f"{title} uv Lockfile Report"]
+        if self.requires_python.has_changes():
+            all.append(f"{sections} Python Constraint Changed")
+            all.append(
+                f"\\`{self.requires_python.old}\\` -> \\`{self.requires_python.new}\\`"
+            )
+        if self.added:
+            all.append(f"{sections} Added")
+            all.extend(self.__lockfile_package_table_header())
+            all.extend([added.markdown_row() for added in self.added])
+
+        if self.updated:
+            all.append(f"{sections} Changed")
+            all.extend(self.__updated_package_table_header())
+            all.extend([updated.markdown_row() for updated in self.updated])
+
+        if self.removed:
+            all.append(f"{sections} Removed")
+            all.extend(self.__lockfile_package_table_header())
+            all.extend([removed.markdown_row() for removed in self.removed])
+        return "\n".join(all)
+
+    def __lockfile_package_table_header(self) -> list[str]:
+        header = []
+        attribute_order = ("name", "version")
+
+        header.append(
+            "| "
+            + " | ".join(
+                [
+                    str(LockfilePackage.model_fields[attr].alias)
+                    for attr in attribute_order
+                ]
+            )
+            + " |"
+        )
+        header.append("|" + "|".join(["--" for _ in attribute_order]) + "|")
+        return header
+
+    def __updated_package_table_header(self) -> list[str]:
+        header = []
+        attribute_order = ("name", "old_version", "new_version")
+
+        header.append(
+            "| "
+            + " | ".join(
+                [
+                    str(UpdatedPackage.model_fields[attr].alias)
+                    for attr in attribute_order
+                ]
+            )
+            + " |"
+        )
+        header.append("|" + "|".join(["--" for _ in attribute_order]) + "|")
+        return header
+
+    @computed_field
+    @property
+    def markdown_simple(self) -> str:
+        title = "##"
+        sections = "###"
+        all = [f"{title} uv Lockfile Report"]
+        if self.requires_python.has_changes():
+            all.append(f"{sections} Python Constraint Changed")
+            all.append(
+                f"\\`{self.requires_python.old}\\` -> \\`{self.requires_python.new}\\`"
+            )
+        if self.added:
+            all.append(f"{sections} Added")
+            all.extend([added.markdown_simple() for added in self.added])
+        if self.updated:
+            all.append(f"{sections} Changed")
+            all.extend([updated.markdown_simple() for updated in self.updated])
+
+        if self.removed:
+            all.append(f"{sections} Removed")
+            all.extend([removed.markdown_simple() for removed in self.removed])
+
+        if self.show_learn_more_link:
+            all.append(self.learn_more_link_text)
+        return "\n".join(all)
+
+    @computed_field
+    @property
+    def learn_more_link_text(self) -> str:
+        return "\n".join(
+            [
+                "",
+                "---",
+                "Learn more about this report at https://github.com/mw-root/uv-lock-report",
+            ]
+        )
+
+
+class LockFileType(StrEnum):
+    UV = auto()
+
+
+class LockFile(BaseModel):
+    type: LockFileType
+    packages: list[LockfilePackage]
+
+    @cached_property
+    def packages_by_name(self) -> dict[str, LockfilePackage]:
+        return {p.name: p for p in self.packages}
+
+    @cached_property
+    def package_names(self) -> set[str]:
+        return set(self.packages_by_name.keys())
+
+
+class UvLockFile(LockFile):
+    type: LockFileType = LockFileType.UV
+    version: int
+    revision: int
+    packages: list[LockfilePackage] = Field(alias="package")
+    requires_python: str = Field(alias="requires-python")
+
+    @classmethod
+    def from_toml_str(cls, toml_str: str) -> "UvLockFile":
+        return cls.model_validate(tomllib.loads(toml_str))
+
+
+class LockFileReporter:
+    def __init__(
+        self,
+        old_lockfile: UvLockFile | None,
+        new_lockfile: UvLockFile | None,
+        output_format: OutputFormat,
+        show_learn_more_link: bool,
+    ) -> None:
+        self.old_lockfile = old_lockfile
+        self.new_lockfile = new_lockfile
+        self.output_format = output_format
+        self.show_learn_more_link = show_learn_more_link
+
+    @cached_property
+    def both_lockfile_package_names(self) -> set[str]:
+        old_package_names = (
+            self.old_lockfile.package_names if self.old_lockfile else set()
+        )
+        new_package_names = (
+            self.new_lockfile.package_names if self.new_lockfile else set()
+        )
+
+        return old_package_names & new_package_names
+
+    def get_changes(self) -> LockfileChanges:
+        return LockfileChanges(
+            requires_python=self.get_requires_python_changes(),
+            added=self.get_added_packages(),
+            removed=self.get_removed_packages(),
+            updated=self.get_updated_packages(),
+            show_learn_more_link=self.show_learn_more_link,
+            output_format=self.output_format,
+        )
+
+    def get_requires_python_changes(self) -> RequiresPythonChanges:
+        old_requires_python = (
+            self.old_lockfile.requires_python if self.old_lockfile else None
+        )
+        new_requires_python = (
+            self.new_lockfile.requires_python if self.new_lockfile else None
+        )
+        return RequiresPythonChanges(
+            old=old_requires_python,
+            new=new_requires_python,
+        )
+
+    @cached_property
+    def added_package_names(self) -> set[str]:
+        if self.old_lockfile is None:
+            if self.new_lockfile is None:
+                return set()
+
+            return self.new_lockfile.package_names
+
+        if self.new_lockfile is None:
+            return set()
+
+        return self.new_lockfile.package_names.difference(
+            self.old_lockfile.package_names
+        )
+
+    @cached_property
+    def removed_package_names(self) -> set[str]:
+        if self.new_lockfile is None:
+            if self.old_lockfile is None:
+                return set()
+
+            return self.old_lockfile.package_names
+        if self.old_lockfile is None:
+            return set()
+
+        return self.old_lockfile.package_names.difference(
+            self.new_lockfile.package_names
+        )
+
+    def get_removed_packages(self) -> list[LockfilePackage]:
+        if self.old_lockfile is None:
+            return []
+        return [
+            pkg
+            for pkg in self.old_lockfile.packages
+            if pkg.name in self.removed_package_names
+        ]
+
+    def get_added_packages(self) -> list[LockfilePackage]:
+        if self.new_lockfile is None:
+            return []
+        return [
+            pkg
+            for pkg in self.new_lockfile.packages
+            if pkg.name in self.added_package_names
+        ]
+
+    def sort_packages_by_change_level(
+        self, packages: list[UpdatedPackage]
+    ) -> list[UpdatedPackage]:
+        return sorted(packages, key=lambda x: (x.change_level(), x.name))
+
+    def get_updated_packages(self) -> list[UpdatedPackage]:
+        if self.old_lockfile is None or self.new_lockfile is None:
+            return []
+        updated_packages: list[UpdatedPackage] = []
+
+        for pkg_name in self.both_lockfile_package_names:
+            old_pkg = self.old_lockfile.packages_by_name[pkg_name]
+            new_pkg = self.new_lockfile.packages_by_name[pkg_name]
+            if old_pkg != new_pkg:
+                updated_packages.append(
+                    UpdatedPackage(  # type: ignore
+                        name=pkg_name,  # type: ignore
+                        old_version=old_pkg.version,  # type: ignore
+                        new_version=new_pkg.version,  # type: ignore
+                    )  # type: ignore
+                )
+        return self.sort_packages_by_change_level(updated_packages)

uv_lock_report/report.py

@@ -0,0 +1,68 @@
+import subprocess
+from pathlib import Path
+
+from uv_lock_report.models import (
+    LockfileChanges,
+    LockFileReporter,
+    OutputFormat,
+    UvLockFile,
+)
+
+CURRENT_UV_LOCK = Path("uv.lock")
+
+
+def get_new_uv_lock_file(base_path: str) -> UvLockFile | None:
+    path = Path(base_path)
+    uv_lock_path = path / CURRENT_UV_LOCK
+    if not uv_lock_path.exists():
+        print("uv.lock not found in current working directory")
+        return None
+    return UvLockFile.from_toml_str(uv_lock_path.read_text())
+
+
+def get_old_uv_lock_file(base_sha: str, base_path: str) -> UvLockFile | None:
+    cmd = ["git", "show", f"{base_sha}:uv.lock"]
+
+    run = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        cwd=base_path,
+    )
+
+    if run.returncode != 0:
+        print("uv.lock not found in base commit")
+        print(run.stderr)
+        print(run.stdout)
+        print(run.args)
+        return None
+
+    print("Found uv.lock in base commit.")
+    return UvLockFile.from_toml_str(run.stdout)
+
+
+def write_changes_file(lockfile_changes: LockfileChanges, output_path: str) -> None:
+    Path(output_path).write_text(lockfile_changes.model_dump_json())
+
+
+def report(
+    base_sha: str,
+    base_path: str,
+    output_path: str,
+    output_format: OutputFormat = OutputFormat.TABLE,
+    show_learn_more_link: bool = True,
+) -> None:
+    old_lockfile = get_old_uv_lock_file(base_sha, base_path)
+    new_lockfile = get_new_uv_lock_file(base_path)
+
+    reporter = LockFileReporter(
+        old_lockfile=old_lockfile,
+        new_lockfile=new_lockfile,
+        output_format=output_format,
+        show_learn_more_link=show_learn_more_link,
+    )
+
+    write_changes_file(
+        lockfile_changes=reporter.get_changes(),
+        output_path=output_path,
+    )