Optimize InputFilter

Author: LeanderCS

flask_inputfilter/_input_filter.pyx

@@ -80,7 +80,7 @@ cdef class InputFilter:
                 all required conditions; otherwise, returns False.
         """
         try:
-            self.validateData()
+            self.validate_data()
 
         except ValidationError as e:
             self.errors = e.args[0]
@@ -99,13 +99,7 @@ cdef class InputFilter:
             cls
 
         Returns:
-            Callable[
-                [Any],
-                Callable[
-                    [tuple[Any, ...], Dict[str, Any]],
-                    Union[Response, tuple[Any, Dict[str, Any]]],
-                ],
-            ]
+            Callable
         """
         def decorator(
             f,
@@ -140,14 +134,22 @@ cdef class InputFilter:
                 if not any(request_method == method for method in input_filter.methods):
                     return Response(status=405, response="Method Not Allowed")
 
-                data = request.json if request.is_json else request.args
+                if request.is_json:
+                    data = request.get_json(cache=True)
+                    if not isinstance(data, dict):
+                        data = {}
+                else:
+                    data = dict(request.args)
 
                 try:
-                    kwargs = kwargs or {}
+                    if kwargs:
+                        data.update(kwargs)
 
-                    input_filter.data = {**data, **kwargs}
+                    input_filter.data = data
+                    input_filter.validated_data = {}
+                    input_filter.errors = {}
 
-                    g.validated_data = input_filter.validateData()
+                    g.validated_data = input_filter.validate_data()
 
                 except ValidationError as e:
                     return Response(
@@ -157,7 +159,7 @@ cdef class InputFilter:
                     )
 
                 except Exception:
-                    logging.getLogger(__name__).exception(
+                    logging.exception(
                         "An unexpected exception occurred while "
                         "validating input data.",
                     )
@@ -205,59 +207,89 @@ cdef class InputFilter:
         """
         data = data or self.data
         cdef dict errors = {}
-        cdef bint required
+        cdef dict validated_data = {}
+
         cdef object default
         cdef object fallback
         cdef list filters
         cdef list validators
         cdef object external_api
         cdef str copy
 
-        for field_name, field_info in self.fields.items():
-            value = data.get(field_name)
-
-            required = field_info.required
-            default = field_info.default
-            fallback = field_info.fallback
-            filters = field_info.filters + self.global_filters
-            validators = field_info.validators + self.global_validators
-            steps = field_info.steps
-            external_api = field_info.external_api
-            copy = field_info.copy
+        cdef list global_filters = self.global_filters
+        cdef list global_validators = self.global_validators
+        cdef bint has_global_filters = bool(global_filters)
+        cdef bint has_global_validators = bool(global_validators)
 
+        for field_name, field_info in self.fields.items():
             try:
-                if copy:
-                    value = self.validated_data.get(copy)
-
-                if external_api:
+                if field_info.copy:
+                    value = validated_data.get(field_info.copy)
+                elif field_info.external_api:
                     value = ExternalApiMixin.call_external_api(
-                        external_api, fallback, self.validated_data
+                        field_info.external_api,
+                        field_info.fallback,
+                        validated_data,
                     )
+                else:
+                    value = data.get(field_name)
+
+                if field_info.filters or has_global_filters:
+                    filters = field_info.filters
+                    if has_global_filters:
+                        filters = filters + global_filters
+                    value = FieldMixin.apply_filters(filters, value)
+
+                if field_info.validators or has_global_validators:
+                    validators = field_info.validators
+                    if has_global_validators:
+                        validators = validators + global_validators
+                    result = FieldMixin.validate_field(
+                        validators, field_info.fallback, value
+                    )
+                    if result is not None:
+                        value = result
 
-                value = FieldMixin.apply_filters(filters, value)
-                value = FieldMixin.validate_field(validators, fallback, value) or value
-                value = FieldMixin.apply_steps(steps, fallback, value) or value
-                value = FieldMixin.check_for_required(
-                    field_name, required, default, fallback, value
-                )
-
-                self.validated_data[field_name] = value
+                if field_info.steps:
+                    result = FieldMixin.apply_steps(
+                        field_info.steps, field_info.fallback, value
+                    )
+                    if result is not None:
+                        value = result
+
+                if value is None:
+                    if field_info.required:
+                        if field_info.fallback is not None:
+                            value = field_info.fallback
+                        elif field_info.default is not None:
+                            value = field_info.default
+                        else:
+                            raise ValidationError(
+                                f"Field '{field_name}' is required."
+                            )
+                    elif field_info.default is not None:
+                        value = field_info.default
+
+                validated_data[field_name] = value
 
             except ValidationError as e:
                 errors[field_name] = str(e)
 
-        try:
-            FieldMixin.check_conditions(self.conditions, self.validated_data)
-        except ValidationError as e:
-            errors["_condition"] = str(e)
+        if self.conditions:
+            try:
+                FieldMixin.check_conditions(self.conditions, validated_data)
+            except ValidationError as e:
+                errors["_condition"] = str(e)
 
         if errors:
             raise ValidationError(errors)
 
+        self.validated_data = validated_data
+
         if self.model_class is not None:
-            return self.serialize()
+            return self.model_class(**validated_data)
 
-        return self.validated_data
+        return validated_data
 
     cpdef void addCondition(self, condition: BaseCondition):
         warnings.warn(
@@ -826,7 +858,7 @@ cdef class InputFilter:
                 "Can only merge with another InputFilter instance."
             )
 
-        for key, new_field in other.getInputs().items():
+        for key, new_field in other.get_inputs().items():
             self.fields[key] = new_field
 
         self.conditions += other.conditions

flask_inputfilter/conditions/temporal_order_condition.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from datetime import date, datetime
 from typing import Any, Dict
 
 from flask_inputfilter.conditions import BaseCondition
-from flask_inputfilter.exceptions import ValidationError
+from flask_inputfilter.helpers import parse_date
 
 
 class TemporalOrderCondition(BaseCondition):
@@ -56,26 +55,6 @@ def __init__(
         self.larger_date_field = larger_date_field
 
     def check(self, data: Dict[str, Any]) -> bool:
-        smaller_date = self._parse_date(data.get(self.smaller_date_field))
-        larger_date = self._parse_date(data.get(self.larger_date_field))
-
-        return smaller_date < larger_date
-
-    @staticmethod
-    def _parse_date(value: Any) -> datetime:
-        if isinstance(value, datetime):
-            return value
-
-        elif isinstance(value, date):
-            return datetime.combine(value, datetime.min.time())
-
-        elif isinstance(value, str):
-            try:
-                return datetime.fromisoformat(value)
-
-            except ValueError:
-                raise ValidationError(f"Invalid date format: {value}")
-
-        raise ValidationError(
-            f"Unsupported type for date parsing: {type(value)}"
+        return parse_date(data.get(self.smaller_date_field)) < parse_date(
+            data.get(self.larger_date_field)
         )

flask_inputfilter/filters/array_element_filter.py

@@ -49,12 +49,12 @@ def apply(self, value: Any) -> List[Any]:
 
         result = []
         for element in value:
-            if isinstance(self.element_filter, BaseFilter):
+            if hasattr(self.element_filter, "apply"):
                 result.append(self.element_filter.apply(element))
                 continue
 
             elif isinstance(self.element_filter, list) and all(
-                isinstance(v, BaseFilter) for v in self.element_filter
+                hasattr(v, "apply") for v in self.element_filter
             ):
                 for filter_instance in self.element_filter:
                     element = filter_instance.apply(element)

flask_inputfilter/filters/base_64_image_downscale_filter.py

@@ -16,12 +16,12 @@ class Base64ImageDownscaleFilter(BaseFilter):
 
     **Parameters:**
 
-    - **size** (*int*, default: ``1024 * 1024``): A rough pixel count used to
-        compute default dimensions.
-    - **width** (*Optional[int]*): The target width. If not provided, it is
-        calculated as ``sqrt(size)``.
-    - **height** (*Optional[int]*): The target height. If not provided, it is
-        calculated as ``sqrt(size)``.
+    - **size** (*Optional[int]*, default: ``1024 * 1024``): A rough pixel
+        count used to compute default dimensions.
+    - **width** (*Optional[int]*, default: ``size**0.5``): The target width.
+        If not provided, it is calculated as ``sqrt(size)``.
+    - **height** (*Optional[int]*, default: ``size**0.5``): The target height.
+        If not provided, it is calculated as ``sqrt(size)``.
     - **proportionally** (*bool*, default: ``True``): Determines if the image
         should be scaled proportionally. If ``False``, the image is
         forcefully resized to the specified width and height.
@@ -46,17 +46,18 @@ def __init__(self):
                 ])
     """
 
-    __slots__ = ("size", "width", "height", "proportionally")
+    __slots__ = ("width", "height", "proportionally")
 
     def __init__(
         self,
-        size: int = 1024 * 1024,
+        size: Optional[int] = None,
         width: Optional[int] = None,
         height: Optional[int] = None,
         proportionally: bool = True,
     ) -> None:
-        self.width = int(width or size**0.5)
-        self.height = int(height or size**0.5)
+        size = size if size else 1024 * 1024
+        self.width = int(width if width else size**0.5)
+        self.height = int(height if height else size**0.5)
         self.proportionally = proportionally
 
     def apply(self, value: Any) -> Any:

flask_inputfilter/filters/base_64_image_resize_filter.py

@@ -2,7 +2,7 @@
 
 import base64
 import io
-from typing import Any
+from typing import Any, Optional
 
 from PIL import Image
 
@@ -56,12 +56,12 @@ def __init__(self):
     def __init__(
         self,
         max_size: int = 4 * 1024 * 1024,
-        format: ImageFormatEnum = ImageFormatEnum.JPEG,
+        format: Optional[ImageFormatEnum] = None,
         preserve_icc_profile: bool = False,
         preserve_metadata: bool = False,
     ) -> None:
         self.max_size = max_size
-        self.format = format
+        self.format = format if format else ImageFormatEnum.JPEG
         self.preserve_metadata = preserve_metadata
         self.preserve_icc_profile = preserve_icc_profile
 

flask_inputfilter/filters/string_remove_emojis_filter.py

@@ -39,6 +39,8 @@ def __init__(self):
                 ])
     """
 
+    __slots__ = ()
+
     def apply(self, value: Any) -> Union[Optional[str], Any]:
         if not isinstance(value, str):
             return value

flask_inputfilter/filters/string_slugify_filter.py

@@ -30,6 +30,8 @@ def __init__(self):
                 ])
     """
 
+    __slots__ = ()
+
     def apply(self, value: Any) -> Union[Optional[str], Any]:
         if not isinstance(value, str):
             return value

flask_inputfilter/filters/string_trim_filter.py

@@ -27,5 +27,7 @@ def __init__(self):
                 ])
     """
 
+    __slots__ = ()
+
     def apply(self, value: Any) -> Union[str, Any]:
         return value.strip() if isinstance(value, str) else value

flask_inputfilter/filters/to_alpha_numeric_filter.py

@@ -29,6 +29,8 @@ def __init__(self):
                 ])
     """
 
+    __slots__ = ()
+
     def apply(self, value: Any) -> Union[Optional[str], Any]:
         if not isinstance(value, str):
             return value

flask_inputfilter/filters/to_boolean_filter.py

@@ -27,5 +27,7 @@ def __init__(self):
                 ])
     """
 
+    __slots__ = ()
+
     def apply(self, value: Any) -> Union[Optional[bool], Any]:
         return bool(value)