lionagi 0.7.8__py3-none-any.whl → 0.8.0__py3-none-any.whl

lionagi/operations/manager.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
 
 from lionagi.protocols._concepts import Manager
 

lionagi/operatives/forms/base.py

@@ -1,237 +1,80 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
+# forms/base_form.py
 
 from typing import Any, Literal
 
-from pydantic import Field, field_validator
+from pydantic import ConfigDict, Field
 from pydantic_core import PydanticUndefined
 
-from lionagi.protocols.types import Node
+from lionagi.protocols.generic.element import Element
 from lionagi.utils import UNDEFINED
 
-from ..models.operable_model import OperableModel
 
-
-class BaseForm(Node, OperableModel):
-    """Base form class providing core functionality for form handling.
-
-    This class serves as a foundation for creating custom forms within the
-    lion-core library. It includes methods for managing output fields,
-    handling results, and applying field annotations.
-
-    The BaseForm class focuses on output fields, which are fields that are
-    presented as the result of form processing. Output fields can include all,
-    part, or none of the request fields and can be conditionally modified by
-    the process if the form is not set to be strict.
-
-    Attributes:
-        assignment: The objective of the task, which may define how input
-            fields are processed into output fields.
-        template_name: The name of the form template.
-        output_fields: A list of field names that are outputted and presented
-            by the form.
-        none_as_valid_value: Indicates whether to treat None as a valid value
-            when processing output fields.
-        has_processed: Indicates if the task has been processed.
-
-    Example:
-        >>> form = BaseForm(
-        ...     assignment="input1, input2 -> output",
-        ...     output_fields=["output1", "output2"],
-        ... )
-        >>> result = form.get_results()
-        >>> print(result)
+class BaseForm(Element):
+    """
+    A minimal base form class to store fields and define output logic.
+    Typically, you'll inherit from this for domain-specific forms.
     """
 
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+    # A short "assignment" describing input->output
     assignment: str | None = Field(
         default=None,
-        description="The objective of the task.",
-        examples=["input1, input2 -> output"],
-    )
-    template_name: str = Field(
-        default="default_form", description="Name of the form template"
+        description="A small DSL describing transformation, e.g. 'a,b -> c'.",
     )
+    # Which fields are produced as 'final' or 'required' outputs.
     output_fields: list[str] = Field(
         default_factory=list,
-        description="Fields that are outputted and presented by the form.",
+        description="Which fields are considered mandatory outputs.",
     )
-    none_as_valid_value: bool = Field(
+    # Whether None counts as valid or incomplete
+    none_as_valid: bool = Field(
         default=False,
-        description="Indicate whether to treat None as a valid value.",
+        description="If True, None is accepted as a valid value for completion checks.",
     )
     has_processed: bool = Field(
         default=False,
-        description="Indicates if the task has been processed.",
-        exclude=True,
+        description="Marks if the form is considered completed or 'processed'.",
     )
 
-    def check_is_completed(
-        self,
-        handle_how: Literal["raise", "return_missing"] = "raise",
-    ) -> list[str] | None:
-        """Check if all required fields are completed.
-
-        Args:
-            handle_how: How to handle incomplete fields.
-
-        Returns:
-            List of incomplete fields if handle_how is "return_missing",
-            None otherwise.
-
-        Raises:
-            ValueError: If required fields are incomplete and handle_how
-                is "raise".
-        """
-        non_complete_request = []
-        invalid_values = [UNDEFINED, PydanticUndefined]
-        if not self.none_as_valid_value:
-            invalid_values.append(None)
-
-        for i in self.required_fields:
-            if getattr(self, i) in invalid_values:
-                non_complete_request.append(i)
-
-        if non_complete_request:
-            if handle_how == "raise":
-                raise ValueError(
-                    f"Incomplete request fields: {non_complete_request}"
-                )
-            elif handle_how == "return_missing":
-                return non_complete_request
-        else:
-            self.has_processed = True
-
     def is_completed(self) -> bool:
-        """Check if the form is completed.
+        """Check if all required output fields are set (and not UNDEFINED/None if not allowed)."""
+        missing = self.check_completeness()
+        return not missing
 
-        Returns:
-            True if the form is completed, False otherwise.
+    def check_completeness(
+        self, how: Literal["raise", "return_missing"] = "return_missing"
+    ) -> list[str]:
         """
-        try:
-            self.check_is_completed(handle_how="raise")
-            return True
-        except Exception:
-            return False
-
-    @field_validator("output_fields", mode="before")
-    @classmethod
-    def _validate_output(cls, value):
-        """Validate the output_fields attribute.
-
-        Args:
-            value: The value to validate.
-
-        Returns:
-            The validated value.
-
-        Raises:
-            LionValueError: If the value is invalid.
+        Return a list of any 'required' output fields that are missing or invalid.
+        If how='raise', raise an exception if missing any.
         """
-        if isinstance(value, str):
-            return [value]
-        if isinstance(value, list) and all(
-            [i for i in value if isinstance(i, str)],
-        ):
-            return value
-        if not value:
-            return []
-        raise ValueError("Invalid output fields.")
+        invalid_vals = [UNDEFINED, PydanticUndefined]
+        if not self.none_as_valid:
+            invalid_vals.append(None)
 
-    @property
-    def work_fields(self) -> list[str]:
-        """Get the list of fields that are outputted by the form.
+        missing = []
+        for f in self.output_fields:
+            val = getattr(self, f, UNDEFINED)
+            if val in invalid_vals:
+                missing.append(f)
 
-        Returns:
-            A list of field names.
-        """
-        return self.output_fields
+        if missing and how == "raise":
+            raise ValueError(f"Form missing required fields: {missing}")
+        return missing
 
-    @property
-    def work_dict(self) -> dict[str, Any]:
-        """Get a dictionary of all work fields and their values.
-
-        Returns:
-            A dictionary of field names and their values.
+    def get_results(self, valid_only: bool = False) -> dict[str, Any]:
         """
-        return {i: getattr(self, i, UNDEFINED) for i in self.work_fields}
-
-    @property
-    def required_fields(self) -> list[str]:
-        """Get the list of required fields for the form.
-
-        Returns:
-            A list of required field names.
-        """
-        return self.output_fields
-
-    @property
-    def required_dict(self) -> dict[str, Any]:
-        """Get a dictionary of all required fields and their values.
-
-        Returns:
-            A dictionary of required field names and their values.
+        Return a dict of all `output_fields`, optionally skipping invalid/None if `valid_only`.
         """
-        dict_ = {}
-        for i in self.required_fields:
-            dict_[i] = getattr(self, i, UNDEFINED)
-
-        return dict_
-
-    def get_results(
-        self,
-        suppress: bool = False,
-        valid_only: bool = False,
-    ) -> dict[str, Any]:
-        """Retrieve the results of the form.
-
-        Args:
-            suppress: If True, suppress errors for missing fields.
-            valid_only: If True, return only valid (non-empty) results.
-
-        Returns:
-            A dictionary of field names and their values.
-
-        Raises:
-            ValueError: If a required field is missing and suppress is False.
-        """
-        result = {}
-        out_fields = self.output_fields or getattr(self, "request_fields", [])
-
-        for i in out_fields:
-            if i not in self.all_fields:
-                if not suppress:
-                    raise ValueError(f"Missing field: {i}")
-            else:
-                result[i] = getattr(self, i, UNDEFINED)
-
-        # add a validator for output fields
-
-        if valid_only:
-            invalid_values = [
-                UNDEFINED,
-                PydanticUndefined,
-            ]
-            if not self.none_as_valid_value:
-                invalid_values.append(None)
-
-            res_ = {}
-            for k, v in result.items():
-                if v not in invalid_values:
-                    res_[k] = v
-            result = res_
-
-        return result
-
-    @property
-    def display_dict(self) -> dict[str, Any]:
-        """
-        Get a dictionary of the required fields and their values for display.
-
-        Returns:
-            A dictionary of required field names and their values.
-        """
-        return self.required_dict
-
-
-__all__ = ["BaseForm"]
+        results = {}
+        invalid_vals = [UNDEFINED, PydanticUndefined]
+        if not self.none_as_valid:
+            invalid_vals.append(None)
+
+        for f in self.output_fields:
+            val = getattr(self, f, UNDEFINED)
+            if valid_only and val in invalid_vals:
+                continue
+            results[f] = val
+        return results

lionagi/operatives/forms/flow.py

@@ -0,0 +1,74 @@
+# forms/flow.py
+from typing import List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FlowStep(BaseModel):
+    """
+    A minimal 'step' describing one transformation from some input fields to some output fields.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: str = Field(..., description="Identifier for the step.")
+    inputs: list[str] = Field(
+        ..., description="Which fields are needed for this step."
+    )
+    outputs: list[str] = Field(
+        ..., description="Which fields are produced by this step."
+    )
+    description: str | None = None  # optional text doc
+
+
+class FlowDefinition(BaseModel):
+    """
+    A minimal DSL-based multi-step flow, e.g. 'a,b->c; c->d' to yield two steps.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    steps: list[FlowStep] = Field(default_factory=list)
+
+    def parse_flow_string(self, flow_str: str):
+        """
+        Parse a string like 'a,b->c; c->d' into multiple FlowSteps.
+        We'll store them in self.steps in order.
+        """
+        if not flow_str:
+            return
+        segments = [seg.strip() for seg in flow_str.split(";") if seg.strip()]
+        for i, seg in enumerate(segments):
+            # seg might be like 'a,b->c' or 'a->b, c' etc
+            if "->" not in seg:
+                raise ValueError(f"Invalid DSL segment (no '->'): '{seg}'")
+            ins_str, outs_str = seg.split("->", 1)
+            inputs = [x.strip() for x in ins_str.split(",") if x.strip()]
+            outputs = [y.strip() for y in outs_str.split(",") if y.strip()]
+            step = FlowStep(name=f"step_{i+1}", inputs=inputs, outputs=outputs)
+            self.steps.append(step)
+
+    def get_required_fields(self) -> set[str]:
+        """
+        Return all fields that are used as inputs in the earliest steps but not produced by prior steps.
+        This is a minimal approach; or we can do more advanced logic if needed.
+        """
+        produced = set()
+        required = set()
+        for step in self.steps:
+            # anything not yet produced is needed
+            for i in step.inputs:
+                if i not in produced:
+                    required.add(i)
+            for o in step.outputs:
+                produced.add(o)
+        return required
+
+    def get_produced_fields(self) -> set[str]:
+        """
+        Return all fields that eventually get produced by any step.
+        """
+        result = set()
+        for st in self.steps:
+            result.update(st.outputs)
+        return result