lionagi 0.0.208__py3-none-any.whl → 0.0.210__py3-none-any.whl

lionagi/{_services → services}/base_service.py

@@ -103,7 +103,7 @@ class BaseRateLimiter(ABC):
         api_key: str,
         max_attempts: int = 3, 
         method: str = "post", 
-        payload: Dict[str, any]=None
+        payload: Dict[str, any]=None, **kwargs
     ) -> Optional[Dict[str, any]]:
         """
         Makes an API call to the specified endpoint using the provided HTTP session.
@@ -125,7 +125,7 @@ class BaseRateLimiter(ABC):
             if self.available_request_capacity < 1 or self.available_token_capacity < 10:  # Minimum token count
                 await asyncio.sleep(1)  # Wait for capacity
                 continue
-            required_tokens = APIUtil.calculate_num_token(payload, endpoint, self.token_encoding_name)
+            required_tokens = APIUtil.calculate_num_token(payload, endpoint, self.token_encoding_name, **kwargs)
             
             if await self.request_permission(required_tokens):
                 request_headers = {"Authorization": f"Bearer {api_key}"}
@@ -343,7 +343,7 @@ class BaseService:
                 if not self.endpoints[ep]._has_initialized:
                     await self.endpoints[ep].init_rate_limiter()
 
-    async def call_api(self, payload, endpoint, method):
+    async def call_api(self, payload, endpoint, method, **kwargs):
         """
         Calls the specified API endpoint with the given payload and method.
 
@@ -363,7 +363,7 @@ class BaseService:
         async with aiohttp.ClientSession() as http_session:
             completion = await self.endpoints[endpoint].rate_limiter._call_api(
                 http_session=http_session, endpoint=endpoint, base_url=self.base_url, api_key=self.api_key,
-                method=method, payload=payload)
+                method=method, payload=payload, **kwargs)
             return completion
 
 

lionagi/{_services → services}/oai.py

@@ -38,7 +38,7 @@ class OpenAIService(BaseService):
         )
         self.active_endpoint = []
 
-    async def serve(self, input_, endpoint="chat/completions", method="post", **kwargs):
+    async def serve(self, input_, endpoint="chat/completions", method="post", tokenizer_kwargs={}, **kwargs):
         """
         Serves the input using the specified endpoint and method.
 
@@ -66,11 +66,11 @@ class OpenAIService(BaseService):
         if endpoint not in self.active_endpoint:
             await self. init_endpoint(endpoint)
         if endpoint == "chat/completions":
-            return await self.serve_chat(input_, **kwargs)
+            return await self.serve_chat(input_, tokenizer_kwargs=tokenizer_kwargs, **kwargs)
         else:
             return ValueError(f'{endpoint} is currently not supported')
     
-    async def serve_chat(self, messages, **kwargs):
+    async def serve_chat(self, messages, tokenizer_kwargs={}, **kwargs):
         """
         Serves the chat completion request with the given messages.
 
@@ -91,7 +91,7 @@ class OpenAIService(BaseService):
             messages, self.endpoints["chat/completions"].config, self.schema["chat/completions"], **kwargs)
 
         try:
-            completion = await self.call_api(payload, "chat/completions", "post")
+            completion = await self.call_api(payload, "chat/completions", "post", **tokenizer_kwargs)
             return payload, completion
         except Exception as e:
             self.status_tracker.num_tasks_failed += 1

lionagi/structures/graph.py

@@ -2,7 +2,7 @@ from typing import List, Any
 from pydantic import Field
 
 from ..utils.call_util import lcall
-from ..schema.base_node import BaseNode
+from ..schema.base_schema import BaseNode
 from .relationship import Relationship
 
 

lionagi/structures/relationship.py

@@ -1,6 +1,6 @@
 from pydantic import Field
 from typing import Dict, Optional, Any
-from ..schema.base_node import BaseNode
+from ..schema.base_schema import BaseNode
 
 
 class Relationship(BaseNode):

lionagi/structures/structure.py

@@ -1,5 +1,5 @@
 from typing import TypeVar
-from ..schema import BaseNode
+from ..schema.base_schema import BaseNode
 from .graph import Graph
 from .relationship import Relationship
 

lionagi/tools/tool_manager.py

@@ -1,163 +0,0 @@
-import json
-import asyncio
-from typing import Dict, Union, List, Tuple, Any
-from lionagi.utils.call_util import lcall, is_coroutine_func, _call_handler, alcall
-from lionagi.schema import BaseNode, Tool
-
-
-class ToolManager(BaseNode):
-    """
-    A manager class for handling the registration and invocation of tools that are subclasses of Tool.
-    
-    This class maintains a registry of tool instances, allowing for dynamic invocation based on
-    tool name and provided arguments. It supports both synchronous and asynchronous tool function
-    calls.
-
-    Attributes:
-        registry (Dict[str, Tool]): A dictionary to hold registered tools, keyed by their names.
-    """
-    registry: Dict = {}
-
-    def name_existed(self, name: str) -> bool:
-        """
-        Checks if a tool name already exists in the registry.
-
-        Args:
-            name (str): The name of the tool to check.
-
-        Returns:
-            bool: True if the name exists, False otherwise.
-        """
-        return True if name in self.registry.keys() else False
-            
-    def _register_tool(self, tool: Tool) -> None:
-        """
-        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.
-
-        Raises:
-            TypeError: If the provided object is not an instance of Tool.
-        """
-        if not isinstance(tool, Tool):
-            raise TypeError('Please register a Tool object.')
-        name = tool.schema_['function']['name']
-        self.registry.update({name: tool})
-                
-    async def invoke(self, func_call: Tuple[str, Dict[str, Any]]) -> Any:
-        """
-        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.
-
-        Returns:
-            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.
-        """
-        name, kwargs = func_call
-        if self.name_existed(name):
-            tool = self.registry[name]
-            func = tool.func
-            parser = tool.parser
-            try:
-                if is_coroutine_func(func):
-                    tasks = [_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: 
-            raise ValueError(f"Function {name} is not registered.")
-    
-    @staticmethod
-    def get_function_call(response: Dict) -> Tuple[str, Dict]:
-        """
-        Extracts a function call and arguments from a response dictionary.
-
-        Args:
-            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.
-
-        Raises:
-            ValueError: If the response does not contain valid function call information.
-        """
-        try:
-            func = response['action'][7:]
-            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')
-    
-    def register_tools(self, tools: List[Tool]) -> None:
-        """
-        Registers multiple tools in the registry.
-
-        Args:
-            tools (List[Tool]): A list of tool instances to register.
-        """
-        lcall(tools, self._register_tool) 
-
-    def to_tool_schema_list(self) -> List[Dict[str, Any]]:
-        """
-        Generates a list of schemas for all registered tools.
-
-        Returns:
-            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
-
-    def _tool_parser(self, tools: Union[Dict, Tool, List[Tool], str, List[str], List[Dict]], **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.
-
-        Returns:
-            Dict: A dictionary containing tool schema information and any additional keyword arguments.
-
-        Raises:
-            ValueError: If a tool name is provided that is not registered.
-        """
-        def tool_check(tool):
-            if isinstance(tool, dict):
-                return tool
-            elif isinstance(tool, Tool):
-                return tool.schema_
-            elif isinstance(tool, str):
-                if self.name_existed(tool):
-                    tool = self.registry[tool]
-                    return tool.schema_
-                else:
-                    raise ValueError(f'Function {tool} is not registered.')
-
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self.to_tool_schema_list()}
-            kwargs = {**tool_kwarg, **kwargs}
-
-        else:
-            if not isinstance(tools, list):
-                tools = [tools]
-            tool_kwarg = {"tools": lcall(tools, tool_check)}
-            kwargs = {**tool_kwarg, **kwargs}
-            
-        return kwargs

lionagi/tools/tool_util.py

@@ -1,5 +1,6 @@
+from ..schema.base_schema import Tool
+
 import inspect
-from ..schema.base_tool import Tool
 
 def _extract_docstring_details_google(func):
     """

lionagi/utils/__init__.py

@@ -1,16 +1,12 @@
-from .sys_util import (
-    get_timestamp, create_copy, create_path, split_path, 
-    get_bins, change_dict_key, str_to_num, create_id, 
-    as_dict, is_package_installed, install_import, to_df
-    )
+from .sys_util import as_dict, create_copy, get_bins, get_timestamp, str_to_num, to_df
 
 from .nested_util import (
     to_readable_dict, nfilter, nset, nget, 
     nmerge, ninsert, flatten, unflatten, 
     is_structure_homogeneous, get_flattened_keys)
 
+from .core_utils import CoreUtil
 from .api_util import APIUtil
-from .encrypt_util import EncrytionUtil
 from .io_util import IOUtil
 
 from .call_util import (
@@ -20,12 +16,9 @@ from .call_util import (
 
 
 __all__ = [
-    "is_package_installed", "install_import", "to_df",
-    'get_timestamp', 'create_copy', 'create_path', 'split_path',
-    'get_bins', 'change_dict_key', 'str_to_num', 'create_id',
-    'as_dict', 'to_list', 'to_readable_dict', 'nfilter', 'nset',
-    'nget', 'nmerge', 'ninsert', 'flatten', 'unflatten',
-    'is_structure_homogeneous', 'get_flattened_keys', 'APIUtil',
-    'EncrytionUtil', 'IOUtil', 'lcall', 'alcall', 'mcall', 'tcall',
-    'bcall', 'rcall', 'CallDecorator'
+    "as_dict", "create_copy", "get_bins", "get_timestamp", "str_to_num", "to_df",
+    "to_readable_dict", "nfilter", "nset", "nget", "nmerge", "ninsert", 
+    "flatten", "unflatten", "is_structure_homogeneous", "get_flattened_keys",
+    "CoreUtil", "APIUtil", "IOUtil",
+    "to_list", "lcall", "alcall", "mcall", "tcall", "bcall", "rcall", "CallDecorator"
 ]

lionagi/utils/api_util.py

@@ -1,3 +1,4 @@
+# import requests
 import aiohttp
 import asyncio
 import hashlib
@@ -8,6 +9,7 @@ import tiktoken
 from functools import lru_cache
 from aiocache import cached
 from typing import Any, Callable, Dict, Optional
+# from bs4 import BeautifulSoup
 
 from .sys_util import strip_lower
 
@@ -284,6 +286,8 @@ class APIUtil:
         payload: Dict[str, Any] = None,
         api_endpoint: str = None,
         token_encoding_name: str = None,
+        disallowed_special = None,
+        **kwargs
     ) -> int:
         """
         Calculates the number of tokens required for a request based on the payload and API endpoint.
@@ -309,7 +313,10 @@ class APIUtil:
             # Expected token calculation for the given payload and endpoint.
         """
 
-        encoding = tiktoken.get_encoding(token_encoding_name)
+        if disallowed_special:
+            kwargs['disallowed_special'] = disallowed_special
+            
+        encoding = tiktoken.get_encoding(token_encoding_name, **kwargs)
         if api_endpoint.endswith("completions"):
             max_tokens = payload.get("max_tokens", 15)
             n = payload.get("n", 1)
@@ -373,4 +380,58 @@ class APIUtil:
                 payload.update({key: config[key]})
                 
         return payload
-    
+
+    # @staticmethod
+    # def get_url_response(url: str, timeout: tuple = (1, 1), **kwargs) -> requests.Response:
+    #     """
+    #     Sends a GET request to a URL and returns the response.
+
+    #     Args:
+    #         url (str): The URL to send the GET request to.
+    #         timeout (tuple): A tuple specifying the connection and read timeouts in seconds.
+    #                         Defaults to (1, 1).
+    #         **kwargs: Additional keyword arguments to be passed to the requests.get() function.
+
+    #     Returns:
+    #         requests.Response: A Response object containing the server's response to the GET request.
+
+    #     Raises:
+    #         TimeoutError: If a timeout occurs while requesting or reading the response.
+    #         Exception: If an error other than a timeout occurs during the request.
+    #     """
+    #     try:
+    #         response = requests.get(url, timeout=timeout, **kwargs)
+    #         response.raise_for_status()
+    #         return response
+    #     except requests.exceptions.ConnectTimeout:
+    #         raise TimeoutError(f"Timeout: requesting >{timeout[0]} seconds.")
+    #     except requests.exceptions.ReadTimeout:
+    #         raise TimeoutError(f"Timeout: reading >{timeout[1]} seconds.")
+    #     except Exception as e:
+    #         raise e
+
+    # @staticmethod    
+    # def get_url_content(url: str) -> str:
+    #     """
+    #     Retrieve and parse the content from a given URL.
+
+    #     Args:
+    #         url (str): The URL to fetch and parse.
+
+    #     Returns:
+    #         str: The text content extracted from the URL.
+
+    #     Raises:
+    #         ValueError: If there is an issue during content retrieval or parsing.
+    #     """
+    #     try:
+    #         response = requests.get(url)
+    #         response.raise_for_status()
+
+    #         soup = BeautifulSoup(response.text, 'html.parser')
+
+    #         text_content = ' '.join([p.get_text() for p in soup.find_all('p')])
+    #         return text_content
+    #     except Exception as e:
+    #         raise f"Error fetching content for {url}: {e}"
+