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

lionagi/tests/test_core/collections/test_flow.py

@@ -1,146 +0,0 @@
-import unittest
-
-from lionagi import Node, flow, pile, progression
-
-
-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()

lionagi/tests/test_core/collections/test_pile.py

@@ -1,172 +0,0 @@
-import asyncio
-import unittest
-
-from lionagi import Node
-from lionagi.core.collections.pile import Pile
-
-
-class TestPile(unittest.TestCase):
-
-    def setUp(self):
-        """Create initial nodes and piles for testing."""
-        self.nodes1 = [Node(content=i) for i in ["A", "B", "C"]]
-        self.nodes2 = [Node(content=i) for i in ["D", "E", "F"]]
-        self.p1 = Pile(self.nodes1)
-        self.p2 = Pile(self.nodes2)
-
-    def test_add_piles(self):
-        """Test adding two piles."""
-        combined_pile = self.p1 + self.p2
-        self.assertEqual(len(combined_pile), 6)
-        contents = [node.content for node in combined_pile.values()]
-        self.assertListEqual(contents, ["A", "B", "C", "D", "E", "F"])
-
-    def test_subtract_piles(self):
-        """Test subtracting nodes from a pile."""
-        with self.assertRaises(Exception):
-            result_pile = self.p1 - self.nodes2[0]  # D not in p1
-
-    def test_containment(self):
-        """Test containment check."""
-        self.assertIn(self.nodes1[1], self.p1)  # B in p1
-        self.assertNotIn(self.nodes2[0], self.p1)  # D not in p1
-
-    def test_include_nodes(self):
-        """Test including nodes in a pile."""
-        self.p1.include(self.nodes2)
-        self.assertEqual(len(self.p1), 6)
-        contents = [node.content for node in self.p1.values()]
-        self.assertListEqual(contents, ["A", "B", "C", "D", "E", "F"])
-
-    def test_exclude_nodes(self):
-        """Test excluding nodes from a pile."""
-        self.p1.include(self.nodes2)  # Include first to have something to exclude
-        self.p1.exclude(self.nodes2)
-        self.assertEqual(len(self.p1), 5)
-        contents = [node.content for node in self.p1.values()]
-        self.assertListEqual(contents, ["A", "B", "C", "E", "F"])
-
-    def test_get_item_by_index(self):
-        """Test getting an item by index."""
-        node = self.p1[0]
-        self.assertEqual(node.content, "A")
-
-    def test_set_item_by_index(self):
-        """Test setting an item at a specific index."""
-        new_node = Node(content="Updated Node")
-        self.p1[0] = new_node
-        self.assertEqual(self.p1[0].content, "Updated Node")
-
-    def test_insert_item(self):
-        """Test inserting an item at a specific position."""
-        new_node = Node(content="Inserted Node")
-        self.p1.insert(0, new_node)
-        self.assertEqual(self.p1[0].content, "Inserted Node")
-        self.assertEqual(len(self.p1), 4)
-
-    def test_homogenous(self):
-        """Test if all items in the pile are of the same type."""
-        self.assertTrue(self.p1.is_homogenous())
-        with self.assertRaises(AttributeError):
-            mixed_pile = Pile(self.nodes1 + [123])  # Adding an int to mix types
-
-    def test_is_empty(self):
-        """Test if the pile is empty."""
-        empty_pile = Pile()
-        self.assertTrue(empty_pile.is_empty())
-        self.assertFalse(self.p1.is_empty())
-
-    def test_pop_item(self):
-        """Test popping an item from the pile."""
-        popped_node = self.p1.pop(self.nodes1[0].ln_id)
-        self.assertEqual(popped_node.content, "A")
-        self.assertEqual(len(self.p1), 2)
-
-    def test_clear_pile(self):
-        """Test clearing the pile."""
-        self.p1.clear()
-        self.assertTrue(self.p1.is_empty())
-
-    def test_update_pile(self):
-        """Test updating the pile with another pile."""
-        self.p1.update(self.p2)
-        self.assertEqual(len(self.p1), 6)
-        contents = [node.content for node in self.p1.values()]
-        self.assertListEqual(contents, ["A", "B", "C", "D", "E", "F"])
-
-    def test_to_dataframe(self):
-        """Test converting the pile to a DataFrame."""
-        df = self.p1.to_df()
-        self.assertEqual(len(df), 3)
-        self.assertListEqual(df["content"].tolist(), ["A", "B", "C"])
-
-    def test_create_index(self):
-        """Test creating an index for the pile."""
-        with self.assertRaises(ValueError):
-            self.p1.create_index(index_type="llama_index")
-
-    def test_create_query_engine(self):
-        """Test creating a query engine for the pile."""
-        with self.assertRaises(ValueError):
-            self.p1.create_query_engine(index_type="llama_index")
-
-    def test_create_chat_engine(self):
-        """Test creating a chat engine for the pile."""
-        with self.assertRaises(ValueError):
-            self.p1.create_chat_engine(index_type="llama_index")
-
-    # async def test_query_pile(self):
-    #     """Test querying the pile."""
-    #     self.p1.create_query_engine(index_type="llama_index")
-    #     response = await self.p1.query_pile(query="test query")
-    #     self.assertIsInstance(response, str)
-
-    # async def test_chat_pile(self):
-    #     """Test chatting with the pile."""
-    #     self.p1.create_chat_engine(index_type="llama_index")
-    #     response = await self.p1.chat_pile(query="test chat")
-    #     self.assertIsInstance(response, str)
-
-    # async def test_embed_pile(self):
-    #     """Test embedding the items in the pile."""
-    #     await self.p1.embed_pile()
-    #     for node in self.p1.values():
-    #         self.assertIn("embedding", node._all_fields)
-
-    def test_to_csv(self):
-        """Test saving the pile to a CSV file."""
-        self.p1.to_csv("test_pile.csv")
-        with open("test_pile.csv", "r") as f:
-            content = f.read()
-        self.assertIn("content", content)
-
-    def test_from_csv(self):
-        """Test loading a pile from a CSV file."""
-        self.p1.to_csv("test_pile.csv")
-        loaded_pile = Pile.from_csv("test_pile.csv")
-        self.assertEqual(len(loaded_pile), 3)
-        self.assertEqual(loaded_pile[0].content, "A")
-
-    def test_from_dataframe(self):
-        """Test loading a pile from a DataFrame."""
-        df = self.p1.to_df()
-        loaded_pile = Pile.from_df(df)
-        self.assertEqual(len(loaded_pile), 3)
-        self.assertEqual(loaded_pile[0].content, "A")
-
-    def test_as_query_tool(self):
-        """Test creating a query tool for the pile."""
-        with self.assertRaises(ValueError):
-            tool = self.p1.as_query_tool(index_type="llama_index")
-
-    def test_str_representation(self):
-        """Test the string representation of the pile."""
-        self.assertIsInstance(str(self.p1), str)
-
-    def test_repr_representation(self):
-        """Test the representation of the pile."""
-        self.assertIsInstance(repr(self.p1), str)
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/collections/test_progression.py

@@ -1,130 +0,0 @@
-import unittest
-
-from lionagi import Node
-from lionagi.core.collections import Progression
-from lionagi.core.collections.abc import ItemNotFoundError
-
-
-class TestProgression(unittest.TestCase):
-
-    def setUp(self):
-        self.nodes = [Node() for _ in range(5)]
-        self.p = Progression(order=[node.ln_id for node in self.nodes])
-
-    def test_initial_order(self):
-        self.assertEqual(self.p.order, [node.ln_id for node in self.nodes])
-
-    def test_append_node(self):
-        new_node = Node()
-        self.p.append(new_node)
-        self.assertIn(new_node.ln_id, self.p.order)
-        self.assertEqual(len(self.p), 6)
-
-    def test_extend_single_node(self):
-        new_node = Node()
-        self.p.extend(new_node)
-        self.assertIn(new_node.ln_id, self.p.order)
-        self.assertEqual(len(self.p), 6)
-
-    def test_extend_multiple_nodes(self):
-        new_nodes = [Node() for _ in range(3)]
-        self.p.extend(new_nodes)
-        for node in new_nodes:
-            self.assertIn(node.ln_id, self.p.order)
-        self.assertEqual(len(self.p), 8)
-
-    def test_include_node(self):
-        new_node = Node()
-        self.p.include(new_node)
-        self.assertIn(new_node.ln_id, self.p.order)
-
-    def test_getitem_slice(self):
-        slice_result = self.p[1:5]
-        self.assertEqual(slice_result.order, self.p.order[1:5])
-
-    def test_setitem(self):
-        new_node = Node()
-        self.p[0] = new_node.ln_id
-        self.assertEqual(self.p[0], new_node.ln_id)
-
-    def test_add_node(self):
-        new_node = Node()
-        new_prog = self.p + new_node
-        self.assertIn(new_node.ln_id, new_prog.order)
-
-    def test_iadd_node(self):
-        new_node = Node()
-        self.p += new_node
-        self.assertIn(new_node.ln_id, self.p.order)
-
-    def test_subtract_node(self):
-        node_to_remove = self.nodes[0]
-        self.p -= node_to_remove.ln_id
-        self.assertNotIn(node_to_remove.ln_id, self.p.order)
-
-    def test_isubtract_node(self):
-        node_to_remove = self.nodes[0]
-        self.p -= node_to_remove.ln_id
-        self.assertNotIn(node_to_remove.ln_id, self.p.order)
-
-    def test_popleft(self):
-        leftmost = self.p.order[0]
-        self.assertEqual(self.p.popleft(), leftmost)
-        self.assertNotIn(leftmost, self.p.order)
-
-    def test_exclude_node(self):
-        node_to_exclude = self.nodes[0]
-        self.p.exclude(node_to_exclude.ln_id)
-        self.assertNotIn(node_to_exclude.ln_id, self.p.order)
-
-    def test_clear(self):
-        self.p.clear()
-        self.assertEqual(len(self.p), 0)
-
-    def test_to_dict(self):
-        p_dict = self.p.to_dict()
-        self.assertEqual(p_dict["order"], self.p.order)
-        self.assertEqual(p_dict["name"], self.p.name)
-
-    def test_bool(self):
-        self.assertTrue(bool(self.p))
-
-    def test_remove_nonexistent_node(self):
-        non_existent_node = Node()
-        with self.assertRaises(ItemNotFoundError):
-            self.p.remove(non_existent_node.ln_id)
-
-    def test_pop_index_error(self):
-        with self.assertRaises(ItemNotFoundError):
-            self.p.pop(100)
-
-    def test_popleft_index_error(self):
-        empty_prog = Progression()
-        with self.assertRaises(ItemNotFoundError):
-            empty_prog.popleft()
-
-    def test_iteration(self):
-        nodes_list = [node.ln_id for node in self.nodes]
-        for i, node in enumerate(self.p):
-            self.assertEqual(node, nodes_list[i])
-
-    def test_contains(self):
-        node_to_check = self.nodes[0]
-        self.assertIn(node_to_check.ln_id, self.p)
-
-    def test_not_contains(self):
-        non_existent_node = Node()
-        self.assertNotIn(non_existent_node.ln_id, self.p)
-
-    def test_equality(self):
-        new_prog = Progression(order=[node.ln_id for node in self.nodes])
-        self.assertEqual(self.p.order, new_prog.order)
-
-    def test_inequality(self):
-        new_node = Node()
-        new_prog = self.p + new_node
-        self.assertNotEqual(self.p.order, new_prog)
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/generic/test_edge.py

@@ -1,69 +0,0 @@
-import unittest
-from unittest.mock import AsyncMock, patch
-
-from pydantic import ValidationError
-
-from lionagi.core.collections.abc import Component, Condition, LionIDable, get_lion_id
-from lionagi.core.generic.edge import Edge
-from lionagi.core.generic.edge_condition import EdgeCondition
-
-
-class TestEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.node1 = Component()
-        self.node2 = Component()
-        self.edge = Edge(head=self.node1.ln_id, tail=self.node2.ln_id)
-
-    def test_initialization(self):
-        """Test initialization of the Edge class."""
-        self.assertEqual(self.edge.head, self.node1.ln_id)
-        self.assertEqual(self.edge.tail, self.node2.ln_id)
-        self.assertIsNone(self.edge.condition)
-        self.assertIsNone(self.edge.label)
-        self.assertFalse(self.edge.bundle)
-
-    async def test_check_condition_without_condition(self):
-        """Test check_condition raises ValueError when condition is not set."""
-        with self.assertRaises(ValueError):
-            await self.edge.check_condition({})
-
-    @patch("lionagi.core.models.edge.EdgeCondition.applies", new_callable=AsyncMock)
-    async def test_check_condition_with_condition(self, mock_applies):
-        """Test check_condition with a set condition."""
-        mock_applies.return_value = True
-        condition = EdgeCondition()
-        self.edge.condition = condition
-        result = await self.edge.check_condition({})
-        self.assertTrue(result)
-        mock_applies.assert_awaited_once()
-
-    def test_validate_head_tail(self):
-        """Test the head and tail validation."""
-        try:
-            valid_id = get_lion_id("valid_head")
-        except Exception as e:
-            if e.__class__.__name__ == "LionTypeError":
-                return
-        self.assertEqual(Edge._validate_head_tail(valid_id), valid_id)
-        with self.assertRaises(ValidationError):
-            Edge._validate_head_tail("invalid_id")
-
-    def test_string_condition_none(self):
-        """Test string_condition method when condition is None."""
-        self.assertIsNone(self.edge.string_condition())
-
-    def test_len(self):
-        """Test the __len__ method."""
-        self.assertEqual(len(self.edge), 1)
-
-    def test_contains(self):
-        """Test the __contains__ method."""
-        self.assertIn(self.node1.ln_id, self.edge)
-        self.assertIn(self.node2.ln_id, self.edge)
-        fake_node = Component()
-        self.assertNotIn(fake_node.ln_id, self.edge)
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/generic/test_graph.py

@@ -1,97 +0,0 @@
-import unittest
-
-from lionagi.core.collections.abc import ItemNotFoundError, LionTypeError
-from lionagi.core.generic import Edge, Graph, Node
-from lionagi.libs.ln_convert import to_list
-
-
-class TestGraph(unittest.TestCase):
-
-    def setUp(self):
-        """Set up a basic graph for testing."""
-        self.node1 = Node()
-        self.node2 = Node()
-        self.node3 = Node()
-        self.node4 = Node()
-        self.g = Graph()
-
-    def test_initial_size(self):
-        """Test the initial size of the graph."""
-        self.assertEqual(self.g.size(), 0)
-
-    def test_initial_internal_edges(self):
-        """Test the initial number of internal edges."""
-        self.assertEqual(len(self.g.internal_edges), 0)
-
-    def test_add_node_no_edge(self):
-        """Test that adding nodes does not create any edges."""
-        self.g.add_node([self.node1, self.node2, self.node3, self.node4])
-        self.assertEqual(len(self.g.internal_edges), 0)
-
-    def test_add_edges(self):
-        """Test adding edges between nodes."""
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        self.assertEqual(len(self.g.internal_edges), 3)
-
-    def test_get_node(self):
-        """Test retrieving a node by its identifier."""
-        self.g.add_node(self.node2)
-        node5 = self.g.get_node(self.node2)
-        self.assertEqual(node5, self.node2)
-
-    def test_get_node_edges(self):
-        """Test getting the edges of a node."""
-        self.g.add_edge(self.node1, self.node2)
-        self.assertEqual(len(self.g.get_node_edges(self.node1)), 1)
-
-    def test_get_heads(self):
-        """Test getting head nodes."""
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        self.assertEqual(len(self.g.get_heads()), 1)
-
-    def test_is_acyclic(self):
-        """Test if the graph is acyclic."""
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        self.assertTrue(self.g.is_acyclic())
-
-    def test_remove_edge(self):
-        """Test removing an edge from the graph."""
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        edge = self.g.internal_edges[0]
-        self.g.remove_edge(edge)
-        self.assertEqual(len(self.g.internal_edges), 2)
-
-    def test_remove_nonexistent_edge(self):
-        """Test removing a nonexistent edge."""
-        self.g.add_edge(self.node1, self.node2)
-        with self.assertRaises(ItemNotFoundError):
-            self.g.remove_edge(edge=Edge(head=self.node2, tail=self.node3))
-
-    def test_clear(self):
-        """Test clearing all nodes and edges from the graph."""
-        self.g.add_node([self.node1, self.node2, self.node3, self.node4])
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        self.g.clear()
-        self.assertTrue(self.g.is_empty())
-        self.assertEqual(len(self.g.internal_edges), 0)
-
-    def test_display(self):
-        """Test displaying the graph (visual check)."""
-        self.g.add_edge(self.node1, self.node2)
-        self.g.add_edge(self.node2, self.node3)
-        self.g.add_edge(self.node3, self.node4)
-        self.g.display()  # This should display the graph visually
-
-
-if __name__ == "__main__":
-    unittest.main()