lionagi 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/core/engine/branch_engine.py

@@ -1,361 +0,0 @@
-import contextlib
-
-from lionagi.core.action import ActionNode
-from lionagi.core.collections import Pile, Progression
-from lionagi.core.executor.base_executor import BaseExecutor
-from lionagi.core.generic.edge import Edge
-from lionagi.core.mail.mail import Mail
-from lionagi.core.message import Instruction, System
-from lionagi.core.session.branch import Branch
-from lionagi.libs import AsyncUtil, ParseUtil, convert
-
-
-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.get(key, Pile()).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 (
-                key in self.mailbox.pending_ins
-                and self.mailbox.pending_ins.get(key, Pile()).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 Exception as e:
-                raise ValueError(
-                    f"Invalid mail to process. Mail:{mail}, Error: {e}"
-                )
-
-    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

@@ -1,213 +0,0 @@
-import asyncio
-
-from pydantic import Field
-
-from lionagi.core.collections import Exchange, Pile, pile, progression
-from lionagi.core.engine.branch_engine import BranchExecutor
-from lionagi.core.executor.base_executor import BaseExecutor
-from lionagi.core.mail.mail import Mail, Package
-from lionagi.core.mail.mail_manager import MailManager
-
-
-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

@@ -1,16 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-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)