lionagi 0.0.112__py3-none-any.whl → 0.0.113__py3-none-any.whl

lionagi/structure/structure.py

@@ -0,0 +1,160 @@
+from typing import TypeVar, Dict, Optional, Any, Type, Union, List
+from pydantic import Field
+from ..schema.base_schema import BaseNode
+from .relationship import Relationship
+
+T = TypeVar('T', bound='BaseNode')
+R = TypeVar('R', bound='Relationship')
+
+
+class Structure(BaseNode):
+    """
+    Represents the structure of a graph consisting of nodes and relationships.
+    """
+    nodes: Dict[str, T] = Field(default_factory=dict)
+    relationships: Dict[str, R] = Field(default_factory=dict)
+    node_relationships: Dict[str, Dict[str, Dict[str, str]]] = Field(default_factory=dict)
+
+    def add_node(self, node: T) -> None:
+        """
+        Adds a node to the structure.
+        
+        Args:
+            node (T): The node instance to be added.
+        """
+        self.nodes[node.id_] = node
+        self.node_relationships[node.id_] = {'in': {}, 'out': {}}
+
+    def add_relationship(self, relationship: R) -> None:
+        """
+        Adds a relationship to the structure.
+        
+        Args:
+            relationship (R): The relationship instance to be added.
+        """
+        id_, source_, target_ = (
+            relationship.id_, relationship.source_node_id, relationship.target_node_id
+            )
+        
+        self.relationships.update({id_ : relationship})
+        self.node_relationships[source_]['out'].update({id_ : target_})
+        self.node_relationships[target_]['in'].update({id_ : source_})
+
+    # type can be dict or list
+    @staticmethod
+    def _typed_return(type: Type[Union[Dict, List]], 
+                      obj: Optional[Dict[str, Any]] = None
+                      ) -> Union[Dict[str, Any], List[Any]]:
+        """
+        Returns the object in the specified type format.
+        
+        Args:
+            type (Type[Union[Dict, List]]): The type to return the object as (dict or list).
+            
+            obj (Optional[Dict[str, Any]]): The object to be converted.
+            
+        Returns:
+            Union[Dict[str, Any], List[Any]]: The object in the specified type format.
+        """
+        if type is list:
+            return list(obj.values())
+        return obj
+    
+    def get_relationships(self, type: Type = dict) -> Union[Dict[str, R], List[R]]:
+        """
+        Returns the relationships in the specified type format.
+        
+        Args:
+            type (Type): The type to return the relationships as (dict or list).
+            
+        Returns:
+            Union[Dict[str, R], List[R]]: The relationships in the specified type format.
+        """
+        return self._typed_return(self.relationships, type=type)
+        
+    def get_node_relationships(self, id_: str, in_out: str, type: Type = dict
+                               ) -> Union[Dict[str, str], List[str]]:
+        """
+        Returns the relationships of a node in the specified type format.
+        
+        Args:
+            id_ (str): The ID of the node.
+            
+            in_out (str): 'in' for incoming relationships, 'out' for outgoing relationships.
+            
+            type (Type): The type to return the relationships as (dict or list).
+            
+        Returns:
+            Union[Dict[str, str], List[str]]: The relationships of the node in the specified type format.
+        """
+        node_relationships = self.node_relationships[id_][in_out]
+        return self._typed_return(node_relationships, type=type)
+
+    def node_exist(self, node: Union[T, str]) -> bool:
+        """
+        Checks if a node exists in the structure.
+        
+        Args:
+            node (Union[T, str]): The node instance or node ID to check for existence.
+            
+        Returns:
+            bool: True if the node exists, False otherwise.
+        """
+
+        return node.id_ in self.nodes.keys()
+    
+    def relationship_exist(self, relationship: R) -> bool:
+        """
+        Checks if a relationship exists in the structure.
+        
+        Args:
+            relationship (R): The relationship instance to check for existence.
+            
+        Returns:
+            bool: True if the relationship exists, False otherwise.
+        """
+        return relationship.id_ in self.relationships.keys()
+        
+    def remove_node_relationships(self, relationship_dict: Dict[str, str], in_out: str) -> None:
+        """
+        Removes relationships of a node from the structure.
+        
+        Args:
+            relationship_dict (Dict[str, str]): A dictionary of relationship IDs to node IDs.
+            
+            in_out (str): 'in' to remove incoming relationships, 'out' to remove outgoing relationships.
+        """
+        for relationship_id, node_id in relationship_dict.items():
+            self.node_relationships[node_id][in_out].pop(relationship_id)
+            self.relationships.pop(relationship_id)
+
+    def remove_node(self, node: Union[T, str]) -> None:
+        """
+        Removes a node and its associated relationships from the structure.
+        
+        Args:
+            node (Union[T, str]): The node instance or node ID to be removed.
+        """
+        node_id = node if isinstance(node, str) else node.id_
+        out_ = self.get_node_relationships(node_id, 'out')
+        in_ = self.get_node_relationships(node_id, 'in')
+        
+        self.remove_node_relationships(out_, 'in')
+        self.remove_node_relationships(in_, 'out')
+        self.node_relationships.pop(node_id)
+
+    def remove_relationship(self, relationship: R) -> None:
+        """
+        Removes a relationship from the structure.
+        
+        Args:
+            relationship (R): The relationship instance to be removed.
+        """
+        id_, source_, target_ = (relationship.id_, 
+                                 relationship.source_node_id, 
+                                 relationship.target_node_id)
+        
+        self.node_relationships[source_]['out'].pop(id_)
+        self.node_relationships[target_]['in'].pop(id_)
+        self.relationships.pop(id_)
+        

lionagi/tests/test_flatten_util.py

@@ -0,0 +1,426 @@
+import unittest
+
+from ..utils.flat_util import *
+
+class TestFlattenDict(unittest.TestCase): 
+
+    def test_flatten_empty_dict(self): 
+        self.assertEqual(flatten_dict({}), {})
+
+    def test_flatten_flat_dict(self):
+        self.assertEqual(flatten_dict({'a': 1, 'b': 2, 'c': 3}), {'a': 1, 'b': 2, 'c': 3})
+
+    def test_flatten_nested_dict(self):
+        nested_dict = {'a': 1, 'b': {'c': 2, 'd': {'e': 3, 'f': 4}}}
+        expected_flat_dict = {'a': 1, 'b_c': 2, 'b_d_e': 3, 'b_d_f': 4}
+        self.assertEqual(flatten_dict(nested_dict), expected_flat_dict)
+
+    def test_flatten_dict_with_custom_separator(self):
+        nested_dict = {'a': {'b': 1, 'c': {'d': 2}}}
+        expected_flat_dict = {'a.b': 1, 'a.c.d': 2}
+        self.assertEqual(flatten_dict(nested_dict, sep='.'), expected_flat_dict)
+
+    def test_flatten_dict_with_empty_subdict(self):
+        nested_dict = {'a': 1, 'b': {}}
+        expected_flat_dict = {'a': 1}
+        self.assertEqual(flatten_dict(nested_dict), expected_flat_dict)
+
+    def test_flatten_dict_with_non_dict_values(self):
+        nested_dict = {'a': [1, 2, 3], 'b': 'string', 'c': {'d': 4}}
+        expected_flat_dict = {'a': [1, 2, 3], 'b': 'string', 'c_d': 4}
+        self.assertEqual(flatten_dict(nested_dict), expected_flat_dict)
+
+class TestFlattenList(unittest.TestCase): 
+    def test_flatten_empty_list(self): self.assertEqual(flatten_list([]), [])
+
+    def test_flatten_flat_list(self):
+        self.assertEqual(flatten_list([1, 2, 3]), [1, 2, 3])
+
+    def test_flatten_nested_list(self):
+        self.assertEqual(flatten_list([1, [2, [3, 4]], 5]), [1, 2, 3, 4, 5])
+
+    def test_flatten_list_with_None(self):
+        self.assertEqual(flatten_list([1, None, [2, None], 3], dropna=True), [1, 2, 3])
+        self.assertEqual(flatten_list([1, None, [2, None], 3], dropna=False), [1, None, 2, None, 3])
+
+    def test_flatten_list_with_other_datatypes(self):
+        self.assertEqual(flatten_list([1, "string", [2, (3, 4)], 5]), [1, "string", 2, (3, 4), 5])
+
+    def test_flatten_list_with_multiple_nested_lists(self):
+        self.assertEqual(flatten_list([[1, [2, 3]], [4, [5, [6, 7]]]]), [1, 2, 3, 4, 5, 6, 7])
+
+class TestChangeSeparator(unittest.TestCase):
+
+    def test_change_separator_basic(self):
+        input_dict = {'a_b': 1, 'a_b_c': 2, 'd': 3}
+        expected_dict = {'a-b': 1, 'a-b-c': 2, 'd': 3}
+        result_dict = change_separator(input_dict, '_', '-')
+        self.assertEqual(expected_dict, result_dict)
+
+    def test_change_separator_no_change(self):
+        input_dict = {'a-b': 1, 'b-c': 2}
+        expected_dict = {'a-b': 1, 'b-c': 2}
+        result_dict = change_separator(input_dict, '_', '-')
+        self.assertEqual(expected_dict, result_dict)
+
+    def test_change_separator_empty_dict(self):
+        self.assertEqual({}, change_separator({}, '_', '-'))
+
+    def test_change_separator_same_separators(self):
+        input_dict = {'a_b': 1, 'b_c': 2}
+        expected_dict = {'a_b': 1, 'b_c': 2}
+        result_dict = change_separator(input_dict, '_', '_')
+        self.assertEqual(expected_dict, result_dict)
+
+    def test_change_separator_multiple_occurrences(self):
+        input_dict = {'a_b_c_b': 1, 'd_e_f_e': 2}
+        expected_dict = {'a-b-c-b': 1, 'd-e-f-e': 2}
+        result_dict = change_separator(input_dict, '_', '-')
+        self.assertEqual(expected_dict, result_dict)
+        
+class TestUnflattenDict(unittest.TestCase):
+
+    def test_unflatten_simple(self):
+        flat_dict = {'a_b_c': 1, 'a_b_d': 2}
+        expected = {'a': {'b': {'c': 1, 'd': 2}}}
+        self.assertEqual(unflatten_dict(flat_dict), expected)
+
+    def test_unflatten_with_int_keys(self):
+        flat_dict = {'1_2_3': 'a', '1_2_4': 'b'}
+        expected = {1: {2: {3: 'a', 4: 'b'}}}
+        self.assertEqual(unflatten_dict(flat_dict), expected)
+
+    def test_unflatten_with_mixed_keys(self):
+        flat_dict = {'a_2_c': 1, 'a_2_d': 2, 'b_3': 3}
+        expected = {'a': {2: {'c': 1, 'd': 2}}, 'b': {3: 3}}
+        self.assertEqual(unflatten_dict(flat_dict), expected)
+
+    def test_unflatten_with_custom_separator(self):
+        flat_dict = {'a|b|c': 1, 'a|b|d': 2}
+        expected = {'a': {'b': {'c': 1, 'd': 2}}}
+        self.assertEqual(unflatten_dict(flat_dict, sep='|'), expected)
+
+    def test_unflatten_with_non_dict_value(self):
+        flat_dict = {'a_b': [1, 2, 3], 'a_c': (4, 5)}
+        expected = {'a': {'b': [1, 2, 3], 'c': (4, 5)}}
+        self.assertEqual(unflatten_dict(flat_dict), expected)
+
+    def test_unflatten_with_nested_list(self):
+        flat_dict = {'a_0': 1, 'a_1': 2, 'b_0': 3, 'b_1': 4}
+        expected = {'a': [1, 2], 'b': [3, 4]}
+        self.assertEqual(unflatten_dict(flat_dict), expected)
+
+    def test_unflatten_with_overlapping_keys(self):
+        flat_dict = {'a_b': 1, 'a': 2}
+        with self.assertRaises(ValueError):
+            unflatten_dict(flat_dict)
+
+class TestIsFlattenable(unittest.TestCase):
+
+    def test_flattenable_dict(self):
+        self.assertTrue(is_flattenable({'a': {'b': 1}, 'c': [2, 3]}))
+
+    def test_flattenable_list(self):
+        self.assertTrue(is_flattenable([1, {'a': 2}, [3]]))
+
+    def test_non_flattenable_dict(self):
+        self.assertFalse(is_flattenable({'a': 1, 'b': 2}))
+
+    def test_non_flattenable_list(self):
+        self.assertFalse(is_flattenable([1, 2, 3]))
+
+    def test_empty_dict(self):
+        self.assertFalse(is_flattenable({}))
+
+    def test_empty_list(self):
+        self.assertFalse(is_flattenable([]))
+
+    def test_non_flattenable_types(self):
+        self.assertFalse(is_flattenable(1))
+        self.assertFalse(is_flattenable(1.0))
+        self.assertFalse(is_flattenable('string'))
+        self.assertFalse(is_flattenable(None))
+
+    def test_nested_mix_flattenable(self):
+        self.assertTrue(is_flattenable({'a': [{'b': 1}], 'c': (2, 3)}))
+
+    def test_deeply_nested_flattenable(self):
+        self.assertTrue(is_flattenable({'a': {'b': {'c': {'d': [1]}}}}))
+        
+
+def default_logic_func(parent_key, key, value, sep='_'):
+    new_key = f"{parent_key}{sep}{key}" if parent_key else key
+    return new_key, value
+
+
+class TestFlattenWithCustomLogic(unittest.TestCase):
+    def test_flatten_dict(self):
+        input_dict = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+        expected_output = {'a': 1, 'b_c': 2, 'b_d_e': 3}
+        self.assertEqual(flatten_with_custom_logic(input_dict, default_logic_func), expected_output)
+
+    def test_flatten_list(self):
+        input_list = [1, 2, [3, 4]]
+        expected_output = {'0': 1, '1': 2, '2_0': 3, '2_1': 4}
+        self.assertEqual(flatten_with_custom_logic(input_list, default_logic_func), expected_output)
+
+
+    def test_empty_dict(self):
+        self.assertEqual(flatten_with_custom_logic({}, default_logic_func), {})
+
+    def test_empty_list(self):
+        self.assertEqual(flatten_with_custom_logic([], default_logic_func), {})
+
+    def test_nested_combination(self):
+        input_obj = {'a': [{'b': 1}, {'c': 2}], 'd': []}
+        expected_output = {'a_0_b': 1, 'a_1_c': 2, 'd': None}
+        self.assertEqual(flatten_with_custom_logic(input_obj, default_logic_func), expected_output)
+
+    def test_custom_separator(self):
+        input_obj = {'a': 1, 'b': {'c': 2}}
+        expected_output = {'a': 1, 'b#c': 2}
+        self.assertEqual(flatten_with_custom_logic(input_obj, default_logic_func, sep='#'), expected_output)
+
+    def test_logic_func_none(self):
+        input_obj = {'a': 1, 'b': {'c': 2}}
+        expected_output = {'a': 1, 'b_c': 2}
+        self.assertEqual(flatten_with_custom_logic(input_obj, None), expected_output)
+
+    def test_obj_with_none_values(self):
+        input_obj = {'a': None, 'b': {'c': None}}
+        expected_output = {'a': None, 'b_c': None}
+        self.assertEqual(flatten_with_custom_logic(input_obj, default_logic_func), expected_output)
+
+    def test_custom_logic_func(self):
+        def custom_logic(parent_key, key, value, sep='_'):
+            new_key = f"{parent_key}{sep}{key}".upper() if parent_key else key.upper()
+            return new_key, value*2 if isinstance(value, int) else value
+        
+        input_obj = {'a': 1, 'b': {'c': 2}}
+        expected_output = {'A': 2, 'B_C': 4}
+        self.assertEqual(flatten_with_custom_logic(input_obj, custom_logic), expected_output)
+
+class TestDynamicFlatten(unittest.TestCase):
+
+    def test_flatten_dict(self):
+        sample_dict = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+        flattened = dynamic_flatten(sample_dict)
+        expected = {'a': 1, 'b_c': 2, 'b_d_e': 3}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_list(self):
+        sample_list = [1, 2, [3, 4]]
+        flattened = dynamic_flatten(sample_list)
+        expected = {'0': 1, '1': 2, '2_0': 3, '2_1': 4}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_with_max_depth(self):
+        sample_dict = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+        flattened = dynamic_flatten(sample_dict, max_depth=1)
+        expected = {'a': 1, 'b_c': 2, 'b_d': {'e': 3}}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_with_different_separator(self):
+        sample_dict = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+        flattened = dynamic_flatten(sample_dict, sep='.')
+        expected = {'a': 1, 'b.c': 2, 'b.d.e': 3}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_empty_dictionary(self):
+        sample_dict = {}
+        flattened = dynamic_flatten(sample_dict)
+        expected = {}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_empty_list(self):
+        sample_list = []
+        flattened = dynamic_flatten(sample_list)
+        expected = {}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_non_dict_non_list(self):
+        with self.assertRaises(TypeError):
+            dynamic_flatten(42)
+
+    def test_flatten_nested_empty_dict(self):
+        sample_dict = {'a': {}, 'b': {'c': {}}}
+        flattened = dynamic_flatten(sample_dict)
+        expected = {'a': {}, 'b_c': {}}
+        self.assertEqual(flattened, expected)
+
+    def test_flatten_nested_empty_list(self):
+        sample_list = [1, [], [3, []]]
+        flattened = dynamic_flatten(sample_list)
+        expected = {'0': 1, '1': [], '2_0': 3, '2_1': []}
+        self.assertEqual(flattened, expected)
+        
+# class TestDynamicUnflatten(unittest.TestCase):
+
+#     def test_unflatten_dict(self):
+#         flat_dict = {'a': 1, 'b_c': 2, 'b_d_e': 3}
+#         expected = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+#         self.assertEqual(dynamic_unflatten(flat_dict), expected)
+
+
+#     def test_unflatten_with_different_separator(self):
+#         flat_dict = {'a': 1, 'b.c': 2, 'b.d.e': 3}
+#         expected = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}}
+#         self.assertEqual(dynamic_unflatten(flat_dict, sep='.'), expected)
+
+#     def test_unflatten_empty_dict(self):
+#         flat_dict = {}
+#         expected = []
+#         self.assertEqual(dynamic_unflatten(flat_dict), expected)
+
+#     def test_unflatten_empty_string_keys(self):
+#         flat_dict = {'': 1}
+#         expected = {'': 1}
+#         self.assertEqual(dynamic_unflatten(flat_dict), expected)
+
+#     def test_unflatten_single_key(self):
+#         flat_dict = {'a': 1}
+#         expected = {'a': 1}
+#         self.assertEqual(dynamic_unflatten(flat_dict), expected)
+
+#     def test_unflatten_nested_empty_dict(self):
+#         flat_dict = {'a': {}, 'b_c': {}}
+#         expected = {'a': {}, 'b': {'c': {}}}
+#         self.assertEqual(dynamic_unflatten(flat_dict), expected)
+
+
+#     def test_unflatten_max_depth(self):
+#         flat_dict = {'a_b_c_d_e': 1}
+#         expected = {'a': {'b': {'c': {'d': {'e': 1}}}}}
+#         self.assertEqual(dynamic_unflatten(flat_dict, max_depth=3), expected)
+        
+class TestUnflattenToList(unittest.TestCase): 
+    
+    def test_unflatten_simple_list(self): 
+        flat_dict = {'0': 'a', '1': 'b', '2': 'c'} 
+        expected = ['a', 'b', 'c'] 
+        self.assertEqual(unflatten_to_list(flat_dict), expected)
+
+    def test_unflatten_nested_dicts_in_list(self):
+        flat_dict = {'0_a': 'value1', '1_b': 'value2', '2_c_d': 'value3'}
+        expected = [{'a': 'value1'}, {'b': 'value2'}, {'c': {'d': 'value3'}}]
+        self.assertEqual(unflatten_to_list(flat_dict), expected)
+
+    def test_unflatten_empty_dict(self):
+        flat_dict = {}
+        expected = []
+        self.assertEqual(unflatten_to_list(flat_dict), expected)
+
+    def test_unflatten_with_custom_separator(self):
+        flat_dict = {'0-a': 'value1', '1-b': 'value2', '2-c-d': 'value3'}
+        expected = [{'a': 'value1'}, {'b': 'value2'}, {'c': {'d': 'value3'}}]
+        self.assertEqual(unflatten_to_list(flat_dict, sep='-'), expected)
+
+    def test_unflatten_with_sparse_indices(self):
+        flat_dict = {'0': 'value1', '2': 'value2', '5': 'value3'}
+        expected = ['value1', None, 'value2', None, None, 'value3']
+        self.assertEqual(unflatten_to_list(flat_dict), expected)
+    
+    def test_unflatten_with_negative_indices(self):
+        flat_dict = {'-1': 'value1', '1': 'value2'}
+        with self.assertRaises(ValueError):  # Expect ValueError instead of IndexError
+            unflatten_to_list(flat_dict)
+
+    def test_unflatten_with_custom_separator(self):
+        flat_dict = {'0-a': 'value1', '1-b': 'value2', '2-c-d': 'value3'}
+        expected = [{'a': 'value1'}, {'b': 'value2'}, {'c': {'d': 'value3'}}]
+        self.assertEqual(unflatten_to_list(flat_dict, sep='-'), expected)
+        
+
+class TestFlattenIterable(unittest.TestCase):
+
+    def test_flatten_empty_list(self):
+        self.assertEqual(list(flatten_iterable([])), [])
+
+    def test_flatten_nested_lists(self):
+        nested_list = [1, [2, [3, 4], 5], 6]
+        expected_flat_list = [1, 2, 3, 4, 5, 6]
+        self.assertEqual(list(flatten_iterable(nested_list)), expected_flat_list)
+
+    def test_flatten_nested_tuples(self):
+        nested_tuple = (1, (2, (3, 4), 5), 6)
+        expected_flat_list = [1, 2, 3, 4, 5, 6]
+        self.assertEqual(list(flatten_iterable(nested_tuple)), expected_flat_list)
+
+    def test_flatten_with_max_depth(self):
+        nested_list = [1, [2, [3, 4], 5], 6]
+        expected_flat_list_depth_1 = [1, [2, [3, 4], 5], 6]
+        self.assertEqual(list(flatten_iterable(nested_list, max_depth=1)), expected_flat_list_depth_1)
+        
+        expected_flat_list_depth_2 = [1, 2, [3, 4], 5, 6]
+        self.assertEqual(list(flatten_iterable(nested_list, max_depth=2)), expected_flat_list_depth_2)
+
+    # def test_flatten_strings(self):
+    #     nested_list = ["hello", ["world", ["!"]]]
+    #     expected_flat_list = ["hello", "world", ["!"]]
+    #     self.assertEqual(list(flatten_iterable(nested_list)), expected_flat_list)
+
+    def test_flatten_with_non_iterable(self):
+        nested_list = [1, [2, 3], 4, "text", 5]
+        expected_flat_list = [1, 2, 3, 4, "text", 5]
+        self.assertEqual(list(flatten_iterable(nested_list)), expected_flat_list)
+
+    def test_flatten_with_none_max_depth(self):
+        nested_list = [1, [2, [3, [4, [5]]]]]
+        expected_flat_list = [1, 2, 3, 4, 5]
+        self.assertEqual(list(flatten_iterable(nested_list, max_depth=None)), expected_flat_list)
+
+    def test_flatten_iterable_to_list_function(self):
+        nested_list = [1, [2, [3, 4], 5], 6]
+        expected_flat_list = [1, 2, 3, 4, 5, 6]
+        self.assertEqual(flatten_iterable_to_list(nested_list), expected_flat_list)
+
+        nested_list_with_depth = [1, [2, [3, [4, [5]]]]]
+        expected_flat_list_with_depth = [1, 2, [3, [4, [5]]]]
+        self.assertEqual(flatten_iterable_to_list(nested_list_with_depth, max_depth=2), expected_flat_list_with_depth)
+        
+        
+class TestUnflattenDictWithCustomLogic(unittest.TestCase):
+    
+    @staticmethod
+    def logic_func_upper(key: str, value: Any) -> Tuple[str, Any]:
+        return key.upper(), value
+
+    @staticmethod
+    def logic_func_append_prefix(key: str, value: Any) -> Tuple[str, Any]:
+ 
+        return f"prefix_{key}", value
+
+    # def test_unflatten_dict_with_uppercase_logic(self):
+    #     flat_dict = {'a_1': 10, 'b_2': 20, 'c_sub_1': 30}
+    #     expected_dict = {'A': {'1': 10}, 'B': {'2': 20}, 'C_SUB': {'1': 30}}
+    #     self.assertEqual(
+    #         unflatten_dict_with_custom_logic(flat_dict, self.logic_func_upper),
+    #         expected_dict
+    #     )
+
+    # def test_unflatten_dict_with_prefix_logic(self):
+    #     flat_dict = {'a_1': 10, 'b_2': 20, 'c_sub_1': 30}
+    #     expected_dict = {'prefix_a': {'prefix_1': 10}, 'prefix_b': {'prefix_2': 20}, 'prefix_c_sub': {'prefix_1': 30}}
+    #     self.assertEqual(
+    #         unflatten_dict_with_custom_logic(flat_dict, self.logic_func_append_prefix),
+    #         expected_dict
+    #     )
+
+    def test_unflatten_dict_with_no_modification_logic(self):
+        flat_dict = {'a_1': 10, 'b_2': 20, 'c_sub_1': 30}
+        identity_logic_func = lambda key, value: (key, value)
+        expected_dict = {'a': {'1': 10}, 'b': {'2': 20}, 'c': {'sub': {'1': 30}}}
+        self.assertEqual(
+            unflatten_dict_with_custom_logic(flat_dict, identity_logic_func),
+            expected_dict
+        )
+
+    def test_unflatten_dict_empty(self):
+        flat_dict = {}
+        self.assertEqual(
+            unflatten_dict_with_custom_logic(flat_dict, self.logic_func_upper),
+            {}
+        )
+        
+if __name__ == "main":
+    unittest.main()

lionagi/tools/__init__.py

@@ -1,5 +0,0 @@
-from .tool_utils import ToolManager
-
-__all__ = [
-    "ToolManager"
-]

lionagi/tools/coder.py

@@ -0,0 +1 @@
+# TODO

lionagi/tools/scorer.py

@@ -0,0 +1 @@
+# TODO

lionagi/tools/validator.py

@@ -0,0 +1 @@
+# TODO

lionagi/utils/__init__.py

@@ -1,23 +1,49 @@
-from .sys_utils import to_flat_dict, to_list, str_to_num, create_copy, to_temp, to_csv, append_to_jsonl, hold_call, ahold_call, l_call, al_call, m_call, am_call, e_call, ae_call, get_timestamp, create_id, create_path, get_bins
+from .flat_util import (
+    flatten_dict, flatten_list, change_separator, 
+    unflatten_dict, is_flattenable, dynamic_flatten, 
+    unflatten_to_list, flatten_iterable, flatten_iterable_to_list
+    )
+
+from .sys_util import (
+    create_copy, get_timestamp, create_id, create_path, 
+    split_path, get_bins, change_dict_key
+    )
+
+
+from .api_util import (
+    api_method, api_endpoint_from_url, api_error, 
+    api_rate_limit_error
+    )
+
+from .call_util import (
+    hcall, ahcall, lcall, alcall, 
+    mcall, amcall, ecall, aecall
+    )
+
+from .io_util import to_temp, to_csv, append_to_jsonl
+from .load_utils import dir_to_path, dir_to_nodes,  chunk_text, read_text, file_to_chunks
+from .type_util import str_to_num, to_list
+from .tool_util import func_to_schema
+
+
+
+
 
 __all__ = [
-    "to_flat_dict", 
-    "to_list",
-    "str_to_num",
-    "create_copy",
-    "to_temp",
-    "to_csv",
-    "append_to_jsonl",
-    "hold_call",
-    "ahold_call",
-    "l_call",
-    "al_call",
-    "m_call",
-    "am_call",
-    "e_call",
-    "ae_call",
-    "get_timestamp",
-    "create_id",
-    "create_path",
-    "get_bins"
+    "api_method", "api_endpoint_from_url", "api_error", 
+    "api_rate_limit_error",
+    
+    "flatten_dict", "flatten_list", "change_separator", 
+    "unflatten_dict", "is_flattenable", "dynamic_flatten", 
+    "unflatten_to_list", "flatten_iterable", "flatten_iterable_to_list",
+    
+    "create_copy", "get_timestamp", "create_id", "create_path", 
+    "split_path", "get_bins", "change_dict_key",
+    
+    "hcall", "ahcall", "lcall", "alcall", 
+    "mcall", "amcall", "ecall", "aecall",
+    
+    "to_temp", "to_csv", "append_to_jsonl",
+    "dir_to_path", "chunk_text", "file_to_chunks",
+    "str_to_num", "to_list", "func_to_schema"
 ]