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

glitchlings/main.py

@@ -11,31 +11,12 @@ from . import SAMPLE_TEXT
 from .zoo import (
     Glitchling,
     Gaggle,
-    jargoyle,
-    mim1c,
-    typogre,
-    reduple,
-    rushmore,
-    redactyl,
-    scannequin,
+    BUILTIN_GLITCHLINGS,
+    DEFAULT_GLITCHLING_NAMES,
+    parse_glitchling_spec,
     summon,
 )
 
-
-BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
-    g.name.lower(): g
-    for g in [
-        typogre,
-        mim1c,
-        jargoyle,
-        reduple,
-        rushmore,
-        redactyl,
-        scannequin,
-    ]
-}
-
-DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
 MAX_NAME_WIDTH = max(len(glitchling.name) for glitchling in BUILTIN_GLITCHLINGS.values())
 
 
@@ -62,8 +43,11 @@ def build_parser() -> argparse.ArgumentParser:
         "--glitchling",
         dest="glitchlings",
         action="append",
-        metavar="NAME",
-        help="Glitchling to apply (repeat for multiples). Defaults to all built-ins.",
+        metavar="SPEC",
+        help=(
+            "Glitchling to apply, optionally with parameters like "
+            "Typogre(max_change_rate=0.05). Repeat for multiples; defaults to all built-ins."
+        ),
     )
     parser.add_argument(
         "-s",
@@ -147,23 +131,16 @@ def read_text(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
 def summon_glitchlings(
     names: list[str] | None, parser: argparse.ArgumentParser, seed: int
 ) -> Gaggle:
-    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``.
-
-    Args:
-        names: Optional list of glitchling names provided by the user.
-        parser: The argument parser used for emitting user-facing errors.
-        seed: Master seed controlling deterministic corruption order.
-
-    Returns:
-        Gaggle: A ready-to-use collection of glitchlings.
-
-    Raises:
-        SystemExit: Raised indirectly via ``parser.error`` when a provided glitchling
-        name is invalid.
-    """
+    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``."""
 
     if names:
-        normalized = [name.lower() for name in names]
+        normalized: list[str | Glitchling] = []
+        for specification in names:
+            try:
+                normalized.append(parse_glitchling_spec(specification))
+            except ValueError as exc:
+                parser.error(str(exc))
+                raise AssertionError("parser.error should exit")
     else:
         normalized = DEFAULT_GLITCHLING_NAMES
 
@@ -174,6 +151,7 @@ def summon_glitchlings(
         raise AssertionError("parser.error should exit")
 
 
+
 def show_diff(original: str, corrupted: str) -> None:
     """Display a unified diff between the original and corrupted text."""
 

glitchlings/util/__init__.py

@@ -141,6 +141,36 @@ _register_layout(
     ),
 )
 
+_register_layout(
+    "QWERTZ",
+    (
+        "^1234567890ß´",
+        " qwertzuiopü+",
+        "  asdfghjklöä#",
+        "   yxcvbnm,.-",
+    ),
+)
+
+_register_layout(
+    "SPANISH_QWERTY",
+    (
+        "º1234567890'¡",
+        " qwertyuiop´+",
+        "  asdfghjklñ´",
+        "   <zxcvbnm,.-",
+    ),
+)
+
+_register_layout(
+    "SWEDISH_QWERTY",
+    (
+        "§1234567890+´",
+        " qwertyuiopå¨",
+        "  asdfghjklöä'",
+        "   <zxcvbnm,.-",
+    ),
+)
+
 
 class KeyNeighbors:
     def __init__(self) -> None:

glitchlings/zoo/__init__.py

@@ -1,6 +1,11 @@
+from __future__ import annotations
+
+import ast
+from typing import Any
+
 from .typogre import Typogre, typogre
 from .mim1c import Mim1c, mim1c
-from .jargoyle import Jargoyle, jargoyle
+from .jargoyle import Jargoyle, jargoyle, dependencies_available as _jargoyle_available
 from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
@@ -25,33 +30,105 @@ __all__ = [
     "Glitchling",
     "Gaggle",
     "summon",
+    "BUILTIN_GLITCHLINGS",
+    "DEFAULT_GLITCHLING_NAMES",
+    "parse_glitchling_spec",
 ]
 
+_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])
+
+BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
+    glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
+}
+
+_BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
+    typogre.name.lower(): Typogre,
+    mim1c.name.lower(): Mim1c,
+    reduple.name.lower(): Reduple,
+    rushmore.name.lower(): Rushmore,
+    redactyl.name.lower(): Redactyl,
+    scannequin.name.lower(): Scannequin,
+}
+if _HAS_JARGOYLE:
+    _BUILTIN_GLITCHLING_TYPES[jargoyle.name.lower()] = Jargoyle
+
+DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
+
+
+def parse_glitchling_spec(specification: str) -> Glitchling:
+    """Return a glitchling instance configured according to ``specification``."""
+
+    text = specification.strip()
+    if not text:
+        raise ValueError("Glitchling specification cannot be empty.")
+
+    if "(" not in text:
+        glitchling = BUILTIN_GLITCHLINGS.get(text.lower())
+        if glitchling is None:
+            raise ValueError(f"Glitchling '{text}' not found.")
+        return glitchling
+
+    if not text.endswith(")"):
+        raise ValueError(f"Invalid parameter syntax for glitchling '{text}'.")
+
+    name_part, arg_source = text[:-1].split("(", 1)
+    name = name_part.strip()
+    if not name:
+        raise ValueError(f"Invalid glitchling specification '{text}'.")
+
+    lower_name = name.lower()
+    glitchling_type = _BUILTIN_GLITCHLING_TYPES.get(lower_name)
+    if glitchling_type is None:
+        raise ValueError(f"Glitchling '{name}' not found.")
+
+    try:
+        call_expr = ast.parse(f"_({arg_source})", mode="eval").body
+    except SyntaxError as exc:
+        raise ValueError(
+            f"Invalid parameter syntax for glitchling '{name}': {exc.msg}"
+        ) from exc
+
+    if not isinstance(call_expr, ast.Call) or call_expr.args:
+        raise ValueError(
+            f"Glitchling '{name}' parameters must be provided as keyword arguments."
+        )
+
+    kwargs: dict[str, Any] = {}
+    for keyword in call_expr.keywords:
+        if keyword.arg is None:
+            raise ValueError(
+                f"Glitchling '{name}' does not support unpacking arbitrary keyword arguments."
+            )
+        try:
+            kwargs[keyword.arg] = ast.literal_eval(keyword.value)
+        except (ValueError, SyntaxError) as exc:
+            raise ValueError(
+                f"Failed to parse value for parameter '{keyword.arg}' on glitchling '{name}': {exc}"
+            ) from exc
+
+    try:
+        return glitchling_type(**kwargs)
+    except TypeError as exc:
+        raise ValueError(f"Failed to instantiate glitchling '{name}': {exc}") from exc
+
 
 def summon(glitchlings: list[str | Glitchling], seed: int = 151) -> Gaggle:
     """Summon glitchlings by name (using defaults) or instance (to change parameters)."""
-    available = {
-        g.name.lower(): g
-        for g in [
-            typogre,
-            mim1c,
-            jargoyle,
-            reduple,
-            rushmore,
-            redactyl,
-            scannequin,
-        ]
-    }
-    summoned = []
+
+    summoned: list[Glitchling] = []
     for entry in glitchlings:
         if isinstance(entry, Glitchling):
             summoned.append(entry)
             continue
 
-        g = available.get(entry.lower())
-        if g:
-            summoned.append(g)
-        else:
-            raise ValueError(f"Glitchling '{entry}' not found.")
+        try:
+            summoned.append(parse_glitchling_spec(entry))
+        except ValueError as exc:
+            raise ValueError(str(exc)) from exc
 
     return Gaggle(summoned, seed=seed)

glitchlings/zoo/_ocr_confusions.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from importlib import resources
+
+_CONFUSION_TABLE: list[tuple[str, list[str]]] | None = None
+
+
+def load_confusion_table() -> list[tuple[str, list[str]]]:
+    """Load the OCR confusion table shared by Python and Rust implementations."""
+    global _CONFUSION_TABLE
+    if _CONFUSION_TABLE is not None:
+        return _CONFUSION_TABLE
+
+    data = resources.files(__package__) / "ocr_confusions.tsv"
+    text = data.read_text(encoding="utf-8")
+    indexed_entries: list[tuple[int, tuple[str, list[str]]]] = []
+    for line_number, line in enumerate(text.splitlines()):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        parts = stripped.split()
+        if len(parts) < 2:
+            continue
+        source, *replacements = parts
+        indexed_entries.append((line_number, (source, replacements)))
+
+    # Sort longer patterns first to avoid overlapping matches, mirroring the
+    # behaviour of the Rust `confusion_table` helper.
+    indexed_entries.sort(
+        key=lambda item: (-len(item[1][0]), item[0])
+    )
+    entries = [entry for _, entry in indexed_entries]
+    _CONFUSION_TABLE = entries
+    return entries

glitchlings/zoo/jargoyle.py

@@ -2,27 +2,67 @@ import random
 import re
 from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Any, Literal, cast
-
-import nltk
-from nltk.corpus.reader import WordNetCorpusReader
-from nltk.data import find
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+try:  # pragma: no cover - exercised in environments with NLTK installed
+    import nltk  # type: ignore[import]
+except ModuleNotFoundError as exc:  # pragma: no cover - triggered when NLTK missing
+    nltk = None  # type: ignore[assignment]
+    find = None  # type: ignore[assignment]
+    _NLTK_IMPORT_ERROR = exc
+else:  # pragma: no cover - executed when NLTK is available
+    from nltk.corpus.reader import WordNetCorpusReader as _WordNetCorpusReader  # type: ignore[import]
+    from nltk.data import find as _nltk_find  # type: ignore[import]
+
+    find = _nltk_find
+    _NLTK_IMPORT_ERROR = None
+
+if TYPE_CHECKING:  # pragma: no cover - typing aid only
+    from nltk.corpus.reader import WordNetCorpusReader  # type: ignore[import]
+else:  # Use ``Any`` at runtime to avoid hard dependency when NLTK missing
+    WordNetCorpusReader = Any
+
+if nltk is not None:  # pragma: no cover - guarded by import success
+    try:
+        from nltk.corpus import wordnet as _WORDNET_MODULE  # type: ignore[import]
+    except ModuleNotFoundError:  # pragma: no cover - only hit on namespace packages
+        _WORDNET_MODULE = None
+    else:
+        WordNetCorpusReader = _WordNetCorpusReader  # type: ignore[assignment]
+else:
+    _WORDNET_MODULE = None
 
 from .core import AttackWave, Glitchling
 
-try:  # pragma: no cover - exercised when the namespace package is present
-    from nltk.corpus import wordnet as _WORDNET_MODULE
-except ModuleNotFoundError:  # pragma: no cover - triggered on modern NLTK installs
-    _WORDNET_MODULE = None
-
 _WORDNET_HANDLE: WordNetCorpusReader | Any | None = _WORDNET_MODULE
 
 _wordnet_ready = False
 
 
+def _require_nltk() -> None:
+    """Ensure the NLTK dependency is present before continuing."""
+
+    if nltk is None or find is None:
+        message = (
+            "The NLTK package is required for the jargoyle glitchling; install "
+            "the 'wordnet' extra via `pip install glitchlings[wordnet]`."
+        )
+        if '_NLTK_IMPORT_ERROR' in globals() and _NLTK_IMPORT_ERROR is not None:
+            raise RuntimeError(message) from _NLTK_IMPORT_ERROR
+        raise RuntimeError(message)
+
+
+def dependencies_available() -> bool:
+    """Return ``True`` when the runtime NLTK dependency is present."""
+
+    return nltk is not None and find is not None
+
+
 def _load_wordnet_reader() -> WordNetCorpusReader:
     """Return a WordNet corpus reader from the downloaded corpus files."""
 
+    _require_nltk()
+
     try:
         root = find("corpora/wordnet")
     except LookupError:
@@ -59,6 +99,8 @@ def ensure_wordnet() -> None:
     if _wordnet_ready:
         return
 
+    _require_nltk()
+
     resource = _wordnet()
 
     try:
@@ -272,4 +314,4 @@ class Jargoyle(Glitchling):
 jargoyle = Jargoyle()
 
 
-__all__ = ["Jargoyle", "ensure_wordnet", "jargoyle"]
+__all__ = ["Jargoyle", "dependencies_available", "ensure_wordnet", "jargoyle"]

glitchlings/zoo/ocr_confusions.tsv

@@ -0,0 +1,30 @@
+# Source  Replacements (space-separated)
+li h
+h li
+rn m
+m rn
+cl d
+d cl
+I l
+l I 1
+1 l I
+0 O
+O 0
+B 8
+8 B
+S 5
+5 S
+Z 2
+2 Z
+G 6
+6 G
+“ "
+” "
+‘ '
+’ '
+— -
+– -
+vv w
+w vv
+ri n
+n ri

glitchlings/zoo/redactyl.py

@@ -82,7 +82,9 @@ def redact_words(
     if rng is None:
         rng = random.Random(seed)
 
-    if _redact_words_rust is not None:
+    use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
+
+    if use_rust:
         return _redact_words_rust(
             text,
             replacement_char,

glitchlings/zoo/scannequin.py

@@ -1,6 +1,7 @@
 import re
 import random
 
+from ._ocr_confusions import load_confusion_table
 from .core import Glitchling, AttackWave, AttackOrder
 
 try:
@@ -33,35 +34,9 @@ def _python_ocr_artifacts(
     if not text:
         return text
 
-    # map: source -> list of possible replacements
-    # Keep patterns small and specific; longer patterns first avoid overmatching
-    confusion_table: list[tuple[str, list[str]]] = [
-        ("li", ["h"]),
-        ("h", ["li"]),
-        ("rn", ["m"]),
-        ("m", ["rn"]),
-        ("cl", ["d"]),
-        ("d", ["cl"]),
-        ("I", ["l"]),
-        ("l", ["I", "1"]),
-        ("1", ["l", "I"]),
-        ("0", ["O"]),
-        ("O", ["0"]),
-        ("B", ["8"]),
-        ("8", ["B"]),
-        ("S", ["5"]),
-        ("5", ["S"]),
-        ("Z", ["2"]),
-        ("2", ["Z"]),
-        ("G", ["6"]),
-        ("6", ["G"]),
-        ("“", ['"']),
-        ("”", ['"']),
-        ("‘", ["'"]),
-        ("’", ["'"]),
-        ("—", ["-"]),  # em dash -> hyphen
-        ("–", ["-"]),  # en dash -> hyphen
-    ]
+    # Keep the confusion definitions in a shared data file so both the Python
+    # and Rust implementations stay in sync.
+    confusion_table = load_confusion_table()
 
     # Build candidate matches as (start, end, choices)
     candidates: list[tuple[int, int, list[str]]] = []

glitchlings/zoo/typogre.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import random
 from typing import Optional
 
@@ -7,7 +8,7 @@ from .core import Glitchling, AttackWave, AttackOrder
 from ..util import KEYNEIGHBORS
 
 try:
-    from glitchlings._typogre_rust import fatfinger as _fatfinger_rust
+    from glitchlings._zoo_rust import fatfinger as _fatfinger_rust
 except ImportError:  # pragma: no cover - compiled extension not present
     _fatfinger_rust = None
 
@@ -91,8 +92,11 @@ def _fatfinger_python(
     layout: dict[str, list[str]],
     rng: random.Random,
 ) -> str:
+    rate = max(0.0, max_change_rate)
     s = text
-    max_changes = max(1, int(len(s) * max_change_rate))
+    max_changes = math.ceil(len(s) * rate)
+    if max_changes == 0:
+        return s
 
     positional_actions = ("char_swap", "missing_char", "extra_char", "nearby_char")
     global_actions = ("skipped_space", "random_space", "unichar", "repeated_char")
@@ -148,12 +152,16 @@ def fatfinger(
     if not text:
         return ""
 
+    rate = max(0.0, max_change_rate)
+    if rate == 0.0:
+        return text
+
     layout = getattr(KEYNEIGHBORS, keyboard)
 
     if _fatfinger_rust is not None:
-        return _fatfinger_rust(text, max_change_rate=max_change_rate, layout=layout, rng=rng)
+        return _fatfinger_rust(text, max_change_rate=rate, layout=layout, rng=rng)
 
-    return _fatfinger_python(text, max_change_rate=max_change_rate, layout=layout, rng=rng)
+    return _fatfinger_python(text, max_change_rate=rate, layout=layout, rng=rng)
 
 
 class Typogre(Glitchling):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.1
+Version: 0.2.2
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -232,11 +232,14 @@ Provides-Extra: hf
 Requires-Dist: datasets>=4.0.0; extra == "hf"
 Provides-Extra: wordnet
 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"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: hypothesis>=6.140.0; extra == "dev"
+Requires-Dist: nltk>=3.9.1; extra == "dev"
+Requires-Dist: numpy<=2.0,>=1.24; extra == "dev"
 Dynamic: license-file
 
 #
@@ -294,22 +297,10 @@ print(gaggle(SAMPLE_TEXT))
 
 ## Usage
 
-Glitchlings slot into evaluation pipelines just as easily as they corrupt stray strings.
-
-- **Direct invocation** – Instantiate a glitchling (or `Gaggle`) and call it on strings, iterables, or datasets. Keep the seed stable to make every run deterministic.
-- **Dataset corruption** – After ``import glitchlings.dlc.huggingface``, call ``Dataset.glitch(...)`` (or a `Gaggle`'s `.corrupt_dataset`) to perturb a Hugging Face `datasets.Dataset` and return a corrupted copy for training or evaluation.
-
-### Rust pipeline acceleration (opt-in)
-
-The refactored Rust pipeline can execute multiple glitchlings without
-bouncing back through Python, but it is gated behind a feature flag so
-teams can roll it out gradually. After compiling the Rust extension
-(`python -m cibuildwheel --output-dir dist`) set
-`GLITCHLINGS_RUST_PIPELINE=1` (or `true`, `yes`, `on`) before importing
-`glitchlings`. When the flag is set and the extension is available,
-`Gaggle` automatically batches compatible glitchlings into the Rust
-pipeline; otherwise it transparently falls back to the legacy Python
-loop.
+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
+integrations, and the feature-flagged Rust pipeline.
 
 ### Prime Intellect environments
 
@@ -384,11 +375,14 @@ glitchlings --list
 # Run Typogre against the contents of a file and inspect the diff.
 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"
+
 # Pipe text straight into the CLI for an on-the-fly corruption.
 echo "Beware LLM-written flavor-text" | glitchlings -g mim1c
 ```
 
-Use `--help` for a complete breakdown of available options.
+Use `--help` for a complete breakdown of available options, including support for parameterised glitchlings via `-g "Name(arg=value, ...)"` to mirror the Python API.
 
 ## Development
 

glitchlings-0.2.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+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,,

glitchlings-0.2.1.dist-info/RECORD

@@ -1,24 +0,0 @@
-glitchlings/__init__.py,sha256=w8heFqUejrXM_9NNlM9CQnIGkmGUyBV29acg3WsocXA,622
-glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
-glitchlings/_typogre_rust.cp312-win_amd64.pyd,sha256=k3PiIXoMQdZX8hMDkooQI4Rg2MH8YuHuq2rK7r5-8o4,265728
-glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=SXku4dvAYyulH-ALhuxJ_A0UareKExQn6gQ75l8fBlk,1943040
-glitchlings/main.py,sha256=LIFZjSRlE4HiozHUhlIlEIelM6oCJii3GIsuTHW51DI,6547
-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=uGdfyq-RgEKu1nqrNbf-FoQRqnadjKME2aXbnK8hhuI,4169
-glitchlings/zoo/__init__.py,sha256=_tE2DXkTmQwsojvCeY1ddAE7QkOvZSMTV6c8JzP_CEw,1401
-glitchlings/zoo/core.py,sha256=aGGc0M97QeKM5rsQjTZs3fhIVac0g8A72mW4u72YnD0,14373
-glitchlings/zoo/jargoyle.py,sha256=BCaJ5gzxCun3-K1Kh3-xweLc2mzcEWgRKnLNln3bbaA,8747
-glitchlings/zoo/mim1c.py,sha256=YHFELu3fpY_9VxRavYfCoAWZYp-HZBXdiLk4DTKdqcY,2979
-glitchlings/zoo/redactyl.py,sha256=vD7XixZEMmu_xXVNzf3AY7OvdRV1iE_sEqqDrAU4mPM,3674
-glitchlings/zoo/reduple.py,sha256=WuMpmuZrf5x7JneiRjDF2Y0beEAn7j1DPCV2BuuTuRY,2873
-glitchlings/zoo/rushmore.py,sha256=dAiv53B_6Zg-zNG5aW8YobJevyBV586HtJVlZqgcGR8,2790
-glitchlings/zoo/scannequin.py,sha256=gwrbHpcCTp-SHXuQyQoqvw4pYzEogCjFdWPTGlmwURA,4796
-glitchlings/zoo/typogre.py,sha256=gr-c7qy1OpvyaAJgomwdfkGFACJiXc1DAiCtQTxrhVI,5542
-glitchlings-0.2.1.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.2.1.dist-info/METADATA,sha256=6ekbj9GPLZgsJxKO-ZyOgyuGinxEsJlKxD-vdePvNe8,28243
-glitchlings-0.2.1.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-glitchlings-0.2.1.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.2.1.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.2.1.dist-info/RECORD,,