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

glitchlings/util/keyboards.py

@@ -0,0 +1,311 @@
+"""Keyboard layout neighbor maps for typo simulation.
+
+This module centralizes keyboard layout data that was previously stored
+directly in :mod:`glitchlings.util.__init__`. It defines adjacency maps
+for various keyboard layouts used by typo-generating glitchlings.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from glitchlings.zoo.transforms import (
+    KeyNeighborMap,
+    build_keyboard_neighbor_map,
+)
+
+__all__ = [
+    "KeyboardLayouts",
+    "KeyNeighbors",
+    "KEYNEIGHBORS",
+    "ShiftMap",
+    "ShiftMaps",
+    "SHIFT_MAPS",
+]
+
+KeyboardLayouts = dict[str, KeyNeighborMap]
+ShiftMap = dict[str, str]
+ShiftMaps = dict[str, ShiftMap]
+
+
+_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_keyboard_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,;:!",
+    ),
+)
+
+_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:
+    """Attribute-based access to keyboard layout neighbor maps."""
+
+    def __init__(self) -> None:
+        for layout_name, layout in _KEYNEIGHBORS.items():
+            setattr(self, layout_name, layout)
+
+
+KEYNEIGHBORS: KeyNeighbors = KeyNeighbors()
+
+
+def _uppercase_keys(layout: str) -> ShiftMap:
+    mapping: ShiftMap = {}
+    for key in _KEYNEIGHBORS.get(layout, {}):
+        if key.isalpha():
+            mapping[key] = key.upper()
+    return mapping
+
+
+def _with_letters(base: ShiftMap, layout: str) -> ShiftMap:
+    mapping = dict(base)
+    mapping.update(_uppercase_keys(layout))
+    return mapping
+
+
+def _qwerty_symbols() -> ShiftMap:
+    return {
+        "`": "~",
+        "1": "!",
+        "2": "@",
+        "3": "#",
+        "4": "$",
+        "5": "%",
+        "6": "^",
+        "7": "&",
+        "8": "*",
+        "9": "(",
+        "0": ")",
+        "-": "_",
+        "=": "+",
+        "[": "{",
+        "]": "}",
+        "\\": "|",
+        ";": ":",
+        "'": '"',
+        ",": "<",
+        ".": ">",
+        "/": "?",
+    }
+
+
+def _azerty_symbols() -> ShiftMap:
+    return {
+        "&": "1",
+        "\u00e9": "2",
+        '"': "3",
+        "'": "4",
+        "(": "5",
+        "-": "6",
+        "\u00e8": "7",
+        "_": "8",
+        "\u00e7": "9",
+        "\u00e0": "0",
+        ")": "\u00b0",
+        "=": "+",
+        "^": "\u00a8",
+        "$": "\u00a3",
+        "*": "\u00b5",
+        "\u00f9": "%",
+        "<": ">",
+        ",": "?",
+        ";": ".",
+        ":": "/",
+        "!": "\u00a7",
+    }
+
+
+def _qwertz_symbols() -> ShiftMap:
+    return {
+        "^": "\u00b0",
+        "1": "!",
+        "2": '"',
+        "3": "\u00a7",
+        "4": "$",
+        "5": "%",
+        "6": "&",
+        "7": "/",
+        "8": "(",
+        "9": ")",
+        "0": "=",
+        "\u00df": "?",
+        "\u00b4": "`",
+        "+": "*",
+        "#": "'",
+        "-": "_",
+        ",": ";",
+        ".": ":",
+        "\u00e4": "\u00c4",
+        "\u00f6": "\u00d6",
+        "\u00fc": "\u00dc",
+    }
+
+
+def _spanish_symbols() -> ShiftMap:
+    return {
+        "\u00ba": "\u00aa",
+        "1": "!",
+        "2": '"',
+        "3": "\u00b7",
+        "4": "$",
+        "5": "%",
+        "6": "&",
+        "7": "/",
+        "8": "(",
+        "9": ")",
+        "0": "=",
+        "'": "?",
+        "\u00a1": "\u00bf",
+        "+": "*",
+        "\u00b4": "\u00a8",
+        "-": "_",
+        ",": ";",
+        ".": ":",
+        "<": ">",
+        "\u00f1": "\u00d1",
+    }
+
+
+def _swedish_symbols() -> ShiftMap:
+    return {
+        "\u00a7": "\u00bd",
+        "1": "!",
+        "2": '"',
+        "3": "#",
+        "4": "\u00a4",
+        "5": "%",
+        "6": "&",
+        "7": "/",
+        "8": "(",
+        "9": ")",
+        "0": "=",
+        "+": "?",
+        "\u00b4": "\u00a8",
+        "-": "_",
+        ",": ";",
+        ".": ":",
+        "<": ">",
+        "\u00e5": "\u00c5",
+        "\u00e4": "\u00c4",
+        "\u00f6": "\u00d6",
+    }
+
+
+_SHIFT_MAPS: ShiftMaps = {
+    "CURATOR_QWERTY": _with_letters(_qwerty_symbols(), "CURATOR_QWERTY"),
+    "QWERTY": _with_letters(_qwerty_symbols(), "QWERTY"),
+    "COLEMAK": _with_letters(_qwerty_symbols(), "COLEMAK"),
+    "DVORAK": _with_letters(_qwerty_symbols(), "DVORAK"),
+    "AZERTY": _with_letters(_azerty_symbols(), "AZERTY"),
+    "QWERTZ": _with_letters(_qwertz_symbols(), "QWERTZ"),
+    "SPANISH_QWERTY": _with_letters(_spanish_symbols(), "SPANISH_QWERTY"),
+    "SWEDISH_QWERTY": _with_letters(_swedish_symbols(), "SWEDISH_QWERTY"),
+}
+
+
+class ShiftMapsAccessor:
+    """Attribute-based access to per-layout shift maps."""
+
+    def __init__(self) -> None:
+        for layout_name, mapping in _SHIFT_MAPS.items():
+            setattr(self, layout_name, mapping)
+
+
+SHIFT_MAPS: ShiftMapsAccessor = ShiftMapsAccessor()

glitchlings/util/transcripts.py

@@ -0,0 +1,108 @@
+"""Shared transcript type helpers used across attack and DLC modules."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Sequence, TypeGuard, Union
+
+TranscriptTurn = dict[str, Any]
+Transcript = list[TranscriptTurn]
+
+# Type alias for transcript target specifications.
+# - "last": corrupt only the last turn (default behavior)
+# - "all": corrupt all turns
+# - "assistant": corrupt only turns with role="assistant"
+# - "user": corrupt only turns with role="user"
+# - int: corrupt a specific index (negative indexing supported)
+# - Sequence[int]: corrupt specific indices
+TranscriptTarget = Union[Literal["last", "all", "assistant", "user"], int, Sequence[int]]
+
+
+def is_transcript(
+    value: Any,
+    *,
+    allow_empty: bool = True,
+    require_all_content: bool = False,
+) -> TypeGuard[Transcript]:
+    """Return True when ``value`` appears to be a chat transcript mapping list."""
+    if not isinstance(value, list):
+        return False
+
+    if not value:
+        return allow_empty
+
+    if not all(isinstance(turn, dict) for turn in value):
+        return False
+
+    if require_all_content:
+        return all("content" in turn for turn in value)
+
+    return "content" in value[-1]
+
+
+def resolve_transcript_indices(
+    transcript: Transcript,
+    target: TranscriptTarget,
+) -> list[int]:
+    """Resolve a transcript target specification to concrete indices.
+
+    Args:
+        transcript: The transcript to resolve indices for.
+        target: The target specification indicating which turns to corrupt.
+
+    Returns:
+        A list of valid indices into the transcript, sorted in ascending order.
+
+    Raises:
+        ValueError: If the target specification is invalid or references
+            indices outside the transcript bounds.
+    """
+    if not transcript:
+        return []
+
+    length = len(transcript)
+
+    if target == "last":
+        return [length - 1]
+
+    if target == "all":
+        return list(range(length))
+
+    if target == "assistant":
+        return [i for i, turn in enumerate(transcript) if turn.get("role") == "assistant"]
+
+    if target == "user":
+        return [i for i, turn in enumerate(transcript) if turn.get("role") == "user"]
+
+    if isinstance(target, int):
+        # Normalize negative indices
+        normalized = target if target >= 0 else length + target
+        if not 0 <= normalized < length:
+            raise ValueError(f"Transcript index {target} out of bounds for length {length}")
+        return [normalized]
+
+    # Handle sequence of indices
+    if isinstance(target, Sequence) and not isinstance(target, str):
+        indices: list[int] = []
+        for idx in target:
+            if not isinstance(idx, int):
+                raise ValueError(f"Transcript indices must be integers, got {type(idx).__name__}")
+            normalized = idx if idx >= 0 else length + idx
+            if not 0 <= normalized < length:
+                raise ValueError(f"Transcript index {idx} out of bounds for length {length}")
+            indices.append(normalized)
+        # Deduplicate and sort
+        return sorted(set(indices))
+
+    raise ValueError(
+        f"Invalid transcript target: {target!r}. "
+        "Expected 'last', 'all', 'assistant', 'user', int, or sequence of ints."
+    )
+
+
+__all__ = [
+    "Transcript",
+    "TranscriptTarget",
+    "TranscriptTurn",
+    "is_transcript",
+    "resolve_transcript_indices",
+]

glitchlings/zoo/__init__.py

@@ -3,15 +3,17 @@ from __future__ import annotations
 import ast
 from typing import Any
 
-from .typogre import Typogre, typogre
+from .core import Gaggle, Glitchling, plan_glitchlings
+from .ekkokin import Ekkokin, ekkokin
+from .hokey import Hokey, hokey
+from .jargoyle import Jargoyle, jargoyle
 from .mim1c import Mim1c, mim1c
-from .jargoyle import Jargoyle, jargoyle, dependencies_available as _jargoyle_available
-from .reduple import Reduple, reduple
-from .rushmore import Rushmore, rushmore
+from .pedant import Pedant, pedant
 from .redactyl import Redactyl, redactyl
+from .rushmore import Rushmore, RushmoreMode, rushmore
 from .scannequin import Scannequin, scannequin
+from .typogre import Typogre, typogre
 from .zeedub import Zeedub, zeedub
-from .core import Glitchling, Gaggle
 
 __all__ = [
     "Typogre",
@@ -20,9 +22,12 @@ __all__ = [
     "mim1c",
     "Jargoyle",
     "jargoyle",
-    "Reduple",
-    "reduple",
+    "Ekkokin",
+    "ekkokin",
+    "Hokey",
+    "hokey",
     "Rushmore",
+    "RushmoreMode",
     "rushmore",
     "Redactyl",
     "redactyl",
@@ -30,20 +35,30 @@ __all__ = [
     "scannequin",
     "Zeedub",
     "zeedub",
+    "Pedant",
+    "pedant",
     "Glitchling",
     "Gaggle",
+    "plan_glitchlings",
     "summon",
     "BUILTIN_GLITCHLINGS",
     "DEFAULT_GLITCHLING_NAMES",
     "parse_glitchling_spec",
+    "get_glitchling_class",
 ]
 
-_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, zeedub])
+_BUILTIN_GLITCHLING_LIST: list[Glitchling] = [
+    typogre,
+    hokey,
+    mim1c,
+    ekkokin,
+    pedant,
+    jargoyle,
+    rushmore,
+    redactyl,
+    scannequin,
+    zeedub,
+]
 
 BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
     glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
@@ -51,22 +66,22 @@ BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
 
 _BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
     typogre.name.lower(): Typogre,
+    ekkokin.name.lower(): Ekkokin,
+    hokey.name.lower(): Hokey,
     mim1c.name.lower(): Mim1c,
-    reduple.name.lower(): Reduple,
+    pedant.name.lower(): Pedant,
+    jargoyle.name.lower(): Jargoyle,
     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
 
 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.")
@@ -93,14 +108,10 @@ def parse_glitchling_spec(specification: str) -> Glitchling:
     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
+        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."
-        )
+        raise ValueError(f"Glitchling '{name}' parameters must be provided as keyword arguments.")
 
     kwargs: dict[str, Any] = {}
     for keyword in call_expr.keywords:
@@ -121,9 +132,21 @@ def parse_glitchling_spec(specification: str) -> Glitchling:
         raise ValueError(f"Failed to instantiate glitchling '{name}': {exc}") from exc
 
 
+def get_glitchling_class(name: str) -> type[Glitchling]:
+    """Look up the glitchling class registered under ``name``."""
+    key = name.strip().lower()
+    if not key:
+        raise ValueError("Glitchling name cannot be empty.")
+
+    glitchling_type = _BUILTIN_GLITCHLING_TYPES.get(key)
+    if glitchling_type is None:
+        raise ValueError(f"Glitchling '{name}' not found.")
+
+    return glitchling_type
+
+
 def summon(glitchlings: list[str | Glitchling], seed: int = 151) -> Gaggle:
     """Summon glitchlings by name (using defaults) or instance (to change parameters)."""
-
     summoned: list[Glitchling] = []
     for entry in glitchlings:
         if isinstance(entry, Glitchling):

glitchlings/zoo/assets/__init__.py

@@ -0,0 +1,29 @@
+"""Compatibility shim for the relocated asset helpers."""
+
+from __future__ import annotations
+
+from glitchlings.assets import (
+    PIPELINE_ASSET_SPECS,
+    PIPELINE_ASSETS,
+    AssetKind,
+    PipelineAsset,
+    hash_asset,
+    load_homophone_groups,
+    load_json,
+    open_binary,
+    open_text,
+    read_text,
+)
+
+__all__ = [
+    "AssetKind",
+    "PipelineAsset",
+    "PIPELINE_ASSETS",
+    "PIPELINE_ASSET_SPECS",
+    "hash_asset",
+    "load_homophone_groups",
+    "load_json",
+    "open_binary",
+    "open_text",
+    "read_text",
+]