starmallow 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

starmallow/params.py

@@ -1,10 +1,10 @@
 import logging
+from collections.abc import Callable, Iterable, Sequence
 from enum import Enum
-from typing import Any, Callable, Dict, Iterable, Optional, Sequence
+from typing import Any, ClassVar
 
 import marshmallow as ma
 import marshmallow.fields as mf
-from marshmallow.utils import is_iterable_but_not_string
 from marshmallow.validate import Length, Range, Regexp
 
 from starmallow.security.base import SecurityBaseResolver
@@ -27,17 +27,17 @@ class ParamType(Enum):
 
 
 class Param:
-    in_: ParamType = None
+    in_: ClassVar[ParamType]
 
     def __init__(
         self,
         default: Any = Ellipsis,
         *,
         # alias to look the param up by.
-        alias: Optional[str] = None,
+        alias: str | None = None,
         deprecated: bool | None = None,
         include_in_schema: bool = True,
-        model: ma.Schema | mf.Field = None,
+        model: ma.Schema | mf.Field | None = None,
         validators: None
         | (
             Callable[[Any], Any]
@@ -52,7 +52,7 @@ class Param:
         max_length: int | None = None,
         regex: str | None = None,
         # OpenAPI title
-        title: str = None,
+        title: str | None = None,
     ) -> None:
         self.default = default
         self.deprecated = deprecated
@@ -79,7 +79,7 @@ class Param:
             self.validators.append(Regexp(regex))
 
         if validators:
-            if is_iterable_but_not_string(validators):
+            if isinstance(validators, Iterable) and not isinstance(validators, str):
                 self.validators += validators
             elif callable(validators):
                 self.validators.append(validators)
@@ -89,7 +89,7 @@ class Param:
         if self.model and getattr(self.model, 'validators', None) and self.validators:
             logger.warning('Provided validators will override model validators')
 
-    def __eq__(self, other: "Param") -> bool:
+    def __eq__(self, other: "object | Param") -> bool:
         return (
             isinstance(other, Param)
             and self.__class__ == other.__class__
@@ -120,10 +120,10 @@ class Header(Param):
         default: Any = Ellipsis,
         *,
         # alias to look the param up by.
-        alias: Optional[str] = None,
+        alias: str | None = None,
         deprecated: bool | None = None,
         include_in_schema: bool = True,
-        model: ma.Schema | mf.Field = None,
+        model: ma.Schema | mf.Field | None = None,
         validators: None
         | (
             Callable[[Any], Any]
@@ -138,7 +138,7 @@ class Header(Param):
         max_length: int | None = None,
         regex: str | None = None,
         # OpenAPI title
-        title: str = None,
+        title: str | None = None,
         convert_underscores: bool = True,
     ) -> None:
         self.convert_underscores = convert_underscores
@@ -174,7 +174,7 @@ class Body(Param):
         media_type: str = "application/json",
         deprecated: bool | None = None,
         include_in_schema: bool = True,
-        model: ma.Schema | mf.Field = None,
+        model: ma.Schema | mf.Field | None = None,
         validators: None
         | (
             Callable[[Any], Any]
@@ -188,7 +188,7 @@ class Body(Param):
         min_length: int | None = None,
         max_length: int | None = None,
         regex: str | None = None,
-        title: str = None,
+        title: str | None = None,
     ) -> None:
         super().__init__(
             default=default,
@@ -218,7 +218,7 @@ class Form(Body):
         media_type: str = "application/x-www-form-urlencoded",
         deprecated: bool | None = None,
         include_in_schema: bool = True,
-        model: ma.Schema | mf.Field = None,
+        model: ma.Schema | mf.Field | None = None,
         validators: None
         | (
             Callable[[Any], Any]
@@ -232,7 +232,7 @@ class Form(Body):
         min_length: int | None = None,
         max_length: int | None = None,
         regex: str | None = None,
-        title: str = None,
+        title: str | None = None,
     ) -> None:
         super().__init__(
             default=default,
@@ -259,14 +259,13 @@ class NoParam:
 
         Arguments will not be added to Swagger docs or be validated in any way.
     '''
-    pass
 
 
 class ResolvedParam:
-    def __init__(self, resolver: Callable[[Any], Any] = None, use_cache: bool = True):
+    def __init__(self, resolver: Callable[[Any], Any] | None = None, use_cache: bool = True):
         self.resolver = resolver
         # Set when we resolve the routes in the EnpointMixin
-        self.resolver_params: Dict[ParamType, Dict[str, Param]] = {}
+        self.resolver_params: dict[ParamType, dict[str, Param]] = {}
         self.use_cache = use_cache
         self.cache_key = (self.resolver, None)
 
@@ -275,14 +274,14 @@ class Security(ResolvedParam):
 
     def __init__(
         self,
-        resolver: SecurityBaseResolver = None,
-        scopes: Optional[Sequence[str]] = None,
+        resolver: SecurityBaseResolver | None = None,
+        scopes: Sequence[str] | None = None,
         use_cache: bool = True,
     ):
         # Not calling super so that the resolver typehinting actually works in VSCode
         self.resolver = resolver
         # Set when we resolve the routes in the EnpointMixin
-        self.resolver_params: Dict[ParamType, Dict[str, Param]] = {}
+        self.resolver_params: dict[ParamType, dict[str, Param]] = {}
         self.scopes = scopes or []
         self.use_cache = use_cache
         self.cache_key = (self.resolver, tuple(sorted(set(self.scopes or []))))

starmallow/request_resolver.py

@@ -1,12 +1,14 @@
 import asyncio
 import inspect
 import logging
+from collections.abc import Callable, Mapping
 from contextlib import AsyncExitStack
-from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
+from typing import Any, cast
 
 import marshmallow as ma
 import marshmallow.fields as mf
 from marshmallow.error_store import ErrorStore
+from marshmallow.exceptions import SCHEMA
 from marshmallow.utils import missing as missing_
 from starlette.background import BackgroundTasks as StarletteBackgroundTasks
 from starlette.datastructures import FormData, Headers, QueryParams
@@ -17,6 +19,7 @@ from starlette.websockets import WebSocket
 
 from starmallow.background import BackgroundTasks
 from starmallow.params import Param, ParamType, ResolvedParam
+from starmallow.security.base import SecurityBaseResolver
 from starmallow.utils import (
     is_async_gen_callable,
     is_gen_callable,
@@ -29,9 +32,9 @@ logger = logging.getLogger(__name__)
 
 async def get_body(
     request: Request,
-    form_params: Dict[str, Param],
-    body_params: Dict[str, Param],
-) -> Union[FormData, bytes, Dict[str, Any]]:
+    form_params: Mapping[str, Param],
+    body_params: Mapping[str, Param],
+) -> FormData | bytes | dict[str, Any]:
     is_body_form = bool(form_params)
     should_process_body = is_body_form or body_params
     try:
@@ -46,18 +49,14 @@ async def get_body(
                 body_bytes = await request.body()
                 if body_bytes:
                     json_body: Any = missing_
-                    content_type_value: str = request.headers.get("content-type")
+                    content_type_value = request.headers.get("content-type")
                     if not content_type_value:
                         json_body = await request.json()
                     else:
                         main_type, sub_type = content_type_value.split(';')[0].split('/')
-                        if main_type == "application":
-                            if sub_type == "json" or sub_type.endswith("+json"):
-                                json_body = await request.json()
-                    if json_body != missing_:
-                        body = json_body
-                    else:
-                        body = body_bytes
+                        if main_type == "application" and (sub_type == "json" or sub_type.endswith("+json")):
+                            json_body = await request.json()
+                    body = json_body if json_body != missing_ else body_bytes
 
         return body
     except Exception as e:
@@ -67,17 +66,20 @@ async def get_body(
 
 
 def request_params_to_args(
-    received_params: Union[Mapping[str, Any], QueryParams, Headers],
-    endpoint_params: Dict[str, Param],
+    received_params: Mapping[str, Any] | QueryParams | Headers | None,
+    endpoint_params: Mapping[str, Param] | None,
     ignore_namespace: bool = True,
-) -> Tuple[Dict[str, Any], ErrorStore]:
+) -> tuple[dict[str, Any], ErrorStore]:
+    received_params = received_params or {}
+    endpoint_params = endpoint_params or {}
     values = {}
     error_store = ErrorStore()
     for field_name, param in endpoint_params.items():
-        if not param.alias and getattr(param, "convert_underscores", None):
-            alias = field_name.replace("_", "-")
-        else:
-            alias = param.alias or field_name
+        alias = (
+            field_name.replace("_", "-")
+            if not param.alias and getattr(param, "convert_underscores", None)
+            else param.alias or field_name
+        )
 
         if isinstance(param.model, mf.Field):
             try:
@@ -91,20 +93,20 @@ def request_params_to_args(
                 error_store.store_error(error.messages, field_name)
         elif isinstance(param.model, ma.Schema):
             try:
-                load_params = received_params if ignore_namespace else received_params.get(alias, {})
+                load_params = received_params if ignore_namespace else received_params.get(alias) or {}
 
                 # Entire model is optional and no data was passed in.
                 if getattr(param.model, 'required', None) is False and not load_params:
                     values[field_name] = None
                 else:
-                    values[field_name] = param.model.load(load_params, unknown=ma.EXCLUDE)
+                    values[field_name] = param.model.load(cast(Mapping, load_params), unknown=ma.EXCLUDE)
 
             except ma.ValidationError as error:
                 # Entire model is optional, so ignore errors
                 if getattr(param.model, 'required', None) is False:
                     values[field_name] = None
                 else:
-                    error_store.store_error(error.messages)
+                    error_store.store_error(error.messages, field_name=SCHEMA if ignore_namespace else field_name)
         else:
             raise Exception(f'Invalid model type {type(param.model)}, expected marshmallow Schema or Field')
 
@@ -115,8 +117,8 @@ async def resolve_basic_args(
     request: Request | WebSocket,
     response: Response,
     background_tasks: StarletteBackgroundTasks,
-    params: Dict[ParamType, Dict[str, Param]],
-):
+    params: Mapping[ParamType, Mapping[str, Param]],
+) -> tuple[dict[str, Any], dict[str, Any | list | dict]]:
     path_values, path_errors = request_params_to_args(
         request.path_params,
         params.get(ParamType.path),
@@ -134,27 +136,28 @@ async def resolve_basic_args(
         params.get(ParamType.cookie),
     )
 
-    form_params = params.get(ParamType.form)
-    body_params = params.get(ParamType.body)
-    body = await get_body(request, form_params, body_params)
     form_values, form_errors = {}, None
     json_values, json_errors = {}, None
-    if form_params:
-        form_values, form_errors = request_params_to_args(
-            body if body is not None and isinstance(body, FormData) else {},
-            form_params,
-            # If there is only one parameter defined, then don't namespace by the parameter name
-            # Otherwise we honor the namespace: https://fastapi.tiangolo.com/tutorial/body-multiple-params/
-            ignore_namespace=len(form_params) == 1,
-        )
-    if body_params:
-        json_values, json_errors = request_params_to_args(
-            body if body is not None and isinstance(body, Mapping) else {},
-            body_params,
-            # If there is only one parameter defined, then don't namespace by the parameter name
-            # Otherwise we honor the namespace: https://fastapi.tiangolo.com/tutorial/body-multiple-params/
-            ignore_namespace=len(body_params) == 1,
-        )
+    if isinstance(request, Request):
+        form_params = params.get(ParamType.form) or {}
+        body_params = params.get(ParamType.body) or {}
+        body = await get_body(request, form_params, body_params)
+        if form_params:
+            form_values, form_errors = request_params_to_args(
+                body if body is not None and isinstance(body, FormData) else {},
+                form_params,
+                # If there is only one parameter defined, then don't namespace by the parameter name
+                # Otherwise we honor the namespace: https://fastapi.tiangolo.com/tutorial/body-multiple-params/
+                ignore_namespace=len(form_params) == 1,
+            )
+        if body_params:
+            json_values, json_errors = request_params_to_args(
+                body if body is not None and isinstance(body, Mapping) else {},
+                body_params,
+                # If there is only one parameter defined, then don't namespace by the parameter name
+                # Otherwise we honor the namespace: https://fastapi.tiangolo.com/tutorial/body-multiple-params/
+                ignore_namespace=len(body_params) == 1,
+            )
 
     values = {
         **path_values,
@@ -179,7 +182,7 @@ async def resolve_basic_args(
         errors['json'] = json_errors.errors
 
     # Handle non-field params
-    for param_name, param_type in params.get(ParamType.noparam).items():
+    for param_name, param_type in (params.get(ParamType.noparam) or {}).items():
         if lenient_issubclass(param_type, (HTTPConnection, Request, WebSocket)):
             values[param_name] = request
         elif lenient_issubclass(param_type, Response):
@@ -194,12 +197,12 @@ async def call_resolver(
     request: Request | WebSocket,
     param_name: str,
     resolved_param: ResolvedParam,
-    resolver_kwargs: Dict[str, Any],
+    resolver_kwargs: dict[str, Any],
 ):
     # Resolver can be a class with __call__ function
     resolver = resolved_param.resolver
     if not inspect.isfunction(resolver) and callable(resolver):
-        resolver = resolver.__call__
+        resolver = resolver.__call__  # type: ignore
     elif not inspect.isfunction(resolver):
         raise TypeError(f'{param_name} = {resolved_param} resolver is not a function or callable')
 
@@ -219,10 +222,11 @@ async def resolve_subparams(
     request: Request | WebSocket,
     response: Response,
     background_tasks: StarletteBackgroundTasks,
-    params: Dict[str, ResolvedParam],
-    dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]],
-) -> Dict[str, Any]:
+    params: Mapping[str, ResolvedParam] | None,
+    dependency_cache: dict[tuple[Callable[..., Any] | SecurityBaseResolver | None, tuple[str, ...] | None], Any],
+) -> tuple[dict[str, Any], dict[str, Any | list | dict]]:
     values = {}
+    params = params or {}
     for param_name, resolved_param in params.items():
         if resolved_param.use_cache and resolved_param.cache_key in dependency_cache:
             values[param_name] = dependency_cache[resolved_param.cache_key]
@@ -238,9 +242,9 @@ async def resolve_subparams(
 
         # Exit early since other resolvers may rely on this one, which could raise argument exceptions
         if resolver_errors:
-            return None, resolver_errors
+            return {}, resolver_errors
 
-        resolved_value = await call_resolver(request, param_name, resolved_param, resolver_kwargs)
+        resolved_value = await call_resolver(request, param_name, resolved_param, resolver_kwargs or {})
         values[param_name] = resolved_value
         if resolved_param.use_cache:
             dependency_cache[resolved_param.cache_key] = resolved_value
@@ -250,11 +254,11 @@ async def resolve_subparams(
 
 async def resolve_params(
     request: Request | WebSocket,
-    params: Dict[ParamType, Dict[str, Param]],
-    background_tasks: Optional[StarletteBackgroundTasks] = None,
-    response: Optional[Response] = None,
-    dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]] = None,
-) -> Tuple[Dict[str, Any], Dict[str, Union[Any, List, Dict]], StarletteBackgroundTasks, Response]:
+    params: Mapping[ParamType, Mapping[str, Param]],
+    background_tasks: StarletteBackgroundTasks | None = None,
+    response: Response | None = None,
+    dependency_cache: dict[tuple[Callable[..., Any] | SecurityBaseResolver | None, tuple[str, ...] | None], Any] | None = None,
+) -> tuple[dict[str, Any] | None, dict[str, Any | list | dict], StarletteBackgroundTasks, Response]:
     dependency_cache = dependency_cache or {}
 
     if response is None:
@@ -270,7 +274,7 @@ async def resolve_params(
         request,
         response,
         background_tasks,
-        params.get(ParamType.security),
+        params.get(ParamType.security), # type: ignore
         dependency_cache=dependency_cache,
     )
     if errors:
@@ -289,7 +293,7 @@ async def resolve_params(
         request,
         response,
         background_tasks,
-        params.get(ParamType.resolved),
+        params.get(ParamType.resolved), # type: ignore
         dependency_cache=dependency_cache,
     )
     if errors:

starmallow/responses.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any
 
 import marshmallow as ma
 import marshmallow.fields as mf
@@ -21,14 +21,15 @@ except ImportError:  # pragma: nocover
 
 
 class JSONResponse(StarJSONResponse):
+    media_type = "application/json"
 
     def __init__(
         self,
         content: Any,
         status_code: int = 200,
-        headers: Optional[Dict[str, str]] = None,
-        media_type: Optional[str] = None,
-        background: Optional[BackgroundTask] = None,
+        headers: dict[str, str] | None = None,
+        media_type: str | None = None,
+        background: BackgroundTask | None = None,
     ) -> None:
         super().__init__(content, status_code, headers, media_type, background)