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

lionagi/core/{flow/direct/predict.py → direct/parallel_predict.py}

@@ -1,19 +1,22 @@
-from lionagi.libs import ln_func_call as func_call
-from lionagi.core.branch.branch import Branch
-from .utils import _handle_single_out
+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(
+async def parallel_predict(
     sentence,
     *,
     num_sentences=1,
     default_key="answer",
     confidence_score=False,
     reason=False,
-    retry_kwargs={},
+    retry_kwargs=None,
     **kwargs,
 ):
-    return await _force_predict(
+    if retry_kwargs is None:
+        retry_kwargs = {}
+    return await _force_parallel_predict(
         sentence,
         num_sentences,
         default_key,
@@ -24,19 +27,26 @@ async def predict(
     )
 
 
-async def _force_predict(
+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 _predict(
-            sentence, num_sentences, default_key, confidence_score, reason, **kwargs
+        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")
@@ -81,25 +91,37 @@ def _create_predict_config(
     return instruct, output_fields, kwargs
 
 
-async def _predict(
+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,  
+        num_sentences=num_sentences,
+        default_key=default_key,
+        confidence_score=confidence_score,
+        reason=reason,
+        **kwargs,
     )
 
-    branch = Branch()
+    session = Session()
 
-    out_ = await branch.chat(
-        _instruct, context=sentence, output_fields=_output_fields, **_kwargs
+    out_ = await session.parallel_chat(
+        _instruct,
+        context=sentence,
+        output_fields=_output_fields,
+        include_mapping=include_mapping,
+        **_kwargs,
     )
 
-    return _handle_single_out(
-        out_, default_key=default_key, to_type="str", to_default=True
+    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/{flow/direct → direct}/react.py

@@ -1,5 +1,5 @@
-from lionagi.core.branch.branch import Branch
-from lionagi.core.flow.monoflow.ReAct import MonoReAct
+from ..branch import Branch
+from ..flow.monoflow import MonoReAct
 
 
 async def react(

lionagi/core/{flow/direct → direct}/score.py

@@ -1,7 +1,5 @@
-from lionagi.core.branch.branch import Branch
-from lionagi.libs import ln_func_call as func_call
-import lionagi.libs.ln_convert as convert
-
+from lionagi.libs import func_call, convert
+from ..branch import Branch
 from .utils import _handle_single_out
 
 
@@ -16,20 +14,22 @@ async def score(
     method="llm",
     reason=False,
     confidence_score=False,
-    retry_kwargs={},
+    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,
+        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,
     )
 
@@ -65,7 +65,7 @@ async def _force_score(
             raise ValueError("No output from the model")
 
         return out_
-    
+
     if "retries" not in retry_kwargs:
         retry_kwargs["retries"] = 2
 
@@ -86,28 +86,28 @@ def _create_score_config(
     **kwargs,
 ):
     instruct = {
-        "task": f"score context according to the following constraints",
+        "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 = ''
+    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.update({"reason": "brief reason for the score"})
+        output_fields["reason"] = "brief reason for the score"
 
     if confidence_score:
-        output_fields.update(
-            {"confidence_score": "a numeric score between 0 to 1 formatted in num:0.2f"}
+        output_fields["confidence_score"] = (
+            "a numeric score between 0 to 1 formatted in num:0.2f"
         )
 
     if "temperature" not in kwargs:
@@ -143,7 +143,12 @@ async def _score(
     out_ = ""
 
     if method == "llm":
-        out_ = await branch.chat(_instruct, tools=None, context=context, output_fields=_output_fields, **_kwargs,
+        out_ = await branch.chat(
+            _instruct,
+            tools=None,
+            context=context,
+            output_fields=_output_fields,
+            **_kwargs,
         )
 
     to_num_kwargs = {

lionagi/core/{flow/direct → direct}/select.py

@@ -1,22 +1,23 @@
-from lionagi.libs import ln_func_call as func_call
-from lionagi.core.branch.branch import Branch
-from lionagi.libs.ln_parse import StringMatch
-
+from lionagi.libs import StringMatch, func_call
+from ..branch.branch import Branch
 from .utils import _handle_single_out
 
+
 async def select(
-    context, 
-    choices, 
+    context,
+    choices,
     *,
     num_choices=1,
-    method='llm', 
+    method="llm",
     objective=None,
-    default_key='answer',
-    reason=False, 
-    confidence_score=False, 
-    retry_kwargs={},
+    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,
@@ -32,19 +33,18 @@ async def select(
 
 
 async def _force_select(
-    context, 
-    choices, 
+    context,
+    choices,
     num_choices=1,
-    method='llm', 
+    method="llm",
     objective=None,
-    default_key='answer',
-    reason=False, 
-    confidence_score=False, 
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
     retry_kwargs={},
     **kwargs,
 ):
-    
-    
+
     async def _inner():
         out_ = await _select(
             context=context,
@@ -61,10 +61,9 @@ async def _force_select(
         if out_ is None:
             raise ValueError("No output from the model")
 
-        if isinstance(out_, dict):
-            if out_[default_key] not in choices:
-                v = StringMatch.choose_most_similar(out_.pop(default_key, ""), choices)
-                out_[default_key] = v
+        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_
 
@@ -78,15 +77,15 @@ async def _force_select(
 
 
 def _create_select_config(
-        choices, 
-        num_choices=1,
-        objective=None,
-        default_key='answer',
-        reason=False, 
-        confidence_score=False, 
-        **kwargs,
+    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
@@ -96,31 +95,31 @@ def _create_select_config(
     output_fields = {**output_fields, **extra_fields}
 
     if reason:
-        output_fields.update({"reason": "brief reason for the selection"})
+        output_fields["reason"] = "brief reason for the selection"
 
     if confidence_score:
-        output_fields.update(
-            {"confidence_score": "a numeric score between 0 to 1 formatted in num:0.2f"}
+        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, 
+    context,
+    choices,
     num_choices=1,
-    method='llm', 
+    method="llm",
     objective=None,
-    default_key='answer',
-    reason=False, 
-    confidence_score=False, 
+    default_key="answer",
+    reason=False,
+    confidence_score=False,
     **kwargs,
 ):
-    
+
     _instruct, _output_fields, _kwargs = _create_select_config(
         choices=choices,
         num_choices=num_choices,
@@ -130,12 +129,16 @@ async def _select(
         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
+            _instruct,
+            tools=None,
+            context=context,
+            output_fields=_output_fields,
+            **_kwargs,
         )
-    
+
     return _handle_single_out(out_, default_key)

lionagi/core/direct/utils.py

@@ -0,0 +1,83 @@
+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,
+    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":
+        out_[default_key] = convert.to_str(answer, **to_type_kwargs)
+
+    elif to_type == "num":
+        out_[default_key] = convert.to_num(answer, **to_type_kwargs)
+
+    return out_[default_key] if to_default and len(out_.keys()) == 1 else out_
+
+
+def _handle_multi_out(
+    out_,
+    default_key,
+    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_ if len(out_) > 1 else out_[0]

lionagi/core/flow/monoflow/ReAct.py

@@ -42,16 +42,17 @@ class MonoReAct(MonoChat):
         try:
             try:
                 return default.format(num_steps=num_steps)
-            except:
+            except Exception:
                 return default.format(instruction=instruction)
-        except:
+        except Exception:
             return default
 
     def _create_followup_config(self, tools, auto=True, **kwargs):
 
-        if tools is not None:
-            if isinstance(tools, list) and isinstance(tools[0], Tool):
-                self.branch.tool_manager.register_tools(tools)
+        if tools is not None and (
+            isinstance(tools, list) and isinstance(tools[0], 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")

lionagi/core/flow/monoflow/__init__.py

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