lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

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()

lionagi/tests/test_core/collections/test_pile.py

@@ -0,0 +1,171 @@
+import unittest
+import asyncio
+from lionagi.core.collections.pile import Pile
+from lionagi import Node
+
+
+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()