lionagi 0.17.5__py3-none-any.whl → 0.17.6__py3-none-any.whl

lionagi/config.py

@@ -83,6 +83,17 @@ class AppSettings(BaseSettings, frozen=True):
     LIONAGI_QDRANT_URL: str = "http://localhost:6333"
     LIONAGI_DEFAULT_QDRANT_COLLECTION: str = "event_logs"
 
+    # Log configuration
+    LOG_PERSIST_DIR: str = "./data/logs"
+    LOG_SUBFOLDER: str | None = None
+    LOG_CAPACITY: int = 50
+    LOG_EXTENSION: str = ".json"
+    LOG_USE_TIMESTAMP: bool = True
+    LOG_HASH_DIGITS: int = 5
+    LOG_FILE_PREFIX: str = "log"
+    LOG_AUTO_SAVE_ON_EXIT: bool = True
+    LOG_CLEAR_AFTER_DUMP: bool = True
+
     # Class variable to store the singleton instance
     _instance: ClassVar[Any] = None
 
@@ -119,6 +130,21 @@ class AppSettings(BaseSettings, frozen=True):
 
         return str(secret)
 
+    @property
+    def LOG_CONFIG(self) -> dict[str, Any]:
+        """Get LOG configuration dict compatible with old Settings.Config.LOG format."""
+        return {
+            "persist_dir": self.LOG_PERSIST_DIR,
+            "subfolder": self.LOG_SUBFOLDER,
+            "capacity": self.LOG_CAPACITY,
+            "extension": self.LOG_EXTENSION,
+            "use_timestamp": self.LOG_USE_TIMESTAMP,
+            "hash_digits": self.LOG_HASH_DIGITS,
+            "file_prefix": self.LOG_FILE_PREFIX,
+            "auto_save_on_exit": self.LOG_AUTO_SAVE_ON_EXIT,
+            "clear_after_dump": self.LOG_CLEAR_AFTER_DUMP,
+        }
+
 
 # Create a singleton instance
 settings = AppSettings()

lionagi/fields/action.py

@@ -11,8 +11,8 @@ from lionagi.libs.validate.common_field_validators import (
     validate_boolean_field,
     validate_nullable_string_field,
 )
+from lionagi.ln import extract_json, to_dict, to_list
 from lionagi.models import FieldModel, HashableModel
-from lionagi.utils import to_dict, to_json, to_list
 
 __all__ = (
     "ActionRequestModel",
@@ -27,11 +27,13 @@ def parse_action_request(content: str | dict) -> list[dict]:
         json_blocks = [content.model_dump()]
 
     elif isinstance(content, str):
-        json_blocks = to_json(content, fuzzy_parse=True)
+        json_blocks = extract_json(content, fuzzy_parse=True)
         if not json_blocks:
             pattern2 = r"```python\s*(.*?)\s*```"
             _d = re.findall(pattern2, content, re.DOTALL)
-            json_blocks = [to_json(match, fuzzy_parse=True) for match in _d]
+            json_blocks = [
+                extract_json(match, fuzzy_parse=True) for match in _d
+            ]
             json_blocks = to_list(json_blocks, dropna=True)
 
         print(json_blocks)

lionagi/libs/file/chunk.py

@@ -28,12 +28,6 @@ def chunk_by_chars(
 
     Raises:
         ValueError: If an error occurs during the chunking process.
-
-    Examples:
-        >>> text = "This is a sample text for chunking."
-        >>> chunks = chunk_by_chars(text, chunk_size=10, overlap=0.2)
-        >>> print(chunks)
-        ['This is a ', 'a sample ', 'le text fo', 'for chunki', 'king.']
     """
     try:
         n_chunks = math.ceil(len(text) / chunk_size)
@@ -112,12 +106,6 @@ def chunk_by_tokens(
 
     Raises:
         ValueError: If an error occurs during the chunking process.
-
-    Examples:
-        >>> tokens = ["This", "is", "a", "sample", "text", "for", "chunking."]
-        >>> chunks = chunk_by_tokens(tokens, chunk_size=3, overlap=0.2)
-        >>> print(chunks)
-        ['This is a', 'a sample text', 'text for chunking.']
     """
     try:
         n_chunks = math.ceil(len(tokens) / chunk_size)
@@ -166,7 +154,9 @@ def _chunk_token_two_parts(
 ) -> list[str | list[str]]:
     """Handle chunking for two parts."""
     chunks = [tokens[: chunk_size + overlap_size]]
-    if residue > threshold:
+    # When residue == 0, we have perfect division, create the second chunk
+    # When residue > threshold, the leftover is big enough for a second chunk
+    if residue == 0 or residue > threshold:
         chunks.append(tokens[chunk_size - overlap_size :])
     else:
         return _process_single_chunk(tokens, return_tokens)
@@ -237,7 +227,6 @@ def chunk_content(
         metadata (Dict[str, Any]): Metadata to be included with each chunk.
         kwargs for tokenizer, if needed.
 
-
     Returns:
         List[Dict[str, Any]]: A list of dictionaries, each representing a chunk with metadata.
     """

lionagi/libs/file/process.py

@@ -9,12 +9,9 @@ from pathlib import Path
 from typing import Any, Literal
 
 from lionagi import ln
+from lionagi.utils import is_import_installed
 
-from ._utils import check_docling_available
 from .chunk import chunk_content
-from .save import save_chunks
-
-_HAS_DOCLING = check_docling_available()
 
 
 def dir_to_files(
@@ -90,82 +87,6 @@ def dir_to_files(
         raise ValueError(f"Error processing directory {directory}: {e}") from e
 
 
-def file_to_chunks(
-    file_path: str | Path,
-    chunk_by: Literal["chars", "tokens"] = "chars",
-    chunk_size: int = 1500,
-    overlap: float = 0.1,
-    threshold: int = 200,
-    encoding: str = "utf-8",
-    custom_metadata: dict[str, Any] | None = None,
-    output_dir: str | Path | None = None,
-    verbose: bool = False,
-    timestamp: bool = True,
-    random_hash_digits: int = 4,
-    as_node: bool = False,
-) -> list[dict[str, Any]]:
-    """
-    Process a file and split its content into chunks.
-
-    This function reads a file, splits its content into chunks using the provided
-    chunking function, and optionally saves the chunks to separate files.
-
-    Args:
-        file_path (Union[str, Path]): Path to the file to be processed.
-        chunk_func (Callable): Function to use for chunking the content.
-        chunk_size (int): The target size for each chunk.
-        overlap (float): The fraction of overlap between chunks.
-        threshold (int): The minimum size for the last chunk.
-        encoding (str): File encoding to use when reading the file.
-        custom_metadata (Optional[Dict[str, Any]]): Additional metadata to include with each chunk.
-        output_dir (Optional[Union[str, Path]]): Directory to save output chunks (if provided).
-        verbose (bool): If True, print verbose output.
-        timestamp (bool): If True, include timestamp in output filenames.
-        random_hash_digits (int): Number of random hash digits to include in output filenames.
-
-    Returns:
-        List[Dict[str, Any]]: A list of dictionaries, each representing a chunk with metadata.
-
-    Raises:
-        ValueError: If there's an error processing the file.
-    """
-    try:
-        if isinstance(file_path, str):
-            file_path = Path(file_path)
-
-        text = file_path.read_text(encoding=encoding)
-
-        metadata = {
-            "file_path": str(file_path),
-            "file_name": file_path.name,
-            "file_size": file_path.stat().st_size,
-            **(custom_metadata or {}),
-        }
-
-        chunks = chunk_content(
-            text,
-            chunk_by=chunk_by,
-            chunk_size=chunk_size,
-            overlap=overlap,
-            threshold=threshold,
-            metadata=metadata,
-            as_node=as_node,
-        )
-
-        if output_dir:
-            save_chunks(
-                chunks=chunks,
-                output_dir=output_dir,
-                verbose=verbose,
-                timestamp=timestamp,
-                random_hash_digits=random_hash_digits,
-            )
-
-        return chunks
-    except Exception as e:
-        raise ValueError(f"Error processing file {file_path}: {e}") from e
-
-
 def chunk(
     *,
     text: str | None = None,
@@ -209,12 +130,12 @@ def chunk(
             reader_tool = lambda x: Path(x).read_text(encoding="utf-8")
 
         if reader_tool == "docling":
-            if _HAS_DOCLING is not True:
-                raise _HAS_DOCLING
-
-            from docling.document_converter import (  # noqa: F401
-                DocumentConverter,
-            )
+            if not is_import_installed("docling"):
+                raise ImportError(
+                    "The 'docling' package is required for this feature. "
+                    "Please install it via 'pip install lionagi[reader]'."
+                )
+            from docling.document_converter import DocumentConverter
 
             converter = DocumentConverter()
             reader_tool = lambda x: converter.convert(
@@ -235,7 +156,7 @@ def chunk(
         threshold=threshold,
         metadata=metadata,
         as_node=True,
-        flatten=True,
+        output_flatten=True,
         tokenizer=tokenizer or str.split,
     )
     if threshold:
@@ -248,15 +169,12 @@ def chunk(
         if output_file.suffix == ".csv":
             p = Pile(chunks)
             p.dump(output_file, "csv")
-
-        if output_file.suffix == "json":
+        elif output_file.suffix == ".json":
             p = Pile(chunks)
             p.dump(output_file, "json")
-
-        if output_file.suffix == ".parquet":
+        elif output_file.suffix == ".parquet":
             p = Pile(chunks)
             p.dump(output_file, "parquet")
-
         else:
             raise ValueError(f"Unsupported output file format: {output_file}")
 

lionagi/libs/schema/breakdown_pydantic_annotation.py

@@ -0,0 +1,45 @@
+from inspect import isclass
+from typing import Any, get_args, get_origin
+
+from pydantic import BaseModel
+
+
+def breakdown_pydantic_annotation(
+    model: type[BaseModel],
+    max_depth: int | None = None,
+    current_depth: int = 0,
+) -> dict[str, Any]:
+    if not _is_pydantic_model(model):
+        raise TypeError("Input must be a Pydantic model")
+
+    if max_depth is not None and current_depth >= max_depth:
+        raise RecursionError("Maximum recursion depth reached")
+
+    out: dict[str, Any] = {}
+    for k, v in model.__annotations__.items():
+        origin = get_origin(v)
+        if _is_pydantic_model(v):
+            out[k] = breakdown_pydantic_annotation(
+                v, max_depth, current_depth + 1
+            )
+        elif origin is list:
+            args = get_args(v)
+            if args and _is_pydantic_model(args[0]):
+                out[k] = [
+                    breakdown_pydantic_annotation(
+                        args[0], max_depth, current_depth + 1
+                    )
+                ]
+            else:
+                out[k] = [args[0] if args else Any]
+        else:
+            out[k] = v
+
+    return out
+
+
+def _is_pydantic_model(x: Any) -> bool:
+    try:
+        return isclass(x) and issubclass(x, BaseModel)
+    except TypeError:
+        return False

lionagi/ln/_async_call.py

@@ -43,7 +43,7 @@ async def alcall(
     output_unique: bool = False,
     output_flatten_tuple_set: bool = False,
     delay_before_start: float = 0,
-    retry_initial_deplay: float = 0,
+    retry_initial_delay: float = 0,
     retry_backoff: float = 1,
     retry_default: Any = Unset,
     retry_timeout: float = None,
@@ -143,7 +143,7 @@ async def alcall(
 
     async def execute_task(i: Any, index: int) -> Any:
         attempts = 0
-        current_delay = retry_initial_deplay
+        current_delay = retry_initial_delay
         while True:
             try:
                 result = await call_func(i)
@@ -223,10 +223,10 @@ async def bcall(
     output_unique: bool = False,
     output_flatten_tuple_set: bool = False,
     delay_before_start: float = 0,
-    retry_initial_deplay: float = 0,
+    retry_initial_delay: float = 0,
     retry_backoff: float = 1,
     retry_default: Any = Unset,
-    retry_timeout: float = 0,
+    retry_timeout: float = None,
     retry_attempts: int = 0,
     max_concurrent: int | None = None,
     throttle_period: float | None = None,
@@ -248,7 +248,7 @@ async def bcall(
             output_unique=output_unique,
             output_flatten_tuple_set=output_flatten_tuple_set,
             delay_before_start=delay_before_start,
-            retry_initial_deplay=retry_initial_deplay,
+            retry_initial_delay=retry_initial_delay,
             retry_backoff=retry_backoff,
             retry_default=retry_default,
             retry_timeout=retry_timeout,
@@ -279,7 +279,7 @@ class AlcallParams(Params):
 
     # retry and timeout
     delay_before_start: float
-    retry_initial_deplay: float
+    retry_initial_delay: float
     retry_backoff: float
     retry_default: Any
     retry_timeout: float

lionagi/ln/fuzzy/_fuzzy_match.py

@@ -1,8 +1,7 @@
-from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any, ClassVar, Literal
 
-from ..types import KeysDict, Params, Unset
+from ..types import KeysLike, Params, Unset
 from ._string_similarity import (
     SIMILARITY_ALGO_MAP,
     SIMILARITY_TYPE,
@@ -21,7 +20,7 @@ HandleUnmatched = Literal["ignore", "raise", "remove", "fill", "force"]
 
 def fuzzy_match_keys(
     d_: dict[str, Any],
-    keys: Sequence[str] | KeysDict,
+    keys: KeysLike,
     /,
     *,
     similarity_algo: SIMILARITY_TYPE | SimilarityFunc = "jaro_winkler",
@@ -166,7 +165,5 @@ class FuzzyMatchKeysParams(Params):
     fill_mapping: dict[str, Any] | Any = Unset
     strict: bool = False
 
-    def __call__(
-        self, d_: dict[str, Any], keys: Sequence[str] | KeysDict
-    ) -> dict[str, Any]:
+    def __call__(self, d_: dict[str, Any], keys: KeysLike) -> dict[str, Any]:
         return fuzzy_match_keys(d_, keys, **self.default_kw())

lionagi/ln/fuzzy/_fuzzy_validate.py

@@ -1,9 +1,9 @@
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, Literal
 
 from lionagi._errors import ValidationError
 
-from ..types import KeysDict
+from ..types import KeysLike
 from ._extract_json import extract_json
 from ._fuzzy_match import FuzzyMatchKeysParams, fuzzy_match_keys
 from ._string_similarity import SIMILARITY_TYPE
@@ -56,7 +56,7 @@ def fuzzy_validate_pydantic(
 
 def fuzzy_validate_mapping(
     d: Any,
-    keys: Sequence[str] | KeysDict,
+    keys: KeysLike,
     /,
     *,
     similarity_algo: (
@@ -110,7 +110,6 @@ def fuzzy_validate_mapping(
     # Try converting to dictionary
     try:
         if isinstance(d, str):
-            # First try to_json for JSON strings and code blocks
             try:
                 json_result = extract_json(
                     d, fuzzy_parse=True, return_one_if_single=True

lionagi/ln/fuzzy/_string_similarity.py

@@ -2,11 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass
-from difflib import SequenceMatcher
-from itertools import product
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 __all__ = ("string_similarity",)
 
@@ -157,6 +159,8 @@ def levenshtein_distance(a: str, b: str) -> int:
         int: Minimum number of single-character edits needed to change one
              string into the other
     """
+    from itertools import product
+
     if not a:
         return len(b)
     if not b:
@@ -213,6 +217,8 @@ def sequence_matcher_similarity(s1: str, s2: str) -> float:
     Returns:
         float: Similarity score between 0 and 1
     """
+    from difflib import SequenceMatcher
+
     return SequenceMatcher(None, s1, s2).ratio()
 
 
@@ -249,7 +255,7 @@ class MatchResult:
 
 def string_similarity(
     word: str,
-    correct_words: Sequence[str],
+    correct_words: "Sequence[str]",
     algorithm: SIMILARITY_TYPE | Callable[[str, str], float] = "jaro_winkler",
     threshold: float = 0.0,
     case_sensitive: bool = False,

lionagi/ln/fuzzy/_to_dict.py

@@ -9,10 +9,6 @@ from typing import Any, Literal
 
 from ._fuzzy_json import fuzzy_json
 
-# ----------------------------
-# Helpers (small, tight, local)
-# ----------------------------
-
 
 def _is_na(obj: Any) -> bool:
     """None / Pydantic undefined sentinels -> treat as NA."""
@@ -67,7 +63,7 @@ def _parse_str(
 def _object_to_mapping_like(
     obj: Any,
     *,
-    use_model_dump: bool,
+    prioritize_model_dump: bool = True,
     **kwargs: Any,
 ) -> Mapping | dict | Any:
     """
@@ -80,11 +76,11 @@ def _object_to_mapping_like(
       5) dict(obj)
     """
     # 1) Pydantic v2
-    if use_model_dump and hasattr(obj, "model_dump"):
+    if prioritize_model_dump and hasattr(obj, "model_dump"):
         return obj.model_dump(**kwargs)
 
     # 2) Common methods
-    for name in ("to_dict", "dict", "to_json", "json"):
+    for name in ("to_dict", "dict", "to_json", "json", "model_dump"):
         if hasattr(obj, name):
             res = getattr(obj, name)(**kwargs)
             return json.loads(res) if isinstance(res, str) else res
@@ -118,7 +114,7 @@ def _preprocess_recursive(
     max_depth: int,
     recursive_custom_types: bool,
     str_parse_opts: dict[str, Any],
-    use_model_dump: bool,
+    prioritize_model_dump: bool,
 ) -> Any:
     """
     Recursively process nested structures:
@@ -145,7 +141,7 @@ def _preprocess_recursive(
             max_depth=max_depth,
             recursive_custom_types=recursive_custom_types,
             str_parse_opts=str_parse_opts,
-            use_model_dump=use_model_dump,
+            prioritize_model_dump=prioritize_model_dump,
         )
 
     # Dict-like
@@ -158,7 +154,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
             for k, v in obj.items()
         }
@@ -172,7 +168,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
             for v in obj
         ]
@@ -198,7 +194,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
         except Exception:
             return obj
@@ -207,7 +203,7 @@ def _preprocess_recursive(
     if recursive_custom_types:
         with contextlib.suppress(Exception):
             mapped = _object_to_mapping_like(
-                obj, use_model_dump=use_model_dump
+                obj, prioritize_model_dump=prioritize_model_dump
             )
             return _preprocess_recursive(
                 mapped,
@@ -215,7 +211,7 @@ def _preprocess_recursive(
                 max_depth=max_depth,
                 recursive_custom_types=recursive_custom_types,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
 
     return obj
@@ -232,7 +228,7 @@ def _convert_top_level_to_dict(
     fuzzy_parse: bool,
     str_type: Literal["json", "xml"] | None,
     parser: Callable[[str], Any] | None,
-    use_model_dump: bool,
+    prioritize_model_dump: bool,
     use_enum_values: bool,
     **kwargs: Any,
 ) -> dict[str, Any]:
@@ -273,7 +269,7 @@ def _convert_top_level_to_dict(
         # faithfully following your previous "non-Sequence -> model path" behavior.
         if not isinstance(obj, Sequence):
             converted = _object_to_mapping_like(
-                obj, use_model_dump=use_model_dump, **kwargs
+                obj, prioritize_model_dump=prioritize_model_dump, **kwargs
             )
             # If conversion returned a string, try to parse JSON to mapping; else pass-through
             if isinstance(converted, str):
@@ -321,7 +317,7 @@ def to_dict(
     input_: Any,
     /,
     *,
-    use_model_dump: bool = True,
+    prioritize_model_dump: bool = True,
     fuzzy_parse: bool = False,
     suppress: bool = False,
     str_type: Literal["json", "xml"] | None = "json",
@@ -330,12 +326,16 @@ def to_dict(
     max_recursive_depth: int | None = None,
     recursive_python_only: bool = True,
     use_enum_values: bool = False,
+    use_model_dump: bool | None = None,  # deprecated
     **kwargs: Any,
 ) -> dict[str, Any]:
     """
     Convert various input types to a dictionary, with optional recursive processing.
     Semantics preserved from original implementation.
     """
+    if use_model_dump is not None:
+        prioritize_model_dump = use_model_dump
+
     try:
         # Clamp recursion depth (match your constraints)
         if not isinstance(max_recursive_depth, int):
@@ -368,7 +368,7 @@ def to_dict(
                 max_depth=max_depth,
                 recursive_custom_types=not recursive_python_only,
                 str_parse_opts=str_parse_opts,
-                use_model_dump=use_model_dump,
+                prioritize_model_dump=prioritize_model_dump,
             )
 
         # Final top-level conversion
@@ -377,7 +377,7 @@ def to_dict(
             fuzzy_parse=fuzzy_parse,
             str_type=str_type,
             parser=parser,
-            use_model_dump=use_model_dump,
+            prioritize_model_dump=prioritize_model_dump,
             use_enum_values=use_enum_values,
             **kwargs,
         )

lionagi/ln/types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from enum import Enum as _Enum
 from typing import Any, ClassVar, Final, Literal, TypeVar, Union
@@ -22,6 +23,7 @@ __all__ = (
     "not_sentinel",
     "Params",
     "DataClass",
+    "KeysLike",
 )
 
 T = TypeVar("T")
@@ -236,6 +238,16 @@ class Params:
                 data[k] = v
         return data
 
+    def __hash__(self) -> int:
+        from ._hash import hash_dict
+
+        return hash_dict(self.to_dict())
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Params):
+            return False
+        return hash(self) == hash(other)
+
 
 @dataclass(slots=True)
 class DataClass:
@@ -297,3 +309,6 @@ class DataClass:
         if value is None and cls._none_as_sentinel:
             return True
         return is_sentinel(value)
+
+
+KeysLike = Sequence[str] | KeysDict

lionagi/operations/operate/operate.py

@@ -12,6 +12,7 @@ from lionagi.models import FieldModel, ModelParams
 from lionagi.protocols.operatives.step import Operative, Step
 from lionagi.protocols.types import Instruction, Progression, SenderRecipient
 from lionagi.service.imodel import iModel
+from lionagi.session.branch import AlcallParams
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch, ToolRef
@@ -64,10 +65,8 @@ async def operate(
     return_operative: bool = False,
     actions: bool = False,
     reason: bool = False,
-    action_kwargs: dict = None,
-    action_strategy: Literal[
-        "sequential", "concurrent", "batch"
-    ] = "concurrent",
+    call_params: AlcallParams = None,
+    action_strategy: Literal["sequential", "concurrent"] = "concurrent",
     verbose_action: bool = False,
     field_models: list[FieldModel] = None,
     exclude_fields: list | dict | None = None,
@@ -191,17 +190,14 @@ async def operate(
         getattr(response_model, "action_required", None) is True
         and getattr(response_model, "action_requests", None) is not None
     ):
-        action_kwargs = action_kwargs or {}
-        action_kwargs["strategy"] = (
-            instruct.action_strategy
-            if instruct.action_strategy
-            else action_kwargs.get("strategy", "concurrent")
+        action_strategy = (
+            action_strategy or instruct.action_strategy or "concurrent"
         )
-
         action_response_models = await branch.act(
             response_model.action_requests,
+            strategy=action_strategy,
             verbose_action=verbose_action,
-            **action_kwargs,
+            call_params=call_params,
         )
         # Possibly refine the operative with the tool outputs
         operative = Step.respond_operative(