lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/__init__.py

@@ -1,15 +1,70 @@
 """
-lionagi is an intelligent automation framework.
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
 """
 
 import logging
 from .version import __version__
 from dotenv import load_dotenv
 
-from .core import direct, Branch, Session, func_to_tool
-from .integrations.provider.services import Services
-from .integrations.chunker.chunk import chunk
-from .integrations.loader.load import load
+from lionagi.libs.ln_convert import to_list, to_dict, to_df, to_readable_dict
+from lionagi.libs.ln_func_call import alcall, bcall, lcall, CallDecorator as cd, tcall
+from lionagi.core.collections.abc import Field
+from lionagi.core.collections import progression, flow, pile, iModel
+from lionagi.core.generic import Node, Graph, Tree, Edge
+from lionagi.core.action import func_to_tool
+from lionagi.core.report import Form, Report
+from lionagi.core.session.branch import Branch
+from lionagi.core.session.session import Session
+from lionagi.core.work.worker import work, Worker
+from lionagi.integrations.provider.services import Services
+from lionagi.integrations.chunker.chunk import chunk
+from lionagi.integrations.loader.load import load
+import lionagi.core.director.direct as direct
+
+
+__all__ = [
+    "Field",
+    "progression",
+    "flow",
+    "pile",
+    "iModel",
+    "work",
+    "Worker",
+    "Branch",
+    "Session",
+    "Form",
+    "Report",
+    "Services",
+    "direct",
+    "Node",
+    "Graph",
+    "Tree",
+    "Edge",
+    "chunk",
+    "load",
+    "func_to_tool",
+    "cd",
+    "alcall",
+    "bcall",
+    "to_list",
+    "to_dict",
+    "lcall",
+    "to_df",
+    "tcall",
+    "to_readable_dict",
+]
 
 
 logger = logging.getLogger(__name__)

lionagi/core/__init__.py

@@ -1,26 +1 @@
 from . import *
-
-from .branch.branch import Branch
-from .session.session import Session
-from .generic import (
-    ActionNode,
-    ActionSelection,
-    Condition,
-)
-from .agent.base_agent import BaseAgent
-from .messages.schema import Instruction, System, Response
-from .tool import func_to_tool
-
-
-__all__ = [
-    "ActionNode",
-    "ActionSelection",
-    "Branch",
-    "Condition",
-    "Session",
-    "System",
-    "Instruction",
-    "Response",
-    "BaseAgent",
-    "func_to_tool",
-]

lionagi/core/_setting/_setting.py

@@ -0,0 +1,59 @@
+# TODO
+
+# import csv
+# import json
+# import threading
+# from contextlib import contextmanager
+
+
+# class Settings:
+#     def __init__(self):
+#         self._lock = threading.Lock()
+#         self._config = {}
+#         self._default_service = None
+
+#     def load_from_json(self, file_path):
+#         with self._lock:
+#             with open(file_path, "r") as file:
+#                 self._config = json.load(file)
+
+#     def save_to_json(self, file_path):
+#         with self._lock:
+#             with open(file_path, "w") as file:
+#                 json.dump(self._config, file, indent=4)
+
+#     def load_default_service(self, file_path):
+#         with self._lock:
+#             with open(file_path, "r") as file:
+#                 reader = csv.DictReader(file)
+#                 self._default_service = next(reader)
+
+#     def save_default_service(self, file_path):
+#         with self._lock:
+#             fieldnames = ["provider", "api_key", "rate_limit"]
+#             with open(file_path, "w", newline="") as file:
+#                 writer = csv.DictWriter(file, fieldnames=fieldnames)
+#                 writer.writeheader()
+#                 writer.writerow(self._default_service)
+
+#     @contextmanager
+#     def service_context(self, provider=None, api_key=None, rate_limit=None):
+#         with self._lock:
+#             service_config = {
+#                 "provider": provider or self._default_service["provider"],
+#                 "api_key": api_key or self._default_service["api_key"],
+#                 "rate_limit": rate_limit or self._default_service["rate_limit"],
+#             }
+#             yield service_config
+
+#     def get_config(self, key):
+#         with self._lock:
+#             return self._config.get(key)
+
+#     def set_config(self, key, value):
+#         with self._lock:
+#             self._config[key] = value
+
+
+# # Singleton instance
+# lionagi_settings = Settings()

lionagi/core/action/__init__.py

@@ -0,0 +1,14 @@
+from .function_calling import FunctionCalling
+from .tool import Tool
+from .tool_manager import ToolManager, func_to_tool
+from .node import ActionNode, DirectiveSelection
+
+
+__all__ = [
+    "FunctionCalling",
+    "Tool",
+    "ToolManager",
+    "func_to_tool",
+    "ActionNode",
+    "DirectiveSelection",
+]

lionagi/core/action/function_calling.py

@@ -0,0 +1,136 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""
+This module defines the FunctionCalling class, which facilitates dynamic
+invocation of functions based on various input types. It supports initializing
+function calls from tuples, dictionaries, ActionRequest objects, or JSON strings.
+
+Note:
+    Function Calling object is the only way for AI system to call functions.
+"""
+
+from functools import singledispatchmethod
+from typing import Any, Callable, Dict
+
+from lionagi.libs import ParseUtil
+from lionagi.libs.ln_func_call import call_handler
+from lionagi.core.collections.abc import Actionable
+from lionagi.core.message.action_request import ActionRequest
+
+
+class FunctionCalling(Actionable):
+    """
+    A class for dynamically invoking functions based on various input types,
+    allowing for specification of the function and arguments through multiple
+    formats including tuples, dictionaries, ActionRequests, or JSON strings.
+    """
+
+    def __init__(self, function: Callable, arguments: Dict[str, Any] = None):
+        """
+        Initializes a new instance of FunctionCalling with the given function
+        and optional arguments.
+
+        Args:
+            function (Callable): The function to be called.
+            arguments (Dict[str, Any]): Arguments to pass to the function.
+                Defaults to an empty dictionary.
+        """
+        self.function = function
+        self.arguments = arguments or {}
+
+    @property
+    def func_name(self) -> str:
+        """
+        Returns the name of the function.
+
+        Returns:
+            str: The function's name.
+        """
+        return self.function.__name__
+
+    @singledispatchmethod
+    @classmethod
+    def create(cls, func_call: Any) -> "FunctionCalling":
+        """
+        Creates an instance of FunctionCalling based on the type of input.
+
+        Args:
+            func_call (Any): The function call description, which can be a tuple, dict,
+                ActionRequest, or JSON string.
+
+        Returns:
+            FunctionCalling: An instance of FunctionCalling prepared to invoke
+                the specified function.
+
+        Raises:
+            TypeError: If the input type is not supported.
+        """
+        raise TypeError(f"Unsupported type {type(func_call)}")
+
+    @create.register(tuple)
+    def _(cls, function_calling: tuple) -> "FunctionCalling":
+        if len(function_calling) == 2:
+            return cls(function=function_calling[0], arguments=function_calling[1])
+        else:
+            raise ValueError(f"Invalid function call {function_calling}")
+
+    @create.register(dict)
+    def _(cls, function_calling: Dict[str, Any]) -> "FunctionCalling":
+        if len(function_calling) == 2 and (
+            {"function", "arguments"} <= function_calling.keys()
+        ):
+            return cls.create(
+                (function_calling["function"], function_calling["arguments"])
+            )
+        raise ValueError(f"Invalid function call {function_calling}")
+
+    @create.register(ActionRequest)
+    def _(cls, function_calling: ActionRequest) -> "FunctionCalling":
+        return cls.create((function_calling.function, function_calling.arguments))
+
+    @create.register(str)
+    def _(cls, function_calling: str) -> "FunctionCalling":
+        _call = None
+        try:
+            _call = ParseUtil.fuzzy_parse_json(function_calling)
+        except Exception as e:
+            raise ValueError(f"Invalid function call {function_calling}") from e
+
+        if isinstance(_call, dict):
+            return cls.create(_call)
+        raise ValueError(f"Invalid function call {function_calling}")
+
+    async def invoke(self) -> Any:
+        """
+        Asynchronously invokes the stored function with the provided arguments.
+
+        Returns:
+            Any: The result of the function call.
+        """
+        return await call_handler(self.function, **self.arguments)
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the function call.
+
+        Returns:
+            str: String representation of the function call.
+        """
+        return f"{self.func_name}({self.arguments})"
+
+    def __repr__(self) -> str:
+        return self.__str__()

lionagi/core/action/manual.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/action/node.py

@@ -0,0 +1,109 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from pydantic import Field
+
+from lionagi.core.collections.abc import Actionable
+from lionagi.core.generic.node import Node
+from .tool import Tool
+
+
+class DirectiveSelection(Node, Actionable):
+    """
+    Represents a directive selection node which can be invoked to perform an action.
+
+    Attributes:
+        directive (str): The action to be performed, with a default value of "chat".
+        directive_kwargs (dict): The arguments for the action.
+
+    Methods:
+        invoke(): An asynchronous method to perform the action defined by the directive.
+    """
+
+    directive: str = Field(
+        "chat", description="The action to be performed", alias="action_type"
+    )
+    directive_kwargs: dict = Field(
+        default_factory=dict,
+        description="The arguments for the action",
+        alias="action_arguments",
+    )
+
+    async def invoke(self):
+        """
+        Perform the action defined by the directive.
+
+        This method is intended to be overridden by subclasses to provide specific
+        implementation details for the action.
+        """
+        pass
+
+
+class ActionNode(DirectiveSelection):
+    """
+    Represents an action node that can invoke actions within a branch using tools and instructions.
+
+    Attributes:
+        tools (list[Tool] | Tool | None): The tools to be used in the action.
+        instruction (Node): The instruction for the action.
+
+    Methods:
+        invoke(branch, context=None): An asynchronous method to invoke the action
+                                      within the given branch.
+    """
+
+    tools: list[Tool] | Tool | None = Field(
+        default_factory=list,
+        description="The tools to be used in the action",
+        alias="tool",
+    )
+    instruction: Node = Field(
+        ..., description="The instruction for the action", alias="instruct"
+    )
+
+    async def invoke(self, branch, context=None):
+        """
+        Invoke the action within the given branch.
+
+        Args:
+            branch: The branch in which to perform the action.
+            context: Optional; Additional context for the action.
+
+        Returns:
+            The result of the action, depending on the directive.
+
+        Raises:
+            ValueError: If the directive is not "chat" or "direct".
+        """
+        if self.directive == "chat":
+            return await branch.chat(
+                instruction=self.instruction.instruct,
+                tools=self.tools,
+                **self.directive_kwargs,
+            )
+        elif self.directive == "direct":
+            if self.tools:
+                self.directive_kwargs["allow_action"] = True
+            return await branch.direct(
+                instruction=self.instruction.instruct,
+                context=context,
+                tools=self.tools,
+                **self.directive_kwargs,
+            )
+        else:
+            raise ValueError(
+                'Invalid directive, valid directives are: "chat", "direct"'
+            )

lionagi/core/action/tool.py

@@ -0,0 +1,114 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Callable, Union, List, Dict, Any
+from pydantic import Field, field_serializer
+from lionagi.libs.ln_func_call import call_handler
+from lionagi.core.collections.abc import Actionable
+from lionagi.core.generic.node import Node
+from .function_calling import FunctionCalling
+
+
+class Tool(Node, Actionable):
+    """
+    Class representing a Tool with capabilities for pre-processing, post-processing,
+    and parsing function results.
+
+    Attributes:
+        function (Callable): The callable function or capability of the tool.
+        schema_ (Union[Dict, None]): Schema in OpenAI format.
+        pre_processor (Union[Callable, None]): Function to preprocess input arguments.
+        pre_processor_kwargs (Union[Dict, None]): Keyword arguments for the pre-processor.
+        post_processor (Union[Callable, None]): Function to post-process the result.
+        post_processor_kwargs (Union[Dict, None]): Keyword arguments for the post-processor.
+        parser (Union[Callable, None]): Function to parse the result to a JSON serializable format.
+    """
+
+    function: Callable = Field(
+        ...,
+        description="The callable function or capability of the tool.",
+    )
+
+    schema_: Union[Dict, None] = Field(
+        None,
+        description="Schema in OpenAI format.",
+    )
+
+    pre_processor: Union[Callable, None] = None
+    pre_processor_kwargs: Union[Dict, None] = None
+
+    post_processor: Union[Callable, None] = None
+    post_processor_kwargs: Union[Dict, None] = None
+
+    parser: Union[Callable, None] = None  # Parse result to JSON serializable format
+
+    @field_serializer("function", check_fields=False)
+    def serialize_func(self, func: Callable) -> str:
+        """
+        Serialize the function for storage or transmission.
+
+        Args:
+            func (Callable): The function to serialize.
+
+        Returns:
+            str: The name of the function.
+        """
+        return func.__name__
+
+    @property
+    def name(self) -> str:
+        """
+        Get the name of the function from the schema.
+
+        Returns:
+            str: The name of the function.
+        """
+        return self.schema_["function"]["name"]
+
+    async def invoke(self, kwargs: Dict = {}) -> Any:
+        """
+        Invoke the tool's function with optional pre-processing and post-processing.
+
+        Args:
+            kwargs (Dict): The arguments to pass to the function.
+
+        Returns:
+            Any: The result of the function call.
+        """
+        if self.pre_processor:
+            pre_process_kwargs = self.pre_processor_kwargs or {}
+            kwargs = await call_handler(
+                self.pre_processor(kwargs, **pre_process_kwargs)
+            )
+            if not isinstance(kwargs, dict):
+                raise ValueError("Pre-processor must return a dictionary.")
+
+        func_call_ = FunctionCalling(function=self.function, arguments=kwargs)
+        try:
+            result = await func_call_.invoke()
+        except Exception:
+            return None
+
+        if self.post_processor:
+            post_process_kwargs = self.post_processor_kwargs or {}
+            result = await call_handler(
+                self.post_processor(result, **post_process_kwargs)
+            )
+
+        return result if not self.parser else self.parser(result)
+
+
+TOOL_TYPE = Union[bool, Tool, str, List[Union[Tool, str, Dict]], Dict]