lionagi 0.0.306__py3-none-any.whl → 0.0.307__py3-none-any.whl

lionagi/core/tool/tool_manager.py

@@ -1,13 +1,9 @@
 from typing import Tuple, Any, TypeVar, Callable
 
 import asyncio
-from lionagi.core.schema.base_node import Tool, TOOL_TYPE
-
-# from lionagi.libs.ln_async import AsyncUtil
-from lionagi.libs.ln_parse import ParseUtil
-from lionagi.libs import ln_convert as convert
-from lionagi.libs import ln_func_call as func_call
 
+from lionagi.libs import func_call, convert, ParseUtil
+from lionagi.core.schema.base_node import Tool, TOOL_TYPE
 
 T = TypeVar("T", bound=Tool)
 
@@ -21,7 +17,7 @@ class ToolManager:
     calls.
 
     Attributes:
-        registry (dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
+            registry (dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
     """
 
     registry: dict = {}
@@ -31,12 +27,12 @@ class ToolManager:
         Checks if a tool name already exists in the registry.
 
         Args:
-            name (str): The name of the tool to check.
+                name (str): The name of the tool to check.
 
         Returns:
-            bool: True if the name exists, False otherwise.
+                bool: True if the name exists, False otherwise.
         """
-        return True if name in self.registry.keys() else False
+        return name in self.registry
 
     @property
     def has_tools(self):
@@ -47,10 +43,10 @@ class ToolManager:
         Registers a tool in the registry. Raises a TypeError if the object is not an instance of Tool.
 
         Args:
-            tool (Tool): The tool instance to register.
+                tool (Tool): The tool instance to register.
 
         Raises:
-            TypeError: If the provided object is not an instance of Tool.
+                TypeError: If the provided object is not an instance of Tool.
         """
         if not isinstance(tool, Tool):
             raise TypeError("Please register a Tool object.")
@@ -62,33 +58,32 @@ class ToolManager:
         Invokes a registered tool's function with the given arguments. Supports both coroutine and regular functions.
 
         Args:
-            func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
+                func_call (Tuple[str, Dict[str, Any]]): A tuple containing the function name and a dictionary of keyword arguments.
 
         Returns:
-            Any: The result of the function call.
+                Any: The result of the function call.
 
         Raises:
-            ValueError: If the function name is not registered or if there's an error during function invocation.
+                ValueError: If the function name is not registered or if there's an error during function invocation.
         """
         name, kwargs = func_calls
-        if self.name_existed(name):
-            tool = self.registry[name]
-            func = tool.func
-            parser = tool.parser
-            try:
-                if func_call.is_coroutine_func(func):
-                    tasks = [func_call.call_handler(func, **kwargs)]
-                    out = await asyncio.gather(*tasks)
-                    return parser(out[0]) if parser else out[0]
-                else:
-                    out = func(**kwargs)
-                    return parser(out) if parser else out
-            except Exception as e:
-                raise ValueError(
-                    f"Error when invoking function {name} with arguments {kwargs} with error message {e}"
-                )
-        else:
+        if not self.name_existed(name):
             raise ValueError(f"Function {name} is not registered.")
+        tool = self.registry[name]
+        func = tool.func
+        parser = tool.parser
+        try:
+            if func_call.is_coroutine_func(func):
+                tasks = [func_call.call_handler(func, **kwargs)]
+                out = await asyncio.gather(*tasks)
+                return parser(out[0]) if parser else out[0]
+            else:
+                out = func(**kwargs)
+                return parser(out) if parser else out
+        except Exception as e:
+            raise ValueError(
+                f"Error when invoking function {name} with arguments {kwargs} with error message {e}"
+            ) from e
 
     @staticmethod
     def get_function_call(response: dict) -> Tuple[str, dict]:
@@ -96,19 +91,19 @@ class ToolManager:
         Extracts a function call and arguments from a response dictionary.
 
         Args:
-            response (dict): The response dictionary containing the function call information.
+                response (dict): The response dictionary containing the function call information.
 
         Returns:
-            Tuple[str, dict]: A tuple containing the function name and a dictionary of arguments.
+                Tuple[str, dict]: A tuple containing the function name and a dictionary of arguments.
 
         Raises:
-            ValueError: If the response does not contain valid function call information.
+                ValueError: If the response does not contain valid function call information.
         """
         try:
             func = response["action"][7:]
             args = convert.to_dict(response["arguments"])
             return func, args
-        except:
+        except Exception:
             try:
                 func = response["recipient_name"].split(".")[-1]
                 args = response["parameters"]
@@ -121,7 +116,7 @@ class ToolManager:
         Registers multiple tools in the registry.
 
         Args:
-            tools (list[Tool]): A list of tool instances to register.
+                tools (list[Tool]): A list of tool instances to register.
         """
         func_call.lcall(tools, self._register_tool)
 
@@ -130,27 +125,24 @@ class ToolManager:
         Generates a list of schemas for all registered tools.
 
         Returns:
-            list[dict[str, Any]]: A list of tool schemas.
+                list[dict[str, Any]]: A list of tool schemas.
 
         """
-        schema_list = []
-        for tool in self.registry.values():
-            schema_list.append(tool.schema_)
-        return schema_list
+        return [tool.schema_ for tool in self.registry.values()]
 
     def parse_tool(self, tools: TOOL_TYPE, **kwargs) -> dict:
         """
         Parses tool information and generates a dictionary for tool invocation.
 
         Args:
-            tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
-            **kwargs: Additional keyword arguments.
+                tools: Tool information which can be a single Tool instance, a list of Tool instances, a tool name, or a list of tool names.
+                **kwargs: Additional keyword arguments.
 
         Returns:
-            dict: A dictionary containing tool schema information and any additional keyword arguments.
+                dict: A dictionary containing tool schema information and any additional keyword arguments.
 
         Raises:
-            ValueError: If a tool name is provided that is not registered.
+                ValueError: If a tool name is provided that is not registered.
         """
 
         def tool_check(tool):
@@ -167,13 +159,13 @@ class ToolManager:
 
         if isinstance(tools, bool):
             tool_kwarg = {"tools": self.to_tool_schema_list()}
-            kwargs = {**tool_kwarg, **kwargs}
+            kwargs = tool_kwarg | kwargs
 
         else:
             if not isinstance(tools, list):
                 tools = [tools]
             tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
-            kwargs = {**tool_kwarg, **kwargs}
+            kwargs = tool_kwarg | kwargs
 
         return kwargs
 
@@ -196,66 +188,66 @@ def func_to_tool(
     objects with structured metadata.
 
     Args:
-        func_ (Callable): The function to be transformed into a Tool object. This
-                          function should have a docstring that follows the
-                          specified docstring style for accurate schema generation.
-        parser (Optional[Any]): An optional parser object associated with the Tool.
-                                This parameter is currently not utilized in the
-                                transformation process but is included for future
-                                compatibility and extension purposes.
-        docstring_style (str): The format of the docstring to be parsed, indicating
-                               the convention used in the function's docstring.
-                               Supports 'google' for Google-style docstrings and
-                               'reST' for reStructuredText-style docstrings. The
-                               chosen style affects how the docstring is parsed and
-                               how the schema is generated.
+            func_ (Callable): The function to be transformed into a Tool object. This
+                                              function should have a docstring that follows the
+                                              specified docstring style for accurate schema generation.
+            parser (Optional[Any]): An optional parser object associated with the Tool.
+                                                            This parameter is currently not utilized in the
+                                                            transformation process but is included for future
+                                                            compatibility and extension purposes.
+            docstring_style (str): The format of the docstring to be parsed, indicating
+                                                       the convention used in the function's docstring.
+                                                       Supports 'google' for Google-style docstrings and
+                                                       'reST' for reStructuredText-style docstrings. The
+                                                       chosen style affects how the docstring is parsed and
+                                                       how the schema is generated.
 
     Returns:
-        Tool: An object representing the original function wrapped as a Tool, along
-              with its generated schema. This Tool object can be used in systems that
-              require detailed metadata about functions, facilitating tasks such as
-              automatic documentation generation, user interface creation, or
-              integration with other software tools.
+            Tool: An object representing the original function wrapped as a Tool, along
+                      with its generated schema. This Tool object can be used in systems that
+                      require detailed metadata about functions, facilitating tasks such as
+                      automatic documentation generation, user interface creation, or
+                      integration with other software tools.
 
     Examples:
-        >>> def example_function_google(param1: int, param2: str) -> bool:
-        ...     '''
-        ...     An example function using Google style docstrings.
-        ...
-        ...     Args:
-        ...         param1 (int): The first parameter, demonstrating an integer input_.
-        ...         param2 (str): The second parameter, demonstrating a string input_.
-        ...
-        ...     Returns:
-        ...         bool: A boolean value, illustrating the return type.
-        ...     '''
-        ...     return True
-        ...
-        >>> tool_google = func_to_tool(example_function_google, docstring_style='google')
-        >>> print(isinstance(tool_google, Tool))
-        True
-
-        >>> def example_function_reST(param1: int, param2: str) -> bool:
-        ...     '''
-        ...     An example function using reStructuredText (reST) style docstrings.
-        ...
-        ...     :param param1: The first parameter, demonstrating an integer input_.
-        ...     :type param1: int
-        ...     :param param2: The second parameter, demonstrating a string input_.
-        ...     :type param2: str
-        ...     :returns: A boolean value, illustrating the return type.
-        ...     :rtype: bool
-        ...     '''
-        ...     return True
-        ...
-        >>> tool_reST = func_to_tool(example_function_reST, docstring_style='reST')
-        >>> print(isinstance(tool_reST, Tool))
-        True
+            >>> def example_function_google(param1: int, param2: str) -> bool:
+            ...     '''
+            ...     An example function using Google style docstrings.
+            ...
+            ...     Args:
+            ...         param1 (int): The first parameter, demonstrating an integer input_.
+            ...         param2 (str): The second parameter, demonstrating a string input_.
+            ...
+            ...     Returns:
+            ...         bool: A boolean value, illustrating the return type.
+            ...     '''
+            ...     return True
+            ...
+            >>> tool_google = func_to_tool(example_function_google, docstring_style='google')
+            >>> print(isinstance(tool_google, Tool))
+            True
+
+            >>> def example_function_reST(param1: int, param2: str) -> bool:
+            ...     '''
+            ...     An example function using reStructuredText (reST) style docstrings.
+            ...
+            ...     :param param1: The first parameter, demonstrating an integer input_.
+            ...     :type param1: int
+            ...     :param param2: The second parameter, demonstrating a string input_.
+            ...     :type param2: str
+            ...     :returns: A boolean value, illustrating the return type.
+            ...     :rtype: bool
+            ...     '''
+            ...     return True
+            ...
+            >>> tool_reST = func_to_tool(example_function_reST, docstring_style='reST')
+            >>> print(isinstance(tool_reST, Tool))
+            True
 
     Note:
-        The transformation process relies heavily on the accuracy and completeness of
-        the function's docstring. Functions with incomplete or incorrectly formatted
-        docstrings may result in incomplete or inaccurate Tool schemas.
+            The transformation process relies heavily on the accuracy and completeness of
+            the function's docstring. Functions with incomplete or incorrectly formatted
+            docstrings may result in incomplete or inaccurate Tool schemas.
     """
 
     fs = []
@@ -263,7 +255,7 @@ def func_to_tool(
     parsers = convert.to_list(parser, flatten=True, dropna=True)
 
     if parser:
-        if len(funcs) != len(parsers) and len(parsers) != 1:
+        if len(funcs) != len(parsers) != 1:
             raise ValueError(
                 "Length of parser must match length of func. Except if you only pass one"
             )

lionagi/integrations/__init__.py

@@ -1,3 +1 @@
-from .provider.services import Services
-
-__all__ = ["Services"]
+from . import *

lionagi/integrations/bridge/langchain_/documents.py

@@ -1,6 +1,5 @@
 from typing import Union, Callable, List, Dict, Any, TypeVar
 
-
 from lionagi.libs.sys_util import SysUtil
 
 T = TypeVar("T")
@@ -15,11 +14,11 @@ def to_langchain_document(datanode: T, **kwargs: Any) -> Any:
     to match the Langchain Document schema before creating a Langchain Document object.
 
     Args:
-        datanode (T): The data node to convert. Must have a `to_dict` method.
-        **kwargs: Additional keyword arguments to be passed to the Langchain Document constructor.
+            datanode (T): The data node to convert. Must have a `to_dict` method.
+            **kwargs: Additional keyword arguments to be passed to the Langchain Document constructor.
 
     Returns:
-        Any: An instance of `LangchainDocument` populated with data from the input node.
+            Any: An instance of `LangchainDocument` populated with data from the input node.
     """
 
     SysUtil.check_import("langchain")
@@ -44,20 +43,20 @@ def langchain_loader(
     It passes specified arguments and keyword arguments to the loader for data retrieval or processing.
 
     Args:
-        loader (Union[str, Callable]): A string representing the loader's name or a callable loader function.
-        loader_args (List[Any], optional): A list of positional arguments for the loader.
-        loader_kwargs (Dict[str, Any], optional): A dictionary of keyword arguments for the loader.
+            loader (Union[str, Callable]): A string representing the loader's name or a callable loader function.
+            loader_args (List[Any], optional): A list of positional arguments for the loader.
+            loader_kwargs (Dict[str, Any], optional): A dictionary of keyword arguments for the loader.
 
     Returns:
-        Any: The result returned by the loader function, typically data loaded into a specified format.
+            Any: The result returned by the loader function, typically data loaded into a specified format.
 
     Raises:
-        ValueError: If the loader cannot be initialized or fails to load data.
+            ValueError: If the loader cannot be initialized or fails to load data.
 
     Examples:
-        >>> data = langchain_loader("json_loader", loader_args=["data.json"])
-        >>> isinstance(data, dict)
-        True
+            >>> data = langchain_loader("json_loader", loader_args=["data.json"])
+            >>> isinstance(data, dict)
+            True
     """
 
     SysUtil.check_import("langchain")
@@ -92,16 +91,16 @@ def langchain_text_splitter(
     or documents into chunks. The splitter can be configured with additional arguments and keyword arguments.
 
     Args:
-        data (Union[str, List]): The text or list of texts to be split.
-        splitter (Union[str, Callable]): The name of the splitter function or the splitter function itself.
-        splitter_args (List[Any], optional): Positional arguments to pass to the splitter function.
-        splitter_kwargs (Dict[str, Any], optional): Keyword arguments to pass to the splitter function.
+            data (Union[str, List]): The text or list of texts to be split.
+            splitter (Union[str, Callable]): The name of the splitter function or the splitter function itself.
+            splitter_args (List[Any], optional): Positional arguments to pass to the splitter function.
+            splitter_kwargs (Dict[str, Any], optional): Keyword arguments to pass to the splitter function.
 
     Returns:
-        List[str]: A list of text chunks produced by the text splitter.
+            List[str]: A list of text chunks produced by the text splitter.
 
     Raises:
-        ValueError: If the splitter is invalid or fails during the split operation.
+            ValueError: If the splitter is invalid or fails during the split operation.
     """
     splitter_args = splitter_args or []
     splitter_kwargs = splitter_kwargs or {}

lionagi/integrations/bridge/langchain_/langchain_bridge.py

@@ -10,11 +10,11 @@ class LangchainBridge:
         to match the Langchain Document schema before creating a Langchain Document object.
 
         Args:
-            datanode (T): The data node to convert. Must have a `to_dict` method.
-            **kwargs: Additional keyword arguments to be passed to the Langchain Document constructor.
+                datanode (T): The data node to convert. Must have a `to_dict` method.
+                **kwargs: Additional keyword arguments to be passed to the Langchain Document constructor.
 
         Returns:
-            Any: An instance of `LangchainDocument` populated with data from the input node.
+                Any: An instance of `LangchainDocument` populated with data from the input node.
         """
         from .documents import to_langchain_document
 
@@ -29,15 +29,15 @@ class LangchainBridge:
         It passes specified arguments and keyword arguments to the loader for data retrieval or processing.
 
         Args:
-            loader (Union[str, Callable]): A string representing the loader's name or a callable loader function.
-            loader_args (List[Any], optional): A list of positional arguments for the loader.
-            loader_kwargs (Dict[str, Any], optional): A dictionary of keyword arguments for the loader.
+                loader (Union[str, Callable]): A string representing the loader's name or a callable loader function.
+                loader_args (List[Any], optional): A list of positional arguments for the loader.
+                loader_kwargs (Dict[str, Any], optional): A dictionary of keyword arguments for the loader.
 
         Returns:
-            Any: The result returned by the loader function, typically data loaded into a specified format.
+                Any: The result returned by the loader function, typically data loaded into a specified format.
 
         Raises:
-            ValueError: If the loader cannot be initialized or fails to load data.
+                ValueError: If the loader cannot be initialized or fails to load data.
         """
         from .documents import langchain_loader
 
@@ -52,16 +52,16 @@ class LangchainBridge:
         or documents into chunks. The splitter can be configured with additional arguments and keyword arguments.
 
         Args:
-            data (Union[str, List]): The text or list of texts to be split.
-            splitter (Union[str, Callable]): The name of the splitter function or the splitter function itself.
-            splitter_args (List[Any], optional): Positional arguments to pass to the splitter function.
-            splitter_kwargs (Dict[str, Any], optional): Keyword arguments to pass to the splitter function.
+                data (Union[str, List]): The text or list of texts to be split.
+                splitter (Union[str, Callable]): The name of the splitter function or the splitter function itself.
+                splitter_args (List[Any], optional): Positional arguments to pass to the splitter function.
+                splitter_kwargs (Dict[str, Any], optional): Keyword arguments to pass to the splitter function.
 
         Returns:
-            List[str]: A list of text chunks produced by the text splitter.
+                List[str]: A list of text chunks produced by the text splitter.
 
         Raises:
-            ValueError: If the splitter is invalid or fails during the split operation.
+                ValueError: If the splitter is invalid or fails during the split operation.
         """
         from .documents import langchain_text_splitter
 

lionagi/integrations/bridge/llamaindex_/llama_index_bridge.py

@@ -9,17 +9,17 @@ class LlamaIndexBridge:
         the expected Llama Index node schema, and then creates a Llama Index node object of the specified type.
 
         Args:
-            lion_node: The Lion node to convert. Must have a `to_dict` method.
-            node_type (Any, optional): The type of Llama Index node to create. Can be a string name of a node class
-                within the Llama Index schema or a class that inherits from `BaseNode`. Defaults to 'TextNode'.
-            **kwargs: Additional keyword arguments to be included in the Llama Index node's initialization.
+                lion_node: The Lion node to convert. Must have a `to_dict` method.
+                node_type (Any, optional): The type of Llama Index node to create. Can be a string name of a node class
+                        within the Llama Index schema or a class that inherits from `BaseNode`. Defaults to 'TextNode'.
+                **kwargs: Additional keyword arguments to be included in the Llama Index node's initialization.
 
         Returns:
-            Any: A new instance of the specified Llama Index node type populated with data from the Lion node.
+                Any: A new instance of the specified Llama Index node type populated with data from the Lion node.
 
         Raises:
-            TypeError: If `node_type` is neither a string nor a subclass of `BaseNode`.
-            AttributeError: If an error occurs due to an invalid node type or during the creation of the node object.
+                TypeError: If `node_type` is neither a string nor a subclass of `BaseNode`.
+                AttributeError: If an error occurs due to an invalid node type or during the creation of the node object.
         """
         from .textnode import to_llama_index_node
 
@@ -34,18 +34,18 @@ class LlamaIndexBridge:
         then loads data using the reader's `load_data` method with the provided loader arguments and keyword arguments.
 
         Args:
-            reader (Union[None, str, Any], optional): The reader to use. This can be a class, a string identifier,
-                or None. If None, a default reader is used.
-            reader_args (List[Any], optional): Positional arguments to initialize the reader.
-            reader_kwargs (Dict[str, Any], optional): Keyword arguments to initialize the reader.
-            loader_args (List[Any], optional): Positional arguments for the reader's `load_data` method.
-            loader_kwargs (Dict[str, Any], optional): Keyword arguments for the reader's `load_data` method.
+                reader (Union[None, str, Any], optional): The reader to use. This can be a class, a string identifier,
+                        or None. If None, a default reader is used.
+                reader_args (List[Any], optional): Positional arguments to initialize the reader.
+                reader_kwargs (Dict[str, Any], optional): Keyword arguments to initialize the reader.
+                loader_args (List[Any], optional): Positional arguments for the reader's `load_data` method.
+                loader_kwargs (Dict[str, Any], optional): Keyword arguments for the reader's `load_data` method.
 
         Returns:
-            Any: The documents or data loaded by the reader.
+                Any: The documents or data loaded by the reader.
 
         Raises:
-            ValueError: If there is an error initializing the reader or loading the data.
+                ValueError: If there is an error initializing the reader or loading the data.
         """
         from .reader import llama_index_read_data
 
@@ -60,16 +60,16 @@ class LlamaIndexBridge:
         then parses documents using the node parser's `get_nodes_from_documents` method.
 
         Args:
-            documents (Any): The documents to be parsed by the node parser.
-            node_parser (Any): The node parser to use. This can be a class, a string identifier, or None.
-            parser_args (Optional[List[Any]], optional): Positional arguments to initialize the node parser.
-            parser_kwargs (Optional[Dict[str, Any]], optional): Keyword arguments to initialize the node parser.
+                documents (Any): The documents to be parsed by the node parser.
+                node_parser (Any): The node parser to use. This can be a class, a string identifier, or None.
+                parser_args (Optional[List[Any]], optional): Positional arguments to initialize the node parser.
+                parser_kwargs (Optional[Dict[str, Any]], optional): Keyword arguments to initialize the node parser.
 
         Returns:
-            Any: The nodes extracted from the documents by the node parser.
+                Any: The nodes extracted from the documents by the node parser.
 
         Raises:
-            ValueError: If there is an error initializing the node parser or parsing the documents.
+                ValueError: If there is an error initializing the node parser or parsing the documents.
         """
         from .node_parser import llama_index_parse_node
 
@@ -87,7 +87,7 @@ class LlamaIndexBridge:
 
         Args:
           reader (Union[Any, str], optional): The reader identifier, which can be a reader class, a string alias
-              for a reader class, or None. If None, returns the SimpleDirectoryReader class.
+                  for a reader class, or None. If None, returns the SimpleDirectoryReader class.
 
         Returns:
           Any: The llama index reader class corresponding to the specified reader.

lionagi/integrations/bridge/llamaindex_/node_parser.py

@@ -12,16 +12,16 @@ def get_llama_index_node_parser(node_parser: Any):
     that the class is a subclass of NodeParser.
 
     Args:
-        node_parser (Any): The node parser identifier, which can be a node parser class, a string alias
-            for a node parser class, or None.
+            node_parser (Any): The node parser identifier, which can be a node parser class, a string alias
+                    for a node parser class, or None.
 
     Returns:
-        Any: The llama index node parser object corresponding to the specified node parser.
+            Any: The llama index node parser object corresponding to the specified node parser.
 
     Raises:
-        TypeError: If the node_parser is neither a string nor a subclass of NodeParser.
-        AttributeError: If there is an issue importing the specified node parser due to it not being
-        found within the llama_index.core.node_parser module.
+            TypeError: If the node_parser is neither a string nor a subclass of NodeParser.
+            AttributeError: If there is an issue importing the specified node parser due to it not being
+            found within the llama_index.core.node_parser module.
     """
 
     SysUtil.check_import("llama_index", pip_name="llama-index")
@@ -57,16 +57,16 @@ def llama_index_parse_node(
     then parses documents using the node parser's `get_nodes_from_documents` method.
 
     Args:
-        documents (Any): The documents to be parsed by the node parser.
-        node_parser (Any): The node parser to use. This can be a class, a string identifier, or None.
-        parser_args (Optional[List[Any]], optional): Positional arguments to initialize the node parser.
-        parser_kwargs (Optional[Dict[str, Any]], optional): Keyword arguments to initialize the node parser.
+            documents (Any): The documents to be parsed by the node parser.
+            node_parser (Any): The node parser to use. This can be a class, a string identifier, or None.
+            parser_args (Optional[List[Any]], optional): Positional arguments to initialize the node parser.
+            parser_kwargs (Optional[Dict[str, Any]], optional): Keyword arguments to initialize the node parser.
 
     Returns:
-        Any: The nodes extracted from the documents by the node parser.
+            Any: The nodes extracted from the documents by the node parser.
 
     Raises:
-        ValueError: If there is an error initializing the node parser or parsing the documents.
+            ValueError: If there is an error initializing the node parser or parsing the documents.
     """
 
     try:

lionagi/integrations/bridge/llamaindex_/reader.py

@@ -15,7 +15,7 @@ def get_llama_index_reader(reader: Any | str = None) -> Any:
 
     Args:
       reader (Union[Any, str], optional): The reader identifier, which can be a reader class, a string alias
-          for a reader class, or None. If None, returns the SimpleDirectoryReader class.
+              for a reader class, or None. If None, returns the SimpleDirectoryReader class.
 
     Returns:
       Any: The llama index reader class corresponding to the specified reader.
@@ -76,10 +76,10 @@ def parse_reader_name(reader_str):
     to facilitate dynamic import and installation if necessary.
 
     Args:
-        reader_str (str): The name of the reader as a string.
+            reader_str (str): The name of the reader as a string.
 
     Returns:
-        Tuple[str, str]: A tuple containing the package name and the pip name corresponding to the reader.
+            Tuple[str, str]: A tuple containing the package name and the pip name corresponding to the reader.
     """
 
     package_name = ""
@@ -172,18 +172,18 @@ def llama_index_read_data(
     then loads data using the reader's `load_data` method with the provided loader arguments and keyword arguments.
 
     Args:
-        reader (Union[None, str, Any], optional): The reader to use. This can be a class, a string identifier,
-            or None. If None, a default reader is used.
-        reader_args (List[Any], optional): Positional arguments to initialize the reader.
-        reader_kwargs (Dict[str, Any], optional): Keyword arguments to initialize the reader.
-        loader_args (List[Any], optional): Positional arguments for the reader's `load_data` method.
-        loader_kwargs (Dict[str, Any], optional): Keyword arguments for the reader's `load_data` method.
+            reader (Union[None, str, Any], optional): The reader to use. This can be a class, a string identifier,
+                    or None. If None, a default reader is used.
+            reader_args (List[Any], optional): Positional arguments to initialize the reader.
+            reader_kwargs (Dict[str, Any], optional): Keyword arguments to initialize the reader.
+            loader_args (List[Any], optional): Positional arguments for the reader's `load_data` method.
+            loader_kwargs (Dict[str, Any], optional): Keyword arguments for the reader's `load_data` method.
 
     Returns:
-        Any: The documents or data loaded by the reader.
+            Any: The documents or data loaded by the reader.
 
     Raises:
-        ValueError: If there is an error initializing the reader or loading the data.
+            ValueError: If there is an error initializing the reader or loading the data.
     """
     try:
         reader_args = reader_args or []