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

lionagi/core/__init__.py

@@ -1,15 +1,26 @@
 from . import *
 
-from .branch import Branch, ExecutableBranch
-from .session import Session
-from .schema import (
-    Tool,
-    Structure,
+from .branch.branch import Branch
+from .session.session import Session
+from .generic import (
     ActionNode,
-    Relationship,
     ActionSelection,
     Condition,
 )
-from .agent import BaseAgent
-from .messages import Instruction, System, Response
+from .agent.base_agent import BaseAgent
+from .messages.schema import Instruction, System, Response
 from .tool import func_to_tool
+
+
+__all__ = [
+    "ActionNode",
+    "ActionSelection",
+    "Branch",
+    "Condition",
+    "Session",
+    "System",
+    "Instruction",
+    "Response",
+    "BaseAgent",
+    "func_to_tool",
+]

lionagi/core/agent/__init__.py

@@ -1,3 +0,0 @@
-from .base_agent import BaseAgent
-
-__all__ = ["BaseAgent"]

lionagi/core/agent/base_agent.py

@@ -2,37 +2,28 @@
 This module contains the BaseAgent class, which serves as a base class for agents.
 """
 
-from lionagi.core.mail.schema import StartMail
-from lionagi.core.schema.base_node import BaseRelatableNode
-from lionagi.core.mail.mail_manager import MailManager
+from pydantic import Field
+from typing import Any, Callable
 
 from lionagi.libs import func_call, AsyncUtil
 
 
-class BaseAgent(BaseRelatableNode):
-    """
-    A base class for agents.
-
-    Attributes:
-        structure: The structure of the agent.
-        executable: The executable object of the agent.
-        start: The StartMail object for triggering the agent.
-        mailManager: The MailManager object for managing agent communication.
-        output_parser: A function for parsing the agent's output (optional).
-        start_context: The initial context for the agent (optional).
-
-    Methods:
-        __init__(self, structure, executable_obj, output_parser=None) -> None:
-            Initializes the BaseAgent instance.
+from lionagi.core.mail.schema import StartMail
+from lionagi.core.generic import Node
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.execute.base_executor import BaseExecutor
+from lionagi.core.execute.structure_executor import StructureExecutor
 
-        async mail_manager_control(self, refresh_time=1) -> None:
-            Controls the mail manager execution based on the structure and executable states.
 
-        async execute(self, context=None) -> Any:
-            Executes the agent with the given context and returns the parsed output (if available).
-    """
+class BaseAgent(Node):
 
-    def __init__(self, structure, executable_obj, output_parser=None) -> None:
+    def __init__(
+        self,
+        structure: StructureExecutor,
+        executable: BaseExecutor,
+        output_parser=None,
+        **kwargs,
+    ) -> None:
         """
         Initializes the BaseAgent instance.
 
@@ -42,12 +33,16 @@ class BaseAgent(BaseRelatableNode):
             output_parser: A function for parsing the agent's output (optional).
         """
         super().__init__()
-        self.structure = structure
-        self.executable = executable_obj
-        self.start = StartMail()
-        self.mailManager = MailManager([self.structure, self.executable, self.start])
-        self.output_parser = output_parser
-        self.start_context = None
+        self.structure: StructureExecutor = structure
+        self.executable: BaseExecutor = executable
+        for v, k in kwargs.items():
+            executable.__setattr__(v, k)
+        self.start: StartMail = StartMail()
+        self.mailManager: MailManager = MailManager(
+            [self.structure, self.executable, self.start]
+        )
+        self.output_parser: Callable | None = output_parser
+        self.start_context: Any | None = None
 
     async def mail_manager_control(self, refresh_time=1):
         """
@@ -92,3 +87,4 @@ class BaseAgent(BaseRelatableNode):
 
         if self.output_parser:
             return self.output_parser(self)
+        

lionagi/core/branch/__init__.py

@@ -1,4 +0,0 @@
-from .branch import Branch
-from .executable_branch import ExecutableBranch
-
-__all__ = ["Branch", "ExecutableBranch"]

lionagi/core/branch/{base_branch.py → base.py}

@@ -1,22 +1,21 @@
 from abc import ABC
 from typing import Any
 
-from lionagi.libs.sys_util import PATH_TYPE
+from pathlib import Path
 from lionagi.libs import convert, dataframe, SysUtil
 
-from ..schema.base_node import BaseRelatableNode
-from ..schema.data_logger import DataLogger, DLog
-from ..messages.schema import (
+from lionagi.core.generic import BaseNode, DataLogger, DLog
+from lionagi.core.messages.schema import (
     BranchColumns,
     System,
     Response,
     Instruction,
     BaseMessage,
 )
-from .util import MessageUtil
+from lionagi.core.branch.util import MessageUtil
 
 
-class BaseBranch(BaseRelatableNode, ABC):
+class BaseBranch(BaseNode, ABC):
     """
     Base class for managing branches of conversation, incorporating messages
     and logging functionality.
@@ -24,7 +23,7 @@ class BaseBranch(BaseRelatableNode, ABC):
     Attributes:
             messages (dataframe.ln_DataFrame): Holds the messages in the branch.
             datalogger (DataLogger): Logs data related to the branch's operation.
-            persist_path (PATH_TYPE): Filesystem path for data persistence.
+            persist_path (str | Path): Filesystem path for data persistence.
     """
 
     _columns: list[str] = BranchColumns.COLUMNS.value
@@ -33,7 +32,7 @@ class BaseBranch(BaseRelatableNode, ABC):
         self,
         messages: dataframe.ln_DataFrame | None = None,
         datalogger: DataLogger | None = None,
-        persist_path: PATH_TYPE | None = None,
+        persist_path: str | Path | None = None,
         name=None,
         **kwargs,
     ) -> None:
@@ -97,6 +96,7 @@ class BaseBranch(BaseRelatableNode, ABC):
                 if self.name is not None:
                     _msg.sender = self.name
 
+        setattr(_msg, "node_id", _msg.id_)
         _msg.content = _msg.msg_content
         self.messages.loc[len(self.messages)] = _msg.to_pd_series()
 
@@ -332,7 +332,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def to_csv_file(
         self,
-        filename: PATH_TYPE = "messages.csv",
+        filename: str | Path = "messages.csv",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -375,7 +375,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def to_json_file(
         self,
-        filename: PATH_TYPE = "messages.json",
+        filename: str | Path = "messages.json",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -420,7 +420,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def log_to_csv(
         self,
-        filename: PATH_TYPE = "log.csv",
+        filename: str | Path = "log.csv",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -456,7 +456,7 @@ class BaseBranch(BaseRelatableNode, ABC):
 
     def log_to_json(
         self,
-        filename: PATH_TYPE = "log.json",
+        filename: str | Path = "log.json",
         dir_exist_ok: bool = True,
         timestamp: bool = True,
         time_prefix: bool = False,
@@ -636,7 +636,6 @@ class BaseBranch(BaseRelatableNode, ABC):
             case_sensitive=case_sensitive,
         )
 
-    # noinspection PyTestUnpassedFixture
     def _info(self, use_sender: bool = False) -> dict[str, int]:
         """
         Helper method to generate summaries of messages either by role or sender.
@@ -651,4 +650,4 @@ class BaseBranch(BaseRelatableNode, ABC):
         messages = self.messages["sender"] if use_sender else self.messages["role"]
         result = messages.value_counts().to_dict()
         result["total"] = len(self.messages)
-        return result
+        return result

lionagi/core/branch/branch.py

@@ -4,19 +4,18 @@ This module contains the Branch class, which represents a branch in a conversati
 
 from collections import deque
 from typing import Any, Union, TypeVar, Callable
+from pathlib import Path
 
-from lionagi.libs.sys_util import PATH_TYPE
 from lionagi.libs import StatusTracker, BaseService, convert, dataframe
 
-from ..schema import TOOL_TYPE, Tool, DataLogger
-from ..tool import ToolManager, func_to_tool
+from lionagi.core.generic import DataLogger
+from lionagi.core.tool import ToolManager, func_to_tool, Tool, TOOL_TYPE
+from lionagi.core.messages.schema import System
+from lionagi.core.mail.schema import BaseMail
 
-from ..messages import System
-from ..mail import BaseMail
-
-from .util import MessageUtil
-from .base_branch import BaseBranch
-from .branch_flow_mixin import BranchFlowMixin
+from lionagi.core.branch.util import MessageUtil
+from lionagi.core.branch.base import BaseBranch
+from lionagi.core.branch.flow_mixin import BranchFlowMixin
 
 from dotenv import load_dotenv
 
@@ -95,7 +94,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: list[Callable | Tool] | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         **kwargs,
     ):
@@ -111,7 +110,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (list[Callable | Tool]): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             **kwargs: Additional keyword arguments.
 
@@ -165,7 +164,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: TOOL_TYPE | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         read_kwargs=None,
         **kwargs,
@@ -180,7 +179,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (TOOL_TYPE): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             read_kwargs: Additional keyword arguments for reading the CSV file (optional).
             **kwargs: Additional keyword arguments.
@@ -211,7 +210,7 @@ class Branch(BaseBranch, BranchFlowMixin):
         llmconfig: dict[str, str | int | dict] | None = None,
         tools: TOOL_TYPE | None = None,
         datalogger: None | DataLogger = None,
-        persist_path: PATH_TYPE | None = None,  # instruction_sets=None,
+        persist_path: str | Path | None = None,  # instruction_sets=None,
         tool_manager: ToolManager | None = None,
         read_kwargs=None,
         **kwargs,
@@ -226,7 +225,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             llmconfig (dict[str, str | int | dict]): The configuration for the language model (optional).
             tools (TOOL_TYPE): The tools to register in the branch (optional).
             datalogger (DataLogger): The data logger for the branch (optional).
-            persist_path (PATH_TYPE): The path to persist the branch data (optional).
+            persist_path (str | Path): The path to persist the branch data (optional).
             tool_manager (ToolManager): The tool manager for the branch (optional).
             read_kwargs: Additional keyword arguments for reading the JSON string file (optional).
             **kwargs: Additional keyword arguments.
@@ -348,7 +347,7 @@ class Branch(BaseBranch, BranchFlowMixin):
             print("tools deletion failed")
         return False
 
-    def send(self, recipient: str, category: str, package: Any) -> None:
+    def send(self, recipient_id: str, category: str, package: Any) -> None:
         """
         Sends a mail to a recipient.
 
@@ -357,10 +356,13 @@ class Branch(BaseBranch, BranchFlowMixin):
             category (str): The category of the mail.
             package (Any): The package to send in the mail.
         """
-        mail_ = BaseMail(
-            sender=self.sender, recipient=recipient, category=category, package=package
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=recipient_id,
+            category=category,
+            package=package,
         )
-        self.pending_outs.append(mail_)
+        self.pending_outs.append(mail)
 
     def receive(
         self,
@@ -468,4 +470,4 @@ class Branch(BaseBranch, BranchFlowMixin):
             }:
                 return True
         except Exception:
-            return False
+            return False

lionagi/core/branch/executable_branch.py

@@ -1,347 +0,0 @@
-"""
-This module contains the ExecutableBranch class, which represents an executable branch in a conversation tree.
-"""
-
-import contextlib
-from collections import deque
-from typing import Any
-
-from lionagi.libs import convert, AsyncUtil, ParseUtil
-
-from ..schema import BaseRelatableNode, ActionNode
-from ..mail import BaseMail
-from ..messages import System, Instruction
-from ..agent import BaseAgent
-
-from .branch import Branch
-
-
-class ExecutableBranch(BaseRelatableNode):
-    """
-    Represents an executable branch in a conversation tree.
-
-    Attributes:
-        branch (Branch): The branch associated with the executable branch.
-        pending_ins (dict): The pending incoming mails for the executable branch.
-        pending_outs (deque): The pending outgoing mails for the executable branch.
-        responses (list): The responses generated by the executable branch.
-        execute_stop (bool): A flag indicating whether the execution should stop.
-        context (Any): The context of the executable branch.
-        context_log (list): The log of contexts for the executable branch.
-        verbose (bool): A flag indicating whether to provide verbose output.
-
-    Methods:
-        __init__(self, verbose=True, **kwargs) -> None:
-            Initializes the ExecutableBranch instance.
-
-        send(self, recipient_id: str, category: str, package: Any) -> None:
-            Sends a mail to a recipient.
-
-        async forward(self) -> None:
-            Forwards the pending incoming mails to the appropriate processing methods.
-
-        async execute(self, refresh_time=1) -> None:
-            Executes the executable branch.
-
-        async _process_node(self, mail: BaseMail) -> None:
-            Processes a node mail.
-
-        _process_node_list(self, mail: BaseMail) -> None:
-            Processes a node list mail.
-
-        _process_condition(self, mail: BaseMail) -> None:
-            Processes a condition mail.
-
-        _system_process(self, system: System, verbose=True, context_verbose=False) -> None:
-            Processes a system message.
-
-        async _instruction_process(self, instruction: Instruction, verbose=True, **kwargs) -> None:
-            Processes an instruction message.
-
-        async _action_process(self, action: ActionNode, verbose=True) -> None:
-            Processes an action node.
-
-        async _agent_process(self, agent, verbose=True) -> None:
-            Processes an agent.
-
-        _process_start(self, mail: BaseMail) -> None:
-            Processes a start mail.
-
-        _process_end(self, mail: BaseMail) -> None:
-            Processes an end mail.
-    """
-
-    def __init__(self, verbose=True, **kwargs):
-        """
-        Initializes the ExecutableBranch instance.
-
-        Args:
-            verbose (bool): A flag indicating whether to provide verbose output (default: True).
-            **kwargs: Additional keyword arguments for initializing the branch.
-        """
-        super().__init__()
-        self.branch: Branch = Branch(**kwargs)
-        self.pending_ins = {}  # needed
-        self.pending_outs = deque()  # needed
-        self.responses = []
-        self.execute_stop = False  # needed
-        self.context = None  # needed
-        self.context_log = []
-        self.verbose = verbose
-
-    def send(self, recipient_id: str, category: str, package: Any) -> None:
-        """
-        Sends a mail to a recipient.
-
-        Args:
-            recipient_id (str): The ID of the recipient.
-            category (str): The category of the mail.
-            package (Any): The package to send in the mail.
-        """
-        mail = BaseMail(
-            sender_id=self.id_,
-            recipient_id=recipient_id,
-            category=category,
-            package=package,
-        )
-        self.pending_outs.append(mail)
-
-    async def forward(self) -> None:
-        """
-        Forwards the pending incoming mails to the appropriate processing methods.
-        """
-        for key in list(self.pending_ins.keys()):
-            while self.pending_ins[key]:
-                mail = self.pending_ins[key].popleft()
-                if mail.category == "start":
-                    self._process_start(mail)
-                elif mail.category == "node":
-                    await self._process_node(mail)
-                elif mail.category == "node_list":
-                    self._process_node_list(mail)
-                elif mail.category == "condition":
-                    self._process_condition(mail)
-                elif mail.category == "end":
-                    self._process_end(mail)
-
-    async def execute(self, refresh_time=1) -> None:
-        """
-        Executes the executable branch.
-
-        Args:
-            refresh_time (int): The refresh time for execution (default: 1).
-        """
-        while not self.execute_stop:
-            await self.forward()
-            await AsyncUtil.sleep(refresh_time)
-
-    async def _process_node(self, mail: BaseMail):
-        """
-        Processes a node mail.
-
-        Args:
-            mail (BaseMail): The node mail to process.
-
-        Raises:
-            ValueError: If the mail package is invalid.
-        """
-        if isinstance(mail.package, System):
-            self._system_process(mail.package, verbose=self.verbose)
-            self.send(mail.sender_id, "node_id", mail.package.id_)
-
-        elif isinstance(mail.package, Instruction):
-            await self._instruction_process(mail.package, verbose=self.verbose)
-            self.send(mail.sender_id, "node_id", mail.package.id_)
-
-        elif isinstance(mail.package, ActionNode):
-            await self._action_process(mail.package, verbose=self.verbose)
-            self.send(mail.sender_id, "node_id", mail.package.instruction.id_)
-        else:
-            try:
-                await self._agent_process(mail.package, verbose=self.verbose)
-                self.send(mail.sender_id, "node_id", mail.package.id_)
-            except:
-                raise ValueError(f"Invalid mail to process. Mail:{mail}")
-
-    def _process_node_list(self, mail: BaseMail):
-        """
-        Processes a node list mail.
-
-        Args:
-            mail (BaseMail): The node list mail to process.
-
-        Raises:
-            ValueError: If multiple path selection is not supported.
-        """
-        self.send(mail.sender_id, "end", "end")
-        self.execute_stop = True
-        raise ValueError("Multiple path selection is currently not supported")
-
-    def _process_condition(self, mail: BaseMail):
-        """
-        Processes a condition mail.
-
-        Args:
-            mail (BaseMail): The condition mail to process.
-        """
-        relationship = mail.package
-        check_result = relationship.condition(self)
-        back_mail = {"relationship_id": mail.package.id_, "check_result": check_result}
-        self.send(mail.sender_id, "condition", back_mail)
-
-    def _system_process(self, system: System, verbose=True, context_verbose=False):
-        """
-        Processes a system message.
-
-        Args:
-            system (System): The system message to process.
-            verbose (bool): A flag indicating whether to provide verbose output (default: True).
-            context_verbose (bool): A flag indicating whether to display the context (default: False).
-        """
-        from lionagi.libs import SysUtil
-
-        SysUtil.check_import("IPython")
-        from IPython.display import Markdown, display
-
-        if verbose:
-            print(f"------------------Welcome: {system.sender}--------------------")
-            display(Markdown(f"system: {convert.to_str(system.system_info)}"))
-            if self.context and context_verbose:
-                display(Markdown(f"context: {convert.to_str(self.context)}"))
-
-        self.branch.add_message(system=system)
-
-    async def _instruction_process(
-        self, instruction: Instruction, verbose=True, **kwargs
-    ):
-        """
-        Processes an instruction message.
-
-        Args:
-            instruction (Instruction): The instruction message to process.
-            verbose (bool): A flag indicating whether to provide verbose output (default: True).
-            **kwargs: Additional keyword arguments for processing the instruction.
-        """
-        from lionagi.libs import SysUtil
-
-        SysUtil.check_import("IPython")
-        from IPython.display import Markdown, display
-
-        if verbose:
-            display(
-                Markdown(
-                    f"{instruction.sender}: {convert.to_str(instruction.instruct)}"
-                )
-            )
-
-        if self.context:
-            instruction.content.update({"context": self.context})
-            self.context = None
-
-        result = await self.branch.chat(instruction, **kwargs)
-        with contextlib.suppress(Exception):
-            result = ParseUtil.fuzzy_parse_json(result)
-            if "response" in result.keys():
-                result = result["response"]
-        if verbose and len(self.branch.assistant_responses) != 0:
-            display(
-                Markdown(
-                    f"{self.branch.last_assistant_response.sender}: {convert.to_str(result)}"
-                )
-            )
-            print("-----------------------------------------------------")
-
-        self.responses.append(result)
-
-    async def _action_process(self, action: ActionNode, verbose=True):
-        """
-        Processes an action node.
-
-        Args:
-            action (ActionNode): The action node to process.
-            verbose (bool): A flag indicating whether to provide verbose output (default: True).
-
-        Raises:
-            ValueError: If the action is not valid.
-        """
-        from lionagi.libs import SysUtil
-
-        SysUtil.check_import("IPython")
-        from IPython.display import Markdown, display
-
-        try:
-            func = getattr(self.branch, action.action)
-        except:
-            raise ValueError(f"{action.action} is not a valid action")
-
-        if verbose:
-            display(
-                Markdown(
-                    f"{action.instruction.sender}: {convert.to_str(action.instruction.instruct)}"
-                )
-            )
-
-        if action.tools:
-            self.branch.register_tools(action.tools)
-        if self.context:
-            result = await func(
-                action.instruction.content["instruction"],
-                context=self.context,
-                tools=action.tools,
-                **action.action_kwargs,
-            )
-            self.context = None
-        else:
-            result = await func(
-                action.instruction.content, tools=action.tools, **action.action_kwargs
-            )
-
-        if verbose and len(self.branch.assistant_responses) != 0:
-            display(
-                Markdown(
-                    f"{self.branch.last_assistant_response.sender}: {convert.to_str(result)}"
-                )
-            )
-            print("-----------------------------------------------------")
-
-        self.responses.append(result)
-
-    async def _agent_process(self, agent, verbose=True):
-        """
-        Processes an agent.
-
-        Args:
-            agent: The agent to process.
-            verbose (bool): A flag indicating whether to provide verbose output (default: True).
-        """
-        context = self.responses
-        if verbose:
-            print("*****************************************************")
-        result = await agent.execute(context)
-
-        if verbose:
-            print("*****************************************************")
-
-        self.context = result
-        self.responses.append(result)
-
-    def _process_start(self, mail):
-        """
-        Processes a start mail.
-
-        Args:
-            mail (BaseMail): The start mail to process.
-        """
-        start_mail_content = mail.package
-        self.context = start_mail_content["context"]
-        self.send(start_mail_content["structure_id"], "start", "start")
-
-    def _process_end(self, mail):
-        """
-        Processes an end mail.
-
-        Args:
-            mail (BaseMail): The end mail to process.
-        """
-        self.execute_stop = True
-        self.send(mail.sender_id, "end", "end")