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

lionagi/core/branch/executable_branch.py

@@ -1,27 +1,20 @@
+import contextlib
 from collections import deque
 from typing import Any
 
-from IPython.display import Markdown, display
+from lionagi.libs import convert, AsyncUtil, ParseUtil
 
-import lionagi.libs.ln_convert as convert
-from lionagi.libs.ln_async import AsyncUtil
-from lionagi.libs.ln_parse import ParseUtil
+from ..schema import BaseRelatableNode, ActionNode
+from ..mail import BaseMail
+from ..messages import System, Instruction
+from ..agent import BaseAgent
 
-from lionagi.core.schema.base_node import BaseRelatableNode
-from lionagi.core.schema.action_node import ActionNode
-
-from lionagi.core.mail.schema import BaseMail
-
-from lionagi.core.messages.schema import System, Instruction
-
-
-from lionagi import Branch
-from lionagi.core.agent.base_agent import BaseAgent
+from .branch import Branch
 
 
 class ExecutableBranch(BaseRelatableNode):
 
-    def __init__(self, **kwargs):
+    def __init__(self, verbose=True, **kwargs):
         super().__init__()
         self.branch: Branch = Branch(**kwargs)
         self.pending_ins = {}  # needed
@@ -29,6 +22,8 @@ class ExecutableBranch(BaseRelatableNode):
         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(
@@ -45,8 +40,12 @@ class ExecutableBranch(BaseRelatableNode):
                 mail = self.pending_ins[key].popleft()
                 if mail.category == "start":  # needed
                     self._process_start(mail)
-                if mail.category == "node":
+                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)
 
@@ -58,28 +57,40 @@ class ExecutableBranch(BaseRelatableNode):
     async def _process_node(self, mail: BaseMail):
 
         if isinstance(mail.package, System):
-            self._system_process(mail.package)
+            self._system_process(mail.package, verbose=self.verbose)
             self.send(mail.sender_id, "node_id", mail.package.id_)
-            return
 
         elif isinstance(mail.package, Instruction):
-            await self._instruction_process(mail.package)
+            await self._instruction_process(mail.package, verbose=self.verbose)
             self.send(mail.sender_id, "node_id", mail.package.id_)
-            return
 
         elif isinstance(mail.package, ActionNode):
-            await self._action_process(mail.package)
+            await self._action_process(mail.package, verbose=self.verbose)
             self.send(mail.sender_id, "node_id", mail.package.instruction.id_)
-            return
+        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}")
 
-        elif isinstance(mail.package, BaseAgent):
-            await self._agent_process(mail.package)
-            self.send(mail.sender_id, "node_id", mail.package.id_)
-            return
+    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.recipient}------------------")
+            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)}"))
@@ -89,6 +100,9 @@ class ExecutableBranch(BaseRelatableNode):
     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(
@@ -101,54 +115,41 @@ class ExecutableBranch(BaseRelatableNode):
             self.context = None
 
         result = await self.branch.chat(instruction, **kwargs)
-        try:
+        with contextlib.suppress(Exception):
             result = ParseUtil.fuzzy_parse_json(result)
             if "response" in result.keys():
                 result = result["response"]
-        except:
-            pass
-
-        if verbose:
+        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):
-        context = self.responses
-        result = await agent.execute(context)
-
-        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")
-
-    async def _action_process(self, action: ActionNode):
-        # instruction = action.instruction
-        # if self.context:
-        #     instruction.content.update({"context": self.context})
-        #     self.context=None
+    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)
-        # result = await func(instruction, tools=action.tools, **action.action_kwargs)
         if self.context:
             result = await func(
-                action.instruction.content,
+                action.instruction.content["instruction"],
                 context=self.context,
                 tools=action.tools,
                 **action.action_kwargs,
@@ -158,5 +159,34 @@ class ExecutableBranch(BaseRelatableNode):
             result = await func(
                 action.instruction.content, tools=action.tools, **action.action_kwargs
             )
-        print("action calls:", result)
+
+        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/{flow/direct → direct}/__init__.py

@@ -10,4 +10,4 @@ __all__ = [
     "score",
     "sentiment",
     "react",
-]
+]