glitchlings 0.2.1__tar.gz → 0.2.2__tar.gz

glitchlings-0.2.2/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include rust *.rs *.toml *.lock *.tsv
+recursive-include src/glitchlings/zoo *.tsv
+prune rust/target
+prune rust/zoo/target

{glitchlings-0.2.1 → glitchlings-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.2.1
+Version: 0.2.2
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -232,11 +232,14 @@ Provides-Extra: hf
 Requires-Dist: datasets>=4.0.0; extra == "hf"
 Provides-Extra: wordnet
 Requires-Dist: nltk>=3.9.1; extra == "wordnet"
+Requires-Dist: numpy<=2.0,>=1.24; extra == "wordnet"
 Provides-Extra: prime
 Requires-Dist: verifiers>=0.1.3.post0; extra == "prime"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: hypothesis>=6.140.0; extra == "dev"
+Requires-Dist: nltk>=3.9.1; extra == "dev"
+Requires-Dist: numpy<=2.0,>=1.24; extra == "dev"
 Dynamic: license-file
 
 #
@@ -294,22 +297,10 @@ print(gaggle(SAMPLE_TEXT))
 
 ## Usage
 
-Glitchlings slot into evaluation pipelines just as easily as they corrupt stray strings.
-
-- **Direct invocation** – Instantiate a glitchling (or `Gaggle`) and call it on strings, iterables, or datasets. Keep the seed stable to make every run deterministic.
-- **Dataset corruption** – After ``import glitchlings.dlc.huggingface``, call ``Dataset.glitch(...)`` (or a `Gaggle`'s `.corrupt_dataset`) to perturb a Hugging Face `datasets.Dataset` and return a corrupted copy for training or evaluation.
-
-### Rust pipeline acceleration (opt-in)
-
-The refactored Rust pipeline can execute multiple glitchlings without
-bouncing back through Python, but it is gated behind a feature flag so
-teams can roll it out gradually. After compiling the Rust extension
-(`python -m cibuildwheel --output-dir dist`) set
-`GLITCHLINGS_RUST_PIPELINE=1` (or `true`, `yes`, `on`) before importing
-`glitchlings`. When the flag is set and the extension is available,
-`Gaggle` automatically batches compatible glitchlings into the Rust
-pipeline; otherwise it transparently falls back to the legacy Python
-loop.
+Need detailed usage patterns, dataset workflows, or tips for enabling the
+Rust accelerator? Consult the [Glitchlings Usage Guide](docs/index.md)
+for end-to-end instructions spanning the Python API, CLI, Hugging Face
+integrations, and the feature-flagged Rust pipeline.
 
 ### Prime Intellect environments
 
@@ -384,11 +375,14 @@ glitchlings --list
 # Run Typogre against the contents of a file and inspect the diff.
 glitchlings -g typogre --file documents/report.txt --diff
 
+# Configure glitchlings inline by passing keyword arguments.
+glitchlings -g "Typogre(max_change_rate=0.05)" "Ghouls just wanna have fun"
+
 # Pipe text straight into the CLI for an on-the-fly corruption.
 echo "Beware LLM-written flavor-text" | glitchlings -g mim1c
 ```
 
-Use `--help` for a complete breakdown of available options.
+Use `--help` for a complete breakdown of available options, including support for parameterised glitchlings via `-g "Name(arg=value, ...)"` to mirror the Python API.
 
 ## Development
 

{glitchlings-0.2.1 → glitchlings-0.2.2}/README.md

@@ -53,22 +53,10 @@ print(gaggle(SAMPLE_TEXT))
 
 ## Usage
 
-Glitchlings slot into evaluation pipelines just as easily as they corrupt stray strings.
-
-- **Direct invocation** – Instantiate a glitchling (or `Gaggle`) and call it on strings, iterables, or datasets. Keep the seed stable to make every run deterministic.
-- **Dataset corruption** – After ``import glitchlings.dlc.huggingface``, call ``Dataset.glitch(...)`` (or a `Gaggle`'s `.corrupt_dataset`) to perturb a Hugging Face `datasets.Dataset` and return a corrupted copy for training or evaluation.
-
-### Rust pipeline acceleration (opt-in)
-
-The refactored Rust pipeline can execute multiple glitchlings without
-bouncing back through Python, but it is gated behind a feature flag so
-teams can roll it out gradually. After compiling the Rust extension
-(`python -m cibuildwheel --output-dir dist`) set
-`GLITCHLINGS_RUST_PIPELINE=1` (or `true`, `yes`, `on`) before importing
-`glitchlings`. When the flag is set and the extension is available,
-`Gaggle` automatically batches compatible glitchlings into the Rust
-pipeline; otherwise it transparently falls back to the legacy Python
-loop.
+Need detailed usage patterns, dataset workflows, or tips for enabling the
+Rust accelerator? Consult the [Glitchlings Usage Guide](docs/index.md)
+for end-to-end instructions spanning the Python API, CLI, Hugging Face
+integrations, and the feature-flagged Rust pipeline.
 
 ### Prime Intellect environments
 
@@ -143,11 +131,14 @@ glitchlings --list
 # Run Typogre against the contents of a file and inspect the diff.
 glitchlings -g typogre --file documents/report.txt --diff
 
+# Configure glitchlings inline by passing keyword arguments.
+glitchlings -g "Typogre(max_change_rate=0.05)" "Ghouls just wanna have fun"
+
 # Pipe text straight into the CLI for an on-the-fly corruption.
 echo "Beware LLM-written flavor-text" | glitchlings -g mim1c
 ```
 
-Use `--help` for a complete breakdown of available options.
+Use `--help` for a complete breakdown of available options, including support for parameterised glitchlings via `-g "Name(arg=value, ...)"` to mirror the Python API.
 
 ## Development
 

{glitchlings-0.2.1 → glitchlings-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "glitchlings"
-version = "0.2.1"
+version = "0.2.2"
 description = "Monsters for your language games."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -46,11 +46,13 @@ glitchlings = "glitchlings.main:main"
 
 [project.optional-dependencies]
 hf = ["datasets>=4.0.0"]
-wordnet = ["nltk>=3.9.1"]
+wordnet = ["nltk>=3.9.1", "numpy>=1.24,<=2.0"]
 prime = ["verifiers>=0.1.3.post0"]
 dev = [
     "pytest>=8.0.0",
     "hypothesis>=6.140.0",
+    "nltk>=3.9.1",
+    "numpy>=1.24,<=2.0",
 ]
 
 [build-system]
@@ -59,6 +61,10 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
 package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.package-data]
+"glitchlings.zoo" = ["ocr_confusions.tsv"]
 
 [tool.setuptools.packages.find]
 where = ["src"]
@@ -69,11 +75,6 @@ path = "rust/zoo/Cargo.toml"
 binding = "PyO3"
 debug = false
 
-[[tool.setuptools-rust.ext-modules]]
-target = "glitchlings._typogre_rust"
-path = "rust/typogre/Cargo.toml"
-binding = "PyO3"
-debug = false
 
 [tool.pytest.ini_options]
 pythonpath = [

{glitchlings-0.2.1 → glitchlings-0.2.2}/rust/Cargo.lock

@@ -316,13 +316,6 @@ version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
-[[package]]
-name = "typogre_rust"
-version = "0.1.0"
-dependencies = [
- "pyo3",
-]
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.19"

{glitchlings-0.2.1 → glitchlings-0.2.2}/rust/Cargo.toml

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-    "typogre",
     "zoo",
 ]
 resolver = "2"

glitchlings-0.2.2/rust/zoo/assets/ocr_confusions.tsv

@@ -0,0 +1,30 @@
+# Source  Replacements (space-separated)
+li h
+h li
+rn m
+m rn
+cl d
+d cl
+I l
+l I 1
+1 l I
+0 O
+O 0
+B 8
+8 B
+S 5
+5 S
+Z 2
+2 Z
+G 6
+6 G
+“ "
+” "
+‘ '
+’ '
+— -
+– -
+vv w
+w vv
+ri n
+n ri

glitchlings-0.2.2/rust/zoo/build.rs

@@ -0,0 +1,134 @@
+use std::env;
+use std::ffi::{OsStr, OsString};
+use std::fs;
+use std::io::{self, ErrorKind};
+use std::path::PathBuf;
+use std::process::Command;
+
+fn main() {
+    prepare_confusion_table().expect("failed to stage OCR confusion table for compilation");
+    pyo3_build_config::add_extension_module_link_args();
+
+    if let Some(python) = configured_python() {
+        link_python(&python);
+    } else if let Some(python) = detect_python() {
+        link_python(&python);
+    }
+}
+
+fn configured_python() -> Option<OsString> {
+    std::env::var_os("PYO3_PYTHON")
+        .or_else(|| std::env::var_os("PYTHON"))
+        .filter(|path| !path.is_empty())
+}
+
+fn detect_python() -> Option<OsString> {
+    const CANDIDATES: &[&str] = &["python3.12", "python3", "python"];
+
+    for candidate in CANDIDATES {
+        let status = Command::new(candidate)
+            .arg("-c")
+            .arg("import sys")
+            .output();
+
+        if let Ok(output) = status {
+            if output.status.success() {
+                return Some(OsString::from(candidate));
+            }
+        }
+    }
+
+    None
+}
+
+fn link_python(python: &OsStr) {
+    if let Some(path) = query_python(
+        python,
+        "import sysconfig; print(sysconfig.get_config_var('LIBDIR') or '')",
+    ) {
+        let trimmed = path.trim();
+        if !trimmed.is_empty() {
+            println!("cargo:rustc-link-search=native={trimmed}");
+        }
+    }
+
+    if let Some(path) = query_python(
+        python,
+        "import sysconfig; print(sysconfig.get_config_var('LIBPL') or '')",
+    ) {
+        let trimmed = path.trim();
+        if !trimmed.is_empty() {
+            println!("cargo:rustc-link-search=native={trimmed}");
+        }
+    }
+
+    if let Some(library) = query_python(
+        python,
+        "import sysconfig; print(sysconfig.get_config_var('LDLIBRARY') or '')",
+    ) {
+        let name = library.trim();
+        if let Some(stripped) = name.strip_prefix("lib") {
+            let stem = stripped
+                .strip_suffix(".so")
+                .or_else(|| stripped.strip_suffix(".a"))
+                .unwrap_or(stripped);
+            if !stem.is_empty() {
+                println!("cargo:rustc-link-lib={stem}");
+            }
+        }
+    }
+}
+
+fn query_python(python: &OsStr, command: &str) -> Option<String> {
+    let output = Command::new(python).arg("-c").arg(command).output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let value = String::from_utf8(output.stdout).ok()?;
+    Some(value)
+}
+
+fn prepare_confusion_table() -> io::Result<()> {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("missing manifest dir"));
+    let out_dir = PathBuf::from(env::var("OUT_DIR").expect("missing OUT_DIR"));
+
+    let repo_path = manifest_dir.join("../../src/glitchlings/zoo/ocr_confusions.tsv");
+    let packaged_path = manifest_dir.join("assets/ocr_confusions.tsv");
+    println!("cargo:rerun-if-changed={}", packaged_path.display());
+
+    let source_path = if repo_path.exists() {
+        println!("cargo:rerun-if-changed={}", repo_path.display());
+        if packaged_path.exists() {
+            let repo_bytes = fs::read(&repo_path)?;
+            let packaged_bytes = fs::read(&packaged_path)?;
+            if repo_bytes != packaged_bytes {
+                return Err(io::Error::new(
+                    ErrorKind::Other,
+                    format!(
+                        "OCR confusion table at {} is out of sync with {}",
+                        packaged_path.display(),
+                        repo_path.display()
+                    ),
+                ));
+            }
+        }
+        repo_path
+    } else {
+        if !packaged_path.exists() {
+            return Err(io::Error::new(
+                ErrorKind::NotFound,
+                format!(
+                    "missing OCR confusion table; looked for {} and {}",
+                    repo_path.display(),
+                    packaged_path.display()
+                ),
+            ));
+        }
+        packaged_path
+    };
+
+    fs::create_dir_all(&out_dir)?;
+    fs::copy(&source_path, out_dir.join("ocr_confusions.tsv"))?;
+    Ok(())
+}
+

{glitchlings-0.2.1 → glitchlings-0.2.2}/rust/zoo/src/glitch_ops.rs

@@ -500,6 +500,6 @@ mod tests {
         let mut rng = PyRng::new(1);
         let op = OcrArtifactsOp { error_rate: 1.0 };
         op.apply(&mut buffer, &mut rng).expect("ocr succeeds");
-        assert_eq!(buffer.to_string(), "Tlie rn m");
+        assert_eq!(buffer.to_string(), "Tlie rn rri");
     }
 }

{glitchlings-0.2.1 → glitchlings-0.2.2}/rust/zoo/src/lib.rs

@@ -3,6 +3,7 @@ mod pipeline;
 mod resources;
 mod rng;
 mod text_buffer;
+mod typogre;
 
 use glitch_ops::{GlitchOp, GlitchRng};
 use pyo3::prelude::*;
@@ -17,7 +18,6 @@ pub use glitch_ops::{
 pub use pipeline::{derive_seed, GlitchDescriptor, Pipeline, PipelineError};
 pub use rng::{PyRng, PyRngError};
 pub use text_buffer::{SegmentKind, TextBuffer, TextBufferError, TextSegment, TextSpan};
-
 struct PythonRngAdapter<'py> {
     rng: Bound<'py, PyAny>,
 }
@@ -279,5 +279,6 @@ fn _zoo_rust(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(ocr_artifacts, m)?)?;
     m.add_function(wrap_pyfunction!(redact_words, m)?)?;
     m.add_function(wrap_pyfunction!(compose_glitchlings, m)?)?;
+    m.add_function(wrap_pyfunction!(typogre::fatfinger, m)?)?;
     Ok(())
 }

{glitchlings-0.2.1 → glitchlings-0.2.2}/rust/zoo/src/resources.rs

@@ -1,6 +1,8 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
 
+const RAW_OCR_CONFUSIONS: &str = include_str!(concat!(env!("OUT_DIR"), "/ocr_confusions.tsv"));
+
 /// Precompiled regex removing spaces before punctuation characters.
 pub static SPACE_BEFORE_PUNCTUATION: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"\s+([.,;:])").expect("valid punctuation regex"));
@@ -9,43 +11,30 @@ pub static SPACE_BEFORE_PUNCTUATION: Lazy<Regex> =
 pub static MULTIPLE_WHITESPACE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"\s{2,}").expect("valid multi-whitespace regex"));
 
-static BASE_CONFUSION_TABLE: &[(&str, &[&str])] = &[
-    ("li", &["h"]),
-    ("h", &["li"]),
-    ("rn", &["m"]),
-    ("m", &["rn"]),
-    ("cl", &["d"]),
-    ("d", &["cl"]),
-    ("I", &["l"]),
-    ("l", &["I", "1"]),
-    ("1", &["l", "I"]),
-    ("0", &["O"]),
-    ("O", &["0"]),
-    ("B", &["8"]),
-    ("8", &["B"]),
-    ("S", &["5"]),
-    ("5", &["S"]),
-    ("Z", &["2"]),
-    ("2", &["Z"]),
-    ("G", &["6"]),
-    ("6", &["G"]),
-    ("“", &["\""]),
-    ("”", &["\""]),
-    ("‘", &["'"]),
-    ("’", &["'"]),
-    ("—", &["-"]),
-    ("–", &["-"]),
-];
-
 /// Sorted confusion pairs reused by glitchling implementations.
 pub static OCR_CONFUSION_TABLE: Lazy<Vec<(&'static str, &'static [&'static str])>> =
     Lazy::new(|| {
-        let mut entries: Vec<(usize, (&'static str, &'static [&'static str]))> =
-            BASE_CONFUSION_TABLE
-                .iter()
-                .copied()
-                .enumerate()
-                .collect();
+        let mut entries: Vec<(usize, (&'static str, &'static [&'static str]))> = Vec::new();
+
+        for (line_number, line) in RAW_OCR_CONFUSIONS.lines().enumerate() {
+            let trimmed = line.trim();
+            if trimmed.is_empty() || trimmed.starts_with('#') {
+                continue;
+            }
+
+            let mut parts = trimmed.split_whitespace();
+            let Some(source) = parts.next() else {
+                continue;
+            };
+            let replacements: Vec<&'static str> = parts.collect();
+            if replacements.is_empty() {
+                continue;
+            }
+
+            let leaked: &'static [&'static str] = Box::leak(replacements.into_boxed_slice());
+            entries.push((line_number, (source, leaked)));
+        }
+
         entries.sort_by(|a, b| {
             let a_len = a.1 .0.len();
             let b_len = b.1 .0.len();
@@ -53,6 +42,7 @@ pub static OCR_CONFUSION_TABLE: Lazy<Vec<(&'static str, &'static [&'static str])
                 .cmp(&a_len)
                 .then_with(|| a.0.cmp(&b.0))
         });
+
         entries.into_iter().map(|(_, pair)| pair).collect()
     });
 

glitchlings-0.2.1/rust/typogre/src/lib.rs → glitchlings-0.2.2/rust/zoo/src/typogre.rs

@@ -1,5 +1,5 @@
 use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict, PyList, PyModule};
+use pyo3::types::{PyAny, PyDict, PyList};
 use pyo3::Bound;
 use std::collections::HashMap;
 
@@ -205,7 +205,7 @@ fn global_action(rng: &Bound<'_, PyAny>, action: &str, chars: &mut Vec<char>) ->
 }
 
 #[pyfunction]
-fn fatfinger(
+pub(crate) fn fatfinger(
     text: &str,
     max_change_rate: f64,
     layout: &Bound<'_, PyDict>,
@@ -224,7 +224,7 @@ fn fatfinger(
     }
 
     let length = chars.len();
-    let mut max_changes = (length as f64 * max_change_rate).floor() as usize;
+    let mut max_changes = (length as f64 * max_change_rate).ceil() as usize;
     if max_changes < 1 {
         max_changes = 1;
     }
@@ -252,9 +252,3 @@ fn fatfinger(
 
     Ok(chars.into_iter().collect())
 }
-
-#[pymodule]
-fn _typogre_rust(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(fatfinger, m)?)?;
-    Ok(())
-}

{glitchlings-0.2.1 → glitchlings-0.2.2}/src/glitchlings/main.py

@@ -11,31 +11,12 @@ from . import SAMPLE_TEXT
 from .zoo import (
     Glitchling,
     Gaggle,
-    jargoyle,
-    mim1c,
-    typogre,
-    reduple,
-    rushmore,
-    redactyl,
-    scannequin,
+    BUILTIN_GLITCHLINGS,
+    DEFAULT_GLITCHLING_NAMES,
+    parse_glitchling_spec,
     summon,
 )
 
-
-BUILTIN_GLITCHLINGS: dict[str, Glitchling] = {
-    g.name.lower(): g
-    for g in [
-        typogre,
-        mim1c,
-        jargoyle,
-        reduple,
-        rushmore,
-        redactyl,
-        scannequin,
-    ]
-}
-
-DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
 MAX_NAME_WIDTH = max(len(glitchling.name) for glitchling in BUILTIN_GLITCHLINGS.values())
 
 
@@ -62,8 +43,11 @@ def build_parser() -> argparse.ArgumentParser:
         "--glitchling",
         dest="glitchlings",
         action="append",
-        metavar="NAME",
-        help="Glitchling to apply (repeat for multiples). Defaults to all built-ins.",
+        metavar="SPEC",
+        help=(
+            "Glitchling to apply, optionally with parameters like "
+            "Typogre(max_change_rate=0.05). Repeat for multiples; defaults to all built-ins."
+        ),
     )
     parser.add_argument(
         "-s",
@@ -147,23 +131,16 @@ def read_text(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
 def summon_glitchlings(
     names: list[str] | None, parser: argparse.ArgumentParser, seed: int
 ) -> Gaggle:
-    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``.
-
-    Args:
-        names: Optional list of glitchling names provided by the user.
-        parser: The argument parser used for emitting user-facing errors.
-        seed: Master seed controlling deterministic corruption order.
-
-    Returns:
-        Gaggle: A ready-to-use collection of glitchlings.
-
-    Raises:
-        SystemExit: Raised indirectly via ``parser.error`` when a provided glitchling
-        name is invalid.
-    """
+    """Instantiate the requested glitchlings and bundle them in a ``Gaggle``."""
 
     if names:
-        normalized = [name.lower() for name in names]
+        normalized: list[str | Glitchling] = []
+        for specification in names:
+            try:
+                normalized.append(parse_glitchling_spec(specification))
+            except ValueError as exc:
+                parser.error(str(exc))
+                raise AssertionError("parser.error should exit")
     else:
         normalized = DEFAULT_GLITCHLING_NAMES
 
@@ -174,6 +151,7 @@ def summon_glitchlings(
         raise AssertionError("parser.error should exit")
 
 
+
 def show_diff(original: str, corrupted: str) -> None:
     """Display a unified diff between the original and corrupted text."""
 

{glitchlings-0.2.1 → glitchlings-0.2.2}/src/glitchlings/util/__init__.py

@@ -141,6 +141,36 @@ _register_layout(
     ),
 )
 
+_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:
     def __init__(self) -> None: