Add more compiler directives

Author: LeanderCS

flask_inputfilter/_input_filter.pyx

@@ -1,9 +1,4 @@
 # cython: language=c++
-# cython: language_level=3
-# cython: binding=True
-# cython: cdivision=True
-# cython: boundscheck=False
-# cython: initializedcheck=False
 import json
 import logging
 from typing import Any, Optional, Type, TypeVar, Union
@@ -190,19 +185,29 @@ cdef class InputFilter:
         cdef dict errors = {}
         cdef dict validated_data = {}
 
-        cdef object default
-        cdef object fallback
-        cdef list filters
-        cdef list validators
-        cdef object external_api
-        cdef str 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():
+        cdef:
+            list global_filters = self.global_filters
+            list global_validators = self.global_validators
+            bint has_global_filters = bool(global_filters)
+            bint has_global_validators = bool(global_validators)
+
+        cdef:
+            int i = 0
+            int n = len(self.fields)
+            list field_names = list(self.fields.keys())
+            list field_infos = list(self.fields.values())
+
+        cdef:
+            object default
+            object fallback
+            list filters
+            list validators
+            object external_api
+            str copy
+
+        for i in range(n):
+            field_name = field_names[i]
+            field_info = field_infos[i]
             try:
                 if field_info.copy:
                     value = validated_data.get(field_info.copy)
@@ -216,27 +221,27 @@ cdef class InputFilter:
                     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)
+                    value = FieldMixin.apply_filters(
+                        field_info.filters + global_filters
+                        if has_global_filters
+                        else field_info.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.validate_field(
+                        field_info.validators + global_validators
+                        if has_global_validators
+                        else field_info.validators,
+                        field_info.fallback,
+                        value
+                    ) or value
 
                 if field_info.steps:
-                    result = FieldMixin.apply_steps(
-                        field_info.steps, field_info.fallback, value
-                    )
-                    if result is not None:
-                        value = result
+                    value = FieldMixin.apply_steps(
+                        field_info.steps,
+                        field_info.fallback, value
+                    ) or value
 
                 if value is None:
                     if field_info.required:
@@ -308,7 +313,15 @@ cdef class InputFilter:
                 data to be filtered and stored.
         """
         self.data = {}
-        for field_name, field_value in data.items():
+        cdef:
+            int i = 0
+            int n = len(data)
+            list keys = list(data.keys())
+            list values = list(data.values())
+
+        for i in range(n):
+            field_name = keys[i]
+            field_value = values[i]
             if field_name in self.fields:
                 field_value = FieldMixin.apply_filters(
                     filters=self.fields[field_name].filters + self.global_filters,
@@ -388,11 +401,17 @@ cdef class InputFilter:
         if not self.fields:
             return {}
 
-        return {
-            field: self.data[field]
-            for field in self.fields
-            if field in self.data
-        }
+        cdef:
+            int i = 0
+            int n = len(self.fields)
+            dict result = {}
+            list field_names = list(self.fields.keys())
+
+        for i in range(n):
+            field = field_names[i]
+            if field in self.data:
+                result[field] = self.data[field]
+        return result
 
     cpdef dict get_unfiltered_data(self):
         """
@@ -711,9 +730,14 @@ cdef class InputFilter:
                 "Can only merge with another InputFilter instance."
             )
 
-        for key, new_field in other.get_inputs().items():
-            self.fields[key] = new_field
+        cdef:
+            int i = 0
+            int n = len(other.get_inputs())
+            list keys = list(other.get_inputs().keys())
+            list new_fields = list(other.get_inputs().values())
 
+        for i in range(n):
+            self.fields[keys[i]] = new_fields[i]
         self.conditions += other.conditions
 
         for filter in other.global_filters:

flask_inputfilter/filters/array_element_filter.py

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

flask_inputfilter/input_filter.py

@@ -205,27 +205,32 @@ def validate_data(
                     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)
+                    value = FieldMixin.apply_filters(
+                        field_info.filters + global_filters
+                        if has_global_filters
+                        else field_info.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
+                    value = (
+                        FieldMixin.validate_field(
+                            field_info.validators + global_validators
+                            if has_global_validators
+                            else field_info.validators,
+                            field_info.fallback,
+                            value,
+                        )
+                        or value
                     )
-                    if result is not None:
-                        value = result
 
                 if field_info.steps:
-                    result = FieldMixin.apply_steps(
-                        field_info.steps, field_info.fallback, value
+                    value = (
+                        FieldMixin.apply_steps(
+                            field_info.steps, field_info.fallback, value
+                        )
+                        or value
                     )
-                    if result is not None:
-                        value = result
 
                 if value is None:
                     if field_info.required:
@@ -694,7 +699,7 @@ def merge(self, other: "InputFilter") -> None:
         Args:
             other (InputFilter): The InputFilter instance to merge.
         """
-        if not hasattr(other, "validate_data"):
+        if not isinstance(other, InputFilter):
             raise TypeError(
                 "Can only merge with another InputFilter instance."
             )

flask_inputfilter/mixins/_external_api_mixin.pyx

@@ -1,11 +1,6 @@
 # cython: language=c++
-# cython: language_level=3
-# cython: binding=True
-# cython: cdivision=True
-# cython: boundscheck=False
-# cython: initializedcheck=False
 import re
-from typing import Any, Dict, Optional
+from typing import Optional
 
 from flask_inputfilter.exceptions import ValidationError
 from flask_inputfilter.models import ExternalApiConfig
@@ -14,7 +9,7 @@ from flask_inputfilter.models import ExternalApiConfig
 cdef class ExternalApiMixin:
 
     @staticmethod
-    cdef str replace_placeholders(
+    cdef inline str replace_placeholders(
             str value,
             dict validated_data
     ):

flask_inputfilter/mixins/_field_mixin.pyx

@@ -1,4 +1,7 @@
-from typing import Any, Union
+# cython: language=c++
+from typing import Union
+
+import cython
 
 from flask_inputfilter.conditions import BaseCondition
 from flask_inputfilter.exceptions import ValidationError
@@ -8,6 +11,7 @@ from flask_inputfilter.validators import BaseValidator
 
 cdef class FieldMixin:
     @staticmethod
+    @cython.exceptval(check=False)
     cdef object apply_filters(list filters, object value):
         """
         Apply filters to the field value.
@@ -24,8 +28,14 @@ cdef class FieldMixin:
         if value is None:
             return None
 
-        for filter in filters:
-            value = filter.apply(value)
+        cdef:
+            int i
+            int n = len(filters)
+            object current_filter
+
+        for i in range(n):
+            current_filter = filters[i]
+            value = current_filter.apply(value)
 
         return value
 
@@ -64,12 +74,18 @@ cdef class FieldMixin:
         if value is None:
             return None
 
+        cdef:
+            int i
+            int n = len(steps)
+            object current_step
+
         try:
-            for step in steps:
-                if hasattr(step, 'apply'):
-                    value = step.apply(value)
-                elif hasattr(step, 'validate'):
-                    step.validate(value)
+            for i in range(n):
+                current_step = steps[i]
+                if isinstance(current_step, BaseFilter):
+                    value = current_step.apply(value)
+                elif isinstance(current_step, BaseValidator):
+                    current_step.validate(value)
         except ValidationError:
             if fallback is None:
                 raise
@@ -92,14 +108,20 @@ cdef class FieldMixin:
             validated_data (dict[str, Any]):
                 The validated data to check against the conditions.
         """
-        for condition in conditions:
-            if not condition.check(validated_data):
+        cdef:
+            int i
+            int n = len(conditions)
+            object current_condition
+
+        for i in range(n):
+            current_condition = conditions[i]
+            if not current_condition.check(validated_data):
                 raise ValidationError(
-                    f"Condition '{condition.__class__.__name__}' not met."
+                    f"Condition '{current_condition.__class__.__name__}' not met."
                 )
 
     @staticmethod
-    cdef object check_for_required(
+    cdef inline object check_for_required(
             str field_name,
             bint required,
             object default,
@@ -160,9 +182,15 @@ cdef class FieldMixin:
         if value is None:
             return None
 
+        cdef:
+            int i
+            int n = len(validators)
+            object current_validator
+
         try:
-            for validator in validators:
-                validator.validate(value)
+            for i in range(n):
+                current_validator = validators[i]
+                current_validator.validate(value)
         except ValidationError:
             if fallback is None:
                 raise

flask_inputfilter/mixins/field_mixin.py

@@ -98,9 +98,9 @@ def apply_steps(
 
         try:
             for step in steps:
-                if hasattr(step, "apply"):
+                if isinstance(step, BaseFilter):
                     value = step.apply(value)
-                elif hasattr(step, "validate"):
+                elif isinstance(step, BaseValidator):
                     step.validate(value)
         except ValidationError:
             if fallback is None:

flask_inputfilter/models/_field_model.pyx

@@ -1,9 +1,4 @@
 # cython: language=c++
-# cython: language_level=3
-# cython: binding=True
-# cython: cdivision=True
-# cython: boundscheck=False
-# cython: initializedcheck=False
 from __future__ import annotations
 
 from typing import Any, Optional, Union

flask_inputfilter/models/external_api_config.py

@@ -9,12 +9,14 @@ class ExternalApiConfig:
     """
     Configuration for an external API call.
 
-    :param url: The URL of the external API.
-    :param method: The HTTP method to use.
-    :param params: The parameters to send to the API.
-    :param data_key: The key in the response JSON to use
-    :param api_key: The API key to use.
-    :param headers: The headers to send to the API.
+    **Parameters:**
+
+    - **url** (*str*): The URL of the external API.
+    - **method** (*str*): The HTTP method to use.
+    - **params** (*Optional[dict[str, str]]*): The parameters to send to the API.
+    - **data_key** (*Optional[str]*): The key in the response JSON to use
+    - **api_key** (*Optional[str]*): The API key to use.
+    - **headers** (*Optional[dict[str, str]]*): The headers to send to the API.
     """
 
     url: str