lionagi 0.0.315__py3-none-any.whl → 0.1.0__py3-none-any.whl

lionagi/core/graph/tree.py

@@ -0,0 +1,190 @@
+"""
+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/__init__.py

@@ -1,8 +0,0 @@
-from .schema import BaseMail, StartMail
-from .mail_manager import MailManager
-
-__all__ = [
-    "BaseMail",
-    "StartMail",
-    "MailManager",
-]

lionagi/core/mail/mail_manager.py

@@ -1,7 +1,7 @@
 from collections import deque
 from lionagi.libs import AsyncUtil
-from ..schema import BaseNode
-from .schema import BaseMail
+from lionagi.core.generic import Node
+from lionagi.core.mail.schema import BaseMail, MailCategory
 
 
 class MailManager:
@@ -34,18 +34,20 @@ class MailManager:
                 if v.id_ not in self.sources:
                     self.sources[v.id_] = v
                     self.mails[v.id_] = {}
+        else:
+            raise ValueError("Failed to add source, please input list or dict.")
 
     @staticmethod
     def create_mail(sender_id, recipient_id, category, package):
         return BaseMail(sender_id, recipient_id, category, package)
 
-    def add_source(self, sources: list[BaseNode]):
-        for source in sources:
-            if source.id_ in self.sources:
-                # raise ValueError(f"Source {source.id_} exists, please input a different name.")
-                continue
-            self.sources[source.id_] = source
-            self.mails[source.id_] = {}
+    # def add_source(self, sources: list[Node]):
+    #     for source in sources:
+    #         if source.id_ in self.sources:
+    #             # raise ValueError(f"Source {source.id_} exists, please input a different name.")
+    #             continue
+    #         self.sources[source.id_] = source
+    #         self.mails[source.id_] = {}
 
     def delete_source(self, source_id):
         if source_id not in self.sources:
@@ -65,7 +67,7 @@ class MailManager:
                     f"Recipient source {mail_.recipient_id} does not exist"
                 )
             if mail_.sender_id not in self.mails[mail_.recipient_id]:
-                self.mails[mail_.recipient_id] = {mail_.sender_id: deque()}
+                self.mails[mail_.recipient_id].update({mail_.sender_id: deque()})
             self.mails[mail_.recipient_id][mail_.sender_id].append(mail_)
 
     def send(self, recipient_id):

lionagi/core/mail/schema.py

@@ -1,7 +1,7 @@
 from collections import deque
 from enum import Enum
 
-from lionagi.core.schema.base_node import BaseRelatableNode
+from lionagi.core.generic import Node
 
 
 class MailCategory(str, Enum):
@@ -39,7 +39,7 @@ class BaseMail:
         self.package = package
 
 
-class StartMail(BaseRelatableNode):
+class StartMail(Node):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -54,3 +54,10 @@ class StartMail(BaseRelatableNode):
             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/__init__.py

@@ -1,3 +0,0 @@
-from .schema import System, Instruction, Response
-
-__all__ = ["System", "Instruction", "Response"]

lionagi/core/messages/schema.py

@@ -1,15 +1,12 @@
 from enum import Enum
 
 from lionagi.libs import nested, convert
-from ..schema import DataNode
-from ..prompt.prompt_template import PromptTemplate
+from lionagi.core.generic import Node
+from lionagi.core.form.form import Form
 
 _message_fields = ["node_id", "timestamp", "role", "sender", "recipient", "content"]
 
 
-# ToDo: actually implement the new message classes
-
-
 class BranchColumns(list[str], Enum):
     COLUMNS = _message_fields
 
@@ -94,14 +91,14 @@ class MessageType(dict, Enum):
     }
 
 
-class BaseMessage(DataNode):
+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): 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
@@ -114,7 +111,7 @@ class BaseMessage(DataNode):
         Constructs and returns a dictionary representation of the message.
 
         Returns:
-                A dictionary representation of the message with 'role' and 'content' keys.
+            A dictionary representation of the message with 'role' and 'content' keys.
         """
         return self._to_message()
 
@@ -124,7 +121,7 @@ class BaseMessage(DataNode):
         Gets the 'content' field of the message.
 
         Returns:
-                The 'content' part of the message.
+            The 'content' part of the message.
         """
         return self.msg["content"]
 
@@ -133,7 +130,7 @@ class BaseMessage(DataNode):
         Constructs and returns a dictionary representation of the message.
 
         Returns:
-                dict: A dictionary representation of the message with 'role' and 'content' keys.
+            dict: A dictionary representation of the message with 'role' and 'content' keys.
         """
         return {"role": self.role, "content": convert.to_str(self.content)}
 
@@ -187,16 +184,16 @@ class Instruction(BaseMessage):
         return self.content["instruction"]
 
     @classmethod
-    def from_prompt_template(
+    def from_form(
         cls,
-        prompt_template: PromptTemplate,
+        form: Form,
         sender: str | None = None,
         recipient=None,
     ):
         return cls(
-            instruction=prompt_template.instruction,
-            context=prompt_template.instruction_context,
-            output_fields=prompt_template.instruction_output_fields,
+            instruction=form.instruction,
+            context=form.instruction_context,
+            output_fields=form.instruction_output_fields,
             sender=sender,
             recipient=recipient,
         )
@@ -297,13 +294,13 @@ class Response(BaseMessage):
         Processes an action request response and extracts relevant information.
 
         Args:
-                response (dict): The response dictionary containing tool calls and other information.
+            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.
+            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.
+            ValueError: If the response does not conform to the expected format for action requests.
         """
         try:
             tool_count = 0
@@ -326,208 +323,3 @@ class Response(BaseMessage):
             raise ValueError(
                 "Response message must be one of regular response or function calling"
             )
-
-
-# class BaseMessage(DataNode):
-
-
-#     def __init__():
-#         ...
-
-#     role: MessageRoleType = Field(..., alias=MessageField.ROLE.value)
-#     sender: str = Field(..., alias=MessageField.SENDER.value)  # Customizable sender
-#     recipient: str | None = Field(None,
-#                                      alias=MessageField.RECIPIENT.value)  # Optional recipient
-
-#     class Config:
-#         extra = 'allow'
-#         use_enum_values = True
-#         populate_by_name = True
-
-#     @model_validator(mode='before')
-#     def handle_extra_fields(cls, values):
-#         """Move undefined fields to metadata."""
-#         fields = set(values.keys())
-#         defined_fields = set(cls.model_fields.keys())
-#         extra_fields = fields - defined_fields
-
-#         if extra_fields:
-#             metadata = values.get('metadata', {})
-#             for field in extra_fields:
-#                 if field in metadata:
-#                     metadata[f"{field}_1"] = values.pop(field)
-#                 else:
-#                     metadata[field] = values.pop(field)
-#             values['metadata'] = metadata
-#         return values
-
-#     def _to_roled_message(self):
-#         return {
-#             MessageField.ROLE.value: self.role.value,
-#             MessageField.CONTENT.value: (
-#                 json.dumps(self.content) if isinstance(self.content, dict)
-#                 else self.content
-#             )
-#         }
-
-#     def to_pd_series(self, *args, **kwargs):
-#         msg_dict = self.to_dict(*args, **kwargs)
-#         if isinstance(to_dict(msg_dict['content']), dict):
-#             msg_dict['content'] = json.dumps(msg_dict['content'])
-#         return pd.Series(msg_dict)
-
-#     @classmethod
-#     def from_pd_series(cls, series: pd.Series, **kwargs):
-#         self = cls.from_dict(series.to_dict(**kwargs))
-#         if isinstance(self.content, str):
-#             try:
-#                 self.content = to_dict(self.content)
-#             except:
-#                 pass
-#         return self
-
-
-#     def __str__(self):
-#         content_preview = self.content[:50] + "..." if len(
-#             self.content) > 50 else self.content
-#         meta_preview = str(self.metadata)[:50] + "..." if len(
-#             str(self.metadata)) > 50 else str(self.metadata)
-
-#         return (
-#             f"Message({self.role.value or 'none'}, {self._sender or 'none'}, "
-#             f"{content_preview or 'none'}, {self.recipient or 'none'},"
-#             f"{self.timestamp or 'none'}, {meta_preview or 'none'}"
-#         )
-
-# class Instruction(BaseMessage):
-
-#     def __init__(self, instruction: Any, context: Any = None,
-#                  sender: str | None = None, recipient: str | None | Any = None,
-#                  metadata: dict | None = None, relation: list | None | Any = None,
-#                  **kwargs):
-#         super().__init__(
-#             role=MessageType.INSTRUCTION.value[MessageField.ROLE.value],
-#             sender=sender or MessageType.INSTRUCTION.value[MessageField.SENDER.value],
-#             content={MessageType.INSTRUCTION.value["content_key"]: instruction},
-#             recipient=recipient or MessageType.SYSTEM.value[MessageField.RECIPIENT.value],
-#             metadata=metadata or {}, relation=relation or [], **kwargs
-#         )
-#         if context:
-#             self.content.update({MessageType.CONTEXT.value["content_key"]: context})
-
-
-# class System(BaseMessage):
-
-#     def __init__(self, system: Any, sender: str | None = None, recipient: Optional[
-#         str] = None, metadata: Optional[dict] = None, relation: Optional[list] = None,
-#                  **kwargs):
-#         super().__init__(
-#             role=MessageType.SYSTEM.value[MessageField.ROLE.value],
-#             sender=sender or MessageType.SYSTEM.value[MessageField.SENDER.value],
-#             content={MessageType.SYSTEM.value["content_key"]: system},
-#             recipient=recipient or MessageType.SYSTEM.value[MessageField.RECIPIENT.value],
-#             metadata=metadata or {}, relation=relation or [], **kwargs
-#         )
-
-
-# class ActionRequest(BaseMessage):
-
-#     def __init__(self, action_request: Any, sender: str | None = None,
-#                  recipient: Optional[
-#                      str] = None, metadata: Optional[dict] = None,
-#                  relation: Optional[list] = None,
-#                  **kwargs
-#                  ):
-
-#         super().__init__(
-#             role=MessageType.ACTION_REQUEST.value[MessageField.ROLE.value],
-#             sender=sender or MessageType.ACTION_REQUEST.value[MessageField.SENDER.value],
-#             content={MessageType.ACTION_REQUEST.value["content_key"]: action_request},
-#             recipient=recipient or MessageType.ACTION_REQUEST.value[
-#                 MessageField.RECIPIENT.value],
-#             metadata=metadata or {}, relation=relation or [], **kwargs
-#         )
-
-#     @classmethod
-#     def from_response(cls, response, sender=None, recipient=None, metadata=None,
-#                       relation=None,
-#                       **kwargs):
-#         return cls(action_request=response, sender=sender, recipient=recipient,
-#                    metadata=metadata,
-#                    relation=relation, **kwargs)
-
-#     @staticmethod
-#     def _handle_action_request(response):
-#         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"
-#             )
-
-
-# class ActionResponse(BaseMessage):
-
-#     def __init__(self, action_response: Any, sender: str | None = None,
-#                  recipient: Optional[
-#                      str] = None, metadata: Optional[dict] = None,
-#                  relation: Optional[list] = None,
-#                  **kwargs
-#                  ):
-#         super().__init__(
-#             role=MessageType.ACTION_RESPONSE.value[MessageField.ROLE.value],
-#             sender=sender or MessageType.ACTION_RESPONSE.value[MessageField.SENDER.value],
-#             content={MessageType.ACTION_RESPONSE.value["content_key"]: action_response},
-#             recipient=recipient or MessageType.ACTION_RESPONSE.value[
-#                 MessageField.RECIPIENT.value],
-#             metadata=metadata or {}, relation=relation or [], **kwargs
-#         )
-
-#     @classmethod
-#     def from_response(cls, response, sender=None, recipient=None, metadata=None,
-#                       relation=None,
-#                       **kwargs):
-#         return cls(action_response=response, sender=sender, recipient=recipient,
-#                    metadata=metadata,
-#                    relation=relation, **kwargs)
-
-
-# class AssistantResponse(BaseMessage):
-
-#     def __init__(self, response: Any, sender: str | None = None,
-#                  recipient: Optional[
-#                      str] = None, metadata: Optional[dict] = None,
-#                  relation: Optional[list] = None,
-#                  **kwargs
-#                  ):
-#         super().__init__(
-#             role='assistant',
-#             sender=sender or MessageType.RESPONSE.value[MessageField.SENDER.value],
-#             content={MessageType.RESPONSE.value["content_key"]: response},
-#             recipient=recipient or MessageType.RESPONSE.value[
-#                 MessageField.RECIPIENT.value],
-#             metadata=metadata or {}, relation=relation or [], **kwargs
-#         )
-
-#     @classmethod
-#     def from_response(cls, response, sender=None, recipient=None, metadata=None,
-#                       relation=None,
-#                       **kwargs):
-#         return cls(response=response, sender=sender, recipient=recipient,
-#                    metadata=metadata,
-#                    relation=relation, **kwargs)

lionagi/core/session/__init__.py

@@ -1,3 +0,0 @@
-from .session import Session
-
-__all__ = ["Session"]