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

lionagi/tests/test_core/test_structure/test_base_structure.py

@@ -1,196 +1,198 @@
-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()
+#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()

lionagi/tests/test_core/test_structure/test_graph.py

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

lionagi/tests/test_core/test_structure/test_tree.py

@@ -1,48 +1,49 @@
-import unittest
-from lionagi.new.schema.todo.tree import Tree
-from lionagi.core.generic import TreeNode
-
-
-class TestTree(unittest.TestCase):
-    def setUp(self):
-        self.tree = Tree()
-        self.node1 = TreeNode(id_="node1", content="Node 1")
-        self.node2 = TreeNode(id_="node2", content="Node 2")
-        self.node3 = TreeNode(id_="node3", content="Node 3")
-        self.tree.add_structure_node(self.node1)
-        self.tree.add_structure_node(self.node2)
-        self.tree.add_structure_node(self.node3)
-
-    def test_add_parent_to_child(self):
-        self.tree.add_parent_to_child(self.node1, self.node2)
-        self.assertEqual(self.node2, self.node1.parent)
-        self.assertIn(self.node1, self.node2.children)
-
-    def test_add_child_to_parent(self):
-        self.tree.add_child_to_parent(self.node3, self.node2)
-        self.assertEqual(self.node2, self.node3.parent)
-        self.assertIn(self.node3, self.node2.children)
-
-    def test_find_parent(self):
-        self.tree.add_parent_to_child(self.node1, self.node2)
-        parent = self.tree.find_parent(self.node1)
-        self.assertEqual(self.node2, parent)
-
-    def test_find_child(self):
-        self.tree.add_parent_to_child(self.node1, self.node2)
-        children = self.tree.find_child(self.node2)
-        self.assertIn(self.node1, children)
-
-    def test_parent_child_relationship(self):
-        self.tree.add_parent_to_child(self.node1, self.node2)
-        self.tree.add_child_to_parent(self.node3, self.node2)
-        self.assertIn(self.node1, self.node2.children)
-        self.assertIn(self.node3, self.node2.children)
-        self.assertEqual(self.node2, self.node1.parent)
-        self.assertEqual(self.node2, self.node3.parent)
-
-    # Add more tests as necessary to cover edge cases and other functionalities
-
-
-if __name__ == "__main__":
-    unittest.main()
+#TODO
+# import unittest
+# from lionagi.new.schema.todo.tree import Tree
+# from lionagi.core.generic import TreeNode
+#
+#
+# class TestTree(unittest.TestCase):
+#     def setUp(self):
+#         self.tree = Tree()
+#         self.node1 = TreeNode(id_="node1", content="Node 1")
+#         self.node2 = TreeNode(id_="node2", content="Node 2")
+#         self.node3 = TreeNode(id_="node3", content="Node 3")
+#         self.tree.add_structure_node(self.node1)
+#         self.tree.add_structure_node(self.node2)
+#         self.tree.add_structure_node(self.node3)
+#
+#     def test_add_parent_to_child(self):
+#         self.tree.add_parent_to_child(self.node1, self.node2)
+#         self.assertEqual(self.node2, self.node1.parent)
+#         self.assertIn(self.node1, self.node2.children)
+#
+#     def test_add_child_to_parent(self):
+#         self.tree.add_child_to_parent(self.node3, self.node2)
+#         self.assertEqual(self.node2, self.node3.parent)
+#         self.assertIn(self.node3, self.node2.children)
+#
+#     def test_find_parent(self):
+#         self.tree.add_parent_to_child(self.node1, self.node2)
+#         parent = self.tree.find_parent(self.node1)
+#         self.assertEqual(self.node2, parent)
+#
+#     def test_find_child(self):
+#         self.tree.add_parent_to_child(self.node1, self.node2)
+#         children = self.tree.find_child(self.node2)
+#         self.assertIn(self.node1, children)
+#
+#     def test_parent_child_relationship(self):
+#         self.tree.add_parent_to_child(self.node1, self.node2)
+#         self.tree.add_child_to_parent(self.node3, self.node2)
+#         self.assertIn(self.node1, self.node2.children)
+#         self.assertIn(self.node3, self.node2.children)
+#         self.assertEqual(self.node2, self.node1.parent)
+#         self.assertEqual(self.node2, self.node3.parent)
+#
+#     # Add more tests as necessary to cover edge cases and other functionalities
+#
+#
+# if __name__ == "__main__":
+#     unittest.main()

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.2.2"
+__version__ = "0.2.3"