lionagi 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/operations/plan/plan.py

@@ -2,16 +2,19 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.core.typing import ID, Any, BaseModel, Literal
-from lionagi.libs.func.types import alcall
-from lionagi.libs.parse import to_flat_list
-from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_FIELD_MODEL,
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+from lionagi.operatives.instruct.instruct import (
+    LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,
 )
+from lionagi.protocols.types import ID
+from lionagi.session.branch import Branch
+from lionagi.session.session import Session
+from lionagi.utils import alcall
 
 from ..utils import prepare_instruct, prepare_session
 from .prompt import EXPANSION_PROMPT, PLAN_PROMPT
@@ -165,8 +168,8 @@ async def plan(
 
     # Ensure the correct field model
     field_models: list = kwargs.get("field_models", [])
-    if INSTRUCT_FIELD_MODEL not in field_models:
-        field_models.append(INSTRUCT_FIELD_MODEL)
+    if LIST_INSTRUCT_FIELD_MODEL not in field_models:
+        field_models.append(LIST_INSTRUCT_FIELD_MODEL)
     kwargs["field_models"] = field_models
 
     # Prepare session/branch
@@ -246,7 +249,7 @@ async def plan(
                         )
                         print(f"Instruction: {snippet}")
 
-                    step_response = await execute_branch.instruct(
+                    step_response = await execute_branch._instruct(
                         plan_step, **(execution_kwargs or {})
                     )
                     seq_results.append(
@@ -274,7 +277,7 @@ async def plan(
                         print(f"\n------ Executing step (concurrently) ------")
                         print(f"Instruction: {snippet}")
                     local_branch = session.split(execute_branch)
-                    resp = await local_branch.instruct(
+                    resp = await local_branch._instruct(
                         plan_step, **(execution_kwargs or {})
                     )
                     return InstructResponse(instruct=plan_step, response=resp)
@@ -306,7 +309,7 @@ async def plan(
 
                     async def _execute(plan_step: Instruct):
                         local_branch = session.split(execute_branch)
-                        resp = await local_branch.instruct(
+                        resp = await local_branch._instruct(
                             plan_step, **(execution_kwargs or {})
                         )
                         return InstructResponse(
@@ -352,7 +355,7 @@ async def plan(
                             print(
                                 f"\n--- Executing step (sequential in chunk) ---\nInstruction: {snippet}"
                             )
-                        resp = await local_branch.instruct(
+                        resp = await local_branch._instruct(
                             plan_step, **(execution_kwargs or {})
                         )
                         chunk_result.append(

lionagi/operations/plan/prompt.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 PLAN_PROMPT = """
 Develop a high-level plan containing {num_steps} distinct steps. Each step must:
 1. Represent a clear milestone or phase.

lionagi/operations/select/__init__.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from .select import select
 
 __all__ = ["select"]

lionagi/operations/select/prompt.py

@@ -1 +1,5 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 PROMPT = "Please select up to {max_num_selections} items from the following list {choices}. Provide the selection(s) into appropriate field in format required, and no comments from you"

lionagi/operations/select/select.py

@@ -9,7 +9,7 @@ from typing import Any
 from pydantic import BaseModel, Field
 
 from lionagi import Branch
-from lionagi.protocols.operatives.instruct import Instruct
+from lionagi.operatives.types import Instruct
 
 from .prompt import PROMPT
 from .utils import parse_selection, parse_to_representation

lionagi/operations/select/utils.py

@@ -2,14 +2,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-
 import inspect
 from enum import Enum
 from typing import Any
 
-from lionagi.core.typing import BaseModel, JsonValue
-from lionagi.libs.parse import is_same_dtype
-from lionagi.libs.string_similarity import string_similarity
+from pydantic import BaseModel, JsonValue
+
+from lionagi.libs.validate.string_similarity import string_similarity
+from lionagi.utils import is_same_dtype
 
 
 def parse_to_representation(

lionagi/{strategies → operations/strategies}/base.py

@@ -1,9 +1,13 @@
+# Copyright (c) 2023 - 2024, 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.core.session.types import Branch, Session
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
 
 from .params import StrategyParams
 

lionagi/{strategies → operations/strategies}/concurrent.py

@@ -1,7 +1,10 @@
-from lionagi.core.session.types import Branch
-from lionagi.libs.func.types import alcall
-from lionagi.libs.parse.types import to_list
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+# Copyright (c) 2023 - 2024, 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
 
@@ -22,7 +25,7 @@ class ConcurrentExecutor(StrategyExecutor):
             return await self.execute_instruct(ins_, b_, False, **kwargs)
 
         config = {**ins.model_dump(), **kwargs}
-        res = await branch.instruct(**config)
+        res = await branch._instruct(**config)
         branch.msgs.logger.dump()
         instructs = (
             res.instruct_models if hasattr(res, "instruct_models") else []

lionagi/{strategies → operations/strategies}/concurrent_chunk.py

@@ -1,8 +1,11 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import ClassVar
 
-from lionagi.libs.func.types import bcall
-from lionagi.libs.parse.types import to_list
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.utils import bcall, to_list
 
 from .concurrent import ConcurrentExecutor
 from .params import ChunkStrategyParams

lionagi/{strategies → operations/strategies}/concurrent_sequential_chunk.py

@@ -1,8 +1,12 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.core.session.types import Branch, Session
-from lionagi.libs.func.types import alcall
-from lionagi.protocols.operatives.instruct import Instruct, InstructResponse
+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
@@ -64,7 +68,7 @@ class ConcurrentSequentialChunkExecutor(StrategyExecutor):
                 else f"\n-----Executing Instruct {idx}-----\n{msg_}"
             )
 
-        res = await self.branch.instruct(ins_, **self.params.execute_kwargs)
+        res = await self.branch._instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

lionagi/{strategies → operations/strategies}/params.py

@@ -1,14 +1,18 @@
+# Copyright (c) 2023 - 2024, 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.core.models.types import FieldModel, SchemaModel
-from lionagi.core.session.types import Branch, Session
-from lionagi.libs.func.types import RCallParams
-from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_FIELD_MODEL,
+from lionagi.operatives.instruct.instruct import (
+    LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
 )
+from lionagi.protocols.types import FieldModel, SchemaModel
+from lionagi.session.session import Branch, Session
+from lionagi.utils import RCallParams
 
 
 class StrategyParams(SchemaModel):
@@ -36,7 +40,7 @@ class StrategyParams(SchemaModel):
     )
     auto_run: bool = False
     auto_execute: bool = False
-    instruct_model_field: type[FieldModel] = INSTRUCT_FIELD_MODEL
+    instruct_model_field: type[FieldModel] = LIST_INSTRUCT_FIELD_MODEL
 
     @field_validator("branch_kwargs", mode="before")
     def _validate_branch_kwargs(cls, v: Any) -> dict:

lionagi/{strategies → operations/strategies}/sequential.py

@@ -1,4 +1,8 @@
-from lionagi.fields.instruct import Instruct, InstructResponse
+# Copyright (c) 2023 - 2024, 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
 
@@ -16,7 +20,7 @@ class SequentialExecutor(StrategyExecutor):
         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(
+            out = await self.execute_branch._instruct(
                 item, **self.params.execute_kwargs
             )
             ress.append(InstructResponse(instruct=item, response=out))

lionagi/{strategies → operations/strategies}/sequential_chunk.py

@@ -1,7 +1,11 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.fields.instruct import Instruct, InstructResponse
-from lionagi.session.types import Branch, Session
+from lionagi.operatives.instruct.instruct import Instruct, InstructResponse
+from lionagi.session.session import Branch, Session
 
 from .base import StrategyExecutor
 from .params import ChunkStrategyParams
@@ -56,7 +60,7 @@ class SequentialChunkExecutor(StrategyExecutor):
             else:
                 print(f"\n-----Executing Instruct-----\n{msg_}")
 
-        res = await self.branch.instruct(ins_, **self.params.execute_kwargs)
+        res = await self.branch._instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

lionagi/{strategies → operations/strategies}/sequential_concurrent_chunk.py

@@ -1,9 +1,14 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import model_validator
 
-from lionagi.fields.instruct import Instruct, InstructResponse
-from lionagi.session.types import Branch, Session
+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 ..libs.async_utils import alcall
 from .base import StrategyExecutor
 from .params import HybridStrategyParams
 
@@ -66,7 +71,7 @@ class SequentialConcurrentChunkExecutor(StrategyExecutor):
             )
 
         branch = self.session.split(self.branch)
-        res = await branch.instruct(ins_, **self.params.execute_kwargs)
+        res = await branch._instruct(ins_, **self.params.execute_kwargs)
         return InstructResponse(instruct=ins_, response=res)
 
     async def _execute_chunk(

lionagi/{strategies → operations/strategies}/utils.py

@@ -1,10 +1,13 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any
 
-from lionagi.fields.instruct import Instruct
+from lionagi.operatives.instruct.instruct import Instruct
+from lionagi.session.session import Branch, Session
 from lionagi.utils import alcall
 
-from ..session.types import Branch, Session
-
 
 async def run_instruct(
     ins: Instruct,

lionagi/{core/models/__init__.py → operations/types.py}

@@ -2,4 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .types import *
+from .brainstorm import *
+from .plan import *
+from .select import *

lionagi/operations/utils.py

@@ -1,6 +1,9 @@
-from lionagi.core.session.branch import Branch
-from lionagi.core.session.session import Session
-from lionagi.protocols.operatives.instruct import Instruct
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.operatives.types import Instruct
+from lionagi.session.session import Branch, Session
 
 
 def prepare_session(

lionagi/operatives/action/function_calling.py

@@ -0,0 +1,136 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+from typing import Any, Self
+
+from pydantic import Field, model_validator
+
+from lionagi.protocols.types import Event, EventStatus
+from lionagi.utils import is_coro_func
+
+from .tool import Tool
+
+
+class FunctionCalling(Event):
+    """Handles asynchronous function execution with pre/post processing.
+
+    This class manages function calls with optional preprocessing and
+    postprocessing, handling both synchronous and asynchronous functions.
+    """
+
+    func_tool: Tool = Field(
+        ...,
+        description="Tool instance containing the function to be called",
+        exclude=True,
+    )
+
+    arguments: dict[str, Any] = Field(
+        ..., description="Dictionary of arguments to pass to the function"
+    )
+
+    @model_validator(mode="after")
+    def _validate_strict_tool(self) -> Self:
+        if self.func_tool.strict_func_call is True:
+            if (
+                not set(self.arguments.keys())
+                == self.func_tool.required_fields
+            ):
+                raise ValueError("arguments must match the function schema")
+
+        else:
+            if not self.func_tool.minimum_acceptable_fields.issubset(
+                set(self.arguments.keys())
+            ):
+                raise ValueError("arguments must match the function schema")
+        return self
+
+    @property
+    def function(self):
+        return self.func_tool.function
+
+    async def invoke(self) -> None:
+        """Execute the function call with pre/post processing.
+
+        Handles both synchronous and asynchronous functions, including optional
+        preprocessing of arguments and postprocessing of results.
+        """
+        start = asyncio.get_event_loop().time()
+
+        async def _preprocess(kwargs):
+            if is_coro_func(self.func_tool.preprocessor):
+                return await self.func_tool.preprocessor(
+                    kwargs, **self.func_tool.preprocessor_kwargs
+                )
+            return self.func_tool.preprocessor(
+                kwargs, **self.func_tool.preprocessor_kwargs
+            )
+
+        async def _post_process(arg: Any):
+            if is_coro_func(self.func_tool.postprocessor):
+                return await self.func_tool.postprocessor(
+                    arg, **self.func_tool.postprocessor_kwargs
+                )
+            return self.func_tool.postprocessor(
+                arg, **self.func_tool.postprocessor_kwargs
+            )
+
+        async def _inner() -> Any:
+            """Execute the function with pre/post processing.
+
+            Returns:
+                Function execution result after processing.
+            """
+            response = None
+            if self.func_tool.preprocessor:
+                self.arguments = await _preprocess(self.arguments)
+
+            if is_coro_func(self.func_tool.func_callable):
+                response = await self.func_tool.func_callable(**self.arguments)
+            else:
+                response = self.func_tool.func_callable(**self.arguments)
+
+            if self.func_tool.postprocessor:
+                response = await _post_process(response)
+            return response
+
+        try:
+            response = await _inner()
+            self.execution.duration = asyncio.get_event_loop().time() - start
+            self.execution.status = EventStatus.COMPLETED
+            self.execution.response = response
+        except Exception as e:
+            self.execution.duration = asyncio.get_event_loop().time() - start
+            self.execution.status = EventStatus.FAILED
+            self.execution.error = str(e)
+
+    def __str__(self) -> str:
+        """Returns a string representation of the function call.
+
+        Returns:
+            A string in the format "function_name(arguments)".
+        """
+        return f"{self.func_tool.function}({self.arguments})"
+
+    def __repr__(self) -> str:
+        """Returns a detailed string representation of the function call.
+
+        Returns:
+            A string containing the class name and key attributes.
+        """
+        return (
+            f"FunctionCalling(function={self.func_tool.function}, "
+            f"arguments={self.arguments})"
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert instance to dictionary.
+
+        Returns:
+            dict[str, Any]: Dictionary representation of the instance.
+        """
+        dict_ = super().to_dict()
+        dict_["function"] = self.function
+        dict_["arguments"] = self.arguments
+        return dict_