Refactor

Author: LeanderCS

flask_inputfilter/_input_filter.pyx

@@ -29,6 +29,15 @@ from libcpp.string cimport string
 
 from libcpp.algorithm cimport find
 
+cdef extern from "helper.h":
+    vector[string] make_default_methods()
+
+    cdef cppclass StringConstants:
+        @staticmethod
+        const char* get(const string& key) nogil
+        @staticmethod
+        bint has(const string& key) nogil
+
 cdef dict _INTERNED_STRINGS = {
     "_condition": sys.intern("_condition"),
     "_error": sys.intern("_error"),
@@ -47,9 +56,6 @@ cdef dict _INTERNED_STRINGS = {
     "validators": sys.intern("validators"),
 }
 
-cdef extern from "helper.h":
-    vector[string] make_default_methods()
-
 T = TypeVar("T")
 
 
@@ -403,16 +409,13 @@ cdef class InputFilter:
             return {}
 
         cdef:
-            Py_ssize_t i, n = len(self.fields)
-            dict result
+            Py_ssize_t i
+            dict result = {}
             list field_names = list(self.fields.keys())
             str field
             object field_value
 
-        # Pre-allocate dictionary size for better performance
-        result = {}
-
-        for i in range(n):
+        for i in range(len(self.fields)):
             field = field_names[i]
             field_value = self.data.get(field)
             if field_value is not None:

flask_inputfilter/include/helper.h

@@ -18,6 +18,102 @@ inline std::vector<std::string> make_default_methods() {
     };
 }
 
+class HttpMethodSet {
+private:
+    std::unordered_set<std::string> methods;
+
+public:
+    HttpMethodSet() = default;
+
+    HttpMethodSet(const HttpMethodSet& other) : methods(other.methods) {}
+
+    HttpMethodSet(HttpMethodSet&& other) noexcept : methods(std::move(other.methods)) {}
+
+    HttpMethodSet& operator=(const HttpMethodSet& other) {
+        if (this != &other) {
+            methods = other.methods;
+        }
+        return *this;
+    }
+
+    HttpMethodSet& operator=(HttpMethodSet&& other) noexcept {
+        if (this != &other) {
+            methods = std::move(other.methods);
+        }
+        return *this;
+    }
+
+    explicit HttpMethodSet(const std::vector<std::string>& method_list) {
+        methods.reserve(method_list.size());
+        for (const auto& method : method_list) {
+            methods.insert(method);
+        }
+    }
+
+    bool contains(const std::string& method) const {
+        return methods.find(method) != methods.end();
+    }
+
+    void add(const std::string& method) {
+        methods.insert(method);
+    }
+
+    void clear() {
+        methods.clear();
+    }
+
+    size_t size() const {
+        return methods.size();
+    }
+
+    void from_vector(const std::vector<std::string>& method_list) {
+        clear();
+        methods.reserve(method_list.size());
+        for (const auto& method : method_list) {
+            methods.insert(method);
+        }
+    }
+};
+
+class StringConstants {
+private:
+    std::unordered_map<std::string, const char*> constants;
+    static StringConstants& get_instance() {
+        static StringConstants instance;
+        return instance;
+    }
+
+    StringConstants() {
+        constants["_condition"] = "_condition";
+        constants["_error"] = "_error";
+        constants["copy"] = "copy";
+        constants["default"] = "default";
+        constants["DELETE"] = "DELETE";
+        constants["external_api"] = "external_api";
+        constants["fallback"] = "fallback";
+        constants["filters"] = "filters";
+        constants["GET"] = "GET";
+        constants["PATCH"] = "PATCH";
+        constants["POST"] = "POST";
+        constants["PUT"] = "PUT";
+        constants["required"] = "required";
+        constants["steps"] = "steps";
+        constants["validators"] = "validators";
+    }
+
+public:
+    static const char* get(const std::string& key) {
+        auto& instance = get_instance();
+        auto it = instance.constants.find(key);
+        return (it != instance.constants.end()) ? it->second : nullptr;
+    }
+
+    static bool has(const std::string& key) {
+        auto& instance = get_instance();
+        return instance.constants.find(key) != instance.constants.end();
+    }
+};
+
 namespace string_ops {
     inline bool fast_startswith(const std::string& str, const std::string& prefix) {
         return str.size() >= prefix.size() &&

flask_inputfilter/mixins/data_mixin/_data_mixin.pyx

@@ -10,6 +10,10 @@ from flask_inputfilter.exceptions import ValidationError
 from flask_inputfilter.mixins.cimports cimport ValidationMixin
 from flask_inputfilter.models.cimports cimport BaseFilter, BaseValidator, FieldModel, BaseCondition, InputFilter
 
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp.algorithm cimport find
+
 DEF LARGE_DATASET_THRESHOLD = 100
 
 
@@ -36,19 +40,9 @@ cdef class DataMixin:
         if not data and fields:
             return True
 
-        cdef set field_set
-
-        # Use set operations for faster lookup when there are many fields
-        if len(fields) > LARGE_DATASET_THRESHOLD:
-            field_set = set(fields.keys())
-            for field_name in data.keys():
-                if field_name not in field_set:
-                    return True
-        else:
-            # Use direct dict lookup for smaller field counts
-            for field_name in data.keys():
-                if field_name not in fields:
-                    return True
+        for field_name in data.keys():
+            if field_name not in fields:
+                return True
 
         return False
 
@@ -73,13 +67,19 @@ cdef class DataMixin:
         """
         cdef:
             dict[str, Any] filtered_data = {}
-            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 []
+            Py_ssize_t i
+            list keys
+            list values
             str field_name
             object field_value
 
-        for i in range(n):
+        if not data:
+            return filtered_data
+
+        keys = list(data.keys())
+        values = list(data.values())
+
+        for i in range(len(data)):
             field_name = keys[i]
             field_value = values[i]
 
@@ -153,6 +153,8 @@ cdef class DataMixin:
             dict source_inputs = source_filter.get_inputs()
             list keys = list(source_inputs.keys()) if source_inputs else []
             list new_fields = list(source_inputs.values()) if source_inputs else []
+            str method
+            bytes encoded_method
 
         n = len(keys)
         for i in range(n):
@@ -161,12 +163,12 @@ cdef class DataMixin:
         target_filter.conditions.extend(source_filter.conditions)
 
         DataMixin._merge_component_list(
-            target_filter.global_filters, 
+            target_filter.global_filters,
             source_filter.global_filters
         )
 
         DataMixin._merge_component_list(
-            target_filter.global_validators, 
+            target_filter.global_validators,
             source_filter.global_validators
         )
 

flask_inputfilter/mixins/validation_mixin/_validation_mixin.pxd

@@ -18,7 +18,7 @@ cdef class ValidationMixin:
     cdef void check_conditions(list[BaseCondition] conditions, dict[str, Any] validated_data) except *
 
     @staticmethod
-    cdef object check_for_required(str field_name, FieldModel field_info, object value)
+    cdef inline object check_for_required(str field_name, FieldModel field_info, object value)
 
     @staticmethod
     cdef tuple validate_fields(
@@ -29,4 +29,4 @@ cdef class ValidationMixin:
     )
 
     @staticmethod
-    cdef object get_field_value(str field_name, FieldModel field_info, dict[str, Any] data, dict[str, Any] validated_data) 
+    cdef inline object get_field_value(str field_name, FieldModel field_info, dict[str, Any] data, dict[str, Any] validated_data) 

flask_inputfilter/mixins/validation_mixin/_validation_mixin.pyx

@@ -42,18 +42,18 @@ cdef class ValidationMixin:
             return None
 
         cdef:
-            Py_ssize_t i, n
+            Py_ssize_t i
             BaseFilter current_filter
 
-        n = len(filters1) if filters1 else 0
-        for i in range(n):
-            current_filter = filters1[i]
-            value = current_filter.apply(value)
+        if filters1:
+            for i in range(len(filters1)):
+                current_filter = filters1[i]
+                value = current_filter.apply(value)
 
-        n = len(filters2) if filters2 else 0
-        for i in range(n):
-            current_filter = filters2[i]
-            value = current_filter.apply(value)
+        if filters2:
+            for i in range(len(filters2)):
+                current_filter = filters2[i]
+                value = current_filter.apply(value)
 
         return value
 
@@ -95,12 +95,15 @@ cdef class ValidationMixin:
         if value is None:
             return None
 
+        if not steps:
+            return value
+
         cdef:
-            Py_ssize_t i, n = len(steps) if steps else 0
+            Py_ssize_t i
             object current_step
 
         try:
-            for i in range(n):
+            for i in range(len(steps)):
                 current_step = steps[i]
                 if isinstance(current_step, BaseFilter):
                     value = current_step.apply(value)
@@ -132,11 +135,14 @@ cdef class ValidationMixin:
         - **validated_data** (*dict[str, Any]*):
           The validated data to check against the conditions.
         """
+        if not conditions:
+            return
+
         cdef:
-            Py_ssize_t i, n = len(conditions) if conditions else 0
+            Py_ssize_t i
             object current_condition
 
-        for i in range(n):
+        for i in range(len(conditions)):
             current_condition = conditions[i]
             if not current_condition.check(validated_data):
                 raise ValidationError(
@@ -215,19 +221,19 @@ cdef class ValidationMixin:
             return None
 
         cdef:
-            Py_ssize_t i, n
+            Py_ssize_t i
             BaseValidator current_validator
 
         try:
-            n = len(validators1) if validators1 else 0
-            for i in range(n):
-                current_validator = validators1[i]
-                current_validator.validate(value)
-
-            n = len(validators2) if validators2 else 0
-            for i in range(n):
-                current_validator = validators2[i]
-                current_validator.validate(value)
+            if validators1:
+                for i in range(len(validators1)):
+                    current_validator = validators1[i]
+                    current_validator.validate(value)
+
+            if validators2:
+                for i in range(len(validators2)):
+                    current_validator = validators2[i]
+                    current_validator.validate(value)
         except ValidationError:
             if fallback is None:
                 raise
@@ -269,16 +275,20 @@ cdef class ValidationMixin:
         cdef:
             dict[str, Any] validated_data = {}
             dict[str, str] errors = {}
-            Py_ssize_t i, n = len(fields) if fields else 0
-
-        cdef:
-            list field_names = list(fields.keys()) if n > 0 else []
-            list field_infos = list(fields.values()) if n > 0 else []
+            Py_ssize_t i
+            list field_names
+            list field_infos
             str field_name
             FieldModel field_info
             object value
 
-        for i in range(n):
+        if not fields:
+            return validated_data, errors
+
+        field_names = list(fields.keys())
+        field_infos = list(fields.values())
+
+        for i in range(len(fields)):
             field_name = field_names[i]
             field_info = field_infos[i]