Fix declarative

Author: LeanderCS

AGENTS.md

@@ -22,7 +22,8 @@ poetry add flask-inputfilter
 Create validation schemas by inheriting from `InputFilter`:
 
 ```python
-from flask_inputfilter import InputFilter, field
+from flask_inputfilter import InputFilter
+from flask_inputfilter.declarative import field, global_filter
 from flask_inputfilter.filters import ToIntegerFilter, StringTrimFilter
 from flask_inputfilter.validators import IsIntegerValidator, LengthValidator
 
@@ -41,8 +42,7 @@ class UserInputFilter(InputFilter):
     )
 
     # Global filters/validators apply to all fields
-    _global_filters = [StringTrimFilter()]
-    _global_validators = []
+    global_filter(StringTrimFilter())
 ```
 
 ### 2. Usage in Flask Routes

docs/source/changelog.rst

@@ -4,6 +4,53 @@ Changelog
 All notable changes to this project will be documented in this file.
 
 
+[0.7.2] - 2025-09-28
+--------------------
+
+Changed
+^^^^^^^
+- Changed the way how to use the new decorator ``_condition``, ``_global_filter``, ``_global_validator`` and ``_model``.
+  They should no longer be assigned to a variable, but should be set with the corresponding declarative method.
+
+  ``_condition = [Example()]`` => ``condition(Example())``
+
+  ``_global_filter = [Example()]`` => ``global_filter(Example())``
+
+  ``_global_validator = [Example()]`` => ``global_validator(Example())``
+
+  ``_model = Example`` => ``model(Example)``
+
+  The previous way is still supported, but is not recommended because it is not streightforward and could lead to confusion.
+  The new methods also support multiple calls and also mass assignment.
+
+  Both of the following examples are valid and have the same effect:
+
+  .. code-block:: python
+
+        class ExampleInputFilter(InputFilter):
+            field1: str = field()
+            field2: str = field()
+            condition(ExactlyOneOfCondition(['field1', 'field2']))
+
+            field3: str = field()
+            field4: str = field()
+            condition(AtLeastOneOfCondition(['field3', 'field4']))
+
+
+  .. code-block:: python
+
+        class ExampleInputFilter(InputFilter):
+            field1: str = field()
+            field2: str = field()
+            field3: str = field()
+            field4: str = field()
+
+            condition(
+                ExactlyOneOfCondition(['field1', 'field2']),
+                AtLeastOneOfCondition(['field3', 'field4'])
+            )
+
+
 [0.7.1] - 2025-09-27
 --------------------
 
@@ -24,13 +71,13 @@ Added
 
   ``self.add`` => ``field``
 
-  ``self.add_condition`` => ``_conditions``
+  ``self.add_condition`` => ``condition``
 
-  ``self.add_global_filter`` => ``_global_filters``
+  ``self.add_global_filter`` => ``global_filter``
 
-  ``self.add_global_validator`` => ``_global_validators``
+  ``self.add_global_validator`` => ``global_validator``
 
-  ``self.add_model`` => ``_model``
+  ``self.add_model`` => ``model``
 
   **Before**:
     .. code-block:: python
@@ -65,13 +112,13 @@ Added
                 validators=[IsIntegerValidator()]
             )
 
-            _conditions = [ExactlyOneOfCondition(['zipcode', 'city'])]
+            condition(ExactlyOneOfCondition(['zipcode', 'city']))
 
-            _global_filters = [StringTrimFilter()]
+            global_filter(StringTrimFilter())
 
-            _global_validators = [IsStringValidator()]
+            global_validator(IsStringValidator())
 
-            _model = UserModel
+            model(UserModel)
 
   The Change is fully backward compatible, but the new way is more readable
   and maintainable.

docs/source/index.rst

@@ -77,7 +77,7 @@ Definition
             validators=[IsStringValidator()]
         )
 
-        _conditions = [ExactlyOneOfCondition(['zipcode', 'city'])]
+        condition(ExactlyOneOfCondition(['zipcode', 'city']))
 
 Usage
 ^^^^^

docs/source/options/condition.rst

@@ -24,7 +24,7 @@ Example
             validators=[IsStringValidator()]
         )
 
-        _conditions = [OneOfCondition(['id', 'name'])]
+        condition(OneOfCondition(['id', 'name']))
 
 Available Conditions
 --------------------

docs/source/options/deserialization.rst

@@ -36,7 +36,7 @@ into an instance of the model class, if there is a model class set.
         username: str = field()
         email: str = field()
 
-        _model = User
+        model(User)
 
 Examples
 --------
@@ -59,7 +59,7 @@ You can also use deserialization in your Flask routes:
     class MyInputFilter(InputFilter):
         username: str = field()
 
-        _model = User
+        model(User)
 
 
     app = Flask(__name__)
@@ -89,7 +89,7 @@ You can also use deserialization outside of Flask routes:
     class MyInputFilter(InputFilter):
         username: str = field()
 
-        _model = User
+        model(User)
 
     app = Flask(__name__)
 

docs/source/options/filter.rst

@@ -26,7 +26,7 @@ Example
             filters=[StringTrimFilter()]
         )
 
-        _global_filters = [ToLowerFilter()]
+        global_filter(ToLowerFilter())
 
 Available Filters
 -----------------

docs/source/options/validator.rst

@@ -24,7 +24,7 @@ Example
             validators=[RangeValidator(min_value=0, max_value=10)]
         )
 
-        _global_validators = [IsIntegerValidator()]
+        global_validator(IsIntegerValidator())
 
 Available Validators
 --------------------

examples/basic/filters/user_inputfilter.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from flask_inputfilter import InputFilter
-from flask_inputfilter.declarative import field
+from flask_inputfilter.declarative import field, model
 from flask_inputfilter.validators import IsIntegerValidator, IsStringValidator
 
 
@@ -13,7 +13,7 @@ class User:
 
 
 class UserInputFilter(InputFilter):
-    _model = User
+    model(User)
 
     name: str = field(required=True, validators=[IsStringValidator()])
 

flask_inputfilter/_input_filter.pxd

@@ -75,4 +75,4 @@ cdef class InputFilter:
     cpdef void add_global_validator(self, BaseValidator validator)
     cpdef list[BaseValidator] get_global_validators(self)
     cdef void _set_methods(self, list methods)
-    cdef void _register_decorator_components(self)
+    cpdef void _register_decorator_components(self)

flask_inputfilter/_input_filter.pyx

@@ -9,6 +9,8 @@
 # cython: optimize.unpack_method_calls=True
 # cython: infer_types=True
 
+import dataclasses
+import inspect
 import json
 import logging
 import sys
@@ -239,45 +241,65 @@ cdef class InputFilter:
         """
         self.conditions.append(condition)
 
-    cdef void _register_decorator_components(self):
-        """Register decorator-based components from the current class only."""
-        cdef object cls, attr_value, conditions, validators, filters
+    cpdef void _register_decorator_components(self):
+        """Register decorator-based components from the current class and
+        inheritance chain."""
+        cdef object cls, attr_value, conditions, validators, filters, base_cls
         cdef str attr_name
         cdef list dir_attrs
         cdef FieldDescriptor field_desc
+        cdef set added_conditions, added_global_validators, added_global_filters
+        cdef object condition_id, validator_id, filter_id
+        cdef object condition, validator, filter_instance
 
         cls = self.__class__
         dir_attrs = dir(cls)
 
         for attr_name in dir_attrs:
-            if (<bytes>attr_name.encode('utf-8')).startswith(b"_"):
+            if attr_name.startswith("_"):
                 continue
+            if hasattr(cls, attr_name):
+                attr_value = getattr(cls, attr_name)
+                if isinstance(attr_value, FieldDescriptor):
+                    self.fields[attr_name] = FieldModel(
+                        attr_value.required,
+                        attr_value.default,
+                        attr_value.fallback,
+                        attr_value.filters,
+                        attr_value.validators,
+                        attr_value.steps,
+                        attr_value.external_api,
+                        attr_value.copy,
+                    )
 
-            attr_value = getattr(cls, attr_name, None)
-            if attr_value is not None and isinstance(attr_value, FieldDescriptor):
-                field_desc = <FieldDescriptor>attr_value
-                self.fields[attr_name] = FieldModel(
-                    field_desc.required,
-                    field_desc._default,
-                    field_desc.fallback,
-                    field_desc.filters,
-                    field_desc.validators,
-                    field_desc.steps,
-                    field_desc.external_api,
-                    field_desc.copy,
-                )
-
-        conditions = getattr(cls, "_conditions", None)
-        if conditions is not None:
-            self.conditions.extend(conditions)
-
-        validators = getattr(cls, "_global_validators", None)
-        if validators is not None:
-            self.global_validators.extend(validators)
-
-        filters = getattr(cls, "_global_filters", None)
-        if filters is not None:
-            self.global_filters.extend(filters)
+        added_conditions = set()
+        added_global_validators = set()
+        added_global_filters = set()
+
+        for base_cls in reversed(cls.__mro__):
+            conditions = getattr(base_cls, "_conditions", None)
+            if conditions is not None:
+                for condition in conditions:
+                    condition_id = id(condition)
+                    if condition_id not in added_conditions:
+                        self.conditions.append(condition)
+                        added_conditions.add(condition_id)
+
+            validators = getattr(base_cls, "_global_validators", None)
+            if validators is not None:
+                for validator in validators:
+                    validator_id = id(validator)
+                    if validator_id not in added_global_validators:
+                        self.global_validators.append(validator)
+                        added_global_validators.add(validator_id)
+
+            filters = getattr(base_cls, "_global_filters", None)
+            if filters is not None:
+                for filter_instance in filters:
+                    filter_id = id(filter_instance)
+                    if filter_id not in added_global_filters:
+                        self.global_filters.append(filter_instance)
+                        added_global_filters.add(filter_id)
 
         self.model_class = getattr(cls, "_model", self.model_class)
 
@@ -731,7 +753,26 @@ cdef class InputFilter:
         if self.model_class is None:
             return self.validated_data
 
-        return self.model_class(**self.validated_data)
+        try:
+            return self.model_class(**self.validated_data)
+        except TypeError:
+            pass
+
+        cdef set field_names = set()
+
+        if dataclasses.is_dataclass(self.model_class):
+            field_names = {f.name for f in dataclasses.fields(self.model_class)}
+        elif hasattr(self.model_class, '__fields__'):
+            field_names = set(self.model_class.__fields__.keys())
+        elif hasattr(self.model_class, '__annotations__'):
+            field_names = set(self.model_class.__annotations__.keys())
+        else:
+            sig = inspect.signature(self.model_class.__init__)
+            field_names = set(sig.parameters.keys()) - {'self'}
+
+        cdef dict filtered_data = {k: v for k, v in self.validated_data.items() if k in field_names}
+
+        return self.model_class(**filtered_data)
 
     cpdef void add_global_validator(self, BaseValidator validator):
         """