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

glitchlings/__init__.py

@@ -5,6 +5,8 @@ from .zoo import (
     mim1c,
     Jargoyle,
     jargoyle,
+    Adjax,
+    adjax,
     Redactyl,
     redactyl,
     Reduple,
@@ -29,6 +31,8 @@ __all__ = [
     "mim1c",
     "Jargoyle",
     "jargoyle",
+    "Adjax",
+    "adjax",
     "Redactyl",
     "redactyl",
     "Reduple",

glitchlings/dlc/prime.py

@@ -49,7 +49,24 @@ def _resolve_columns(dataset: Dataset, columns: Sequence[str] | None) -> list[st
         if candidate in available:
             return [candidate]
 
-    sample = dataset[0] if len(dataset) else {}
+    try:
+        dataset_length = len(dataset)  # type: ignore[arg-type]
+    except TypeError:
+        preview_rows: list[dict[str, Any]]
+        take_fn = getattr(dataset, "take", None)
+        if callable(take_fn):
+            preview_rows = list(take_fn(1))
+        else:
+            iterator = iter(dataset)
+            try:
+                first_row = next(iterator)
+            except StopIteration:
+                preview_rows = []
+            else:
+                preview_rows = [first_row]
+        sample = dict(preview_rows[0]) if preview_rows else {}
+    else:
+        sample = dataset[0] if dataset_length else {}
     inferred = [
         name
         for name in dataset.column_names

glitchlings/zoo/__init__.py

@@ -6,6 +6,7 @@ from typing import Any
 from .typogre import Typogre, typogre
 from .mim1c import Mim1c, mim1c
 from .jargoyle import Jargoyle, jargoyle, dependencies_available as _jargoyle_available
+from .adjax import Adjax, adjax
 from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
@@ -20,6 +21,8 @@ __all__ = [
     "mim1c",
     "Jargoyle",
     "jargoyle",
+    "Adjax",
+    "adjax",
     "Reduple",
     "reduple",
     "Rushmore",
@@ -43,7 +46,7 @@ _HAS_JARGOYLE = _jargoyle_available()
 _BUILTIN_GLITCHLING_LIST: list[Glitchling] = [typogre, mim1c]
 if _HAS_JARGOYLE:
     _BUILTIN_GLITCHLING_LIST.append(jargoyle)
-_BUILTIN_GLITCHLING_LIST.extend([reduple, rushmore, redactyl, scannequin, zeedub])
+_BUILTIN_GLITCHLING_LIST.extend([adjax, reduple, rushmore, redactyl, scannequin, zeedub])
 
 BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
     glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
@@ -52,6 +55,7 @@ BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
 _BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
     typogre.name.lower(): Typogre,
     mim1c.name.lower(): Mim1c,
+    adjax.name.lower(): Adjax,
     reduple.name.lower(): Reduple,
     rushmore.name.lower(): Rushmore,
     redactyl.name.lower(): Redactyl,

glitchlings/zoo/_text_utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+
+_WORD_SPLIT_PATTERN = re.compile(r"(\s+)")
+_TOKEN_EDGES_PATTERN = re.compile(r"^(\W*)(.*?)(\W*)$")
+
+
+def split_preserving_whitespace(text: str) -> list[str]:
+    """Split text while keeping whitespace tokens for stable reconstruction."""
+
+    return _WORD_SPLIT_PATTERN.split(text)
+
+
+def split_token_edges(token: str) -> tuple[str, str, str]:
+    """Return leading, core, and trailing segments for a token."""
+
+    match = _TOKEN_EDGES_PATTERN.match(token)
+    if match is None:
+        return "", token, ""
+    return match.group(1), match.group(2), match.group(3)
+
+
+def token_core_length(token: str) -> int:
+    """Return the length of the main word characters for weighting heuristics."""
+
+    _, core, _ = split_token_edges(token)
+    candidate = core if core else token
+    length = len(candidate)
+    if length <= 0:
+        stripped = token.strip()
+        length = len(stripped) if stripped else len(token)
+    if length <= 0:
+        length = 1
+    return length
+
+
+__all__ = [
+    "split_preserving_whitespace",
+    "split_token_edges",
+    "token_core_length",
+]

glitchlings/zoo/adjax.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from ._rate import resolve_rate
+from ._text_utils import split_preserving_whitespace, split_token_edges
+from .core import AttackWave, Glitchling
+
+try:
+    from glitchlings._zoo_rust import swap_adjacent_words as _swap_adjacent_words_rust
+except ImportError:  # pragma: no cover - optional acceleration
+    _swap_adjacent_words_rust = None
+
+
+def _python_swap_adjacent_words(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+) -> str:
+    """Swap the cores of adjacent words while keeping affixes and spacing intact."""
+
+    tokens = split_preserving_whitespace(text)
+    if len(tokens) < 2:
+        return text
+
+    word_indices: list[int] = []
+    for index in range(len(tokens)):
+        token = tokens[index]
+        if not token or token.isspace():
+            continue
+        if index % 2 == 0:
+            word_indices.append(index)
+
+    if len(word_indices) < 2:
+        return text
+
+    clamped = max(0.0, min(rate, 1.0))
+    if clamped <= 0.0:
+        return text
+
+    for cursor in range(0, len(word_indices) - 1, 2):
+        left_index = word_indices[cursor]
+        right_index = word_indices[cursor + 1]
+
+        left_token = tokens[left_index]
+        right_token = tokens[right_index]
+
+        left_prefix, left_core, left_suffix = split_token_edges(left_token)
+        right_prefix, right_core, right_suffix = split_token_edges(right_token)
+
+        if not left_core or not right_core:
+            continue
+
+        should_swap = clamped >= 1.0 or rng.random() < clamped
+        if not should_swap:
+            continue
+
+        tokens[left_index] = f"{left_prefix}{right_core}{left_suffix}"
+        tokens[right_index] = f"{right_prefix}{left_core}{right_suffix}"
+
+    return "".join(tokens)
+
+
+def swap_adjacent_words(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    swap_rate: float | None = None,
+) -> str:
+    """Swap adjacent word cores while preserving spacing and punctuation."""
+
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=swap_rate,
+        default=0.5,
+        legacy_name="swap_rate",
+    )
+    clamped_rate = max(0.0, min(effective_rate, 1.0))
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _swap_adjacent_words_rust is not None:
+        return _swap_adjacent_words_rust(text, clamped_rate, rng)
+
+    return _python_swap_adjacent_words(text, rate=clamped_rate, rng=rng)
+
+
+class Adjax(Glitchling):
+    """Glitchling that swaps adjacent words to scramble local semantics."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        swap_rate: float | None = None,
+        seed: int | None = None,
+    ) -> None:
+        self._param_aliases = {"swap_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=swap_rate,
+            default=0.5,
+            legacy_name="swap_rate",
+        )
+        super().__init__(
+            name="Adjax",
+            corruption_function=swap_adjacent_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            rate=effective_rate,
+        )
+
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        rate = self.kwargs.get("rate")
+        if rate is None:
+            return None
+        return {
+            "type": "swap_adjacent",
+            "swap_rate": float(rate),
+        }
+
+
+adjax = Adjax()
+
+
+__all__ = ["Adjax", "adjax", "swap_adjacent_words"]

glitchlings/zoo/core.py

@@ -27,17 +27,25 @@ log = logging.getLogger(__name__)
 
 
 _PIPELINE_FEATURE_FLAG_ENV = "GLITCHLINGS_RUST_PIPELINE"
+_PIPELINE_ENABLE_VALUES = {"1", "true", "yes", "on"}
+_PIPELINE_DISABLE_VALUES = {"0", "false", "no", "off"}
 
 
 def _pipeline_feature_flag_enabled() -> bool:
-    """Return ``True`` when the environment explicitly opts into the Rust pipeline."""
+    """Return ``True`` when the environment does not explicitly disable the Rust pipeline."""
 
     value = os.environ.get(_PIPELINE_FEATURE_FLAG_ENV)
     if value is None:
-        return False
+        return True
 
     normalized = value.strip().lower()
-    return normalized in {"1", "true", "yes", "on"}
+    if normalized in _PIPELINE_DISABLE_VALUES:
+        return False
+
+    if normalized in _PIPELINE_ENABLE_VALUES:
+        return True
+
+    return True
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from datasets import Dataset  # type: ignore
@@ -51,18 +59,26 @@ else:
         def with_transform(self, function: Any) -> "Dataset": ...
 
 
-def _is_transcript(value: Any) -> bool:
-    """Return True when the value resembles a chat transcript."""
+def _is_transcript(
+    value: Any,
+    *,
+    allow_empty: bool = True,
+    require_all_content: bool = False,
+) -> bool:
+    """Return `True` when `value` appears to be a chat transcript."""
 
     if not isinstance(value, list):
         return False
 
     if not value:
-        return True
+        return allow_empty
 
     if not all(isinstance(turn, dict) for turn in value):
         return False
 
+    if require_all_content:
+        return all("content" in turn for turn in value)
+
     return "content" in value[-1]
 
 
@@ -225,21 +241,15 @@ class Glitchling:
             message = "datasets is not installed"
             raise ModuleNotFoundError(message) from _datasets_error
 
-        def _is_transcript(value: Any) -> bool:
-            """Return ``True`` when the value resembles a chat transcript."""
-
-            if not isinstance(value, list) or not value:
-                return False
-
-            return all(
-                isinstance(turn, dict) and "content" in turn for turn in value
-            )
-
         def __corrupt_row(row: dict[str, Any]) -> dict[str, Any]:
             row = dict(row)
             for column in columns:
                 value = row[column]
-                if _is_transcript(value):
+                if _is_transcript(
+                    value,
+                    allow_empty=False,
+                    require_all_content=True,
+                ):
                     row[column] = self.corrupt(value)
                 elif isinstance(value, list):
                     row[column] = [self.corrupt(item) for item in value]
@@ -356,7 +366,7 @@ class Gaggle(Glitchling):
 
     @staticmethod
     def rust_pipeline_enabled() -> bool:
-        """Return ``True`` when the Rust pipeline is available and opted in."""
+        """Return ``True`` when the Rust pipeline is available and not explicitly disabled."""
 
         return Gaggle.rust_pipeline_supported() and _pipeline_feature_flag_enabled()
 

glitchlings/zoo/redactyl.py

@@ -2,8 +2,13 @@ import re
 import random
 from typing import Any
 
-from .core import Glitchling, AttackWave
 from ._rate import resolve_rate
+from ._text_utils import (
+    split_preserving_whitespace,
+    split_token_edges,
+    token_core_length,
+)
+from .core import AttackWave, Glitchling
 
 FULL_BLOCK = "█"
 
@@ -68,8 +73,7 @@ def _python_redact_words(
     - rng: RNG used for sampling decisions.
     - unweighted: When True, sample words uniformly instead of by length.
     """
-    # Preserve exact spacing and punctuation by using regex
-    tokens = re.split(r"(\s+)", text)
+    tokens = split_preserving_whitespace(text)
     word_indices = [i for i, token in enumerate(tokens) if i % 2 == 0 and token.strip()]
     if not word_indices:
         raise ValueError(
@@ -78,15 +82,12 @@ def _python_redact_words(
     weights: list[float] = []
     for index in word_indices:
         word = tokens[index]
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        core = match.group(2) if match else word
-        core_length = len(core) if core else len(word)
-        if core_length <= 0:
-            core_length = len(word.strip()) or len(word)
-        if core_length <= 0:
-            core_length = 1
-        weights.append(1.0 if unweighted else float(core_length))
-    num_to_redact = max(1, int(len(word_indices) * rate))
+        length = token_core_length(word)
+        weights.append(1.0 if unweighted else float(length))
+    raw_quota = len(word_indices) * rate
+    num_to_redact = int(raw_quota)
+    if rate > 0:
+        num_to_redact = max(1, num_to_redact)
     if num_to_redact > len(word_indices):
         raise ValueError("Sample larger than population or is negative")
     indices_to_redact = _weighted_sample_without_replacement(
@@ -102,16 +103,11 @@ def _python_redact_words(
             break
 
         word = tokens[i]
-        if not word or word.isspace():  # Skip empty or whitespace
+        if not word or word.isspace():
             continue
 
-        # Check if word has trailing punctuation
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        if match:
-            prefix, core, suffix = match.groups()
-            tokens[i] = f"{prefix}{replacement_char * len(core)}{suffix}"
-        else:
-            tokens[i] = f"{replacement_char * len(word)}"
+        prefix, core, suffix = split_token_edges(word)
+        tokens[i] = f"{prefix}{replacement_char * len(core)}{suffix}"
 
     text = "".join(tokens)
 

glitchlings/zoo/reduple.py

@@ -1,9 +1,13 @@
-import re
 import random
 from typing import Any
 
-from .core import Glitchling, AttackWave
 from ._rate import resolve_rate
+from ._text_utils import (
+    split_preserving_whitespace,
+    split_token_edges,
+    token_core_length,
+)
+from .core import AttackWave, Glitchling
 
 try:
     from glitchlings._zoo_rust import reduplicate_words as _reduplicate_words_rust
@@ -30,26 +34,16 @@ def _python_reduplicate_words(
     - Preserves spacing and punctuation by tokenizing with separators.
     - Deterministic when run with a fixed seed or via Gaggle.
     """
-    # Preserve exact spacing and punctuation by using regex
-    tokens = re.split(r"(\s+)", text)  # Split but keep separators
+    tokens = split_preserving_whitespace(text)
 
     candidate_weights: list[tuple[int, float]] = []
-    for i in range(0, len(tokens), 2):  # Every other token is a word
-        if i >= len(tokens):
-            break
-
+    for i in range(0, len(tokens), 2):
         word = tokens[i]
-        if not word or word.isspace():  # Skip empty or whitespace
+        if not word or word.isspace():
             continue
 
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        core = match.group(2) if match else word
-        core_length = len(core) if core else len(word)
-        if core_length <= 0:
-            core_length = len(word.strip()) or len(word)
-        if core_length <= 0:
-            core_length = 1
-        weight = 1.0 if unweighted else 1.0 / core_length
+        length = token_core_length(word)
+        weight = 1.0 if unweighted else 1.0 / length
         candidate_weights.append((i, weight))
 
     if not candidate_weights:
@@ -75,13 +69,8 @@ def _python_reduplicate_words(
             continue
 
         word = tokens[index]
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        if match:
-            prefix, core, suffix = match.groups()
-            # Reduplicate with a space: "word" -> "word word"
-            tokens[index] = f"{prefix}{core} {core}{suffix}"
-        else:
-            tokens[index] = f"{word} {word}"
+        prefix, core, suffix = split_token_edges(word)
+        tokens[index] = f"{prefix}{core} {core}{suffix}"
     return "".join(tokens)
 
 

glitchlings/zoo/rushmore.py

@@ -3,8 +3,13 @@ import random
 import re
 from typing import Any
 
-from .core import Glitchling, AttackWave
 from ._rate import resolve_rate
+from ._text_utils import (
+    split_preserving_whitespace,
+    split_token_edges,
+    token_core_length,
+)
+from .core import AttackWave, Glitchling
 
 try:
     from glitchlings._zoo_rust import delete_random_words as _delete_random_words_rust
@@ -25,22 +30,16 @@ def _python_delete_random_words(
     if effective_rate <= 0.0:
         return text
 
-    tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
+    tokens = split_preserving_whitespace(text)
 
     candidate_data: list[tuple[int, float]] = []
-    for i in range(2, len(tokens), 2):  # Every other token is a word, skip the first word
+    for i in range(2, len(tokens), 2):
         word = tokens[i]
         if not word or word.isspace():
             continue
 
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        core = match.group(2) if match else word
-        core_length = len(core) if core else len(word)
-        if core_length <= 0:
-            core_length = len(word.strip()) or len(word)
-        if core_length <= 0:
-            core_length = 1
-        weight = 1.0 if unweighted else 1.0 / core_length
+        length = token_core_length(word)
+        weight = 1.0 if unweighted else 1.0 / length
         candidate_data.append((i, weight))
 
     if not candidate_data:
@@ -70,12 +69,8 @@ def _python_delete_random_words(
             continue
 
         word = tokens[index]
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        if match:
-            prefix, _, suffix = match.groups()
-            tokens[index] = f"{prefix.strip()}{suffix.strip()}"
-        else:
-            tokens[index] = ""
+        prefix, _, suffix = split_token_edges(word)
+        tokens[index] = f"{prefix.strip()}{suffix.strip()}"
 
         deletions += 1
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.5
+Version: 0.3.0
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -209,7 +209,7 @@ 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,large language models,llms,data augmentation,confusables,typo,
+Keywords: nlp,text,adversarial augmentation,text augmentation,large language models,llms,data augmentation,rlvr
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
@@ -296,7 +296,7 @@ print(gaggle(SAMPLE_TEXT))
 
 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.
+integrations, and the autodetected Rust pipeline (enabled whenever the extension is present).
 
 ## Motivation
 
@@ -428,7 +428,8 @@ _Did you say that or did I?_
 >
 > Args
 >
-> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.05, 5%).
+> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Rushmore
@@ -440,6 +441,19 @@ _I accidentally an entire word._
 > Args
 >
 > - `rate (float)`: The maximum proportion of words to delete (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
+> - `seed (int)`: The random seed for reproducibility (default: 151).
+
+### Adjax
+
+_Keep your hands and punctuation where I can see them._
+
+> _**Perfect Shuffle.**_ Adjax trades the cores of neighbouring words while leaving punctuation, casing, and surrounding whitespace untouched, turning fluent prose into locally scrambled tongue-twisters.
+>
+> Args
+>
+> - `rate (float)`: Probability that each adjacent pair swaps cores (default: 0.5, 50%).
+> - `swap_rate (float)`: Alias for `rate`, retained for backward compatibility.
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Redactyl
@@ -450,9 +464,10 @@ _Oops, that was my black highlighter._
 >
 > ### Args
 >
-> - `replacement_char (str)`: The character to use for redaction (default: █).
-> - `rate (float)`: The maximum proportion of words to redact (default: 0.05, 5%).
+> - `replacement_char (str)`: The character to use for redaction (default: FULL_BLOCK).
+> - `rate (float)`: The maximum proportion of words to redact (default: 0.025, 2.5%).
 > - `merge_adjacent (bool)`: Whether to redact the space between adjacent redacted words (default: False).
+> - `unweighted (bool)`: Sample words uniformly instead of biasing toward longer tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ## Field Report: Uncontained Specimens

glitchlings-0.3.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+glitchlings/__init__.py,sha256=lqzYzB1RdQnw-NpWXN2dtcEGDkQ-OkC2OTEL16HDMYc,730
+glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
+glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=AW-mnIw4O-B53whfrlhwNRB-OEAssSdgnSJEUfjxZvc,2024960
+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=b5CE1qDl5MxZjTudlKrqMsmSGxXNKZ16krqPyrr2nK8,9569
+glitchlings/util/__init__.py,sha256=GoyQuHTfGRkHzuZwJji6QWSiGd_LHa9QiyjjEpBFW7E,4679
+glitchlings/zoo/__init__.py,sha256=LryHn930FuEdKRyvtRu7breBvz9IYYTvJv7yGIxLd5Y,4520
+glitchlings/zoo/_ocr_confusions.py,sha256=W59Aa5MBDwRF65f8GV-6XwGAmlR5Uk7pa5qvHvhIYdY,1252
+glitchlings/zoo/_rate.py,sha256=EYUWXYyR2IK0zYBWyBOlnUjDxU32JE9mZTZeodVx5CA,548
+glitchlings/zoo/_text_utils.py,sha256=pul6iGtVWir4mX-Mq5ni06JFOzf6x3J82iYSICXJCGE,1162
+glitchlings/zoo/adjax.py,sha256=G2diAEsQ8T4mjFCcTeiGzLF0261n7LjLyW5HyVCy3R4,3661
+glitchlings/zoo/core.py,sha256=sK3F1OVifbzQFsDrG-pQIImcGP7YfccwTfbqFTJi8Fc,14622
+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=poBzhXtApDa55G7iVCGEM4v1_YSYh3LfEAp2fkVFIJ4,6579
+glitchlings/zoo/reduple.py,sha256=orgS3ajpuGTDN-QqGuYgfkEI7yVCgIXHtL_HHp8jGmE,4471
+glitchlings/zoo/rushmore.py,sha256=rUluMdjvSxaVlUfK9_N0F108O5Exoa4klWLumrV2CgA,4535
+glitchlings/zoo/scannequin.py,sha256=TJyNYTTIB7rxZH3XKIETy0YVf4EjsMgGWYmYaxH9jxU,5030
+glitchlings/zoo/typogre.py,sha256=olTTXDmFkVQ3r-T1vxm2mLomRvIDXHrNHfgin316wzE,6221
+glitchlings/zoo/zeedub.py,sha256=n1qTKE_Dl0m8SEKhaP91oHAyJ484NxaGLPu_ZLr0Ldo,3696
+glitchlings-0.3.0.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
+glitchlings-0.3.0.dist-info/METADATA,sha256=b9uWb19S04moT94a_onQBjurDfBHJulwIW4R2ep84mE,28084
+glitchlings-0.3.0.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+glitchlings-0.3.0.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.3.0.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.3.0.dist-info/RECORD,,

glitchlings-0.2.5.dist-info/RECORD

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