glitchlings 0.4.5__cp313-cp313-win_amd64.whl → 0.5.0__cp313-cp313-win_amd64.whl

glitchlings/config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import importlib
 import os
-import warnings
 from dataclasses import dataclass, field
 from io import TextIOBase
 from pathlib import Path
@@ -57,17 +56,6 @@ ATTACK_CONFIG_SCHEMA: dict[str, Any] = {
                         "required": ["name"],
                         "properties": {
                             "name": {"type": "string", "minLength": 1},
-                            "type": {"type": "string", "minLength": 1},
-                            "parameters": {"type": "object"},
-                        },
-                        "additionalProperties": True,
-                    },
-                    {
-                        "type": "object",
-                        "required": ["type"],
-                        "properties": {
-                            "name": {"type": "string", "minLength": 1},
-                            "type": {"type": "string", "minLength": 1},
                             "parameters": {"type": "object"},
                         },
                         "additionalProperties": True,
@@ -263,7 +251,12 @@ def _validate_attack_config_schema(data: Any, *, source: str) -> Mapping[str, An
 
     for index, entry in enumerate(raw_glitchlings, start=1):
         if isinstance(entry, Mapping):
-            name_candidate = entry.get("name") or entry.get("type")
+            if "type" in entry:
+                raise ValueError(
+                    f"{source}: glitchling #{index} uses unsupported 'type'; use 'name'."
+                )
+
+            name_candidate = entry.get("name")
             if not isinstance(name_candidate, str) or not name_candidate.strip():
                 raise ValueError(f"{source}: glitchling #{index} is missing a 'name'.")
             parameters = entry.get("parameters")
@@ -326,17 +319,12 @@ def _build_glitchling(entry: Any, source: str, index: int) -> "Glitchling":
             raise ValueError(f"{source}: glitchling #{index}: {exc}") from exc
 
     if isinstance(entry, Mapping):
-        name_value = entry.get("name")
-        legacy_type = entry.get("type")
-        if name_value is None and legacy_type is not None:
-            warnings.warn(
-                f"{source}: glitchling #{index} uses 'type'; prefer 'name'.",
-                DeprecationWarning,
-                stacklevel=2,
+        if "type" in entry:
+            raise ValueError(
+                f"{source}: glitchling #{index} uses unsupported 'type'; use 'name'."
             )
-            name_value = legacy_type
-        elif name_value is None:
-            name_value = legacy_type
+
+        name_value = entry.get("name")
 
         if not isinstance(name_value, str) or not name_value.strip():
             raise ValueError(f"{source}: glitchling #{index} is missing a 'name'.")
@@ -352,7 +340,7 @@ def _build_glitchling(entry: Any, source: str, index: int) -> "Glitchling":
             kwargs = {
                 key: value
                 for key, value in entry.items()
-                if key not in {"name", "type", "parameters"}
+                if key not in {"name", "parameters"}
             }
 
         try:

glitchlings/dev/__init__.py

@@ -0,0 +1,5 @@
+"""Developer-facing utilities for maintaining the Glitchlings repository."""
+
+from .sync_assets import sync_assets
+
+__all__ = ["sync_assets"]

glitchlings/dev/sync_assets.py

@@ -0,0 +1,153 @@
+"""Synchronise canonical glitchling assets with the vendored Rust copies."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+from typing import Iterator, Sequence
+
+RUST_VENDORED_ASSETS: frozenset[str] = frozenset({
+    "hokey_assets.json",
+    "ocr_confusions.tsv",
+})
+
+
+def _project_root(default: Path | None = None) -> Path:
+    if default is not None:
+        return default
+    return Path(__file__).resolve().parents[3]
+
+
+def _canonical_asset_dir(project_root: Path) -> Path:
+    canonical = project_root / "src" / "glitchlings" / "zoo" / "assets"
+    if not canonical.is_dir():
+        raise RuntimeError(
+            "expected canonical assets under 'src/glitchlings/zoo/assets'; "
+            "run this command from the repository root"
+        )
+    return canonical
+
+
+def _rust_asset_dir(project_root: Path) -> Path:
+    return project_root / "rust" / "zoo" / "assets"
+
+
+def _iter_extraneous_assets(rust_dir: Path) -> Iterator[Path]:
+    if not rust_dir.exists():
+        return
+    for path in rust_dir.iterdir():
+        if path.is_file() and path.name not in RUST_VENDORED_ASSETS:
+            yield path
+
+
+def sync_assets(
+    project_root: Path | None = None,
+    *,
+    check: bool = False,
+    quiet: bool = False,
+) -> bool:
+    """Synchronise the vendored Rust asset copies with the canonical sources."""
+
+    root = _project_root(project_root)
+    canonical_dir = _canonical_asset_dir(root)
+    rust_dir = _rust_asset_dir(root)
+
+    missing_sources = [
+        name
+        for name in RUST_VENDORED_ASSETS
+        if not (canonical_dir / name).is_file()
+    ]
+    if missing_sources:
+        missing_list = ", ".join(sorted(missing_sources))
+        raise RuntimeError(f"missing canonical assets: {missing_list}")
+
+    extraneous = list(_iter_extraneous_assets(rust_dir))
+
+    mismatched: list[tuple[str, str]] = []
+    for name in sorted(RUST_VENDORED_ASSETS):
+        source = canonical_dir / name
+        target = rust_dir / name
+        if not target.exists():
+            mismatched.append((name, "missing"))
+            continue
+        if source.read_bytes() != target.read_bytes():
+            mismatched.append((name, "outdated"))
+
+    if check:
+        if mismatched or extraneous:
+            if not quiet:
+                for name, reason in mismatched:
+                    target = rust_dir / name
+                    print(
+                        f"{target.relative_to(root)} is {reason}; run sync_assets to refresh it",
+                        file=sys.stderr,
+                    )
+                for extra in extraneous:
+                    print(
+                        (
+                            "unexpected vendored asset "
+                            f"{extra.relative_to(root)}; run sync_assets to prune it"
+                        ),
+                        file=sys.stderr,
+                    )
+            return False
+        if not quiet:
+            print("Rust asset bundle is up to date.")
+        return True
+
+    rust_dir.mkdir(parents=True, exist_ok=True)
+
+    for name, reason in mismatched:
+        source = canonical_dir / name
+        target = rust_dir / name
+        shutil.copy2(source, target)
+        if not quiet:
+            verb = "Copied" if reason == "missing" else "Updated"
+            print(
+                f"{verb} {source.relative_to(root)} -> {target.relative_to(root)}",
+            )
+
+    for extra in extraneous:
+        extra.unlink()
+        if not quiet:
+            print(f"Removed extraneous vendored asset {extra.relative_to(root)}")
+
+    if not mismatched and not extraneous and not quiet:
+        print("Rust asset bundle already aligned with canonical copies.")
+
+    return True
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Synchronise canonical glitchling assets with the vendored Rust copies.",
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="exit with a non-zero status when vendored assets diverge",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="suppress status output",
+    )
+    parser.add_argument(
+        "--project-root",
+        type=Path,
+        help="override the detected project root (useful for testing)",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    ok = sync_assets(project_root=args.project_root, check=args.check, quiet=args.quiet)
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI entry point
+    raise SystemExit(main())

glitchlings/util/stretchability.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-import json
 import re
 from dataclasses import dataclass
-from importlib import resources
-from typing import Any, Protocol, Sequence, TypedDict, cast
+from typing import Protocol, Sequence, TypedDict, cast
+
+from glitchlings.zoo import assets
 
 # Regexes reused across the module
 TOKEN_REGEX = re.compile(r"\w+|\W+")
@@ -32,12 +32,7 @@ class RandomLike(Protocol):
 
 # Lexical prior probabilities and pragmatic lexica shared with the Rust fast path.
 def _load_assets() -> HokeyAssets:
-    with (
-        resources.files("glitchlings.data")
-        .joinpath("hokey_assets.json")
-        .open("r", encoding="utf-8") as payload
-    ):
-        data: Any = json.load(payload)
+    data = assets.load_json("hokey_assets.json")
     return cast(HokeyAssets, data)
 
 

glitchlings/zoo/_ocr_confusions.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
-from importlib import resources
+from .assets import read_text
 
 _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")
+    text = read_text("ocr_confusions.tsv")
     indexed_entries: list[tuple[int, tuple[str, list[str]]]] = []
     for line_number, line in enumerate(text.splitlines()):
         stripped = line.strip()

glitchlings/zoo/_text_utils.py

@@ -21,9 +21,9 @@ def split_token_edges(token: str) -> tuple[str, str, str]:
     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)
+def _resolve_core_length(core: str, token: str) -> int:
+    """Return a stable core-length measurement used by weighting heuristics."""
+
     candidate = core if core else token
     length = len(candidate)
     if length <= 0:
@@ -34,6 +34,12 @@ def token_core_length(token: str) -> int:
     return length
 
 
+def token_core_length(token: str) -> int:
+    """Return the length of the main word characters for weighting heuristics."""
+    _, core, _ = split_token_edges(token)
+    return _resolve_core_length(core, token)
+
+
 @dataclass(frozen=True)
 class WordToken:
     """Metadata describing a non-whitespace token yielded by word splitters."""
@@ -71,12 +77,7 @@ def collect_word_tokens(
             continue
 
         prefix, core, suffix = split_token_edges(token)
-        core_length = len(core)
-        if core_length <= 0:
-            stripped = token.strip()
-            core_length = len(stripped) if stripped else len(token)
-        if core_length <= 0:
-            core_length = 1
+        core_length = _resolve_core_length(core, token)
 
         collected.append(
             WordToken(

glitchlings/zoo/adjax.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import random
 from typing import Any, cast
 
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from ._text_utils import split_preserving_whitespace, split_token_edges
 from .core import AttackWave, Glitchling
@@ -66,16 +65,9 @@ def swap_adjacent_words(
     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",
-    )
+    effective_rate = 0.5 if rate is None else rate
     clamped_rate = max(0.0, min(effective_rate, 1.0))
 
     if rng is None:
@@ -94,16 +86,9 @@ class Adjax(Glitchling):
         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",
-        )
+        effective_rate = 0.5 if rate is None else rate
         super().__init__(
             name="Adjax",
             corruption_function=swap_adjacent_words,
@@ -118,7 +103,7 @@ class Adjax(Glitchling):
             return None
         return {
             "type": "swap_adjacent",
-            "swap_rate": float(rate),
+            "rate": float(rate),
         }
 
 

glitchlings/zoo/apostrofae.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
-import json
 import random
 from functools import cache
-from importlib import resources
 from typing import Any, Sequence, cast
 
 from ._rust_extensions import get_rust_operation
+from .assets import load_json
 from .core import AttackOrder, AttackWave, Gaggle, Glitchling
 
 # Load Rust-accelerated operation if available
@@ -19,9 +18,7 @@ _apostrofae_rust = get_rust_operation("apostrofae")
 def _load_replacement_pairs() -> dict[str, list[tuple[str, str]]]:
     """Load the curated mapping of straight quotes to fancy pairs."""
 
-    resource = resources.files(f"{__package__}.assets").joinpath("apostrofae_pairs.json")
-    with resource.open("r", encoding="utf-8") as handle:
-        data: dict[str, list[Sequence[str]]] = json.load(handle)
+    data: dict[str, list[Sequence[str]]] = load_json("apostrofae_pairs.json")
 
     parsed: dict[str, list[tuple[str, str]]] = {}
     for straight, replacements in data.items():

glitchlings/zoo/assets/__init__.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+from hashlib import blake2b
+from importlib import resources
+from importlib.resources.abc import Traversable
+from typing import Any, BinaryIO, TextIO, cast
+
+_DEFAULT_DIGEST_SIZE = 32
+
+
+def _asset(name: str) -> Traversable:
+    asset = resources.files(__name__).joinpath(name)
+    if not asset.is_file():  # pragma: no cover - defensive guard for packaging issues
+        raise FileNotFoundError(f"Asset '{name}' not found at {asset}")
+    return asset
+
+
+def read_text(name: str, *, encoding: str = "utf-8") -> str:
+    """Return the decoded contents of a bundled text asset."""
+
+    return cast(str, _asset(name).read_text(encoding=encoding))
+
+
+def open_text(name: str, *, encoding: str = "utf-8") -> TextIO:
+    """Open a bundled text asset for reading."""
+
+    return cast(TextIO, _asset(name).open("r", encoding=encoding))
+
+
+def open_binary(name: str) -> BinaryIO:
+    """Open a bundled binary asset for reading."""
+
+    return cast(BinaryIO, _asset(name).open("rb"))
+
+
+def load_json(name: str, *, encoding: str = "utf-8") -> Any:
+    """Deserialize a JSON asset using the shared loader helpers."""
+
+    with open_text(name, encoding=encoding) as handle:
+        return json.load(handle)
+
+
+def hash_asset(name: str) -> str:
+    """Return a BLAKE2b digest for the bundled asset ``name``."""
+
+    digest = blake2b(digest_size=_DEFAULT_DIGEST_SIZE)
+    with open_binary(name) as handle:
+        for chunk in iter(lambda: handle.read(8192), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+__all__ = ["read_text", "open_text", "open_binary", "load_json", "hash_asset"]

glitchlings/zoo/jargoyle.py

@@ -7,7 +7,6 @@ from typing import Any, Literal, cast
 
 from glitchlings.lexicon import Lexicon, get_default_lexicon
 
-from ._rate import resolve_rate
 from .core import AttackWave, Glitchling
 
 _wordnet_module: ModuleType | None
@@ -119,7 +118,6 @@ def substitute_random_synonyms(
     seed: int | None = None,
     rng: random.Random | None = None,
     *,
-    replacement_rate: float | None = None,
     lexicon: Lexicon | None = None,
 ) -> str:
     """Replace words with random lexicon-driven synonyms.
@@ -144,12 +142,7 @@ def substitute_random_synonyms(
       deterministic subsets per word and part-of-speech using the active seed.
 
     """
-    effective_rate = resolve_rate(
-        rate=rate,
-        legacy_value=replacement_rate,
-        default=0.1,
-        legacy_name="replacement_rate",
-    )
+    effective_rate = 0.1 if rate is None else rate
 
     active_rng: random.Random
     if rng is not None:
@@ -258,23 +251,16 @@ class Jargoyle(Glitchling):
         self,
         *,
         rate: float | None = None,
-        replacement_rate: float | None = None,
         part_of_speech: PartOfSpeechInput = "n",
         seed: int | None = None,
         lexicon: Lexicon | None = None,
     ) -> None:
-        self._param_aliases = {"replacement_rate": "rate"}
         self._owns_lexicon = lexicon is None
         self._external_lexicon_original_seed = (
             lexicon.seed if isinstance(lexicon, Lexicon) else None
         )
         self._initializing = True
-        effective_rate = resolve_rate(
-            rate=rate,
-            legacy_value=replacement_rate,
-            default=0.01,
-            legacy_name="replacement_rate",
-        )
+        effective_rate = 0.01 if rate is None else rate
         prepared_lexicon = lexicon or get_default_lexicon(seed=seed)
         if lexicon is not None and seed is not None:
             prepared_lexicon.reseed(seed)

glitchlings/zoo/mim1c.py

@@ -4,7 +4,6 @@ from typing import Literal
 
 from confusable_homoglyphs import confusables
 
-from ._rate import resolve_rate
 from .core import AttackOrder, AttackWave, Glitchling
 
 
@@ -15,8 +14,6 @@ def swap_homoglyphs(
     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.
 
@@ -37,12 +34,7 @@ def swap_homoglyphs(
     - 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",
-    )
+    effective_rate = 0.02 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -79,18 +71,11 @@ class Mim1c(Glitchling):
         self,
         *,
         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",
-        )
+        effective_rate = 0.02 if rate is None else rate
         super().__init__(
             name="Mim1c",
             corruption_function=swap_homoglyphs,

glitchlings/zoo/redactyl.py

@@ -2,7 +2,6 @@ import random
 import re
 from typing import Any, cast
 
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from ._sampling import weighted_sample_without_replacement
 from ._text_utils import (
@@ -97,16 +96,10 @@ def redact_words(
     seed: int = 151,
     rng: random.Random | None = None,
     *,
-    redaction_rate: float | None = None,
     unweighted: bool = False,
 ) -> str:
     """Redact random words by replacing their characters."""
-    effective_rate = resolve_rate(
-        rate=rate,
-        legacy_value=redaction_rate,
-        default=0.025,
-        legacy_name="redaction_rate",
-    )
+    effective_rate = 0.025 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -148,18 +141,11 @@ class Redactyl(Glitchling):
         *,
         replacement_char: str = FULL_BLOCK,
         rate: float | None = None,
-        redaction_rate: float | None = None,
         merge_adjacent: bool = False,
         seed: int = 151,
         unweighted: bool = False,
     ) -> None:
-        self._param_aliases = {"redaction_rate": "rate"}
-        effective_rate = resolve_rate(
-            rate=rate,
-            legacy_value=redaction_rate,
-            default=0.025,
-            legacy_name="redaction_rate",
-        )
+        effective_rate = 0.025 if rate is None else rate
         super().__init__(
             name="Redactyl",
             corruption_function=redact_words,
@@ -181,7 +167,7 @@ class Redactyl(Glitchling):
         return {
             "type": "redact",
             "replacement_char": str(replacement_char),
-            "redaction_rate": float(rate),
+            "rate": float(rate),
             "merge_adjacent": bool(merge_adjacent),
             "unweighted": unweighted,
         }

glitchlings/zoo/reduple.py

@@ -1,7 +1,6 @@
 import random
 from typing import Any, cast
 
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
 from .core import AttackWave, Glitchling
@@ -71,7 +70,6 @@ def reduplicate_words(
     seed: int | None = None,
     rng: random.Random | None = None,
     *,
-    reduplication_rate: float | None = None,
     unweighted: bool = False,
 ) -> str:
     """Randomly reduplicate words in the text.
@@ -79,12 +77,7 @@ def reduplicate_words(
     Falls back to the Python implementation when the optional Rust
     extension is unavailable.
     """
-    effective_rate = resolve_rate(
-        rate=rate,
-        legacy_value=reduplication_rate,
-        default=0.01,
-        legacy_name="reduplication_rate",
-    )
+    effective_rate = 0.01 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -110,17 +103,10 @@ class Reduple(Glitchling):
         self,
         *,
         rate: float | None = None,
-        reduplication_rate: float | None = None,
         seed: int | None = None,
         unweighted: bool = False,
     ) -> None:
-        self._param_aliases = {"reduplication_rate": "rate"}
-        effective_rate = resolve_rate(
-            rate=rate,
-            legacy_value=reduplication_rate,
-            default=0.01,
-            legacy_name="reduplication_rate",
-        )
+        effective_rate = 0.01 if rate is None else rate
         super().__init__(
             name="Reduple",
             corruption_function=reduplicate_words,
@@ -137,7 +123,7 @@ class Reduple(Glitchling):
         unweighted = bool(self.kwargs.get("unweighted", False))
         return {
             "type": "reduplicate",
-            "reduplication_rate": float(rate),
+            "rate": float(rate),
             "unweighted": unweighted,
         }
 

glitchlings/zoo/rushmore.py

@@ -3,7 +3,6 @@ import random
 import re
 from typing import Any, cast
 
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
 from .core import AttackWave, Glitchling
@@ -74,20 +73,13 @@ def delete_random_words(
     rate: float | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
-    *,
-    max_deletion_rate: float | None = None,
     unweighted: bool = False,
 ) -> 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",
-    )
+    effective_rate = 0.01 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -113,17 +105,10 @@ class Rushmore(Glitchling):
         self,
         *,
         rate: float | None = None,
-        max_deletion_rate: float | None = None,
         seed: int | None = None,
         unweighted: bool = False,
     ) -> 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",
-        )
+        effective_rate = 0.01 if rate is None else rate
         super().__init__(
             name="Rushmore",
             corruption_function=delete_random_words,
@@ -135,14 +120,12 @@ class Rushmore(Glitchling):
 
     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
         unweighted = bool(self.kwargs.get("unweighted", False))
         return {
             "type": "delete",
-            "max_deletion_rate": float(rate),
+            "rate": float(rate),
             "unweighted": unweighted,
         }
 

glitchlings/zoo/scannequin.py

@@ -3,7 +3,6 @@ import re
 from typing import Any, cast
 
 from ._ocr_confusions import load_confusion_table
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
@@ -102,8 +101,6 @@ def ocr_artifacts(
     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.
 
@@ -112,12 +109,7 @@ 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",
-    )
+    effective_rate = 0.02 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -137,16 +129,9 @@ class Scannequin(Glitchling):
         self,
         *,
         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",
-        )
+        effective_rate = 0.02 if rate is None else rate
         super().__init__(
             name="Scannequin",
             corruption_function=ocr_artifacts,
@@ -158,11 +143,9 @@ class Scannequin(Glitchling):
 
     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)}
+        return {"type": "ocr", "rate": float(rate)}
 
 
 scannequin = Scannequin()

glitchlings/zoo/typogre.py

@@ -5,7 +5,6 @@ import random
 from typing import Any, Optional, cast
 
 from ..util import KEYNEIGHBORS
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
@@ -144,16 +143,9 @@ def fatfinger(
     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",
-    )
+    effective_rate = 0.02 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -182,17 +174,10 @@ class Typogre(Glitchling):
         self,
         *,
         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",
-        )
+        effective_rate = 0.02 if rate is None else rate
         super().__init__(
             name="Typogre",
             corruption_function=fatfinger,
@@ -205,8 +190,6 @@ class Typogre(Glitchling):
 
     def pipeline_operation(self) -> dict[str, Any] | None:
         rate = self.kwargs.get("rate")
-        if rate is None:
-            rate = self.kwargs.get("max_change_rate")
         if rate is None:
             return None
 

glitchlings/zoo/zeedub.py

@@ -5,7 +5,6 @@ import random
 from collections.abc import Sequence
 from typing import Any, cast
 
-from ._rate import resolve_rate
 from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
@@ -77,12 +76,7 @@ def insert_zero_widths(
     characters: Sequence[str] | None = None,
 ) -> str:
     """Inject zero-width characters between non-space character pairs."""
-    effective_rate = resolve_rate(
-        rate=rate,
-        legacy_value=None,
-        default=0.02,
-        legacy_name="rate",
-    )
+    effective_rate = 0.02 if rate is None else rate
 
     if rng is None:
         rng = random.Random(seed)
@@ -142,12 +136,7 @@ class Zeedub(Glitchling):
         seed: int | None = None,
         characters: Sequence[str] | None = None,
     ) -> None:
-        effective_rate = resolve_rate(
-            rate=rate,
-            legacy_value=None,
-            default=0.02,
-            legacy_name="rate",
-        )
+        effective_rate = 0.02 if rate is None else rate
         super().__init__(
             name="Zeedub",
             corruption_function=insert_zero_widths,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.4.5
+Version: 0.5.0
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -294,11 +294,14 @@ Dynamic: license-file
                         Every language game breeds monsters.
 ```
 
+![Python Versions](https://img.shields.io/pypi/pyversions/glitchlings.svg)
 [![PyPI version](https://img.shields.io/pypi/v/glitchlings.svg)](https://pypi.org/project/glitchlings/)
-[![PyPI Status](https://github.com/osoleve/glitchlings/actions/workflows/publish.yml/badge.svg)](https://github.com/osoleve/glitchlings/actions/workflows/publish.yml)
-[![Lint and Type](https://github.com/osoleve/glitchlings/actions/workflows/ci.yml/badge.svg)](https://github.com/osoleve/glitchlings/actions/workflows/ci.yml)
-[![Website status](https://img.shields.io/website-up-down-green-red/https/osoleve.github.io/glitchlings)](https://osoleve.github.io/glitchlings/)
-[![License](https://img.shields.io/github/license/osoleve/glitchlings.svg)](https://github.com/osoleve/glitchlings/blob/main/LICENSE)
+![Wheel](https://img.shields.io/pypi/wheel/glitchlings.svg)
+![Linting and Typing](https://github.com/osoleve/glitchlings/actions/workflows/ci.yml/badge.svg)  
+![Entropy Budget](https://img.shields.io/badge/entropy-lifegiving-magenta.svg)
+![Chaos](https://img.shields.io/badge/chaos-friend--shaped-chartreuse.svg)
+![Charm](https://img.shields.io/badge/jouissance-indefatigable-cyan.svg)  
+![Lore Compliance](https://img.shields.io/badge/ISO--474--▓▓-Z--Compliant-blue.svg)
 
 `Glitchlings` are **utilities for corrupting the text inputs to your language models in deterministic, _linguistically principled_** ways.  
 Each embodies a different way that documents can be compromised in the wild.
@@ -596,7 +599,6 @@ _Keep your hands and punctuation where I can see them._
 > 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

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

@@ -1,12 +1,12 @@
 glitchlings/__init__.py,sha256=pNL6Vx6ggpRq-vW0CXJjnWOe_LktP6Zz9xNhqDHj3Dw,1301
 glitchlings/__main__.py,sha256=nB7btO_T4wBFOcyawfWpjEindVrUfTqqV5hdeeS1HT8,128
-glitchlings/_zoo_rust.cp313-win_amd64.pyd,sha256=6hdbgPFxuHKkzuoajgzrX67X9--NKf5BX2UehNGO1AY,2349568
+glitchlings/_zoo_rust.cp313-win_amd64.pyd,sha256=OFN9vx0K5-NueJ-sOSQKwhWudU2mRqGcHK4AkWxZ8-c,2349056
 glitchlings/compat.py,sha256=j4lkWNtyox5sen5j7u0SHfnk8QUn-yicaqvuLlZp1-s,9174
-glitchlings/config.py,sha256=rBBHRmkIyoWRPcUFrsxmSm08qxZ07wDAuO5AAF6sjAk,13323
+glitchlings/config.py,sha256=00BAHPbfOFnGHvC7FCcz1YpJjdsfpn1ET5SJJdsVQog,12677
 glitchlings/config.toml,sha256=OywXmEpuOPtyJRbcRt4cwQkHiZ__5axEHoCaX9ye-uA,102
 glitchlings/main.py,sha256=eCUEFsu8-NLDz1xyKNDIucVm975HNQZJYm6YCv8RIyg,10987
-glitchlings/data/__init__.py,sha256=kIT4a2EDNo_R-iL8kVisJ8PxR_BrygNYegfG_Ua6DcE,69
-glitchlings/data/hokey_assets.json,sha256=1GaSEzXwtT1nvf0B9mFyLzHOcqzKbPreibsC6iBWAHA,3083
+glitchlings/dev/__init__.py,sha256=Pr2tXDwfa6SHW1wPseLHRXPINi7lEs6QNClreU0rAiw,147
+glitchlings/dev/sync_assets.py,sha256=QgUNrNpNloxqVGTCX0kVYwQMkJ58zGiZd37svteeS5M,4830
 glitchlings/dlc/__init__.py,sha256=iFDTwkaWl2C0_QUYykIXfmOUzy__oURX_BiJhexf-8o,312
 glitchlings/dlc/_shared.py,sha256=q1xMclEsbR0KIEn9chwZXRubMnIvU-uIc_0PxCFpmqE,4560
 glitchlings/dlc/huggingface.py,sha256=6wD4Vu2jp1d8GYSUiAvOAXqCO9w4HBxCOSfbJM8Ylzw,2657
@@ -23,31 +23,31 @@ glitchlings/util/__init__.py,sha256=Q5lkncOaM6f2eJK3HAtZyxpCjGnekCpwPloqasS3JDo,
 glitchlings/util/adapters.py,sha256=mFhPlE8JaFuO_C-3_aqhgwkqa6isV8Y2ifqVh3Iv9JM,720
 glitchlings/util/hokey_generator.py,sha256=hNWVbscVeKvcqwFtJ1oaWYf2Z0qHSxy0-iMLjht6zuM,4627
 glitchlings/util/stretch_locator.py,sha256=tM4XsQ_asNXQq2Yee8STybFMCC2HbSKCu9I49G0yJ3c,4334
-glitchlings/util/stretchability.py,sha256=ja1PJKVAKySUP5G2T0Q_THwIvydJn49xYFaQn58cQYw,13194
+glitchlings/util/stretchability.py,sha256=WWGMN9MTbHhgQIBB_p_cz-JKb51rCHZqyDRjPGkUOjY,13037
 glitchlings/zoo/__init__.py,sha256=Ab69SD_RUXfiWUEzqU3wteGWobpm2kkbmwndYLEbv_0,5511
-glitchlings/zoo/_ocr_confusions.py,sha256=pPlvJOoan3ouwwGt8hATcO-9luIrGJl0vwUqssUMXD8,1236
-glitchlings/zoo/_rate.py,sha256=KxFDFJEGWsv76v1JcoHXIETj9kGdbbAiUqCPwAcWcDw,3710
+glitchlings/zoo/_ocr_confusions.py,sha256=Kyo3W6w-FGs4C7jXp4bLFHFCaa0RUJWvUrWKqfBOdBk,1171
 glitchlings/zoo/_rust_extensions.py,sha256=SdU06m-qjf-rRHnqM5OMophx1IacoI4KbyRu2HXrTUc,4354
 glitchlings/zoo/_sampling.py,sha256=AAPLObjqKrmX882TX8hdvPHReBOcv0Z4pUuW6AxuGgU,1640
-glitchlings/zoo/_text_utils.py,sha256=LqCa33E-Qxbk6N5AVfxEmAz6C2u7_mCF0xPT9-404A8,2854
-glitchlings/zoo/adjax.py,sha256=8AqTfcJe50vPVxER5wREuyr4qqsmyKqi-klDW77HVYM,3646
-glitchlings/zoo/apostrofae.py,sha256=WB1zvCc1_YvTD9XdTNtFrK8H9FleaF-UNMCai_E7lqE,3949
+glitchlings/zoo/_text_utils.py,sha256=DRjPuC-nFoxFeA7KIbpuIB5k8DXbvvvcHNJniL_8KoQ,2872
+glitchlings/zoo/adjax.py,sha256=Oz3WGSsa4qpH7HLgBQC0r4JktJYGl3A0vkVknqeSG5I,3249
+glitchlings/zoo/apostrofae.py,sha256=C9x9_jj9CidYEWL9OEoNJU_Jzr3Vk4UQ8tITThVbwvY,3798
 glitchlings/zoo/core.py,sha256=tkJFqGwpVa7qQxkUr9lsHOB8zS3lDCo987R6Nvz375U,21257
 glitchlings/zoo/hokey.py,sha256=h-yjCLqYAZFksIYw4fMniuTWUywFw9GU9yUFs_uECHo,5471
-glitchlings/zoo/jargoyle.py,sha256=kgKw_hsaJaKQjrxzt_CMlgtZApedM6I2-U3d3aeipXs,12014
-glitchlings/zoo/mim1c.py,sha256=GqUMErVAVcqMAZjx4hhJ0Af25CxA0Aorv3U_fTqLZek,3546
-glitchlings/zoo/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
-glitchlings/zoo/redactyl.py,sha256=xSdt-Az3HI8XLC-uV8hK6JIoNa1nL-cTCFCoShFvKt0,5752
-glitchlings/zoo/reduple.py,sha256=YfdKZPr2TO2ZK7h8K5xlsnoubEZ3kQLRpDX65GzrKls,4372
-glitchlings/zoo/rushmore.py,sha256=JjLKTKQoXlvp0uvCzMRlJSXE_N2VFZPHMF_nkolKm3g,4439
-glitchlings/zoo/scannequin.py,sha256=-YG6tRTE72MGw4CpWAPo42gFaCTpyDvOJnk0gynitCg,5041
-glitchlings/zoo/typogre.py,sha256=X6jcnCYifNtoSwe2ig7YS3QrODyrACirMZ9pjN5LLBA,6917
-glitchlings/zoo/zeedub.py,sha256=KApSCSiTr3b412vsA8UHWFhYQDxe_jg0308wWK-GNtM,5025
-glitchlings/zoo/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glitchlings/zoo/jargoyle.py,sha256=2FwL4A_DpI2Lz6pnZo5iSJZzgd8wDNM9bMeOsMVFSmw,11581
+glitchlings/zoo/mim1c.py,sha256=86lCawTFWRWsO_vH6GMRJfM09TMTUy5MNhO9gsBEkk0,3105
+glitchlings/zoo/redactyl.py,sha256=2BYQfcKwp1WFPwXomQCmh-z0UPN9sNx6Px84WilFs3k,5323
+glitchlings/zoo/reduple.py,sha256=YukTZvLMBoarx96T4LHLGHr_KJVmFkAb0OBsO13ws8A,3911
+glitchlings/zoo/rushmore.py,sha256=CiVkLlskOmfKtzFanmYe6wxKJkCSMbLeKTWDrwZZaXw,3895
+glitchlings/zoo/scannequin.py,sha256=s2wno1_7aGebXvG3o9WvDQ5RRwp5Upl2dejbDUGIXkY,4560
+glitchlings/zoo/typogre.py,sha256=B1-kMfOygKtiKXDBQOHJxvheielBWGbbdWk-cgoONgs,6402
+glitchlings/zoo/zeedub.py,sha256=4x9bNQEq4VSsfol77mYx8jyBRyTugjRQPyk-ANy6gpY,4792
+glitchlings/zoo/assets/__init__.py,sha256=6dOYQnMw-Hk9Tb3lChgZ4aoRr9qacZtbXR8ROnDfBq8,1691
 glitchlings/zoo/assets/apostrofae_pairs.json,sha256=lPLFLndzn_f7_5wZizxsLMnwBY4O63zsCvDjyJ56MLA,553
-glitchlings-0.4.5.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.4.5.dist-info/METADATA,sha256=sULt2kvkK1lfhdqBbSvawNoRNyevwLsFrITBPMBrE9M,34146
-glitchlings-0.4.5.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
-glitchlings-0.4.5.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.4.5.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.4.5.dist-info/RECORD,,
+glitchlings/zoo/assets/hokey_assets.json,sha256=1GaSEzXwtT1nvf0B9mFyLzHOcqzKbPreibsC6iBWAHA,3083
+glitchlings/zoo/assets/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
+glitchlings-0.5.0.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
+glitchlings-0.5.0.dist-info/METADATA,sha256=Nu4n4Oy-LoMko5-2ncvshT_OKMWxr-k9YOm5uMLIHBk,34013
+glitchlings-0.5.0.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
+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/data/__init__.py

@@ -1 +0,0 @@
-"""Static data assets shared across Glitchlings implementations."""

glitchlings/zoo/_rate.py

@@ -1,131 +0,0 @@
-"""Utilities for handling legacy parameter names across glitchling classes."""
-
-from __future__ import annotations
-
-import warnings
-
-
-def resolve_rate(
-    *,
-    rate: float | None,
-    legacy_value: float | None,
-    default: float,
-    legacy_name: str,
-) -> float:
-    """Return the effective rate while enforcing mutual exclusivity.
-
-    This function centralizes the handling of legacy parameter names, allowing
-    glitchlings to maintain backwards compatibility while encouraging migration
-    to the standardized 'rate' parameter.
-
-    Parameters
-    ----------
-    rate : float | None
-        The preferred parameter value.
-    legacy_value : float | None
-        The deprecated legacy parameter value.
-    default : float
-        Default value if neither parameter is specified.
-    legacy_name : str
-        Name of the legacy parameter for error/warning messages.
-
-    Returns
-    -------
-    float
-        The resolved rate value.
-
-    Raises
-    ------
-    ValueError
-        If both rate and legacy_value are specified simultaneously.
-
-    Warnings
-    --------
-    DeprecationWarning
-        If the legacy parameter is used, a deprecation warning is issued.
-
-    Examples
-    --------
-    >>> resolve_rate(rate=0.5, legacy_value=None, default=0.1, legacy_name="old_rate")
-    0.5
-    >>> resolve_rate(rate=None, legacy_value=0.3, default=0.1, legacy_name="old_rate")
-    0.3  # Issues deprecation warning
-    >>> resolve_rate(rate=None, legacy_value=None, default=0.1, legacy_name="old_rate")
-    0.1
-
-    """
-    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:
-        warnings.warn(
-            f"The '{legacy_name}' parameter is deprecated and will be removed in version 0.6.0. "
-            f"Use 'rate' instead.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        return legacy_value
-
-    return default
-
-
-def resolve_legacy_param(
-    *,
-    preferred_value: object,
-    legacy_value: object,
-    default: object,
-    preferred_name: str,
-    legacy_name: str,
-) -> object:
-    """Resolve a parameter that has both preferred and legacy names.
-
-    This is a generalized version of resolve_rate() that works with any type.
-
-    Parameters
-    ----------
-    preferred_value : object
-        The value from the preferred parameter name.
-    legacy_value : object
-        The value from the legacy parameter name.
-    default : object
-        Default value if neither parameter is specified.
-    preferred_name : str
-        Name of the preferred parameter.
-    legacy_name : str
-        Name of the legacy parameter for warning messages.
-
-    Returns
-    -------
-    object
-        The resolved parameter value.
-
-    Raises
-    ------
-    ValueError
-        If both preferred and legacy values are specified simultaneously.
-
-    Warnings
-    --------
-    DeprecationWarning
-        If the legacy parameter is used.
-
-    """
-    if preferred_value is not None and legacy_value is not None:
-        raise ValueError(f"Specify either '{preferred_name}' or '{legacy_name}', not both.")
-
-    if preferred_value is not None:
-        return preferred_value
-
-    if legacy_value is not None:
-        warnings.warn(
-            f"The '{legacy_name}' parameter is deprecated and will be removed in version 0.6.0. "
-            f"Use '{preferred_name}' instead.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        return legacy_value
-
-    return default