45 | Move static pure methods outside of InputFilter class

Author: LeanderCS

docs/source/changelog.rst

@@ -8,8 +8,9 @@ All notable changes to this project will be documented in this file.
 
 Changed
 ^^^^^^^
-- Introduced c++ vectors in ``InputFilter`` to improve performance.
+- Introduced first c++ vector in ``InputFilter`` to improve performance.
 - Updated required ``cython`` version to 3.0 or higher for python 3.7 - 3.11.
+- Moved static methods outside of pure InputFilter class.
 
 
 [0.4.0] - 2025-04-20

docs/source/options/copy.rst

@@ -44,7 +44,7 @@ Basic Copy Integration
     def test_route():
         validated_data = g.validated_data
 
-        # Cotains the same value as username but escaped eg. "very-important-user"
+        # Contains the same value as username but escaped eg. "very-important-user"
         print(validated_data["escapedUsername"])
 
 

flask_inputfilter/InputFilter.py

@@ -10,7 +10,7 @@
 from flask_inputfilter.Condition import BaseCondition
 from flask_inputfilter.Exception import ValidationError
 from flask_inputfilter.Filter import BaseFilter
-from flask_inputfilter.Mixin import ExternalApiMixin
+from flask_inputfilter.Mixin import ExternalApiMixin, FieldMixin
 from flask_inputfilter.Model import ExternalApiConfig, FieldModel
 from flask_inputfilter.Validator import BaseValidator
 
@@ -197,17 +197,17 @@ def validateData(
                     value = self.validated_data.get(copy)
 
                 if external_api:
-                    value = ExternalApiMixin().callExternalApi(
+                    value = ExternalApiMixin.callExternalApi(
                         external_api, fallback, self.validated_data
                     )
 
-                value = InputFilter.applyFilters(filters, value)
+                value = FieldMixin.applyFilters(filters, value)
                 value = (
-                    InputFilter.validateField(validators, fallback, value)
+                    FieldMixin.validateField(validators, fallback, value)
                     or value
                 )
-                value = InputFilter.applySteps(steps, fallback, value) or value
-                value = InputFilter.checkForRequired(
+                value = FieldMixin.applySteps(steps, fallback, value) or value
+                value = FieldMixin.checkForRequired(
                     field_name, required, default, fallback, value
                 )
 
@@ -217,7 +217,7 @@ def validateData(
                 errors[field_name] = str(e)
 
         try:
-            InputFilter.checkConditions(self.conditions, self.validated_data)
+            FieldMixin.checkConditions(self.conditions, self.validated_data)
         except ValidationError as e:
             errors["_condition"] = str(e)
 
@@ -252,30 +252,6 @@ def getConditions(self) -> List[BaseCondition]:
         """
         return self.conditions
 
-    @staticmethod
-    def checkConditions(
-        conditions: List[BaseCondition], validated_data: Dict[str, Any]
-    ) -> None:
-        """
-        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
-            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."
-                )
-
     def setData(self, data: Dict[str, Any]) -> None:
         """
         Filters and sets the provided data into the object's internal
@@ -291,7 +267,7 @@ def setData(self, data: Dict[str, Any]) -> None:
         self.data = {}
         for field_name, field_value in data.items():
             if field_name in self.fields:
-                field_value = InputFilter.applyFilters(
+                field_value = FieldMixin.applyFilters(
                     filters=self.fields[field_name].filters,
                     value=field_value,
                 )
@@ -349,7 +325,7 @@ def getRawValue(self, name: str) -> Any:
         Returns:
             Any: The raw value associated with the provided key.
         """
-        return self.data.get(name) if name in self.data else None
+        return self.data.get(name)
 
     def getRawValues(self) -> Dict[str, Any]:
         """
@@ -634,98 +610,6 @@ def replace(
             copy=copy,
         )
 
-    @staticmethod
-    def applySteps(
-        steps: List[Union[BaseFilter, BaseValidator]],
-        fallback: Any,
-        value: Any,
-    ) -> 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
-    def checkForRequired(
-        field_name: str,
-        required: bool,
-        default: Any,
-        fallback: Any,
-        value: Any,
-    ) -> 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.")
-
     def addGlobalFilter(self, filter: BaseFilter) -> None:
         """
         Add a global filter to be applied to all fields.
@@ -748,28 +632,6 @@ def getGlobalFilters(self) -> List[BaseFilter]:
         """
         return self.global_filters
 
-    @staticmethod
-    def applyFilters(filters: List[BaseFilter], value: Any) -> 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
-
     def clear(self) -> None:
         """
         Resets all fields of the InputFilter instance to
@@ -875,33 +737,3 @@ def getGlobalValidators(self) -> List[BaseValidator]:
             List[BaseValidator]: A list of global validators.
         """
         return self.global_validators
-
-    @staticmethod
-    def validateField(
-        validators: List[BaseValidator], fallback: Any, value: Any
-    ) -> 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/Mixin/ExternalApiMixin.py

@@ -8,8 +8,8 @@
 
 
 class ExternalApiMixin:
+    @staticmethod
     def callExternalApi(
-        self,
         config: ExternalApiConfig,
         fallback: Any,
         validated_data: Dict[str, Any],