Move complex logic outside of base InputFilter class

Author: LeanderCS

MANIFEST.in

@@ -1,7 +1,9 @@
 include docs/source/index.rst
 include LICENSE
 include docs/source/changelog.rst
-recursive-include flask_inputfilter *.py *.pyi *.pyx *.pxd *.c *.cpp
-recursive-include flask_inputfilter/include *.h
+recursive-include flask_inputfilter *.py *.pyi *.pyx *.pxd *.h
+
+recursive-exclude flask_inputfilter *.cpp
+
 prune tests
 recursive-prune __pycache__

flask_inputfilter/_input_filter.pxd

@@ -74,5 +74,3 @@ cdef class InputFilter:
     cpdef object serialize(self)
     cpdef void add_global_validator(self, BaseValidator validator)
     cpdef list[BaseValidator] get_global_validators(self)
-
-    cdef inline void _check_all_conditions(self, dict validated_data, dict errors)

flask_inputfilter/_input_filter.pyx

@@ -9,7 +9,7 @@ from flask import Response, g, request
 
 from flask_inputfilter.exceptions import ValidationError
 
-from flask_inputfilter.mixins.cimports cimport FieldMixin
+from flask_inputfilter.mixins.cimports cimport DataMixin
 from flask_inputfilter.models.cimports cimport BaseCondition, BaseFilter, BaseValidator, ExternalApiConfig, FieldModel
 
 from libcpp.vector cimport vector
@@ -180,14 +180,12 @@ cdef class InputFilter:
         """
         data = data or self.data
         cdef:
-            dict[str, str] errors = {},
-            dict[str, Any] validated_data = {}
+            dict[str, str] errors
+            dict[str, Any] validated_data
 
-        validated_data, errors = FieldMixin.validate_fields(
-            self.fields, data, self.global_filters, self.global_validators)
-
-        if self.conditions:
-            self._check_all_conditions(validated_data, errors)
+        validated_data, errors = DataMixin.validate_with_conditions(
+            self.fields, data, self.global_filters, self.global_validators, self.conditions
+        )
 
         if errors:
             raise ValidationError(errors)
@@ -230,25 +228,7 @@ cdef class InputFilter:
                 represent field names and values represent the associated
                 data to be filtered and stored.
         """
-        self.data = {}
-        cdef:
-            Py_ssize_t i, n = len(data) if data else 0
-            list keys = list(data.keys()) if n > 0 else []
-            list values = list(data.values()) if n > 0 else []
-            str field_name
-            object field_value
-
-        for i in range(n):
-            field_name = keys[i]
-            field_value = values[i]
-            if field_name in self.fields:
-                field_value = FieldMixin.apply_filters(
-                    self.fields[field_name].filters,
-                    self.global_filters,
-                    field_value,
-                )
-
-            self.data[field_name] = field_value
+        self.data = DataMixin.filter_data(data, self.fields, self.global_filters)
 
     cpdef object get_value(self, str name):
         """
@@ -371,21 +351,7 @@ cdef class InputFilter:
         Returns:
             bool: True if there are any unknown fields; False otherwise.
         """
-        if not self.data and self.fields:
-            return True
-        cdef set field_set
-
-        if len(self.fields) > 10:
-            field_set = set(self.fields.keys())
-            for field_name in self.data.keys():
-                if field_name not in field_set:
-                    return True
-        else:
-            for field_name in self.data.keys():
-                if field_name not in self.fields:
-                    return True
-
-        return False
+        return DataMixin.has_unknown_fields(self.data, self.fields)
 
     cpdef str get_error_message(self, str field_name):
         """
@@ -658,41 +624,7 @@ cdef class InputFilter:
                 "Can only merge with another InputFilter instance."
             )
 
-        cdef:
-            Py_ssize_t i, n
-            dict other_inputs = other.get_inputs()
-            list keys = list(other_inputs.keys()) if other_inputs else []
-            list new_fields = list(other_inputs.values()) if other_inputs else []
-
-        # Merge fields
-        n = len(keys)
-        for i in range(n):
-            self.fields[keys[i]] = new_fields[i]
-        
-        # Merge conditions
-        self.conditions += other.conditions
-
-        # Merge global filters (avoid duplicates by type)
-        for filter in other.global_filters:
-            existing_type_map = {
-                type(v): i for i, v in enumerate(self.global_filters)
-            }
-            if type(filter) in existing_type_map:
-                self.global_filters[existing_type_map[type(filter)]] = filter
-            else:
-                self.global_filters.append(filter)
-
-        # Merge global validators (avoid duplicates by type)
-        for validator in other.global_validators:
-            existing_type_map = {
-                type(v): i for i, v in enumerate(self.global_validators)
-            }
-            if type(validator) in existing_type_map:
-                self.global_validators[
-                    existing_type_map[type(validator)]
-                ] = validator
-            else:
-                self.global_validators.append(validator)
+        DataMixin.merge_input_filters(self, other)
 
     cpdef void set_model(self, model_class: Type[T]):
         """
@@ -739,16 +671,3 @@ cdef class InputFilter:
             list[BaseValidator]: A list of global validators.
         """
         return self.global_validators
-
-    cdef inline void _check_all_conditions(self, dict[str, Any] validated_data, dict[str, str] errors):
-        """
-        Check all conditions against the validated data.
-
-        Args:
-            validated_data (dict[str, Any]): The data that has been validated.
-            errors (dict[str, str]): A dictionary to store any validation errors.
-        """
-        try:
-            FieldMixin.check_conditions(self.conditions, validated_data)
-        except ValidationError as e:
-            errors[_INTERNED_STRINGS["_condition"]] = str(e)

flask_inputfilter/input_filter.py

@@ -8,7 +8,7 @@
 from flask import Response, g, request
 
 from flask_inputfilter.exceptions import ValidationError
-from flask_inputfilter.mixins import FieldMixin
+from flask_inputfilter.mixins import DataMixin
 from flask_inputfilter.models import BaseFilter, ExternalApiConfig, FieldModel
 
 if TYPE_CHECKING:
@@ -185,13 +185,14 @@ def validate_data(
         """
         data = data or self.data
 
-        validated_data, errors = FieldMixin.validate_fields(
-            self.fields, data, self.global_filters, self.global_validators
+        validated_data, errors = DataMixin.validate_with_conditions(
+            self.fields,
+            data,
+            self.global_filters,
+            self.global_validators,
+            self.conditions,
         )
 
-        if self.conditions:
-            self._check_all_conditions(validated_data, errors)
-
         if errors:
             raise ValidationError(errors)
 
@@ -233,16 +234,9 @@ def set_data(self, data: dict[str, Any]) -> None:
                 represent field names and values represent the associated
                 data to be filtered and stored.
         """
-        self.data = {}
-        for field_name, field_value in data.items():
-            if field_name in self.fields:
-                field_value = FieldMixin.apply_filters(
-                    self.fields[field_name].filters,
-                    self.global_filters,
-                    field_value,
-                )
-
-            self.data[field_name] = field_value
+        self.data = DataMixin.filter_data(
+            data, self.fields, self.global_filters
+        )
 
     def get_value(self, name: str) -> Any:
         """
@@ -315,6 +309,12 @@ def get_raw_values(self) -> dict[str, Any]:
         if not self.fields:
             return {}
 
+        # Use optimized intersection for larger datasets
+        if len(self.fields) > 10:
+            field_set = set(self.fields.keys())
+            data_set = set(self.data.keys())
+            common_fields = field_set & data_set
+            return {field: self.data[field] for field in common_fields}
         return {
             field: self.data[field]
             for field in self.fields
@@ -358,10 +358,7 @@ def has_unknown(self) -> bool:
         Returns:
             bool: True if there are any unknown fields; False otherwise.
         """
-        if not self.data and self.fields:
-            return True
-
-        return any(field_name not in self.fields for field_name in self.data)
+        return DataMixin.has_unknown_fields(self.data, self.fields)
 
     def get_error_message(self, field_name: str) -> Optional[str]:
         """
@@ -634,30 +631,7 @@ def merge(self, other: InputFilter) -> None:
                 "Can only merge with another InputFilter instance."
             )
 
-        for key, new_field in other.get_inputs().items():
-            self.fields[key] = new_field
-
-        self.conditions += other.conditions
-
-        for filter in other.global_filters:
-            existing_type_map = {
-                type(v): i for i, v in enumerate(self.global_filters)
-            }
-            if type(filter) in existing_type_map:
-                self.global_filters[existing_type_map[type(filter)]] = filter
-            else:
-                self.global_filters.append(filter)
-
-        for validator in other.global_validators:
-            existing_type_map = {
-                type(v): i for i, v in enumerate(self.global_validators)
-            }
-            if type(validator) in existing_type_map:
-                self.global_validators[existing_type_map[type(validator)]] = (
-                    validator
-                )
-            else:
-                self.global_validators.append(validator)
+        DataMixin.merge_input_filters(self, other)
 
     def set_model(self, model_class: Type[T]) -> None:
         """
@@ -703,10 +677,3 @@ def get_global_validators(self) -> list[BaseValidator]:
             list[BaseValidator]: A list of global validators.
         """
         return self.global_validators
-
-    def _check_all_conditions(self, validated_data, errors) -> None:
-        """Check all conditions against validated data."""
-        try:
-            FieldMixin.check_conditions(self.conditions, validated_data)
-        except ValidationError as e:
-            errors["_condition"] = str(e)

flask_inputfilter/input_filter.pyi

@@ -90,4 +90,3 @@ class InputFilter:
     def serialize(self) -> Union[dict[str, Any], T]: ...
     def add_global_validator(self, validator: BaseValidator) -> None: ...
     def get_global_validators(self) -> list[BaseValidator]: ...
-    def _check_all_conditions(self, validated_data, errors) -> None: ...

flask_inputfilter/mixins/__init__.py

@@ -1,14 +1,17 @@
 import shutil
 
 if shutil.which("g++") is not None:
+    from .data_mixin._data_mixin import DataMixin
     from .external_api_mixin._external_api_mixin import ExternalApiMixin
-    from .field_mixin._field_mixin import FieldMixin
+    from .validation_mixin._validation_mixin import ValidationMixin
 
 else:
+    from .data_mixin.data_mixin import DataMixin
     from .external_api_mixin.external_api_mixin import ExternalApiMixin
-    from .field_mixin.field_mixin import FieldMixin
+    from .validation_mixin.validation_mixin import ValidationMixin
 
 __all__ = [
+    "DataMixin",
     "ExternalApiMixin",
-    "FieldMixin",
+    "ValidationMixin",
 ]

flask_inputfilter/mixins/cimports.pxd

@@ -1,2 +1,3 @@
 from .external_api_mixin._external_api_mixin cimport ExternalApiMixin
-from .field_mixin._field_mixin cimport FieldMixin
+from .validation_mixin._validation_mixin cimport ValidationMixin
+from .data_mixin._data_mixin cimport DataMixin

…putfilter/mixins/field_mixin/__init__.py …nputfilter/mixins/data_mixin/__init__.pyflask_inputfilter/mixins/field_mixin/__init__.py renamed to flask_inputfilter/mixins/data_mixin/__init__.py flask_inputfilter/mixins/field_mixin/__init__.py renamed to flask_inputfilter/mixins/data_mixin/__init__.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from flask_inputfilter.models.cimports cimport BaseFilter, BaseValidator, FieldModel, BaseCondition, InputFilter
+
+
+cdef class DataMixin:
+
+    @staticmethod
+    cdef bint has_unknown_fields(dict[str, Any] data, dict[str, FieldModel] fields)
+
+    @staticmethod
+    cdef dict[str, Any] filter_data(dict[str, Any] data, dict[str, FieldModel] fields, list[BaseFilter] global_filters)
+
+    @staticmethod
+    cdef tuple validate_with_conditions(
+        dict[str, FieldModel] fields,
+        dict[str, Any] data,
+        list[BaseFilter] global_filters,
+        list[BaseValidator] global_validators,
+        list[BaseCondition] conditions
+    )
+
+    @staticmethod
+    cdef void merge_input_filters(InputFilter target_filter, InputFilter source_filter) except *
+
+    @staticmethod
+    cdef void _merge_component_list(list target_list, list source_list)