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

lionagi/core/execute/structure_executor.py

@@ -19,10 +19,32 @@ from lionagi.core.graph.graph import Graph
 
 
 class StructureExecutor(BaseExecutor, Graph):
+    """
+    Executes tasks within a graph structure, handling dynamic node flows and conditional edge logic.
+
+    Attributes:
+        condition_check_result (bool | None): Result of the last condition check performed during execution,
+            used to control flow based on dynamic conditions.
+    """
 
     condition_check_result: bool | None = None
 
     async def check_edge_condition(self, edge: Edge, executable_id, request_source):
+        """
+        Evaluates the condition associated with an edge, determining if execution should proceed along that edge based
+        on the condition's source type.
+
+        Args:
+            edge (Edge): The edge whose condition needs to be checked.
+            executable_id (str): ID of the executor handling this edge's condition.
+            request_source (str): Origin of the request prompting this condition check.
+
+        Returns:
+            bool: Result of the condition evaluation.
+
+        Raises:
+            ValueError: If the source_type of the condition is invalid.
+        """
         if edge.condition.source_type == "structure":
             return edge.condition(self)
 
@@ -59,6 +81,17 @@ class StructureExecutor(BaseExecutor, Graph):
     async def _check_executable_condition(
         self, edge: Edge, executable_id, request_source
     ):
+        """
+        Sends the edge's condition to an external executable for evaluation and waits for the result.
+
+        Args:
+            edge (Edge): The edge containing the condition to be checked.
+            executable_id (str): ID of the executable that will evaluate the condition.
+            request_source (str): Source of the request for condition evaluation.
+
+        Returns:
+            bool: The result of the condition check.
+        """
         self.send(
             recipient_id=executable_id,
             category="condition",
@@ -73,6 +106,16 @@ class StructureExecutor(BaseExecutor, Graph):
         return check_result
 
     async def _handle_node_id(self, mail: BaseMail):
+        """
+        Processes the node identified by its ID in the mail's package, ensuring it exists and retrieving the next set of
+        nodes based on the current node.
+
+        Args:
+            mail (BaseMail): The mail containing the node ID and related execution details.
+
+        Raises:
+            ValueError: If the node does not exist within the structure.
+        """
         if mail.package["package"] not in self.internal_nodes:
             raise ValueError(
                 f"Node {mail.package} does not exist in the structure {self.id_}"
@@ -84,6 +127,15 @@ class StructureExecutor(BaseExecutor, Graph):
         )
 
     async def _handle_node(self, mail: BaseMail):
+        """
+        Processes the node specified in the mail's package, ensuring it exists within the structure.
+
+        Args:
+            mail (BaseMail): The mail containing the node details to be processed.
+
+        Raises:
+            ValueError: If the node does not exist within the structure.
+        """
         if not self.node_exist(mail.package["package"]):
             raise ValueError(
                 f"Node {mail.package} does not exist in the structure {self.id_}"
@@ -93,7 +145,15 @@ class StructureExecutor(BaseExecutor, Graph):
         )
 
     async def _handle_mail(self, mail: BaseMail):
+        """
+        Processes incoming mail based on its category, initiating node execution or structure operations accordingly.
+
+        Args:
+            mail (BaseMail): The mail to be processed, containing category and package information.
 
+        Raises:
+            ValueError: If the mail type is invalid for the current structure or an error occurs in handling the node ID.
+        """
         if mail.category == "start":
             return self.get_heads()
 
@@ -116,7 +176,7 @@ class StructureExecutor(BaseExecutor, Graph):
         else:
             raise ValueError(f"Invalid mail type for structure")
 
-    async def _next_node(self, current_node: BaseNode, executable_id, request_source):
+    async def _next_node(self, current_node: Node, executable_id, request_source):
         """
         Get the next step nodes based on the current node.
 
@@ -128,7 +188,7 @@ class StructureExecutor(BaseExecutor, Graph):
             list[Node]: The next step nodes.
         """
         next_nodes = []
-        next_edges: dict[Edge] = self.get_node_edges(current_node, node_as="out")
+        next_edges = self.get_node_edges(current_node, node_as="out")
         for edge in convert.to_list(list(next_edges.values())):
             if edge.bundle:
                 continue
@@ -139,7 +199,7 @@ class StructureExecutor(BaseExecutor, Graph):
                 if not check:
                     continue
             node = self.internal_nodes[edge.tail]
-            further_edges: dict[Edge] = self.get_node_edges(node, node_as="out")
+            further_edges = self.get_node_edges(node, node_as="out")
             bundled_nodes = deque()
             for f_edge in convert.to_list(list(further_edges.values())):
                 if f_edge.bundle:
@@ -150,6 +210,13 @@ class StructureExecutor(BaseExecutor, Graph):
         return next_nodes
 
     def _send_mail(self, next_nodes: list | None, mail: BaseMail):
+        """
+        Sends mails to the next nodes or signals the end of execution if no next nodes exist.
+
+        Args:
+            next_nodes (list | None): List of next nodes to process or None if no further nodes are available.
+            mail (BaseMail): The base mail used for sending follow-up actions.
+        """
         if not next_nodes:  # tail
             self.send(
                 recipient_id=mail.sender_id,
@@ -181,6 +248,26 @@ class StructureExecutor(BaseExecutor, Graph):
 
     @staticmethod
     def parse_bundled_to_action(instruction: Node, bundled_nodes: deque):
+        """
+        Constructs an action node from a bundle of nodes, combining various types of nodes like ActionSelection or Tool
+        into a single actionable unit.
+
+        This method takes a bundle of nodes and systematically integrates their functionalities into a single `ActionNode`.
+        This is crucial in scenarios where multiple actions or tools need to be executed sequentially or in a coordinated
+        manner as part of a larger instruction flow.
+
+        Args:
+            instruction (Node): The initial instruction node leading to this action.
+            bundled_nodes (deque): A deque containing nodes to be bundled into the action. These nodes typically represent
+                either actions to be taken or tools to be utilized.
+
+        Returns:
+            ActionNode: An `ActionNode` that encapsulates the combined functionality of the bundled nodes, ready for execution.
+
+        Raises:
+            ValueError: If an unrecognized node type is encountered within the bundled nodes. Only `ActionSelection` and
+                `Tool` nodes are valid for bundling into an `ActionNode`.
+        """
         action_node = ActionNode(instruction=instruction)
         while bundled_nodes:
             node = bundled_nodes.popleft()
@@ -210,6 +297,15 @@ class StructureExecutor(BaseExecutor, Graph):
                     raise ValueError(f"Error handling mail: {e}") from e
 
     async def execute(self, refresh_time=1):
+        """
+        Executes the forward processing loop, checking conditions and processing nodes at defined intervals.
+
+        Args:
+            refresh_time (int): The delay between execution cycles, allowing for asynchronous operations to complete.
+
+        Raises:
+            ValueError: If the graph structure is found to be cyclic, which is unsupported.
+        """
         if not self.acyclic:
             raise ValueError("Structure is not acyclic")
 

lionagi/core/flow/monoflow/ReAct.py

@@ -46,8 +46,7 @@ class MonoReAct(MonoChat):
     """
 
     ACTION_PROMPT = """
-    You have {num_steps} steps left in the current task. If further actions are needed, invoke tool usage.
-    If you are done, present the final result to the user without further tool usage.
+    You have {num_steps} steps left in the current task. invoke tool usage.
     """
 
     OUTPUT_PROMPT = "Notice: Present the final output to the user. Original user instruction: {instruction}"
@@ -127,15 +126,15 @@ class MonoReAct(MonoChat):
 
     def _create_followup_config(self, tools, tool_choice="auto", **kwargs):
         """
-        Creates the configuration for the followup steps based on the provided tools and parameters.
+        Creates the configuration for the followup chat based on the provided tools and parameters.
 
         Args:
-            tools (Optional[Any]): Specifies tools to be invoked during the followup steps.
+            tools (Optional[Any]): Specifies tools to be invoked during the followup chat.
             tool_choice (str): The choice of tools to use (default: "auto").
-            **kwargs: Additional keyword arguments for the followup configuration.
+            **kwargs: Additional keyword arguments for the followup chat configuration.
 
         Returns:
-            dict: The configuration for the followup steps.
+            dict: The configuration for the followup chat.
 
         Raises:
             ValueError: If no tools are found and registered.
@@ -159,7 +158,7 @@ class MonoReAct(MonoChat):
         system=None,
         tools=None,
         num_rounds: int = 1,
-        auto=False,
+        auto=True,
         reason_prompt=None,
         action_prompt=None,
         output_prompt=None,
@@ -188,6 +187,7 @@ class MonoReAct(MonoChat):
             The result of the reasoning and action steps.
         """
         config = self._create_followup_config(tools, **kwargs)
+        kwargs.pop("tools", None)
 
         i = 0
         _out = ""
@@ -220,19 +220,19 @@ class MonoReAct(MonoChat):
 
             _out = await self.chat(_prompt, sender=sender, **config)
 
-            if auto and not self.branch._is_invoked():
+            if not self.branch._is_invoked():
                 return _out if out else None
 
             i += 1
 
-        if auto:
-            if not self.branch._is_invoked():
-                return _out if out else None
 
-            _prompt = self._get_prompt(
-                prompt=output_prompt,
-                default=self.OUTPUT_PROMPT,
-                instruction=instruction,
-            )
-            _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None
+        if not self.branch._is_invoked():
+            return _out if out else None
+
+        _prompt = self._get_prompt(
+            prompt=output_prompt,
+            default=self.OUTPUT_PROMPT,
+            instruction=instruction,
+        )
+        _out = await self.chat(_prompt, sender=sender, **kwargs)
+        return _out if out else None

lionagi/core/flow/monoflow/chat_mixin.py

@@ -250,4 +250,4 @@ class MonoChatMixin(MonoChatConfigMixin, MonoChatInvokeMixin, ABC):
     Mixin class that combines MonoChatConfigMixin and MonoChatInvokeMixin.
     """
 
-    pass
+    pass

lionagi/core/flow/monoflow/followup.py

@@ -150,7 +150,7 @@ class MonoFollowup(MonoChat):
         system=None,
         tools=None,
         max_followup: int = 1,
-        auto=False,
+        auto=True,
         followup_prompt=None,
         output_prompt=None,
         out=True,
@@ -196,19 +196,18 @@ class MonoFollowup(MonoChat):
             else:
                 _out = await self.chat(_prompt, sender=sender, **config)
 
-            if auto and not self.branch._is_invoked():
+            if not self.branch._is_invoked():
                 return _out if out else None
 
             i += 1
 
-        if auto:
-            if not self.branch._is_invoked():
-                return _out if out else None
+        if not self.branch._is_invoked():
+            return _out if out else None
 
-            _prompt = self._get_prompt(
-                prompt=output_prompt,
-                default=self.OUTPUT_PROMPT,
-                instruction=instruction,
-            )
-            _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None
+        _prompt = self._get_prompt(
+            prompt=output_prompt,
+            default=self.OUTPUT_PROMPT,
+            instruction=instruction,
+        )
+        _out = await self.chat(_prompt, sender=sender, **kwargs)
+        return _out if out else None

lionagi/core/flow/polyflow/__init__.py

@@ -1 +1 @@
-from .chat import PolyChat
+from .chat import PolyChat

lionagi/core/generic/component.py

@@ -150,7 +150,6 @@ class BaseComponent(BaseModel, ABC):
             dict_.update(self._get_field_annotation(i))
         return dict_
 
-
     @_get_field_annotation.register(tuple)
     def _(self, field_name) -> dict[str, Any]:
         """
@@ -168,7 +167,6 @@ class BaseComponent(BaseModel, ABC):
             dict_.update(self._get_field_annotation(i))
         return dict_
 
-
     def _field_has_attr(self, k: str, attr: str) -> bool:
         """
         Check if a field has a specific attribute.

lionagi/core/generic/condition.py

@@ -35,7 +35,7 @@ class Condition(BaseModel, ABC):
         extra = "allow"
 
     @abstractmethod
-    def __call__(self, *args, **kwargs) -> bool:
+    def __call__(self, executable) -> bool:
         """Evaluates the condition based on implemented logic.
 
         Returns:

lionagi/core/generic/edge.py

@@ -85,6 +85,58 @@ class Edge(BaseComponent):
             raise ValueError("The condition for the edge is not set.")
         return self.condition(obj)
 
+    def string_condition(self):
+        """
+        Retrieves the source code of the condition class associated with this edge 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 in interactive environments.
+
+        Returns:
+            str: The source code of the condition's class, if available. If the condition is None or the source code
+                cannot be located, this method returns None.
+
+        Raises:
+            TypeError: If the source code of the condition's class 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 Relationship.

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