lionagi 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

lionagi/core/generic/edge.py

@@ -1,15 +1,15 @@
 """
-Module for representing conditions and edges between nodes in a graph structure.
+Module for representing conditions and edges between nodes in a graph.
 
-This module provides the base for creating and managing edges that connect nodes
-within a graph. It includes support for conditional edges, allowing the dynamic
-evaluation of connections based on custom logic.
+This module provides the base for creating and managing edges that connect
+nodes within a graph. It includes support for conditional edges, allowing
+the dynamic evaluation of connections based on custom logic.
 """
 
 from typing import Any
 from pydantic import Field, field_validator
-from lionagi.core.generic.component import BaseComponent, BaseNode
-from lionagi.core.generic.condition import Condition
+from .component import BaseComponent
+from .condition import Condition
 
 
 class Edge(BaseComponent):
@@ -19,12 +19,14 @@ class Edge(BaseComponent):
     Attributes:
         head (str): The identifier of the head node of the edge.
         tail (str): The identifier of the tail node of the edge.
-        condition (Optional[Condition]): An optional condition that must be met
+        condition (Condition | None): Optional condition that must be met
             for the edge to be considered active.
-        label (Optional[str]): An optional label for the edge.
+        label (str | None): An optional label for the edge.
+        bundle (bool): A flag indicating if the edge is bundled.
 
     Methods:
-        check_condition: Evaluates if the condition associated with the edge is met.
+        check_condition: Evaluates if the condition is met.
+        string_condition: Retrieves the condition class source code.
     """
 
     head: str = Field(
@@ -37,7 +39,8 @@ class Edge(BaseComponent):
     )
     condition: Condition | None = Field(
         default=None,
-        description="An optional condition that must be met for the edge to be considered active.",
+        description="Optional condition that must be met for the edge "
+                    "to be considered active.",
     )
     label: str | None = Field(
         default=None,
@@ -51,20 +54,19 @@ class Edge(BaseComponent):
     @field_validator("head", "tail", mode="before")
     def _validate_head_tail(cls, value):
         """
-        Validates the head and tail fields to ensure they are valid node identifiers.
+        Validates head and tail fields to ensure valid node identifiers.
 
         Args:
-            value: The value of the field being validated.
-            values: A dictionary of all other values on the model.
-            field: The model field being validated.
+            value (Any): The value of the field being validated.
 
         Returns:
-            The validated value, ensuring it is a valid identifier.
+            str: The validated value, ensuring it is a valid identifier.
 
         Raises:
             ValueError: If the validation fails.
         """
-        if isinstance(value, BaseNode):
+
+        if isinstance(value, BaseComponent):
             return value.id_
         return value
 
@@ -73,7 +75,7 @@ class Edge(BaseComponent):
         Evaluates if the condition associated with the edge is met.
 
         Args:
-            obj (dict[str, Any]): The context object used for condition evaluation.
+            obj (dict[str, Any]): Context for condition evaluation.
 
         Returns:
             bool: True if the condition is met, False otherwise.
@@ -85,11 +87,66 @@ class Edge(BaseComponent):
             raise ValueError("The condition for the edge is not set.")
         return self.condition(obj)
 
-    def __str__(self) -> str:
+    def string_condition(self):
         """
-        Returns a simple string representation of the Relationship.
+        Retrieves the condition class source code as a string.
+
+        This method is useful for serialization and debugging, allowing
+        the condition logic to be inspected or stored in a human-readable
+        format. It employs advanced introspection techniques to locate and
+        extract the exact class definition, handling edge cases like
+        dynamically defined classes or classes defined interactively.
+
+        Returns:
+            str | None: The condition class source code if available.
+                If the condition is None or the source code cannot be
+                located, this method returns None.
+
+        Raises:
+            TypeError: If the condition class source code cannot be found
+                due to the class being defined in a non-standard manner or
+                in the interactive interpreter (__main__ context).
         """
+        if self.condition is None:
+            return
+
+        import inspect, sys
+
+        def new_getfile(object, _old_getfile=inspect.getfile):
+            if not inspect.isclass(object):
+                return _old_getfile(object)
+
+            # Lookup by parent module (as in current inspect)
+            if hasattr(object, "__module__"):
+                object_ = sys.modules.get(object.__module__)
+                if hasattr(object_, "__file__"):
+                    return object_.__file__
+
+            # If parent module is __main__, lookup by methods (NEW)
+            for name, member in inspect.getmembers(object):
+                if (
+                    inspect.isfunction(member)
+                    and object.__qualname__ + "." + member.__name__
+                    == member.__qualname__
+                ):
+                    return inspect.getfile(member)
+            else:
+                raise TypeError("Source for {!r} not found".format(object))
+
+        inspect.getfile = new_getfile
+
+        import inspect
+        from IPython.core.magics.code import extract_symbols
+
+        obj = self.condition.__class__
+        cell_code = "".join(inspect.linecache.getlines(new_getfile(obj)))
+        class_code = extract_symbols(cell_code, obj.__name__)[0][0]
+        return class_code
 
+    def __str__(self) -> str:
+        """
+        Returns a simple string representation of the Edge.
+        """
         return (
             f"Edge (id_={self.id_}, from={self.head}, to={self.tail}, "
             f"label={self.label})"
@@ -97,12 +154,7 @@ class Edge(BaseComponent):
 
     def __repr__(self) -> str:
         """
-        Returns a detailed string representation of the Relationship.
-
-        Examples:
-            >>> edge = Relationship(source_node_id="node1", target_node_id="node2")
-            >>> repr(edge)
-            'Relationship(id_=None, from=node1, to=node2, content=None, metadata=None, label=None)'
+        Returns a detailed string representation of the Edge.
         """
         return (
             f"Edge(id_={self.id_}, from={self.head}, to={self.tail}, "

lionagi/core/graph/graph.py

@@ -92,7 +92,7 @@ class Graph(BaseStructure):
         for node_id, node in self.internal_nodes.items():
             node_info = node.to_dict()
             node_info.pop("id_")
-            node_info.update({"class_name": node.class_name()})
+            node_info.update({"class_name": node.class_name})
             g.add_node(node_id, **node_info)
 
         for _edge in list(self.internal_edges.values()):

lionagi/core/mail/mail_manager.py

@@ -17,10 +17,11 @@ class MailManager:
                     and sender.
     """
 
-    def __init__(self, sources):
+    def __init__(self, sources=None):
         self.sources = {}
         self.mails = {}
-        self.add_sources(sources)
+        if sources:
+            self.add_sources(sources)
         self.execute_stop = False
 
     def add_sources(self, sources):

lionagi/core/session/session.py

@@ -982,4 +982,4 @@ class Session:
         if system:
             self.default_branch.add_message(system=system, sender=sender)
 
-        self.llmconfig = self.default_branch.llmconfig
+        self.llmconfig = self.default_branch.llmconfig

lionagi/core/tool/tool_manager.py

@@ -159,15 +159,16 @@ class ToolManager:
                 else:
                     raise ValueError(f"Function {tool} is not registered.")
 
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self.to_tool_schema_list()}
-            kwargs = tool_kwarg | kwargs
-
-        else:
-            if not isinstance(tools, list):
-                tools = [tools]
-            tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
-            kwargs = tool_kwarg | kwargs
+        if tools:
+            if isinstance(tools, bool):
+                tool_kwarg = {"tools": self.to_tool_schema_list()}
+                kwargs = tool_kwarg | kwargs
+
+            else:
+                if not isinstance(tools, list):
+                    tools = [tools]
+                tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
+                kwargs = tool_kwarg | kwargs
 
         return kwargs
 

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."
+                )

lionagi/experimental/directive/evaluator/base_evaluator.py

@@ -0,0 +1,202 @@
+import ast
+import operator
+from typing import Any, Dict, Tuple, Callable
+
+from lionagi.libs.ln_convert import to_dict
+
+
+class BaseEvaluator:
+    """
+    A class to evaluate mathematical and boolean expressions from strings using Python's AST.
+
+    Attributes:
+        allowed_operators (Dict[type, Any]): A dictionary mapping AST node types to their corresponding Python operator functions.
+        cache (Dict[Tuple[str, Tuple], Any]): A dictionary used to cache the results of evaluated expressions and sub-expressions.
+    """
+
+    def __init__(self) -> None:
+        """Initializes the evaluator with supported operators and an empty cache."""
+        self.allowed_operators: Dict[type, Any] = {
+            ast.Add: operator.add,
+            ast.Sub: operator.sub,
+            ast.Mult: operator.mul,
+            ast.Div: operator.truediv,
+            ast.Pow: operator.pow,
+            ast.Mod: operator.mod,
+            ast.Eq: operator.eq,
+            ast.NotEq: operator.ne,
+            ast.Lt: operator.lt,
+            ast.LtE: operator.le,
+            ast.Gt: operator.gt,
+            ast.GtE: operator.ge,
+            ast.And: lambda x, y: x and y,
+            ast.Or: lambda x, y: x or y,
+            ast.Not: operator.not_,
+            ast.USub: operator.neg,
+        }
+        self.cache: Dict[Tuple[str, Tuple], Any] = {}
+
+    def evaluate(self, expression: str, context: Dict[str, Any]) -> Any:
+        """
+        Evaluates a given expression string using the provided context.
+
+        Args:
+            expression (str): The expression to evaluate.
+            context (Dict[str, Any]): A dictionary mapping variable names to their values.
+
+        Returns:
+            Any: The result of the evaluated expression.
+
+        Raises:
+            ValueError: If the expression cannot be evaluated.
+        """
+        cache_key = (expression, tuple(sorted(context.items())))
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        try:
+            tree = ast.parse(expression, mode="eval")
+            result = self._evaluate_node(tree.body, context)
+            self.cache[cache_key] = result
+            return result
+        except Exception as e:
+            raise ValueError(f"Failed to evaluate expression: {expression}. Error: {e}")
+
+    def _evaluate_node(self, node: ast.AST, context: Dict[str, Any]) -> Any:
+        """Recursively evaluates an AST node."""
+        if isinstance(node, ast.BinOp):
+            left = self._evaluate_node(node.left, context)
+            op_func = self.allowed_operators[type(node.op)]
+            right = self._evaluate_node(node.right, context)
+            result = op_func(left, right)
+        elif isinstance(node, ast.UnaryOp):
+            operand = self._evaluate_node(node.operand, context)
+            result = self.allowed_operators[type(node.op)](operand)
+        elif isinstance(node, ast.Name):
+            result = context.get(node.id, None)
+        elif isinstance(node, ast.Constant):
+            result = node.value
+        elif isinstance(node, ast.Compare):
+            left = self._evaluate_node(node.left, context)
+            result = True
+            for operation, comparator in zip(node.ops, node.comparators):
+                op_func = self.allowed_operators[type(operation)]
+                right = self._evaluate_node(comparator, context)
+                result = result and op_func(left, right)
+                if not result:
+                    break
+                left = right
+        elif isinstance(node, ast.BoolOp):
+            values = [self._evaluate_node(value, context) for value in node.values]
+            if isinstance(node.op, ast.And):
+                result = all(values)
+            elif isinstance(node.op, ast.Or):
+                result = any(values)
+            else:
+                raise ValueError("Unsupported boolean operation.")
+        else:
+            raise ValueError("Unsupported operation in condition.")
+        return result
+
+    def add_custom_operator(self, operator_name, operation_func):
+        """Adds a custom operator to the evaluator."""
+        custom_node_class = type(operator_name, (ast.AST,), {})
+        if custom_node_class not in self.allowed_operators:
+            self.allowed_operators[custom_node_class] = operation_func
+        else:
+            raise ValueError(f"Custom operator '{operator_name}' is already defined.")
+
+    def evaluate_file(self, file_path, context, format="line"):
+        """Evaluates expressions from a file."""
+        if format == "line":
+            with open(file_path, "r") as file:
+                last_result = None
+                for line in file:
+                    line = line.strip()
+                    if line:
+                        last_result = self.evaluate(line, context)
+                return last_result
+        elif format == "json":
+            with open(file_path, "r") as file:
+                data = to_dict(file)
+                last_result = None
+                for expression in data:
+                    last_result = self.evaluate(expression, context)
+                return last_result
+        else:
+            raise ValueError(f"Unsupported file format: {format}")
+
+    def validate_expression(self, expression):
+        """Validates the given expression."""
+        try:
+            tree = ast.parse(expression, mode="eval")
+            self._validate_node(tree.body)
+            return True, "Expression is valid."
+        except Exception as e:
+            return False, f"Invalid expression: {str(e)}"
+
+    def _validate_node(self, node):
+        """Validates an AST node."""
+        if isinstance(
+            node, (ast.BinOp, ast.Compare, ast.BoolOp, ast.Name, ast.Constant)
+        ):
+            if (
+                isinstance(node, ast.BinOp)
+                and type(node.op) not in self.allowed_operators
+            ):
+                raise ValueError(
+                    f"Operation {type(node.op).__name__} is not supported."
+                )
+        else:
+            raise ValueError("Unsupported node type in expression.")
+
+
+class BaseEvaluationEngine:
+    def __init__(self) -> None:
+        self.variables: Dict[str, Any] = {}
+        self.functions: Dict[str, Callable] = {
+            "print": print,
+        }
+
+    def _evaluate_expression(self, expression: str) -> Any:
+        try:
+            return eval(expression, {}, self.variables)
+        except NameError as e:
+            raise ValueError(f"Undefined variable. {e}")
+
+    def _assign_variable(self, var_name: str, value: Any) -> None:
+        self.variables[var_name] = value
+
+    def _execute_function(self, func_name: str, *args: Any) -> None:
+        if func_name in self.functions:
+            self.functions[func_name](*args)
+        else:
+            raise ValueError(f"Function {func_name} not defined.")
+
+    def _execute_statement(self, stmt: ast.AST) -> None:
+        if isinstance(stmt, ast.Assign):
+            var_name = stmt.targets[0].id
+            value = self._evaluate_expression(ast.unparse(stmt.value))
+            self._assign_variable(var_name, value)
+        elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+            func_name = stmt.value.func.id
+            args = [
+                self._evaluate_expression(ast.unparse(arg)) for arg in stmt.value.args
+            ]
+            self._execute_function(func_name, *args)
+        elif isinstance(stmt, ast.For):
+            iter_var = stmt.target.id
+            if isinstance(stmt.iter, ast.Call) and stmt.iter.func.id == "range":
+                start, end = [
+                    self._evaluate_expression(ast.unparse(arg))
+                    for arg in stmt.iter.args
+                ]
+                for i in range(start, end):
+                    self.variables[iter_var] = i
+                    for body_stmt in stmt.body:
+                        self._execute_statement(body_stmt)
+
+    def execute(self, script: str) -> None:
+        tree = ast.parse(script)
+        for stmt in tree.body:
+            self._execute_statement(stmt)

lionagi/experimental/directive/evaluator/sandbox_.py

@@ -0,0 +1,14 @@
+# filename: enhanced_script_engine.py
+import ast
+
+
+class SandboxTransformer(ast.NodeTransformer):
+    """AST transformer to enforce restrictions in sandbox mode."""
+
+    def visit_Import(self, node):
+        raise RuntimeError("Import statements are not allowed in sandbox mode.")
+
+    def visit_Exec(self, node):
+        raise RuntimeError("Exec statements are not allowed in sandbox mode.")
+
+    # Add other visit methods for disallowed operations or nodes

lionagi/experimental/directive/evaluator/script_engine.py

@@ -0,0 +1,83 @@
+import ast
+from functools import lru_cache
+from lionagi.libs import AsyncUtil
+from .base_evaluator import BaseEvaluator
+from .sandbox_ import SandboxTransformer
+
+
+class ScriptEngine:
+    def __init__(self):
+        self.variables = {}
+        self.safe_evaluator = BaseEvaluator()
+        self.functions = {
+            "processData": self.process_data,
+        }
+
+    def process_data(self, data):
+        return data * 2
+
+    def _evaluate_expression(self, expression):
+        return self.safe_evaluator.evaluate(expression, self.variables)
+
+    def _assign_variable(self, var_name, value):
+        self.variables[var_name] = value
+
+    def _execute_function(self, func_name, arg):
+        if func_name in self.functions:
+            return self.functions[func_name](arg)
+        else:
+            raise ValueError(f"Function {func_name} not defined.")
+
+    def execute(self, script):
+        tree = ast.parse(script)
+        for stmt in tree.body:
+            if isinstance(stmt, ast.Assign):
+                var_name = stmt.targets[0].id
+                value = self._evaluate_expression(ast.unparse(stmt.value))
+                self._assign_variable(var_name, value)
+            elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+                func_name = stmt.value.func.id
+                arg = self._evaluate_expression(ast.unparse(stmt.value.args[0]))
+                result = self._execute_function(func_name, arg)
+                # For demonstration, manually update 'x' to simulate expected behavior
+                if func_name == "processData":
+                    self._assign_variable("x", result)
+
+    def add_hook(self, event_name, callback):
+        """Subscribe a callback function to a specific event."""
+        self.hooks[event_name].append(callback)
+
+    def trigger_hooks(self, event_name, *args, **kwargs):
+        """Trigger all callbacks attached to a specific event."""
+        for callback in self.hooks[event_name]:
+            callback(*args, **kwargs)
+
+    async def process_data(self, data):
+        # Example asynchronous function
+        return data * 2
+
+    @lru_cache(maxsize=128)
+    def evaluate_expression(self, expression):
+        return self.safe_evaluator.evaluate(expression, self.variables)
+
+    async def _execute_function_async(self, func_name, arg):
+        if func_name in self.functions:
+            func = self.functions[func_name]
+            if AsyncUtil.is_coroutine_func(func):
+                return await func(arg)
+            else:
+                return func(arg)
+        else:
+            raise ValueError(f"Function {func_name} not defined.")
+
+    def execute_sandboxed(self, script):
+        # Parse and sanitize the script
+        tree = ast.parse(script, mode="exec")
+        sanitized_tree = SandboxTransformer().visit(tree)
+        ast.fix_missing_locations(sanitized_tree)
+
+        # Compile the sanitized AST
+        code = compile(sanitized_tree, "<sandbox>", "exec")
+
+        # Execute the code in a restricted namespace
+        exec(code, {"__builtins__": None}, self.variables)