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

lionagi/core/{execute → executor}/neo4j_executor.py

@@ -2,16 +2,16 @@ from collections import deque
 import json
 from typing import Callable
 
-from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.executor.base_executor import BaseExecutor
 from lionagi.integrations.storage.neo4j import Neo4j
 from lionagi.integrations.storage.storage_util import ParseNode
-from lionagi.core.generic import ActionNode
 from lionagi.core.agent.base_agent import BaseAgent
-from lionagi.core.execute.instruction_map_executor import InstructionMapExecutor
+from lionagi.core.engine.instruction_map_engine import InstructionMapEngine
 
-from lionagi.core.mail.schema import BaseMail
-from lionagi.core.tool import Tool
-from lionagi.core.generic import ActionSelection, Edge
+from lionagi.core.mail import Mail
+from lionagi.core.action import Tool, DirectiveSelection, ActionNode
+from lionagi.core.generic.edge import Edge
+from lionagi.core.collections.progression import progression
 
 from lionagi.libs import AsyncUtil
 
@@ -33,9 +33,12 @@ class Neo4jExecutor(BaseExecutor):
     structure_id: str = None
     structure_name: str = None
     middle_agents: list | None = None
-    default_agent_executable: BaseExecutor = InstructionMapExecutor()
+    default_agent_executable: BaseExecutor = InstructionMapEngine()
     condition_check_result: bool | None = None
 
+    class Config:
+        arbitrary_types_allowed = True
+
     async def check_edge_condition(
         self, condition, executable_id, request_source, head, tail
     ):
@@ -52,9 +55,9 @@ class Neo4jExecutor(BaseExecutor):
         Returns:
             bool: Result of the condition check.
         """
-        if condition.source_type == "structure":
-            return condition(self)
-        elif condition.source_type == "executable":
+        if condition.source == "structure":
+            return condition.applies(self)
+        elif condition.source == "executable":
             return await self._check_executable_condition(
                 condition, executable_id, head, tail, request_source
             )
@@ -66,20 +69,20 @@ class Neo4jExecutor(BaseExecutor):
         Args:
             edge_id (str): The ID of the edge.
         """
-        for key in list(self.pending_ins.keys()):
-            skipped_requests = deque()
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            skipped_requests = progression()
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile[mail_id]
                 if (
                     mail.category == "condition"
-                    and mail.package["package"]["edge_id"] == edge_id
+                    and mail.package.package["edge_id"] == edge_id
                 ):
-                    self.condition_check_result = mail.package["package"][
-                        "check_result"
-                    ]
+                    self.mailbox.pile.pop(mail_id)
+                    self.condition_check_result = mail.package.package["check_result"]
                 else:
                     skipped_requests.append(mail)
-            self.pending_ins[key] = skipped_requests
+            self.mailbox.pending_ins[key] = skipped_requests
 
     async def _check_executable_condition(
         self, condition, executable_id, head, tail, request_source
@@ -99,13 +102,14 @@ class Neo4jExecutor(BaseExecutor):
         """
         edge = Edge(head=head, tail=tail, condition=condition)
         self.send(
-            recipient_id=executable_id,
+            recipient=executable_id,
             category="condition",
-            package={"request_source": request_source, "package": edge},
+            package=edge,
+            request_source=request_source,
         )
         while self.condition_check_result is None:
             await AsyncUtil.sleep(0.1)
-            self._process_edge_condition(edge.id_)
+            self._process_edge_condition(edge.ln_id)
             continue
         check_result = self.condition_check_result
         self.condition_check_result = None
@@ -126,27 +130,27 @@ class Neo4jExecutor(BaseExecutor):
         bundled_nodes = deque()
         for node_labels, node_properties in bundle_list:
             try:
-                if "ActionSelection" in node_labels:
-                    node = ParseNode.parse_actionSelection(node_properties)
+                if "DirectiveSelection" in node_labels:
+                    node = ParseNode.parse_directiveSelection(node_properties)
                     bundled_nodes.append(node)
                 elif "Tool" in node_labels:
                     node = ParseNode.parse_tool(node_properties)
                     bundled_nodes.append(node)
                 else:
                     raise ValueError(
-                        f"Invalid bundle node {node_properties.id}. Valid nodes are ActionSelection or Tool"
+                        f"Invalid bundle node {node_properties.ln_id}. Valid nodes are ActionSelection or Tool"
                     )
             except Exception as e:
                 raise ValueError(
-                    f"Failed to parse ActionSelection or Tool node {node_properties.id}. Error: {e}"
+                    f"Failed to parse ActionSelection or Tool node {node_properties.ln_id}. Error: {e}"
                 )
 
         action_node = ActionNode(instruction=instruction)
         while bundled_nodes:
             node = bundled_nodes.popleft()
-            if isinstance(node, ActionSelection):
-                action_node.action = node.action
-                action_node.action_kwargs = node.action_kwargs
+            if isinstance(node, DirectiveSelection):
+                action_node.directive = node.directive
+                action_node.directive_kwargs = node.directive_kwargs
             elif isinstance(node, Tool):
                 action_node.tools.append(node)
         return action_node
@@ -161,7 +165,11 @@ class Neo4jExecutor(BaseExecutor):
         Returns:
             BaseAgent: An agent executor configured with the given properties.
         """
-        output_parser = ParseNode.convert_to_def(node_properties["outputParser"])
+        output_parser = (
+            ParseNode.convert_to_def(node_properties["outputParser"])
+            if "outputParser" in node_properties
+            else None
+        )
 
         structure = Neo4jExecutor(
             driver=self.driver, structure_id=node_properties["structureId"]
@@ -170,9 +178,9 @@ class Neo4jExecutor(BaseExecutor):
             structure=structure,
             executable=self.default_agent_executable,
             output_parser=output_parser,
+            ln_id=node_properties["ln_id"],
+            timestamp=node_properties["timestamp"],
         )
-        agent.id_ = node_properties["id"]
-        agent.timestamp = node_properties["timestamp"]
         return agent
 
     async def _next_node(
@@ -202,7 +210,7 @@ class Neo4jExecutor(BaseExecutor):
                     condition_obj = ParseNode.parse_condition(condition, condition_cls)
 
                     head = node_id
-                    tail = node_properties["id"]
+                    tail = node_properties["ln_id"]
                     check = await self.check_edge_condition(
                         condition_obj, executable_id, request_source, head, tail
                     )
@@ -210,7 +218,7 @@ class Neo4jExecutor(BaseExecutor):
                         continue
                 except Exception as e:
                     raise ValueError(
-                        f"Failed to use condition {edge_properties['condition']} from {node_id} to {node_properties['id']}, Error: {e}"
+                        f"Failed to use condition {edge_properties['condition']} from {node_id} to {node_properties['ln_id']}, Error: {e}"
                     )
 
             try:
@@ -223,14 +231,14 @@ class Neo4jExecutor(BaseExecutor):
 
                 else:
                     raise ValueError(
-                        f"Invalid start node {node_properties.id}. Valid nodes are System or Instruction"
+                        f"Invalid start node {node_properties.ln_id}. Valid nodes are System or Instruction"
                     )
             except Exception as e:
                 raise ValueError(
-                    f"Failed to parse System or Instruction node {node_properties.id}. Error: {e}"
+                    f"Failed to parse System or Instruction node {node_properties.ln_id}. Error: {e}"
                 )
 
-            bundle_list = await self.driver.get_bundle(node.id_)
+            bundle_list = await self.driver.get_bundle(node.ln_id)
 
             if bundle_list and "System" in node_labels:
                 raise ValueError("System node does not support bundle edge")
@@ -247,10 +255,10 @@ class Neo4jExecutor(BaseExecutor):
             ValueError: If there is an issue with finding or starting the structure.
         """
         try:
-            id, head_list = await self.driver.get_heads(
+            id_, head_list = await self.driver.get_heads(
                 self.structure_name, self.structure_id
             )
-            self.structure_id = id
+            self.structure_id = id_
             return await self._next_node(head_list)
         except Exception as e:
             raise ValueError(f"Error in searching for structure in Neo4j. Error: {e}")
@@ -273,12 +281,12 @@ class Neo4jExecutor(BaseExecutor):
         node_list = await self.driver.get_forwards(node_id)
         return await self._next_node(node_list, node_id, executable_id, request_source)
 
-    async def _handle_mail(self, mail: BaseMail):
+    async def _handle_mail(self, mail: Mail):
         """
         Processes incoming mail, determining the next action based on the mail's category and content.
 
         Args:
-            mail (BaseMail): The incoming mail to be processed.
+            mail (Mail): The incoming mail to be processed.
 
         Raises:
             ValueError: If there is an error processing the mail.
@@ -295,9 +303,9 @@ class Neo4jExecutor(BaseExecutor):
 
         elif mail.category == "node_id":
             try:
-                node_id = mail.package["package"]
-                executable_id = mail.sender_id
-                request_source = mail.package["request_source"]
+                node_id = mail.package.package
+                executable_id = mail.sender
+                request_source = mail.package.request_source
                 return await self._handle_node_id(
                     node_id, executable_id, request_source
                 )
@@ -305,9 +313,9 @@ class Neo4jExecutor(BaseExecutor):
                 raise ValueError(f"Error in handling node_id: {e}")
         elif mail.category == "node":
             try:
-                node_id = mail.package["package"].id_
-                executable_id = mail.sender_id
-                request_source = mail.package["request_source"]
+                node_id = mail.package.package.ln_id
+                executable_id = mail.sender
+                request_source = mail.package.request_source
                 return await self._handle_node_id(
                     node_id, executable_id, request_source
                 )
@@ -316,50 +324,45 @@ class Neo4jExecutor(BaseExecutor):
         else:
             raise ValueError(f"Invalid mail type for structure")
 
-    def _send_mail(self, next_nodes: list | None, mail: BaseMail):
+    def _send_mail(self, next_nodes: list | None, mail: Mail):
         """
         Sends out mail to the next nodes or marks the execution as ended if there are no next nodes.
 
         Args:
             next_nodes (list | None): List of next nodes to which mail should be sent.
-            mail (BaseMail): The current mail being processed.
+            mail (Mail): The current mail being processed.
         """
         if not next_nodes:  # tail
             self.send(
-                recipient_id=mail.sender_id,
+                recipient=mail.sender,
                 category="end",
-                package={
-                    "request_source": mail.package["request_source"],
-                    "package": "end",
-                },
+                package="end",
+                request_source=mail.package.request_source,
             )
         else:
             if len(next_nodes) == 1:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes[0],
-                    },
+                    package=next_nodes[0],
+                    request_source=mail.package.request_source,
                 )
             else:
                 self.send(
-                    recipient_id=mail.sender_id,
+                    recipient=mail.sender,
                     category="node_list",
-                    package={
-                        "request_source": mail.package["request_source"],
-                        "package": next_nodes,
-                    },
+                    package=next_nodes,
+                    request_source=mail.package.request_source,
                 )
 
     async def forward(self) -> None:
         """
         Forwards execution by processing all pending mails and advancing to next nodes or actions.
         """
-        for key in list(self.pending_ins.keys()):
-            while self.pending_ins[key]:
-                mail: BaseMail = self.pending_ins[key].popleft()
+        for key in list(self.mailbox.pending_ins.keys()):
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile.pop(mail_id)
                 try:
                     if mail == "end":
                         self.execute_stop = True

lionagi/core/generic/__init__.py

@@ -1,37 +1,7 @@
-from .component import BaseComponent, BaseNode
-from .condition import Condition
-from .data_logger import DataLogger, DLog
-from .signal import Signal, Start
-from .mail import Mail, Package
-from .mailbox import MailBox
 from .edge import Edge
-from .relation import Relations
-from .transfer import Transfer
-from .work import Work, Worker
 from .node import Node
-from .structure import BaseStructure
-from .action import ActionNode, ActionSelection
+from .graph import Graph
+from .tree import Tree
 
 
-__all__ = [
-    "BaseComponent",
-    "BaseNode",
-    "BaseStructure",
-    "BaseWork",
-    "Condition",
-    "Edge",
-    "Mail",
-    "MailBox",
-    "Start",
-    "Package",
-    "Relations",
-    "Signal",
-    "Transfer",
-    "Node",
-    "Work",
-    "Worker",
-    "ActionNode",
-    "ActionSelection",
-    "DataLogger",
-    "DLog",
-]
+__all__ = ["Edge", "Node", "Graph", "Tree"]

lionagi/core/generic/edge.py

@@ -1,105 +1,71 @@
-"""
-Module for representing conditions and edges between nodes in a graph structure.
-
-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
-
-
-class Edge(BaseComponent):
-    """
-    Represents an edge between two nodes, potentially with a condition.
+from typing import Any
+from lionagi.core.collections.abc import Component, get_lion_id, LionIDable, Condition
+from lionagi.core.generic.edge_condition import EdgeCondition
 
-    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
-            for the edge to be considered active.
-        label (Optional[str]): An optional label for the edge.
 
-    Methods:
-        check_condition: Evaluates if the condition associated with the edge is met.
-    """
+class Edge(Component):
+    """Represents a directed edge between two nodes in a graph."""
 
     head: str = Field(
+        ...,
         title="Head",
         description="The identifier of the head node of the edge.",
     )
+
     tail: str = Field(
-        title="Tail",
+        ...,
+        title="Out",
         description="The identifier of the tail node of the edge.",
     )
-    condition: Condition | None = Field(
+
+    condition: Condition | EdgeCondition | 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,
         description="An optional label for the edge.",
     )
+
     bundle: bool = Field(
         default=False,
         description="A flag indicating if the edge is bundled.",
     )
 
-    @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.
-
-        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.
-
-        Returns:
-            The validated value, ensuring it is a valid identifier.
-
-        Raises:
-            ValueError: If the validation fails.
-        """
-        if isinstance(value, BaseNode):
-            return value.id_
-        return value
-
-    def check_condition(self, obj: dict[str, Any]) -> bool:
-        """
-        Evaluates if the condition associated with the edge is met.
-
-        Args:
-            obj (dict[str, Any]): The context object used for condition evaluation.
-
-        Returns:
-            bool: True if the condition is met, False otherwise.
-
-        Raises:
-            ValueError: If the condition is not set.
-        """
+    async def check_condition(self, obj: Any) -> bool:
+        """Check if the edge condition is met for the given object."""
         if not self.condition:
             raise ValueError("The condition for the edge is not set.")
-        return self.condition(obj)
+        check = await self.condition.applies(obj)
+        return check
+
+    @field_validator("head", "tail", mode="before")
+    def _validate_head_tail(cls, value):
+        """Validate the head and tail fields."""
+        return get_lion_id(value)
 
     def string_condition(self):
         """
-        Retrieves the source code of the condition class associated with this edge as a string.
+        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 in interactive environments.
+        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: 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.
+            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 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).
+            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
@@ -137,26 +103,10 @@ class Edge(BaseComponent):
         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.
-        """
+    def __len__(self):
+        """Return the length of the edge (always 1)."""
+        return 1
 
-        return (
-            f"Edge (id_={self.id_}, from={self.head}, to={self.tail}, "
-            f"label={self.label})"
-        )
-
-    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)'
-        """
-        return (
-            f"Edge(id_={self.id_}, from={self.head}, to={self.tail}, "
-            f"label={self.label})"
-        )
+    def __contains__(self, item: LionIDable) -> bool:
+        """Check if the given item is the head or tail of the edge."""
+        return get_lion_id(item) in (self.head, self.tail)

lionagi/core/generic/edge_condition.py

@@ -0,0 +1,16 @@
+from typing import Any
+from pydantic import Field
+from lionagi.core.collections.abc import Condition
+from pydantic import BaseModel
+
+
+class EdgeCondition(Condition, BaseModel):
+    source: Any = Field(
+        title="Source",
+        description="The source for condition check",
+    )
+
+    class Config:
+        """Model configuration settings."""
+
+        extra = "allow"