glitchlings 0.1.1__py3-none-any.whl → 0.1.2__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/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,
-)