lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/core/engine/branch_engine.py

@@ -0,0 +1,333 @@
+import contextlib
+from lionagi.libs import convert, AsyncUtil, ParseUtil
+from lionagi.core.generic.edge import Edge
+from lionagi.core.action import ActionNode
+from lionagi.core.mail.mail import Mail
+from lionagi.core.message import System, Instruction
+from lionagi.core.collections import Pile, Progression
+
+from lionagi.core.session.branch import Branch
+from lionagi.core.executor.base_executor import BaseExecutor
+
+
+class BranchExecutor(Branch, BaseExecutor):
+
+    def __init__(
+        self,
+        context=None,
+        verbose=True,
+        system=None,
+        user=None,
+        messages=None,
+        progress=None,
+        tool_manager=None,
+        tools=None,
+        imodel=None,
+        **kwargs,
+    ):
+        super().__init__(
+            system=system,
+            user=user,
+            messages=messages,
+            progress=progress,
+            tool_manager=tool_manager,
+            tools=tools,
+            imodel=imodel,
+            **kwargs,
+        )
+        self.context = context
+        self.verbose = verbose
+
+    async def forward(self) -> None:
+        """
+        Forwards the execution by processing all pending incoming mails in each branch. Depending on the category of the mail,
+        it processes starts, nodes, node lists, conditions, or ends, accordingly executing different functions.
+        """
+        for key in list(self.mailbox.pending_ins.keys()):
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile.pop(mail_id)
+                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":
+                    await self._process_condition(mail)
+                elif mail.category == "end":
+                    self._process_end(mail)
+            if self.mailbox.pending_ins[key].size() == 0:
+                self.mailbox.pending_ins.pop(key)
+
+    async def execute(self, refresh_time=1) -> None:
+        """
+        Executes the forward process repeatedly at specified time intervals until execution is instructed to stop.
+
+        Args:
+            refresh_time (int): The interval, in seconds, at which the forward method is called repeatedly.
+        """
+        while not self.execute_stop:
+            await self.forward()
+            await AsyncUtil.sleep(refresh_time)
+
+    async def _process_node(self, mail: Mail):
+        """
+        Processes a single node based on the node type specified in the mail's package. It handles different types of nodes such as System,
+        Instruction, ActionNode, and generic nodes through separate processes.
+
+        Args:
+            mail (Mail): The mail containing the node to be processed along with associated details.
+
+        Raises:
+            ValueError: If an invalid mail is encountered or the process encounters errors.
+        """
+        node = mail.package.package
+        if isinstance(node, System):
+            self._system_process(node, verbose=self.verbose)
+            self.send(
+                recipient=mail.sender,
+                category="node_id",
+                package=node.ln_id,
+                request_source=self.ln_id,
+            )
+
+        elif isinstance(node, Instruction):
+            await self._instruction_process(node, verbose=self.verbose)
+            self.send(
+                recipient=mail.sender,
+                category="node_id",
+                package=node.ln_id,
+                request_source=self.ln_id,
+            )
+
+        elif isinstance(node, ActionNode):
+            await self._action_process(node, verbose=self.verbose)
+            self.send(
+                recipient=mail.sender,
+                category="node_id",
+                package=node.instruction.ln_id,
+                request_source=self.ln_id,
+            )
+        else:
+            try:
+                await self._agent_process(node, verbose=self.verbose)
+                self.send(
+                    recipient=mail.sender,
+                    category="node_id",
+                    package=node.ln_id,
+                    request_source=self.ln_id,
+                )
+            except:
+                raise ValueError(f"Invalid mail to process. Mail:{mail}")
+
+    def _process_node_list(self, mail: Mail):
+        """
+        Processes a list of nodes provided in the mail, but currently only sends an end signal as multiple path selection is not supported.
+
+        Args:
+            mail (BaseMail): The mail containing a list of nodes to be processed.
+
+        Raises:
+            ValueError: When trying to process multiple paths which is currently unsupported.
+        """
+        self.send(mail.sender, category="end", package="end", request_source=self.ln_id)
+        self.execute_stop = True
+        raise ValueError("Multiple path selection is not supported in BranchExecutor")
+
+    async def _process_condition(self, mail: Mail):
+        """
+        Processes a condition associated with an edge based on the mail's package, setting up the result of the condition check.
+
+        Args:
+            mail (BaseMail): The mail containing the condition to be processed.
+        """
+        edge: Edge = mail.package.package
+        check_result = await edge.check_condition(self)
+        back_mail = {
+            "from": self.ln_id,
+            "edge_id": edge.ln_id,
+            "check_result": check_result,
+        }
+        self.send(
+            recipient=mail.sender,
+            category="condition",
+            package=back_mail,
+            request_source=self.ln_id,
+        )
+
+    def _system_process(self, system: System, verbose=True, context_verbose=False):
+        """
+        Processes a system node, possibly displaying its content and context if verbose is enabled.
+
+        Args:
+            system (System): The system node to process.
+            verbose (bool): Flag to enable verbose output.
+            context_verbose (bool): Flag to enable verbose output specifically for context.
+        """
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        if verbose:
+            print(f"------------------Welcome: {system.sender}--------------------")
+            with contextlib.suppress(Exception):
+                system.content = ParseUtil.fuzzy_parse_json(system.content)
+            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.add_message(system=system)
+
+    async def _instruction_process(
+        self, instruction: Instruction, verbose=True, **kwargs
+    ):
+        """
+        Processes an instruction node, possibly displaying its content if verbose is enabled, and handling any additional keyword arguments.
+
+        Args:
+            instruction (Instruction): The instruction node to process.
+            verbose (bool): Flag to enable verbose output.
+            **kwargs: Additional keyword arguments that might affect how instructions are processed.
+        """
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        if verbose:
+            with contextlib.suppress(Exception):
+                instruction.content = ParseUtil.fuzzy_parse_json(instruction.content)
+            display(
+                Markdown(
+                    f"{instruction.sender}: {convert.to_str(instruction.instruct)}"
+                )
+            )
+
+        if self.context:
+            result = await self.chat(
+                instruction=instruction.instruct, context=self.context, **kwargs
+            )
+            self.context = None
+        else:
+            result = await self.chat(instruction=instruction.instruct, **kwargs)
+            # instruction._add_context(context=self.context)
+            # self.context_log.append(self.context)
+            # self.context = None
+
+        with contextlib.suppress(Exception):
+            result = ParseUtil.fuzzy_parse_json(result)
+            if "assistant_response" in result.keys():
+                result = result["assistant_response"]
+        if verbose:
+            display(Markdown(f"assistant {self.ln_id}: {convert.to_str(result)}"))
+            print("-----------------------------------------------------")
+
+        self.execution_responses.append(result)
+
+    async def _action_process(self, action: ActionNode, verbose=True):
+        """
+        Processes an action node, executing the defined action along with any tools specified within the node.
+
+        Args:
+            action (ActionNode): The action node to process.
+            verbose (bool): Flag to enable verbose output of the action results.
+        """
+        from lionagi.libs import SysUtil
+
+        SysUtil.check_import("IPython")
+        from IPython.display import Markdown, display
+
+        # try:
+        #     func = getattr(self, 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.register_tools(action.tools)
+        # if self.context:
+        # result = await self.direct(
+        #     action.directive,
+        #     instruction=action.instruction.instruct,
+        #     context=self.context,
+        #     tools=action.tools,
+        #     **action.directive_kwargs,
+        # )
+        result = await action.invoke(branch=self, context=self.context)
+        self.context = None
+        # else:
+        #     result = await self.direct(
+        #         action.directive,
+        #         instruction=action.instruction.content,
+        #         tools=action.tools,
+        #         **action.directive_kwargs
+        #     )
+
+        if verbose:
+            if action.directive == "chat":
+                display(Markdown(f"assistant {self.ln_id}: {convert.to_str(result)}"))
+            else:
+                display(Markdown(f"assistant {self.ln_id}:\n"))
+                for k, v in result.work_fields.items():
+                    display(Markdown(f"{k}: \n{v}\n"))
+            print("-----------------------------------------------------")
+
+        self.execution_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 = [msg["content"] for msg in self.to_chat_messages()]
+        if verbose:
+            print("*****************************************************")
+        result = await agent.execute(context)
+
+        if verbose:
+            print("*****************************************************")
+
+        self.context = result
+        self.execution_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.package
+        self.context = start_mail_content["context"]
+        self.send(
+            recipient=start_mail_content["structure_id"],
+            category="start",
+            package="start",
+            request_source=self.ln_id,
+        )
+
+    def _process_end(self, mail: Mail):
+        """
+        Processes an end mail.
+
+        Args:
+            mail (BaseMail): The end mail to process.
+        """
+        self.execute_stop = True
+        self.send(
+            recipient=mail.sender,
+            category="end",
+            package="end",
+            request_source=self.ln_id,
+        )

lionagi/core/engine/instruction_map_engine.py

@@ -0,0 +1,204 @@
+import asyncio
+from pydantic import Field
+
+from lionagi.core.mail.mail import Mail, Package
+from lionagi.core.collections import Exchange
+from lionagi.core.mail.mail_manager import MailManager
+from lionagi.core.executor.base_executor import BaseExecutor
+from lionagi.core.engine.branch_engine import BranchExecutor
+from lionagi.core.collections import progression, pile, Pile
+
+
+class InstructionMapEngine(BaseExecutor):
+    """
+    Manages the execution of a mapped set of instructions across multiple branches within an executable structure.
+
+    Attributes:
+        branches (dict[str, BranchExecutor]): A dictionary of branch executors managing individual instruction flows.
+        structure_id (str): The identifier for the structure within which these branches operate.
+        mail_transfer (Exchange): Handles the transfer of mail between branches and other components.
+        branch_kwargs (dict): Keyword arguments used for initializing branches.
+        num_end_branches (int): Tracks the number of branches that have completed execution.
+        mail_manager (MailManager): Manages the distribution and collection of mails across branches.
+    """
+
+    branches: Pile[BranchExecutor] = Field(
+        default_factory=dict, description="The branches of the instruction mapping."
+    )
+    structure_id: str = Field("", description="The ID of the executable structure.")
+    mail_transfer: Exchange = Field(
+        default_factory=Exchange, description="The mail transfer."
+    )
+    branch_kwargs: dict = Field(
+        default_factory=dict,
+        description="The keyword arguments for the initializing the branches.",
+    )
+    num_end_branches: int = Field(0, description="The number of end branches.")
+    mail_manager: MailManager = Field(
+        default_factory=MailManager, description="The mail manager."
+    )
+
+    def __init__(self, **kwargs):
+        """
+        Initializes an InstructionMapExecutor with the given parameters.
+
+        Args:
+            **kwargs: Arbitrary keyword arguments passed to the base executor and used for initializing branch executors.
+        """
+        super().__init__(**kwargs)
+        self.mail_manager = MailManager([self.mail_transfer])
+
+    def transfer_ins(self):
+        """
+        Processes incoming mails, directing them appropriately based on their categories, and handles the initial setup
+        of branches or the routing of node and condition mails.
+        """
+        for key in list(self.mailbox.pending_ins.keys()):
+            while self.mailbox.pending_ins[key].size() > 0:
+                mail_id = self.mailbox.pending_ins[key].popleft()
+                mail = self.mailbox.pile.pop(mail_id)
+                if mail.category == "start":
+                    self._process_start(mail)
+                elif mail.category == "node_list":
+                    self._process_node_list(mail)
+                elif (
+                    (mail.category == "node")
+                    or (mail.category == "condition")
+                    or (mail.category == "end")
+                ):
+                    mail.sender = self.mail_transfer.ln_id
+                    mail.recipient = mail.package.request_source
+                    self.mail_transfer.include(mail, "out")
+
+    def transfer_outs(self):
+        """
+        Processes outgoing mails from the central mail transfer, handling end-of-execution notifications and routing
+        other mails to appropriate recipients.
+        """
+        for key in list(self.mail_transfer.pending_ins.keys()):
+            while self.mail_transfer.pending_ins[key].size() > 0:
+                mail_id = self.mail_transfer.pending_ins[key].popleft()
+                mail = self.mail_transfer.pile.pop(mail_id)
+                if mail.category == "end":
+                    self.num_end_branches += 1
+                    if self.num_end_branches == len(
+                        self.branches
+                    ):  # tell when structure should stop
+                        mail.sender = self.ln_id
+                        mail.recipient = self.structure_id
+                        self.mailbox.include(mail, "out")
+                        self.execute_stop = True
+                else:
+                    mail.sender = self.ln_id
+                    mail.recipient = self.structure_id
+                    self.mailbox.include(mail, "out")
+
+    def _process_start(self, start_mail: Mail):
+        """
+        Processes a start mail to initialize a new branch executor and configures it based on the mail's package content.
+
+        Args:
+            start_mail (BaseMail): The mail initiating the start of a new branch execution.
+        """
+        branch = BranchExecutor(verbose=self.verbose, **self.branch_kwargs)
+        branch.context = start_mail.package.package["context"]
+        self.branches[branch.ln_id] = branch
+        self.mail_manager.add_sources([branch])
+        self.structure_id = start_mail.package.package["structure_id"]
+
+        pack = Package(category="start", package="start", request_source=branch.ln_id)
+        mail = Mail(
+            sender=self.ln_id,
+            recipient=self.structure_id,
+            package=pack,
+        )
+        self.mailbox.include(mail, "out")
+
+    def _process_node_list(self, nl_mail: Mail):
+        """
+        Processes a node list mail, setting up new branches or propagating the execution context based on the node list
+        provided in the mail.
+
+        Args:
+            nl_mail (BaseMail): The mail containing a list of nodes to be processed in subsequent branches.
+        """
+        source_branch_id = nl_mail.package.request_source
+        node_list = nl_mail.package.package
+        shared_context = self.branches[source_branch_id].context
+        shared_context_log = self.branches[source_branch_id].context_log
+        base_branch = self.branches[source_branch_id]
+
+        pack = Package(
+            category="node", package=node_list[0], request_source=source_branch_id
+        )
+        mail = Mail(
+            sender=self.mail_transfer.ln_id,
+            recipient=source_branch_id,
+            package=pack,
+        )
+        self.mail_transfer.include(mail, "out")
+
+        for i in range(1, len(node_list)):
+            system = base_branch.system.clone() if base_branch.system else None
+            if system:
+                system.sender = base_branch.ln_id
+            progress = progression()
+            messages = pile()
+
+            for id_ in base_branch.progress:
+                clone_message = base_branch.messages[id_].clone()
+                progress.append(clone_message.ln_id)
+                messages.append(clone_message)
+
+            branch = BranchExecutor(
+                verbose=self.verbose,
+                messages=messages,
+                user=base_branch.user,
+                system=base_branch.system.clone(),
+                progress=progress,
+                imodel=base_branch.imodel,
+            )
+            for message in branch.messages:
+                message.sender = base_branch.ln_id
+                message.recipient = branch.ln_id
+
+            branch.context = shared_context
+            branch.context_log = shared_context_log
+            self.branches[branch.ln_id] = branch
+            self.mail_manager.add_sources([branch])
+            node_pacakge = Package(
+                category="node", package=node_list[i], request_source=source_branch_id
+            )
+            node_mail = Mail(
+                sender=self.mail_transfer.ln_id,
+                recipient=branch.ln_id,
+                package=node_pacakge,
+            )
+            self.mail_transfer.include(node_mail, "out")
+
+    async def forward(self):
+        """
+        Forwards the execution by processing all incoming and outgoing mails and advancing the state of all active branches.
+        """
+        self.transfer_ins()
+        self.transfer_outs()
+        self.mail_manager.collect_all()
+        self.mail_manager.send_all()
+        tasks = [
+            branch.forward()
+            for branch in self.branches.values()
+            if branch.mailbox.pending_ins
+        ]
+        await asyncio.gather(*tasks)
+        return
+
+    async def execute(self, refresh_time=1):
+        """
+        Continuously executes the forward process at specified intervals until instructed to stop.
+
+        Args:
+            refresh_time (int): The time in seconds between execution cycles.
+        """
+        while not self.execute_stop:
+            await self.forward()
+            await asyncio.sleep(refresh_time)

lionagi/core/engine/sandbox_.py

@@ -0,0 +1,14 @@
+# filename: enhanced_script_engine.py
+import ast
+
+
+class SandboxTransformer(ast.NodeTransformer):
+    """AST transformer to enforce restrictions in sandbox mode."""
+
+    def visit_Import(self, node):
+        raise RuntimeError("Import statements are not allowed in sandbox mode.")
+
+    def visit_Exec(self, node):
+        raise RuntimeError("Exec statements are not allowed in sandbox mode.")
+
+    # Add other visit methods for disallowed operations or nodes

lionagi/core/engine/script_engine.py

@@ -0,0 +1,99 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import ast
+from functools import lru_cache
+from lionagi.libs import AsyncUtil
+from ..evaluator.base_evaluator import BaseEvaluator
+from .sandbox_ import SandboxTransformer
+
+
+class ScriptEngine:
+    def __init__(self):
+        self.variables = {}
+        self.safe_evaluator = BaseEvaluator()
+        self.functions = {
+            "processData": self.process_data,
+        }
+
+    def process_data(self, data):
+        return data * 2
+
+    def _evaluate_expression(self, expression):
+        return self.safe_evaluator.evaluate(expression, self.variables)
+
+    def _assign_variable(self, var_name, value):
+        self.variables[var_name] = value
+
+    def _execute_function(self, func_name, arg):
+        if func_name in self.functions:
+            return self.functions[func_name](arg)
+        else:
+            raise ValueError(f"Function {func_name} not defined.")
+
+    def execute(self, script):
+        tree = ast.parse(script)
+        for stmt in tree.body:
+            if isinstance(stmt, ast.Assign):
+                var_name = stmt.targets[0].id
+                value = self._evaluate_expression(ast.unparse(stmt.value))
+                self._assign_variable(var_name, value)
+            elif isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+                func_name = stmt.value.func.id
+                arg = self._evaluate_expression(ast.unparse(stmt.value.args[0]))
+                result = self._execute_function(func_name, arg)
+                # For demonstration, manually update 'x' to simulate expected behavior
+                if func_name == "processData":
+                    self._assign_variable("x", result)
+
+    def add_hook(self, event_name, callback):
+        """Subscribe a callback function to a specific event."""
+        self.hooks[event_name].append(callback)
+
+    def trigger_hooks(self, event_name, *args, **kwargs):
+        """Trigger all callbacks attached to a specific event."""
+        for callback in self.hooks[event_name]:
+            callback(*args, **kwargs)
+
+    async def process_data(self, data):
+        # Example asynchronous function
+        return data * 2
+
+    @lru_cache(maxsize=128)
+    def evaluate_expression(self, expression):
+        return self.safe_evaluator.evaluate(expression, self.variables)
+
+    async def _execute_function_async(self, func_name, arg):
+        if func_name in self.functions:
+            func = self.functions[func_name]
+            if AsyncUtil.is_coroutine_func(func):
+                return await func(arg)
+            else:
+                return func(arg)
+        else:
+            raise ValueError(f"Function {func_name} not defined.")
+
+    def execute_sandboxed(self, script):
+        # Parse and sanitize the script
+        tree = ast.parse(script, mode="exec")
+        sanitized_tree = SandboxTransformer().visit(tree)
+        ast.fix_missing_locations(sanitized_tree)
+
+        # Compile the sanitized AST
+        code = compile(sanitized_tree, "<sandbox>", "exec")
+
+        # Execute the code in a restricted namespace
+        exec(code, {"__builtins__": None}, self.variables)