Merge pull request #53 from LeanderCS/45

45 | Move more static methods outside of InputFilter class

Author: LeanderCS

MANIFEST.in

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

docs/source/changelog.rst

@@ -3,6 +3,19 @@ Changelog
 
 All notable changes to this project will be documented in this file.
 
+[0.5.2] - 2025-04-27
+--------------------
+
+Changed
+^^^^^^^
+- Moved multiple internal methods to own ``FieldMixin``
+  - ``applyFilters``
+  - ``applySteps``
+  - ``checkConditions``
+  - ``checkForRequired``
+  - ``validateField``
+
+
 [0.5.1] - 2025-04-26
 --------------------
 

docs/source/conf.py

@@ -1,7 +1,7 @@
 project = "flask-inputfilter"
 copyright = "2025, Leander Cain Slotosch"
 author = "Leander Cain Slotosch"
-release = "0.5.1"
+release = "0.5.2"
 
 extensions = ["sphinx_rtd_theme", "sphinx_design"]
 

flask_inputfilter/_input_filter.pyx

@@ -13,7 +13,8 @@ from flask import Response, g, request
 from flask_inputfilter.conditions import BaseCondition
 from flask_inputfilter.exceptions import ValidationError
 from flask_inputfilter.filters import BaseFilter
-from flask_inputfilter.mixins import ExternalApiMixin
+from flask_inputfilter.mixins._external_api_mixin cimport ExternalApiMixin
+from flask_inputfilter.mixins._field_mixin cimport FieldMixin
 from flask_inputfilter.models import ExternalApiConfig, FieldModel
 from flask_inputfilter.validators import BaseValidator
 
@@ -210,14 +211,14 @@ cdef class InputFilter:
                     value = self.validated_data.get(copy)
 
                 if external_api:
-                    value = ExternalApiMixin().callExternalApi(
+                    value = ExternalApiMixin.callExternalApi(
                         external_api, fallback, self.validated_data
                     )
 
-                value = self.applyFilters(filters, value)
-                value = self.validateField(validators, fallback, value) or value
-                value = self.applySteps(steps, fallback, value) or value
-                value = InputFilter.checkForRequired(
+                value = FieldMixin.applyFilters(filters, value)
+                value = FieldMixin.validateField(validators, fallback, value) or value
+                value = FieldMixin.applySteps(steps, fallback, value) or value
+                value = FieldMixin.checkForRequired(
                     field_name, required, default, fallback, value
                 )
 
@@ -227,7 +228,7 @@ cdef class InputFilter:
                 errors[field_name] = str(e)
 
         try:
-            self.checkConditions(self.conditions, self.validated_data)
+            FieldMixin.checkConditions(self.conditions, self.validated_data)
         except ValidationError as e:
             errors["_condition"] = str(e)
 
@@ -262,27 +263,6 @@ cdef class InputFilter:
         """
         return self.conditions
 
-    cdef void checkConditions(self, conditions: List[BaseCondition], validated_data: Dict[str, Any]) except *:
-        """
-        Checks if all conditions are met.
-
-        This method iterates through all registered conditions and checks
-        if they are satisfied based on the provided validated data. If any
-        condition is not met, a ValidationError is raised with an appropriate
-        message indicating which condition failed.
-
-        Args:
-            conditions (List[BaseCondition]):
-                A list of conditions to be checked against the validated data.
-            validated_data (Dict[str, Any]):
-                The validated data to check against the conditions.
-        """
-        for condition in conditions:
-            if not condition.check(validated_data):
-                raise ValidationError(
-                    f"Condition '{condition.__class__.__name__}' not met."
-                )
-
     cpdef void setData(self, data: Dict[str, Any]):
         """
         Filters and sets the provided data into the object's internal
@@ -298,7 +278,7 @@ cdef class InputFilter:
         self.data = {}
         for field_name, field_value in data.items():
             if field_name in self.fields:
-                field_value = self.applyFilters(
+                field_value = FieldMixin.applyFilters(
                     filters=self.fields[field_name].filters + self.global_filters,
                     value=field_value,
                 )
@@ -411,7 +391,7 @@ cdef class InputFilter:
         """
         self.data = data
 
-    def hasUnknown(self) -> bool:
+    cpdef bint hasUnknown(self):
         """
         Checks whether any values in the current data do not have
         corresponding configurations in the defined fields.
@@ -422,10 +402,11 @@ cdef class InputFilter:
         if not self.data and self.fields:
             return True
 
-        return any(
-            field_name not in self.fields.keys()
-            for field_name in self.data.keys()
-        )
+        for field_name in self.data.keys():
+            if field_name not in self.fields:
+                return True
+
+        return False
 
     cpdef str getErrorMessage(self, field_name: str):
         """
@@ -641,94 +622,6 @@ cdef class InputFilter:
             copy=copy,
         )
 
-    cdef object applySteps(
-        self,
-        steps: List[Union[BaseFilter, BaseValidator]],
-        fallback: Any,
-        value: Any,
-    ):
-        """
-        Apply multiple filters and validators in a specific order.
-
-        This method processes a given value by sequentially applying a list of 
-        filters and validators. Filters modify the value, while validators 
-        ensure the value meets specific criteria. If a validation error occurs 
-        and a fallback value is provided, the fallback is returned. Otherwise, 
-        the validation error is raised.
-
-        Args:
-            steps (List[Union[BaseFilter, BaseValidator]]): 
-                A list of filters and validators to be applied in order.
-            fallback (Any): 
-                A fallback value to return if validation fails.
-            value (Any): 
-                The initial value to be processed.
-
-        Returns:
-            Any: The processed value after applying all filters and validators. 
-                If a validation error occurs and a fallback is provided, the 
-                fallback value is returned.
-
-        Raises:
-            ValidationError: If validation fails and no fallback value is 
-                provided.
-        """
-        if value is None:
-            return
-
-        try:
-            for step in steps:
-                if isinstance(step, BaseFilter):
-                    value = step.apply(value)
-                elif isinstance(step, BaseValidator):
-                    step.validate(value)
-        except ValidationError:
-            if fallback is None:
-                raise
-            return fallback
-        return value
-
-    @staticmethod
-    cdef object checkForRequired(
-        field_name: str,
-        required: bool,
-        default: Any,
-        fallback: Any,
-        value: Any,
-    ):
-        """
-        Determine the value of the field, considering the required and
-        fallback attributes.
-
-        If the field is not required and no value is provided, the default
-        value is returned. If the field is required and no value is provided,
-        the fallback value is returned. If no of the above conditions are met,
-        a ValidationError is raised.
-        
-        Args:
-            field_name (str): The name of the field being processed.
-            required (bool): Indicates whether the field is required.
-            default (Any): The default value to use if the field is not provided and not required.
-            fallback (Any): The fallback value to use if the field is required but not provided.
-            value (Any): The current value of the field being processed.
-
-        Returns:
-            Any: The determined value of the field after considering required, default, and fallback attributes.
-
-        Raises:
-            ValidationError: If the field is required and no value or fallback is provided.
-        """
-        if value is not None:
-            return value
-
-        if not required:
-            return default
-
-        if fallback is not None:
-            return fallback
-
-        raise ValidationError(f"Field '{field_name}' is required.")
-
     cpdef void addGlobalFilter(self, filter: BaseFilter):
         """
         Add a global filter to be applied to all fields.
@@ -751,27 +644,6 @@ cdef class InputFilter:
         """
         return self.global_filters
 
-    cdef object applyFilters(self, filters: List[BaseFilter], value: Any):
-        """
-        Apply filters to the field value.
-        
-        Args:
-            filters (List[BaseFilter]): A list of filters to apply to the 
-                value.
-            value (Any): The value to be processed by the filters.
-        
-        Returns:
-            Any: The processed value after applying all filters. 
-                If the value is None, None is returned.
-        """
-        if value is None:
-            return
-
-        for filter in filters:
-            value = filter.apply(value)
-
-        return value
-
     cpdef void clear(self):
         """
         Resets all fields of the InputFilter instance to
@@ -877,32 +749,3 @@ cdef class InputFilter:
             List[BaseValidator]: A list of global validators.
         """
         return self.global_validators
-
-    cdef object validateField(
-        self, validators: List[BaseValidator], fallback: Any, value: Any
-    ):
-        """
-        Validate the field value.
-
-        Args:
-            validators (List[BaseValidator]): A list of validators to apply 
-                to the field value.
-            fallback (Any): A fallback value to return if validation fails.
-            value (Any): The value to be validated.
-
-        Returns:
-            Any: The validated value if all validators pass. If validation 
-                fails and a fallback is provided, the fallback value is 
-                returned.
-        """
-        if value is None:
-            return
-
-        try:
-            for validator in validators:
-                validator.validate(value)
-        except ValidationError:
-            if fallback is None:
-                raise
-
-            return fallback

flask_inputfilter/input_filter.pyi

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any, Dict, List, Optional, Type, TypeVar, Union
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
 
 from flask import Response
 
@@ -31,8 +31,8 @@ class InputFilter:
     ) -> Callable[
         [Any],
         Callable[
-            [tuple[Any, ...], Dict[str, Any]],
-            Union[Response, tuple[Any, Dict[str, Any]]],
+            [Tuple[Any, ...], Dict[str, Any]],
+            Union[Response, Tuple[Any, Dict[str, Any]]],
         ],
     ]: ...
     def validateData(

flask_inputfilter/mixins/__init__.py

@@ -2,6 +2,7 @@
 
 if shutil.which("g++") is not None:
     from ._external_api_mixin import ExternalApiMixin
+    from ._field_mixin import FieldMixin
 
 else:
     from .external_api_mixin import ExternalApiMixin

flask_inputfilter/mixins/_external_api_mixin.pxd

@@ -0,0 +1,17 @@
+from typing import Any, Dict
+
+from flask_inputfilter.models import ExternalApiConfig
+
+
+cdef class ExternalApiMixin:
+    @staticmethod
+    cdef str replacePlaceholders(
+            value: str,
+            validated_data: Dict[str, Any]
+    )
+    @staticmethod
+    cdef dict replacePlaceholdersInParams(
+            params: dict, validated_data: Dict[str, Any]
+    )
+    @staticmethod
+    cdef object callExternalApi(config: ExternalApiConfig, fallback: Any, validated_data: Dict[str, Any])