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

lionagi/core/session/session.py

@@ -1,14 +1,14 @@
 from collections import deque
 from typing import Tuple
 
-from lionagi.libs.sys_util import PATH_TYPE
+from pathlib import Path
 from lionagi.libs import BaseService, convert, dataframe
 
-from lionagi.core.schema import TOOL_TYPE, Tool, DataLogger
-from lionagi.core.tool import ToolManager
-from lionagi.core.mail import MailManager
-from lionagi.core.messages import System, Instruction
-from lionagi.core.branch import Branch
+from lionagi.core.generic import DataLogger
+from lionagi.core.tool import ToolManager, Tool, TOOL_TYPE
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.messages.schema import System, Instruction
+from lionagi.core.branch.branch import Branch
 from lionagi.core.flow.polyflow import PolyChat
 
 
@@ -41,7 +41,7 @@ class Session:
         tool_manager: ToolManager | None = None,
         messages: dataframe.ln_DataFrame | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,
+        persist_path: Path | str | None = None,
     ):
         """Initialize a new session with optional configuration for managing conversations.
 
@@ -226,7 +226,7 @@ class Session:
     @classmethod
     def from_csv(
         cls,
-        filepath: PATH_TYPE,
+        filepath: Path | str,
         system: dict | list | System | None = None,
         sender: str | None = None,
         llmconfig: dict[str, str | int | dict] | None = None,
@@ -272,7 +272,7 @@ class Session:
     @classmethod
     def from_json(
         cls,
-        filepath: PATH_TYPE,
+        filepath: Path | str,
         system: dict | list | System | None = None,
         sender: str | None = None,
         llmconfig: dict[str, str | int | dict] | None = None,
@@ -852,8 +852,8 @@ class Session:
 
     def take_branch(self, branch):
         self.branches[branch.branch_name] = branch
-        self.mail_manager.sources[branch.branch_name] = branch
-        self.mail_manager.mails[branch.branch_name] = {}
+        self.mail_manager.sources[branch.id_] = branch
+        self.mail_manager.mails[branch.id_] = {}
 
     def collect(self, from_: str | Branch | list[str | Branch] | None = None):
         """
@@ -872,16 +872,17 @@ class Session:
                 >>> session.collect()  # Collects from all branches
         """
         if from_ is None:
-            for branch in self.branches.keys():
-                self.mail_manager.collect(branch)
+            for branch in self.branches.values():
+                self.mail_manager.collect(branch.id_)
         else:
             if not isinstance(from_, list):
-                from_ = convert.to_list(from_)
+                from_ = [from_]
             for branch in from_:
-                if isinstance(branch, Branch):
-                    branch = branch.name
                 if isinstance(branch, str):
-                    self.mail_manager.collect(branch)
+                    branch = self.branches[branch]
+                    self.mail_manager.collect(branch.id_)
+                elif isinstance(branch, Branch):
+                    self.mail_manager.collect(branch.id_)
 
     def send(self, to_: str | Branch | list[str | Branch] | None = None):
         """
@@ -900,16 +901,17 @@ class Session:
                 >>> session.send()  # Sends to all branches
         """
         if to_ is None:
-            for branch in self.branches.keys():
-                self.mail_manager.send(branch)
+            for branch in self.branches.values():
+                self.mail_manager.send(branch.id_)
         else:
             if not isinstance(to_, list):
                 to_ = [to_]
             for branch in to_:
-                if isinstance(branch, Branch):
-                    branch = branch.name
                 if isinstance(branch, str):
-                    self.mail_manager.send(branch)
+                    branch = self.branches[branch]
+                    self.mail_manager.send(branch.id_)
+                if isinstance(branch, Branch):
+                    self.mail_manager.send(branch.id_)
 
     def collect_send_all(self, receive_all=False):
         """

lionagi/core/tool/__init__.py

@@ -1,3 +1,5 @@
+from .tool import Tool, TOOL_TYPE
 from .tool_manager import ToolManager, func_to_tool
 
-__all__ = ["ToolManager", "func_to_tool"]
+
+__all__ = ["Tool", "TOOL_TYPE", "ToolManager", "func_to_tool"]

lionagi/core/tool/tool.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from pydantic import field_serializer
+from lionagi.core.generic import Node
+
+
+class Tool(Node):
+    """
+    Represents a tool, extending BaseNode with specific functionalities and configurations.
+
+    Attributes:
+        func: The main function or capability of the tool.
+        schema_: An optional schema defining the structure and constraints of data the tool works with.
+        manual: Optional documentation or manual for using the tool.
+        parser: An optional parser associated with the tool for data processing or interpretation.
+    """
+
+    func: Any
+    schema_: dict | None = None
+    manual: Any | None = None
+    parser: Any | None = None
+
+    @field_serializer("func")
+    def serialize_func(self, func):
+        return func.__name__
+
+
+TOOL_TYPE = bool | Tool | str | list[Tool | str | dict] | dict

lionagi/core/tool/tool_manager.py

@@ -1,9 +1,9 @@
-from typing import Tuple, Any, TypeVar, Callable
-
 import asyncio
 
+from typing import Tuple, Any, TypeVar, Callable
 from lionagi.libs import func_call, convert, ParseUtil
-from lionagi.core.schema import Tool, TOOL_TYPE
+
+from lionagi.core.tool.tool import Tool, TOOL_TYPE
 
 T = TypeVar("T", bound=Tool)
 
@@ -17,7 +17,7 @@ class ToolManager:
     calls.
 
     Attributes:
-            registry (dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
+        registry (dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
     """
 
     registry: dict = {}
@@ -27,10 +27,10 @@ class ToolManager:
         Checks if a tool name already exists in the registry.
 
         Args:
-                name (str): The name of the tool to check.
+            name (str): The name of the tool to check.
 
         Returns:
-                bool: True if the name exists, False otherwise.
+            bool: True if the name exists, False otherwise.
         """
         return name in self.registry
 
@@ -43,10 +43,10 @@ class ToolManager:
         Registers a tool in the registry. Raises a TypeError if the object is not an instance of Tool.
 
         Args:
-                tool (Tool): The tool instance to register.
+            tool (Tool): The tool instance to register.
 
         Raises:
-                TypeError: If the provided object is not an instance of Tool.
+            TypeError: If the provided object is not an instance of Tool.
         """
         if isinstance(tool, Callable):
             tool = func_to_tool(tool)[0]
@@ -60,13 +60,13 @@ class ToolManager:
         Invokes a registered tool's function with the given arguments. Supports both coroutine and regular functions.
 
         Args:
-                func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
+            func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
 
         Returns:
-                Any: The result of the function call.
+            Any: The result of the function call.
 
         Raises:
-                ValueError: If the function name is not registered or if there's an error during function invocation.
+            ValueError: If the function name is not registered or if there's an error during function invocation.
         """
         name, kwargs = func_calls
         if not self.name_existed(name):
@@ -93,13 +93,13 @@ class ToolManager:
         Extracts a function call and arguments from a response dictionary.
 
         Args:
-                response (dict): The response dictionary containing the function call information.
+            response (dict): The response dictionary containing the function call information.
 
         Returns:
-                Tuple[str, dict]: A tuple containing the function name and a dictionary of arguments.
+            Tuple[str, dict]: A tuple containing the function name and a dictionary of arguments.
 
         Raises:
-                ValueError: If the response does not contain valid function call information.
+            ValueError: If the response does not contain valid function call information.
         """
         try:
             func = response["action"][7:]
@@ -118,7 +118,7 @@ class ToolManager:
         Registers multiple tools in the registry.
 
         Args:
-                tools (list[Tool]): A list of tool instances to register.
+            tools (list[Tool]): A list of tool instances to register.
         """
         func_call.lcall(tools, self._register_tool)
 
@@ -127,7 +127,7 @@ class ToolManager:
         Generates a list of schemas for all registered tools.
 
         Returns:
-                list[dict[str, Any]]: A list of tool schemas.
+            list[dict[str, Any]]: A list of tool schemas.
 
         """
         return [tool.schema_ for tool in self.registry.values()]
@@ -137,14 +137,14 @@ class ToolManager:
         Parses tool information and generates a dictionary for tool invocation.
 
         Args:
-                tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
-                **kwargs: Additional keyword arguments.
+            tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-                dict: A dictionary containing tool schema information and any additional keyword arguments.
+            dict: A dictionary containing tool schema information and any additional keyword arguments.
 
         Raises:
-                ValueError: If a tool name is provided that is not registered.
+            ValueError: If a tool name is provided that is not registered.
         """
 
         def tool_check(tool):
@@ -154,7 +154,7 @@ class ToolManager:
                 return tool.schema_
             elif isinstance(tool, str):
                 if self.name_existed(tool):
-                    tool = self.registry[tool]
+                    tool: Tool = self.registry[tool]
                     return tool.schema_
                 else:
                     raise ValueError(f"Function {tool} is not registered.")
@@ -190,66 +190,66 @@ def func_to_tool(
     objects with structured metadata.
 
     Args:
-            func_ (Callable): The function to be transformed into a Tool object. This
-                                              function should have a docstring that follows the
-                                              specified docstring style for accurate schema generation.
-            parser (Optional[Any]): An optional parser object associated with the Tool.
-                                                            This parameter is currently not utilized in the
-                                                            transformation process but is included for future
-                                                            compatibility and extension purposes.
-            docstring_style (str): The format of the docstring to be parsed, indicating
-                                                       the convention used in the function's docstring.
-                                                       Supports 'google' for Google-style docstrings and
-                                                       'reST' for reStructuredText-style docstrings. The
-                                                       chosen style affects how the docstring is parsed and
-                                                       how the schema is generated.
+        func_ (Callable): The function to be transformed into a Tool object. This
+            function should have a docstring that follows the
+            specified docstring style for accurate schema generation.
+        parser (Optional[Any]): An optional parser object associated with the Tool.
+                  This parameter is currently not utilized in the
+                  transformation process but is included for future
+                  compatibility and extension purposes.
+        docstring_style (str): The format of the docstring to be parsed, indicating
+                 the convention used in the function's docstring.
+                 Supports 'google' for Google-style docstrings and
+                 'reST' for reStructuredText-style docstrings. The
+                 chosen style affects how the docstring is parsed and
+                 how the schema is generated.
 
     Returns:
-            Tool: An object representing the original function wrapped as a Tool, along
-                      with its generated schema. This Tool object can be used in systems that
-                      require detailed metadata about functions, facilitating tasks such as
-                      automatic documentation generation, user interface creation, or
-                      integration with other software tools.
+        Tool: An object representing the original function wrapped as a Tool, along
+            with its generated schema. This Tool object can be used in systems that
+            require detailed metadata about functions, facilitating tasks such as
+            automatic documentation generation, user interface creation, or
+            integration with other software tools.
 
     Examples:
-            >>> def example_function_google(param1: int, param2: str) -> bool:
-            ...     '''
-            ...     An example function using Google style docstrings.
-            ...
-            ...     Args:
-            ...         param1 (int): The first parameter, demonstrating an integer input_.
-            ...         param2 (str): The second parameter, demonstrating a string input_.
-            ...
-            ...     Returns:
-            ...         bool: A boolean value, illustrating the return type.
-            ...     '''
-            ...     return True
-            ...
-            >>> tool_google = func_to_tool(example_function_google, docstring_style='google')
-            >>> print(isinstance(tool_google, Tool))
-            True
-
-            >>> def example_function_reST(param1: int, param2: str) -> bool:
-            ...     '''
-            ...     An example function using reStructuredText (reST) style docstrings.
-            ...
-            ...     :param param1: The first parameter, demonstrating an integer input_.
-            ...     :type param1: int
-            ...     :param param2: The second parameter, demonstrating a string input_.
-            ...     :type param2: str
-            ...     :returns: A boolean value, illustrating the return type.
-            ...     :rtype: bool
-            ...     '''
-            ...     return True
-            ...
-            >>> tool_reST = func_to_tool(example_function_reST, docstring_style='reST')
-            >>> print(isinstance(tool_reST, Tool))
-            True
+        >>> def example_function_google(param1: int, param2: str) -> bool:
+        ...     '''
+        ...     An example function using Google style docstrings.
+        ...
+        ...     Args:
+        ...         param1 (int): The first parameter, demonstrating an integer input_.
+        ...         param2 (str): The second parameter, demonstrating a string input_.
+        ...
+        ...     Returns:
+        ...         bool: A boolean value, illustrating the return type.
+        ...     '''
+        ...     return True
+        ...
+        >>> tool_google = func_to_tool(example_function_google, docstring_style='google')
+        >>> print(isinstance(tool_google, Tool))
+        True
+
+        >>> def example_function_reST(param1: int, param2: str) -> bool:
+        ...     '''
+        ...     An example function using reStructuredText (reST) style docstrings.
+        ...
+        ...     :param param1: The first parameter, demonstrating an integer input_.
+        ...     :type param1: int
+        ...     :param param2: The second parameter, demonstrating a string input_.
+        ...     :type param2: str
+        ...     :returns: A boolean value, illustrating the return type.
+        ...     :rtype: bool
+        ...     '''
+        ...     return True
+        ...
+        >>> tool_reST = func_to_tool(example_function_reST, docstring_style='reST')
+        >>> print(isinstance(tool_reST, Tool))
+        True
 
     Note:
-            The transformation process relies heavily on the accuracy and completeness of
-            the function's docstring. Functions with incomplete or incorrectly formatted
-            docstrings may result in incomplete or inaccurate Tool schemas.
+        The transformation process relies heavily on the accuracy and completeness of
+        the function's docstring. Functions with incomplete or incorrectly formatted
+        docstrings may result in incomplete or inaccurate Tool schemas.
     """
 
     fs = []

lionagi/experimental/directive/evaluator/ast_evaluator.py

@@ -0,0 +1,115 @@
+import ast
+import operator
+
+
+class ASTEvaluator:
+    """
+    Safely evaluates expressions using AST parsing to prevent unsafe operations.
+    """
+
+    def __init__(self):
+        self.allowed_operators = {
+            ast.Eq: operator.eq,
+            ast.NotEq: operator.ne,
+            ast.Lt: operator.lt,
+            ast.LtE: operator.le,
+            ast.Gt: operator.gt,
+            ast.GtE: operator.ge,
+            # Additional operators can be added here as needed
+        }
+
+    def evaluate(self, expression, context):
+        """
+        Evaluate a condition expression within a given context using AST parsing.
+        """
+        try:
+            tree = ast.parse(expression, mode="eval")
+            return self._evaluate_node(tree.body, context)
+        except Exception as e:
+            raise ValueError(f"Failed to evaluate expression: {expression}. Error: {e}")
+
+    def _evaluate_node(self, node, context):
+        if isinstance(node, ast.Compare):
+            left = self._evaluate_node(node.left, context)
+            for operation, comparator in zip(node.ops, node.comparators):
+                op_func = self.allowed_operators.get(type(operation))
+                if not op_func:
+                    raise ValueError(
+                        f"Operation {type(operation).__name__} is not allowed."
+                    )
+                right = self._evaluate_node(comparator, context)
+                if not op_func(left, right):
+                    return False
+            return True
+        elif isinstance(node, ast.Name):
+            return context.get(node.id)
+        elif isinstance(node, ast.Constant):
+            return node.n
+        else:
+            raise ValueError(
+                "Unsupported AST node type encountered in condition evaluation."
+            )
+
+
+class ASTEvaluationEngine:
+    """
+    Executes scripts safely using the SafeEvaluator for expression evaluation.
+    """
+
+    def __init__(self):
+        self.variables = {}
+        self.safe_evaluator = ASTEvaluator()
+        self.functions = {
+            "processData": self.process_data,
+        }
+
+    def process_data(self, data):
+        # Example placeholder function for data processing
+        return data * 2
+
+    def _evaluate_expression(self, expression):
+        """
+        Evaluates expressions within scripts using SafeEvaluator.
+        """
+        # Here, 'self.variables' serves as the context for the evaluation
+        return self.safe_evaluator.evaluate(expression, self.variables)
+
+    def _assign_variable(self, var_name, value):
+        """
+        Assigns a value to a variable within the script's context.
+        """
+        self.variables[var_name] = value
+
+    def _execute_function(self, func_name, arg):
+        """
+        Executes a predefined function with the given argument.
+        """
+        if func_name in self.functions:
+            function = self.functions[func_name]
+            return function(arg)
+        else:
+            raise ValueError(f"Function '{func_name}' is not defined.")
+
+    def execute(self, script):
+        """
+        Parses and executes a script, handling variable assignments and function calls.
+        """
+        tree = ast.parse(script, mode="exec")
+        for stmt in tree.body:
+            if isinstance(stmt, ast.Assign):
+                var_name = stmt.targets[
+                    0
+                ].id  # Assumes single target assignment for simplicity
+                # Convert the AST node back to a string for evaluation
+                value_expr = ast.unparse(stmt.value)
+                value = self._evaluate_expression(value_expr)
+                self._assign_variable(var_name, value)
+            elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+                func_name = stmt.value.func.id
+                arg_expr = ast.unparse(stmt.value.args[0])
+                arg = self._evaluate_expression(arg_expr)
+                self._execute_function(func_name, arg)
+            else:
+                raise ValueError(
+                    "Unsupported statement type encountered in script execution."
+                )