glitchlings 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

__init__.py

@@ -1,73 +0,0 @@
-from .zoo import (
-    typogre,
-    mim1c,
-    jargoyle,
-    redactyl,
-    reduple,
-    rushmore,
-    scannequin,
-    Glitchling,
-    Gaggle,
-    summon,
-)
-from .util import SAMPLE_TEXT
-
-
-__all__ = [
-    "typogre",
-    "mim1c",
-    "jargoyle",
-    "reduple",
-    "rushmore",
-    "redactyl",
-    "scannequin",
-    "summon",
-    "Glitchling",
-    "Gaggle",
-    "SAMPLE_TEXT",
-]
-
-
-if __name__ == "__main__":
-    # Example usage
-    import verifiers as vf
-    from openai import OpenAI
-    from dlc import prime as gl
-    from typing import cast
-
-    openai = OpenAI()
-
-    # redactyl.set_param("redaction_rate", 0.5)
-    # jargoyle.set_param("replacement_rate", 0.25)
-
-    # gaggle = summon(["reduple", "mim1c", "typogre", jargoyle, "rushmore", redactyl])
-    # corrupted = gaggle(SAMPLE_TEXT)
-    # print(SAMPLE_TEXT, end="\n\n")
-    # print(gaggle.pretty_diff(SAMPLE_TEXT), end="\n\n")
-    # print(corrupted)
-
-    # env = load_environment("alphabet-sort")
-    # x = env.evaluate(client=openai, model="gpt-4.1-nano", num_examples=100)
-    # dx = env.make_dataset(x).to_dict()
-    # print(sum(dx["weighted_reward"]))
-
-    bare_env = vf.load_environment("alphabet-sort")
-    x = bare_env.evaluate(client=openai, model="gpt-4.1-nano", num_examples=10)
-    dx = cast(dict[str, list[float]], bare_env.make_dataset(x).to_dict())  # type: ignore
-    original = 100 * sum(dx["reward"]) / max(1, len(dx["reward"]))
-
-    easy_env = gl.load_environment("alphabet-sort")
-    y = easy_env.evaluate(client=openai, model="gpt-4.1-nano", num_examples=10)
-    dy = cast(dict[str, list[float]], easy_env.make_dataset(y).to_dict())  # type: ignore
-    easy = 100 * sum(dy["reward"]) / max(1, len(dy["reward"]))
-    easy_drop = 100 * (original - easy) / original
-
-    crazy_env = gl.load_environment("alphabet-sort", CR=gl.CR.Four)
-    z = crazy_env.evaluate(client=openai, model="gpt-4.1-nano", num_examples=10)
-    dz = cast(dict[str, list[float]], crazy_env.make_dataset(z).to_dict())  # type: ignore
-    crazy = 100 * sum(dz["reward"]) / max(1, len(dz["reward"]))
-    crazy_drop = 100 * (original - crazy) / original
-
-    print(f"Base Environment:   {original:.1f}%")
-    print(f"Glitchlings (CR 1): {easy:.1f}% ({easy_drop:.1f}% drop)")
-    print(f"Glitchlings (CR 4): {crazy:.1f}% ({crazy_drop:.1f}% drop)")

glitchlings-0.1.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-./.gitignore,sha256=oIxsd1LRy7y7yqq5k5JCrFKW4p6HlQd14lFUSLi-Qx8,144
-./LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-./MONSTER_MANUAL.md,sha256=vdoVnUl-Zdl3gH6E51fUGlSnhxdxxIbIXVNorReJAng,9344
-./PKG-INFO,sha256=2VrY4qI-J6MM_3VXAcHI0gC-8eoRYerXEj7o28XfBpc,24182
-./README.md,sha256=hdQzNbHjygjeNsikdDaLRncN3H7qN9qgWhjnGWBS5WE,10121
-./__init__.py,sha256=dOvJSFqrFUQvYNUHne5CmSUUwzME8rdyL-lXGNWKoL0,2365
-./main.py,sha256=HZveNbsuHiHJFGhB31I_u4EK2aI7KOCevcI2ZP9u5Lw,89
-./pyproject.toml,sha256=fi33wc0qVZrK_UXQv_uOXykOnGn_xBWI-kYuo8KyiZI,1675
-./.github/workflows/publish.yml,sha256=0N02QrLlOaj3y9PGfl3Ns9wVgP-EaCizmcospjGGMco,1118
-./dlc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-./dlc/prime.py,sha256=FunhqcEXGUMm49WadYtWbH7MrMcYuqcmk-LPEZEEZeI,1382
-./util/__init__.py,sha256=C7VPB225Uro-9MzpMpofIyTH86gYUpiYbGDxk_Jtvaw,2190
-./zoo/__init__.py,sha256=vOfvSfvAZegCrJ_xEyQBfDQLVXLz6OXFepA1cmT9X58,1218
-./zoo/core.py,sha256=jBigckZRNOKhg4Bnki0iTfgp8z6yI43K5SkqMBcChv4,4776
-./zoo/jargoyle.py,sha256=CbhprejTP54KEaI9tWJqG-mKxCOcqKgtJvuuLb_zCZM,2972
-./zoo/mim1c.py,sha256=i0K2NjeM_pLVXOmTTUPelSIMhyTRwT5zMwXJ5XFLip4,2118
-./zoo/redactyl.py,sha256=V9-4XNLKzAQhqFqZ8pE6zFJatVKYdxOvBS3E8JVtoqo,2211
-./zoo/reduple.py,sha256=ggrGshp-Zx-O4xA_bhbMTWp9d4DEarYV6pTftjzLvHM,1711
-./zoo/rushmore.py,sha256=r67-qiNS194gXSz1Ep2TrojlOJd4O362njOnRAJFyTo,1612
-./zoo/scannequin.py,sha256=-dcykPGWFrnF5nDyHQLfW9Olj-uxV1e-6DVDXgdN8rg,3765
-./zoo/typogre.py,sha256=kw_lvD5a6JjYU9mwrOyicmQz3HuqxtvUVAdrGf32WrA,7872
-glitchlings-0.1.1.dist-info/METADATA,sha256=2VrY4qI-J6MM_3VXAcHI0gC-8eoRYerXEj7o28XfBpc,24182
-glitchlings-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-glitchlings-0.1.1.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.1.1.dist-info/licenses/LICENSE,sha256=EFEP1evBfHaxsMTBjxm0sZVRp2wct8QLvHE1saII5FI,11538
-glitchlings-0.1.1.dist-info/RECORD,,

main.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello from glitchlings!")
-
-
-if __name__ == "__main__":
-    main()

pyproject.toml

@@ -1,79 +0,0 @@
-[project]
-name = "glitchlings"
-version = "0.1.1"
-description = "Monsters for your language games."
-readme = "README.md"
-requires-python = ">=3.12"
-
-dependencies = [
-    "confusable-homoglyphs>=3.3.1",
-    "datasets>=4.0.0",
-    "jellyfish>=1.2.0",
-]
-
-authors = [
-    { name = "osoleve" }
-]
-
-keywords = ["nlp", "text", "adversarial", "data", "evaluation", "glitch"]
-
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
-    "Operating System :: OS Independent",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    "Topic :: Software Development :: Testing",
-]
-
-[project.license]
-file = "LICENSE"
-
-[project.urls]
-Homepage = "https://github.com/osoleve/glitchlings"
-Repository = "https://github.com/osoleve/glitchlings.git"
-Issues = "https://github.com/osoleve/glitchlings/issues"
-Changelog = "https://github.com/osoleve/glitchlings/releases"
-
-[project.scripts]
-glitchlings = "glitchlings.main:main"
-
-[project.optional-dependencies]
-jargoyle = [
-    "nltk>=3.9.1",
-]
-prime = [
-    "verifiers>=0.1.3.post0",
-]
-dev = [
-    "pytest>=8.0.0",
-]
-
-[build-system]
-requires = ["hatchling>=1.18"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build]
-exclude = [
-    "**/__pycache__/**",
-    ".git/**",
-    ".venv/**",
-]
-
-[tool.hatch.build.targets.sdist]
-exclude = [
-    "**/__pycache__/**",
-    ".git/**",
-    ".venv/**",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-exclude = [
-    "tests/**",
-    "tests",
-    "**/__pycache__/**",
-]

util/__init__.py

@@ -1,73 +0,0 @@
-import difflib
-
-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):
-    """
-    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 = []
-    buffer = []
-
-    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
-
-
-_KEYNEIGHBORS = {
-    "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"],
-    }
-}
-
-
-class KeyNeighbors:
-    def __init__(self):
-        for layout_name, layout in _KEYNEIGHBORS.items():
-            setattr(self, layout_name, layout)
-
-
-KEYNEIGHBORS = KeyNeighbors()

zoo/core.py

@@ -1,136 +0,0 @@
-from enum import IntEnum, auto
-from datasets import Dataset
-import random
-from typing import Any, Callable
-
-import functools as ft
-
-
-# Text levels for glitchlings, to enforce a sort order
-# Work from highest level down, because e.g.
-# duplicating a word then adding a typo is potentially different than
-# adding a typo then duplicating a word
-class AttackWave(IntEnum):
-    DOCUMENT = auto()
-    PARAGRAPH = auto()
-    SENTENCE = auto()
-    WORD = auto()
-    CHARACTER = auto()
-
-
-# Modifier for within the same attack wave
-class AttackOrder(IntEnum):
-    FIRST = auto()
-    EARLY = auto()
-    NORMAL = auto()
-    LATE = auto()
-    LAST = auto()
-
-
-class Glitchling:
-    def __init__(
-        self,
-        name: str,
-        corruption_function: Callable,
-        scope: AttackWave,
-        order: AttackOrder = AttackOrder.NORMAL,
-        seed: int | None = None,
-        **kwargs,
-    ):
-        # Each Glitchling maintains its own RNG for deterministic yet isolated behavior.
-        # If no seed is supplied, we fall back to Python's default entropy.
-        self.seed = seed
-        self.rng: random.Random = random.Random(seed)
-        self.name: str = name
-        self.corruption_function: Callable[..., str] = corruption_function
-        self.level: AttackWave = scope
-        self.order: AttackOrder = order
-        self.kwargs: dict[str, Any] = {}
-        for kw, val in kwargs.items():
-            self.set_param(kw, val)
-
-    def set_param(self, key: str, value: Any):
-        setattr(self, key, value)
-        self.kwargs[key] = value
-
-    def __corrupt(self, text, *args, **kwargs):
-        # Pass rng to underlying corruption function if it expects it.
-        if "rng" in self.corruption_function.__code__.co_varnames:
-            corrupted = self.corruption_function(text, *args, rng=self.rng, **kwargs)
-        else:
-            corrupted = self.corruption_function(text, *args, **kwargs)
-        return corrupted
-
-    def corrupt(self, text: str | list[dict]) -> str | list[dict]:
-        if isinstance(text, list):
-            text[-1]["content"] = self.__corrupt(text[-1]["content"], **self.kwargs)
-        else:
-            text = self.__corrupt(text, **self.kwargs)
-
-        return text
-
-    def corrupt_dataset(self, dataset: Dataset, columns: list[str]) -> Dataset:
-        def __corrupt_row(row):
-            for column in columns:
-                row[column] = self.corrupt(row[column])
-            return row
-
-        dataset = dataset.map(__corrupt_row)
-
-        return dataset
-
-    def __call__(self, text: str, *args, **kwds) -> str | list[dict]:
-        return self.corrupt(text, *args, **kwds)
-
-    def reset_rng(self, seed=None):
-        """Reset this glitchling's RNG to its initial seed (if one was provided)."""
-        if seed is not None:
-            self.seed = seed
-        if self.seed is not None:
-            self.rng = random.Random(self.seed)
-
-    def clone(self, seed=None) -> "Glitchling":
-        """Create a copy of this glitchling, optionally with a new seed."""
-        new_glitchling = Glitchling(
-            self.name,
-            self.corruption_function,
-            self.level,
-            self.order,
-            seed=seed if seed is not None else self.seed,
-            **self.kwargs,
-        )
-        return new_glitchling
-
-
-class Gaggle(Glitchling):
-    def __init__(self, glitchlings: list[Glitchling], seed: int = 151):
-        super().__init__("Gaggle", self.corrupt, AttackWave.DOCUMENT, seed=seed)
-        self.glitchlings: dict[AttackWave, list[Glitchling]] = {
-            level: [] for level in AttackWave
-        }
-        self.apply_order: list[Glitchling] = []
-        # Derive deterministic per-glitchling seeds from master seed if provided
-        for idx, g in enumerate(glitchlings):
-            _g = g.clone()
-            derived_seed = Gaggle.derive_seed(seed, _g.name, idx)
-            _g.reset_rng(derived_seed)
-            self.glitchlings[g.level].append(_g)
-        self.sort_glitchlings()
-
-    @staticmethod
-    def derive_seed(master_seed: int, glitchling_name: str, index: int) -> int:
-        """Derive a deterministic seed for a glitchling based on the master seed."""
-        return hash((master_seed, glitchling_name, index)) & 0xFFFFFFFF
-
-    def sort_glitchlings(self):
-        self.apply_order = [
-            g
-            for _, glitchlings in sorted(self.glitchlings.items())
-            for g in sorted(glitchlings, key=lambda x: (x.order, x.name))
-        ]
-
-    def corrupt(self, text: str) -> str:
-        corrupted = text
-        for glitchling in self.apply_order:
-            corrupted = glitchling(corrupted)
-        return corrupted

zoo/jargoyle.py

@@ -1,89 +0,0 @@
-import random
-from typing import Literal, Any, cast
-import nltk
-import re
-from nltk.corpus import wordnet as wn
-from .core import Glitchling, AttackWave
-
-nltk.download("wordnet", quiet=True)
-
-
-def substitute_random_synonyms(
-    text: str,
-    replacement_rate: float = 0.1,
-    part_of_speech: Literal["n", "v", "a", "r"] = wn.NOUN,
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Replace words with random WordNet synonyms.
-
-    Parameters
-    - text: Input text.
-    - replacement_rate: Max proportion of candidate words to replace (default 0.1).
-    - part_of_speech: WordNet POS to target. One of wn.NOUN (default), wn.VERB, wn.ADJ, wn.ADV.
-    - rng: Optional RNG instance used for deterministic sampling.
-    - seed: Optional seed if `rng` not provided.
-
-    Determinism
-    - Candidates collected in left-to-right order; no set() reordering.
-    - Replacement positions chosen via rng.sample.
-    - Synonyms sorted before rng.choice to fix ordering.
-    - Only first synset is used for stability.
-    """
-    if rng is None and seed is not None:
-        rng = random.Random(seed)
-    elif rng is None:
-        rng = random.Random()
-
-    # Split but keep whitespace separators so we can rebuild easily
-    tokens = re.split(r"(\s+)", text)
-
-    # Collect indices of candidate tokens (even positions 0,2,.. are words given our split design)
-    candidate_indices: list[int] = []
-    for idx, tok in enumerate(tokens):
-        if idx % 2 == 0 and tok and not tok.isspace():
-            if wn.synsets(tok, pos=part_of_speech):
-                candidate_indices.append(idx)
-
-    if not candidate_indices:
-        return text
-
-    max_replacements = int(len(candidate_indices) * replacement_rate)
-    if max_replacements <= 0:
-        return text
-
-    # Choose which positions to replace deterministically via rng.sample
-    replace_positions = rng.sample(candidate_indices, k=max_replacements)
-    # Process in ascending order to avoid affecting later indices
-    replace_positions.sort()
-
-    for pos in replace_positions:
-        word = tokens[pos]
-        synsets = wn.synsets(word, pos=part_of_speech)
-        if not synsets:
-            continue
-        synset0: Any = synsets[0]
-        lemmas_list = [lemma.name() for lemma in cast(Any, synset0).lemmas()]
-        if not lemmas_list:
-            continue
-        # Normalize & dedupe deterministically
-        synonyms = sorted(
-            {
-                lemma_str.replace("_", " ")
-                for lemma_str in lemmas_list
-                if lemma_str.lower() != word.lower()
-            }
-        )
-        if not synonyms:
-            continue
-        replacement = rng.choice(synonyms)
-        tokens[pos] = replacement
-
-    return "".join(tokens)
-
-
-jargoyle = Glitchling(
-    name="Jargoyle",
-    corruption_function=substitute_random_synonyms,
-    scope=AttackWave.WORD,
-)

zoo/rushmore.py

@@ -1,53 +0,0 @@
-import random
-import re
-from .core import Glitchling, AttackWave
-
-
-def delete_random_words(
-    text: str,
-    max_deletion_rate: float = 0.01,
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Delete random words from the input text.
-
-    Parameters
-    - text: The input text.
-    - max_deletion_rate: The maximum proportion of words to delete (default 0.01).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
-    """
-    if rng is None:
-        rng = random.Random(seed)
-
-    # Preserve exact spacing and punctuation by using regex
-    tokens = re.split(r"(\s+)", text)  # Split but keep separators
-
-    for i in range(
-        2, len(tokens), 2
-    ):  # Every other token is a word, but skip the first 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 deletion
-        if rng.random() < max_deletion_rate:
-            # Check if word has trailing punctuation
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, _, suffix = match.groups()
-                tokens[i] = f"{prefix.strip()}{suffix.strip()}"
-            else:
-                tokens[i] = ""
-
-    text = "".join(tokens)
-    text = re.sub(r"\s+([.,;:])", r"\1", text)
-    text = re.sub(r"\s{2,}", " ", text).strip()
-
-    return text
-
-
-rushmore = Glitchling("rushmore", delete_random_words, scope=AttackWave.WORD)