lionagi 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/core/report/base.py

@@ -1,201 +0,0 @@
-import contextlib
-from abc import abstractmethod
-from typing import Any, Dict, List
-
-from lionagi.core.collections.abc import Component, Field
-
-from ..collections.util import to_list_type
-
-
-class BaseForm(Component):
-    """
-    NOTICE:
-        The Form/Report system is inspired by DSPy. (especially in DSPy's usage
-        of `Signature` and `Module`)
-        https://github.com/stanfordnlp/dspy
-
-        MIT License
-        Copyright (c) 2023 Stanford Future Data Systems
-
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-
-    REFERENCES:
-        @article{khattab2023dspy,
-        title={DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines},
-        author={Khattab, Omar and Singhvi, Arnav and Maheshwari, Paridhi and Zhang, Zhiyuan and
-        Santhanam, Keshav and Vardhamanan, Sri and Haq, Saiful and Sharma, Ashutosh and Joshi,
-        Thomas T. and Moazam, Hanna and Miller, Heather and Zaharia, Matei and Potts, Christopher},
-        journal={arXiv preprint arXiv:2310.03714},
-        year={2023}
-        }
-        @article{khattab2022demonstrate,
-        title={Demonstrate-Search-Predict: Composing Retrieval and Language Models for
-        Knowledge-Intensive {NLP}},
-        author={Khattab, Omar and Santhanam, Keshav and Li, Xiang Lisa and Hall, David and Liang,
-        Percy and Potts, Christopher and Zaharia, Matei},
-        journal={arXiv preprint arXiv:2212.14024},
-        year={2022}
-        }
-
-    LionAGI Modifications:
-        - Redesigned focusing on form-based task handling
-        - fully integrated with LionAGI's existing collections and components
-        - developed report system for multi-step task handling
-        - created work system for task execution and management
-
-    Base class for handling form-like structures within an application.
-    Manages form components and operations such as filling forms and
-    checking their state (filled, workable).
-
-    Attributes:
-        assignment (str): The objective of the form specifying input/output fields.
-        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.
-        task (Any): The work to be done by the form, including custom instructions.
-        validation_kwargs (Dict[str, Dict[str, Any]]): Additional validation constraints for the form fields.
-    """
-
-    template_name: str = "default_directive"
-
-    assignment: str | None = Field(
-        None,
-        description="The objective of the form specifying input/output fields.",
-        examples=["input1, input2 -> output"],
-    )
-
-    input_fields: list[str] = Field(
-        default_factory=list,
-        description="Fields required to carry out the objective of the form.",
-    )
-
-    requested_fields: list[str] = Field(
-        default_factory=list,
-        description="Fields requested to be filled by the user.",
-    )
-
-    task: Any = Field(
-        default_factory=str,
-        description="The work to be done by the form, including custom instructions.",
-    )
-
-    validation_kwargs: dict[str, dict[str, Any]] = Field(
-        default_factory=dict,
-        description="Additional validation constraints for the form fields.",
-        examples=[{"field": {"config1": "a", "config2": "b"}}],
-    )
-
-    @property
-    def work_fields(self) -> dict[str, Any]:
-        """
-        Get the fields relevant to the current task, including input and
-        requested fields. Must be implemented by subclasses.
-
-        Returns:
-            Dict[str, Any]: The fields relevant to the current task.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def fill(self, *args, **kwargs):
-        """
-        Fill the form from various sources, including other forms and
-        additional fields. Implement this method in subclasses.
-
-        Args:
-            *args: Additional positional arguments.
-            **kwargs: Additional keyword arguments.
-        """
-        pass
-
-    @abstractmethod
-    def is_workable(self) -> bool:
-        """
-        Check if the form object is ready for work execution. Raise an error
-        if the form is not workable. Use with the workable property.
-
-        Returns:
-            bool: True if the form is workable, otherwise False.
-        """
-        pass
-
-    @property
-    def filled(self) -> bool:
-        """
-        Check if the form is filled with all required fields. Uses the
-        _is_filled method and suppresses any ValueError raised by it.
-
-        Returns:
-            bool: True if the form is filled, otherwise False.
-        """
-        with contextlib.suppress(ValueError):
-            return self._is_filled()
-        return False
-
-    @property
-    def workable(self) -> bool:
-        """
-        Check if the form is workable. This property does not raise an error
-        and will return True or False.
-
-        Returns:
-            bool: True if the form is workable, otherwise False.
-        """
-        with contextlib.suppress(ValueError):
-            return self.is_workable()
-        return False
-
-    def _is_filled(self) -> bool:
-        """
-        Private method to check if all work fields are filled. Raises a
-        ValueError if any field is not filled.
-
-        Returns:
-            bool: True if all work fields are filled, otherwise raises ValueError.
-
-        Raises:
-            ValueError: If any field is not filled.
-        """
-        for k, value in self.work_fields.items():
-            if value is None:
-                raise ValueError(f"Field {k} is not filled")
-        return True
-
-    def _get_all_fields(
-        self, form: list["BaseForm"] = None, **kwargs
-    ) -> dict[str, Any]:
-        """
-        Given a form or collections of forms, and additional fields, gather
-        all fields together including self fields with valid value.
-
-        Args:
-            form (List[BaseForm], optional): A list of forms to gather fields from.
-            **kwargs: Additional fields to include.
-
-        Returns:
-            Dict[str, Any]: A dictionary of all gathered fields.
-        """
-        form: list["BaseForm"] = to_list_type(form) if form else []
-        all_fields = self.work_fields.copy()
-        all_form_fields = (
-            {}
-            if not form
-            else {
-                k: v
-                for i in form
-                for k, v in i.work_fields.items()
-                if v is not None
-            }
-        )
-        all_fields.update({**all_form_fields, **kwargs})
-        return all_fields
-
-    def copy(self):
-        return self.model_copy()

lionagi/core/report/form.py

@@ -1,212 +0,0 @@
-import json
-from typing import Any, Dict
-
-from lionagi.core.collections.abc import SYSTEM_FIELDS
-from lionagi.core.report.base import BaseForm
-from lionagi.core.report.util import get_input_output_fields
-
-
-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 Markdown, display
-
-        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 = json.dumps(v, indent=4)
-            if len(str(v)) > 50:
-                display(Markdown(f"**{k}**: \n {v}"))
-            else:
-                display(Markdown(f"**{k}**: {v}"))

lionagi/core/report/report.py

@@ -1,150 +0,0 @@
-from typing import Any, Type
-
-from lionagi.core.collections import Pile, pile
-from lionagi.core.collections.abc import Field
-from lionagi.core.report.base import BaseForm
-from lionagi.core.report.form import Form
-from lionagi.core.report.util import get_input_output_fields
-
-
-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

@@ -1,15 +0,0 @@
-def get_input_output_fields(str_: str) -> list[list[str]]:
-    if str_ is None:
-        return [], []
-
-    if "->" not in str_:
-        raise ValueError(
-            "Invalid assignment format. Expected 'inputs -> outputs'."
-        )
-
-    inputs, outputs = str_.split("->")
-
-    input_fields = [str(i).strip().lower() for i in inputs.split(",")]
-    requested_fields = [str(o).strip().lower() for o in outputs.split(",")]
-
-    return input_fields, requested_fields

lionagi/core/rule/_default.py

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

lionagi/core/rule/action.py

@@ -1,87 +0,0 @@
-from enum import Enum
-
-from lionfuncs import to_dict, to_list
-
-from lionagi.core.collections.abc import ActionError
-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 = to_dict(value, fuzzy_parse=True)
-
-        try:
-            value = to_list(value, dropna=True, flatten=True)
-            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