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

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,91 +1,51 @@
-"""
-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.
-"""
-
-from typing import Any
 from pydantic import Field, field_validator
-from .component import BaseComponent
-from .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 (Condition | None): Optional condition that must be met
-            for the edge to be considered active.
-        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 is met.
-        string_condition: Retrieves the condition class source code.
-    """
+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="Optional condition that must be met for the edge "
-                    "to be considered active.",
+        "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 head and tail fields to ensure valid node identifiers.
-
-        Args:
-            value (Any): The value of the field being validated.
-
-        Returns:
-            str: The validated value, ensuring it is a valid identifier.
-
-        Raises:
-            ValueError: If the validation fails.
-        """
-
-        if isinstance(value, BaseComponent):
-            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]): Context 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):
         """
@@ -143,20 +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 Edge.
-        """
-        return (
-            f"Edge (id_={self.id_}, from={self.head}, to={self.tail}, "
-            f"label={self.label})"
-        )
+    def __len__(self):
+        """Return the length of the edge (always 1)."""
+        return 1
 
-    def __repr__(self) -> str:
-        """
-        Returns a detailed string representation of the Edge.
-        """
-        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"

lionagi/core/generic/graph.py

@@ -0,0 +1,236 @@
+import contextlib
+from collections import deque
+from typing import Any
+
+from lionagi.libs.ln_convert import to_list
+from lionagi.core.collections.abc import (
+    Condition,
+    Actionable,
+    LionTypeError,
+    ItemNotFoundError,
+    LionIDable,
+)
+from lionagi.core.collections import pile, Pile
+
+from lionagi.core.generic.edge import Edge
+from lionagi.core.generic.node import Node
+
+
+class Graph(Node):
+    """Represents a graph structure with nodes and edges."""
+
+    internal_nodes: Pile = pile()
+
+    @property
+    def internal_edges(self) -> Pile[Edge]:
+        """Return a pile of all edges in the graph."""
+        return pile(
+            {edge.ln_id: edge for node in self.internal_nodes for edge in node.edges},
+            Edge,
+        )
+
+    def is_empty(self) -> bool:
+        """Check if the graph is empty (has no nodes)."""
+        return self.internal_nodes.is_empty()
+
+    def clear(self):
+        """Clear all nodes and edges from the graph."""
+        self.internal_nodes.clear()
+
+    def add_edge(
+        self,
+        head: Node,
+        tail: Node,
+        condition: Condition | None = None,
+        bundle=False,
+        label=None,
+        **kwargs,
+    ):
+        """Add an edge between two nodes in the graph."""
+        if isinstance(head, Actionable):
+            raise LionTypeError("Actionable nodes cannot be related as head.")
+        if isinstance(tail, Actionable):
+            bundle = True
+
+        self.internal_nodes.include(head)
+        self.internal_nodes.include(tail)
+
+        head.relate(
+            tail,
+            direction="out",
+            condition=condition,
+            label=label,
+            bundle=bundle,
+            **kwargs,
+        )
+
+    def remove_edge(self, edge: Any) -> bool:
+        """Remove an edge from the graph."""
+        edge = edge if isinstance(edge, list) else [edge]
+        for i in edge:
+            if i not in self.internal_edges:
+                raise ItemNotFoundError(f"Edge {i} does not exist in structure.")
+            with contextlib.suppress(ItemNotFoundError):
+                self._remove_edge(i)
+
+    def add_node(self, node: Any) -> None:
+        """Add a node to the graph."""
+        self.internal_nodes.update(node)
+
+    def get_node(self, item: LionIDable, default=...):
+        """Get a node from the graph by its identifier."""
+        return self.internal_nodes.get(item, default)
+
+    def get_node_edges(
+        self,
+        node: Node | str,
+        direction: str = "both",
+        label: list | str = None,
+    ) -> Pile[Edge] | None:
+        """Get the edges of a node in the specified direction and with the given label."""
+        node = self.internal_nodes[node]
+        edges = None
+        match direction:
+            case "both":
+                edges = node.edges
+            case "head" | "predecessor" | "outgoing" | "out" | "predecessors":
+                edges = node.relations["out"]
+            case "tail" | "successor" | "incoming" | "in" | "successors":
+                edges = node.relations["in"]
+
+        if label:
+            return (
+                pile(
+                    [
+                        edge
+                        for edge in edges
+                        if edge.label in to_list(label, dropna=True, flatten=True)
+                    ]
+                )
+                if edges
+                else None
+            )
+        return pile(edges) if edges else None
+
+    def pop_node(self, item, default=...):
+        """Remove and return a node from the graph by its identifier."""
+        return self.internal_nodes.pop(item, default)
+
+    def remove_node(self, item):
+        """Remove a node from the graph by its identifier."""
+        return self.internal_nodes.remove(item)
+
+    def _remove_edge(self, edge: Edge | str) -> bool:
+        """Remove a specific edge from the graph."""
+        if edge not in self.internal_edges:
+            raise ItemNotFoundError(f"Edge {edge} does not exist in structure.")
+
+        edge = self.internal_edges[edge]
+        head: Node = self.internal_nodes[edge.head]
+        tail: Node = self.internal_nodes[edge.tail]
+
+        head.unrelate(tail, edge=edge)
+        return True
+
+    def get_heads(self) -> Pile:
+        """Get all head nodes in the graph."""
+        return pile(
+            [
+                node
+                for node in self.internal_nodes
+                if node.relations["in"].is_empty() and not isinstance(node, Actionable)
+            ]
+        )
+
+    def is_acyclic(self) -> bool:
+        """Check if the graph is acyclic (contains no cycles)."""
+        node_ids = list(self.internal_nodes.keys())
+        check_deque = deque(node_ids)
+        check_dict = {key: 0 for key in node_ids}  # 0: not visited, 1: temp, 2: perm
+
+        def visit(key):
+            if check_dict[key] == 2:
+                return True
+            elif check_dict[key] == 1:
+                return False
+
+            check_dict[key] = 1
+
+            for edge in self.internal_nodes[key].relations["out"]:
+                check = visit(edge.tail)
+                if not check:
+                    return False
+
+            check_dict[key] = 2
+            return True
+
+        while check_deque:
+            key = check_deque.pop()
+            check = visit(key)
+            if not check:
+                return False
+        return True
+
+    def to_networkx(self, **kwargs) -> Any:
+        """Convert the graph to a NetworkX graph object."""
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("networkx")
+
+        from networkx import DiGraph
+
+        g = DiGraph(**kwargs)
+        for node in self.internal_nodes:
+            node_info = node.to_dict()
+            node_info.pop("ln_id")
+            node_info.update({"class_name": node.class_name})
+            g.add_node(node.ln_id, **node_info)
+
+        for _edge in self.internal_edges:
+            edge_info = _edge.to_dict()
+            edge_info.pop("ln_id")
+            edge_info.update({"class_name": _edge.class_name})
+            source_node_id = edge_info.pop("head")
+            target_node_id = edge_info.pop("tail")
+            g.add_edge(source_node_id, target_node_id, **edge_info)
+
+        return g
+
+    def display(self, **kwargs):
+        """Display the graph using NetworkX and Matplotlib."""
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("networkx")
+        SysUtil.check_import("matplotlib", "pyplot")
+
+        import networkx as nx
+        import matplotlib.pyplot as plt
+
+        g = self.to_networkx(**kwargs)
+        pos = nx.spring_layout(g)
+        nx.draw(
+            g,
+            pos,
+            edge_color="black",
+            width=1,
+            linewidths=1,
+            node_size=500,
+            node_color="orange",
+            alpha=0.9,
+            labels=nx.get_node_attributes(g, "class_name"),
+        )
+
+        labels = nx.get_edge_attributes(g, "label")
+        labels = {k: v for k, v in labels.items() if v}
+
+        if labels:
+            nx.draw_networkx_edge_labels(
+                g, pos, edge_labels=labels, font_color="purple"
+            )
+
+        plt.axis("off")
+        plt.show()
+
+    def size(self) -> int:
+        """Return the number of nodes in the graph."""
+        return len(self.internal_nodes)

lionagi/core/generic/hyperedge.py

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