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

lionagi/core/engine/branch_engine.py

@@ -44,7 +44,7 @@ class BranchExecutor(Branch, BaseExecutor):
         it processes starts, nodes, node lists, conditions, or ends, accordingly executing different functions.
         """
         for key in list(self.mailbox.pending_ins.keys()):
-            while self.mailbox.pending_ins[key].size() > 0:
+            while self.mailbox.pending_ins.get(key, Pile()).size() > 0:
                 mail_id = self.mailbox.pending_ins[key].popleft()
                 mail = self.mailbox.pile.pop(mail_id)
                 if mail.category == "start":
@@ -57,7 +57,7 @@ class BranchExecutor(Branch, BaseExecutor):
                     await self._process_condition(mail)
                 elif mail.category == "end":
                     self._process_end(mail)
-            if self.mailbox.pending_ins[key].size() == 0:
+            if key in self.mailbox.pending_ins and self.mailbox.pending_ins.get(key, Pile()).size() == 0:
                 self.mailbox.pending_ins.pop(key)
 
     async def execute(self, refresh_time=1) -> None:
@@ -118,8 +118,8 @@ class BranchExecutor(Branch, BaseExecutor):
                     package=node.ln_id,
                     request_source=self.ln_id,
                 )
-            except:
-                raise ValueError(f"Invalid mail to process. Mail:{mail}")
+            except Exception as e:
+                raise ValueError(f"Invalid mail to process. Mail:{mail}, Error: {e}")
 
     def _process_node_list(self, mail: Mail):
         """

lionagi/integrations/provider/litellm.py

@@ -26,9 +26,10 @@ class LiteLLMService(BaseService):
 
         SysUtil.check_import("litellm")
 
-        from litellm import acompletion
-
-        self.acompletion = acompletion
+        import litellm
+        litellm.drop_params = True
+        
+        self.acompletion = litellm.acompletion
         self.model = model
         self.kwargs = kwargs
         self.allowed_kwargs = allowed_kwargs
@@ -41,12 +42,13 @@ class LiteLLMService(BaseService):
                 config[k] = v
 
         kwargs = {**self.kwargs, **config}
+        kwargs["model"] = self.model or kwargs.get("model")
 
         try:
             completion = await self.acompletion(
-                model=self.model, messages=messages, **kwargs
+                messages=messages, **kwargs
             )
-            return payload, completion
+            return payload, completion.model_dump()
         except Exception as e:
             self.status_tracker.num_tasks_failed += 1
             raise e

lionagi/tests/api/aws/conftest.py

@@ -0,0 +1,28 @@
+import pytest
+from api.apicore import _connect as _connect_
+from api.apicore import _config as _config_
+
+
+"""
+Setup the testing construct to ease future testing cases
+"""
+
+
+@pytest.fixture()
+def config():
+    _config = _config_.ConfigSingleton()
+    _config.config["MOCK"] = True  # turn on mock mode
+    yield _config
+
+
+@pytest.fixture
+def test_s3_conn(config):
+    yield _connect_.get_object("AWSS3")
+
+
+@pytest.fixture
+def test_ec2_conn(config):
+    yield _connect_.get_object("AWSEC2")
+
+
+

lionagi/tests/api/aws/test_aws_s3.py

@@ -0,0 +1,7 @@
+from moto import mock_aws
+
+
+@mock_aws
+def test_awss3_list_bucket_pass(test_s3_conn):
+    assert test_s3_conn.list_bucket_names() == []
+

lionagi/tests/test_core/generic/test_structure.py

@@ -1,193 +1,194 @@
-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()
+#TODO
+# 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

@@ -1,70 +1,71 @@
-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()
+#TODO
+# 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()