glitchlings 0.2.5__tar.gz → 0.3.0__tar.gz

{glitchlings-0.2.5 → glitchlings-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.5
+Version: 0.3.0
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -209,7 +209,7 @@ Project-URL: Homepage, https://github.com/osoleve/glitchlings
 Project-URL: Repository, https://github.com/osoleve/glitchlings.git
 Project-URL: Issues, https://github.com/osoleve/glitchlings/issues
 Project-URL: Changelog, https://github.com/osoleve/glitchlings/releases
-Keywords: nlp,text,adversarial augmentation,text augmentation,large language models,llms,data augmentation,confusables,typo,
+Keywords: nlp,text,adversarial augmentation,text augmentation,large language models,llms,data augmentation,rlvr
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
@@ -296,7 +296,7 @@ print(gaggle(SAMPLE_TEXT))
 
 Consult the [Glitchlings Usage Guide](docs/index.md)
 for end-to-end instructions spanning the Python API, CLI, HuggingFace and Prime Intellect
-integrations, and the feature-flagged Rust pipeline.
+integrations, and the autodetected Rust pipeline (enabled whenever the extension is present).
 
 ## Motivation
 
@@ -428,7 +428,8 @@ _Did you say that or did I?_
 >
 > Args
 >
-> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.05, 5%).
+> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Rushmore
@@ -440,6 +441,19 @@ _I accidentally an entire word._
 > Args
 >
 > - `rate (float)`: The maximum proportion of words to delete (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
+> - `seed (int)`: The random seed for reproducibility (default: 151).
+
+### Adjax
+
+_Keep your hands and punctuation where I can see them._
+
+> _**Perfect Shuffle.**_ Adjax trades the cores of neighbouring words while leaving punctuation, casing, and surrounding whitespace untouched, turning fluent prose into locally scrambled tongue-twisters.
+>
+> Args
+>
+> - `rate (float)`: Probability that each adjacent pair swaps cores (default: 0.5, 50%).
+> - `swap_rate (float)`: Alias for `rate`, retained for backward compatibility.
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Redactyl
@@ -450,9 +464,10 @@ _Oops, that was my black highlighter._
 >
 > ### Args
 >
-> - `replacement_char (str)`: The character to use for redaction (default: █).
-> - `rate (float)`: The maximum proportion of words to redact (default: 0.05, 5%).
+> - `replacement_char (str)`: The character to use for redaction (default: FULL_BLOCK).
+> - `rate (float)`: The maximum proportion of words to redact (default: 0.025, 2.5%).
 > - `merge_adjacent (bool)`: Whether to redact the space between adjacent redacted words (default: False).
+> - `unweighted (bool)`: Sample words uniformly instead of biasing toward longer tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ## Field Report: Uncontained Specimens

{glitchlings-0.2.5 → glitchlings-0.3.0}/README.md

@@ -55,7 +55,7 @@ print(gaggle(SAMPLE_TEXT))
 
 Consult the [Glitchlings Usage Guide](docs/index.md)
 for end-to-end instructions spanning the Python API, CLI, HuggingFace and Prime Intellect
-integrations, and the feature-flagged Rust pipeline.
+integrations, and the autodetected Rust pipeline (enabled whenever the extension is present).
 
 ## Motivation
 
@@ -187,7 +187,8 @@ _Did you say that or did I?_
 >
 > Args
 >
-> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.05, 5%).
+> - `rate (float)`: The maximum proportion of words to reduplicate (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Rushmore
@@ -199,6 +200,19 @@ _I accidentally an entire word._
 > Args
 >
 > - `rate (float)`: The maximum proportion of words to delete (default: 0.01, 1%).
+> - `unweighted (bool)`: Sample words uniformly instead of favouring shorter tokens (default: False).
+> - `seed (int)`: The random seed for reproducibility (default: 151).
+
+### Adjax
+
+_Keep your hands and punctuation where I can see them._
+
+> _**Perfect Shuffle.**_ Adjax trades the cores of neighbouring words while leaving punctuation, casing, and surrounding whitespace untouched, turning fluent prose into locally scrambled tongue-twisters.
+>
+> Args
+>
+> - `rate (float)`: Probability that each adjacent pair swaps cores (default: 0.5, 50%).
+> - `swap_rate (float)`: Alias for `rate`, retained for backward compatibility.
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ### Redactyl
@@ -209,9 +223,10 @@ _Oops, that was my black highlighter._
 >
 > ### Args
 >
-> - `replacement_char (str)`: The character to use for redaction (default: █).
-> - `rate (float)`: The maximum proportion of words to redact (default: 0.05, 5%).
+> - `replacement_char (str)`: The character to use for redaction (default: FULL_BLOCK).
+> - `rate (float)`: The maximum proportion of words to redact (default: 0.025, 2.5%).
 > - `merge_adjacent (bool)`: Whether to redact the space between adjacent redacted words (default: False).
+> - `unweighted (bool)`: Sample words uniformly instead of biasing toward longer tokens (default: False).
 > - `seed (int)`: The random seed for reproducibility (default: 151).
 
 ## Field Report: Uncontained Specimens

{glitchlings-0.2.5 → glitchlings-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "glitchlings"
-version = "0.2.5"
+version = "0.3.0"
 description = "Monsters for your language games."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,7 +13,7 @@ authors = [
     { name = "osoleve" }
 ]
 
-keywords = ["nlp", "text", "adversarial augmentation", "text augmentation", "large language models", "llms", "data augmentation", "confusables", "typo", ""]
+keywords = ["nlp", "text", "adversarial augmentation", "text augmentation", "large language models", "llms", "data augmentation", "rlvr"]
 
 classifiers = [
     "Development Status :: 3 - Alpha",

{glitchlings-0.2.5 → glitchlings-0.3.0}/rust/zoo/src/glitch_ops.rs

@@ -359,6 +359,61 @@ impl GlitchOp for DeleteRandomWordsOp {
     }
 }
 
+/// Swaps adjacent word cores while keeping punctuation and spacing intact.
+#[derive(Debug, Clone, Copy)]
+pub struct SwapAdjacentWordsOp {
+    pub swap_rate: f64,
+}
+
+impl GlitchOp for SwapAdjacentWordsOp {
+    fn apply(&self, buffer: &mut TextBuffer, rng: &mut dyn GlitchRng) -> Result<(), GlitchOpError> {
+        let total_words = buffer.word_count();
+        if total_words < 2 {
+            return Ok(());
+        }
+
+        let clamped = self.swap_rate.max(0.0).min(1.0);
+        if clamped <= 0.0 {
+            return Ok(());
+        }
+
+        let mut index = 0usize;
+        while index + 1 < total_words {
+            let left_segment = match buffer.word_segment(index) {
+                Some(segment) => segment,
+                None => break,
+            };
+            let right_segment = match buffer.word_segment(index + 1) {
+                Some(segment) => segment,
+                None => break,
+            };
+
+            let left_original = left_segment.text().to_string();
+            let right_original = right_segment.text().to_string();
+
+            let (left_prefix, left_core, left_suffix) = split_affixes(&left_original);
+            let (right_prefix, right_core, right_suffix) = split_affixes(&right_original);
+
+            if left_core.is_empty() || right_core.is_empty() {
+                index += 2;
+                continue;
+            }
+
+            let should_swap = clamped >= 1.0 || rng.random()? < clamped;
+            if should_swap {
+                let left_replacement = format!("{left_prefix}{right_core}{left_suffix}");
+                let right_replacement = format!("{right_prefix}{left_core}{right_suffix}");
+                buffer.replace_word(index, &left_replacement)?;
+                buffer.replace_word(index + 1, &right_replacement)?;
+            }
+
+            index += 2;
+        }
+
+        Ok(())
+    }
+}
+
 /// Redacts words by replacing core characters with a replacement token.
 #[derive(Debug, Clone)]
 pub struct RedactWordsOp {
@@ -555,6 +610,7 @@ impl GlitchOp for OcrArtifactsOp {
 pub enum GlitchOperation {
     Reduplicate(ReduplicateWordsOp),
     Delete(DeleteRandomWordsOp),
+    SwapAdjacent(SwapAdjacentWordsOp),
     Redact(RedactWordsOp),
     Ocr(OcrArtifactsOp),
 }
@@ -564,6 +620,7 @@ impl GlitchOp for GlitchOperation {
         match self {
             GlitchOperation::Reduplicate(op) => op.apply(buffer, rng),
             GlitchOperation::Delete(op) => op.apply(buffer, rng),
+            GlitchOperation::SwapAdjacent(op) => op.apply(buffer, rng),
             GlitchOperation::Redact(op) => op.apply(buffer, rng),
             GlitchOperation::Ocr(op) => op.apply(buffer, rng),
         }
@@ -574,7 +631,7 @@ impl GlitchOp for GlitchOperation {
 mod tests {
     use super::{
         DeleteRandomWordsOp, GlitchOp, GlitchOpError, OcrArtifactsOp, RedactWordsOp,
-        ReduplicateWordsOp,
+        ReduplicateWordsOp, SwapAdjacentWordsOp,
     };
     use crate::rng::PyRng;
     use crate::text_buffer::TextBuffer;
@@ -592,6 +649,27 @@ mod tests {
         assert_eq!(buffer.to_string(), "Hello Hello world world");
     }
 
+    #[test]
+    fn swap_adjacent_words_swaps_cores() {
+        let mut buffer = TextBuffer::from_str("Alpha, beta! Gamma delta");
+        let mut rng = PyRng::new(7);
+        let op = SwapAdjacentWordsOp { swap_rate: 1.0 };
+        op.apply(&mut buffer, &mut rng)
+            .expect("swap operation succeeds");
+        assert_eq!(buffer.to_string(), "beta, Alpha! delta Gamma");
+    }
+
+    #[test]
+    fn swap_adjacent_words_respects_zero_rate() {
+        let original = "Do not move these words";
+        let mut buffer = TextBuffer::from_str(original);
+        let mut rng = PyRng::new(42);
+        let op = SwapAdjacentWordsOp { swap_rate: 0.0 };
+        op.apply(&mut buffer, &mut rng)
+            .expect("swap operation succeeds");
+        assert_eq!(buffer.to_string(), original);
+    }
+
     #[test]
     fn delete_random_words_cleans_up_spacing() {
         let mut buffer = TextBuffer::from_str("One two three four five");

{glitchlings-0.2.5 → glitchlings-0.3.0}/rust/zoo/src/lib.rs

@@ -14,7 +14,7 @@ use pyo3::{exceptions::PyValueError, FromPyObject};
 
 pub use glitch_ops::{
     DeleteRandomWordsOp, GlitchOpError, GlitchOperation, OcrArtifactsOp, RedactWordsOp,
-    ReduplicateWordsOp,
+    ReduplicateWordsOp, SwapAdjacentWordsOp,
 };
 pub use pipeline::{derive_seed, GlitchDescriptor, Pipeline, PipelineError};
 pub use rng::{PyRng, PyRngError};
@@ -101,6 +101,9 @@ enum PyGlitchOperation {
         max_deletion_rate: f64,
         unweighted: bool,
     },
+    SwapAdjacent {
+        swap_rate: f64,
+    },
     Redact {
         replacement_char: String,
         redaction_rate: f64,
@@ -154,6 +157,15 @@ impl<'py> FromPyObject<'py> for PyGlitchOperation {
                     unweighted,
                 })
             }
+            "swap_adjacent" => {
+                let rate = dict
+                    .get_item("swap_rate")?
+                    .ok_or_else(|| {
+                        PyValueError::new_err("swap_adjacent operation missing 'swap_rate'")
+                    })?
+                    .extract()?;
+                Ok(PyGlitchOperation::SwapAdjacent { swap_rate: rate })
+            }
             "redact" => {
                 let replacement_char = dict
                     .get_item("replacement_char")?
@@ -241,6 +253,16 @@ fn delete_random_words(
     apply_operation(text, op, rng).map_err(glitch_ops::GlitchOpError::into_pyerr)
 }
 
+#[pyfunction]
+fn swap_adjacent_words(
+    text: &str,
+    swap_rate: f64,
+    rng: &Bound<'_, PyAny>,
+) -> PyResult<String> {
+    let op = SwapAdjacentWordsOp { swap_rate };
+    apply_operation(text, op, rng).map_err(glitch_ops::GlitchOpError::into_pyerr)
+}
+
 #[pyfunction]
 fn ocr_artifacts(text: &str, error_rate: f64, rng: &Bound<'_, PyAny>) -> PyResult<String> {
     let op = OcrArtifactsOp { error_rate };
@@ -289,6 +311,11 @@ fn compose_glitchlings(
                     max_deletion_rate,
                     unweighted,
                 }),
+                PyGlitchOperation::SwapAdjacent { swap_rate } => {
+                    GlitchOperation::SwapAdjacent(glitch_ops::SwapAdjacentWordsOp {
+                        swap_rate,
+                    })
+                }
                 PyGlitchOperation::Redact {
                     replacement_char,
                     redaction_rate,
@@ -320,6 +347,7 @@ fn compose_glitchlings(
 fn _zoo_rust(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(reduplicate_words, m)?)?;
     m.add_function(wrap_pyfunction!(delete_random_words, m)?)?;
+    m.add_function(wrap_pyfunction!(swap_adjacent_words, m)?)?;
     m.add_function(wrap_pyfunction!(ocr_artifacts, m)?)?;
     m.add_function(wrap_pyfunction!(redact_words, m)?)?;
     m.add_function(wrap_pyfunction!(compose_glitchlings, m)?)?;

{glitchlings-0.2.5 → glitchlings-0.3.0}/rust/zoo/src/pipeline.rs

@@ -112,6 +112,7 @@ mod tests {
     use super::{derive_seed, GlitchDescriptor, Pipeline};
     use crate::glitch_ops::{
         DeleteRandomWordsOp, GlitchOperation, OcrArtifactsOp, RedactWordsOp, ReduplicateWordsOp,
+        SwapAdjacentWordsOp,
     };
 
     #[test]
@@ -207,4 +208,18 @@ mod tests {
             .expect("pipeline run succeeds");
         assert_eq!(output, "Guard the ██ at ██████████");
     }
+    #[test]
+    fn pipeline_swaps_adjacent_words() {
+        let master_seed = 2025i128;
+        let descriptors = vec![GlitchDescriptor {
+            name: "Adjax".to_string(),
+            seed: derive_seed(master_seed, "Adjax", 0),
+            operation: GlitchOperation::SwapAdjacent(SwapAdjacentWordsOp { swap_rate: 1.0 }),
+        }];
+        let pipeline = Pipeline::new(master_seed, descriptors);
+        let output = pipeline
+            .run("Echo this line please")
+            .expect("pipeline succeeds");
+        assert_eq!(output, "this Echo please line");
+    }
 }

{glitchlings-0.2.5 → glitchlings-0.3.0}/src/glitchlings/__init__.py

@@ -5,6 +5,8 @@ from .zoo import (
     mim1c,
     Jargoyle,
     jargoyle,
+    Adjax,
+    adjax,
     Redactyl,
     redactyl,
     Reduple,
@@ -29,6 +31,8 @@ __all__ = [
     "mim1c",
     "Jargoyle",
     "jargoyle",
+    "Adjax",
+    "adjax",
     "Redactyl",
     "redactyl",
     "Reduple",

{glitchlings-0.2.5 → glitchlings-0.3.0}/src/glitchlings/dlc/prime.py

@@ -49,7 +49,24 @@ def _resolve_columns(dataset: Dataset, columns: Sequence[str] | None) -> list[st
         if candidate in available:
             return [candidate]
 
-    sample = dataset[0] if len(dataset) else {}
+    try:
+        dataset_length = len(dataset)  # type: ignore[arg-type]
+    except TypeError:
+        preview_rows: list[dict[str, Any]]
+        take_fn = getattr(dataset, "take", None)
+        if callable(take_fn):
+            preview_rows = list(take_fn(1))
+        else:
+            iterator = iter(dataset)
+            try:
+                first_row = next(iterator)
+            except StopIteration:
+                preview_rows = []
+            else:
+                preview_rows = [first_row]
+        sample = dict(preview_rows[0]) if preview_rows else {}
+    else:
+        sample = dataset[0] if dataset_length else {}
     inferred = [
         name
         for name in dataset.column_names

{glitchlings-0.2.5 → glitchlings-0.3.0}/src/glitchlings/zoo/__init__.py

@@ -6,6 +6,7 @@ from typing import Any
 from .typogre import Typogre, typogre
 from .mim1c import Mim1c, mim1c
 from .jargoyle import Jargoyle, jargoyle, dependencies_available as _jargoyle_available
+from .adjax import Adjax, adjax
 from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
 from .redactyl import Redactyl, redactyl
@@ -20,6 +21,8 @@ __all__ = [
     "mim1c",
     "Jargoyle",
     "jargoyle",
+    "Adjax",
+    "adjax",
     "Reduple",
     "reduple",
     "Rushmore",
@@ -43,7 +46,7 @@ _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.extend([adjax, reduple, rushmore, redactyl, scannequin, zeedub])
 
 BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
     glitchling.name.lower(): glitchling for glitchling in _BUILTIN_GLITCHLING_LIST
@@ -52,6 +55,7 @@ BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
 _BUILTIN_GLITCHLING_TYPES: dict[str, type[Glitchling]] = {
     typogre.name.lower(): Typogre,
     mim1c.name.lower(): Mim1c,
+    adjax.name.lower(): Adjax,
     reduple.name.lower(): Reduple,
     rushmore.name.lower(): Rushmore,
     redactyl.name.lower(): Redactyl,

glitchlings-0.3.0/src/glitchlings/zoo/_text_utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import re
+
+_WORD_SPLIT_PATTERN = re.compile(r"(\s+)")
+_TOKEN_EDGES_PATTERN = re.compile(r"^(\W*)(.*?)(\W*)$")
+
+
+def split_preserving_whitespace(text: str) -> list[str]:
+    """Split text while keeping whitespace tokens for stable reconstruction."""
+
+    return _WORD_SPLIT_PATTERN.split(text)
+
+
+def split_token_edges(token: str) -> tuple[str, str, str]:
+    """Return leading, core, and trailing segments for a token."""
+
+    match = _TOKEN_EDGES_PATTERN.match(token)
+    if match is None:
+        return "", token, ""
+    return match.group(1), match.group(2), match.group(3)
+
+
+def token_core_length(token: str) -> int:
+    """Return the length of the main word characters for weighting heuristics."""
+
+    _, core, _ = split_token_edges(token)
+    candidate = core if core else token
+    length = len(candidate)
+    if length <= 0:
+        stripped = token.strip()
+        length = len(stripped) if stripped else len(token)
+    if length <= 0:
+        length = 1
+    return length
+
+
+__all__ = [
+    "split_preserving_whitespace",
+    "split_token_edges",
+    "token_core_length",
+]

glitchlings-0.3.0/src/glitchlings/zoo/adjax.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from ._rate import resolve_rate
+from ._text_utils import split_preserving_whitespace, split_token_edges
+from .core import AttackWave, Glitchling
+
+try:
+    from glitchlings._zoo_rust import swap_adjacent_words as _swap_adjacent_words_rust
+except ImportError:  # pragma: no cover - optional acceleration
+    _swap_adjacent_words_rust = None
+
+
+def _python_swap_adjacent_words(
+    text: str,
+    *,
+    rate: float,
+    rng: random.Random,
+) -> str:
+    """Swap the cores of adjacent words while keeping affixes and spacing intact."""
+
+    tokens = split_preserving_whitespace(text)
+    if len(tokens) < 2:
+        return text
+
+    word_indices: list[int] = []
+    for index in range(len(tokens)):
+        token = tokens[index]
+        if not token or token.isspace():
+            continue
+        if index % 2 == 0:
+            word_indices.append(index)
+
+    if len(word_indices) < 2:
+        return text
+
+    clamped = max(0.0, min(rate, 1.0))
+    if clamped <= 0.0:
+        return text
+
+    for cursor in range(0, len(word_indices) - 1, 2):
+        left_index = word_indices[cursor]
+        right_index = word_indices[cursor + 1]
+
+        left_token = tokens[left_index]
+        right_token = tokens[right_index]
+
+        left_prefix, left_core, left_suffix = split_token_edges(left_token)
+        right_prefix, right_core, right_suffix = split_token_edges(right_token)
+
+        if not left_core or not right_core:
+            continue
+
+        should_swap = clamped >= 1.0 or rng.random() < clamped
+        if not should_swap:
+            continue
+
+        tokens[left_index] = f"{left_prefix}{right_core}{left_suffix}"
+        tokens[right_index] = f"{right_prefix}{left_core}{right_suffix}"
+
+    return "".join(tokens)
+
+
+def swap_adjacent_words(
+    text: str,
+    rate: float | None = None,
+    seed: int | None = None,
+    rng: random.Random | None = None,
+    *,
+    swap_rate: float | None = None,
+) -> str:
+    """Swap adjacent word cores while preserving spacing and punctuation."""
+
+    effective_rate = resolve_rate(
+        rate=rate,
+        legacy_value=swap_rate,
+        default=0.5,
+        legacy_name="swap_rate",
+    )
+    clamped_rate = max(0.0, min(effective_rate, 1.0))
+
+    if rng is None:
+        rng = random.Random(seed)
+
+    if _swap_adjacent_words_rust is not None:
+        return _swap_adjacent_words_rust(text, clamped_rate, rng)
+
+    return _python_swap_adjacent_words(text, rate=clamped_rate, rng=rng)
+
+
+class Adjax(Glitchling):
+    """Glitchling that swaps adjacent words to scramble local semantics."""
+
+    def __init__(
+        self,
+        *,
+        rate: float | None = None,
+        swap_rate: float | None = None,
+        seed: int | None = None,
+    ) -> None:
+        self._param_aliases = {"swap_rate": "rate"}
+        effective_rate = resolve_rate(
+            rate=rate,
+            legacy_value=swap_rate,
+            default=0.5,
+            legacy_name="swap_rate",
+        )
+        super().__init__(
+            name="Adjax",
+            corruption_function=swap_adjacent_words,
+            scope=AttackWave.WORD,
+            seed=seed,
+            rate=effective_rate,
+        )
+
+    def pipeline_operation(self) -> dict[str, Any] | None:
+        rate = self.kwargs.get("rate")
+        if rate is None:
+            return None
+        return {
+            "type": "swap_adjacent",
+            "swap_rate": float(rate),
+        }
+
+
+adjax = Adjax()
+
+
+__all__ = ["Adjax", "adjax", "swap_adjacent_words"]