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

glitchlings/dlc/prime.py

@@ -79,8 +79,8 @@ def tutorial_level(
 ) -> vf.Environment:
     """Create a low-corruption environment using tuned defaults."""
 
-    tuned_mim1c = Mim1c(replacement_rate=0.01 * difficulty.value)
-    tuned_typogre = Typogre(max_change_rate=0.025 * difficulty.value)
+    tuned_mim1c = Mim1c(rate=0.01 * difficulty.value)
+    tuned_typogre = Typogre(rate=0.025 * difficulty.value)
 
     return load_environment(
         env,
@@ -220,32 +220,54 @@ def echo_chamber(
             "Specify which split to use when the dataset loads as a DatasetDict."
         )
 
-    prompts: list[list[dict[str, str]]] = []
-    answers: list[str] = []
+    filtered_dataset = hf_dataset.filter(
+        lambda row: row.get(column) is not None,
+        load_from_cache_file=False,
+    )
 
-    for row in hf_dataset:
-        value = row.get(column)
-        if value is None:
-            continue
+    source_column_names = list(filtered_dataset.column_names)
 
-        text = str(value)
-        prompts.append(
-            [
-                {"role": "system", "content": instructions},
-                {"role": "user", "content": f"Corrupted text:\n{text}"},
-            ]
-        )
-        answers.append(text)
+    def _build_prompt(row: dict[str, Any]) -> dict[str, Any]:
+        text = str(row[column])
+        prompt = [
+            {"role": "system", "content": instructions},
+            {"role": "user", "content": f"Corrupted text:\n{text}"},
+        ]
+        return {"prompt": prompt, "answer": text}
 
-    if not prompts:
-        raise ValueError(
-            f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
-        )
+    base_dataset = filtered_dataset.map(
+        _build_prompt,
+        remove_columns=source_column_names,
+        load_from_cache_file=False,
+    )
 
-    dataset = HFDataset.from_dict({"prompt": prompts, "answer": answers})
+    try:
+        dataset_length = len(base_dataset)  # type: ignore[arg-type]
+    except TypeError:
+        preview_rows: list[dict[str, Any]]
+        take_fn = getattr(base_dataset, "take", None)
+        if callable(take_fn):
+            preview_rows = list(take_fn(1))
+        else:
+            iterator = iter(base_dataset)
+            try:
+                first_row = next(iterator)
+            except StopIteration:
+                preview_rows = []
+            else:
+                preview_rows = [first_row]
+        if not preview_rows:
+            raise ValueError(
+                f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
+            )
+    else:
+        if dataset_length == 0:
+            raise ValueError(
+                f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
+            )
 
     gaggle = _as_gaggle(glitchlings, seed=seed)
-    glitched_dataset = gaggle.corrupt_dataset(dataset, ["prompt"])
+    glitched_dataset = gaggle.corrupt_dataset(base_dataset, ["prompt"])
 
     rubric_func = reward_function or symmetric_damerau_levenshtein_similarity
     rubric = vf.Rubric(funcs=[rubric_func], weights=[1.0])

glitchlings/main.py

@@ -46,7 +46,7 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="SPEC",
         help=(
             "Glitchling to apply, optionally with parameters like "
-            "Typogre(max_change_rate=0.05). Repeat for multiples; defaults to all built-ins."
+            "Typogre(rate=0.05). Repeat for multiples; defaults to all built-ins."
         ),
     )
     parser.add_argument(

glitchlings/zoo/_rate.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+
+def resolve_rate(
+    *,
+    rate: float | None,
+    legacy_value: float | None,
+    default: float,
+    legacy_name: str,
+) -> float:
+    """Return the effective rate while enforcing mutual exclusivity."""
+
+    if rate is not None and legacy_value is not None:
+        raise ValueError(
+            f"Specify either 'rate' or '{legacy_name}', not both."
+        )
+    if rate is not None:
+        return rate
+    if legacy_value is not None:
+        return legacy_value
+    return default

glitchlings/zoo/core.py

@@ -107,6 +107,7 @@ class Glitchling:
         scope: AttackWave,
         order: AttackOrder = AttackOrder.NORMAL,
         seed: int | None = None,
+        pipeline_operation: Callable[["Glitchling"], dict[str, Any] | None] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize a glitchling.
@@ -128,31 +129,76 @@ class Glitchling:
         self.corruption_function: CorruptionCallable = corruption_function
         self.level: AttackWave = scope
         self.order: AttackOrder = order
+        self._pipeline_descriptor_factory = pipeline_operation
         self.kwargs: dict[str, Any] = {}
+        self._cached_rng_callable: CorruptionCallable | None = None
+        self._cached_rng_expectation: bool | None = None
         for kw, val in kwargs.items():
             self.set_param(kw, val)
 
     def set_param(self, key: str, value: Any) -> None:
         """Persist a parameter for use by the corruption callable."""
 
-        setattr(self, key, value)
-        self.kwargs[key] = value
-        if key == "seed":
+        aliases = getattr(self, "_param_aliases", {})
+        canonical = aliases.get(key, key)
+
+        # Drop stale alias keys so we only forward canonical kwargs.
+        self.kwargs.pop(key, None)
+        for alias, target in aliases.items():
+            if target == canonical:
+                self.kwargs.pop(alias, None)
+
+        self.kwargs[canonical] = value
+        setattr(self, canonical, value)
+
+        if canonical == "seed":
             self.reset_rng(value)
 
-    def __corrupt(self, text: str, *args: Any, **kwargs: Any) -> str:
-        """Execute the corruption callable, injecting the RNG when required."""
+        for alias, target in aliases.items():
+            if target == canonical:
+                setattr(self, alias, value)
 
-        # Pass rng to underlying corruption function if it expects it.
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        """Return the Rust pipeline operation descriptor for this glitchling."""
+
+        factory = self._pipeline_descriptor_factory
+        if factory is None:
+            return None
+
+        return factory(self)
+
+    def _corruption_expects_rng(self) -> bool:
+        """Return `True` when the corruption function accepts an rng keyword."""
+
+        cached_callable = self._cached_rng_callable
+        cached_expectation = self._cached_rng_expectation
+        corruption_function = self.corruption_function
+
+        if (
+            cached_callable is corruption_function
+            and cached_expectation is not None
+        ):
+            return cached_expectation
+
+        expects_rng = False
         try:
-            signature = inspect.signature(self.corruption_function)
+            signature = inspect.signature(corruption_function)
         except (TypeError, ValueError):
             signature = None
 
-        expects_rng = False
         if signature is not None:
             expects_rng = "rng" in signature.parameters
 
+        self._cached_rng_callable = corruption_function
+        self._cached_rng_expectation = expects_rng
+        return expects_rng
+
+    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.
+        expects_rng = self._corruption_expects_rng()
+
         if expects_rng:
             corrupted = self.corruption_function(text, *args, rng=self.rng, **kwargs)
         else:
@@ -231,53 +277,14 @@ class Glitchling:
                 self.corruption_function,
                 self.level,
                 self.order,
+                pipeline_operation=self._pipeline_descriptor_factory,
                 **filtered_kwargs,
             )
 
         return cls(**filtered_kwargs)
 
 
-def _pipeline_operation_reduplicate(glitchling: "Glitchling") -> dict[str, Any] | None:
-    rate = glitchling.kwargs.get("reduplication_rate")
-    if rate is None:
-        return None
-    return {"type": "reduplicate", "reduplication_rate": float(rate)}
-
 
-def _pipeline_operation_delete(glitchling: "Glitchling") -> dict[str, Any] | None:
-    rate = glitchling.kwargs.get("max_deletion_rate")
-    if rate is None:
-        return None
-    return {"type": "delete", "max_deletion_rate": float(rate)}
-
-
-def _pipeline_operation_redact(glitchling: "Glitchling") -> dict[str, Any] | None:
-    replacement_char = glitchling.kwargs.get("replacement_char")
-    redaction_rate = glitchling.kwargs.get("redaction_rate")
-    merge_adjacent = glitchling.kwargs.get("merge_adjacent")
-    if replacement_char is None or redaction_rate is None or merge_adjacent is None:
-        return None
-    return {
-        "type": "redact",
-        "replacement_char": str(replacement_char),
-        "redaction_rate": float(redaction_rate),
-        "merge_adjacent": bool(merge_adjacent),
-    }
-
-
-def _pipeline_operation_ocr(glitchling: "Glitchling") -> dict[str, Any] | None:
-    error_rate = glitchling.kwargs.get("error_rate")
-    if error_rate is None:
-        return None
-    return {"type": "ocr", "error_rate": float(error_rate)}
-
-
-_PIPELINE_OPERATION_BUILDERS: dict[str, Callable[["Glitchling"], dict[str, Any] | None]] = {
-    "Reduple": _pipeline_operation_reduplicate,
-    "Rushmore": _pipeline_operation_delete,
-    "Redactyl": _pipeline_operation_redact,
-    "Scannequin": _pipeline_operation_ocr,
-}
 
 
 class Gaggle(Glitchling):
@@ -359,10 +366,7 @@ class Gaggle(Glitchling):
 
         descriptors: list[dict[str, Any]] = []
         for glitchling in self.apply_order:
-            builder = _PIPELINE_OPERATION_BUILDERS.get(glitchling.name)
-            if builder is None:
-                return None
-            operation = builder(glitchling)
+            operation = glitchling.pipeline_operation()
             if operation is None:
                 return None
 

glitchlings/zoo/jargoyle.py

@@ -33,6 +33,7 @@ else:
     _WORDNET_MODULE = None
 
 from .core import AttackWave, Glitchling
+from ._rate import resolve_rate
 
 _WORDNET_HANDLE: WordNetCorpusReader | Any | None = _WORDNET_MODULE
 
@@ -211,16 +212,18 @@ def _collect_synonyms(
 
 def substitute_random_synonyms(
     text: str,
-    replacement_rate: float = 0.1,
+    rate: float | None = None,
     part_of_speech: PartOfSpeechInput = "n",
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    replacement_rate: float | None = None,
 ) -> str:
     """Replace words with random WordNet synonyms.
 
     Parameters
     - text: Input text.
-    - replacement_rate: Max proportion of candidate words to replace (default 0.1).
+    - rate: Max proportion of candidate words to replace (default 0.1).
     - part_of_speech: WordNet POS tag(s) to target. Accepts "n", "v", "a", "r",
       any iterable of those tags, or "any" to include all four.
     - rng: Optional RNG instance used for deterministic sampling.
@@ -232,6 +235,13 @@ def substitute_random_synonyms(
     - Synonyms sorted before rng.choice to fix ordering.
     - For each POS, the first synset containing alternate lemmas is used for stability.
     """
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=replacement_rate,
+        default=0.1,
+        legacy_name="replacement_rate",
+    )
+
     ensure_wordnet()
     wordnet = _wordnet()
 
@@ -270,7 +280,8 @@ def substitute_random_synonyms(
     if not candidate_indices:
         return text
 
-    max_replacements = int(len(candidate_indices) * replacement_rate)
+    clamped_rate = max(0.0, effective_rate)
+    max_replacements = int(len(candidate_indices) * clamped_rate)
     if max_replacements <= 0:
         return text
 
@@ -297,16 +308,24 @@ class Jargoyle(Glitchling):
     def __init__(
         self,
         *,
-        replacement_rate: float = 0.1,
+        rate: float | None = None,
+        replacement_rate: float | None = None,
         part_of_speech: PartOfSpeechInput = "n",
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"replacement_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=replacement_rate,
+            default=0.1,
+            legacy_name="replacement_rate",
+        )
         super().__init__(
             name="Jargoyle",
             corruption_function=substitute_random_synonyms,
             scope=AttackWave.WORD,
             seed=seed,
-            replacement_rate=replacement_rate,
+            rate=effective_rate,
             part_of_speech=part_of_speech,
         )
 

glitchlings/zoo/mim1c.py

@@ -5,21 +5,24 @@ from typing import Literal
 from confusable_homoglyphs import confusables
 
 from .core import AttackOrder, AttackWave, Glitchling
+from ._rate import resolve_rate
 
 
 def swap_homoglyphs(
     text: str,
-    replacement_rate: float = 0.02,
+    rate: float | None = None,
     classes: list[str] | Literal["all"] | None = None,
     banned_characters: Collection[str] | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    replacement_rate: float | None = None,
 ) -> str:
     """Replace characters with visually confusable homoglyphs.
 
     Parameters
     - text: Input text.
-    - replacement_rate: Max proportion of eligible characters to replace (default 0.02).
+    - rate: Max proportion of eligible characters to replace (default 0.02).
     - classes: Restrict replacements to these Unicode script classes (default ["LATIN","GREEK","CYRILLIC"]). Use "all" to allow any.
     - banned_characters: Characters that must never appear as replacements.
     - seed: Optional seed if `rng` not provided.
@@ -29,6 +32,13 @@ def swap_homoglyphs(
     - Only replaces characters present in confusables.confusables_data with single-codepoint alternatives.
     - Maintains determinism by shuffling candidates and sampling via the provided RNG.
     """
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=replacement_rate,
+        default=0.02,
+        legacy_name="replacement_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
 
@@ -39,7 +49,8 @@ def swap_homoglyphs(
     confusable_chars = [
         char for char in target_chars if char in confusables.confusables_data
     ]
-    num_replacements = int(len(confusable_chars) * replacement_rate)
+    clamped_rate = max(0.0, effective_rate)
+    num_replacements = int(len(confusable_chars) * clamped_rate)
     done = 0
     rng.shuffle(confusable_chars)
     banned_set = set(banned_characters or ())
@@ -66,18 +77,26 @@ class Mim1c(Glitchling):
     def __init__(
         self,
         *,
-        replacement_rate: float = 0.02,
+        rate: float | None = None,
+        replacement_rate: float | None = None,
         classes: list[str] | Literal["all"] | None = None,
         banned_characters: Collection[str] | None = None,
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"replacement_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=replacement_rate,
+            default=0.02,
+            legacy_name="replacement_rate",
+        )
         super().__init__(
             name="Mim1c",
             corruption_function=swap_homoglyphs,
             scope=AttackWave.CHARACTER,
             order=AttackOrder.LAST,
             seed=seed,
-            replacement_rate=replacement_rate,
+            rate=effective_rate,
             classes=classes,
             banned_characters=banned_characters,
         )

glitchlings/zoo/redactyl.py

@@ -1,7 +1,9 @@
 import re
 import random
+from typing import Any
 
 from .core import Glitchling, AttackWave
+from ._rate import resolve_rate
 
 FULL_BLOCK = "█"
 
@@ -16,7 +18,7 @@ def _python_redact_words(
     text: str,
     *,
     replacement_char: str,
-    redaction_rate: float,
+    rate: float,
     merge_adjacent: bool,
     rng: random.Random,
 ) -> str:
@@ -25,7 +27,7 @@ def _python_redact_words(
     Parameters
     - text: Input text.
     - replacement_char: The character to use for redaction (default FULL_BLOCK).
-    - redaction_rate: Max proportion of words to redact (default 0.05).
+    - 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.
@@ -35,7 +37,7 @@ def _python_redact_words(
     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))
+    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)
@@ -72,23 +74,34 @@ def _python_redact_words(
 def redact_words(
     text: str,
     replacement_char: str = FULL_BLOCK,
-    redaction_rate: float = 0.05,
+    rate: float | None = None,
     merge_adjacent: bool = False,
     seed: int = 151,
     rng: random.Random | None = None,
+    *,
+    redaction_rate: float | None = None,
 ) -> str:
     """Redact random words by replacing their characters."""
 
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=redaction_rate,
+        default=0.05,
+        legacy_name="redaction_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
 
+    clamped_rate = max(0.0, effective_rate)
+
     use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
 
     if use_rust:
         return _redact_words_rust(
             text,
             replacement_char,
-            redaction_rate,
+            clamped_rate,
             merge_adjacent,
             rng,
         )
@@ -96,7 +109,7 @@ def redact_words(
     return _python_redact_words(
         text,
         replacement_char=replacement_char,
-        redaction_rate=redaction_rate,
+        rate=clamped_rate,
         merge_adjacent=merge_adjacent,
         rng=rng,
     )
@@ -109,20 +122,42 @@ class Redactyl(Glitchling):
         self,
         *,
         replacement_char: str = FULL_BLOCK,
-        redaction_rate: float = 0.05,
+        rate: float | None = None,
+        redaction_rate: float | None = None,
         merge_adjacent: bool = False,
         seed: int = 151,
     ) -> None:
+        self._param_aliases = {"redaction_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=redaction_rate,
+            default=0.05,
+            legacy_name="redaction_rate",
+        )
         super().__init__(
             name="Redactyl",
             corruption_function=redact_words,
             scope=AttackWave.WORD,
             seed=seed,
             replacement_char=replacement_char,
-            redaction_rate=redaction_rate,
+            rate=effective_rate,
             merge_adjacent=merge_adjacent,
         )
 
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        replacement_char = self.kwargs.get("replacement_char")
+        rate = self.kwargs.get("rate")
+        merge_adjacent = self.kwargs.get("merge_adjacent")
+        if replacement_char is None or rate is None or merge_adjacent is None:
+            return None
+        return {
+            "type": "redact",
+            "replacement_char": str(replacement_char),
+            "redaction_rate": float(rate),
+            "merge_adjacent": bool(merge_adjacent),
+        }
+
+
 
 redactyl = Redactyl()
 

glitchlings/zoo/reduple.py

@@ -1,7 +1,9 @@
 import re
 import random
+from typing import Any
 
 from .core import Glitchling, AttackWave
+from ._rate import resolve_rate
 
 try:
     from glitchlings._zoo_rust import reduplicate_words as _reduplicate_words_rust
@@ -12,14 +14,14 @@ except ImportError:  # pragma: no cover - compiled extension not present
 def _python_reduplicate_words(
     text: str,
     *,
-    reduplication_rate: float,
+    rate: float,
     rng: random.Random,
 ) -> str:
     """Randomly reduplicate words in the text.
 
     Parameters
     - text: Input text.
-    - reduplication_rate: Max proportion of words to reduplicate (default 0.05).
+    - rate: Max proportion of words to reduplicate (default 0.05).
     - seed: Optional seed if `rng` not provided.
     - rng: Optional RNG; overrides seed.
 
@@ -39,7 +41,7 @@ def _python_reduplicate_words(
             continue
 
         # Only consider actual words for reduplication
-        if rng.random() < reduplication_rate:
+        if rng.random() < rate:
             # Check if word has trailing punctuation
             match = re.match(r"^(\W*)(.*?)(\W*)$", word)
             if match:
@@ -53,9 +55,11 @@ def _python_reduplicate_words(
 
 def reduplicate_words(
     text: str,
-    reduplication_rate: float = 0.05,
+    rate: float | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    reduplication_rate: float | None = None,
 ) -> str:
     """Randomly reduplicate words in the text.
 
@@ -63,15 +67,24 @@ def reduplicate_words(
     extension is unavailable.
     """
 
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=reduplication_rate,
+        default=0.05,
+        legacy_name="reduplication_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
 
+    clamped_rate = max(0.0, effective_rate)
+
     if _reduplicate_words_rust is not None:
-        return _reduplicate_words_rust(text, reduplication_rate, rng)
+        return _reduplicate_words_rust(text, clamped_rate, rng)
 
     return _python_reduplicate_words(
         text,
-        reduplication_rate=reduplication_rate,
+        rate=clamped_rate,
         rng=rng,
     )
 
@@ -82,17 +95,32 @@ class Reduple(Glitchling):
     def __init__(
         self,
         *,
-        reduplication_rate: float = 0.05,
+        rate: float | None = None,
+        reduplication_rate: float | None = None,
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"reduplication_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=reduplication_rate,
+            default=0.05,
+            legacy_name="reduplication_rate",
+        )
         super().__init__(
             name="Reduple",
             corruption_function=reduplicate_words,
             scope=AttackWave.WORD,
             seed=seed,
-            reduplication_rate=reduplication_rate,
+            rate=effective_rate,
         )
 
+    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)}
+
+
 
 reduple = Reduple()
 

glitchlings/zoo/rushmore.py

@@ -1,8 +1,10 @@
 import math
 import random
 import re
+from typing import Any
 
 from .core import Glitchling, AttackWave
+from ._rate import resolve_rate
 
 try:
     from glitchlings._zoo_rust import delete_random_words as _delete_random_words_rust
@@ -13,11 +15,14 @@ except ImportError:  # pragma: no cover - compiled extension not present
 def _python_delete_random_words(
     text: str,
     *,
-    max_deletion_rate: float,
+    rate: float,
     rng: random.Random,
 ) -> str:
     """Delete random words from the input text while preserving whitespace."""
 
+    if rate <= 0.0:
+        return text
+
     tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
 
     candidate_indices: list[int] = []
@@ -29,14 +34,14 @@ def _python_delete_random_words(
         candidate_indices.append(i)
 
     allowed_deletions = min(
-        len(candidate_indices), math.floor(len(candidate_indices) * max_deletion_rate)
+        len(candidate_indices), math.floor(len(candidate_indices) * rate)
     )
     if allowed_deletions <= 0:
         return text
 
     deletions = 0
     for i in candidate_indices:
-        if rng.random() < max_deletion_rate:
+        if rng.random() < rate:
             word = tokens[i]
             match = re.match(r"^(\W*)(.*?)(\W*)$", word)
             if match:
@@ -58,24 +63,35 @@ def _python_delete_random_words(
 
 def delete_random_words(
     text: str,
-    max_deletion_rate: float = 0.01,
+    rate: float | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    max_deletion_rate: float | None = None,
 ) -> str:
     """Delete random words from the input text.
 
     Uses the optional Rust implementation when available.
     """
 
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=max_deletion_rate,
+        default=0.01,
+        legacy_name="max_deletion_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
 
+    clamped_rate = max(0.0, effective_rate)
+
     if _delete_random_words_rust is not None:
-        return _delete_random_words_rust(text, max_deletion_rate, rng)
+        return _delete_random_words_rust(text, clamped_rate, rng)
 
     return _python_delete_random_words(
         text,
-        max_deletion_rate=max_deletion_rate,
+        rate=clamped_rate,
         rng=rng,
     )
 
@@ -86,17 +102,33 @@ class Rushmore(Glitchling):
     def __init__(
         self,
         *,
-        max_deletion_rate: float = 0.01,
+        rate: float | None = None,
+        max_deletion_rate: float | None = None,
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"max_deletion_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=max_deletion_rate,
+            default=0.01,
+            legacy_name="max_deletion_rate",
+        )
         super().__init__(
             name="Rushmore",
             corruption_function=delete_random_words,
             scope=AttackWave.WORD,
             seed=seed,
-            max_deletion_rate=max_deletion_rate,
+            rate=effective_rate,
         )
 
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        rate = self.kwargs.get("rate")
+        if rate is None:
+            rate = self.kwargs.get("max_deletion_rate")
+        if rate is None:
+            return None
+        return {"type": "delete", "max_deletion_rate": float(rate)}
+
 
 rushmore = Rushmore()
 

glitchlings/zoo/scannequin.py

@@ -1,8 +1,10 @@
 import re
 import random
+from typing import Any
 
 from ._ocr_confusions import load_confusion_table
 from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
 
 try:
     from glitchlings._zoo_rust import ocr_artifacts as _ocr_artifacts_rust
@@ -13,14 +15,14 @@ except ImportError:  # pragma: no cover - compiled extension not present
 def _python_ocr_artifacts(
     text: str,
     *,
-    error_rate: float,
+    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).
+    - rate: Max proportion of eligible confusion matches to replace (default 0.02).
     - seed: Optional seed if `rng` not provided.
     - rng: Optional RNG; overrides seed.
 
@@ -53,7 +55,7 @@ def _python_ocr_artifacts(
         return text
 
     # Decide how many to replace
-    k = int(len(candidates) * error_rate)
+    k = int(len(candidates) * rate)
     if k <= 0:
         return text
 
@@ -95,9 +97,11 @@ def _python_ocr_artifacts(
 
 def ocr_artifacts(
     text: str,
-    error_rate: float = 0.02,
+    rate: float | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    error_rate: float | None = None,
 ) -> str:
     """Introduce OCR-like artifacts into text.
 
@@ -107,13 +111,22 @@ def ocr_artifacts(
     if not text:
         return text
 
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=error_rate,
+        default=0.02,
+        legacy_name="error_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
 
+    clamped_rate = max(0.0, effective_rate)
+
     if _ocr_artifacts_rust is not None:
-        return _ocr_artifacts_rust(text, error_rate, rng)
+        return _ocr_artifacts_rust(text, clamped_rate, rng)
 
-    return _python_ocr_artifacts(text, error_rate=error_rate, rng=rng)
+    return _python_ocr_artifacts(text, rate=clamped_rate, rng=rng)
 
 
 class Scannequin(Glitchling):
@@ -122,18 +135,35 @@ class Scannequin(Glitchling):
     def __init__(
         self,
         *,
-        error_rate: float = 0.02,
+        rate: float | None = None,
+        error_rate: float | None = None,
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"error_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=error_rate,
+            default=0.02,
+            legacy_name="error_rate",
+        )
         super().__init__(
             name="Scannequin",
             corruption_function=ocr_artifacts,
             scope=AttackWave.CHARACTER,
             order=AttackOrder.LATE,
             seed=seed,
-            error_rate=error_rate,
+            rate=effective_rate,
         )
 
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        rate = self.kwargs.get("rate")
+        if rate is None:
+            rate = self.kwargs.get("error_rate")
+        if rate is None:
+            return None
+        return {"type": "ocr", "error_rate": float(rate)}
+
+
 
 scannequin = Scannequin()
 

glitchlings/zoo/typogre.py

@@ -5,6 +5,7 @@ import random
 from typing import Optional
 
 from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
 from ..util import KEYNEIGHBORS
 
 try:
@@ -88,11 +89,13 @@ def _python_draw_eligible_index(
 def _fatfinger_python(
     text: str,
     *,
-    max_change_rate: float,
+    rate: float,
     layout: dict[str, list[str]],
     rng: random.Random,
 ) -> str:
-    rate = max(0.0, max_change_rate)
+    if rate <= 0.0:
+        return text
+
     s = text
     max_changes = math.ceil(len(s) * rate)
     if max_changes == 0:
@@ -140,28 +143,37 @@ def _fatfinger_python(
 
 def fatfinger(
     text: str,
-    max_change_rate: float = 0.02,
+    rate: float | None = None,
     keyboard: str = "CURATOR_QWERTY",
     seed: int | None = None,
     rng: random.Random | None = None,
+    *,
+    max_change_rate: float | None = None,
 ) -> str:
     """Introduce character-level "fat finger" edits with a Rust fast path."""
 
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=max_change_rate,
+        default=0.02,
+        legacy_name="max_change_rate",
+    )
+
     if rng is None:
         rng = random.Random(seed)
     if not text:
         return ""
 
-    rate = max(0.0, max_change_rate)
-    if rate == 0.0:
+    clamped_rate = max(0.0, effective_rate)
+    if clamped_rate == 0.0:
         return text
 
     layout = getattr(KEYNEIGHBORS, keyboard)
 
     if _fatfinger_rust is not None:
-        return _fatfinger_rust(text, max_change_rate=rate, layout=layout, rng=rng)
+        return _fatfinger_rust(text, max_change_rate=clamped_rate, layout=layout, rng=rng)
 
-    return _fatfinger_python(text, max_change_rate=rate, layout=layout, rng=rng)
+    return _fatfinger_python(text, rate=clamped_rate, layout=layout, rng=rng)
 
 
 class Typogre(Glitchling):
@@ -170,17 +182,25 @@ class Typogre(Glitchling):
     def __init__(
         self,
         *,
-        max_change_rate: float = 0.02,
+        rate: float | None = None,
+        max_change_rate: float | None = None,
         keyboard: str = "CURATOR_QWERTY",
         seed: int | None = None,
     ) -> None:
+        self._param_aliases = {"max_change_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=max_change_rate,
+            default=0.02,
+            legacy_name="max_change_rate",
+        )
         super().__init__(
             name="Typogre",
             corruption_function=fatfinger,
             scope=AttackWave.CHARACTER,
             order=AttackOrder.EARLY,
             seed=seed,
-            max_change_rate=max_change_rate,
+            rate=effective_rate,
             keyboard=keyboard,
         )
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.2
+Version: 0.2.4
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -209,25 +209,21 @@ Project-URL: Homepage, https://github.com/osoleve/glitchlings
 Project-URL: Repository, https://github.com/osoleve/glitchlings.git
 Project-URL: Issues, https://github.com/osoleve/glitchlings/issues
 Project-URL: Changelog, https://github.com/osoleve/glitchlings/releases
-Keywords: nlp,text,adversarial augmentation,text augmentation
+Keywords: nlp,text,adversarial augmentation,text augmentation,large language models,llms,data augmentation,confusables,typo,
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Rust
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: confusable-homoglyphs>=3.3.1
-Requires-Dist: jellyfish>=1.2.0
 Provides-Extra: hf
 Requires-Dist: datasets>=4.0.0; extra == "hf"
 Provides-Extra: wordnet
@@ -235,6 +231,7 @@ Requires-Dist: nltk>=3.9.1; extra == "wordnet"
 Requires-Dist: numpy<=2.0,>=1.24; extra == "wordnet"
 Provides-Extra: prime
 Requires-Dist: verifiers>=0.1.3.post0; extra == "prime"
+Requires-Dist: jellyfish>=1.2.0; extra == "prime"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: hypothesis>=6.140.0; extra == "dev"
@@ -280,14 +277,16 @@ After all, what good is general intelligence if it can't handle a little chaos?
 pip install -U glitchlings
 ```
 
+> Glitchlings requires Python 3.10 or newer.
+
 ```python
 from glitchlings import Gaggle, SAMPLE_TEXT, Typogre, Mim1c, Reduple, Rushmore
 
 gaggle = Gaggle([
-    Typogre(max_change_rate=0.03),
-    Mim1c(replacement_rate=0.02),
+    Typogre(rate=0.03),
+    Mim1c(rate=0.02),
     Reduple(seed=404),
-    Rushmore(max_deletion_rate=0.02),
+    Rushmore(rate=0.02),
 ])
 
 print(gaggle(SAMPLE_TEXT))
@@ -295,41 +294,10 @@ 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.
 
-## Usage
-
-Need detailed usage patterns, dataset workflows, or tips for enabling the
-Rust accelerator? Consult the [Glitchlings Usage Guide](docs/index.md)
-for end-to-end instructions spanning the Python API, CLI, Hugging Face
+Consult the [Glitchlings Usage Guide](docs/index.md)
+for end-to-end instructions spanning the Python API, CLI, HuggingFace and Prime Intellect
 integrations, and the feature-flagged Rust pipeline.
 
-### Prime Intellect environments
-
-After `pip install -e .[prime]`, the `glitchlings.dlc.prime.load_environment` helper mirrors `verifiers.load_environment` for Prime Intellect scenarios while optionally applying glitchlings before returning the environment:
-
-```python
-from glitchlings import Mim1c, Typogre
-from glitchlings.dlc.prime import echo_chamber, load_environment
-
-env = load_environment(
-    "osoleve/syllabify-en",
-    glitchlings=[Mim1c(replacement_rate=0.01), Typogre(max_change_rate=0.02)],
-    seed=404,
-)
-
-# Spin up an echo chamber that corrupts a dataset column and
-# rewards models for perfectly restoring it
-practice_env = echo_chamber(
-    "osoleve/clean-room",
-    column="text",
-    glitchlings=["Typogre", "Mim1c"],
-    reward_function=lambda prompt, completion, answer: float(completion == answer),
-)
-```
-
-Skip the `glitchlings` argument to receive an untouched verifier dataset, and
-override `reward_function` when you want to evaluate completions with a custom
-scoring routine.
-
 ## Motivation
 
 If your model performs well on a particular task, but not when `Glitchling`s are present, it's a sign that it hasn't actually generalized to the problem.
@@ -344,8 +312,8 @@ Glitchlings are standard Python classes, so you can instantiate them with whatev
 ```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"])
+custom_typogre = Typogre(rate=0.1)
+selective_mimic = Mim1c(rate=0.05, classes=["LATIN", "GREEK"])
 
 gaggle = Gaggle([custom_typogre, selective_mimic], seed=99)
 print(gaggle("Summoned heroes do not fear the glitch."))
@@ -376,7 +344,7 @@ glitchlings --list
 glitchlings -g typogre --file documents/report.txt --diff
 
 # Configure glitchlings inline by passing keyword arguments.
-glitchlings -g "Typogre(max_change_rate=0.05)" "Ghouls just wanna have fun"
+glitchlings -g "Typogre(rate=0.05)" "Ghouls just wanna have fun"
 
 # Pipe text straight into the CLI for an on-the-fly corruption.
 echo "Beware LLM-written flavor-text" | glitchlings -g mim1c
@@ -400,7 +368,7 @@ _What a nice word, would be a shame if something happened to it._
 >
 > Args
 >
-> - `max_change_rate (float)`: The maximum number of edits to make as a percentage of the length (default: 0.02, 2%).
+> - `rate (float)`: The maximum number of edits to make as a percentage of the length (default: 0.02, 2%).
 > - `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).
 
@@ -412,7 +380,7 @@ _Wait, was that...?_
 >
 > Args
 >
-> - `replacement_rate (float)`: The maximum proportion of characters to replace (default: 0.02, 2%).
+> - `rate (float)`: The maximum proportion of characters to replace (default: 0.02, 2%).
 > - `classes (list[str] | "all")`: Restrict replacements to these Unicode script classes (default: ["LATIN", "GREEK", "CYRILLIC"]).
 > - `banned_characters (Collection[str])`: Characters that must never appear as replacements (default: none).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
@@ -425,7 +393,7 @@ _How can a computer need reading glasses?_
 >
 > Args
 >
-> - `error_rate (float)`: The maximum proportion of eligible confusion spans to replace (default: 0.02, 2%).
+> - `rate (float)`: The maximum proportion of eligible confusion spans to replace (default: 0.02, 2%).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Jargoyle
@@ -436,7 +404,7 @@ _Uh oh. The worst person you know just bought a thesaurus._
 >
 > Args
 >
-> - `replacement_rate (float)`: The maximum proportion of words to replace (default: 0.1, 10%).
+> - `rate (float)`: The maximum proportion of words to replace (default: 0.1, 10%).
 > - `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).
 
@@ -448,7 +416,7 @@ _Did you say that or did I?_
 >
 > Args
 >
-> - `reduplication_rate (float)`: The maximum proportion of words to reduplicate (default: 0.05, 5%).
+> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.05, 5%).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Rushmore
@@ -459,7 +427,7 @@ _I accidentally an entire word._
 >
 > Args
 >
-> - `max_deletion_rate (float)`: The maximum proportion of words to delete (default: 0.01, 1%).
+> - `rate (float)`: The maximum proportion of words to delete (default: 0.01, 1%).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Redactyl
@@ -471,7 +439,7 @@ _Oops, that was my black highlighter._
 > ### Args
 >
 > - `replacement_char (str)`: The character to use for redaction (default: █).
-> - `redaction_rate (float)`: The maximum proportion of words to redact (default: 0.05, 5%).
+> - `rate (float)`: The maximum proportion of words to redact (default: 0.05, 5%).
 > - `merge_adjacent (bool)`: Whether to redact the space between adjacent redacted words (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 

glitchlings-0.2.4.dist-info/RECORD

@@ -0,0 +1,26 @@
+glitchlings/__init__.py,sha256=w8heFqUejrXM_9NNlM9CQnIGkmGUyBV29acg3WsocXA,622
+glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
+glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=qHk8hPmRrzJTwOyhcBNr-2qhXBaEBUy__7_SMFhzWSc,1989632
+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/_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/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-0.2.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-glitchlings/__init__.py,sha256=w8heFqUejrXM_9NNlM9CQnIGkmGUyBV29acg3WsocXA,622
-glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
-glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=Eh4tD2b4ym3zX0KWxVWCFRpmPsZFnyeOiFWr_qQGg5A,1989632
-glitchlings/main.py,sha256=krujz3GBrdP6FU3O6Z9f3rvc444rT79Hm69zAPG3b-U,6160
-glitchlings/dlc/__init__.py,sha256=IHD-GGhVFb7SVzErvf2YCJkOR4wGo0nFHXkn_daMvS8,146
-glitchlings/dlc/huggingface.py,sha256=PIesnDIEvyJxj1IuLw2P9nVPTr4Nv81XM7w2axfyhkA,3029
-glitchlings/dlc/prime.py,sha256=oKVAVWSD-aa-LqDsctSLXzq0JW2RaIc1l2859ogr4lY,8107
-glitchlings/util/__init__.py,sha256=GoyQuHTfGRkHzuZwJji6QWSiGd_LHa9QiyjjEpBFW7E,4679
-glitchlings/zoo/__init__.py,sha256=kYKKlNvEwKtrD26E1hfde33rkN83CMf_h5AQFGjQyBQ,4312
-glitchlings/zoo/_ocr_confusions.py,sha256=W59Aa5MBDwRF65f8GV-6XwGAmlR5Uk7pa5qvHvhIYdY,1252
-glitchlings/zoo/core.py,sha256=aGGc0M97QeKM5rsQjTZs3fhIVac0g8A72mW4u72YnD0,14373
-glitchlings/zoo/jargoyle.py,sha256=TBzt9CFL5GBP_DjqKqUY54DFsX2VAU4LnBNMDIg7P-Y,10444
-glitchlings/zoo/mim1c.py,sha256=YHFELu3fpY_9VxRavYfCoAWZYp-HZBXdiLk4DTKdqcY,2979
-glitchlings/zoo/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
-glitchlings/zoo/redactyl.py,sha256=VV2mPE2WQ41Sl874TjaHu9ShhYlFNLI7embQqKM5_ZE,3738
-glitchlings/zoo/reduple.py,sha256=WuMpmuZrf5x7JneiRjDF2Y0beEAn7j1DPCV2BuuTuRY,2873
-glitchlings/zoo/rushmore.py,sha256=dAiv53B_6Zg-zNG5aW8YobJevyBV586HtJVlZqgcGR8,2790
-glitchlings/zoo/scannequin.py,sha256=BLJ8VFNTrXxv6mKjTMPUHOqziXO-NLpKNQNPbxG7jLI,4178
-glitchlings/zoo/typogre.py,sha256=CISk0aqI8y5SdZXibqhfP0cu5MZ7TkiOQ7kftqW9RtI,5680
-glitchlings-0.2.2.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.2.2.dist-info/METADATA,sha256=mRSQQoNoQAPmmVzfUn6ZZLHL1I6n5wxr45o3DyWsSMw,27811
-glitchlings-0.2.2.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-glitchlings-0.2.2.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.2.2.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.2.2.dist-info/RECORD,,