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

lionagi/objs/tool_manager.py

@@ -1,253 +0,0 @@
-import json
-import asyncio
-from typing import Dict
-from lionagi.utils import lcall
-from lionagi.schema import BaseNode, Tool
-
-
-class ToolManager(BaseNode):
-    registry: Dict = {}
-
-    def name_existed(self, name: str):
-        return True if name in self.registry.keys() else False
-            
-    def _register_tool(self, tool): #,update=False, new=False, prefix=None, postfix=None):
-        
-        # if self._name_existed(tool.name):
-        #     if update and new:
-        #         raise ValueError(f"Cannot both update and create new registry for existing function {tool.name} at the same time")
-
-            # if len(name) > len(tool.func.__name__):
-            #     if new and not postfix:
-            #         try:
-            #             idx = str_to_num(name[-3:], int)
-            #             if idx > 0:
-            #                 postfix = idx + 1
-            #         except:
-            #             pass
-
-        # name = f"{prefix or ''}{name}{postfix}" if new else tool.func.__name__
-
-        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):
-        name, kwargs = func_call
-        if self.name_existed(name):
-            tool = self.registry[name]
-            func = tool.func
-            parser = tool.parser
-            try:
-                if asyncio.iscoroutinefunction(func):
-                    return await parser(func(**kwargs)) if parser else func(**kwargs)
-                else:
-                    return parser(func(**kwargs)) if parser else 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.")
-    
-    @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:
-            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')
-    
-    def register_tools(self, tools): #, update=False, new=False, prefix=None, postfix=None ):
-        lcall(tools, self._register_tool) #, update=update, new=new, prefix=prefix, postfix=postfix)
-
-    def to_tool_schema_list(self):
-        schema_list = []
-        for tool in self.registry.values():
-            schema_list.append(tool.schema_)
-        return schema_list
-
-
-# import asyncio
-# import json
-# from typing import Dict, Any, Optional, List, Tuple
-
-# from lionagi.schema.base_tool import Tool
-# from lionagi.utils.type_util import to_list
-# from lionagi.utils.tool_util import func_to_tool
-
-# class ToolRegistry:
-#     """
-#     ToolManager manages the registration and invocation of tools.
-
-#     This class provides functionalities to register tools, check for their existence,
-#     and invoke them dynamically with specified arguments.
-
-#     Attributes:
-#         registry (Dict[str, BaseTool]): A dictionary to store registered tools by name.
-    
-#     Methods:
-#         _name_exists: Checks if a tool name already exists in the registry.
-        
-#         _register_tool: Registers a tool in the registry.
-        
-#         invoke: Dynamically invokes a registered tool with given arguments.
-        
-#         register_tools: Registers multiple tools in the registry.
-#     """    
-    
-#     def __init__(self):
-#         """
-#         Initializes the ToolManager with an empty registry.
-#         """        
-#         self.registry: Dict[str, Tool] = {}
-
-#     def _name_exists(self, name: str) -> bool:
-#         """
-#         Checks if a tool name already exists in the registry.
-
-#         Parameters:
-#             name (str): The name of the tool to check.
-
-#         Returns:
-#             bool: True if the name exists in the registry, False otherwise.
-#         """
-#         return name in self.registry
-
-#     def _register_tool(self, tool: Tool, name: Optional[str] = None, update: bool = False, new: bool = False, prefix: Optional[str] = None, postfix: Optional[int] = None):
-#         """
-#         Registers a tool in the registry.
-
-#         Parameters:
-#             tool (BaseTool): The tool to be registered.
-            
-#             name (Optional[str]): The name to register the tool with. Defaults to the tool's function name.
-            
-#             update (bool): If True, updates the existing tool. Defaults to False.
-            
-#             new (bool): If True, creates a new registry entry. Defaults to False.
-            
-#             prefix (Optional[str]): A prefix for the tool name.
-            
-#             postfix (Optional[int]): A postfix for the tool name.
-
-#         Raises:
-#             ValueError: If both update and new are True for an existing function.
-#         """
-#         name = name or tool.func.__name__
-#         original_name = name
-
-#         if self._name_exists(name):
-#             if update and new:
-#                 raise ValueError("Cannot both update and create new registry for existing function.")
-#             if new:
-#                 idx = 1
-#                 while self._name_exists(f"{prefix or ''}{name}{postfix or ''}{idx}"):
-#                     idx += 1
-#                 name = f"{prefix or ''}{name}{postfix or ''}{idx}"
-#             else:
-#                 self.registry.pop(original_name, None)
-
-#         self.registry[name] = tool
-
-#     async def invoke(self, name_kwargs: Tuple) -> Any:
-#         """
-#         Dynamically invokes a registered tool with given arguments.
-
-#         Parameters:
-#             name (str): The name of the tool to invoke.
-            
-#             kwargs (Dict[str, Any]): A dictionary of keyword arguments to pass to the tool.
-
-#         Returns:
-#             Any: The result of the tool invocation.
-
-#         Raises:
-#             ValueError: If the tool is not registered or if an error occurs during invocation.
-#         """
-#         name, kwargs = name_kwargs
-#         if not self._name_exists(name):
-#             raise ValueError(f"Function {name} is not registered.")
-
-#         tool = self.registry[name]
-#         func = tool.func
-#         parser = tool.parser
-
-#         try:
-#             result = await func(**kwargs) if asyncio.iscoroutinefunction(func) else func(**kwargs)
-#             return await parser(result) if parser and asyncio.iscoroutinefunction(parser) else parser(result) if parser else result
-#         except Exception as e:
-#             raise ValueError(f"Error invoking function {name}: {str(e)}")
-
-#     def register_tools(self, tools: List[Tool], update: bool = False, new: bool = False,
-#                        prefix: Optional[str] = None, postfix: Optional[int] = None):
-#         """
-#         Registers multiple tools in the registry.
-
-#         Parameters:
-#             tools (List[BaseTool]): A list of tools to register.
-            
-#             update (bool): If True, updates existing tools. Defaults to False.
-            
-#             new (bool): If True, creates new registry entries. Defaults to False.
-            
-#             prefix (Optional[str]): A prefix for the tool names.
-            
-#             postfix (Optional[int]): A postfix for the tool names.
-#         """        
-#         for tool in tools:
-#             self._register_tool(tool, update=update, new=new, prefix=prefix, postfix=postfix)
-
-#     def _register_func(self, func_, parser=None, **kwargs):
-#         # kwargs for _register_tool
-        
-#         tool = func_to_tool(func_=func_, parser=parser)
-#         self._register_tool(tool=tool, **kwargs)
-    
-#     def register_funcs(self, funcs, parsers=None, **kwargs):
-#         funcs, parsers = to_list(funcs), to_list(parsers)
-#         if parsers is not None and len(parsers) != len(funcs):
-#             raise ValueError("The number of funcs and tools should be the same")
-#         parsers = parsers or [None for _ in range(len(funcs))]
-        
-#         for i, func in enumerate(funcs):
-#             self._register_func(func_=func, parser=parsers[i], **kwargs)
-            
-#     @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')
-            

lionagi/services/__init__.py

@@ -1,11 +0,0 @@
-from .base_api_service import BaseAPIService, BaseAPIRateLimiter
-from .oai import OpenAIService
-from .openrouter import OpenRouterService
-
-
-__all__ = [
-    "BaseAPIService",
-    "BaseAPIRateLimiter",
-    "OpenAIService",
-    "OpenRouterService",
-]

lionagi/services/base_api_service.py

@@ -1,230 +0,0 @@
-import re
-import asyncio
-import os
-import tiktoken
-import logging
-import aiohttp
-from typing import Generator, NoReturn, Dict, Any, Optional
-from ..objs.status_tracker import StatusTracker
-from ..objs.abc_objs import  BaseService, RateLimiter
-from ..objs.async_queue import AsyncQueue
-
-class BaseAPIRateLimiter(RateLimiter):
-
-    def __init__(
-        self, max_requests_per_minute: int, max_tokens_per_minute: int
-    ) -> None:
-        super().__init__(max_requests_per_minute, max_tokens_per_minute)
-
-    @classmethod
-    async def create(
-        cls, max_requests_per_minute: int, max_tokens_per_minute: int
-    ) -> None:
-        self = cls(max_requests_per_minute, max_tokens_per_minute)
-        if not os.getenv("env_readthedocs"):
-            self.rate_limit_replenisher_task = await asyncio.create_task(
-                self.rate_limit_replenisher()
-            )
-        return self
-
-    async def rate_limit_replenisher(self) -> NoReturn:
-        """
-        Asynchronously replenishes the rate limit capacities at regular intervals.
-
-        This coroutine runs indefinitely, replenishing the available request and token capacities
-        based on the maximum limits defined for the OpenAI API. This task should run in the background
-        to consistently reset the capacities.
-
-        Example:
-            >>> rate_limiter = OpenAIRateLimiter(100, 200)
-            >>> asyncio.create_task(rate_limiter.rate_limit_replenisher())
-            # This will start the background task for rate limit replenishment.
-        """
-        while True:
-            await asyncio.sleep(60)  # Replenishes every 60 seconds
-            self.available_request_capacity = self.max_requests_per_minute
-            self.available_token_capacity = self.max_tokens_per_minute
-
-# credit to OpenAI for the following function
-    def calculate_num_token(
-        self,
-        payload: Dict[str, Any] = None,
-        api_endpoint: str = None,
-        token_encoding_name: str = None,
-    ) -> int:
-        """
-        Calculates the number of tokens required for a request based on the payload and API endpoint.
-
-        The token calculation logic might vary based on different API endpoints and payload content.
-        This method should be implemented in a subclass to provide the specific calculation logic
-        for the OpenAI API.
-
-        Parameters:
-            payload (Dict[str, Any]): The payload of the request.
-
-            api_endpoint (str): The specific API endpoint for the request.
-
-            token_encoding_name (str): The name of the token encoding method.
-
-        Returns:
-            int: The estimated number of tokens required for the request.
-
-        Example:
-            >>> rate_limiter = OpenAIRateLimiter(100, 200)
-            >>> payload = {'prompt': 'Translate the following text:', 'max_tokens': 50}
-            >>> rate_limiter.calculate_num_token(payload, 'completions')
-            # Expected token calculation for the given payload and endpoint.
-        """
-
-        encoding = tiktoken.get_encoding(token_encoding_name)
-        if api_endpoint.endswith("completions"):
-            max_tokens = payload.get("max_tokens", 15)
-            n = payload.get("n", 1)
-            completion_tokens = n * max_tokens
-
-            # chat completions
-            if api_endpoint.startswith("chat/"):
-                num_tokens = 0
-                for message in payload["messages"]:
-                    num_tokens += 4  # every message follows <im_start>{role/name}\n{content}<im_end>\n
-                    for key, value in message.items():
-                        num_tokens += len(encoding.encode(value))
-                        if key == "name":  # if there's a name, the role is omitted
-                            num_tokens -= (
-                                1  # role is always required and always 1 token
-                            )
-                num_tokens += 2  # every reply is primed with <im_start>assistant
-                return num_tokens + completion_tokens
-            # normal completions
-            else:
-                prompt = payload["prompt"]
-                if isinstance(prompt, str):  # single prompt
-                    prompt_tokens = len(encoding.encode(prompt))
-                    num_tokens = prompt_tokens + completion_tokens
-                    return num_tokens
-                elif isinstance(prompt, list):  # multiple prompts
-                    prompt_tokens = sum([len(encoding.encode(p)) for p in prompt])
-                    num_tokens = prompt_tokens + completion_tokens * len(prompt)
-                    return num_tokens
-                else:
-                    raise TypeError(
-                        'Expecting either string or list of strings for "prompt" field in completion request'
-                    )
-        elif api_endpoint == "embeddings":
-            input = payload["input"]
-            if isinstance(input, str):  # single input
-                num_tokens = len(encoding.encode(input))
-                return num_tokens
-            elif isinstance(input, list):  # multiple inputs
-                num_tokens = sum([len(encoding.encode(i)) for i in input])
-                return num_tokens
-            else:
-                raise TypeError(
-                    'Expecting either string or list of strings for "inputs" field in embedding request'
-                )
-        else:
-            raise NotImplementedError(
-                f'API endpoint "{api_endpoint}" not implemented in this script'
-            )
-
-
-class BaseAPIService(BaseService):
-    
-    def __init__(self, api_key: str = None, 
-                 status_tracker = None,
-                 queue = None, endpoint=None, schema=None, 
-                 ratelimiter=None, max_requests_per_minute=None, max_tokens_per_minute=None) -> None:
-        self.api_key = api_key
-        self.status_tracker = status_tracker or StatusTracker()
-        self.queue = queue or AsyncQueue()
-        self.endpoint=endpoint
-        self.schema = schema
-        self.rate_limiter = ratelimiter(max_requests_per_minute, max_tokens_per_minute)
-    
-    @staticmethod                    
-    def api_methods(http_session, method="post"):
-        if method not in ["post", "delete", "head", "options", "patch"]:
-            raise ValueError("Invalid request, method must be in ['post', 'delete', 'head', 'options', 'patch']")
-        elif method == "post":
-            return http_session.post
-        elif method == "delete":
-            return http_session.delete
-        elif method == "head":
-            return http_session.head
-        elif method == "options":
-            return http_session.options
-        elif method == "patch":
-            return http_session.patch
-
-    @staticmethod
-    def api_endpoint_from_url(request_url: str) -> str:
-        match = re.search(r"^https://[^/]+/v\d+/(.+)$", request_url)
-        if match:
-            return match.group(1)
-        else:
-            return ""
-
-    @staticmethod
-    def task_id_generator_function() -> Generator[int, None, None]:
-        task_id = 0
-        while True:
-            yield task_id
-            task_id += 1
-
-    async def _call_api(self, http_session, endpoint_, method="post", payload: Dict[str, any] =None) -> Optional[Dict[str, any]]:
-        endpoint_ = self.api_endpoint_from_url("https://api.openai.com/v1/"+endpoint_)
-        
-        while True:
-            if self.rate_limiter.available_request_capacity < 1 or self.rate_limiter.available_token_capacity < 10:  # Minimum token count
-                await asyncio.sleep(1)  # Wait for capacity
-                continue
-            
-            required_tokens = self.rate_limiter.calculate_num_token(payload, endpoint_, self.token_encoding_name)
-            
-            if self.rate_limiter.available_token_capacity >= required_tokens:
-                self.rate_limiter.available_request_capacity -= 1
-                self.rate_limiter.available_token_capacity -= required_tokens
-
-                request_headers = {"Authorization": f"Bearer {self.api_key}"}
-                attempts_left = self.max_attempts
-
-                while attempts_left > 0:
-                    try:
-                        method = self.api_methods(http_session, method)                         
-                        async with method(
-                            url=(self.base_url+endpoint_), headers=request_headers, json=payload
-                        ) as response:
-                            response_json = await response.json()
-
-                            if "error" in response_json:
-                                logging.warning(
-                                    f"API call failed with error: {response_json['error']}"
-                                )
-                                attempts_left -= 1
-
-                                if "Rate limit" in response_json["error"].get("message", ""):
-                                    await asyncio.sleep(15)
-                            else:
-                                return response_json
-                    except Exception as e:
-                        logging.warning(f"API call failed with exception: {e}")
-                        attempts_left -= 1
-
-                logging.error("API call failed after all attempts.")
-                break
-            else:
-                await asyncio.sleep(1)
-    
-    async def _serve(self, payload, endpoint_="chat/completions", method="post"):
-         
-        async def call_api():
-            async with aiohttp.ClientSession() as http_session:
-                completion = await self._call_api(http_session=http_session, endpoint_=endpoint_, payload=payload, method=method)
-                return completion
-
-        try:
-            return await call_api()
-        except Exception as e:
-                self.status_tracker.num_tasks_failed += 1
-                raise e
-            

lionagi/services/oai.py

@@ -1,34 +0,0 @@
-from os import getenv
-import dotenv
-from .base_api_service import BaseAPIService, BaseAPIRateLimiter
-
-dotenv.load_dotenv()
-
-class OpenAIService(BaseAPIService):
-
-    base_url = "https://api.openai.com/v1/"
-
-    def __init__(
-        self,
-        api_key: str = None,
-        token_encoding_name: str = "cl100k_base",
-        max_attempts: int = 3,
-        max_requests_per_minute: int = 500,
-        max_tokens_per_minute: int = 150_000,
-        ratelimiter = BaseAPIRateLimiter ,
-        status_tracker = None,
-        queue = None,
-    ):
-        super().__init__(
-            api_key = api_key or getenv("OPENAI_API_KEY"),
-            status_tracker = status_tracker,
-            queue = queue,
-            ratelimiter=ratelimiter,
-            max_requests_per_minute=max_requests_per_minute, 
-            max_tokens_per_minute=max_tokens_per_minute),
-        self.token_encoding_name=token_encoding_name
-        self.max_attempts = max_attempts
-
-    async def serve(self, payload, endpoint_="chat/completions", method="post"):
-        return await self._serve(payload=payload, endpoint_=endpoint_, method=method)
-    

lionagi/services/openrouter.py

@@ -1,31 +0,0 @@
-from os import getenv
-from .base_api_service import BaseAPIService, BaseAPIRateLimiter
-
-class OpenRouterService(BaseAPIService):
-    key_scheme = "OPENROUTER_API_KEY"
-    base_url = "https://openrouter.ai/api/v1/"
-
-    def __init__(
-        self,
-        api_key: str = None,
-        token_encoding_name: str = "cl100k_base",
-        max_attempts: int = 3,
-        max_requests_per_minute: int = 500,
-        max_tokens_per_minute: int = 150_000,
-        ratelimiter = BaseAPIRateLimiter ,
-        status_tracker = None,
-        queue = None,
-    ):
-        super().__init__(
-            api_key = api_key or getenv(self.key_scheme),
-            status_tracker = status_tracker,
-            queue = queue,
-            ratelimiter=ratelimiter,
-            max_requests_per_minute=max_requests_per_minute, 
-            max_tokens_per_minute=max_tokens_per_minute),
-        self.token_encoding_name=token_encoding_name
-        self.max_attempts = max_attempts
-        
-    async def serve(self, payload, endpoint_="chat/completions"):
-        return await self._serve(payload=payload, endpoint_=endpoint_)
-    

lionagi/tests/test_api_util.py

@@ -1,46 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-
-# Assuming the Python module with the above functions is named 'api_utils'
-from lionagi.utils.api_util import *
-
-class TestApiUtils(unittest.TestCase):
-
-    def test_api_method_valid(self):
-        session = MagicMock()
-        methods = ['post', 'delete', 'head', 'options', 'patch']
-        for method in methods:
-            with self.subTest(method=method):
-                func = api_method(session, method)
-                self.assertTrue(callable(func))
-
-    def test_api_method_invalid(self):
-        session = MagicMock()
-        with self.assertRaises(ValueError):
-            api_method(session, 'get')
-
-    def test_api_error(self):
-        response_with_error = {'error': 'Something went wrong'}
-        response_without_error = {'result': 'Success'}
-
-        self.assertTrue(api_error(response_with_error))
-        self.assertFalse(api_error(response_without_error))
-
-    def test_api_rate_limit_error(self):
-        response_with_rate_limit_error = {'error': {'message': 'Rate limit exceeded'}}
-        response_without_rate_limit_error = {'error': {'message': 'Another error'}}
-
-        self.assertTrue(api_rate_limit_error(response_with_rate_limit_error))
-        self.assertFalse(api_rate_limit_error(response_without_rate_limit_error))
-
-    def test_api_endpoint_from_url(self):
-        url_with_endpoint = "https://api.example.com/v1/users"
-        url_without_endpoint = "https://api.example.com/users"
-        url_invalid = "Just a string"
-
-        self.assertEqual(api_endpoint_from_url(url_with_endpoint), 'users')
-        self.assertEqual(api_endpoint_from_url(url_without_endpoint), '')
-        self.assertEqual(api_endpoint_from_url(url_invalid), '')
-
-if __name__ == '__main__':
-    unittest.main()