lionagi 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

lionagi/tests/test_core/generic/test_structure.py

@@ -0,0 +1,194 @@
+#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

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

lionagi/tests/test_core/graph/test_tree.py

@@ -0,0 +1,76 @@
+#TODO
+# 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,98 @@
+import pytest
+
+from lionagi.core.mail import Mail
+from lionagi.core.mail.package import Package
+from datetime import datetime
+
+"""
+More to be added
+"""
+
+
+def trim_timestamp_to_day(timestamp_str):
+    dt = datetime.fromisoformat(timestamp_str)
+    return dt.strftime('%Y-%m-%d')
+
+
+class MockPackage(Package):
+    """A mock package class for testing purposes."""
+
+
+@pytest.fixture
+def mail():
+    """Fixture to create a Mail instance with a MockPackage."""
+    package = MockPackage()
+    mail_instance = Mail(timestamp=datetime.today().strftime('%Y-%m-%d'), package=package)
+    return mail_instance
+
+
+def test_mail_category(mail):
+    """Test the category property of Mail."""
+    assert mail.category is None
+
+
+
+
+
+# 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,198 @@
+#TODO
+
+# 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()