lionagi 0.2.2__tar.gz → 0.2.4__tar.gz

{lionagi-0.2.2 → lionagi-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.2.2
+Version: 0.2.4
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -222,6 +222,10 @@ Requires-Dist: tiktoken>=0.5.1
 Requires-Dist: pydantic>=2.6.0
 Requires-Dist: aiocache>=0.12.2
 Requires-Dist: pandas>=2.1.0
+Requires-Dist: pytest>=8.2.2
+Requires-Dist: moto>=5.0.9
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: boto3>=1.34.131
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 
@@ -230,10 +234,10 @@ Requires-Dist: pandas>=2.1.0
 
 
 # Language InterOperable Network - LION
-### An AGentic Intelligence Operating System
+### an AGentic Intelligence Operating System
 
 ```
-pip install lionagi==0.2.2
+pip install lionagi==0.2.3
 ```
 
 **Powerful Intelligent Workflow Automation**

{lionagi-0.2.2 → lionagi-0.2.4}/README.md

@@ -5,10 +5,10 @@
 
 
 # Language InterOperable Network - LION
-### An AGentic Intelligence Operating System
+### an AGentic Intelligence Operating System
 
 ```
-pip install lionagi==0.2.2
+pip install lionagi==0.2.3
 ```
 
 **Powerful Intelligent Workflow Automation**

{lionagi-0.2.2 → lionagi-0.2.4}/lionagi/core/engine/branch_engine.py

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

{lionagi-0.2.2 → lionagi-0.2.4}/lionagi/integrations/provider/litellm.py

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

lionagi-0.2.4/lionagi/tests/api/aws/conftest.py

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

lionagi-0.2.4/lionagi/tests/api/aws/test_aws_s3.py

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

lionagi-0.2.4/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-0.2.4/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-0.2.4/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-0.2.4/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()