glitchlings 0.2.6__cp310-cp310-manylinux_2_28_x86_64.whl → 0.3.0__cp310-cp310-manylinux_2_28_x86_64.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/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

@@ -59,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]
 
 
@@ -233,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]

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,14 +82,8 @@ 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))
+        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:
@@ -105,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.6.dist-info → glitchlings-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.6
+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
@@ -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.2.6.dist-info → glitchlings-0.3.0.dist-info}/RECORD

@@ -1,27 +1,29 @@
-glitchlings/__init__.py,sha256=ui8kzf7mK5YAlFY1Og5UX5Rp14v4wC2ZqHihAJBBj6s,632
+glitchlings/__init__.py,sha256=BLwp5ncEEVTurUDEo6DZcYjYz7r12LzblLfOcVc4MEU,680
 glitchlings/__main__.py,sha256=EOiBgay0x6B9VlSDzSQvMuoq6bHJdSvFSgcAVGGKkd4,121
-glitchlings/_zoo_rust.cpython-310-x86_64-linux-gnu.so,sha256=hNoaFhJbKFM9bOvj-JSSUb_worfI2-YsTVD6PLsHtN4,3158312
+glitchlings/_zoo_rust.cpython-310-x86_64-linux-gnu.so,sha256=ES5PTbdW3auzJV6ADNITU_-M4KodYFTJvtjOh8GvviQ,3164328
 glitchlings/main.py,sha256=u6969Vl0n47e3S-ZlYZBj3HWVsjs-hvW6RpF9RYuXnc,5931
 glitchlings/dlc/__init__.py,sha256=eTLEEWrVWPqniXHqee4W23H1rjElI1PQ_jcqWFe9D3g,141
 glitchlings/dlc/huggingface.py,sha256=I1QWanWVxO02awgSpHDtgQEVF-9AQRLtsta2RCitWhE,2933
 glitchlings/dlc/prime.py,sha256=wpRMNtgka1vNlEzifeCjGMp1q_-QclZn3NxXczGnNpM,9278
 glitchlings/util/__init__.py,sha256=7KiZ0gKMjocfd34cajneZhTqYb7Hkwi_PpjltPqvkNI,4498
-glitchlings/zoo/__init__.py,sha256=pdQSiQjMCqnhrM3qSRvu98FJd-EyXLNNwvthnYSXpmM,4282
+glitchlings/zoo/__init__.py,sha256=sTmh-1u02kgjYlpRPz9lF9c1aXHamcShRXUOGK87J5Q,4378
 glitchlings/zoo/_ocr_confusions.py,sha256=MkCbwk9T24SO2pD3JNPajYCfpMMlm2vQ5_sJty5GoXE,1218
 glitchlings/zoo/_rate.py,sha256=TMyfVFV7pLxSGVswPlOAtBvk25Bjtx5xXTtpb_utgik,527
-glitchlings/zoo/core.py,sha256=xLF9Op07KtMH0ql1-O7KyZ6lLESsdeNkvxdyiSOzhAc,14236
+glitchlings/zoo/_text_utils.py,sha256=ZXy5khgoMTZp7NHdekkkj4vQjeMWGK2bzXPwIECBIfo,1120
+glitchlings/zoo/adjax.py,sha256=N3CzfM7m7mAYgFcQYLQkqK2VYLw_vFvEMBM2aNU--ZA,3530
+glitchlings/zoo/core.py,sha256=fhceCZKa9W1vVlhpR2zVKBXnzgJICB2-nmDywiqx4js,14207
 glitchlings/zoo/jargoyle.py,sha256=T6vPWBxceIPE6gOQ7BaihaqALOJwzXuhfiZzvKa4S50,10666
 glitchlings/zoo/mim1c.py,sha256=yAt1ngR3j2KXLbzc8LhrQlIWRO_KT5dFK1EE8QivMAQ,3429
 glitchlings/zoo/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
-glitchlings/zoo/redactyl.py,sha256=wn7hxbtA0xMRuIXa6NNeeNOi0h0S8vh2bAa3x5Ec_Y0,6783
-glitchlings/zoo/reduple.py,sha256=YNhTBH25XsXLeQD8xxXPE_JJMiCtmEpUFGGn36rd2tY,4857
-glitchlings/zoo/rushmore.py,sha256=oG8MmMbrpmHH4rOp-NXkQznVlBCtSnrOttAZMdVlMkc,4729
+glitchlings/zoo/redactyl.py,sha256=8xsamnVt1RFy7ztvfgfJDwCadQIlN-9fDz-TLfBQ89k,6357
+glitchlings/zoo/reduple.py,sha256=IQM0WYinWJWjMIaBSuPPcpOXOynly9Tp2UtJEZxibGk,4313
+glitchlings/zoo/rushmore.py,sha256=Cw6qpk3jp8DjtxmFALd5zTIOnS6C0tIkoPFA7F-xlVk,4369
 glitchlings/zoo/scannequin.py,sha256=Ps8nxysKjkJV408zaL1kjVjy4jliATDBpYcNHLWbNFg,4859
 glitchlings/zoo/typogre.py,sha256=xD02ldcMIA07XsdSts2bUniOc-k_DqTf0PBMaXGjLZE,6009
 glitchlings/zoo/zeedub.py,sha256=D6rGk3O02OQ9jEIO9o0Ag-maVzNPN5O6qO3klG6Y62c,3552
-glitchlings-0.2.6.dist-info/METADATA,sha256=5Xg6w5_-87bIRXY51i-nd7EmJMVPLtcBH_V3tj74CWI,26749
-glitchlings-0.2.6.dist-info/WHEEL,sha256=yzF9ixp0XVYLhnovZSdud9vspTPdVe52BzwI7Tv3jTM,113
-glitchlings-0.2.6.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.2.6.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.2.6.dist-info/RECORD,,
-glitchlings-0.2.6.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.3.0.dist-info/METADATA,sha256=iflxCI-vHtZP-omUePVGqx0QHLoFiJoHzcM7aSNvboQ,27579
+glitchlings-0.3.0.dist-info/WHEEL,sha256=yzF9ixp0XVYLhnovZSdud9vspTPdVe52BzwI7Tv3jTM,113
+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.3.0.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337