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

lionagi/core/direct/vote.py

@@ -1,64 +0,0 @@
-"""
-This module contains the vote function for generating and scoring multiple outputs and selecting the top-ranked ones.
-
-The vote function generates multiple outputs using a specified directive function (default: predict), scores each output
-using the score function, and returns the top-ranked output(s) based on the scores. It allows for customization of the
-number of generations, number of outputs to return, number of scorers, score range, and scorer instruction.
-"""
-
-from lionagi.libs import func_call
-import numpy as np
-from .predict import predict
-from .score import score
-
-
-async def vote(
-    sentence,
-    directive=predict,
-    num_generations=5,
-    num_output=1,
-    num_scorer=5,
-    score_range=(0, 100),
-    num_digit=2,
-    scorer_instruction=None,
-    **kwargs,
-):
-    """
-    Generates and scores multiple outputs and returns the top-ranked output(s).
-
-    Args:
-        sentence (str): The input sentence or context.
-        directive (function): The function used to generate outputs (default: predict).
-        num_generations (int): The number of outputs to generate (default: 5).
-        num_output (int): The number of top-ranked outputs to return (default: 1).
-        num_scorer (int): The number of scorers to use for scoring each output (default: 5).
-        score_range (tuple): The range of scores to assign (default: (0, 100)).
-        num_digit (int): The number of digits after the decimal point for scores (default: 2).
-        scorer_instruction (str): The instruction for the scorers (default: None).
-        **kwargs: Additional keyword arguments to pass to the directive function.
-
-    Returns:
-        The top-ranked output if num_output is 1, or a list of top-ranked outputs if num_output is greater than 1.
-    """
-
-    async def _inner(i):
-        out_ = await directive(sentence, **kwargs)
-        score_ = await score(
-            out_.answer,
-            context=sentence,
-            instruction=scorer_instruction,
-            score_range=score_range,
-            num_digit=num_digit,
-            num_instances=num_scorer,
-            return_template=False,
-        )
-
-        out_.__setattr__("score", score_)
-        return out_
-
-    _outs = await func_call.alcall(list(range(num_generations)), _inner)
-
-    top_index = np.argsort([i.score for i in _outs])[-num_output:]
-    final_output = list(np.array(_outs)[top_index])
-
-    return final_output[0] if len(final_output) == 1 else final_output

lionagi/core/flow/base/baseflow.py

@@ -1,23 +0,0 @@
-from abc import ABC
-
-
-class BaseFlow(ABC):
-
-    @classmethod
-    def class_name(cls) -> str:
-        """
-        Returns the class name of the flow.
-        """
-        return cls.__name__
-
-
-class BaseMonoFlow(BaseFlow):
-
-    def __init__(self, branch) -> None:
-        self.branch = branch
-
-
-class BasePolyFlow(BaseFlow):
-
-    def __init__(self, session) -> None:
-        self.session = session

lionagi/core/flow/monoflow/ReAct.py

@@ -1,238 +0,0 @@
-"""
-This module contains the MonoReAct class for performing reasoning and action tasks with an LLM.
-
-The MonoReAct class allows for conducting a series of reasoning and action steps with an LLM, with the ability to
-process instructions, system messages, and invoke tools during the conversation. It extends the MonoChat class.
-"""
-
-from typing import Callable
-from .chat import MonoChat
-from lionagi.core.schema import Tool
-from lionagi.core.messages import Instruction
-
-
-class MonoReAct(MonoChat):
-    """
-    A class for performing reasoning and action tasks with an LLM, processing instructions and system messages,
-    and optionally invoking tools.
-
-    Attributes:
-        REASON_PROMPT (str): The default prompt for reasoning steps.
-        ACTION_PROMPT (str): The default prompt for action steps.
-        OUTPUT_PROMPT (str): The default prompt for presenting the final output to the user.
-
-    Methods:
-        async ReAct(self, instruction, context=None, sender=None, system=None, tools=None,
-                    num_rounds=1, reason_prompt=None, action_prompt=None, output_prompt=None, **kwargs):
-            Performs a series of reasoning and action steps with an LLM, processing instructions and system messages,
-            and optionally invoking tools.
-
-        _get_prompt(prompt=None, default=None, num_steps=None, instruction=None) -> str:
-            Retrieves the appropriate prompt for the reasoning or action step based on the provided parameters.
-
-        _create_followup_config(self, tools, tool_choice="auto", **kwargs) -> dict:
-            Creates the configuration for the followup steps based on the provided tools and parameters.
-
-        async _ReAct(self, instruction, context=None, sender=None, system=None, tools=None,
-                     num_rounds=1, auto=False, reason_prompt=None, action_prompt=None,
-                     output_prompt=None, out=True, **kwargs):
-            Performs the actual reasoning and action steps with the LLM, processing instructions and system messages,
-            and optionally invoking tools.
-    """
-
-    REASON_PROMPT = """
-    You have {num_steps} steps left in the current task. If available, integrate previous tool responses.
-    Perform reasoning and prepare an action plan according to available tools only. Apply divide and conquer technique.
-    """
-
-    ACTION_PROMPT = """
-    You have {num_steps} steps left in the current task. If further actions are needed, invoke tool usage.
-    If you are done, present the final result to the user without further tool usage.
-    """
-
-    OUTPUT_PROMPT = "Notice: Present the final output to the user. Original user instruction: {instruction}"
-
-    async def ReAct(
-        self,
-        instruction: Instruction | str | dict[str, dict | str],
-        context=None,
-        sender=None,
-        system=None,
-        tools=None,
-        num_rounds: int = 1,
-        reason_prompt=None,
-        action_prompt=None,
-        output_prompt=None,
-        **kwargs,
-    ):
-        """
-        Performs a series of reasoning and action steps with an LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Instruction | str | dict[str, dict | str]): The instruction for the task.
-            context (Optional[Any]): Additional context for the task.
-            sender (Optional[str]): The sender of the task message.
-            system (Optional[Any]): System message to be processed during the task.
-            tools (Optional[Any]): Specifies tools to be invoked during the task.
-            num_rounds (int): The number of reasoning and action rounds to perform (default: 1).
-            reason_prompt (Optional[str]): The prompt to use for reasoning steps.
-            action_prompt (Optional[str]): The prompt to use for action steps.
-            output_prompt (Optional[str]): The prompt to use for presenting the final output to the user.
-            **kwargs: Additional keyword arguments for the task.
-
-        Returns:
-            The result of the reasoning and action steps.
-        """
-        return await self._ReAct(
-            instruction,
-            context=context,
-            sender=sender,
-            system=system,
-            tools=tools,
-            num_rounds=num_rounds,
-            reason_prompt=reason_prompt,
-            action_prompt=action_prompt,
-            output_prompt=output_prompt,
-            **kwargs,
-        )
-
-    @staticmethod
-    def _get_prompt(prompt=None, default=None, num_steps=None, instruction=None):
-        """
-        Retrieves the appropriate prompt for the reasoning or action step based on the provided parameters.
-
-        Args:
-            prompt (Optional[str]): The prompt to use for the step.
-            default (Optional[str]): The default prompt to use if no specific prompt is provided.
-            num_steps (Optional[int]): The number of remaining steps in the task.
-            instruction (Optional[Any]): The original user instruction.
-
-        Returns:
-            str: The appropriate prompt for the reasoning or action step.
-        """
-
-        if prompt is not None:
-            return prompt
-
-        try:
-            if num_steps is not None:
-                return default.format(num_steps=num_steps)
-            elif instruction is not None:
-                return default.format(instruction=instruction)
-        except (KeyError, ValueError):
-            pass
-
-        return default
-
-    def _create_followup_config(self, tools, tool_choice="auto", **kwargs):
-        """
-        Creates the configuration for the followup steps based on the provided tools and parameters.
-
-        Args:
-            tools (Optional[Any]): Specifies tools to be invoked during the followup steps.
-            tool_choice (str): The choice of tools to use (default: "auto").
-            **kwargs: Additional keyword arguments for the followup configuration.
-
-        Returns:
-            dict: The configuration for the followup steps.
-
-        Raises:
-            ValueError: If no tools are found and registered.
-        """
-        if tools and isinstance(tools, list) and isinstance(tools[0], (Callable, Tool)):
-            self.branch.tool_manager.register_tools(tools)
-
-        if not self.branch.tool_manager.has_tools:
-            raise ValueError("No tools found. You need to register tools.")
-
-        config = self.branch.tool_manager.parse_tool(tools=True, **kwargs)
-        config["tool_parsed"] = True
-        config["tool_choice"] = tool_choice
-        return config
-
-    async def _ReAct(
-        self,
-        instruction: Instruction | str | dict[str, dict | str],
-        context=None,
-        sender=None,
-        system=None,
-        tools=None,
-        num_rounds: int = 1,
-        auto=False,
-        reason_prompt=None,
-        action_prompt=None,
-        output_prompt=None,
-        out=True,
-        **kwargs,
-    ):
-        """
-        Performs the actual reasoning and action steps with the LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Instruction | str | dict[str, dict | str]): The instruction for the task.
-            context (Optional[Any]): Additional context for the task.
-            sender (Optional[str]): The sender of the task message.
-            system (Optional[Any]): System message to be processed during the task.
-            tools (Optional[Any]): Specifies tools to be invoked during the task.
-            num_rounds (int): The number of reasoning and action rounds to perform (default: 1).
-            auto (bool): Flag indicating whether to automatically determine if the task is finished (default: False).
-            reason_prompt (Optional[str]): The prompt to use for reasoning steps.
-            action_prompt (Optional[str]): The prompt to use for action steps.
-            output_prompt (Optional[str]): The prompt to use for presenting the final output to the user.
-            out (bool): Flag indicating whether to return the output of the task (default: True).
-            **kwargs: Additional keyword arguments for the task.
-
-        Returns:
-            The result of the reasoning and action steps.
-        """
-        config = self._create_followup_config(tools, **kwargs)
-
-        i = 0
-        _out = ""
-
-        while i < num_rounds:
-            _prompt = self._get_prompt(
-                prompt=reason_prompt,
-                default=self.REASON_PROMPT,
-                num_steps=(num_rounds - i) * 2,
-            )
-            _instruct = {"NOTICE": _prompt}
-
-            # reason
-            if i == 0:
-                _instruct["TASK"] = instruction
-
-                await self.chat(
-                    _instruct, context=context, sender=sender, system=system, **kwargs
-                )
-
-            elif i > 0:
-                await self.chat(_instruct, sender=sender, **kwargs)
-
-            # action
-            _prompt = self._get_prompt(
-                prompt=action_prompt,
-                default=self.ACTION_PROMPT,
-                num_steps=(num_rounds - i) * 2 - 1,
-            )
-
-            _out = await self.chat(_prompt, sender=sender, **config)
-
-            if auto and not self.branch._is_invoked():
-                return _out if out else None
-
-            i += 1
-
-        if auto:
-            if not self.branch._is_invoked():
-                return _out if out else None
-
-            _prompt = self._get_prompt(
-                prompt=output_prompt,
-                default=self.OUTPUT_PROMPT,
-                instruction=instruction,
-            )
-            _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None

lionagi/core/flow/monoflow/__init__.py

@@ -1,9 +0,0 @@
-from .chat import MonoChat
-from .followup import MonoFollowup
-from .ReAct import MonoReAct
-
-__all__ = [
-    "MonoChat",
-    "MonoFollowup",
-    "MonoReAct",
-]

lionagi/core/flow/monoflow/chat.py

@@ -1,95 +0,0 @@
-"""
-This module contains the MonoChat class for performing chat conversations with an LLM.
-
-The MonoChat class allows for processing instructions and system messages, and optionally invoking tools
-during the chat conversation. It extends the BaseMonoFlow and MonoChatMixin classes.
-"""
-
-from typing import Any
-
-from lionagi.core.flow.base.baseflow import BaseMonoFlow
-from lionagi.core.flow.monoflow.chat_mixin import MonoChatMixin
-
-
-class MonoChat(BaseMonoFlow, MonoChatMixin):
-    """
-    A class for performing a chat conversation with an LLM, processing instructions and system messages,
-    and optionally invoking tools.
-
-    Attributes:
-        branch: The Branch instance to perform chat operations.
-
-    Methods:
-        __init__(self, branch) -> None:
-            Initializes the MonoChat instance.
-
-        async chat(self, instruction=None, context=None, sender=None, system=None, tools=False,
-                   out=True, invoke=True, output_fields=None, prompt_template=None, **kwargs) -> Any:
-            Performs a chat conversation with an LLM, processing instructions and system messages,
-            and optionally invoking tools.
-    """
-
-    def __init__(self, branch) -> None:
-        """
-        Initializes the MonoChat instance.
-
-        Args:
-            branch: The Branch instance to perform chat operations.
-        """
-        super().__init__(branch)
-
-    async def chat(
-        self,
-        instruction=None,
-        context=None,
-        sender=None,
-        system=None,
-        tools=False,
-        out: bool = True,
-        invoke: bool = True,
-        output_fields=None,
-        prompt_template=None,
-        **kwargs,
-    ) -> Any:
-        """
-        Performs a chat conversation with an LLM, processing instructions and system messages,
-        and optionally invoking tools.
-
-        Args:
-            instruction (Union[Instruction, str]): The instruction for the chat.
-            context (Optional[Any]): Additional context for the chat.
-            sender (Optional[str]): The sender of the chat message.
-            system (Optional[Union[System, str, Dict[str, Any]]]): System message to be processed.
-            tools (Union[bool, Tool, List[Tool], str, List[str]]): Specifies tools to be invoked.
-            out (bool): If True, outputs the chat response.
-            invoke (bool): If True, invokes tools as part of the chat.
-            output_fields (Optional[Any]): The output fields for the chat.
-            prompt_template (Optional[Any]): The prompt template for the chat.
-            **kwargs: Arbitrary keyword arguments for chat completion.
-
-        Returns:
-            Any: The result of the chat conversation.
-
-        Examples:
-            >>> await MonoChat.chat(branch, "Ask about user preferences")
-        """
-
-        config = self._create_chat_config(
-            instruction=instruction,
-            context=context,
-            sender=sender,
-            system=system,
-            prompt_template=prompt_template,
-            tools=tools,
-            output_fields=output_fields,
-            **kwargs,
-        )
-
-        await self._call_chatcompletion(**config)
-
-        return await self._output(
-            invoke=invoke,
-            out=out,
-            output_fields=output_fields,
-            prompt_template=prompt_template,
-        )

lionagi/core/flow/monoflow/chat_mixin.py

@@ -1,263 +0,0 @@
-"""
-This module contains mixins for configuring and invoking chatbots.
-"""
-
-from abc import ABC
-from typing import Any
-
-from lionagi.core.messages.schema import Instruction
-from lionagi.core.schema.base_node import TOOL_TYPE
-from lionagi.libs import (
-    ln_nested as nested,
-    ln_func_call as func_call,
-    ln_convert as convert,
-)
-from lionagi.libs.ln_parse import ParseUtil, StringMatch
-
-
-class MonoChatConfigMixin(ABC):
-    """
-    Mixin class for configuring chatbots.
-
-    Methods:
-        _create_chat_config(self, instruction=None, context=None, sender=None, system=None,
-                            output_fields=None, prompt_template=None, tools=False, **kwargs) -> Any:
-            Creates a chat configuration based on the provided parameters.
-    """
-
-    def _create_chat_config(
-        self,
-        instruction: Instruction | str | dict[str, Any] = None,
-        context: Any | None = None,
-        sender: str | None = None,
-        system: str | dict[str, Any] | None = None,
-        output_fields=None,
-        prompt_template=None,
-        tools: TOOL_TYPE = False,
-        **kwargs,
-    ) -> Any:
-        """
-        Creates a chat configuration based on the provided parameters.
-
-        Args:
-            instruction (Instruction | str | dict[str, Any]): The instruction for the chatbot (optional).
-            context (Any): The context for the chatbot (optional).
-            sender (str): The sender of the message (optional).
-            system (str | dict[str, Any]): The system message for the chatbot (optional).
-            output_fields: The output fields for the chatbot (optional).
-            prompt_template: The prompt template for the chatbot (optional).
-            tools (TOOL_TYPE): The tools for the chatbot (default: False).
-            **kwargs: Additional keyword arguments for the chat configuration.
-
-        Returns:
-            Any: The chat configuration.
-        """
-        if system:
-            self.branch.change_first_system_message(system)
-
-        if not prompt_template:
-            self.branch.add_message(
-                instruction=instruction,
-                context=context,
-                sender=sender,
-                output_fields=output_fields,
-            )
-        else:
-            instruct_ = Instruction.from_prompt_template(prompt_template)
-            self.branch.add_message(instruction=instruct_)
-
-        if "tool_parsed" in kwargs:
-            kwargs.pop("tool_parsed")
-            tool_kwarg = {"tools": tools}
-            kwargs = tool_kwarg | kwargs
-        elif tools and self.branch.has_tools:
-            kwargs = self.branch.tool_manager.parse_tool(tools=tools, **kwargs)
-
-        config = {**self.branch.llmconfig, **kwargs}
-        if sender is not None:
-            config["sender"] = sender
-
-        return config
-
-
-class MonoChatInvokeMixin(ABC):
-    """
-    Mixin class for invoking chatbots.
-
-    Methods:
-        async _output(self, invoke, out, output_fields, func_calls_=None, prompt_template=None,
-                      return_template=True):
-            Processes the output of the chatbot.
-
-        _return_response(content_, output_fields) -> Any:
-            Returns the response from the chatbot.
-
-        async _invoke_tools(self, content_=None, func_calls_=None):
-            Invokes the tools associated with the chatbot.
-
-        _process_chatcompletion(self, payload, completion, sender):
-            Processes the chat completion.
-
-        async _call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
-            Calls the chat completion API.
-    """
-
-    async def _output(
-        self,
-        invoke,
-        out,
-        output_fields,
-        func_calls_=None,
-        prompt_template=None,
-        return_template=True,
-    ):
-        """
-        Processes the output of the chatbot.
-
-        Args:
-            invoke: Flag indicating whether to invoke the tools.
-            out: Flag indicating whether to return the output.
-            output_fields: The output fields for the chatbot.
-            func_calls_: The function calls for invoking the tools (optional).
-            prompt_template: The prompt template for the chatbot (optional).
-            return_template (bool): Flag indicating whether to return the prompt template (default: True).
-        """
-
-        content_ = self.branch.last_message_content
-
-        if invoke:
-            try:
-                await self._invoke_tools(content_, func_calls_=func_calls_)
-            except Exception:
-                pass
-
-        response_ = self._return_response(content_, output_fields)
-        if prompt_template:
-            prompt_template._process_response(response_)
-            return prompt_template if return_template else prompt_template.out
-
-        if out:
-            return response_
-
-    @staticmethod
-    def _return_response(content_, output_fields):
-        """
-        Returns the response from the chatbot.
-
-        Args:
-            content_: The content of the last message.
-            output_fields: The output fields for the chatbot.
-
-        Returns:
-            Any: The response from the chatbot.
-        """
-        out_ = ""
-
-        if len(content_.items()) == 1 and len(nested.get_flattened_keys(content_)) == 1:
-            key = nested.get_flattened_keys(content_)[0]
-            out_ = content_[key]
-
-        if output_fields:
-            try:
-                if isinstance(out_, dict):
-                    out_ = convert.to_str(out_.values())
-
-                if isinstance(out_, str):
-                    try:
-                        out_ = ParseUtil.md_to_json(out_)
-                    except Exception:
-                        out_ = ParseUtil.md_to_json(out_.replace("'", '"'))
-
-                out_ = StringMatch.correct_keys(output_fields=output_fields, out_=out_)
-            except Exception:
-                pass
-
-        if isinstance(out_, str):
-            try:
-                out_ = ParseUtil.md_to_json(out_)
-                out_ = StringMatch.correct_keys(output_fields=output_fields, out_=out_)
-                return out_
-            except Exception:
-                pass
-
-        return out_
-
-    async def _invoke_tools(self, content_=None, func_calls_=None):
-        """
-        Invokes the tools associated with the chatbot.
-
-        Args:
-            content_: The content of the last message (optional).
-            func_calls_: The function calls for invoking the tools (optional).
-
-        Returns:
-            list: The results of invoking the tools.
-        """
-        if func_calls_ is None and content_ is not None:
-            tool_uses = content_
-            func_calls_ = func_call.lcall(
-                [convert.to_dict(i) for i in tool_uses["action_request"]],
-                self.branch.tool_manager.get_function_call,
-            )
-
-        outs = await func_call.alcall(func_calls_, self.branch.tool_manager.invoke)
-        outs = convert.to_list(outs, flatten=True)
-
-        a = []
-        for out_, f in zip(outs, func_calls_):
-            res = {
-                "function": f[0],
-                "arguments": f[1],
-                "output": out_,
-            }
-            self.branch.add_message(response=res)
-            a.append(res)
-
-        return a
-
-    def _process_chatcompletion(self, payload, completion, sender):
-        """
-        Processes the chat completion.
-
-        Args:
-            payload: The payload for the chat completion.
-            completion: The completed chat response.
-            sender: The sender of the message.
-        """
-        if "choices" in completion:
-            add_msg_config = {"response": completion["choices"][0]}
-            if sender is not None:
-                add_msg_config["sender"] = sender
-
-            self.branch.datalogger.append(input_data=payload, output_data=completion)
-            self.branch.add_message(**add_msg_config)
-            self.branch.status_tracker.num_tasks_succeeded += 1
-        else:
-            self.branch.status_tracker.num_tasks_failed += 1
-
-    async def _call_chatcompletion(self, sender=None, with_sender=False, **kwargs):
-        """
-        Calls the chat completion API.
-
-        Args:
-            sender: The sender of the message (optional).
-            with_sender (bool): Flag indicating whether to include the sender in the chat messages (default: False).
-            **kwargs: Additional keyword arguments for the chat completion API.
-        """
-        messages = (
-            self.branch.chat_messages_with_sender
-            if with_sender
-            else self.branch.chat_messages
-        )
-        payload, completion = await self.branch.service.serve_chat(
-            messages=messages, **kwargs
-        )
-        self._process_chatcompletion(payload, completion, sender)
-
-
-class MonoChatMixin(MonoChatConfigMixin, MonoChatInvokeMixin, ABC):
-    """
-    Mixin class that combines MonoChatConfigMixin and MonoChatInvokeMixin.
-    """
-
-    pass