lionagi 0.0.103__py3-none-any.whl → 0.0.105__py3-none-any.whl

lionagi/__init__.py

@@ -16,7 +16,6 @@ Copyright 2023 HaiyangLi <ocean@lionagi.ai>
 
 import logging
 from .version import __version__
-from .config import *
 from .session import *
 from .utils import *
 from .api import *

lionagi/api/__init__.py

@@ -1,6 +1,7 @@
-from .OAIService import OpenAIRateLimiter, OpenAIService
+from .oai_service import OpenAIService
+from .oai_config import oai_llmconfig
 
 __all__ = [
-    "OpenAIRateLimiter",
+    "oai_llmconfig",
     "OpenAIService",
 ]

lionagi/{config/llmconfig.py → api/oai_config.py}

@@ -1,7 +1,7 @@
-llmconfig = {
+oai_llmconfig = {
     "model": "gpt-4-1106-preview",
     "frequency_penalty": 0,
-    "max_tokens": 4000,
+    "max_tokens": None,
     "n": 1,
     "presence_penalty": 0, 
     "response_format": {"type": "text"}, 

lionagi/api/{OAIService.py → oai_service.py}

@@ -1,8 +1,12 @@
+import os
+import dotenv
 import asyncio
 import logging
 import tiktoken
 from typing import Optional, NoReturn, Dict, Any
 
+dotenv.load_dotenv()
+
 from ..utils.api_util import AsyncQueue, StatusTracker, RateLimiter, BaseAPIService
 
 
@@ -32,7 +36,8 @@ class OpenAIRateLimiter(RateLimiter):
             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)
-        self.rate_limit_replenisher_task = asyncio.create_task(self.rate_limit_replenisher())
+        if not os.getenv('env_readthedocs'):
+            self.rate_limit_replenisher_task = asyncio.create_task(self.rate_limit_replenisher())
     
     async def rate_limit_replenisher(self) -> NoReturn:
         """
@@ -52,8 +57,8 @@ class OpenAIRateLimiter(RateLimiter):
             self.available_request_capacity = self.max_requests_per_minute
             self.available_token_capacity = self.max_tokens_per_minute
             
-    def calculate_num_token(self, payload: Dict[str, Any], 
-                            api_endpoint: str, token_encoding_name: str) -> int:
+    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.
 
@@ -143,11 +148,13 @@ class OpenAIService(BaseAPIService):
 
     def __init__(
         self,
-        api_key: str,
-        token_encoding_name: str,
-        max_attempts: int,
+        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,
-        rate_limiter: Optional[OpenAIRateLimiter] = None,
         queue: Optional[AsyncQueue] = None
     ):
         """
@@ -172,10 +179,13 @@ class OpenAIService(BaseAPIService):
             ... )
             # 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, 
-                         status_tracker, rate_limiter, queue)
+                         max_requests_per_minute, max_tokens_per_minute,
+                         ratelimiter, status_tracker, queue)
+        
 
-    async def call_api(self, session, request_url: str, payload: Dict[str, any]) -> Optional[Dict[str, any]]:
+    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.
 
@@ -199,12 +209,13 @@ class OpenAIService(BaseAPIService):
             ... )
             # Calls the specified API endpoint with the given payload.
         """
+        endpoint = self.api_endpoint_from_url(self.base_url+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
             
-            endpoint = self.api_endpoint_from_url(request_url)
             required_tokens = self.rate_limiter.calculate_num_token(payload, endpoint, self.token_encoding_name)
             
             if self.rate_limiter.available_token_capacity >= required_tokens:
@@ -216,8 +227,8 @@ class OpenAIService(BaseAPIService):
 
                 while attempts_left > 0:
                     try:
-                        async with session.post(
-                            url=request_url, headers=request_headers, json=payload
+                        async with http_session.post(
+                            url=(self.base_url+endpoint), headers=request_headers, json=payload
                         ) as response:
                             response_json = await response.json()
 
@@ -239,4 +250,3 @@ class OpenAIService(BaseAPIService):
                 break
             else:
                 await asyncio.sleep(1)  # Wait for token capacity
-                

lionagi/session/__init__.py

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

lionagi/session/conversation.py

@@ -2,87 +2,91 @@ from .message import Message
 
 class Conversation:
     """
-    A class modeling conversations and managing messages within the conversation.
+    A class representing a conversation between users and the assistant.
 
-    This class facilitates the organization and manipulation of messages in a conversation.
-    It includes methods for initiating a conversation, adding messages, changing the system message,
-    appending the last response, and keeping the last N exchanges.
+    This class manages the exchange of messages within a conversation, including system settings,
+    user instructions, and assistant responses.
 
     Attributes:
-        response_counts: A class-level attribute to track the number of responses.
-        messages: A list containing messages in the conversation.
-        msg: An instance of the Message class for creating and processing messages.
-        responses: A list containing response messages.
+        response_counts (int): The count of assistant responses in the conversation.
+        messages (list): A list to store messages in the conversation.
+        msg (Message): An instance of the Message class for creating messages.
+        responses (list): A list to store assistant responses in the conversation.
 
     Methods:
-        initiate_conversation: Start a new conversation with system and user instructions.
-        add_messages: Add messages to the conversation.
-        change_system: Change the system message in the conversation.
-        append_last_response: Append the last response to the conversation.
-        keep_last_n_exchanges: Keep only the last N exchanges in the conversation.
+        initiate_conversation(system, instruction, context=None, name=None):
+            Initiate a conversation with a system setting and user instruction.
+
+        add_messages(system, instruction, context=None, response=None, tool=None, name=None):
+            Add messages to the conversation, including system setting, user instruction, and assistant response.
+
+        change_system(system):
+            Change the system setting in the conversation.
+
+        keep_last_n_exchanges(n: int):
+            Keep the last n exchanges in the conversation.
     """
-    
     response_counts = 0
     
     def __init__(self, messages=None) -> None:
         """
         Initialize a Conversation object.
 
-        Args:
-            messages: A list of messages to initialize the conversation.
+        Parameters:
+            messages (list): A list of messages to initialize the conversation. Default is None.
+
         """
         self.messages = messages or []
         self.msg = Message()
         self.responses = []
 
-    def initiate_conversation(self, system, instruction, context=None):
+    def initiate_conversation(self, system, instruction, context=None, name=None):
         """
-        Start a new conversation with a system message and an instruction.
+        Initiate a conversation with a system setting and user instruction.
 
-        Args:
-            system: The content of the system message.
-            instruction: The content of the user instruction.
-            context: Additional context for the user instruction.
+        Parameters:
+            system (str): The system setting for the conversation.
+            instruction (str): The user instruction to initiate the conversation.
+            context (dict): Additional context for the conversation. Default is None.
+            name (str): The name associated with the user. Default is None.
         """
         self.messages, self.responses = [], []
         self.add_messages(system=system)
-        self.add_messages(instruction=instruction, context=context)
+        self.add_messages(instruction=instruction, context=context, name=name)
 
-    def add_messages(self, system=None, instruction=None, context=None, response=None):
+    # modify the message adding to accomodate tools
+    def add_messages(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
         """
-        Add messages to the conversation.
+        Add messages to the conversation, including system setting, user instruction, and assistant response.
 
-        Args:
-            system: The content of the system message.
-            instruction: The content of the user instruction.
-            context: Additional context for the user instruction.
-            response: The content of the assistant's response.
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
         """
-        msg = self.msg(system=system, instruction=instruction, response=response, context=context)
+        msg = self.msg(system=system, instruction=instruction, context=context, response=response, tool=tool, name=name)
         self.messages.append(msg)
 
     def change_system(self, system):
         """
-        Change the system message in the conversation.
+        Change the system setting in the conversation.
 
-        Args:
-            system: The new content for the system message.
+        Parameters:
+            system (str): The new system setting for the conversation.
         """
         self.messages[0] = self.msg(system=system)
 
-    def append_last_response(self):
-        """
-        Append the last response to the conversation.
-        """
-        self.add_messages(response=self.responses[-1])
-
     def keep_last_n_exchanges(self, n: int):
         """
-        Keep only the last N exchanges in the conversation.
+        Keep the last n exchanges in the conversation.
 
-        Args:
-            n: The number of exchanges to keep.
+        Parameters:
+            n (int): The number of exchanges to keep.
         """
+        # keep last n_exchanges, one exchange is marked by one assistant response
         response_indices = [
             index for index, message in enumerate(self.messages[1:]) if message["role"] == "assistant"
         ]

lionagi/session/message.py

@@ -1,73 +1,139 @@
 from datetime import datetime
 import json
-from ..utils.sys_util import create_id
+from ..utils.sys_util import create_id, l_call
 from ..utils.log_util import DataLogger
 
 
 class Message:
     """
-    A class modeling messages in conversations.
+    A class representing a message in a conversation.
 
-    This class is designed to encapsulate messages exchanged between different roles
-    (user, assistant, or system) in a conversation. It includes functionality to process,
-    log, and manage messages.
+    This class encapsulates messages from users, the assistant, systems, and external tools.
 
     Attributes:
-        role: The role of the message (user, assistant, or system).
-        content: The content of the message.
-        sender: The sender of the message.
-        logger: An instance of DataLogger for logging message information.
+        role (str): The role of the message, indicating if it's from the user, assistant, system, or tool.
+        content: The content of the message, which can be an instruction, response, system setting, or tool information.
+        name (str): The name associated with the message, specifying the source (user, assistant, system, or tool).
+        metadata (dict): Additional metadata including id, timestamp, and name.
+        _logger (DataLogger): An instance of the DataLogger class for logging message details.
 
     Methods:
-        __call__: Process and log a message based on its role.
+        create_message(system, instruction, context, response, tool, name):
+            Create a message based on the provided information.
+
+        to_json() -> dict:
+            Convert the message to a JSON format.
+
+        __call__(system, instruction, context, response, name, tool) -> dict:
+            Create and return a message in JSON format.
+
+        to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok):
+            Save the message to a CSV file.
     """
     def __init__(self) -> None:
         """
-        Initialize a Message object with attributes for role, content, sender, and a DataLogger.
+        Initialize a Message object.
         """
         self.role = None
         self.content = None
-        self.sender = None
-        self.logger = DataLogger()
-
-    def __call__(self, system=None, instruction=None, response=None, context=None, sender=None):
+        self.name = None
+        self.metadata = None
+        self._logger = DataLogger()
+    
+    def create_message(self, system=None, instruction=None, context=None, response=None, tool=None, name=None):
         """
-        Process and log a message based on the specified role (system, instruction, or response).
+        Create a message based on the provided information.
 
-        Args:
-            system: The content of the message in the system role.
-            instruction: The content of the message in the user role.
-            response: The content of the message in the assistant role.
-            context: Additional context for the user instruction.
-            sender: The sender of the message.
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
         """
+        if sum(l_call([system, instruction, response, tool], bool)) > 1:
+            raise ValueError("Error: Message cannot have more than one role.")
         
-        if sum(map(bool, [system, instruction, response])) > 1:
-            raise ValueError("Message cannot have more than one role.")
-        else:
+        else: 
             if response:
                 self.role = "assistant"
-                self.sender = sender or "assistant"
-                self.content = response['content']
+                response = response["message"]
+                if str(response['content']) == "None":
+                    try:
+                        # currently can only support a single function response
+                        if response['tool_calls'][0]['type'] == 'function':
+                            self.name = name or ("func_" + response['tool_calls'][0]['function']['name'])
+                            content = response['tool_calls'][0]['function']['arguments']
+                            self.content = {"function":self.name, "arguments": content}
+                    except:
+                        raise ValueError("Response message must be one of regular response or function calling")
+                else:
+                    self.content = response['content']
+                    self.name = name or "assistant"
             elif instruction:
                 self.role = "user"
-                self.sender = sender or "user"
                 self.content = {"instruction": instruction}
+                self.name = name or "user"
                 if context:
-                    self.content.update(context)
+                    self.content.update({"context": context})
             elif system:
                 self.role = "system"
-                self.sender = sender or "system"
                 self.content = system
+                self.name = name or "system"
+            elif tool:
+                self.role = "tool"
+                self.content = tool
+                self.name = name or "tool"
+    
+    def to_json(self):
+        """
+        Convert the message to a JSON format.
+
+        Returns:
+        - dict: The message in JSON format.
+        """
         out = {
             "role": self.role,
             "content": json.dumps(self.content) if isinstance(self.content, dict) else self.content
             }
-        
-        a = {**{
+    
+        self.metadata = {
             "id": create_id(),
             "timestamp": datetime.now().isoformat(),
-            "sender": self.sender
-        }, **out}
-        self.logger(a)
-        return out
+            "name": self.name}
+        
+        self._logger({**self.metadata, **out})
+        return out
+        
+    def __call__(self, system=None, instruction=None, context=None, response=None, name=None, tool=None):
+        """
+        Create and return a message in JSON format.
+
+        Parameters:
+            system (str): The system setting for the message. Default is None.
+            instruction (str): The instruction content for the message. Default is None.
+            context (dict): Additional context for the message. Default is None.
+            response (dict): The response content for the message. Default is None.
+            name (str): The name associated with the message. Default is None.
+            tool (dict): The tool information for the message. Default is None.
+
+        Returns:
+            dict: The message in JSON format.
+        """
+        self.create_message(system, instruction, context, response, tool, name)
+        return self.to_json()
+    
+    def to_csv(self, dir=None, filename=None, verbose=True, timestamp=True, dir_exist_ok=True, file_exist_ok=False):
+        """
+        Save the message to a CSV file.
+
+        Parameters:
+            dir (str): The directory path for saving the CSV file. Default is None.
+            filename (str): The filename for the CSV file. Default is None.
+            verbose (bool): Whether to include verbose information in the CSV. Default is True.
+            timestamp (bool): Whether to include timestamps in the CSV. Default is True.
+            dir_exist_ok (bool): Whether to allow the directory to exist. Default is True.
+            file_exist_ok (bool): Whether to allow the file to exist. Default is False.
+        """
+        self._logger.to_csv(dir, filename, verbose, timestamp, dir_exist_ok, file_exist_ok)