glitchlings 0.2.1__cp312-cp312-win_amd64.whl → 0.2.3__cp312-cp312-win_amd64.whl

glitchlings/dlc/prime.py

@@ -79,8 +79,8 @@ def tutorial_level(
 ) -> vf.Environment:
     """Create a low-corruption environment using tuned defaults."""
 
-    tuned_mim1c = Mim1c(replacement_rate=0.01 * difficulty.value)
-    tuned_typogre = Typogre(max_change_rate=0.025 * difficulty.value)
+    tuned_mim1c = Mim1c(rate=0.01 * difficulty.value)
+    tuned_typogre = Typogre(rate=0.025 * difficulty.value)
 
     return load_environment(
         env,
@@ -220,32 +220,54 @@ def echo_chamber(
             "Specify which split to use when the dataset loads as a DatasetDict."
         )
 
-    prompts: list[list[dict[str, str]]] = []
-    answers: list[str] = []
+    filtered_dataset = hf_dataset.filter(
+        lambda row: row.get(column) is not None,
+        load_from_cache_file=False,
+    )
 
-    for row in hf_dataset:
-        value = row.get(column)
-        if value is None:
-            continue
+    source_column_names = list(filtered_dataset.column_names)
 
-        text = str(value)
-        prompts.append(
-            [
-                {"role": "system", "content": instructions},
-                {"role": "user", "content": f"Corrupted text:\n{text}"},
-            ]
-        )
-        answers.append(text)
+    def _build_prompt(row: dict[str, Any]) -> dict[str, Any]:
+        text = str(row[column])
+        prompt = [
+            {"role": "system", "content": instructions},
+            {"role": "user", "content": f"Corrupted text:\n{text}"},
+        ]
+        return {"prompt": prompt, "answer": text}
 
-    if not prompts:
-        raise ValueError(
-            f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
-        )
+    base_dataset = filtered_dataset.map(
+        _build_prompt,
+        remove_columns=source_column_names,
+        load_from_cache_file=False,
+    )
 
-    dataset = HFDataset.from_dict({"prompt": prompts, "answer": answers})
+    try:
+        dataset_length = len(base_dataset)  # type: ignore[arg-type]
+    except TypeError:
+        preview_rows: list[dict[str, Any]]
+        take_fn = getattr(base_dataset, "take", None)
+        if callable(take_fn):
+            preview_rows = list(take_fn(1))
+        else:
+            iterator = iter(base_dataset)
+            try:
+                first_row = next(iterator)
+            except StopIteration:
+                preview_rows = []
+            else:
+                preview_rows = [first_row]
+        if not preview_rows:
+            raise ValueError(
+                f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
+            )
+    else:
+        if dataset_length == 0:
+            raise ValueError(
+                f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
+            )
 
     gaggle = _as_gaggle(glitchlings, seed=seed)
-    glitched_dataset = gaggle.corrupt_dataset(dataset, ["prompt"])
+    glitched_dataset = gaggle.corrupt_dataset(base_dataset, ["prompt"])
 
     rubric_func = reward_function or symmetric_damerau_levenshtein_similarity
     rubric = vf.Rubric(funcs=[rubric_func], weights=[1.0])

glitchlings/main.py

@@ -11,31 +11,12 @@ from . import SAMPLE_TEXT
 from .zoo import (
     Glitchling,
     Gaggle,
-    jargoyle,
-    mim1c,
-    typogre,
-    reduple,
-    rushmore,
-    redactyl,
-    scannequin,
+    BUILTIN_GLITCHLINGS,
+    DEFAULT_GLITCHLING_NAMES,
+    parse_glitchling_spec,
     summon,
 )
 
-
-BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
-    g.name.lower(): g
-    for g in [
-        typogre,
-        mim1c,
-        jargoyle,
-        reduple,
-        rushmore,
-        redactyl,
-        scannequin,
-    ]
-}
-
-DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
 MAX_NAME_WIDTH = max(len(glitchling.name) for glitchling in BUILTIN_GLITCHLINGS.values())
 
 
@@ -62,8 +43,11 @@ def build_parser() -> argparse.ArgumentParser:
         "--glitchling",
         dest="glitchlings",
         action="append",
-        metavar="NAME",
-        help="Glitchling to apply (repeat for multiples). Defaults to all built-ins.",
+        metavar="SPEC",
+        help=(
+            "Glitchling to apply, optionally with parameters like "
+            "Typogre(rate=0.05). Repeat for multiples; defaults to all built-ins."
+        ),
     )
     parser.add_argument(
         "-s",
@@ -147,23 +131,16 @@ def read_text(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
 def summon_glitchlings(
     names: list[str] | None, parser: argparse.ArgumentParser, seed: int
 ) -> Gaggle:
-    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``.
-
-    Args:
-        names: Optional list of glitchling names provided by the user.
-        parser: The argument parser used for emitting user-facing errors.
-        seed: Master seed controlling deterministic corruption order.
-
-    Returns:
-        Gaggle: A ready-to-use collection of glitchlings.
-
-    Raises:
-        SystemExit: Raised indirectly via ``parser.error`` when a provided glitchling
-        name is invalid.
-    """
+    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``."""
 
     if names:
-        normalized = [name.lower() for name in names]
+        normalized: list[str | Glitchling] = []
+        for specification in names:
+            try:
+                normalized.append(parse_glitchling_spec(specification))
+            except ValueError as exc:
+                parser.error(str(exc))
+                raise AssertionError("parser.error should exit")
     else:
         normalized = DEFAULT_GLITCHLING_NAMES
 
@@ -174,6 +151,7 @@ def summon_glitchlings(
         raise AssertionError("parser.error should exit")
 
 
+
 def show_diff(original: str, corrupted: str) -> None:
     """Display a unified diff between the original and corrupted text."""
 

glitchlings/util/__init__.py

@@ -141,6 +141,36 @@ _register_layout(
     ),
 )
 
+_register_layout(
+    "QWERTZ",
+    (
+        "^1234567890ß´",
+        " qwertzuiopü+",
+        "  asdfghjklöä#",
+        "   yxcvbnm,.-",
+    ),
+)
+
+_register_layout(
+    "SPANISH_QWERTY",
+    (
+        "º1234567890'¡",
+        " qwertyuiop´+",
+        "  asdfghjklñ´",
+        "   <zxcvbnm,.-",
+    ),
+)
+
+_register_layout(
+    "SWEDISH_QWERTY",
+    (
+        "§1234567890+´",
+        " qwertyuiopå¨",
+        "  asdfghjklöä'",
+        "   <zxcvbnm,.-",
+    ),
+)
+
 
 class KeyNeighbors:
     def __init__(self) -> None:

glitchlings/zoo/__init__.py

@@ -1,6 +1,11 @@
+from __future__ import annotations
+
+import ast
+from typing import Any
+
 from .typogre import Typogre, typogre
 from .mim1c import Mim1c, mim1c
-from .jargoyle import Jargoyle, jargoyle
+from .jargoyle import Jargoyle, jargoyle, dependencies_available as _jargoyle_available
 from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
@@ -25,33 +30,105 @@ __all__ = [
     "Glitchling",
     "Gaggle",
     "summon",
+    "BUILTIN_GLITCHLINGS",
+    "DEFAULT_GLITCHLING_NAMES",
+    "parse_glitchling_spec",
 ]
 
+_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_GLITCHLINGS: dict[str, Glitchling] = {
+    glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
+}
+
+_BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
+    typogre.name.lower(): Typogre,
+    mim1c.name.lower(): Mim1c,
+    reduple.name.lower(): Reduple,
+    rushmore.name.lower(): Rushmore,
+    redactyl.name.lower(): Redactyl,
+    scannequin.name.lower(): Scannequin,
+}
+if _HAS_JARGOYLE:
+    _BUILTIN_GLITCHLING_TYPES[jargoyle.name.lower()] = Jargoyle
+
+DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
+
+
+def parse_glitchling_spec(specification: str) -> Glitchling:
+    """Return a glitchling instance configured according to ``specification``."""
+
+    text = specification.strip()
+    if not text:
+        raise ValueError("Glitchling specification cannot be empty.")
+
+    if "(" not in text:
+        glitchling = BUILTIN_GLITCHLINGS.get(text.lower())
+        if glitchling is None:
+            raise ValueError(f"Glitchling '{text}' not found.")
+        return glitchling
+
+    if not text.endswith(")"):
+        raise ValueError(f"Invalid parameter syntax for glitchling '{text}'.")
+
+    name_part, arg_source = text[:-1].split("(", 1)
+    name = name_part.strip()
+    if not name:
+        raise ValueError(f"Invalid glitchling specification '{text}'.")
+
+    lower_name = name.lower()
+    glitchling_type = _BUILTIN_GLITCHLING_TYPES.get(lower_name)
+    if glitchling_type is None:
+        raise ValueError(f"Glitchling '{name}' not found.")
+
+    try:
+        call_expr = ast.parse(f"_({arg_source})", mode="eval").body
+    except SyntaxError as exc:
+        raise ValueError(
+            f"Invalid parameter syntax for glitchling '{name}': {exc.msg}"
+        ) from exc
+
+    if not isinstance(call_expr, ast.Call) or call_expr.args:
+        raise ValueError(
+            f"Glitchling '{name}' parameters must be provided as keyword arguments."
+        )
+
+    kwargs: dict[str, Any] = {}
+    for keyword in call_expr.keywords:
+        if keyword.arg is None:
+            raise ValueError(
+                f"Glitchling '{name}' does not support unpacking arbitrary keyword arguments."
+            )
+        try:
+            kwargs[keyword.arg] = ast.literal_eval(keyword.value)
+        except (ValueError, SyntaxError) as exc:
+            raise ValueError(
+                f"Failed to parse value for parameter '{keyword.arg}' on glitchling '{name}': {exc}"
+            ) from exc
+
+    try:
+        return glitchling_type(**kwargs)
+    except TypeError as exc:
+        raise ValueError(f"Failed to instantiate glitchling '{name}': {exc}") from exc
+
 
 def summon(glitchlings: list[str | Glitchling], seed: int = 151) -> Gaggle:
     """Summon glitchlings by name (using defaults) or instance (to change parameters)."""
-    available = {
-        g.name.lower(): g
-        for g in [
-            typogre,
-            mim1c,
-            jargoyle,
-            reduple,
-            rushmore,
-            redactyl,
-            scannequin,
-        ]
-    }
-    summoned = []
+
+    summoned: list[Glitchling] = []
     for entry in glitchlings:
         if isinstance(entry, Glitchling):
             summoned.append(entry)
             continue
 
-        g = available.get(entry.lower())
-        if g:
-            summoned.append(g)
-        else:
-            raise ValueError(f"Glitchling '{entry}' not found.")
+        try:
+            summoned.append(parse_glitchling_spec(entry))
+        except ValueError as exc:
+            raise ValueError(str(exc)) from exc
 
     return Gaggle(summoned, seed=seed)

glitchlings/zoo/_ocr_confusions.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from importlib import resources
+
+_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")
+    indexed_entries: list[tuple[int, tuple[str, list[str]]]] = []
+    for line_number, line in enumerate(text.splitlines()):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        parts = stripped.split()
+        if len(parts) < 2:
+            continue
+        source, *replacements = parts
+        indexed_entries.append((line_number, (source, replacements)))
+
+    # Sort longer patterns first to avoid overlapping matches, mirroring the
+    # behaviour of the Rust `confusion_table` helper.
+    indexed_entries.sort(
+        key=lambda item: (-len(item[1][0]), item[0])
+    )
+    entries = [entry for _, entry in indexed_entries]
+    _CONFUSION_TABLE = entries
+    return entries

glitchlings/zoo/_rate.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+
+def resolve_rate(
+    *,
+    rate: float | None,
+    legacy_value: float | None,
+    default: float,
+    legacy_name: str,
+) -> float:
+    """Return the effective rate while enforcing mutual exclusivity."""
+
+    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:
+        return legacy_value
+    return default

glitchlings/zoo/core.py

@@ -107,6 +107,7 @@ class Glitchling:
         scope: AttackWave,
         order: AttackOrder = AttackOrder.NORMAL,
         seed: int | None = None,
+        pipeline_operation: Callable[["Glitchling"], dict[str, Any] | None] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize a glitchling.
@@ -128,31 +129,76 @@ class Glitchling:
         self.corruption_function: CorruptionCallable = corruption_function
         self.level: AttackWave = scope
         self.order: AttackOrder = order
+        self._pipeline_descriptor_factory = pipeline_operation
         self.kwargs: dict[str, Any] = {}
+        self._cached_rng_callable: CorruptionCallable | None = None
+        self._cached_rng_expectation: bool | None = None
         for kw, val in kwargs.items():
             self.set_param(kw, val)
 
     def set_param(self, key: str, value: Any) -> None:
         """Persist a parameter for use by the corruption callable."""
 
-        setattr(self, key, value)
-        self.kwargs[key] = value
-        if key == "seed":
+        aliases = getattr(self, "_param_aliases", {})
+        canonical = aliases.get(key, key)
+
+        # Drop stale alias keys so we only forward canonical kwargs.
+        self.kwargs.pop(key, None)
+        for alias, target in aliases.items():
+            if target == canonical:
+                self.kwargs.pop(alias, None)
+
+        self.kwargs[canonical] = value
+        setattr(self, canonical, value)
+
+        if canonical == "seed":
             self.reset_rng(value)
 
-    def __corrupt(self, text: str, *args: Any, **kwargs: Any) -> str:
-        """Execute the corruption callable, injecting the RNG when required."""
+        for alias, target in aliases.items():
+            if target == canonical:
+                setattr(self, alias, value)
 
-        # Pass rng to underlying corruption function if it expects it.
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        """Return the Rust pipeline operation descriptor for this glitchling."""
+
+        factory = self._pipeline_descriptor_factory
+        if factory is None:
+            return None
+
+        return factory(self)
+
+    def _corruption_expects_rng(self) -> bool:
+        """Return `True` when the corruption function accepts an rng keyword."""
+
+        cached_callable = self._cached_rng_callable
+        cached_expectation = self._cached_rng_expectation
+        corruption_function = self.corruption_function
+
+        if (
+            cached_callable is corruption_function
+            and cached_expectation is not None
+        ):
+            return cached_expectation
+
+        expects_rng = False
         try:
-            signature = inspect.signature(self.corruption_function)
+            signature = inspect.signature(corruption_function)
         except (TypeError, ValueError):
             signature = None
 
-        expects_rng = False
         if signature is not None:
             expects_rng = "rng" in signature.parameters
 
+        self._cached_rng_callable = corruption_function
+        self._cached_rng_expectation = expects_rng
+        return expects_rng
+
+    def __corrupt(self, text: str, *args: Any, **kwargs: Any) -> str:
+        """Execute the corruption callable, injecting the RNG when required."""
+
+        # Pass rng to underlying corruption function if it expects it.
+        expects_rng = self._corruption_expects_rng()
+
         if expects_rng:
             corrupted = self.corruption_function(text, *args, rng=self.rng, **kwargs)
         else:
@@ -231,53 +277,14 @@ class Glitchling:
                 self.corruption_function,
                 self.level,
                 self.order,
+                pipeline_operation=self._pipeline_descriptor_factory,
                 **filtered_kwargs,
             )
 
         return cls(**filtered_kwargs)
 
 
-def _pipeline_operation_reduplicate(glitchling: "Glitchling") -> dict[str, Any] | None:
-    rate = glitchling.kwargs.get("reduplication_rate")
-    if rate is None:
-        return None
-    return {"type": "reduplicate", "reduplication_rate": float(rate)}
-
 
-def _pipeline_operation_delete(glitchling: "Glitchling") -> dict[str, Any] | None:
-    rate = glitchling.kwargs.get("max_deletion_rate")
-    if rate is None:
-        return None
-    return {"type": "delete", "max_deletion_rate": float(rate)}
-
-
-def _pipeline_operation_redact(glitchling: "Glitchling") -> dict[str, Any] | None:
-    replacement_char = glitchling.kwargs.get("replacement_char")
-    redaction_rate = glitchling.kwargs.get("redaction_rate")
-    merge_adjacent = glitchling.kwargs.get("merge_adjacent")
-    if replacement_char is None or redaction_rate is None or merge_adjacent is None:
-        return None
-    return {
-        "type": "redact",
-        "replacement_char": str(replacement_char),
-        "redaction_rate": float(redaction_rate),
-        "merge_adjacent": bool(merge_adjacent),
-    }
-
-
-def _pipeline_operation_ocr(glitchling: "Glitchling") -> dict[str, Any] | None:
-    error_rate = glitchling.kwargs.get("error_rate")
-    if error_rate is None:
-        return None
-    return {"type": "ocr", "error_rate": float(error_rate)}
-
-
-_PIPELINE_OPERATION_BUILDERS: dict[str, Callable[["Glitchling"], dict[str, Any] | None]] = {
-    "Reduple": _pipeline_operation_reduplicate,
-    "Rushmore": _pipeline_operation_delete,
-    "Redactyl": _pipeline_operation_redact,
-    "Scannequin": _pipeline_operation_ocr,
-}
 
 
 class Gaggle(Glitchling):
@@ -359,10 +366,7 @@ class Gaggle(Glitchling):
 
         descriptors: list[dict[str, Any]] = []
         for glitchling in self.apply_order:
-            builder = _PIPELINE_OPERATION_BUILDERS.get(glitchling.name)
-            if builder is None:
-                return None
-            operation = builder(glitchling)
+            operation = glitchling.pipeline_operation()
             if operation is None:
                 return None