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

lionagi/objs/messenger.py

@@ -1,163 +1,85 @@
-# from typing import Optional, Any, Union, Dict, Tuple
+from collections import deque
+from typing import Optional, Any, Union, Dict, Tuple
 
-# from lionagi.utils.call_util import lcall
-# from lionagi.schema.data_logger import DataLogger
-# from lionagi.core.messages import Message, Response, Instruction, System
+from lionagi.utils.call_util import lcall
+from lionagi.schema.data_logger import DataLogger
+from lionagi.messages import Message, Response, Instruction, System
 
 
-# class Messenger:
-#     """
-#     Messenger handles the creation, logging, and exporting of messages.
-
-#     This class is responsible for creating various types of messages (system, instruction, response),
-#     logging them, and optionally exporting the log to a CSV file.
-
-#     Attributes:
-#         _logger (DataLogger): An instance of DataLogger to manage message logging.
+class Messenger:
     
-#     Methods:
-#         set_dir: Sets the directory for the DataLogger to save CSV files.
-        
-#         set_log: Sets the log object for the DataLogger.
-        
-#         log_message: Logs a message in JSON format.
+    def __init__(self) -> None:
+        self._logger = DataLogger()
         
-#         to_csv: Exports logged messages to a CSV file.
+    def set_dir(self, dir: str) -> None:
+        self._logger.dir = dir
+    
+    def set_log(self, log) -> None:
+        self._logger.log = log
         
-#         _create_message: Internal method to create a specific type of message.
+    def log_message(self, msg: Message) -> None:
+        self._logger(msg.to_json())
         
-#         create_message: Public interface to create messages, log them, and optionally return them in different formats.
-#     """
+    def to_csv(self, **kwargs) -> None:
+        self._logger.to_csv(**kwargs)
     
-#     def __init__(self) -> None:
-#         """
-#         Initializes the Messenger with a DataLogger instance.
-#         """
-#         self._logger = DataLogger()
-        
-#     def set_dir(self, dir: str) -> None:
-#         """
-#         Sets the directory where the DataLogger will save CSV files.
-
-#         Parameters:
-#             dir (str): The directory path to set for the DataLogger.
-#         """
-#         self._logger.dir = dir
+    def clear_log(self):
+        self._logger.log = deque()
     
-#     def set_log(self, log) -> None:
-#         """
-#         Sets the log object for the DataLogger.
-
-#         Parameters:
-#             log: The log object to be used by the DataLogger.
-#         """
-#         self._logger.log = log
+    def _create_message(
+        self, 
+        system: Optional[Any] = None, 
+        instruction: Optional[Any] = None, 
+        context: Optional[Any] = None, 
+        response: Optional[Any] = None, 
+        name: Optional[str] = None
+        ) -> Message:
         
-#     def log_message(self, msg: Message) -> None:
-#         """
-#         Logs a message in JSON format using the DataLogger.
-
-#         Parameters:
-#             msg (Message): The message object to be logged.
-#         """
-#         self._logger(msg.to_json())
-        
-#     def to_csv(self, **kwargs) -> None:
-#         """
-#         Exports the logged messages to a CSV file.
-
-#         Parameters:
-#             **kwargs: Additional keyword arguments to be passed to the DataLogger's to_csv method.
-#         """
-#         self._logger.to_csv(**kwargs)
+        if sum(lcall([system, instruction, response], bool)) != 1:
+            raise ValueError("Error: Message must have one and only one role.")
         
-#     def _create_message(self, 
-#                         system: Optional[Any] = None, 
-#                         instruction: Optional[Any] = None, 
-#                         context: Optional[Any] = None, 
-#                         response: Optional[Any] = None, 
-#                         name: Optional[str] = None) -> Message:
-#         """
-#         Creates a specific type of message based on the provided parameters.
-
-#         Parameters:
-#             system (Optional[Any]): System message content.
-            
-#             instruction (Optional[Any]): Instruction message content.
-            
-#             context (Optional[Any]): Context for the instruction message.
-            
-#             response (Optional[Any]): Response message content.
+        else:
+            msg = 0
             
-#             name (Optional[str]): Name associated with the message.
-
-#         Returns:
-#             Message: The created message object of type Response, Instruction, or System.
-
-#         Raises:
-#             ValueError: If more than one or none of the message content parameters (system, instruction, response) are provided.
-#         """
-        
-#         if sum(lcall([system, instruction, response], bool)) != 1:
-#             raise ValueError("Error: Message must have one and only one role.")
-        
-#         else:
-#             msg = 0
-            
-#             if response:
-#                 msg = Response()
-#                 msg.create_message(response=response, 
-#                                    name=name,)
-#             elif instruction:
-#                 msg = Instruction()
-#                 msg.create_message(instruction=instruction, 
-#                                    context=context, 
-#                                    name=name,)
-#             elif system:
-#                 msg = System()
-#                 msg.create_message(system=system,
-#                                    name=name,)
-#             return msg
+            if response:
+                msg = Response()
+                msg._create_message(
+                    response=response, name=name,
+                    )
+            elif instruction:
+                msg = Instruction()
+                msg._create_message(
+                    instruction=instruction, context=context, 
+                    name=name,
+                    )
+            elif system:
+                msg = System()
+                msg._create_message(
+                    system=system, name=name,
+                    )
+            return msg
     
-#     def create_message(self, 
-#                        system: Optional[Any] = None, 
-#                        instruction: Optional[Any] = None, 
-#                        context: Optional[Any] = None, 
-#                        response: Optional[Any] = None, 
-#                        name: Optional[str] = None,
-#                        obj: bool = False,
-#                        log_: bool = True) -> Union[Message, Tuple[Message, Dict]]:
-#         """
-#         Creates and optionally logs a message, returning it in different formats based on parameters.
-
-#         Parameters:
-#             system (Optional[Any]): System message content.
-            
-#             instruction (Optional[Any]): Instruction message content.
-            
-#             context (Optional[Any]): Context for the instruction message.
-            
-#             response (Optional[Any]): Response message content.
-            
-#             name (Optional[str]): Name associated with the message.
-            
-#             obj (bool): If True, returns the Message object and its dictionary representation. Defaults to False.
-            
-#             log_ (bool): If True, logs the created message. Defaults to True.
-
-#         Returns:
-#             Union[Message, Tuple[Message, Dict]]: The created message in the specified format.
-#         """
+    def create_message(
+        self, 
+        system: Optional[Any] = None, 
+        instruction: Optional[Any] = None, 
+        context: Optional[Any] = None, 
+        response: Optional[Any] = None, 
+        name: Optional[str] = None, 
+        obj: bool = True, 
+        log_: bool = True
+        ) -> Union[Message, Tuple[Message, Dict]]:
+        
+        msg = self._create_message(
+            system=system, 
+            instruction=instruction, 
+            context=context, 
+            response=response, 
+            name=name
+            )
         
-#         msg = self._create_message(system=system, 
-#                                   instruction=instruction, 
-#                                   context=context, 
-#                                   response=response, 
-#                                   name=name)
-#         if log_:
-#             self.log_message(msg)
-#         if obj:
-#             return (msg, msg._to_message())
-#         else:
-#             return msg._to_message()
+        if log_:
+            self.log_message(msg)
+        if obj:
+            return msg
     

lionagi/objs/status_tracker.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+
+
+# credit to OpenAI for the following object
+@dataclass
+class StatusTracker:
+    """
+    Class for keeping track of various task statuses.
+    
+    This class serves as a simple way to monitor different types of task
+    outcomes and errors within a system. It uses dataclasses for easy
+    creation and management of state.
+    
+    Attributes:
+        num_tasks_started:
+            The number of tasks that have been initiated.
+        num_tasks_in_progress:
+            The number of tasks currently being processed.
+        num_tasks_succeeded:
+            The number of tasks that have completed successfully.
+        num_tasks_failed:
+            The number of tasks that have failed.
+        num_rate_limit_errors:
+            The number of tasks that failed due to rate limiting.
+        num_api_errors:
+            The number of tasks that failed due to API errors.
+        num_other_errors:
+            The number of tasks that failed due to other errors.
+    """
+    num_tasks_started: int = 0
+    num_tasks_in_progress: int = 0
+    num_tasks_succeeded: int = 0
+    num_tasks_failed: int = 0
+    num_rate_limit_errors: int = 0
+    num_api_errors: int = 0
+    num_other_errors: int = 0
+    

lionagi/objs/{tool_registry.py → tool_manager.py}

@@ -1,14 +1,14 @@
 import json
 import asyncio
 from typing import Dict
-from ..utils import lcall, str_to_num
-from ..schema import BaseNode
+from lionagi.utils import lcall
+from lionagi.schema import BaseNode, Tool
 
 
 class ToolManager(BaseNode):
     registry: Dict = {}
 
-    def _name_existed(self, name: str):
+    def name_existed(self, name: str):
         return True if name in self.registry.keys() else False
             
     def _register_tool(self, tool): #,update=False, new=False, prefix=None, postfix=None):
@@ -28,12 +28,14 @@ class ToolManager(BaseNode):
 
         # name = f"{prefix or ''}{name}{postfix}" if new else tool.func.__name__
 
+        if not isinstance(tool, Tool):
+            raise TypeError('Please register a Tool object.')
         name = tool.schema_['function']['name']
         self.registry.update({name: tool})
                 
     async def invoke(self, func_call):
         name, kwargs = func_call
-        if self._name_existed(name):
+        if self.name_existed(name):
             tool = self.registry[name]
             func = tool.func
             parser = tool.parser
@@ -48,7 +50,7 @@ class ToolManager(BaseNode):
             raise ValueError(f"Function {name} is not registered.")
     
     @staticmethod
-    def _get_function_call(response):
+    def get_function_call(response):
         """
         Extract function name and arguments from a response JSON.
 
@@ -73,7 +75,7 @@ class ToolManager(BaseNode):
     def register_tools(self, tools): #, update=False, new=False, prefix=None, postfix=None ):
         lcall(tools, self._register_tool) #, update=update, new=new, prefix=prefix, postfix=postfix)
 
-    def to_tool_schema(self):
+    def to_tool_schema_list(self):
         schema_list = []
         for tool in self.registry.values():
             schema_list.append(tool.schema_)

lionagi/schema/__init__.py

@@ -1,11 +1,11 @@
-from .base_schema import BaseNode, DataNode, Message
+from .base_node import BaseNode
 from .base_tool import Tool
 from .data_logger import DataLogger
+from .data_node import DataNode
 
 __all__ = [
     "BaseNode", 
     "DataNode", 
-    "Message",
     "Tool", 
-    "DataLogger"
+    "DataLogger", 
 ]

lionagi/schema/base_node.py

@@ -0,0 +1,251 @@
+# uses utils
+import json
+import xml.etree.ElementTree as ET
+from typing import Any, Dict, Optional, TypeVar, Type, List, Callable, Union
+from pydantic import BaseModel, Field, AliasChoices
+
+from lionagi.utils import (
+    create_id, is_schema, change_dict_key, create_copy, 
+    encrypt, decrypt, dict_to_xml
+)
+
+T = TypeVar('T', bound='BaseNode')
+
+
+class BaseNode(BaseModel):
+    """
+    A foundational building block for representing a node in a graph-like structure.
+    This class includes functionalities for serialization, metadata manipulation,
+    content encryption/decryption, and utility methods.
+
+    Attributes:
+        id_ (str): Unique identifier for the node, aliased as 'node_id'.
+        metadata (Dict[str, Any]): Dictionary of metadata related to the node.
+        label (Optional[str]): Label categorizing or identifying the node.
+        related_nodes (List[str]): Identifiers for nodes related to this node.
+        content (Union[str, Dict[str, Any], None, Any]): Content of the node.
+    """
+    id_: str = Field(default_factory=lambda: str(create_id()), alias="node_id")
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    label: Optional[str] = None
+    related_nodes: List[str] = Field(default_factory=list)
+    content: Union[str, Dict[str, Any], None, Any] = Field(
+        default=None, validation_alias=AliasChoices('text', 'page_content', 'chunk_content')
+    )
+    
+    class Config:
+        extra = 'allow'
+        populate_by_name = True
+        validate_assignment = True
+        str_strip_whitespace = True
+
+    # from-to [json, dict, xml]
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> T:
+        """Creates a BaseNode instance from a dictionary."""
+        return cls(**data)
+
+    @classmethod
+    def from_json(cls: Type[T], json_str: str, **kwargs) -> T:
+        """Creates a BaseNode instance from a JSON string."""
+        try:
+            data = json.loads(json_str, **kwargs)
+            return cls(**data)
+        except json.JSONDecodeError as e:
+            raise ValueError("Invalid JSON string provided for deserialization.") from e
+
+    @classmethod
+    def from_xml(cls, xml_str: str) -> T:
+        """Creates a BaseNode instance from an XML string."""
+        root = ET.fromstring(xml_str)
+        data = cls._xml_to_dict(root)
+        return cls(**data)
+
+    def to_json(self) -> str:
+        """Converts the BaseNode instance into a JSON string."""
+        return self.model_dump_json(by_alias=True)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts the BaseNode instance into a dictionary."""
+        return self.model_dump(by_alias=True)
+    
+    def to_xml(self) -> str:
+        """Converts the BaseNode instance into an XML string."""
+        return dict_to_xml(self.to_dict())
+    
+    # Metadata manipulation methods
+    def set_meta(self, metadata_: Dict[str, Any]) -> None:
+        """Sets the metadata for the node."""
+        self.metadata = metadata_
+        
+    def get_meta_key(self, key: str) -> Any:
+        """Retrieves a specific metadata value by key."""
+        return self.metadata.get(key)
+
+    def change_meta_key(self, old_key: str, new_key: str) -> None:
+        """Changes a metadata key from old_key to new_key."""
+        change_dict_key(self.metadata,old_key=old_key, new_key=new_key)
+
+    def delete_meta_key(self, key: str) -> None:
+        """Deletes a metadata key from the node."""
+        if key in self.metadata:
+            del self.metadata[key]
+            
+    def merge_metadata(self, other_metadata: Dict[str, Any], overwrite: bool = True) -> None:
+        """Merges another metadata dictionary into the node's metadata."""
+        if not overwrite:
+            other_metadata = ({
+                k: v for k, v in other_metadata.items() 
+                if k not in self.metadata
+            })
+        self.metadata.update(other_metadata)
+
+    def clear_metadata(self) -> None:
+        """Clears all metadata from the node."""
+        self.metadata.clear()
+
+    @property
+    def meta_keys(self) -> List[str]:
+        """Returns a list of all metadata keys."""
+        return list(self.metadata.keys())
+
+    def has_meta_key(self, key: str) -> bool:
+        """Checks if a specific metadata key exists."""
+        return key in self.metadata
+
+    def filter_meta(self, filter_func: Callable[[Any], bool]) -> Dict[str, Any]:
+        """Filters metadata based on a provided function."""
+        return {k: v for k, v in self.metadata.items() if filter_func(v)}
+
+    def apply_to_meta(self, apply_func: Callable[[Any], Any]) -> None:
+        """Applies a function to each metadata value."""
+        for key in self.metadata:
+            self.metadata[key] = apply_func(self.metadata[key])
+        
+    def meta_schema_is_valid(self, schema: Dict[str, type]) -> bool:
+        """Checks if the metadata matches a given schema."""
+        return is_schema(dict_=self.metadata, schema=schema)
+
+    def update_meta(self, **kwargs) -> None:
+        """Updates metadata with the provided key-value pairs."""
+        self.metadata.update(kwargs)
+
+    # Encryption methods
+    def encrypt_content(self, key: str) -> None:
+        """Encrypts the content of the node."""
+        self.content = encrypt(self.content, key)
+
+    def decrypt_content(self, key: str) -> None:
+        """Decrypts the content of the node."""
+        self.content = decrypt(self.content, key)
+        
+    # Getters and setters
+    def set_content(self, content: Optional[Any]) -> None:
+        """Sets the content of the node."""
+        self.content = content
+
+    def get_content(self) -> Optional[Any]:
+        """Retrieves the content of the node."""
+        return self.content
+
+    def set_id(self, id_: str) -> None:
+        """Sets the ID of the node."""
+        self.id_ = id_
+
+    def get_id(self) -> str:
+        """Retrieves the ID of the node."""
+        return self.id_
+
+    def add_related_node(self, node_id: str) -> None:
+        """Adds a related node ID."""
+        if node_id not in self.related_nodes:
+            self.related_nodes.append(node_id)
+
+    def remove_related_node(self, node_id: str) -> None:
+        """Removes a related node ID."""
+        self.related_nodes = [id_ for id_ in self.related_nodes if id_ != node_id]
+
+    # Utility methods
+    def is_empty(self) -> bool:
+        """Checks if the node is empty (no content and metadata)."""
+        return not self.content and not self.metadata
+
+    def has_label(self, label: str) -> bool:
+        """Checks if the node has a specific label."""
+        return self.label == label
+
+    def is_metadata_key_present(self, key: str) -> bool:
+        """Checks if a specific key is present in the metadata."""
+        return key in self.metadata
+
+    def copy(self, n: int = 1) -> Union[List[T], T]:
+        """
+        Creates one or multiple deep copies of the node.
+
+        Parameters:
+            n (int): Number of copies to create.
+
+        Returns:
+            Union[List[T], T]: A copy or list of copies of the node.
+        """
+        return create_copy(self, n)
+
+    def data_equals(self, other: 'BaseNode') -> bool:
+        """
+        Checks if the node's data equals another node's data.
+
+        Parameters:
+            other (BaseNode): Another node to compare with.
+
+        Returns:
+            bool: True if data is equal, False otherwise.
+        """
+        return (
+            self.content == other.content and
+            self.metadata == other.metadata and
+            self.related_nodes == other.related_nodes
+        )
+
+    def is_copy_of(self, other: 'BaseNode') -> bool:
+        """
+        Checks if the node is a copy of another node.
+
+        Parameters:
+            other (BaseNode): Another node to compare with.
+
+        Returns:
+            bool: True if it is a copy, False otherwise.
+        """
+        return (
+            self.data_equals(other) and
+            self is not other
+        )
+
+    def __eq__(self, other: 'BaseNode') -> bool:
+        """
+        Overrides the equality operator to compare nodes.
+
+        Parameters:
+            other (BaseNode): Another node to compare with.
+
+        Returns:
+            bool: True if nodes are equal, False otherwise.
+        """
+        return (self.id_ == other.id_ and self.data_equals(other))
+
+    def __str__(self) -> str:
+        """
+        Returns a user-friendly string representation of the BaseNode.
+
+        Returns:
+            str: A string representation of the BaseNode.
+        """
+        content_preview = (str(self.content)[:75] + '...') if len(str(self.content)) > 75 else str(self.content)
+        return f"{self.__class__.__name__}(id={self.id_}, label={self.label}, content='{content_preview}')"
+
+    def __repr__(self):
+        """
+        Official string representation of Message object.
+        Utilizes the json representation of the object for clarity.
+        """
+        return f"{self.__class__.__name__}({self.to_json()})"

lionagi/schema/base_tool.py

@@ -1,9 +1,14 @@
 from typing import Any
-from .base_schema import BaseNode
+from pydantic import field_serializer
+from .base_node import BaseNode
 
 class Tool(BaseNode):
-    name: str = None
+    # name: str = None
     func: Any
     content: Any = None
     parser: Any = None
-    schema_: Any
+    schema_: dict
+
+    @field_serializer('func')
+    def serialize_func(self, func):
+        return func.__name__

lionagi/schema/data_logger.py

@@ -1,7 +1,6 @@
 from collections import deque
-from typing import List, Optional
-from ..utils.sys_util import create_path
-from ..utils.io_util import to_csv
+from typing import Optional
+from lionagi.utils import create_path, to_csv
 
 
 class DataLogger:

lionagi/schema/data_node.py

@@ -0,0 +1,37 @@
+from .base_node import BaseNode
+from typing import Any
+
+
+class DataNode(BaseNode):
+
+    def to_llama_index(self, **kwargs):
+        # to llama_index textnode
+        from lionagi.bridge.llama_index import to_llama_index_textnode
+        return to_llama_index_textnode(self, **kwargs)
+
+    def to_langchain(self, **kwargs):
+        # to langchain document
+        from lionagi.bridge.langchain import to_langchain_document
+        return to_langchain_document(self, **kwargs)
+
+    @classmethod
+    def from_llama_index(cls, llama_node: Any, **kwargs):
+        llama_dict = llama_node.to_dict(**kwargs)
+        return cls.from_dict(llama_dict)
+
+    @classmethod
+    def from_langchain(cls, lc_doc: Any):
+        info_json = lc_doc.to_json()
+        info_node = {'lc_id': info_json['id']}
+        info_node = {**info_node, **info_json['kwargs']}
+        return cls(**info_node)
+
+
+class File(DataNode):
+
+    ...
+    
+
+class Chunk(DataNode):
+
+    ...    

lionagi/services/__init__.py

@@ -1,14 +1,11 @@
-from .chatcompletion import ChatCompletion
 from .base_api_service import BaseAPIService, BaseAPIRateLimiter
 from .oai import OpenAIService
 from .openrouter import OpenRouterService
 
 
-
 __all__ = [
     "BaseAPIService",
+    "BaseAPIRateLimiter",
     "OpenAIService",
     "OpenRouterService",
-    "ChatCompletion", 
-    "BaseAPIRateLimiter"
 ]