Added _is_sequence() and tests for new cases

Author: oda02

.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,11 +16,15 @@
 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({})
     request_body: Union[dict, List[dict]] = {}
@@ -50,7 +55,23 @@ class RequestBodyModel(BaseModel):
 
 class FormModel(BaseModel):
     f1: int
-    f2: str = None
+    f2: Optional[str] = None
+
+
+class RequestBodyWithIterableModel(BaseModel):
+    b1: List[str]
+    b2: Tuple[str, int]
+    b3: Optional[List[int]] = None
+    b4: Union[Tuple[str, int], None] = None
+
+
+if sys.version_info >= (3, 10):
+    # New Python(>=3.10) syntax tests
+    class RequestBodyWithIterableModelPy310(BaseModel):
+        b1: list[str]
+        b2: tuple[str, int]
+        b3: list[int] | None = None
+        b4: tuple[str, int] | None = None
 
 
 class RequestBodyModelRoot(RootModel):
@@ -195,8 +216,54 @@ class RequestBodyModelRoot(RootModel):
         ),
         id="invalid form param",
     ),
+    pytest.param(
+        ValidateParams(
+            body_model=RequestBodyWithIterableModel,
+            request_body={
+                "b1": ["str1", "str1"],
+                "b2": ("str", 123),
+                "b3": [1, 2, 3],
+                "b4": ("str", 321),
+            },
+            expected_response_body={
+                "b1": ["str1", "str1"],
+                "b2": ("str", 123),
+                "b3": [1, 2, 3],
+                "b4": ("str", 321),
+            },
+            response_model=RequestBodyWithIterableModel,
+            expected_status_code=200,
+        ),
+        id="ASASD",
+    ),
 ]
 
+if sys.version_info >= (3, 10):
+    validate_test_cases.extend(
+        [
+            pytest.param(
+                ValidateParams(
+                    body_model=RequestBodyWithIterableModelPy310,
+                    request_body={
+                        "b1": ["str1", "str1"],
+                        "b2": ("str", 123),
+                        "b3": [1, 2, 3],
+                        "b4": ("str", 321),
+                    },
+                    expected_response_body={
+                        "b1": ["str1", "str1"],
+                        "b2": ("str", 123),
+                        "b3": [1, 2, 3],
+                        "b4": ("str", 321),
+                    },
+                    response_model=RequestBodyWithIterableModelPy310,
+                    expected_status_code=200,
+                ),
+                id="ASASD",
+            ),
+        ]
+    )
+
 
 class TestValidate:
     @pytest.mark.parametrize("parameters", validate_test_cases)

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)