vocker 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

vocker/dedup_models.py

@@ -1,10 +1,14 @@
+from __future__ import annotations
+
 import dataclasses
 import typing as ty
 
+import attr
 import sqlalchemy as sa
 from sqlalchemy import orm as sao
 from sqlalchemy.orm import Mapped as M, mapped_column as mc, relationship, DeclarativeBase
 from sqlalchemy_boltons.orm import RelationshipComparator as Rel
+from sqlalchemy_boltons.temporary import CacheTemporaryMetaData as CacheTmp, MetaDataMaker
 
 from . import multihash as mh
 from .util_models import now, rel_kw_basic, rel_kw_cascade
@@ -14,57 +18,78 @@ class BaseDedup(DeclarativeBase):
     pass
 
 
+_make_file_fk = lambda: sa.ForeignKey("dedup_file.id", ondelete="CASCADE")
+_make_obj_fk = lambda: sa.ForeignKey("dedup_obj.id", ondelete="CASCADE")
+_make_pending_fk = lambda: sa.ForeignKey("dedup_pending.id", ondelete="CASCADE")
+
+
 @BaseDedup.registry.mapped_as_dataclass(init=False)
 class DedupConfig:
     __tablename__ = "dedup_config"
 
     key: M[str] = mc(primary_key=True)
-    value: M[str] = mc(nullable=False)
+    value: M[str] = mc()
 
 
 @BaseDedup.registry.mapped_as_dataclass(init=False)
-class DedupFile:
+class Obj:
+    __tablename__ = "dedup_obj"
     """
-    Represents a single deduplicated file regardless of backend (hardlink, symlink, reflink).
+    Represents an idealized deduplicated file. There may be multiple actual filesystem files
+    associated to this idealized object.
 
-    The file contents may not yet be available if :attr:`pending_file` is nonempty.
-    """
+    When an Obj has no more links, :attr:`orphaned_at` is set to the current time.
 
-    __tablename__ = "dedup_file"
+    When a File has no more links, and there are other Files with the same content, we should delete
+    all but one of the Files. This is not implemented yet.
+
+    Incomplete: Obj exists, has no File with pending_id != None.
+    Complete: Obj exists, has at least one File with pending_id == None,
+
+    Lifecycle:
+    1. Incomplete + Used: Newly created object, data not written yet.
+    2. Complete + Used: Data written, links created.
+    3. Complete + Unused: Data written, no more links exist.
+    4. Incomplete + Unused: Data maybe deleted, no more links exist.
+    """
 
     id: M[int] = mc(primary_key=True)
-    file_metadata: M[bytes] = mc("metadata")
+    pending_id: M[int | None] = mc(_make_pending_fk())
+    metadata_bytes: M[bytes] = mc("metadata")
     size: M[int] = mc()
-    mtime: M[int] = mc()
-    created_at: M[int] = mc(insert_default=now)
+    created_at: M[int] = mc()
+    updated_at: M[int] = mc(server_default=sa.text("-1"), index=True)
     orphaned_at: M[int | None] = mc()
-    pending_id: M[int | None] = mc(sa.ForeignKey("dedup_pending.id", ondelete="CASCADE"))
-
-    links: M[list["Link"]] = relationship(back_populates="file", **rel_kw_cascade)
-    tags: M[list["Tag"]] = relationship(back_populates="file", **rel_kw_cascade)
-    hashes: M[list["Hash"]] = relationship(back_populates="file", **rel_kw_cascade)
-    pending: M["Pending | None"] = relationship(back_populates="files", **rel_kw_basic)
 
-    # this is used as a speedup when verifying hardlinks
-    _cached_file_stat = None
+    files: M[list["File"]] = relationship(back_populates="obj", **rel_kw_cascade)
+    tags: M[list["Tag"]] = relationship(back_populates="obj", **rel_kw_cascade)
+    hashes: M[list["Hash"]] = relationship(back_populates="obj", **rel_kw_cascade)
+    pending: M["Pending | None"] = relationship(back_populates="objs", **rel_kw_basic)
 
     @property
     def hashes_dict(self):
         return {(h := x.to_digest()).function: h for x in self.hashes}
 
     @classmethod
-    def make_update_orphaned(cls, orphaned_at_now=None):
+    def q_is_complete(cls):
+        F = sao.aliased(File)
+        return sa.exists().select_from(F).where(Rel(F.obj) == cls, F.pending_id == None)
+
+    @classmethod
+    def q_is_orphaned(cls):
+        F = sao.aliased(File)
+        return ~sa.exists().select_from(F).where(Rel(F.obj) == cls, F.link_count != 0)
+
+    @classmethod
+    def make_sql_update_orphaned(cls, orphaned_at_now):
         """
         Construct the SQL DML statement which sets :attr:`orphaned_at` according to whether any
         links are left that point to this dedup file.
         """
-        if orphaned_at_now is None:
-            orphaned_at_now = now()
-        L = sao.aliased(Link)
         return sa.update(cls).values(
             orphaned_at=sa.case(
                 # If a Link exists, then it's NULL.
-                (sa.exists().select_from(L).where(Rel(L.file) == cls), None),
+                (~cls.q_is_orphaned(), None),
                 # If the orphaned_at file was set in the past, then keep that value.
                 (cls.orphaned_at < orphaned_at_now, cls.orphaned_at),
                 # Otherwise, set it to the current timestamp.
@@ -73,7 +98,43 @@ class DedupFile:
         )
 
 
-_make_file_fk = lambda: sa.ForeignKey("dedup_file.id", ondelete="CASCADE")
+@BaseDedup.registry.mapped_as_dataclass(init=False)
+class File:
+    """
+    Represents a single deduplicated file regardless of backend (hardlink, symlink, reflink).
+
+    The file contents may not yet be available if :attr:`pending_id` is not NULL.
+
+    If :attr:`obj_id` is NULL, then the File has been (probably) deleted and in a future transaction
+    the row should also be deleted if the file is confirmed deleted.
+    """
+
+    __tablename__ = "dedup_file"
+
+    # this is used as a speedup when verifying hardlinks
+    _cached_file_stat = None
+
+    id: M[int] = mc(primary_key=True)
+    obj_id: M[int | None] = mc(_make_obj_fk(), index=True)
+    link_count: M[int] = mc(server_default=sa.text("-1"))
+    pending_id: M[int | None] = mc(sa.ForeignKey("dedup_pending.id", ondelete="CASCADE"))
+    created_at: M[int | None] = mc()
+
+    obj: M[list[Obj]] = relationship(back_populates="files", **rel_kw_cascade)
+    links: M[list["Link"]] = relationship(back_populates="file", **rel_kw_cascade)
+    pending: M["Pending | None"] = relationship(back_populates="files", **rel_kw_basic)
+
+
+@BaseDedup.registry.mapped_as_dataclass(init=False)
+class FileCorruption:
+    """
+    Represents information about a corrupted file.
+    """
+
+    __tablename__ = "dedup_file_corrupt"
+    id: M[int] = mc(sa.ForeignKey("dedup_file.id", ondelete="CASCADE"), primary_key=True)
+    exception_name: M[str] = mc()
+    exception_string: M[str] = mc()
 
 
 @BaseDedup.registry.mapped_as_dataclass(init=False)
@@ -83,7 +144,8 @@ class Pending:
     id: M[int] = mc(primary_key=True)
     expire_at: M[int] = mc()
 
-    files: M[list["DedupFile"]] = relationship(back_populates="pending", **rel_kw_cascade)
+    files: M[list["File"]] = relationship(back_populates="pending", **rel_kw_cascade)
+    objs: M[list["Obj"]] = relationship(back_populates="pending", **rel_kw_cascade)
 
 
 @BaseDedup.registry.mapped_as_dataclass(init=False)
@@ -92,44 +154,131 @@ class Link:
 
     __tablename__ = "dedup_link"
 
-    link_path: M[bytes] = mc(primary_key=True)  # utf-8 encoded
-    file_id: M[int] = mc(_make_file_fk(), index=True, nullable=False)
-    created_at: M[int] = mc(insert_default=now, nullable=False)
-
-    file: M["DedupFile"] = relationship(back_populates="links", **rel_kw_basic)
-
-
-tmp_bytes = sa.Table("bytes", sa.MetaData(), sa.Column("id", sa.LargeBinary, primary_key=True))
-tmp_ints = sa.Table("ints", sa.MetaData(), sa.Column("id", sa.Integer, primary_key=True))
-tmp_hash_lookup = sa.Table(
-    "files_by_hash",
-    sa.MetaData(),
-    sa.Column("id", sa.Integer, primary_key=True),
-    sa.Column("hash_function", sa.Integer),
-    sa.Column("digest", sa.LargeBinary),
-    sa.Column("metadata_bytes", sa.LargeBinary),
-)
+    path: M[bytes] = mc(primary_key=True)  # utf-8 encoded
+    file_id: M[int] = mc(_make_file_fk(), index=True)
+    mtime: M[int | None] = mc()  # whether this field means anything depends on the backend
+    created_at: M[int | None] = mc()
+
+    file: M["File"] = relationship(back_populates="links", **rel_kw_basic)
+
+
+_tmp_meta = sa.MetaData()
+tmp_bytes = sa.Table("bytes", _tmp_meta, sa.Column("id", sa.LargeBinary, primary_key=True))
+tmp_ints = sa.Table("ints", _tmp_meta, sa.Column("id", sa.Integer, primary_key=True))
+
+
+@attr.s(frozen=True)
+class TmpNewFiles:
+    files: sa.Table = attr.ib()
+    tags: sa.Table = attr.ib()
+    hashes: sa.Table = attr.ib()
+
+
+@attr.s(frozen=True)
+class TmpNewFiles2:
+    files: sa.Table = attr.ib()
+    links: sa.Table = attr.ib()
+    objs: sa.Table = attr.ib()
+
+
+@attr.s(frozen=True)
+class TmpCheckLinks:
+    links: sa.Table = attr.ib()
+
+
+@attr.s(frozen=True)
+class TmpDeleteExtra:
+    files: sa.Table = attr.ib()
+
+
+def _make_temp_new_files(maker: MetaDataMaker):
+    # If an Obj has already-available contents in a File, then that File's id is written to
+    # content_file_id. Otherwise it is NULL.
+    files = maker.table(
+        "files",
+        sa.Column("id", sa.Integer, primary_key=True, nullable=False),
+        sa.Column("link_path", sa.LargeBinary, nullable=True),
+        sa.Column("metadata_bytes", sa.LargeBinary),
+        sa.Column("insert_obj_if_missing", sa.Boolean),
+        # sa.Column("adopt_existing", sa.Boolean, server_default=text("0")),
+        sa.Column("obj_id", sa.Integer, nullable=True),  # ref: Obj.id
+        sa.Column("new_obj_id", sa.Integer, nullable=True),  # ref: Obj.id
+    )
+    tags = maker.table(
+        "files_by_tag",
+        sa.Column("id", sa.Integer, primary_key=True, index=True),  # ref: temp.files.id
+        sa.Column("name", sa.LargeBinary, primary_key=True),
+    )
+    hashes = maker.table(
+        "files_by_hash",
+        sa.Column("id", sa.Integer, primary_key=True),  # ref: temp.files.id
+        sa.Column("hash_function", sa.Integer, primary_key=True),
+        sa.Column("hash", sa.LargeBinary),
+    )
+    return TmpNewFiles(files=files, tags=tags, hashes=hashes)
+
+
+def _make_temp_new_files2(maker: MetaDataMaker):
+    files = maker.table(
+        "files",
+        sa.Column("file_id", sa.Integer, primary_key=True, nullable=False),
+        sa.Column("obj_id", sa.Integer),
+    )
+    links = maker.table(
+        "links",
+        sa.Column("link_path", sa.LargeBinary, primary_key=True, nullable=False),
+        sa.Column("file_id", sa.Integer),
+        sa.Column("link_count", sa.Integer),
+    )
+    objs = maker.table(
+        "objs",
+        sa.Column("obj_id", sa.Integer, primary_key=True, nullable=False),
+        sa.Column("size", sa.Integer),
+    )
+    return TmpNewFiles2(files=files, links=links, objs=objs)
+
+
+def _make_temp_check_lx(maker: MetaDataMaker):
+    links = maker.table(
+        "links",
+        sa.Column("path", sa.LargeBinary, primary_key=True, nullable=False),
+    )
+    return TmpCheckLinks(links)
+
+
+def _make_temp_delete_extra(maker: MetaDataMaker):
+    files = maker.table(
+        "files",
+        sa.Column("id", sa.Integer, primary_key=True, nullable=False),
+    )
+    return TmpDeleteExtra(files)
+
+
+tmp_new_files: CacheTmp[TmpNewFiles] = CacheTmp(_make_temp_new_files)
+tmp_new_files2: CacheTmp[TmpNewFiles2] = CacheTmp(_make_temp_new_files2)
+tmp_check_links: CacheTmp[TmpCheckLinks] = CacheTmp(_make_temp_check_lx)
+tmp_delete_extra: CacheTmp[TmpDeleteExtra] = CacheTmp(_make_temp_delete_extra)
 
 
 @BaseDedup.registry.mapped_as_dataclass(init=False)
 class Tag:
     __tablename__ = "dedup_tag"
 
-    file_id: M[int] = mc(_make_file_fk(), primary_key=True, nullable=False)
+    obj_id: M[int] = mc(_make_obj_fk(), primary_key=True)
     name: M[bytes] = mc(primary_key=True, index=True)
 
-    file: M["DedupFile"] = relationship(back_populates="tags", **rel_kw_basic)
+    obj: M["Obj"] = relationship(back_populates="tags", **rel_kw_basic)
 
 
 @BaseDedup.registry.mapped_as_dataclass(init=False)
 class Hash:
     __tablename__ = "dedup_hashes"
 
-    file_id: M[int] = mc(_make_file_fk(), primary_key=True, nullable=False)
+    obj_id: M[int] = mc(_make_obj_fk(), primary_key=True)
     hash_function: M[int] = mc(primary_key=True)
     hash: M[bytes] = mc(index=True)
 
-    file: M["DedupFile"] = relationship(back_populates="hashes", **rel_kw_basic)
+    obj: M["Obj"] = relationship(back_populates="hashes", **rel_kw_basic)
 
     @classmethod
     def from_digest(cls, digest: mh.Digest, **kw):
@@ -164,11 +313,17 @@ class _HashCompareByDigest:
         return sa.not_(self == other)
 
 
+sa.Index("ix_dedup_obj_pending_partial", Obj.pending_id, sqlite_where=Obj.pending_id != None)
+sa.Index("ix_dedup_file_pending_partial", File.pending_id, sqlite_where=File.pending_id != None)
+sa.Index("ix_dedup_obj_orphaned_at_partial", Obj.orphaned_at, sqlite_where=Obj.orphaned_at != None)
+sa.Index("ix_dedup_file_link_count", File.obj_id, sa.desc(File.link_count))
 sa.Index(
-    "ix_dedup_file_pending_partial", DedupFile.pending_id, sqlite_where=DedupFile.pending_id != None
+    "ix_dedup_file_link_count_invalid",
+    File.id,
+    sqlite_where=File.link_count < sa.literal_column("0"),
 )
 sa.Index(
-    "ix_dedup_file_orphaned_at_partial",
-    DedupFile.orphaned_at,
-    sqlite_where=DedupFile.orphaned_at != None,
+    "ix_dedup_obj_created_at_partial",
+    Obj.created_at,
+    sqlite_where=Obj.created_at < sa.literal_column("0"),
 )

vocker/repo/io.py

@@ -387,6 +387,10 @@ class RepoTransfer:
 
         assert_(not is_dir)
 
+        # The content may already be available locally, let's just try.
+        if (fp := self.dedup.open_by_hash(digest)) is not None:
+            return fp
+
         _open = None if acc is None else (lambda: acc.download_open(path))
 
         req = de.DedupLinkRequest(
@@ -560,6 +564,8 @@ class RepoTransfer:
                 for archive_info in archive_infos:
                     archive_io = ex.enter_context(self.open_compressed(archive_info.archive_path))
                     files += (A(archive_io, info) for info in archive_info.files)
+                if files and (fs := files[0].info.files):
+                    logger.info("extracting files...", data_sample_path=str(fs[0].path))
                 exporter.provide_files(files)
 
         def _group_archive_infos(iterable):
@@ -583,6 +589,7 @@ class RepoTransfer:
                 exe.submit(_process, a_info_group)
                 for a_info_group in _group_archive_infos(iterable)
             )
+        logger.info("done extracting, now finalizing...")
         exporter.end_session()
 
 

vocker/system.py

@@ -169,15 +169,15 @@ class UpdatingLocalRepository:
         def p(suffix):
             return path.with_name(path.name + suffix)
 
-        # compress contents directly to zstandard
-        with self.open(p(".zst"), "wb") as f1, cx.open_compressor(f1, "zst") as f:
+        # compress contents directly to xz
+        with self.open(p(".xz"), "wb") as f1, cx.open_compressor(f1, "xz") as f:
             yield f
 
-        # compress to xz as well
-        with self.open(p(".zst"), "rb") as fr1, cx.open_decompressor(fr1, "zst") as fr, self.open(
-            p(".xz"), "wb"
-        ) as fw1, cx.open_compressor(fw1, "xz") as fw:
-            shutil.copyfileobj(fr, fw)
+        # # compress to zst as well
+        # with self.open(p(".xz"), "rb") as fr1, cx.open_decompressor(fr1, "xz") as fr, self.open(
+        #     p(".zst"), "wb"
+        # ) as fw1, cx.open_compressor(fw1, "zst") as fw:
+        #     shutil.copyfileobj(fr, fw)
 
     def iterdir(self, path: PurePath):
         raise NotImplementedError("not needed yet")
@@ -261,7 +261,10 @@ class LocalRepository:
             yield u
 
             # Adopt the files.
+            dedup = self.system.repo_dedup
+            _plain = de.DedupFileMetadata.make_plain()
             base = self._path_base
+            hashes = {}
             reqs_adopt = []
             reqs_copy = []
             for p_rel in u.updated_paths:
@@ -270,12 +273,20 @@ class LocalRepository:
                 if p.exists():
                     if not p.is_file():
                         raise ValueError("only regular files are supported")
-                    reqs_adopt.append(adopt_req := de.AdoptRequest(p))
-                    reqs_copy.append(de.DedupCopyLinkRequest(src=p, dst=(dst := base / p_rel)))
-                    dst.parent.mkdir(exist_ok=True, parents=True)
+                    hashes[p_rel] = h = dedup.get_file_hash(hf, p, check_link=True)
+                    if h is None:
+                        reqs_adopt.append(
+                            de.DedupLinkRequest(
+                                hash_function=hf,
+                                link_path=p,
+                                file_metadata=_plain,
+                                file_contents_hash=None,
+                                open_file_once=None,
+                                adopt_existing=True,
+                            )
+                        )
 
-            dedup = self.system.repo_dedup
-            dedup.adopt_files(hf, reqs_adopt)
+            dedup.run_batch(reqs_adopt)
 
             # Now we gather the hashes for all the files so we can update the manifest nodes. We
             # need to do this after the `adopt_files` above because that operation computes the
@@ -285,12 +296,24 @@ class LocalRepository:
             )
             for p_rel in u.updated_paths:
                 if (p := u.workspace_path / p_rel).exists():
-                    r = dedup.get_file_hash(hf, u.workspace_path / p_rel, check_link=True)
-                    assert r is not None
+                    if (r := hashes[p_rel]) is None:
+                        r = dedup.get_file_hash(hf, p, check_link=True)
+                    assert r is not None, f"expected {p} to be adopted"
                     value = False, r[1]
+                    reqs_copy.append(
+                        de.DedupLinkRequest(
+                            hash_function=hf,
+                            link_path=(dst := base / p_rel),
+                            file_metadata=_plain,
+                            file_contents_hash=r[1],
+                            open_file_once=None,
+                        )
+                    )
+                    dst.parent.mkdir(exist_ok=True, parents=True)
                 else:
                     value = None
                 dirs[len(p_rel.parts) - 1][p_rel.parent][p_rel.name] = value
+            del hashes
 
             # Here begins the critical section. If this part fails, the local repository will be broken.
             self._path_ok.unlink(missing_ok=True)
@@ -556,7 +579,7 @@ class System:
                 with u.open(archive_path / "h.bin", "wb") as f:
                     rio.HashesWriter(f).write_all(h for h in archive_digests)
 
-                archive_size = u.get_path_for_open(archive_path / "a.zst", "wb").stat().st_size
+                archive_size = u.get_path_for_open(archive_path / "a.xz", "wb").stat().st_size
 
                 shard_path = u.id_to_path("shard", (shard_id := u.allocate_id("shard")))
                 with u.open_for_write_multi_compressed(shard_path / "p") as f:
@@ -585,7 +608,7 @@ class System:
             with u.open_for_write_multi_compressed(img_path / "u") as f:
                 rio.cbor_dump({"image_type": image_type.value}, f)
 
-            with u.open(img_path / "u.zst", "rb") as f1, cx.open_decompressor(f1, "zst") as f:
+            with u.open(img_path / "u.xz", "rb") as f1, cx.open_decompressor(f1, "xz") as f:
                 hasher = hf()
                 while b := f.read(65536):
                     hasher.update(b)

vocker/util.py

@@ -47,10 +47,12 @@ def pprofile(options=None):
         with runner:
             yield runner
     finally:
-        with open(cg, "wt", encoding="utf-8") as file:
-            prof.callgrind(file)
-        with open(annotate, "wt", encoding="utf-8") as file:
-            prof.annotate(file)
+        if cg:
+            with open(cg, "wt", encoding="utf-8") as file:
+                prof.callgrind(file)
+        if annotate:
+            with open(annotate, "wt", encoding="utf-8") as file:
+                prof.annotate(file)
 
 
 def supports_executable() -> bool:

{vocker-0.2.0.dist-info → vocker-0.3.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: vocker
-Version: 0.2.0
+Version: 0.3.1
 Summary: Docker-like manager for virtualenvs
 Author-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
 License: General Public License v3
-Project-URL: Homepage, https://hydra.ecd.space/deaduard/vocker/
-Project-URL: Changelog, https://hydra.ecd.space/deaduard/vocker/file?name=CHANGELOG.md&ci=trunk
+Project-URL: Homepage, https://hydra.ecd.space/ecd/vocker/
+Project-URL: Changelog, https://hydra.ecd.space/ecd/vocker/file?name=CHANGELOG.md&ci=trunk
 Description-Content-Type: text/markdown
 Requires-Dist: atomicwrites
 Requires-Dist: attrs
@@ -15,8 +15,8 @@ Requires-Dist: filelock
 Requires-Dist: immutabledict
 Requires-Dist: marshmallow
 Requires-Dist: platformdirs
-Requires-Dist: sansio_tools>=1.0.0
-Requires-Dist: sqlalchemy_boltons>=2.4.0
+Requires-Dist: sansio_tools>=1
+Requires-Dist: sqlalchemy_boltons>=5
 Requires-Dist: SQLAlchemy
 Requires-Dist: structlog
 Requires-Dist: cbor2

{vocker-0.2.0.dist-info → vocker-0.3.1.dist-info}/RECORD

@@ -1,19 +1,19 @@
 vocker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vocker/__main__.py,sha256=jNkuxmxpoWPeKXHVf-TyEECSY62QZQHoR2F_Bp6zsNM,35
-vocker/cli.py,sha256=MQfac_AL5febfwDcgNOjuQA9rsq6kyGXVn2rp-6toP8,13248
-vocker/dedup.py,sha256=XgWJMZ14mP4BgNkH3gVOqwKX6KScRrGuRPs4Q2vysH8,63923
-vocker/dedup_models.py,sha256=R0lTKazCQnYNaIdlTfeCLldR4e66CxQ8jgfIjxfjmrA,5612
+vocker/cli.py,sha256=066HLK3ayv1qSajlFhkvU3wowPzH84ZOt_yGtedaSNk,13151
+vocker/dedup.py,sha256=J7bdhbNPaeMFV6bj72_uYtYfOSBboAIljSBuNTHARso,72447
+vocker/dedup_models.py,sha256=stgBOshVzEwWZykcv1RVHX_3P2qTeRWzB1xWLuNdW4E,11227
 vocker/image.py,sha256=lewNLLiXnd_N1CSs4gnYFEj-d5RkIBiPQiN8hNL2fIs,28181
 vocker/integer_to_path.py,sha256=5ghlupk9VLzXLtcfwnVEVFxtBxyT8A_ooV8-2EAnoFw,1433
 vocker/multihash.py,sha256=-VhksUBam6N01fICtTg_TJrJcEIHJrYVKzkD1B_bdfI,8760
 vocker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vocker/system.py,sha256=S7ZhqaUJilPl4tiO2XHxf0tR3Uw_HJXfvvx5j-QV7Ug,24766
-vocker/util.py,sha256=bQcMzscMPaiBC4PGV9_clTOLDTJHuqa6l6o2thQJeU8,3223
+vocker/system.py,sha256=fX3By0_MqC705T1IdmkxAY4FM6VaY8x6FdegB6a8-dM,25727
+vocker/util.py,sha256=1Escs1FSrzrTy3Rzhn9r41K75KTt9VjQV91iT3P_FyI,3275
 vocker/util_models.py,sha256=2bN5eousF92oH7BAv1ZFoyh6iqNAnJ_niiclp2_RaHI,395
 vocker/repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vocker/repo/compression.py,sha256=l2g1e6SaugpqORbg3zwRM1zwlEXedbYOihm5nDpCejU,6442
-vocker/repo/io.py,sha256=7oUDd2vag300hRJe72VcfGVAtWDIxtMd-5pY6I_z_Fs,25250
-vocker-0.2.0.dist-info/METADATA,sha256=l_sFYB7OlQVrvlACM7Y3jQ95BlLtU9iTZSyj9mHYFzA,3853
-vocker-0.2.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-vocker-0.2.0.dist-info/top_level.txt,sha256=5x7g7T2L44UKODxVZ4vmWjxDnnruxaZ5yloYi0wLoUg,7
-vocker-0.2.0.dist-info/RECORD,,
+vocker/repo/io.py,sha256=Juzt7vHjfd-H36tWpdYZNh7ucf-h0bC7_WwZ46liNx0,25614
+vocker-0.3.1.dist-info/METADATA,sha256=NUmG0yxLQmKnVUvsKM-8awDqd4d924LB_fVt9fdB67E,3835
+vocker-0.3.1.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+vocker-0.3.1.dist-info/top_level.txt,sha256=5x7g7T2L44UKODxVZ4vmWjxDnnruxaZ5yloYi0wLoUg,7
+vocker-0.3.1.dist-info/RECORD,,