glitchlings 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

glitchlings/__init__.py

@@ -0,0 +1,42 @@
+from .zoo import (
+    Typogre,
+    typogre,
+    Mim1c,
+    mim1c,
+    Jargoyle,
+    jargoyle,
+    Redactyl,
+    redactyl,
+    Reduple,
+    reduple,
+    Rushmore,
+    rushmore,
+    Scannequin,
+    scannequin,
+    Glitchling,
+    Gaggle,
+    summon,
+)
+from .util import SAMPLE_TEXT
+
+
+__all__ = [
+    "Typogre",
+    "typogre",
+    "Mim1c",
+    "mim1c",
+    "Jargoyle",
+    "jargoyle",
+    "Redactyl",
+    "redactyl",
+    "Reduple",
+    "reduple",
+    "Rushmore",
+    "rushmore",
+    "Scannequin",
+    "scannequin",
+    "summon",
+    "Glitchling",
+    "Gaggle",
+    "SAMPLE_TEXT",
+]

glitchlings/__main__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+
+from .main import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{dlc → glitchlings/dlc}/prime.py

@@ -1,50 +1,52 @@
-from enum import Enum
-import functools as ft
-
-import verifiers as vf
-from datasets import Dataset
-
-from zoo import Glitchling, Gaggle, mim1c, typogre, summon
-
-
-class CR(Enum):
-    """Challenge Rating levels for tutorial environments."""
-
-    Zero = 0.1
-    Half = 0.5
-    One = 1
-    Two = 1.5
-    Three = 4
-    Four = 9
-
-
-def tutorial_level(
-    env: vf.Environment | str, seed=151, CR: CR = CR.One
-) -> vf.Environment:
-    """Create a low-corruption environment."""
-
-    mim1c.set_param("replacement_rate", 0.01 * CR.value)
-    typogre.set_param("max_change_rate", 0.025 * CR.value)
-
-    glitchlings: Gaggle = summon([mim1c, typogre], seed=seed)
-
-    if isinstance(env, str):
-        env = vf.load_environment(env)
-
-    assert isinstance(env, vf.Environment), "Invalid environment type"
-
-    if "prompt" in env.dataset.column_names:
-        env.dataset = glitchlings.corrupt_dataset(env.dataset, ["prompt"])
-    elif "question" in env.dataset.column_names:
-        env.dataset = glitchlings.corrupt_dataset(env.dataset, ["question"])
-    else:
-        raise ValueError("Can't find prompt or question column")
-
-    return env
-
-
-def load_environment(
-    env: str | vf.Environment, seed=151, CR: CR = CR.One, loader=tutorial_level
-) -> vf.Environment:
-    """Load an environment by name."""
-    return loader(env, seed=seed, CR=CR)
+from enum import Enum
+import functools as ft
+
+import verifiers as vf
+from datasets import Dataset
+
+from ..zoo import Glitchling, Gaggle, Mim1c, Typogre, summon
+
+
+class Difficulty(Enum):
+    """Difficulty levels for tutorial environments."""
+
+    Easy = 0.25
+    Normal = 1.0
+    Hard = 1.75
+    Extreme = 3
+    Impossible = 9
+
+
+def tutorial_level(
+    env: vf.Environment | str, seed=151, difficulty: Difficulty = Difficulty.Normal
+) -> vf.Environment:
+    """Create a low-corruption environment."""
+
+    tuned_mim1c = Mim1c(replacement_rate=0.01 * difficulty.value)
+    tuned_typogre = Typogre(max_change_rate=0.025 * difficulty.value)
+
+    glitchlings: Gaggle = summon([tuned_mim1c, tuned_typogre], seed=seed)
+
+    if isinstance(env, str):
+        env = vf.load_environment(env)
+
+    assert isinstance(env, vf.Environment), "Invalid environment type"
+
+    if "prompt" in env.dataset.column_names:
+        env.dataset = glitchlings.corrupt_dataset(env.dataset, ["prompt"])
+    elif "question" in env.dataset.column_names:
+        env.dataset = glitchlings.corrupt_dataset(env.dataset, ["question"])
+    else:
+        raise ValueError("Can't find prompt or question column")
+
+    return env
+
+
+def load_environment(
+    env: str | vf.Environment,
+    seed=151,
+    difficulty: Difficulty = Difficulty.Normal,
+    loader=tutorial_level,
+) -> vf.Environment:
+    """Load an environment by name."""
+    return loader(env, seed=seed, difficulty=difficulty)

glitchlings/main.py

@@ -0,0 +1,238 @@
+"""Command line interface for summoning and running glitchlings."""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+from pathlib import Path
+import sys
+
+from . import SAMPLE_TEXT
+from .zoo import (
+    Glitchling,
+    Gaggle,
+    jargoyle,
+    mim1c,
+    typogre,
+    reduple,
+    rushmore,
+    redactyl,
+    scannequin,
+    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())
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Create and configure the CLI argument parser.
+
+    Returns:
+        argparse.ArgumentParser: The configured argument parser instance.
+    """
+
+    parser = argparse.ArgumentParser(
+        description=(
+            "Summon glitchlings to corrupt text. Provide input text as an argument, "
+            "via --file, or pipe it on stdin."
+        )
+    )
+    parser.add_argument(
+        "text",
+        nargs="?",
+        help="Text to corrupt. If omitted, stdin is used or --sample provides fallback text.",
+    )
+    parser.add_argument(
+        "-g",
+        "--glitchling",
+        dest="glitchlings",
+        action="append",
+        metavar="NAME",
+        help="Glitchling to apply (repeat for multiples). Defaults to all built-ins.",
+    )
+    parser.add_argument(
+        "-s",
+        "--seed",
+        type=int,
+        default=151,
+        help="Seed controlling deterministic corruption order (default: 151).",
+    )
+    parser.add_argument(
+        "-f",
+        "--file",
+        type=Path,
+        help="Read input text from a file instead of the command line argument.",
+    )
+    parser.add_argument(
+        "--sample",
+        action="store_true",
+        help="Use the included SAMPLE_TEXT when no other input is provided.",
+    )
+    parser.add_argument(
+        "--diff",
+        action="store_true",
+        help="Show a unified diff between the original and corrupted text.",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List available glitchlings and exit.",
+    )
+    return parser
+
+
+def list_glitchlings() -> None:
+    """Print information about the available built-in glitchlings."""
+
+    for key in DEFAULT_GLITCHLING_NAMES:
+        glitchling = BUILTIN_GLITCHLINGS[key]
+        display_name = glitchling.name
+        scope = glitchling.level.name.title()
+        order = glitchling.order.name.lower()
+        print(f"{display_name:>{MAX_NAME_WIDTH}} — scope: {scope}, order: {order}")
+
+
+def read_text(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
+    """Resolve the input text based on CLI arguments.
+
+    Args:
+        args: Parsed arguments from the CLI.
+        parser: The argument parser used for emitting user-facing errors.
+
+    Returns:
+        str: The text to corrupt.
+
+    Raises:
+        SystemExit: Raised indirectly via ``parser.error`` on failure.
+    """
+
+    if args.file is not None:
+        try:
+            return args.file.read_text(encoding="utf-8")
+        except OSError as exc:  # pragma: no cover - exercised via CLI
+            parser.error(str(exc))
+
+    if args.text:
+        return args.text
+
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+
+    if args.sample:
+        return SAMPLE_TEXT
+
+    parser.error(
+        "No input text provided. Supply text as an argument, use --file, pipe input, or pass --sample."
+    )
+    raise AssertionError("parser.error should exit")
+
+
+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.
+    """
+
+    if names:
+        normalized = [name.lower() for name in names]
+    else:
+        normalized = DEFAULT_GLITCHLING_NAMES
+
+    try:
+        return summon(normalized, seed=seed)
+    except ValueError as exc:
+        parser.error(str(exc))
+        raise AssertionError("parser.error should exit")
+
+
+def show_diff(original: str, corrupted: str) -> None:
+    """Display a unified diff between the original and corrupted text."""
+
+    diff_lines = list(
+        difflib.unified_diff(
+            original.splitlines(keepends=True),
+            corrupted.splitlines(keepends=True),
+            fromfile="original",
+            tofile="corrupted",
+            lineterm="",
+        )
+    )
+    if diff_lines:
+        for line in diff_lines:
+            print(line)
+    else:
+        print("No changes detected.")
+
+
+def run_cli(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
+    """Execute the CLI workflow using the provided arguments.
+
+    Args:
+        args: Parsed CLI arguments.
+        parser: Argument parser used for error reporting.
+
+    Returns:
+        int: Exit code for the process (``0`` on success).
+    """
+
+    if args.list:
+        list_glitchlings()
+        return 0
+
+    text = read_text(args, parser)
+    gaggle = summon_glitchlings(args.glitchlings, parser, args.seed)
+
+    corrupted = gaggle(text)
+
+    if args.diff:
+        show_diff(text, corrupted)
+    else:
+        print(corrupted)
+
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point for the ``glitchlings`` command line interface.
+
+    Args:
+        argv: Optional list of command line arguments. Defaults to ``sys.argv``.
+
+    Returns:
+        int: Exit code suitable for use with ``sys.exit``.
+    """
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return run_cli(args, parser)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

glitchlings/util/__init__.py

@@ -0,0 +1,151 @@
+import difflib
+from collections.abc import Iterable
+
+SAMPLE_TEXT = "One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible vermin. He lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightly domed and divided by arches into stiff sections. The bedding was hardly able to cover it and seemed ready to slide off any moment. His many legs, pitifully thin compared with the size of the rest of him, waved about helplessly as he looked."
+
+
+def string_diffs(a: str, b: str) -> list[list[tuple[str, str, str]]]:
+    """
+    Compare two strings using SequenceMatcher and return
+    grouped adjacent opcodes (excluding 'equal' tags).
+
+    Each element is a tuple: (tag, a_text, b_text).
+    """
+    sm = difflib.SequenceMatcher(None, a, b)
+    ops: list[list[tuple[str, str, str]]] = []
+    buffer: list[tuple[str, str, str]] = []
+
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            # flush any buffered operations before skipping
+            if buffer:
+                ops.append(buffer)
+                buffer = []
+            continue
+
+        # append operation to buffer
+        buffer.append((tag, a[i1:i2], b[j1:j2]))
+
+    # flush trailing buffer
+    if buffer:
+        ops.append(buffer)
+
+    return ops
+
+
+KeyNeighborMap = dict[str, list[str]]
+KeyboardLayouts = dict[str, KeyNeighborMap]
+
+
+def _build_neighbor_map(rows: Iterable[str]) -> KeyNeighborMap:
+    """Derive 8-neighbour adjacency lists from keyboard layout rows."""
+
+    grid: dict[tuple[int, int], str] = {}
+    for y, row in enumerate(rows):
+        for x, char in enumerate(row):
+            if char == " ":
+                continue
+            grid[(x, y)] = char.lower()
+
+    neighbors: KeyNeighborMap = {}
+    for (x, y), char in grid.items():
+        seen: list[str] = []
+        for dy in (-1, 0, 1):
+            for dx in (-1, 0, 1):
+                if dx == 0 and dy == 0:
+                    continue
+                candidate = grid.get((x + dx, y + dy))
+                if candidate is None:
+                    continue
+                seen.append(candidate)
+        # Preserve encounter order but drop duplicates for determinism
+        deduped = list(dict.fromkeys(seen))
+        neighbors[char] = deduped
+
+    return neighbors
+
+
+_KEYNEIGHBORS: KeyboardLayouts = {
+    "CURATOR_QWERTY": {
+        "a": [*"qwsz"],
+        "b": [*"vghn  "],
+        "c": [*"xdfv  "],
+        "d": [*"serfcx"],
+        "e": [*"wsdrf34"],
+        "f": [*"drtgvc"],
+        "g": [*"ftyhbv"],
+        "h": [*"gyujnb"],
+        "i": [*"ujko89"],
+        "j": [*"huikmn"],
+        "k": [*"jilom,"],
+        "l": [*"kop;.,"],
+        "m": [*"njk,  "],
+        "n": [*"bhjm  "],
+        "o": [*"iklp90"],
+        "p": [*"o0-[;l"],
+        "q": [*"was 12"],
+        "r": [*"edft45"],
+        "s": [*"awedxz"],
+        "t": [*"r56ygf"],
+        "u": [*"y78ijh"],
+        "v": [*"cfgb  "],
+        "w": [*"q23esa"],
+        "x": [*"zsdc  "],
+        "y": [*"t67uhg"],
+        "z": [*"asx"],
+    }
+}
+
+
+def _register_layout(name: str, rows: Iterable[str]) -> None:
+    _KEYNEIGHBORS[name] = _build_neighbor_map(rows)
+
+
+_register_layout(
+    "DVORAK",
+    (
+        "`1234567890[]\\",
+        " ',.pyfgcrl/=\\",
+        "  aoeuidhtns-",
+        "   ;qjkxbmwvz",
+    ),
+)
+
+_register_layout(
+    "COLEMAK",
+    (
+        "`1234567890-=",
+        " qwfpgjluy;[]\\",
+        "  arstdhneio'",
+        "   zxcvbkm,./",
+    ),
+)
+
+_register_layout(
+    "QWERTY",
+    (
+        "`1234567890-=",
+        " qwertyuiop[]\\",
+        "  asdfghjkl;'",
+        "   zxcvbnm,./",
+    ),
+)
+
+_register_layout(
+    "AZERTY",
+    (
+        "²&é\"'(-è_çà)=",
+        " azertyuiop^$",
+        "  qsdfghjklmù*",
+        "   <wxcvbn,;:!",
+    ),
+)
+
+
+class KeyNeighbors:
+    def __init__(self) -> None:
+        for layout_name, layout in _KEYNEIGHBORS.items():
+            setattr(self, layout_name, layout)
+
+
+KEYNEIGHBORS: KeyNeighbors = KeyNeighbors()

{zoo → glitchlings/zoo}/__init__.py

@@ -1,50 +1,57 @@
-from .typogre import typogre
-from .mim1c import mim1c
-from .jargoyle import jargoyle
-from .reduple import reduple
-from .rushmore import rushmore
-from .redactyl import redactyl
-from .scannequin import scannequin
-from .core import Glitchling, Gaggle
-
-__all__ = [
-    "typogre",
-    "mim1c",
-    "jargoyle",
-    "reduple",
-    "rushmore",
-    "redactyl",
-    "scannequin",
-    "Glitchling",
-    "Gaggle",
-    "summon",
-]
-
-
-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 = []
-    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.")
-
-    return Gaggle(summoned, seed=seed)
+from .typogre import Typogre, typogre
+from .mim1c import Mim1c, mim1c
+from .jargoyle import Jargoyle, jargoyle
+from .reduple import Reduple, reduple
+from .rushmore import Rushmore, rushmore
+from .redactyl import Redactyl, redactyl
+from .scannequin import Scannequin, scannequin
+from .core import Glitchling, Gaggle
+
+__all__ = [
+    "Typogre",
+    "typogre",
+    "Mim1c",
+    "mim1c",
+    "Jargoyle",
+    "jargoyle",
+    "Reduple",
+    "reduple",
+    "Rushmore",
+    "rushmore",
+    "Redactyl",
+    "redactyl",
+    "Scannequin",
+    "scannequin",
+    "Glitchling",
+    "Gaggle",
+    "summon",
+]
+
+
+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 = []
+    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.")
+
+    return Gaggle(summoned, seed=seed)