glitchlings 0.2.3__cp310-cp310-manylinux_2_28_x86_64.whl

glitchlings/zoo/reduple.py

@@ -0,0 +1,128 @@
+import re
+import random
+from typing import Any
+
+from .core import Glitchling, AttackWave
+from ._rate import resolve_rate
+
+try:
+    from glitchlings._zoo_rust import reduplicate_words as _reduplicate_words_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _reduplicate_words_rust = None
+
+
+def _python_reduplicate_words(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+) -> 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.
+
+    Notes
+    - Preserves spacing and punctuation by tokenizing with separators.
+    - Deterministic when run with a fixed seed or via Gaggle.
+    """
+    # Preserve exact spacing and punctuation by using regex
+    tokens = re.split(r"(\s+)", text)  # Split but keep separators
+
+    for i in range(0, len(tokens), 2):  # Every other token is a word
+        if i >= len(tokens):
+            break
+
+        word = tokens[i]
+        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}"
+            else:
+                tokens[i] = f"{word} {word}"
+    return "".join(tokens)
+
+
+def reduplicate_words(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    reduplication_rate: float | None = None,
+) -> str:
+    """Randomly reduplicate words in the text.
+
+    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.05,
+        legacy_name="reduplication_rate",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    clamped_rate = max(0.0, effective_rate)
+
+    if _reduplicate_words_rust is not None:
+        return _reduplicate_words_rust(text, clamped_rate, rng)
+
+    return _python_reduplicate_words(
+        text,
+        rate=clamped_rate,
+        rng=rng,
+    )
+
+
+class Reduple(Glitchling):
+    """Glitchling that repeats words to simulate stuttering speech."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        reduplication_rate: float | None = None,
+        seed: int | None = None,
+    ) -> None:
+        self._param_aliases = {"reduplication_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=reduplication_rate,
+            default=0.05,
+            legacy_name="reduplication_rate",
+        )
+        super().__init__(
+            name="Reduple",
+            corruption_function=reduplicate_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            rate=effective_rate,
+        )
+
+    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)}
+
+
+
+reduple = Reduple()
+
+
+__all__ = ["Reduple", "reduple"]

glitchlings/zoo/rushmore.py

@@ -0,0 +1,136 @@
+import math
+import random
+import re
+from typing import Any
+
+from .core import Glitchling, AttackWave
+from ._rate import resolve_rate
+
+try:
+    from glitchlings._zoo_rust import delete_random_words as _delete_random_words_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _delete_random_words_rust = None
+
+
+def _python_delete_random_words(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+) -> str:
+    """Delete random words from the input text while preserving whitespace."""
+
+    if rate <= 0.0:
+        return text
+
+    tokens = re.split(r"(\s+)", text)  # Split but keep separators for later rejoin
+
+    candidate_indices: list[int] = []
+    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)
+
+    allowed_deletions = min(
+        len(candidate_indices), math.floor(len(candidate_indices) * rate)
+    )
+    if allowed_deletions <= 0:
+        return text
+
+    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()}"
+            else:
+                tokens[i] = ""
+
+            deletions += 1
+            if deletions >= allowed_deletions:
+                break
+
+    text = "".join(tokens)
+    text = re.sub(r"\s+([.,;:])", r"\1", text)
+    text = re.sub(r"\s{2,}", " ", text).strip()
+
+    return text
+
+
+def delete_random_words(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    max_deletion_rate: float | None = None,
+) -> 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",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    clamped_rate = max(0.0, effective_rate)
+
+    if _delete_random_words_rust is not None:
+        return _delete_random_words_rust(text, clamped_rate, rng)
+
+    return _python_delete_random_words(
+        text,
+        rate=clamped_rate,
+        rng=rng,
+    )
+
+
+class Rushmore(Glitchling):
+    """Glitchling that deletes words to simulate missing information."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        max_deletion_rate: float | None = None,
+        seed: int | None = None,
+    ) -> 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",
+        )
+        super().__init__(
+            name="Rushmore",
+            corruption_function=delete_random_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            rate=effective_rate,
+        )
+
+    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
+        return {"type": "delete", "max_deletion_rate": float(rate)}
+
+
+rushmore = Rushmore()
+
+
+__all__ = ["Rushmore", "rushmore"]

glitchlings/zoo/scannequin.py

@@ -0,0 +1,171 @@
+import re
+import random
+from typing import Any
+
+from ._ocr_confusions import load_confusion_table
+from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
+
+try:
+    from glitchlings._zoo_rust import ocr_artifacts as _ocr_artifacts_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _ocr_artifacts_rust = None
+
+
+def _python_ocr_artifacts(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+) -> str:
+    """Introduce OCR-like artifacts into text.
+
+    Parameters
+    - text: Input text to corrupt.
+    - rate: Max proportion of eligible confusion matches to replace (default 0.02).
+    - seed: Optional seed if `rng` not provided.
+    - rng: Optional RNG; overrides seed.
+
+    Notes
+    - Uses a curated set of common OCR confusions (rn↔m, cl↔d, O↔0, l/I/1, etc.).
+    - Collects all non-overlapping candidate spans in reading order, then samples
+      a subset deterministically with the provided RNG.
+    - Replacements can change length (e.g., m→rn), so edits are applied from left
+      to right using precomputed spans to avoid index drift.
+    """
+    if not text:
+        return text
+
+    # Keep the confusion definitions in a shared data file so both the Python
+    # and Rust implementations stay in sync.
+    confusion_table = load_confusion_table()
+
+    # Build candidate matches as (start, end, choices)
+    candidates: list[tuple[int, int, list[str]]] = []
+
+    # To avoid double-counting overlapping patterns (like 'l' inside 'li'),
+    # we will scan longer patterns first by sorting by len(src) desc.
+    for src, choices in sorted(confusion_table, key=lambda p: -len(p[0])):
+        pattern = re.escape(src)
+        for m in re.finditer(pattern, text):
+            start, end = m.span()
+            candidates.append((start, end, choices))
+
+    if not candidates:
+        return text
+
+    # Decide how many to replace
+    k = int(len(candidates) * rate)
+    if k <= 0:
+        return text
+
+    # Shuffle deterministically and select non-overlapping k spans
+    rng.shuffle(candidates)
+    chosen: list[tuple[int, int, str]] = []
+    occupied: list[tuple[int, int]] = []
+
+    def overlaps(a: tuple[int, int], b: tuple[int, int]) -> bool:
+        return not (a[1] <= b[0] or b[1] <= a[0])
+
+    for start, end, choices in candidates:
+        if len(chosen) >= k:
+            break
+        span = (start, end)
+        if any(overlaps(span, occ) for occ in occupied):
+            continue
+        replacement = rng.choice(choices)
+        chosen.append((start, end, replacement))
+        occupied.append(span)
+
+    if not chosen:
+        return text
+
+    # Apply edits from left to right
+    chosen.sort(key=lambda t: t[0])
+    out_parts = []
+    cursor = 0
+    for start, end, rep in chosen:
+        if cursor < start:
+            out_parts.append(text[cursor:start])
+        out_parts.append(rep)
+        cursor = end
+    if cursor < len(text):
+        out_parts.append(text[cursor:])
+
+    return "".join(out_parts)
+
+
+def ocr_artifacts(
+    text: str,
+    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.
+
+    Prefers the Rust implementation when available.
+    """
+
+    if not text:
+        return text
+
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=error_rate,
+        default=0.02,
+        legacy_name="error_rate",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    clamped_rate = max(0.0, effective_rate)
+
+    if _ocr_artifacts_rust is not None:
+        return _ocr_artifacts_rust(text, clamped_rate, rng)
+
+    return _python_ocr_artifacts(text, rate=clamped_rate, rng=rng)
+
+
+class Scannequin(Glitchling):
+    """Glitchling that simulates OCR artifacts using common confusions."""
+
+    def __init__(
+        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",
+        )
+        super().__init__(
+            name="Scannequin",
+            corruption_function=ocr_artifacts,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.LATE,
+            seed=seed,
+            rate=effective_rate,
+        )
+
+    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)}
+
+
+
+scannequin = Scannequin()
+
+
+__all__ = ["Scannequin", "scannequin"]

glitchlings/zoo/typogre.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import math
+import random
+from typing import Optional
+
+from .core import Glitchling, AttackWave, AttackOrder
+from ._rate import resolve_rate
+from ..util import KEYNEIGHBORS
+
+try:
+    from glitchlings._zoo_rust import fatfinger as _fatfinger_rust
+except ImportError:  # pragma: no cover - compiled extension not present
+    _fatfinger_rust = None
+
+
+def _python_unichar(text: str, rng: random.Random) -> str:
+    """Collapse one random doubled letter (like 'ee' in 'seed') to a single occurrence."""
+    import re
+
+    matches = list(re.finditer(r"((.)\2)(?=\w)", text))
+    if not matches:
+        return text
+    start, end = rng.choice(matches).span(1)
+    return text[:start] + text[start] + text[end:]
+
+
+def _python_skipped_space(text: str, rng: random.Random) -> str:
+    import re
+
+    space_positions = [m.start() for m in re.finditer(r" ", text)]
+    if not space_positions:
+        return text
+    idx = rng.choice(space_positions)
+    return text[:idx] + text[idx + 1 :]
+
+
+def _python_random_space(text: str, rng: random.Random) -> str:
+    if len(text) < 2:
+        return text
+    idx = rng.randrange(1, len(text))
+    return text[:idx] + " " + text[idx:]
+
+
+def _python_repeated_char(text: str, rng: random.Random) -> str:
+    positions = [i for i, c in enumerate(text) if not c.isspace()]
+    if not positions:
+        return text
+    i = rng.choice(positions)
+    return text[:i] + text[i] + text[i:]
+
+
+def _python_is_word_char(c: str) -> bool:
+    return c.isalnum() or c == "_"
+
+
+def _python_eligible_idx(s: str, i: int) -> bool:
+    if i < 0 or i >= len(s):
+        return False
+    if not _python_is_word_char(s[i]):
+        return False
+    left_ok = i > 0 and _python_is_word_char(s[i - 1])
+    right_ok = i + 1 < len(s) and _python_is_word_char(s[i + 1])
+    return left_ok and right_ok
+
+
+def _python_draw_eligible_index(
+    rng: random.Random, s: str, max_tries: int = 16
+) -> Optional[int]:
+    n = len(s)
+    if n == 0:
+        return None
+    for _ in range(max_tries):
+        i = rng.randrange(n)
+        if _python_eligible_idx(s, i):
+            return i
+    start = rng.randrange(n)
+    i = start
+    while True:
+        if _python_eligible_idx(s, i):
+            return i
+        i += 1
+        if i == n:
+            i = 0
+        if i == start:
+            return None
+
+
+def _fatfinger_python(
+    text: str,
+    *,
+    rate: float,
+    layout: dict[str, list[str]],
+    rng: random.Random,
+) -> str:
+    if rate <= 0.0:
+        return text
+
+    s = text
+    max_changes = math.ceil(len(s) * rate)
+    if max_changes == 0:
+        return s
+
+    positional_actions = ("char_swap", "missing_char", "extra_char", "nearby_char")
+    global_actions = ("skipped_space", "random_space", "unichar", "repeated_char")
+    all_actions = positional_actions + global_actions
+
+    actions_drawn = [rng.choice(all_actions) for _ in range(max_changes)]
+
+    for action in actions_drawn:
+        if action in positional_actions:
+            idx = _python_draw_eligible_index(rng, s)
+            if idx is None:
+                continue
+            if action == "char_swap":
+                j = idx + 1
+                s = s[:idx] + s[j] + s[idx] + s[j + 1 :]
+            elif action == "missing_char":
+                if _python_eligible_idx(s, idx):
+                    s = s[:idx] + s[idx + 1 :]
+            elif action == "extra_char":
+                ch = s[idx]
+                neighbors = layout.get(ch.lower(), []) or [ch]
+                ins = rng.choice(neighbors) or ch
+                s = s[:idx] + ins + s[idx:]
+            elif action == "nearby_char":
+                ch = s[idx]
+                neighbors = layout.get(ch.lower(), [])
+                if neighbors:
+                    rep = rng.choice(neighbors)
+                    s = s[:idx] + rep + s[idx + 1 :]
+        else:
+            if action == "skipped_space":
+                s = _python_skipped_space(s, rng)
+            elif action == "random_space":
+                s = _python_random_space(s, rng)
+            elif action == "unichar":
+                s = _python_unichar(s, rng)
+            elif action == "repeated_char":
+                s = _python_repeated_char(s, rng)
+    return s
+
+
+def fatfinger(
+    text: str,
+    rate: float | None = None,
+    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",
+    )
+
+    if rng is None:
+        rng = random.Random(seed)
+    if not text:
+        return ""
+
+    clamped_rate = max(0.0, effective_rate)
+    if clamped_rate == 0.0:
+        return text
+
+    layout = getattr(KEYNEIGHBORS, keyboard)
+
+    if _fatfinger_rust is not None:
+        return _fatfinger_rust(text, max_change_rate=clamped_rate, layout=layout, rng=rng)
+
+    return _fatfinger_python(text, rate=clamped_rate, layout=layout, rng=rng)
+
+
+class Typogre(Glitchling):
+    """Glitchling that introduces deterministic keyboard-typing errors."""
+
+    def __init__(
+        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",
+        )
+        super().__init__(
+            name="Typogre",
+            corruption_function=fatfinger,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.EARLY,
+            seed=seed,
+            rate=effective_rate,
+            keyboard=keyboard,
+        )
+
+
+typogre = Typogre()
+
+
+__all__ = ["Typogre", "typogre"]
+