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

{zoo → glitchlings/zoo}/typogre.py

@@ -1,224 +1,231 @@
-from .core import Glitchling, AttackWave, AttackOrder
-from ..util import KEYNEIGHBORS
-import random
-import re
-from typing import Literal, Optional
-
-# Removed dependency on external 'typo' library for deterministic control.
-
-
-def unichar(text: str, rng: random.Random) -> str:
-    """Collapse one random doubled letter (like 'ee' in 'seed') to a single occurrence."""
-    # capture doubled letter followed by trailing word chars so we don't match punctuation
-    matches = list(re.finditer(r"((.)\2)(?=\w)", text))
-    if not matches:
-        return text
-    m = rng.choice(matches)
-    start, end = m.span(1)
-    # Replace the doubled pair with a single char
-    return text[:start] + text[start] + text[end:]
-
-
-def subs(text, index, rng: random.Random, key_neighbors=None):
-    if key_neighbors is None:
-        key_neighbors = getattr(KEYNEIGHBORS, "CURATOR_QWERTY")
-    char = text[index]
-    neighbors = key_neighbors.get(char, [])
-    if not neighbors:
-        return text
-    new_char = rng.choice(neighbors)
-    return text[:index] + new_char + text[index + 1 :]
-
-
-def indel(
-    text: str,
-    index: int,
-    op: Literal["delete", "insert", "swap"],
-    rng: random.Random,
-    key_neighbors=None,
-):
-    if key_neighbors is None:
-        key_neighbors = getattr(KEYNEIGHBORS, "CURATOR_QWERTY")
-    if index < 0 or index >= len(text):
-        return text
-    if op == "delete":
-        return text[:index] + text[index + 1 :]
-    if op == "swap":
-        if index >= len(text) - 1:
-            return text
-        return text[:index] + text[index + 1] + text[index] + text[index + 2 :]
-    # insert (choose neighbor of this char) – if none, just duplicate char
-    char = text[index]
-    candidates = key_neighbors.get(char, []) or [char]
-    new_char = rng.choice(candidates)
-    return text[:index] + new_char + text[index:]
-
-
-def repeated_char(text: str, rng: random.Random) -> str:
-    """Repeat a random non-space character once (e.g., 'cat' -> 'caat')."""
-    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 random_space(text: str, rng: random.Random) -> str:
-    """Insert a space at a random boundary between characters (excluding ends)."""
-    if len(text) < 2:
-        return text
-    idx = rng.randrange(1, len(text))
-    return text[:idx] + " " + text[idx:]
-
-
-def skipped_space(text: str, rng: random.Random) -> str:
-    """Remove a random existing single space (simulate missed space press)."""
-    space_positions = [m.start() for m in re.finditer(r" ", text)]
-    if not space_positions:
-        return text
-    idx = rng.choice(space_positions)
-    # collapse this one space: remove it
-    return text[:idx] + text[idx + 1 :]
-
-
-def _is_word_char(c: str) -> bool:
-    return c.isalnum() or c == "_"
-
-
-def _eligible_idx(s: str, i: int, preserve_first_last: bool) -> bool:
-    """O(1) check whether index i is eligible under preserve_first_last."""
-    if i < 0 or i >= len(s):
-        return False
-    if not _is_word_char(s[i]):
-        return False
-    if not preserve_first_last:
-        return True
-    # interior-of-word only
-    left_ok = i > 0 and _is_word_char(s[i - 1])
-    right_ok = i + 1 < len(s) and _is_word_char(s[i + 1])
-    return left_ok and right_ok
-
-
-def _draw_eligible_index(
-    rng: random.Random, s: str, preserve_first_last: bool, max_tries: int = 16
-) -> Optional[int]:
-    """Try a few uniform draws; if none hit, do a single wraparound scan."""
-    n = len(s)
-    if n == 0:
-        return None
-    for _ in range(max_tries):
-        i = rng.randrange(n)
-        if _eligible_idx(s, i, preserve_first_last):
-            return i
-    # Fallback: linear scan starting from a random point (rare path)
-    start = rng.randrange(n)
-    i = start
-    while True:
-        if _eligible_idx(s, i, preserve_first_last):
-            return i
-        i += 1
-        if i == n:
-            i = 0
-        if i == start:
-            return None
-
-
-def fatfinger(
-    text: str,
-    max_change_rate: float = 0.02,
-    preserve_first_last: bool = False,
-    keyboard: str = "CURATOR_QWERTY",
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Introduce character-level "fat finger" edits.
-
-    Parameters
-    - text: Input string to corrupt.
-    - max_change_rate: Max proportion of characters to edit (default 0.02).
-    - preserve_first_last: If True, avoid modifying first/last character of words (default False).
-    - keyboard: Name of keyboard neighbor map from util.KEYNEIGHBORS to use (default "CURATOR_QWERTY").
-    - seed: Optional seed used if `rng` is not provided; creates a dedicated Random.
-    - rng: Optional random.Random to use; if provided, overrides `seed`.
-
-    Notes
-    - Chooses indices lazily from the current text after each edit to keep offsets valid.
-    - Uses the glitchling's own RNG for determinism when run via Gaggle/summon.
-    """
-    if rng is None:
-        rng = random.Random(seed)
-    if not text:
-        return ""
-
-    s = text
-    max_changes = max(1, int(len(s) * max_change_rate))
-
-    # Prebind for speed
-    layout = getattr(KEYNEIGHBORS, keyboard)
-    choose = rng.choice
-
-    # Actions that require a specific index vs. "global" actions
-    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
-
-    # Pre-draw action types (cheap); pick indices lazily on each step
-    actions_drawn = [choose(all_actions) for _ in range(max_changes)]
-
-    for action in actions_drawn:
-        if action in positional_actions:
-            idx = _draw_eligible_index(rng, s, preserve_first_last)
-            if idx is None:
-                continue  # nothing eligible; skip
-
-            if action == "char_swap":
-                # Try swapping to the right; if not possible, optionally try left
-                j = idx + 1
-                if j < len(s) and (
-                    not preserve_first_last or _eligible_idx(s, j, True)
-                ):
-                    s = s[:idx] + s[j] + s[idx] + s[j + 1 :]
-                else:
-                    j = idx - 1
-                    if j >= 0 and (
-                        not preserve_first_last or _eligible_idx(s, j, True)
-                    ):
-                        s = s[:j] + s[idx] + s[j] + s[idx + 1 :]
-                    # else: give up this action
-
-            elif action == "missing_char":
-                s = s[:idx] + s[idx + 1 :]
-
-            elif action == "extra_char":
-                ch = s[idx]
-                neighbors = layout.get(ch.lower(), []) or [ch]
-                ins = choose(neighbors) or ch
-                s = s[:idx] + ins + s[idx:]
-
-            elif action == "nearby_char":
-                ch = s[idx]
-                neighbors = layout.get(ch.lower(), [])
-                if neighbors:
-                    rep = choose(neighbors)
-                    s = s[:idx] + rep + s[idx + 1 :]
-
-        else:
-            # "Global" actions that internally pick their own positions
-            if action == "skipped_space":
-                s = skipped_space(s, rng)
-            elif action == "random_space":
-                s = random_space(s, rng)
-            elif action == "unichar":
-                s = unichar(s, rng)
-            elif action == "repeated_char":
-                s = repeated_char(s, rng)
-
-    return s
-
-
-typogre = Glitchling(
-    name="Typogre",
-    corruption_function=fatfinger,
-    scope=AttackWave.CHARACTER,
-    order=AttackOrder.EARLY,
-)
+from .core import Glitchling, AttackWave, AttackOrder
+from ..util import KEYNEIGHBORS
+import random
+import re
+from typing import Literal, Optional
+
+# Removed dependency on external 'typo' library for deterministic control.
+
+
+def unichar(text: str, rng: random.Random) -> str:
+    """Collapse one random doubled letter (like 'ee' in 'seed') to a single occurrence."""
+    # capture doubled letter followed by trailing word chars so we don't match punctuation
+    matches = list(re.finditer(r"((.)\2)(?=\w)", text))
+    if not matches:
+        return text
+    m = rng.choice(matches)
+    start, end = m.span(1)
+    # Replace the doubled pair with a single char
+    return text[:start] + text[start] + text[end:]
+
+
+def subs(text, index, rng: random.Random, key_neighbors=None):
+    if key_neighbors is None:
+        key_neighbors = getattr(KEYNEIGHBORS, "CURATOR_QWERTY")
+    char = text[index]
+    neighbors = key_neighbors.get(char, [])
+    if not neighbors:
+        return text
+    new_char = rng.choice(neighbors)
+    return text[:index] + new_char + text[index + 1 :]
+
+
+def indel(
+    text: str,
+    index: int,
+    op: Literal["delete", "insert", "swap"],
+    rng: random.Random,
+    key_neighbors=None,
+):
+    if key_neighbors is None:
+        key_neighbors = getattr(KEYNEIGHBORS, "CURATOR_QWERTY")
+    if index < 0 or index >= len(text):
+        return text
+    if op == "delete":
+        return text[:index] + text[index + 1 :]
+    if op == "swap":
+        if index >= len(text) - 1:
+            return text
+        return text[:index] + text[index + 1] + text[index] + text[index + 2 :]
+    # insert (choose neighbor of this char) – if none, just duplicate char
+    char = text[index]
+    candidates = key_neighbors.get(char, []) or [char]
+    new_char = rng.choice(candidates)
+    return text[:index] + new_char + text[index:]
+
+
+def repeated_char(text: str, rng: random.Random) -> str:
+    """Repeat a random non-space character once (e.g., 'cat' -> 'caat')."""
+    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 random_space(text: str, rng: random.Random) -> str:
+    """Insert a space at a random boundary between characters (excluding ends)."""
+    if len(text) < 2:
+        return text
+    idx = rng.randrange(1, len(text))
+    return text[:idx] + " " + text[idx:]
+
+
+def skipped_space(text: str, rng: random.Random) -> str:
+    """Remove a random existing single space (simulate missed space press)."""
+    space_positions = [m.start() for m in re.finditer(r" ", text)]
+    if not space_positions:
+        return text
+    idx = rng.choice(space_positions)
+    # collapse this one space: remove it
+    return text[:idx] + text[idx + 1 :]
+
+
+def _is_word_char(c: str) -> bool:
+    return c.isalnum() or c == "_"
+
+
+def _eligible_idx(s: str, i: int) -> bool:
+    """O(1) check whether index i is eligible under preserve_first_last."""
+    if i < 0 or i >= len(s):
+        return False
+    if not _is_word_char(s[i]):
+        return False
+    # interior-of-word only
+    left_ok = i > 0 and _is_word_char(s[i - 1])
+    right_ok = i + 1 < len(s) and _is_word_char(s[i + 1])
+    return left_ok and right_ok
+
+
+def _draw_eligible_index(
+    rng: random.Random, s: str, max_tries: int = 16
+) -> Optional[int]:
+    """Try a few uniform draws; if none hit, do a single wraparound scan."""
+    n = len(s)
+    if n == 0:
+        return None
+    for _ in range(max_tries):
+        i = rng.randrange(n)
+        if _eligible_idx(s, i):
+            return i
+    # Fallback: linear scan starting from a random point (rare path)
+    start = rng.randrange(n)
+    i = start
+    while True:
+        if _eligible_idx(s, i):
+            return i
+        i += 1
+        if i == n:
+            i = 0
+        if i == start:
+            return None
+
+
+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.
+
+    Parameters
+    - text: Input string to corrupt.
+    - max_change_rate: Max proportion of characters to edit (default 0.02).
+    - keyboard: Name of keyboard neighbor map from util.KEYNEIGHBORS to use (default "CURATOR_QWERTY").
+    - seed: Optional seed used if `rng` is not provided; creates a dedicated Random.
+    - rng: Optional random.Random to use; if provided, overrides `seed`.
+
+    Notes
+    - Chooses indices lazily from the current text after each edit to keep offsets valid.
+    - Uses the glitchling's own RNG for determinism when run via Gaggle/summon.
+    """
+    if rng is None:
+        rng = random.Random(seed)
+    if not text:
+        return ""
+
+    s = text
+    max_changes = max(1, int(len(s) * max_change_rate))
+
+    # Prebind for speed
+    layout = getattr(KEYNEIGHBORS, keyboard)
+    choose = rng.choice
+
+    # Actions that require a specific index vs. "global" actions
+    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
+
+    # Pre-draw action types (cheap); pick indices lazily on each step
+    actions_drawn = [choose(all_actions) for _ in range(max_changes)]
+
+    for action in actions_drawn:
+        if action in positional_actions:
+            idx = _draw_eligible_index(rng, s)
+            if idx is None:
+                continue  # nothing eligible; skip
+
+            if action == "char_swap":
+                # Try swapping with neighbor while respecting word boundaries
+
+                j = idx + 1
+                s = s[:idx] + s[j] + s[idx] + s[j + 1 :]
+
+            elif action == "missing_char":
+                if _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 = choose(neighbors) or ch
+                s = s[:idx] + ins + s[idx:]
+
+            elif action == "nearby_char":
+                ch = s[idx]
+                neighbors = layout.get(ch.lower(), [])
+                if neighbors:
+                    rep = choose(neighbors)
+                    s = s[:idx] + rep + s[idx + 1 :]
+
+        else:
+            # "Global" actions that internally pick their own positions
+            if action == "skipped_space":
+                s = skipped_space(s, rng)
+            elif action == "random_space":
+                s = random_space(s, rng)
+            elif action == "unichar":
+                s = unichar(s, rng)
+            elif action == "repeated_char":
+                s = repeated_char(s, rng)
+
+    return s
+
+
+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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.1.1
+Version: 0.1.2
 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.2.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=PHKkNxFpBmTEgX7pAEJDiDQOWmqkdPp4qPk_dhu56sM,6778
+glitchlings/zoo/jargoyle.py,sha256=fvBP4ngqZ9BHLmpIjiLqGedriwAMuZc6ryqKT5GWfPw,6924
+glitchlings/zoo/mim1c.py,sha256=X4jW4YrNqbyG0IEDx7wXUsPTwrUXGw2vXUO1kC2yY94,2471
+glitchlings/zoo/redactyl.py,sha256=XAd57e8oM_s3cEKoEzS6lDgVsyrdN-6L1lA-4_HQGok,2613
+glitchlings/zoo/reduple.py,sha256=yXGBAqZyeBSuDkLT8BXAXiEs14GUFKxSo3tdlm1ZChM,2065
+glitchlings/zoo/rushmore.py,sha256=7p8MzNbln_Xs393F7cYNfji57Y-dsvSWBTE_IPDrO34,2001
+glitchlings/zoo/scannequin.py,sha256=We4I_3RFckkiSC5ERZs112jD-TH-VxAojtNTLzBgmwY,4019
+glitchlings/zoo/typogre.py,sha256=hA_UF3PL-hcEmosafB1IRUNk95ip2n-36bK26OU3jZc,7424
+glitchlings-0.1.2.dist-info/METADATA,sha256=dz3pti6nqokKwMXfklVMB4IyK0QsbqKXiy7tKCyGa4E,24978
+glitchlings-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+glitchlings-0.1.2.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.1.2.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.1.2.dist-info/RECORD,,