lionagi 0.9.19__py3-none-any.whl → 0.10.0__py3-none-any.whl

lionagi/operatives/action/utils.py

@@ -1,147 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import re
-from typing import Any
-
-from pydantic import BaseModel
-
-from lionagi.libs.validate.common_field_validators import (
-    validate_boolean_field,
-    validate_nullable_string_field,
-)
-from lionagi.utils import to_dict, to_json, to_list
-
-from ..models.field_model import FieldModel
-
-function_field_description = (
-    "Name of the function to call from the provided `tool_schemas`. "
-    "If no `tool_schemas` exist, set to None or leave blank. "
-    "Never invent new function names outside what's given."
-)
-
-arguments_field_description = (
-    "Dictionary of arguments for the chosen function. "
-    "Use only argument names/types defined in `tool_schemas`. "
-    "Never introduce extra argument names."
-)
-
-action_required_field_description = (
-    "Whether this step strictly requires performing actions. "
-    "If true, the requests in `action_requests` must be fulfilled, "
-    "assuming `tool_schemas` are available. "
-    "If false or no `tool_schemas` exist, actions are optional."
-)
-
-action_requests_field_description = (
-    "List of actions to be executed when `action_required` is true. "
-    "Each action must align with the available `tool_schemas`. "
-    "Leave empty if no actions are needed."
-)
-
-
-__all__ = (
-    "FUNCTION_FIELD",
-    "ARGUMENTS_FIELD",
-    "ACTION_REQUIRED_FIELD",
-    "parse_action_request",
-)
-
-
-def parse_action_request(content: str | dict) -> list[dict]:
-
-    json_blocks = []
-
-    if isinstance(content, BaseModel):
-        json_blocks = [content.model_dump()]
-
-    elif isinstance(content, str):
-        json_blocks = to_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 = to_list(json_blocks, dropna=True)
-
-        print(json_blocks)
-
-    elif content and isinstance(content, dict):
-        json_blocks = [content]
-
-    if json_blocks and not isinstance(json_blocks, list):
-        json_blocks = [json_blocks]
-
-    out = []
-
-    for i in json_blocks:
-        j = {}
-        if isinstance(i, dict):
-            if "function" in i and isinstance(i["function"], dict):
-                if "name" in i["function"]:
-                    i["function"] = i["function"]["name"]
-            for k, v in i.items():
-                k = (
-                    k.replace("action_", "")
-                    .replace("recipient_", "")
-                    .replace("s", "")
-                )
-                if k in ["name", "function", "recipient"]:
-                    j["function"] = v
-                elif k in ["parameter", "argument", "arg", "param"]:
-                    j["arguments"] = to_dict(
-                        v, str_type="json", fuzzy_parse=True, suppress=True
-                    )
-            if (
-                j
-                and all(key in j for key in ["function", "arguments"])
-                and j["arguments"]
-            ):
-                out.append(j)
-
-    return out
-
-
-def validate_function_name(cls, value: Any) -> str | None:
-    return validate_nullable_string_field(cls, value, strict=False)
-
-
-def validate_arguments(cls, value: Any) -> dict:
-    return to_dict(
-        value,
-        fuzzy_parse=True,
-        suppress=True,
-        recursive=True,
-    )
-
-
-FUNCTION_FIELD = FieldModel(
-    name="function",
-    default=None,
-    annotation=str | None,
-    title="Function",
-    description=function_field_description,
-    examples=["add", "multiply", "divide"],
-    validator=validate_function_name,
-)
-
-ARGUMENTS_FIELD = FieldModel(
-    name="arguments",
-    annotation=dict | None,
-    default_factory=dict,
-    title="Action Arguments",
-    description=arguments_field_description,
-    examples=[{"num1": 1, "num2": 2}, {"x": "hello", "y": "world"}],
-    validator=validate_arguments,
-    validator_kwargs={"mode": "before"},
-)
-
-ACTION_REQUIRED_FIELD = FieldModel(
-    name="action_required",
-    annotation=bool,
-    default=False,
-    title="Action Required",
-    description=action_required_field_description,
-    validator=lambda cls, v: validate_boolean_field(cls, v, False),
-    validator_kwargs={"mode": "before"},
-)

lionagi/operatives/instruct/__init__.py

@@ -1,3 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0

lionagi/operatives/instruct/base.py

@@ -1,81 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""deprecated"""
-
-from pydantic import JsonValue
-
-from lionagi.libs.validate.common_field_validators import (
-    validate_boolean_field,
-    validate_nullable_jsonvalue_field,
-)
-
-from ..models.field_model import FieldModel
-from .prompts import (
-    actions_field_description,
-    context_field_description,
-    guidance_field_description,
-    instruction_field_description,
-    reason_field_description,
-)
-
-__all__ = (
-    "INSTRUCTION_FIELD",
-    "GUIDANCE_FIELD",
-    "CONTEXT_FIELD",
-    "REASON_FIELD",
-    "ACTIONS_FIELD",
-)
-
-
-# Field Models
-INSTRUCTION_FIELD = FieldModel(
-    name="instruction",
-    annotation=JsonValue | None,
-    default=None,
-    title="Primary Instruction",
-    description=instruction_field_description,
-    validator=validate_nullable_jsonvalue_field,
-    validator_kwargs={"mode": "before"},
-)
-
-GUIDANCE_FIELD = FieldModel(
-    name="guidance",
-    annotation=JsonValue | None,
-    default=None,
-    title="Execution Guidance",
-    description=guidance_field_description,
-)
-
-CONTEXT_FIELD = FieldModel(
-    name="context",
-    annotation=JsonValue | None,
-    default=None,
-    title="Task Context",
-    description=context_field_description,
-)
-
-REASON_FIELD = FieldModel(
-    name="reason",
-    annotation=bool,
-    default=False,
-    title="Include Reasoning",
-    description=reason_field_description,
-    validator=lambda cls, value: validate_boolean_field(
-        cls, value, default=False
-    ),
-    validator_kwargs={"mode": "before"},
-)
-
-ACTIONS_FIELD = FieldModel(
-    name="actions",
-    annotation=bool,
-    default=False,
-    title="Require Actions",
-    description=actions_field_description,
-    validator=lambda cls, value: validate_boolean_field(
-        cls, value, default=False
-    ),
-    validator_kwargs={"mode": "before"},
-)

lionagi/operatives/instruct/instruct_collection.py

@@ -1,52 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from functools import lru_cache
-
-from pydantic import BaseModel
-
-from ..models.model_params import ModelParams
-from .instruct import INSTRUCT_FIELD, Instruct
-from .node import InstructNode
-
-__all__ = ("InstructCollection",)
-
-
-class InstructCollection(BaseModel):
-
-    @property
-    def instruct_models(self) -> list[Instruct]:
-        fields = []
-        for field in self.model_fields:
-            if field.startswith("instruct_"):
-                fields.append(field)
-        return [getattr(self, field) for field in fields]
-
-    @classmethod
-    def create_model_params(
-        cls, num_instructs: int = 3, **kwargs
-    ) -> ModelParams:
-        return create_instruct_collection_model_params(
-            cls, num_instructs, **kwargs
-        )
-
-    def to_instruct_nodes(self) -> list[InstructNode]:
-        return [
-            InstructNode(instruct=instruct)
-            for instruct in self.instruct_models
-        ]
-
-
-@lru_cache
-def create_instruct_collection_model_params(
-    base_type: type[BaseModel], num_instructs: int = 3, **kwargs
-) -> ModelParams:
-    model_params = ModelParams(**kwargs)
-    for i in range(num_instructs):
-        field = INSTRUCT_FIELD.model_copy()
-        field.name = f"instruct_{i}"
-        model_params.field_models.append(field)
-
-    model_params.base_type = base_type
-    return model_params

lionagi/operatives/instruct/node.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.protocols.types import Node
-
-from .instruct import INSTRUCT_FIELD, Instruct
-
-__all__ = ("InstructNode",)
-
-
-class InstructNode(Node):
-    instruct: Instruct | None = INSTRUCT_FIELD.field_info

lionagi/operatives/instruct/prompts.py

@@ -1,51 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""deprecated"""
-
-instruction_field_description = (
-    "A clear, actionable task definition. Specify:\n"
-    "1) The primary goal or objective\n"
-    "2) Key success criteria or constraints\n"
-    "\n"
-    "Guidelines:\n"
-    "- Start with a direct action verb (e.g., 'Analyze', 'Generate', 'Create')\n"
-    "- Include scope, boundaries, or constraints\n"
-    "- Provide success criteria if relevant\n"
-    "- For complex tasks, break them into logical steps"
-)
-
-guidance_field_description = (
-    "Strategic direction and constraints for executing the task. "
-    "Include:\n"
-    "1) Preferred methods or frameworks\n"
-    "2) Quality benchmarks (e.g., speed, clarity)\n"
-    "3) Resource or environmental constraints\n"
-    "4) Relevant compliance or standards\n"
-    "Use None if no special guidance."
-)
-
-context_field_description = (
-    "Background information and current-state data needed for the task. "
-    "Should be:\n"
-    "1) Directly relevant\n"
-    "2) Sufficient to perform the task\n"
-    "3) Free of extraneous detail\n"
-    "Include environment, prior outcomes, system states, or dependencies. "
-    "Use None if no additional context is needed."
-)
-
-reason_field_description = (
-    "Include a thoughtful explanation of decisions, trade-offs, "
-    "and insights. Encourage deeper introspection on why certain "
-    "choices were made, potential alternatives, and how confidence "
-    "was shaped. If not needed, set to None."
-)
-
-actions_field_description = (
-    "Controls execution mode. "
-    "True: Execute specified actions. "
-    "False: Analysis/recommendations only. "
-    "None: Contextual execution."
-)

lionagi/operatives/manager.py

@@ -1,9 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-
-class OperativeManager:
-
-    def __init__(self):
-        self.registry = {}

lionagi/operatives/models/__init__.py

@@ -1,3 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0

lionagi/operatives/strategies/__init__.py

@@ -1,3 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0

lionagi/operatives/strategies/base.py

@@ -1,56 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import ClassVar
-
-from pydantic import BaseModel, model_validator
-
-from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
-from lionagi.session.session import Branch, Session
-
-from .params import StrategyParams
-
-
-class StrategyExecutor(BaseModel):
-    """Base class for different execution strategies.
-
-    Each concrete executor should implement `execute()` to run instructions
-    according to a specific strategy (e.g., sequential, concurrent, chunked).
-    """
-
-    session: Session = None
-    branch: Branch = None
-    execute_branch: Branch = None
-    params: StrategyParams = None
-    params_cls: ClassVar[type[StrategyParams]] = StrategyParams
-
-    @model_validator(mode="before")
-    def validate_execution_config(cls, values: dict) -> dict:
-        params_cls = values.get("params_cls", cls.params_cls)
-        params = values.get("params", None)
-
-        if isinstance(params, dict):
-            params = params_cls(**params)
-        if not isinstance(params, StrategyParams):
-            params = params_cls(**values)
-
-        session: Session = values.get("session", params.session)
-        branch = values.get("branch", params.branch)
-        execute_branch = values.get("execute_branch", None) or session.split(
-            branch
-        )
-
-        return {
-            "params": params,
-            "session": session,
-            "branch": branch,
-            "execute_branch": execute_branch,
-            "params_cls": params_cls,
-        }
-
-    async def execute(
-        self, res
-    ) -> tuple[list[Instruct], list[InstructResponse]]:
-        """Run the instructions based on the strategy implemented by subclasses."""
-        raise NotImplementedError

lionagi/operatives/strategies/concurrent.py

@@ -1,75 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
-from lionagi.session.session import Branch
-from lionagi.utils import alcall, to_list
-
-from .base import StrategyExecutor
-
-
-class ConcurrentExecutor(StrategyExecutor):
-    """Executor for concurrent instruction processing.
-
-    Runs each instruction in parallel without chunking.
-    """
-
-    async def execute_instruct(
-        self, ins: Instruct, branch: Branch, auto_run: bool, **kwargs
-    ):
-        async def run(ins_):
-            if self.params.verbose:
-                print(f"\n-----Running sub-instruction-----\n{ins_.msg}")
-            b_ = self.session.split(branch)
-            return await self.execute_instruct(ins_, b_, False, **kwargs)
-
-        config = {**ins.model_dump(), **kwargs}
-        res = await branch.instruct(**config)
-        branch.msgs.logger.dump()
-        instructs = (
-            res.instruct_models if hasattr(res, "instruct_models") else []
-        )
-
-        if auto_run and instructs:
-            ress = await alcall(instructs, run)
-            response_ = []
-            for r in ress:
-                if isinstance(r, list):
-                    response_.extend(r)
-                else:
-                    response_.append(r)
-            response_.insert(0, res)
-            return response_
-        return res
-
-    async def instruct_concurrent_single(
-        self, ins_: Instruct, execute_branch: Branch
-    ) -> InstructResponse:
-        if self.params.verbose:
-            print(f"\n-----Running instruction-----\n{ins_.msg}")
-        b_ = self.session.split(execute_branch)
-        response = await self.execute_instruct(
-            ins_, b_, self.params.auto_run, **self.params.execute_kwargs
-        )
-        return InstructResponse(instruct=ins_, response=response)
-
-    async def execute(
-        self, res
-    ) -> tuple[list[Instruct], list[InstructResponse]]:
-        async with self.session.branches:
-            response_ = []
-            instructs = []
-            if hasattr(res, "instruct_models"):
-                instructs: list[Instruct] = res.instruct_models
-                ress = await alcall(
-                    instructs,
-                    self.instruct_concurrent_single,
-                    execute_branch=self.execute_branch,
-                )
-                ress = to_list(ress, dropna=True, flatten=True)
-                response_ = [r for r in ress if not isinstance(r, (str, dict))]
-                response_ = to_list(
-                    response_, unique=True, dropna=True, flatten=True
-                )
-            return instructs, response_

lionagi/operatives/strategies/concurrent_chunk.py

@@ -1,46 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import ClassVar
-
-from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
-from lionagi.utils import bcall, to_list
-
-from .concurrent import ConcurrentExecutor
-from .params import ChunkStrategyParams
-
-
-class ConcurrentChunkExecutor(ConcurrentExecutor):
-    """Executor for concurrent chunked instruction processing.
-
-    Breaks instructions into chunks and executes each chunk concurrently.
-    """
-
-    params: ChunkStrategyParams | None = None
-    params_cls: ClassVar[type[ChunkStrategyParams]] = ChunkStrategyParams
-
-    async def execute(
-        self, res
-    ) -> tuple[list[Instruct], list[InstructResponse]]:
-        async with self.session.branches:
-            instructs = []
-            response_ = []
-            if hasattr(res, "instruct_models"):
-                instructs: list[Instruct] = res.instruct_models
-                ress = []
-                async for chunk_result in await bcall(
-                    instructs,
-                    self.instruct_concurrent_single,
-                    execute_branch=self.execute_branch,
-                    batch_size=self.params.chunk_size,
-                    **self.params.rcall_params.to_dict(),
-                ):
-                    ress.extend(chunk_result)
-
-                ress = to_list(ress, dropna=True, flatten=True)
-                response_ = [r for r in ress if not isinstance(r, (str, dict))]
-                response_ = to_list(
-                    response_, unique=True, dropna=True, flatten=True
-                )
-            return instructs, response_

lionagi/operatives/strategies/concurrent_sequential_chunk.py

@@ -1,108 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pydantic import model_validator
-
-from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
-from lionagi.session.session import Branch, Session
-from lionagi.utils import alcall
-
-from .base import StrategyExecutor
-from .params import HybridStrategyParams
-
-
-class ConcurrentSequentialChunkExecutor(StrategyExecutor):
-    """Concurrent-sequential chunked executor:
-    1. Splits instructions into chunks
-    2. Processes chunks concurrently
-    3. Processes each instruction within a chunk sequentially.
-    """
-
-    params: HybridStrategyParams
-    session: Session
-    branch: Branch
-
-    @model_validator(mode="before")
-    def validate_execution_config(cls, values: dict) -> dict:
-        params = values.get("params", None)
-        if params is None:
-            params = HybridStrategyParams(**values)
-
-        if (
-            params.outer_mode != "concurrent"
-            or params.inner_mode != "sequential"
-        ):
-            raise ValueError(
-                "Requires outer_mode='concurrent' and inner_mode='sequential'"
-            )
-
-        session = values.get("session", params.session)
-        if not session:
-            raise ValueError("Session is required")
-        branch = values.get("branch", params.branch)
-        if isinstance(branch, Branch):
-            if branch not in session.branches:
-                session.branches.include(branch)
-        elif not branch:
-            branch = session.new_branch()
-        elif isinstance(branch, str):
-            branch = session.split(branch)
-        else:
-            raise ValueError("Invalid branch type")
-
-        return {"params": params, "session": session, "branch": branch}
-
-    async def _execute_single(
-        self, ins_: Instruct, idx: int, ttl: int
-    ) -> InstructResponse:
-        if self.params.verbose:
-            msg_ = (
-                (ins_.instruction[:100] + "...")
-                if len(ins_.instruction) > 100
-                else ins_.instruction
-            )
-            print(
-                f"\n-----Executing Instruct {idx}/{ttl}-----\n{msg_}"
-                if ttl
-                else f"\n-----Executing Instruct {idx}-----\n{msg_}"
-            )
-
-        res = await self.branch.instruct(ins_, **self.params.execute_kwargs)
-        return InstructResponse(instruct=ins_, response=res)
-
-    async def _execute_chunk(
-        self, chunk: list[tuple[Instruct, int, int]]
-    ) -> list[InstructResponse]:
-        # Each chunk sequential
-        branch = self.session.split(self.branch)
-        responses = []
-        for ins_, idx, ttl in chunk:
-            r = await self._execute_single(ins_, idx, ttl)
-            responses.append(r)
-        return responses
-
-    async def execute(self) -> list[InstructResponse]:
-        instructions = self.params.instruct
-        chunk_size = self.params.chunk_size
-        total = len(instructions)
-
-        if total <= chunk_size:
-            chunk = [(ins, i + 1, total) for i, ins in enumerate(instructions)]
-            return await self._execute_chunk(chunk)
-
-        chunks = []
-        for start in range(0, total, chunk_size):
-            end = min(start + chunk_size, total)
-            chunk = [
-                (instructions[i], i + 1, total) for i in range(start, end)
-            ]
-            chunks.append(chunk)
-
-        chunk_responses = await alcall(
-            chunks, self._execute_chunk, max_workers=self.params.max_workers
-        )
-        responses = []
-        for c in chunk_responses:
-            responses.extend(c)
-        return responses