lionagi 0.0.316__py3-none-any.whl → 0.1.0__py3-none-any.whl

lionagi/core/flow/monoflow/chat_mixin.py

@@ -5,14 +5,10 @@ This module contains mixins for configuring and invoking chatbots.
 from abc import ABC
 from typing import Any
 
+import re
+from lionagi.libs import nested, func_call, convert, StringMatch, ParseUtil
+from lionagi.core.tool.tool import TOOL_TYPE
 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):
@@ -21,8 +17,8 @@ class MonoChatConfigMixin(ABC):
 
     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.
+        output_fields=None, form=None, tools=False, **kwargs) -> Any:
+        Creates a chat configuration based on the provided parameters.
     """
 
     def _create_chat_config(
@@ -32,7 +28,7 @@ class MonoChatConfigMixin(ABC):
         sender: str | None = None,
         system: str | dict[str, Any] | None = None,
         output_fields=None,
-        prompt_template=None,
+        form=None,
         tools: TOOL_TYPE = False,
         **kwargs,
     ) -> Any:
@@ -45,7 +41,7 @@ class MonoChatConfigMixin(ABC):
             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).
+            form: 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.
 
@@ -55,7 +51,7 @@ class MonoChatConfigMixin(ABC):
         if system:
             self.branch.change_first_system_message(system)
 
-        if not prompt_template:
+        if not form:
             self.branch.add_message(
                 instruction=instruction,
                 context=context,
@@ -63,7 +59,7 @@ class MonoChatConfigMixin(ABC):
                 output_fields=output_fields,
             )
         else:
-            instruct_ = Instruction.from_prompt_template(prompt_template)
+            instruct_ = Instruction.from_form(form)
             self.branch.add_message(instruction=instruct_)
 
         if "tool_parsed" in kwargs:
@@ -85,8 +81,8 @@ 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):
+        async _output(self, invoke, out, output_fields, func_calls_=None, form=None,
+                    return_template=True):
             Processes the output of the chatbot.
 
         _return_response(content_, output_fields) -> Any:
@@ -108,7 +104,7 @@ class MonoChatInvokeMixin(ABC):
         out,
         output_fields,
         func_calls_=None,
-        prompt_template=None,
+        form=None,
         return_template=True,
     ):
         """
@@ -119,7 +115,7 @@ class MonoChatInvokeMixin(ABC):
             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).
+            form: The prompt template for the chatbot (optional).
             return_template (bool): Flag indicating whether to return the prompt template (default: True).
         """
 
@@ -132,9 +128,10 @@ class MonoChatInvokeMixin(ABC):
                 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 form:
+            form._process_response(response_)
+            return form if return_template else form.outputs
 
         if out:
             return response_
@@ -159,24 +156,17 @@ class MonoChatInvokeMixin(ABC):
 
         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_)
+                return StringMatch.force_validate_dict(
+                    out_, keys=list(output_fields.keys())
+                )
             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_
+                match = re.search(r"```json\n({.*?})\n```", out_, re.DOTALL)
+                if match:
+                    out_ = ParseUtil.fuzzy_parse_json(match.group(1))
             except Exception:
                 pass
 
@@ -260,4 +250,4 @@ class MonoChatMixin(MonoChatConfigMixin, MonoChatInvokeMixin, ABC):
     Mixin class that combines MonoChatConfigMixin and MonoChatInvokeMixin.
     """
 
-    pass
+    pass

lionagi/core/flow/monoflow/followup.py

@@ -6,9 +6,9 @@ process instructions, system messages, and invoke tools during the conversation.
 """
 
 from typing import Callable
-from lionagi.core.messages import Instruction
-from lionagi.core.schema import Tool
-from .chat import MonoChat
+from lionagi.core.messages.schema import Instruction
+from lionagi.core.tool.tool import Tool
+from lionagi.core.flow.monoflow.chat import MonoChat
 
 
 class MonoFollowup(MonoChat):
@@ -211,4 +211,4 @@ class MonoFollowup(MonoChat):
                 instruction=instruction,
             )
             _out = await self.chat(_prompt, sender=sender, **kwargs)
-            return _out if out else None
+            return _out if out else None

lionagi/core/flow/polyflow/__init__.py

@@ -1 +1 @@
-from .chat import PolyChat
+from .chat import PolyChat

lionagi/core/flow/polyflow/chat.py

@@ -8,13 +8,10 @@ created branches within the session.
 
 from typing import Any
 
-from lionagi.libs import ln_convert as convert
-from lionagi.libs.ln_async import AsyncUtil
-
+from lionagi.libs import convert, AsyncUtil
 from lionagi.core.messages.schema import Instruction
 from lionagi.core.branch.branch import Branch
-
-from lionagi.core.flow.base.baseflow import BasePolyFlow
+from lionagi.core.flow.baseflow import BasePolyFlow
 
 
 class PolyChat(BasePolyFlow):
@@ -22,17 +19,23 @@ class PolyChat(BasePolyFlow):
     A class for performing parallel chat conversations with multiple branches.
 
     Methods:
-        __init__(self, session) -> None:
+        __init__(self, session: Any) -> None:
             Initializes the PolyChat instance.
 
-        async parallel_chat(self, instruction, num_instances=1, context=None, sender=None, branch_system=None,
-                             messages=None, tools=False, out=True, invoke=True, output_fields=None,
-                             persist_path=None, branch_config=None, explode=False, **kwargs) -> Any:
+        async parallel_chat(self, instruction: Union[Instruction, str], num_instances: int = 1,
+                             context: Optional[Any] = None, sender: Optional[str] = None,
+                             branch_system: Optional[Any] = None, messages: Optional[Any] = None,
+                             tools: bool = False, out: bool = True, invoke: bool = True,
+                             output_fields: Optional[Any] = None, persist_path: Optional[str] = None,
+                             branch_config: Optional[dict] = None, explode: bool = False, **kwargs) -> Any:
             Performs parallel chat conversations with multiple branches.
 
-        async _parallel_chat(self, instruction, num_instances=1, context=None, sender=None, messages=None,
-                              tools=False, out=True, invoke=True, output_fields=None, persist_path=None,
-                              branch_config={}, explode=False, include_mapping=True, default_key="response",
+        async _parallel_chat(self, instruction: Union[Instruction, str], num_instances: int = 1,
+                              context: Optional[Any] = None, sender: Optional[str] = None,
+                              messages: Optional[Any] = None, tools: bool = False, out: bool = True,
+                              invoke: bool = True, output_fields: Optional[Any] = None,
+                              persist_path: Optional[str] = None, branch_config: dict = {},
+                              explode: bool = False, include_mapping: bool = True, default_key: str = "response",
                               **kwargs) -> Any:
             Internal method for performing parallel chat conversations with multiple branches.
     """

lionagi/core/{prompt/action_template.py → form/action_form.py}

@@ -1,13 +1,13 @@
 from typing import Any
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
 
-from .scored_template import ScoredTemplate
+from lionagi.core.form.scored_form import ScoredForm
 
 
 class ActionRequest: ...
 
 
-class ActionedTemplate(ScoredTemplate):
+class ActionForm(ScoredForm):
 
     action_needed: bool | None = Field(
         False, description="true if actions are needed else false"

lionagi/core/{prompt → form}/field_validator.py

@@ -9,8 +9,16 @@ maps data types to their corresponding validation functions.
 from lionagi.libs import convert, StringMatch, ParseUtil
 
 
-def _has_action_keys(dict_):
-    return list(dict_.keys()) >= ["function", "arguments"]
+def check_dict_field(x, keys: list[str] | dict, fix_=True, **kwargs):
+    if isinstance(x, dict):
+        return x
+    if fix_:
+        try:
+            x = convert.to_str(x)
+            return StringMatch.force_validate_dict(x, keys=keys, **kwargs)
+        except Exception as e:
+            raise ValueError("Invalid dict field type.") from e
+    raise ValueError(f"Default value for DICT must be a dict, got {type(x).__name__}")
 
 
 def check_action_field(x, fix_=True, **kwargs):
@@ -27,26 +35,6 @@ def check_action_field(x, fix_=True, **kwargs):
         raise ValueError("Invalid action field type.") from e
 
 
-def _fix_action_field(x, discard_=True):
-    corrected = []
-    if isinstance(x, str):
-        x = ParseUtil.fuzzy_parse_json(x)
-
-    try:
-        x = convert.to_list(x)
-
-        for i in x:
-            i = convert.to_dict(i)
-            if _has_action_keys(i):
-                corrected.append(i)
-            elif not discard_:
-                raise ValueError(f"Invalid action field: {i}")
-    except Exception as e:
-        raise ValueError(f"Invalid action field: {e}") from e
-
-    return corrected
-
-
 def check_number_field(x, fix_=True, **kwargs):
     """
     Checks if the given value is a valid numeric field.
@@ -171,6 +159,30 @@ def check_enum_field(x, choices, fix_=True, **kwargs):
     return x
 
 
+def _has_action_keys(dict_):
+    return list(dict_.keys()) >= ["function", "arguments"]
+
+
+def _fix_action_field(x, discard_=True):
+    corrected = []
+    if isinstance(x, str):
+        x = ParseUtil.fuzzy_parse_json(x)
+
+    try:
+        x = convert.to_list(x)
+
+        for i in x:
+            i = convert.to_dict(i)
+            if _has_action_keys(i):
+                corrected.append(i)
+            elif not discard_:
+                raise ValueError(f"Invalid action field: {i}")
+    except Exception as e:
+        raise ValueError(f"Invalid action field: {e}") from e
+
+    return corrected
+
+
 def _fix_number_field(x, *args, **kwargs):
     """
     Attempts to fix an invalid numeric field value.
@@ -209,17 +221,13 @@ def _fix_bool_field(x):
         ValueError: If the value cannot be converted into a valid boolean value.
     """
     try:
-        x = convert.to_str(x)
-        if (
-            convert.strip_lower(x) in ["true", "1", "correct", "yes"]
-            or convert.to_num(x) == 1
-        ):
+        x = convert.strip_lower(convert.to_str(x))
+        if x in ["true", "1", "correct", "yes"]:
             return True
-        elif (
-            convert.strip_lower(x) in ["false", "0", "incorrect", "no", "none", "n/a"]
-            or convert.to_num(x) == 0
-        ):
+
+        elif x in ["false", "0", "incorrect", "no", "none", "n/a"]:
             return False
+
         raise ValueError(f"Failed to convert {x} into a boolean value")
     except Exception as e:
         raise ValueError(f"Failed to convert {x} into a boolean value") from e
@@ -275,4 +283,5 @@ validation_funcs = {
     "str": check_str_field,
     "enum": check_enum_field,
     "action": check_action_field,
+    "dict": check_dict_field,
 }

lionagi/core/form/form.py

@@ -0,0 +1,302 @@
+from typing import Any
+from pydantic import Field
+
+from lionagi.libs import convert, func_call
+
+from lionagi.core.generic import BaseComponent
+from lionagi.core.form.field_validator import validation_funcs
+
+
+non_prompt_words = [
+    "id_",
+    "node_id",
+    "meta",
+    "metadata",
+    "timestamp",
+    "content",
+    "signature",
+    "task",
+    "template_name",
+    "version",
+    "description",
+    "in_validation_kwargs",
+    "out_validation_kwargs",
+    "fix_input",
+    "fix_output",
+    "input_fields",
+    "output_fields",
+    "choices",
+    "prompt_fields",
+    "prompt_fields_annotation",
+    "instruction_context",
+    "instruction",
+    "instruction_output_fields",
+    "inputs",
+    "outputs",
+    "process",
+    "_validate_field",
+    "_process_input",
+    "_process_response",
+    "_validate_field_choices",
+    "_validate_input_choices",
+    "_validate_output_choices",
+]
+
+
+class Form(BaseComponent):
+    template_name: str = Field(
+        default="default_form",
+        description="The name of the prompt template.",
+    )
+    signature: str = Field("null", description="signature indicating inputs, outputs")
+    version: str | float | int | None = Field(
+        default=None, description="The version of the prompt template."
+    )
+    description: str | dict[str, Any] | None | Any = Field(
+        default=None, description="The description of the prompt template."
+    )
+    task: str | dict[str, Any] | None = Field(
+        default=None, description="The task associated with the prompt template."
+    )
+    out_validation_kwargs: dict[str, Any] = Field(
+        default_factory=dict, description="validation kwargs for output"
+    )
+    in_validation_kwargs: dict[str, Any] = Field(
+        default_factory=dict, description="validation kwargs for input"
+    )
+    fix_input: bool = Field(True, description="whether to fix input")
+    fix_output: bool = Field(True, description="whether to fix output")
+    input_fields: list[str] = Field(
+        default_factory=list, description="Extracted input fields from the signature."
+    )
+    output_fields: list[str] = Field(
+        default_factory=list, description="Extracted output fields from the signature."
+    )
+    choices: dict[str, list[str]] = Field(
+        default_factory=dict, description="Choices available for each template field."
+    )
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.input_fields, self.output_fields = self._get_input_output_fields(
+            self.signature
+        )
+        self.process(in_=True)
+
+    @property
+    def prompt_fields(self):
+        return self.input_fields + self.output_fields
+
+    @property
+    def instruction_context(self):
+        a = "".join(
+            f"""
+        ## input: {i}:
+        - description: {self.model_fields[i].description}
+        - value: {str(self.__getattribute__(self.input_fields[idx]))}
+        """
+            for idx, i in enumerate(self.input_fields)
+        )
+        return a.replace("        ", "")
+
+    @property
+    def instruction(self):
+        ccc = f"""
+        0. Your task is {self.task},
+        1. provided: {self.input_fields}, 
+        2. requested: {self.output_fields}
+        ----------
+        """
+        return ccc.replace("        ", "")
+
+    @property
+    def instruction_output_fields(self):
+        return {i: self.model_fields[i].description for i in self.output_fields}
+
+    @property
+    def inputs(self):
+        return {i: getattr(self, i) for i in self.input_fields}
+
+    @property
+    def outputs(self):
+        return {i: getattr(self, i) for i in self.output_fields}
+
+    def process(self, in_=None, out_=None):
+        if in_:
+            self._process_input()
+            self._validate_input_choices()
+        if out_:
+            self._process_response(out_)
+            self._validate_output_choices()
+        return self
+
+    def _validate_field_choices(self, fields, fix_: bool = False):
+        if len(self.choices) >= 1:
+            for k, choices in self.choices.items():
+                if k in fields and not self._validate_field(
+                    k, getattr(self, k), choices, fix_
+                ):
+                    raise ValueError(
+                        f"Invalid choice for field {k}: {getattr(self, k)} is not in {choices}"
+                    )
+
+    def _validate_input_choices(self):
+        return self._validate_field_choices(self.input_fields, self.fix_input)
+
+    def _validate_output_choices(self):
+        return self._validate_field_choices(self.output_fields, self.fix_output)
+
+    def _validate_field(self, k, v, choices=None, keys=None, fix_=False, **kwargs):
+
+        str_ = self._prompt_fields_annotation[k]
+
+        if keys:
+            v_ = validation_funcs["dict"](v, keys=keys, fix_=fix_, **kwargs)
+            setattr(self, k, v_)
+            return True
+
+        if choices:
+            v_ = validation_funcs["enum"](v, choices=choices, fix_=fix_, **kwargs)
+            if v_ not in choices:
+                raise ValueError(f"{v} is not in chocies {choices}")
+            setattr(self, k, v_)
+            return True
+
+        if "lionagi.core.form.action_form.actionrequest" in str_:
+            self.__setattr__(k, validation_funcs["action"](v))
+            return True
+
+        if "bool" in str_ and "str" not in str_:
+            self.__setattr__(k, validation_funcs["bool"](v, fix_=fix_, **kwargs))
+            return True
+
+        if any(i in str_ for i in ["int", "float", "number"]) and "str" not in str_:
+            self.__setattr__(k, validation_funcs["number"](v, fix_=fix_, **kwargs))
+            return True
+
+        elif "str" in str_:
+            self.__setattr__(k, validation_funcs["str"](v, fix_=fix_, **kwargs))
+            return True
+
+        return False
+
+    def _process_input(self, fix_=False):
+        kwargs = self.in_validation_kwargs.copy()
+        for k, v in self.inputs.items():
+            if k not in kwargs:
+                kwargs = {k: {}}
+
+            if self._field_has_choices(k):
+                self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
+                if self._validate_field(
+                    k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
+                ):
+                    continue
+                else:
+                    raise ValueError(f"{k} has no choices")
+
+            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
+                continue
+            else:
+                raise ValueError(f"failed to validate field {k}")
+
+    def _get_field_attr(self, k, attr) -> Any:
+        if not self._field_has_attr(k, attr):
+            raise ValueError(f"field {k} has no attribute {attr}")
+        field = self.model_fields[k]
+        a = getattr(field, attr)
+        if not a:
+            try:
+                a = field.json_schema_extra[attr]
+                return a
+            except Exception:
+                return None
+        return a
+
+    def _field_has_attr(self, k, attr):
+        a = False
+
+        field = self.model_fields[k]
+        a = hasattr(field, attr)
+
+        if not a:
+            try:
+                a = (
+                    self.model_fields[k].json_schema_extra[attr] is not None
+                    and attr in self.model_fields[k].json_schema_extra
+                )
+                return a if isinstance(a, bool) else False
+            except Exception:
+                return False
+
+    def _field_has_keys(self, k):
+        return self._field_has_attr(k, "keys")
+
+    def _field_has_choices(self, k):
+        return self._field_has_attr(k, "choices")
+
+    def _process_choices(self, k, v, fix_=False, kwargs=None):
+        choices = self._get_field_attr(k, "choices")
+
+        if self._validate_field(k, v, choices=choices, fix_=fix_, **kwargs):
+            self.choices[k] = choices
+            return True
+        else:
+            raise ValueError(f"{k} has no choices")
+
+    def _process_keys(self, k, v, fix_=False, kwargs=None):
+        keys = self._get_field_attr(k, "keys")
+        if self._validate_field(k, v, keys=keys, fix_=fix_, **kwargs):
+            return True
+        else:
+            raise ValueError(f"{k} has no keys")
+
+    def _process_response(self, out_, fix_=fix_output):
+        kwargs = self.out_validation_kwargs.copy()
+        for k, v in out_.items():
+            if k not in kwargs:
+                kwargs = {k: {}}
+
+            if self._field_has_choices(k):
+                try:
+                    return self._process_choices(k, v, fix_=fix_, kwargs=kwargs[k])
+                except Exception as e:
+                    raise ValueError(
+                        f"failed to process field {k} with value {v}"
+                    ) from e
+
+            elif self._field_has_keys(k):
+                try:
+                    return self._process_keys(k, v, fix_=fix_, kwargs=kwargs[k])
+                except Exception as e:
+                    raise ValueError(
+                        f"failed to process field {k} with value {v}"
+                    ) from e
+
+            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
+                continue
+
+            else:
+                raise ValueError(f"failed to validate field {k} with value {v}")
+
+    @staticmethod
+    def _get_input_output_fields(str_: str) -> Any:
+        inputs, outputs = str_.split("->")
+
+        input_fields = [convert.strip_lower(i) for i in inputs.split(",")]
+        output_fields = [convert.strip_lower(o) for o in outputs.split(",")]
+
+        return input_fields, output_fields
+
+    @property
+    def _prompt_fields_annotation(self):
+        dict_ = {i: self.model_fields[i].annotation for i in self.prompt_fields}
+        for k, v in dict_.items():
+            if "|" in str(v):
+                v = str(v)
+                v = v.split("|")
+                dict_[k] = func_call.lcall(v, convert.strip_lower)
+            else:
+                dict_[k] = [v.__name__]
+
+        return dict_