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

lionagi/operatives/strategies/params.py

@@ -1,151 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any, Literal
-
-from pydantic import Field, field_validator, model_validator
-
-from lionagi.operatives.instruct.instruct import (
-    LIST_INSTRUCT_FIELD_MODEL,
-    Instruct,
-)
-from lionagi.operatives.types import FieldModel, SchemaModel
-from lionagi.session.session import Branch, Session
-
-
-class RCallParams(SchemaModel):
-    """Parameters for remote function calls."""
-
-    timeout: float = Field(
-        default=60, description="Timeout for remote function call"
-    )
-    max_retries: int = Field(
-        default=3, description="Maximum number of retries"
-    )
-    retry_delay: float = Field(
-        default=0.5, description="Delay between retries"
-    )
-    retry_backoff: float = Field(
-        default=2, description="Backoff factor for retry delay"
-    )
-
-
-class StrategyParams(SchemaModel):
-    """Base parameters for execution strategies."""
-
-    instruct: list[Instruct] | Instruct = Field(
-        ..., description="Instructions to execute"
-    )
-    session: Session | None = Field(
-        default=None, description="Session for managing branches"
-    )
-    branch: Branch | str | None = Field(
-        default=None, description="Branch or branch reference for execution"
-    )
-    verbose: bool = Field(
-        default=True, description="Whether to print execution progress"
-    )
-    execute_kwargs: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Additional keyword arguments for execution",
-    )
-    branch_kwargs: dict[str, Any] = Field(
-        default_factory=dict,
-        description="Keyword arguments for creating new branches",
-    )
-    auto_run: bool = False
-    auto_execute: bool = False
-    instruct_model_field: type[FieldModel] = LIST_INSTRUCT_FIELD_MODEL
-
-    @field_validator("branch_kwargs", mode="before")
-    def _validate_branch_kwargs(cls, v: Any) -> dict:
-        if v is None:
-            return {}
-        if hasattr(v, "to_dict"):
-            return v.to_dict()
-        if isinstance(v, dict):
-            return v
-        raise ValueError("branch_kwargs must be a dictionary or SchemaModel")
-
-    @field_validator("instruct", mode="before")
-    def validate_instructions(cls, v: Any) -> list[Instruct]:
-        """Validate and convert instructions to list format."""
-        if isinstance(v, Instruct):
-            return [v]
-        if isinstance(v, (list, tuple)):
-            if not all(isinstance(i, Instruct) for i in v):
-                raise ValueError("All instructions must be Instruct instances")
-            return list(v)
-        raise ValueError("Instructions must be Instruct or list of Instruct")
-
-    @field_validator("branch", mode="before")
-    def validate_branch(cls, v: Any) -> Branch | str | None:
-        """Validate branch reference."""
-        if v is None or isinstance(v, (Branch, str)):
-            return v
-        raise ValueError("Branch must be a Branch instance or branch ID")
-
-    @field_validator("session", mode="before")
-    def validate_session(cls, v: Any) -> Session | None:
-        """Validate session reference."""
-        if v is None or isinstance(v, Session):
-            return v
-        raise ValueError("Session must be a Session instance")
-
-    @model_validator(mode="after")
-    def _validate_session_branch(self):
-        if self.session is None:
-            self.session = Session()
-        if self.branch is None:
-            self.branch = self.session.new_branch(**self.branch_kwargs)
-        elif isinstance(self.branch, Branch):
-            if self.branch not in self.session.branches:
-                self.session.branches.include(self.branch)
-        elif isinstance(self.branch, str):
-            if self.branch not in self.session.branches:
-                raise ValueError("Branch ID not found in session")
-            self.branch = self.session.branches[self.branch]
-        return self
-
-
-class ChunkStrategyParams(StrategyParams):
-    """Parameters for chunked execution strategies."""
-
-    chunk_size: int = Field(
-        default=5,
-        description="Number of instructions to process in each chunk",
-        gt=0,
-    )
-    rcall_params: RCallParams = Field(default_factory=RCallParams)
-
-    @field_validator("rcall_params", mode="before")
-    def validate_rcall_params(cls, v: dict) -> RCallParams:
-        return RCallParams(**v)
-
-
-class HybridStrategyParams(ChunkStrategyParams):
-    """Parameters for hybrid execution strategies."""
-
-    outer_mode: Literal["concurrent", "sequential"] = Field(
-        ..., description="Execution mode for outer loop"
-    )
-    inner_mode: Literal["concurrent", "sequential"] = Field(
-        ..., description="Execution mode for inner loop"
-    )
-    inner_chunk_size: int | None = Field(
-        default=None, description="Chunk size for inner loop execution", gt=0
-    )
-    inner_rcall_params: RCallParams = Field(default_factory=RCallParams)
-
-    @field_validator("inner_chunk_size", mode="before")
-    def validate_inner_chunk_size(cls, v: Any) -> int | None:
-        if v is None:
-            return None
-        if not isinstance(v, int) or v <= 0:
-            raise ValueError("inner_chunk_size must be a positive integer")
-        return v
-
-    @field_validator("inner_rcall_params", mode="before")
-    def validate_inner_rcall_params(cls, v: dict):
-        return RCallParams(**v)

lionagi/operatives/strategies/sequential.py

@@ -1,27 +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 .base import StrategyExecutor
-
-
-class SequentialExecutor(StrategyExecutor):
-    """Executor that runs instructions sequentially, one after another."""
-
-    async def execute(
-        self, res
-    ) -> tuple[list[Instruct], list[InstructResponse]]:
-        ress = []
-        instructs = (
-            res.instruct_models if hasattr(res, "instruct_models") else []
-        )
-        for idx, item in enumerate(instructs, start=1):
-            if self.params.verbose:
-                print(f"\nExecuting step {idx}/{len(instructs)}")
-            out = await self.execute_branch.instruct(
-                item, **self.params.execute_kwargs
-            )
-            ress.append(InstructResponse(instruct=item, response=out))
-        return instructs, ress

lionagi/operatives/strategies/sequential_chunk.py

@@ -1,93 +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 .base import StrategyExecutor
-from .params import ChunkStrategyParams
-
-
-class SequentialChunkExecutor(StrategyExecutor):
-    """Executor for sequential chunked instruction processing.
-
-    Splits instructions into chunks and processes each chunk one by one.
-    """
-
-    params: ChunkStrategyParams
-    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 = ChunkStrategyParams(**values)
-
-        session = values.get("session", params.session)
-        if not session:
-            raise ValueError(
-                "Session is required for sequential chunk execution"
-            )
-
-        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
-            )
-            if idx and ttl:
-                print(f"\n-----Executing Instruct {idx}/{ttl}-----\n{msg_}")
-            else:
-                print(f"\n-----Executing Instruct-----\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]:
-        responses = []
-        for ins_, idx, ttl in chunk:
-            res = await self._execute_single(ins_, idx, ttl)
-            responses.append(res)
-        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)
-
-        responses = []
-        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)
-            ]
-            chunk_responses = await self._execute_chunk(chunk)
-            responses.extend(chunk_responses)
-
-        return responses

lionagi/operatives/strategies/sequential_concurrent_chunk.py

@@ -1,105 +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.operations.strategies.params import HybridStrategyParams
-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 SequentialConcurrentChunkExecutor(StrategyExecutor):
-    """Sequential-concurrent chunked executor:
-    1. Splits instructions into chunks
-    2. Processes chunks sequentially
-    3. Within each chunk, processes instructions concurrently
-    """
-
-    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 != "sequential"
-            or params.inner_mode != "concurrent"
-        ):
-            raise ValueError(
-                "Requires outer_mode='sequential' and inner_mode='concurrent'"
-            )
-
-        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_}"
-            )
-
-        branch = self.session.split(self.branch)
-        res = await 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 concurrently
-        return await alcall(
-            chunk,
-            self._execute_single,
-            max_workers=self.params.inner_max_workers,
-        )
-
-    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)
-
-        responses = []
-        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)
-            ]
-            chunk_responses = await self._execute_chunk(chunk)
-            responses.extend(chunk_responses)
-
-        return responses

lionagi/operatives/strategies/utils.py

@@ -1,52 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any
-
-from lionagi.operatives.instruct.instruct import Instruct
-from lionagi.session.session import Branch, Session
-from lionagi.utils import alcall
-
-
-async def run_instruct(
-    ins: Instruct,
-    session: Session,
-    branch: Branch,
-    auto_run: bool,
-    verbose: bool = True,
-    **kwargs: Any,
-) -> Any:
-    async def run(ins_):
-        if verbose:
-            msg_ = (
-                ins_.instruction[:100] + "..."
-                if len(ins_.instruction) > 100
-                else ins_.instruction
-            )
-            print(f"\n-----Running instruction-----\n{msg_}")
-        b_ = session.split(branch)
-        return await run_instruct(
-            ins_, session, b_, False, verbose=verbose, **kwargs
-        )
-
-    config = {**ins.model_dump(), **kwargs}
-    res = await branch.operate(**config)
-    branch.msgs.logger.dump()
-    instructs = []
-
-    if hasattr(res, "instruct_models"):
-        instructs = res.instruct_models
-
-    if auto_run is True and instructs:
-        ress = await alcall(instructs, run)
-        response_ = []
-        for res in ress:
-            if isinstance(res, list):
-                response_.extend(res)
-            else:
-                response_.append(res)
-        response_.insert(0, res)
-        return response_
-
-    return res

lionagi/operatives/types.py

@@ -1,72 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .action.function_calling import FunctionCalling
-from .action.manager import ActionManager
-from .action.request_response_model import (
-    ActionRequestModel,
-    ActionResponseModel,
-)
-from .action.tool import FuncTool, FuncToolRef, Tool, ToolRef
-from .forms.base import BaseForm
-from .forms.flow import FlowDefinition, FlowStep
-from .forms.form import Form
-from .forms.report import Report
-from .instruct.base import (
-    ACTIONS_FIELD,
-    CONTEXT_FIELD,
-    GUIDANCE_FIELD,
-    INSTRUCTION_FIELD,
-    REASON_FIELD,
-)
-from .instruct.instruct import (
-    INSTRUCT_FIELD,
-    LIST_INSTRUCT_FIELD_MODEL,
-    Instruct,
-    InstructResponse,
-)
-from .instruct.node import InstructNode
-from .instruct.reason import CONFIDENCE_SCORE_FIELD, REASON_FIELD, Reason
-from .models.field_model import FieldModel
-from .models.model_params import ModelParams
-from .models.note import Note
-from .models.operable_model import OperableModel
-from .models.schema_model import SchemaModel
-from .operative import Operative
-from .step import Step
-
-__all__ = (
-    "ActionManager",
-    "ActionRequestModel",
-    "ActionResponseModel",
-    "BaseForm",
-    "CONFIDENCE_SCORE_FIELD",
-    "CONTEXT_FIELD",
-    "Form",
-    "GUIDANCE_FIELD",
-    "INSTRUCT_FIELD",
-    "INSTRUCTION_FIELD",
-    "Instruct",
-    "InstructNode",
-    "InstructResponse",
-    "LIST_INSTRUCT_FIELD_MODEL",
-    "ModelParams",
-    "Note",
-    "OperableModel",
-    "Operative",
-    "REASON_FIELD",
-    "Reason",
-    "Report",
-    "SchemaModel",
-    "Step",
-    "Tool",
-    "ToolRef",
-    "ACTIONS_FIELD",
-    "FieldModel",
-    "FuncTool",
-    "FuncToolRef",
-    "FunctionCalling",
-    "FlowDefinition",
-    "FlowStep",
-)