vocker 0.1.0__py3-none-any.whl → 0.3.0__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

@@ -16,8 +16,9 @@ import typing as ty
 
 import atomicwrites
 import attr
+import marshmallow as ma
+import marshmallow.fields as maf
 import platformdirs
-import strictyaml as sy
 import structlog
 
 from . import dedup as de, multihash as mh, image as im
@@ -40,10 +41,6 @@ def validate_local_repo_name(name: str) -> None:
         raise ValueError(f"invalid repo name: {name!r}")
 
 
-def cget(x, *args):
-    return x.value.get(*args)
-
-
 @attr.s(eq=False, hash=False)
 class RemoteRepository:
     uri: str = attr.ib()
@@ -73,7 +70,8 @@ class _Remotes(MutableMapping[str, RemoteRepository]):
         return self.system._config["remote_repositories"]
 
     def __getitem__(self, k):
-        d = self._data[k].data
+        d = self._data[k]
+        d.pop("comment", None)
         return RemoteRepository(**d)
 
     def __setitem__(self, k, v: RemoteRepository | None):
@@ -90,21 +88,25 @@ class _Remotes(MutableMapping[str, RemoteRepository]):
         self[k] = None
 
     def __iter__(self):
-        return iter(x.value for x in self._data.value)
+        return iter(x for x in self._data)
 
     def __len__(self, k, v):
-        return len(self._data.value)
+        return len(self._data)
+
+
+class _SchemaWithComment(ma.Schema):
+    class Meta:
+        unknown = ma.RAISE
+
+    comment = maf.Field(allow_none=True, data_key="#", required=False)
 
 
-config_schema = sy.EmptyDict() | sy.MapCombined(
-    {
-        sy.Optional("remote_repositories"): (
-            sy.EmptyDict() | sy.MapPattern(sy.Str(), sy.Map({"uri": sy.Str()}))
-        ),
-    },
-    sy.Str(),
-    sy.Any(),
-)
+class SchemaRemoteRepository(_SchemaWithComment):
+    uri = maf.String(required=True)
+
+
+class SchemaConfig(_SchemaWithComment):
+    remote_repositories = maf.Dict(maf.String(), maf.Nested(SchemaRemoteRepository, required=False))
 
 
 class ImageType(enum.Enum):
@@ -112,18 +114,16 @@ class ImageType(enum.Enum):
 
 
 @attr.s(eq=False, hash=False)
-class StrictYamlFileWithCaching:
+class JSONFileWithCaching:
     path: Path = attr.ib()
-    schema = attr.ib(default=None)
+    schema: ma.Schema = attr.ib(default=None)
     _mtime = None
     _document = None
 
     @property
     def document(self):
         if (mtime := (p := self.path).stat().st_mtime_ns) != self._mtime:
-            self._document = doc = sy.load(
-                p.read_bytes().decode("utf-8"), schema=self.schema, label=str(self.path)
-            )
+            self._document = doc = self.schema.load(json.loads(p.read_bytes()))
             self._mtime = mtime
         else:
             doc = self._document
@@ -134,7 +134,7 @@ class StrictYamlFileWithCaching:
         with atomicwrites.atomic_write(
             str(self.path), mode="wt", overwrite=True, encoding="utf-8", newline="\n"
         ) as fp:
-            fp.write(new_value.as_yaml())
+            json.dump(self.schema.dump(new_value), fp, indent=2)
         self._document = new_value
 
 
@@ -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)
@@ -418,13 +441,13 @@ class System:
 
         self.path_repo_local.mkdir(exist_ok=True, parents=True)
 
-        config_path = self.path_base / "config.yaml"
-        cfg = StrictYamlFileWithCaching(config_path, schema=config_schema)
+        config_path = self.path_base / "vocker.json"
+        cfg = JSONFileWithCaching(config_path, schema=SchemaConfig())
         try:
             cfg.document
         except FileNotFoundError:
             config_path.parent.mkdir(exist_ok=True, parents=True)
-            config_path.write_bytes(b"")
+            config_path.write_bytes(b"{}")
             cfg.document
         self._config_file = cfg
         self._init_config()
@@ -433,10 +456,17 @@ class System:
         c = self._config
         modified = False
 
-        if cget(c, k := "remote_repositories") is None:
+        if c.get(k := "remote_repositories") is None:
             c[k] = {}
             modified = True
 
+        if c.get(k := "comment") is None:
+            c[k] = [
+                "Since JSON doesn't allow comments, you can place them inside the '#' key inside",
+                "most of the dictionaries.",
+            ]
+            modified = True
+
         if modified:
             self._config_write(c)
 

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.1.0.dist-info → vocker-0.3.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: vocker
-Version: 0.1.0
+Version: 0.3.0
 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,10 +15,9 @@ 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: strictyaml
 Requires-Dist: structlog
 Requires-Dist: cbor2
 Provides-Extra: zstandard

{vocker-0.1.0.dist-info → vocker-0.3.0.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=kw0-0vxE5jjHjnE1kzhDZB_YdzA5kBDLeU0TdudnJgg,24416
-vocker/util.py,sha256=bQcMzscMPaiBC4PGV9_clTOLDTJHuqa6l6o2thQJeU8,3223
+vocker/system.py,sha256=v3ONv335EqDdCzne--ybTZPdHgUZ_kRKhzCALXjrcFw,25728
+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.1.0.dist-info/METADATA,sha256=P9TNrszsFyA2Q3HItjFoMeKdeCALldVmbu4VCxwv_KE,3879
-vocker-0.1.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-vocker-0.1.0.dist-info/top_level.txt,sha256=5x7g7T2L44UKODxVZ4vmWjxDnnruxaZ5yloYi0wLoUg,7
-vocker-0.1.0.dist-info/RECORD,,
+vocker/repo/io.py,sha256=Juzt7vHjfd-H36tWpdYZNh7ucf-h0bC7_WwZ46liNx0,25614
+vocker-0.3.0.dist-info/METADATA,sha256=a7Qhq98kbIQe8sQfef7xl5S3dXZUN54Hx0snel0MTW4,3835
+vocker-0.3.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+vocker-0.3.0.dist-info/top_level.txt,sha256=5x7g7T2L44UKODxVZ4vmWjxDnnruxaZ5yloYi0wLoUg,7
+vocker-0.3.0.dist-info/RECORD,,