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

{zoo → glitchlings/zoo}/mim1c.py

@@ -1,62 +1,79 @@
-from typing import Literal
-from .core import Glitchling, AttackWave, AttackOrder
-import random
-from confusable_homoglyphs import confusables
-
-
-def swap_homoglyphs(
-    text: str,
-    replacement_rate: float = 0.02,
-    classes: list[str] | Literal["all"] | None = None,
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Replace characters with visually confusable homoglyphs.
-
-    Parameters
-    - text: Input text.
-    - replacement_rate: Max proportion of eligible characters to replace (default 0.02).
-    - classes: Restrict replacements to these Unicode script classes (default ["LATIN","GREEK","CYRILLIC"]). Use "all" to allow any.
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
-
-    Notes
-    - Only replaces characters present in confusables.confusables_data with single-codepoint alternatives.
-    - Maintains determinism by shuffling candidates and sampling via the provided RNG.
-    """
-    if rng is None:
-        rng = random.Random(seed)
-
-    if classes is None:
-        classes = ["LATIN", "GREEK", "CYRILLIC"]
-
-    target_chars = [char for char in text if char.isalnum()]
-    confusable_chars = [
-        char for char in target_chars if char in confusables.confusables_data
-    ]
-    num_replacements = int(len(confusable_chars) * replacement_rate)
-    done = 0
-    rng.shuffle(confusable_chars)
-    for char in confusable_chars:
-        if done >= num_replacements:
-            break
-        options = [
-            o["c"] for o in confusables.confusables_data[char] if len(o["c"]) == 1
-        ]
-        if classes != "all":
-            options = [opt for opt in options if confusables.alias(opt) in classes]
-        if not options:
-            continue
-        text = text.replace(char, rng.choice(options), 1)
-        done += 1
-    return text
-
-
-mim1c = Glitchling(
-    name="Mim1c",
-    corruption_function=swap_homoglyphs,
-    scope=AttackWave.CHARACTER,
-    order=AttackOrder.LAST,
-    replacement_rate=0.02,
-    classes=["LATIN", "GREEK", "CYRILLIC"],
-)
+from typing import Literal
+from .core import Glitchling, AttackWave, AttackOrder
+import random
+from confusable_homoglyphs import confusables
+
+
+def swap_homoglyphs(
+    text: str,
+    replacement_rate: float = 0.02,
+    classes: list[str] | Literal["all"] | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Replace characters with visually confusable homoglyphs.
+
+    Parameters
+    - text: Input text.
+    - replacement_rate: Max proportion of eligible characters to replace (default 0.02).
+    - classes: Restrict replacements to these Unicode script classes (default ["LATIN","GREEK","CYRILLIC"]). Use "all" to allow any.
+    - seed: Optional seed if `rng` not provided.
+    - rng: Optional RNG; overrides seed.
+
+    Notes
+    - Only replaces characters present in confusables.confusables_data with single-codepoint alternatives.
+    - Maintains determinism by shuffling candidates and sampling via the provided RNG.
+    """
+    if rng is None:
+        rng = random.Random(seed)
+
+    if classes is None:
+        classes = ["LATIN", "GREEK", "CYRILLIC"]
+
+    target_chars = [char for char in text if char.isalnum()]
+    confusable_chars = [
+        char for char in target_chars if char in confusables.confusables_data
+    ]
+    num_replacements = int(len(confusable_chars) * replacement_rate)
+    done = 0
+    rng.shuffle(confusable_chars)
+    for char in confusable_chars:
+        if done >= num_replacements:
+            break
+        options = [
+            o["c"] for o in confusables.confusables_data[char] if len(o["c"]) == 1
+        ]
+        if classes != "all":
+            options = [opt for opt in options if confusables.alias(opt) in classes]
+        if not options:
+            continue
+        text = text.replace(char, rng.choice(options), 1)
+        done += 1
+    return text
+
+
+class Mim1c(Glitchling):
+    """Glitchling that swaps characters for visually similar homoglyphs."""
+
+    def __init__(
+        self,
+        *,
+        replacement_rate: float = 0.02,
+        classes: list[str] | Literal["all"] | None = None,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            name="Mim1c",
+            corruption_function=swap_homoglyphs,
+            scope=AttackWave.CHARACTER,
+            order=AttackOrder.LAST,
+            seed=seed,
+            replacement_rate=replacement_rate,
+            classes=classes,
+        )
+
+
+mim1c = Mim1c()
+
+
+__all__ = ["Mim1c", "mim1c"]

{zoo → glitchlings/zoo}/redactyl.py

@@ -1,73 +1,91 @@
-import re
-import random
-from .core import Glitchling, AttackWave
-
-FULL_BLOCK = "█"
-
-
-def redact_words(
-    text: str,
-    replacement_char: str = FULL_BLOCK,
-    redaction_rate: float = 0.05,
-    merge_adjacent: bool = False,
-    seed: int = 151,
-    rng: random.Random | None = None,
-) -> str:
-    """Redact random words by replacing their characters.
-
-    Parameters
-    - text: Input text.
-    - replacement_char: The character to use for redaction (default FULL_BLOCK).
-    - redaction_rate: Max proportion of words to redact (default 0.05).
-    - merge_adjacent: If True, merges adjacent redactions across intervening non-word chars.
-    - seed: Seed used if `rng` not provided (default 151).
-    - 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)
-    word_indices = [i for i, token in enumerate(tokens) if i % 2 == 0 and token.strip()]
-    num_to_redact = max(1, int(len(word_indices) * redaction_rate))
-
-    # Sample from the indices of actual words
-    indices_to_redact = rng.sample(word_indices, k=num_to_redact)
-    indices_to_redact.sort()
-
-    for i in indices_to_redact:
-        if i >= len(tokens):
-            break
-
-        word = tokens[i]
-        if not word or word.isspace():  # Skip empty or whitespace
-            continue
-
-        # Check if word has trailing punctuation
-        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-        if match:
-            prefix, core, suffix = match.groups()
-            tokens[i] = f"{prefix}{replacement_char * len(core)}{suffix}"
-        else:
-            tokens[i] = f"{replacement_char * len(word)}"
-
-    text = "".join(tokens)
-
-    if merge_adjacent:
-        text = re.sub(
-            rf"{replacement_char}\W+{replacement_char}",
-            lambda m: replacement_char * (len(m.group(0)) - 1),
-            text,
-        )
-
-    return text
-
-
-redactyl = Glitchling(
-    name="Redactyl",
-    corruption_function=redact_words,
-    replacement_char=FULL_BLOCK,
-    redaction_rate=0.05,
-    scope=AttackWave.WORD,
-    seed=151,
-)
+import re
+import random
+from .core import Glitchling, AttackWave
+
+FULL_BLOCK = "█"
+
+
+def redact_words(
+    text: str,
+    replacement_char: str = FULL_BLOCK,
+    redaction_rate: float = 0.05,
+    merge_adjacent: bool = False,
+    seed: int = 151,
+    rng: random.Random | None = None,
+) -> str:
+    """Redact random words by replacing their characters.
+
+    Parameters
+    - text: Input text.
+    - replacement_char: The character to use for redaction (default FULL_BLOCK).
+    - redaction_rate: Max proportion of words to redact (default 0.05).
+    - merge_adjacent: If True, merges adjacent redactions across intervening non-word chars.
+    - seed: Seed used if `rng` not provided (default 151).
+    - 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)
+    word_indices = [i for i, token in enumerate(tokens) if i % 2 == 0 and token.strip()]
+    num_to_redact = max(1, int(len(word_indices) * redaction_rate))
+
+    # Sample from the indices of actual words
+    indices_to_redact = rng.sample(word_indices, k=num_to_redact)
+    indices_to_redact.sort()
+
+    for i in indices_to_redact:
+        if i >= len(tokens):
+            break
+
+        word = tokens[i]
+        if not word or word.isspace():  # Skip empty or whitespace
+            continue
+
+        # Check if word has trailing punctuation
+        match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+        if match:
+            prefix, core, suffix = match.groups()
+            tokens[i] = f"{prefix}{replacement_char * len(core)}{suffix}"
+        else:
+            tokens[i] = f"{replacement_char * len(word)}"
+
+    text = "".join(tokens)
+
+    if merge_adjacent:
+        text = re.sub(
+            rf"{replacement_char}\W+{replacement_char}",
+            lambda m: replacement_char * (len(m.group(0)) - 1),
+            text,
+        )
+
+    return text
+
+
+class Redactyl(Glitchling):
+    """Glitchling that redacts words with block characters."""
+
+    def __init__(
+        self,
+        *,
+        replacement_char: str = FULL_BLOCK,
+        redaction_rate: float = 0.05,
+        merge_adjacent: bool = False,
+        seed: int = 151,
+    ) -> None:
+        super().__init__(
+            name="Redactyl",
+            corruption_function=redact_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            replacement_char=replacement_char,
+            redaction_rate=redaction_rate,
+            merge_adjacent=merge_adjacent,
+        )
+
+
+redactyl = Redactyl()
+
+
+__all__ = ["Redactyl", "redactyl"]

{zoo → glitchlings/zoo}/reduple.py

@@ -1,54 +1,73 @@
-import re
-import random
-from .core import Glitchling, AttackWave
-
-
-def reduplicate_words(
-    text: str,
-    reduplication_rate: float = 0.05,
-    seed: int | None = None,
-    rng: random.Random | None = None,
-) -> str:
-    """Randomly reduplicate words in the text.
-
-    Parameters
-    - text: Input text.
-    - reduplication_rate: Max proportion of words to reduplicate (default 0.05).
-    - seed: Optional seed if `rng` not provided.
-    - rng: Optional RNG; overrides seed.
-
-    Notes
-    - Preserves spacing and punctuation by tokenizing with separators.
-    - Deterministic when run with a fixed seed or via Gaggle.
-    """
-    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(0, len(tokens), 2):  # Every other token is a 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 reduplication
-        if rng.random() < reduplication_rate:
-            # Check if word has trailing punctuation
-            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
-            if match:
-                prefix, core, suffix = match.groups()
-                # Reduplicate with a space: "word" -> "word word"
-                tokens[i] = f"{prefix}{core} {core}{suffix}"
-            else:
-                tokens[i] = f"{word} {word}"
-
-    return "".join(tokens)
-
-
-reduple = Glitchling(
-    name="Reduple", corruption_function=reduplicate_words, scope=AttackWave.WORD
-)
+import re
+import random
+from .core import Glitchling, AttackWave
+
+
+def reduplicate_words(
+    text: str,
+    reduplication_rate: float = 0.05,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+) -> str:
+    """Randomly reduplicate words in the text.
+
+    Parameters
+    - text: Input text.
+    - reduplication_rate: Max proportion of words to reduplicate (default 0.05).
+    - seed: Optional seed if `rng` not provided.
+    - rng: Optional RNG; overrides seed.
+
+    Notes
+    - Preserves spacing and punctuation by tokenizing with separators.
+    - Deterministic when run with a fixed seed or via Gaggle.
+    """
+    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(0, len(tokens), 2):  # Every other token is a 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 reduplication
+        if rng.random() < reduplication_rate:
+            # Check if word has trailing punctuation
+            match = re.match(r"^(\W*)(.*?)(\W*)$", word)
+            if match:
+                prefix, core, suffix = match.groups()
+                # Reduplicate with a space: "word" -> "word word"
+                tokens[i] = f"{prefix}{core} {core}{suffix}"
+            else:
+                tokens[i] = f"{word} {word}"
+
+    return "".join(tokens)
+
+
+class Reduple(Glitchling):
+    """Glitchling that repeats words to simulate stuttering speech."""
+
+    def __init__(
+        self,
+        *,
+        reduplication_rate: float = 0.05,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            name="Reduple",
+            corruption_function=reduplicate_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            reduplication_rate=reduplication_rate,
+        )
+
+
+reduple = Reduple()
+
+
+__all__ = ["Reduple", "reduple"]

{zoo → glitchlings/zoo}/rushmore.py

@@ -1,53 +1,74 @@
-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)
+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
+
+
+class Rushmore(Glitchling):
+    """Glitchling that deletes words to simulate missing information."""
+
+    def __init__(
+        self,
+        *,
+        max_deletion_rate: float = 0.01,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            name="Rushmore",
+            corruption_function=delete_random_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            max_deletion_rate=max_deletion_rate,
+        )
+
+
+rushmore = Rushmore()
+
+
+__all__ = ["Rushmore", "rushmore"]