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

lionagi/core/report/form.py

@@ -0,0 +1,231 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""
+This module extends the BaseForm class to implement the Form class, which
+dynamically manages form operations based on specific assignments. It provides
+functionalities for initializing fields, filling forms with data, and
+validating the readiness of forms for further processing.
+"""
+
+from typing import Dict, Any
+from lionagi.libs.ln_convert import to_readable_dict
+from lionagi.core.collections.abc import SYSTEM_FIELDS
+from lionagi.core.report.util import get_input_output_fields
+from lionagi.core.report.base import BaseForm
+
+
+class Form(BaseForm):
+    """
+    A specialized implementation of BaseForm designed to manage form fields
+    dynamically based on specified assignments. Supports initialization and
+    management of input and requested fields, handles form filling operations,
+    and ensures forms are properly configured for use.
+
+    Attributes:
+        input_fields (List[str]): Fields required to carry out the objective of the form.
+        requested_fields (List[str]): Fields requested to be filled by the user.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new instance of the Form, setting up input and requested
+        fields based on the form's assignment.
+        """
+        super().__init__(**kwargs)
+        self.input_fields, self.requested_fields = get_input_output_fields(
+            self.assignment
+        )
+
+        for i in self.input_fields:
+            self.append_to_input(i)
+
+        for i in self.input_fields + self.requested_fields:
+            if i not in self._all_fields:
+                self._add_field(i, value=None)
+
+    def append_to_request(self, field: str, value=None):
+        """
+        Appends a field to the requested fields.
+
+        Args:
+            field (str): The name of the field to be requested.
+            value (optional): The value to be assigned to the field. Defaults to None.
+        """
+        if "," in field:
+            field = field.split(",")
+        if not isinstance(field, list):
+            field = [field]
+
+        for i in field:
+            i = i.strip()
+            if i not in self._all_fields:
+                self._add_field(i, value=value)
+
+            if i not in self.requested_fields:
+                self.requested_fields.append(i)
+                self.validation_kwargs[i] = self._get_field_attr(
+                    i, "validation_kwargs", {}
+                )
+
+    def append_to_input(self, field: str, value=None):
+        """
+        Appends a field to the input fields.
+
+        Args:
+            field (str): The name of the field to be added to input.
+            value (optional): The value to be assigned to the field. Defaults to None.
+        """
+        if "," in field:
+            field = field.split(",")
+        if not isinstance(field, list):
+            field = [field]
+
+        for i in field:
+            i = i.strip()
+            if i not in self._all_fields:
+                self._add_field(i, value=value)
+
+            if i not in self.input_fields:
+                self.input_fields.append(i)
+                self.validation_kwargs[i] = self._get_field_attr(
+                    i, "validation_kwargs", {}
+                )
+
+    @property
+    def work_fields(self) -> Dict[str, Any]:
+        """
+        Retrieves a dictionary of the fields relevant to the current task,
+        excluding any SYSTEM_FIELDS and including only the input and requested
+        fields.
+
+        Returns:
+            Dict[str, Any]: The relevant fields for the current task.
+        """
+        dict_ = self.to_dict()
+        return {
+            k: v
+            for k, v in dict_.items()
+            if k not in SYSTEM_FIELDS and k in self.input_fields + self.requested_fields
+        }
+
+    def fill(self, form: "Form" = None, strict: bool = True, **kwargs) -> None:
+        """
+        Fills the form from another form instance or provided keyword arguments.
+        Raises an error if the form is already filled.
+
+        Args:
+            form (Form, optional): The form to fill from.
+            strict (bool, optional): Whether to enforce strict filling. Defaults to True.
+            **kwargs: Additional fields to fill.
+        """
+        if self.filled:
+            if strict:
+                raise ValueError("Form is filled, cannot be worked on again")
+
+        all_fields = self._get_all_fields(form, **kwargs)
+
+        for k, v in all_fields.items():
+            if (
+                k in self.work_fields
+                and v is not None
+                and getattr(self, k, None) is None
+            ):
+                setattr(self, k, v)
+
+    def is_workable(self) -> bool:
+        """
+        Determines if the form is ready for processing. Checks if all required
+        fields are filled and raises an error if the form is already filled or
+        if any required field is missing.
+
+        Returns:
+            bool: True if the form is workable, otherwise raises ValueError.
+        """
+        if self.filled:
+            raise ValueError("Form is already filled, cannot be worked on again")
+
+        for i in self.input_fields:
+            if not getattr(self, i, None):
+                raise ValueError(f"Required field {i} is not provided")
+
+        return True
+
+    @property
+    def _instruction_context(self) -> str:
+        """
+        Generates a detailed description of the input fields, including their
+        current values and descriptions.
+
+        Returns:
+            str: A detailed description of the input fields.
+        """
+        return "".join(
+            f"""
+        ## input: {i}:
+        - description: {getattr(self._all_fields[i], "description", "N/A")}
+        - value: {str(getattr(self, self.input_fields[idx]))}
+        """
+            for idx, i in enumerate(self.input_fields)
+        )
+
+    @property
+    def _instruction_prompt(self) -> str:
+        return f"""
+        ## Task Instructions
+        Please follow prompts to complete the task:
+        1. Your task is: {self.task}
+        2. The provided input fields are: {', '.join(self.input_fields)}
+        3. The requested output fields are: {', '.join(self.requested_fields)}
+        4. Provide your response in the specified JSON format.
+        """
+
+    @property
+    def _instruction_requested_fields(self) -> Dict[str, str]:
+        """
+        Provides a dictionary mapping requested field names to their
+        descriptions.
+
+        Returns:
+            Dict[str, str]: A dictionary of requested field descriptions.
+        """
+        return {
+            i: getattr(self._all_fields[i], "description", "N/A")
+            for i in self.requested_fields
+        }
+
+    def display(self, fields=None):
+        """
+        Displays the form fields using IPython display.
+
+        Args:
+            fields (optional): Specific fields to display. Defaults to None.
+        """
+        from IPython.display import display, Markdown
+
+        fields = fields or self.work_fields
+
+        if "answer" in fields:
+            answer = fields.pop("answer")
+            fields["answer"] = answer
+
+        for k, v in fields.items():
+            if isinstance(v, dict):
+                v = to_readable_dict(v)
+            if len(str(v)) > 50:
+                display(Markdown(f"**{k}**: \n {v}"))
+            else:
+                display(Markdown(f"**{k}**: {v}"))

lionagi/core/report/report.py

@@ -0,0 +1,166 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+"""
+This module introduces the Report class, an extension of the BaseForm class
+designed to manage and synchronize a collection of Form instances based on
+specific assignments. The Report class handles the creation and updating of
+forms, ensuring each is properly configured according to the report's
+requirements.
+"""
+
+from typing import Any, Type
+from lionagi.core.collections.abc import Field
+from lionagi.core.collections import Pile, pile
+from lionagi.core.report.util import get_input_output_fields
+from lionagi.core.report.base import BaseForm
+from lionagi.core.report.form import Form
+
+
+class Report(BaseForm):
+    """
+    Extends BaseForm to handle a collection of Form instances based on specific
+    assignments, managing a pile of forms and ensuring synchronization and
+    proper configuration.
+    """
+
+    forms: Pile[Form] = Field(
+        None,
+        description="A pile of forms related to the report.",
+    )
+
+    form_assignments: list = Field(
+        [],
+        description="assignment for the report",
+        examples=[["a, b -> c", "a -> e", "b -> f", "c -> g", "e, f, g -> h"]],
+    )
+
+    form_template: Type[Form] = Field(
+        Form, description="The template for the forms in the report."
+    )
+
+    def __init__(self, **kwargs):
+        """
+        Initializes the Report with input and requested fields based on the
+        report's assignment, creating forms dynamically from provided assignments.
+        """
+        super().__init__(**kwargs)
+        self.input_fields, self.requested_fields = get_input_output_fields(
+            self.assignment
+        )
+
+        # if assignments is not provided, set it to report assignment
+        if self.form_assignments == []:
+            self.form_assignments.append(self.assignment)
+
+        # create forms
+        self.forms = pile(
+            [self.form_template(assignment=i) for i in self.form_assignments],
+            [Form, BaseForm, Report],
+        )
+
+        # Add undeclared fields to report with None values
+        for v in self.forms:
+            for _field in list(v.work_fields.keys()):
+                if _field not in self._all_fields:
+                    field_obj = v._all_fields[_field]
+                    self._add_field(_field, value=None, field_obj=field_obj)
+
+        # Synchronize fields between report and forms
+        for k, v in self._all_fields.items():
+            if getattr(self, k, None) is not None:
+                for _form in self.forms:
+                    if k in _form.work_fields:
+                        _form.fill(**{k: getattr(self, k)})
+
+    @property
+    def work_fields(self) -> dict[str, Any]:
+        all_fields = {}
+        for form in self.forms.values():
+            for k, v in form.work_fields.items():
+                if k not in all_fields:
+                    all_fields[k] = v
+        return all_fields
+
+    def fill(self, form: Form | list[Form] | dict[Form] = None, strict=True, **kwargs):
+        if self.filled:
+            if strict:
+                raise ValueError("Form is filled, cannot be worked on again")
+
+        # gather all unique valid fields from input form,
+        # kwargs and self workfields data
+        all_fields = self._get_all_fields(form, **kwargs)
+
+        # if there are information in the forms that are not in the report,
+        # add them to the report
+        for k, v in all_fields.items():
+            if k in self.work_fields and getattr(self, k, None) is None:
+                setattr(self, k, v)
+
+        # if there are information in the report that are not in the forms,
+        # add them to the forms
+        for _form in self.forms:
+            for k, v in _form.work_fields.items():
+                _kwargs = {}
+                if v is None and (a := getattr(self, k, None)) is not None:
+                    _kwargs[k] = a
+                _form.fill(**_kwargs)
+
+    def is_workable(self) -> bool:
+        """
+        Checks if the report is ready for processing, ensuring all necessary fields
+        are filled and output fields are unique across forms.
+
+        Returns:
+            bool: True if the report is workable, otherwise raises ValueError.
+        """
+        if self.filled:
+            raise ValueError("Form is already filled, cannot be worked on again")
+
+        for i in self.input_fields:
+            if not getattr(self, i, None):
+                raise ValueError(f"Required field {i} is not provided")
+
+        # this is the required fields from report's own assignment
+        fields = self.input_fields
+        fields.extend(self.requested_fields)
+
+        # if the report's own assignment is not in the forms, return False
+        for f in fields:
+            if f not in self.work_fields:
+                raise ValueError(f"Field {f} is not in the forms")
+
+        # get all the output fields from all the forms
+        outs = []
+        for form in self.forms.values():
+            outs.extend(form.requested_fields)
+
+        # all output fields should be unique, not a single output field should be
+        # calculated by more than one form
+        if len(outs) != len(set(outs)):
+            raise ValueError("Output fields are not unique")
+
+        return True
+
+    def next_forms(self) -> Pile[Form]:
+        """
+        Returns a pile of workable forms based on current form states within the report.
+
+        Returns:
+            Pile[Form]: A pile of workable forms or None if there are no workable forms.
+        """
+        a = [i for i in self.forms if i.workable]
+        return pile(a, Form) if len(a) > 0 else None

lionagi/core/report/util.py

@@ -0,0 +1,28 @@
+from lionagi.libs.ln_convert import strip_lower
+
+
+def get_input_output_fields(str_: str) -> list[list[str]]:
+    """
+    Parses an assignment string to extract input and output fields.
+
+    Args:
+        str_ (str): The assignment string in the format 'inputs -> outputs'.
+
+    Returns:
+        list[list[str]]: A list containing two lists - one for input fields and one for requested fields.
+
+    Raises:
+        ValueError: If the assignment string is None or if it does not contain '->' indicating invalid format.
+    """
+    if str_ is None:
+        return [], []
+
+    if "->" not in str_:
+        raise ValueError("Invalid assignment format. Expected 'inputs -> outputs'.")
+
+    inputs, outputs = str_.split("->")
+
+    input_fields = [strip_lower(i) for i in inputs.split(",")]
+    requested_fields = [strip_lower(o) for o in outputs.split(",")]
+
+    return input_fields, requested_fields

lionagi/core/rule/_default.py

@@ -0,0 +1,16 @@
+from enum import Enum
+from .choice import ChoiceRule
+from .mapping import MappingRule
+from .number import NumberRule
+from .boolean import BooleanRule
+from .string import StringRule
+from .action import ActionRequestRule
+
+
+class DEFAULT_RULES(Enum):
+    CHOICE = ChoiceRule
+    MAPPING = MappingRule
+    NUMBER = NumberRule
+    BOOL = BooleanRule
+    STR = StringRule
+    ACTION = ActionRequestRule

lionagi/core/rule/action.py

@@ -0,0 +1,99 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from enum import Enum
+from lionagi.core.collections.abc import ActionError
+from lionagi.libs import ParseUtil
+from lionagi.libs.ln_convert import to_list, to_dict
+from lionagi.core.rule.mapping import MappingRule
+
+
+class ActionRequestKeys(Enum):
+    FUNCTION = "function"
+    ARGUMENTS = "arguments"
+
+
+class ActionRequestRule(MappingRule):
+    """
+    Rule for validating and fixing action requests.
+
+    Inherits from `MappingRule` and provides specific validation and fix logic
+    for action requests.
+
+    Attributes:
+        discard (bool): Indicates whether to discard invalid action requests.
+    """
+
+    def __init__(self, apply_type="actionrequest", discard=True, **kwargs):
+        """
+        Initializes the ActionRequestRule.
+
+        Args:
+            apply_type (str): The type of data to which the rule applies.
+            discard (bool, optional): Indicates whether to discard invalid action requests.
+            **kwargs: Additional keyword arguments for initialization.
+        """
+        super().__init__(
+            apply_type=apply_type, keys=ActionRequestKeys, fix=True, **kwargs
+        )
+        self.discard = discard or self.validation_kwargs.get("discard", False)
+
+    async def validate(self, value):
+        """
+        Validates the action request.
+
+        Args:
+            value (Any): The value of the action request.
+
+        Returns:
+            Any: The validated action request.
+
+        Raises:
+            ActionError: If the action request is invalid.
+        """
+        if isinstance(value, dict) and list(value.keys()) >= ["function", "arguments"]:
+            return value
+        raise ActionError(f"Invalid action request: {value}")
+
+    async def perform_fix(self, value):
+        """
+        Attempts to fix an invalid action request.
+
+        Args:
+            value (Any): The value of the action request to fix.
+
+        Returns:
+            Any: The fixed action request.
+
+        Raises:
+            ActionError: If the action request cannot be fixed.
+        """
+        corrected = []
+        if isinstance(value, str):
+            value = ParseUtil.fuzzy_parse_json(value)
+
+        try:
+            value = to_list(value)
+            for i in value:
+                i = to_dict(i)
+                if list(i.keys()) >= ["function", "arguments"]:
+                    corrected.append(i)
+                elif not self.discard:
+                    raise ActionError(f"Invalid action request: {i}")
+        except Exception as e:
+            raise ActionError(f"Invalid action field: ") from e
+
+        return corrected