starmallow 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

starmallow/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.1"
+__version__ = "0.3.3"
 
 from .applications import StarMallow
 from .exceptions import RequestValidationError

starmallow/applications.py

@@ -135,10 +135,13 @@ class StarMallow(Starlette):
         ] = {}
 
         for key, value in self.exception_handlers.items():
+            # Ensure we handle any middleware exceptions using the Exception handler
+            # But also ensure we don't fall through all middlewares if the route itself threw an Exception
+            # As this would result in an incredibly long stacktrace
             if key in (500, Exception):
                 error_handler = value
-            else:
-                exception_handlers[key] = value
+
+            exception_handlers[key] = value
 
         middleware = (
             [Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug)]

starmallow/endpoint.py

@@ -45,6 +45,8 @@ from starmallow.utils import (
     get_args,
     get_model_field,
     get_path_param_names,
+    get_typed_return_annotation,
+    get_typed_signature,
     is_marshmallow_dataclass,
     is_marshmallow_field,
     is_marshmallow_schema,
@@ -255,7 +257,7 @@ class EndpointMixin:
             try:
                 return get_model_field(model, **kwargs)
             except Exception as e:
-                raise Exception(f'Unknown model type for parameter {parameter_name}, model is {model}') from e
+                raise Exception(f'Unknown model type for parameter {parameter_name}, model is {model}, {type(model)}') from e
 
     def get_resolved_param(self, resolved_param: ResolvedParam, annotation: Any, path: str) -> ResolvedParam:
         # Supports `field = ResolvedParam(resolver_callable)
@@ -274,7 +276,7 @@ class EndpointMixin:
     ) -> Dict[ParamType, Dict[str, Param]]:
         path_param_names = get_path_param_names(path)
         params = {param_type: {} for param_type in ParamType}
-        for name, parameter in inspect.signature(func).parameters.items():
+        for name, parameter in get_typed_signature(func).parameters.items():
             default_value = parameter.default
 
             # The type annotation. i.e.: 'str' in these `value: str`. Or `value: [str, Query(gt=3)]`
@@ -316,15 +318,18 @@ class EndpointMixin:
                 or isinstance(starmallow_param, NoParam)
             ):
                 continue
+            elif isinstance(starmallow_param, Security):
+                security_param: Security = self.get_resolved_param(starmallow_param, type_annotation, path=path)
+                params[ParamType.security][name] = security_param
+                continue
             elif isinstance(starmallow_param, ResolvedParam):
                 resolved_param: ResolvedParam = self.get_resolved_param(starmallow_param, type_annotation, path=path)
-                params[ParamType.resolved][name] = resolved_param
 
-                if isinstance(starmallow_param, Security):
-                    params[ParamType.security][name] = resolved_param
-                # Allow `ResolvedParam(HTTPBearer())`
-                elif isinstance(resolved_param.resolver, SecurityBaseResolver):
+                # Allow `ResolvedParam(HTTPBearer())` - treat as securty param
+                if isinstance(resolved_param.resolver, SecurityBaseResolver):
                     params[ParamType.security][name] = resolved_param
+                else:
+                    params[ParamType.resolved][name] = resolved_param
 
                 continue
             elif lenient_issubclass(
@@ -394,7 +399,7 @@ class EndpointMixin:
     ) -> EndpointModel:
         params = self._get_params(endpoint, path)
 
-        response_model = create_response_model(response_model or inspect.signature(endpoint).return_annotation)
+        response_model = create_response_model(response_model or get_typed_return_annotation(endpoint))
 
         return EndpointModel(
             path=path,

starmallow/params.py

@@ -215,10 +215,12 @@ class NoParam:
 
 
 class ResolvedParam:
-    def __init__(self, resolver: Callable[[Any], Any] = None):
+    def __init__(self, resolver: Callable[[Any], Any] = 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.use_cache = use_cache
+        self.cache_key = (self.resolver, None)
 
 
 class Security(ResolvedParam):
@@ -227,9 +229,12 @@ class Security(ResolvedParam):
         self,
         resolver: SecurityBaseResolver = None,
         scopes: Optional[Sequence[str]] = 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.scopes = scopes or []
+        self.use_cache = use_cache
+        self.cache_key = (self.resolver, tuple(sorted(set(self.scopes or []))))

starmallow/request_resolver.py

@@ -0,0 +1,292 @@
+import asyncio
+import inspect
+import logging
+from contextlib import AsyncExitStack
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
+
+import marshmallow as ma
+import marshmallow.fields as mf
+from marshmallow.error_store import ErrorStore
+from marshmallow.utils import missing as missing_
+from starlette.background import BackgroundTasks
+from starlette.datastructures import FormData, Headers, QueryParams
+from starlette.exceptions import HTTPException
+from starlette.requests import HTTPConnection, Request
+from starlette.responses import Response
+from starlette.websockets import WebSocket
+
+from starmallow.params import Param, ParamType, ResolvedParam
+from starmallow.utils import (
+    is_async_gen_callable,
+    is_gen_callable,
+    lenient_issubclass,
+    solve_generator,
+)
+
+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]]:
+    is_body_form = bool(form_params)
+    should_process_body = is_body_form or body_params
+    try:
+        body: Any = None
+        if should_process_body:
+            if is_body_form:
+                body = await request.form()
+                stack = request.scope.get("starmallow_astack")
+                assert isinstance(stack, AsyncExitStack)
+                stack.push_async_callback(body.close)
+            else:
+                body_bytes = await request.body()
+                if body_bytes:
+                    json_body: Any = missing_
+                    content_type_value: str = request.headers.get("content-type")
+                    if not content_type_value:
+                        json_body = await request.json()
+                    else:
+                        main_type, sub_type = content_type_value.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
+
+        return body
+    except Exception as e:
+        raise HTTPException(
+            status_code=400, detail="There was an error parsing the body",
+        ) from e
+
+
+def request_params_to_args(
+    received_params: Union[Mapping[str, Any], QueryParams, Headers],
+    endpoint_params: Dict[str, Param],
+    ignore_namespace: bool = True,
+) -> Tuple[Dict[str, Any], ErrorStore]:
+    values = {}
+    error_store = ErrorStore()
+    for field_name, param in endpoint_params.items():
+        if isinstance(param.model, mf.Field):
+            try:
+                # Load model from specific param
+                values[field_name] = param.model.deserialize(
+                    received_params.get(field_name, ma.missing),
+                    field_name,
+                    received_params,
+                )
+            except ma.ValidationError as error:
+                error_store.store_error(error.messages, field_name)
+        elif isinstance(param.model, ma.Schema):
+            try:
+                if ignore_namespace:
+                    # Load model from entire params
+                    values[field_name] = param.model.load(received_params, unknown=ma.EXCLUDE)
+                else:
+                    values[field_name] = param.model.load(
+                        received_params.get(field_name, ma.missing),
+                        unknown=ma.EXCLUDE,
+                    )
+            except ma.ValidationError as error:
+                error_store.store_error(error.messages)
+        else:
+            raise Exception(f'Invalid model type {type(param.model)}, expected marshmallow Schema or Field')
+
+    return values, error_store
+
+
+async def resolve_basic_args(
+    request: Request | WebSocket,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    params: Dict[ParamType, Dict[str, Param]],
+):
+    path_values, path_errors = request_params_to_args(
+        request.path_params,
+        params.get(ParamType.path),
+    )
+    query_values, query_errors = request_params_to_args(
+        request.query_params,
+        params.get(ParamType.query),
+    )
+    header_values, header_errors = request_params_to_args(
+        request.headers,
+        params.get(ParamType.header),
+    )
+    cookie_values, cookie_errors = request_params_to_args(
+        request.cookies,
+        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,
+        )
+
+    values = {
+        **path_values,
+        **query_values,
+        **header_values,
+        **cookie_values,
+        **form_values,
+        **json_values,
+    }
+    errors = {}
+    if path_errors.errors:
+        errors['path'] = path_errors.errors
+    if query_errors.errors:
+        errors['query'] = query_errors.errors
+    if header_errors.errors:
+        errors['header'] = header_errors.errors
+    if cookie_errors.errors:
+        errors['cookie'] = cookie_errors.errors
+    if form_errors and form_errors.errors:
+        errors['form'] = form_errors.errors
+    if json_errors and json_errors.errors:
+        errors['json'] = json_errors.errors
+
+    # Handle non-field params
+    for param_name, param_type in params.get(ParamType.noparam).items():
+        if lenient_issubclass(param_type, (HTTPConnection, Request, WebSocket)):
+            values[param_name] = request
+        elif lenient_issubclass(param_type, Response):
+            values[param_name] = response
+        elif lenient_issubclass(param_type, BackgroundTasks):
+            values[param_name] = background_tasks
+
+    return values, errors
+
+
+async def call_resolver(
+    request: Request | WebSocket,
+    param_name: str,
+    resolved_param: ResolvedParam,
+    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__
+    elif not inspect.isfunction(resolver):
+        raise TypeError(f'{param_name} = {resolved_param} resolver is not a function or callable')
+
+    if is_gen_callable(resolver) or is_async_gen_callable(resolver):
+        stack = request.scope.get("starmallow_astack")
+        assert isinstance(stack, AsyncExitStack)
+        return await solve_generator(
+            call=resolver, stack=stack, gen_kwargs=resolver_kwargs,
+        )
+    elif asyncio.iscoroutinefunction(resolver):
+        return await resolver(**resolver_kwargs)
+    else:
+        return resolver(**resolver_kwargs)
+
+
+async def resolve_subparams(
+    request: Request | WebSocket,
+    response: Response,
+    background_tasks: BackgroundTasks,
+    params: Dict[str, ResolvedParam],
+    dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]],
+) -> Dict[str, Any]:
+    values = {}
+    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]
+            continue
+
+        resolver_kwargs, resolver_errors = await resolve_params(
+            request=request,
+            background_tasks=background_tasks,
+            response=response,
+            params=resolved_param.resolver_params,
+            dependency_cache=dependency_cache,
+        )
+
+        # Exit early since other resolvers may rely on this one, which could raise argument exceptions
+        if resolver_errors:
+            return None, resolver_errors
+
+        resolved_value = await call_resolver(request, param_name, resolved_param, resolver_kwargs)
+        values[param_name] = resolved_value
+        if resolved_param.use_cache:
+            dependency_cache[resolved_param.cache_key] = resolved_value
+
+    return values, {}
+
+
+async def resolve_params(
+    request: Request | WebSocket,
+    params: Dict[ParamType, Dict[str, Param]],
+    background_tasks: Optional[BackgroundTasks] = 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]]]:
+    dependency_cache = dependency_cache or {}
+
+    if response is None:
+        response = Response()
+        del response.headers["content-length"]
+        response.status_code = None  # type: ignore
+
+    if background_tasks is None:
+        background_tasks = BackgroundTasks()
+
+    # Process security params first so we can raise permission issues
+    security_values, errors = await resolve_subparams(
+        request,
+        response,
+        background_tasks,
+        params.get(ParamType.security),
+        dependency_cache=dependency_cache,
+    )
+    if errors:
+        return None, errors
+
+    arg_values, errors = await resolve_basic_args(
+        request,
+        response,
+        background_tasks,
+        params,
+    )
+    if errors:
+        return None, errors
+
+    resolved_values, errors = await resolve_subparams(
+        request,
+        response,
+        background_tasks,
+        params.get(ParamType.resolved),
+        dependency_cache=dependency_cache,
+    )
+    if errors:
+        return None, errors
+
+    return {
+        **security_values,
+        **arg_values,
+        **resolved_values,
+    }, {}

starmallow/routing.py

@@ -2,20 +2,13 @@ import asyncio
 import functools
 import inspect
 import logging
-from contextlib import AsyncExitStack
 from enum import Enum, IntEnum
-from typing import Any, Callable, Coroutine, Dict, List, Mapping, Optional, Set, Tuple, Type, Union
+from typing import Any, Callable, Coroutine, Dict, List, Optional, Set, Tuple, Type, Union
 
 import marshmallow as ma
-import marshmallow.fields as mf
-from marshmallow.error_store import ErrorStore
-from marshmallow.utils import missing as missing_
 from starlette import routing
-from starlette.background import BackgroundTasks
 from starlette.concurrency import run_in_threadpool
-from starlette.datastructures import FormData, Headers, QueryParams
-from starlette.exceptions import HTTPException
-from starlette.requests import HTTPConnection, Request
+from starlette.requests import Request
 from starlette.responses import Response
 from starlette.routing import BaseRoute, Match, compile_path, request_response
 from starlette.status import WS_1008_POLICY_VIOLATION
@@ -28,225 +21,24 @@ from starmallow.decorators import EndpointOptions
 from starmallow.endpoint import EndpointMixin, EndpointModel
 from starmallow.endpoints import APIHTTPEndpoint
 from starmallow.exceptions import RequestValidationError, WebSocketRequestValidationError
-from starmallow.params import Param, ParamType
+from starmallow.request_resolver import resolve_params
 from starmallow.responses import JSONResponse
 from starmallow.types import DecoratedCallable
 from starmallow.utils import (
     create_response_model,
     generate_unique_id,
     get_name,
+    get_typed_signature,
     get_value_or_default,
-    is_async_gen_callable,
     is_body_allowed_for_status_code,
-    is_gen_callable,
     is_marshmallow_field,
     is_marshmallow_schema,
-    lenient_issubclass,
-    solve_generator,
 )
 from starmallow.websockets import APIWebSocket
 
 logger = logging.getLogger(__name__)
 
 
-async def get_body(
-    request: Request,
-    endpoint_model: "EndpointModel",
-) -> Union[FormData, bytes, Dict[str, Any]]:
-    is_body_form = bool(endpoint_model.flat_params[ParamType.form])
-    should_process_body = is_body_form or endpoint_model.flat_params[ParamType.body]
-    try:
-        body: Any = None
-        if should_process_body:
-            if is_body_form:
-                body = await request.form()
-                stack = request.scope.get("starmallow_astack")
-                assert isinstance(stack, AsyncExitStack)
-                stack.push_async_callback(body.close)
-            else:
-                body_bytes = await request.body()
-                if body_bytes:
-                    json_body: Any = missing_
-                    content_type_value: str = request.headers.get("content-type")
-                    if not content_type_value:
-                        json_body = await request.json()
-                    else:
-                        main_type, sub_type = content_type_value.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
-
-        return body
-    except Exception as e:
-        raise HTTPException(
-            status_code=400, detail="There was an error parsing the body",
-        ) from e
-
-
-def request_params_to_args(
-    received_params: Union[Mapping[str, Any], QueryParams, Headers],
-    endpoint_params: Dict[str, Param],
-    ignore_namespace: bool = True,
-) -> Tuple[Dict[str, Any], ErrorStore]:
-    values = {}
-    error_store = ErrorStore()
-    for field_name, param in endpoint_params.items():
-        if isinstance(param.model, mf.Field):
-            try:
-                # Load model from specific param
-                values[field_name] = param.model.deserialize(
-                    received_params.get(field_name, ma.missing),
-                    field_name,
-                    received_params,
-                )
-            except ma.ValidationError as error:
-                error_store.store_error(error.messages, field_name)
-        elif isinstance(param.model, ma.Schema):
-            try:
-                if ignore_namespace:
-                    # Load model from entire params
-                    values[field_name] = param.model.load(received_params, unknown=ma.EXCLUDE)
-                else:
-                    values[field_name] = param.model.load(
-                        received_params.get(field_name, ma.missing),
-                        unknown=ma.EXCLUDE,
-                    )
-            except ma.ValidationError as error:
-                error_store.store_error(error.messages)
-        else:
-            raise Exception(f'Invalid model type {type(param.model)}, expected marshmallow Schema or Field')
-
-    return values, error_store
-
-
-async def get_request_args(
-    request: Request | WebSocket,
-    endpoint_model: EndpointModel,
-    background_tasks: Optional[BackgroundTasks] = None,
-    response: Optional[Response] = None,
-) -> Tuple[Dict[str, Any], Dict[str, Union[Any, List, Dict]]]:
-    path_values, path_errors = request_params_to_args(
-        request.path_params,
-        endpoint_model.path_params,
-    )
-    query_values, query_errors = request_params_to_args(
-        request.query_params,
-        endpoint_model.query_params,
-    )
-    header_values, header_errors = request_params_to_args(
-        request.headers,
-        endpoint_model.header_params,
-    )
-    cookie_values, cookie_errors = request_params_to_args(
-        request.cookies,
-        endpoint_model.cookie_params,
-    )
-
-    body = await get_body(request, endpoint_model)
-    form_values, form_errors = {}, None
-    json_values, json_errors = {}, None
-    form_params = endpoint_model.form_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,
-        )
-    body_params = endpoint_model.body_params
-    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,
-        **query_values,
-        **header_values,
-        **cookie_values,
-        **form_values,
-        **json_values,
-    }
-    errors = {}
-    if path_errors.errors:
-        errors['path'] = path_errors.errors
-    if query_errors.errors:
-        errors['query'] = query_errors.errors
-    if header_errors.errors:
-        errors['header'] = header_errors.errors
-    if cookie_errors.errors:
-        errors['cookie'] = cookie_errors.errors
-    if form_errors and form_errors.errors:
-        errors['form'] = form_errors.errors
-    if json_errors and json_errors.errors:
-        errors['json'] = json_errors.errors
-
-    # Exit before resolving ResolvedParams as that could cause function call exceptions
-    if errors:
-        return None, errors
-
-    if response is None:
-        response = Response()
-        del response.headers["content-length"]
-        response.status_code = None  # type: ignore
-
-    # Handle non-field params
-    for param_name, param_type in endpoint_model.non_field_params.items():
-        if lenient_issubclass(param_type, (HTTPConnection, Request, WebSocket)):
-            values[param_name] = request
-        elif lenient_issubclass(param_type, Response):
-            values[param_name] = response
-        elif lenient_issubclass(param_type, BackgroundTasks):
-            if background_tasks is None:
-                background_tasks = BackgroundTasks()
-            values[param_name] = background_tasks
-
-    # Handle resolved params
-    for param_name, resolved_param in endpoint_model.resolved_params.items():
-        # Get all known arguments for the resolver.
-        resolver_kwargs = {}
-        for name, parameter in inspect.signature(resolved_param.resolver).parameters.items():
-            if lenient_issubclass(parameter.annotation, (HTTPConnection, Request, WebSocket)):
-                resolver_kwargs[name] = request
-            elif lenient_issubclass(parameter.annotation, Response):
-                resolver_kwargs[name] = response
-            elif lenient_issubclass(parameter.annotation, BackgroundTasks):
-                if background_tasks is None:
-                    background_tasks = BackgroundTasks()
-                resolver_kwargs[name] = background_tasks
-            elif name in values:
-                resolver_kwargs[name] = values[name]
-
-        # Resolver can be a class with __call__ function
-        resolver = resolved_param.resolver
-        if not inspect.isfunction(resolver) and callable(resolver):
-            resolver = resolver.__call__
-        elif not inspect.isfunction(resolver):
-            raise TypeError(f'{param_name} = {resolved_param} resolver is not a function or callable')
-
-        if is_gen_callable(resolver) or is_async_gen_callable(resolver):
-            stack = request.scope.get("starmallow_astack")
-            assert isinstance(stack, AsyncExitStack)
-            values[param_name] = await solve_generator(
-                call=resolver, stack=stack, gen_kwargs=resolver_kwargs,
-            )
-        elif asyncio.iscoroutinefunction(resolver):
-            values[param_name] = await resolver(**resolver_kwargs)
-        else:
-            values[param_name] = resolver(**resolver_kwargs)
-
-    return values, errors
-
-
 async def run_endpoint_function(
     endpoint_model: EndpointModel,
     values: Dict[str, Any],
@@ -255,7 +47,7 @@ async def run_endpoint_function(
 
     kwargs = {
         name: values[name]
-        for name in inspect.signature(endpoint_model.call).parameters
+        for name in get_typed_signature(endpoint_model.call).parameters
         if name in values
     }
 
@@ -283,7 +75,7 @@ def get_request_handler(
     assert endpoint_model.call is not None, "dependant.call must be a function"
 
     async def app(request: Request) -> Response:
-        values, errors = await get_request_args(request, endpoint_model)
+        values, errors = await resolve_params(request, endpoint_model.params)
 
         if errors:
             raise RequestValidationError(errors)
@@ -318,7 +110,7 @@ def get_websocker_hander(
     assert endpoint_model.call is not None, "dependant.call must be a function"
 
     async def app(websocket: WebSocket) -> None:
-        values, errors = await get_request_args(websocket, endpoint_model)
+        values, errors = await resolve_params(websocket, endpoint_model.params)
 
         if errors:
             await websocket.close(code=WS_1008_POLICY_VIOLATION)

starmallow/security/api_key.py

@@ -16,7 +16,7 @@ class APIKeyIn(Enum):
     cookie = "cookie"
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class APIKeyModel(SecurityBase):
     type: ClassVar[SecurityTypes] = SecurityTypes.apiKey
     in_: APIKeyIn = required_field(data_key='in')

starmallow/security/base.py

@@ -14,7 +14,7 @@ class SecurityTypes(Enum):
     openIdConnect = "openIdConnect"
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class SecurityBase:
     type: ClassVar[SecurityTypes]
     description: Optional[str] = None

starmallow/security/http.py

@@ -11,13 +11,13 @@ from starmallow.security.base import SecurityBase, SecurityBaseResolver, Securit
 from starmallow.security.utils import get_authorization_scheme_param
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class HTTPBasicCredentials:
     username: str
     password: str
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class HTTPAuthorizationCredentials:
     '''
         Will hold the parsed HTTP Authorization Creditials like bearer tokens.
@@ -30,14 +30,14 @@ class HTTPAuthorizationCredentials:
     credentials: str
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class HTTPBaseModel(SecurityBase):
     type: ClassVar[SecurityTypes] = SecurityTypes.http
     description: Optional[str] = None
     scheme: str = None
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class HTTPBearerModel(HTTPBaseModel):
     scheme: str = "bearer"
     bearerFormat: Optional[str] = None
@@ -72,7 +72,6 @@ class HTTPBase(SecurityBaseResolver):
         return HTTPAuthorizationCredentials(scheme=scheme, credentials=credentials)
 
 
-@ma_dataclass
 class HTTPBasic(HTTPBase):
 
     def __init__(
@@ -125,7 +124,6 @@ class HTTPBasic(HTTPBase):
         return HTTPBasicCredentials(username=username, password=password)
 
 
-@ma_dataclass
 class HTTPBearer(HTTPBase):
 
     def __init__(
@@ -163,7 +161,6 @@ class HTTPBearer(HTTPBase):
         return HTTPAuthorizationCredentials(scheme=scheme, credentials=credentials)
 
 
-@ma_dataclass
 class HTTPDigest(HTTPBase):
 
     def __init__(

starmallow/security/oauth2.py

@@ -13,7 +13,7 @@ from starmallow.security.utils import get_authorization_scheme_param
 
 
 # region - Models
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlow:
     refreshUrl: Optional[str] = optional_field()
     scopes: Dict[str, str] = optional_field(default_factory=dict)
@@ -31,28 +31,28 @@ class OAuthFlow:
         }
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlowImplicit(OAuthFlow):
     authorizationUrl: str = required_field()
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlowPassword(OAuthFlow):
     tokenUrl: str = required_field()
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlowClientCredentials(OAuthFlow):
     tokenUrl: str = required_field()
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlowAuthorizationCode(OAuthFlow):
     authorizationUrl: str = required_field()
     tokenUrl: str = required_field()
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuthFlowsModel:
     implicit: Optional[OAuthFlowImplicit] = optional_field()
     password: Optional[OAuthFlowPassword] = optional_field()
@@ -72,7 +72,7 @@ class OAuthFlowsModel:
         }
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OAuth2Model(SecurityBase):
     type: SecurityTypes = SecurityTypes.oauth2
     flows: OAuthFlowsModel = required_field()

starmallow/security/open_id_connect_url.py

@@ -9,7 +9,7 @@ from starmallow.dataclasses import required_field
 from starmallow.security.base import SecurityBase, SecurityBaseResolver, SecurityTypes
 
 
-@ma_dataclass
+@ma_dataclass(frozen=True)
 class OpenIdConnectModel(SecurityBase):
     type: SecurityTypes = SecurityTypes.openIdConnect
     openIdConnectUrl: str = required_field()

starmallow/utils.py

@@ -9,11 +9,13 @@ from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
 from dataclasses import is_dataclass
 from decimal import Decimal
 from enum import Enum
+from types import NoneType
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
+    ForwardRef,
     FrozenSet,
     List,
     Mapping,
@@ -22,6 +24,7 @@ from typing import (
     Tuple,
     Type,
     Union,
+    _eval_type,
     _GenericAlias,
     get_args,
     get_origin,
@@ -303,7 +306,7 @@ def deep_dict_update(main_dict: Dict[Any, Any], update_dict: Dict[Any, Any]) ->
 
 
 def create_response_model(type_: Type[Any]) -> ma.Schema | mf.Field | None:
-    if type_ in [inspect._empty, None] or issubclass(type_, Response):
+    if type_ in [inspect._empty, None] or (inspect.isclass(type_) and issubclass(type_, Response)):
         return None
 
     field = get_model_field(type_)
@@ -337,3 +340,55 @@ def get_name(endpoint: Callable) -> str:
     if inspect.isroutine(endpoint) or inspect.isclass(endpoint):
         return endpoint.__qualname__
     return endpoint.__class__.__name__
+
+
+# Functions that help resolve forward references like
+# def foo(a: 'str') -> 'UnresolvedClass': pass
+# inspect.signature returns the literal string instead of the actual type.
+def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
+    signature = inspect.signature(call)
+    globalns = getattr(call, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(param.annotation, globalns),
+        )
+        for param in signature.parameters.values()
+    ]
+    typed_signature = inspect.Signature(typed_params)
+    return typed_signature
+
+
+def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+        annotation = evaluate_forwardref(annotation, globalns, globalns)
+    return annotation
+
+
+def get_typed_return_annotation(call: Callable[..., Any]) -> Any:
+    signature = inspect.signature(call)
+    annotation = signature.return_annotation
+
+    if annotation is inspect.Signature.empty:
+        return None
+
+    globalns = getattr(call, "__globals__", {})
+    return get_typed_annotation(annotation, globalns)
+
+
+
+def evaluate_forwardref(value: Any, globalns: dict[str, Any] | None, localns: dict[str, Any] | None) -> Any:
+    """Behaves like typing._eval_type, except it won't raise an error if a forward reference can't be resolved."""
+    if value is None:
+        value = NoneType
+    elif isinstance(value, str):
+        value = ForwardRef(value, is_argument=False, is_class=True)
+
+    try:
+        return _eval_type(value, globalns, localns)  # type: ignore
+    except NameError:
+        # the point of this function is to be tolerant to this case
+        return value

{starmallow-0.3.1.dist-info → starmallow-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: starmallow
-Version: 0.3.1
+Version: 0.3.3
 Summary: StarMallow framework
 Project-URL: Homepage, https://github.com/mvanderlee/starmallow
 Author-email: Michiel Vanderlee <jmt.vanderlee@gmail.com>

{starmallow-0.3.1.dist-info → starmallow-0.3.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
-starmallow/__init__.py,sha256=slSraQMA-1h7BqB09favkpD1LL7yREP4RLaDIVzs6QI,322
-starmallow/applications.py,sha256=aoaHg_MgmRqRdaM8MFzeqsHqXuOQDWk6G70UQbdm_Fk,29469
+starmallow/__init__.py,sha256=-ln4p19cwSrpztpgmO3aEauXyq2lSCuXvZH4ece_AlA,322
+starmallow/applications.py,sha256=oZxxLof82QdfK44-q6wUHq9z8_sRGSEVzSQkNvfGKIg,29708
 starmallow/concurrency.py,sha256=MVRjo4Vqss_yqhaoeVt3xb7rLaSuAq_q9uYgTwbsojE,1375
 starmallow/constants.py,sha256=u0h8cJKhJY0oIZqzr7wpEZG2bPLrw5FroMnn3d8KBNQ,129
 starmallow/dataclasses.py,sha256=ap9DInvQjH2AyI4MAAnbDEuNnbPb94PigaNmEb7AQU8,2658
@@ -7,18 +7,19 @@ starmallow/datastructures.py,sha256=iH_KJuJ6kBCWEsnHFLdA3iyb6ZxhfdMHYrJlhiEZtDU,
 starmallow/decorators.py,sha256=SBrzmKxzF2q7hNCW_V7j0UV461QERSh9OTtTdTFi6Kg,3597
 starmallow/delimited_field.py,sha256=gonWgYg6G5xH2yXAyfDgkePmQ8dUaRSp2hdJ3mCfOBw,3466
 starmallow/docs.py,sha256=eA39LunVMEoPU5ge4qxm2eiJbrFTUSUu5EhG1L_LKxk,6268
-starmallow/endpoint.py,sha256=5oHoWu2dSG_nnctRM60ZPkB1R9Mh4cJv5yxRbYEZHec,15593
+starmallow/endpoint.py,sha256=T4VH7CSM-M157ijHUVihoru8BKmAzDBMRMBpeww5JR8,15841
 starmallow/endpoints.py,sha256=UrwVZCxbmWI20iNtJ0oXxo4d3-y12TjsOGs_jnStTiU,939
 starmallow/exception_handlers.py,sha256=gr2qLYWEtsIEH28n7OreEiiLVz6Y7b6osRyS9esJbBk,891
 starmallow/exceptions.py,sha256=vabtPJkTmtCdC8_2OPBE8Osz0v0KxaSOX6IWf1jgNkc,872
 starmallow/fields.py,sha256=arrTabCYoJFZcoY69EZTBH3YUg7CUSr3-zYLiAjYLTM,1238
-starmallow/params.py,sha256=XRWIFLm2H5jQUIo4gm5Oi4xVqGNosaQSSi7QYqjJyxQ,7000
+starmallow/params.py,sha256=bb5hHps7zabhYKpQjqqPqPSxtG4gvFCZtL9CptgH4sY,7253
+starmallow/request_resolver.py,sha256=6NikzrNpQE82j-iasTipeBFblIx-WfX3l6EvdIXMFkY,10450
 starmallow/responses.py,sha256=k2pf_m21ykf_FECdODUz400pMucMJJf_Zm8TXFujvaU,2012
-starmallow/routing.py,sha256=bq7RThRbpPzMUKgkBhqUimeKx5KAXZt-5ydYmBMLYgg,47312
+starmallow/routing.py,sha256=QPBl4X8M2bjlj5EGt21KLyYuroLRg60ZvNdIm74IbQQ,38743
 starmallow/schema_generator.py,sha256=BKtXVQoNFWoAIEtiRNylWls_7nyFIshy3_myooogjoI,17806
 starmallow/serializers.py,sha256=rBEKMNgONgz_bai12uDvAEMCI_aEFGsqMSeIoWtlrOI,12514
 starmallow/types.py,sha256=8GXWjvzXQhF5NMHf14fbid6uErxVd1Xk_w2I4FoUgZ4,717
-starmallow/utils.py,sha256=MS44NCYDpKA3JRCvJ7lRhrBK57wT5T8QlylZxlcZLEU,9484
+starmallow/utils.py,sha256=AkVesTbYnshaXZqdgpc09TpZF07LIUeCOwOlvCaQrAI,11412
 starmallow/websockets.py,sha256=yIz3LzTBMNclpEoG7oTMbQwxbcdKNU6M8XcqZMyBTuA,2223
 starmallow/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 starmallow/ext/marshmallow/__init__.py,sha256=33jENGdfPq4-CDG0LOmN3KOGW1pXTy7a2oMwy4hrYzM,208
@@ -26,13 +27,13 @@ starmallow/ext/marshmallow/openapi.py,sha256=5aGvbwLGVucsVhXExpYeyt8n5dQTzazrf-n
 starmallow/middleware/__init__.py,sha256=vtNm85Z9pUPjJd-9giJGg3YL1wO7Jm5ooXBm31pDOK8,53
 starmallow/middleware/asyncexitstack.py,sha256=0GPhQSxqSVmAiVIqBIN5slueWYZ8bwh9f2bBPy7AbP0,1191
 starmallow/security/__init__.py,sha256=1rQFBIGnEbE51XDZSSi9NgPjXLScFq3RoLu4vk0KVYw,191
-starmallow/security/api_key.py,sha256=v2a3FHv1c--F2guiJ3wxKQi5k0nIcl40d4tqMPFyb44,3131
-starmallow/security/base.py,sha256=6ybCCf22t8GNR4RZXIzOfFEGws28S-KVqri-gHHXVCU,1131
-starmallow/security/http.py,sha256=rMwBYQQRil5iVjM87b0gsCENSFQXiqsdAfy0g6Qmvt8,6597
-starmallow/security/oauth2.py,sha256=PWdrgqUeijxzRAQilXMXRb9DnA-U2-xMQ5LKL4S66t8,9914
-starmallow/security/open_id_connect_url.py,sha256=ykokB7mJYu4pFsHW4Ro1y71h-5H11mt90jyv64EIQBM,1386
+starmallow/security/api_key.py,sha256=E326Sxb_qhWbfN70vHuq4KEJcToW1Fxw0qGL0pHmQjc,3144
+starmallow/security/base.py,sha256=_7PR7tepr0CHJxg6uTc_cBAeY90jBS5gu8z5598yEM0,1144
+starmallow/security/http.py,sha256=cpGjM1kFDq3i_bOY96kMkf4cspBUxFkkET9lTK3NA-0,6607
+starmallow/security/oauth2.py,sha256=1nv1580PY4cwgu5gzpQCf2MfMNv2Cfv05753AUHPOhQ,10005
+starmallow/security/open_id_connect_url.py,sha256=IPsL2YzWc2mPwJbrUn6oFRTi7uRAG6mR62CGwmzBs1k,1399
 starmallow/security/utils.py,sha256=bd8T0YM7UQD5ATKucr1bNtAvz_Y3__dVNAv5UebiPvc,293
-starmallow-0.3.1.dist-info/METADATA,sha256=6RbpVd1OozE5ggQjC9wDR5rk6_d_VLnFBj4tpTju0bk,5651
-starmallow-0.3.1.dist-info/WHEEL,sha256=y1bSCq4r5i4nMmpXeUJMqs3ipKvkZObrIXSvJHm1qCI,87
-starmallow-0.3.1.dist-info/licenses/LICENSE.md,sha256=QelyGgOzch8CXzy6HrYwHh7nmj0rlWkDA0YzmZ3CPaY,1084
-starmallow-0.3.1.dist-info/RECORD,,
+starmallow-0.3.3.dist-info/METADATA,sha256=Xtq-b_MKBANM7Frnbvx1u3CN9P_b4Po2STs_3Jjfitk,5651
+starmallow-0.3.3.dist-info/WHEEL,sha256=y1bSCq4r5i4nMmpXeUJMqs3ipKvkZObrIXSvJHm1qCI,87
+starmallow-0.3.3.dist-info/licenses/LICENSE.md,sha256=QelyGgOzch8CXzy6HrYwHh7nmj0rlWkDA0YzmZ3CPaY,1084
+starmallow-0.3.3.dist-info/RECORD,,