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

lionagi/experimental/work2/form.py

@@ -0,0 +1,371 @@
+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

@@ -0,0 +1,289 @@
+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

@@ -0,0 +1,30 @@
+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"
+    )

lionagi/experimental/{work → work2}/tests.py

@@ -1,5 +1,5 @@
 from .schema import Work, WorkStatus
-from ._logger import WorkLog
+from ..work.worklog import WorkLog
 from .work_function import WorkFunction
 
 import unittest