lionagi 0.0.305__py3-none-any.whl → 0.0.307__py3-none-any.whl

lionagi/core/direct/parallel_predict.py

@@ -0,0 +1,127 @@
+from lionagi.libs import func_call
+from ..branch import Branch
+from ..session import Session
+from .utils import _handle_single_out, _handle_multi_out
+
+
+async def parallel_predict(
+    sentence,
+    *,
+    num_sentences=1,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    retry_kwargs=None,
+    **kwargs,
+):
+    if retry_kwargs is None:
+        retry_kwargs = {}
+    return await _force_parallel_predict(
+        sentence,
+        num_sentences,
+        default_key,
+        confidence_score,
+        reason,
+        retry_kwargs,
+        **kwargs,
+    )
+
+
+async def _force_parallel_predict(
+    sentence,
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    retry_kwargs={},
+    include_mapping=False,
+    **kwargs,
+):
+
+    async def _inner():
+        out_ = await _parallel_predict(
+            sentence=sentence,
+            num_sentences=num_sentences,
+            default_key=default_key,
+            confidence_score=confidence_score,
+            reason=reason,
+            include_mapping=include_mapping,
+            **kwargs,
+        )
+        if out_ is None:
+            raise ValueError("No output from the model")
+
+        return out_
+
+    if "retries" not in retry_kwargs:
+        retry_kwargs["retries"] = 2
+
+    if "delay" not in retry_kwargs:
+        retry_kwargs["delay"] = 0.5
+
+    return await func_call.rcall(_inner, **retry_kwargs)
+
+
+def _create_predict_config(
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    **kwargs,
+):
+    instruct = {
+        "task": f"predict the next {num_sentences} sentence(s)",
+    }
+    extra_fields = kwargs.pop("output_fields", {})
+
+    output_fields = {default_key: "the predicted sentence(s)"}
+    output_fields = {**output_fields, **extra_fields}
+
+    if reason:
+        output_fields.update({"reason": "brief reason for the prediction"})
+
+    if confidence_score:
+        output_fields.update(
+            {"confidence_score": "a numeric score between 0 to 1 formatted in num:0.2f"}
+        )
+
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    return instruct, output_fields, kwargs
+
+
+async def _parallel_predict(
+    sentence,
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    include_mapping=False,
+    **kwargs,
+):
+    _instruct, _output_fields, _kwargs = _create_predict_config(
+        num_sentences=num_sentences,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        reason=reason,
+        **kwargs,
+    )
+
+    session = Session()
+
+    out_ = await session.parallel_chat(
+        _instruct,
+        context=sentence,
+        output_fields=_output_fields,
+        include_mapping=include_mapping,
+        **_kwargs,
+    )
+
+    return _handle_multi_out(
+        out_,
+        default_key=default_key,
+        to_type="str",
+        to_default=True,
+        include_mapping=include_mapping,
+    )

lionagi/core/direct/predict.py

@@ -0,0 +1,174 @@
+from lionagi.libs import func_call
+from ..branch import Branch
+from ..session import Session
+from .utils import _handle_single_out, _handle_multi_out
+
+
+async def predict(
+    sentence,
+    *,
+    num_sentences=1,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    retry_kwargs=None,
+    include_mapping=False,
+    **kwargs,
+):
+    if retry_kwargs is None:
+        retry_kwargs = {}
+    return await _force_predict(
+        sentence=sentence,
+        num_sentences=num_sentences,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        reason=reason,
+        retry_kwargs=retry_kwargs,
+        include_mapping=include_mapping,
+        **kwargs,
+    )
+
+
+async def _force_predict(
+    sentence,
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    retry_kwargs={},
+    include_mapping=False,
+    **kwargs,
+):
+
+    async def _inner1():
+        out_ = await _predict(
+            sentence=sentence,
+            num_sentences=num_sentences,
+            default_key=default_key,
+            confidence_score=confidence_score,
+            reason=reason,
+            **kwargs,
+        )
+        if out_ is None:
+            raise ValueError("No output from the model")
+
+        return out_
+
+    async def _inner2():
+        out_ = await _parallel_predict(
+            sentence=sentence,
+            num_sentences=num_sentences,
+            default_key=default_key,
+            confidence_score=confidence_score,
+            reason=reason,
+            include_mapping=include_mapping,
+            **kwargs,
+        )
+
+        if out_ is None:
+            raise ValueError("No output from the model")
+
+        return out_
+
+    if "retries" not in retry_kwargs:
+        retry_kwargs["retries"] = 2
+
+    if "delay" not in retry_kwargs:
+        retry_kwargs["delay"] = 0.5
+
+    if (isinstance(sentence, (list, tuple)) and len(sentence) > 1) or include_mapping:
+        return await func_call.rcall(_inner2, **retry_kwargs)
+
+    return await func_call.rcall(_inner1, **retry_kwargs)
+
+
+def _create_predict_config(
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    **kwargs,
+):
+    instruct = {
+        "task": f"predict the next {num_sentences} sentence(s)",
+    }
+    extra_fields = kwargs.pop("output_fields", {})
+
+    output_fields = {default_key: "the predicted sentence(s)"}
+    output_fields = {**output_fields, **extra_fields}
+
+    if reason:
+        output_fields["reason"] = "brief reason for the prediction"
+
+    if confidence_score:
+        output_fields["confidence_score"] = (
+            "a numeric score between 0 to 1 formatted in num:0.2f"
+        )
+
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    return instruct, output_fields, kwargs
+
+
+async def _predict(
+    sentence,
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    **kwargs,
+):
+    _instruct, _output_fields, _kwargs = _create_predict_config(
+        num_sentences=num_sentences,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        reason=reason,
+        **kwargs,
+    )
+
+    branch = Branch()
+
+    out_ = await branch.chat(
+        _instruct, context=sentence, output_fields=_output_fields, **_kwargs
+    )
+
+    return _handle_single_out(
+        out_, default_key=default_key, to_type="str", to_default=True
+    )
+
+
+async def _parallel_predict(
+    sentence,
+    num_sentences,
+    default_key="answer",
+    confidence_score=False,
+    reason=False,
+    include_mapping=False,
+    **kwargs,
+):
+    _instruct, _output_fields, _kwargs = _create_predict_config(
+        num_sentences=num_sentences,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        reason=reason,
+        **kwargs,
+    )
+
+    session = Session()
+
+    out_ = await session.parallel_chat(
+        _instruct,
+        context=sentence,
+        output_fields=_output_fields,
+        include_mapping=include_mapping,
+        **_kwargs,
+    )
+
+    return _handle_multi_out(
+        out_,
+        default_key=default_key,
+        to_type="str",
+        to_default=True,
+        include_mapping=include_mapping,
+    )

lionagi/core/direct/react.py

@@ -0,0 +1,33 @@
+from ..branch import Branch
+from ..flow.monoflow import MonoReAct
+
+
+async def react(
+    instruction=None,
+    system=None,
+    context=None,
+    output_fields=None,
+    tools=None,
+    reason_prompt=None,
+    action_prompt=None,
+    output_prompt=None,
+    **kwargs,
+):
+    branch = Branch(system=system, tools=tools)
+    flow = MonoReAct(branch)
+
+    out = await flow._react(
+        instruction=instruction,
+        context=context,
+        output_fields=output_fields,
+        reason_prompt=reason_prompt,
+        action_prompt=action_prompt,
+        **kwargs,
+    )
+
+    output_prompt = output_prompt or "integrate everything, present final output"
+    output_fields_ = {"answer": "..."}
+    out1 = await flow.chat(output_prompt, output_fields=output_fields_)
+
+    out["answer"] = out1["answer"]
+    return out

lionagi/core/direct/score.py

@@ -0,0 +1,163 @@
+from lionagi.libs import func_call, convert
+from ..branch import Branch
+from .utils import _handle_single_out
+
+
+async def score(
+    context,
+    instruction=None,
+    *,
+    score_range=(1, 10),
+    inclusive=True,
+    num_digit=0,
+    default_key="score",
+    method="llm",
+    reason=False,
+    confidence_score=False,
+    retry_kwargs=None,
+    **kwargs,
+):
+    if retry_kwargs is None:
+        retry_kwargs = {}
+    return await _force_score(
+        context=context,
+        instruction=instruction,
+        score_range=score_range,
+        inclusive=inclusive,
+        num_digit=num_digit,
+        default_key=default_key,
+        method=method,
+        reason=reason,
+        confidence_score=confidence_score,
+        retry_kwargs=retry_kwargs,
+        **kwargs,
+    )
+
+
+async def _force_score(
+    context,
+    instruction=None,
+    score_range=(1, 10),
+    inclusive=True,
+    num_digit=1,
+    default_key="score",
+    method="llm",
+    reason=False,
+    confidence_score=False,
+    retry_kwargs={},
+    **kwargs,
+):
+
+    async def _inner():
+        out_ = await _score(
+            instruction=instruction,
+            context=context,
+            score_range=score_range,
+            inclusive=inclusive,
+            num_digit=num_digit,
+            reason=reason,
+            default_key=default_key,
+            confidence_score=confidence_score,
+            method=method,
+            **kwargs,
+        )
+        if out_ is None:
+            raise ValueError("No output from the model")
+
+        return out_
+
+    if "retries" not in retry_kwargs:
+        retry_kwargs["retries"] = 2
+
+    if "delay" not in retry_kwargs:
+        retry_kwargs["delay"] = 0.5
+
+    return await func_call.rcall(_inner, **retry_kwargs)
+
+
+def _create_score_config(
+    instruction,
+    score_range=(1, 10),
+    inclusive=True,
+    num_digit=0,
+    reason=False,
+    default_key="score",
+    confidence_score=False,
+    **kwargs,
+):
+    instruct = {
+        "task": "score context according to the following constraints",
+        "instruction": convert.to_str(instruction),
+        "score_range": convert.to_str(score_range),
+        "include_endpoints": "yes" if inclusive else "no",
+    }
+
+    return_precision = ""
+    if num_digit == 0:
+        return_precision = "integer"
+    else:
+        return_precision = f"num:{convert.to_str(num_digit)}f"
+
+    extra_fields = kwargs.pop("output_fields", {})
+    output_fields = {default_key: f"""a numeric score as {return_precision}"""}
+    output_fields = {**output_fields, **extra_fields}
+
+    if reason:
+        output_fields["reason"] = "brief reason for the score"
+
+    if confidence_score:
+        output_fields["confidence_score"] = (
+            "a numeric score between 0 to 1 formatted in num:0.2f"
+        )
+
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    return instruct, output_fields, kwargs
+
+
+async def _score(
+    context,
+    instruction=None,
+    score_range=(1, 10),
+    inclusive=True,
+    num_digit=0,
+    default_key="score",
+    method="llm",
+    reason=False,
+    confidence_score=False,
+    **kwargs,
+):
+    _instruct, _output_fields, _kwargs = _create_score_config(
+        instruction=instruction,
+        score_range=score_range,
+        inclusive=inclusive,
+        num_digit=num_digit,
+        reason=reason,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        **kwargs,
+    )
+
+    branch = Branch()
+    out_ = ""
+
+    if method == "llm":
+        out_ = await branch.chat(
+            _instruct,
+            tools=None,
+            context=context,
+            output_fields=_output_fields,
+            **_kwargs,
+        )
+
+    to_num_kwargs = {
+        "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,
+    }
+
+    return _handle_single_out(
+        out_, default_key, to_type="num", to_type_kwargs=to_num_kwargs
+    )

lionagi/core/direct/select.py

@@ -0,0 +1,144 @@
+from lionagi.libs import StringMatch, func_call
+from ..branch.branch import Branch
+from .utils import _handle_single_out
+
+
+async def select(
+    context,
+    choices,
+    *,
+    num_choices=1,
+    method="llm",
+    objective=None,
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
+    retry_kwargs=None,
+    **kwargs,
+):
+    if retry_kwargs is None:
+        retry_kwargs = {}
+    return await _force_select(
+        context=context,
+        choices=choices,
+        num_choices=num_choices,
+        method=method,
+        objective=objective,
+        default_key=default_key,
+        reason=reason,
+        confidence_score=confidence_score,
+        retry_kwargs=retry_kwargs,
+        **kwargs,
+    )
+
+
+async def _force_select(
+    context,
+    choices,
+    num_choices=1,
+    method="llm",
+    objective=None,
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
+    retry_kwargs={},
+    **kwargs,
+):
+
+    async def _inner():
+        out_ = await _select(
+            context=context,
+            choices=choices,
+            num_choices=num_choices,
+            method=method,
+            objective=objective,
+            default_key=default_key,
+            reason=reason,
+            confidence_score=confidence_score,
+            retry_kwargs=retry_kwargs,
+            **kwargs,
+        )
+        if out_ is None:
+            raise ValueError("No output from the model")
+
+        if isinstance(out_, dict) and out_[default_key] not in choices:
+            v = StringMatch.choose_most_similar(out_.pop(default_key, ""), choices)
+            out_[default_key] = v
+
+        return out_
+
+    if "retries" not in retry_kwargs:
+        retry_kwargs["retries"] = 2
+
+    if "delay" not in retry_kwargs:
+        retry_kwargs["delay"] = 0.5
+
+    return await func_call.rcall(_inner, **retry_kwargs)
+
+
+def _create_select_config(
+    choices,
+    num_choices=1,
+    objective=None,
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
+    **kwargs,
+):
+
+    instruct = {"task": f"select {num_choices} from provided", "choices": choices}
+    if objective is not None:
+        instruct["objective"] = objective
+
+    extra_fields = kwargs.pop("output_fields", {})
+    output_fields = {default_key: "..."}
+    output_fields = {**output_fields, **extra_fields}
+
+    if reason:
+        output_fields["reason"] = "brief reason for the selection"
+
+    if confidence_score:
+        output_fields["confidence_score"] = (
+            "a numeric score between 0 to 1 formatted in num:0.2f"
+        )
+
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    return instruct, output_fields, kwargs
+
+
+async def _select(
+    context,
+    choices,
+    num_choices=1,
+    method="llm",
+    objective=None,
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
+    **kwargs,
+):
+
+    _instruct, _output_fields, _kwargs = _create_select_config(
+        choices=choices,
+        num_choices=num_choices,
+        objective=objective,
+        default_key=default_key,
+        reason=reason,
+        confidence_score=confidence_score,
+        **kwargs,
+    )
+
+    branch = Branch()
+    out_ = ""
+    if method == "llm":
+        out_ = await branch.chat(
+            _instruct,
+            tools=None,
+            context=context,
+            output_fields=_output_fields,
+            **_kwargs,
+        )
+
+    return _handle_single_out(out_, default_key)

lionagi/core/direct/sentiment.py

@@ -0,0 +1,51 @@
+from .select import select
+from .score import score
+
+
+async def sentiment(
+    context,
+    choices=None,
+    instruction=None,
+    score_range=(0, 1),
+    inclusive=True,
+    num_digit=2,
+    reason=False,
+    method="llm",
+    objective=None,
+    default_key="answer",
+    retries=2,
+    to_type="str",
+    **kwargs,
+):
+    if to_type == "str":
+        if choices is None:
+            choices = ["positive", "negative", "neutral"]
+
+        if objective is None:
+            objective = "classify sentiment"
+
+        return await select(
+            context=context,
+            choices=choices,
+            method=method,
+            objective=objective,
+            default_key=default_key,
+            retries=retries,
+            reason=reason,
+            out_str=True,
+            **kwargs,
+        )
+
+    elif to_type == "num":
+        return await score(
+            context=context,
+            instruction=instruction,
+            score_range=score_range,
+            inclusive=inclusive,
+            num_digit=num_digit,
+            reason=reason,
+            method=method,
+            default_key=default_key,
+            retries=retries,
+            **kwargs,
+        )