glitchlings 0.1.3__tar.gz → 0.2.0__tar.gz

glitchlings-0.2.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include rust *

{glitchlings-0.1.3 → glitchlings-0.2.0}/PKG-INFO

@@ -1,11 +1,7 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.1.3
+Version: 0.2.0
 Summary: Monsters for your language games.
-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
 Author: osoleve
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -208,27 +204,34 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-License-File: LICENSE
-Keywords: adversarial augmentation,nlp,text,text augmentation
+        
+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
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: confusable-homoglyphs>=3.3.1
 Requires-Dist: datasets>=4.0.0
 Requires-Dist: jellyfish>=1.2.0
 Requires-Dist: nltk>=3.9.1
-Provides-Extra: dev
-Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Provides-Extra: prime
-Requires-Dist: verifiers>=0.1.3.post0; extra == 'prime'
-Description-Content-Type: text/markdown
+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"
+Dynamic: license-file
 
 #
 
@@ -283,6 +286,41 @@ print(gaggle(SAMPLE_TEXT))
 
 > Onҽ m‎ھ‎rning, wһen Gregor Samƽa woke from trouble𝐝 𝑑reams, he found himself transformed in his bed into a horrible vermin‎٠‎ He l   lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightlh domed and divided by arches ino stiff sections. The bedding was adly able to cover it and and seemed ready to slide off any  moment. His many legxs, pitifully thin compared with the size of the the rest of him, waved about helplessly ashe looked looked.
 
+## 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.
+
+### Prime Intellect environments
+
+After `pip install -e .[prime]`, the `glitchlings.dlc.prime.load_environment` helper mirrors `verifiers.load_environment` for Prime Intellect scenarios while optionally applying glitchlings before returning the environment:
+
+```python
+from glitchlings import Mim1c, Typogre
+from glitchlings.dlc.prime import echo_chamber, load_environment
+
+env = load_environment(
+    "osoleve/syllabify-en",
+    glitchlings=[Mim1c(replacement_rate=0.01), Typogre(max_change_rate=0.02)],
+    seed=404,
+)
+
+# Spin up an echo chamber that corrupts a dataset column and
+# rewards models for perfectly restoring it
+practice_env = echo_chamber(
+    "osoleve/clean-room",
+    column="text",
+    glitchlings=["Typogre", "Mim1c"],
+    reward_function=lambda prompt, completion, answer: float(completion == answer),
+)
+```
+
+Skip the `glitchlings` argument to receive an untouched verifier dataset, and
+override `reward_function` when you want to evaluate completions with a custom
+scoring routine.
+
 ## Motivation
 
 If your model performs well on a particular task, but not when `Glitchling`s are present, it's a sign that it hasn't actually generalized to the problem.

{glitchlings-0.1.3 → glitchlings-0.2.0}/README.md

@@ -51,6 +51,41 @@ print(gaggle(SAMPLE_TEXT))
 
 > Onҽ m‎ھ‎rning, wһen Gregor Samƽa woke from trouble𝐝 𝑑reams, he found himself transformed in his bed into a horrible vermin‎٠‎ He l   lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightlh domed and divided by arches ino stiff sections. The bedding was adly able to cover it and and seemed ready to slide off any  moment. His many legxs, pitifully thin compared with the size of the the rest of him, waved about helplessly ashe looked looked.
 
+## 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.
+
+### Prime Intellect environments
+
+After `pip install -e .[prime]`, the `glitchlings.dlc.prime.load_environment` helper mirrors `verifiers.load_environment` for Prime Intellect scenarios while optionally applying glitchlings before returning the environment:
+
+```python
+from glitchlings import Mim1c, Typogre
+from glitchlings.dlc.prime import echo_chamber, load_environment
+
+env = load_environment(
+    "osoleve/syllabify-en",
+    glitchlings=[Mim1c(replacement_rate=0.01), Typogre(max_change_rate=0.02)],
+    seed=404,
+)
+
+# Spin up an echo chamber that corrupts a dataset column and
+# rewards models for perfectly restoring it
+practice_env = echo_chamber(
+    "osoleve/clean-room",
+    column="text",
+    glitchlings=["Typogre", "Mim1c"],
+    reward_function=lambda prompt, completion, answer: float(completion == answer),
+)
+```
+
+Skip the `glitchlings` argument to receive an untouched verifier dataset, and
+override `reward_function` when you want to evaluate completions with a custom
+scoring routine.
+
 ## Motivation
 
 If your model performs well on a particular task, but not when `Glitchling`s are present, it's a sign that it hasn't actually generalized to the problem.

{glitchlings-0.1.3 → glitchlings-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "glitchlings"
-version = "0.1.3"
+version = "0.2.0"
 description = "Monsters for your language games."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -48,35 +48,30 @@ prime = [
 ]
 dev = [
     "pytest>=8.0.0",
+    "hypothesis>=6.140.0",
 ]
 
 [build-system]
-requires = ["hatchling>=1.18"]
-build-backend = "hatchling.build"
+requires = ["setuptools>=64", "wheel", "setuptools-rust>=1.8"]
+build-backend = "setuptools.build_meta"
 
-[tool.hatch.build]
-exclude = [
-    "**/__pycache__/**",
-    ".git/**",
-    ".venv/**",
-]
+[tool.setuptools]
+package-dir = {"" = "src"}
 
-[tool.hatch.build.targets.sdist]
-exclude = [
-    "**/__pycache__/**",
-    ".git/**",
-    ".venv/**",
-]
+[tool.setuptools.packages.find]
+where = ["src"]
 
-[tool.hatch.build.targets.wheel]
-packages = [
-    "src/glitchlings"
-]
-exclude = [
-    "tests/**",
-    "tests",
-    "**/__pycache__/**",
-]
+[[tool.setuptools-rust.ext-modules]]
+target = "glitchlings._zoo_rust"
+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.1.3/rust/zoo → glitchlings-0.2.0/rust}/Cargo.lock

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

glitchlings-0.2.0/rust/Cargo.toml

@@ -0,0 +1,10 @@
+[workspace]
+members = [
+    "typogre",
+    "zoo",
+]
+resolver = "2"
+
+[workspace.dependencies]
+pyo3 = { version = "0.21", features = ["extension-module"] }
+regex = "1"

{glitchlings-0.1.3 → glitchlings-0.2.0}/rust/typogre/Cargo.toml

@@ -8,7 +8,7 @@ name = "_typogre_rust"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.21", features = ["extension-module"] }
+pyo3 = { workspace = true }
 
 [package.metadata.maturin]
 module-name = "glitchlings._typogre_rust"

{glitchlings-0.1.3 → glitchlings-0.2.0}/rust/zoo/Cargo.toml

@@ -8,8 +8,8 @@ name = "_zoo_rust"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.21", features = ["extension-module"] }
-regex = "1"
+pyo3 = { workspace = true }
+regex = { workspace = true }
 
 [package.metadata.maturin]
 module-name = "glitchlings._zoo_rust"

{glitchlings-0.1.3 → glitchlings-0.2.0}/rust/zoo/src/lib.rs

@@ -116,20 +116,35 @@ fn delete_random_words(
     }
 
     let mut tokens = split_with_separators(text);
+    let mut candidate_indices: Vec<usize> = Vec::new();
     let mut i = 2;
     while i < tokens.len() {
-        let word = tokens[i].clone();
-        if word.is_empty() || is_whitespace_only(&word) {
-            i += 2;
-            continue;
+        let word = &tokens[i];
+        if !word.is_empty() && !is_whitespace_only(word) {
+            candidate_indices.push(i);
+        }
+        i += 2;
+    }
+
+    let allowed = ((candidate_indices.len() as f64) * max_deletion_rate).floor() as usize;
+    if allowed == 0 {
+        return Ok(text.to_string());
+    }
+
+    let mut deletions = 0;
+    for idx in candidate_indices {
+        if deletions >= allowed {
+            break;
         }
+
+        let word = tokens[idx].clone();
         if random_unit(rng)? < max_deletion_rate {
             let (prefix, _, suffix) = split_affixes(&word);
             let trimmed_prefix = prefix.trim();
             let trimmed_suffix = suffix.trim();
-            tokens[i] = format!("{trimmed_prefix}{trimmed_suffix}");
+            tokens[idx] = format!("{trimmed_prefix}{trimmed_suffix}");
+            deletions += 1;
         }
-        i += 2;
     }
 
     let mut joined = tokens.concat();
@@ -283,7 +298,7 @@ fn redact_words(
 
     if word_indices.is_empty() {
         return Err(pyo3::exceptions::PyValueError::new_err(
-            "No words found to redact",
+            "Cannot redact words because the input text contains no redactable words.",
         ));
     }
 

glitchlings-0.2.0/setup.cfg

@@ -0,0 +1,7 @@
+[bdist_wheel]
+plat_name = manylinux_2_17_x86_64
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

glitchlings-0.2.0/src/glitchlings/dlc/__init__.py

@@ -0,0 +1,5 @@
+"""Optional DLC integrations for Glitchlings."""
+
+from .huggingface import install as install_huggingface
+
+__all__ = ["install_huggingface"]

glitchlings-0.2.0/src/glitchlings/dlc/huggingface.py

@@ -0,0 +1,96 @@
+"""Integration helpers for the Hugging Face datasets library."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+try:  # pragma: no cover - optional dependency is required at runtime
+    from datasets import Dataset as _DatasetsDataset
+except ModuleNotFoundError as _datasets_error:  # pragma: no cover - optional dependency
+    _DatasetsDataset = None  # type: ignore[assignment]
+else:
+    _datasets_error = None
+
+from ..zoo import Gaggle, Glitchling, summon
+
+
+def _normalise_columns(column: str | Sequence[str]) -> list[str]:
+    """Normalise a column specification to a list."""
+
+    if isinstance(column, str):
+        return [column]
+
+    normalised = list(column)
+    if not normalised:
+        raise ValueError("At least one column must be specified")
+    return normalised
+
+
+def _as_gaggle(glitchlings: Glitchling | Gaggle | str | Iterable[str | Glitchling], seed: int) -> Gaggle:
+    """Coerce any supported glitchling specification into a :class:`Gaggle`."""
+
+    if isinstance(glitchlings, Gaggle):
+        return glitchlings
+
+    if isinstance(glitchlings, (Glitchling, str)):
+        resolved: Iterable[str | Glitchling] = [glitchlings]
+    else:
+        resolved = glitchlings
+
+    return summon(list(resolved), seed=seed)
+
+
+def _glitch_dataset(
+    dataset: Any,
+    glitchlings: Glitchling | Gaggle | str | Iterable[str | Glitchling],
+    column: str | Sequence[str],
+    *,
+    seed: int = 151,
+) -> Any:
+    """Internal helper implementing :meth:`Dataset.glitch`."""
+
+    columns = _normalise_columns(column)
+    gaggle = _as_gaggle(glitchlings, seed=seed)
+    return gaggle.corrupt_dataset(dataset, columns)
+
+
+def _ensure_dataset_class() -> Any:
+    """Return the Hugging Face :class:`~datasets.Dataset` patched with ``.glitch``."""
+
+    if _DatasetsDataset is None:  # pragma: no cover - datasets is an install-time dependency
+        message = "datasets is not installed"
+        raise ModuleNotFoundError(message) from _datasets_error
+
+    if getattr(_DatasetsDataset, "glitch", None) is None:
+
+        def glitch(  # type: ignore[override]
+            self: Any,
+            glitchlings: Glitchling | Gaggle | str | Iterable[str | Glitchling],
+            *,
+            column: str | Sequence[str],
+            seed: int = 151,
+            **_: Any,
+        ) -> Any:
+            """Return a lazily corrupted copy of the dataset."""
+
+            return _glitch_dataset(self, glitchlings, column, seed=seed)
+
+        setattr(_DatasetsDataset, "glitch", glitch)
+
+    return _DatasetsDataset
+
+
+def install() -> None:
+    """Monkeypatch the Hugging Face :class:`~datasets.Dataset` with ``.glitch``."""
+
+    _ensure_dataset_class()
+
+
+if _DatasetsDataset is not None:
+    Dataset = _ensure_dataset_class()
+else:  # pragma: no cover - datasets is an install-time dependency
+    Dataset = None  # type: ignore[assignment]
+
+
+__all__ = ["Dataset", "install"]

glitchlings-0.2.0/src/glitchlings/dlc/prime.py

@@ -0,0 +1,252 @@
+"""Integration helpers for the optional verifiers prime DLC."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from enum import Enum
+from typing import Any, Callable
+
+import verifiers as vf
+
+from jellyfish import damerau_levenshtein_distance
+
+try:
+    from .huggingface import Dataset
+except ModuleNotFoundError:  # pragma: no cover - optional dependency
+    Dataset = object  # type: ignore[assignment]
+else:
+    if Dataset is None:  # pragma: no cover - optional dependency
+        Dataset = object  # type: ignore[assignment]
+
+from ..zoo import Gaggle, Glitchling, Mim1c, Typogre, summon
+
+
+def _resolve_environment(env: str | vf.Environment) -> vf.Environment:
+    """Return a fully-instantiated verifier environment."""
+
+    if isinstance(env, str):
+        env = vf.load_environment(env)
+
+    if not isinstance(env, vf.Environment):
+        raise TypeError("Invalid environment type")
+
+    return env
+
+
+def _resolve_columns(dataset: Dataset, columns: Sequence[str] | None) -> list[str]:
+    """Identify which dataset columns should be corrupted."""
+
+    available = set(dataset.column_names)
+
+    if columns is not None:
+        missing = sorted(set(columns) - available)
+        if missing:
+            missing_str = ", ".join(missing)
+            raise ValueError(f"Columns not found in dataset: {missing_str}")
+        return list(columns)
+
+    for candidate in ("prompt", "question"):
+        if candidate in available:
+            return [candidate]
+
+    sample = dataset[0] if len(dataset) else {}
+    inferred = [
+        name
+        for name in dataset.column_names
+        if isinstance(sample.get(name), str)
+    ]
+
+    if inferred:
+        return inferred
+
+    raise ValueError("Unable to determine which dataset columns to corrupt.")
+
+
+class Difficulty(Enum):
+    """Difficulty levels for tutorial environments."""
+
+    Easy = 0.25
+    Normal = 1.0
+    Hard = 1.75
+    Extreme = 3
+    Impossible = 9
+
+
+def tutorial_level(
+    env: vf.Environment | str,
+    seed: int = 151,
+    difficulty: Difficulty = Difficulty.Normal,
+) -> vf.Environment:
+    """Create a low-corruption environment using tuned defaults."""
+
+    tuned_mim1c = Mim1c(replacement_rate=0.01 * difficulty.value)
+    tuned_typogre = Typogre(max_change_rate=0.025 * difficulty.value)
+
+    return load_environment(
+        env,
+        glitchlings=[tuned_mim1c, tuned_typogre],
+        seed=seed,
+    )
+
+
+def load_environment(
+    env: str | vf.Environment,
+    glitchlings: Iterable[str | Glitchling] | Glitchling | str | Gaggle | None = None,
+    *,
+    seed: int = 151,
+    columns: Sequence[str] | None = None,
+) -> vf.Environment:
+    """Load an environment and optionally corrupt it with glitchlings."""
+
+    environment = _resolve_environment(env)
+
+    if glitchlings is None:
+        return environment
+
+    if isinstance(glitchlings, Gaggle):
+        gaggle = glitchlings
+    else:
+        if isinstance(glitchlings, (Glitchling, str)):
+            resolved = [glitchlings]
+        else:
+            resolved = list(glitchlings)
+
+        gaggle = summon(resolved, seed=seed)
+
+    dataset = environment.dataset
+    corrupt_columns = _resolve_columns(dataset, columns)
+    environment.dataset = gaggle.corrupt_dataset(dataset, corrupt_columns)
+    return environment
+
+
+def _as_gaggle(
+    glitchlings: Iterable[str | Glitchling] | Glitchling | str | Gaggle,
+    *,
+    seed: int,
+) -> Gaggle:
+    """Coerce any supported glitchling specification into a :class:`Gaggle`."""
+
+    if isinstance(glitchlings, Gaggle):
+        return glitchlings
+
+    if isinstance(glitchlings, (Glitchling, str)):
+        resolved: Iterable[str | Glitchling] = [glitchlings]
+    else:
+        resolved = glitchlings
+
+    return summon(list(resolved), seed=seed)
+
+
+def _extract_completion_text(completion: Any) -> str:
+    """Normalise a completion payload into a plain string."""
+
+    if isinstance(completion, str):
+        return completion
+
+    if isinstance(completion, list) and completion:
+        first = completion[0]
+        if isinstance(first, dict) and "content" in first:
+            return str(first["content"])
+        return str(first)
+
+    return str(completion)
+
+
+def symmetric_damerau_levenshtein_similarity(
+    _: Any,
+    completion: Any,
+    answer: str,
+) -> float:
+    """Return ``1 - (distance / max_len)`` using Damerau-Levenshtein distance."""
+
+    completion_text = _extract_completion_text(completion)
+    target = answer or ""
+    denominator = max(len(completion_text), len(target), 1)
+    distance = damerau_levenshtein_distance(completion_text, target)
+    score = 1.0 - (distance / denominator)
+    return max(0.0, min(1.0, score))
+
+
+DEFAULT_CLEANUP_INSTRUCTIONS = (
+    "You are a meticulous copy editor. Restore the provided text to its original form."
+)
+
+
+def echo_chamber(
+    dataset_id: str,
+    column: str,
+    glitchlings: Iterable[str | Glitchling] | Glitchling | str | Gaggle,
+    *,
+    seed: int = 151,
+    instructions: str = DEFAULT_CLEANUP_INSTRUCTIONS,
+    reward_function: Callable[..., float] | None = None,
+    split: str | None = None,
+    **load_dataset_kwargs: Any,
+) -> vf.Environment:
+    """Create an Echo Chamber Prime environment from a Hugging Face dataset column.
+
+    Args:
+        dataset_id: Identifier of the Hugging Face dataset to load.
+        column: Name of the column whose text should be glitched.
+        glitchlings: Glitchling specifiers that will corrupt the prompts.
+        seed: RNG seed forwarded to :func:`summon`.
+        instructions: System instructions supplied to the environment prompts.
+        reward_function: Optional callable used to score completions. Defaults to
+            :func:`symmetric_damerau_levenshtein_similarity` when omitted.
+        split: Optional dataset split to load.
+        **load_dataset_kwargs: Extra keyword arguments forwarded to
+            :func:`datasets.load_dataset`.
+    """
+
+    try:
+        from datasets import Dataset as HFDataset, DatasetDict, load_dataset
+    except ModuleNotFoundError as exc:  # pragma: no cover - optional dependency
+        message = "datasets is required to build an echo chamber"
+        raise ModuleNotFoundError(message) from exc
+
+    hf_dataset: HFDataset | DatasetDict
+    if split is None:
+        hf_dataset = load_dataset(dataset_id, **load_dataset_kwargs)
+        if isinstance(hf_dataset, DatasetDict):
+            try:
+                hf_dataset = next(iter(hf_dataset.values()))
+            except StopIteration as exc:  # pragma: no cover - defensive
+                raise ValueError("The specified dataset does not contain any splits") from exc
+    else:
+        hf_dataset = load_dataset(dataset_id, split=split, **load_dataset_kwargs)
+
+    if isinstance(hf_dataset, DatasetDict):
+        raise ValueError(
+            "Specify which split to use when the dataset loads as a DatasetDict."
+        )
+
+    prompts: list[list[dict[str, str]]] = []
+    answers: list[str] = []
+
+    for row in hf_dataset:
+        value = row.get(column)
+        if value is None:
+            continue
+
+        text = str(value)
+        prompts.append(
+            [
+                {"role": "system", "content": instructions},
+                {"role": "user", "content": f"Corrupted text:\n{text}"},
+            ]
+        )
+        answers.append(text)
+
+    if not prompts:
+        raise ValueError(
+            f"Column '{column}' did not yield any textual entries in dataset '{dataset_id}'."
+        )
+
+    dataset = HFDataset.from_dict({"prompt": prompts, "answer": answers})
+
+    gaggle = _as_gaggle(glitchlings, seed=seed)
+    glitched_dataset = gaggle.corrupt_dataset(dataset, ["prompt"])
+
+    rubric_func = reward_function or symmetric_damerau_levenshtein_similarity
+    rubric = vf.Rubric(funcs=[rubric_func], weights=[1.0])
+    return vf.SingleTurnEnv(dataset=glitched_dataset, rubric=rubric)

{glitchlings-0.1.3 → glitchlings-0.2.0}/src/glitchlings/main.py

@@ -124,8 +124,10 @@ def read_text(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
     if args.file is not None:
         try:
             return args.file.read_text(encoding="utf-8")
-        except OSError as exc:  # pragma: no cover - exercised via CLI
-            parser.error(str(exc))
+        except OSError as exc:
+            filename = getattr(exc, "filename", None) or args.file
+            reason = exc.strerror or str(exc)
+            parser.error(f"Failed to read file {filename}: {reason}")
 
     if args.text:
         return args.text