lionagi 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/direct/select.py

@@ -1,170 +0,0 @@
-"""
-This module contains the SelectTemplate class for selecting an item from given choices based on a given context.
-
-The SelectTemplate class is a subclass of ScoredTemplate and provides functionality for selecting an item from
-given choices using a language model. It includes fields for the input sentence, choices, selected answer,
-confidence score, and reason for the selection.
-
-The module also includes a function for selecting an item from given choices using the SelectTemplate class
-and a language model.
-"""
-
-from enum import Enum
-from pydantic import Field
-
-from lionagi.libs import func_call, StringMatch
-from lionagi.core.form.scored_form import ScoredForm
-from lionagi.core.branch.branch import Branch
-
-
-class SelectTemplate(ScoredForm):
-    """
-    A class for selecting an item from given choices based on a given context.
-
-    Attributes:
-        template_name (str): The name of the select template (default: "default_select").
-        sentence (str | list | dict): The given context.
-        answer (Enum | str): The selected item from the given choices.
-        signature (str): The signature indicating the input and output fields (default: "sentence -> answer").
-
-    Methods:
-        __init__(self, sentence=None, choices=None, instruction=None, reason=False, confidence_score=False, **kwargs):
-            Initializes a new instance of the SelectTemplate class.
-    """
-
-    template_name: str = "default_select"
-    sentence: str | list | dict = Field(
-        default_factory=str, description="the given context"
-    )
-    answer: Enum | str = Field(
-        default_factory=str, description="selection from given choices"
-    )
-    choices: list = Field(default_factory=list, description="the given choices")
-
-    signature: str = "sentence -> answer"
-
-    def __init__(
-        self,
-        sentence=None,
-        choices=None,
-        instruction=None,
-        reason=False,
-        confidence_score=False,
-        **kwargs,
-    ):
-        """
-        Initializes a new instance of the SelectTemplate class.
-
-        Args:
-            sentence (Optional[str | list | dict]): The given context.
-            choices (Optional[list]): The list of choices to select from.
-            instruction (Optional[str]): The instruction for selection.
-            reason (bool): Whether to include the reason for the selection in the output (default: False).
-            confidence_score (bool): Whether to include the confidence score in the output (default: False).
-            **kwargs: Additional keyword arguments.
-        """
-        super().__init__(**kwargs)
-
-        self.sentence = sentence
-        self.choices = choices
-        self.task = f"select 1 item, from provided choices {choices}."
-        if instruction:
-            self.task += f"objetive {instruction}."
-
-        if reason:
-            self.output_fields.append("reason")
-
-        if confidence_score:
-            self.output_fields.append("confidence_score")
-
-
-async def select(
-    sentence,
-    choices=None,
-    instruction=None,
-    confidence_score=False,
-    reason=False,
-    retries=2,
-    delay=0.5,
-    backoff_factor=2,
-    default_value=None,
-    timeout=None,
-    branch_name=None,
-    system=None,
-    messages=None,
-    service=None,
-    sender=None,
-    llmconfig=None,
-    tools=None,
-    datalogger=None,
-    persist_path=None,
-    tool_manager=None,
-    **kwargs,
-):
-    """
-    Selects an item from given choices based on a given context using a language model.
-
-    Args:
-        sentence (str | list | dict): The given context.
-        choices (Optional[list]): The list of choices to select from.
-        instruction (Optional[str]): The instruction for selection.
-        confidence_score (bool): Whether to include the confidence score in the output (default: False).
-        reason (bool): Whether to include the reason for the selection in the output (default: False).
-        retries (int): The number of retries for the API call (default: 2).
-        delay (float): The initial delay between retries in seconds (default: 0.5).
-        backoff_factor (float): The backoff factor for exponential delay between retries (default: 2).
-        default_value (Optional[Any]): The default value to return if the API call fails (default: None).
-        timeout (Optional[float]): The timeout for the API call in seconds (default: None).
-        branch_name (Optional[str]): The name of the branch to use for selection.
-        system (Optional[Any]): The system configuration for the branch.
-        messages (Optional[Any]): The messages to initialize the branch with.
-        service (Optional[Any]): The service to use for selection.
-        sender (Optional[str]): The sender of the selection request.
-        llmconfig (Optional[Any]): The configuration for the language model.
-        tools (Optional[Any]): The tools to use for selection.
-        datalogger (Optional[Any]): The data logger for the branch.
-        persist_path (Optional[str]): The path to persist the branch data.
-        tool_manager (Optional[Any]): The tool manager for the branch.
-        **kwargs: Additional keyword arguments for the API call.
-
-    Returns:
-        SelectTemplate: The select template with the selected item.
-    """
-    branch = Branch(
-        name=branch_name,
-        system=system,
-        messages=messages,
-        service=service,
-        sender=sender,
-        llmconfig=llmconfig,
-        tools=tools,
-        datalogger=datalogger,
-        persist_path=persist_path,
-        tool_manager=tool_manager,
-    )
-
-    _template = SelectTemplate(
-        sentence=sentence,
-        choices=choices,
-        instruction=instruction,
-        confidence_score=confidence_score,
-        reason=reason,
-    )
-
-    await func_call.rcall(
-        branch.chat,
-        form=_template,
-        retries=retries,
-        delay=delay,
-        backoff_factor=backoff_factor,
-        default=default_value,
-        timeout=timeout,
-        **kwargs,
-    )
-
-    ans = _template.answer
-
-    if ans not in _template.choices:
-        _template.answer = StringMatch.choose_most_similar(ans, _template.choices)
-
-    return _template

lionagi/core/direct/sentiment.py

@@ -1 +0,0 @@
-# TODO: sentiment analysis

lionagi/core/direct/utils.py

@@ -1,110 +0,0 @@
-from typing import Callable
-from lionagi.core.tool import func_to_tool, Tool
-
-# import contextlib
-# from lionagi.libs import ParseUtil, StringMatch, convert, func_call
-
-
-# def _parse_out(out_):
-#     if isinstance(out_, str):
-#         try:
-#             out_ = ParseUtil.md_to_json(out_)
-#         except Exception:
-#             with contextlib.suppress(Exception):
-#                 out_ = ParseUtil.fuzzy_parse_json(out_.strip("```json").strip("```"))
-#     return out_
-
-
-# def _handle_single_out(
-#     out_,
-#     default_key="answer",
-#     choices=None,
-#     to_type="dict",
-#     to_type_kwargs=None,
-#     to_default=True,
-# ):
-
-#     if to_type_kwargs is None:
-#         to_type_kwargs = {}
-#     out_ = _parse_out(out_)
-
-#     if default_key not in out_:
-#         raise ValueError(f"Key {default_key} not found in output")
-
-#     answer = out_[default_key]
-
-#     if (
-#         choices is not None
-#         and answer not in choices
-#         and convert.strip_lower(out_) in ["", "none", "null", "na", "n/a"]
-#     ):
-#         raise ValueError(f"Answer {answer} not in choices {choices}")
-
-#     if to_type == "str":
-#         answer = convert.to_str(answer, **to_type_kwargs)
-
-#     elif to_type == "num":
-#         answer = convert.to_num(answer, **to_type_kwargs)
-
-#     out_[default_key] = answer
-
-#     return answer if to_default else out_
-
-
-# def _handle_multi_out(
-#     out_,
-#     default_key="answer",
-#     choices=None,
-#     to_type="dict",
-#     to_type_kwargs=None,
-#     to_default=True,
-#     include_mapping=False,
-# ):
-#     if to_type_kwargs is None:
-#         to_type_kwargs = {}
-
-#     if include_mapping:
-#         for i in out_:
-#             i[default_key] = _handle_single_out(
-#                 i[default_key],
-#                 choices=choices,
-#                 default_key=default_key,
-#                 to_type=to_type,
-#                 to_type_kwargs=to_type_kwargs,
-#                 to_default=to_default,
-#             )
-#     else:
-#         _out = []
-#         for i in out_:
-#             i = _handle_single_out(
-#                 i,
-#                 choices=choices,
-#                 default_key=default_key,
-#                 to_type=to_type,
-#                 to_type_kwargs=to_type_kwargs,
-#                 to_default=to_default,
-#             )
-#             _out.append(i)
-#         return _out
-
-#     return out_ if len(out_) > 1 else out_[0]
-
-
-def _process_tools(tool_obj, branch):
-    if isinstance(tool_obj, Callable):
-        _process_tool(tool_obj, branch)
-    else:
-        for i in tool_obj:
-            _process_tool(i, branch)
-
-
-def _process_tool(tool_obj, branch):
-    if (
-        isinstance(tool_obj, Tool)
-        and tool_obj.schema_["function"]["name"] not in branch.tool_manager.registry
-    ):
-        branch.register_tools(tool_obj)
-    if isinstance(tool_obj, Callable):
-        tool = func_to_tool(tool_obj)[0]
-        if tool.schema_["function"]["name"] not in branch.tool_manager.registry:
-            branch.register_tools(tool)

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 lionagi.core.direct.predict import predict
-from lionagi.core.direct.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/execute/base_executor.py

@@ -1,47 +0,0 @@
-from collections import deque
-from abc import ABC, abstractmethod
-from typing import Any
-
-from pydantic import Field
-
-from lionagi.core.generic import BaseComponent
-from lionagi.core.mail.schema import BaseMail
-
-
-class BaseExecutor(BaseComponent, ABC):
-    pending_ins: dict = Field(
-        default_factory=dict, description="The pending incoming mails."
-    )
-    pending_outs: deque = Field(
-        default_factory=deque, description="The pending outgoing mails."
-    )
-    execute_stop: bool = Field(
-        False, description="A flag indicating whether to stop execution."
-    )
-    context: dict | str | list | None = Field(
-        None, description="The context buffer for the next instruction."
-    )
-    execution_responses: list = Field(
-        default_factory=list, description="The list of responses."
-    )
-    context_log: list = Field(default_factory=list, description="The context log.")
-    verbose: bool = Field(
-        True, description="A flag indicating whether to provide verbose output."
-    )
-
-    def send(self, recipient_id: str, category: str, package: Any) -> None:
-        """
-        Sends a mail to a recipient.
-
-        Args:
-            recipient_id (str): The ID of the recipient.
-            category (str): The category of the mail.
-            package (Any): The package to send in the mail.
-        """
-        mail = BaseMail(
-            sender_id=self.id_,
-            recipient_id=recipient_id,
-            category=category,
-            package=package,
-        )
-        self.pending_outs.append(mail)

lionagi/core/flow/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 lionagi.core.flow.monoflow.chat import MonoChat
-from lionagi.core.tool import Tool
-from lionagi.core.messages.schema 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. invoke 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 chat based on the provided tools and parameters.
-
-        Args:
-            tools (Optional[Any]): Specifies tools to be invoked during the followup chat.
-            tool_choice (str): The choice of tools to use (default: "auto").
-            **kwargs: Additional keyword arguments for the followup chat configuration.
-
-        Returns:
-            dict: The configuration for the followup chat.
-
-        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=True,
-        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)
-        kwargs.pop("tools", None)
-
-        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 not self.branch._is_invoked():
-                return _out if out else None
-
-            i += 1
-
-
-        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",
-]