Update cython to optimize for larger objects

Author: LeanderCS

.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(docker exec:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

docs/source/changelog.rst

@@ -3,18 +3,7 @@ Changelog
 
 All notable changes to this project will be documented in this file.
 
-[0.6.4] - 2025-08-12
---------------------
-
-Changed
-^^^^^^^
-- Increased freelist sizes for ``InputFilter``, ``FieldModel``, and ``ExternalApiConfig`` to reduce allocations
-- Replaced Python generators with C-style loops and added early exit conditions in filter/validator chains
-- Optimized dictionary operations and string lookups with extended interning
-- Improved ``has_unknown_fields`` with adaptive strategies based on data size
-
-
-[0.6.3] - 2025-08-11
+[0.6.3] - 2025-08-12
 --------------------
 
 Added
@@ -28,6 +17,10 @@ Changed
 - Updated Dockerfile base image from ``debian:buster-slim`` to ``debian:bookworm-slim`` to fix package repository issues after Debian Buster reached end-of-life.
 - Optimized Cython compilation with enhanced compiler flags (``-O3``, ``-march=native``, etc.) for better performance.
 - Enhanced ``ValidationMixin`` to support lazy evaluation when filter chains exceed the configured threshold.
+- Increased freelist sizes for ``InputFilter``, ``FieldModel``, and ``ExternalApiConfig`` to reduce allocations
+- Replaced Python generators with C-style loops and added early exit conditions in filter/validator chains
+- Optimized dictionary operations and string lookups with extended interning
+- Improved ``has_unknown_fields`` with adaptive strategies based on data size
 
 
 [0.6.2] - 2025-07-03

flask_inputfilter/_input_filter.pxd

@@ -3,17 +3,17 @@ from typing import Any
 
 from flask_inputfilter.models.cimports cimport BaseCondition, BaseFilter, BaseValidator, ExternalApiConfig, FieldModel
 
-from libcpp.vector cimport vector
+from libcpp.unordered_set cimport unordered_set
 from libcpp.string cimport string
 
 
 cdef extern from "helper.h":
-    vector[string] make_default_methods()
+    unordered_set[string] make_default_methods_set()
 
 
 cdef class InputFilter:
     cdef readonly:
-        vector[string] methods
+        unordered_set[string] methods
         dict[str, FieldModel] fields
         list[BaseCondition] conditions
         list[BaseFilter] global_filters

flask_inputfilter/_input_filter.pyx

@@ -3,7 +3,11 @@
 # cython: boundscheck=False
 # cython: wraparound=False
 # cython: cdivision=True
+# cython: nonecheck=False
+# cython: initializedcheck=False
+# cython: overflowcheck=False
 
+import cython
 import json
 import logging
 import sys
@@ -16,35 +20,52 @@ from flask_inputfilter.exceptions import ValidationError
 from flask_inputfilter.mixins.cimports cimport DataMixin
 from flask_inputfilter.models.cimports cimport BaseCondition, BaseFilter, BaseValidator, ExternalApiConfig, FieldModel
 
-from libcpp.vector cimport vector
+from libcpp.unordered_set cimport unordered_set
 from libcpp.string cimport string
 
 cdef dict _INTERNED_STRINGS = {
     "_condition": sys.intern("_condition"),
     "_error": sys.intern("_error"),
+    "apply": sys.intern("apply"),
+    "Authorization": sys.intern("Authorization"),
+    "cache": sys.intern("cache"),
+    "check": sys.intern("check"),
     "copy": sys.intern("copy"),
+    "data": sys.intern("data"),
+    "data_key": sys.intern("data_key"),
     "default": sys.intern("default"),
     "DELETE": sys.intern("DELETE"),
+    "errors": sys.intern("errors"),
     "external_api": sys.intern("external_api"),
     "fallback": sys.intern("fallback"),
+    "fields": sys.intern("fields"),
     "filters": sys.intern("filters"),
     "GET": sys.intern("GET"),
+    "get": sys.intern("get"),
+    "headers": sys.intern("headers"),
+    "items": sys.intern("items"),
+    "json": sys.intern("json"),
+    "keys": sys.intern("keys"),
+    "method": sys.intern("method"),
+    "name": sys.intern("name"),
+    "params": sys.intern("params"),
     "PATCH": sys.intern("PATCH"),
     "POST": sys.intern("POST"),
     "PUT": sys.intern("PUT"),
     "required": sys.intern("required"),
+    "status_code": sys.intern("status_code"),
     "steps": sys.intern("steps"),
-    "validators": sys.intern("validators"),
-    "data": sys.intern("data"),
-    "errors": sys.intern("errors"),
+    "text": sys.intern("text"),
+    "url": sys.intern("url"),
+    "validate": sys.intern("validate"),
     "validated_data": sys.intern("validated_data"),
-    "fields": sys.intern("fields"),
-    "name": sys.intern("name"),
+    "validators": sys.intern("validators"),
     "value": sys.intern("value"),
+    "values": sys.intern("values"),
 }
 
 cdef extern from "helper.h":
-    vector[string] make_default_methods()
+    unordered_set[string] make_default_methods_set()
 
 T = TypeVar("T")
 
@@ -55,7 +76,7 @@ cdef class InputFilter:
     """
 
     def __cinit__(self) -> None:
-        self.methods = make_default_methods()
+        self.methods = make_default_methods_set()
         self.fields = {}
         self.conditions = []
         self.global_filters = []
@@ -66,9 +87,11 @@ cdef class InputFilter:
         self.model_class: Optional[Type[T]] = None
 
     def __init__(self, methods: Optional[list[str]] = None) -> None:
+        cdef str method
         if methods is not None:
             self.methods.clear()
-            [self.methods.push_back(method.encode()) for method in methods]
+            for method in methods:
+                self.methods.insert(method.encode())
 
     cpdef bint is_valid(self):
         """
@@ -134,13 +157,7 @@ cdef class InputFilter:
                 cdef:
                     InputFilter input_filter = cls()
                     string request_method = request.method.encode()
-                    Py_ssize_t i, n = input_filter.methods.size()
-                    bint method_allowed = False
-
-                for i in range(n):
-                    if request_method == input_filter.methods[i]:
-                        method_allowed = True
-                        break
+                    bint method_allowed = input_filter.methods.count(request_method) > 0
 
                 if not method_allowed:
                     return Response(status=405, response="Method Not Allowed")
@@ -332,8 +349,8 @@ cdef class InputFilter:
             object value
 
         for i in range(n):
-            field = field_names[i]
-            value = self.data.get(field)
+            field = <str>field_names[i]
+            value = self.data.get(field, None)
             if value is not None:
                 result[field] = value
         return result

flask_inputfilter/conditions/__init__.py

@@ -2,13 +2,17 @@
 
 from .array_length_equal_condition import ArrayLengthEqualCondition
 from .array_longer_than_condition import ArrayLongerThanCondition
+
+# New conditions
+from .at_least_one_required_condition import AtLeastOneRequiredCondition
 from .custom_condition import CustomCondition
 from .equal_condition import EqualCondition
 from .exactly_n_of_condition import ExactlyNOfCondition
 from .exactly_n_of_matches_condition import ExactlyNOfMatchesCondition
 from .exactly_one_of_condition import ExactlyOneOfCondition
 from .exactly_one_of_matches_condition import ExactlyOneOfMatchesCondition
 from .integer_bigger_than_condition import IntegerBiggerThanCondition
+from .mutually_exclusive_condition import MutuallyExclusiveCondition
 from .n_of_condition import NOfCondition
 from .n_of_matches_condition import NOfMatchesCondition
 from .not_equal_condition import NotEqualCondition
@@ -37,4 +41,7 @@
     "RequiredIfCondition",
     "StringLongerThanCondition",
     "TemporalOrderCondition",
+    # New conditions
+    "AtLeastOneRequiredCondition",
+    "MutuallyExclusiveCondition",
 ]

flask_inputfilter/conditions/at_least_one_required_condition.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+"""At least one field required condition."""
+
+from typing import Any, Dict, List, Optional
+
+from flask_inputfilter.models import BaseCondition
+
+
+class AtLeastOneRequiredCondition(BaseCondition):
+    """
+    Ensures that at least one field from a list is present.
+
+    This condition validates that at least one field from a specified list of
+    fields is present and has a non-empty value.
+    """
+
+    def __init__(
+        self,
+        fields: List[str],
+        min_required: int = 1,
+        check_empty: bool = True,
+        custom_message: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize the at least one required condition.
+
+        Args:
+            fields: List of field names to check
+            min_required: Minimum number of fields that must be present
+            check_empty: Whether to consider empty strings as absent
+            custom_message: Custom error message
+
+        Example:
+            # At least one contact method required
+            AtLeastOneRequiredCondition(['email', 'phone', 'address'])
+        """
+        self.fields = fields
+        self.min_required = min_required
+        self.check_empty = check_empty
+        self.custom_message = custom_message
+
+    def check(self, data: Dict[str, Any]) -> bool:
+        """
+        Check if at least the minimum required fields are present.
+
+        Args:
+            data: The validated data dictionary
+
+        Returns:
+            True if condition is met, False otherwise
+        """
+        if not isinstance(data, dict):
+            return False
+
+        present_count = 0
+
+        for field in self.fields:
+            if field in data and data[field] is not None:
+                if self.check_empty and isinstance(data[field], str):
+                    if data[field].strip() == "":
+                        continue
+
+                if self.check_empty and isinstance(data[field], (list, dict)):
+                    if len(data[field]) == 0:
+                        continue
+
+                present_count += 1
+
+        return present_count >= self.min_required
+
+    def get_error_message(self, data: Dict[str, Any]) -> str:
+        """
+        Get a descriptive error message.
+
+        Args:
+            data: The validated data dictionary
+
+        Returns:
+            Error message string
+        """
+        if self.custom_message:
+            return self.custom_message
+
+        present_fields = []
+        missing_fields = []
+
+        for field in self.fields:
+            if field in data and data[field] is not None:
+                if self.check_empty:
+                    if (
+                        isinstance(data[field], str)
+                        and data[field].strip() == ""
+                    ) or (
+                        isinstance(data[field], (list, dict))
+                        and len(data[field]) == 0
+                    ):
+                        missing_fields.append(field)
+                    else:
+                        present_fields.append(field)
+                else:
+                    present_fields.append(field)
+            else:
+                missing_fields.append(field)
+
+        if self.min_required == 1:
+            return (
+                f"At least one of the following fields is required: {', '.join(self.fields)}. "
+                f"None were provided or all were empty."
+            )
+        return (
+            f"At least {self.min_required} of the following fields are required: "
+            f"{', '.join(self.fields)}. Only {len(present_fields)} provided."
+        )