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

lionagi/core/instruction_set.py

@@ -1,150 +0,0 @@
-from typing import List, Union
-from ..schema import Tool
-from ..structures import Relationship, Structure
-from .messages import Instruction
-
-
-# dynamically structured preconfigured instructions
-class InstructionSet(Structure):
-    """
-    Represents a set of instructions and their relationships to tools.
-
-    Attributes:
-        last_instruct (Optional[str]): ID of the last instruction added.
-        first_instruct (Optional[str]): ID of the first instruction added.
-        instruct_len (int): The total number of instructions.
-
-    Example usage:
-        >>> instruction_set = InstructionSet()
-        >>> instruction = Instruction(...)
-        >>> tool = Tool(...)
-        >>> instruction_set.add_instruction(instruction)
-        >>> instruction_set.add_instruction(instruction, tools=tool)
-        >>> instruction_set.pop_instruction()
-        >>> instruction_node = instruction_set.get_instruction_by_id('node_id')
-        >>> next_instruction = instruction_set.get_next_instruction(instruction_node)
-        >>> tools = instruction_set.get_associated_tools(instruction_node)
-    """
-    last_instruct: str = None
-    first_instruct: str = None
-    instruct_len: int = 0
-
-    def add_instruction(self, instruction: Instruction, tools: Union[Tool, List[Tool]] = None):
-        """
-        Add an instruction to the instruction set.
-
-        Args:
-            instruction (Instruction): The instruction to add.
-            tools (Union[Tool, List[Tool]], optional): The tool or list of tools related to the instruction.
-
-        Example usage:
-            >>> instruction_set = InstructionSet()
-            >>> instruction = Instruction(...)
-            >>> tool = Tool(...)
-            >>> instruction_set.push_instruction(instruction)
-            >>> instruction_set.push_instruction(instruction, tools=tool)
-        """
-
-        if self.graph.is_empty():
-            self.graph.add_node(instruction)
-            self.last_instruct = instruction.id_
-            self.first_instruct = instruction.id_
-        else:
-            relationship = Relationship(source_node_id=self.last_instruct, target_node_id=instruction.id_, label='instruction')
-            self.graph.add_node(instruction)
-            self.graph.add_relationship(relationship)
-            self.last_instruct = instruction.id_
-        self.instruct_len += 1
-
-        if tools:
-            if isinstance(tools, Tool):
-                tools = [tools]
-            for tool in tools:
-                relationship = Relationship(source_node_id=tool.id_, target_node_id=self.last_instruct, label='tool')
-                self.graph.add_node(tool)
-                self.graph.add_relationship(relationship)
-
-    def pop_instruction(self):
-        """
-        Remove the last instruction from the instruction set.
-
-        Example usage:
-            >>> instruction_set = InstructionSet()
-            >>> instruction_set.pop_instruction()
-        """
-        if self.graph.is_empty():
-            return
-        elif self.instruct_len == 1:
-            self.graph.clear()
-            self.last_instruct = None
-            self.first_instruct = None
-            self.instruct_len -= 1
-        else:
-            relationships = self.get_node_relationships(self.graph.nodes[self.last_instruct], out_edge=False)
-            prev_instruct = None
-            for r in relationships:
-                if r.label != 'instruction':
-                    self.graph.remove_node(self.graph.nodes[r.source_node_id])
-                else:
-                    prev_instruct = r.source_node_id
-
-            self.graph.remove_node(self.graph.nodes[self.last_instruct])
-            self.last_instruct = prev_instruct
-            self.instruct_len -= 1
-
-    def get_instruction_by_id(self, node_id):
-        """
-        Retrieve an instruction by its ID.
-
-        Args:
-            node_id (str): The ID of the instruction node.
-
-        Returns:
-            Instruction: The instruction node associated with the given ID.
-
-        Example usage:
-            >>> instruction_set = InstructionSet()
-            >>> instruction_node = instruction_set.get_instruction_by_id('node_id')
-        """
-        return self.graph.nodes[node_id]
-
-    def get_next_instruction(self, instruct_node: Instruction):
-        """
-        Retrieve the next instruction following the given instruction node.
-
-        Args:
-            instruct_node (Instruction): The current instruction node.
-
-        Returns:
-            Optional[Instruction]: The next instruction node in the sequence, if it exists.
-
-        Example usage:
-            >>> instruction_set = InstructionSet()
-            >>> current_node = Instruction(...)
-            >>> next_node = instruction_set.get_next_instruction(current_node)
-        """
-        relationship = self.get_node_relationships(instruct_node)
-        if relationship:
-            return self.graph.nodes[relationship[0].target_node_id]
-
-    def get_tools(self, instruct_node: Instruction):
-        """
-        Retrieve the tools associated with a given instruction node.
-
-        Args:
-            instruct_node (Instruction): The instruction node to retrieve tools for.
-
-        Returns:
-            List[Tool]: The tools associated with the instruction node.
-
-        Example usage:
-            >>> instruction_set = InstructionSet()
-            >>> instruction_node = Instruction(...)
-            >>> tools = instruction_set.get_tools(instruction_node)
-        """
-        relationships = self.get_node_relationships(instruct_node, out_edge=False, labels=['tool'])
-        tools = []
-        for r in relationships:
-            tool = self.graph.nodes[r.source_node_id]
-            tools.append(tool)
-        return tools

lionagi/core/messages.py

@@ -1,243 +0,0 @@
-import json
-from typing import Any, Optional, Dict
-from ..utils.sys_util import strip_lower, as_dict
-from ..utils.nested_util import nget, to_readable_dict
-from ..schema import BaseNode
-
-
-class Message(BaseNode):
-    """
-    Represents a message with associated role, name, and content.
-
-    Attributes:
-        role (Optional[str]): The role of the entity sending the message.
-        name (Optional[str]): The name of the entity sending the message.
-        content (Any): The content of the message.
-    """
-    
-    role: Optional[str] = None
-    name: Optional[str] = None
-    
-    @property
-    def msg(self) -> Dict[str, Any]:
-        """The message as a dictionary.
-
-        Returns:
-            Dict[str, Any]: The message in dictionary form with 'role' or 'name' as a key.
-        """
-        return self._to_message()
-        
-    @property
-    def named_msg(self) -> Dict[str, Any]:
-        """The message as a dictionary with the sender's name.
-
-        Returns:
-            Dict[str, Any]: The message in dictionary form with 'name' as a key.
-        """
-        return self._to_message(use_name=True)
-    
-    @property
-    def msg_content(self) -> Any:
-        """The content of the message.
-
-        Returns:
-            Any: The content of the message.
-        """
-        return self.msg['content']
-    
-    @property
-    def sender(self) -> str:
-        """The name of the sender of the message.
-
-        Returns:
-            Optional[str]: The name of the sender.
-        """
-        return self.name
-    
-    @property
-    def readable_content(self) -> str:
-        """The content of the message in a human-readable format.
-
-        Returns:
-            str: The message content as a human-readable string.
-        """
-        return to_readable_dict(self.content)
-
-    @staticmethod
-    def create_system(content: Any, name: Optional[str] = None):
-        """Create a system message.
-
-        Args:
-            content (Any): The content of the system message.
-            name (Optional[str]): The name of the system.
-
-        Returns:
-            System: The created system message.
-        """
-        return System(system=content, name=name)
-
-    @staticmethod
-    def create_instruction(
-        content: Any, context: Optional[Any] = None, name: Optional[str] = None
-    ) -> "Instruction":
-        """Create an instruction message.
-
-        Args:
-            content (Any): The content of the instruction.
-            context (Optional[Any]): Additional context for the instruction.
-            name (Optional[str]): The name of the sender.
-
-        Returns:
-            Instruction: The created instruction message.
-        """
-        return Instruction(instruction=content, context=context, name=name)
-
-    @staticmethod
-    def create_response(content: Any, name: Optional[str] = None) -> "Response":
-        """Create a response message.
-
-        Args:
-            content (Any): The content of the response.
-            name (Optional[str]): The name of the sender.
-
-        Returns:
-            Response: The created response message.
-        """
-        return Response(response=content, name=name)
-    
-    def _to_message(self, use_name: bool = False) -> Dict[str, Any]:
-        """Convert the message to a dictionary.
-
-        Args:
-            use_name (bool): Whether to use the sender's name as a key.
-
-        Returns:
-            Dict[str, Any]: The message in dictionary form.
-        """
-        out = {"name": self.name} if use_name else {"role": self.role}
-        out['content'] = json.dumps(self.content) if isinstance(self.content, dict) else self.content
-        return out
-
-    def to_plain_text(self) -> str:
-        """Convert the message content to plain text.
-
-        Returns:
-            str: The plain text content of the message.
-        """
-        if isinstance(self.content, str):
-            return self.content
-        elif isinstance(self.content, dict):
-            return json.dumps(self.content)
-        elif self.content is None:
-            return ""
-        else:
-            return str(self.content)
-
-    def __str__(self) -> str:
-        """String representation of the Message object.
-
-        Returns:
-            str: The string representation of the message.
-        """
-        content_preview = self.to_plain_text()[:75] + "..." if len(self.to_plain_text()) > 75 else self.to_plain_text()
-        return f"Message(role={self.role}, name={self.name}, content='{content_preview}')"
-
-
-class System(Message):
-    """Represents a system message."""
-
-    def __init__(self, system: Any, name: Optional[str] = None):
-        """Initialize the System message.
-
-        Args:
-            system (Any): The content of the system message.
-            name (Optional[str]): The name of the system.
-        """
-        super().__init__(role="system", name=name or 'system', content={"system_info": system})
-
-
-class Instruction(Message):
-    """Represents an instruction message."""
-
-    def __init__(self, instruction: Any, context=None, name: Optional[str] = None):
-        """Initialize the Instruction message.
-
-        Args:
-            instruction (Any): The content of the instruction.
-            context (Optional[Any]): Additional context for the instruction.
-            name (Optional[str]): The name of the sender.
-        """
-
-        super().__init__(role="user", name=name or 'user', content={"instruction": instruction})
-        if context:
-            self.content.update({"context": context})
-
-
-
-
-class Response(Message):
-
-    def __init__(self, response: Any, name: Optional[str] = None, content_key=None) -> None:
-        try:
-            response = response["message"]
-
-            if strip_lower(response['content']) == "none":
-                content_ = self._handle_action_request(response)
-                name = name or "action_request"
-                content_key = content_key or "action_list"
-
-            else:
-                try:
-                    if 'tool_uses' in json.loads(response['content']):
-                        content_ = json.loads(response['content'])['tool_uses']
-                        content_key = content_key or "action_list"
-                        name = name or "action_request"
-                    else:
-                        content_ = response['content']
-                        content_key = content_key or "response"
-                        name = name or "assistant"
-                except:
-                    content_ = response['content']
-                    content_key = content_key or "response"
-                    name = name or "assistant"
-
-        except:
-            name = name or "action_response"
-            content_ = response
-            content_key = content_key or "action_response"
-        
-        super().__init__(role="assistant", name=name, content={content_key: content_})
-        
-    @staticmethod
-    def _handle_action_request(response):
-        """Handle an action request from the response.
-
-        Args:
-            response (Dict[str, Any]): The response dictionary containing the action request.
-
-        Returns:
-            List[Dict[str, Any]]: The list of actions parsed from the request.
-
-        Raises:
-            ValueError: If the response does not contain valid function calling information.
-        """
-        try:
-            tool_count = 0
-            func_list = []
-            while tool_count < len(response['tool_calls']):
-                _path = ['tool_calls', tool_count, 'type']
-                
-                if nget(response, _path) == 'function':
-                    _path1 = ['tool_calls', tool_count, 'function', 'name']
-                    _path2 = ['tool_calls', tool_count, 'function', 'arguments']
-                    
-                    func_content = {
-                        "action": ("action_" + nget(response, _path1)),
-                        "arguments": nget(response, _path2)
-                        }
-                    func_list.append(func_content)
-                tool_count += 1
-            return func_list
-        except:
-            raise ValueError("Response message must be one of regular response or function calling")
-