glitchlings 0.4.0__cp311-cp311-macosx_11_0_universal2.whl → 0.4.2__cp311-cp311-macosx_11_0_universal2.whl

glitchlings/util/__init__.py

@@ -1,12 +1,27 @@
 import difflib
 from collections.abc import Iterable
 
-SAMPLE_TEXT = "One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible vermin. He lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightly domed and divided by arches into stiff sections. The bedding was hardly able to cover it and seemed ready to slide off any moment. His many legs, pitifully thin compared with the size of the rest of him, waved about helplessly as he looked."
+__all__ = [
+    "SAMPLE_TEXT",
+    "string_diffs",
+    "KeyNeighborMap",
+    "KeyboardLayouts",
+    "KeyNeighbors",
+    "KEYNEIGHBORS",
+]
+
+SAMPLE_TEXT = (
+    "One morning, when Gregor Samsa woke from troubled dreams, he found himself "
+    "transformed in his bed into a horrible vermin. He lay on his armour-like back, and "
+    "if he lifted his head a little he could see his brown belly, slightly domed and "
+    "divided by arches into stiff sections. The bedding was hardly able to cover it and "
+    "seemed ready to slide off any moment. His many legs, pitifully thin compared with "
+    "the size of the rest of him, waved about helplessly as he looked."
+)
 
 
 def string_diffs(a: str, b: str) -> list[list[tuple[str, str, str]]]:
-    """
-    Compare two strings using SequenceMatcher and return
+    """Compare two strings using SequenceMatcher and return
     grouped adjacent opcodes (excluding 'equal' tags).
 
     Each element is a tuple: (tag, a_text, b_text).
@@ -39,7 +54,6 @@ KeyboardLayouts = dict[str, KeyNeighborMap]
 
 def _build_neighbor_map(rows: Iterable[str]) -> KeyNeighborMap:
     """Derive 8-neighbour adjacency lists from keyboard layout rows."""
-
     grid: dict[tuple[int, int], str] = {}
     for y, row in enumerate(rows):
         for x, char in enumerate(row):

glitchlings/util/adapters.py

@@ -0,0 +1,27 @@
+"""Adapter helpers shared across Python and DLC integrations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ..zoo import Gaggle, Glitchling, summon
+
+
+def coerce_gaggle(
+    glitchlings: Glitchling | Gaggle | str | Iterable[str | Glitchling],
+    *,
+    seed: int,
+) -> Gaggle:
+    """Return a :class:`Gaggle` built from any supported glitchling specifier."""
+    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)
+
+
+__all__ = ["coerce_gaggle"]

glitchlings/zoo/__init__.py

@@ -3,16 +3,25 @@ from __future__ import annotations
 import ast
 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 .core import (
+    Gaggle,
+    Glitchling,
+    is_rust_pipeline_enabled,
+    is_rust_pipeline_supported,
+    pipeline_feature_flag_enabled,
+    plan_glitchling_specs,
+    plan_glitchlings,
+)
+from .jargoyle import Jargoyle, jargoyle
+from .jargoyle import dependencies_available as _jargoyle_available
+from .mim1c import Mim1c, mim1c
+from .redactyl import Redactyl, redactyl
 from .reduple import Reduple, reduple
 from .rushmore import Rushmore, rushmore
-from .redactyl import Redactyl, redactyl
 from .scannequin import Scannequin, scannequin
+from .typogre import Typogre, typogre
 from .zeedub import Zeedub, zeedub
-from .core import Glitchling, Gaggle
 
 __all__ = [
     "Typogre",
@@ -35,6 +44,11 @@ __all__ = [
     "zeedub",
     "Glitchling",
     "Gaggle",
+    "plan_glitchlings",
+    "plan_glitchling_specs",
+    "is_rust_pipeline_enabled",
+    "is_rust_pipeline_supported",
+    "pipeline_feature_flag_enabled",
     "summon",
     "BUILTIN_GLITCHLINGS",
     "DEFAULT_GLITCHLING_NAMES",
@@ -71,7 +85,6 @@ DEFAULT_GLITCHLING_NAMES: list[str] = list(BUILTIN_GLITCHLINGS.keys())
 
 def parse_glitchling_spec(specification: str) -> Glitchling:
     """Return a glitchling instance configured according to ``specification``."""
-
     text = specification.strip()
     if not text:
         raise ValueError("Glitchling specification cannot be empty.")
@@ -98,14 +111,10 @@ def parse_glitchling_spec(specification: str) -> Glitchling:
     try:
         call_expr = ast.parse(f"_({arg_source})", mode="eval").body
     except SyntaxError as exc:
-        raise ValueError(
-            f"Invalid parameter syntax for glitchling '{name}': {exc.msg}"
-        ) from exc
+        raise ValueError(f"Invalid parameter syntax for glitchling '{name}': {exc.msg}") from exc
 
     if not isinstance(call_expr, ast.Call) or call_expr.args:
-        raise ValueError(
-            f"Glitchling '{name}' parameters must be provided as keyword arguments."
-        )
+        raise ValueError(f"Glitchling '{name}' parameters must be provided as keyword arguments.")
 
     kwargs: dict[str, Any] = {}
     for keyword in call_expr.keywords:
@@ -128,7 +137,6 @@ def parse_glitchling_spec(specification: str) -> Glitchling:
 
 def get_glitchling_class(name: str) -> type[Glitchling]:
     """Look up the glitchling class registered under ``name``."""
-
     key = name.strip().lower()
     if not key:
         raise ValueError("Glitchling name cannot be empty.")
@@ -142,7 +150,6 @@ def get_glitchling_class(name: str) -> type[Glitchling]:
 
 def summon(glitchlings: list[str | Glitchling], seed: int = 151) -> Gaggle:
     """Summon glitchlings by name (using defaults) or instance (to change parameters)."""
-
     summoned: list[Glitchling] = []
     for entry in glitchlings:
         if isinstance(entry, Glitchling):

glitchlings/zoo/_ocr_confusions.py

@@ -26,9 +26,7 @@ def load_confusion_table() -> list[tuple[str, list[str]]]:
 
     # Sort longer patterns first to avoid overlapping matches, mirroring the
     # behaviour of the Rust `confusion_table` helper.
-    indexed_entries.sort(
-        key=lambda item: (-len(item[1][0]), item[0])
-    )
+    indexed_entries.sort(key=lambda item: (-len(item[1][0]), item[0]))
     entries = [entry for _, entry in indexed_entries]
     _CONFUSION_TABLE = entries
     return entries

glitchlings/zoo/_rate.py

@@ -9,11 +9,8 @@ def resolve_rate(
     legacy_name: str,
 ) -> float:
     """Return the effective rate while enforcing mutual exclusivity."""
-
     if rate is not None and legacy_value is not None:
-        raise ValueError(
-            f"Specify either 'rate' or '{legacy_name}', not both."
-        )
+        raise ValueError(f"Specify either 'rate' or '{legacy_name}', not both.")
     if rate is not None:
         return rate
     if legacy_value is not None:

glitchlings/zoo/_sampling.py

@@ -17,7 +17,6 @@ def weighted_sample_without_replacement(
     handling and RNG interactions so the Python and Rust implementations remain
     aligned.
     """
-
     if k < 0:
         raise ValueError("Sample size cannot be negative")
 

glitchlings/zoo/_text_utils.py

@@ -10,13 +10,11 @@ _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, ""
@@ -25,7 +23,6 @@ def split_token_edges(token: str) -> tuple[str, str, str]:
 
 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)
@@ -50,7 +47,6 @@ class WordToken:
     @property
     def has_core(self) -> bool:
         """Return ``True`` when the token contains at least one core character."""
-
         return bool(self.core)
 
 
@@ -65,8 +61,8 @@ def collect_word_tokens(
         tokens: Token sequence produced by :func:`split_preserving_whitespace`.
         skip_first_word: Exclude the first candidate token (used by Rushmore to
             preserve leading words).
-    """
 
+    """
     start = 2 if skip_first_word else 0
     collected: list[WordToken] = []
     for index in range(start, len(tokens), 2):

glitchlings/zoo/adjax.py

@@ -20,7 +20,6 @@ def _python_swap_adjacent_words(
     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
@@ -72,7 +71,6 @@ def swap_adjacent_words(
     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,

glitchlings/zoo/core.py

@@ -4,23 +4,21 @@ import inspect
 import logging
 import os
 import random
+from collections.abc import Mapping, Sequence
 from enum import IntEnum, auto
 from hashlib import blake2s
-from typing import TYPE_CHECKING, Any, Callable, Protocol
+from typing import TYPE_CHECKING, Any, Callable, Protocol, TypedDict, Union
 
-_datasets_error: ModuleNotFoundError | None = None
-try:  # pragma: no cover - optional dependency
-    from datasets import Dataset as _DatasetsDataset
-except ModuleNotFoundError as error:  # pragma: no cover - optional dependency
-    _DatasetsDataset = None  # type: ignore[assignment]
-    _datasets_error = error
-else:
-    _datasets_error = None
+from ..compat import get_datasets_dataset, require_datasets
+
+_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
 
 
 log = logging.getLogger(__name__)
@@ -31,9 +29,17 @@ _PIPELINE_ENABLE_VALUES = {"1", "true", "yes", "on"}
 _PIPELINE_DISABLE_VALUES = {"0", "false", "no", "off"}
 
 
-def _pipeline_feature_flag_enabled() -> bool:
-    """Return ``True`` when the environment does not explicitly disable the Rust pipeline."""
+class PlanSpecification(TypedDict):
+    name: str
+    scope: int
+    order: int
 
+
+PlanEntry = Union["Glitchling", Mapping[str, Any]]
+
+
+def pipeline_feature_flag_enabled() -> bool:
+    """Return ``True`` when the environment does not explicitly disable the Rust pipeline."""
     value = os.environ.get(_PIPELINE_FEATURE_FLAG_ENV)
     if value is None:
         return True
@@ -47,6 +53,138 @@ def _pipeline_feature_flag_enabled() -> bool:
 
     return True
 
+
+def _pipeline_feature_flag_enabled() -> bool:
+    """Compatibility shim for legacy callers."""
+    return pipeline_feature_flag_enabled()
+
+
+def is_rust_pipeline_supported() -> bool:
+    """Return ``True`` when the optional Rust extension is importable."""
+    return _compose_glitchlings_rust is not None
+
+
+def is_rust_pipeline_enabled() -> bool:
+    """Return ``True`` when the Rust pipeline is available and not explicitly disabled."""
+    return is_rust_pipeline_supported() and pipeline_feature_flag_enabled()
+
+
+def _spec_from_glitchling(glitchling: "Glitchling") -> PlanSpecification:
+    """Create a plan specification mapping from a glitchling instance."""
+    return {
+        "name": glitchling.name,
+        "scope": int(glitchling.level),
+        "order": int(glitchling.order),
+    }
+
+
+def _normalize_plan_entry(entry: PlanEntry) -> PlanSpecification:
+    """Convert a plan entry (glitchling or mapping) into a normalized specification."""
+    if isinstance(entry, Glitchling):
+        return _spec_from_glitchling(entry)
+
+    if not isinstance(entry, Mapping):
+        message = "plan_glitchlings expects Glitchling instances or mapping specifications"
+        raise TypeError(message)
+
+    try:
+        name = str(entry["name"])
+        scope_value = int(entry["scope"])
+        order_value = int(entry["order"])
+    except KeyError as exc:  # pragma: no cover - defensive guard
+        raise ValueError(f"Plan specification missing required field: {exc.args[0]}") from exc
+    except (TypeError, ValueError) as exc:
+        raise ValueError("Plan specification fields must be coercible to integers") from exc
+
+    return {"name": name, "scope": scope_value, "order": order_value}
+
+
+def _normalize_plan_entries(entries: Sequence[PlanEntry]) -> list[PlanSpecification]:
+    """Normalize a collection of orchestration plan entries."""
+    return [_normalize_plan_entry(entry) for entry in entries]
+
+
+def _plan_glitchlings_python(
+    specs: Sequence[Mapping[str, Any]],
+    master_seed: int,
+) -> list[tuple[int, int]]:
+    """Pure-Python fallback for orchestrating glitchlings in deterministic order."""
+    master_seed_int = int(master_seed)
+    planned: list[tuple[int, int, int, int, str]] = []
+    for index, spec in enumerate(specs):
+        name = str(spec["name"])
+        scope = int(spec["scope"])
+        order = int(spec["order"])
+        derived_seed = Gaggle.derive_seed(master_seed_int, name, index)
+        planned.append((index, derived_seed, scope, order, name))
+
+    planned.sort(key=lambda entry: (entry[2], entry[3], entry[4], entry[0]))
+    return [(index, seed) for index, seed, *_ in planned]
+
+
+def _plan_glitchlings_with_rust(
+    specs: Sequence[Mapping[str, Any]],
+    master_seed: int,
+) -> list[tuple[int, int]] | None:
+    """Attempt to obtain the orchestration plan from the compiled Rust module."""
+    if _plan_glitchlings_rust is None:
+        return None
+
+    try:
+        plan = _plan_glitchlings_rust(specs, int(master_seed))
+    except Exception:  # 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
+
+    return [(int(index), int(seed)) for index, seed in plan]
+
+
+def _resolve_orchestration_plan(
+    specs: Sequence[PlanSpecification],
+    master_seed: int,
+    prefer_rust: bool,
+) -> list[tuple[int, int]]:
+    """Dispatch to the Rust planner when available, otherwise fall back to Python."""
+    if prefer_rust:
+        plan = _plan_glitchlings_with_rust(list(specs), master_seed)
+        if plan is not None:
+            return plan
+
+    return _plan_glitchlings_python(list(specs), master_seed)
+
+
+def plan_glitchling_specs(
+    specs: Sequence[Mapping[str, Any]],
+    master_seed: int | None,
+    *,
+    prefer_rust: bool = True,
+) -> list[tuple[int, int]]:
+    """Resolve orchestration order and seeds from glitchling specifications."""
+    if master_seed is None:
+        message = "Gaggle orchestration requires a master seed"
+        raise ValueError(message)
+
+    normalized_specs = [_normalize_plan_entry(spec) for spec in specs]
+    master_seed_int = int(master_seed)
+    return _resolve_orchestration_plan(normalized_specs, master_seed_int, prefer_rust)
+
+
+def plan_glitchlings(
+    entries: Sequence[PlanEntry],
+    master_seed: int | None,
+    *,
+    prefer_rust: bool = True,
+) -> list[tuple[int, int]]:
+    """Normalize glitchling instances or specs and compute an orchestration plan."""
+    if master_seed is None:
+        message = "Gaggle orchestration requires a master seed"
+        raise ValueError(message)
+
+    normalized_specs = _normalize_plan_entries(entries)
+    master_seed_int = int(master_seed)
+    return _resolve_orchestration_plan(normalized_specs, master_seed_int, prefer_rust)
+
+
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from datasets import Dataset  # type: ignore
 elif _DatasetsDataset is not None:
@@ -66,7 +204,6 @@ def _is_transcript(
     require_all_content: bool = False,
 ) -> bool:
     """Return `True` when `value` appears to be a chat transcript."""
-
     if not isinstance(value, list):
         return False
 
@@ -135,8 +272,8 @@ class Glitchling:
             order: Relative ordering within the same scope.
             seed: Optional seed for deterministic random behaviour.
             **kwargs: Additional parameters forwarded to the corruption callable.
-        """
 
+        """
         # Each Glitchling maintains its own RNG for deterministic yet isolated behavior.
         # If no seed is supplied, we fall back to Python's default entropy.
         self.seed = seed
@@ -154,7 +291,6 @@ class Glitchling:
 
     def set_param(self, key: str, value: Any) -> None:
         """Persist a parameter for use by the corruption callable."""
-
         aliases = getattr(self, "_param_aliases", {})
         canonical = aliases.get(key, key)
 
@@ -176,7 +312,6 @@ class Glitchling:
 
     def pipeline_operation(self) -> dict[str, Any] | None:
         """Return the Rust pipeline operation descriptor for this glitchling."""
-
         factory = self._pipeline_descriptor_factory
         if factory is None:
             return None
@@ -185,15 +320,11 @@ class Glitchling:
 
     def _corruption_expects_rng(self) -> bool:
         """Return `True` when the corruption function accepts an rng keyword."""
-
         cached_callable = self._cached_rng_callable
         cached_expectation = self._cached_rng_expectation
         corruption_function = self.corruption_function
 
-        if (
-            cached_callable is corruption_function
-            and cached_expectation is not None
-        ):
+        if cached_callable is corruption_function and cached_expectation is not None:
             return cached_expectation
 
         expects_rng = False
@@ -211,7 +342,6 @@ class Glitchling:
 
     def __corrupt(self, text: str, *args: Any, **kwargs: Any) -> str:
         """Execute the corruption callable, injecting the RNG when required."""
-
         # Pass rng to underlying corruption function if it expects it.
         expects_rng = self._corruption_expects_rng()
 
@@ -223,23 +353,17 @@ class Glitchling:
 
     def corrupt(self, text: str | list[dict[str, Any]]) -> str | list[dict[str, Any]]:
         """Apply the corruption function to text or conversational transcripts."""
-
         if _is_transcript(text):
             transcript = [dict(turn) for turn in text]
             if transcript:
-                transcript[-1]["content"] = self.__corrupt(
-                    transcript[-1]["content"], **self.kwargs
-                )
+                transcript[-1]["content"] = self.__corrupt(transcript[-1]["content"], **self.kwargs)
             return transcript
 
         return self.__corrupt(text, **self.kwargs)
 
     def corrupt_dataset(self, dataset: Dataset, columns: list[str]) -> Dataset:
         """Apply corruption lazily across dataset columns."""
-
-        if _DatasetsDataset is None:
-            message = "datasets is not installed"
-            raise ModuleNotFoundError(message) from _datasets_error
+        require_datasets("datasets is not installed")
 
         def __corrupt_row(row: dict[str, Any]) -> dict[str, Any]:
             row = dict(row)
@@ -261,12 +385,10 @@ class Glitchling:
 
     def __call__(self, text: str, *args: Any, **kwds: Any) -> str | list[dict[str, Any]]:
         """Allow a glitchling to be invoked directly like a callable."""
-
         return self.corrupt(text, *args, **kwds)
 
     def reset_rng(self, seed: int | None = None) -> None:
         """Reset the glitchling's RNG to its initial seed."""
-
         if seed is not None:
             self.seed = seed
         if self.seed is not None:
@@ -274,7 +396,6 @@ class Glitchling:
 
     def clone(self, seed: int | None = None) -> "Glitchling":
         """Create a copy of this glitchling, optionally with a new seed."""
-
         cls = self.__class__
         filtered_kwargs = {k: v for k, v in self.kwargs.items() if k != "seed"}
         clone_seed = seed if seed is not None else self.seed
@@ -294,9 +415,6 @@ class Glitchling:
         return cls(**filtered_kwargs)
 
 
-
-
-
 class Gaggle(Glitchling):
     """A collection of glitchlings executed in a deterministic order."""
 
@@ -306,25 +424,24 @@ class Gaggle(Glitchling):
         Args:
             glitchlings: Glitchlings to orchestrate.
             seed: Master seed used to derive per-glitchling seeds.
-        """
 
+        """
         super().__init__("Gaggle", self.corrupt, AttackWave.DOCUMENT, seed=seed)
-        self.glitchlings: dict[AttackWave, list[Glitchling]] = {
-            level: [] for level in AttackWave
-        }
+        self._clones_by_index: list[Glitchling] = []
+        for idx, glitchling in enumerate(glitchlings):
+            clone = glitchling.clone()
+            setattr(clone, "_gaggle_index", idx)
+            self._clones_by_index.append(clone)
+
+        self.glitchlings: dict[AttackWave, list[Glitchling]] = {level: [] for level in AttackWave}
         self.apply_order: list[Glitchling] = []
-        # Derive deterministic per-glitchling seeds from master seed if provided
-        for idx, g in enumerate(glitchlings):
-            _g = g.clone()
-            derived_seed = Gaggle.derive_seed(seed, _g.name, idx)
-            _g.reset_rng(derived_seed)
-            setattr(_g, "_gaggle_index", idx)
-            self.glitchlings[g.level].append(_g)
+        self._plan: list[tuple[int, int]] = []
         self.sort_glitchlings()
 
     @staticmethod
     def derive_seed(master_seed: int, glitchling_name: str, index: int) -> int:
         """Derive a deterministic seed for a glitchling based on the master seed."""
+
         def _int_to_bytes(value: int) -> bytes:
             if value == 0:
                 return b"\x00"
@@ -351,24 +468,37 @@ class Gaggle(Glitchling):
 
     def sort_glitchlings(self) -> None:
         """Sort glitchlings by wave then order to produce application order."""
+        plan = plan_glitchlings(self._clones_by_index, self.seed)
+        self._plan = plan
+
+        self.glitchlings = {level: [] for level in AttackWave}
+        for clone in self._clones_by_index:
+            self.glitchlings[clone.level].append(clone)
+
+        missing = set(range(len(self._clones_by_index)))
+        apply_order: list[Glitchling] = []
+        for index, derived_seed in plan:
+            clone = self._clones_by_index[index]
+            clone.reset_rng(int(derived_seed))
+            apply_order.append(clone)
+            missing.discard(index)
 
-        self.apply_order = [
-            g
-            for _, glitchlings in sorted(self.glitchlings.items())
-            for g in sorted(glitchlings, key=lambda x: (x.order, x.name))
-        ]
+        if missing:
+            missing_indices = ", ".join(str(idx) for idx in sorted(missing))
+            message = f"Orchestration plan missing glitchlings at indices: {missing_indices}"
+            raise RuntimeError(message)
+
+        self.apply_order = apply_order
 
     @staticmethod
     def rust_pipeline_supported() -> bool:
         """Return ``True`` when the compiled Rust pipeline is importable."""
-
-        return _compose_glitchlings_rust is not None
+        return is_rust_pipeline_supported()
 
     @staticmethod
     def rust_pipeline_enabled() -> bool:
         """Return ``True`` when the Rust pipeline is available and not explicitly disabled."""
-
-        return Gaggle.rust_pipeline_supported() and _pipeline_feature_flag_enabled()
+        return is_rust_pipeline_enabled()
 
     def _pipeline_descriptors(self) -> list[dict[str, Any]] | None:
         if not self.rust_pipeline_enabled():
@@ -400,7 +530,6 @@ class Gaggle(Glitchling):
 
     def corrupt(self, text: str) -> str:
         """Apply each glitchling to the provided text sequentially."""
-
         master_seed = self.seed
         descriptors = self._pipeline_descriptors()
         if master_seed is not None and descriptors is not None: