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

lionagi/tests/test_core/test_branch.py

@@ -1,116 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-import lionagi as li
-from lionagi.core.action.tool_manager import ToolManager
-from lionagi.core.collections import Exchange, Pile, Progression
-from lionagi.core.message import ActionResponse, AssistantResponse, Instruction, System
-
-
-class TestBranch(unittest.TestCase):
-
-    def setUp(self):
-        self.branch = li.Branch()
-
-    def test_initialize_branch(self):
-        self.assertIsInstance(self.branch, li.Branch)
-        self.assertIsInstance(self.branch.messages, Pile)
-        self.assertIsInstance(self.branch.progress, Progression)
-        self.assertIsInstance(self.branch.tool_manager, ToolManager)
-        self.assertIsInstance(self.branch.mailbox, Exchange)
-        self.assertIsInstance(self.branch.imodel, li.iModel)
-
-    def test_add_message_system(self):
-        self.branch.add_message(
-            system="You are a helpful assistant, let's think step by step"
-        )
-        self.assertEqual(len(self.branch.messages), 1)
-        self.assertEqual(
-            self.branch.messages[0].content,
-            {"system_info": "You are a helpful assistant, let's think step by step"},
-        )
-
-    def test_to_df(self):
-        self.branch.add_message(
-            system="You are a helpful assistant, let's think step by step"
-        )
-        df = self.branch.to_df()
-        self.assertEqual(df.iloc[0]["message_type"], "System")
-        self.assertEqual(df.iloc[0]["role"], "system")
-
-    def test_to_chat_messages(self):
-        self.branch.add_message(
-            system="You are a helpful assistant, let's think step by step"
-        )
-        chat_msgs = self.branch.to_chat_messages()
-        self.assertEqual(chat_msgs[0]["role"], "system")
-        self.assertEqual(
-            chat_msgs[0]["content"],
-            "You are a helpful assistant, let's think step by step",
-        )
-
-    @patch("lionagi.Branch.chat")
-    async def test_chat(self, mock_chat):
-        mock_chat.return_value = (
-            "Rain poured, but their love shone brighter than any storm."
-        )
-        response = await self.branch.chat("tell me a 10 word story", logprobs=True)
-        self.assertEqual(
-            response, "Rain poured, but their love shone brighter than any storm."
-        )
-        mock_chat.assert_called_once_with("tell me a 10 word story", logprobs=True)
-
-    def test_metadata(self):
-        self.branch.add_message(
-            system="You are a helpful assistant, let's think step by step"
-        )
-        self.assertIn("last_updated", self.branch.messages[0].metadata)
-
-    # def test_register_tools(self):
-    #     tool = MagicMock()
-    #     self.branch.register_tools([tool])
-    #     self.assertIn(tool, self.branch.tool_manager.registry.values())
-
-    # def test_delete_tools(self):
-    #     tool = MagicMock()
-    #     tool.schema_ = {"function": {"name": "test_tool"}}
-    #     self.branch.register_tools([tool])
-    #     self.branch.delete_tools([tool])
-    #     self.assertNotIn("test_tool", self.branch.tool_manager.registry)
-
-    def test_send_receive_mail(self):
-        self.branch.send = MagicMock()
-        self.branch.receive = MagicMock()
-        package = MagicMock()
-        self.branch.send(recipient="recipient_id", category="message", package=package)
-        self.branch.receive(sender="recipient_id")
-        self.branch.send.assert_called_once_with(
-            recipient="recipient_id", category="message", package=package
-        )
-        self.branch.receive.assert_called_once_with(sender="recipient_id")
-
-    async def test_chat_with_tool(self):
-        async def mock_multiply(number1, number2, number3=1):
-            return number1 * number2 * number3
-
-        instruction = """
-        solve the following problem
-        """
-        context = """
-        I have 730_000 trees, with average 123 apples per tree, each weigh 0.4 lbs. 
-        20 percent are bad and sold for 0.1 dollar per lbs, 30 percent are sold to 
-        brewery for 0.3 dollar per apple, what is my revenue?
-        """
-
-        self.branch = li.Branch(
-            "act like a calculator, invoke tool uses", tools=[mock_multiply]
-        )
-        response = await self.branch.chat(
-            instruction=instruction, context=context, tools=True
-        )
-        self.assertIsNotNone(response)
-        self.assertIn("revenue", response.lower())
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/test_form.py

@@ -1,47 +0,0 @@
-import unittest
-
-from lionagi import Form
-
-
-class TestForm(unittest.TestCase):
-
-    def setUp(self):
-        self.form = Form(assignment="input1, input2 -> output")
-
-    def test_initial_state(self):
-        self.assertEqual(self.form.input_fields, ["input1", "input2"])
-        self.assertEqual(self.form.requested_fields, ["output"])
-        self.assertFalse(self.form.workable)
-        self.assertFalse(self.form.filled)
-        self.assertEqual(
-            self.form.work_fields, {"input1": None, "input2": None, "output": None}
-        )
-
-    def test_fill_input_fields(self):
-        self.form.fill(input1=1, input2=2)
-        self.assertTrue(self.form.workable)
-        self.assertFalse(self.form.filled)
-        self.assertEqual(
-            self.form.work_fields, {"input1": 1, "input2": 2, "output": None}
-        )
-
-    def test_fill_all_fields(self):
-        self.form.fill(input1=1, input2=2)
-        self.form.fill(output=3)
-        self.assertTrue(self.form.filled)
-        self.assertFalse(self.form.workable)
-        self.assertEqual(self.form.work_fields, {"input1": 1, "input2": 2, "output": 3})
-
-    def test_fill_once(self):
-        self.form.fill(input1=1, input2=2)
-        self.form.fill(output=3)
-        with self.assertRaises(ValueError) as context:
-            self.form.fill(input1=2, input2=3)
-        self.assertTrue(
-            "Form is filled, cannot be worked on again" in str(context.exception)
-        )
-        self.assertEqual(self.form.work_fields, {"input1": 1, "input2": 2, "output": 3})
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/test_report.py

@@ -1,106 +0,0 @@
-import unittest
-
-from lionagi.core.report.form import Form
-from lionagi.core.report.report import Report
-
-
-class TestForm(unittest.TestCase):
-
-    def setUp(self):
-        self.form = Form(assignment="input1, input2 -> output")
-
-    def test_initial_fields(self):
-        self.assertEqual(self.form.input_fields, ["input1", "input2"])
-        self.assertEqual(self.form.requested_fields, ["output"])
-        self.assertFalse(self.form.workable)
-        self.assertFalse(self.form.filled)
-        self.assertEqual(
-            self.form.work_fields, {"input1": None, "input2": None, "output": None}
-        )
-
-    def test_fill_input_fields(self):
-        self.form.fill(input1=1, input2=2)
-        self.assertTrue(self.form.workable)
-        self.assertFalse(self.form.filled)
-        self.assertEqual(
-            self.form.work_fields, {"input1": 1, "input2": 2, "output": None}
-        )
-
-    def test_fill_output_field(self):
-        self.form.fill(input1=1, input2=2)
-        self.form.fill(output=3)
-        self.assertTrue(self.form.filled)
-        self.assertEqual(self.form.work_fields, {"input1": 1, "input2": 2, "output": 3})
-        self.assertFalse(self.form.workable)
-
-    def test_fill_again_raises_error(self):
-        self.form.fill(input1=1, input2=2, output=3)
-        with self.assertRaises(ValueError):
-            self.form.fill(input1=2, input2=3)
-
-
-class TestReport(unittest.TestCase):
-
-    def setUp(self):
-        self.report = Report(assignment="a, b -> c")
-
-    def test_initial_fields(self):
-        self.assertEqual(self.report.input_fields, ["a", "b"])
-        self.assertEqual(self.report.requested_fields, ["c"])
-        self.assertEqual(self.report.work_fields, {"a": None, "b": None, "c": None})
-        self.assertFalse(self.report.filled)
-        self.assertFalse(self.report.workable)
-
-    def test_fill_input_fields(self):
-        self.report.fill(a=3, b=4)
-        self.assertEqual(self.report.work_fields, {"a": 3, "b": 4, "c": None})
-        self.assertTrue(self.report.workable)
-
-    def test_fill_output_field(self):
-        self.report.fill(a=3, b=4)
-        self.report.fill(c=4)
-        self.assertEqual(self.report.work_fields, {"a": 3, "b": 4, "c": 4})
-        self.assertTrue(self.report.filled)
-        self.assertFalse(self.report.workable)
-
-    def test_next_forms_none(self):
-        self.assertIsNone(self.report.next_forms())
-
-    def test_complex_assignment(self):
-        self.report = Report(
-            assignment="a, b -> h",
-            form_assignments=[
-                "a, b -> c",
-                "a -> e",
-                "b -> f",
-                "c -> g",
-                "e, f, g -> h",
-            ],
-            a=3,
-            b=4,
-        )
-        self.assertEqual(
-            self.report.work_fields,
-            {
-                "a": None,
-                "b": None,
-                "c": None,
-                "e": None,
-                "f": None,
-                "g": None,
-                "h": None,
-            },
-        )
-        self.report.fill(c=5, e=6, f=7, g=8, h=10)
-        self.assertEqual(
-            self.report.work_fields,
-            {"a": None, "b": None, "c": 5, "e": 6, "f": 7, "g": 8, "h": 10},
-        )
-        self.assertFalse(self.report.filled)
-        self.assertFalse(self.report.workable)
-        with self.assertRaises(ValueError):
-            self.report.fill(c="xx", e="yy")
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/test_structure/test_base_structure.py

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