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

lionagi/core/sessions.py

@@ -1,297 +0,0 @@
-import json
-from typing import Any
-from dotenv import load_dotenv
-
-from ..schema import DataLogger
-from ..utils import lcall, alcall
-from ..services import OpenAIService, ChatCompletion
-from ..core.conversations import Conversation
-from ..objs.tool_registry import ToolManager
-from ..configs.oai_configs import oai_schema
-
-load_dotenv()
-OAIService = OpenAIService()
-
-
-class Session:
-    """
-    The Session class is responsible for managing a conversation session with a given system,
-    handling the logging of data, and invoking tools as part of the conversation.
-
-    Attributes:
-        conversation (Conversation):
-            An object to manage the conversation flow and history.
-        system (str):
-            The name of the system with which the conversation is happening.
-        llmconfig (dict):
-            Configuration for the language model.
-        logger_ (DataLogger):
-            An object for logging conversation data.
-        service (OpenAIService):
-            A service object for interacting with OpenAI APIs.
-        tool_manager (ToolManager):
-            An object to manage the registration and invocation of tools.
-    """
-
-    def __init__(
-        self, system, dir=None, llmconfig=oai_schema['chat']['config'], 
-        service=OAIService
-        ):
-        """
-        Initializes the Session object.
-
-        Parameters:
-            system (str): The name of the system with which the session is initiated.
-            
-            dir (str, optional): The directory for saving logs. Defaults to None.
-            
-            llmconfig (dict): Configuration for the language model. Defaults to chat config schema.
-            
-            service (OpenAIService): The service object for API interactions. Defaults to an instance of OpenAIService.
-        """
-
-        self.conversation = Conversation()
-        self.system = system
-        self.llmconfig = llmconfig
-        self.logger_ = DataLogger(dir=dir)
-        self.service = service
-        self.tool_manager = ToolManager()
-    
-    def set_dir(self, dir):
-        """
-        Sets the directory where data logs should be saved.
-        
-        Parameters:
-            dir (str): The path to the directory for saving logs.
-        """
-        self.logger_.dir = dir
-    
-    def set_system(self, system):
-        """
-        Changes the system associated with the conversation.
-        
-        Parameters:
-            system (str): The name of the new system for the conversation.
-        """
-        self.conversation.change_system(system)
-    
-    def set_llmconfig(self, llmconfig):
-        """
-        Updates the language model configuration.
-        
-        Parameters:
-            llmconfig (dict): The new configuration for the language model.
-        """
-        self.llmconfig = llmconfig
-    
-    def set_service(self, service):
-        """
-        Sets the service object used for API interactions.
-        
-        Parameters:
-            service (OpenAIService): The new service object.
-        """
-        self.service = service
-    
-    async def _output(self, invoke=True, out=True):
-        """
-        Processes the output from the conversation, possibly invoking tools and returning the latest response.
-        
-        Parameters:
-            invoke (bool): Indicates whether to invoke tools based on the latest response. Defaults to True.
-            
-            out (bool): Determines whether to return the latest response content. Defaults to True.
-        
-        Returns:
-            The content of the latest response if out is True. Otherwise, returns None.
-        """
-        if invoke:
-            try: 
-                # func, args = self.tool_manager._get_function_call(self.conversation.responses[-1]['content'])
-                # outs = await self.tool_manager.invoke(func, args)
-                # self.conversation.add_messages(response=outs)
-
-                tool_uses = json.loads(self.conversation.responses[-1]['content'])
-                if 'function_list' in tool_uses.keys():
-                    func_calls = lcall(tool_uses['function_list'], self.tool_manager._get_function_call)
-                else:
-                    func_calls = lcall(tool_uses['tool_uses'], self.tool_manager._get_function_call)
-
-                outs = await alcall(func_calls, self.tool_manager.invoke)
-                for out, f in zip(outs, func_calls):
-                    response = {"function": f[0], "arguments": f[1], "output": out}
-                    self.conversation.add_messages(response=response)
-
-            except:
-                pass
-        if out:
-            return self.conversation.responses[-1]['content']
-    
-    def _is_invoked(self):
-        """
-        Checks if the last message in the conversation indicates a function call result.
-        
-        Returns:
-            bool: True if the last message is a function call result, False otherwise.
-        """
-        msg = self.conversation.messages[-1]
-        try:
-            if json.loads(msg['content']).keys() >= {'function', 'arguments', 'output'}:
-                return True
-        except: 
-            return False    
-
-    def register_tools(self, tools): #, update=False, new=False, prefix=None, postfix=None):
-        """
-        Registers a list of tools to the tool manager and updates the language model configuration.
-        
-        Parameters:
-            tools: A single tool or a list of tools to be registered.
-
-            update (bool): If True, update existing tools. Defaults to False.
-
-            new (bool): If True, add as new tools. Defaults to False.
-
-            prefix: A prefix added to all tool names. Defaults to None.
-
-            postfix: A postfix added to all tool names. Defaults to None.
-        """
-        if not isinstance(tools, list):
-            tools=[tools]
-        self.tool_manager.register_tools(tools=tools) #, update=update, new=new, prefix=prefix, postfix=postfix)
-        # tools_schema = lcall(tools, lambda tool: tool.to_dict()['schema_'])
-        # if self.llmconfig['tools'] is None:
-        #     self.llmconfig['tools'] = tools_schema
-        # else:
-        #     self.llmconfig['tools'] += tools_schema
-    
-    async def initiate(self, instruction, system=None, context=None, 
-                       name=None, invoke=True, out=True, **kwargs) -> Any:
-        """
-        Initiates a conversation with an instruction and possibly additional context.
-        
-        Parameters:
-            instruction (str): The initial instruction for the conversation.
-
-            system (str, optional): The name of the system to be used. If None, defaults to current system.
-
-            context (str, optional): Additional context for the conversation. Defaults to None.
-
-            name (str, optional): The name associated with the conversation. Defaults to None.
-
-            invoke (bool): Indicates whether to invoke tools. Defaults to True.
-
-            out (bool): Determines whether to return the latest response content. Defaults to True.
-
-            **kwargs: Additional keyword arguments for language model configuration.
-        
-        Returns:
-            The output of the conversation if out is True, otherwise None.
-        """
-        if self.tool_manager.registry != {}:
-            if 'tools' not in kwargs:
-                tool_kwarg = {"tools": self.tool_manager.to_tool_schema()}
-                kwargs = {**tool_kwarg, **kwargs}
-
-        config = {**self.llmconfig, **kwargs}
-        system = system or self.system
-        self.conversation.initiate_conversation(system=system, instruction=instruction, context=context, name=name)
-        await self.call_chatcompletion(**config)
-        
-        return await self._output(invoke, out)
-
-    async def followup(self, instruction, system=None, context=None, 
-                       out=True, name=None, invoke=True, **kwargs) -> Any:
-        """
-        Continues the conversation with a follow-up instruction.
-        
-        Parameters:
-            instruction (str): The follow-up instruction for the conversation.
-
-            system (str, optional): The name of the system to be used. If None, defaults to current system.
-
-            context (str, optional): Additional context for the conversation. Defaults to None.
-
-            out (bool): Determines whether to return the latest response content. Defaults to True.
-
-            name (str, optional): The name associated with the conversation. Defaults to None.
-
-            invoke (bool): Indicates whether to invoke tools. Defaults to True.
-
-            **kwargs: Additional keyword arguments for language model configuration.
-        
-        Returns:
-            The output of the conversation if out is True, otherwise None.
-        """
-        if system:
-            self.conversation.change_system(system)
-        self.conversation.add_messages(instruction=instruction, context=context, name=name)
-        if self.tool_manager.registry != {}:
-            if 'tools' not in kwargs:
-                tool_kwarg = {"tools": self.tool_manager.to_tool_schema()}
-                kwargs = {**tool_kwarg, **kwargs}
-        config = {**self.llmconfig, **kwargs}
-        await self.call_chatcompletion(**config)
-
-        return await self._output(invoke, out)
-
-    async def auto_followup(self, instruct, num=3, **kwargs):
-        """
-        Automatically generates follow-up messages based on whether the last response invoked a tool.
-        
-        Parameters:
-            instruct (str): The instruction to pass for follow-up.
-
-            num (int): The number of follow-ups to attempt. Defaults to 3.
-
-            **kwargs: Additional keyword arguments for the follow-up process.
-        """
-        if self.tool_manager.registry != {}:
-            if 'tools' not in kwargs:
-                tool_kwarg = {"tools": self.tool_manager.to_tool_schema()}
-                kwargs = {**tool_kwarg, **kwargs}
-
-        cont_ = True
-        while num > 0 and cont_ is True:
-            await self.followup(instruct, tool_choice="auto", **kwargs)
-            num -= 1
-            cont_ = True if self._is_invoked() else False
-        if num == 0:
-            await self.followup(instruct, **kwargs)
-
-    def messages_to_csv(self, dir=None, filename="messages.csv", **kwargs):
-        """
-        Exports the conversation messages to a CSV file.
-        
-        Parameters:
-            dir (str, optional): The directory where the CSV should be saved. Defaults to the logger's directory.
-
-            filename (str): The name of the CSV file. Defaults to "messages.csv".
-
-            **kwargs: Additional keyword arguments passed to the CSV writing function.
-        
-        Raises:
-            ValueError: If no directory is specified.
-        """
-        dir = dir or self.logger_.dir
-        if dir is None:
-            raise ValueError("No directory specified.")
-        self.conversation.msg.to_csv(dir=dir, filename=filename, **kwargs)
-        
-    def log_to_csv(self, dir=None, filename="llmlog.csv", **kwargs):
-        dir = dir or self.logger_.dir
-        if dir is None:
-            raise ValueError("No directory specified.")
-        self.logger_.to_csv(dir=dir, filename=filename, **kwargs)
-    
-    async def call_chatcompletion(self, schema=oai_schema['chat'], **kwargs):
-        payload = ChatCompletion.create_payload(messages=self.conversation.messages, schema=schema, llmconfig=self.llmconfig,**kwargs)
-        completion = await self.service.serve(payload=payload)
-        if "choices" in completion:
-            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
-            self.service.status_tracker.num_tasks_succeeded += 1
-        else:
-            self.service.status_tracker.num_tasks_failed += 1

lionagi/schema/base_schema.py

@@ -1,252 +0,0 @@
-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.
-
-        Parameters:
-            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.
-
-        Parameters:
-            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.
-
-        Parameters:
-            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.
-
-        Parameters:
-            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/services/chatcompletion.py

@@ -1,48 +0,0 @@
-import abc
-
-
-class BaseEndpoint(abc.ABC):
-    endpoint: str = abc.abstractproperty()
-
-    @abc.abstractmethod
-    def create_payload(self, **kwargs):
-        """
-        Create a payload for the request based on configuration.
-        
-        Parameters:
-            **kwargs: Additional keyword arguments for configuration.
-
-        Returns:
-            dict: The payload for the request.
-        """
-        pass
-
-    @abc.abstractmethod
-    def process_response(self, response):
-        """
-        Process the response from the API call.
-        
-        Parameters:
-            response: The response to process.
-        """
-        pass
-
-
-class ChatCompletion(BaseEndpoint):
-    endpoint: str = "chat/completion"
-
-    @classmethod
-    def create_payload(scls, messages, llmconfig, schema, **kwargs):
-        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):
-        ...
-