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

lionagi/core/flow/polyflow/chat.py

@@ -1,251 +0,0 @@
-"""
-This module contains the PolyChat class for performing parallel chat conversations with multiple branches.
-
-The PolyChat class allows for conducting parallel chat conversations with multiple branches, each processing
-instructions and context independently. It provides methods for parallel chat execution and manages the
-created branches within the session.
-"""
-
-from typing import Any
-
-from lionagi.libs import convert, AsyncUtil
-from lionagi.core.messages.schema import Instruction
-from lionagi.core.branch.branch import Branch
-from lionagi.core.flow.baseflow import BasePolyFlow
-
-
-class PolyChat(BasePolyFlow):
-    """
-    A class for performing parallel chat conversations with multiple branches.
-
-    Methods:
-        __init__(self, session: Any) -> None:
-            Initializes the PolyChat instance.
-
-        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: 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.
-    """
-
-    def __init__(self, session) -> None:
-        """
-        Initializes the PolyChat instance.
-
-        Args:
-            session: The session object.
-        """
-        super().__init__(session)
-
-    async def parallel_chat(
-        self,
-        instruction: Instruction | str,
-        num_instances=1,
-        context=None,
-        sender=None,
-        branch_system=None,
-        messages=None,
-        tools=False,
-        out=True,
-        invoke: bool = True,
-        output_fields=None,
-        persist_path=None,
-        branch_config=None,
-        explode=False,
-        **kwargs,
-    ) -> Any:
-        """
-        Performs parallel chat conversations with multiple branches.
-
-        Args:
-            instruction (Instruction | str): The instruction for the chat conversation.
-            num_instances (int): The number of branch instances to create (default: 1).
-            context (Optional[Any]): Additional context for the chat conversation.
-            sender (Optional[str]): The sender of the chat message.
-            branch_system (Optional[Any]): The system configuration for the branches.
-            messages (Optional[Any]): Messages to initialize the branches with.
-            tools (bool): Flag indicating whether to use tools in the chat conversation (default: False).
-            out (bool): Flag indicating whether to return the output of the chat conversation (default: True).
-            invoke (bool): Flag indicating whether to invoke tools during the chat conversation (default: True).
-            output_fields (Optional[Any]): The output fields for the chat conversation.
-            persist_path (Optional[str]): The path to persist the branch data.
-            branch_config (Optional[dict]): Additional configuration for the branches.
-            explode (bool): Flag indicating whether to explode the instruction and context combinations (default: False).
-            **kwargs: Additional keyword arguments for the chat conversation.
-
-        Returns:
-            Any: The result of the parallel chat conversation.
-        """
-        if branch_config is None:
-            branch_config = {}
-        return await self._parallel_chat(
-            instruction,
-            num_instances=num_instances,
-            context=context,
-            sender=sender,
-            branch_system=branch_system,
-            messages=messages,
-            tools=tools,
-            out=out,
-            invoke=invoke,
-            output_fields=output_fields,
-            persist_path=persist_path,
-            branch_config=branch_config,
-            explode=explode,
-            **kwargs,
-        )
-
-    async def _parallel_chat(
-        self,
-        instruction: Instruction | str,
-        num_instances=1,
-        context=None,
-        sender=None,
-        messages=None,
-        tools=False,
-        out=True,
-        invoke: bool = True,
-        output_fields=None,
-        persist_path=None,
-        branch_config={},
-        explode=False,
-        include_mapping=True,
-        default_key="response",
-        **kwargs,
-    ) -> Any:
-        """
-        Internal method for performing parallel chat conversations with multiple branches.
-
-        Args:
-            instruction (Instruction | str): The instruction for the chat conversation.
-            num_instances (int): The number of branch instances to create (default: 1).
-            context (Optional[Any]): Additional context for the chat conversation.
-            sender (Optional[str]): The sender of the chat message.
-            messages (Optional[Any]): Messages to initialize the branches with.
-            tools (bool): Flag indicating whether to use tools in the chat conversation (default: False).
-            out (bool): Flag indicating whether to return the output of the chat conversation (default: True).
-            invoke (bool): Flag indicating whether to invoke tools during the chat conversation (default: True).
-            output_fields (Optional[Any]): The output fields for the chat conversation.
-            persist_path (Optional[str]): The path to persist the branch data.
-            branch_config (dict): Additional configuration for the branches (default: {}).
-            explode (bool): Flag indicating whether to explode the instruction and context combinations (default: False).
-            include_mapping (bool): Flag indicating whether to include mapping information in the output (default: True).
-            default_key (str): The default key for the output mapping (default: "response").
-            **kwargs: Additional keyword arguments for the chat conversation.
-
-        Returns:
-            Any: The result of the parallel chat conversation.
-        """
-
-        branches = {}
-
-        async def _inner(i, ins_, cxt_):
-
-            branch_ = Branch(
-                messages=messages,
-                service=self.session.default_branch.service,
-                llmconfig=self.session.default_branch.llmconfig,
-                persist_path=persist_path,
-                **branch_config,
-            )
-
-            branch_.branch_name = branch_.id_
-
-            if tools:
-                branch_.tool_manager = self.session.default_branch.tool_manager
-
-            res_ = await branch_.chat(
-                instruction=ins_ or instruction,
-                context=cxt_ or context,
-                sender=sender,
-                tools=tools,
-                invoke=invoke,
-                out=out,
-                output_fields=output_fields,
-                **kwargs,
-            )
-
-            branches[branch_.id_] = branch_
-            if include_mapping:
-                return {
-                    "instruction": ins_ or instruction,
-                    "context": cxt_ or context,
-                    "branch_id": branch_.id_,
-                    default_key: res_,
-                }
-
-            else:
-                return res_
-
-        async def _inner_2(i, ins_=None, cxt_=None):
-            """returns num_instances of branches performing for same task/context"""
-            tasks = [_inner(i, ins_, cxt_) for _ in range(num_instances)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_3(i):
-            """different instructions but same context"""
-            tasks = [_inner_2(i, ins_=ins_) for ins_ in convert.to_list(instruction)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_3_b(i):
-            """different context but same instruction"""
-            tasks = [_inner_2(i, cxt_=cxt_) for cxt_ in convert.to_list(context)]
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        async def _inner_4(i):
-            """different instructions and different context"""
-
-            tasks = []
-            if explode:
-                tasks = [
-                    _inner_2(i, ins_=ins_, cxt_=cxt_)
-                    for ins_ in convert.to_list(instruction)
-                    for cxt_ in convert.to_list(context)
-                ]
-            else:
-                tasks = [
-                    _inner_2(i, ins_=ins_, cxt_=cxt_)
-                    for ins_, cxt_ in zip(
-                        convert.to_list(instruction), convert.to_list(context)
-                    )
-                ]
-
-            ress = await AsyncUtil.execute_tasks(*tasks)
-            return convert.to_list(ress)
-
-        if len(convert.to_list(instruction)) == 1:
-            if len(convert.to_list(context)) == 1:
-                out_ = await _inner_2(0)
-                self.session.branches.update(branches)
-                return out_
-
-            elif len(convert.to_list(context)) > 1:
-                out_ = await _inner_3_b(0)
-                self.session.branches.update(branches)
-                return out_
-
-        elif len(convert.to_list(instruction)) > 1:
-            if len(convert.to_list(context)) == 1:
-                out_ = await _inner_3(0)
-                self.session.branches.update(branches)
-                return out_
-
-            elif len(convert.to_list(context)) > 1:
-                out_ = await _inner_4(0)
-                self.session.branches.update(branches)
-                return out_

lionagi/core/form/action_form.py

@@ -1,26 +0,0 @@
-from typing import Any
-from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
-
-from lionagi.core.form.scored_form import ScoredForm
-
-
-class ActionRequest: ...
-
-
-class ActionForm(ScoredForm):
-
-    action_needed: bool | None = Field(
-        False, description="true if actions are needed else false"
-    )
-
-    actions: list[dict | ActionRequest | Any] | None = Field(
-        default_factory=list,
-        description="""provide The list of action(s) to take, each action in {"function": function_name, "arguments": {param1:..., param2:..., ...}}. Leave blank if no further actions are needed, you must use provided parameters for each action, DO NOT MAKE UP KWARG NAME!!!""",
-    )
-
-    answer: str | dict | Any | None = Field(
-        default_factory=str,
-        description="output answer to the questions asked if further actions are not needed, leave blank if an accurate answer cannot be provided from context during this step",
-    )
-
-    signature: str = "sentence -> reason, action_needed, actions, answer"

lionagi/core/form/field_validator.py

@@ -1,287 +0,0 @@
-"""
-This module provides functions for validating and fixing field values based on their data types.
-
-The module defines several functions for checking and fixing field values of different data types,
-including numeric, boolean, string, and enum. It also provides a dictionary `validation_funcs` that
-maps data types to their corresponding validation functions.
-"""
-
-from lionagi.libs import convert, StringMatch, ParseUtil
-
-
-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):
-    if (
-        isinstance(x, list)
-        and convert.is_same_dtype(x, dict)
-        and all(_has_action_keys(y) for y in x)
-    ):
-        return x
-    try:
-        x = _fix_action_field(x, fix_)
-        return x
-    except Exception as e:
-        raise ValueError("Invalid action field type.") from e
-
-
-def check_number_field(x, fix_=True, **kwargs):
-    """
-    Checks if the given value is a valid numeric field.
-
-    Args:
-        x: The value to check.
-        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
-        **kwargs: Additional keyword arguments for fixing the value.
-
-    Returns:
-        The original value if it's valid, or the fixed value if `fix_` is True.
-
-    Raises:
-        ValueError: If the value is not a valid numeric field and cannot be fixed.
-    """
-    if not isinstance(x, (int, float)):
-        if fix_:
-            try:
-                return _fix_number_field(x, **kwargs)
-            except Exception as e:
-                raise e
-
-        raise ValueError(
-            f"Default value for NUMERIC must be an int or float, got {type(x).__name__}"
-        )
-    return x
-
-
-def check_bool_field(x, fix_=True):
-    """
-    Checks if the given value is a valid boolean field.
-
-    Args:
-        x: The value to check.
-        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
-
-    Returns:
-        The original value if it's valid, or the fixed value if `fix_` is True.
-
-    Raises:
-        ValueError: If the value is not a valid boolean field and cannot be fixed.
-    """
-    if not isinstance(x, bool):
-        if fix_:
-            try:
-                return _fix_bool_field(x)
-            except Exception as e:
-                raise e
-
-        raise ValueError(
-            f"Default value for BOOLEAN must be a bool, got {type(x).__name__}"
-        )
-    return x
-
-
-def check_str_field(x, *args, fix_=True, **kwargs):
-    """
-    Checks if the given value is a valid string field.
-
-    Args:
-        x: The value to check.
-        *args: Additional positional arguments for fixing the value.
-        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
-        **kwargs: Additional keyword arguments for fixing the value.
-
-    Returns:
-        The original value if it's valid, or the fixed value if `fix_` is True.
-
-    Raises:
-        ValueError: If the value is not a valid string field and cannot be fixed.
-    """
-    if not isinstance(x, str):
-        if fix_:
-            try:
-                return _fix_str_field(x, *args, **kwargs)
-            except Exception as e:
-                raise e
-
-        raise ValueError(
-            f"Default value for STRING must be a str, got {type(x).__name__}"
-        )
-    return x
-
-
-def check_enum_field(x, choices, fix_=True, **kwargs):
-    """
-    Checks if the given value is a valid enum field.
-
-    Args:
-        x: The value to check.
-        choices: The list of valid choices for the enum field.
-        fix_ (bool): Flag indicating whether to attempt fixing the value if it's invalid (default: True).
-        **kwargs: Additional keyword arguments for fixing the value.
-
-    Returns:
-        The original value if it's valid, or the fixed value if `fix_` is True.
-
-    Raises:
-        ValueError: If the value is not a valid enum field and cannot be fixed.
-    """
-    same_dtype, dtype_ = convert.is_same_dtype(choices, return_dtype=True)
-    if not same_dtype:
-        raise ValueError(
-            f"Field type ENUM requires all choices to be of the same type, got {choices}"
-        )
-
-    if not isinstance(x, dtype_):
-        raise ValueError(
-            f"Default value for ENUM must be an instance of the {dtype_.__name__}, got {type(x).__name__}"
-        )
-
-    if x not in choices:
-        if fix_:
-            try:
-                return _fix_enum_field(x, choices, **kwargs)
-            except Exception as e:
-                raise e
-        raise ValueError(
-            f"Default value for ENUM must be one of the {choices}, got {x}"
-        )
-
-    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.
-
-    Args:
-        x: The value to fix.
-        *args: Additional positional arguments for fixing the value.
-        **kwargs: Additional keyword arguments for fixing the value.
-
-    Returns:
-        The fixed numeric value.
-
-    Raises:
-        ValueError: If the value cannot be converted into a valid numeric value.
-    """
-    try:
-        x = convert.to_num(x, *args, **kwargs)
-        if isinstance(x, (int, float)):
-            return x
-        raise ValueError(f"Failed to convert {x} into a numeric value")
-    except Exception as e:
-        raise ValueError(f"Failed to convert {x} into a numeric value") from e
-
-
-def _fix_bool_field(x):
-    """
-    Attempts to fix an invalid boolean field value.
-
-    Args:
-        x: The value to fix.
-
-    Returns:
-        The fixed boolean value.
-
-    Raises:
-        ValueError: If the value cannot be converted into a valid boolean value.
-    """
-    try:
-        x = convert.strip_lower(convert.to_str(x))
-        if x in ["true", "1", "correct", "yes"]:
-            return True
-
-        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
-
-
-def _fix_str_field(x):
-    """
-    Attempts to fix an invalid string field value.
-
-    Args:
-        x: The value to fix.
-
-    Returns:
-        The fixed string value.
-
-    Raises:
-        ValueError: If the value cannot be converted into a valid string value.
-    """
-    try:
-        x = convert.to_str(x)
-        if isinstance(x, str):
-            return x
-        raise ValueError(f"Failed to convert {x} into a string value")
-    except Exception as e:
-        raise ValueError(f"Failed to convert {x} into a string value") from e
-
-
-def _fix_enum_field(x, choices, **kwargs):
-    """
-    Attempts to fix an invalid enum field value.
-
-    Args:
-        x: The value to fix.
-        choices: The list of valid choices for the enum field.
-        **kwargs: Additional keyword arguments for fixing the value.
-
-    Returns:
-        The fixed enum value.
-
-    Raises:
-        ValueError: If the value cannot be converted into a valid enum value.
-    """
-    try:
-        x = convert.to_str(x)
-        return StringMatch.choose_most_similar(x, choices, **kwargs)
-    except Exception as e:
-        raise ValueError(f"Failed to convert {x} into one of the choices") from e
-
-
-validation_funcs = {
-    "number": check_number_field,
-    "bool": check_bool_field,
-    "str": check_str_field,
-    "enum": check_enum_field,
-    "action": check_action_field,
-    "dict": check_dict_field,
-}