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

lionagi/utils/tool_util.py

@@ -1,209 +1,92 @@
-import json
-import asyncio
-from .sys_util import l_call
-    
-
-class ToolManager:
-    """
-    A manager class for handling and invoking registered tools and functions.
-
-    This class allows the registration of tools and functions, enabling their invocation.
-
-    Attributes:
-        registry (dict):
-            A dictionary storing the registered tools and their corresponding functions.
-
-    Methods:
-        _to_dict(name, function, content=None) -> dict:
-            Convert tool information to a dictionary entry.
+import inspect
+from ..schema.base_tool import Tool
 
-        _name_existed(name) -> bool:
-            Check if a given name exists in the registry.
 
-        _register_function(name, function, content=None, update=False, new=False, prefix=None, postfix=None) -> None:
-            Register a function with a specified name in the registry.
-
-        invoke(name, args) -> Any:
-            Invoke a registered function with the provided arguments.
-
-        ainvoke(func_call) -> Any:
-            Asynchronously invoke a registered function with the provided arguments.
-
-        _get_function_call(response) -> Tuple[str, dict]:
-            Extract function name and arguments from a response JSON.
-
-        _from_tool(tool, func) -> Tuple[str, callable, list]:
-            Convert tool information to function registration parameters.
-
-        register_tools(tools, functions, update=False, new=False, prefix=None, postfix=None) -> None:
-            Register multiple tools and their corresponding functions.
+def extract_docstring_details(func):
     """
-    def __init__(self):
-        """
-        Initialize a ToolManager object with an empty registry.
-        """
-        self.registry = {}
-        
-    @staticmethod
-    def _to_dict(name, func, content=None):
-        """
-        Convert tool information to a dictionary entry.
-
-        Parameters:
-            name (str): The name of the tool.
-
-            func (callable): The function associated with the tool.
-
-            content (Optional[str]): Additional content for the tool.
-
-        Returns:
-            dict: A dictionary entry representing the tool.
-        """
-        return {name: {"function": func, "content": content or "none"}}
-
-    def _name_existed(self, name):
-        """
-        Check if a given name exists in the registry.
-
-        Parameters:
-            name (str): The name to check.
-
-        Returns:
-            bool: True if the name exists in the registry, False otherwise.
-
-        """
-        return True if name in self.registry.keys() else False
-            
-    def _register_function(self, name, func, content=None, update=False, new=False, prefix=None, postfix=None):
-        """
-        Register a function with a specified name in the registry.
-
-        Parameters:
-            name (str): The name of the function.
-
-            func (callable): The function to register.
-
-            content (Optional[str]): Additional content for the function.
-
-            update (bool): Whether to update an existing function with the same name.
+    Extracts detailed descriptions for each parameter and the function from the docstring.
 
-            new (bool): Whether to create a new registry for an existing function.
+    Args:
+    - func (function): The function to extract details from.
 
-            prefix (Optional[str]): A prefix to add to the function name.
-
-            postfix (Optional[str]): A postfix to add to the function name.
-
-        """
-        if self._name_existed(name):
-            if update and new:
-                raise ValueError(f"Cannot both update and create new registry for existing function {name} at the same time")
-            
-        name = f"{prefix or ''}{name}{postfix or '1'}" if new else name                
-        self.registry.update(self._to_dict(name, func, content)) 
-                
-    def invoke(self, name, kwargs):
-        """
-        Invoke a registered function with the provided arguments.
-
-        Parameters:
-            name (str): The name of the function to invoke.
+    Returns:
+    - Tuple[str, dict]: Function description and a dictionary of parameter descriptions.
+    """
+    docstring = inspect.getdoc(func)
+    if not docstring:
+        return "No description available.", {}
+
+    # Splitting the docstring into lines
+    lines = docstring.split('\n')
+
+    # Extracting the function description
+    func_description = lines[0].strip()
+
+    # Extracting parameter descriptions
+    param_descriptions = {}
+    current_param = None
+    for line in lines[1:]:
+        line = line.strip()
+        if line.startswith(':param'):
+            _, param, desc = line.split(' ', 2)
+            current_param = param.strip(':')
+            param_descriptions[current_param] = desc
+        elif current_param and line:
+            # Continue the description of the current parameter
+            param_descriptions[current_param] += ' ' + line
+
+    return func_description, param_descriptions
+
+def func_to_schema(func):
+    """
+    Generates a schema description for a given function, using typing hints and docstrings.
+    The schema includes the function's name, description, and parameters.
 
-            kwargs (dict): The arguments to pass to the function.
+    Args:
+    - func (function): The function to generate a schema for.
 
-        Returns:
-            Any: The result of invoking the function.
-        """
-        if self._name_existed(name):
-            try:
-                return self.registry[name](**kwargs)
-            except Exception as e:
-                raise ValueError(f"Error when invoking function {name} with arguments {kwargs} with error message {e}")
-        else: 
-            raise ValueError(f"Function {name} is not registered.")
+    Returns:
+    - dict: A schema describing the function.
+    """
+    # Extracting function name and docstring details
+    func_name = func.__name__
+    func_description, param_descriptions = extract_docstring_details(func)
     
-    async def ainvoke(self, func_call):
-        """
-        Asynchronously invoke a registered function with the provided arguments.
-
-        Parameters:
-            func_call (Tuple[str, dict]): The name of the function and the arguments to pass.
-
-        Returns:
-            Any: The result of invoking the function asynchronously.
-
-        """
-        name, kwargs = func_call
-        if self._name_existed(name):
-            func = self.registry[name]["function"]
-            try:
-                if asyncio.iscoroutinefunction(func):
-                    return await func(**kwargs)
-                else:
-                    return func(**kwargs)
-            except Exception as e:
-                raise ValueError(f"Error when invoking function {name} with arguments {kwargs} with error message {e}")
-        else: 
-            raise ValueError(f"Function {name} is not registered.")
+    # Extracting parameters with typing hints
+    sig = inspect.signature(func)
+    parameters = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    }
     
-    @staticmethod
-    def _get_function_call(response):
-        """
-        Extract function name and arguments from a response JSON.
-
-        Parameters:
-            response (dict): The JSON response containing function information.
-
-        Returns:
-            Tuple[str, dict]: The function name and its arguments.
-        """
-        try: 
-            # out = json.loads(response)
-            func = response['function'][5:]
-            args = json.loads(response['arguments'])
-            return (func, args)
-        except:
-            try:
-                func = response['recipient_name'].split('.')[-1]
-                args = response['parameters']
-                return (func, args)
-            except:
-                raise ValueError('response is not a valid function call')
+    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 = param.annotation.__name__
+
+        # Extract parameter description from docstring, if available
+        param_description = param_descriptions.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,
+        }
     
-    @staticmethod
-    def _from_tool(tool, func):
-        """
-        Convert tool information to function registration parameters.
-
-        Parameters:
-            tool (dict): The tool information.
-
-            func (callable): The function associated with the tool.
-
-        Returns:
-            Tuple[str, callable, list]: The function name, the function, and the list of function parameters.
-
-        """
-        return (tool['function']['name'], func, 
-                tool['function']['parameters']['properties'].keys())
-        
-    def register_tools(self, tools, functions, update=False, new=False, prefix=None, postfix=None):
-        """
-        Register multiple tools and their corresponding functions.
-
-        Parameters:
-            tools (list): The list of tool information dictionaries.
-
-            functions (list): The list of corresponding functions.
-
-            update (bool): Whether to update existing functions.
-
-            new (bool): Whether to create new registries for existing functions.
-
-            prefix (Optional[str]): A prefix to add to the function names.
-
-            postfix (Optional[str]): A postfix to add to the function names.
-
-        """
-        funcs = l_call(range(len(tools)), lambda i: self._from_tool(tools[i], functions[i]))
-        l_call(range(len(tools)), lambda i: self._register_function(funcs[i][0], funcs[i][1], update=update, new=new, prefix=prefix, postfix=postfix))
-        
+    # Constructing the schema
+    schema = {
+        "type": "function",
+        "function": {
+            "name": func_name,
+            "description": func_description,
+            "parameters": parameters,
+        }
+    }
+    return schema
+
+def func_to_tool(func_, schema, parser=None):
+    # schema = func_to_schema(func_)
+    return Tool(func=func_, parser=parser, schema_=schema)

lionagi/utils/type_util.py

@@ -0,0 +1,81 @@
+import re
+from typing import Optional, Union, Iterable, List, Any, Type
+
+from .flat_util import flatten_list
+
+
+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.
+
+    Args:
+        input_str (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 to_list(input_: Any, flatten: bool = True, dropna: bool = False) -> List[Any]:
+    """
+    Converts the input to a list, optionally flattening it and dropping None values.
+
+    Args:
+        input_item (Any): The input to convert to a list.
+        
+        flatten (bool): Whether to flatten the input if it is a nested list. Defaults to True.
+        
+        dropna (bool): Whether to drop None values from the list. Defaults to False.
+
+    Returns:
+        List[Any]: The input converted to a list.
+
+    Raises:
+        ValueError: If the input cannot be converted to a list.
+    """
+    if isinstance(input_, list) and flatten:
+        input_ = flatten_list(input_)
+        if dropna:
+            input_ = [i for i in input_ if i is not None]
+    elif isinstance(input_, Iterable) and not isinstance(input_, (str, dict)):
+        try:
+            input_ = list(input_)
+        except:
+            raise ValueError("Input cannot be converted to a list.")
+    else:
+        input_ = [input_]
+    return input_

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.111"
+__version__ = "0.0.113"

{lionagi-0.0.111.dist-info → lionagi-0.0.113.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.111
+Version: 0.0.113
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -220,39 +220,50 @@ Requires-Dist: python-dotenv ==1.0.0
 Requires-Dist: tiktoken ==0.5.1
 Requires-Dist: httpx ==0.25.1
 
-![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?labelColor=233476aa&color=231fc935) ![GitHub License](https://img.shields.io/github/license/lion-agi/lionagi?labelColor=233476aa&color=231fc935) 
+![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)  ![Read the Docs](https://img.shields.io/readthedocs/lionagi)  ![PyPI - License](https://img.shields.io/pypi/l/lionagi?color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 
-[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://lionagi.readthedocs.io/en/latest/) | [Website](https://www.lionagi.ai) | [Discord](https://discord.gg/7RGWqpSxze)
+
+
+
+
+[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://lionagi.readthedocs.io/en/latest/) | [Discord](https://discord.gg/7RGWqpSxze)
 
   
 # LionAGI
 **Towards Automated General Intelligence**
 
-LionAGI is a Python intelligent agent framework that combines data manipulation with AI tools, aiming to simplify the integration of advanced machine learning tools, such as Large Language Models (i.e. OpenAI's GPT), with production-level data-centric projects. 
+
+LionAGI is a cutting-edge **intelligent agent framework**. It integrates data manipulation with advanced machine learning tools, such as Large Language Models (i.e. OpenAI's GPT). 
+- Designed for data-centric, production-level projects,
+- dramatically lowers the barrier in creating intelligent, automated systems
+- that can understand and interact meaningfully with large volumes of data. 
 
 Install LionAGI with pip:
 
 ```bash
 pip install lionagi
 ```
-Download the `.env_template` file, input your OPENAI_API_KEY, save the file, rename as `.env` and put in your project's root directory. 
+Download the `.env_template` file, input your appropriate `API_KEY`, save the file, rename as `.env` and put in your project's root directory. 
+by default we use `OPENAI_API_KEY`.
 
-### Features
 
-- Robust performance. LionAGI is written in almost pure python. With minimum external dependency (`aiohttp`, `httpx`, `python-dotenv`, `tiktoken`)
-- Efficient data operations for reading, chunking, binning, writing, storing and managing data.
-- Fast interaction with LLM services like OpenAI with **configurable rate limiting concurrent API calls** for maximum throughput. 
-- Create a production ready LLM application **in hours**. Intuitive workflow management to streamline and expedite the process from idea to market.
 
+### Features
+- Create a production ready LLM application **in hours**, with more than 100 models to choose from
+- written in pure python, minimum dependency `aiohttp`, `python-dotenv`, `tiktoken`, `pydantic`
+- Efficient and verstile data operations for reading, chunking, binning, writing, storing data with built-in support for `langchain` and `llamaindex`
+- Unified interface with any LLM provider, API or local
+  - Fast and **concurrent** API call with **configurable rate limit**
+  - (Work In Progress) support for hundreds of models both API and local
 ---
-Currently, LionAGI only natively support OpenAI API calls, support for other LLM providers as well as open source models will be integrated in future releases. LionAGI is designed to be async only, please check python official documentation on how `async` work: [here](https://docs.python.org/3/library/asyncio.html)
+LionAGI is designed to be `asynchronous` only, please check python official documentation on how `async` work: [here](https://docs.python.org/3/library/asyncio.html)
 
 
 **Notice**: 
 * calling API with maximum throughput over large set of data with advanced models i.e. gpt-4 can get **EXPENSIVE IN JUST SECONDS**,
 * please know what you are doing, and check the usage on OpenAI regularly
 * default rate limits are set to be **tier 1** of OpenAI model `gpt-4-1104-preview`, please check the [OpenAI usage limit documentation](https://platform.openai.com/docs/guides/rate-limits?context=tier-free) you can modify token rate parameters to fit different use cases.
-* Documentation is under process
+* if you would like to build from source, please download the [latest release](https://github.com/lion-agi/lionagi/releases),  **main is under development and will be changed without notice**
 
 
 ### Quick Start
@@ -266,11 +277,11 @@ import lionagi as li
 system = "You are a helpful assistant designed to perform calculations."
 instruction = {"Addition":"Add the two numbers together i.e. x+y"}
 context = {"x": 10, "y": 5}
+```
 
-# Initialize a session with a system message
+```python
+# in interactive environment (.ipynb for example)
 calculator = li.Session(system=system)
-
-# run a LLM API call
 result = await calculator.initiate(instruction=instruction,
                                    context=context,
                                    model="gpt-4-1106-preview")
@@ -278,6 +289,24 @@ result = await calculator.initiate(instruction=instruction,
 print(f"Calculation Result: {result}")
 ```
 
+```python
+# or otherwise, you can use
+import asyncio
+from dotenv import loadenv
+
+load_dotenv()
+
+async def main():
+    calculator = li.Session(system=system)
+    result = await calculator.initiate(instruction=instruction,
+                                       context=context, 
+                                       model="gpt-4-1106-preview")
+    print(f"Calculation Result: {result}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
 Visit our notebooks for our examples. 
 
 ### Community

lionagi-0.0.113.dist-info/RECORD

@@ -0,0 +1,84 @@
+lionagi/__init__.py,sha256=gAOIyJ-kItUn2ya8G3zW6pvuzmk60xk7zO_GN66UJAM,888
+lionagi/version.py,sha256=WJPRYfehqmqr60a1h9m6a2fbtJa0dT03ixD6hahuBgE,24
+lionagi/bridge/__init__.py,sha256=I19ztSDDwV1-e-GSRs45bJgjbg454e0vcFv2jwgwQY0,139
+lionagi/bridge/langchain.py,sha256=nJdnv_zHpchQXUlh5ml6OZKGO9Rbaa7B-XbeKB3Ej7Y,4579
+lionagi/bridge/llama_index.py,sha256=sapGIgS3RkDUyrPCdjZizoRdAmktZLHzUbYQBw6nnZw,5510
+lionagi/configs/__init__.py,sha256=88KoeoB8dHhgZdQ8I4rbb7e8-FUd-_gi1dXaA95vJ3Y,141
+lionagi/configs/oai_configs.py,sha256=C89jXb2Xb7qoOXIhtrMlIRVYJqjh7knpu6CAOloj9eo,1199
+lionagi/configs/openrouter_config.py,sha256=qbEQQqQPpzMp3eP5U8kuvGTUYdMgemuuq-BdgOYgYI8,1256
+lionagi/core/__init__.py,sha256=XAw2vF1wuQYKSAxHcBanfYN0k-5qLSggkl3yZgwjSRw,347
+lionagi/core/conversations.py,sha256=Jh4Bvv0SBaW5ZG_D9hyWveQ-PXPDGfvp_V7UxbPsFoA,4084
+lionagi/core/flows.py,sha256=rhPBmdN-JKo7Zcv9hiy6k0b-CjKBHMemkYITM7a9fNo,32
+lionagi/core/instruction_sets.py,sha256=y-fDltfDtji4fCtHn8fJ_M9OtYCfjqeTds7bpzknvhU,51
+lionagi/core/messages.py,sha256=XisuXcJBUoyYcd-6DLcV_NZnsKXzZcFf4Dk_fxTlXc8,6533
+lionagi/core/sessions.py,sha256=sjg7bCORFhpaEgDBTExyhfgGxRAUwkOCft0MmP-BGoU,11161
+lionagi/datastore/__init__.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/chroma.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/deeplake.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/elasticsearch.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/lantern.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/pinecone.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/postgres.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/datastore/qdrant.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/loader/__init__.py,sha256=0FNrggZnSq1ONLZY2f325SF19UfYHaqJeJXLvpu8KWQ,262
+lionagi/loader/chunker.py,sha256=zGdfS-Gybxc6lm_vMIdt-f25kY2CwDFTLvY-arKxQ8c,6476
+lionagi/loader/reader.py,sha256=8kxYlqhwmMpuNTWdYtsNc9g-1Mf264Y8XRu1GkevhTg,4527
+lionagi/objs/__init__.py,sha256=4qxo9ZGKe37fjj_Gt2hgi4QTTIPmDf7mkyUK7euVmsU,137
+lionagi/objs/messenger.py,sha256=k-ueq2LBLTTDgk8u-Vyja8WBFM7dWFInWO97HNyOXaI,6137
+lionagi/objs/tool_registry.py,sha256=cnoaW1TvNhKKerQ4tTUOSHEADmsTdoUW2lT24LcHIx0,9357
+lionagi/schema/__init__.py,sha256=cB7rSYeRXujDwp2f5IMK83-NzdqPfbMhGijPCPXgT_c,210
+lionagi/schema/base_condition.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/schema/base_schema.py,sha256=gx4LDxYnVO9vqp0JdevUSasqrat7Lu3rRURTiv7gGj0,8348
+lionagi/schema/base_tool.py,sha256=sKbCrS0ZZINkr03Fj0lk0Kt0XPiBz9IXwA9A1aDgN88,192
+lionagi/schema/data_logger.py,sha256=nmv0jJDkE-vzz_KyBl1_bHB8KVvhZ6sItOBQcvBkAvE,3417
+lionagi/services/__init__.py,sha256=js4LnJEJv4kkxPPamkOgFkOsrc1yr2dK-z9CLTTsX04,313
+lionagi/services/anthropic.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/services/anyscale.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/azure.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/services/base_api_service.py,sha256=vGCnC1GnW8czpseOx8mcDeyiiAKc_dabUInxjytE-A0,9756
+lionagi/services/bedrock.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/chatcompletion.py,sha256=9jVkB4JUX-kzvAHsohA1ZO6ZeXdlN9OAe-cVvLCa9-0,1257
+lionagi/services/everlyai.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/gemini.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/gpt4all.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/huggingface.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/litellm.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/services/localai.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/mistralai.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/oai.py,sha256=NcKiqmQ8YpKEkoVv-6a-mvIZVBumWOVpstpVD0oTiUs,1122
+lionagi/services/ollama.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/services/openllm.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/openrouter.py,sha256=vjY0ZydLY5XK4_T2cRiAl8_QNysWy26wcfyIP-1hlSw,1110
+lionagi/services/perplexity.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/predibase.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/rungpt.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/service_objs.py,sha256=w1Rs69eAGyEukTMMvwQHDmFkwTMf2pB9DdGQ-xCjTUw,9727
+lionagi/services/vllm.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/services/xinference.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/structure/__init__.py,sha256=wMPekT2vbWwUkJ5aW5o-lzJC9Fzhta6RHDiFPTNUm_0,120
+lionagi/structure/relationship.py,sha256=5urGnomfhBJUwPLpYpk5YCx-zO2yprJDaPQqMsgQM0A,4124
+lionagi/structure/structure.py,sha256=KWVOTFWk_IBMtY57gut_GFUuO7dKWlIrMH7xZ_ys2c4,5952
+lionagi/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tests/test_flatten_util.py,sha256=-sOAQriGtHK1U0FTd31IpdKJpgMQREpaXp-hf6FAojQ,17362
+lionagi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/tools/coder.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/planner.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/prompter.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/sandbox.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/scorer.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/summarizer.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/tools/validator.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+lionagi/utils/__init__.py,sha256=91eJpmYZLXi_xsFV7yb_uvlRmdhBQWBqa9Bmy18nJYY,1419
+lionagi/utils/api_util.py,sha256=wNYillgmAY9UJ5zP6NLo37levC3JEJGiis7nbPBRYXw,2769
+lionagi/utils/call_util.py,sha256=g4MRQChRGAz_1W35ThnEkyVR0W-neEk3ylgUq9IxbR8,12440
+lionagi/utils/flat_util.py,sha256=I1HJXs5llQ6oOoJudT4B7bp9u9_TLEFT_yPcXoNhrNA,22899
+lionagi/utils/io_util.py,sha256=Yzzo-GACV3QXdEFpdfVrpjxc8YJEHJof7hACiTQ59gU,3515
+lionagi/utils/load_utils.py,sha256=nSDWSXRFHO-tJXGMW-7icOqkeL1baQENf9BDyJZU88o,6667
+lionagi/utils/sys_util.py,sha256=nxv5mFagY0zBdMLhf9LD_SsK5Cd2rz9zMslr9xIwpfM,6305
+lionagi/utils/tool_util.py,sha256=RgTML1ZZbmVGdBV2pMpbDCDaNawf_p4d8bqliaOS898,2914
+lionagi/utils/type_util.py,sha256=eUfsvIr_VRykruE4TEUHssBME8Iug_4U4myY8xFV2bA,3135
+lionagi-0.0.113.dist-info/LICENSE,sha256=TBnSyG8fs_tMRtK805GzA1cIyExleKyzoN_kuVxT9IY,11358
+lionagi-0.0.113.dist-info/METADATA,sha256=-zs_6eEFEiCbvqycmpy9YxKVOOIUdzAlB6IrnrHJadk,18027
+lionagi-0.0.113.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lionagi-0.0.113.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
+lionagi-0.0.113.dist-info/RECORD,,

lionagi/api/__init__.py

@@ -1,8 +0,0 @@
-from .oai_service import OpenAIService, OpenAIRateLimiter
-from .oai_config import oai_llmconfig
-
-__all__ = [
-    "oai_llmconfig",
-    "OpenAIRateLimiter",
-    "OpenAIService",
-]

lionagi/api/oai_config.py

@@ -1,16 +0,0 @@
-oai_llmconfig = {
-    "model": "gpt-4-1106-preview",
-    "frequency_penalty": 0,
-    "max_tokens": None,
-    "n": 1,
-    "presence_penalty": 0, 
-    "response_format": {"type": "text"}, 
-    "seed": None, 
-    "stop": None,
-    "stream": False,
-    "temperature": 0.7, 
-    "top_p": 1, 
-    "tools": None,
-    "tool_choice": "none", 
-    "user": None
-    }

lionagi/session/__init__.py

@@ -1,7 +0,0 @@
-from .message import Message
-from .conversation import Conversation
-from .session import Session
-
-__all__ = [
-    "Session", "Message", "Conversation"
-]