glitchlings 0.4.0__cp310-cp310-manylinux_2_28_x86_64.whl → 0.4.1__cp310-cp310-manylinux_2_28_x86_64.whl

glitchlings/lexicon/__init__.py

@@ -4,10 +4,12 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from hashlib import blake2s
+from pathlib import Path
 import random
 from typing import Callable, Iterable
 
 from glitchlings.config import get_config
+from ._cache import CacheEntries, CacheSnapshot
 
 
 class Lexicon(ABC):
@@ -79,6 +81,21 @@ class Lexicon(ABC):
         return f"{self.__class__.__name__}(seed={self._seed!r})"
 
 
+class LexiconBackend(Lexicon):
+    """Extended lexicon interface that supports cache persistence."""
+
+    Cache = CacheEntries
+
+    @classmethod
+    @abstractmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Return a validated cache snapshot loaded from ``path``."""
+
+    @abstractmethod
+    def save_cache(self, path: str | Path | None = None) -> Path | None:
+        """Persist the backend cache to ``path`` and return the destination."""
+
+
 from .graph import GraphLexicon
 from .metrics import (
     compare_lexicons,
@@ -176,6 +193,7 @@ def get_default_lexicon(seed: int | None = None) -> Lexicon:
 
 __all__ = [
     "Lexicon",
+    "LexiconBackend",
     "VectorLexicon",
     "GraphLexicon",
     "WordNetLexicon",

glitchlings/lexicon/_cache.py

@@ -0,0 +1,111 @@
+"""Shared cache helpers for lexicon backends."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from hashlib import blake2s
+from pathlib import Path
+from typing import Mapping, Sequence
+
+
+CacheEntries = dict[str, list[str]]
+
+
+@dataclass(frozen=True)
+class CacheSnapshot:
+    """Materialised cache data and its integrity checksum."""
+
+    entries: CacheEntries
+    checksum: str | None = None
+
+
+def _normalise_entries(payload: Mapping[str, Sequence[str]]) -> CacheEntries:
+    """Convert raw cache payloads into canonical mapping form."""
+
+    entries: CacheEntries = {}
+    for key, values in payload.items():
+        if not isinstance(key, str):
+            raise RuntimeError("Synonym cache keys must be strings.")
+        if not isinstance(values, Sequence):
+            raise RuntimeError("Synonym cache values must be sequences of strings.")
+        entries[key] = [str(value) for value in values]
+    return entries
+
+
+def _canonical_json(entries: Mapping[str, Sequence[str]]) -> str:
+    """Return a deterministic JSON serialisation for ``entries``."""
+
+    serialisable = {key: list(values) for key, values in sorted(entries.items())}
+    return json.dumps(serialisable, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def compute_checksum(entries: Mapping[str, Sequence[str]]) -> str:
+    """Return a BLAKE2s checksum for ``entries``."""
+
+    digest = blake2s(_canonical_json(entries).encode("utf8"), digest_size=16)
+    return digest.hexdigest()
+
+
+def load_cache(path: Path) -> CacheSnapshot:
+    """Load a cache from ``path`` and verify its checksum if present."""
+
+    if not path.exists():
+        return CacheSnapshot(entries={}, checksum=None)
+
+    with path.open("r", encoding="utf8") as handle:
+        payload = json.load(handle)
+
+    checksum: str | None = None
+    entries_payload: Mapping[str, Sequence[str]]
+
+    if isinstance(payload, Mapping) and "__meta__" in payload and "entries" in payload:
+        meta = payload["__meta__"]
+        entries_payload = payload["entries"]  # type: ignore[assignment]
+        if not isinstance(entries_payload, Mapping):
+            raise RuntimeError("Synonym cache entries must be stored as a mapping.")
+        if isinstance(meta, Mapping):
+            raw_checksum = meta.get("checksum")
+            if raw_checksum is not None and not isinstance(raw_checksum, str):
+                raise RuntimeError("Synonym cache checksum must be a string when provided.")
+            checksum = raw_checksum
+        else:
+            raise RuntimeError("Synonym cache metadata must be a mapping.")
+    elif isinstance(payload, Mapping):
+        entries_payload = payload  # legacy format without metadata
+    else:
+        raise RuntimeError("Synonym cache payload must be a mapping of strings to lists.")
+
+    entries = _normalise_entries(entries_payload)
+    if checksum is not None:
+        expected = compute_checksum(entries)
+        if checksum != expected:
+            raise RuntimeError(
+                "Synonym cache checksum mismatch; the cache file appears to be corrupted."
+            )
+
+    return CacheSnapshot(entries=entries, checksum=checksum)
+
+
+def write_cache(path: Path, entries: Mapping[str, Sequence[str]]) -> CacheSnapshot:
+    """Persist ``entries`` to ``path`` with checksum metadata."""
+
+    serialisable = {key: list(values) for key, values in sorted(entries.items())}
+    checksum = compute_checksum(serialisable)
+    payload = {
+        "__meta__": {
+            "checksum": checksum,
+            "entries": len(serialisable),
+        },
+        "entries": serialisable,
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    with path.open("w", encoding="utf8") as handle:
+        json.dump(payload, handle, ensure_ascii=False, indent=2, sort_keys=True)
+
+    return CacheSnapshot(entries=serialisable, checksum=checksum)
+
+
+__all__ = ["CacheEntries", "CacheSnapshot", "compute_checksum", "load_cache", "write_cache"]
+

glitchlings/lexicon/graph.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-import json
 import re
 from pathlib import Path
 from typing import Iterable, Mapping, MutableMapping, Sequence
 
-from . import Lexicon
+from . import LexiconBackend
+from ._cache import CacheSnapshot, load_cache as _load_cache_file, write_cache as _write_cache_file
 from .vector import VectorLexicon
 
 
@@ -140,30 +140,7 @@ def _load_numberbatch(path: Path, *, languages: set[str]) -> Mapping[str, list[f
     return embeddings
 
 
-def _load_cache(path: Path) -> dict[str, list[str]]:
-    if not path.exists():
-        return {}
-    with path.open("r", encoding="utf8") as handle:
-        payload = json.load(handle)
-    if not isinstance(payload, Mapping):
-        raise RuntimeError("Graph lexicon cache must be a mapping of strings to lists.")
-    cache: dict[str, list[str]] = {}
-    for key, values in payload.items():
-        if not isinstance(key, str):
-            raise RuntimeError("Graph lexicon cache keys must be strings.")
-        if not isinstance(values, Sequence):
-            raise RuntimeError("Graph lexicon cache values must be sequences of strings.")
-        cache[key] = [str(value) for value in values]
-    return cache
-
-
-def _write_cache(path: Path, cache: Mapping[str, Sequence[str]]) -> None:
-    serialisable = {key: list(values) for key, values in sorted(cache.items())}
-    with path.open("w", encoding="utf8") as handle:
-        json.dump(serialisable, handle, ensure_ascii=False, indent=2, sort_keys=True)
-
-
-class GraphLexicon(Lexicon):
+class GraphLexicon(LexiconBackend):
     """Lexicon backed by ConceptNet/Numberbatch embeddings."""
 
     def __init__(
@@ -184,9 +161,12 @@ class GraphLexicon(Lexicon):
         self._max_neighbors = max(1, max_neighbors)
         self._min_similarity = min_similarity
         self._cache: MutableMapping[str, list[str]] = {}
-        self._cache_path = Path(cache_path) if cache_path is not None else None
+        self._cache_path: Path | None = Path(cache_path) if cache_path is not None else None
+        self._cache_checksum: str | None = None
         if self._cache_path is not None:
-            self._cache.update(_load_cache(self._cache_path))
+            snapshot = _load_cache_file(self._cache_path)
+            self._cache.update(snapshot.entries)
+            self._cache_checksum = snapshot.checksum
         if cache is not None:
             for key, values in cache.items():
                 self._cache[str(key)] = [str(value) for value in values]
@@ -278,6 +258,12 @@ class GraphLexicon(Lexicon):
     def export_cache(self) -> dict[str, list[str]]:
         return {key: list(values) for key, values in self._cache.items()}
 
+    @classmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Load and validate a persisted ConceptNet cache file."""
+
+        return _load_cache_file(Path(path))
+
     def save_cache(self, path: str | Path | None = None) -> Path:
         if path is None:
             if self._cache_path is None:
@@ -286,7 +272,8 @@ class GraphLexicon(Lexicon):
         else:
             target = Path(path)
             self._cache_path = target
-        _write_cache(target, self._cache)
+        snapshot = _write_cache_file(target, self._cache)
+        self._cache_checksum = snapshot.checksum
         self._cache_dirty = False
         return target
 

glitchlings/lexicon/vector.py

@@ -10,7 +10,8 @@ from pathlib import Path
 import sys
 from typing import Any, Callable, Iterable, Iterator, Mapping, MutableMapping, Sequence
 
-from . import Lexicon
+from . import LexiconBackend
+from ._cache import CacheSnapshot, load_cache as _load_cache_file, write_cache as _write_cache_file
 
 
 def _cosine_similarity(vector_a: Sequence[float], vector_b: Sequence[float]) -> float:
@@ -241,38 +242,7 @@ def _resolve_source(source: Any | None) -> _Adapter | None:
     raise RuntimeError("Unsupported vector source supplied to VectorLexicon.")
 
 
-def _load_cache(path: Path) -> dict[str, list[str]]:
-    """Load a synonym cache from ``path`` if it exists."""
-
-    if not path.exists():
-        return {}
-
-    with path.open("r", encoding="utf8") as handle:
-        payload = json.load(handle)
-
-    if not isinstance(payload, Mapping):
-        raise RuntimeError("Synonym cache must be a JSON mapping of strings to lists.")
-
-    cache: dict[str, list[str]] = {}
-    for key, values in payload.items():
-        if not isinstance(key, str):
-            raise RuntimeError("Synonym cache keys must be strings.")
-        if not isinstance(values, Sequence):
-            raise RuntimeError("Synonym cache values must be lists of strings.")
-        cache[key] = [str(value) for value in values]
-
-    return cache
-
-
-def _write_cache(path: Path, cache: Mapping[str, Sequence[str]]) -> None:
-    """Write ``cache`` to ``path`` deterministically."""
-
-    serialisable = {key: list(values) for key, values in sorted(cache.items())}
-    with path.open("w", encoding="utf8") as handle:
-        json.dump(serialisable, handle, ensure_ascii=False, indent=2, sort_keys=True)
-
-
-class VectorLexicon(Lexicon):
+class VectorLexicon(LexiconBackend):
     """Lexicon implementation backed by dense word embeddings."""
 
     def __init__(
@@ -292,9 +262,13 @@ class VectorLexicon(Lexicon):
         self._max_neighbors = max(1, max_neighbors)
         self._min_similarity = min_similarity
         self._cache: MutableMapping[str, list[str]] = {}
+        self._cache_path: Path | None
+        self._cache_checksum: str | None = None
         if cache_path is not None:
             path = Path(cache_path)
-            self._cache.update(_load_cache(path))
+            snapshot = _load_cache_file(path)
+            self._cache.update(snapshot.entries)
+            self._cache_checksum = snapshot.checksum
             self._cache_path = path
         else:
             self._cache_path = None
@@ -411,6 +385,12 @@ class VectorLexicon(Lexicon):
 
         return {key: list(values) for key, values in self._cache.items()}
 
+    @classmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        """Load and validate a cache file for reuse."""
+
+        return _load_cache_file(Path(path))
+
     def save_cache(self, path: str | Path | None = None) -> Path:
         """Persist the current cache to disk, returning the path used."""
 
@@ -422,7 +402,8 @@ class VectorLexicon(Lexicon):
             target = Path(path)
             self._cache_path = target
 
-        _write_cache(target, self._cache)
+        snapshot = _write_cache_file(target, self._cache)
+        self._cache_checksum = snapshot.checksum
         self._cache_dirty = False
         return target
 

glitchlings/lexicon/wordnet.py

@@ -32,7 +32,10 @@ if nltk is not None:  # pragma: no cover - guarded by import success
 else:
     _WORDNET_MODULE = None
 
-from . import Lexicon
+from pathlib import Path
+
+from . import LexiconBackend
+from ._cache import CacheSnapshot
 
 _WORDNET_HANDLE: WordNetCorpusReader | Any | None = _WORDNET_MODULE
 _wordnet_ready = False
@@ -151,7 +154,7 @@ def _collect_synonyms(word: str, parts_of_speech: tuple[str, ...]) -> list[str]:
     return sorted(synonyms)
 
 
-class WordNetLexicon(Lexicon):
+class WordNetLexicon(LexiconBackend):
     """Lexicon that retrieves synonyms from the NLTK WordNet corpus."""
 
     def get_synonyms(
@@ -175,6 +178,13 @@ class WordNetLexicon(Lexicon):
             return True
         return pos.lower() in _VALID_POS
 
+    @classmethod
+    def load_cache(cls, path: str | Path) -> CacheSnapshot:
+        raise RuntimeError("WordNetLexicon does not persist or load caches.")
+
+    def save_cache(self, path: str | Path | None = None) -> Path | None:
+        raise RuntimeError("WordNetLexicon does not persist or load caches.")
+
     def __repr__(self) -> str:  # pragma: no cover - trivial representation
         return f"WordNetLexicon(seed={self.seed!r})"
 

glitchlings/zoo/core.py

@@ -18,9 +18,13 @@ else:
     _datasets_error = None
 
 try:  # pragma: no cover - optional dependency
-    from glitchlings._zoo_rust import compose_glitchlings as _compose_glitchlings_rust
+    from glitchlings._zoo_rust import (
+        compose_glitchlings as _compose_glitchlings_rust,
+        plan_glitchlings as _plan_glitchlings_rust,
+    )
 except ImportError:  # pragma: no cover - compiled extension not present
     _compose_glitchlings_rust = None
+    _plan_glitchlings_rust = None
 
 
 log = logging.getLogger(__name__)
@@ -47,6 +51,76 @@ def _pipeline_feature_flag_enabled() -> bool:
 
     return True
 
+def _plan_glitchlings_python(
+    specs: list[dict[str, Any]],
+    master_seed: int,
+) -> list[tuple[int, int]]:
+    """Pure-Python fallback for orchestrating glitchlings in deterministic order."""
+
+    master_seed_int = int(master_seed)
+    planned: list[tuple[int, int, int, int, str]] = []
+    for index, spec in enumerate(specs):
+        name = str(spec["name"])
+        scope = int(spec["scope"])
+        order = int(spec["order"])
+        derived_seed = Gaggle.derive_seed(master_seed_int, name, index)
+        planned.append((index, derived_seed, scope, order, name))
+
+    planned.sort(key=lambda entry: (entry[2], entry[3], entry[4], entry[0]))
+    return [(index, seed) for index, seed, *_ in planned]
+
+
+def _plan_glitchlings_with_rust(
+    specs: list[dict[str, Any]],
+    master_seed: int,
+) -> list[tuple[int, int]] | None:
+    """Attempt to obtain the orchestration plan from the compiled Rust module."""
+
+    if _plan_glitchlings_rust is None:
+        return None
+
+    try:
+        plan = _plan_glitchlings_rust(specs, int(master_seed))
+    except Exception:  # pragma: no cover - defer to Python fallback on failure
+        log.debug("Rust orchestration planning failed; falling back to Python plan", exc_info=True)
+        return None
+
+    return [(int(index), int(seed)) for index, seed in plan]
+
+
+def _plan_glitchling_specs(
+    specs: list[dict[str, Any]],
+    master_seed: int | None,
+) -> list[tuple[int, int]]:
+    """Resolve orchestration order and seeds from glitchling specifications."""
+
+    if master_seed is None:
+        message = "Gaggle orchestration requires a master seed"
+        raise ValueError(message)
+
+    master_seed_int = int(master_seed)
+    plan = _plan_glitchlings_with_rust(specs, master_seed_int)
+    if plan is not None:
+        return plan
+
+    return _plan_glitchlings_python(specs, master_seed_int)
+
+
+def _plan_glitchling_sequence(
+    glitchlings: list["Glitchling"], master_seed: int | None
+) -> list[tuple[int, int]]:
+    """Derive orchestration plan for concrete glitchling instances."""
+
+    specs = [
+        {
+            "name": glitchling.name,
+            "scope": int(glitchling.level),
+            "order": int(glitchling.order),
+        }
+        for glitchling in glitchlings
+    ]
+    return _plan_glitchling_specs(specs, master_seed)
+
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from datasets import Dataset  # type: ignore
 elif _DatasetsDataset is not None:
@@ -309,17 +383,17 @@ class Gaggle(Glitchling):
         """
 
         super().__init__("Gaggle", self.corrupt, AttackWave.DOCUMENT, seed=seed)
+        self._clones_by_index: list[Glitchling] = []
+        for idx, glitchling in enumerate(glitchlings):
+            clone = glitchling.clone()
+            setattr(clone, "_gaggle_index", idx)
+            self._clones_by_index.append(clone)
+
         self.glitchlings: dict[AttackWave, list[Glitchling]] = {
             level: [] for level in AttackWave
         }
         self.apply_order: list[Glitchling] = []
-        # Derive deterministic per-glitchling seeds from master seed if provided
-        for idx, g in enumerate(glitchlings):
-            _g = g.clone()
-            derived_seed = Gaggle.derive_seed(seed, _g.name, idx)
-            _g.reset_rng(derived_seed)
-            setattr(_g, "_gaggle_index", idx)
-            self.glitchlings[g.level].append(_g)
+        self._plan: list[tuple[int, int]] = []
         self.sort_glitchlings()
 
     @staticmethod
@@ -352,11 +426,27 @@ class Gaggle(Glitchling):
     def sort_glitchlings(self) -> None:
         """Sort glitchlings by wave then order to produce application order."""
 
-        self.apply_order = [
-            g
-            for _, glitchlings in sorted(self.glitchlings.items())
-            for g in sorted(glitchlings, key=lambda x: (x.order, x.name))
-        ]
+        plan = _plan_glitchling_sequence(self._clones_by_index, self.seed)
+        self._plan = plan
+
+        self.glitchlings = {level: [] for level in AttackWave}
+        for clone in self._clones_by_index:
+            self.glitchlings[clone.level].append(clone)
+
+        missing = set(range(len(self._clones_by_index)))
+        apply_order: list[Glitchling] = []
+        for index, derived_seed in plan:
+            clone = self._clones_by_index[index]
+            clone.reset_rng(int(derived_seed))
+            apply_order.append(clone)
+            missing.discard(index)
+
+        if missing:
+            missing_indices = ", ".join(str(idx) for idx in sorted(missing))
+            message = f"Orchestration plan missing glitchlings at indices: {missing_indices}"
+            raise RuntimeError(message)
+
+        self.apply_order = apply_order
 
     @staticmethod
     def rust_pipeline_supported() -> bool:

{glitchlings-0.4.0.dist-info → glitchlings-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.4.0
+Version: 0.4.1
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -420,7 +420,7 @@ _How can a computer need reading glasses?_
 
 ### Zeedub
 
-_A whispering glyph parasite that lives in the interstices of codepoints, marking territory with invisible traces._
+_Watch your step around here._
 
 > _**Invisible Ink.**_ Zeedub slips zero-width codepoints between non-space character pairs, forcing models to reason about text whose visible form masks hidden glyphs.
 >

{glitchlings-0.4.0.dist-info → glitchlings-0.4.1.dist-info}/RECORD

@@ -1,17 +1,18 @@
 glitchlings/__init__.py,sha256=hEmQ1rl3G5uZBDbfJX_W4aIUNSsPAsy_Ai5DgQHasvk,813
 glitchlings/__main__.py,sha256=EOiBgay0x6B9VlSDzSQvMuoq6bHJdSvFSgcAVGGKkd4,121
-glitchlings/_zoo_rust.cpython-310-x86_64-linux-gnu.so,sha256=XRtY6N72ag46KSBzzdvHrkhHouNvGEp8tYCqs5iQSFs,3223648
+glitchlings/_zoo_rust.cpython-310-x86_64-linux-gnu.so,sha256=F721eARrgegPxmV63xrdkwoHrYNJHki92gs41xpqRDs,3263968
 glitchlings/config.py,sha256=hwkcMkhEvUzK8FECgG6kbf_4MpMQcopskiSgXzK5B3o,7785
 glitchlings/config.toml,sha256=MWwgbx1-KIRAY3JZmMrCVbZNxFjHgRJXbtNAVuUNcxY,108
 glitchlings/main.py,sha256=Rw9pCgNrGxwzC1rZbbng7cHUP9xlL0WWWTdjW95XiSM,10084
 glitchlings/dlc/__init__.py,sha256=eTLEEWrVWPqniXHqee4W23H1rjElI1PQ_jcqWFe9D3g,141
 glitchlings/dlc/huggingface.py,sha256=I1QWanWVxO02awgSpHDtgQEVF-9AQRLtsta2RCitWhE,2933
 glitchlings/dlc/prime.py,sha256=wpRMNtgka1vNlEzifeCjGMp1q_-QclZn3NxXczGnNpM,9278
-glitchlings/lexicon/__init__.py,sha256=-w35jPtg7WCP_IfRxAUZBNFXeSnlIaVfbJiPDI3f3K4,5663
-glitchlings/lexicon/graph.py,sha256=_2w5shu-fEieDN-egpqLvMu0rxG78RAQWqENU0r7PlM,10533
+glitchlings/lexicon/__init__.py,sha256=e3MbtV3R_UOoZXsckR3gnThwgqCi4HXnfduaqxqYXvw,6229
+glitchlings/lexicon/_cache.py,sha256=KlcHKtOFH1yPxwhr8_HF_qgpALmUuHkGTzNfWnQ2Jb8,3955
+glitchlings/lexicon/graph.py,sha256=YYLrYnmSZ8uf8VvrNLuVF_nIVDH7OoR3RuxJ-9JMA2c,10041
 glitchlings/lexicon/metrics.py,sha256=W8TCemZaCjBOUSX8G7JdgQAbMykXXfRTfodkDSkc3aQ,4599
-glitchlings/lexicon/vector.py,sha256=Qqspc8KR4hqJiTTiXnu8DCIp2ROYPgEKK4RM4kLkyGY,20284
-glitchlings/lexicon/wordnet.py,sha256=FwjTtVPOQEmWEXL0Sl4faM-C4PPNkDu_z7-FyINlh3c,5652
+glitchlings/lexicon/vector.py,sha256=oeZQwYxrK25REu4MhUUlMmaStW17Gx6RwrU1v6NooOg,19713
+glitchlings/lexicon/wordnet.py,sha256=Zv0YNHSM-DE2ucVZl_OOutTV1s0-i2xPOrfqYYdZKTU,6034
 glitchlings/lexicon/data/default_vector_cache.json,sha256=7obKHqmR3odbTfgJPWLSRFYFh4J_6uvv_CntCSe_EjI,725
 glitchlings/util/__init__.py,sha256=7KiZ0gKMjocfd34cajneZhTqYb7Hkwi_PpjltPqvkNI,4498
 glitchlings/zoo/__init__.py,sha256=eFYmaWeFDlSqfaiED51HWM-OqiTo_BOz0ASeyhOwOsw,4818
@@ -20,7 +21,7 @@ glitchlings/zoo/_rate.py,sha256=TMyfVFV7pLxSGVswPlOAtBvk25Bjtx5xXTtpb_utgik,527
 glitchlings/zoo/_sampling.py,sha256=VOSWDgYWXIiAuKxn2IckFJhpRgGotQP_KW28db8kTKI,1587
 glitchlings/zoo/_text_utils.py,sha256=nAfFT_VdXMXciCR7eQ5EAmym5wvzL6_Sdn9dvCx2s3Q,2758
 glitchlings/zoo/adjax.py,sha256=N3CzfM7m7mAYgFcQYLQkqK2VYLw_vFvEMBM2aNU--ZA,3530
-glitchlings/zoo/core.py,sha256=fhceCZKa9W1vVlhpR2zVKBXnzgJICB2-nmDywiqx4js,14207
+glitchlings/zoo/core.py,sha256=YymiEc66V4mW_4MbTST2038D7YdZVyRkiUZn886IV4I,17203
 glitchlings/zoo/jargoyle.py,sha256=6-DJxUFz2AjT-iQDFlK2ZG9pVwq2boDtslEzCNyI_04,11481
 glitchlings/zoo/mim1c.py,sha256=yAt1ngR3j2KXLbzc8LhrQlIWRO_KT5dFK1EE8QivMAQ,3429
 glitchlings/zoo/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
@@ -30,9 +31,9 @@ glitchlings/zoo/rushmore.py,sha256=J1wd4IB7WOAR2TdntkxCMZWseWR0Yii8UQZ7ucfpWCc,4
 glitchlings/zoo/scannequin.py,sha256=Ps8nxysKjkJV408zaL1kjVjy4jliATDBpYcNHLWbNFg,4859
 glitchlings/zoo/typogre.py,sha256=0fYaxOEiTnxiCqmsiSN1r_wl1vC1Ueaiks2e94kks70,6668
 glitchlings/zoo/zeedub.py,sha256=l51swlo556-TXhDk4nayHOm1XgHwWmfUKzQ01YMuCpE,4801
-glitchlings-0.4.0.dist-info/METADATA,sha256=Dldj4SIrrNF6TKAvvJghd_L4lVrzdViqb8DWMSvPWVE,28345
-glitchlings-0.4.0.dist-info/WHEEL,sha256=yzF9ixp0XVYLhnovZSdud9vspTPdVe52BzwI7Tv3jTM,113
-glitchlings-0.4.0.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.4.0.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.4.0.dist-info/RECORD,,
-glitchlings-0.4.0.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.4.1.dist-info/METADATA,sha256=9HdqQt7PazdHMtPP5JpINljl3kvL8HOqTFE3Wwyrm2g,28260
+glitchlings-0.4.1.dist-info/WHEEL,sha256=yzF9ixp0XVYLhnovZSdud9vspTPdVe52BzwI7Tv3jTM,113
+glitchlings-0.4.1.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.4.1.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.4.1.dist-info/RECORD,,
+glitchlings-0.4.1.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337