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

lionagi/experimental/work2/form.py

@@ -1,371 +0,0 @@
-from typing import Any
-from pydantic import Field
-from lionagi.core.generic import BaseComponent
-from lionagi.libs import validation_funcs, convert
-from lionagi.experimental.report.util import get_input_output_fields
-
-
-class Form(BaseComponent):
-
-    form_name: str = Field(
-        default="default_form",
-    )
-    description: Any = Field(default=None)
-    assignment: str = Field(..., examples=["input1, input2 -> output"])
-    instruction: Any = Field(
-        default=None,
-    )
-    input_fields: list[str] = Field(default_factory=list)
-    output_fields: list[str] = Field(default_factory=list)
-    examples: Any = Field(
-        default=None,
-    )
-    fix_input: bool = Field(False, description="whether to fix input")
-    fix_output: bool = Field(True, description="whether to fix output")
-    filled: bool = Field(False, description="whether the form is completed")
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.input_fields, self.output_fields = get_input_output_fields(self.assignment)
-
-        for field in self.input_fields:
-            if not hasattr(self, field):
-                setattr(self, field, None)  # zero initialization
-        self.process()
-
-    @property
-    def work_fields(self):
-        return self.input_fields + self.output_fields
-
-    @property
-    def is_completed(self):
-        return all(getattr(self, i, None) for i in self.work_fields)
-
-    def process(self, in_=True, out_=None):
-        if not in_ and not out_:
-            raise ValueError("at least one of in_ and out_ must be True")
-        if in_:
-            self._process_input()
-        if out_:
-            self._process_output(out_)
-
-    def _process_input(self):
-        for k in self.input_fields:
-            try:
-                valid_ = self._validate_field(
-                    k,
-                    getattr(self, k, None),
-                    choices=self._get_field_attr(k, "choices", None),
-                    keys=self._get_field_attr(k, "keys", None),
-                    fix_=self.fix_input,
-                    **self._get_field_attr(k, "validation_kwargs", {}),
-                )
-                if not valid_:
-                    raise ValueError(f"failed to validate field {k}")
-            except Exception as e:
-                raise ValueError(f"failed to validate field {k}") from e
-
-    def _process_output(self, out_: dict = None):
-        for k, v in out_.items():
-            try:
-                valid_ = self._validate_field(
-                    k,
-                    v,
-                    choices=self._get_field_attr(k, "choices", None),
-                    keys=self._get_field_attr(k, "keys", None),
-                    fix_=self.fix_output,
-                    **self._get_field_attr(k, "validation_kwargs", {}),
-                )
-                if not valid_:
-                    raise ValueError(f"failed to validate field {k}")
-            except Exception as e:
-                raise ValueError(f"failed to validate field {k}") from e
-
-        if self.is_completed:
-            self.filled = True
-
-    def _validate_field(self, k, v, choices=None, keys=None, fix_=False, **kwargs):
-        annotation = self.field_annotations[k]
-
-        if choices:
-            if choices and not isinstance(choices, list):
-                try:
-                    choices = [i.value for i in choices]
-                except Exception as e:
-                    raise ValueError(f"failed to get choices for field {k}") from e
-            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 any("actionrequest" in i for i in annotation):
-            self.__setattr__(k, validation_funcs["action"](v))
-            return True
-
-        if "bool" in annotation and "str" not in annotation:
-            self.__setattr__(k, validation_funcs["bool"](v, fix_=fix_, **kwargs))
-            return True
-
-        if (
-            any([i in annotation for i in ["int", "float", "number"]])
-            and "str" not in annotation
-        ):
-            if "float" in annotation:
-                kwargs["num_type"] = float
-                if "precision" not in kwargs:
-                    kwargs["precision"] = 10
-
-            self.__setattr__(k, validation_funcs["number"](v, fix_=fix_, **kwargs))
-            return True
-
-        if "dict" in annotation:
-            if "str" not in annotation or keys:
-                v_ = validation_funcs["dict"](v, keys=keys, fix_=fix_, **kwargs)
-                setattr(self, k, v_)
-                return True
-
-        if "str" in annotation:
-            self.__setattr__(k, validation_funcs["str"](v, fix_=fix_, **kwargs))
-            return True
-
-        return False
-
-
-# from enum import Enum
-# from pydantic import Field
-
-# class EXAMPLES(str, Enum):
-#     EXAMPLE1 = "example1"
-#     EXAMPLE2 = "example2"
-#     EXAMPLE3 = "example3"
-
-# class Form1(Form):
-#     a: str | EXAMPLES = Field("example3", choices=EXAMPLES)
-#     b: str = "input2"
-#     c: str|None = Field(None, choices=["output1", "output2"])
-#     d: float | None = Field(None, json_schema_extra={"validation_kwargs":{"num_type": float, "precision": 2}})
-#     assignment: str='a, b -> c, d'
-#     form_name: str='custom_form'
-#     description: str='Test Form'
-
-# form = Form1()
-# form.process(out_ = {"c": "output1", "d": "1.1"})
-
-
-"""
-usage pattern:
-
-from pydantic import Field
-
-class JokeForm(Form):
-
-    # 1. use the key kwarg to specify the key in the dict,
-    # which will be used validate the field value
-    
-    # 2. use fix flag to indicate whether to fix the value 
-    # if it is not valid, default to True
-
-    material: dict = Field(
-        ..., 
-        description="materials to read", 
-        keys=["title", "author", "year"],       # use fix flag for dict key can be dangerous
-        fix=True                                # the validator will force the value to match
-    )                                           # the provided keys, which might pollute the data
-
-
-    # 3. use choices to specify the available options
-    topic: str = Field(
-        ..., 
-        description="topic to write joke on", 
-        choices=["animal", "food", "people"],
-    )
-    
-    # you can also use enum or subclass of Enum to explicitly 
-    # declare that the field requires
-    # the value to be one of the provided choices
-    
-    from enum import Enum
-    
-    class TOPIC(str, Enum):
-        ANIMAL = "animal"
-        FOOD = "food"
-        PEOPLE = "people"
-    
-    
-    topic: TOPIC = Field(
-        default = TOPIC.ANIMAL, 
-        description="topic to write joke on", 
-        choices=TOPIC,
-        fix_input=True,                             # fix_input and fix_output are used to indicate
-    )                                               # whether to fix invalid values, default to True
-    
-    # 4. using optional fields
-    # you can add None in type annotation to indicate that the field is optional
-    # otherwise there will be a validation error if there is no default
-    # field value, and value is also not provided at initialization
-
-    joke: str | None = Field(
-        default = None, 
-        description = "joke to write"
-    )
-    
-    # 5. using validation_kwargs
-    # you can use validation_kwargs to specify the validation parameters
-    # there are built-in validators for numbers
-
-    rating: float | None = Field(
-        default=None, 
-        description="rating, a numerical value", 
-        validation_kwargs={
-            "upper_bound": 10,                      # this will ensure the value for this field 
-            "lower_bound": 0,                       # is a number between upper_bound and lower_bound
-            "num_type": "float",                    
-            "precision": 2}                         
-        )
-    
-    
-    # 6. using assignment
-    # in a form, you do not need to specify the input output for each field, 
-    # instead, you can use assignment to specify the input and output of the form
-    
-    # an assignment is a string that describes the input and output of the form
-    # it is used to generate a composable set of fields specific to different context
-    # from the same custom Form class you specified, for example, two fields "a" and "b",  
-    # in one form, you can specify the assignment as "a -> b", and in another form,
-    # you can specify the assignment as "b -> a", and the system will generate two different
-    # instruction for the worker to perform. 
-    
-    assignment: str = Field(
-        default=..., 
-        examples=["input1, input2 -> output"]
-    )
-    
-    # for example, "work -> review, rating" and "review, work -> rating" have completely different
-    # meanings, and the system will generate two different forms for the worker to complete
-    # the former means, a review task of a work performance with corresponding rating for the work
-    # the latter means, a rating task on the review quality for the work performance, 
-    # such as, whether it is fair for the rating
-    
-
-    # 7. general guidance
-    # in principle, a field should only be filled once, thus making form a single use object
-    # the form has a filled flag to indicate whether the form is completed
-    
-"""
-
-# import unittest
-# from pydantic import Field
-
-
-# class Form1(Form):
-#     input1: str = Field("input1", json_schema_extra={"choices": ["option1", "option2"]})
-#     input2: str = "input2"
-#     output1: str = "output1"
-
-
-# class TestForm(unittest.TestCase):
-
-#     def test_default_initialization(self):
-#         class Form1(Form):
-#             input1: str = "input1"
-#             input2: str = "input2"
-#             output1: str = "output1"
-#             assignment: str = "input1, input2 -> output1"
-
-#         form = Form1()
-#         self.assertEqual(form.form_name, "default_form")
-#         self.assertIsNone(form.description)
-#         self.assertEqual(form.input_fields, ["input1", "input2"])
-#         self.assertEqual(form.output_fields, ["output1"])
-#         self.assertFalse(form.filled)
-#         self.assertFalse(form.fix_input)
-#         self.assertTrue(form.fix_output)
-
-#     def test_custom_initialization(self):
-#         class Form1(Form):
-#             a: str = "input1"
-#             b: str = "input2"
-#             c: str = "output1"
-#             assignment: str = "a, b -> c"
-#             form_name: str = "custom_form"
-#             description: str = "Test Form"
-
-#         form = Form1()
-#         self.assertEqual(form.form_name, "custom_form")
-#         self.assertEqual(form.description, "Test Form")
-#         self.assertEqual(form.input_fields, ["a", "b"])
-#         self.assertEqual(form.output_fields, ["c"])
-
-#     def test_process_inputs_outputs(self):
-#         class Form1(Form):
-#             input1: str = Field(
-#                 "option1", json_schema_extra={"choices": ["option1", "option2"]}
-#             )
-#             input2: str = "input2"
-#             output1: str = "output1"
-#             assignment: str = "input1, input2 -> output1"
-
-#         form = Form1()
-#         setattr(form, "input1", "option1")
-#         # Test processing valid input
-#         form.process(in_=True)  # Should process without error
-
-#         setattr(form, "input1", "option3")
-#         # Test processing invalid input
-#         with self.assertRaises(ValueError):
-#             form.process(in_=True)  # Should raise error
-
-#     def test_check_complete(self):
-#         class Form1(Form):
-#             input1: str = "input1"
-#             input2: str = "input2"
-#             output1: str = "output1"
-
-#         form = Form1(assignment="input1, input2 -> output1")
-#         setattr(form, "input1", "value1")
-#         setattr(form, "input2", "value2")
-#         setattr(form, "output1", "result1")
-#         self.assertTrue(form.is_completed)
-
-#     def test_input_output_fields_parsing(self):
-#         class Form1(Form):
-#             x: str = "input1"
-#             y: str = "input2"
-#             z: str = "output1"
-
-#         form = Form1(assignment="x, y -> z")
-#         self.assertEqual(form.input_fields, ["x", "y"])
-#         self.assertEqual(form.output_fields, ["z"])
-
-#     def test_validation_failure(self):
-#         class Form1(Form):
-#             input1: str = Field(
-#                 None, json_schema_extra={"choices": ["option1", "option2"]}
-#             )
-#             input2: str = "input2"
-#             output1: str = "output1"
-#             assignment: str = "input1, input2 -> output1"
-
-#         # Test handling invalid input choice
-#         with self.assertRaises(ValueError):
-#             form = Form1()
-
-#     def test_output_assignment(self):
-#         class Form1(Form):
-#             input1: str = "value1"
-#             output1: str = Field("output1", choices=["result1", "result2"])
-#             assignment: str = "input1 -> output1"
-
-#         form = Form1()
-#         # Test handling invalid output choice
-#         try:
-#             form.process(out_={"output1": "result3"})
-#         except ValueError:
-#             pass
-
-#         form.process(out_={"output1": "result3"})  # Should process without error
-
-
-# if __name__ == "__main__":
-#     unittest.main()

lionagi/experimental/work2/report.py

@@ -1,289 +0,0 @@
-from typing import Any
-from pydantic import Field
-from lionagi.experimental.report.form import Form
-from lionagi.core.generic import BaseComponent
-from lionagi.experimental.report.util import get_input_output_fields
-
-"""
-## Report Usage Pattern
-
-
-
-
-
-
-requirements, 
-the assignments name should be consistent within a report, 
-meaning, all forms will refer to the same field value when using the same name.
-
-the same input field can be used in multiple forms, but each unique output field 
-should be filled only once.
-meaning, not two forms should have the any output fields in common.
-
-a filled field cannot be None
-
-usage pattern:
-
-class Report1(Report):
-    a: Any = None
-    b: Any = None
-    c: Any = None
-    d: Any = None
-    e: Any = None
-    f: Any = None
-    
-    assignments: list = [
-        "a, b -> c", 
-        "c -> d", 
-        "b, d -> e"
-    ]
-
-this means that the report will have 3 work steps, each corresponding to an unique 
-form. the context for the report is the fields that cannot be output by any work 
-teps in the report. 
-
-the deliverable for the report is the fields that are output produced by the work 
-steps but not used as input for any other work steps in the same report.
-
-under the hood:
-
-the report first create three forms and add to its forms dictionary
-
-form1 = Form1(assignment="a, b -> c")
-form2 = Form2(assignment="c -> d")
-form3 = Form3(assignment="b -> e")
-form3 = Form3(assignment="d, e -> f")
-
-The Form1, Form2, Form3 can be a single form class or multiple form classes, 
-as long as they have the same fields to interact
-
-report is created by intaking different context inputs, in this case, we 
-need to provide a and b to the report
-
-report let work scheduler know which form to fill next, by using the next_forms() method, 
-this method check if the dependencies of a form are filled, if so, all such forms are 
-deemed to be next to fill. 
-
-so to begin with we need the context fields, a and b, then the report checks the 
-next forms, notice, for (a, b -> c), we have a and b, so this form can be filled next
-also for (b -> e), we have b, so this form can also be filled next
-
-thus the report will first send forms of those two assignments to the scheduler. 
-
-as work gets done, forms get filled, the completed forms will be sent back to scheduler, 
-and the scheduler is in charge of filling in the fields onto the report. After each 
-time a report gets new fields filled, the scheduler will check the next forms to fill, 
-and the process continues until all forms are filled.
-
-so as (a, b -> c) is done, we get c, thus c -> d is then the next form
-and d, e -> f is the last form to fill
-once all forms are filled and all fields transfered to reports, the report is completed.
-
-"""
-
-
-class Report(BaseComponent):
-
-    report_name: str = Field(
-        default="default_report",
-    )
-    description: Any = Field(default=None)
-    task: Any = Field(default=None)
-    forms: dict[str, Form] = Field(
-        default_factory=dict,
-        description="A dictionary of forms related to the report, in {form.id_: form} format.",
-    )
-    context: dict = Field(default_factory=dict, description="context for the report")
-    deliverable: dict = Field(
-        default_factory=dict, description="deliverable for the report"
-    )
-    intermediate: dict = Field(
-        default_factory=dict, description="intermediate fields for the report"
-    )
-    filled: bool = Field(False, description="whether the report is completed")
-    assignments: list = Field([], description="assignment for the report")
-
-    def fill_report(self, form: Form | str):
-        form = self.forms[form] if isinstance(form, str) else form
-        if not form.filled or form not in self.forms.values():
-            raise ValueError("The form is not filled or not in the report.")
-
-        for i in form.input_fields:
-            if i not in self._filled_fields:
-                setattr(self, i, getattr(form, i))
-                if i not in self.deliverable:
-                    self.intermediate[i] = getattr(form, i)
-
-        for i in form.output_fields:
-            setattr(self, i, getattr(form, i))
-            if i not in self.deliverable:
-                self.intermediate[i] = getattr(form, i)
-
-    @property
-    def work_fields(self):
-        """
-        all work fields across all forms, including intermediate output fields
-        """
-        all_fields = []
-        for form in self.forms.values():
-            all_fields.extend(form.work_fields)
-        return list(set(all_fields))
-
-    @property
-    def is_completed(self):
-        return all([hasattr(self, i) for i in self.work_fields])
-
-    @property
-    def is_workable(self):
-        context_fields, deliverable_fields = get_input_output_fields(self.assignment)
-        context_fields.extend(deliverable_fields)
-
-        # check whether all work fields are assigned in the forms for the report
-        if not all([i in self.work_fields for i in context_fields]):
-            raise ValueError(
-                f"Not all work fields are assigned in the forms for the report."
-            )
-
-        outs = []
-        for form in self.forms.values():
-            outs.extend(form.output_fields)
-
-        if len(outs) != len(set(outs)):
-            raise ValueError(f"Output fields should be unique across all forms.")
-
-        inputs = []
-        for form in self.forms.values():
-            inputs.extend(form.input_fields)
-
-        inputs = [i for i in inputs if i not in outs]
-        if not all([i in self.work_fields for i in inputs]):
-            raise ValueError(
-                f"Not all input fields are assigned in the forms for the report."
-            )
-
-        return True
-
-    def next_forms(self):
-        to_do = []
-        for i in self._unfilled_forms:
-            if all([j in self._filled_fields for j in i.input_fields]):
-                to_do.append(i)
-        return to_do[0] if len(to_do) == 1 else to_do or None
-
-    @property
-    def _filled_forms(self):
-        return [form for form in self.forms.values() if form.filled]
-
-    @property
-    def _unfilled_forms(self):
-        return [form for form in self.forms.values() if not form.filled]
-
-    @property
-    def _filled_fields(self):
-        filled_fields = []
-        for i in self.work_fields:
-            if getattr(self, i, None) is not None:
-                filled_fields.append(i)
-        return filled_fields
-
-    @property
-    def _unfilled_fields(self):
-        return [i for i in self.work_fields if i not in self._filled_fields]
-
-
-# import unittest
-# from enum import Enum
-# from typing import Any
-# from pydantic import Field
-# from lionagi import logging as _logging
-# from lionagi.experimental.form.form import Form
-# from lionagi.core.generic import BaseComponent
-# from lionagi.experimental.form.util import get_input_output_fields
-
-
-# class EXAMPLES(str, Enum):
-#     EXAMPLE1 = "example1"
-#     EXAMPLE2 = "example2"
-#     EXAMPLE3 = "example3"
-
-
-# class Form1(Form):
-#     a: str | EXAMPLES = Field(EXAMPLES.EXAMPLE3, choices=list(EXAMPLES))
-#     b: str = "input2"
-#     c: str | None = Field(None, choices=["output1", "output2"])
-#     d: float | None = Field(None)
-#     assignment: str = "a, b -> c, d"
-#     form_name: str = "custom_form"
-#     description: str = "Test Form"
-
-
-# class TestReport(unittest.TestCase):
-#     def setUp(self):
-#         self.report = Report(assignment="a, b -> c, d")
-#         self.form1 = Form1(assignment="a, b -> c, d")
-#         self.report.forms[self.form1.id_] = self.form1
-
-#     def test_initialization(self):
-#         self.assertEqual(self.report.report_name, "default_report")
-#         self.assertIn(self.form1.id_, self.report.forms)
-
-#     def test_fill_report(self):
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertTrue(self.form1.filled)
-#         self.assertEqual(self.report.intermediate["c"], "output1")
-
-#     def test_report_completeness(self):
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertTrue(self.report.is_completed)
-
-#     def test_report_workability(self):
-#         # self.form1.process(out_={'c': 'output1', 'd': 1.1})
-#         # self.report.fill_report(self.form1)
-#         self.assertTrue(self.report.is_workable)
-
-#     def test_handling_invalid_form_id(self):
-#         with self.assertRaises(KeyError):
-#             self.report.fill_report("nonexistent_form")
-
-#     def test_next_forms_logic(self):
-#         next_forms = self.report.next_forms()
-#         self.assertEqual(next_forms, None)
-
-#     def test_work_fields_property(self):
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertIn("a", self.report.work_fields)
-#         self.assertIn("b", self.report.work_fields)
-#         self.assertIn("c", self.report.work_fields)
-#         self.assertIn("d", self.report.work_fields)
-
-#     def test_filled_forms_property(self):
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertIn(self.form1, self.report._filled_forms)
-
-#     def test_unfilled_forms_property(self):
-#         self.assertIn(self.form1, self.report._unfilled_forms)
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertNotIn(self.form1, self.report._unfilled_forms)
-
-#     def test_filled_fields_property(self):
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertIn("c", self.report._filled_fields)
-#         self.assertIn("d", self.report._filled_fields)
-
-#     def test_unfilled_fields_property(self):
-#         self.assertIn("c", self.report._unfilled_fields)
-#         self.assertIn("d", self.report._unfilled_fields)
-#         self.form1.process(out_={"c": "output1", "d": 1.1})
-#         self.report.fill_report(self.form1)
-#         self.assertNotIn("c", self.report._unfilled_fields)
-#         self.assertNotIn("d", self.report._unfilled_fields)
-
-
-# if __name__ == "__main__":
-#     unittest.main()

lionagi/experimental/work2/schema.py

@@ -1,30 +0,0 @@
-from enum import Enum
-from typing import Any, Dict, List
-from pydantic import Field
-from lionagi.core.generic import BaseComponent
-
-
-class WorkStatus(str, Enum):
-    """Enum to represent different statuses of work."""
-
-    PENDING = "PENDING"
-    IN_PROGRESS = "IN_PROGRESS"
-    COMPLETED = "COMPLETED"
-    FAILED = "FAILED"
-    CANCELLED = "CANCELLED"
-
-
-class Work(BaseComponent):
-    """Base component for handling individual units of work."""
-
-    form_id: str = Field(..., description="ID of the form for this work")
-    priority: int = Field(default=0, description="Priority of the work")
-    status: WorkStatus = Field(
-        default=WorkStatus.PENDING, description="Current status of the work"
-    )
-    deliverables: Dict[str, Any] | list = Field(
-        default={}, description="Deliverables produced by the work"
-    )
-    dependencies: List["Work"] = Field(
-        default_factory=list, description="List of work items this work depends on"
-    )