lionagi 0.0.305__py3-none-any.whl → 0.0.307__py3-none-any.whl

lionagi/core/branch/branch_flow_mixin.py

@@ -1,12 +1,9 @@
 from abc import ABC
 from typing import Any, Optional, Union, TypeVar
 
-from lionagi.core.schema.base_node import TOOL_TYPE, Tool
-from lionagi.core.flow.monoflow.mono_chat import MonoChat
-from lionagi.core.flow.monoflow.mono_followup import MonoFollowup
-from lionagi.core.flow.monoflow.mono_react import MonoReAct
-
-from lionagi.core.messages.schema import Instruction, System
+from ..schema import TOOL_TYPE, Tool
+from ..messages import Instruction, System
+from ..flow.monoflow import MonoChat, MonoFollowup, MonoReAct
 
 T = TypeVar("T", bound=Tool)
 
@@ -25,7 +22,6 @@ class BranchFlowMixin(ABC):
         output_fields=None,
         **kwargs,
     ) -> Any:
-
         flow = MonoChat(self)
         return await flow.chat(
             instruction=instruction,

lionagi/core/branch/executable_branch.py

@@ -0,0 +1,192 @@
+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):
+
+    def __init__(self, verbose=True, **kwargs):
+        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:
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=recipient_id,
+            category=category,
+            package=package,
+        )
+        self.pending_outs.append(mail)
+
+    async def forward(self):
+        for key in list(self.pending_ins.keys()):
+            while self.pending_ins[key]:
+                mail = self.pending_ins[key].popleft()
+                if mail.category == "start":  # needed
+                    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":  # needed
+                    self._process_end(mail)
+
+    async def execute(self, refresh_time=1):  # needed
+        while not self.execute_stop:
+            await self.forward()
+            await AsyncUtil.sleep(refresh_time)
+
+    async def _process_node(self, mail: BaseMail):
+
+        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):
+        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):
+        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):
+        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
+    ):
+        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):
+        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):
+        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):
+        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):
+        self.execute_stop = True
+        self.send(mail.sender_id, "end", "end")

lionagi/core/branch/util.py

@@ -1,10 +1,8 @@
+import contextlib
 from datetime import datetime
 from typing import Any
 
-from lionagi.libs import ln_convert as convert
-from lionagi.libs import ln_nested as nested
-from lionagi.libs import ln_func_call as func_call
-from lionagi.libs import ln_dataframe as dataframe
+from lionagi.libs import convert, nested, func_call, dataframe
 
 from lionagi.core.messages.schema import (
     System,
@@ -14,7 +12,6 @@ from lionagi.core.messages.schema import (
     BranchColumns,
 )
 
-
 CUSTOM_TYPE = dict[str, Any] | str | list[Any] | None
 
 
@@ -33,42 +30,41 @@ class MessageUtil:
         Creates a message object based on the input parameters, ensuring only one message role is present.
 
         Args:
-            system: Information for creating a System message.
-            instruction: Information for creating an Instruction message.
-            context: Context information for the message.
-            response: Response data for creating a message.
-            **kwargs: Additional keyword arguments for message creation.
+                system: Information for creating a System message.
+                instruction: Information for creating an Instruction message.
+                context: Context information for the message.
+                response: Response data for creating a message.
+                **kwargs: Additional keyword arguments for message creation.
 
         Returns:
-            A message object of the appropriate type based on provided inputs.
+                A message object of the appropriate type based on provided inputs.
 
         Raises:
-            ValueError: If more than one of the role-specific parameters are provided.
+                ValueError: If more than one of the role-specific parameters are provided.
         """
         if sum(func_call.lcall([system, instruction, response], bool)) != 1:
             raise ValueError("Error: Message must have one and only one role.")
 
-        else:
-            if isinstance(system, System):
-                return system
-            elif isinstance(instruction, Instruction):
-                return instruction
-            elif isinstance(response, Response):
-                return response
-
-            msg = 0
-            if response:
-                msg = Response(response=response, **kwargs)
-            elif instruction:
-                msg = Instruction(
-                    instruction=instruction,
-                    context=context,
-                    output_fields=output_fields,
-                    **kwargs,
-                )
-            elif system:
-                msg = System(system=system, **kwargs)
-            return msg
+        if isinstance(system, System):
+            return system
+        elif isinstance(instruction, Instruction):
+            return instruction
+        elif isinstance(response, Response):
+            return response
+
+        msg = 0
+        if response:
+            msg = Response(response=response, **kwargs)
+        elif instruction:
+            msg = Instruction(
+                instruction=instruction,
+                context=context,
+                output_fields=output_fields,
+                **kwargs,
+            )
+        elif system:
+            msg = System(system=system, **kwargs)
+        return msg
 
     @staticmethod
     def validate_messages(messages: dataframe.ln_DataFrame) -> bool:
@@ -76,21 +72,21 @@ class MessageUtil:
         Validates the format and content of a DataFrame containing messages.
 
         Args:
-            messages: A DataFrame with message information.
+                messages: A DataFrame with message information.
 
         Returns:
-            True if the messages DataFrame is correctly formatted, False otherwise.
+                True if the messages DataFrame is correctly formatted, False otherwise.
 
         Raises:
-            ValueError: If the DataFrame does not match expected schema or content requirements.
+                ValueError: If the DataFrame does not match expected schema or content requirements.
         """
 
         if list(messages.columns) != BranchColumns.COLUMNS.value:
             raise ValueError("Invalid messages dataframe. Unmatched columns.")
         if messages.isnull().values.any():
             raise ValueError("Invalid messages dataframe. Cannot have null.")
-        if not all(
-            role in ["system", "user", "assistant"]
+        if any(
+            role not in ["system", "user", "assistant"]
             for role in messages["role"].unique()
         ):
             raise ValueError(
@@ -115,14 +111,14 @@ class MessageUtil:
         Appends a sender prefix to the 'content' field of each message in a DataFrame.
 
         Args:
-            messages: A DataFrame containing message data.
-            sender: The identifier of the sender to prefix to message contents.
+                messages: A DataFrame containing message data.
+                sender: The identifier of the sender to prefix to message contents.
 
         Returns:
-            A DataFrame with sender-prefixed message contents.
+                A DataFrame with sender-prefixed message contents.
 
         Raises:
-            ValueError: If the sender is None or the value is 'none'.
+                ValueError: If the sender is None or the value is 'none'.
         """
 
         if sender is None or convert.strip_lower(sender) == "none":
@@ -152,16 +148,16 @@ class MessageUtil:
         Filters messages in a DataFrame based on specified criteria.
 
         Args:
-            messages: The DataFrame to filter.
-            role: The role to filter by.
-            sender: The sender to filter by.
-            start_time: The minimum timestamp for messages.
-            end_time: The maximum timestamp for messages.
-            content_keywords: Keywords to look for in message content.
-            case_sensitive: Whether the keyword search should be case-sensitive.
+                messages: The DataFrame to filter.
+                role: The role to filter by.
+                sender: The sender to filter by.
+                start_time: The minimum timestamp for messages.
+                end_time: The maximum timestamp for messages.
+                content_keywords: Keywords to look for in message content.
+                case_sensitive: Whether the keyword search should be case-sensitive.
 
         Returns:
-            A filtered DataFrame based on the specified criteria.
+                A filtered DataFrame based on the specified criteria.
         """
 
         try:
@@ -180,7 +176,7 @@ class MessageUtil:
             return convert.to_df(outs)
 
         except Exception as e:
-            raise ValueError(f"Error in filtering messages: {e}")
+            raise ValueError(f"Error in filtering messages: {e}") from e
 
     @staticmethod
     def remove_message(messages: dataframe.ln_DataFrame, node_id: str) -> bool:
@@ -188,15 +184,15 @@ class MessageUtil:
         Removes a message from the DataFrame based on its node ID.
 
         Args:
-            messages: The DataFrame containing messages.
-            node_id: The unique identifier of the message to be removed.
+                messages: The DataFrame containing messages.
+                node_id: The unique identifier of the message to be removed.
 
         Returns:
-            If any messages are removed.
+                If any messages are removed.
 
         Examples:
-            >>> messages = dataframe.ln_DataFrame([...])
-            >>> updated_messages = MessageUtil.remove_message(messages, "node_id_123")
+                >>> messages = dataframe.ln_DataFrame([...])
+                >>> updated_messages = MessageUtil.remove_message(messages, "node_id_123")
         """
 
         initial_length = len(messages)
@@ -218,15 +214,15 @@ class MessageUtil:
         Retrieves a specified number of message rows based on sender and role.
 
         Args:
-            messages: The DataFrame containing messages.
-            sender: Filter messages by the sender.
-            role: Filter messages by the role.
-            n: The number of messages to retrieve.
-            sign_: If True, sign the message with the sender.
-            from_: Specify retrieval from the 'front' or 'last' of the DataFrame.
+                messages: The DataFrame containing messages.
+                sender: Filter messages by the sender.
+                role: Filter messages by the role.
+                n: The number of messages to retrieve.
+                sign_: If True, sign the message with the sender.
+                from_: Specify retrieval from the 'front' or 'last' of the DataFrame.
 
         Returns:
-            A DataFrame containing the filtered messages.
+                A DataFrame containing the filtered messages.
         """
 
         outs = ""
@@ -266,17 +262,17 @@ class MessageUtil:
         Extends a DataFrame with another DataFrame's rows, ensuring no duplicate 'node_id'.
 
         Args:
-            df1: The primary DataFrame.
-            df2: The DataFrame to merge with the primary DataFrame.
-            **kwargs: Additional keyword arguments for `drop_duplicates`.
+                df1: The primary DataFrame.
+                df2: The DataFrame to merge with the primary DataFrame.
+                **kwargs: Additional keyword arguments for `drop_duplicates`.
 
         Returns:
-            A DataFrame combined from df1 and df2 with duplicates removed based on 'node_id'.
+                A DataFrame combined from df1 and df2 with duplicates removed based on 'node_id'.
 
         Examples:
-            >>> df_main = dataframe.ln_DataFrame([...])
-            >>> df_additional = dataframe.ln_DataFrame([...])
-            >>> combined_df = MessageUtil.extend(df_main, df_additional, keep='first')
+                >>> df_main = dataframe.ln_DataFrame([...])
+                >>> df_additional = dataframe.ln_DataFrame([...])
+                >>> combined_df = MessageUtil.extend(df_main, df_additional, keep='first')
         """
 
         MessageUtil.validate_messages(df2)
@@ -288,7 +284,7 @@ class MessageUtil:
                 )
                 return convert.to_df(df)
         except Exception as e:
-            raise ValueError(f"Error in extending messages: {e}")
+            raise ValueError(f"Error in extending messages: {e}") from e
 
     @staticmethod
     def to_markdown_string(messages: dataframe.ln_DataFrame) -> str:
@@ -296,11 +292,11 @@ class MessageUtil:
         Converts messages in a DataFrame to a Markdown-formatted string for easy reading.
 
         Args:
-            messages: A DataFrame containing messages with columns for 'role' and 'content'.
+                messages: A DataFrame containing messages with columns for 'role' and 'content'.
 
         Returns:
-            A string formatted in Markdown, where each message's content is presented
-            according to its role in a readable format.
+                A string formatted in Markdown, where each message's content is presented
+                according to its role in a readable format.
         """
 
         answers = []
@@ -308,101 +304,20 @@ class MessageUtil:
             content = convert.to_dict(i.content)
 
             if i.role == "assistant":
-                try:
+                with contextlib.suppress(Exception):
                     a = nested.nget(content, ["action_response", "func"])
                     b = nested.nget(content, ["action_response", "arguments"])
                     c = nested.nget(content, ["action_response", "output"])
                     if a is not None:
-                        answers.append(f"Function: {a}")
-                        answers.append(f"Arguments: {b}")
-                        answers.append(f"Output: {c}")
+                        answers.extend(
+                            (f"Function: {a}", f"Arguments: {b}", f"Output: {c}")
+                        )
                     else:
                         answers.append(nested.nget(content, ["assistant_response"]))
-                except:
-                    pass
             elif i.role == "user":
-                try:
+                with contextlib.suppress(Exception):
                     answers.append(nested.nget(content, ["instruction"]))
-                except:
-                    pass
             else:
-                try:
+                with contextlib.suppress(Exception):
                     answers.append(nested.nget(content, ["system_info"]))
-                except:
-                    pass
-
-        out_ = "\n".join(answers)
-        return out_
-
-    # @staticmethod
-    # def to_json_content(value):
-    #     if isinstance(value, dict):
-    #         for key, val in value.items():
-    #             value[key] = MessageUtil.to_json_content(val)
-    #         value = json.dumps(value)
-    #     if isinstance(value, list):
-    #         for i in range(len(value)):
-    #             value[i] = MessageUtil.to_json_content(value[i])
-    #     return value
-
-    # @staticmethod
-    # def to_dict_content(value):
-    #     try:
-    #         value = json.loads(value)
-    #         if isinstance(value, dict):
-    #             for key, val in value.items():
-    #                 value[key] = MessageUtil.to_dict_content(val)
-    #         if isinstance(value, list):
-    #             for i in range(len(value)):
-    #                 value[i] = MessageUtil.to_dict_content(value[i])
-    #         return value
-    #     except:
-    #         return value
-
-    # @staticmethod
-    # def response_to_message(response: dict[str, Any], **kwargs) -> Any:
-    #     """
-    #     Processes a message response dictionary to generate an appropriate message object.
-
-    #     Args:
-    #         response: A dictionary potentially containing message information.
-    #         **kwargs: Additional keyword arguments to pass to the message constructors.
-
-    #     Returns:
-    #         An instance of a message class, such as ActionRequest or AssistantResponse,
-    #         depending on the content of the response.
-    #     """
-    #     try:
-    #         response = response["message"]
-    #         if .strip_lower(response['content']) == "none":
-
-    #             content = ActionRequest._handle_action_request(response)
-    #             return ActionRequest(action_request=content, **kwargs)
-
-    #         else:
-
-    #             try:
-    #                 if 'tool_uses' in to_dict(response[MessageField.CONTENT.value]):
-    #                     content_ = to_dict(response[MessageField.CONTENT.value])[
-    #                         'tool_uses']
-    #                     return ActionRequest(action_request=content_, **kwargs)
-
-    #                 elif MessageContentKey.RESPONSE.value in to_dict(
-    #                         response[MessageField.CONTENT.value]):
-    #                     content_ = to_dict(response[MessageField.CONTENT.value])[
-    #                         MessageContentKey.RESPONSE.value]
-    #                     return AssistantResponse(assistant_response=content_, **kwargs)
-
-    #                 elif MessageContentKey.ACTION_REQUEST.value in to_dict(
-    #                         response[MessageField.CONTENT.value]):
-    #                     content_ = to_dict(response[MessageField.CONTENT.value])[
-    #                         MessageContentKey.ACTION_REQUEST.value]
-    #                     return ActionRequest(action_request=content_, **kwargs)
-
-    #                 else:
-    #                     return AssistantResponse(assistant_response=response, **kwargs)
-
-    #             except:
-    #                 return AssistantResponse(assistant_response=response, **kwargs)
-    #     except:
-    #         return ActionResponse(action_response=response, **kwargs)
+        return "\n".join(answers)

lionagi/core/direct/__init__.py

@@ -0,0 +1,13 @@
+from .predict import predict
+from .select import select
+from .score import score
+from .sentiment import sentiment
+from .react import react
+
+__all__ = [
+    "predict",
+    "select",
+    "score",
+    "sentiment",
+    "react",
+]