glitchlings 0.2.5__cp312-cp312-win_amd64.whl → 0.9.3__cp312-cp312-win_amd64.whl

glitchlings/zoo/typogre.py

@@ -1,199 +1,80 @@
 from __future__ import annotations
 
-import math
 import random
-from typing import Optional
+from collections.abc import Mapping, Sequence
+from typing import cast
 
-from .core import Glitchling, AttackWave, AttackOrder
-from ._rate import resolve_rate
-from ..util import KEYNEIGHBORS
+from glitchlings.constants import DEFAULT_TYPOGRE_KEYBOARD, DEFAULT_TYPOGRE_RATE
+from glitchlings.internal.rust_ffi import fatfinger_rust, resolve_seed
 
-try:
-    from glitchlings._zoo_rust import fatfinger as _fatfinger_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _fatfinger_rust = None
+from ..util import KEYNEIGHBORS, SHIFT_MAPS
+from .core import AttackOrder, AttackWave, Glitchling, PipelineOperationPayload
 
 
-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 _resolve_slip_exit_rate(
+    shift_slip_rate: float,
+    shift_slip_exit_rate: float | None,
+) -> float:
+    """Derive the slip exit rate, defaulting to a burst-friendly value."""
 
-
-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
+    if shift_slip_exit_rate is not None:
+        return max(0.0, shift_slip_exit_rate)
+    return max(0.0, shift_slip_rate * 0.5)
 
 
 def fatfinger(
     text: str,
     rate: float | None = None,
-    keyboard: str = "CURATOR_QWERTY",
+    keyboard: str = DEFAULT_TYPOGRE_KEYBOARD,
+    layout: Mapping[str, Sequence[str]] | None = None,
     seed: int | None = None,
     rng: random.Random | None = None,
     *,
-    max_change_rate: float | None = None,
+    shift_slip_rate: float = 0.0,
+    shift_slip_exit_rate: float | None = None,
+    shift_map: Mapping[str, str] | None = None,
 ) -> str:
     """Introduce character-level "fat finger" edits with a Rust fast path."""
+    effective_rate = DEFAULT_TYPOGRE_RATE if rate is None else rate
 
-    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 ""
 
+    layout_mapping = layout if layout is not None else getattr(KEYNEIGHBORS, keyboard)
+    slip_rate = max(0.0, shift_slip_rate)
+    slip_exit_rate = _resolve_slip_exit_rate(slip_rate, shift_slip_exit_rate)
+    slip_map = shift_map if shift_map is not None else getattr(SHIFT_MAPS, keyboard, None)
+
     clamped_rate = max(0.0, effective_rate)
-    if clamped_rate == 0.0:
+    if slip_rate == 0.0 and 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)
+    return fatfinger_rust(
+        text,
+        clamped_rate,
+        layout_mapping,
+        resolve_seed(seed, rng),
+        shift_slip_rate=slip_rate,
+        shift_slip_exit_rate=slip_exit_rate,
+        shift_map=slip_map,
+    )
 
 
 class Typogre(Glitchling):
     """Glitchling that introduces deterministic keyboard-typing errors."""
 
+    flavor = "What a nice word, would be a shame if something happened to it..."
+
     def __init__(
         self,
         *,
         rate: float | None = None,
-        max_change_rate: float | None = None,
-        keyboard: str = "CURATOR_QWERTY",
+        keyboard: str = DEFAULT_TYPOGRE_KEYBOARD,
+        shift_slip_rate: float = 0.0,
+        shift_slip_exit_rate: float | None = None,
         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 = DEFAULT_TYPOGRE_RATE if rate is None else rate
         super().__init__(
             name="Typogre",
             corruption_function=fatfinger,
@@ -202,11 +83,44 @@ class Typogre(Glitchling):
             seed=seed,
             rate=effective_rate,
             keyboard=keyboard,
+            shift_slip_rate=max(0.0, shift_slip_rate),
+            shift_slip_exit_rate=shift_slip_exit_rate,
         )
 
+    def pipeline_operation(self) -> PipelineOperationPayload:
+        rate_value = self.kwargs.get("rate")
+        rate = DEFAULT_TYPOGRE_RATE if rate_value is None else float(rate_value)
+        keyboard = self.kwargs.get("keyboard", DEFAULT_TYPOGRE_KEYBOARD)
+        layout = getattr(KEYNEIGHBORS, str(keyboard), None)
+        if layout is None:
+            message = f"Unknown keyboard layout '{keyboard}' for Typogre pipeline"
+            raise RuntimeError(message)
+
+        serialized_layout = {key: list(value) for key, value in layout.items()}
+        shift_slip_rate = float(self.kwargs.get("shift_slip_rate", 0.0) or 0.0)
+        shift_slip_exit_rate = self.kwargs.get("shift_slip_exit_rate")
+        resolved_exit_rate = _resolve_slip_exit_rate(shift_slip_rate, shift_slip_exit_rate)
+        shift_map = getattr(SHIFT_MAPS, str(keyboard), None)
+        if shift_slip_rate > 0.0 and shift_map is None:
+            message = f"Unknown shift map layout '{keyboard}' for Typogre pipeline"
+            raise RuntimeError(message)
+        serialized_shift_map = dict(shift_map) if shift_map is not None else None
+
+        return cast(
+            PipelineOperationPayload,
+            {
+                "type": "typo",
+                "rate": float(rate),
+                "keyboard": str(keyboard),
+                "layout": serialized_layout,
+                "shift_slip_rate": shift_slip_rate,
+                "shift_slip_exit_rate": float(resolved_exit_rate),
+                "shift_map": serialized_shift_map,
+            },
+        )
 
-typogre = Typogre()
 
+typogre = Typogre()
 
-__all__ = ["Typogre", "typogre"]
 
+__all__ = ["Typogre", "typogre", "fatfinger"]