lionagi 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/graph/tree.py

@@ -1,190 +0,0 @@
-"""
-This module provides classes for representing and working with tree structures.
-
-The module includes the following classes:
-- TreeLabel: An enumeration representing tree relationships (parent and child).
-- TreeNode: A specialized node representing a node within a tree structure,
-  extending the basic node functionality with parent-child relationships.
-- Tree: Represents a tree structure, extending the graph with tree-specific
-  functionalities like managing parent-child relationships.
-"""
-
-from enum import Enum
-from pydantic import Field
-
-from lionagi.core.generic import Node, Condition
-from lionagi.core.graph.graph import Graph
-
-
-class TreeLabel(str, Enum):
-    """
-    Enumeration representing tree relationships.
-
-    Attributes:
-        PARENT (str): Represents the parent edge.
-        CHILD (str): Represents the child edge.
-    """
-
-    PARENT = "parent"
-    CHILD = "child"
-
-
-class TreeNode(Node):
-    """
-    A specialized node representing a node within a tree structure.
-
-    Extends the basic node functionality with parent-child relationships.
-
-    Attributes:
-        parent (Node | None): The parent node. Defaults to None if the node has
-            no parent.
-    """
-
-    parent: Node | None = Field(
-        default=None,
-        description="The parent node, as an instance of Node.",
-    )
-
-    @property
-    def children(self) -> list[str]:
-        """
-        Retrieves the IDs of all child nodes.
-
-        Returns:
-            list[str]: A list containing the IDs of the child nodes.
-        """
-        if not self.parent:
-            return list(self.related_nodes)
-        else:
-            return [
-                node_id for node_id in self.related_nodes if node_id != self.parent.id_
-            ]
-
-    def relate_child(
-        self,
-        child: Node | list[Node],
-        condition: Condition | None = None,
-        bundle: bool = False,
-    ) -> None:
-        """
-        Establishes a parent-child relationship between this node and the given
-        child node(s).
-
-        Args:
-            child (Node | list[Node]): The child node or list of child nodes to
-                be related.
-            condition (Condition | None): The condition associated with the
-                relationship, if any.
-            bundle (bool): Indicates whether to bundle the relation into a
-                single transaction. Defaults to False.
-        """
-        children = [child] if isinstance(child, Node) else child
-        for _child in children:
-            self.relate(
-                _child,
-                node_as="head",
-                label=TreeLabel.PARENT,
-                condition=condition,
-                bundle=bundle,
-            )
-            if isinstance(_child, TreeNode):
-                _child.parent = self
-
-    def relate_parent(
-        self,
-        parent: Node,
-        condition: Condition | None = None,
-        bundle: bool = False,
-    ) -> None:
-        """
-        Establishes a parent-child relationship between the given parent node
-        and this node.
-
-        Args:
-            parent (Node): The parent node to be related.
-            condition (Condition | None): The condition associated with the
-                relationship, if any.
-            bundle (bool): Indicates whether to bundle the relation into a
-                single transaction. Defaults to False.
-        """
-        if self.parent:
-            self.unrelate(self.parent)
-        self.relate(
-            parent,
-            node_as="tail",
-            label=TreeLabel.PARENT,
-            condition=condition,
-            bundle=bundle,
-        )
-        self.parent = parent
-
-    def unrelate_parent(self):
-        """
-        Removes the parent relationship of this node.
-        """
-        self.unrelate(self.parent)
-        self.parent = None
-
-    def unrelate_child(self, child: Node | list[Node]):
-        """
-        Removes the child relationship between this node and the given child
-        node(s).
-
-        Args:
-            child (Node | list[Node]): The child node or list of child nodes to
-                be unrelated.
-        """
-        children: list[Node] = [child] if isinstance(child, Node) else child
-        for _child in children:
-            self.unrelate(_child)
-            if isinstance(_child, TreeNode):
-                _child.parent = None
-
-
-class Tree(Graph):
-    """
-    Represents a tree structure, extending the graph with tree-specific
-    functionalities.
-
-    Manages parent-child relationships within the tree.
-
-    Attributes:
-        root (TreeNode | None): The root node of the tree. Defaults to None.
-    """
-
-    root: TreeNode | None = Field(
-        default=None, description="The root node of the tree graph."
-    )
-
-    def relate_parent_child(
-        self,
-        parent: TreeNode,
-        children: list[TreeNode],
-        condition: Condition | None = None,
-        bundle: bool = False,
-    ) -> None:
-        """
-        Establishes parent-child relationships between the given parent node and
-        child node(s).
-
-        Args:
-            parent (TreeNode): The parent node.
-            children (list[TreeNode]): A list of child nodes.
-            condition (Condition | None): The condition associated with the
-                relationships, if any.
-            bundle (bool): Indicates whether to bundle the relations into a
-                single transaction. Defaults to False.
-        """
-        children = [children] if isinstance(children, TreeNode) else children
-        for child in children:
-            if child.id_ not in self.internal_nodes:
-                self.add_node(child)
-
-        for child in children:
-            parent.relate_child(child, condition=condition, bundle=bundle)
-
-        if parent.id_ not in self.internal_nodes:
-            self.add_node(parent)
-
-        if self.root is None:
-            self.root = parent

lionagi/core/mail/schema.py

@@ -1,63 +0,0 @@
-from collections import deque
-from enum import Enum
-
-from lionagi.core.generic import Node
-
-
-class MailCategory(str, Enum):
-    MESSAGES = "messages"
-    TOOL = "tool"
-    SERVICE = "service"
-    MODEL = "model"
-    NODE = "node"
-    NODE_LIST = "node_list"
-    NODE_ID = "node_id"
-    START = "start"
-    END = "end"
-    CONDITION = "condition"
-
-
-class BaseMail:
-
-    def __init__(self, sender_id, recipient_id, category, package):
-        self.sender_id = sender_id
-        self.recipient_id = recipient_id
-        try:
-            if isinstance(category, str):
-                category = MailCategory(category)
-            if isinstance(category, MailCategory):
-                self.category = category
-            else:
-                raise ValueError(
-                    f"Invalid request title. Valid titles are" f" {list(MailCategory)}"
-                )
-        except Exception as e:
-            raise ValueError(
-                f"Invalid request title. Valid titles are "
-                f"{list(MailCategory)}, Error: {e}"
-            ) from e
-        self.package = package
-
-
-class StartMail(Node):
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.pending_outs = deque()
-
-    def trigger(self, context, structure_id, executable_id):
-        start_mail_content = {"context": context, "structure_id": structure_id}
-        start_mail = BaseMail(
-            sender_id=self.id_,
-            recipient_id=executable_id,
-            category="start",
-            package=start_mail_content,
-        )
-        self.pending_outs.append(start_mail)
-
-
-class MailTransfer(Node):
-    def __init__(self):
-        super().__init__()
-        self.pending_ins = {}
-        self.pending_outs = deque()

lionagi/core/messages/schema.py

@@ -1,325 +0,0 @@
-from enum import Enum
-
-from lionagi.libs import nested, convert
-from lionagi.core.generic import Node
-from lionagi.core.form.form import Form
-
-_message_fields = ["node_id", "timestamp", "role", "sender", "recipient", "content"]
-
-
-class BranchColumns(list[str], Enum):
-    COLUMNS = _message_fields
-
-
-class MessageField(str, Enum):
-    NODE_ID = "node_id"
-    TIMESTAMP = "timestamp"
-    ROLE = "role"
-    SENDER = "sender"
-    RECIPIENT = "recipient"
-    CONTENT = "content"
-    METADATA = "metadata"
-    RELATION = "relation"
-
-
-class MessageRoleType(str, Enum):
-    SYSTEM = "system"
-    USER = "user"
-    ASSISTANT = "assistant"
-
-
-class MessageContentKey(str, Enum):
-    INSTRUCTION = "instruction"
-    CONTEXT = "context"
-    SYSTEM = "system_info"
-    ACTION_REQUEST = "action_request"
-    ACTION_RESPONSE = "action_response"
-    RESPONSE = "response"
-
-
-class MessageType(dict, Enum):
-    SYSTEM = (
-        {
-            MessageField.ROLE.value: MessageRoleType.SYSTEM.value,
-            MessageField.SENDER.value: MessageRoleType.SYSTEM.value,
-            MessageField.RECIPIENT.value: "null",
-            "content_key": MessageContentKey.SYSTEM.value,
-        },
-    )
-
-    INSTRUCTION = (
-        {
-            MessageField.ROLE.value: MessageRoleType.USER.value,
-            MessageField.SENDER.value: MessageRoleType.USER.value,
-            MessageField.RECIPIENT.value: "null",
-            "content_key": MessageContentKey.INSTRUCTION.value,
-        },
-    )
-
-    CONTEXT = (
-        {
-            MessageField.ROLE.value: MessageRoleType.USER.value,
-            MessageField.SENDER.value: MessageRoleType.USER.value,
-            MessageField.RECIPIENT.value: "null",
-            "content_key": MessageContentKey.CONTEXT.value,
-        },
-    )
-
-    ACTION_REQUEST = (
-        {
-            MessageField.ROLE.value: MessageRoleType.ASSISTANT.value,
-            MessageField.SENDER.value: MessageRoleType.ASSISTANT.value,
-            MessageField.RECIPIENT.value: "null",
-            "content_key": MessageContentKey.ACTION_REQUEST.value,
-        },
-    )
-
-    ACTION_RESPONSE = (
-        {
-            MessageField.ROLE.value: MessageRoleType.ASSISTANT.value,
-            MessageField.SENDER.value: MessageRoleType.ASSISTANT.value,
-            MessageField.RECIPIENT.value: "null",
-            "content_key": MessageContentKey.ACTION_RESPONSE.value,
-        },
-    )
-
-    RESPONSE = {
-        MessageField.ROLE.value: MessageRoleType.ASSISTANT.value,
-        MessageField.SENDER.value: MessageRoleType.ASSISTANT.value,
-        MessageField.RECIPIENT.value: "null",
-        "content_key": MessageContentKey.RESPONSE.value,
-    }
-
-
-class BaseMessage(Node):
-    """
-    Represents a message in a chatbot-like system, inheriting from BaseNode.
-
-    Attributes:
-        role (str | None): The role of the entity sending the message, e.g., 'user', 'system'.
-        sender (str | None): The identifier of the sender of the message.
-        content (Any): The actual content of the message.
-    """
-
-    role: str | None = None
-    sender: str | None = None
-    recipient: str | None = None
-
-    @property
-    def msg(self) -> dict:
-        """
-        Constructs and returns a dictionary representation of the message.
-
-        Returns:
-            A dictionary representation of the message with 'role' and 'content' keys.
-        """
-        return self._to_message()
-
-    @property
-    def msg_content(self) -> str | dict:
-        """
-        Gets the 'content' field of the message.
-
-        Returns:
-            The 'content' part of the message.
-        """
-        return self.msg["content"]
-
-    def _to_message(self):
-        """
-        Constructs and returns a dictionary representation of the message.
-
-        Returns:
-            dict: A dictionary representation of the message with 'role' and 'content' keys.
-        """
-        return {"role": self.role, "content": convert.to_str(self.content)}
-
-    def __str__(self):
-        content_preview = (
-            f"{str(self.content)[:75]}..."
-            if self.content and len(self.content) > 75
-            else str(self.content)
-        )
-        return f"Message(role={self.role}, sender={self.sender}, content='{content_preview}')"
-
-
-class Instruction(BaseMessage):
-    """
-    Represents an instruction message, a specialized subclass of Message.
-
-    This class is specifically used for creating messages that are instructions from the user,
-    including any associated context. It sets the message role to 'user'.
-    """
-
-    def __init__(
-        self,
-        instruction: dict | list | str,
-        context=None,
-        sender: str | None = None,
-        output_fields=None,
-        recipient=None,
-    ):
-        super().__init__(
-            role="user",
-            sender=sender or "user",
-            content={"instruction": instruction},
-            recipient=recipient or "assistant",
-        )
-        if context:
-            self.content.update({"context": context})
-
-        if output_fields:
-            format_ = f"""
-            MUST EXACTLY Follow the following response format. NO ADDITIONAL COMMENTS ALLOWED!
-            ```json
-            {output_fields}
-            ```
-            """
-            self.content.update(
-                {"response_format": format_.replace("            ", "")}
-            )
-
-    @property
-    def instruct(self):
-        return self.content["instruction"]
-
-    @classmethod
-    def from_form(
-        cls,
-        form: Form,
-        sender: str | None = None,
-        recipient=None,
-    ):
-        return cls(
-            instruction=form.instruction,
-            context=form.instruction_context,
-            output_fields=form.instruction_output_fields,
-            sender=sender,
-            recipient=recipient,
-        )
-
-
-class System(BaseMessage):
-    """
-    Represents a system-related message, a specialized subclass of Message.
-
-    Designed for messages containing system information, this class sets the message role to 'system'.
-    """
-
-    def __init__(
-        self, system: dict | list | str, sender: str | None = None, recipient=None
-    ):
-        super().__init__(
-            role="system",
-            sender=sender or "system",
-            content={"system_info": system},
-            recipient=recipient or "assistant",
-        )
-
-    @property
-    def system_info(self):
-        return self.content["system_info"]
-
-
-class Response(BaseMessage):
-    """
-    Represents a response message, a specialized subclass of Message.
-
-    Used for various types of response messages including regular responses, action requests,
-    and action responses. It sets the message role to 'assistant'.
-
-    """
-
-    def __init__(
-        self, response: dict | list | str, sender: str | None = None, recipient=None
-    ) -> None:
-        content_key = ""
-        try:
-            response = response["message"]
-            if convert.strip_lower(response["content"]) == "none":
-                content_ = self._handle_action_request(response)
-                sender = sender or "action_request"
-                content_key = content_key or "action_request"
-                recipient = recipient or "action"
-
-            else:
-                try:
-                    if "tool_uses" in convert.to_dict(response["content"]):
-                        content_ = convert.to_dict(response["content"])["tool_uses"]
-                        content_key = content_key or "action_request"
-                        sender = sender or "action_request"
-                        recipient = recipient or "action"
-
-                    elif "response" in convert.to_dict(response["content"]):
-                        sender = sender or "assistant"
-                        content_key = content_key or "response"
-                        content_ = convert.to_dict(response["content"])["response"]
-                        recipient = recipient or "user"
-
-                    elif "action_request" in convert.to_dict(response["content"]):
-                        sender = sender or "action_request"
-                        content_key = content_key or "action_request"
-                        content_ = convert.to_dict(response["content"])[
-                            "action_request"
-                        ]
-                        recipient = recipient or "action"
-
-                    else:
-                        content_ = response["content"]
-                        content_key = content_key or "response"
-                        sender = sender or "assistant"
-                        recipient = recipient or "user"
-                except Exception:
-                    content_ = response["content"]
-                    content_key = content_key or "response"
-                    sender = sender or "assistant"
-                    recipient = recipient or "user"
-
-        except Exception:
-            sender = sender or "action_response"
-            content_ = response
-            content_key = content_key or "action_response"
-            recipient = recipient or "assistant"
-
-        super().__init__(
-            role="assistant",
-            sender=sender,
-            content={content_key: content_},
-            recipient=recipient,
-        )
-
-    @staticmethod
-    def _handle_action_request(response):
-        """
-        Processes an action request response and extracts relevant information.
-
-        Args:
-            response (dict): The response dictionary containing tool calls and other information.
-
-        Returns:
-            list: A list of dictionaries, each representing a function call with action and arguments.
-
-        Raises:
-            ValueError: If the response does not conform to the expected format for action requests.
-        """
-        try:
-            tool_count = 0
-            func_list = []
-            while tool_count < len(response["tool_calls"]):
-                _path = ["tool_calls", tool_count, "type"]
-
-                if nested.nget(response, _path) == "function":
-                    _path1 = ["tool_calls", tool_count, "function", "name"]
-                    _path2 = ["tool_calls", tool_count, "function", "arguments"]
-
-                    func_content = {
-                        "action": f"action_{nested.nget(response, _path1)}",
-                        "arguments": nested.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"
-            )

lionagi/core/tool/__init__.py

@@ -1,5 +0,0 @@
-from .tool import Tool, TOOL_TYPE
-from .tool_manager import ToolManager, func_to_tool
-
-
-__all__ = ["Tool", "TOOL_TYPE", "ToolManager", "func_to_tool"]

lionagi/core/tool/tool.py

@@ -1,28 +0,0 @@
-from typing import Any
-
-from pydantic import field_serializer
-from lionagi.core.generic import Node
-
-
-class Tool(Node):
-    """
-    Represents a tool, extending BaseNode with specific functionalities and configurations.
-
-    Attributes:
-        func: The main function or capability of the tool.
-        schema_: An optional schema defining the structure and constraints of data the tool works with.
-        manual: Optional documentation or manual for using the tool.
-        parser: An optional parser associated with the tool for data processing or interpretation.
-    """
-
-    func: Any
-    schema_: dict | None = None
-    manual: Any | None = None
-    parser: Any | None = None
-
-    @field_serializer("func")
-    def serialize_func(self, func):
-        return func.__name__
-
-
-TOOL_TYPE = bool | Tool | str | list[Tool | str | dict] | dict