lionagi 0.0.115__py3-none-any.whl → 0.0.204__py3-none-any.whl

lionagi/tests/test_flat_util.py

@@ -1,426 +0,0 @@
-import unittest
-
-from lionagi.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/utils/convert_util.py

@@ -1,229 +0,0 @@
-# this module has no internal dependency 
-import inspect
-import re
-import xml.etree.ElementTree as ET
-from typing import Optional, Union, Any, Type, Dict
-
-
-def str_to_num(input_: str, 
-               upper_bound: Optional[Union[int, float]] = None, 
-               lower_bound: Optional[Union[int, float]] = None, 
-               num_type: Type[Union[int, float]] = int, 
-               precision: Optional[int] = None) -> Union[int, float]:
-    """
-    Converts the first number in the input string to the specified numeric type.
-
-    Parameters:
-        input_ (str): The input string to extract the number from.
-        
-        upper_bound (Optional[Union[int, float]]): The upper bound for the number. Defaults to None.
-        
-        lower_bound (Optional[Union[int, float]]): The lower bound for the number. Defaults to None.
-        
-        num_type (Type[Union[int, float]]): The type of the number to return (int or float). Defaults to int.
-        
-        precision (Optional[int]): The precision for the floating-point number. Defaults to None.
-
-    Returns:
-        Union[int, float]: The converted number.
-
-    Raises:
-        ValueError: If no numeric values are found in the string or if there are conversion errors.
-    """
-    numbers = re.findall(r'-?\d+\.?\d*', input_)
-    if not numbers:
-        raise ValueError(f"No numeric values found in the string: {input_}")
-    
-    try:
-        numbers = numbers[0]
-        if num_type is int: 
-            numbers = int(float(numbers))
-        elif num_type is float:
-            numbers = round(float(numbers), precision) if precision is not None else float(numbers)
-        else:
-            raise ValueError(f"Invalid number type: {num_type}")
-        if upper_bound is not None and numbers > upper_bound:
-            raise ValueError(f"Number {numbers} is greater than the upper bound of {upper_bound}.")
-        if lower_bound is not None and numbers < lower_bound:
-            raise ValueError(f"Number {numbers} is less than the lower bound of {lower_bound}.")
-        return numbers
-    
-    except ValueError as e:
-        raise ValueError(f"Error converting string to number: {e}")
-    
-def dict_to_xml(data: Dict[str, Any], root_tag: str = 'node') -> str:
-    """
-    Helper method to convert a dictionary to an XML string.
-
-    Parameters:
-        data (Dict[str, Any]): The dictionary to convert to XML.
-        root_tag (str): The root tag name for the XML.
-
-    Returns:
-        str: An XML string representation of the dictionary.
-    """
-    root = ET.Element(root_tag)
-    _build_xml(root, data)
-    return ET.tostring(root, encoding='unicode')
-
-def _build_xml(element: ET.Element, data: Any):
-    """Recursively builds XML elements from data."""
-    if isinstance(data, dict):
-        for key, value in data.items():
-            sub_element = ET.SubElement(element, key)
-            _build_xml(sub_element, value)
-    elif isinstance(data, list):
-        for item in data:
-            item_element = ET.SubElement(element, 'item')
-            _build_xml(item_element, item)
-    else:
-        element.text = str(data)
-
-def xml_to_dict(element: ET.Element) -> Dict[str, Any]:
-    """
-    Helper method to convert an XML element back into a dictionary.
-    """
-    dict_data = {}
-    for child in element:
-        if child.getchildren():
-            dict_data[child.tag] = xml_to_dict(child)
-        else:
-            dict_data[child.tag] = child.text
-    return dict_data
-
-def extract_docstring_details_google(func):
-    docstring = inspect.getdoc(func)
-    if not docstring:
-        return "No description available.", {}
-    lines = docstring.split('\n')
-    func_description = lines[0].strip()
-
-    param_start_pos = 0
-    lines_len = len(lines)
-
-    params_description = {}
-    for i in range(1, lines_len):
-        if lines[i].startswith('Args') or lines[i].startswith('Arguments') or lines[i].startswith('Parameters'):
-            param_start_pos = i + 1
-            break
-
-    current_param = None
-    for i in range(param_start_pos, lines_len):
-        if lines[i] == '':
-            continue
-        elif lines[i].startswith(' '):
-            param_desc = lines[i].split(':', 1)
-            if len(param_desc) == 1:
-                params_description[current_param] += ' ' + param_desc[0].strip()
-                continue
-            param, desc = param_desc
-            param = param.split('(')[0].strip()
-            params_description[param] = desc.strip()
-            current_param = param
-        else:
-            break
-    return func_description, params_description
-
-def extract_docstring_details_rest(func):
-    docstring = inspect.getdoc(func)
-    if not docstring:
-        return "No description available.", {}
-    lines = docstring.split('\n')
-    func_description = lines[0].strip()
-
-    params_description = {}
-    current_param = None
-    for line in lines[1:]:
-        line = line.strip()
-        if line.startswith(':param'):
-            param_desc = line.split(':', 2)
-            _, param, desc = param_desc
-            param = param.split()[-1].strip()
-            params_description[param] = desc.strip()
-            current_param = param
-        elif line.startswith(' '):
-            params_description[current_param] += ' ' + line
-
-    return func_description, params_description
-
-def extract_docstring_details(func, style='google'):
-    if style == 'google':
-        func_description, params_description = extract_docstring_details_google(func)
-    elif style == 'reST':
-        func_description, params_description = extract_docstring_details_rest(func)
-    else:
-        raise ValueError(f'{style} is not supported. Please choose either "google" or "reST".')
-    return func_description, params_description
-
-def python_to_json_type(py_type):
-    """
-    Converts a Python type to its JSON type equivalent.
-
-    Parameters:
-        py_type (str): The name of the Python type.
-
-    Returns:
-        str: The corresponding JSON type.
-    """
-    type_mapping = {
-        'str': 'string',
-        'int': 'number',
-        'float': 'number',
-        'list': 'array',
-        'tuple': 'array',
-        'bool': 'boolean',
-        'dict': 'object'
-    }
-    return type_mapping.get(py_type, 'object')
-
-def func_to_schema(func, style='google'):
-    """
-    Generates a schema description for a given function, using typing hints and docstrings.
-    The schema includes the function's name, description, and parameters.
-
-    Parameters:
-        func (function): The function to generate a schema for.
-
-        style (str): The docstring format.
-
-    Returns:
-        dict: A schema describing the function.
-    """
-    # Extracting function name and docstring details
-    func_name = func.__name__
-    func_description, params_description = extract_docstring_details(func, style)
-
-    # Extracting parameters with typing hints
-    sig = inspect.signature(func)
-    parameters = {
-        "type": "object",
-        "properties": {},
-        "required": [],
-    }
-
-    for name, param in sig.parameters.items():
-        # Default type to string and update if type hint is available
-        param_type = "string"
-        if param.annotation is not inspect.Parameter.empty:
-            param_type = python_to_json_type(param.annotation.__name__)
-
-        # Extract parameter description from docstring, if available
-        param_description = params_description.get(name, "No description available.")
-
-        # Assuming all parameters are required for simplicity
-        parameters["required"].append(name)
-        parameters["properties"][name] = {
-            "type": param_type,
-            "description": param_description,
-        }
-
-    # Constructing the schema
-    schema = {
-        "type": "function",
-        "function": {
-            "name": func_name,
-            "description": func_description,
-            "parameters": parameters,
-        }
-    }
-    return schema