lionagi 0.0.115__py3-none-any.whl → 0.0.204__py3-none-any.whl

lionagi/loaders/reader.py

@@ -1,25 +1,28 @@
-# use utils, schema, and bridge
 from typing import Union, Callable
 
-from lionagi.utils import lcall
-from lionagi.bridge import langchain_loader, from_langchain, llama_index_reader, from_llama_index
+from ..utils import lcall
+from ..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):
     """
-    Parses a list of nodes using the given parser function.
-    
-    Parameters:
-        nodes (List[Any]): The list of nodes to be parsed.
-        
-        parser (Callable): The parser function to transform nodes into DataNode instances.
-    
+    Parses raw data into DataNode instances using the provided parser function.
+
+    Args:
+        nodes: The list of raw data to be parsed.
+        parser: The parser function to transform nodes into DataNode instances.
+
     Returns:
-        List[Any]: A list of parsed nodes.
-    
+        A list of parsed DataNode instances.
+
     Raises:
         ValueError: If the parser function fails.
+
+    Example usage:
+        >>> raw_nodes = [{'content': 'Example content'}]
+        >>> parser = lambda x: [DataNode(**node) for node in x]
+        >>> datanodes = _datanode_parser(raw_nodes, parser)
     """
     try:
         nodes = parser(nodes)
@@ -27,18 +30,21 @@ def _datanode_parser(nodes, parser):
         raise ValueError(f'DataNode parser {parser} failed. Error:{e}')
     return nodes
 
-
 def text_reader(args, kwargs):
     """
     Reads text files from a directory and converts them to DataNode instances.
-    
-    Parameters:
-        args (List[Any]): Positional arguments for the dir_to_nodes function.
-        
-        kwargs (dict): Keyword arguments for the dir_to_nodes function.
-    
+
+    Args:
+        args: Positional arguments for the dir_to_nodes function.
+        kwargs: Keyword arguments for the dir_to_nodes function.
+
     Returns:
-        List[Any]: A list of DataNode instances.
+        A list of DataNode instances.
+
+    Example usage:
+        >>> args = ['path/to/text/files']
+        >>> kwargs = {'file_extension': 'txt'}
+        >>> nodes = text_reader(args, kwargs)
     """
     return dir_to_nodes(*args, **kwargs)
 
@@ -52,28 +58,28 @@ def load(reader: Union[str, Callable],
          to_datanode: Union[bool, Callable] = True):
     """
     Loads documents using the specified reader and reader type.
-    
-    Parameters:
-        reader (Union[str, Callable]): The reader function or its name as a string.
-        
-        reader_type (ReaderType): The type of the reader. Defaults to ReaderType.PLAIN.
-        
-        reader_args (List[Any]): Positional arguments for the reader function. Defaults to an empty list.
-        
-        reader_kwargs (dict): Keyword arguments for the reader function. Defaults to an empty dict.
-        
-        load_args (List[Any]): Positional arguments for the loader function. Defaults to an empty list.
-        
-        load_kwargs (dict): Keyword arguments for the loader function. Defaults to an empty dict.
-        
-        to_datanode (Union[bool, Callable]): Determines whether to convert the result into DataNode instances, or
-        a callable to convert the result. Defaults to True.
-    
+
+    Args:
+        reader: The reader function or its name as a string.
+        reader_type: The type of the reader. Defaults to ReaderType.PLAIN.
+        reader_args: Positional arguments for the reader function. Defaults to an empty list.
+        reader_kwargs: Keyword arguments for the reader function. Defaults to an empty dict.
+        load_args: Positional arguments for the loader function. Defaults to an empty list.
+        load_kwargs: Keyword arguments for the loader function. Defaults to an empty dict.
+        to_datanode: Determines whether to convert the result into DataNode instances, or
+                     a callable to convert the result. Defaults to True.
+
     Returns:
-        List[Any]: A list of loaded and potentially parsed documents.
-    
+        A list of loaded and potentially parsed documents.
+
     Raises:
         ValueError: If the reader fails or an unsupported reader type is provided.
+
+    Example usage:
+        >>> reader = 'text_reader'
+        >>> reader_args = ['path/to/text/files']
+        >>> reader_kwargs = {'file_extension': 'txt'}
+        >>> nodes = load(reader, reader_args=reader_args, reader_kwargs=reader_kwargs)
     """
     if reader_type == ReaderType.PLAIN:
         try:

lionagi/models/imodel.py

@@ -0,0 +1,53 @@
+# from ..configs import oai_schema
+
+# class BaseIntelligentModel:
+    
+#     def __init__(
+#         self, 
+#         service=None, 
+#         default_config=oai_schema['chat']['config'], 
+#         **kwargs
+#     ) -> None:
+#     # kwargs are the individual parameters that the model can take
+#     # different for different models
+#         self.service=service, 
+#         self.config = {**default_config, **kwargs},
+
+#     async def __call__(
+#         self, 
+#         payload, 
+#         service=None, 
+#         endpoint_='chat/completions', 
+#         method='post'
+#     ):
+#         service = service or self.service
+#         return await service.serve(
+#             payload=payload, endpoint_=endpoint_, method=method
+#         )
+
+#     def set_service(self, service):
+#         self.service = service
+
+#     def set_config(self, config):
+#         self.config=config
+
+#     def change_model(self, model):
+#         self.config['model'] = model
+        
+#     def change_temperature(self, temperature):
+#         self.config['temperature'] = temperature
+    
+#     def revert_to_default_config(self):
+#         self.config = oai_schema['chat']['config']
+    
+#     def modify_config(self, **kwargs):
+#         self.config = {**self.config, **kwargs}
+    
+
+# class IModel(BaseIntelligentModel):
+    
+#     def __init__(
+#         self, service=None, default_model_kwargs=None, **kwargs
+#     ) -> None:
+#         super().__init__(service, default_model_kwargs, **kwargs)
+        

lionagi/schema/async_queue.py

@@ -0,0 +1,158 @@
+# import asyncio
+# from typing import Any, Callable
+# from ..utils.call_util import tcall
+
+# 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)
+            
+#     async def process_requests(self, func, timeout=None):
+#         """
+#         Process items with timeout management for each task.
+#         """
+#         tasks = set()
+#         while not self.stopped():
+#             if len(tasks) >= self.max_concurrent_tasks:
+#                 done, tasks = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+
+#             item = await self.dequeue()
+#             if item is None:
+#                 await self.stop()
+#                 break
+
+#             # Wrap the function call with tcall for timeout handling
+#             task = asyncio.create_task(tcall(item, func, timeout=timeout))
+#             tasks.add(task)
+
+#         if tasks:
+#             await asyncio.wait(tasks)
+