lionagi 0.0.112__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/{service_/oai.py → services/base_api_service.py}

@@ -1,55 +1,18 @@
-import os
-import dotenv
+import re
 import asyncio
-import logging
+import os
 import tiktoken
+import logging
 import aiohttp
-from typing import Optional, NoReturn, Dict, Any
-
-from .base_service import BaseAPIService
-
-dotenv.load_dotenv()
-
-from .base_service import BaseAPIService
-from .service_utils import StatusTracker, AsyncQueue, RateLimiter
-
+from typing import Generator, NoReturn, Dict, Any, Optional
+from .service_objs import BaseService, RateLimiter, StatusTracker, AsyncQueue
 
-
-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.
-
-    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)
-        if not os.getenv('env_readthedocs'):
-            self.rate_limit_replenisher_task = asyncio.create_task(self.rate_limit_replenisher())
 
     @classmethod
     async def create(
@@ -160,48 +123,53 @@ class OpenAIRateLimiter(RateLimiter):
             raise NotImplementedError(
                 f'API endpoint "{api_endpoint}" not implemented in this script'
             )
-            
-
-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.
-    """
+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 ""
 
-    base_url = "https://api.openai.com/v1/"
+    @staticmethod
+    def task_id_generator_function() -> Generator[int, None, None]:
+        task_id = 0
+        while True:
+            yield task_id
+            task_id += 1
 
-    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 = None,
-        queue = None,
-    ):
-        super().__init__(
-            api_key = api_key or os.getenv("OPENAI_API_KEY"),
-            status_tracker = status_tracker or StatusTracker(),
-            queue = queue or AsyncQueue(),
-            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 _call_api(self, http_session, endpoint_, method="post", payload: Dict[str, any] =None) -> Optional[Dict[str, any]]:
-        endpoint_ = self.api_endpoint_from_url(self.base_url+endpoint_)
+        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
@@ -244,7 +212,7 @@ class OpenAIService(BaseAPIService):
             else:
                 await asyncio.sleep(1)
     
-    async def serve(self, payload, endpoint_="chat/completions", method="post"):
+    async def _serve(self, payload, endpoint_="chat/completions", method="post"):
          
         async def call_api():
             async with aiohttp.ClientSession() as http_session:
@@ -256,5 +224,4 @@ class OpenAIService(BaseAPIService):
         except Exception as e:
                 self.status_tracker.num_tasks_failed += 1
                 raise e
-        
             

lionagi/{endpoint/base_endpoint.py → services/chatcompletion.py}

@@ -1,5 +1,6 @@
 import abc
 
+
 class BaseEndpoint(abc.ABC):
     endpoint: str = abc.abstractproperty()
 
@@ -16,17 +17,6 @@ class BaseEndpoint(abc.ABC):
         """
         pass
 
-    # @abc.abstractmethod
-    # async def call_api(self, session, **kwargs):
-    #     """
-    #     Make a call to the API endpoint and process the response.
-        
-    #     Parameters:
-    #         session: The aiohttp client session.
-    #         **kwargs: Additional keyword arguments for configuration.
-    #     """
-    #     pass
-
     @abc.abstractmethod
     def process_response(self, response):
         """
@@ -38,14 +28,21 @@ class BaseEndpoint(abc.ABC):
         pass
 
 
-
-
-    # @abc.abstractmethod
-    # def handle_error(self, error):
-    #     """
-    #     Handle any errors that occur during the API call.
-        
-    #     Parameters:
-    #         error: The error to handle.
-    #     """
-    #     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/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/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_)
+    

lionagi/{service_/service_utils.py → services/service_objs.py}

@@ -280,4 +280,3 @@ class RateLimiter(ABC):
         ...
 
 
-

lionagi/structure/__init__.py

@@ -0,0 +1,7 @@
+from .relationship import Relationship
+from .structure import Structure
+
+__all__=[
+    "Relationship",
+    "Structure"
+]

lionagi/structure/relationship.py

@@ -0,0 +1,128 @@
+from pydantic import Field
+from typing import Dict, Optional, Any
+from ..schema.base_schema import BaseNode
+
+
+class Relationship(BaseNode):
+    """
+    Relationship class represents a relationship between two nodes in a graph.
+
+    Inherits from BaseNode and adds functionality to manage conditions and relationships 
+    between source and target nodes.
+
+    Attributes:
+        source_node_id (str): The identifier of the source node.
+        target_node_id (str): The identifier of the target node.
+        condition (Dict[str, Any]): A dictionary representing conditions for the relationship.
+    """
+
+    source_node_id: str
+    target_node_id: str
+    condition: dict = Field(default={})
+
+    def add_condition(self, condition: Dict[str, Any]) -> None:
+        """
+        Adds a condition to the relationship.
+
+        Parameters:
+            condition (Dict[str, Any]): The condition to be added.
+        """
+        self.condition.update(condition)
+
+    def remove_condition(self, condition_key: str) -> Any:
+        """
+        Removes a condition from the relationship.
+
+        Parameters:
+            condition_key (str): The key of the condition to be removed.
+
+        Returns:
+            Any: The value of the removed condition.
+
+        Raises:
+            KeyError: If the condition key is not found.
+        """
+        if condition_key not in self.condition.keys():
+            raise KeyError(f'condition {condition_key} is not found')
+        return self.condition.pop(condition_key)
+
+    def condition_exists(self, condition_key: str) -> bool:
+        """
+        Checks if a condition exists in the relationship.
+
+        Parameters:
+            condition_key (str): The key of the condition to check.
+
+        Returns:
+            bool: True if the condition exists, False otherwise.
+        """
+        if condition_key in self.condition.keys():
+            return True
+        else:
+            return False
+
+    def get_condition(self, condition_key: Optional[str] = None) -> Any:
+        """
+        Retrieves a specific condition or all conditions of the relationship.
+
+        Parameters:
+            condition_key (Optional[str]): The key of the specific condition. Defaults to None.
+
+        Returns:
+            Any: The requested condition or all conditions if no key is provided.
+
+        Raises:
+            ValueError: If the specified condition key does not exist.
+        """
+        if condition_key is None:
+            return self.condition
+        if self.condition_exists(condition_key=condition_key):
+            return self.condition[condition_key]
+        else:
+            raise ValueError(f"Condition {condition_key} does not exist")
+    
+    def _source_existed(self, obj: Dict[str, Any]) -> bool:
+        """
+        Checks if the source node exists in a given object.
+
+        Parameters:
+            obj (Dict[str, Any]): The object to check.
+
+        Returns:
+            bool: True if the source node exists, False otherwise.
+        """
+        return self.source_node_id in obj.keys()
+    
+    def _target_existed(self, obj: Dict[str, Any]) -> bool:
+        """
+        Checks if the target node exists in a given object.
+
+        Parameters:
+            obj (Dict[str, Any]): The object to check.
+
+        Returns:
+            bool: True if the target node exists, False otherwise.
+        """
+        return self.target_node_id in obj.keys()
+    
+    def _is_in(self, obj: Dict[str, Any]) -> bool:
+        """
+        Validates the existence of both source and target nodes in a given object.
+
+        Parameters:
+            obj (Dict[str, Any]): The object to check.
+
+        Returns:
+            bool: True if both nodes exist.
+
+        Raises:
+            ValueError: If either the source or target node does not exist.
+        """
+        if self._source_existed(obj) and self._target_existed(obj):
+            return True
+        
+        elif self._source_existed(obj):
+            raise ValueError(f"Target node {self.source_node_id} does not exist")
+        else :
+            raise ValueError(f"Source node {self.target_node_id} does not exist")
+