lazyscribe 2.2.2__tar.gz → 2.3.0__tar.gz

{lazyscribe-2.2.2 → lazyscribe-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lazyscribe
-Version: 2.2.2
+Version: 2.3.0
 Summary: Lightweight and lazy experiment logging
 Keywords: experiment,machine learning,model
 Author: Akshay Gupta
@@ -25,7 +25,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Documentation
 Requires-Dist: attrs>=21.2.0,<=26.1.0
 Requires-Dist: fsspec>=0.4.0,<=2026.9.0
-Requires-Dist: python-slugify>=5.0.0,<=9.1.2
+Requires-Dist: python-slugify>=5.0.0,<=9.1.3
 Requires-Dist: tomli>=2.2.1,<=2.3.0 ; python_full_version < '3.11'
 Requires-Dist: commitizen ; extra == 'build'
 Requires-Dist: uv ; extra == 'build'

lazyscribe-2.3.0/lazyscribe/_meta.py

@@ -0,0 +1,3 @@
+"""Version."""
+
+__version__ = "2.3.0"

{lazyscribe-2.2.2 → lazyscribe-2.3.0}/lazyscribe/release.py

@@ -29,6 +29,128 @@ else:
 LOG = logging.getLogger(__name__)
 
 
+@define(auto_attribs=True)
+class ReleaseDiff:
+    """Dataclass for holding the difference between two release objects.
+
+    In particular, this class will be used to generate human-readable reports on the differences
+    between two releases.
+
+    Parameters
+    ----------
+    tags : tuple[str, str]
+        Tags of the releases being compared.
+    identical : list[str]
+        The list of artifact-version combinations that are identical between the releases.
+    modified : list[tuple[str, int, int]]
+        A list of artifacts that exist in both releases, just with different versions.
+        The second entry in each tuple is the version of the artifact present in the release
+        corresponding to the first entry of ``tags``. The second entry in each tuple is the
+        version corresponding to the second entry.
+    unique : tuple[list[tuple[str, int]], list[tuple[str, int]]]
+        A tuple of artifact-versions that exist only in the respective releases.
+    """
+
+    tags: tuple[str, str]
+    identical: list[str]
+    modified: list[tuple[str, int, int]]
+    unique: tuple[list[tuple[str, int]], list[tuple[str, int]]]
+
+    def report(self, repository: Repository) -> str:
+        """Generate a human-readable report describing the differences between releases.
+
+        Parameters
+        ----------
+        repository : lazyscribe.repository.Repository
+            The repository that was used to generate the releases.
+
+        Returns
+        -------
+        str
+            A markdown-formatted string.
+        """
+        first_section_: str = f"# {self.tags[0]} vs. {self.tags[1]}\n\n"
+        if self.identical:
+            first_section_ += (
+                f"The following artifacts are identical: {', '.join(self.identical)}\n"
+            )
+        if self.unique[0]:
+            first_section_ += f"The following artifacts exist only in {self.tags[0]}: {', '.join(str(i) for i, _ in self.unique[0])}\n"
+        if self.unique[1]:
+            first_section_ += f"The following artifacts exist only in {self.tags[1]}: {', '.join(str(i) for i, _ in self.unique[1])}\n"
+        binary_arts_: list[tuple[str, int, int]] = []
+        art_diffs_: list[tuple[str, int, int, str]] = []
+        for art, ref, other in self.modified:
+            if repository._search_artifact_versions(art, ref).binary:
+                binary_arts_.append((art, ref, other))
+                continue
+            if repository._search_artifact_versions(art, other).binary:
+                binary_arts_.append((art, ref, other))
+                continue
+            art_diffs_.append(
+                (art, ref, other, repository.get_version_diff(art, (ref, other)))
+            )
+
+        second_section_: str = ""
+        if art_diffs_ or binary_arts_:
+            second_section_ += (
+                f"## Artifact comparison\n\nThis section contains artifacts that exist "
+                f"in both {self.tags[0]} and {self.tags[1]} with different versions.\n"
+            )
+        if binary_arts_:
+            # Find the maximum character length for each column
+            artifact_name_length = max(
+                [len("Artifact"), *(len(name) for name, _, _ in binary_arts_)]
+            )
+            ref_version_length = max(
+                [len(self.tags[0]), *(len(str(ver)) for _, ver, _ in binary_arts_)]
+            )
+            other_version_length = max(
+                [len(self.tags[1]), *(len(str(ver)) for _, _, ver in binary_arts_)]
+            )
+
+            def _tbl_line(x: str, y: str, z: str) -> str:
+                return (
+                    "| "
+                    + " | ".join(
+                        [
+                            x.ljust(artifact_name_length),
+                            y.ljust(ref_version_length),
+                            z.ljust(other_version_length),
+                        ]
+                    )
+                    + " |\n"
+                )
+
+            tbl_ = (
+                _tbl_line("Artifact", self.tags[0], self.tags[1])
+                + "| "
+                + " | ".join(
+                    [
+                        "".join(["-"] * artifact_name_length),
+                        "".join(["-"] * ref_version_length),
+                        "".join(["-"] * other_version_length),
+                    ]
+                )
+                + " |\n"
+            )
+            for art, ref, other in binary_arts_:
+                tbl_ += _tbl_line(art, str(ref), str(other))
+
+            second_section_ += f"The following artifacts are binary:\n\n{tbl_}\n\n"
+        if art_diffs_:
+            second_section_ += (
+                "The following artifacts can be compared using ``difflib``.\n\n"
+            )
+            for art, ref, other, diff in art_diffs_:
+                second_section_ += (
+                    f"### {art}\n\nVersion {ref} in {self.tags[0]} and {other} in {self.tags[1]}.\n\n"
+                    f"```diff\n{diff}\n```\n"
+                )
+
+        return first_section_ + "\n" + second_section_
+
+
 @define
 class Release:
     """Create a release associated with a Repository instance.
@@ -82,6 +204,55 @@ class Release:
             created_at=datetime.fromisoformat(info["created_at"]),
         )
 
+    def __sub__(self, other: Release) -> ReleaseDiff:
+        """Compare two releases.
+
+        The output dataclass can be used to generate reporting.
+
+        Parameters
+        ----------
+        other : lazyscribe.release.Release
+            The other release object.
+
+        Returns
+        -------
+        lazyscribe.release.ReleaseDiff
+            A lightweight dataclass for reporting the differences between
+            :py:class:`lazyscribe.release.Release` objects.
+        """
+        identical_: set[str] = set()
+        modified_: set[tuple[str, int, int]] = set()
+        unique_: set[tuple[str, int]] = set()
+
+        other_names_: list[str] = [art[0] for art in other.artifacts]
+        for art, version in self.artifacts:
+            try:
+                other_art_: tuple[str, int] = other.artifacts[other_names_.index(art)]
+                if other_art_[1] == version:
+                    identical_.add(art)
+                else:
+                    modified_.add((art, version, other_art_[1]))
+            except ValueError:
+                unique_.add((art, version))
+
+        other_unique_: set[tuple[str, int]] = set()
+        for art, version in other.artifacts:
+            if art in identical_:
+                continue
+            if art in {i[0] for i in modified_}:
+                continue
+            other_unique_.add((art, version))
+
+        return ReleaseDiff(
+            tags=(self.tag, other.tag),
+            identical=sorted(identical_),
+            modified=sorted(modified_, key=lambda x: x[0]),
+            unique=(
+                sorted(unique_, key=lambda x: x[0]),
+                sorted(other_unique_, key=lambda x: x[0]),
+            ),
+        )
+
 
 def create_release(repository: Repository, tag: str) -> Release:
     """Create a release.
@@ -113,8 +284,12 @@ def create_release(repository: Repository, tag: str) -> Release:
     all_artifacts_ = sorted({art.name for art in repository.artifacts})
     latest: list[tuple[str, int]] = []
     for name in all_artifacts_:
-        art = repository._search_artifact_versions(name)
-        latest.append((name, art.version))
+        try:
+            art = repository._search_artifact_versions(name)
+            latest.append((name, art.version))
+        except VersionNotFoundError:
+            LOG.info("Artifact '%s' has no valid versions available", name)
+            continue
 
     return Release(tag=tag, artifacts=latest)
 

{lazyscribe-2.2.2 → lazyscribe-2.3.0}/lazyscribe/repository.py

@@ -112,8 +112,12 @@ class Repository:
         for artifact in data:
             handler_cls = _get_handler(artifact.pop("handler"))
             created_at = datetime.fromisoformat(artifact.pop("created_at"))
+            if (expiry := artifact.pop("expiry", None)) is not None:
+                expiry = datetime.fromisoformat(expiry)
             artifacts.append(
-                handler_cls.construct(**artifact, created_at=created_at, dirty=False)
+                handler_cls.construct(
+                    **artifact, created_at=created_at, expiry=expiry, dirty=False
+                )
             )
         self.artifacts = artifacts
 

{lazyscribe-2.2.2 → lazyscribe-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "uv-build>=0.8.0,<=0.9.5" ]
 
 [project]
 name = "lazyscribe"
-version = "2.2.2"
+version = "2.3.0"
 description = "Lightweight and lazy experiment logging"
 readme = { file = "README.md", content-type = "text/markdown" }
 keywords = [ "experiment", "machine learning", "model" ]
@@ -35,7 +35,7 @@ classifiers = [
 dependencies = [
     "attrs<=26.1.0,>=21.2.0",
     "fsspec<=2026.9.0,>=0.4.0",
-    "python-slugify<=9.1.2,>=5.0.0",
+    "python-slugify<=9.1.3,>=5.0.0",
     "tomli<=2.3.0,>=2.2.1; python_version<='3.10'",
 ]
 optional-dependencies.build = [ "commitizen", "uv" ]
@@ -119,34 +119,34 @@ lint.pydocstyle.convention = "numpy"
 lint.preview = true
 
 [tool.pyproject-fmt]
-column_width = 88
+column_width = 99
 indent = 4
 keep_full_version = true
 max_supported_python = "3.14"
 
-[tool.coverage]
-run.relative_files = true
-
 [tool.mypy]
-python_version = "3.10"
 exclude = [
     "^docs\\/",
     "^tests\\/",
 ]
-strict = true
+ignore_missing_imports = true
+python_version = "3.10"
 warn_return_any = true
+strict = true
 warn_unused_configs = true
-ignore_missing_imports = true
+
+[tool.coverage]
+run.relative_files = true
 
 [tool.commitizen]
 version_provider = "uv"
-tag_format = "v$version"
-bump_message = "chore: version $current_version -> $new_version"
-update_changelog_on_bump = true
 version_files = [
-    "lazyscribe/_meta.py:__version__",
     "docs/conf.py:version",
+    "lazyscribe/_meta.py:__version__",
 ]
+bump_message = "chore: version $current_version -> $new_version"
+tag_format = "v$version"
+update_changelog_on_bump = true
 
 [tool.edgetest]
 exclude_newer = "3 days"

lazyscribe-2.2.2/lazyscribe/_meta.py

@@ -1,3 +0,0 @@
-"""Version."""
-
-__version__ = "2.2.2"