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

lionagi/tests/libs/test_sys_util.py

@@ -1,222 +0,0 @@
-import shutil
-import sys
-import tempfile
-import time
-import unittest
-from datetime import datetime, timezone
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-from lionagi.libs.sys_util import SysUtil
-
-
-class TestSysUtil(unittest.TestCase):
-
-    def test_sleep(self):
-        start = time.time()
-        SysUtil.sleep(0.1)  # Sleep for 0.1 seconds
-        end = time.time()
-        self.assertTrue((end - start) >= 0.1)
-
-    def test_get_now(self):
-        # Test returning Unix timestamp
-        timestamp = time.time()
-        self.assertIsInstance(timestamp, float)
-
-        # Test returning datetime object
-        now = SysUtil.get_now(datetime_=True)
-        self.assertIsInstance(now, datetime)
-
-    def test_change_dict_key(self):
-        dict_ = {"old_key": "value"}
-        SysUtil.change_dict_key(dict_, "old_key", "new_key")
-        self.assertIn("new_key", dict_)
-        self.assertNotIn("old_key", dict_)
-
-    def test_get_timestamp(self):
-        timestamp = SysUtil.get_timestamp()
-        self.assertIsInstance(timestamp, str)
-        # Test custom separator
-        custom_sep_timestamp = SysUtil.get_timestamp(sep="-")
-        self.assertIn("-", custom_sep_timestamp)
-
-    def test_create_copy(self):
-        input_ = {"key": "value"}
-        # Single copy
-        single_copy = SysUtil.create_copy(input_)
-        self.assertEqual(input_, single_copy)
-        self.assertNotEqual(id(input_), id(single_copy))
-        # Multiple copies
-        copies = SysUtil.create_copy(input_, 2)
-        self.assertIsInstance(copies, list)
-        self.assertEqual(len(copies), 2)
-        self.assertNotEqual(id(copies[0]), id(copies[1]))
-
-    def test_create_id(self):
-        id1 = SysUtil.create_id()
-        id2 = SysUtil.create_id()
-        self.assertIsInstance(id1, str)
-        self.assertEqual(len(id1), 32)
-        self.assertNotEqual(id1, id2)
-
-    def test_get_bins(self):
-        input_ = ["a" * 500, "b" * 1000, "c" * 500, "d" * 1000]
-        bins = SysUtil.get_bins(input_)
-        self.assertEqual(len(bins), 2)
-        self.assertEqual(bins, [[0, 1], [2, 3]])
-
-    def test_get_cpu_architecture(self):
-        architecture = SysUtil.get_cpu_architecture()
-        self.assertIn(architecture, ["apple_silicon", "other_cpu"])
-
-    def test_is_package_installed(self):
-        with patch("importlib.util.find_spec", return_value=None):
-            self.assertFalse(SysUtil.is_package_installed("nonexistent_package"))
-        with patch("importlib.util.find_spec", return_value=True):
-            self.assertTrue(SysUtil.is_package_installed("existent_package"))
-
-    @patch(
-        "importlib.metadata.distributions",
-        return_value=[type("", (), {"metadata": {"Name": "fake-package"}})()],
-    )
-    def test_list_installed_packages(self, mock_distributions):
-        installed_packages = SysUtil.list_installed_packages()
-        self.assertIn("fake-package", installed_packages)
-
-    @patch("subprocess.check_call")
-    def test_uninstall_package(self, mock_subprocess):
-        SysUtil.uninstall_package("fake-package")
-        mock_subprocess.assert_called_with(
-            [sys.executable, "-m", "pip", "uninstall", "fake-package", "-y"]
-        )
-
-    @patch("subprocess.check_call")
-    def test_update_package(self, mock_subprocess):
-        SysUtil.update_package("fake-package")
-        mock_subprocess.assert_called_with(
-            [sys.executable, "-m", "pip", "install", "--upgrade", "fake-package"]
-        )
-
-    def test_split_path_file(self):
-        """Test splitting a file path."""
-        parent, name = SysUtil.split_path("/tmp/example.txt")
-        self.assertEqual(parent, Path("/tmp"))
-        self.assertEqual(name, "example.txt")
-
-    def test_split_path_directory(self):
-        """Test splitting a directory path."""
-        parent, name = SysUtil.split_path("/tmp/example/")
-        self.assertEqual(parent, Path("/tmp"))
-        self.assertEqual(name, "example")
-
-    def test_split_path_root(self):
-        """Test splitting the root path."""
-        parent, name = SysUtil.split_path("/")
-        self.assertEqual(parent, Path("/"))
-        self.assertEqual(name, "")
-
-    def setUp(self):
-        # Create a temporary directory
-        self.test_dir = tempfile.mkdtemp()
-
-        # Create some test files
-        Path(self.test_dir, "test_file.txt").touch()
-        Path(self.test_dir, "another_test_file.md").touch()
-
-    def tearDown(self):
-        # Remove the temporary directory after the test
-        shutil.rmtree(self.test_dir)
-
-    def test_list_files_no_extension(self):
-        files = SysUtil.list_files(self.test_dir)
-        self.assertEqual(len(files), 2)  # Expecting 2 files
-
-    def test_list_files_with_extension(self):
-        files = SysUtil.list_files(self.test_dir, extension="txt")
-        self.assertEqual(len(files), 1)  # Expecting 1 .txt file
-        self.assertTrue(files[0].name.endswith(".txt"))
-
-    def test_change_existing_key(self):
-        test_dict = {"old_key": "value"}
-        SysUtil.change_dict_key(test_dict, "old_key", "new_key")
-        self.assertIn("new_key", test_dict)
-        self.assertNotIn("old_key", test_dict)
-
-    def test_change_non_existing_key(self):
-        test_dict = {"key": "value"}
-        SysUtil.change_dict_key(test_dict, "non_existing_key", "new_key")
-        self.assertNotIn("new_key", test_dict)
-        self.assertIn("key", test_dict)
-
-    def test_change_key_to_existing_key(self):
-        test_dict = {"old_key": "value1", "new_key": "value2"}
-        SysUtil.change_dict_key(test_dict, "old_key", "new_key")
-        self.assertEqual(test_dict["new_key"], "value1")
-
-    def test_default_separator(self):
-        timestamp = SysUtil.get_timestamp()
-        self.assertNotIn(":", timestamp)
-        self.assertNotIn(".", timestamp)
-
-    def test_custom_separator(self):
-        timestamp = SysUtil.get_timestamp(sep="-")
-        self.assertNotIn(":", timestamp)
-        self.assertNotIn(".", timestamp)
-        self.assertIn("-", timestamp)
-
-    def test_valid_schema(self):
-        test_dict = {"key1": 1, "key2": "value"}
-        schema = {"key1": int, "key2": str}
-        self.assertTrue(SysUtil.is_schema(test_dict, schema))
-
-    def test_invalid_schema(self):
-        test_dict = {"key1": "value", "key2": "value"}
-        schema = {"key1": int, "key2": str}
-        self.assertFalse(SysUtil.is_schema(test_dict, schema))
-
-    def test_partial_schema(self):
-        test_dict = {"key1": 1}
-        schema = {"key1": int, "key2": str}
-        self.assertFalse(SysUtil.is_schema(test_dict, schema))
-
-    def test_single_copy(self):
-        original = {"key": "value"}
-        copy = SysUtil.create_copy(original)
-        self.assertEqual(original, copy)
-        self.assertNotEqual(id(original), id(copy))
-
-    def test_multiple_copies(self):
-        original = {"key": "value"}
-        copies = SysUtil.create_copy(original, num=2)
-        self.assertEqual(len(copies), 2)
-        self.assertNotEqual(id(copies[0]), id(copies[1]))
-
-    def test_invalid_num(self):
-        with self.assertRaises(ValueError):
-            SysUtil.create_copy({}, num=0)
-
-    def test_id_length(self):
-        id_ = SysUtil.create_id()
-        self.assertEqual(len(id_), 32)
-
-    def test_custom_length(self):
-        id_ = SysUtil.create_id(n=16)
-        self.assertEqual(len(id_), 16)
-
-    def test_bins_with_small_strings(self):
-        input_ = ["a", "b", "c", "d"]
-        bins = SysUtil.get_bins(input_, upper=2)
-        self.assertEqual(len(bins), 4)
-
-    def test_bins_with_large_strings(self):
-        input_ = ["a" * 1000, "b" * 1000, "c" * 1000]
-        bins = SysUtil.get_bins(input_)
-        self.assertEqual(len(bins), 3)
-
-    def test_bins_with_empty_input(self):
-        bins = SysUtil.get_bins([])
-        self.assertEqual(len(bins), 0)
-
-
-if __name__ == "__main__":
-    unittest.main()

lionagi/tests/test_core/collections/test_component.py

@@ -1,208 +0,0 @@
-import json
-import unittest
-from datetime import datetime
-
-import pandas as pd
-
-from lionagi.core.collections.abc.component import (
-    Component,
-    LionTypeError,
-    LionValueError,
-)
-
-
-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

@@ -1,139 +0,0 @@
-import unittest
-
-from lionagi import Node, pile, progression
-from lionagi.core.collections import Exchange
-from lionagi.core.collections.abc import Element
-
-
-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()