glitchlings 0.2.4__cp312-cp312-win_amd64.whl → 0.2.5__cp312-cp312-win_amd64.whl

glitchlings/__init__.py

@@ -13,6 +13,8 @@ from .zoo import (
     rushmore,
     Scannequin,
     scannequin,
+    Zeedub,
+    zeedub,
     Glitchling,
     Gaggle,
     summon,
@@ -35,6 +37,8 @@ __all__ = [
     "rushmore",
     "Scannequin",
     "scannequin",
+    "Zeedub",
+    "zeedub",
     "summon",
     "Glitchling",
     "Gaggle",

glitchlings/zoo/__init__.py

@@ -10,6 +10,7 @@ from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
 from .scannequin import Scannequin, scannequin
+from .zeedub import Zeedub, zeedub
 from .core import Glitchling, Gaggle
 
 __all__ = [
@@ -27,6 +28,8 @@ __all__ = [
     "redactyl",
     "Scannequin",
     "scannequin",
+    "Zeedub",
+    "zeedub",
     "Glitchling",
     "Gaggle",
     "summon",
@@ -40,7 +43,7 @@ _HAS_JARGOYLE = _jargoyle_available()
 _BUILTIN_GLITCHLING_LIST: list[Glitchling] = [typogre, mim1c]
 if _HAS_JARGOYLE:
     _BUILTIN_GLITCHLING_LIST.append(jargoyle)
-_BUILTIN_GLITCHLING_LIST.extend([reduple, rushmore, redactyl, scannequin])
+_BUILTIN_GLITCHLING_LIST.extend([reduple, rushmore, redactyl, scannequin, zeedub])
 
 BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
     glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
@@ -53,6 +56,7 @@ _BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
     rushmore.name.lower(): Rushmore,
     redactyl.name.lower(): Redactyl,
     scannequin.name.lower(): Scannequin,
+    zeedub.name.lower(): Zeedub,
 }
 if _HAS_JARGOYLE:
     _BUILTIN_GLITCHLING_TYPES[jargoyle.name.lower()] = Jargoyle

glitchlings/zoo/redactyl.py

@@ -14,6 +14,41 @@ except ImportError:  # pragma: no cover - compiled extension not present
     _redact_words_rust = None
 
 
+def _weighted_sample_without_replacement(
+    population: list[int],
+    weights: list[float],
+    *,
+    k: int,
+    rng: random.Random,
+) -> list[int]:
+    """Select `k` unique indices according to the given weights."""
+
+    selections: list[int] = []
+    items = list(zip(population, weights))
+    if k <= 0 or not items:
+        return selections
+    if k > len(items):
+        raise ValueError("Sample larger than population or is negative")
+
+    for _ in range(k):
+        total_weight = sum(weight for _, weight in items)
+        if total_weight <= 0:
+            chosen_index = rng.randrange(len(items))
+        else:
+            threshold = rng.random() * total_weight
+            cumulative = 0.0
+            chosen_index = len(items) - 1
+            for idx, (_, weight) in enumerate(items):
+                cumulative += weight
+                if cumulative >= threshold:
+                    chosen_index = idx
+                    break
+        value, _ = items.pop(chosen_index)
+        selections.append(value)
+
+    return selections
+
+
 def _python_redact_words(
     text: str,
     *,
@@ -21,6 +56,7 @@ def _python_redact_words(
     rate: float,
     merge_adjacent: bool,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Redact random words by replacing their characters.
 
@@ -29,18 +65,36 @@ def _python_redact_words(
     - replacement_char: The character to use for redaction (default FULL_BLOCK).
     - rate: Max proportion of words to redact (default 0.05).
     - merge_adjacent: If True, merges adjacent redactions across intervening non-word chars.
-    - seed: Seed used if `rng` not provided (default 151).
-    - rng: Optional RNG; overrides seed.
+    - rng: RNG used for sampling decisions.
+    - unweighted: When True, sample words uniformly instead of by length.
     """
     # Preserve exact spacing and punctuation by using regex
     tokens = re.split(r"(\s+)", text)
     word_indices = [i for i, token in enumerate(tokens) if i % 2 == 0 and token.strip()]
     if not word_indices:
-        raise ValueError("Cannot redact words because the input text contains no redactable words.")
+        raise ValueError(
+            "Cannot redact words because the input text contains no redactable words."
+        )
+    weights: list[float] = []
+    for index in word_indices:
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weights.append(1.0 if unweighted else float(core_length))
     num_to_redact = max(1, int(len(word_indices) * rate))
-
-    # Sample from the indices of actual words
-    indices_to_redact = rng.sample(word_indices, k=num_to_redact)
+    if num_to_redact > len(word_indices):
+        raise ValueError("Sample larger than population or is negative")
+    indices_to_redact = _weighted_sample_without_replacement(
+        word_indices,
+        weights,
+        k=num_to_redact,
+        rng=rng,
+    )
     indices_to_redact.sort()
 
     for i in indices_to_redact:
@@ -80,13 +134,14 @@ def redact_words(
     rng: random.Random | None = None,
     *,
     redaction_rate: float | None = None,
+    unweighted: bool = False,
 ) -> str:
     """Redact random words by replacing their characters."""
 
     effective_rate = resolve_rate(
         rate=rate,
         legacy_value=redaction_rate,
-        default=0.05,
+        default=0.025,
         legacy_name="redaction_rate",
     )
 
@@ -94,6 +149,7 @@ def redact_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
 
@@ -103,6 +159,7 @@ def redact_words(
             replacement_char,
             clamped_rate,
             merge_adjacent,
+            unweighted_flag,
             rng,
         )
 
@@ -112,6 +169,7 @@ def redact_words(
         rate=clamped_rate,
         merge_adjacent=merge_adjacent,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -126,12 +184,13 @@ class Redactyl(Glitchling):
         redaction_rate: float | None = None,
         merge_adjacent: bool = False,
         seed: int = 151,
+        unweighted: bool = False,
     ) -> None:
         self._param_aliases = {"redaction_rate": "rate"}
         effective_rate = resolve_rate(
             rate=rate,
             legacy_value=redaction_rate,
-            default=0.05,
+            default=0.025,
             legacy_name="redaction_rate",
         )
         super().__init__(
@@ -142,6 +201,7 @@ class Redactyl(Glitchling):
             replacement_char=replacement_char,
             rate=effective_rate,
             merge_adjacent=merge_adjacent,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
@@ -150,15 +210,16 @@ class Redactyl(Glitchling):
         merge_adjacent = self.kwargs.get("merge_adjacent")
         if replacement_char is None or rate is None or merge_adjacent is None:
             return None
+        unweighted = bool(self.kwargs.get("unweighted", False))
         return {
             "type": "redact",
             "replacement_char": str(replacement_char),
             "redaction_rate": float(rate),
             "merge_adjacent": bool(merge_adjacent),
+            "unweighted": unweighted,
         }
 
 
-
 redactyl = Redactyl()
 
 

glitchlings/zoo/reduple.py

@@ -16,14 +16,15 @@ def _python_reduplicate_words(
     *,
     rate: float,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Randomly reduplicate words in the text.
 
     Parameters
     - text: Input text.
     - rate: Max proportion of words to reduplicate (default 0.05).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
+    - rng: RNG used for sampling decisions.
+    - unweighted: When True, sample words uniformly instead of length-weighted.
 
     Notes
     - Preserves spacing and punctuation by tokenizing with separators.
@@ -32,6 +33,7 @@ def _python_reduplicate_words(
     # Preserve exact spacing and punctuation by using regex
     tokens = re.split(r"(\s+)", text)  # Split but keep separators
 
+    candidate_weights: list[tuple[int, float]] = []
     for i in range(0, len(tokens), 2):  # Every other token is a word
         if i >= len(tokens):
             break
@@ -40,16 +42,46 @@ def _python_reduplicate_words(
         if not word or word.isspace():  # Skip empty or whitespace
             continue
 
-        # Only consider actual words for reduplication
-        if rng.random() < rate:
-            # Check if word has trailing punctuation
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, core, suffix = match.groups()
-                # Reduplicate with a space: "word" -> "word word"
-                tokens[i] = f"{prefix}{core} {core}{suffix}"
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weight = 1.0 if unweighted else 1.0 / core_length
+        candidate_weights.append((i, weight))
+
+    if not candidate_weights:
+        return "".join(tokens)
+
+    effective_rate = max(rate, 0.0)
+    if effective_rate <= 0.0:
+        return "".join(tokens)
+
+    mean_weight = sum(weight for _, weight in candidate_weights) / len(
+        candidate_weights
+    )
+
+    for index, weight in candidate_weights:
+        if effective_rate >= 1.0:
+            probability = 1.0
+        else:
+            if mean_weight <= 0.0:
+                probability = effective_rate
             else:
-                tokens[i] = f"{word} {word}"
+                probability = min(1.0, effective_rate * (weight / mean_weight))
+        if rng.random() >= probability:
+            continue
+
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        if match:
+            prefix, core, suffix = match.groups()
+            # Reduplicate with a space: "word" -> "word word"
+            tokens[index] = f"{prefix}{core} {core}{suffix}"
+        else:
+            tokens[index] = f"{word} {word}"
     return "".join(tokens)
 
 
@@ -60,6 +92,7 @@ def reduplicate_words(
     rng: random.Random | None = None,
     *,
     reduplication_rate: float | None = None,
+    unweighted: bool = False,
 ) -> str:
     """Randomly reduplicate words in the text.
 
@@ -70,7 +103,7 @@ def reduplicate_words(
     effective_rate = resolve_rate(
         rate=rate,
         legacy_value=reduplication_rate,
-        default=0.05,
+        default=0.01,
         legacy_name="reduplication_rate",
     )
 
@@ -78,14 +111,16 @@ def reduplicate_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     if _reduplicate_words_rust is not None:
-        return _reduplicate_words_rust(text, clamped_rate, rng)
+        return _reduplicate_words_rust(text, clamped_rate, unweighted_flag, rng)
 
     return _python_reduplicate_words(
         text,
         rate=clamped_rate,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -98,12 +133,13 @@ class Reduple(Glitchling):
         rate: float | None = None,
         reduplication_rate: float | None = None,
         seed: int | None = None,
+        unweighted: bool = False,
     ) -> None:
         self._param_aliases = {"reduplication_rate": "rate"}
         effective_rate = resolve_rate(
             rate=rate,
             legacy_value=reduplication_rate,
-            default=0.05,
+            default=0.01,
             legacy_name="reduplication_rate",
         )
         super().__init__(
@@ -112,14 +148,19 @@ class Reduple(Glitchling):
             scope=AttackWave.WORD,
             seed=seed,
             rate=effective_rate,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
         rate = self.kwargs.get("rate")
         if rate is None:
             return None
-        return {"type": "reduplicate", "reduplication_rate": float(rate)}
-
+        unweighted = bool(self.kwargs.get("unweighted", False))
+        return {
+            "type": "reduplicate",
+            "reduplication_rate": float(rate),
+            "unweighted": unweighted,
+        }
 
 
 reduple = Reduple()

glitchlings/zoo/rushmore.py

@@ -17,42 +17,67 @@ def _python_delete_random_words(
     *,
     rate: float,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Delete random words from the input text while preserving whitespace."""
 
-    if rate <= 0.0:
+    effective_rate = max(rate, 0.0)
+    if effective_rate <= 0.0:
         return text
 
     tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
 
-    candidate_indices: list[int] = []
+    candidate_data: list[tuple[int, float]] = []
     for i in range(2, len(tokens), 2):  # Every other token is a word, skip the first word
         word = tokens[i]
         if not word or word.isspace():
             continue
 
-        candidate_indices.append(i)
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weight = 1.0 if unweighted else 1.0 / core_length
+        candidate_data.append((i, weight))
+
+    if not candidate_data:
+        return text
 
     allowed_deletions = min(
-        len(candidate_indices), math.floor(len(candidate_indices) * rate)
+        len(candidate_data), math.floor(len(candidate_data) * effective_rate)
     )
     if allowed_deletions <= 0:
         return text
 
+    mean_weight = sum(weight for _, weight in candidate_data) / len(candidate_data)
+
     deletions = 0
-    for i in candidate_indices:
-        if rng.random() < rate:
-            word = tokens[i]
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, _, suffix = match.groups()
-                tokens[i] = f"{prefix.strip()}{suffix.strip()}"
+    for index, weight in candidate_data:
+        if deletions >= allowed_deletions:
+            break
+
+        if effective_rate >= 1.0:
+            probability = 1.0
+        else:
+            if mean_weight <= 0.0:
+                probability = effective_rate
             else:
-                tokens[i] = ""
+                probability = min(1.0, effective_rate * (weight / mean_weight))
+        if rng.random() >= probability:
+            continue
+
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        if match:
+            prefix, _, suffix = match.groups()
+            tokens[index] = f"{prefix.strip()}{suffix.strip()}"
+        else:
+            tokens[index] = ""
 
-            deletions += 1
-            if deletions >= allowed_deletions:
-                break
+        deletions += 1
 
     text = "".join(tokens)
     text = re.sub(r"\s+([.,;:])", r"\1", text)
@@ -68,6 +93,7 @@ def delete_random_words(
     rng: random.Random | None = None,
     *,
     max_deletion_rate: float | None = None,
+    unweighted: bool = False,
 ) -> str:
     """Delete random words from the input text.
 
@@ -85,14 +111,16 @@ def delete_random_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     if _delete_random_words_rust is not None:
-        return _delete_random_words_rust(text, clamped_rate, rng)
+        return _delete_random_words_rust(text, clamped_rate, unweighted_flag, rng)
 
     return _python_delete_random_words(
         text,
         rate=clamped_rate,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -105,6 +133,7 @@ class Rushmore(Glitchling):
         rate: float | None = None,
         max_deletion_rate: float | None = None,
         seed: int | None = None,
+        unweighted: bool = False,
     ) -> None:
         self._param_aliases = {"max_deletion_rate": "rate"}
         effective_rate = resolve_rate(
@@ -119,6 +148,7 @@ class Rushmore(Glitchling):
             scope=AttackWave.WORD,
             seed=seed,
             rate=effective_rate,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
@@ -127,7 +157,12 @@ class Rushmore(Glitchling):
             rate = self.kwargs.get("max_deletion_rate")
         if rate is None:
             return None
-        return {"type": "delete", "max_deletion_rate": float(rate)}
+        unweighted = bool(self.kwargs.get("unweighted", False))
+        return {
+            "type": "delete",
+            "max_deletion_rate": float(rate),
+            "unweighted": unweighted,
+        }
 
 
 rushmore = Rushmore()

glitchlings/zoo/zeedub.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import math
+import random
+from collections.abc import Sequence
+
+from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
+
+try:
+    from glitchlings._zoo_rust import inject_zero_widths as _inject_zero_widths_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _inject_zero_widths_rust = None
+
+_DEFAULT_ZERO_WIDTH_CHARACTERS: tuple[str, ...] = (
+    "\u200b",  # ZERO WIDTH SPACE
+    "\u200c",  # ZERO WIDTH NON-JOINER
+    "\u200d",  # ZERO WIDTH JOINER
+    "\ufeff",  # ZERO WIDTH NO-BREAK SPACE
+    "\u2060",  # WORD JOINER
+)
+
+
+def _python_insert_zero_widths(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+    characters: Sequence[str],
+) -> str:
+    if not text:
+        return text
+
+    palette = [char for char in characters if char]
+    if not palette:
+        return text
+
+    positions = [
+        index + 1
+        for index in range(len(text) - 1)
+        if not text[index].isspace() and not text[index + 1].isspace()
+    ]
+    if not positions:
+        return text
+
+    total = len(positions)
+    clamped_rate = max(0.0, rate)
+    if clamped_rate <= 0.0:
+        return text
+
+    target = clamped_rate * total
+    count = math.floor(target)
+    remainder = target - count
+    if remainder > 0.0 and rng.random() < remainder:
+        count += 1
+    count = min(total, count)
+
+    if count <= 0:
+        return text
+
+    chosen = rng.sample(positions, count)
+    chosen.sort()
+
+    chars = list(text)
+    for position in reversed(chosen):
+        chars.insert(position, rng.choice(palette))
+
+    return "".join(chars)
+
+
+def insert_zero_widths(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    characters: Sequence[str] | None = None,
+) -> str:
+    """Inject zero-width characters between non-space character pairs."""
+
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=None,
+        default=0.02,
+        legacy_name="rate",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    palette: Sequence[str] = (
+        tuple(characters) if characters is not None else _DEFAULT_ZERO_WIDTH_CHARACTERS
+    )
+
+    cleaned_palette = tuple(char for char in palette if char)
+    if not cleaned_palette or not text:
+        return text
+
+    clamped_rate = max(0.0, effective_rate)
+    if clamped_rate == 0.0:
+        return text
+
+    if _inject_zero_widths_rust is not None:
+        return _inject_zero_widths_rust(text, clamped_rate, list(cleaned_palette), rng)
+
+    return _python_insert_zero_widths(
+        text,
+        rate=clamped_rate,
+        rng=rng,
+        characters=cleaned_palette,
+    )
+
+
+class Zeedub(Glitchling):
+    """Glitchling that plants zero-width glyphs inside words."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        seed: int | None = None,
+        characters: Sequence[str] | None = None,
+    ) -> None:
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=None,
+            default=0.02,
+            legacy_name="rate",
+        )
+        super().__init__(
+            name="Zeedub",
+            corruption_function=insert_zero_widths,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.LAST,
+            seed=seed,
+            rate=effective_rate,
+            characters=tuple(characters) if characters is not None else None,
+        )
+
+
+zeedub = Zeedub()
+
+
+__all__ = ["Zeedub", "zeedub", "insert_zero_widths"]

{glitchlings-0.2.4.dist-info → glitchlings-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.4
+Version: 0.2.5
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -396,6 +396,18 @@ _How can a computer need reading glasses?_
 > - `rate (float)`: The maximum proportion of eligible confusion spans to replace (default: 0.02, 2%).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
+### Zeedub
+
+_A whispering glyph parasite that lives in the interstices of codepoints, marking territory with invisible traces._
+
+> _**Invisible Ink.**_ Zeedub slips zero-width codepoints between non-space character pairs, forcing models to reason about text whose visible form masks hidden glyphs.
+>
+> Args
+>
+> - `rate (float)`: Expected number of zero-width insertions as a proportion of eligible bigrams (default: 0.02, 2%).
+> - `characters (Sequence[str])`: Optional override for the pool of zero-width strings to inject (default: curated invisibles such as U+200B, U+200C, U+200D, U+FEFF, U+2060).
+> - `seed (int)`: The random seed for reproducibility (default: 151).
+
 ### Jargoyle
 
 _Uh oh. The worst person you know just bought a thesaurus._

{glitchlings-0.2.4.dist-info → glitchlings-0.2.5.dist-info}/RECORD

@@ -1,26 +1,27 @@
-glitchlings/__init__.py,sha256=w8heFqUejrXM_9NNlM9CQnIGkmGUyBV29acg3WsocXA,622
+glitchlings/__init__.py,sha256=fjerquRITZQY_rY5mhTVVQyeGAz1qTpgicvDhbpqgi8,678
 glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
-glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=qHk8hPmRrzJTwOyhcBNr-2qhXBaEBUy__7_SMFhzWSc,1989632
+glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=JO0QDAqXc14YPXxmghAKNuXZ3uHFEOyBa-SkU4EO_fI,2019328
 glitchlings/main.py,sha256=QrSSLWcKh1_NDfJDGh-3UVKdI7AkzfMy6Jz1ouxIgnE,6149
 glitchlings/dlc/__init__.py,sha256=IHD-GGhVFb7SVzErvf2YCJkOR4wGo0nFHXkn_daMvS8,146
 glitchlings/dlc/huggingface.py,sha256=PIesnDIEvyJxj1IuLw2P9nVPTr4Nv81XM7w2axfyhkA,3029
 glitchlings/dlc/prime.py,sha256=hySyYBncUM-49j6JtrHYO6c3HpbG2vTt2EYZnOJ85C0,8972
 glitchlings/util/__init__.py,sha256=GoyQuHTfGRkHzuZwJji6QWSiGd_LHa9QiyjjEpBFW7E,4679
-glitchlings/zoo/__init__.py,sha256=kYKKlNvEwKtrD26E1hfde33rkN83CMf_h5AQFGjQyBQ,4312
+glitchlings/zoo/__init__.py,sha256=mAhsnR3ZK9BocxT3J4WF6JcYQMYI9e_EYZ-GMxHv0P4,4420
 glitchlings/zoo/_ocr_confusions.py,sha256=W59Aa5MBDwRF65f8GV-6XwGAmlR5Uk7pa5qvHvhIYdY,1252
 glitchlings/zoo/_rate.py,sha256=EYUWXYyR2IK0zYBWyBOlnUjDxU32JE9mZTZeodVx5CA,548
 glitchlings/zoo/core.py,sha256=QKHmzmONNkiA3RdfgLdNx-FPFwoH4Bm-Tkc3vSCHNpc,14412
 glitchlings/zoo/jargoyle.py,sha256=1fnL_8bv1Y-T2h1C6NRzIylYyOuAUI-BiMReFewqh00,11002
 glitchlings/zoo/mim1c.py,sha256=3ddNOzWgLABuEOh5T98Xk439ejx-YHGI7ErXET03Crc,3537
 glitchlings/zoo/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
-glitchlings/zoo/redactyl.py,sha256=dM3W59xLhuiS8t5jXETc_L8EEhRN1CpLazBnVPiSknk,4834
-glitchlings/zoo/reduple.py,sha256=9jid6tCvCaiSxWSPMNuHWZitd7et60RRFYeek3S0ElU,3641
-glitchlings/zoo/rushmore.py,sha256=pJy3g_H1z8PNoHitvD3-HsytAuE0U6FOdsdaKZy6OqY,3680
+glitchlings/zoo/redactyl.py,sha256=jjLad9ugG8516CNhuUfv16OOs9HwqTiUzVqY0CLskhY,6928
+glitchlings/zoo/reduple.py,sha256=oGkOkH9bJiG-ogsi5ewglq6FUmzvRM6UC4N61LyNdvk,5026
+glitchlings/zoo/rushmore.py,sha256=RE-br8OAIBRil3Mz381OcdMtb1fuNCZ7LzAjt44hFkM,4900
 glitchlings/zoo/scannequin.py,sha256=TJyNYTTIB7rxZH3XKIETy0YVf4EjsMgGWYmYaxH9jxU,5030
 glitchlings/zoo/typogre.py,sha256=olTTXDmFkVQ3r-T1vxm2mLomRvIDXHrNHfgin316wzE,6221
-glitchlings-0.2.4.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.2.4.dist-info/METADATA,sha256=mGKlfmodtLjWsfrz6O0cLk4DDPFeUO5vt6LKgw-uu-M,26513
-glitchlings-0.2.4.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-glitchlings-0.2.4.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.2.4.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.2.4.dist-info/RECORD,,
+glitchlings/zoo/zeedub.py,sha256=n1qTKE_Dl0m8SEKhaP91oHAyJ484NxaGLPu_ZLr0Ldo,3696
+glitchlings-0.2.5.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
+glitchlings-0.2.5.dist-info/METADATA,sha256=UG-L-7qePJBz0sKAWGX2yKNmup3D_gaid0DDlPsuf3Y,27198
+glitchlings-0.2.5.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+glitchlings-0.2.5.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.2.5.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.2.5.dist-info/RECORD,,