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

lionagi/session/session.py

@@ -3,111 +3,226 @@ import asyncio
 from typing import Any
 
 from .conversation import Conversation
-from ..config.llmconfig import llmconfig
+from ..utils.sys_util import to_list
 from ..utils.log_util import DataLogger
 from ..utils.api_util import StatusTracker
-from ..config.oaiconfig import OAIService
+from ..utils.tool_util import ToolManager
+from ..api.oai_service import OpenAIService
+
+from ..api.oai_config import oai_llmconfig
+
 
 status_tracker = StatusTracker()
+OAIService = OpenAIService()
 
 class Session():
     """
-    A class representing a conversation session with chat completion capabilities.
+    A class representing a conversation session with a conversational AI system.
 
-    This class manages conversations, interacts with chat completion services (currently OpenAI),
-    and logs the interactions using a DataLogger.
+    This class manages the flow of conversation, system settings, and interactions with external tools.
 
     Attributes:
-        conversation: An instance of the Conversation class for managing messages.
-        system: The system identifier for the conversation session.
-        llmconfig: Configuration parameters for language models.
-        logger: An instance of DataLogger for logging conversation interactions.
-        api_service: An instance of the API service for making asynchronous API calls.
+        conversation (Conversation): An instance of the Conversation class to manage messages.
+        system (str): The current system setting for the conversation.
+        llmconfig (dict): Configuration settings for the language model.
+        _logger (DataLogger): An instance of the DataLogger class for logging conversation details.
+        api_service: An instance of the API service for making calls to the conversational AI model.
+        toolmanager (ToolManager): An instance of the ToolManager class for managing external tools.
 
     Methods:
-        initiate: Initiate a conversation session with the given instruction.
-        followup: Continue the conversation session with a follow-up instruction.
-        create_payload_chatcompletion: Create a payload for chat completion API calls.
-        call_chatcompletion: Make an asynchronous call to the chat completion API.
+        set_dir(dir):
+            Set the directory for logging.
+
+        set_system(system):
+            Set the system for the conversation.
+
+        set_llmconfig(llmconfig):
+            Set the language model configuration.
+
+        set_api_service(api_service):
+            Set the API service for making model calls.
+
+        _output(output, invoke=True, out=True) -> Any:
+            Process the output, invoke tools if needed, and optionally return the output.
+
+        register_tools(tools, funcs, update=False, new=False, prefix=None, postfix=None):
+            Register tools and their corresponding functions.
+
+        initiate(instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+            Start a new conversation session with the provided instruction.
+
+        followup(instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+            Continue the conversation with the provided instruction.
+
+        create_payload_chatcompletion(**kwargs) -> dict:
+            Create a payload for chat completion based on the conversation state and configuration.
+
+        call_chatcompletion(sleep=0.1, **kwargs) -> None:
+            Make a call to the chat completion API and process the response.
+
+        messages_to_csv(dir=None, filename="_messages.csv", **kwargs) -> None:
+            Save conversation messages to a CSV file.
+
+        log_to_csv(dir=None, filename="_llmlog.csv", **kwargs) -> None:
+            Save conversation logs to a CSV file.
     """
     
-    def __init__(self, system, dir=None, llmconfig=llmconfig, api_service=OAIService):
+    def __init__(self, system, dir=None, llmconfig=oai_llmconfig, api_service=OAIService):
         """
-        Initialize a Session object.
+        Initialize a Session object with default or provided settings.
 
-        Args:
-            system: The system identifier for the conversation session.
-            dir: The directory for logging interactions.
-            llmconfig: Configuration parameters for language models.
-            api_service: An instance of the API service for making asynchronous API calls.
+        Parameters:
+            system (str): The initial system setting for the conversation.
+            dir (Optional[str]): The directory for logging. Default is None.
+            llmconfig (Optional[dict]): Configuration settings for the language model. Default is oai_llmconfig.
+            api_service: An instance of the API service for making calls to the conversational AI model.
         """
         self.conversation = Conversation()
         self.system = system
         self.llmconfig = llmconfig
-        self.logger = DataLogger(dir=dir)
+        self._logger = DataLogger(dir=dir)
+        self.api_service = api_service
+        self.toolmanager = ToolManager()
+    
+    def set_dir(self, dir):
+        """
+        Set the directory for logging.
+
+        Parameters:
+            dir (str): The directory path.
+        """
+        self._logger.dir = dir
+    
+    def set_system(self, system):
+        """
+        Set the system for the conversation.
+
+        Parameters:
+            system (str): The system setting.
+        """
+        self.conversation.change_system(system)
+    
+    def set_llmconfig(self, llmconfig):
+        """
+        Set the language model configuration.
+
+        Parameters:
+            llmconfig (dict): Configuration settings for the language model.
+        """
+        self.llmconfig = llmconfig
+    
+    def set_api_service(self, api_service):
+        """
+        Set the API service for making model calls.
+
+        Parameters:
+            api_service: An instance of the API service.
+        """
         self.api_service = api_service
     
-    async def initiate(self, instruction, system=None, context=None, out=True, **kwargs) -> Any:
+    async def _output(self, output, invoke=True, out=True):
         """
-        Initiate a conversation session with the given instruction.
+        Process the output, invoke tools if needed, and optionally return the output.
 
-        Args:
-            instruction: The user's instruction to initiate the conversation.
-            system: The content of the system message.
-            context: Additional context for the user instruction.
-            out: Whether to return the output content.
+        Parameters:
+            output: The output to process.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            out (bool): Whether to return the output. Default is True.
 
         Returns:
-            Any: The output content if 'out' is True, otherwise None.
+            Any: The processed output.
+        """
+        if invoke:
+            try: 
+                func, args = self.toolmanager._get_function_call(output)
+                outs = await self.toolmanager.ainvoke(func, args)
+                self.conversation.add_messages(tool=outs)
+            except:
+                pass
+        if out:
+            return output
+        
+    def register_tools(self, tools, funcs, update=False, new=False, prefix=None, postfix=None):
+        """
+        Register tools and their corresponding functions.
+
+        Parameters:
+            tools (list): The list of tool information dictionaries.
+            funcs (list): The list of corresponding functions.
+            update (bool): Whether to update existing functions.
+            new (bool): Whether to create new registries for existing functions.
+            prefix (Optional[str]): A prefix to add to the function names.
+            postfix (Optional[str]): A postfix to add to the function names.
+        """
+        funcs = to_list(funcs)
+        self.toolmanager.register_tools(tools, funcs, update, new, prefix, postfix)
+    
+    async def initiate(self, instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
+        """
+        Start a new conversation session with the provided instruction.
+
+        Parameters:
+            instruction (str): The instruction to initiate the conversation.
+            system (Optional[str]): The system setting for the conversation. Default is None.
+            context (Optional[dict]): Additional context for the instruction. Default is None.
+            out (bool): Whether to return the output. Default is True.
+            name (Optional[str]): The name associated with the instruction. Default is None.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            kwargs: Additional keyword arguments for configuration.
+
+        Returns:
+            Any: The processed output.
         """
         config = {**self.llmconfig, **kwargs}
         system = system or self.system
-        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context)
-        
+        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context, name=name)
         await self.call_chatcompletion(**config)
-        if out:
-            return self.conversation.responses[-1]['content']        
+        output = self.conversation.responses[-1]['content']
+        
+        return await self._output(output, invoke, out)
 
-    async def followup(self, instruction, system=None, context=None, out=True, **kwargs) -> Any:
+    async def followup(self, instruction, system=None, context=None, out=True, name=None, invoke=True, **kwargs) -> Any:
         """
-        Continue the conversation session with a follow-up instruction.
+        Continue the conversation with the provided instruction.
 
-        Args:
-            instruction: The user's follow-up instruction.
-            system: The content of the system message.
-            context: Additional context for the user instruction.
-            out: Whether to return the output content.
+        Parameters:
+            instruction (str): The instruction to continue the conversation.
+            system (Optional[str]): The system setting for the conversation. Default is None.
+            context (Optional[dict]): Additional context for the instruction. Default is None.
+            out (bool): Whether to return the output. Default is True.
+            name (Optional[str]): The name associated with the instruction. Default is None.
+            invoke (bool): Whether to invoke tools based on the output. Default is True.
+            kwargs: Additional keyword arguments for configuration.
 
         Returns:
-            Any: The output content if 'out' is True, otherwise None.
+            Any: The processed output.
         """
-        self.conversation.append_last_response()
         if system:
             self.conversation.change_system(system)
-        self.conversation.add_messages(instruction=instruction, context=context)
-        
+        self.conversation.add_messages(instruction=instruction, context=context, name=name)
         config = {**self.llmconfig, **kwargs}
         await self.call_chatcompletion(**config)
-        if out:
-            return self.conversation.responses[-1]['content']
+        output = self.conversation.responses[-1]['content']
+        
+        return await self._output(output, invoke, out)
     
     def create_payload_chatcompletion(self, **kwargs):
         """
-        Create a payload for chat completion API calls.
+        Create a payload for chat completion based on the conversation state and configuration.
 
-        Args:
-            kwargs: Additional keyword arguments for customization.
+        Parameters:
+            kwargs: Additional keyword arguments for configuration.
+
+        Returns:
+            dict: The payload for chat completion.
         """
         # currently only openai chat completions are supported
         messages = self.conversation.messages
-        request_url = f"https://api.openai.com/v1/chat/completions"
         config = {**self.llmconfig, **kwargs}
-        
         payload = {
             "messages": messages,
             "model": config.get('model'),
             "frequency_penalty": config.get('frequency_penalty'),
-            "max_tokens": config.get('max_tokens'),
             "n": config.get('n'),
             "presence_penalty": config.get('presence_penalty'),
             "response_format": config.get('response_format'),
@@ -115,35 +230,62 @@ class Session():
             "top_p": config.get('top_p'),
             }
         
-        for key in ["seed", "stop", "stream", "tools", "tool_choice", "user"]:
-            if config[key] is True:
+        for key in ["seed", "stop", "stream", "tools", "tool_choice", "user", "max_tokens"]:
+            if bool(config[key]) is True and str(config[key]) != "none":
                 payload.update({key: config[key]})
-    
-        return (payload, request_url)
-    
-    async def call_chatcompletion(self, delay=1, **kwargs):
+        return payload
+
+    async def call_chatcompletion(self, sleep=0.1,  **kwargs):
         """
-        Make an asynchronous call to the chat completion API.
+        Make a call to the chat completion API and process the response.
 
-        Args:
-            delay: The delay (in seconds) between API calls.
-            kwargs: Additional keyword arguments for customization.
+        Parameters:
+            sleep (float): The sleep duration after making the API call. Default is 0.1.
+            kwargs: Additional keyword arguments for configuration.
         """
-        # currently only openai chat completions are supported
-        payload, request_url = self.create_payload_chatcompletion(**kwargs)
+        endpoint = f"chat/completions"
         try:
             async with aiohttp.ClientSession() as session:
-                completion = await self.api_service.call_api(session, request_url, payload)
+                payload = self.create_payload_chatcompletion(**kwargs)
+                completion = await self.api_service.call_api(
+                                session, endpoint, payload)
                 if "choices" in completion:
-                    completion = completion['choices'][0]       # currently can only call one completion at a time, n has to be 1
-                    self.logger({"input":self.conversation.messages, "output": completion})
-                    response = {"role": "assistant", "content": completion['message']["content"]}
-                    self.conversation.responses.append(response)
+                    self._logger({"input":payload, "output": completion})
+                    self.conversation.add_messages(response=completion['choices'][0])
+                    self.conversation.responses.append(self.conversation.messages[-1])
                     self.conversation.response_counts += 1
-                    await asyncio.sleep(delay=delay)
+                    await asyncio.sleep(sleep)
                     status_tracker.num_tasks_succeeded += 1
                 else:
                     status_tracker.num_tasks_failed += 1
         except Exception as e:
             status_tracker.num_tasks_failed += 1
-            raise e
+            raise e
+    
+    def messages_to_csv(self, dir=None, filename="_messages.csv", **kwags):
+        """
+        Save conversation messages to a CSV file.
+
+        Parameters:
+            dir (Optional[str]): The directory path for saving the CSV file. Default is None.
+            filename (Optional[str]): The filename for the CSV file. Default is "_messages.csv".
+            kwargs: Additional keyword arguments for CSV file settings.
+        """
+        dir = dir or self._logger.dir
+        if dir is None:
+            raise ValueError("No directory specified.")
+        self.conversation.msg.to_csv(dir=dir, filename=filename, **kwags)
+        
+    def log_to_csv(self, dir=None, filename="_llmlog.csv", **kwags):
+        """
+        Save conversation logs to a CSV file.
+
+        Parameters:
+            dir (Optional[str]): The directory path for saving the CSV file. Default is None.
+            filename (Optional[str]): The filename for the CSV file. Default is "_llmlog.csv".
+            kwargs: Additional keyword arguments for CSV file settings.
+        """
+        dir = dir or self._logger.dir
+        if dir is None:
+            raise ValueError("No directory specified.")
+        self._logger.to_csv(dir=dir, filename=filename, **kwags)

lionagi/utils/__init__.py

@@ -1,11 +1,10 @@
-from .sys_util import to_flat_dict, append_to_jsonl, to_list, str_to_num, make_copy, to_temp, to_csv, hold_call, ahold_call, l_call, al_call, m_call, am_call, e_call, ae_call, get_timestamp, _flatten_dict, _flatten_list, create_id, create_path
-from .api_util import StatusTracker, RateLimiter, BaseAPIService, AsyncQueue
+from .sys_util import to_flat_dict, append_to_jsonl, to_list, str_to_num, make_copy, to_temp, to_csv, hold_call, ahold_call, l_call, al_call, m_call, am_call, e_call, ae_call, get_timestamp, create_path
 from .doc_util import dir_to_path, read_text, dir_to_files, chunk_text, file_to_chunks, file_to_chunks, get_bins
 from .log_util import DataLogger
+from .tool_util import ToolManager
 
 __all__ = [
-    "to_list", "str_to_num", "make_copy", "to_temp", "to_csv", "hold_call", "ahold_call", "l_call", "al_call", "m_call", "am_call", "e_call", "ae_call", "get_timestamp", "_flatten_dict", "_flatten_list", "create_id", "create_path", "to_flat_dict", "append_to_jsonl",
-    "StatusTracker", "RateLimiter", "BaseAPIService", "AsyncQueue",
+    "to_list", "str_to_num", "make_copy", "to_temp", "to_csv", "hold_call", "ahold_call", "l_call", "al_call", "m_call", "am_call", "e_call", "ae_call", "get_timestamp", "create_path", "to_flat_dict", "append_to_jsonl",
     "dir_to_path", "read_text", "dir_to_files", "chunk_text", "file_to_chunks", "file_to_chunks", "get_bins",
-    "DataLogger"
+    "DataLogger", "ToolManager"
 ]

lionagi/utils/api_util.py

@@ -215,7 +215,8 @@ class RateLimiter(ABC):
             ...
             >>> limiter = MyRateLimiter(100, 200)
         """
-        pass
+        
+        ...
     
     @abstractmethod
     def calculate_num_token(self, payload: Dict[str, Any], api_endpoint: str) -> int:
@@ -241,7 +242,8 @@ class RateLimiter(ABC):
             >>> limiter.calculate_num_token({'data': '12345'}, 'api/send')
             0
         """
-        pass
+        
+        ...
 
 class BaseAPIService(ABC):
     """
@@ -272,9 +274,11 @@ class BaseAPIService(ABC):
         api_key: str,
         token_encoding_name: str,
         max_attempts: int,
-        status_tracker: Optional[StatusTracker],
-        rate_limiter: RateLimiter,
-        queue: Optional[AsyncQueue]
+        max_requests_per_minute: int,
+        max_tokens_per_minute: int,
+        ratelimiter,
+        status_tracker: Optional[StatusTracker] = None,
+        queue: Optional[AsyncQueue] = None,       
     ) -> None:
         """
         Initializes the BaseAPIService with necessary configuration.
@@ -299,8 +303,8 @@ class BaseAPIService(ABC):
         self.token_encoding_name = token_encoding_name
         self.max_attempts = max_attempts
         self.status_tracker = status_tracker or StatusTracker()
-        self.rate_limiter = rate_limiter
         self.queue = queue or AsyncQueue()
+        self.rate_limiter = ratelimiter(max_requests_per_minute, max_tokens_per_minute)
         
     @abstractmethod
     async def call_api(self) -> Any:
@@ -316,7 +320,8 @@ class BaseAPIService(ABC):
             ...         # Implementation details here
             ...
         """
-        pass
+        
+        ...
 
     def handle_error(
         self,
@@ -346,19 +351,6 @@ class BaseAPIService(ABC):
         self.append_to_jsonl(data, save_filepath)
         logging.error(f"Request failed after all attempts. Saving errors: {data}")
 
-    @staticmethod
-    def append_to_jsonl(data: Any, filename: str) -> None:
-        """
-        Appends the given data to the specified JSONL file.
-        
-        Args:
-            data (Any): The data to be appended in JSON Lines format.
-            filename (str): The file path to the JSONL file.
-        """
-        json_string = json.dumps(data)
-        with open(filename, "a") as f:
-            f.write(json_string + "\n")
-
     @staticmethod
     def api_endpoint_from_url(request_url: str) -> str:
         """

lionagi/utils/doc_util.py

@@ -26,7 +26,7 @@ def dir_to_path(dir: str, ext, recursive: bool = False, flat: bool = True):
     def _dir_to_path(ext, recursive=recursive):
         tem = '**/*' if recursive else '*'
         return list(Path(dir).glob(tem + ext))
-    
+
     return to_list(l_call(ext, _dir_to_path, flat=True), flat=flat)
 
 def read_text(filepath: str, clean: bool = True) -> str:
@@ -48,15 +48,15 @@ def read_text(filepath: str, clean: bool = True) -> str:
         content = f.read()
         if clean:
             # Define characters to replace and their replacements
-            replacements = {'\\': ' ', '\\\n': ' ', '\\\t': ' ', '  ': ' ', '\'': ' '}
+            replacements = {'\\': ' ', '\n': ' ', '\t': ' ', '  ': ' ', '\'': ' '}
             for old, new in replacements.items():
                 content = content.replace(old, new)
         return content
 
-def dir_to_files(dir: str, ext: str, recursive: bool = False, 
-                 reader: Callable = read_text, clean: bool = True, 
+def dir_to_files(dir: str, ext: str, recursive: bool = False,
+                 reader: Callable = read_text, clean: bool = True,
                  to_csv: bool = False, project: str = 'project',
-                 output_dir: str = 'data/logs/sources/', filename: Optional[str] = None, 
+                 output_dir: str = 'data/logs/sources/', filename: Optional[str] = None,
                  verbose: bool = True, timestamp: bool = True, logger: Optional[DataLogger] = None):
     """
     Reads and processes files in a specified directory with the given extension.
@@ -81,9 +81,9 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
     Examples:
         >>> logs = dir_to_files(dir='my_directory', ext='.txt', to_csv=True)
     """
-    
+
     sources = dir_to_path(dir, ext, recursive)
-    
+
     def split_path(path: Path) -> tuple:
         folder_name = path.parent.name
         file_name = path.name
@@ -99,9 +99,9 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
             "file_size": len(str(content)),
             'content': content
         } if content else None
-    
+
     logs = to_list(l_call(sources, to_dict, flat=True), dropna=True)
-    
+
     if to_csv:
         filename = filename or f"{project}_sources.csv"
         logger = DataLogger(dir=output_dir, log=logs) if not logger else logger
@@ -109,7 +109,7 @@ def dir_to_files(dir: str, ext: str, recursive: bool = False,
 
     return logs
 
-def chunk_text(input: str, chunk_size: int, overlap: float, 
+def chunk_text(input: str, chunk_size: int, overlap: float,
                threshold: int) -> List[Union[str, None]]:
     """
     Splits a string into chunks of a specified size, allowing for optional overlap between chunks.
@@ -127,19 +127,19 @@ def chunk_text(input: str, chunk_size: int, overlap: float,
     Returns:
         List[Union[str, None]]: List of text chunks.
     """
-    
+
     try:
         # Ensure text is a string
         if not isinstance(input, str):
             input = str(input)
-        
+
         chunks = []
         n_chunks = math.ceil(len(input) / chunk_size)
         overlap_size = int(chunk_size * overlap / 2)
-        
+
         if n_chunks == 1:
             return [input]
-        
+
         elif n_chunks == 2:
             chunks.append(input[:chunk_size + overlap_size])
             if len(input) - chunk_size > threshold:
@@ -147,28 +147,28 @@ def chunk_text(input: str, chunk_size: int, overlap: float,
             else:
                 return [input]
             return chunks
-        
+
         elif n_chunks > 2:
             chunks.append(input[:chunk_size + overlap_size])
             for i in range(1, n_chunks - 1):
                 start_idx = chunk_size * i - overlap_size
                 end_idx = chunk_size * (i + 1) + overlap_size
                 chunks.append(input[start_idx:end_idx])
-            
+
             if len(input) - chunk_size * (n_chunks - 1) > threshold:
                 chunks.append(input[chunk_size * (n_chunks - 1) - overlap_size:])
             else:
-                chunks[-1] += input[chunk_size * (n_chunks - 1):]
-            
+                chunks[-1] += input[chunk_size * (n_chunks - 1) + overlap_size:]
+
             return chunks
-        
+
     except Exception as e:
         raise ValueError(f"An error occurred while chunking the text. {e}")
 
-def _file_to_chunks(input: Dict[str, Any], 
-                   field: str = 'content', 
-                   chunk_size: int = 1500, 
-                   overlap: float = 0.2, 
+def _file_to_chunks(input: Dict[str, Any],
+                   field: str = 'content',
+                   chunk_size: int = 1500,
+                   overlap: float = 0.2,
                    threshold: int = 200) -> List[Dict[str, Any]]:
     """
     Splits text from a specified dictionary field into chunks and returns a list of dictionaries.
@@ -195,7 +195,7 @@ def _file_to_chunks(input: Dict[str, Any],
     try:
         out = {key: value for key, value in input.items() if key != field}
         out.update({"chunk_overlap": overlap, "chunk_threshold": threshold})
-        
+
         chunks = chunk_text(input[field], chunk_size=chunk_size, overlap=overlap, threshold=threshold)
         logs = []
         for i, chunk in enumerate(chunks):
@@ -209,22 +209,22 @@ def _file_to_chunks(input: Dict[str, Any],
             logs.append(chunk_dict)
 
         return logs
-        
+
     except Exception as e:
         raise ValueError(f"An error occurred while chunking the file. {e}")
-    
-def file_to_chunks(input, 
-                   field: str = 'content', 
-                   chunk_size: int = 1500, 
-                   overlap: float = 0.2, 
-                   threshold: int = 200, 
-                   to_csv=False, 
+
+def file_to_chunks(input,
+                   field: str = 'content',
+                   chunk_size: int = 1500,
+                   overlap: float = 0.2,
+                   threshold: int = 200,
+                   to_csv=False,
                    project='project',
-                   output_dir='data/logs/sources/', 
+                   output_dir='data/logs/sources/',
                    chunk_func = _file_to_chunks,
-                   filename=None, 
-                   verbose=True, 
-                   timestamp=True, 
+                   filename=None,
+                   verbose=True,
+                   timestamp=True,
                    logger=None):
     """
         Splits text from a specified dictionary field into chunks and returns a list of dictionaries.
@@ -243,10 +243,10 @@ def file_to_chunks(input,
         timestamp: If True, include a timestamp in the exported file name.
         logger: An optional DataLogger instance for logging.
     """
-    
+
     f = lambda x: chunk_func(x, field=field, chunk_size=chunk_size, overlap=overlap, threshold=threshold)
     logs = to_list(l_call(input, f), flat=True)
-    
+
     if to_csv:
         filename = filename if filename else f"{project}_sources.csv"
         logger = DataLogger(log=logs) if not logger else logger