Merge pull request #105 from oda02/convert-query-params-fix

fix: added _is_sequence() to support more sequence types in models and tests for new cases

Author: stv8

.github/workflows/tests.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
         os: [ubuntu-latest, macOS-latest]
         # Python 3.7 is not supported on Apple ARM64,
         # or the latest Ubuntu 2404

flask_pydantic/converters.py

@@ -1,4 +1,6 @@
-from typing import Type, Union
+import types
+from collections import deque
+from typing import Deque, FrozenSet, List, Sequence, Set, Tuple, Type, Union
 
 try:
     from typing import get_args, get_origin
@@ -10,15 +12,29 @@
 from werkzeug.datastructures import ImmutableMultiDict
 
 V1OrV2BaseModel = Union[BaseModel, V1BaseModel]
+UnionType = getattr(types, "UnionType", Union)
 
+sequence_types = {
+    Sequence,
+    List,
+    list,
+    Tuple,
+    tuple,
+    Set,
+    set,
+    FrozenSet,
+    frozenset,
+    Deque,
+    deque,
+}
 
-def _is_list(type_: Type) -> bool:
-    origin = get_origin(type_)
-    if origin is list:
-        return True
-    if origin is Union:
-        return any(_is_list(t) for t in get_args(type_))
-    return False
+
+def _is_sequence(type_: Type) -> bool:
+    origin = get_origin(type_) or type_
+    if origin is Union or origin is UnionType:
+        return any(_is_sequence(t) for t in get_args(type_))
+
+    return origin in sequence_types and origin not in (str, bytes)
 
 
 def convert_query_params(
@@ -38,7 +54,7 @@ def convert_query_params(
                 key: value
                 for key, value in query_params.to_dict(flat=False).items()
                 if key in model.model_fields
-                and _is_list(model.model_fields[key].annotation)
+                and _is_sequence(model.model_fields[key].annotation)
             },
         }
     else:

tests/unit/test_core.py

@@ -1,5 +1,6 @@
 import re
-from typing import Any, List, NamedTuple, Optional, Type, Union
+import sys
+from typing import Any, List, NamedTuple, Optional, Tuple, Type, Union
 
 import pytest
 from flask import jsonify
@@ -15,13 +16,18 @@
 from ..util import assert_matches
 
 
+class EmptyModel(BaseModel):
+    pass
+
+
 class ValidateParams(NamedTuple):
-    body_model: Optional[Type[BaseModel]] = None
-    query_model: Optional[Type[BaseModel]] = None
-    form_model: Optional[Type[BaseModel]] = None
-    response_model: Type[BaseModel] = None
+    body_model: Type[BaseModel] = EmptyModel
+    query_model: Type[BaseModel] = EmptyModel
+    form_model: Type[BaseModel] = EmptyModel
+    response_model: Type[BaseModel] = EmptyModel
     on_success_status: int = 200
     request_query: ImmutableMultiDict = ImmutableMultiDict({})
+    flat_request_query: bool = True
     request_body: Union[dict, List[dict]] = {}
     request_form: ImmutableMultiDict = ImmutableMultiDict({})
     expected_response_body: Optional[dict] = None
@@ -50,7 +56,25 @@ class RequestBodyModel(BaseModel):
 
 class FormModel(BaseModel):
     f1: int
-    f2: str = None
+    f2: Optional[str] = None
+
+
+class RequestWithIterableModel(BaseModel):
+    b1: List
+    b2: List[str]
+    b3: Tuple[str, int]
+    b4: Optional[List[int]] = None
+    b5: Union[Tuple[str, int], None] = None
+
+
+if sys.version_info >= (3, 10):
+    # New Python(>=3.10) syntax tests
+    class RequestWithIterableModelPy310(BaseModel):
+        b1: list
+        b2: list[str]
+        b3: tuple[str, int]
+        b4: list[int] | None = None
+        b5: tuple[str, int] | None = None
 
 
 class RequestBodyModelRoot(RootModel):
@@ -195,8 +219,76 @@ class RequestBodyModelRoot(RootModel):
         ),
         id="invalid form param",
     ),
+    pytest.param(
+        ValidateParams(
+            request_query=ImmutableMultiDict(
+                [
+                    ("b1", "str1"),
+                    ("b1", "str2"),
+                    ("b2", "str1"),
+                    ("b2", "str2"),
+                    ("b3", "str"),
+                    ("b3", 123),
+                    ("b4", 1),
+                    ("b4", 2),
+                    ("b4", 3),
+                    ("b5", "str"),
+                    ("b5", 321),
+                ]
+            ),
+            flat_request_query=False,
+            expected_response_body={
+                "b1": ["str1", "str2"],
+                "b2": ["str1", "str2"],
+                "b3": ("str", 123),
+                "b4": [1, 2, 3],
+                "b5": ("str", 321),
+            },
+            query_model=RequestWithIterableModel,
+            response_model=RequestWithIterableModel,
+            expected_status_code=200,
+        ),
+        id="iterable and Optional[Iterable] fields in pydantic model in query",
+    ),
 ]
 
+if sys.version_info >= (3, 10):
+    validate_test_cases.extend(
+        [
+            pytest.param(
+                ValidateParams(
+                    request_query=ImmutableMultiDict(
+                        [
+                            ("b1", "str1"),
+                            ("b1", "str2"),
+                            ("b2", "str1"),
+                            ("b2", "str2"),
+                            ("b3", "str"),
+                            ("b3", 123),
+                            ("b4", 1),
+                            ("b4", 2),
+                            ("b4", 3),
+                            ("b5", "str"),
+                            ("b5", 321),
+                        ]
+                    ),
+                    flat_request_query=False,
+                    expected_response_body={
+                        "b1": ["str1", "str2"],
+                        "b2": ["str1", "str2"],
+                        "b3": ("str", 123),
+                        "b4": [1, 2, 3],
+                        "b5": ("str", 321),
+                    },
+                    query_model=RequestWithIterableModelPy310,
+                    response_model=RequestWithIterableModelPy310,
+                    expected_status_code=200,
+                ),
+                id="iterable and Iterable | None fields in pydantic model in query (Python 3.10+)",
+            ),
+        ]
+    )
+
 
 class TestValidate:
     @pytest.mark.parametrize("parameters", validate_test_cases)
@@ -230,17 +322,17 @@ def f():
         assert response.status_code == parameters.expected_status_code
         assert_matches(parameters.expected_response_body, response.json)
         if 200 <= response.status_code < 300:
-            assert (
+            assert_matches(
+                parameters.request_body,
                 mock_request.body_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_body
+                ),
             )
-            assert (
+            assert_matches(
+                parameters.request_query.to_dict(flat=parameters.flat_request_query),
                 mock_request.query_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_query.to_dict()
+                ),
             )
 
     @pytest.mark.parametrize("parameters", validate_test_cases)
@@ -269,17 +361,17 @@ def f(
         assert_matches(parameters.expected_response_body, response.json)
         assert response.status_code == parameters.expected_status_code
         if 200 <= response.status_code < 300:
-            assert (
+            assert_matches(
+                parameters.request_body,
                 mock_request.body_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_body
+                ),
             )
-            assert (
+            assert_matches(
+                parameters.request_query.to_dict(flat=parameters.flat_request_query),
                 mock_request.query_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_query.to_dict()
+                ),
             )
 
     @pytest.mark.usefixtures("request_ctx")
@@ -468,17 +560,17 @@ def f() -> Any:
         assert response.status_code == parameters.expected_status_code
         assert_matches(parameters.expected_response_body, response.json)
         if 200 <= response.status_code < 300:
-            assert (
+            assert_matches(
+                parameters.request_body,
                 mock_request.body_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_body
+                ),
             )
-            assert (
+            assert_matches(
+                parameters.request_query.to_dict(flat=parameters.flat_request_query),
                 mock_request.query_params.model_dump(
                     exclude_none=True, exclude_defaults=True
-                )
-                == parameters.request_query.to_dict()
+                ),
             )
 
     def test_fail_validation_custom_status_code(self, app, request_ctx, mocker):

tests/util.py

@@ -21,7 +21,7 @@ def assert_matches(expected: ExpectedType, actual: ActualType):
         assert set(expected.keys()) == set(actual.keys())
         for key, value in expected.items():
             assert_matches(value, actual[key])
-    elif isinstance(expected, list):
+    elif isinstance(expected, (list, tuple)):
         assert len(expected) == len(actual)
         for a, b in zip(expected, actual):
             assert_matches(a, b)