Cython decorator

Author: LeanderCS

docs/source/changelog.rst

@@ -3,6 +3,44 @@ Changelog
 
 All notable changes to this project will be documented in this file.
 
+
+[0.7.0] - 2025-09-25
+--------------------
+
+Added
+^^^^^
+- Added that fields, conditons, global filters and global validators can be
+  added as decorator and do not require a self.add, ... call in the __init__.
+
+  **Before**:
+    .. code-block:: python
+
+        class UpdateZipcodeInputFilter(InputFilter):
+            def __init__(self):
+                super().__init__()
+                self.add(
+                    'id',
+                    required=True,
+                    filters=[ToIntegerFilter(), ToNullFilter()],
+                    validators=[
+                        IsIntegerValidator()
+                    ]
+                )
+
+  **After**:
+
+    .. code-block:: python
+
+        class UpdateZipcodeInputFilter(InputFilter):
+            id: int = field(
+                required=True,
+                filters=[ToIntegerFilter(), ToNullFilter()],
+                validators=[
+                    IsIntegerValidator()
+                ]
+            )
+
+
 [0.6.3] - 2025-09-24
 --------------------
 

flask_inputfilter/_input_filter.pxd

@@ -43,8 +43,8 @@ cdef class InputFilter:
         bint required=*,
         object default=*,
         object fallback=*,
-        list filters=*,
-        list validators=*,
+        list[BaseFilter] filters=*,
+        list[BaseValidator] validators=*,
         list steps=*,
         ExternalApiConfig external_api=*,
         str copy=*,
@@ -74,3 +74,5 @@ cdef class InputFilter:
     cpdef object serialize(self)
     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)

flask_inputfilter/_input_filter.pyx

@@ -1,4 +1,13 @@
 # cython: language=c++
+# cython: boundscheck=False
+# cython: wraparound=False
+# cython: cdivision=True
+# cython: overflowcheck=False
+# cython: initializedcheck=False
+# cython: nonecheck=False
+# cython: optimize.use_switch=True
+# cython: optimize.unpack_method_calls=True
+# cython: infer_types=True
 
 import json
 import logging
@@ -9,11 +18,14 @@ from flask import Response, g, request
 
 from flask_inputfilter.exceptions import ValidationError
 
+from flask_inputfilter.declarative.cimports cimport FieldDescriptor
 from flask_inputfilter.mixins.cimports cimport DataMixin
 from flask_inputfilter.models.cimports cimport BaseCondition, BaseFilter, BaseValidator, ExternalApiConfig, FieldModel
 
 from libcpp.vector cimport vector
 from libcpp.string cimport string
+from libcpp cimport bool as cbool
+from libcpp.algorithm cimport find
 
 cdef dict _INTERNED_STRINGS = {
     "_condition": sys.intern("_condition"),
@@ -36,6 +48,44 @@ cdef dict _INTERNED_STRINGS = {
 cdef extern from "helper.h":
     vector[string] make_default_methods()
 
+    cdef cppclass ObjectPool[T]:
+        ObjectPool()
+        T* acquire()
+        void release(T* obj)
+        void release_all()
+        void reserve(size_t capacity)
+        size_t size()
+        size_t available()
+
+    cdef cppclass FieldLookup:
+        FieldLookup()
+        void add_field(const string& name)
+        bint has_field(const string& name)
+        size_t get_index(const string& name)
+        const vector[string]& get_field_names()
+        void clear()
+        void reserve(size_t capacity)
+
+    cdef cppclass StringIntern:
+        @staticmethod
+        const string& intern(const string& str)
+        @staticmethod
+        void clear()
+        @staticmethod
+        size_t count()
+
+
+# Fast C++ string processing
+cdef extern from "<string_view>" namespace "std":
+    cdef cppclass string_view:
+        string_view()
+        string_view(const char* data)
+        string_view(const char* data, size_t len)
+        cbool empty()
+        size_t size()
+        const char* data()
+        cbool starts_with(string_view prefix)
+
 T = TypeVar("T")
 
 
@@ -57,8 +107,22 @@ cdef class InputFilter:
 
     def __init__(self, methods: Optional[list[str]] = None) -> None:
         if methods is not None:
-            self.methods.clear()
-            [self.methods.push_back(method.encode()) for method in methods]
+            self._set_methods(methods)
+
+        self._register_decorator_components()
+
+    cdef void _set_methods(self, list methods):
+        """Efficiently set HTTP methods using C++ vector operations."""
+        cdef str method
+        cdef bytes encoded_method
+        cdef Py_ssize_t n = len(methods)
+
+        self.methods.clear()
+        self.methods.reserve(n)
+
+        for method in methods:
+            encoded_method = method.encode('utf-8')
+            self.methods.push_back(string(encoded_method))
 
     cpdef bint is_valid(self):
         """
@@ -122,8 +186,14 @@ cdef class InputFilter:
                 """
 
                 cdef InputFilter input_filter = cls()
-                cdef string request_method = request.method.encode()
-                if not any(request_method == method for method in input_filter.methods):
+                cdef bytes request_method_bytes = request.method.encode('utf-8')
+                cdef string request_method = string(request_method_bytes)
+                cdef vector[string].iterator method_it = find(
+                    input_filter.methods.begin(),
+                    input_filter.methods.end(),
+                    request_method
+                )
+                if method_it == input_filter.methods.end():
                     return Response(status=405, response="Method Not Allowed")
 
                 if request.is_json:
@@ -206,6 +276,48 @@ 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
+        cdef str attr_name
+        cdef list dir_attrs
+        cdef FieldDescriptor field_desc
+
+        cls = self.__class__
+        dir_attrs = dir(cls)
+
+        for attr_name in dir_attrs:
+            if (<bytes>attr_name.encode('utf-8')).startswith(b"_"):
+                continue
+
+            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)
+
+        self.model_class = getattr(cls, "_model", self.model_class)
+
     cpdef list get_conditions(self):
         """
         Retrieve the list of all registered conditions.
@@ -307,14 +419,19 @@ cdef class InputFilter:
 
         cdef:
             Py_ssize_t i, n = len(self.fields)
-            dict result = {}
+            dict result
             list field_names = list(self.fields.keys())
             str field
+            object field_value
+
+        # Pre-allocate dictionary size for better performance
+        result = {}
 
         for i in range(n):
             field = field_names[i]
-            if field in self.data:
-                result[field] = self.data[field]
+            field_value = self.data.get(field)
+            if field_value is not None:
+                result[field] = field_value
         return result
 
     cpdef dict[str, Any] get_unfiltered_data(self):

flask_inputfilter/declarative/__init__.py

@@ -1,5 +1,9 @@
-from .factory_functions import field
-from .field_descriptor import FieldDescriptor
+try:
+    from ._field_descriptor import FieldDescriptor
+    from ._factory_functions import field
+except ImportError:
+    from .field_descriptor import FieldDescriptor
+    from .factory_functions import field
 
 __all__ = [
     "FieldDescriptor",

flask_inputfilter/declarative/_factory_functions.pxd

@@ -0,0 +1,15 @@
+# cython: language_level=3
+
+from flask_inputfilter.models.cimports cimport BaseFilter, BaseValidator, ExternalApiConfig
+from ._field_descriptor cimport FieldDescriptor
+
+cpdef FieldDescriptor field(
+    bint required=*,
+    object default=*,
+    object fallback=*,
+    list[BaseFilter] filters=*,
+    list[BaseValidator] validators=*,
+    list steps=*,
+    ExternalApiConfig external_api=*,
+    str copy=*
+)

flask_inputfilter/declarative/_factory_functions.pyx

@@ -0,0 +1,64 @@
+# cython: language_level=3
+
+from ._field_descriptor cimport FieldDescriptor
+from flask_inputfilter.models.cimports cimport BaseFilter, BaseValidator, ExternalApiConfig
+
+cpdef FieldDescriptor field(
+    bint required = False,
+    object default = None,
+    object fallback = None,
+    list[BaseFilter] filters = None,
+    list[BaseValidator] validators = None,
+    list steps = None,
+    ExternalApiConfig external_api = None,
+    str copy = None,
+):
+    """
+    Create a field descriptor for declarative field definition.
+
+    This function creates a FieldDescriptor that can be used as a class
+    attribute to define input filter fields declaratively.
+
+    **Parameters:**
+
+    - **required** (*bool*): Whether the field is required. Default: False.
+    - **default** (*Any*): The default value of the field. Default: None.
+    - **fallback** (*Any*): The fallback value of the field, if
+      validations fail or field is None, although it is required. Default: None.
+    - **filters** (*Optional[list[BaseFilter]]*): The filters to apply to
+      the field value. Default: None.
+    - **validators** (*Optional[list[BaseValidator]]*): The validators to
+      apply to the field value. Default: None.
+    - **steps** (*Optional[list[Union[BaseFilter, BaseValidator]]]*): Allows
+      to apply multiple filters and validators in a specific order. Default: None.
+    - **external_api** (*Optional[ExternalApiConfig]*): Configuration for an
+      external API call. Default: None.
+    - **copy** (*Optional[str]*): The name of the field to copy the value
+      from. Default: None.
+
+    **Returns:**
+
+    A field descriptor configured with the given parameters.
+
+    **Example:**
+
+    .. code-block:: python
+
+        from flask_inputfilter import InputFilter
+        from flask_inputfilter.declarative import field
+        from flask_inputfilter.validators import IsStringValidator
+
+        class UserInputFilter(InputFilter):
+            name: str = field(required=True, validators=[IsStringValidator()])
+            age: int = field(required=True, default=18)
+    """
+    return FieldDescriptor(
+        required=required,
+        default=default,
+        fallback=fallback,
+        filters=filters,
+        validators=validators,
+        steps=steps,
+        external_api=external_api,
+        copy=copy,
+    )

flask_inputfilter/declarative/_field_descriptor.pxd

@@ -0,0 +1,18 @@
+# cython: language_level=3
+
+from flask_inputfilter.models.cimports cimport BaseFilter, BaseValidator, ExternalApiConfig
+
+cdef class FieldDescriptor:
+    cdef readonly:
+        bint required
+        object _default
+        object fallback
+        list[BaseFilter] filters
+        list[BaseValidator] validators
+        list steps
+        ExternalApiConfig external_api
+        str copy
+    cdef public:
+        str name
+
+    cpdef void __set_name__(self, object owner, str name)