glitchlings 0.2.4__cp312-cp312-win_amd64.whl → 0.2.6__cp312-cp312-win_amd64.whl

glitchlings/__init__.py

@@ -13,6 +13,8 @@ from .zoo import (
     rushmore,
     Scannequin,
     scannequin,
+    Zeedub,
+    zeedub,
     Glitchling,
     Gaggle,
     summon,
@@ -35,6 +37,8 @@ __all__ = [
     "rushmore",
     "Scannequin",
     "scannequin",
+    "Zeedub",
+    "zeedub",
     "summon",
     "Glitchling",
     "Gaggle",

glitchlings/dlc/prime.py

@@ -49,7 +49,24 @@ def _resolve_columns(dataset: Dataset, columns: Sequence[str] | None) -> list[st
         if candidate in available:
             return [candidate]
 
-    sample = dataset[0] if len(dataset) else {}
+    try:
+        dataset_length = len(dataset)  # type: ignore[arg-type]
+    except TypeError:
+        preview_rows: list[dict[str, Any]]
+        take_fn = getattr(dataset, "take", None)
+        if callable(take_fn):
+            preview_rows = list(take_fn(1))
+        else:
+            iterator = iter(dataset)
+            try:
+                first_row = next(iterator)
+            except StopIteration:
+                preview_rows = []
+            else:
+                preview_rows = [first_row]
+        sample = dict(preview_rows[0]) if preview_rows else {}
+    else:
+        sample = dataset[0] if dataset_length else {}
     inferred = [
         name
         for name in dataset.column_names

glitchlings/zoo/__init__.py

@@ -10,6 +10,7 @@ from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
 from .scannequin import Scannequin, scannequin
+from .zeedub import Zeedub, zeedub
 from .core import Glitchling, Gaggle
 
 __all__ = [
@@ -27,6 +28,8 @@ __all__ = [
     "redactyl",
     "Scannequin",
     "scannequin",
+    "Zeedub",
+    "zeedub",
     "Glitchling",
     "Gaggle",
     "summon",
@@ -40,7 +43,7 @@ _HAS_JARGOYLE = _jargoyle_available()
 _BUILTIN_GLITCHLING_LIST: list[Glitchling] = [typogre, mim1c]
 if _HAS_JARGOYLE:
     _BUILTIN_GLITCHLING_LIST.append(jargoyle)
-_BUILTIN_GLITCHLING_LIST.extend([reduple, rushmore, redactyl, scannequin])
+_BUILTIN_GLITCHLING_LIST.extend([reduple, rushmore, redactyl, scannequin, zeedub])
 
 BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
     glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
@@ -53,6 +56,7 @@ _BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
     rushmore.name.lower(): Rushmore,
     redactyl.name.lower(): Redactyl,
     scannequin.name.lower(): Scannequin,
+    zeedub.name.lower(): Zeedub,
 }
 if _HAS_JARGOYLE:
     _BUILTIN_GLITCHLING_TYPES[jargoyle.name.lower()] = Jargoyle

glitchlings/zoo/core.py

@@ -27,17 +27,25 @@ log = logging.getLogger(__name__)
 
 
 _PIPELINE_FEATURE_FLAG_ENV = "GLITCHLINGS_RUST_PIPELINE"
+_PIPELINE_ENABLE_VALUES = {"1", "true", "yes", "on"}
+_PIPELINE_DISABLE_VALUES = {"0", "false", "no", "off"}
 
 
 def _pipeline_feature_flag_enabled() -> bool:
-    """Return ``True`` when the environment explicitly opts into the Rust pipeline."""
+    """Return ``True`` when the environment does not explicitly disable the Rust pipeline."""
 
     value = os.environ.get(_PIPELINE_FEATURE_FLAG_ENV)
     if value is None:
-        return False
+        return True
 
     normalized = value.strip().lower()
-    return normalized in {"1", "true", "yes", "on"}
+    if normalized in _PIPELINE_DISABLE_VALUES:
+        return False
+
+    if normalized in _PIPELINE_ENABLE_VALUES:
+        return True
+
+    return True
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from datasets import Dataset  # type: ignore
@@ -356,7 +364,7 @@ class Gaggle(Glitchling):
 
     @staticmethod
     def rust_pipeline_enabled() -> bool:
-        """Return ``True`` when the Rust pipeline is available and opted in."""
+        """Return ``True`` when the Rust pipeline is available and not explicitly disabled."""
 
         return Gaggle.rust_pipeline_supported() and _pipeline_feature_flag_enabled()
 

glitchlings/zoo/redactyl.py

@@ -14,6 +14,41 @@ except ImportError:  # pragma: no cover - compiled extension not present
     _redact_words_rust = None
 
 
+def _weighted_sample_without_replacement(
+    population: list[int],
+    weights: list[float],
+    *,
+    k: int,
+    rng: random.Random,
+) -> list[int]:
+    """Select `k` unique indices according to the given weights."""
+
+    selections: list[int] = []
+    items = list(zip(population, weights))
+    if k <= 0 or not items:
+        return selections
+    if k > len(items):
+        raise ValueError("Sample larger than population or is negative")
+
+    for _ in range(k):
+        total_weight = sum(weight for _, weight in items)
+        if total_weight <= 0:
+            chosen_index = rng.randrange(len(items))
+        else:
+            threshold = rng.random() * total_weight
+            cumulative = 0.0
+            chosen_index = len(items) - 1
+            for idx, (_, weight) in enumerate(items):
+                cumulative += weight
+                if cumulative >= threshold:
+                    chosen_index = idx
+                    break
+        value, _ = items.pop(chosen_index)
+        selections.append(value)
+
+    return selections
+
+
 def _python_redact_words(
     text: str,
     *,
@@ -21,6 +56,7 @@ def _python_redact_words(
     rate: float,
     merge_adjacent: bool,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Redact random words by replacing their characters.
 
@@ -29,18 +65,39 @@ def _python_redact_words(
     - replacement_char: The character to use for redaction (default FULL_BLOCK).
     - rate: Max proportion of words to redact (default 0.05).
     - merge_adjacent: If True, merges adjacent redactions across intervening non-word chars.
-    - seed: Seed used if `rng` not provided (default 151).
-    - rng: Optional RNG; overrides seed.
+    - rng: RNG used for sampling decisions.
+    - unweighted: When True, sample words uniformly instead of by length.
     """
     # Preserve exact spacing and punctuation by using regex
     tokens = re.split(r"(\s+)", text)
     word_indices = [i for i, token in enumerate(tokens) if i % 2 == 0 and token.strip()]
     if not word_indices:
-        raise ValueError("Cannot redact words because the input text contains no redactable words.")
-    num_to_redact = max(1, int(len(word_indices) * rate))
-
-    # Sample from the indices of actual words
-    indices_to_redact = rng.sample(word_indices, k=num_to_redact)
+        raise ValueError(
+            "Cannot redact words because the input text contains no redactable words."
+        )
+    weights: list[float] = []
+    for index in word_indices:
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weights.append(1.0 if unweighted else float(core_length))
+    raw_quota = len(word_indices) * rate
+    num_to_redact = int(raw_quota)
+    if rate > 0:
+        num_to_redact = max(1, num_to_redact)
+    if num_to_redact > len(word_indices):
+        raise ValueError("Sample larger than population or is negative")
+    indices_to_redact = _weighted_sample_without_replacement(
+        word_indices,
+        weights,
+        k=num_to_redact,
+        rng=rng,
+    )
     indices_to_redact.sort()
 
     for i in indices_to_redact:
@@ -80,13 +137,14 @@ def redact_words(
     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.05,
+        default=0.025,
         legacy_name="redaction_rate",
     )
 
@@ -94,6 +152,7 @@ def redact_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
 
@@ -103,6 +162,7 @@ def redact_words(
             replacement_char,
             clamped_rate,
             merge_adjacent,
+            unweighted_flag,
             rng,
         )
 
@@ -112,6 +172,7 @@ def redact_words(
         rate=clamped_rate,
         merge_adjacent=merge_adjacent,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -126,12 +187,13 @@ class Redactyl(Glitchling):
         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.05,
+            default=0.025,
             legacy_name="redaction_rate",
         )
         super().__init__(
@@ -142,6 +204,7 @@ class Redactyl(Glitchling):
             replacement_char=replacement_char,
             rate=effective_rate,
             merge_adjacent=merge_adjacent,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
@@ -150,15 +213,16 @@ class Redactyl(Glitchling):
         merge_adjacent = self.kwargs.get("merge_adjacent")
         if replacement_char is None or rate is None or merge_adjacent is None:
             return None
+        unweighted = bool(self.kwargs.get("unweighted", False))
         return {
             "type": "redact",
             "replacement_char": str(replacement_char),
             "redaction_rate": float(rate),
             "merge_adjacent": bool(merge_adjacent),
+            "unweighted": unweighted,
         }
 
 
-
 redactyl = Redactyl()
 
 

glitchlings/zoo/reduple.py

@@ -16,14 +16,15 @@ def _python_reduplicate_words(
     *,
     rate: float,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Randomly reduplicate words in the text.
 
     Parameters
     - text: Input text.
     - rate: Max proportion of words to reduplicate (default 0.05).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
+    - rng: RNG used for sampling decisions.
+    - unweighted: When True, sample words uniformly instead of length-weighted.
 
     Notes
     - Preserves spacing and punctuation by tokenizing with separators.
@@ -32,6 +33,7 @@ def _python_reduplicate_words(
     # Preserve exact spacing and punctuation by using regex
     tokens = re.split(r"(\s+)", text)  # Split but keep separators
 
+    candidate_weights: list[tuple[int, float]] = []
     for i in range(0, len(tokens), 2):  # Every other token is a word
         if i >= len(tokens):
             break
@@ -40,16 +42,46 @@ def _python_reduplicate_words(
         if not word or word.isspace():  # Skip empty or whitespace
             continue
 
-        # Only consider actual words for reduplication
-        if rng.random() < rate:
-            # Check if word has trailing punctuation
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, core, suffix = match.groups()
-                # Reduplicate with a space: "word" -> "word word"
-                tokens[i] = f"{prefix}{core} {core}{suffix}"
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weight = 1.0 if unweighted else 1.0 / core_length
+        candidate_weights.append((i, weight))
+
+    if not candidate_weights:
+        return "".join(tokens)
+
+    effective_rate = max(rate, 0.0)
+    if effective_rate <= 0.0:
+        return "".join(tokens)
+
+    mean_weight = sum(weight for _, weight in candidate_weights) / len(
+        candidate_weights
+    )
+
+    for index, weight in candidate_weights:
+        if effective_rate >= 1.0:
+            probability = 1.0
+        else:
+            if mean_weight <= 0.0:
+                probability = effective_rate
             else:
-                tokens[i] = f"{word} {word}"
+                probability = min(1.0, effective_rate * (weight / mean_weight))
+        if rng.random() >= probability:
+            continue
+
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        if match:
+            prefix, core, suffix = match.groups()
+            # Reduplicate with a space: "word" -> "word word"
+            tokens[index] = f"{prefix}{core} {core}{suffix}"
+        else:
+            tokens[index] = f"{word} {word}"
     return "".join(tokens)
 
 
@@ -60,6 +92,7 @@ def reduplicate_words(
     rng: random.Random | None = None,
     *,
     reduplication_rate: float | None = None,
+    unweighted: bool = False,
 ) -> str:
     """Randomly reduplicate words in the text.
 
@@ -70,7 +103,7 @@ def reduplicate_words(
     effective_rate = resolve_rate(
         rate=rate,
         legacy_value=reduplication_rate,
-        default=0.05,
+        default=0.01,
         legacy_name="reduplication_rate",
     )
 
@@ -78,14 +111,16 @@ def reduplicate_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     if _reduplicate_words_rust is not None:
-        return _reduplicate_words_rust(text, clamped_rate, rng)
+        return _reduplicate_words_rust(text, clamped_rate, unweighted_flag, rng)
 
     return _python_reduplicate_words(
         text,
         rate=clamped_rate,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -98,12 +133,13 @@ class Reduple(Glitchling):
         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.05,
+            default=0.01,
             legacy_name="reduplication_rate",
         )
         super().__init__(
@@ -112,14 +148,19 @@ class Reduple(Glitchling):
             scope=AttackWave.WORD,
             seed=seed,
             rate=effective_rate,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
         rate = self.kwargs.get("rate")
         if rate is None:
             return None
-        return {"type": "reduplicate", "reduplication_rate": float(rate)}
-
+        unweighted = bool(self.kwargs.get("unweighted", False))
+        return {
+            "type": "reduplicate",
+            "reduplication_rate": float(rate),
+            "unweighted": unweighted,
+        }
 
 
 reduple = Reduple()

glitchlings/zoo/rushmore.py

@@ -17,42 +17,67 @@ def _python_delete_random_words(
     *,
     rate: float,
     rng: random.Random,
+    unweighted: bool = False,
 ) -> str:
     """Delete random words from the input text while preserving whitespace."""
 
-    if rate <= 0.0:
+    effective_rate = max(rate, 0.0)
+    if effective_rate <= 0.0:
         return text
 
     tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
 
-    candidate_indices: list[int] = []
+    candidate_data: list[tuple[int, float]] = []
     for i in range(2, len(tokens), 2):  # Every other token is a word, skip the first word
         word = tokens[i]
         if not word or word.isspace():
             continue
 
-        candidate_indices.append(i)
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        core = match.group(2) if match else word
+        core_length = len(core) if core else len(word)
+        if core_length <= 0:
+            core_length = len(word.strip()) or len(word)
+        if core_length <= 0:
+            core_length = 1
+        weight = 1.0 if unweighted else 1.0 / core_length
+        candidate_data.append((i, weight))
+
+    if not candidate_data:
+        return text
 
     allowed_deletions = min(
-        len(candidate_indices), math.floor(len(candidate_indices) * rate)
+        len(candidate_data), math.floor(len(candidate_data) * effective_rate)
     )
     if allowed_deletions <= 0:
         return text
 
+    mean_weight = sum(weight for _, weight in candidate_data) / len(candidate_data)
+
     deletions = 0
-    for i in candidate_indices:
-        if rng.random() < rate:
-            word = tokens[i]
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, _, suffix = match.groups()
-                tokens[i] = f"{prefix.strip()}{suffix.strip()}"
+    for index, weight in candidate_data:
+        if deletions >= allowed_deletions:
+            break
+
+        if effective_rate >= 1.0:
+            probability = 1.0
+        else:
+            if mean_weight <= 0.0:
+                probability = effective_rate
             else:
-                tokens[i] = ""
+                probability = min(1.0, effective_rate * (weight / mean_weight))
+        if rng.random() >= probability:
+            continue
+
+        word = tokens[index]
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        if match:
+            prefix, _, suffix = match.groups()
+            tokens[index] = f"{prefix.strip()}{suffix.strip()}"
+        else:
+            tokens[index] = ""
 
-            deletions += 1
-            if deletions >= allowed_deletions:
-                break
+        deletions += 1
 
     text = "".join(tokens)
     text = re.sub(r"\s+([.,;:])", r"\1", text)
@@ -68,6 +93,7 @@ def delete_random_words(
     rng: random.Random | None = None,
     *,
     max_deletion_rate: float | None = None,
+    unweighted: bool = False,
 ) -> str:
     """Delete random words from the input text.
 
@@ -85,14 +111,16 @@ def delete_random_words(
         rng = random.Random(seed)
 
     clamped_rate = max(0.0, effective_rate)
+    unweighted_flag = bool(unweighted)
 
     if _delete_random_words_rust is not None:
-        return _delete_random_words_rust(text, clamped_rate, rng)
+        return _delete_random_words_rust(text, clamped_rate, unweighted_flag, rng)
 
     return _python_delete_random_words(
         text,
         rate=clamped_rate,
         rng=rng,
+        unweighted=unweighted_flag,
     )
 
 
@@ -105,6 +133,7 @@ class Rushmore(Glitchling):
         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(
@@ -119,6 +148,7 @@ class Rushmore(Glitchling):
             scope=AttackWave.WORD,
             seed=seed,
             rate=effective_rate,
+            unweighted=unweighted,
         )
 
     def pipeline_operation(self) -> dict[str, Any] | None:
@@ -127,7 +157,12 @@ class Rushmore(Glitchling):
             rate = self.kwargs.get("max_deletion_rate")
         if rate is None:
             return None
-        return {"type": "delete", "max_deletion_rate": float(rate)}
+        unweighted = bool(self.kwargs.get("unweighted", False))
+        return {
+            "type": "delete",
+            "max_deletion_rate": float(rate),
+            "unweighted": unweighted,
+        }
 
 
 rushmore = Rushmore()

glitchlings/zoo/zeedub.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import math
+import random
+from collections.abc import Sequence
+
+from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
+
+try:
+    from glitchlings._zoo_rust import inject_zero_widths as _inject_zero_widths_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _inject_zero_widths_rust = None
+
+_DEFAULT_ZERO_WIDTH_CHARACTERS: tuple[str, ...] = (
+    "\u200b",  # ZERO WIDTH SPACE
+    "\u200c",  # ZERO WIDTH NON-JOINER
+    "\u200d",  # ZERO WIDTH JOINER
+    "\ufeff",  # ZERO WIDTH NO-BREAK SPACE
+    "\u2060",  # WORD JOINER
+)
+
+
+def _python_insert_zero_widths(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+    characters: Sequence[str],
+) -> str:
+    if not text:
+        return text
+
+    palette = [char for char in characters if char]
+    if not palette:
+        return text
+
+    positions = [
+        index + 1
+        for index in range(len(text) - 1)
+        if not text[index].isspace() and not text[index + 1].isspace()
+    ]
+    if not positions:
+        return text
+
+    total = len(positions)
+    clamped_rate = max(0.0, rate)
+    if clamped_rate <= 0.0:
+        return text
+
+    target = clamped_rate * total
+    count = math.floor(target)
+    remainder = target - count
+    if remainder > 0.0 and rng.random() < remainder:
+        count += 1
+    count = min(total, count)
+
+    if count <= 0:
+        return text
+
+    chosen = rng.sample(positions, count)
+    chosen.sort()
+
+    chars = list(text)
+    for position in reversed(chosen):
+        chars.insert(position, rng.choice(palette))
+
+    return "".join(chars)
+
+
+def insert_zero_widths(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    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",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    palette: Sequence[str] = (
+        tuple(characters) if characters is not None else _DEFAULT_ZERO_WIDTH_CHARACTERS
+    )
+
+    cleaned_palette = tuple(char for char in palette if char)
+    if not cleaned_palette or not text:
+        return text
+
+    clamped_rate = max(0.0, effective_rate)
+    if clamped_rate == 0.0:
+        return text
+
+    if _inject_zero_widths_rust is not None:
+        return _inject_zero_widths_rust(text, clamped_rate, list(cleaned_palette), rng)
+
+    return _python_insert_zero_widths(
+        text,
+        rate=clamped_rate,
+        rng=rng,
+        characters=cleaned_palette,
+    )
+
+
+class Zeedub(Glitchling):
+    """Glitchling that plants zero-width glyphs inside words."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        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",
+        )
+        super().__init__(
+            name="Zeedub",
+            corruption_function=insert_zero_widths,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.LAST,
+            seed=seed,
+            rate=effective_rate,
+            characters=tuple(characters) if characters is not None else None,
+        )
+
+
+zeedub = Zeedub()
+
+
+__all__ = ["Zeedub", "zeedub", "insert_zero_widths"]

{glitchlings-0.2.4.dist-info → glitchlings-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.4
+Version: 0.2.6
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -296,7 +296,7 @@ print(gaggle(SAMPLE_TEXT))
 
 Consult the [Glitchlings Usage Guide](docs/index.md)
 for end-to-end instructions spanning the Python API, CLI, HuggingFace and Prime Intellect
-integrations, and the feature-flagged Rust pipeline.
+integrations, and the autodetected Rust pipeline (enabled whenever the extension is present).
 
 ## Motivation
 
@@ -396,6 +396,18 @@ _How can a computer need reading glasses?_
 > - `rate (float)`: The maximum proportion of eligible confusion spans to replace (default: 0.02, 2%).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
+### Zeedub
+
+_A whispering glyph parasite that lives in the interstices of codepoints, marking territory with invisible traces._
+
+> _**Invisible Ink.**_ Zeedub slips zero-width codepoints between non-space character pairs, forcing models to reason about text whose visible form masks hidden glyphs.
+>
+> Args
+>
+> - `rate (float)`: Expected number of zero-width insertions as a proportion of eligible bigrams (default: 0.02, 2%).
+> - `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).
+
 ### Jargoyle
 
 _Uh oh. The worst person you know just bought a thesaurus._

glitchlings-0.2.6.dist-info/RECORD

@@ -0,0 +1,27 @@
+glitchlings/__init__.py,sha256=fjerquRITZQY_rY5mhTVVQyeGAz1qTpgicvDhbpqgi8,678
+glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
+glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=ix_yBFGWDMdQqMgg0-RlHdnayxiTeJd_N1SQN5XfDhc,2019328
+glitchlings/main.py,sha256=QrSSLWcKh1_NDfJDGh-3UVKdI7AkzfMy6Jz1ouxIgnE,6149
+glitchlings/dlc/__init__.py,sha256=IHD-GGhVFb7SVzErvf2YCJkOR4wGo0nFHXkn_daMvS8,146
+glitchlings/dlc/huggingface.py,sha256=PIesnDIEvyJxj1IuLw2P9nVPTr4Nv81XM7w2axfyhkA,3029
+glitchlings/dlc/prime.py,sha256=b5CE1qDl5MxZjTudlKrqMsmSGxXNKZ16krqPyrr2nK8,9569
+glitchlings/util/__init__.py,sha256=GoyQuHTfGRkHzuZwJji6QWSiGd_LHa9QiyjjEpBFW7E,4679
+glitchlings/zoo/__init__.py,sha256=mAhsnR3ZK9BocxT3J4WF6JcYQMYI9e_EYZ-GMxHv0P4,4420
+glitchlings/zoo/_ocr_confusions.py,sha256=W59Aa5MBDwRF65f8GV-6XwGAmlR5Uk7pa5qvHvhIYdY,1252
+glitchlings/zoo/_rate.py,sha256=EYUWXYyR2IK0zYBWyBOlnUjDxU32JE9mZTZeodVx5CA,548
+glitchlings/zoo/core.py,sha256=B0E9ycaG9oAOSf2n2gJ4iFbWSjhRUDOdlLIJYeWqICs,14649
+glitchlings/zoo/jargoyle.py,sha256=1fnL_8bv1Y-T2h1C6NRzIylYyOuAUI-BiMReFewqh00,11002
+glitchlings/zoo/mim1c.py,sha256=3ddNOzWgLABuEOh5T98Xk439ejx-YHGI7ErXET03Crc,3537
+glitchlings/zoo/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
+glitchlings/zoo/redactyl.py,sha256=jPEzP9b6_AizY1xOP4LgjJwWdpZv3Qr7JQPWK96609Y,7012
+glitchlings/zoo/reduple.py,sha256=oGkOkH9bJiG-ogsi5ewglq6FUmzvRM6UC4N61LyNdvk,5026
+glitchlings/zoo/rushmore.py,sha256=RE-br8OAIBRil3Mz381OcdMtb1fuNCZ7LzAjt44hFkM,4900
+glitchlings/zoo/scannequin.py,sha256=TJyNYTTIB7rxZH3XKIETy0YVf4EjsMgGWYmYaxH9jxU,5030
+glitchlings/zoo/typogre.py,sha256=olTTXDmFkVQ3r-T1vxm2mLomRvIDXHrNHfgin316wzE,6221
+glitchlings/zoo/zeedub.py,sha256=n1qTKE_Dl0m8SEKhaP91oHAyJ484NxaGLPu_ZLr0Ldo,3696
+glitchlings-0.2.6.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
+glitchlings-0.2.6.dist-info/METADATA,sha256=76zHWRnP4ZRH1iVdyu0jujx1zYLVenFYtrbC6i_NTsg,27239
+glitchlings-0.2.6.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+glitchlings-0.2.6.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.2.6.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.2.6.dist-info/RECORD,,

glitchlings-0.2.4.dist-info/RECORD

@@ -1,26 +0,0 @@
-glitchlings/__init__.py,sha256=w8heFqUejrXM_9NNlM9CQnIGkmGUyBV29acg3WsocXA,622
-glitchlings/__main__.py,sha256=pqNe1C9hMf8pap4oh6x6yo2h4Nsa2RFSaMWHfGtNXj0,130
-glitchlings/_zoo_rust.cp312-win_amd64.pyd,sha256=qHk8hPmRrzJTwOyhcBNr-2qhXBaEBUy__7_SMFhzWSc,1989632
-glitchlings/main.py,sha256=QrSSLWcKh1_NDfJDGh-3UVKdI7AkzfMy6Jz1ouxIgnE,6149
-glitchlings/dlc/__init__.py,sha256=IHD-GGhVFb7SVzErvf2YCJkOR4wGo0nFHXkn_daMvS8,146
-glitchlings/dlc/huggingface.py,sha256=PIesnDIEvyJxj1IuLw2P9nVPTr4Nv81XM7w2axfyhkA,3029
-glitchlings/dlc/prime.py,sha256=hySyYBncUM-49j6JtrHYO6c3HpbG2vTt2EYZnOJ85C0,8972
-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/_rate.py,sha256=EYUWXYyR2IK0zYBWyBOlnUjDxU32JE9mZTZeodVx5CA,548
-glitchlings/zoo/core.py,sha256=QKHmzmONNkiA3RdfgLdNx-FPFwoH4Bm-Tkc3vSCHNpc,14412
-glitchlings/zoo/jargoyle.py,sha256=1fnL_8bv1Y-T2h1C6NRzIylYyOuAUI-BiMReFewqh00,11002
-glitchlings/zoo/mim1c.py,sha256=3ddNOzWgLABuEOh5T98Xk439ejx-YHGI7ErXET03Crc,3537
-glitchlings/zoo/ocr_confusions.tsv,sha256=S-IJEYCIXYKT1Uu7Id8Lnvg5pw528yNigTtWUdnMv9k,213
-glitchlings/zoo/redactyl.py,sha256=dM3W59xLhuiS8t5jXETc_L8EEhRN1CpLazBnVPiSknk,4834
-glitchlings/zoo/reduple.py,sha256=9jid6tCvCaiSxWSPMNuHWZitd7et60RRFYeek3S0ElU,3641
-glitchlings/zoo/rushmore.py,sha256=pJy3g_H1z8PNoHitvD3-HsytAuE0U6FOdsdaKZy6OqY,3680
-glitchlings/zoo/scannequin.py,sha256=TJyNYTTIB7rxZH3XKIETy0YVf4EjsMgGWYmYaxH9jxU,5030
-glitchlings/zoo/typogre.py,sha256=olTTXDmFkVQ3r-T1vxm2mLomRvIDXHrNHfgin316wzE,6221
-glitchlings-0.2.4.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.2.4.dist-info/METADATA,sha256=mGKlfmodtLjWsfrz6O0cLk4DDPFeUO5vt6LKgw-uu-M,26513
-glitchlings-0.2.4.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-glitchlings-0.2.4.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.2.4.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.2.4.dist-info/RECORD,,