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

lionagi/schema/data_logger.py

@@ -0,0 +1,94 @@
+from collections import deque
+from typing import List, Optional
+from ..utils.sys_util import create_path
+from ..utils.io_util import to_csv
+
+
+class DataLogger:
+    """
+    A class for logging data entries and exporting them as CSV files.
+
+    This class provides functionality to log data entries in a deque and 
+    supports exporting the logged data to a CSV file. The DataLogger can 
+    be configured to use a specific directory for saving files.
+
+    Attributes:
+        dir (Optional[str]): 
+            The default directory where CSV files will be saved.
+        log (deque): 
+            A deque object that stores the logged data entries.
+
+    Methods:
+        __call__:
+            Adds an entry to the log.
+        to_csv:
+            Exports the logged data to a CSV file and clears the log.
+        set_dir:
+            Sets the default directory for saving CSV files.
+    """    
+
+    def __init__(self, dir= None, log: list = None) -> None:
+        """
+        Initializes the DataLogger with an optional directory and initial log.
+
+        Parameters:
+            dir (Optional[str]): 
+                The directory where CSV files will be saved. Defaults to None.
+            log (Optional[List]): 
+                An initial list of log entries. Defaults to an empty list.
+        """        
+        self.dir = dir
+        self.log = deque(log) if log else deque()
+
+    def __call__(self, entry):
+        """
+        Adds a new entry to the log.
+
+        Parameters:
+            entry: 
+                The data entry to be added to the log.
+        """        
+        self.log.append(entry)
+
+    def to_csv(self, filename: str, dir: Optional[str] = None, verbose: bool = True, 
+               timestamp: bool = True, dir_exist_ok: bool = True, file_exist_ok: bool = False) -> None:
+        """
+        Exports the logged data to a CSV file and optionally clears the log.
+
+        Parameters:
+            filename (str): 
+                The name of the CSV file.
+            dir (Optional[str]): 
+                The directory to save the file. Defaults to the instance's dir attribute.
+            verbose (bool): 
+                If True, prints a message upon completion. Defaults to True.
+            timestamp (bool): 
+                If True, appends a timestamp to the filename. Defaults to True.
+            dir_exist_ok (bool): 
+                If True, will not raise an error if the directory already exists. Defaults to True.
+            file_exist_ok (bool): 
+                If True, overwrites the file if it exists. Defaults to False.
+
+        Side Effects:
+            Clears the log after saving the CSV file.
+            Prints a message indicating the save location and number of logs saved if verbose is True.
+        """        
+        dir = dir or self.dir
+        filepath = create_path(
+            dir=dir, filename=filename, timestamp=timestamp, dir_exist_ok=dir_exist_ok)
+        to_csv(list(self.log), filepath, file_exist_ok=file_exist_ok)
+        n_logs = len(list(self.log))
+        self.log = deque()
+        if verbose:
+            print(f"{n_logs} logs saved to {filepath}")
+            
+    def set_dir(self, dir: str) -> None:
+        """
+        Sets the default directory for saving CSV files.
+
+        Parameters:
+            dir (str): 
+                The directory to be set as the default for saving files.
+        """
+        self.dir = dir
+        

lionagi/services/__init__.py

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

lionagi/services/anthropic.py

@@ -0,0 +1 @@
+# TODO

lionagi/services/azure.py

@@ -0,0 +1 @@
+# TODO

lionagi/{api/oai_service.py → services/base_api_service.py}

@@ -1,47 +1,17 @@
-import os
-import dotenv
+import re
 import asyncio
-import logging
+import os
 import tiktoken
-from typing import Optional, NoReturn, Dict, Any
-
-dotenv.load_dotenv()
-
-from ..utils.api_util import AsyncQueue, StatusTracker, RateLimiter, BaseAPIService
-
-
-class OpenAIRateLimiter(RateLimiter):
-    """
-    A specialized RateLimiter for managing requests to the OpenAI API.
-
-    Extends the generic RateLimiter to enforce specific rate-limiting rules and limits
-    as required by the OpenAI API. This includes maximum requests and tokens per minute
-    and replenishing these limits at regular intervals.
-
-    Attributes:
-        max_requests_per_minute (int):
-            Maximum number of requests allowed per minute.
-        max_tokens_per_minute (int):
-            Maximum number of tokens allowed per minute.
+import logging
+import aiohttp
+from typing import Generator, NoReturn, Dict, Any, Optional
+from .service_objs import BaseService, RateLimiter, StatusTracker, AsyncQueue
 
-    Methods:
-        rate_limit_replenisher:
-            Coroutine to replenish rate limits over time.
-        calculate_num_token:
-            Calculates the required tokens for a request.
-    """
+class BaseAPIRateLimiter(RateLimiter):
 
     def __init__(
         self, max_requests_per_minute: int, max_tokens_per_minute: int
     ) -> None:
-        """
-        Initializes the rate limiter with specific limits for OpenAI API.
-
-        Parameters:
-            max_requests_per_minute (int): The maximum number of requests allowed per minute.
-
-            max_tokens_per_minute (int): The maximum number of tokens that can accumulate per minute.
-        """
         super().__init__(max_requests_per_minute, max_tokens_per_minute)
 
     @classmethod
@@ -155,114 +125,59 @@ class OpenAIRateLimiter(RateLimiter):
             )
 
 
-class OpenAIService(BaseAPIService):
-    """
-    Service class for interacting with the OpenAI API.
-
-    This class provides methods for calling OpenAI's API endpoints, handling the responses,
-    and managing rate limits and asynchronous tasks associated with API calls.
-
-    Attributes:
-        base_url (str): The base URL for OpenAI's API.
-
-    Methods:
-        call_api: Call an API endpoint with a payload and handle the response.
-    """
-
-    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=OpenAIRateLimiter,
-        status_tracker: Optional[StatusTracker] = None,
-        queue: Optional[AsyncQueue] = None,
-    ):
-        """
-        Initializes the OpenAI service with configuration for API interaction.
-
-        Parameters:
-            api_key (str): The API key for authenticating with OpenAI.
-
-            token_encoding_name (str): The name of the text encoding used by OpenAI.
-
-            max_attempts (int): The maximum number of attempts for calling an API endpoint.
-
-            status_tracker (Optional[StatusTracker]): Tracker for API call outcomes.
-
-            ratelimiter (Optional[OpenAIRateLimiter]): Rate limiter for OpenAI's limits.
-
-            queue (Optional[AsyncQueue]): Queue for managing asynchronous API calls.
-
-        Example:
-            >>> service = OpenAIService(
-            ...     api_key="api-key-123",
-            ...     token_encoding_name="utf-8",
-            ...     max_attempts=5,
-            ...     status_tracker=None,
-            ...     rate_limiter=OpenAIRateLimiter(100, 200),
-            ...     queue=AsyncQueue()
-            ... )
-            # Service is configured for interacting with OpenAI API.
-        """
-        api_key = api_key or os.getenv("OPENAI_API_KEY")
-        super().__init__(
-            api_key,
-            token_encoding_name,
-            max_attempts,
-            max_requests_per_minute,
-            max_tokens_per_minute,
-            ratelimiter,
-            status_tracker,
-            queue,
-        )
-
-    async def call_api(
-        self, http_session, endpoint, payload: Dict[str, any] = None
-    ) -> Optional[Dict[str, any]]:
-        """
-        Call an OpenAI API endpoint with a specific payload and handle the response.
-
-        Parameters:
-            http_session: The session object for making HTTP requests.
-
-            endpoint (str): The full URL of the OpenAI API endpoint to be called.
-
-            payload (Dict[str, any]): The payload to send with the API request.
-
-        Returns:
-            Optional[Dict[str, any]]: The response data from the API call or None if the call fails.
-
-        Raises:
-            asyncio.TimeoutError: If the request attempts exceed the configured maximum limit.
+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 ""
 
-        Example:
-            >>> session = aiohttp.ClientSession()
-            >>> response = await service.call_api(
-            ...     session,
-            ...     "https://api.openai.com/v1/engines",
-            ...     {"model": "davinci"}
-            ... )
-            # Calls the specified API endpoint with the given payload.
-        """
-        endpoint = self.api_endpoint_from_url(self.base_url + endpoint)
+    @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
+            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
-            )
-
+            
+            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
@@ -272,10 +187,9 @@ class OpenAIService(BaseAPIService):
 
                 while attempts_left > 0:
                     try:
-                        async with http_session.post(
-                            url=(self.base_url + endpoint),
-                            headers=request_headers,
-                            json=payload,
+                        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()
 
@@ -285,9 +199,7 @@ class OpenAIService(BaseAPIService):
                                 )
                                 attempts_left -= 1
 
-                                if "Rate limit" in response_json["error"].get(
-                                    "message", ""
-                                ):
+                                if "Rate limit" in response_json["error"].get("message", ""):
                                     await asyncio.sleep(15)
                             else:
                                 return response_json
@@ -298,4 +210,18 @@ class OpenAIService(BaseAPIService):
                 logging.error("API call failed after all attempts.")
                 break
             else:
-                await asyncio.sleep(1)  # Wait for token capacity
+                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/chatcompletion.py

@@ -0,0 +1,48 @@
+import abc
+
+
+class BaseEndpoint(abc.ABC):
+    endpoint: str = abc.abstractproperty()
+
+    @abc.abstractmethod
+    def create_payload(self, **kwargs):
+        """
+        Create a payload for the request based on configuration.
+        
+        Parameters:
+            **kwargs: Additional keyword arguments for configuration.
+
+        Returns:
+            dict: The payload for the request.
+        """
+        pass
+
+    @abc.abstractmethod
+    def process_response(self, response):
+        """
+        Process the response from the API call.
+        
+        Parameters:
+            response: The response to process.
+        """
+        pass
+
+
+class ChatCompletion(BaseEndpoint):
+    endpoint: str = "chat/completion"
+
+    @classmethod
+    def create_payload(scls, messages, llmconfig, schema, **kwargs):
+        config = {**llmconfig, **kwargs}
+        payload = {"messages": messages}
+        for key in schema['required']:
+            payload.update({key: config[key]})
+
+        for key in schema['optional']:
+            if bool(config[key]) is True and str(config[key]).lower() != "none":
+                payload.update({key: config[key]})
+        return payload
+    
+    def process_response(self, session, payload, completion):
+        ...
+        

lionagi/services/litellm.py

@@ -0,0 +1 @@
+# TODO

lionagi/services/oai.py

@@ -0,0 +1,34 @@
+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/ollama.py

@@ -0,0 +1 @@
+# TODO

lionagi/services/openrouter.py

@@ -0,0 +1,32 @@
+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_)
+