lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/{core → operatives}/models/operable_model.py

@@ -2,56 +2,43 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from lionagi.libs.utils import is_same_dtype
-
-from ..typing._pydantic import (
-    ConfigDict,
-    Field,
-    FieldInfo,
-    PydanticUndefined,
-    field_serializer,
-    field_validator,
-)
-from ..typing._typing import UNDEFINED, Any, TypeVar, override
-from .base import BaseAutoModel
+from typing import Any, Self, TypeVar
+
+from pydantic import ConfigDict, Field, field_validator, model_validator
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+from typing_extensions import override
+
+from lionagi.utils import UNDEFINED, HashableModel, is_same_dtype
+
 from .field_model import FieldModel
 
-FIELD_NAME = TypeVar("FIELD_NAME", bound=str)
+FieldName = TypeVar("FieldName", bound=str)
 
 
-class OperableModel(BaseAutoModel):
-    """Model class supporting dynamic field management and operations.
+__all__ = ("OperableModel",)
 
-    Provides:
-    - Dynamic field addition/updates
-    - Field attribute access
-    - Metadata tracking
-    - Nested model serialization
 
-    Example:
-        ```python
-        class DynamicModel(OperableModel):
-            base_field: str = "base"
-
-        model = DynamicModel()
-
-        # Add field with validation
-        def validate_positive(v: int) -> int:
-            if v <= 0:
-                raise ValueError("Must be positive")
-            return v
-
-        model.add_field(
-            "age",
-            value=25,
-            annotation=int,
-            validator=validate_positive
-        )
-        ```
+class OperableModel(HashableModel):
+    """Base model supporting dynamic field management and operations.
+
+    This class extends Pydantic's model system to allow runtime field
+    modifications, attribute tracking, and nested model serialization.
+    Fields can be added, updated, and removed dynamically while maintaining
+    type safety and validation.
 
     Attributes:
-        extra_fields: Dictionary storing dynamic field definitions
-        model_config: Configuration forbidding extra direct fields
+        extra_fields: Dynamically added field definitions.
+        extra_field_models: Associated field models.
+
+    Example:
+        >>> class UserModel(OperableModel):
+        ...     name: str = "default"
+        ...
+        >>> user = UserModel()
+        >>> user.add_field("age", value=25, annotation=int)
+        >>> user.age
+        25
     """
 
     model_config = ConfigDict(
@@ -62,9 +49,18 @@ class OperableModel(BaseAutoModel):
         use_enum_values=True,
     )
 
-    extra_fields: dict[str, Any] = Field(default_factory=dict)
+    extra_fields: dict[str, FieldInfo] | Any = Field(
+        default_factory=dict,
+        description="Dictionary of dynamically added field definitions",
+        exclude=True,
+    )
+
+    extra_field_models: dict[str, FieldModel] = Field(
+        default_factory=dict,
+        description="Dictionary of field models for dynamic fields",
+        exclude=True,
+    )
 
-    @field_serializer("extra_fields")
     def _serialize_extra_fields(
         self,
         value: dict[str, FieldInfo],
@@ -72,17 +68,18 @@ class OperableModel(BaseAutoModel):
         """Serialize extra fields to dictionary format.
 
         Args:
-            value: Dictionary of field name to FieldInfo mappings
+            value: Dictionary mapping field names to their FieldInfo objects.
 
         Returns:
-            Dictionary of field name to value mappings,
-            with nested models serialized
+            dict[str, Any]: Serialized field values.
         """
         output_dict = {}
         for k in value.keys():
             k_value = self.__dict__.get(k)
-            if isinstance(k_value, BaseAutoModel):
+            if hasattr(k_value, "to_dict"):
                 k_value = k_value.to_dict()
+            elif hasattr(k_value, "model_dump"):
+                k_value = k_value.model_dump()
             output_dict[k] = k_value
         return output_dict
 
@@ -91,16 +88,16 @@ class OperableModel(BaseAutoModel):
         cls,
         value: list[FieldModel] | dict[str, FieldModel | FieldInfo],
     ) -> dict[str, FieldInfo]:
-        """Validate and convert extra fields to FieldInfo objects.
+        """Validate and normalize extra field definitions.
 
         Args:
-            value: List of FieldModels or dict of field definitions
+            value: Field definitions as list or dictionary.
 
         Returns:
-            Dictionary mapping field names to FieldInfo objects
+            dict[str, FieldInfo]: Normalized field definitions.
 
         Raises:
-            ValueError: If value format is invalid
+            ValueError: If value format is invalid.
         """
         out = {}
         if isinstance(value, dict):
@@ -116,6 +113,63 @@ class OperableModel(BaseAutoModel):
 
         raise ValueError("Invalid extra_fields value")
 
+    @model_validator(mode="after")
+    def _validate_extra_field_models(self) -> Self:
+        """Validate and normalize extra field models after initial validation.
+
+        Returns:
+            Self: Validated instance with normalized extra fields.
+        """
+        extra_fields = {}
+        extra_field_models = {}
+
+        # Handle dict[str, FieldInfo | FieldModel]
+        if isinstance(self.extra_fields, dict):
+            for k, v in self.extra_fields.items():
+                if isinstance(v, FieldModel):
+                    extra_fields[k] = v.field_info
+                    extra_field_models[k] = v
+                elif isinstance(v, FieldInfo):
+                    extra_fields[k] = v
+
+        # Handle list input
+        elif isinstance(self.extra_fields, list):
+            for v in self.extra_fields:
+                # list[FieldModel]
+                if isinstance(v, FieldModel):
+                    extra_fields[v.name] = v.field_info
+                    extra_field_models[v.name] = v
+
+                # Handle list[tuple[str, FieldInfo | FieldModel]]
+                if isinstance(v, tuple) and len(v) == 2:
+                    if isinstance(v[0], str):
+                        if isinstance(v[1], FieldInfo):
+                            extra_fields[v[0]] = v[1]
+                        if isinstance(v[1], FieldModel):
+                            extra_fields[v[1].name] = v[1].field_info
+                            extra_field_models[v[1].name] = v[1]
+
+        self.extra_fields = extra_fields
+        self.extra_field_models = extra_field_models
+        return self
+
+    @override
+    def __getattr__(self, field_name: str) -> Any:
+        """Get attribute value with metadata tracking.
+
+        Args:
+            field_name: Name of the field to get
+
+        Returns:
+            Field value
+
+        Raises:
+            AttributeError: If field not found
+        """
+        if field_name == "extra_field" or field_name in self.all_fields:
+            return self.__dict__.get(field_name, UNDEFINED)
+        raise AttributeError(f"Field {field_name} not found in object fields.")
+
     @override
     def __setattr__(self, field_name: str, value: Any) -> None:
         """Set attribute value with metadata tracking.
@@ -131,13 +185,41 @@ class OperableModel(BaseAutoModel):
             AttributeError: If attempting to directly assign to metadata or
                 extra_fields
         """
+        if not callable(value) and field_name.startswith("__"):
+            raise AttributeError("Cannot directly assign to dunder fields")
+
+        if (
+            field_name in self.extra_field_models
+            and self.extra_field_models[field_name].validator is not UNDEFINED
+        ):
+            value = self.extra_field_models[field_name].validator(None, value)
         if field_name in self.extra_fields:
             object.__setattr__(self, field_name, value)
         else:
             super().__setattr__(field_name, value)
 
+    def __delattr__(self, field_name):
+        if field_name in self.extra_fields:
+            if self.extra_fields[field_name].default not in [
+                UNDEFINED,
+                PydanticUndefined,
+            ]:
+                setattr(
+                    self, field_name, self.extra_fields[field_name].default
+                )
+                return
+            if self.extra_fields[field_name].default_factory is not UNDEFINED:
+                setattr(
+                    self,
+                    field_name,
+                    self.extra_fields[field_name].default_factory(),
+                )
+                return
+
+        super().__delattr__(field_name)
+
     @override
-    def to_dict(self, clean: bool = False) -> dict:
+    def to_dict(self) -> dict:
         """Convert model to dictionary including extra fields.
 
         Args:
@@ -147,13 +229,9 @@ class OperableModel(BaseAutoModel):
             Dictionary containing all fields and their values
         """
         dict_ = self.model_dump()
-        dict_.pop("extra_fields")
         dict_.update(self._serialize_extra_fields(self.extra_fields))
-        if clean:
-            for k, v in dict_.items():
-                if v is UNDEFINED:
-                    dict_.pop(k)
-        return dict_
+        print(dict_)
+        return {k: v for k, v in dict_.items() if v is not UNDEFINED}
 
     @property
     def all_fields(self) -> dict[str, FieldInfo]:
@@ -169,7 +247,7 @@ class OperableModel(BaseAutoModel):
 
     def add_field(
         self,
-        field_name: FIELD_NAME,
+        field_name: FieldName,
         /,
         value: Any = UNDEFINED,
         annotation: type = UNDEFINED,
@@ -204,7 +282,7 @@ class OperableModel(BaseAutoModel):
 
     def update_field(
         self,
-        field_name: FIELD_NAME,
+        field_name: FieldName,
         /,
         value: Any = UNDEFINED,
         annotation: type = UNDEFINED,
@@ -249,6 +327,7 @@ class OperableModel(BaseAutoModel):
                     "Invalid field_model, should be a FieldModel object"
                 )
             self.extra_fields[field_name] = field_model.field_info
+            self.extra_field_models[field_name] = field_model
 
         # Handle kwargs
         if kwargs:
@@ -263,7 +342,7 @@ class OperableModel(BaseAutoModel):
             if field_name not in self.all_fields:
                 self.extra_fields[field_name] = Field()
 
-        field_obj = self.all_fields[field_name]
+        field_obj = self.extra_fields[field_name]
 
         # Handle annotation
         if annotation is not None:
@@ -273,6 +352,9 @@ class OperableModel(BaseAutoModel):
 
         # Handle value
         if value is UNDEFINED:
+            if field_name in self.all_fields:
+                if self.__dict__.get(field_name, UNDEFINED) is not UNDEFINED:
+                    value = self.__dict__.get(field_name)
             if getattr(self, field_name, UNDEFINED) is not UNDEFINED:
                 value = getattr(self, field_name)
             elif getattr(field_obj, "default") is not PydanticUndefined:
@@ -282,9 +364,15 @@ class OperableModel(BaseAutoModel):
 
         setattr(self, field_name, value)
 
+    def remove_field(self, field_name: FieldName, /):
+        if field_name in self.extra_fields:
+            del self.extra_fields[field_name]
+        if field_name in self.__dict__:
+            del self.__dict__[field_name]
+
     def field_setattr(
         self,
-        field_name: FIELD_NAME,
+        field_name: FieldName,
         attr: str,
         value: Any,
         /,
@@ -312,7 +400,7 @@ class OperableModel(BaseAutoModel):
 
     def field_hasattr(
         self,
-        field_name: FIELD_NAME,
+        field_name: FieldName,
         attr: str,
         /,
     ) -> bool:
@@ -342,7 +430,7 @@ class OperableModel(BaseAutoModel):
 
     def field_getattr(
         self,
-        field_name: FIELD_NAME,
+        field_name: FieldName,
         attr: str,
         default: Any = UNDEFINED,
         /,
@@ -388,9 +476,3 @@ class OperableModel(BaseAutoModel):
             raise AttributeError(
                 f"field {field_name} has no attribute {attr}",
             )
-
-
-__all__ = [
-    "OperableModel",
-    "FIELD_NAME",
-]

lionagi/{core → operatives}/models/schema_model.py

@@ -2,13 +2,14 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from ..typing._pydantic import ConfigDict
-from .base import BaseAutoModel
+from pydantic import ConfigDict
+
+from lionagi.utils import HashableModel
 
 __all__ = ("SchemaModel",)
 
 
-class SchemaModel(BaseAutoModel):
+class SchemaModel(HashableModel):
 
     model_config = ConfigDict(
         extra="forbid",

lionagi/{protocols/operatives → operatives}/operative.py

@@ -7,12 +7,14 @@ from typing import Self
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 from pydantic.fields import FieldInfo
 
-from lionagi.core.models import FieldModel, ModelParams, OperableModel
-from lionagi.core.typing import UNDEFINED
-from lionagi.libs.parse import to_json, validate_keys
+from lionagi.libs.validate.fuzzy_match_keys import fuzzy_match_keys
+from lionagi.operatives.models.schema_model import SchemaModel
+from lionagi.utils import UNDEFINED, to_json
 
+from .models.model_params import FieldModel, ModelParams
 
-class Operative(OperableModel):
+
+class Operative(SchemaModel):
     """Class representing an operative that handles request and response models for operations."""
 
     name: str | None = None
@@ -22,11 +24,12 @@ class Operative(OperableModel):
 
     response_params: ModelParams | None = Field(default=None)
     response_type: type[BaseModel] | None = Field(default=None)
-    response_model: OperableModel | None = Field(default=None)
+    response_model: BaseModel | None = Field(default=None)
     response_str_dict: dict | str | None = Field(default=None)
 
     auto_retry_parse: bool = True
     max_retries: int = 3
+    parse_kwargs: dict | None = None
     _should_retry: bool = PrivateAttr(default=None)
 
     @model_validator(mode="after")
@@ -51,7 +54,7 @@ class Operative(OperableModel):
         if isinstance(d_, list | tuple) and len(d_) == 1:
             d_ = d_[0]
         try:
-            d_ = validate_keys(
+            d_ = fuzzy_match_keys(
                 d_, self.request_type.model_fields, handle_unmatched="raise"
             )
             d_ = {k: v for k, v in d_.items() if v != UNDEFINED}
@@ -72,7 +75,7 @@ class Operative(OperableModel):
             d_ = to_json(text, fuzzy_parse=True)
             if isinstance(d_, list | tuple) and len(d_) == 1:
                 d_ = d_[0]
-            d_ = validate_keys(
+            d_ = fuzzy_match_keys(
                 d_, self.request_type.model_fields, handle_unmatched="force"
             )
             d_ = {k: v for k, v in d_.items() if v != UNDEFINED}

lionagi/{protocols/operatives → operatives}/step.py

@@ -2,20 +2,21 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from pydantic.fields import FieldInfo
 
-from lionagi.core.typing import FieldModel, ModelParams
-from lionagi.protocols.operatives.operative import Operative
+from lionagi.operatives.instruct.reason import REASON_FIELD, Reason
+from lionagi.operatives.operative import Operative
 
-from .action import (
+from .action.request_response_model import (
     ACTION_REQUESTS_FIELD,
-    ACTION_REQUIRED_FIELD,
     ACTION_RESPONSES_FIELD,
     ActionRequestModel,
     ActionResponseModel,
 )
-from .reason import REASON_FIELD, ReasonModel
+from .action.utils import ACTION_REQUIRED_FIELD
+from .models.field_model import FieldModel
+from .models.model_params import ModelParams
 
 
 class StepModel(BaseModel):
@@ -23,13 +24,13 @@ class StepModel(BaseModel):
 
     title: str
     description: str
-    reason: ReasonModel | None = REASON_FIELD.field_info
-    action_requests: list[ActionRequestModel] = (
-        ACTION_REQUESTS_FIELD.field_info
+    reason: Reason | None = Field(**REASON_FIELD.to_dict())
+    action_requests: list[ActionRequestModel] = Field(
+        **ACTION_REQUESTS_FIELD.to_dict()
     )
-    action_required: bool = ACTION_REQUIRED_FIELD.field_info
-    action_responses: list[ActionResponseModel] = (
-        ACTION_RESPONSES_FIELD.field_info
+    action_required: bool = Field(**ACTION_REQUIRED_FIELD.to_dict())
+    action_responses: list[ActionResponseModel] = Field(
+        **ACTION_RESPONSES_FIELD.to_dict()
     )
 
 
@@ -39,6 +40,7 @@ class Step:
     @staticmethod
     def request_operative(
         *,
+        operative: Operative = None,
         operative_name: str | None = None,
         reason: bool = False,
         actions: bool = False,
@@ -53,6 +55,9 @@ class Step:
         config_dict: dict | None = None,
         doc: str | None = None,
         frozen: bool = False,
+        max_retries: int = None,
+        auto_retry_parse: bool = True,
+        parse_kwargs: dict | None = None,
     ) -> Operative:
         """Creates an Operative instance configured for request handling.
 
@@ -71,36 +76,61 @@ class Step:
             config_dict (dict | None, optional): Configuration dictionary.
             doc (str | None, optional): Documentation string.
             frozen (bool, optional): Whether the model is frozen.
+            max_retries (int, optional): Maximum number of retries.
 
         Returns:
             Operative: The configured operative instance.
         """
 
+        params = {}
+        if operative:
+            params = operative.model_dump()
+            request_params = operative.request_params.model_dump()
+            field_models = request_params.field_models
+
         field_models = field_models or []
         exclude_fields = exclude_fields or []
         field_descriptions = field_descriptions or {}
-        if reason:
+        if reason and REASON_FIELD not in field_models:
             field_models.append(REASON_FIELD)
-        if actions:
+        if actions and ACTION_REQUESTS_FIELD not in field_models:
             field_models.extend(
                 [
                     ACTION_REQUESTS_FIELD,
                     ACTION_REQUIRED_FIELD,
                 ]
             )
-        request_params = request_params or ModelParams(
-            parameter_fields=parameter_fields,
-            base_type=base_type,
-            field_models=field_models,
-            exclude_fields=exclude_fields,
-            name=new_model_name,
-            field_descriptions=field_descriptions,
-            inherit_base=inherit_base,
-            config_dict=config_dict,
-            doc=doc,
-            frozen=frozen,
+
+        if isinstance(request_params, ModelParams):
+            request_params = request_params.model_dump()
+
+        request_params = request_params or {}
+        request_params_fields = {
+            "parameter_fields": parameter_fields,
+            "field_models": field_models,
+            "exclude_fields": exclude_fields,
+            "field_descriptions": field_descriptions,
+            "inherit_base": inherit_base,
+            "config_dict": config_dict,
+            "doc": doc,
+            "frozen": frozen,
+            "base_type": base_type,
+            "name": new_model_name,
+        }
+        request_params.update(
+            {k: v for k, v in request_params_fields.items() if v is not None}
         )
-        return Operative(name=operative_name, request_params=request_params)
+        request_params = ModelParams(**request_params)
+        if max_retries:
+            params["max_retries"] = max_retries
+        if operative_name:
+            params["name"] = operative_name
+        if isinstance(auto_retry_parse, bool):
+            params["auto_retry_parse"] = auto_retry_parse
+        if parse_kwargs:
+            params["parse_kwargs"] = parse_kwargs
+        params["request_params"] = request_params
+        return Operative(**params)
 
     @staticmethod
     def respond_operative(
@@ -132,6 +162,17 @@ class Step:
 
         additional_data = additional_data or {}
         field_models = field_models or []
+        if hasattr(operative.response_model, "action_required"):
+            field_models.extend(
+                [
+                    ACTION_RESPONSES_FIELD,
+                    ACTION_REQUIRED_FIELD,
+                    ACTION_REQUESTS_FIELD,
+                ]
+            )
+        if "reason" in operative.response_model.model_fields:
+            field_models.extend([REASON_FIELD])
+
         operative = Step._create_response_type(
             operative=operative,
             response_params=response_params,

lionagi/operatives/types.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .action.function_calling import FunctionCalling
+from .action.manager import ActionManager
+from .action.request_response_model import (
+    ActionRequestModel,
+    ActionResponseModel,
+)
+from .action.tool import FuncTool, FuncToolRef, Tool, ToolRef
+from .forms.base import BaseForm
+from .forms.form import Form
+from .forms.report import Report
+from .instruct.base import (
+    ACTIONS_FIELD,
+    CONTEXT_FIELD,
+    GUIDANCE_FIELD,
+    INSTRUCTION_FIELD,
+    REASON_FIELD,
+)
+from .instruct.instruct import (
+    INSTRUCT_FIELD,
+    LIST_INSTRUCT_FIELD_MODEL,
+    Instruct,
+    InstructResponse,
+)
+from .instruct.node import InstructNode
+from .instruct.reason import CONFIDENCE_SCORE_FIELD, REASON_FIELD, Reason
+from .models.field_model import FieldModel
+from .models.model_params import ModelParams
+from .models.note import Note
+from .models.operable_model import OperableModel
+from .models.schema_model import SchemaModel
+from .operative import Operative
+from .step import Step
+
+__all__ = (
+    "ActionManager",
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "BaseForm",
+    "CONFIDENCE_SCORE_FIELD",
+    "CONTEXT_FIELD",
+    "Form",
+    "GUIDANCE_FIELD",
+    "INSTRUCT_FIELD",
+    "INSTRUCTION_FIELD",
+    "Instruct",
+    "InstructNode",
+    "InstructResponse",
+    "LIST_INSTRUCT_FIELD_MODEL",
+    "ModelParams",
+    "Note",
+    "OperableModel",
+    "Operative",
+    "REASON_FIELD",
+    "Reason",
+    "Report",
+    "SchemaModel",
+    "Step",
+    "Tool",
+    "ToolRef",
+    "ACTIONS_FIELD",
+    "FieldModel",
+    "FuncTool",
+    "FuncToolRef",
+    "FunctionCalling",
+)