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

lionagi/core/direct/predict.py

@@ -1,161 +0,0 @@
-"""
-This module contains the PredictTemplate class for predicting the next sentence(s) based on a given sentence.
-
-The PredictTemplate class is a subclass of ScoredTemplate and provides functionality for predicting the next sentence(s)
-using a language model. It includes fields for the input sentence, number of sentences to predict, predicted answer,
-confidence score, and reason for the prediction.
-"""
-
-from pydantic import Field
-from lionagi.libs import func_call
-from ..prompt.prompt_template import ScoredTemplate
-from ..branch import Branch
-
-
-class PredictTemplate(ScoredTemplate):
-    """
-    A class for predicting the next sentence(s) based on a given sentence.
-
-    Attributes:
-        template_name (str): The name of the predict template (default: "default_predict_template").
-        sentence (str | list | dict): The given sentence(s) to predict.
-        num_sentences (int): The number of sentences to predict.
-        answer (str | list): The predicted sentence(s).
-        signature (str): The signature indicating the input and output fields (default: "sentence -> answer").
-
-    Methods:
-        __init__(self, sentence=None, num_sentences=None, confidence_score=False, reason=False, **kwargs):
-            Initializes a new instance of the PredictTemplate class.
-
-        async predict(sentence=None, num_sentences=1, 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) -> PredictTemplate:
-            Predicts the next sentence(s) based on the given sentence using a language model.
-    """
-
-    template_name: str = "default_predict"
-    sentence: str | list | dict = Field(
-        default_factory=str, description="the given sentence(s) to predict"
-    )
-    num_sentences: int = Field(
-        default_factory=int, description="the number of sentences to predict"
-    )
-    answer: str | list = Field(
-        default_factory=str, description="the predicted sentence(s)"
-    )
-    signature: str = "sentence -> answer"
-
-    def __init__(
-        self,
-        sentence=None,
-        num_sentences=None,
-        confidence_score=False,
-        reason=False,
-        **kwargs,
-    ):
-        """
-        Initializes a new instance of the PredictTemplate class.
-
-        Args:
-            sentence (Optional[str | list | dict]): The given sentence(s) to predict.
-            num_sentences (Optional[int]): The number of sentences to predict.
-            confidence_score (bool): Whether to include the confidence score in the output (default: False).
-            reason (bool): Whether to include the reason for the prediction in the output (default: False).
-            **kwargs: Additional keyword arguments.
-        """
-        super().__init__(**kwargs)
-
-        self.sentence = sentence
-        self.num_sentences = num_sentences
-        self.task = f"predict the next {self.num_sentences} sentence(s)"
-
-        if reason:
-            self.output_fields.append("reason")
-
-        if confidence_score:
-            self.output_fields.append("confidence_score")
-
-
-async def predict(
-    sentence=None,
-    num_sentences=1,
-    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,
-) -> "PredictTemplate":
-    """
-    Predicts the next sentence(s) based on the given sentence using a language model.
-
-    Args:
-        sentence (Optional[str | list | dict]): The given sentence(s) to predict.
-        num_sentences (int): The number of sentences to predict (default: 1).
-        confidence_score (bool): Whether to include the confidence score in the output (default: False).
-        reason (bool): Whether to include the reason for the prediction 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 prediction.
-        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 prediction.
-        sender (Optional[str]): The sender of the prediction request.
-        llmconfig (Optional[Any]): The configuration for the language model.
-        tools (Optional[Any]): The tools to use for prediction.
-        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:
-        PredictTemplate: The predict template with the predicted sentence(s).
-    """
-    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,
-    )
-
-    predict_template = PredictTemplate(
-        sentence=sentence,
-        num_sentences=num_sentences,
-        confidence_score=confidence_score,
-        reason=reason,
-    )
-
-    await func_call.rcall(
-        branch.chat,
-        prompt_template=predict_template,
-        retries=retries,
-        delay=delay,
-        backoff_factor=backoff_factor,
-        default=default_value,
-        timeout=timeout,
-        **kwargs,
-    )
-
-    return predict_template

lionagi/core/direct/score.py

@@ -1,278 +0,0 @@
-"""
-This module contains the ScoreTemplate class and related functions for scoring a given context using a language model.
-
-The ScoreTemplate class is a subclass of ScoredTemplate and provides functionality for scoring a given context
-based on specified instructions, score range, and other parameters. It includes fields for the input sentence,
-score range, inclusive flag, number of digits, confidence score, and reason for the score.
-
-The module also includes functions for scoring a single instance or multiple instances of the context using the
-ScoreTemplate class and a language model.
-"""
-
-from pydantic import Field
-import numpy as np
-from lionagi.libs import func_call, convert
-from ..prompt.prompt_template import ScoredTemplate
-from ..branch import Branch
-
-
-class ScoreTemplate(ScoredTemplate):
-    """
-    A class for scoring a given context using a language model.
-
-    Attributes:
-        template_name (str): The name of the score template (default: "default_score").
-        sentence (str | list | dict): The given context to score.
-        answer (float): The numeric score for the context.
-        signature (str): The signature indicating the input and output fields (default: "sentence -> answer").
-
-    Methods:
-        __init__(self, sentence=None, instruction=None, score_range=(1, 10), inclusive=True, num_digit=0,
-                 confidence_score=False, reason=False, **kwargs):
-            Initializes a new instance of the ScoreTemplate class.
-    """
-
-    template_name: str = "default_score"
-    sentence: str | list | dict = Field(
-        default_factory=str, description="the given context to score"
-    )
-    answer: float = Field(default_factory=float, description=f"a numeric score")
-    signature: str = "sentence -> answer"
-
-    def __init__(
-        self,
-        sentence=None,
-        instruction=None,
-        score_range=(1, 10),
-        inclusive=True,
-        num_digit=0,
-        confidence_score=False,
-        reason=False,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.sentence = sentence
-
-        return_precision = ""
-        if num_digit == 0:
-            return_precision = "integer"
-        else:
-            return_precision = f"num:{convert.to_str(num_digit)}f"
-
-        self.task = f"""
-score context according to the following constraints
-1. objective, {convert.to_str(instruction)}
-2. score range, {convert.to_str(score_range)}
-3. include_endpoints, {"yes" if inclusive else "no"}
-4. format the score in {return_precision}
-"""
-
-        if reason:
-            self.output_fields.append("reason")
-
-        if confidence_score:
-            self.output_fields.append("confidence_score")
-
-        self.out_validation_kwargs["answer"] = {
-            "upper_bound": score_range[1],
-            "lower_bound": score_range[0],
-            "num_type": int if num_digit == 0 else float,
-            "precision": num_digit if num_digit != 0 else None,
-        }
-
-
-async def _score(
-    sentence,
-    instruction=None,
-    score_range=(1, 10),
-    inclusive=True,
-    num_digit=0,
-    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,
-):
-    """
-    Scores a given context using a language model.
-
-    Args:
-        sentence (str | list | dict): The given context to score.
-        instruction (Optional[str]): The instruction for scoring the context.
-        score_range (tuple): The range of valid scores (default: (1, 10)).
-        inclusive (bool): Whether to include the endpoints of the score range (default: True).
-        num_digit (int): The number of digits after the decimal point for the score (default: 0).
-        confidence_score (bool): Whether to include the confidence score in the output (default: False).
-        reason (bool): Whether to include the reason for the score 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 scoring.
-        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 scoring.
-        sender (Optional[str]): The sender of the scoring request.
-        llmconfig (Optional[Any]): The configuration for the language model.
-        tools (Optional[Any]): The tools to use for scoring.
-        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:
-        ScoreTemplate: The score template with the scored context.
-    """
-
-    if "temperature" not in kwargs:
-        kwargs["temperature"] = 0.1
-
-    instruction = instruction or ""
-
-    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 = ScoreTemplate(
-        sentence=sentence,
-        instruction=instruction,
-        score_range=score_range,
-        inclusive=inclusive,
-        num_digit=num_digit,
-        confidence_score=confidence_score,
-        reason=reason,
-    )
-
-    await func_call.rcall(
-        branch.chat,
-        prompt_template=_template,
-        retries=retries,
-        delay=delay,
-        backoff_factor=backoff_factor,
-        default=default_value,
-        timeout=timeout,
-        **kwargs,
-    )
-
-    return _template
-
-
-async def score(
-    sentence,
-    num_instances=1,
-    instruction=None,
-    score_range=(1, 10),
-    inclusive=True,
-    num_digit=0,
-    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,
-    return_template=True,
-    **kwargs,
-) -> ScoreTemplate | float:
-    """
-    Scores a given context using a language model, with the option to score multiple instances.
-
-    Args:
-        sentence (str | list | dict): The given context to score.
-        num_instances (int): The number of instances to score (default: 1).
-        instruction (Optional[str]): The instruction for scoring the context.
-        score_range (tuple): The range of valid scores (default: (1, 10)).
-        inclusive (bool): Whether to include the endpoints of the score range (default: True).
-        num_digit (int): The number of digits after the decimal point for the score (default: 0).
-        confidence_score (bool): Whether to include the confidence score in the output (default: False).
-        reason (bool): Whether to include the reason for the score 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 scoring.
-        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 scoring.
-        sender (Optional[str]): The sender of the scoring request.
-        llmconfig (Optional[Any]): The configuration for the language model.
-        tools (Optional[Any]): The tools to use for scoring.
-        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.
-        return_template (bool): Whether to return the score template or only the score (default: True).
-        **kwargs: Additional keyword arguments for the API call.
-
-    Returns:
-        ScoreTemplate | float: The score template with the scored context or the average score if `return_template` is False.
-    """
-
-    async def _inner(i=0):
-        return await _score(
-            sentence=sentence,
-            instruction=instruction,
-            score_range=score_range,
-            inclusive=inclusive,
-            num_digit=num_digit,
-            confidence_score=confidence_score,
-            reason=reason,
-            retries=retries,
-            delay=delay,
-            backoff_factor=backoff_factor,
-            default_value=default_value,
-            timeout=timeout,
-            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,
-            **kwargs,
-        )
-
-    if num_instances == 1:
-        _out = await _inner()
-        return _out if return_template else _out.answer
-
-    elif num_instances > 1:
-        _outs = await func_call.alcall(range(num_instances), _inner)
-        return _outs if return_template else np.mean([i.answer for i in _outs])

lionagi/core/direct/select.py

@@ -1,169 +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 ..prompt.prompt_template import ScoredTemplate
-from ..branch import Branch
-
-
-class SelectTemplate(ScoredTemplate):
-    """
-    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"
-    )
-
-    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,
-        prompt_template=_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/utils.py

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