glitchlings 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

{zoo → glitchlings/zoo}/scannequin.py

@@ -1,124 +1,166 @@
-import re
-import random
-from .core import Glitchling, AttackWave, AttackOrder
-
-
-def ocr_artifacts(
-    text: str,
-    error_rate: float = 0.02,
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Introduce OCR-like artifacts into text.
-
-    Parameters
-    - text: Input text to corrupt.
-    - error_rate: Max proportion of eligible confusion matches to replace (default 0.02).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
-
-    Notes
-    - Uses a curated set of common OCR confusions (rn↔m, cl↔d, O↔0, l/I/1, etc.).
-    - Collects all non-overlapping candidate spans in reading order, then samples
-      a subset deterministically with the provided RNG.
-    - Replacements can change length (e.g., m→rn), so edits are applied from left
-      to right using precomputed spans to avoid index drift.
-    """
-    if not text:
-        return text
-
-    if rng is None:
-        rng = random.Random(seed)
-
-    # map: source -> list of possible replacements
-    # Keep patterns small and specific; longer patterns first avoid overmatching
-    confusion_table: list[tuple[str, list[str]]] = [
-        ("li", ["h"]),
-        ("h", ["li"]),
-        ("rn", ["m"]),
-        ("m", ["rn"]),
-        ("cl", ["d"]),
-        ("d", ["cl"]),
-        ("I", ["l"]),
-        ("l", ["I", "1"]),
-        ("1", ["l", "I"]),
-        ("0", ["O"]),
-        ("O", ["0"]),
-        ("B", ["8"]),
-        ("8", ["B"]),
-        ("S", ["5"]),
-        ("5", ["S"]),
-        ("Z", ["2"]),
-        ("2", ["Z"]),
-        ("G", ["6"]),
-        ("6", ["G"]),
-        ("“", ['"']),
-        ("”", ['"']),
-        ("‘", ["'"]),
-        ("’", ["'"]),
-        ("—", ["-"]),  # em dash -> hyphen
-        ("–", ["-"]),  # en dash -> hyphen
-    ]
-
-    # Build candidate matches as (start, end, choices)
-    candidates: list[tuple[int, int, list[str]]] = []
-
-    # To avoid double-counting overlapping patterns (like 'l' inside 'li'),
-    # we will scan longer patterns first by sorting by len(src) desc.
-    for src, choices in sorted(confusion_table, key=lambda p: -len(p[0])):
-        pattern = re.escape(src)
-        for m in re.finditer(pattern, text):
-            start, end = m.span()
-            candidates.append((start, end, choices))
-
-    if not candidates:
-        return text
-
-    # Decide how many to replace
-    k = int(len(candidates) * error_rate)
-    if k <= 0:
-        return text
-
-    # Shuffle deterministically and select non-overlapping k spans
-    rng.shuffle(candidates)
-    chosen: list[tuple[int, int, str]] = []
-    occupied: list[tuple[int, int]] = []
-
-    def overlaps(a: tuple[int, int], b: tuple[int, int]) -> bool:
-        return not (a[1] <= b[0] or b[1] <= a[0])
-
-    for start, end, choices in candidates:
-        if len(chosen) >= k:
-            break
-        span = (start, end)
-        if any(overlaps(span, occ) for occ in occupied):
-            continue
-        replacement = rng.choice(choices)
-        chosen.append((start, end, replacement))
-        occupied.append(span)
-
-    if not chosen:
-        return text
-
-    # Apply edits from left to right
-    chosen.sort(key=lambda t: t[0])
-    out_parts = []
-    cursor = 0
-    for start, end, rep in chosen:
-        if cursor < start:
-            out_parts.append(text[cursor:start])
-        out_parts.append(rep)
-        cursor = end
-    if cursor < len(text):
-        out_parts.append(text[cursor:])
-
-    return "".join(out_parts)
-
-
-scannequin = Glitchling(
-    name="Scannequin",
-    corruption_function=ocr_artifacts,
-    scope=AttackWave.CHARACTER,
-    order=AttackOrder.LATE,
-    error_rate=0.02,
-)
+import re
+import random
+
+from .core import Glitchling, AttackWave, AttackOrder
+
+try:
+    from glitchlings._zoo_rust import ocr_artifacts as _ocr_artifacts_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _ocr_artifacts_rust = None
+
+
+def _python_ocr_artifacts(
+    text: str,
+    *,
+    error_rate: float,
+    rng: random.Random,
+) -> str:
+    """Introduce OCR-like artifacts into text.
+
+    Parameters
+    - text: Input text to corrupt.
+    - error_rate: Max proportion of eligible confusion matches to replace (default 0.02).
+    - seed: Optional seed if `rng` not provided.
+    - rng: Optional RNG; overrides seed.
+
+    Notes
+    - Uses a curated set of common OCR confusions (rn↔m, cl↔d, O↔0, l/I/1, etc.).
+    - Collects all non-overlapping candidate spans in reading order, then samples
+      a subset deterministically with the provided RNG.
+    - Replacements can change length (e.g., m→rn), so edits are applied from left
+      to right using precomputed spans to avoid index drift.
+    """
+    if not text:
+        return text
+
+    # map: source -> list of possible replacements
+    # Keep patterns small and specific; longer patterns first avoid overmatching
+    confusion_table: list[tuple[str, list[str]]] = [
+        ("li", ["h"]),
+        ("h", ["li"]),
+        ("rn", ["m"]),
+        ("m", ["rn"]),
+        ("cl", ["d"]),
+        ("d", ["cl"]),
+        ("I", ["l"]),
+        ("l", ["I", "1"]),
+        ("1", ["l", "I"]),
+        ("0", ["O"]),
+        ("O", ["0"]),
+        ("B", ["8"]),
+        ("8", ["B"]),
+        ("S", ["5"]),
+        ("5", ["S"]),
+        ("Z", ["2"]),
+        ("2", ["Z"]),
+        ("G", ["6"]),
+        ("6", ["G"]),
+        ("“", ['"']),
+        ("”", ['"']),
+        ("‘", ["'"]),
+        ("’", ["'"]),
+        ("—", ["-"]),  # em dash -> hyphen
+        ("–", ["-"]),  # en dash -> hyphen
+    ]
+
+    # Build candidate matches as (start, end, choices)
+    candidates: list[tuple[int, int, list[str]]] = []
+
+    # To avoid double-counting overlapping patterns (like 'l' inside 'li'),
+    # we will scan longer patterns first by sorting by len(src) desc.
+    for src, choices in sorted(confusion_table, key=lambda p: -len(p[0])):
+        pattern = re.escape(src)
+        for m in re.finditer(pattern, text):
+            start, end = m.span()
+            candidates.append((start, end, choices))
+
+    if not candidates:
+        return text
+
+    # Decide how many to replace
+    k = int(len(candidates) * error_rate)
+    if k <= 0:
+        return text
+
+    # Shuffle deterministically and select non-overlapping k spans
+    rng.shuffle(candidates)
+    chosen: list[tuple[int, int, str]] = []
+    occupied: list[tuple[int, int]] = []
+
+    def overlaps(a: tuple[int, int], b: tuple[int, int]) -> bool:
+        return not (a[1] <= b[0] or b[1] <= a[0])
+
+    for start, end, choices in candidates:
+        if len(chosen) >= k:
+            break
+        span = (start, end)
+        if any(overlaps(span, occ) for occ in occupied):
+            continue
+        replacement = rng.choice(choices)
+        chosen.append((start, end, replacement))
+        occupied.append(span)
+
+    if not chosen:
+        return text
+
+    # Apply edits from left to right
+    chosen.sort(key=lambda t: t[0])
+    out_parts = []
+    cursor = 0
+    for start, end, rep in chosen:
+        if cursor < start:
+            out_parts.append(text[cursor:start])
+        out_parts.append(rep)
+        cursor = end
+    if cursor < len(text):
+        out_parts.append(text[cursor:])
+
+    return "".join(out_parts)
+
+
+def ocr_artifacts(
+    text: str,
+    error_rate: float = 0.02,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Introduce OCR-like artifacts into text.
+
+    Prefers the Rust implementation when available.
+    """
+
+    if not text:
+        return text
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _ocr_artifacts_rust is not None:
+        return _ocr_artifacts_rust(text, error_rate, rng)
+
+    return _python_ocr_artifacts(text, error_rate=error_rate, rng=rng)
+
+
+class Scannequin(Glitchling):
+    """Glitchling that simulates OCR artifacts using common confusions."""
+
+    def __init__(
+        self,
+        *,
+        error_rate: float = 0.02,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            name="Scannequin",
+            corruption_function=ocr_artifacts,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.LATE,
+            seed=seed,
+            error_rate=error_rate,
+        )
+
+
+scannequin = Scannequin()
+
+
+__all__ = ["Scannequin", "scannequin"]

glitchlings/zoo/typogre.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import random
+from typing import Optional
+
+from .core import Glitchling, AttackWave, AttackOrder
+from ..util import KEYNEIGHBORS
+
+try:
+    from glitchlings._typogre_rust import fatfinger as _fatfinger_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _fatfinger_rust = None
+
+
+def _python_unichar(text: str, rng: random.Random) -> str:
+    """Collapse one random doubled letter (like 'ee' in 'seed') to a single occurrence."""
+    import re
+
+    matches = list(re.finditer(r"((.)\2)(?=\w)", text))
+    if not matches:
+        return text
+    start, end = rng.choice(matches).span(1)
+    return text[:start] + text[start] + text[end:]
+
+
+def _python_skipped_space(text: str, rng: random.Random) -> str:
+    import re
+
+    space_positions = [m.start() for m in re.finditer(r" ", text)]
+    if not space_positions:
+        return text
+    idx = rng.choice(space_positions)
+    return text[:idx] + text[idx + 1 :]
+
+
+def _python_random_space(text: str, rng: random.Random) -> str:
+    if len(text) < 2:
+        return text
+    idx = rng.randrange(1, len(text))
+    return text[:idx] + " " + text[idx:]
+
+
+def _python_repeated_char(text: str, rng: random.Random) -> str:
+    positions = [i for i, c in enumerate(text) if not c.isspace()]
+    if not positions:
+        return text
+    i = rng.choice(positions)
+    return text[:i] + text[i] + text[i:]
+
+
+def _python_is_word_char(c: str) -> bool:
+    return c.isalnum() or c == "_"
+
+
+def _python_eligible_idx(s: str, i: int) -> bool:
+    if i < 0 or i >= len(s):
+        return False
+    if not _python_is_word_char(s[i]):
+        return False
+    left_ok = i > 0 and _python_is_word_char(s[i - 1])
+    right_ok = i + 1 < len(s) and _python_is_word_char(s[i + 1])
+    return left_ok and right_ok
+
+
+def _python_draw_eligible_index(
+    rng: random.Random, s: str, max_tries: int = 16
+) -> Optional[int]:
+    n = len(s)
+    if n == 0:
+        return None
+    for _ in range(max_tries):
+        i = rng.randrange(n)
+        if _python_eligible_idx(s, i):
+            return i
+    start = rng.randrange(n)
+    i = start
+    while True:
+        if _python_eligible_idx(s, i):
+            return i
+        i += 1
+        if i == n:
+            i = 0
+        if i == start:
+            return None
+
+
+def _fatfinger_python(
+    text: str,
+    *,
+    max_change_rate: float,
+    layout: dict[str, list[str]],
+    rng: random.Random,
+) -> str:
+    s = text
+    max_changes = max(1, int(len(s) * max_change_rate))
+
+    positional_actions = ("char_swap", "missing_char", "extra_char", "nearby_char")
+    global_actions = ("skipped_space", "random_space", "unichar", "repeated_char")
+    all_actions = positional_actions + global_actions
+
+    actions_drawn = [rng.choice(all_actions) for _ in range(max_changes)]
+
+    for action in actions_drawn:
+        if action in positional_actions:
+            idx = _python_draw_eligible_index(rng, s)
+            if idx is None:
+                continue
+            if action == "char_swap":
+                j = idx + 1
+                s = s[:idx] + s[j] + s[idx] + s[j + 1 :]
+            elif action == "missing_char":
+                if _python_eligible_idx(s, idx):
+                    s = s[:idx] + s[idx + 1 :]
+            elif action == "extra_char":
+                ch = s[idx]
+                neighbors = layout.get(ch.lower(), []) or [ch]
+                ins = rng.choice(neighbors) or ch
+                s = s[:idx] + ins + s[idx:]
+            elif action == "nearby_char":
+                ch = s[idx]
+                neighbors = layout.get(ch.lower(), [])
+                if neighbors:
+                    rep = rng.choice(neighbors)
+                    s = s[:idx] + rep + s[idx + 1 :]
+        else:
+            if action == "skipped_space":
+                s = _python_skipped_space(s, rng)
+            elif action == "random_space":
+                s = _python_random_space(s, rng)
+            elif action == "unichar":
+                s = _python_unichar(s, rng)
+            elif action == "repeated_char":
+                s = _python_repeated_char(s, rng)
+    return s
+
+
+def fatfinger(
+    text: str,
+    max_change_rate: float = 0.02,
+    keyboard: str = "CURATOR_QWERTY",
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Introduce character-level "fat finger" edits with a Rust fast path."""
+
+    if rng is None:
+        rng = random.Random(seed)
+    if not text:
+        return ""
+
+    layout = getattr(KEYNEIGHBORS, keyboard)
+
+    if _fatfinger_rust is not None:
+        return _fatfinger_rust(text, max_change_rate=max_change_rate, layout=layout, rng=rng)
+
+    return _fatfinger_python(text, max_change_rate=max_change_rate, layout=layout, rng=rng)
+
+
+class Typogre(Glitchling):
+    """Glitchling that introduces deterministic keyboard-typing errors."""
+
+    def __init__(
+        self,
+        *,
+        max_change_rate: float = 0.02,
+        keyboard: str = "CURATOR_QWERTY",
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            name="Typogre",
+            corruption_function=fatfinger,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.EARLY,
+            seed=seed,
+            max_change_rate=max_change_rate,
+            keyboard=keyboard,
+        )
+
+
+typogre = Typogre()
+
+
+__all__ = ["Typogre", "typogre"]
+

{glitchlings-0.1.1.dist-info → glitchlings-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.1.1
+Version: 0.1.3
 Summary: Monsters for your language games.
 Project-URL: Homepage, https://github.com/osoleve/glitchlings
 Project-URL: Repository, https://github.com/osoleve/glitchlings.git
@@ -209,7 +209,7 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
 License-File: LICENSE
-Keywords: adversarial,data,evaluation,glitch,nlp,text
+Keywords: adversarial augmentation,nlp,text,text augmentation
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -223,10 +223,9 @@ Requires-Python: >=3.12
 Requires-Dist: confusable-homoglyphs>=3.3.1
 Requires-Dist: datasets>=4.0.0
 Requires-Dist: jellyfish>=1.2.0
+Requires-Dist: nltk>=3.9.1
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
-Provides-Extra: jargoyle
-Requires-Dist: nltk>=3.9.1; extra == 'jargoyle'
 Provides-Extra: prime
 Requires-Dist: verifiers>=0.1.3.post0; extra == 'prime'
 Description-Content-Type: text/markdown
@@ -270,10 +269,16 @@ pip install -U glitchlings
 ```
 
 ```python
-from glitchlings import summon, SAMPLE_TEXT
+from glitchlings import Gaggle, SAMPLE_TEXT, Typogre, Mim1c, Reduple, Rushmore
 
-gaggle = summon(["reduple", "mim1c", "typogre", "rushmore"])
-gaggle(SAMPLE_TEXT)
+gaggle = Gaggle([
+    Typogre(max_change_rate=0.03),
+    Mim1c(replacement_rate=0.02),
+    Reduple(seed=404),
+    Rushmore(max_deletion_rate=0.02),
+])
+
+print(gaggle(SAMPLE_TEXT))
 ```
 
 > Onҽ m‎ھ‎rning, wһen Gregor Samƽa woke from trouble𝐝 𝑑reams, he found himself transformed in his bed into a horrible vermin‎٠‎ He l   lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightlh domed and divided by arches ino stiff sections. The bedding was adly able to cover it and and seemed ready to slide off any  moment. His many legxs, pitifully thin compared with the size of the the rest of him, waved about helplessly ashe looked looked.
@@ -286,14 +291,23 @@ Conversely, training a model to perform well in the presence of the types of per
 
 ## Your First Battle
 
-Summon your chosen `Glitchling` (_or a few, if ya nasty_) and call it on your text or slot it into `Dataset.map(...)`, supplying a seed if desired.  
-Some `Glitchling`s may have additional keyword arguments but they will always be optional with what I decide are "reasonable defaults".  
-Seed defaults to 151, obviously.
+Summon your chosen `Glitchling` (_or a few, if ya nasty_) and call it on your text or slot it into `Dataset.map(...)`, supplying a seed if desired.
+Glitchlings are standard Python classes, so you can instantiate them with whatever parameters fit your scenario:
+
+```python
+from glitchlings import Gaggle, Typogre, Mim1c
+
+custom_typogre = Typogre(max_change_rate=0.1)
+selective_mimic = Mim1c(replacement_rate=0.05, classes=["LATIN", "GREEK"])
 
-Calling a `Glitchling` on a `str` transparently calls `.corrupt(str, ...) -> str`.  
+gaggle = Gaggle([custom_typogre, selective_mimic], seed=99)
+print(gaggle("Summoned heroes do not fear the glitch."))
+```
+
+Calling a `Glitchling` on a `str` transparently calls `.corrupt(str, ...) -> str`.
 This means that as long as your glitchlings get along logically, they play nicely with one another.
 
-When summoned as a `Gaggle`, the `Glitchling`s will automatically order themselves into attack waves, based on the scope of the change they make:
+When summoned as or gathered into a `Gaggle`, the `Glitchling`s will automatically order themselves into attack waves, based on the scope of the change they make:
 
 1. Document
 2. Paragraph
@@ -303,6 +317,23 @@ When summoned as a `Gaggle`, the `Glitchling`s will automatically order themselv
 
 They're horrible little gremlins, but they're not _unreasonable_.
 
+## Command-Line Interface (CLI)
+
+Keyboard warriors can challenge them directly via the `glitchlings` command:
+
+```bash
+# Discover which glitchlings are currently on the loose.
+glitchlings --list
+
+# Run Typogre against the contents of a file and inspect the diff.
+glitchlings -g typogre --file documents/report.txt --diff
+
+# Pipe text straight into the CLI for an on-the-fly corruption.
+echo "Beware LLM-written flavor-text" | glitchlings -g mim1c
+```
+
+Use `--help` for a complete breakdown of available options.
+
 ## Starter 'lings
 
 For maintainability reasons, all `Glitchling` have consented to be given nicknames once they're in your care. See the [Monster Manual](MONSTER_MANUAL.md) for a complete bestiary.
@@ -311,13 +342,12 @@ For maintainability reasons, all `Glitchling` have consented to be given nicknam
 
 _What a nice word, would be a shame if something happened to it._
 
-> _**Fatfinger.**_ Typogre introduces character-level errors (duplicating, dropping, adding, or swapping) based on the layout of a (currently QWERTY) keyboard.
+> _**Fatfinger.**_ Typogre introduces character-level errors (duplicating, dropping, adding, or swapping) based on the layout of a keyboard (QWERTY by default, with Dvorak and Colemak variants built-in).
 >
 > Args
 >
 > - `max_change_rate (float)`: The maximum number of edits to make as a percentage of the length (default: 0.02, 2%).
-> - `preserve_first_last (bool)`: Avoid editing the first and last character of a word (default: False).
-> - `keyboard (str)`: Keyboard layout key-neighbor map to use (default: "CURATOR_QWERTY").
+> - `keyboard (str)`: Keyboard layout key-neighbor map to use (default: "CURATOR_QWERTY"; also accepts "QWERTY", "DVORAK", "COLEMAK", and "AZERTY").
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Mim1c
@@ -347,12 +377,12 @@ _How can a computer need reading glasses?_
 
 _Uh oh. The worst person you know just bought a thesaurus._
 
-> _**Sesquipedalianism.**_ Jargoyle, the insufferable `Glitchling`, replaces nouns with synonyms at random, without regard for connotational or denotational differences.
+> _**Sesquipedalianism.**_ Jargoyle, the insufferable `Glitchling`, replaces words from selected parts of speech with synonyms at random, without regard for connotational or denotational differences.
 >
 > Args
 >
 > - `replacement_rate (float)`: The maximum proportion of words to replace (default: 0.1, 10%).
-> - `part_of_speech`: The WordNet part of speech to target (default: nouns). Accepts `wn.NOUN`, `wn.VERB`, `wn.ADJ`, or `wn.ADV`.
+> - `part_of_speech`: The WordNet part(s) of speech to target (default: nouns). Accepts `wn.NOUN`, `wn.VERB`, `wn.ADJ`, `wn.ADV`, any iterable of those tags, or the string `"any"` to include them all.
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Reduple
@@ -406,19 +436,15 @@ Cave paintings and oral tradition contain many depictions of strange, otherworld
 These _Apocryphal `Glitchling`_ are said to possess unique abilities or behaviors.  
 If you encounter one of these elusive beings, please document your findings and share them with _The Curator_.
 
-### Reproducible Corruption
+### Ensuring Reproducible Corruption
 
-Every `Glitchling` owns its own independent `random.Random` instance. That means:
+Every `Glitchling` should own its own independent `random.Random` instance. That means:
 
 - No `random.seed(...)` calls touch Python's global RNG.
 - Supplying a `seed` when you construct a `Glitchling` (or when you `summon(...)`) makes its behavior reproducible.
 - Re-running a `Gaggle` with the same master seed and the same input text (_and same external data!_) yields identical corruption output.
 - Corruption functions are written to accept an `rng` parameter internally so that all randomness is centralized and testable.
 
-#### Caveats
-
-- If you mutate a glitchling's parameters after you've used it (e.g. `typogre.set_param(...)`) the outputs may not be the same as before the change. So don't do that.
-
 #### At Wits' End?
 
 If you're trying to add a new glitchling and can't seem to make it deterministic, here are some places to look for determinism-breaking code:

glitchlings-0.1.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+glitchlings/__init__.py,sha256=yD0BaldUpcc_QlHVca1z1iwpOp8ne1H9YVQHc85d1So,580
+glitchlings/__main__.py,sha256=EOiBgay0x6B9VlSDzSQvMuoq6bHJdSvFSgcAVGGKkd4,121
+glitchlings/main.py,sha256=1pdVqytcrkh_GxOb0UPnZ0NzYKMoUnXmAWQB4cY5SEg,6199
+glitchlings/dlc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glitchlings/dlc/prime.py,sha256=WnLIon2WbdPGx_PK4vF6nOwJICXudZ6zKGR1hVES4Oc,1452
+glitchlings/util/__init__.py,sha256=OCpWFtloU-sATBv2XpBGlkR7UFR6RemUtuCheuRA4yw,4018
+glitchlings/zoo/__init__.py,sha256=hXQci2tysMoRHXiR6NDkWtGkKgcO0xxsMB91eiM_Llc,1344
+glitchlings/zoo/core.py,sha256=5f9pWBZZSDADiUSs-xUahIqCEb9EUq-YcR_N5HzBAw0,8021
+glitchlings/zoo/jargoyle.py,sha256=fvBP4ngqZ9BHLmpIjiLqGedriwAMuZc6ryqKT5GWfPw,6924
+glitchlings/zoo/mim1c.py,sha256=X4jW4YrNqbyG0IEDx7wXUsPTwrUXGw2vXUO1kC2yY94,2471
+glitchlings/zoo/redactyl.py,sha256=T0SAAbkva4A-tnQkXsUJ43N6Q33TsKElDvldUz69sMQ,3546
+glitchlings/zoo/reduple.py,sha256=ML4TLQNfOkSaF7G9Sjy_i9ILB4FIl1I101CIppNGmOw,2773
+glitchlings/zoo/rushmore.py,sha256=FH-pHnj1XKFzLRRQIHOojTkbkCpipNKnxSfxP9UGYZI,2528
+glitchlings/zoo/scannequin.py,sha256=4QP_dpReUxno0mk5Hnn2uCfd3B6eDa7ZGePuW1dyqBU,4630
+glitchlings/zoo/typogre.py,sha256=8aYULO4nvdyFDsknAfrlQYKeWz_Tgh5uXAkF3omHe0o,5358
+glitchlings-0.1.3.dist-info/METADATA,sha256=fwqJfu1FrQwJfAnc5UQIaaN3L7er_FWek0cMzRFSVuw,24978
+glitchlings-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+glitchlings-0.1.3.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.1.3.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.1.3.dist-info/RECORD,,