glitchlings 0.4.3__cp311-cp311-macosx_11_0_universal2.whl → 0.4.4__cp311-cp311-macosx_11_0_universal2.whl

glitchlings/dlc/_shared.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from collections.abc import Callable, Sequence
 from typing import Any
 
+from ..zoo.core import Gaggle, _is_transcript
+
 
 def resolve_environment(
     env: Any,
@@ -65,4 +67,87 @@ def resolve_columns(dataset: Any, columns: Sequence[str] | None) -> list[str]:
     raise ValueError("Unable to determine which dataset columns to corrupt.")
 
 
-__all__ = ["resolve_columns", "resolve_environment"]
+def normalise_column_spec(
+    columns: str | int | Sequence[str | int] | None,
+) -> list[str | int] | None:
+    """Normalise a column specification into a list of keys or indices.
+
+    Args:
+        columns: Column specification as a single value, sequence of values, or None.
+
+    Returns:
+        A list of column identifiers, or None if input was None.
+
+    Raises:
+        ValueError: If an empty sequence is provided.
+    """
+    if columns is None:
+        return None
+
+    if isinstance(columns, (str, int)):
+        return [columns]
+
+    normalised = list(columns)
+    if not normalised:
+        raise ValueError("At least one column must be specified")
+    return normalised
+
+
+def is_textual_candidate(value: Any) -> bool:
+    """Return ``True`` when ``value`` looks like text that glitchlings can corrupt.
+
+    Args:
+        value: The value to check for textual content.
+
+    Returns:
+        True if the value appears to be textual content.
+    """
+    if isinstance(value, str):
+        return True
+
+    if _is_transcript(value, allow_empty=False, require_all_content=True):
+        return True
+
+    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray, str)):
+        if not value:
+            return False
+        if all(isinstance(item, str) for item in value):
+            return True
+        if _is_transcript(list(value), allow_empty=False, require_all_content=True):
+            return True
+
+    return False
+
+
+def corrupt_text_value(value: Any, gaggle: Gaggle) -> Any:
+    """Return ``value`` with glitchlings applied when possible.
+
+    Args:
+        value: The value to corrupt (string, transcript, or sequence of strings).
+        gaggle: The gaggle of glitchlings to apply.
+
+    Returns:
+        The corrupted value, preserving the original type where possible.
+    """
+    if isinstance(value, str):
+        return gaggle.corrupt(value)
+
+    if _is_transcript(value, allow_empty=True):
+        return gaggle.corrupt(value)
+
+    if isinstance(value, list) and value and all(isinstance(item, str) for item in value):
+        return [gaggle.corrupt(item) for item in value]
+
+    if isinstance(value, tuple) and value and all(isinstance(item, str) for item in value):
+        return tuple(gaggle.corrupt(item) for item in value)
+
+    return value
+
+
+__all__ = [
+    "corrupt_text_value",
+    "is_textual_candidate",
+    "normalise_column_spec",
+    "resolve_columns",
+    "resolve_environment",
+]

glitchlings/dlc/pytorch.py

@@ -9,63 +9,13 @@ from ..compat import get_torch_dataloader, require_torch
 from ..compat import torch as _torch_dependency
 from ..util.adapters import coerce_gaggle
 from ..zoo import Gaggle, Glitchling
-from ..zoo.core import _is_transcript
-
-
-def _normalise_columns(columns: str | int | Sequence[str | int] | None) -> list[str | int] | None:
-    """Normalise a column specification into a list of keys or indices."""
-    if columns is None:
-        return None
-
-    if isinstance(columns, (str, int)):
-        return [columns]
-
-    normalised = list(columns)
-    if not normalised:
-        raise ValueError("At least one column must be specified")
-    return normalised
-
-
-def _is_textual_candidate(value: Any) -> bool:
-    """Return ``True`` when ``value`` looks like text that glitchlings can corrupt."""
-    if isinstance(value, str):
-        return True
-
-    if _is_transcript(value, allow_empty=False, require_all_content=True):
-        return True
-
-    if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray, str)):
-        if not value:
-            return False
-        if all(isinstance(item, str) for item in value):
-            return True
-        if _is_transcript(list(value), allow_empty=False, require_all_content=True):
-            return True
-
-    return False
-
-
-def _corrupt_text(value: Any, gaggle: Gaggle) -> Any:
-    """Return ``value`` with glitchlings applied when possible."""
-    if isinstance(value, str):
-        return gaggle.corrupt(value)
-
-    if _is_transcript(value, allow_empty=True):
-        return gaggle.corrupt(value)
-
-    if isinstance(value, list) and value and all(isinstance(item, str) for item in value):
-        return [gaggle.corrupt(item) for item in value]
-
-    if isinstance(value, tuple) and value and all(isinstance(item, str) for item in value):
-        return tuple(gaggle.corrupt(item) for item in value)
-
-    return value
+from ._shared import corrupt_text_value, is_textual_candidate, normalise_column_spec
 
 
 def _apply_to_batch(batch: Any, targets: list[str | int] | None, gaggle: Gaggle) -> Any:
     """Return ``batch`` with glitchlings applied to the specified ``targets``."""
     if targets is None:
-        return _corrupt_text(batch, gaggle)
+        return corrupt_text_value(batch, gaggle)
 
     if isinstance(batch, Mapping):
         mutated = cast(MutableMapping[str, Any], dict(batch))
@@ -74,7 +24,7 @@ def _apply_to_batch(batch: Any, targets: list[str | int] | None, gaggle: Gaggle)
                 raise TypeError("Mapping batches require string column names")
             if key not in mutated:
                 raise ValueError(f"Column '{key}' not found in DataLoader batch")
-            mutated[key] = _corrupt_text(mutated[key], gaggle)
+            mutated[key] = corrupt_text_value(mutated[key], gaggle)
         return mutated
 
     if isinstance(batch, Sequence) and not isinstance(batch, (bytes, bytearray, str)):
@@ -83,7 +33,7 @@ def _apply_to_batch(batch: Any, targets: list[str | int] | None, gaggle: Gaggle)
             if not isinstance(index, int):
                 raise TypeError("Sequence batches require integer column indices")
             try:
-                mutated_sequence[index] = _corrupt_text(mutated_sequence[index], gaggle)
+                mutated_sequence[index] = corrupt_text_value(mutated_sequence[index], gaggle)
             except IndexError as exc:  # pragma: no cover - defensive
                 raise IndexError("Column index out of range for DataLoader batch") from exc
         if isinstance(batch, tuple):
@@ -96,20 +46,20 @@ def _apply_to_batch(batch: Any, targets: list[str | int] | None, gaggle: Gaggle)
 def _infer_targets(batch: Any) -> list[str | int] | None:
     """Infer which fields should be glitched from a representative ``batch``."""
     if isinstance(batch, Mapping):
-        inferred = [key for key, value in batch.items() if _is_textual_candidate(value)]
+        inferred = [key for key, value in batch.items() if is_textual_candidate(value)]
         if inferred:
             return inferred
         raise ValueError("Unable to infer which mapping columns contain text")
 
     if isinstance(batch, Sequence) and not isinstance(batch, (bytes, bytearray, str)):
         inferred_indices: list[str | int] = [
-            idx for idx, value in enumerate(batch) if _is_textual_candidate(value)
+            idx for idx, value in enumerate(batch) if is_textual_candidate(value)
         ]
         if inferred_indices:
             return inferred_indices
         raise ValueError("Unable to infer which sequence indices contain text")
 
-    if _is_textual_candidate(batch):
+    if is_textual_candidate(batch):
         return None
 
     raise TypeError("Unsupported DataLoader batch type for glitching")
@@ -184,7 +134,7 @@ def _ensure_dataloader_class() -> type[Any]:
         ) -> _GlitchedDataLoader:
             """Return a lazily glitched view of the loader's batches."""
             gaggle = coerce_gaggle(glitchlings, seed=seed)
-            normalised = _normalise_columns(columns)
+            normalised = normalise_column_spec(columns)
             return _GlitchedDataLoader(self, gaggle, columns=normalised)
 
         setattr(dataloader_cls, "glitch", glitch)

glitchlings/dlc/pytorch_lightning.py

@@ -8,29 +8,7 @@ from typing import Any, cast
 from ..compat import get_pytorch_lightning_datamodule, require_pytorch_lightning
 from ..util.adapters import coerce_gaggle
 from ..zoo import Gaggle, Glitchling
-from ..zoo.core import _is_transcript
-
-
-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 _glitch_value(value: Any, gaggle: Gaggle) -> Any:
-    """Apply glitchlings to a value when it contains textual content."""
-    if isinstance(value, str) or _is_transcript(value, allow_empty=False, require_all_content=True):
-        return gaggle.corrupt(value)
-
-    if isinstance(value, Sequence) and value and all(isinstance(item, str) for item in value):
-        return [gaggle.corrupt(item) for item in value]
-
-    return value
+from ._shared import corrupt_text_value, normalise_column_spec
 
 
 def _glitch_batch(batch: Any, columns: list[str], gaggle: Gaggle) -> Any:
@@ -49,7 +27,7 @@ def _glitch_batch(batch: Any, columns: list[str], gaggle: Gaggle) -> Any:
         raise ValueError(f"Columns not found in batch: {missing_str}")
 
     for column in columns:
-        mutated[column] = _glitch_value(mutated[column], gaggle)
+        mutated[column] = corrupt_text_value(mutated[column], gaggle)
 
     return mutated
 
@@ -111,9 +89,13 @@ def _glitch_datamodule(
 ) -> Any:
     """Return a proxy that applies glitchlings to batches from the datamodule."""
 
-    columns = _normalise_columns(column)
+    columns = normalise_column_spec(column)
+    if columns is None:  # pragma: no cover - defensive
+        raise ValueError("At least one column must be specified")
+    # Lightning datamodules only support string column names (mapping keys)
+    columns_str = cast(list[str], columns)
     gaggle = coerce_gaggle(glitchlings, seed=seed)
-    return _GlitchedLightningDataModule(datamodule, columns, gaggle)
+    return _GlitchedLightningDataModule(datamodule, columns_str, gaggle)
 
 
 class _GlitchedLightningDataModule:

glitchlings/lexicon/__init__.py

@@ -102,7 +102,11 @@ from .vector import VectorLexicon, build_vector_cache  # noqa: E402
 _WordNetLexicon: type[LexiconBackend] | None
 try:  # pragma: no cover - optional dependency
     from .wordnet import WordNetLexicon as _WordNetLexicon
-except Exception:  # pragma: no cover - triggered when nltk unavailable
+except (
+    ImportError,
+    ModuleNotFoundError,
+    AttributeError,
+):  # pragma: no cover - triggered when nltk unavailable
     _WordNetLexicon = None
 
 WordNetLexicon: type[LexiconBackend] | None = _WordNetLexicon

glitchlings/zoo/_rate.py

@@ -1,5 +1,9 @@
+"""Utilities for handling legacy parameter names across glitchling classes."""
+
 from __future__ import annotations
 
+import warnings
+
 
 def resolve_rate(
     *,
@@ -8,11 +12,120 @@ def resolve_rate(
     default: float,
     legacy_name: str,
 ) -> float:
-    """Return the effective rate while enforcing mutual exclusivity."""
+    """Return the effective rate while enforcing mutual exclusivity.
+
+    This function centralizes the handling of legacy parameter names, allowing
+    glitchlings to maintain backwards compatibility while encouraging migration
+    to the standardized 'rate' parameter.
+
+    Parameters
+    ----------
+    rate : float | None
+        The preferred parameter value.
+    legacy_value : float | None
+        The deprecated legacy parameter value.
+    default : float
+        Default value if neither parameter is specified.
+    legacy_name : str
+        Name of the legacy parameter for error/warning messages.
+
+    Returns
+    -------
+    float
+        The resolved rate value.
+
+    Raises
+    ------
+    ValueError
+        If both rate and legacy_value are specified simultaneously.
+
+    Warnings
+    --------
+    DeprecationWarning
+        If the legacy parameter is used, a deprecation warning is issued.
+
+    Examples
+    --------
+    >>> resolve_rate(rate=0.5, legacy_value=None, default=0.1, legacy_name="old_rate")
+    0.5
+    >>> resolve_rate(rate=None, legacy_value=0.3, default=0.1, legacy_name="old_rate")
+    0.3  # Issues deprecation warning
+    >>> resolve_rate(rate=None, legacy_value=None, default=0.1, legacy_name="old_rate")
+    0.1
+
+    """
     if rate is not None and legacy_value is not None:
         raise ValueError(f"Specify either 'rate' or '{legacy_name}', not both.")
+
     if rate is not None:
         return rate
+
+    if legacy_value is not None:
+        warnings.warn(
+            f"The '{legacy_name}' parameter is deprecated and will be removed in version 0.6.0. "
+            f"Use 'rate' instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        return legacy_value
+
+    return default
+
+
+def resolve_legacy_param(
+    *,
+    preferred_value: object,
+    legacy_value: object,
+    default: object,
+    preferred_name: str,
+    legacy_name: str,
+) -> object:
+    """Resolve a parameter that has both preferred and legacy names.
+
+    This is a generalized version of resolve_rate() that works with any type.
+
+    Parameters
+    ----------
+    preferred_value : object
+        The value from the preferred parameter name.
+    legacy_value : object
+        The value from the legacy parameter name.
+    default : object
+        Default value if neither parameter is specified.
+    preferred_name : str
+        Name of the preferred parameter.
+    legacy_name : str
+        Name of the legacy parameter for warning messages.
+
+    Returns
+    -------
+    object
+        The resolved parameter value.
+
+    Raises
+    ------
+    ValueError
+        If both preferred and legacy values are specified simultaneously.
+
+    Warnings
+    --------
+    DeprecationWarning
+        If the legacy parameter is used.
+
+    """
+    if preferred_value is not None and legacy_value is not None:
+        raise ValueError(f"Specify either '{preferred_name}' or '{legacy_name}', not both.")
+
+    if preferred_value is not None:
+        return preferred_value
+
     if legacy_value is not None:
+        warnings.warn(
+            f"The '{legacy_name}' parameter is deprecated and will be removed in version 0.6.0. "
+            f"Use '{preferred_name}' instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
         return legacy_value
+
     return default

glitchlings/zoo/_rust_extensions.py

@@ -0,0 +1,143 @@
+"""Centralized loading and fallback management for optional Rust extensions.
+
+This module provides a single source of truth for importing Rust-accelerated
+operations, eliminating duplicated try/except blocks across the codebase.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable
+
+log = logging.getLogger(__name__)
+
+
+# Cache of loaded Rust operations to avoid repeated import attempts
+_rust_operation_cache: dict[str, Callable[..., Any] | None] = {}
+_rust_module_available: bool | None = None
+
+
+def is_rust_module_available() -> bool:
+    """Check if the Rust extension module can be imported.
+
+    Returns
+    -------
+    bool
+        True if glitchlings._zoo_rust can be imported successfully.
+
+    Notes
+    -----
+    The result is cached after the first check to avoid repeated import attempts.
+    """
+    global _rust_module_available
+
+    if _rust_module_available is not None:
+        return _rust_module_available
+
+    try:
+        import glitchlings._zoo_rust  # noqa: F401
+
+        _rust_module_available = True
+        log.debug("Rust extension module successfully loaded")
+    except (ImportError, ModuleNotFoundError):
+        _rust_module_available = False
+        log.debug("Rust extension module not available; using Python fallbacks")
+
+    return _rust_module_available
+
+
+def get_rust_operation(operation_name: str) -> Callable[..., Any] | None:
+    """Load a specific Rust operation by name with caching.
+
+    Parameters
+    ----------
+    operation_name : str
+        The name of the operation to import from glitchlings._zoo_rust.
+
+    Returns
+    -------
+    Callable | None
+        The Rust operation callable if available, None otherwise.
+
+    Examples
+    --------
+    >>> fatfinger = get_rust_operation("fatfinger")
+    >>> if fatfinger is not None:
+    ...     result = fatfinger(text, ...)
+    ... else:
+    ...     result = python_fallback(text, ...)
+
+    Notes
+    -----
+    - Results are cached to avoid repeated imports
+    - Returns None if the Rust module is unavailable or the operation doesn't exist
+    - All import errors are logged at debug level
+    """
+    # Check cache first
+    if operation_name in _rust_operation_cache:
+        return _rust_operation_cache[operation_name]
+
+    # If the module isn't available, don't try to import individual operations
+    if not is_rust_module_available():
+        _rust_operation_cache[operation_name] = None
+        return None
+
+    try:
+        from glitchlings import _zoo_rust
+
+        operation = getattr(_zoo_rust, operation_name, None)
+        _rust_operation_cache[operation_name] = operation
+
+        if operation is None:
+            log.debug(f"Rust operation '{operation_name}' not found in extension module")
+        else:
+            log.debug(f"Rust operation '{operation_name}' loaded successfully")
+
+        return operation
+
+    except (ImportError, ModuleNotFoundError, AttributeError) as exc:
+        log.debug(f"Failed to load Rust operation '{operation_name}': {exc}")
+        _rust_operation_cache[operation_name] = None
+        return None
+
+
+def clear_cache() -> None:
+    """Clear the operation cache, forcing re-import on next access.
+
+    This is primarily useful for testing scenarios where the Rust module
+    availability might change during runtime.
+    """
+    global _rust_module_available, _rust_operation_cache
+
+    _rust_module_available = None
+    _rust_operation_cache.clear()
+    log.debug("Rust extension cache cleared")
+
+
+def preload_operations(*operation_names: str) -> dict[str, Callable[..., Any] | None]:
+    """Eagerly load multiple Rust operations at once.
+
+    Parameters
+    ----------
+    *operation_names : str
+        Names of operations to preload.
+
+    Returns
+    -------
+    dict[str, Callable | None]
+        Mapping of operation names to their callables (or None if unavailable).
+
+    Examples
+    --------
+    >>> ops = preload_operations("fatfinger", "reduplicate_words", "delete_random_words")
+    >>> fatfinger = ops["fatfinger"]
+    """
+    return {name: get_rust_operation(name) for name in operation_names}
+
+
+__all__ = [
+    "is_rust_module_available",
+    "get_rust_operation",
+    "clear_cache",
+    "preload_operations",
+]

glitchlings/zoo/adjax.py

@@ -4,13 +4,12 @@ import random
 from typing import Any, cast
 
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 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
+# Load Rust-accelerated operation if available
+_swap_adjacent_words_rust = get_rust_operation("swap_adjacent_words")
 
 
 def _python_swap_adjacent_words(

glitchlings/zoo/apostrofae.py

@@ -8,12 +8,11 @@ from functools import cache
 from importlib import resources
 from typing import Any, Sequence, cast
 
+from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Gaggle, Glitchling
 
-try:  # pragma: no cover - compiled extension not present in pure-Python envs
-    from glitchlings._zoo_rust import apostrofae as _apostrofae_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _apostrofae_rust = None
+# Load Rust-accelerated operation if available
+_apostrofae_rust = get_rust_operation("apostrofae")
 
 
 @cache

glitchlings/zoo/core.py

@@ -10,15 +10,13 @@ from hashlib import blake2s
 from typing import TYPE_CHECKING, Any, Callable, Protocol, TypedDict, TypeGuard, Union, cast
 
 from ..compat import get_datasets_dataset, require_datasets
+from ._rust_extensions import get_rust_operation
 
 _DatasetsDataset = get_datasets_dataset()
 
-try:  # pragma: no cover - optional dependency
-    from glitchlings._zoo_rust import compose_glitchlings as _compose_glitchlings_rust
-    from glitchlings._zoo_rust import plan_glitchlings as _plan_glitchlings_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _compose_glitchlings_rust = None
-    _plan_glitchlings_rust = None
+# Load Rust-accelerated orchestration operations if available
+_compose_glitchlings_rust = get_rust_operation("compose_glitchlings")
+_plan_glitchlings_rust = get_rust_operation("plan_glitchlings")
 
 
 log = logging.getLogger(__name__)
@@ -135,7 +133,12 @@ def _plan_glitchlings_with_rust(
 
     try:
         plan = _plan_glitchlings_rust(specs, int(master_seed))
-    except Exception:  # pragma: no cover - defer to Python fallback on failure
+    except (
+        TypeError,
+        ValueError,
+        RuntimeError,
+        AttributeError,
+    ):  # pragma: no cover - defer to Python fallback on failure
         log.debug("Rust orchestration planning failed; falling back to Python plan", exc_info=True)
         return None
 
@@ -537,10 +540,19 @@ class Gaggle(Glitchling):
         """Apply each glitchling to string input sequentially."""
         master_seed = self.seed
         descriptors = self._pipeline_descriptors()
-        if master_seed is not None and descriptors is not None:
+        if (
+            master_seed is not None
+            and descriptors is not None
+            and _compose_glitchlings_rust is not None
+        ):
             try:
                 return cast(str, _compose_glitchlings_rust(text, descriptors, master_seed))
-            except Exception:  # pragma: no cover - fall back to Python execution
+            except (
+                TypeError,
+                ValueError,
+                RuntimeError,
+                AttributeError,
+            ):  # pragma: no cover - fall back to Python execution
                 log.debug("Rust pipeline failed; falling back", exc_info=True)
 
         corrupted = text

glitchlings/zoo/jargoyle.py

@@ -14,7 +14,11 @@ _wordnet_module: ModuleType | None
 
 try:  # pragma: no cover - optional WordNet dependency
     import glitchlings.lexicon.wordnet as _wordnet_module
-except Exception:  # pragma: no cover - triggered when nltk unavailable
+except (
+    ImportError,
+    ModuleNotFoundError,
+    AttributeError,
+):  # pragma: no cover - triggered when nltk unavailable
     _wordnet_module = None
 
 _wordnet_runtime: ModuleType | None = _wordnet_module
@@ -49,7 +53,7 @@ def dependencies_available() -> bool:
     try:
         # Fall back to the configured default lexicon (typically the bundled vector cache).
         get_default_lexicon(seed=None)
-    except Exception:
+    except (RuntimeError, ImportError, ModuleNotFoundError, AttributeError):
         return False
     return True
 

glitchlings/zoo/redactyl.py

@@ -3,6 +3,7 @@ import re
 from typing import Any, cast
 
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from ._sampling import weighted_sample_without_replacement
 from ._text_utils import (
     WordToken,
@@ -13,11 +14,8 @@ from .core import AttackWave, Glitchling
 
 FULL_BLOCK = "█"
 
-
-try:
-    from glitchlings._zoo_rust import redact_words as _redact_words_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _redact_words_rust = None
+# Load Rust-accelerated operation if available
+_redact_words_rust = get_rust_operation("redact_words")
 
 
 def _python_redact_words(
@@ -119,6 +117,7 @@ def redact_words(
     use_rust = _redact_words_rust is not None and isinstance(merge_adjacent, bool)
 
     if use_rust:
+        assert _redact_words_rust is not None  # Type narrowing for mypy
         return cast(
             str,
             _redact_words_rust(

glitchlings/zoo/reduple.py

@@ -2,13 +2,12 @@ import random
 from typing import Any, cast
 
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
 from .core import AttackWave, Glitchling
 
-try:
-    from glitchlings._zoo_rust import reduplicate_words as _reduplicate_words_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _reduplicate_words_rust = None
+# Load Rust-accelerated operation if available
+_reduplicate_words_rust = get_rust_operation("reduplicate_words")
 
 
 def _python_reduplicate_words(

glitchlings/zoo/rushmore.py

@@ -4,13 +4,12 @@ import re
 from typing import Any, cast
 
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from ._text_utils import WordToken, collect_word_tokens, split_preserving_whitespace
 from .core import AttackWave, Glitchling
 
-try:
-    from glitchlings._zoo_rust import delete_random_words as _delete_random_words_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _delete_random_words_rust = None
+# Load Rust-accelerated operation if available
+_delete_random_words_rust = get_rust_operation("delete_random_words")
 
 
 def _python_delete_random_words(

glitchlings/zoo/scannequin.py

@@ -4,12 +4,11 @@ from typing import Any, cast
 
 from ._ocr_confusions import load_confusion_table
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
-try:
-    from glitchlings._zoo_rust import ocr_artifacts as _ocr_artifacts_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _ocr_artifacts_rust = None
+# Load Rust-accelerated operation if available
+_ocr_artifacts_rust = get_rust_operation("ocr_artifacts")
 
 
 def _python_ocr_artifacts(

glitchlings/zoo/typogre.py

@@ -6,12 +6,11 @@ from typing import Any, Optional, cast
 
 from ..util import KEYNEIGHBORS
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
-try:
-    from glitchlings._zoo_rust import fatfinger as _fatfinger_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _fatfinger_rust = None
+# Load Rust-accelerated operation if available
+_fatfinger_rust = get_rust_operation("fatfinger")
 
 
 def _python_unichar(text: str, rng: random.Random) -> str:

glitchlings/zoo/zeedub.py

@@ -6,12 +6,11 @@ from collections.abc import Sequence
 from typing import Any, cast
 
 from ._rate import resolve_rate
+from ._rust_extensions import get_rust_operation
 from .core import AttackOrder, AttackWave, Glitchling
 
-try:
-    from glitchlings._zoo_rust import inject_zero_widths as _inject_zero_widths_rust
-except ImportError:  # pragma: no cover - compiled extension not present
-    _inject_zero_widths_rust = None
+# Load Rust-accelerated operation if available
+_inject_zero_widths_rust = get_rust_operation("inject_zero_widths")
 
 _DEFAULT_ZERO_WIDTH_CHARACTERS: tuple[str, ...] = (
     "\u200b",  # ZERO WIDTH SPACE

{glitchlings-0.4.3.dist-info → glitchlings-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glitchlings
-Version: 0.4.3
+Version: 0.4.4
 Summary: Monsters for your language games.
 Author: osoleve
 License:                                  Apache License
@@ -217,6 +217,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Testing
@@ -237,9 +238,10 @@ Requires-Dist: mkdocs-material>=9.5.0; extra == "all"
 Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "all"
 Requires-Dist: mkdocstrings-python>=1.10.0; extra == "all"
 Requires-Dist: mypy>=1.8.0; extra == "all"
-Requires-Dist: numpy<=2.0,>=1.24; extra == "all"
+Requires-Dist: numpy<3.0,>=1.24; extra == "all"
 Requires-Dist: pre-commit>=3.8.0; extra == "all"
 Requires-Dist: pytest>=8.0.0; extra == "all"
+Requires-Dist: pytest-cov>=4.1.0; extra == "all"
 Requires-Dist: ruff>=0.6.0; extra == "all"
 Requires-Dist: verifiers>=0.1.3.post0; extra == "all"
 Provides-Extra: hf
@@ -247,7 +249,7 @@ Requires-Dist: datasets>=4.0.0; extra == "hf"
 Provides-Extra: lightning
 Requires-Dist: pytorch_lightning>=2.0.0; extra == "lightning"
 Provides-Extra: vectors
-Requires-Dist: numpy<=2.0,>=1.24; extra == "vectors"
+Requires-Dist: numpy<3.0,>=1.24; extra == "vectors"
 Requires-Dist: spacy>=3.7.2; extra == "vectors"
 Requires-Dist: gensim>=4.3.2; extra == "vectors"
 Provides-Extra: st
@@ -259,8 +261,9 @@ Provides-Extra: torch
 Requires-Dist: torch>=2.0.0; extra == "torch"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
 Requires-Dist: hypothesis>=6.140.0; extra == "dev"
-Requires-Dist: numpy<=2.0,>=1.24; extra == "dev"
+Requires-Dist: numpy<3.0,>=1.24; extra == "dev"
 Requires-Dist: mkdocs>=1.6.0; extra == "dev"
 Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "dev"
 Requires-Dist: mkdocs-material>=9.5.0; extra == "dev"

{glitchlings-0.4.3.dist-info → glitchlings-0.4.4.dist-info}/RECORD

@@ -1,17 +1,17 @@
 glitchlings/__init__.py,sha256=bkyRgzjC8ssidEO9UL9VpbYXQxTV1Hz3VAPOIqd9uMg,1182
 glitchlings/__main__.py,sha256=f-P4jiVBd7ZpS6QxRpa_6SJgOG03UhZhcWasMDRWLs8,120
-glitchlings/_zoo_rust.cpython-311-darwin.so,sha256=PXMyeT6b3p8dGysMHMoAK2r1rNiTYRQqNMZJmkR8xk4,2586944
+glitchlings/_zoo_rust.cpython-311-darwin.so,sha256=AyrfGzwHr5yhqGaDYOjWpapgJlD25Kh6DV4fjHKwxSg,2603472
 glitchlings/compat.py,sha256=T_5Ia8yCzZvsMdicZ2TCcOgDO53_AjNGkSXWTR_qEnA,8908
 glitchlings/config.py,sha256=ofxDMkoMg4j51CFube54aca1Ky9y_ZeVktXpeUEdWmA,12953
 glitchlings/config.toml,sha256=04-Y_JCdQU68SRmwk2qZqrH_bbX4jEH9uh7URtxdIHA,99
 glitchlings/main.py,sha256=uw8VbDgxov1m-wYHPDl2dP5ItpLB4ZHpb0ChJXzcL0o,10623
 glitchlings/dlc/__init__.py,sha256=qlY4nuagy4AAWuPMwmuhwK2m36ktp-qkeiIxC7OXg34,305
-glitchlings/dlc/_shared.py,sha256=EFSnush3rjjaf4La5QfVaf_KEp0U_l_3-q4PKx0A6NQ,1972
+glitchlings/dlc/_shared.py,sha256=OmEjJmSs1pQ7j1ggR_H8D8RDp5E1ZqOnzSIxyqRE1aE,4407
 glitchlings/dlc/huggingface.py,sha256=9lW7TnTHA_bXyo4Is8pymZchrB9BIL1bMCP2p7LCMtg,2576
 glitchlings/dlc/prime.py,sha256=qGFI1d4BiOEIgQZ5v9QnlbYx4J4q-vNlh5tWZng11xs,8607
-glitchlings/dlc/pytorch.py,sha256=tfHEDsDAOUnEvImFgRMjqC7Ig_aNVO8suXKpv24C2cA,7823
-glitchlings/dlc/pytorch_lightning.py,sha256=Om45BHYx8tMoUwYOOTk5B5A5AIjNkh58V37OC2IBFxE,8553
-glitchlings/lexicon/__init__.py,sha256=PLuu63iX6GSRypGI4DxiN_U-QmqmDobk1Xb7B5IrsZg,5951
+glitchlings/dlc/pytorch.py,sha256=QaiIYyQ3koy2-enhUI9WY3SIMRX65gmsnjDvCsf8xbg,6233
+glitchlings/dlc/pytorch_lightning.py,sha256=Ls7Xh5Mg643Tyk3KvCMq_MsB4vvekfUUZOhE0z4K22c,8074
+glitchlings/lexicon/__init__.py,sha256=ooEPcAJhCI2Nw5z8OsQ0EtVpKBfiTrU0-AQJq8Zn2nQ,6007
 glitchlings/lexicon/_cache.py,sha256=aWSUb5Ex162dr3HouO2Ic2O8ck3ViEFWs8-XMLKMeJ0,4086
 glitchlings/lexicon/metrics.py,sha256=VBFfFpxjiEwZtK-jS55H8xP7MTC_0OjY8lQ5zSQ9aTY,4572
 glitchlings/lexicon/vector.py,sha256=yWf-vlN2OEHnTCPu7tgDnJbhm47cmhdrTtjR0RZKkUM,22530
@@ -21,26 +21,27 @@ glitchlings/util/__init__.py,sha256=vc3EAY8ehRjbOiryFdaqvvljXcyNGtZSPiEp9ok1vVw,
 glitchlings/util/adapters.py,sha256=psxQFYSFmh1u7NuqtIrKwQP5FOhOrZoxZzc7X7DDi9U,693
 glitchlings/zoo/__init__.py,sha256=1dWZPCTXuh5J7WdCxHX7ZX9bNd8bakzYndxQRhF43i8,5243
 glitchlings/zoo/_ocr_confusions.py,sha256=Ju2_avXiwsr1p8zWFUTOzMxJ8vT5PpYobuGIn4L_sqI,1204
-glitchlings/zoo/_rate.py,sha256=Vb1_5HAzrqr9eAh_zzngSV-d0zI264zcYspnT3VHPkE,504
+glitchlings/zoo/_rate.py,sha256=tkIlXHewE8s9w1jpCw8ZzkVN31690FAnvTM_R3dCIpY,3579
+glitchlings/zoo/_rust_extensions.py,sha256=Bsd0kiPB1rUn5x3k7ykydFuk2YSvXS9CQGPRlE5XzXY,4211
 glitchlings/zoo/_sampling.py,sha256=KrWyUSsYXghlvktS5hQBO0bPqywEEyA49A2qDWInB7Q,1586
 glitchlings/zoo/_text_utils.py,sha256=fS5L_eq-foBbBdiv4ymI8-O0D0csc3yDekHpX8bqfV4,2754
-glitchlings/zoo/adjax.py,sha256=TABKGQOwpyj_5czSoN8tPyEinwp8oZHKOBfU78ae9n0,3545
-glitchlings/zoo/apostrofae.py,sha256=m2-VPO-ahp0zAEJTHPItXMwnpD9D8bQIjVyyIRzj46k,3922
-glitchlings/zoo/core.py,sha256=3IHYEo8f2K7q4EbSZBYPb4MQXUVoMPm6B0IgsjiWNXk,20493
-glitchlings/zoo/jargoyle.py,sha256=zGXi6WFSzYA_44UXvyK0aj18CMFHIFL4eQeijEHfZl4,11568
+glitchlings/zoo/adjax.py,sha256=XT5kKqPOUPgKSDOcR__HBnv4OXtBKee40GuNNmm1GYI,3518
+glitchlings/zoo/apostrofae.py,sha256=qjpfnxdPWXMNzZnSD7UMfvHyzGKa7TLsvUhMsIvjwj8,3822
+glitchlings/zoo/core.py,sha256=dRzUTmhOswDV0hWcaD-Sx7rZdPlrszn7C_1G2xd4ECk,20675
+glitchlings/zoo/jargoyle.py,sha256=2TGU_z8gILwQ-lyZEqvmsrLupxqb8ydlDiwcp-O6WwY,11679
 glitchlings/zoo/mim1c.py,sha256=-fgodKWZq--Xw8L2t1EqNbsh48bwX5jZxmiXdoaQShI,3437
 glitchlings/zoo/ocr_confusions.tsv,sha256=KhtR7vJDTITpfTSGa-I7RHr6CK7LkGi2KjdhEWipI6o,183
-glitchlings/zoo/redactyl.py,sha256=9Rtgkg87LnGt47DHKsD8XW25gtg9pv2aXvrFv46XOTQ,5516
-glitchlings/zoo/reduple.py,sha256=ttHha3Yl0SRzEyAx9SfENbJRO_WhmJYL8ow5LGKn248,4258
-glitchlings/zoo/rushmore.py,sha256=R6dgt4HSvkt31foazNmUhO4wL9PHpjh_7pzJ8vQPgO0,4322
-glitchlings/zoo/scannequin.py,sha256=AQ7JPIxLiPFy4fDV6MgO4OFo34dMShc7sipStUaCG40,4900
-glitchlings/zoo/typogre.py,sha256=AuAtx-KyWrk-zX3uuxjkvjiduLyDwGJNW7XYktnsuos,6712
-glitchlings/zoo/zeedub.py,sha256=3VneZOEeL98Ek1VnZQI4V2o1alv41vvMzZXrKc9Lt1s,4875
+glitchlings/zoo/redactyl.py,sha256=eWn7JC81BXkp2bSinwrBfU3jXukcUGDVkaa6BcGvte4,5559
+glitchlings/zoo/reduple.py,sha256=zSc1N_-tz9Kl7CDMrdZKgCuW3Bxp_-g6axadAa6AszM,4224
+glitchlings/zoo/rushmore.py,sha256=k429trwNPcWJHEOIoeGsdKBzJNL4Fxz9KRqX3Ro9u_0,4286
+glitchlings/zoo/scannequin.py,sha256=GfjLYWWp-jdnOBmdg7gt5wQnobY8jWQHScB5EMgo6HE,4870
+glitchlings/zoo/typogre.py,sha256=BQotNL-gn4PXQI9j63d2w9mQ4X6ZJKSJ4de-GN-gmUI,6686
+glitchlings/zoo/zeedub.py,sha256=aNnjZGeTmMqA2WjgtGh7Fgl9pUQo3AZ2B-tYs2ZFOQE,4840
 glitchlings/zoo/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 glitchlings/zoo/assets/apostrofae_pairs.json,sha256=bfjSEaMTI_axGNJ93nI431KXU0IVp7ayO42gGcMgL6U,521
-glitchlings-0.4.3.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
-glitchlings-0.4.3.dist-info/METADATA,sha256=NV0-8T4jx5R2Eswhib6B29vAeoiXBdIDBFOu6KrzqdM,32242
-glitchlings-0.4.3.dist-info/WHEEL,sha256=Tgp8Vc-mmQm0KX-V22BSUoymoX1p0w13bZbX85y8hSs,114
-glitchlings-0.4.3.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
-glitchlings-0.4.3.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
-glitchlings-0.4.3.dist-info/RECORD,,
+glitchlings-0.4.4.dist-info/licenses/LICENSE,sha256=YCvGip-LoaRyu6h0nPo71q6eHEkzUpsE11psDJOIRkw,11337
+glitchlings-0.4.4.dist-info/METADATA,sha256=onpPJTtANv13MyyvYS930OWiJb_Ipxvje5sTrNmNPQw,32388
+glitchlings-0.4.4.dist-info/WHEEL,sha256=Tgp8Vc-mmQm0KX-V22BSUoymoX1p0w13bZbX85y8hSs,114
+glitchlings-0.4.4.dist-info/entry_points.txt,sha256=kGOwuAsjFDLtztLisaXtOouq9wFVMOJg5FzaAkg-Hto,54
+glitchlings-0.4.4.dist-info/top_level.txt,sha256=VHFNBrLjtDwPCYXbGKi6o17Eueedi81eNbR3hBOoST0,12
+glitchlings-0.4.4.dist-info/RECORD,,