lionagi 0.0.114__py3-none-any.whl → 0.0.116__py3-none-any.whl

lionagi/endpoints/chatcompletion.py

@@ -0,0 +1,54 @@
+from lionagi.objs.abc_objs import BaseEndpoint
+
+
+class ChatCompletion(BaseEndpoint):
+    """
+    Represents an endpoint for chat completions in an API.
+
+    This class is designed to handle the creation of payloads for chat completion requests. The 'endpoint' attribute specifies the API endpoint for chat completions.
+
+    Attributes:
+        endpoint (str): The API endpoint for chat completions.
+    """
+    endpoint: str = "chat/completions"
+
+    @classmethod
+    def create_payload(scls, messages, llmconfig, schema, **kwargs):
+        """
+        Creates a payload for a chat completion request using provided messages, configuration, and schema.
+
+        This method constructs a payload dictionary that includes required and optional parameters 
+        as specified in the schema. Required parameters are extracted from 'llmconfig' and 'kwargs', 
+        while optional parameters are included only if they are truthy and not equal to the string "none".
+
+        Parameters:
+            messages (list): A list of message objects to include in the payload.
+            llmconfig (dict): A dictionary containing configuration settings for the large language model.
+            schema (dict): A dictionary defining required and optional keys for the payload.
+                The 'required' key should map to a list of required parameter names.
+                The 'optional' key should map to a list of optional parameter names.
+            **kwargs: Additional keyword arguments that can override or supplement 'llmconfig'.
+
+        Returns:
+            dict: A dictionary representing the payload for the chat completion request.
+
+        Example:
+            payload = ChatCompletion.create_payload(
+                messages=[{"text": "Hello, world!"}],
+                llmconfig={"max_tokens": 100},
+                schema={"required": ["max_tokens"], "optional": ["temperature"]}
+            )
+        """
+        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/{loader → loaders}/__init__.py

@@ -1,3 +1,4 @@
+from .load_util import dir_to_path, dir_to_nodes,  chunk_text, read_text, file_to_chunks
 from .reader import load, ReaderType, text_reader
 from .chunker import chunk, datanodes_convert, ChunkerType, text_chunker
 
@@ -8,5 +9,10 @@ __all__ = [
     'text_reader',
     'text_chunker',
     'ReaderType',
-    'ChunkerType'
+    'ChunkerType',
+    'dir_to_path', 
+    'dir_to_nodes', 
+    'chunk_text', 
+    'read_text', 
+    'file_to_chunks'
 ]

lionagi/{loader → loaders}/chunker.py

@@ -1,17 +1,11 @@
-from enum import Enum
+# use utils, schema and bridge
 from typing import Union, Callable
 
-from ..bridge.langchain import langchain_text_splitter, from_langchain
-from ..bridge.llama_index import llama_index_node_parser, from_llama_index
-from ..schema.base_schema import DataNode
-from ..utils import lcall, file_to_chunks
-
-# define an enum to represent different types of chunkers
-class ChunkerType(str, Enum):
-    PLAIN = 'plain'                 # default
-    LANGCHAIN = 'langchain'         # using langchain functions
-    LLAMAINDEX = 'llama_index'      # using llamaindex functions
-    SELFDEFINED = 'self_defined'    # create custom functions
+from lionagi.utils import lcall
+from lionagi.schema import DataNode
+from lionagi.bridge import langchain_text_splitter, from_langchain, llama_index_node_parser, from_llama_index
+from .load_util import ChunkerType, file_to_chunks
+
 
 # Function to convert documents to a specific format based on the chunker type
 def datanodes_convert(documents, chunker_type):

lionagi/{utils/load_utils.py → loaders/load_util.py}

@@ -1,16 +1,30 @@
+# use utils and schema
 import math
+from enum import Enum
 from pathlib import Path
 from typing import List, Union, Dict, Any, Tuple
 
-from .type_util import to_list
-from .call_util import lcall
-from .io_util import to_csv
-from ..schema.base_schema import DataNode
+from lionagi.utils import to_list, lcall
+from lionagi.schema import DataNode
 
+class ReaderType(str, Enum):
+    PLAIN = 'plain'
+    LANGCHAIN = 'langchain'
+    LLAMAINDEX = 'llama_index'
+    SELFDEFINED = 'self_defined'
 
+
+class ChunkerType(str, Enum):
+    PLAIN = 'plain'                 # default
+    LANGCHAIN = 'langchain'         # using langchain functions
+    LLAMAINDEX = 'llama_index'      # using llamaindex functions
+    SELFDEFINED = 'self_defined'    # create custom functions
+    
+    
 def dir_to_path(
     dir: str, ext: str, recursive: bool = False, 
-    flatten: bool = True) -> List[Path]:
+    flatten: bool = True
+) -> List[Path]:
     """
     Generates a list of file paths from a directory with the given file extension.
 
@@ -39,7 +53,32 @@ def dir_to_path(
     except: 
         raise ValueError("Invalid directory or extension, please check the path")
 
-def dir_to_nodes(dir: str, ext, recursive: bool = False, flatten: bool = True, clean_text: bool = True):
+def dir_to_nodes(
+    dir: str, ext: Union[List[str], str], 
+    recursive: bool = False, flatten: bool = True, 
+    clean_text: bool = True
+) -> List[DataNode]:
+    """
+    Converts directory contents into DataNode objects based on specified file extensions.
+
+    This function first retrieves a list of file paths from the specified directory, matching the given file extension. It then reads the content of these files, optionally cleaning the text, and converts each file's content into a DataNode object. 
+
+    Parameters:
+        dir (str): The directory path from which to read files.
+        ext: The file extension(s) to include. Can be a single string or a list/tuple of strings.
+        recursive (bool, optional): If True, the function searches for files recursively in subdirectories. Defaults to False.
+        flatten (bool, optional): If True, flattens the directory structure in the returned paths. Defaults to True.
+        clean_text (bool, optional): If True, cleans the text read from files. Defaults to True.
+
+    Returns:
+        list: A list of DataNode objects created from the files in the specified directory.
+
+    Example:
+        nodes = dir_to_nodes("/path/to/dir", ".txt", recursive=True)
+        # This would read all .txt files in /path/to/dir and its subdirectories, 
+        # converting them into DataNode objects.
+    """
+
     path_list = dir_to_path(dir, ext, recursive, flatten)
     files_info = lcall(path_list, read_text, clean=clean_text)
     nodes = lcall(files_info, lambda x: DataNode(content=x[0], metadata=x[1]))
@@ -186,6 +225,8 @@ def _file_to_chunks(input: Dict[str, Any],
     except Exception as e:
         raise ValueError(f"An error occurred while chunking the file. {e}")
 
+
+# needs doing TODO
 def file_to_chunks(input,
                 #    project='project',
                 #    output_dir='data/logs/sources/',

lionagi/{loader → loaders}/reader.py

@@ -1,17 +1,9 @@
-from enum import Enum
+# use utils, schema, and bridge
 from typing import Union, Callable
 
-from lionagi.bridge.langchain import langchain_loader, from_langchain
-from lionagi.bridge.llama_index import llama_index_reader, from_llama_index
-from lionagi.utils.call_util import lcall
-from lionagi.utils.load_utils import dir_to_nodes
-
-
-class ReaderType(str, Enum):
-    PLAIN = 'PLAIN'
-    LANGCHAIN = 'langchain'
-    LLAMAINDEX = 'llama_index'
-    SELFDEFINED = 'self_defined'
+from lionagi.utils import lcall
+from lionagi.bridge import langchain_loader, from_langchain, llama_index_reader, from_llama_index
+from .load_util import dir_to_nodes, ReaderType
 
 
 def _datanode_parser(nodes, parser):

lionagi/messages/__init__.py

@@ -0,0 +1,11 @@
+from .message import Message
+from .system import System
+from .instruction import Instruction
+from .response import Response
+
+__all__ = [
+    "Message",
+    "System",
+    "Instruction",
+    "Response"
+]

lionagi/messages/instruction.py

@@ -0,0 +1,15 @@
+from typing import Any, Optional
+from .message import Message
+
+class Instruction(Message):
+
+    def _create_message(self, instruction: Any, context=None ,name: Optional[str] = None) -> None:
+        self._create_roled_message(
+            role_="user", 
+            content_key="instruction", 
+            content=instruction, 
+            name=name
+        )
+        if context: 
+            self.content.update({"context": context})
+            

lionagi/messages/message.py

@@ -0,0 +1,110 @@
+import json
+from typing import Any, Optional
+from lionagi.schema import BaseNode
+
+class Message(BaseNode):
+    """
+    Represents a message within a communication system, extending from BaseNode.
+
+    This class encapsulates the details of a message, including its role, content, and name. 
+    It provides methods to manipulate and retrieve message information.
+
+    Attributes:
+        role (Optional[str]): The role associated with the message (e.g., 'user', 'system'). Defaults to None.
+        name (Optional[str]): The name associated with the message, often reflecting the role. Defaults to None.
+
+    Properties:
+        message: Returns the message as a dictionary including role and content.
+        message_content: Returns only the content part of the message.
+
+    Methods:
+        to_message: Converts the message object into a dictionary format.
+        create_role_message: Sets the role, content, and name of the message.
+        get_role: Retrieves the role of the message, formatted as a lowercase string.
+        get_name: Retrieves the name of the message, formatted as a lowercase string.
+    """
+
+    role: Optional[str] = None
+    name: Optional[str] = None
+    
+    @property
+    def message(self):
+        """
+        Property that returns the message as a dictionary.
+
+        Returns:
+            dict: A dictionary representation of the message with 'role' and 'content'.
+        """
+        return self._to_message()
+    
+    @property
+    def message_content(self):
+        """
+        Property that returns the content part of the message.
+
+        Returns:
+            Any: The content of the message.
+        """
+        return self.message['content']
+    
+    def _to_message(self):
+        """
+        Converts the message object into a dictionary format, including role and content.
+
+        Returns:
+            dict: A dictionary with 'role' and 'content' keys.
+        """
+        out = {
+            "role": self.role,
+            "content": json.dumps(self.content) if isinstance(self.content, dict) else self.content
+            }
+        return out
+
+    def _create_roled_message(
+        self, role_: str, content: Any, content_key: str, 
+        name: Optional[str] = None
+    ) -> None:
+        """
+        Sets the role, content, and name of the message.
+
+        Parameters:
+            role_ (str): The role to assign to the message.
+            content (Any): The content of the message.
+            content_key (str): The key under which the content is stored.
+            name (Optional[str]): The name associated with the message. Defaults to the role if not provided.
+        """
+        self.role = role_
+        self.content = {content_key: content}
+        self.name = name or role_
+
+    def get_role(self):
+        """
+        Retrieves the role of the message, formatted as a lowercase string.
+
+        Returns:
+            str: The message's role in lowercase.
+        """
+        return str(self.role).strip().lower()
+    
+    def get_name(self):
+        """
+        Retrieves the name of the message, formatted as a lowercase string.
+
+        Returns:
+            str: The message's name in lowercase.
+        """
+        return str(self.name).strip().lower()
+        
+    def __str__(self):
+        """
+        Informal string representation of Message object, intended to be readable.
+        Includes role, name, and a brief preview of the content.
+        """
+        content_preview = (
+            (str(self.content)[:75] + '...') if self.content and len(self.content) > 75 
+            else str(self.content)
+        )
+        return f"Message(role={self.role}, name={self.name}, content='{content_preview}')"
+
+
+    

lionagi/messages/response.py

@@ -0,0 +1,33 @@
+from typing import Any, Optional
+from .message import Message
+
+class Response(Message):
+
+    def _create_message(self, response: Any, name: Optional[str] = None) -> None:
+        self.role = "assistant"
+        try:
+            response = response["message"]
+            if str(response['content']) == "None":
+                try:
+                    tool_count = 0
+                    func_list = []
+                    while tool_count < len(response['tool_calls']):
+                        if response['tool_calls'][tool_count]['type'] == 'function':
+                            func_content = {
+                                "function": ("func_" + response['tool_calls'][tool_count]['function']['name']),
+                                "arguments": response['tool_calls'][tool_count]['function']['arguments']
+                                }
+                            func_list.append(func_content)
+                        tool_count += 1
+
+                    self.name = name or "func_request"
+                    self.content = {'function_list': func_list}
+                except:
+                    raise ValueError("Response message must be one of regular response or function calling")
+            else:
+                self.content = response['content']
+                self.name = name or "assistant"
+        except:
+            self.name = name or "func_call"
+            self.content = response
+        

lionagi/messages/system.py

@@ -0,0 +1,12 @@
+from typing import Any, Optional
+from .message import Message
+
+class System(Message):
+    
+    def _create_message(self, system: Any, name: Optional[str] = None) -> None:
+        self._create_roled_message(
+            role_="system", 
+            content_key="system", 
+            content=system, 
+            name=name
+        )

lionagi/objs/__init__.py

@@ -1,7 +1,11 @@
-# # from .messenger import Messenger
-# from .tool_registry import ToolRegistry
+from .messenger import Messenger
+from .tool_manager import ToolManager
+from .async_queue import AsyncQueue
+from .status_tracker import StatusTracker
 
-# __all__ = [
-#     'Messenger',
-#     'ToolRegistry'
-# ]
+__all__ = [
+    'Messenger',
+    'ToolManager',
+    'AsyncQueue',
+    'StatusTracker'
+]

lionagi/objs/abc_objs.py

@@ -0,0 +1,39 @@
+from abc import abstractmethod, ABC, abstractproperty
+from typing import Any, Dict, NoReturn
+
+
+class BaseService(ABC):
+    
+    @abstractmethod
+    def __init__(self) -> None:
+        ...
+
+    @abstractmethod
+    async def serve(self) -> Any:     
+        ...
+        
+        
+class RateLimiter(ABC):
+
+    def __init__(self, max_requests_per_minute: int, max_tokens_per_minute: int) -> None:
+        self.max_requests_per_minute = max_requests_per_minute
+        self.max_tokens_per_minute = max_tokens_per_minute
+        self.available_request_capacity = max_requests_per_minute
+        self.available_token_capacity = max_tokens_per_minute
+    
+    @abstractmethod
+    async def rate_limit_replenisher(self) -> NoReturn:
+        ...
+    
+    @abstractmethod
+    def calculate_num_token(self, payload: Dict[str, Any], api_endpoint: str) -> int:
+        ...
+        
+
+class BaseEndpoint(ABC):
+    
+    endpoint: str = abstractproperty()
+
+    @abstractmethod
+    def create_payload(self, **kwargs):
+        ...

lionagi/objs/async_queue.py

@@ -0,0 +1,135 @@
+import asyncio
+from typing import Any, Callable
+
+class AsyncQueue:
+    """
+    A queue class that handles asynchronous operations using asyncio.
+
+    This class provides an asynchronous queue that can enqueue items, process them
+    asynchronously, and support graceful shutdowns. It is designed to facilitate
+    concurrent task processing in an orderly and controlled manner.
+
+    Attributes:
+        queue (asyncio.Queue):
+            A queue to hold items for asynchronous processing.
+        _stop_event (asyncio.Event):
+            An event to signal when the queue should stop processing.
+
+    Methods:
+        enqueue(item):
+            Add an item to the queue for processing.
+        dequeue():
+            Remove and return an item from the queue.
+        join():
+            Wait until all items in the queue have been processed.
+        stop():
+            Signal to stop processing new items in the queue.
+        stopped():
+            Check if the queue has been signaled to stop.
+        process_requests(func):
+            Process items using a provided function.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes an AsyncQueue object with an empty asyncio Queue and a stop event.
+        """
+        self.queue = asyncio.Queue()
+        self._stop_event = asyncio.Event()
+
+    async def enqueue(self, item: Any) -> None:
+        """
+        Asynchronously add an item to the queue for processing.
+
+        Parameters:
+            item (Any): The item to be added to the queue.
+
+        Example:
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.enqueue('Task 1'))
+        """
+        await self.queue.put(item)
+
+    async def dequeue(self) -> Any:
+        """
+        Asynchronously remove and return an item from the queue.
+
+        If the queue is empty, this method will wait until an item is available.
+
+        Returns:
+            Any: The next item from the queue.
+
+        Example:
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.enqueue('Task 1'))
+            >>> asyncio.run(async_queue.dequeue())
+            'Task 1'
+        """
+        return await self.queue.get()
+
+    async def join(self) -> None:
+        """
+        Asynchronously wait until all items in the queue have been processed.
+
+        This method blocks until every item that has been enqueued is processed, 
+        ensuring that all tasks are completed.
+
+        Example:
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.enqueue('Task 1'))
+            >>> asyncio.run(async_queue.join())  # This will block until 'Task 1' is processed.
+        """
+        await self.queue.join()
+
+    async def stop(self) -> None:
+        """
+        Signal the queue to stop processing new items.
+
+        Once called, the queue will not process any new items after the current ones
+        are completed, allowing for a graceful shutdown.
+
+        Example:
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.stop())  # This signals the queue to stop processing.
+        """
+        self._stop_event.set()
+
+    def stopped(self) -> bool:
+        """
+        Check if the queue has been signaled to stop processing.
+
+        Returns:
+            bool: True if a stop has been signaled, False otherwise.
+
+        Example:
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.stop())
+            >>> async_queue.stopped()
+            True
+        """
+        return self._stop_event.is_set()
+
+    async def process_requests(self, func: Callable[[Any], Any]) -> None:
+        """
+        Asynchronously process items from the queue using the provided function.
+
+        Continuously dequeues items and applies the given function to each. 
+        The processing stops when the queue is signaled to stop or a sentinel value (`None`) is dequeued.
+
+        Parameters:
+            func (Callable[[Any], Any]): A coroutine function to process items from the queue.
+
+        Example:
+            >>> async def sample_processing(task):
+            ...     print("Processing:", task)
+            >>> async_queue = AsyncQueue()
+            >>> asyncio.run(async_queue.enqueue('Task 1'))
+            >>> asyncio.run(async_queue.process_requests(sample_processing))
+            Processing: Task 1
+        """
+        while not self.stopped():
+            item = await self.dequeue()
+            if item is None:  # Using `None` as a sentinel value to cease processing.
+                await self.stop()
+                break
+            await func(item)