glitchlings 0.5.0__cp313-cp313-macosx_11_0_universal2.whl → 0.5.1__cp313-cp313-macosx_11_0_universal2.whl

glitchlings/zoo/ekkokin.py

@@ -0,0 +1,226 @@
+"""Homophone substitution glitchling implementation."""
+
+from __future__ import annotations
+
+import math
+import random
+from typing import Any, Iterable, Mapping, Sequence, cast
+
+from ._rust_extensions import get_rust_operation
+from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
+from .assets import load_homophone_groups
+from .core import AttackOrder, AttackWave, Glitchling
+
+_DEFAULT_RATE = 0.02
+_DEFAULT_WEIGHTING = "flat"
+_VALID_WEIGHTINGS = {_DEFAULT_WEIGHTING}
+
+_homophone_groups: tuple[tuple[str, ...], ...] = load_homophone_groups()
+
+
+def _normalise_group(group: Sequence[str]) -> tuple[str, ...]:
+    """Return a tuple of lowercase homophones preserving original order."""
+
+    # Use dict.fromkeys to preserve the original ordering while de-duplicating.
+    return tuple(dict.fromkeys(word.lower() for word in group if word))
+
+
+def _build_lookup(groups: Iterable[Sequence[str]]) -> Mapping[str, tuple[str, ...]]:
+    """Return a mapping from word -> homophone group."""
+
+    lookup: dict[str, tuple[str, ...]] = {}
+    for group in groups:
+        normalised = _normalise_group(group)
+        if len(normalised) < 2:
+            continue
+        for word in normalised:
+            lookup[word] = normalised
+    return lookup
+
+
+_homophone_lookup = _build_lookup(_homophone_groups)
+_ekkokin_rust = get_rust_operation("ekkokin_homophones")
+
+
+def _normalise_weighting(weighting: str | None) -> str:
+    if weighting is None:
+        return _DEFAULT_WEIGHTING
+    lowered = weighting.lower()
+    if lowered not in _VALID_WEIGHTINGS:
+        options = ", ".join(sorted(_VALID_WEIGHTINGS))
+        raise ValueError(f"Unsupported weighting '{weighting}'. Expected one of: {options}")
+    return lowered
+
+
+def _apply_casing(template: str, candidate: str) -> str:
+    """Return ``candidate`` adjusted to mirror the casing pattern of ``template``."""
+
+    if not candidate:
+        return candidate
+    if template.isupper():
+        return candidate.upper()
+    if template.islower():
+        return candidate.lower()
+    if template[:1].isupper() and template[1:].islower():
+        return candidate.capitalize()
+    return candidate
+
+
+def _choose_alternative(
+    *,
+    group: Sequence[str],
+    source_word: str,
+    weighting: str,
+    rng: random.Random,
+) -> str | None:
+    """Return a replacement for ``source_word`` drawn from ``group``."""
+
+    del weighting  # Reserved for future weighting strategies.
+    lowered = source_word.lower()
+    candidates = [candidate for candidate in group if candidate != lowered]
+    if not candidates:
+        return None
+    index = rng.randrange(len(candidates))
+    replacement = candidates[index]
+    return _apply_casing(source_word, replacement)
+
+
+def _python_substitute_homophones(
+    text: str,
+    *,
+    rate: float,
+    weighting: str,
+    rng: random.Random,
+) -> str:
+    """Replace words in ``text`` with curated homophones."""
+
+    if not text:
+        return text
+
+    if math.isnan(rate):
+        return text
+
+    clamped_rate = max(0.0, min(1.0, rate))
+    if clamped_rate <= 0.0:
+        return text
+
+    tokens = split_preserving_whitespace(text)
+    word_tokens = collect_word_tokens(tokens)
+    if not word_tokens:
+        return text
+
+    mutated = False
+    for token in word_tokens:
+        replacement = _maybe_replace_token(token, clamped_rate, weighting, rng)
+        if replacement is None:
+            continue
+        tokens[token.index] = replacement
+        mutated = True
+
+    if not mutated:
+        return text
+    return "".join(tokens)
+
+
+def _maybe_replace_token(
+    token: WordToken,
+    rate: float,
+    weighting: str,
+    rng: random.Random,
+) -> str | None:
+    lookup = _homophone_lookup.get(token.core.lower())
+    if lookup is None:
+        return None
+    if rng.random() >= rate:
+        return None
+    replacement_core = _choose_alternative(
+        group=lookup,
+        source_word=token.core,
+        weighting=weighting,
+        rng=rng,
+    )
+    if replacement_core is None:
+        return None
+    return f"{token.prefix}{replacement_core}{token.suffix}"
+
+
+def substitute_homophones(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    weighting: str | None = None,
+) -> str:
+    """Replace words in ``text`` with curated homophones."""
+
+    effective_rate = _DEFAULT_RATE if rate is None else rate
+    normalized_weighting = _normalise_weighting(weighting)
+
+    active_rng = rng if rng is not None else random.Random(seed)
+
+    clamped_rate = 0.0 if math.isnan(effective_rate) else max(0.0, min(1.0, effective_rate))
+    if _ekkokin_rust is not None:
+        return cast(
+            str,
+            _ekkokin_rust(text, clamped_rate, normalized_weighting, active_rng),
+        )
+    return _python_substitute_homophones(
+        text,
+        rate=clamped_rate,
+        weighting=normalized_weighting,
+        rng=active_rng,
+    )
+
+
+class Ekkokin(Glitchling):
+    """Glitchling that swaps words for curated homophones."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        seed: int | None = None,
+        weighting: str | None = None,
+    ) -> None:
+        effective_rate = _DEFAULT_RATE if rate is None else rate
+        normalized_weighting = _normalise_weighting(weighting)
+        super().__init__(
+            name="Ekkokin",
+            corruption_function=substitute_homophones,
+            scope=AttackWave.WORD,
+            order=AttackOrder.EARLY,
+            seed=seed,
+            pipeline_operation=_build_pipeline_descriptor,
+            rate=effective_rate,
+            weighting=normalized_weighting,
+        )
+
+    def set_param(self, key: str, value: Any) -> None:
+        """Normalise weighting updates before storing them on the glitchling."""
+        if key == "weighting":
+            value = _normalise_weighting(cast(str | None, value))
+        super().set_param(key, value)
+
+
+def _build_pipeline_descriptor(glitch: Glitchling) -> dict[str, object] | None:
+    rate = glitch.kwargs.get("rate")
+    if rate is None:
+        return None
+    weighting = _normalise_weighting(cast(str | None, glitch.kwargs.get("weighting")))
+    return {
+        "type": "ekkokin",
+        "rate": float(rate),
+        "weighting": str(weighting),
+    }
+
+
+ekkokin = Ekkokin()
+
+
+__all__ = [
+    "Ekkokin",
+    "ekkokin",
+    "substitute_homophones",
+    "_python_substitute_homophones",
+]

glitchlings/zoo/spectroll.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import random
+import re
+from itertools import zip_longest
+
+from .core import AttackOrder, AttackWave, Glitchling
+
+_CANONICAL_COLOR_MAP: dict[str, str] = {
+    "red": "blue",
+    "blue": "red",
+    "green": "lime",
+    "lime": "green",
+    "yellow": "purple",
+    "purple": "yellow",
+    "orange": "cyan",
+    "cyan": "orange",
+    "magenta": "teal",
+    "teal": "magenta",
+    "black": "white",
+    "white": "black",
+}
+
+_VALID_MODES = {"literal", "drift"}
+
+_COLOR_PATTERN = re.compile(
+    r"\b(?P<color>"
+    + "|".join(sorted(_CANONICAL_COLOR_MAP, key=len, reverse=True))
+    + r")(?P<suffix>[a-zA-Z]*)\b",
+    re.IGNORECASE,
+)
+
+_COLOR_ADJACENCY: dict[str, tuple[str, ...]] = {
+    "red": ("orange", "magenta", "purple"),
+    "blue": ("cyan", "teal", "purple"),
+    "green": ("teal", "cyan", "yellow"),
+    "lime": ("yellow", "white", "cyan"),
+    "yellow": ("orange", "lime", "white"),
+    "purple": ("magenta", "red", "blue"),
+    "orange": ("red", "yellow", "magenta"),
+    "cyan": ("blue", "green", "teal"),
+    "magenta": ("purple", "red", "blue"),
+    "teal": ("cyan", "green", "blue"),
+    "black": ("purple", "blue", "teal"),
+    "white": ("yellow", "lime", "cyan"),
+}
+
+
+def _apply_case(template: str, replacement: str) -> str:
+    if not template:
+        return replacement
+    if template.isupper():
+        return replacement.upper()
+    if template.islower():
+        return replacement.lower()
+    if template[0].isupper() and template[1:].islower():
+        return replacement.capitalize()
+
+    characters: list[str] = []
+    for repl_char, template_char in zip_longest(replacement, template, fillvalue=""):
+        if template_char.isupper():
+            characters.append(repl_char.upper())
+        elif template_char.islower():
+            characters.append(repl_char.lower())
+        else:
+            characters.append(repl_char)
+    return "".join(characters)
+
+
+def _harmonize_suffix(original: str, replacement: str, suffix: str) -> str:
+    if not suffix:
+        return suffix
+
+    if (
+        original
+        and suffix
+        and original[-1].lower() == suffix[0].lower()
+        and replacement[-1].lower() != suffix[0].lower()
+    ):
+        return suffix[1:]
+    return suffix
+
+
+def _normalize_mode(mode: str | None) -> str:
+    normalized = "literal" if mode is None else mode.lower()
+    if normalized not in _VALID_MODES:
+        valid = ", ".join(sorted(_VALID_MODES))
+        raise ValueError(f"Unsupported Spectroll mode '{mode}'. Expected one of: {valid}")
+    return normalized
+
+
+def swap_colors(
+    text: str,
+    *,
+    seed: int | None = None,
+    mode: str = "literal",
+    rng: random.Random | None = None,
+) -> str:
+    """Swap canonical colour words for their partners.
+
+    Examples:
+        >>> swap_colors("red green blue")
+        'blue lime red'
+        >>> swap_colors("red green blue", mode="drift", seed=42)
+        'purple teal cyan'
+    """
+
+    normalized_mode = _normalize_mode(mode)
+    active_rng = rng if rng is not None else random.Random(seed)
+
+    def replace(match: re.Match[str]) -> str:
+        base = match.group("color")
+        suffix = match.group("suffix") or ""
+        canonical = base.lower()
+
+        replacement_base: str | None
+        if normalized_mode == "literal":
+            replacement_base = _CANONICAL_COLOR_MAP.get(canonical)
+        else:
+            palette = _COLOR_ADJACENCY.get(canonical)
+            if palette:
+                replacement_base = active_rng.choice(palette)
+            else:
+                replacement_base = _CANONICAL_COLOR_MAP.get(canonical)
+
+        if not replacement_base:
+            return match.group(0)
+
+        suffix_fragment = _harmonize_suffix(base, replacement_base, suffix)
+        adjusted = _apply_case(base, replacement_base)
+        return f"{adjusted}{suffix_fragment}"
+
+    return _COLOR_PATTERN.sub(replace, text)
+
+
+class Spectroll(Glitchling):
+    """Glitchling that remaps colour terms to alternate hues."""
+
+    def __init__(
+        self,
+        *,
+        mode: str = "literal",
+        seed: int | None = None,
+    ) -> None:
+        normalized_mode = _normalize_mode(mode)
+        super().__init__(
+            name="Spectroll",
+            corruption_function=swap_colors,
+            scope=AttackWave.WORD,
+            order=AttackOrder.NORMAL,
+            seed=seed,
+            mode=normalized_mode,
+        )
+
+
+spectroll = Spectroll()
+
+
+__all__ = ["Spectroll", "spectroll", "swap_colors"]

{glitchlings-0.5.0.dist-info → glitchlings-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.5.0
+Version: 0.5.1
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -393,11 +393,13 @@ glitchlings --list
 Apostrofae — scope: Character, order: normal
      Hokey — scope: Character, order: first
      Mim1c — scope: Character, order: last
+   Ekkokin — scope: Word, order: early
   Jargoyle — scope: Word, order: normal
      Adjax — scope: Word, order: normal
    Reduple — scope: Word, order: normal
   Rushmore — scope: Word, order: normal
   Redactyl — scope: Word, order: normal
+ Spectroll — scope: Word, order: normal
 Scannequin — scope: Character, order: late
     Zeedub — scope: Character, order: last
 ```
@@ -552,6 +554,18 @@ _Watch your step around here._
 > - `characters (Sequence[str])`: Optional override for the pool of zero-width strings to inject (default: curated invisibles such as U+200B, U+200C, U+200D, U+FEFF, U+2060).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
+### Ekkokin
+
+_Did you hear what I heard?_
+
+> _**Echo Chamber.**_ Ekkokin swaps words with curated homophones so the text still sounds right while the spelling drifts. Groups are normalised to prevent duplicates and casing is preserved when substitutions fire.
+>
+> Args
+>
+> - `rate (float)`: Maximum proportion of eligible words to replace with homophones (default: 0.02, 2%).
+> - `weighting (str)`: Sampling strategy applied within each homophone set (default: "flat").
+> - `seed (int)`: The random seed for reproducibility (default: 151).
+
 ### Jargoyle
 
 _Uh oh. The worst person you know just bought a thesaurus._
@@ -619,7 +633,6 @@ _Oops, that was my black highlighter._
 
 ### _Containment procedures pending_
 
-- `ekkokin` substitutes words with homophones (phonetic equivalents).
 - `nylingual` backtranslates portions of text.
 - `glothopper` introduces code-switching effects, blending languages or dialects.
 - `palimpsest` rewrites, but leaves accidental traces of the past.

{glitchlings-0.5.0.dist-info → glitchlings-0.5.1.dist-info}/RECORD

@@ -1,18 +1,23 @@
-glitchlings/__init__.py,sha256=A6m-sj1Gnq5DXdaD7IRsPnMvXW9UjZh3fQGcvps22uw,1230
+glitchlings/__init__.py,sha256=pDqhE33ZkTz8xzvVjc1FsSOYRBPdgaSL1es9e0v31Uc,1947
 glitchlings/__main__.py,sha256=f-P4jiVBd7ZpS6QxRpa_6SJgOG03UhZhcWasMDRWLs8,120
-glitchlings/_zoo_rust.cpython-313-darwin.so,sha256=ATs1jmgixn4nihkmrZrEyJVVvE9WymbJC7VJIjckHRY,2697808
-glitchlings/compat.py,sha256=lswR7J3kXER5hPXeyfkO-7USJvUhdtTi1ovJgEpspKc,8892
+glitchlings/_zoo_rust.cpython-313-darwin.so,sha256=IeIxP7owt7LbN0ksQFM899v3JccqxfoXJ5DqdbJJpPI,2753200
+glitchlings/compat.py,sha256=_iUEErikfkgPOik1zymPCU4-Pbyt-6h5fWoF7viohXs,12065
 glitchlings/config.py,sha256=xqTc2YJGMYJHbnh1nxQBdCKhQ6sqcjWJViArjarsZa4,12303
 glitchlings/config.toml,sha256=04-Y_JCdQU68SRmwk2qZqrH_bbX4jEH9uh7URtxdIHA,99
 glitchlings/main.py,sha256=uw8VbDgxov1m-wYHPDl2dP5ItpLB4ZHpb0ChJXzcL0o,10623
+glitchlings/spectroll.py,sha256=m5FRDYa-MjPfh29Zpk9bDmL6xPKOXS-kysFFz9WOTkE,150
+glitchlings/assets/apostrofae_pairs.json,sha256=bfjSEaMTI_axGNJ93nI431KXU0IVp7ayO42gGcMgL6U,521
+glitchlings/assets/ekkokin_homophones.json,sha256=TAvwBojTpWc-jk6jQjVDGMbHLfsjZLBPe7f78mkNLF0,17059
+glitchlings/assets/hokey_assets.json,sha256=9drpOv_PHHxs7jZOcgMr9G-Nswx_UuMzC4yQ0O8mIZ0,2890
+glitchlings/assets/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
 glitchlings/dev/__init__.py,sha256=v-qk9iE6b7VEg-4bpKH2PAifG-rkrCRgrS0C4VPR7ow,142
-glitchlings/dev/sync_assets.py,sha256=BDzfzRMhcvPC2N-bIjnsB8KUA5I7YrfSY-EnXQqh3WY,4677
+glitchlings/dev/sync_assets.py,sha256=xtco1x9tZFfVLajronYs8Iv0_43DU7ZTrD-sRR74b88,3675
 glitchlings/dlc/__init__.py,sha256=qlY4nuagy4AAWuPMwmuhwK2m36ktp-qkeiIxC7OXg34,305
 glitchlings/dlc/_shared.py,sha256=moQwnJdHMo-dx5uK0zM8XdPy5cs-OlAzYKVWfUP0RSQ,4407
 glitchlings/dlc/huggingface.py,sha256=BWceVUm28Yd8b7Tf_lmnPGgSVN1hZEmseRjf17nAPJw,2576
 glitchlings/dlc/prime.py,sha256=zhm0oTVKNDa1ByxZTP42rmMVaJDyx77w2g6NHy4jndc,8607
 glitchlings/dlc/pytorch.py,sha256=Laqz5o0UZXE1X9P-Qxb6KE0D5lcBKAoBbKsn-fnd6c0,6233
-glitchlings/dlc/pytorch_lightning.py,sha256=rhDwRgOGVzaEet27QG8GigKh6hK5ZdTBOxGE2G0MPxw,8005
+glitchlings/dlc/pytorch_lightning.py,sha256=BcxH6WHCl2SpDje7WuTN9V04KKfTqhaXFb2UzajNr4Y,8478
 glitchlings/lexicon/__init__.py,sha256=ooEPcAJhCI2Nw5z8OsQ0EtVpKBfiTrU0-AQJq8Zn2nQ,6007
 glitchlings/lexicon/_cache.py,sha256=oWdQtiU3csUAs-fYJRHuS_314j8JJ-T8AL73-GxVXzA,4072
 glitchlings/lexicon/metrics.py,sha256=VBFfFpxjiEwZtK-jS55H8xP7MTC_0OjY8lQ5zSQ9aTY,4572
@@ -24,7 +29,7 @@ glitchlings/util/adapters.py,sha256=psxQFYSFmh1u7NuqtIrKwQP5FOhOrZoxZzc7X7DDi9U,
 glitchlings/util/hokey_generator.py,sha256=NCbOGw55SG720VYnuwEdFAfdOvYlmjsZ0hAr5Y0Ja0Y,4483
 glitchlings/util/stretch_locator.py,sha256=INTMz7PXe-0HoDaMnQIQxJ266nABMXBYD67oJM8ur8g,4194
 glitchlings/util/stretchability.py,sha256=Rs-OHlfhRxGFlZeEQgEN66Z_CYTcWJrGypu7X5Yc9i4,12667
-glitchlings/zoo/__init__.py,sha256=xCVVAHLJ4lxl1JQUzff9fr84pJbB04fyXBjuX1m3YSw,5339
+glitchlings/zoo/__init__.py,sha256=MU2GLhBQ64I_T8rcozVFK6LWNzF4pAbdi5BIK92Uqrw,5579
 glitchlings/zoo/_ocr_confusions.py,sha256=0Y2GvfXCUIrXggL-tsFMQqzEFYVp6p5r7F-4dGrXiT4,1139
 glitchlings/zoo/_rust_extensions.py,sha256=Bsd0kiPB1rUn5x3k7ykydFuk2YSvXS9CQGPRlE5XzXY,4211
 glitchlings/zoo/_sampling.py,sha256=KrWyUSsYXghlvktS5hQBO0bPqywEEyA49A2qDWInB7Q,1586
@@ -32,6 +37,7 @@ glitchlings/zoo/_text_utils.py,sha256=NG9Iru9k3oSCxwYFAbvY4iG5NzHRYOIEtUXtvhKe4w
 glitchlings/zoo/adjax.py,sha256=D3gadataEL7QzxrTOElwNdXHKrJmb2EB9qwNLbTVUK0,3136
 glitchlings/zoo/apostrofae.py,sha256=zfQrq_ds0N6CTdqz3zsDO4KfiVLb5gx-0S4_VU19vMM,3674
 glitchlings/zoo/core.py,sha256=dRzUTmhOswDV0hWcaD-Sx7rZdPlrszn7C_1G2xd4ECk,20675
+glitchlings/zoo/ekkokin.py,sha256=jLMndJCIeoeb6fnFbVEf3FAav5FpWM6nkAXsqys56Ms,6442
 glitchlings/zoo/hokey.py,sha256=71z1JGzKGb_N8Wo7LVuS7qAqH2T0Y0h2LemIw66eprs,5298
 glitchlings/zoo/jargoyle.py,sha256=dkJpcDwBqyNJpsJDk3k1hAkLpLXKu0fH0ZJyhhllHWI,11260
 glitchlings/zoo/mim1c.py,sha256=BQ0kR-ob5TK5BrysipTUx1Yox6G5wlYi-EBH2V93xmI,3011
@@ -39,15 +45,13 @@ glitchlings/zoo/redactyl.py,sha256=lmFb3dobXpsQfwmgT-9yhoKIvrJyilu_yhj4mef0cm0,5
 glitchlings/zoo/reduple.py,sha256=uawpaq5cDBdGGbw0CwdITYp56nI6fazCTr9QIrJb0ag,3777
 glitchlings/zoo/rushmore.py,sha256=jsffZAfhpDTIUtG-jjBzM7bZUCnz2truR0fNNkpVR3M,3759
 glitchlings/zoo/scannequin.py,sha256=oaBiqU57dLruCPHo-W2ojno3lolefSAcvTjXpFwLarM,4406
+glitchlings/zoo/spectroll.py,sha256=WrXkZo8saXTPL_2pBCi5K-7UmXXhTR42em5IvjrJPCQ,4476
 glitchlings/zoo/typogre.py,sha256=NqA9b3HmFl8hR6bVLe85Tjv6uEYoDoSkb0i9gnd8t2Y,6188
 glitchlings/zoo/zeedub.py,sha256=Smegw7zUBAiMapKwZUqP0MqBKSCN5RNXvpbpU_ypnfI,4618
-glitchlings/zoo/assets/__init__.py,sha256=kETGGz0_V1OLpqB4rEfD5SU3XX0Ea9nSZ9isNL6SXWU,1637
-glitchlings/zoo/assets/apostrofae_pairs.json,sha256=bfjSEaMTI_axGNJ93nI431KXU0IVp7ayO42gGcMgL6U,521
-glitchlings/zoo/assets/hokey_assets.json,sha256=9drpOv_PHHxs7jZOcgMr9G-Nswx_UuMzC4yQ0O8mIZ0,2890
-glitchlings/zoo/assets/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
-glitchlings-0.5.0.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
-glitchlings-0.5.0.dist-info/METADATA,sha256=mWzN0o6h8e0hFfT6ZhiDy9U1yaJNCCXWXNYLO3i6vLk,33363
-glitchlings-0.5.0.dist-info/WHEEL,sha256=3s_eT7rbkGQeiKRiW_YCG21vqO2C4rGI4Jg-le1fLJ0,114
-glitchlings-0.5.0.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.5.0.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.5.0.dist-info/RECORD,,
+glitchlings/zoo/assets/__init__.py,sha256=0OLRgQvfwYeRVMQTUOAFDiOnRZPgVFnmaZj2KE-AL_I,2729
+glitchlings-0.5.1.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.5.1.dist-info/METADATA,sha256=wGG7OKTnMBFU4SBqIxOr8csj6nZqxY6H5GPL_2C76xk,33917
+glitchlings-0.5.1.dist-info/WHEEL,sha256=3s_eT7rbkGQeiKRiW_YCG21vqO2C4rGI4Jg-le1fLJ0,114
+glitchlings-0.5.1.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.5.1.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.5.1.dist-info/RECORD,,