lionagi 0.2.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

lionagi/tests/test_core/generic/test_node.py

@@ -1,107 +0,0 @@
-import unittest
-
-from lionagi.core.collections.abc import Condition, RelationError
-from lionagi.core.generic import Node
-from lionagi.core.generic.edge import Edge
-
-
-class TestNode(unittest.TestCase):
-
-    def setUp(self):
-        """Setup nodes for testing."""
-        self.node_a = Node()
-        self.node_b = Node()
-        self.node_c = Node()
-
-    def test_initialization(self):
-        """Test that a Node initializes with empty relations."""
-        self.assertEqual(len(self.node_a.relations["in"]), 0)
-        self.assertEqual(len(self.node_a.relations["out"]), 0)
-
-    def test_relate_outgoing(self):
-        """Test relating nodes with an outgoing edge."""
-        self.node_a.relate(self.node_b, "out")
-        self.assertIn(self.node_b.ln_id, self.node_a.related_nodes)
-        self.assertIn(self.node_a.ln_id, self.node_b.related_nodes)
-        self.assertIn(self.node_b.ln_id, self.node_a.successors)
-        self.assertIn(self.node_a.ln_id, self.node_b.predecessors)
-
-    def test_relate_incoming(self):
-        """Test relating nodes with an incoming edge."""
-        self.node_a.relate(self.node_c, "in")
-        self.assertIn(self.node_c.ln_id, self.node_a.related_nodes)
-        self.assertIn(self.node_a.ln_id, self.node_c.related_nodes)
-        self.assertIn(self.node_a.ln_id, self.node_c.successors)
-        self.assertIn(self.node_c.ln_id, self.node_a.predecessors)
-
-    def test_invalid_relate(self):
-        """Test that relating nodes with an invalid direction raises ValueError."""
-        with self.assertRaises(ValueError):
-            self.node_a.relate(self.node_b, "invalid_direction")
-
-    def test_remove_edge(self):
-        """Test removing a specific edge between nodes."""
-        self.node_a.relate(self.node_b, "out")
-        edge = next(iter(self.node_a.relations["out"]))
-        self.assertTrue(self.node_a.remove_edge(self.node_b, edge))
-
-    def test_unrelate_all_edges(self):
-        """Test unrelating all edges between nodes."""
-        self.node_a.relate(self.node_b, "out")
-        self.assertTrue(self.node_a.unrelate(self.node_b))
-        self.assertNotIn(self.node_b.ln_id, self.node_a.related_nodes)
-        self.assertNotIn(self.node_a.ln_id, self.node_b.related_nodes)
-
-    def test_unrelate_specific_edge(self):
-        """Test unrelating a specific edge between nodes."""
-        self.node_a.relate(self.node_b, "out")
-        edge = next(iter(self.node_a.relations["out"]))
-        self.assertTrue(self.node_a.unrelate(self.node_b, edge))
-        self.assertNotIn(self.node_b.ln_id, self.node_a.related_nodes)
-        self.assertNotIn(self.node_a.ln_id, self.node_b.related_nodes)
-
-    def test_node_relations(self):
-        """Test that node relations are correctly categorized."""
-        self.node_a.relate(self.node_b, "out")
-        self.node_a.relate(self.node_c, "in")
-        relations = self.node_a.node_relations
-        self.assertIn(self.node_b.ln_id, relations["out"])
-        self.assertIn(self.node_c.ln_id, relations["in"])
-
-    def test_related_nodes(self):
-        """Test that related nodes list is correct."""
-        self.node_a.relate(self.node_b, "out")
-        self.node_a.relate(self.node_c, "in")
-        related_nodes = self.node_a.related_nodes
-        self.assertIn(self.node_b.ln_id, related_nodes)
-        self.assertIn(self.node_c.ln_id, related_nodes)
-
-    def test_predecessors(self):
-        """Test that predecessors list is correct."""
-        self.node_a.relate(self.node_c, "in")
-        self.assertIn(self.node_c.ln_id, self.node_a.predecessors)
-
-    def test_successors(self):
-        """Test that successors list is correct."""
-        self.node_a.relate(self.node_b, "out")
-        self.assertIn(self.node_b.ln_id, self.node_a.successors)
-
-    def test_str(self):
-        """Test the string representation of a node."""
-        self.node_a.relate(self.node_b, "out")
-        node_str = str(self.node_a)
-        self.assertIn(self.node_a.ln_id, node_str)
-        self.assertIn("relations", node_str)
-        self.assertIn("1", node_str)  # 1 relation
-
-    def test_repr(self):
-        """Test the repr representation of a node."""
-        self.node_a.relate(self.node_b, "out")
-        node_repr = repr(self.node_a)
-        self.assertIn(self.node_a.ln_id, node_repr)
-        self.assertIn("relations", node_repr)
-        self.assertIn("1", node_repr)  # 1 relation
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/generic/test_structure.py

@@ -1,194 +0,0 @@
-# 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/generic/test_tree_node.py

@@ -1,74 +0,0 @@
-import unittest
-
-from lionagi.core.generic.tree import Tree
-from lionagi.core.generic.tree_node import TreeNode
-
-
-class TestTreeNode(unittest.TestCase):
-
-    def setUp(self):
-        self.tree_node1 = TreeNode()
-        self.tree_node2 = TreeNode()
-        self.tree_node3 = TreeNode()
-        self.tree_node4 = TreeNode()
-        self.tree = Tree()
-
-    def test_initialization(self):
-        self.assertIsNone(self.tree_node1.parent)
-        self.assertEqual(self.tree_node1.children, [])
-        self.assertIsInstance(self.tree_node1, TreeNode)
-        self.assertIsInstance(self.tree_node1.ln_id, str)
-
-    def test_relate_child(self):
-        self.tree_node1.relate_child([self.tree_node2, self.tree_node3])
-        self.assertIn(self.tree_node2.ln_id, self.tree_node1.children)
-        self.assertIn(self.tree_node3.ln_id, self.tree_node1.children)
-        self.assertEqual(self.tree_node2.parent, self.tree_node1)
-        self.assertEqual(self.tree_node3.parent, self.tree_node1)
-
-    def test_relate_parent(self):
-        self.tree_node1.relate_parent(self.tree_node4)
-        self.assertEqual(self.tree_node1.parent, self.tree_node4)
-        self.assertIn(self.tree_node1.ln_id, self.tree_node4.children)
-
-    def test_unrelate_parent(self):
-        self.tree_node1.relate_parent(self.tree_node4)
-        self.tree_node1.unrelate_parent()
-        self.assertIsNone(self.tree_node1.parent)
-
-    def test_unrelate_child(self):
-        self.tree_node1.relate_child([self.tree_node2, self.tree_node3])
-        self.tree_node1.unrelate_child([self.tree_node2, self.tree_node3])
-        self.assertNotIn(self.tree_node2.ln_id, self.tree_node1.children)
-        self.assertNotIn(self.tree_node3.ln_id, self.tree_node1.children)
-        self.assertIsNone(self.tree_node2.parent)
-        self.assertIsNone(self.tree_node3.parent)
-
-    def test_tree_integration(self):
-        self.tree.relate_parent_child(
-            self.tree_node1, [self.tree_node2, self.tree_node3, self.tree_node4]
-        )
-        self.assertEqual(len(self.tree.internal_nodes), 4)
-        self.assertEqual(len(self.tree_node1.children), 3)
-        self.assertEqual(self.tree.root, self.tree_node1)
-
-    def test_tree_node_edges(self):
-        self.tree_node1.relate_child([self.tree_node2, self.tree_node3])
-        df = self.tree_node1.edges.to_df()
-        self.assertEqual(len(df), 2)
-        self.assertIn(self.tree_node2.ln_id, df["tail"].values)
-        self.assertIn(self.tree_node3.ln_id, df["tail"].values)
-
-    def test_tree_display(self):
-        # This test is mainly to check if the display function runs without errors
-        self.tree.relate_parent_child(
-            self.tree_node1, [self.tree_node2, self.tree_node3, self.tree_node4]
-        )
-        try:
-            self.tree.display()
-        except Exception as e:
-            self.fail(f"Tree display method raised an exception: {e}")
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/graph/test_graph.py

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

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

@@ -1,98 +0,0 @@
-from datetime import datetime
-
-import pytest
-
-from lionagi.core.mail import Mail
-from lionagi.core.mail.package import Package
-
-"""
-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()