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

glitchlings/zoo/core.py

@@ -1,10 +1,13 @@
 """Core data structures used to model glitchlings and their interactions."""
 
-from enum import IntEnum, auto
-from datasets import Dataset
+import inspect
 import random
+from enum import IntEnum, auto
+from hashlib import blake2s
 from typing import Any, Protocol
 
+from datasets import Dataset
+
 
 class CorruptionCallable(Protocol):
     """Protocol describing a callable capable of corrupting text."""
@@ -77,12 +80,23 @@ class Glitchling:
 
         setattr(self, key, value)
         self.kwargs[key] = value
+        if key == "seed":
+            self.reset_rng(value)
 
     def __corrupt(self, text: str, *args: Any, **kwargs: Any) -> str:
         """Execute the corruption callable, injecting the RNG when required."""
 
         # Pass rng to underlying corruption function if it expects it.
-        if "rng" in self.corruption_function.__code__.co_varnames:
+        try:
+            signature = inspect.signature(self.corruption_function)
+        except (TypeError, ValueError):
+            signature = None
+
+        expects_rng = False
+        if signature is not None:
+            expects_rng = "rng" in signature.parameters
+
+        if expects_rng:
             corrupted = self.corruption_function(text, *args, rng=self.rng, **kwargs)
         else:
             corrupted = self.corruption_function(text, *args, **kwargs)
@@ -104,7 +118,11 @@ class Glitchling:
         def __corrupt_row(row: dict[str, Any]) -> dict[str, Any]:
             row = dict(row)
             for column in columns:
-                row[column] = self.corrupt(row[column])
+                value = row[column]
+                if isinstance(value, list):
+                    row[column] = [self.corrupt(item) for item in value]
+                else:
+                    row[column] = self.corrupt(value)
             return row
 
         return dataset.with_transform(__corrupt_row)
@@ -170,7 +188,29 @@ class Gaggle(Glitchling):
     @staticmethod
     def derive_seed(master_seed: int, glitchling_name: str, index: int) -> int:
         """Derive a deterministic seed for a glitchling based on the master seed."""
-        return hash((master_seed, glitchling_name, index)) & 0xFFFFFFFF
+        def _int_to_bytes(value: int) -> bytes:
+            if value == 0:
+                return b"\x00"
+
+            abs_value = abs(value)
+            length = max(1, (abs_value.bit_length() + 7) // 8)
+
+            if value < 0:
+                while True:
+                    try:
+                        return value.to_bytes(length, "big", signed=True)
+                    except OverflowError:
+                        length += 1
+
+            return abs_value.to_bytes(length, "big", signed=False)
+
+        hasher = blake2s(digest_size=8)
+        hasher.update(_int_to_bytes(master_seed))
+        hasher.update(b"\x00")
+        hasher.update(glitchling_name.encode("utf-8"))
+        hasher.update(b"\x00")
+        hasher.update(_int_to_bytes(index))
+        return int.from_bytes(hasher.digest(), "big")
 
     def sort_glitchlings(self) -> None:
         """Sort glitchlings by wave then order to produce application order."""

glitchlings/zoo/redactyl.py

@@ -1,17 +1,24 @@
 import re
 import random
+
 from .core import Glitchling, AttackWave
 
 FULL_BLOCK = "█"
 
 
-def redact_words(
+try:
+    from glitchlings._zoo_rust import redact_words as _redact_words_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _redact_words_rust = None
+
+
+def _python_redact_words(
     text: str,
-    replacement_char: str = FULL_BLOCK,
-    redaction_rate: float = 0.05,
-    merge_adjacent: bool = False,
-    seed: int = 151,
-    rng: random.Random | None = None,
+    *,
+    replacement_char: str,
+    redaction_rate: float,
+    merge_adjacent: bool,
+    rng: random.Random,
 ) -> str:
     """Redact random words by replacing their characters.
 
@@ -23,12 +30,11 @@ def redact_words(
     - seed: Seed used if `rng` not provided (default 151).
     - rng: Optional RNG; overrides seed.
     """
-    if rng is None:
-        rng = random.Random(seed)
-
     # 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.")
     num_to_redact = max(1, int(len(word_indices) * redaction_rate))
 
     # Sample from the indices of actual words
@@ -63,6 +69,37 @@ def redact_words(
     return text
 
 
+def redact_words(
+    text: str,
+    replacement_char: str = FULL_BLOCK,
+    redaction_rate: float = 0.05,
+    merge_adjacent: bool = False,
+    seed: int = 151,
+    rng: random.Random | None = None,
+) -> str:
+    """Redact random words by replacing their characters."""
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _redact_words_rust is not None:
+        return _redact_words_rust(
+            text,
+            replacement_char,
+            redaction_rate,
+            merge_adjacent,
+            rng,
+        )
+
+    return _python_redact_words(
+        text,
+        replacement_char=replacement_char,
+        redaction_rate=redaction_rate,
+        merge_adjacent=merge_adjacent,
+        rng=rng,
+    )
+
+
 class Redactyl(Glitchling):
     """Glitchling that redacts words with block characters."""
 

glitchlings/zoo/reduple.py

@@ -1,13 +1,19 @@
 import re
 import random
+
 from .core import Glitchling, AttackWave
 
+try:
+    from glitchlings._zoo_rust import reduplicate_words as _reduplicate_words_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _reduplicate_words_rust = None
 
-def reduplicate_words(
+
+def _python_reduplicate_words(
     text: str,
-    reduplication_rate: float = 0.05,
-    seed: int | None = None,
-    rng: random.Random | None = None,
+    *,
+    reduplication_rate: float,
+    rng: random.Random,
 ) -> str:
     """Randomly reduplicate words in the text.
 
@@ -21,9 +27,6 @@ def reduplicate_words(
     - Preserves spacing and punctuation by tokenizing with separators.
     - Deterministic when run with a fixed seed or via Gaggle.
     """
-    if rng is None:
-        rng = random.Random(seed)
-
     # Preserve exact spacing and punctuation by using regex
     tokens = re.split(r"(\s+)", text)  # Split but keep separators
 
@@ -45,10 +48,34 @@ def reduplicate_words(
                 tokens[i] = f"{prefix}{core} {core}{suffix}"
             else:
                 tokens[i] = f"{word} {word}"
-
     return "".join(tokens)
 
 
+def reduplicate_words(
+    text: str,
+    reduplication_rate: float = 0.05,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Randomly reduplicate words in the text.
+
+    Falls back to the Python implementation when the optional Rust
+    extension is unavailable.
+    """
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _reduplicate_words_rust is not None:
+        return _reduplicate_words_rust(text, reduplication_rate, rng)
+
+    return _python_reduplicate_words(
+        text,
+        reduplication_rate=reduplication_rate,
+        rng=rng,
+    )
+
+
 class Reduple(Glitchling):
     """Glitchling that repeats words to simulate stuttering speech."""
 

glitchlings/zoo/rushmore.py

@@ -1,41 +1,40 @@
+import math
 import random
 import re
+
 from .core import Glitchling, AttackWave
 
+try:
+    from glitchlings._zoo_rust import delete_random_words as _delete_random_words_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _delete_random_words_rust = None
 
-def delete_random_words(
+
+def _python_delete_random_words(
     text: str,
-    max_deletion_rate: float = 0.01,
-    seed: int | None = None,
-    rng: random.Random | None = None,
+    *,
+    max_deletion_rate: float,
+    rng: random.Random,
 ) -> str:
-    """Delete random words from the input text.
+    """Delete random words from the input text while preserving whitespace."""
 
-    Parameters
-    - text: The input text.
-    - max_deletion_rate: The maximum proportion of words to delete (default 0.01).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
-    """
-    if rng is None:
-        rng = random.Random(seed)
-
-    # Preserve exact spacing and punctuation by using regex
-    tokens = re.split(r"(\s+)", text)  # Split but keep separators
-
-    for i in range(
-        2, len(tokens), 2
-    ):  # Every other token is a word, but skip the first word
-        if i >= len(tokens):
-            break
+    tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
 
+    candidate_indices: list[int] = []
+    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():  # Skip empty or whitespace
+        if not word or word.isspace():
             continue
 
-        # Only consider actual words for deletion
+        candidate_indices.append(i)
+
+    allowed_deletions = math.floor(len(candidate_indices) * max_deletion_rate)
+    if allowed_deletions <= 0:
+        return text
+
+    for i in candidate_indices:
         if rng.random() < max_deletion_rate:
-            # Check if word has trailing punctuation
+            word = tokens[i]
             match = re.match(r"^(\W*)(.*?)(\W*)$", word)
             if match:
                 prefix, _, suffix = match.groups()
@@ -50,6 +49,30 @@ def delete_random_words(
     return text
 
 
+def delete_random_words(
+    text: str,
+    max_deletion_rate: float = 0.01,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Delete random words from the input text.
+
+    Uses the optional Rust implementation when available.
+    """
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _delete_random_words_rust is not None:
+        return _delete_random_words_rust(text, max_deletion_rate, rng)
+
+    return _python_delete_random_words(
+        text,
+        max_deletion_rate=max_deletion_rate,
+        rng=rng,
+    )
+
+
 class Rushmore(Glitchling):
     """Glitchling that deletes words to simulate missing information."""
 

glitchlings/zoo/scannequin.py

@@ -1,13 +1,19 @@
 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 ocr_artifacts(
+
+def _python_ocr_artifacts(
     text: str,
-    error_rate: float = 0.02,
-    seed: int | None = None,
-    rng: random.Random | None = None,
+    *,
+    error_rate: float,
+    rng: random.Random,
 ) -> str:
     """Introduce OCR-like artifacts into text.
 
@@ -27,9 +33,6 @@ def ocr_artifacts(
     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]]] = [
@@ -115,6 +118,29 @@ def ocr_artifacts(
     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."""
 

glitchlings/zoo/typogre.py

@@ -1,118 +1,81 @@
+from __future__ import annotations
+
+import random
+from typing import Optional
+
 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.
+try:
+    from glitchlings._typogre_rust import fatfinger as _fatfinger_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _fatfinger_rust = None
 
 
-def unichar(text: str, rng: random.Random) -> str:
+def _python_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
+    import re
+
     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
+    start, end = rng.choice(matches).span(1)
     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 _python_skipped_space(text: str, rng: random.Random) -> str:
+    import re
 
-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:
+    space_positions = [m.start() for m in re.finditer(r" ", text)]
+    if not space_positions:
         return text
-    i = rng.choice(positions)
-    return text[:i] + text[i] + text[i:]
+    idx = rng.choice(space_positions)
+    return text[:idx] + text[idx + 1 :]
 
 
-def random_space(text: str, rng: random.Random) -> str:
-    """Insert a space at a random boundary between characters (excluding ends)."""
+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 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:
+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
-    idx = rng.choice(space_positions)
-    # collapse this one space: remove it
-    return text[:idx] + text[idx + 1 :]
+    i = rng.choice(positions)
+    return text[:i] + text[i] + text[i:]
 
 
-def _is_word_char(c: str) -> bool:
+def _python_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."""
+def _python_eligible_idx(s: str, i: int) -> bool:
     if i < 0 or i >= len(s):
         return False
-    if not _is_word_char(s[i]):
+    if not _python_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])
+    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 _draw_eligible_index(
+def _python_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):
+        if _python_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):
+        if _python_eligible_idx(s, i):
             return i
         i += 1
         if i == n:
@@ -121,89 +84,78 @@ def _draw_eligible_index(
             return None
 
 
-def fatfinger(
+def _fatfinger_python(
     text: str,
-    max_change_rate: float = 0.02,
-    keyboard: str = "CURATOR_QWERTY",
-    seed: int | None = None,
-    rng: random.Random | None = None,
+    *,
+    max_change_rate: float,
+    layout: dict[str, list[str]],
+    rng: random.Random,
 ) -> 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)]
+    actions_drawn = [rng.choice(all_actions) for _ in range(max_changes)]
 
     for action in actions_drawn:
         if action in positional_actions:
-            idx = _draw_eligible_index(rng, s)
+            idx = _python_draw_eligible_index(rng, s)
             if idx is None:
-                continue  # nothing eligible; skip
-
+                continue
             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):
+                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 = choose(neighbors) 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 = choose(neighbors)
+                    rep = rng.choice(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)
+                s = _python_skipped_space(s, rng)
             elif action == "random_space":
-                s = random_space(s, rng)
+                s = _python_random_space(s, rng)
             elif action == "unichar":
-                s = unichar(s, rng)
+                s = _python_unichar(s, rng)
             elif action == "repeated_char":
-                s = repeated_char(s, rng)
-
+                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."""
 
@@ -229,3 +181,4 @@ typogre = Typogre()
 
 
 __all__ = ["Typogre", "typogre"]
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.1.2
+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

{glitchlings-0.1.2.dist-info → glitchlings-0.1.3.dist-info}/RECORD

@@ -5,16 +5,16 @@ 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/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=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,,
+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,,