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

lionagi/tests/libs/test_queue.py

@@ -0,0 +1,67 @@
+import asyncio
+import unittest
+from unittest.mock import patch
+from lionagi.libs.ln_queue import AsyncQueue
+
+
+class TestAsyncQueue(unittest.TestCase):
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.queue = AsyncQueue(max_concurrent_tasks=3)
+
+    def tearDown(self):
+        self.loop.close()
+
+    def test_enqueue_dequeue(self):
+        async def test():
+            await self.queue.enqueue("task1")
+            result = await self.queue.dequeue()
+            self.assertEqual(result, "task1")
+
+        self.loop.run_until_complete(test())
+
+    def test_stop(self):
+        async def test():
+            await self.queue.stop()
+            self.assertTrue(self.queue.stopped())
+
+        self.loop.run_until_complete(test())
+
+    @patch("lionagi.libs.ln_func_call.rcall", autospec=True)
+    def test_process_requests(self, mock_rcall):
+        future = asyncio.Future()
+        future.set_result("Processed successfully")
+        mock_rcall.return_value = future
+
+        async def processor(task):
+            return f"Processed {task}"
+
+        async def add_tasks():
+            for i in range(5):
+                await self.queue.enqueue(f"task{i}")
+            # This ensures that the queue stops after all tasks are added
+            await self.queue.stop()
+
+        async def process():
+            await self.queue.process_requests(processor, retry_kwargs={"retries": 2})
+
+        self.loop.create_task(add_tasks())
+        self.loop.run_until_complete(process())
+        # mock_rcall.assert_called()
+
+    def test_concurrency_limit(self):
+        async def add_tasks():
+            for i in range(10):
+                await self.queue.enqueue(f"task{i}")
+
+        async def process():
+            await asyncio.sleep(0.1)
+            await self.queue.stop()
+
+        self.loop.run_until_complete(add_tasks())
+        self.loop.run_until_complete(process())
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/collections/test_component.py

@@ -0,0 +1,206 @@
+import unittest
+from lionagi.core.collections.abc.component import (
+    Component,
+    LionValueError,
+    LionTypeError,
+)
+import pandas as pd
+from datetime import datetime
+import json
+
+
+class TestComponent(unittest.TestCase):
+
+    def setUp(self):
+        """Set up a basic Component instance for testing."""
+        self.component = Component()
+
+    def test_initialization(self):
+        """Test basic initialization and attributes."""
+        self.assertIsInstance(self.component.ln_id, str)
+        self.assertIsInstance(self.component.timestamp, str)
+        self.assertIsInstance(self.component.metadata, dict)
+        self.assertIsNone(self.component.content)
+        self.assertEqual(self.component.embedding, [])
+
+    def test_setting_attributes(self):
+        """Test setting and updating attributes."""
+        self.component.content = 1
+        self.assertEqual(self.component.content, 1)
+        self.assertIn("content", self.component.metadata["last_updated"])
+
+    def test_class_name(self):
+        """Test the class_name property."""
+        self.assertEqual(self.component.class_name, "Component")
+
+    def test_to_dict(self):
+        """Test converting to dictionary."""
+        self.component.content = "example content"
+        dict_repr = self.component.to_dict()
+        self.assertEqual(dict_repr["content"], "example content")
+        self.assertEqual(dict_repr["lion_class"], "Component")
+
+    def test_to_json_str(self):
+        """Test converting to JSON string."""
+        self.component.content = "example content"
+        json_str = self.component.to_json_str()
+        self.assertIn('"content": "example content"', json_str)
+
+    def test_to_xml(self):
+        """Test converting to XML string."""
+        self.component.content = "example content"
+        xml_str = self.component.to_xml()
+        self.assertIn("<content>example content</content>", xml_str)
+
+    def test_to_pd_series(self):
+        """Test converting to Pandas Series."""
+        self.component.content = "example content"
+        series = self.component.to_pd_series()
+        self.assertEqual(series["content"], "example content")
+
+    def test_from_obj_dict(self):
+        """Test creating a Component from a dictionary."""
+        dict_obj = {"a": 1, "b": 2}
+        new_component = Component.from_obj(dict_obj)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_str(self):
+        """Test creating a Component from a JSON string."""
+        json_str = '{"a": 1, "b": 2}'
+        new_component = Component.from_obj(json_str)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_fuzzy_str(self):
+        """Test creating a Component from a fuzzy JSON string."""
+        fuzzy_json_str = '{"name": "John", "age": 30, "city": ["New York", "DC", "LA"]'
+        new_component = Component.from_obj(fuzzy_json_str, fuzzy_parse=True)
+        self.assertEqual(new_component.metadata["name"], "John")
+        self.assertEqual(new_component.metadata["age"], 30)
+        self.assertEqual(new_component.metadata["city"], ["New York", "DC", "LA"])
+
+    def test_from_obj_series(self):
+        """Test creating a Component from a Pandas Series."""
+        series_obj = pd.Series({"a": 1, "b": 2})
+        new_component = Component.from_obj(series_obj)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_dataframe(self):
+        """Test creating Components from a Pandas DataFrame."""
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["row1", "row2"])
+        components = Component.from_obj(df)
+        self.assertEqual(len(components), 2)
+        self.assertEqual(components[0].metadata["a"], 1)
+        self.assertEqual(components[0].metadata["b"], 3)
+        self.assertEqual(components[1].metadata["a"], 2)
+        self.assertEqual(components[1].metadata["b"], 4)
+
+    def test_metadata_manipulation(self):
+        """Test manipulation of metadata."""
+        self.component._meta_insert(["new_key"], "new_value")
+        self.assertEqual(self.component.metadata["new_key"], "new_value")
+        self.component._meta_set(["new_key"], "updated_value")
+        self.assertEqual(self.component.metadata["new_key"], "updated_value")
+        nested_value = {"a": 1, "b": 2}
+        self.component._meta_insert(["nested", 0], nested_value)
+        self.assertEqual(self.component.metadata["nested"][0], nested_value)
+        self.assertEqual(self.component._meta_get(["nested", 0, "a"]), 1)
+
+    def test_invalid_metadata_assignment(self):
+        """Test invalid direct assignment to metadata."""
+        with self.assertRaises(AttributeError):
+            self.component.metadata = {}
+
+    def test_field_annotations(self):
+        """Test field annotations."""
+        annotations = self.component._field_annotations
+        self.assertIn("ln_id", annotations)
+        self.assertIn("timestamp", annotations)
+
+    def test_dynamic_field_addition(self):
+        """Test adding fields dynamically to the Component."""
+        self.component._add_field(
+            "welcome", str, default="new value", value="hello world again"
+        )
+        self.assertEqual(
+            self.component._get_field_attr("welcome", "default"), "new value"
+        )
+        self.assertEqual(getattr(self.component, "welcome"), "hello world again")
+
+    def test_validation_error_handling(self):
+        """Test handling of validation errors."""
+        with self.assertRaises(LionValueError):
+            Component.from_obj({"ln_id": 12345})  # Invalid ln_id type
+
+    def test_str_repr_methods(self):
+        """Test __str__ and __repr__ methods."""
+        self.component.content = "example content"
+        self.assertIn("example content", str(self.component))
+        self.assertIn("example content", repr(self.component))
+
+    def test_embedded_content(self):
+        """Test embedded content handling."""
+        embedding_str = "[1.0, 2.0, 3.0]"
+        self.component.embedding = self.component._validate_embedding(embedding_str)
+        self.assertEqual(self.component.embedding, [1.0, 2.0, 3.0])
+
+    def test_invalid_embedded_content(self):
+        """Test invalid embedded content handling."""
+        with self.assertRaises(ValueError):
+            self.component._validate_embedding("[1.0, 'invalid', 3.0]")
+
+    def test_timestamp_format(self):
+        """Test if the timestamp is in the correct format."""
+        timestamp = self.component.timestamp
+        try:
+            datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f")
+        except ValueError:
+            self.fail("Timestamp is not in the correct format")
+
+    def test_default_field_values(self):
+        """Test the default values of fields."""
+        default_fields = self.component._all_fields
+        self.assertEqual(default_fields["embedding"].default, [])
+        self.assertEqual(default_fields["metadata"].default_factory(), {})
+        self.assertEqual(default_fields["extra_fields"].default_factory(), {})
+        self.assertIsNone(default_fields["content"].default)
+
+    def test_deeply_nested_metadata(self):
+        """Test setting and getting deeply nested metadata."""
+        nested_value = {"level1": {"level2": {"level3": "deep_value"}}}
+        self.component._meta_insert(["nested", 0], nested_value)
+        self.assertEqual(
+            self.component._meta_get(["nested", 0, "level1", "level2", "level3"]),
+            "deep_value",
+        )
+
+    def test_invalid_from_obj_type(self):
+        """Test invalid type in from_obj method."""
+        with self.assertRaises(LionTypeError):
+            Component.from_obj(12345)  # Invalid type
+
+    def test_from_obj_pydantic_model(self):
+        """Test creating a Component from a Pydantic BaseModel."""
+        from pydantic import BaseModel
+
+        class SampleModel(BaseModel):
+            name: str
+            age: int
+
+        sample_instance = SampleModel(name="John Doe", age=30)
+        new_component = Component.from_obj(sample_instance)
+        self.assertEqual(new_component.metadata["name"], "John Doe")
+        self.assertEqual(new_component.metadata["age"], 30)
+
+    def test_json_serialization_deserialization(self):
+        """Test JSON serialization and deserialization."""
+        original_dict = self.component.to_dict()
+        json_str = json.dumps(original_dict)
+        new_component = Component.from_obj(json_str)
+        self.assertEqual(original_dict, new_component.to_dict())
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/collections/test_exchange.py

@@ -0,0 +1,138 @@
+import unittest
+from lionagi import Node, pile, progression
+from lionagi.core.collections.abc import Element
+from lionagi.core.collections import Exchange
+
+
+class TestExchange(unittest.TestCase):
+
+    def setUp(self):
+        # Setup for creating initial nodes, piles, and progressions
+        self.nodes = [Node(content=i) for i in range(10)]
+        self.pile1 = pile(self.nodes)
+        self.prog1 = progression(self.nodes[:5], name="left")
+        self.prog2 = progression(self.nodes[5:], name="right")
+        self.exchange = Exchange()
+
+    def test_initialization(self):
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+    def test_include_in(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        self.assertEqual(len(self.exchange.pile), 5)
+        self.assertIn(sender_id, self.exchange.pending_ins)
+        self.assertEqual(len(self.exchange.pending_ins[sender_id]), 5)
+
+    def test_include_out(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        self.assertEqual(len(self.exchange.pile), 5)
+        self.assertEqual(len(self.exchange.pending_outs), 5)
+
+    def test_exclude(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        node_to_remove = self.nodes[0]
+        self.exchange.exclude(node_to_remove)
+        self.assertNotIn(node_to_remove, self.exchange.pile)
+        self.assertNotIn(node_to_remove, self.exchange.pending_outs)
+
+    def test_exclude_from_in(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        node_to_remove = self.nodes[0]
+        self.exchange.exclude(node_to_remove)
+        self.assertNotIn(node_to_remove, self.exchange.pile)
+        self.assertNotIn(node_to_remove, self.exchange.pending_ins[sender_id])
+
+    def test_senders(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        self.assertIn(sender_id, self.exchange.senders)
+
+    def test_to_dict(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        exchange_dict = self.exchange.to_dict()
+        self.assertIn("pile", exchange_dict)
+        self.assertIn("pending_ins", exchange_dict)
+        self.assertIn("pending_outs", exchange_dict)
+
+    def test_bool(self):
+        self.assertTrue(self.exchange)
+
+    # Additional Tests for Edge Cases
+    def test_include_non_sendable(self):
+        non_sendable = Element()
+        with self.assertRaises(AttributeError):
+            self.exchange.include(non_sendable, "in")
+
+    def test_exclude_nonexistent_item(self):
+        non_existent_node = Node(content="nonexistent")
+        result = self.exchange.exclude(non_existent_node)
+        self.assertTrue(result)
+
+    def test_include_multiple_items_in(self):
+        sender_id = "sender2"
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            new_node.sender = sender_id
+            self.exchange.include(new_node, "in")
+
+        self.assertEqual(len(self.exchange.pile), 2)
+        self.assertEqual(len(self.exchange.pending_ins[sender_id]), 2)
+
+    def test_include_multiple_items_out(self):
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            self.exchange.include(new_node, "out")
+
+        self.assertEqual(len(self.exchange.pile), 2)
+        self.assertEqual(len(self.exchange.pending_outs), 2)
+
+    def test_exclude_from_empty_exchange(self):
+        result = self.exchange.exclude(Node(content="nonexistent"))
+        self.assertTrue(result)
+
+    def test_clear_empty_exchange(self):
+        self.exchange.pile.clear()
+        self.exchange.pending_ins.clear()
+        self.exchange.pending_outs.clear()
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+    def test_clear_exchange(self):
+        sender_id = "sender3"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+        for node in self.nodes[5:]:
+            self.exchange.include(node, "out")
+
+        self.exchange.pile.clear()
+        self.exchange.pending_ins.clear()
+        self.exchange.pending_outs.clear()
+
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/collections/test_flow.py

@@ -0,0 +1,145 @@
+import unittest
+from lionagi import Node, pile, progression, flow
+
+
+class TestFlow(unittest.TestCase):
+
+    def setUp(self):
+        # Setup for creating initial nodes, piles, and progressions
+        self.nodes = [Node(content=i) for i in range(10)]
+        self.pile1 = pile(self.nodes)
+        self.prog1 = progression(self.nodes[:5], name="left")
+        self.prog2 = progression(self.nodes[5:], name="right")
+        self.flow = flow([self.prog1, self.prog2])
+
+    def test_initialization(self):
+        self.assertEqual(len(self.flow.sequences), 2)
+        self.assertIn("left", self.flow.registry)
+        self.assertIn("right", self.flow.registry)
+
+    def test_append_to_flow(self):
+        new_node = Node(content="new_node")
+        self.flow.append(new_node, "left")
+        self.assertIn(new_node.ln_id, self.flow.get("left"))
+
+    def test_exclude_from_flow(self):
+        node_to_remove = self.nodes[0]
+        self.flow.exclude("left", node_to_remove)
+        self.assertNotIn(node_to_remove.ln_id, self.flow.get("left"))
+
+    def test_get_sequence(self):
+        seq = self.flow.get("left")
+        self.assertEqual(seq, self.prog1)
+        seq_default = self.flow.get("nonexistent", default=None)
+        self.assertIsNone(seq_default)
+
+    def test_register_sequence(self):
+        new_prog = progression(self.nodes[2:4], name="middle")
+        self.flow.register(new_prog)
+        self.assertIn("middle", self.flow.registry)
+
+    def test_popleft(self):
+        first_node_id = self.prog1[0]
+        removed_node_id = self.flow.popleft("left")
+        self.assertEqual(first_node_id, removed_node_id)
+        self.assertNotIn(removed_node_id, self.flow.get("left"))
+
+    def test_shape_and_size(self):
+        shape = self.flow.shape()
+        self.assertEqual(shape["left"], 5)
+        self.assertEqual(shape["right"], 5)
+        size = self.flow.size()
+        self.assertEqual(size, 10)
+
+    def test_clear(self):
+        self.flow.clear()
+        self.assertEqual(len(self.flow.sequences), 0)
+        self.assertEqual(len(self.flow.registry), 0)
+
+    def test_iteration(self):
+        items = list(self.flow)
+        self.assertEqual(len(items), 2)
+
+    def test_to_df(self):
+        df = self.flow.to_df()
+        self.assertEqual(df.shape[0], 2)
+        self.assertEqual(df.columns.tolist(), ["order", "name"])
+
+    def test_inclusion_check(self):
+        self.assertTrue(self.prog1 in self.flow)
+        self.assertTrue(self.prog2 in self.flow)
+        try:
+            a = Node(content="nonexistent") in self.flow
+        except TypeError:
+            pass
+
+    # Additional Tests for Edge Cases
+    def test_empty_flow_initialization(self):
+        empty_flow = flow()
+        self.assertEqual(len(empty_flow.sequences), 0)
+        self.assertEqual(len(empty_flow.registry), 0)
+
+    def test_append_to_nonexistent_sequence(self):
+        new_node = Node(content="new_node")
+        self.flow.append(new_node, "nonexistent")
+        self.assertIn(new_node.ln_id, self.flow.get("nonexistent"))
+
+    def test_exclude_nonexistent_item(self):
+        non_existent_node = Node(content="nonexistent")
+        result = self.flow.exclude("left", non_existent_node)
+        self.assertTrue(result)
+
+    def test_exclude_nonexistent_sequence(self):
+        result = self.flow.exclude("nonexistent")
+        self.assertFalse(result)
+
+    def test_get_nonexistent_sequence(self):
+        try:
+            self.flow.get("nonexistent")
+        except Exception as e:
+            if e.__class__.__name__ == "LionTypeError":
+                return
+            raise AssertionError("LionTypeError not raised")
+
+    def test_register_existing_sequence_name(self):
+        with self.assertRaises(ValueError):
+            self.flow.register(self.prog1, name="right")
+
+    def test_popleft_nonexistent_sequence(self):
+        try:
+            self.flow.popleft("nonexistent")
+        except Exception as e:
+            if e.__class__.__name__ == "LionTypeError":
+                return
+            raise AssertionError("LionTypeError not raised")
+
+    def test_append_multiple_items(self):
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            self.flow.append(new_node, "left")
+        for new_node in new_nodes:
+            self.assertIn(new_node.ln_id, self.flow.get("left"))
+
+    def test_remove_from_all_sequences(self):
+        node_to_remove = self.nodes[0]
+        self.flow.append(node_to_remove, "right")
+        self.flow.remove(node_to_remove)
+        self.assertNotIn(node_to_remove.ln_id, self.flow.get("right"))
+
+    def test_shape_empty_flow(self):
+        empty_flow = flow()
+        self.assertEqual(empty_flow.shape(), {})
+
+    def test_size_empty_flow(self):
+        empty_flow = flow()
+        self.assertEqual(empty_flow.size(), 0)
+
+    def test_clear_empty_flow(self):
+        empty_flow = flow()
+        empty_flow.clear()
+        self.assertEqual(len(empty_flow.sequences), 0)
+        self.assertEqual(len(empty_flow.registry), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()