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

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/assets/hokey_assets.json

@@ -0,0 +1,193 @@
+{
+  "lexical_prior": {
+    "so": 0.92,
+    "no": 0.89,
+    "go": 0.72,
+    "yeah": 0.86,
+    "yay": 0.81,
+    "ya": 0.7,
+    "hey": 0.66,
+    "okay": 0.68,
+    "ok": 0.64,
+    "cool": 0.78,
+    "omg": 0.74,
+    "wow": 0.88,
+    "wee": 0.62,
+    "woo": 0.69,
+    "woohoo": 0.74,
+    "whoa": 0.71,
+    "woah": 0.7,
+    "yayyy": 0.75,
+    "yayyyy": 0.76,
+    "yas": 0.79,
+    "yass": 0.8,
+    "yaaas": 0.82,
+    "please": 0.53,
+    "pleaseee": 0.57,
+    "pleaseeee": 0.6,
+    "pleaseeeee": 0.63,
+    "lol": 0.83,
+    "lmao": 0.65,
+    "omggg": 0.75,
+    "omgggg": 0.76,
+    "squee": 0.64,
+    "hahaha": 0.6,
+    "haha": 0.56,
+    "really": 0.58,
+    "very": 0.49,
+    "love": 0.55,
+    "cute": 0.52,
+    "nice": 0.47,
+    "sweet": 0.45,
+    "yayness": 0.44,
+    "ugh": 0.5,
+    "aww": 0.61,
+    "yess": 0.81,
+    "yes": 0.9,
+    "pls": 0.48,
+    "pleeeease": 0.62,
+    "nooo": 0.88,
+    "noooo": 0.89,
+    "dang": 0.41,
+    "geez": 0.39,
+    "danggg": 0.44,
+    "dangit": 0.38,
+    "sick": 0.35,
+    "epic": 0.37,
+    "rad": 0.5,
+    "goal": 0.56,
+    "great": 0.46,
+    "awesome": 0.51,
+    "amazing": 0.52,
+    "perfect": 0.49,
+    "fantastic": 0.5,
+    "stellar": 0.48,
+    "yippee": 0.67,
+    "stoked": 0.48,
+    "yikes": 0.43,
+    "gosh": 0.41,
+    "heck": 0.36
+  },
+  "interjections": [
+    "wow",
+    "omg",
+    "hey",
+    "ugh",
+    "yay",
+    "yayyy",
+    "yayyyy",
+    "woo",
+    "woohoo",
+    "whoa",
+    "woah",
+    "whooo",
+    "ah",
+    "aw",
+    "aww",
+    "hmm",
+    "huh",
+    "yo",
+    "yikes",
+    "gah",
+    "phew",
+    "sheesh"
+  ],
+  "intensifiers": [
+    "so",
+    "very",
+    "really",
+    "super",
+    "mega",
+    "ultra",
+    "too",
+    "way",
+    "crazy",
+    "insanely",
+    "totally",
+    "extremely",
+    "seriously",
+    "absolutely",
+    "completely",
+    "entirely",
+    "utterly",
+    "hella",
+    "wicked",
+    "truly"
+  ],
+  "evaluatives": [
+    "cool",
+    "great",
+    "awesome",
+    "amazing",
+    "perfect",
+    "nice",
+    "sweet",
+    "lovely",
+    "loving",
+    "silly",
+    "wild",
+    "fun",
+    "funny",
+    "adorable",
+    "cute",
+    "fantastic",
+    "fabulous",
+    "brilliant",
+    "stellar",
+    "rad",
+    "epic",
+    "delightful",
+    "gorgeous"
+  ],
+  "positive_lexicon": [
+    "love",
+    "loved",
+    "loving",
+    "like",
+    "liked",
+    "awesome",
+    "amazing",
+    "yay",
+    "great",
+    "good",
+    "fun",
+    "funny",
+    "blessed",
+    "excited",
+    "cool",
+    "best",
+    "beautiful",
+    "happy",
+    "happiest",
+    "joy",
+    "joyful",
+    "thrilled",
+    "ecstatic",
+    "stoked",
+    "pumped",
+    "glad"
+  ],
+  "negative_lexicon": [
+    "bad",
+    "sad",
+    "angry",
+    "annoyed",
+    "mad",
+    "terrible",
+    "awful",
+    "hate",
+    "hated",
+    "crying",
+    "hurt",
+    "tired",
+    "worst",
+    "ugh",
+    "nope",
+    "upset",
+    "frustrated",
+    "drained",
+    "exhausted",
+    "bummed",
+    "grumpy"
+  ]
+}

glitchlings/zoo/hokey.py

@@ -0,0 +1,173 @@
+"""Hokey glitchling that performs expressive lengthening."""
+
+from __future__ import annotations
+
+import random
+from typing import Any, cast
+
+from ..util.hokey_generator import HokeyConfig, HokeyGenerator, StretchEvent
+from ..util.stretchability import StretchabilityAnalyzer
+from ._rust_extensions import get_rust_operation
+from .core import AttackOrder, AttackWave, Gaggle
+from .core import Glitchling as GlitchlingBase
+
+_hokey_rust = get_rust_operation("hokey")
+_ANALYZER = StretchabilityAnalyzer()
+_GENERATOR = HokeyGenerator(analyzer=_ANALYZER)
+
+
+def _python_extend_vowels(
+    text: str,
+    *,
+    rate: float,
+    extension_min: int,
+    extension_max: int,
+    word_length_threshold: int,
+    base_p: float,
+    rng: random.Random,
+    return_trace: bool = False,
+) -> str | tuple[str, list[StretchEvent]]:
+    config = HokeyConfig(
+        rate=rate,
+        extension_min=extension_min,
+        extension_max=extension_max,
+        word_length_threshold=word_length_threshold,
+        base_p=base_p,
+    )
+    result, events = _GENERATOR.generate(text, rng=rng, config=config)
+    return (result, events) if return_trace else result
+
+
+def extend_vowels(
+    text: str,
+    rate: float = 0.3,
+    extension_min: int = 2,
+    extension_max: int = 5,
+    word_length_threshold: int = 6,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    return_trace: bool = False,
+    base_p: float | None = None,
+) -> str | tuple[str, list[StretchEvent]]:
+    """Extend expressive segments of words for emphasis.
+
+    Parameters
+    ----------
+    text : str
+        Input text to transform.
+    rate : float, optional
+        Global selection rate for candidate words.
+    extension_min : int, optional
+        Minimum number of extra repetitions for the stretch unit.
+    extension_max : int, optional
+        Maximum number of extra repetitions for the stretch unit.
+    word_length_threshold : int, optional
+        Preferred maximum alphabetic length; longer words are de-emphasised but not
+        excluded.
+    seed : int, optional
+        Deterministic seed when ``rng`` is not supplied.
+    rng : random.Random, optional
+        Random number generator to drive sampling.
+    return_trace : bool, optional
+        When ``True`` also return the stretch events for introspection.
+    base_p : float, optional
+        Base probability for the negative-binomial sampler (heavier tails for smaller
+        values). Defaults to ``0.45``.
+    """
+    if not text:
+        empty_trace: list[StretchEvent] = []
+        return (text, empty_trace) if return_trace else text
+
+    if rng is None:
+        rng = random.Random(seed)
+    base_probability = base_p if base_p is not None else 0.45
+
+    if return_trace or _hokey_rust is None:
+        return _python_extend_vowels(
+            text,
+            rate=rate,
+            extension_min=extension_min,
+            extension_max=extension_max,
+            word_length_threshold=word_length_threshold,
+            base_p=base_probability,
+            rng=rng,
+            return_trace=return_trace,
+        )
+
+    return cast(
+        str,
+        _hokey_rust(
+            text,
+            rate,
+            extension_min,
+            extension_max,
+            word_length_threshold,
+            base_probability,
+            rng,
+        ),
+    )
+
+
+class Hokey(GlitchlingBase):
+    """Glitchling that stretches words using linguistic heuristics."""
+
+    seed: int | None
+
+    def __init__(
+        self,
+        *,
+        rate: float = 0.3,
+        extension_min: int = 2,
+        extension_max: int = 5,
+        word_length_threshold: int = 6,
+        base_p: float = 0.45,
+        seed: int | None = None,
+    ) -> None:
+        self._master_seed: int | None = seed
+
+        def _corruption_wrapper(text: str, **kwargs: Any) -> str:
+            result = extend_vowels(text, **kwargs)
+            return result if isinstance(result, str) else result[0]
+
+        super().__init__(
+            name="Hokey",
+            corruption_function=_corruption_wrapper,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.FIRST,
+            seed=seed,
+            rate=rate,
+            extension_min=extension_min,
+            extension_max=extension_max,
+            word_length_threshold=word_length_threshold,
+            base_p=base_p,
+        )
+
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        return {
+            "type": "hokey",
+            "rate": self.kwargs.get("rate", 0.3),
+            "extension_min": self.kwargs.get("extension_min", 2),
+            "extension_max": self.kwargs.get("extension_max", 5),
+            "word_length_threshold": self.kwargs.get("word_length_threshold", 6),
+            "base_p": self.kwargs.get("base_p", 0.45),
+        }
+
+    def reset_rng(self, seed: int | None = None) -> None:
+        if seed is not None:
+            self._master_seed = seed
+            super().reset_rng(seed)
+            if self.seed is None:
+                return
+            derived = Gaggle.derive_seed(int(seed), self.name, 0)
+            self.seed = int(derived)
+            self.rng = random.Random(self.seed)
+            self.kwargs["seed"] = self.seed
+        else:
+            super().reset_rng(None)
+
+
+hokey = Hokey()
+
+
+__all__ = ["Hokey", "hokey", "extend_vowels"]

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,
         }