lionagi 0.0.112__py3-none-any.whl → 0.0.113__py3-none-any.whl

lionagi/objs/messenger.py

@@ -0,0 +1,163 @@
+# 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
+
+
+# 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.
+    
+#     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.
+        
+#         to_csv: Exports logged messages to a CSV file.
+        
+#         _create_message: Internal method to create a specific type of message.
+        
+#         create_message: Public interface to create messages, log them, and optionally return them in different formats.
+#     """
+    
+#     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 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 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)
+        
+#     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.
+            
+#             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
+    
+#     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.
+#         """
+        
+#         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()
+    

lionagi/objs/tool_registry.py

@@ -0,0 +1,247 @@
+import json
+import asyncio
+from typing import Dict
+from ..utils import lcall, str_to_num
+from ..schema import BaseNode
+
+
+class ToolManager(BaseNode):
+    registry : Dict = {}
+
+    def _name_existed(self, name: str):
+        return True if name in self.registry.keys() else False
+            
+    def _register_tool(self, tool, name: str=None, update=False, new=False, prefix=None, postfix=None):
+        
+        if self._name_existed(name):
+            if update and new:
+                raise ValueError(f"Cannot both update and create new registry for existing function {name} at the same time")
+
+            if len(name) > len(tool.func.__name__):
+                if new and not postfix: 
+                    try:
+                        idx = str_to_num(name[-3:], int)
+                        if idx > 0: 
+                            postfix = idx + 1
+                    except:
+                        pass
+
+        name = f"{prefix or ''}{name}{postfix}" if new else tool.func.__name__                
+        self.registry.update({name:tool})
+                
+    async def invoke(self, func_call):
+        name, kwargs = func_call
+        if self._name_existed(name):
+            tool = self.registry[name]
+            func = tool.func
+            parser = tool.parser
+            try:
+                if asyncio.iscoroutinefunction(func):
+                    return await parser(func(**kwargs)) if parser else func(**kwargs)
+                else:
+                    return parser(func(**kwargs)) if parser else func(**kwargs)
+            except Exception as e:
+                raise ValueError(f"Error when invoking function {name} with arguments {kwargs} with error message {e}")
+        else: 
+            raise ValueError(f"Function {name} is not registered.")
+    
+    @staticmethod
+    def _get_function_call(response):
+        """
+        Extract function name and arguments from a response JSON.
+
+        Parameters:
+            response (dict): The JSON response containing function information.
+
+        Returns:
+            Tuple[str, dict]: The function name and its arguments.
+        """
+        try: 
+            # out = json.loads(response)
+            func = response['function'][5:]
+            args = json.loads(response['arguments'])
+            return (func, args)
+        except:
+            try:
+                # out = json.loads(response)
+                # out = out['tool_uses'][0]
+                func = response['recipient_name'].split('.')[-1]
+                args = response['parameters']
+                return (func, args)
+            except:
+                raise ValueError('response is not a valid function call')
+    
+    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)
+        
+
+
+# import asyncio
+# import json
+# from typing import Dict, Any, Optional, List, Tuple
+
+# from lionagi.schema.base_tool import Tool
+# from lionagi.utils.type_util import to_list
+# from lionagi.utils.tool_util import func_to_tool
+
+# class ToolRegistry:
+#     """
+#     ToolManager manages the registration and invocation of tools.
+
+#     This class provides functionalities to register tools, check for their existence,
+#     and invoke them dynamically with specified arguments.
+
+#     Attributes:
+#         registry (Dict[str, BaseTool]): A dictionary to store registered tools by name.
+    
+#     Methods:
+#         _name_exists: Checks if a tool name already exists in the registry.
+        
+#         _register_tool: Registers a tool in the registry.
+        
+#         invoke: Dynamically invokes a registered tool with given arguments.
+        
+#         register_tools: Registers multiple tools in the registry.
+#     """    
+    
+#     def __init__(self):
+#         """
+#         Initializes the ToolManager with an empty registry.
+#         """        
+#         self.registry: Dict[str, Tool] = {}
+
+#     def _name_exists(self, name: str) -> bool:
+#         """
+#         Checks if a tool name already exists in the registry.
+
+#         Parameters:
+#             name (str): The name of the tool to check.
+
+#         Returns:
+#             bool: True if the name exists in the registry, False otherwise.
+#         """
+#         return name in self.registry
+
+#     def _register_tool(self, tool: Tool, name: Optional[str] = None, update: bool = False, new: bool = False, prefix: Optional[str] = None, postfix: Optional[int] = None):
+#         """
+#         Registers a tool in the registry.
+
+#         Parameters:
+#             tool (BaseTool): The tool to be registered.
+            
+#             name (Optional[str]): The name to register the tool with. Defaults to the tool's function name.
+            
+#             update (bool): If True, updates the existing tool. Defaults to False.
+            
+#             new (bool): If True, creates a new registry entry. Defaults to False.
+            
+#             prefix (Optional[str]): A prefix for the tool name.
+            
+#             postfix (Optional[int]): A postfix for the tool name.
+
+#         Raises:
+#             ValueError: If both update and new are True for an existing function.
+#         """
+#         name = name or tool.func.__name__
+#         original_name = name
+
+#         if self._name_exists(name):
+#             if update and new:
+#                 raise ValueError("Cannot both update and create new registry for existing function.")
+#             if new:
+#                 idx = 1
+#                 while self._name_exists(f"{prefix or ''}{name}{postfix or ''}{idx}"):
+#                     idx += 1
+#                 name = f"{prefix or ''}{name}{postfix or ''}{idx}"
+#             else:
+#                 self.registry.pop(original_name, None)
+
+#         self.registry[name] = tool
+
+#     async def invoke(self, name_kwargs: Tuple) -> Any:
+#         """
+#         Dynamically invokes a registered tool with given arguments.
+
+#         Parameters:
+#             name (str): The name of the tool to invoke.
+            
+#             kwargs (Dict[str, Any]): A dictionary of keyword arguments to pass to the tool.
+
+#         Returns:
+#             Any: The result of the tool invocation.
+
+#         Raises:
+#             ValueError: If the tool is not registered or if an error occurs during invocation.
+#         """
+#         name, kwargs = name_kwargs
+#         if not self._name_exists(name):
+#             raise ValueError(f"Function {name} is not registered.")
+
+#         tool = self.registry[name]
+#         func = tool.func
+#         parser = tool.parser
+
+#         try:
+#             result = await func(**kwargs) if asyncio.iscoroutinefunction(func) else func(**kwargs)
+#             return await parser(result) if parser and asyncio.iscoroutinefunction(parser) else parser(result) if parser else result
+#         except Exception as e:
+#             raise ValueError(f"Error invoking function {name}: {str(e)}")
+
+#     def register_tools(self, tools: List[Tool], update: bool = False, new: bool = False,
+#                        prefix: Optional[str] = None, postfix: Optional[int] = None):
+#         """
+#         Registers multiple tools in the registry.
+
+#         Parameters:
+#             tools (List[BaseTool]): A list of tools to register.
+            
+#             update (bool): If True, updates existing tools. Defaults to False.
+            
+#             new (bool): If True, creates new registry entries. Defaults to False.
+            
+#             prefix (Optional[str]): A prefix for the tool names.
+            
+#             postfix (Optional[int]): A postfix for the tool names.
+#         """        
+#         for tool in tools:
+#             self._register_tool(tool, update=update, new=new, prefix=prefix, postfix=postfix)
+
+#     def _register_func(self, func_, parser=None, **kwargs):
+#         # kwargs for _register_tool
+        
+#         tool = func_to_tool(func_=func_, parser=parser)
+#         self._register_tool(tool=tool, **kwargs)
+    
+#     def register_funcs(self, funcs, parsers=None, **kwargs):
+#         funcs, parsers = to_list(funcs), to_list(parsers)
+#         if parsers is not None and len(parsers) != len(funcs):
+#             raise ValueError("The number of funcs and tools should be the same")
+#         parsers = parsers or [None for _ in range(len(funcs))]
+        
+#         for i, func in enumerate(funcs):
+#             self._register_func(func_=func, parser=parsers[i], **kwargs)
+            
+#     @staticmethod
+#     def get_function_call(response):
+#         """
+#         Extract function name and arguments from a response JSON.
+
+#         Parameters:
+#             response (dict): The JSON response containing function information.
+
+#         Returns:
+#             Tuple[str, dict]: The function name and its arguments.
+#         """
+#         try: 
+#             # out = json.loads(response)
+#             func = response['function'][5:]
+#             args = json.loads(response['arguments'])
+#             return (func, args)
+#         except:
+#             try:
+#                 func = response['recipient_name'].split('.')[-1]
+#                 args = response['parameters']
+#                 return (func, args)
+#             except:
+#                 raise ValueError('response is not a valid function call')
+            

lionagi/schema/__init__.py

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

lionagi/schema/base_schema.py

@@ -0,0 +1,239 @@
+import json
+from typing import Any, Dict, Optional, TypeVar, Type, List, Callable, Union
+from pydantic import BaseModel, Field, AliasChoices
+
+from ..utils.sys_util import create_id
+
+T = TypeVar('T', bound='BaseNode')
+
+
+class BaseNode(BaseModel):
+    """
+    BaseNode: A foundational building block for representing a node in a graph-like structure.
+
+    Attributes:
+        id_ (str): Unique identifier for the node, aliased as 'node_id'.
+        content (Optional[Any]): Content or value the node represents.
+        metadata (Dict[str, Any]): A dictionary of metadata related to the node.
+        label (Optional[str]): A label for categorizing or identifying the node.
+        related_nodes (List[str]): A list of identifiers for nodes related to this node.
+    """
+    id_: str = Field(default_factory=lambda: str(create_id()), alias="node_id")
+    content: Union[str, Dict[str, Any], None, Any] = Field(default=None,
+                                                           validation_alias=AliasChoices('text', 'page_content', 'chunk_content'))
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    label: Optional[str] = None
+    related_nodes: List[str] = Field(default_factory=list)
+
+    class Config:
+        extra = 'allow'
+        populate_by_name = True
+        validate_assignment = True
+        str_strip_whitespace = True
+
+    def to_json(self) -> str:
+        """Converts the node instance into JSON string representation."""
+        return self.model_dump_json(by_alias=True)
+
+    @classmethod
+    def from_json(cls: Type[T], json_str: str, **kwargs) -> T:
+        """
+        Creates a node instance from a JSON string.
+
+        Args:
+            json_str (str): The JSON string representing a node.
+            **kwargs: Additional keyword arguments to pass to json.loads.
+
+        Returns:
+            An instance of BaseNode.
+
+        Raises:
+            ValueError: If the provided string is not valid JSON.
+        """
+        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
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts the node instance into a dictionary representation."""
+        return self.model_dump(by_alias=True)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> T:
+        """Creates a node instance from a dictionary."""
+        return cls(**data)
+
+    def copy(self, deep: bool = True, n: int = 1) -> T:
+        """
+        Creates a copy of the node instance.
+
+        Args:
+            deep (bool): Whether to make a deep copy.
+            n (int): Number of copies to create.
+
+        Returns:
+            A copy or list of copies of the BaseNode instance.
+        """
+        copies = [self.copy(deep=deep) for _ in range(n)]
+        return copies[0] if n == 1 else copies
+
+    def merge_metadata(self, other_metadata: Dict[str, Any], overwrite: bool = True) -> None:
+        """
+        Merges another metadata dictionary into the node's metadata.
+
+        Args:
+            other_metadata (Dict[str, Any]): The metadata to merge in.
+            overwrite (bool): Whether to overwrite existing keys in the 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 set_meta(self, metadata_: Dict[str, Any]) -> None:
+        self.metadata = metadata_
+
+    def get_meta(self) -> Dict[str, Any]:
+        return self.metadata
+
+    def set_content(self, content: Optional[Any]) -> None:
+        self.content = content
+
+    def get_content(self) -> Optional[Any]:
+        return self.content
+
+    def set_id(self, id_: str) -> None:
+        self.id_ = id_
+
+    def get_id(self) -> str:
+        return self.id_
+
+    def update_meta(self, **kwargs) -> None:
+        self.metadata.update(kwargs)
+
+    def add_related_node(self, node_id: str) -> None:
+        if node_id not in self.related_nodes:
+            self.related_nodes.append(node_id)
+
+    def remove_related_node(self, node_id: str) -> None:
+        self.related_nodes = [id_ for id_ in self.related_nodes if id_ != node_id]
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, T):
+            return NotImplemented
+        return self.model_dump() == other.model_dump()
+
+    # def __str__(self) -> str:
+    #     """Returns a simple string representation of the BaseNode."""
+    #     return f"BaseNode(id={self.id_}, label={self.label})"
+
+    # def __repr__(self) -> str:
+    #     """Returns a detailed string representation of the BaseNode."""
+    #     return f"BaseNode(id={self.id_}, content={self.content}, metadata={self.metadata}, label={self.label})"
+    
+    # Utility Methods
+    def is_empty(self) -> bool:
+        return not self.content and not self.metadata
+
+    def has_label(self, label: str) -> bool:
+        return self.label == label
+
+    def is_metadata_key_present(self, key: str) -> bool:
+        return key in self.metadata
+
+
+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)
+
+    # def __repr__(self) -> str:
+    #     return f"DataNode(id={self.id_}, content={self.content}, metadata={self.metadata}, label={self.label})"
+
+    # def __str__(self) -> str:
+    #     return f"DataNode(id={self.id_}, label={self.label})"
+
+
+class File(DataNode):
+
+    ...
+    
+
+class Chunk(DataNode):
+
+    ...    
+
+    
+class Message(BaseNode):
+    """
+    Message: A specialized type of BaseNode for handling messages.
+
+    This class represents a message node, extending the BaseNode with additional
+    attributes specific to messages, such as role and name, and provides methods
+    for message-specific operations.
+
+    Attributes:
+        role (Optional[str]): The role of the message, e.g., 'sender', 'receiver'.
+        name (Optional[str]): The name associated with the message, e.g., a user name or system name.
+    """
+    
+    role: Optional[str] = None
+    name: Optional[str] = None
+    
+    def _to_message(self):
+        """
+        Converts the message node to a dictionary representation suitable for messaging purposes.
+
+        The method serializes the content attribute to a JSON string if it is a dictionary.
+        Otherwise, it keeps the content as is.
+
+        Returns:
+            A dictionary representing the message 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_role_message(self, role_: str, 
+                             content: Any, 
+                             content_key: str, 
+                             name: Optional[str] = None
+                             ) -> None:
+        """
+        Creates a message with a specific role, content, and an optional name.
+
+        This method sets up the message node with the specified role, content, and name. The content
+        is stored in a dictionary under the provided content_key.
+
+        Args:
+            role_ (str): The role of the message.
+            content (Any): The content of the message.
+            content_key (str): The key under which the content will be 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_
+        

lionagi/schema/base_tool.py

@@ -0,0 +1,9 @@
+from typing import Any
+from .base_schema import BaseNode
+
+class Tool(BaseNode):
+    name: str = None
+    func: Any = None
+    content: Any = None
+    parser: Any = None
+    schema_: Any = None