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

lionagi/tests/test_core/generic/test_structure.py

@@ -0,0 +1,193 @@
+import unittest
+from lionagi.core.generic.structure import *
+
+class TestCondition(Condition):
+    def check(self, node: Node) -> bool:
+        return True
+
+class TestBaseStructure(unittest.TestCase):
+    def setUp(self):
+        self.structure = BaseStructure(id_="test_structure")
+        self.node1 = Node(id_="node1", content="Node 1 content")
+        self.node2 = Node(id_="node2", content="Node 2 content")
+        self.node3 = Node(id_="node3", content="Node 3 content")
+
+    def test_internal_edges(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2)
+        self.assertEqual(len(self.structure.internal_edges), 1)
+
+    def test_is_empty(self):
+        self.assertTrue(self.structure.is_empty)
+        self.structure.add_node(self.node1)
+        self.assertFalse(self.structure.is_empty)
+
+    def test_add_node_single(self):
+        self.structure.add_node(self.node1)
+        self.assertIn(self.node1.id_, self.structure.internal_nodes)
+
+    def test_add_node_list(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.assertIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_add_node_dict(self):
+        self.structure.add_node({self.node1.id_: self.node1, self.node2.id_: self.node2})
+        self.assertIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_add_node_duplicate(self):
+        self.structure.add_node(self.node1)
+        with self.assertRaises(ValueError):
+            self.structure.add_node(self.node1)
+
+    def test_get_node_str(self):
+        self.structure.add_node(self.node1)
+        self.assertEqual(self.structure.get_node(self.node1.id_), self.node1)
+
+    def test_get_node_node(self):
+        self.structure.add_node(self.node1)
+        self.assertEqual(self.structure.get_node(self.node1), self.node1)
+
+    def test_get_node_list(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.assertEqual(self.structure.get_node([self.node1.id_, self.node2.id_]), [self.node1, self.node2])
+
+    def test_get_node_dict(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.assertEqual(self.structure.get_node({self.node1.id_: self.node1, self.node2.id_: self.node2}), [self.node1, self.node2])
+
+    def test_get_node_not_found(self):
+        with self.assertRaises(KeyError):
+            self.structure.get_node("nonexistent_node")
+
+    def test_get_node_default(self):
+        self.assertIsNone(self.structure.get_node("nonexistent_node", default=None))
+
+    def test_remove_node_node(self):
+        self.structure.add_node(self.node1)
+        self.structure.remove_node(self.node1)
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+
+    def test_remove_node_str(self):
+        self.structure.add_node(self.node1)
+        self.structure.remove_node(self.node1.id_)
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+
+    def test_remove_node_list(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.remove_node([self.node1, self.node2])
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertNotIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_remove_node_dict(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.remove_node({self.node1.id_: self.node1, self.node2.id_: self.node2})
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertNotIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_pop_node_node(self):
+        self.structure.add_node(self.node1)
+        popped_node = self.structure.pop_node(self.node1)
+        self.assertEqual(popped_node, self.node1)
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+
+    def test_pop_node_str(self):
+        self.structure.add_node(self.node1)
+        popped_node = self.structure.pop_node(self.node1.id_)
+        self.assertEqual(popped_node, self.node1)
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+
+    def test_pop_node_list(self):
+        self.structure.add_node([self.node1, self.node2])
+        popped_nodes = self.structure.pop_node([self.node1, self.node2])
+        self.assertEqual(popped_nodes, [self.node1, self.node2])
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertNotIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_pop_node_dict(self):
+        self.structure.add_node([self.node1, self.node2])
+        popped_nodes = self.structure.pop_node({self.node1.id_: self.node1, self.node2.id_: self.node2})
+        self.assertEqual(popped_nodes, [self.node1, self.node2])
+        self.assertNotIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertNotIn(self.node2.id_, self.structure.internal_nodes)
+
+    def test_pop_node_default(self):
+        self.assertIsNone(self.structure.pop_node("nonexistent_node", default=None))
+
+    def test_remove_edge_edge(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2)
+        edge = list(self.node1.edges.values())[0]
+        self.structure.remove_edge(edge)
+        self.assertNotIn(edge.id_, self.structure.internal_edges)
+
+    def test_remove_edge_str(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2)
+        edge = list(self.node1.edges.values())[0]
+        self.structure.remove_edge(edge.id_)
+        self.assertNotIn(edge.id_, self.structure.internal_edges)
+
+    def test_remove_edge_list(self):
+        self.structure.add_node([self.node1, self.node2, self.node3])
+        self.structure.relate_nodes(self.node1, self.node2)
+        self.structure.relate_nodes(self.node2, self.node3)
+        edges = list(self.node2.edges.values())
+        
+        self.structure.remove_edge(edges)
+        self.assertNotIn(edges[0].id_, self.structure.internal_edges)
+        self.assertNotIn(edges[1].id_, self.structure.internal_edges)
+
+    def test_remove_edge_dict(self):
+        self.structure.add_node([self.node1, self.node2, self.node3])
+        self.structure.relate_nodes(self.node1, self.node2)
+        self.structure.relate_nodes(self.node2, self.node3)
+        
+        edge_dict = self.node2.edges
+        edge_list = list(edge_dict.values())
+        
+        self.structure.remove_edge(edge_dict)
+        self.assertNotIn(edge_list[0].id_, self.structure.internal_edges)
+        self.assertNotIn(edge_list[1].id_, self.structure.internal_edges)
+
+    def test_remove_edge_not_found(self):
+        with self.assertRaises(ValueError):
+            self.structure.remove_edge("nonexistent_edge")
+
+    def test_clear(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.clear()
+        self.assertTrue(self.structure.is_empty)
+
+    def test_get_node_edges_head(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2)
+        edges = self.structure.get_node_edges(self.node1, node_as="head")
+        self.assertEqual(len(edges), 1)
+
+    def test_get_node_edges_tail(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2)
+        edges = self.structure.get_node_edges(self.node2, node_as="tail")
+        self.assertEqual(len(edges), 1)
+
+    def test_get_node_edges_label(self):
+        self.structure.add_node([self.node1, self.node2])
+        self.structure.relate_nodes(self.node1, self.node2, label="test_label")
+        edges = self.structure.get_node_edges(self.node1, node_as="head", label="test_label")
+        self.assertEqual(len(edges), 1)
+
+    def test_add_edge(self):
+        self.structure.relate_nodes(self.node1, self.node2)
+        self.assertIn(self.node1.id_, self.structure.internal_nodes)
+        self.assertIn(self.node2.id_, self.structure.internal_nodes)
+        self.assertEqual(len(self.structure.internal_edges), 1)
+
+    def test_add_edge_with_label(self):
+        self.structure.relate_nodes(self.node1, self.node2, label="test_label")
+        edge = list(self.structure.internal_edges.values())[0]
+        self.assertEqual(edge.label, "test_label")
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/graph/test_graph.py

@@ -0,0 +1,70 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from lionagi.core.graph.graph import Graph
+from lionagi.core.generic.node import Node
+from lionagi.core.generic.edge import Edge
+
+class TestGraph(unittest.TestCase):
+
+    def setUp(self):
+        self.graph = Graph()
+        self.node1 = Node(id_="node1", content="Node 1 content")
+        self.node2 = Node(id_="node2", content="Node 2 content")
+        self.node3 = Node(id_="node3", content="Node 3 content")
+        self.graph.add_node(self.node1)
+        self.graph.add_node(self.node2)
+        self.graph.add_node(self.node3)
+        
+    def test_graph_heads(self):
+        self.graph.relate_nodes(self.node1, self.node2)
+        self.assertEqual(["node1"], self.graph.graph_heads)
+
+
+    def test_acyclic(self):
+        self.graph.relate_nodes(self.node1, self.node2)
+        self.assertTrue(self.graph.acyclic)
+
+        self.graph.relate_nodes(self.node2, self.node1)  # Creating a cycle
+        self.assertFalse(self.graph.acyclic)
+
+    @patch("lionagi.libs.SysUtil.check_import")
+    def test_to_networkx_success(self, mock_check_import):
+        mock_check_import.return_value = None
+        with patch("networkx.DiGraph") as mock_digraph:
+            mock_graph = MagicMock()
+            mock_digraph.return_value = mock_graph
+            result = self.graph.to_networkx()
+            self.assertEqual(result, mock_graph)
+
+    @patch("lionagi.libs.SysUtil.check_import")
+    def test_to_networkx_empty_graph(self, mock_check_import):
+        mock_check_import.return_value = None
+        with patch("networkx.DiGraph") as mock_digraph:
+            mock_graph = MagicMock()
+            mock_digraph.return_value = mock_graph
+
+            self.graph.internal_nodes = {}
+            result = self.graph.to_networkx()
+
+            self.assertEqual(result, mock_graph)
+            mock_check_import.assert_called_once_with("networkx")
+            mock_digraph.assert_called_once()
+            mock_graph.add_node.assert_not_called()
+            mock_graph.add_edge.assert_not_called()
+
+    def test_add_node(self):
+        new_node = Node(id_="node4", content="Node 4 content")
+        self.graph.add_node(new_node)
+        self.assertIn("node4", self.graph.internal_nodes)
+
+    def test_remove_node(self):
+        self.graph.remove_node(self.node1)
+        self.assertNotIn("node1", self.graph.internal_nodes)
+
+    def test_clear(self):
+        self.graph.clear()
+        self.assertEqual(len(self.graph.internal_nodes), 0)
+        self.assertTrue(self.graph.is_empty)
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/graph/test_tree.py

@@ -0,0 +1,75 @@
+import unittest
+from lionagi.core.graph.tree import TreeNode, Tree
+
+class TestTreeNode(unittest.TestCase):
+    def setUp(self):
+        self.parent_node = TreeNode(id_="parent", content="Parent Node")
+        self.child_node1 = TreeNode(id_="child1", content="Child Node 1")
+        self.child_node2 = TreeNode(id_="child2", content="Child Node 2")
+
+    def test_relate_child(self):
+        self.parent_node.relate_child(self.child_node1)
+        self.assertIn("child1", self.parent_node.children)
+        self.assertEqual(self.child_node1.parent, self.parent_node)
+
+    def test_relate_children(self):
+        self.parent_node.relate_child([self.child_node1, self.child_node2])
+        self.assertIn("child1", self.parent_node.children)
+        self.assertIn("child2", self.parent_node.children)
+        self.assertEqual(self.child_node1.parent, self.parent_node)
+        self.assertEqual(self.child_node2.parent, self.parent_node)
+
+    def test_relate_parent(self):
+        self.child_node1.relate_parent(self.parent_node)
+        self.assertIn("child1", self.parent_node.children)
+        self.assertEqual(self.child_node1.parent, self.parent_node)
+
+    def test_unrelate_child(self):
+        self.parent_node.relate_child(self.child_node1)
+        self.parent_node.unrelate_child(self.child_node1)
+        self.assertNotIn("child1", self.parent_node.children)
+        self.assertIsNone(self.child_node1.parent)
+
+    def test_unrelate_parent(self):
+        self.child_node1.relate_parent(self.parent_node)
+        self.child_node1.unrelate_parent()
+        self.assertNotIn("child1", self.parent_node.children)
+        self.assertIsNone(self.child_node1.parent)
+
+class TestTree(unittest.TestCase):
+    def setUp(self):
+        self.tree = Tree()
+        self.root = TreeNode(id_="root", content="Root Node")
+        self.child_node1 = TreeNode(id_="child1", content="Child Node 1")
+        self.child_node2 = TreeNode(id_="child2", content="Child Node 2")
+        self.grandchild_node = TreeNode(id_="grandchild", content="Grandchild Node")
+
+    def test_add_node(self):
+        self.tree.add_node(self.root)
+        self.assertIn("root", self.tree.internal_nodes)
+
+    def test_relate_parent_child(self):
+        self.tree.relate_parent_child(self.root, [self.child_node1, self.child_node2])
+        self.assertIn("child1", self.root.children)
+        self.assertIn("child2", self.root.children)
+        self.assertEqual(self.tree.root, self.root)
+
+    def test_tree_structure(self):
+        # Build the tree
+        self.tree.relate_parent_child(self.root, [self.child_node1, self.child_node2])
+        self.tree.relate_parent_child(self.child_node1, self.grandchild_node)
+
+        # Check the tree structure
+        self.assertIn("grandchild", self.child_node1.children)
+        self.assertEqual(self.grandchild_node.parent, self.child_node1)
+        self.assertEqual(self.child_node1.parent, self.root)
+
+    def test_acyclic(self):
+        # Build the tree
+        self.tree.relate_parent_child(self.root, self.child_node1)
+        self.tree.relate_parent_child(self.child_node1, self.child_node2)
+        # Trees should always be acyclic
+        self.assertTrue(self.tree.acyclic)
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/mail/test_mail.py

@@ -0,0 +1,62 @@
+from lionagi.core.generic.mail import *
+
+import unittest
+
+
+class TestMail(unittest.TestCase):
+    def setUp(self):
+        self.mail = Mail(
+            sender="node1",
+            recipient="node2",
+            category=MailPackageCategory.MESSAGES,
+            package="Hello, World!"
+        )
+
+    def test_mail_initialization(self):
+        """Test initialization of Mail objects."""
+        self.assertIsInstance(self.mail, BaseComponent)
+        self.assertEqual(self.mail.sender, "node1")
+        self.assertEqual(self.mail.recipient, "node2")
+        self.assertEqual(self.mail.category, MailPackageCategory.MESSAGES)
+        self.assertEqual(self.mail.package, "Hello, World!")
+
+    def test_mail_str(self):
+        """Test the string representation of Mail."""
+        expected_str = "Mail from node1 to node2 with category messages and package Hello, World!"
+        self.assertEqual(str(self.mail), expected_str)
+
+class TestMailBox(unittest.TestCase):
+    def setUp(self):
+        self.mailbox = MailBox()
+        self.mail1 = Mail(
+            sender="node1",
+            recipient="node3",
+            category="model",
+            package={"model": "Random Forest"}
+        )
+        self.mail2 = Mail(
+            sender="node2",
+            recipient="node3",
+            category=MailPackageCategory.SERVICE,
+            package={"service": "Prediction"}
+        )
+
+    def test_adding_mails(self):
+        """Test adding mails to MailBox."""
+        self.mailbox.pending_ins["node1"] = self.mail1
+        self.mailbox.pending_outs["node3"] = self.mail2
+
+        self.assertIn("node1", self.mailbox.pending_ins)
+        self.assertIn("node3", self.mailbox.pending_outs)
+        self.assertEqual(self.mailbox.pending_ins["node1"], self.mail1)
+        self.assertEqual(self.mailbox.pending_outs["node3"], self.mail2)
+
+    def test_mailbox_str(self):
+        """Test the string representation of MailBox."""
+        self.mailbox.pending_ins["node1"] = self.mail1
+        self.mailbox.pending_outs["node3"] = self.mail2
+        expected_str = "MailBox with 1 pending incoming mails and 1 pending outgoing mails."
+        self.assertEqual(str(self.mailbox), expected_str)
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/test_structure/test_base_structure.py

@@ -0,0 +1,196 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from lionagi.core.tool.structure import *
+
+
+class TestBaseStructure(unittest.TestCase):
+    def setUp(self):
+        self.structure = BaseStructure()
+        self.node1 = BaseNode(id_="node1")
+        self.node2 = BaseNode(id_="node2")
+        self.node3 = BaseNode(id_="node3")
+        self.edge1 = Edge(id_="edge1", source_node_id="node1", target_node_id="node2")
+        self.edge2 = Edge(id_="edge2", source_node_id="node2", target_node_id="node3")
+
+    def test_node_edges_property(self):
+        self.node1.in_relations = {"edge1": self.edge1}
+        self.node1.out_relations = {"edge2": self.edge2}
+        self.structure.structure_nodes = {"node1": self.node1}
+        expected_result = {
+            "node1": {"in": {"edge1": self.edge1}, "out": {"edge2": self.edge2}}
+        }
+        self.assertEqual(self.structure.node_edges, expected_result)
+
+    def test_get_node_edges_with_node(self):
+        self.node1.out_relations = {"edge1": self.edge1}
+        self.node1.in_relations = {"edge2": self.edge2}
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertEqual(
+            self.structure.get_node_edges(self.node1, direction="out"), [self.edge1]
+        )
+        self.assertEqual(
+            self.structure.get_node_edges(self.node1, direction="in"), [self.edge2]
+        )
+        self.assertEqual(
+            self.structure.get_node_edges(self.node1, direction="all"),
+            [self.edge2, self.edge1],
+        )
+
+    def test_get_node_edges_without_node(self):
+        self.structure.structure_edges = {"edge1": self.edge1, "edge2": self.edge2}
+        self.assertEqual(self.structure.get_node_edges(), [self.edge1, self.edge2])
+
+    def test_get_node_edges_node_not_found(self):
+        invalid_node = BaseNode(id_="invalid_node")
+        try:
+            self.structure.get_node_edges(invalid_node)
+        except KeyError as e:
+            self.assertEqual(str(e), f"node {invalid_node.id_} is not found")
+
+    def test_has_structure_edge_with_edge_object(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.assertTrue(self.structure.has_structure_edge(self.edge1))
+
+    def test_has_structure_edge_with_edge_id(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.assertTrue(self.structure.has_structure_edge("edge1"))
+
+    def test_get_structure_edge_with_edge_object(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.assertEqual(self.structure.get_structure_edge(self.edge1), self.edge1)
+
+    def test_get_structure_edge_with_edge_id(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.assertEqual(self.structure.get_structure_edge("edge1"), self.edge1)
+
+    def test_add_structure_edge_success(self):
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.structure.add_structure_edge(self.edge1)
+        self.assertEqual(self.structure.structure_edges, {"edge1": self.edge1})
+        self.assertEqual(self.node1.out_relations, {"node2": self.edge1})
+        self.assertEqual(self.node2.in_relations, {"node1": self.edge1})
+
+    def test_add_structure_edge_failure(self):
+        with self.assertRaises(ValueError):
+            self.structure.add_structure_edge(self.edge1)
+
+    def test_remove_structure_edge_with_edge_object(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.node1.out_relations = {"node2": self.edge1}
+        self.node2.in_relations = {"node1": self.edge1}
+        self.structure.remove_structure_edge(self.edge1)
+        self.assertEqual(self.structure.structure_edges, {})
+        self.assertEqual(self.node1.out_relations, {})
+        self.assertEqual(self.node2.in_relations, {})
+
+    def test_remove_structure_edge_with_edge_id(self):
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.node1.out_relations = {"node2": self.edge1}
+        self.node2.in_relations = {"node1": self.edge1}
+        self.structure.remove_structure_edge("edge1")
+        self.assertEqual(self.structure.structure_edges, {})
+        self.assertEqual(self.node1.out_relations, {})
+        self.assertEqual(self.node2.in_relations, {})
+
+    def test_remove_structure_node_success(self):
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.node1.out_relations = {"node2": self.edge1}
+        self.node2.in_relations = {"node1": self.edge1}
+        self.structure.remove_structure_node(self.node1)
+        self.assertEqual(self.structure.structure_nodes, {"node2": self.node2})
+        self.assertEqual(self.structure.structure_edges, {})
+
+    def test_remove_structure_node_failure(self):
+        with self.assertRaises(ValueError):
+            self.structure.remove_structure_node(self.node1)
+
+    def test_add_structure_node_with_base_node(self):
+        self.structure.add_structure_node(self.node1)
+        self.assertEqual(self.structure.structure_nodes, {"node1": self.node1})
+
+    def test_add_structure_node_with_list(self):
+        self.structure.add_structure_node([self.node1, self.node2])
+        self.assertEqual(
+            self.structure.structure_nodes, {"node1": self.node1, "node2": self.node2}
+        )
+
+    def test_add_structure_node_with_dict(self):
+        self.structure.add_structure_node({"node1": self.node1, "node2": self.node2})
+        self.assertEqual(
+            self.structure.structure_nodes, {"node1": self.node1, "node2": self.node2}
+        )
+
+    def test_add_structure_node_unsupported_type(self):
+        with self.assertRaises(NotImplementedError):
+            self.structure.add_structure_node(1)
+
+    def test_get_structure_node_with_node_id(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertEqual(self.structure.get_structure_node("node1"), self.node1)
+
+    def test_get_structure_node_with_base_node(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertEqual(self.structure.get_structure_node(self.node1), self.node1)
+
+    def test_get_structure_node_with_list(self):
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.assertEqual(
+            self.structure.get_structure_node(["node1", "node2"]),
+            [self.node1, self.node2],
+        )
+
+    def test_pop_structure_node_with_node_id(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertEqual(self.structure.pop_structure_node("node1"), self.node1)
+        self.assertEqual(self.structure.structure_nodes, {})
+
+    def test_pop_structure_node_with_base_node(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertEqual(self.structure.pop_structure_node(self.node1), self.node1)
+        self.assertEqual(self.structure.structure_nodes, {})
+
+    def test_pop_structure_node_with_list(self):
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.assertEqual(
+            self.structure.pop_structure_node(["node1", "node2"]),
+            [self.node1, self.node2],
+        )
+        self.assertEqual(self.structure.structure_nodes, {})
+
+    def test_pop_structure_node_unsupported_type(self):
+        with self.assertRaises(NotImplementedError):
+            self.structure.pop_structure_node(1)
+
+    def test_has_structure_node_with_node_id(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertTrue(self.structure.has_structure_node("node1"))
+        self.assertFalse(self.structure.has_structure_node("node2"))
+
+    def test_has_structure_node_with_base_node(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertTrue(self.structure.has_structure_node(self.node1))
+        self.assertFalse(self.structure.has_structure_node(self.node2))
+
+    def test_has_structure_node_with_list(self):
+        self.structure.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.assertTrue(self.structure.has_structure_node(["node1", "node2"]))
+        self.assertFalse(self.structure.has_structure_node(["node1", "node3"]))
+
+    def test_is_empty_property(self):
+        self.assertTrue(self.structure.is_empty)
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.assertFalse(self.structure.is_empty)
+
+    def test_clear_method(self):
+        self.structure.structure_nodes = {"node1": self.node1}
+        self.structure.structure_edges = {"edge1": self.edge1}
+        self.structure.clear()
+        self.assertEqual(self.structure.structure_nodes, {})
+        self.assertEqual(self.structure.structure_edges, {})
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/test_structure/test_graph.py

@@ -0,0 +1,54 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from lionagi.core.generic import BaseNode, Edge
+from lionagi.new.schema.todo.graph import Graph
+
+
+class TestGraph(unittest.TestCase):
+    def setUp(self):
+        self.graph = Graph()
+        self.node1 = BaseNode(id_="node1", content="Node 1")
+        self.node2 = BaseNode(id_="node2", content="Node 2")
+        self.edge1 = Edge(
+            id_="edge1", source_node_id="node1", target_node_id="node2", label="Edge 1"
+        )
+        self.graph.structure_nodes = {"node1": self.node1, "node2": self.node2}
+        self.graph.structure_edges = {"edge1": self.edge1}
+
+    @patch("lionagi.libs.SysUtil.check_import")
+    def test_to_networkx_success(self, mock_check_import):
+        mock_check_import.return_value = None
+        with patch("networkx.DiGraph") as mock_digraph:
+            mock_graph = MagicMock()
+            mock_digraph.return_value = mock_graph
+
+            result = self.graph.to_networkx()
+
+            self.assertEqual(result, mock_graph)
+
+    @patch("lionagi.libs.SysUtil.check_import")
+    def test_to_networkx_empty_graph(self, mock_check_import):
+        mock_check_import.return_value = None
+        with patch("networkx.DiGraph") as mock_digraph:
+            mock_graph = MagicMock()
+            mock_digraph.return_value = mock_graph
+
+            self.graph.structure_nodes = {}
+            self.graph.structure_edges = {}
+            result = self.graph.to_networkx()
+
+            self.assertEqual(result, mock_graph)
+            mock_check_import.assert_called_once_with("networkx")
+            mock_digraph.assert_called_once()
+            mock_graph.add_node.assert_not_called()
+            mock_graph.add_edge.assert_not_called()
+
+    @patch("lionagi.libs.SysUtil.check_import", side_effect=ImportError)
+    def test_to_networkx_import_error(self, mock_check_import):
+        with self.assertRaises(ImportError):
+            self.graph.to_networkx()
+        mock_check_import.assert_called_once_with("networkx")
+
+
+if __name__ == "__main__":
+    unittest.main()