starmallow 0.6.2__tar.gz → 0.6.4__tar.gz

{starmallow-0.6.2 → starmallow-0.6.4}/PKG-INFO

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

{starmallow-0.6.2 → starmallow-0.6.4}/starmallow/__init__.py

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

starmallow-0.6.4/starmallow/background.py

@@ -0,0 +1,29 @@
+import typing
+from logging import getLogger
+
+from starlette.background import BackgroundTask as StarletteBackgroundTask
+from starlette.background import BackgroundTasks as StarletteBackgroundTasks
+from starlette.background import P
+from starlette.concurrency import run_in_threadpool
+
+logger = getLogger(__name__)
+
+
+class BackgroundTask(StarletteBackgroundTask):
+
+    async def __call__(self) -> None:
+        try:
+            if self.is_async:
+                await self.func(*self.args, **self.kwargs)
+            else:
+                await run_in_threadpool(self.func, *self.args, **self.kwargs)
+        except BaseException as e:
+            logger.exception(f'Background Task {self.func} failed: {e}')
+
+
+class BackgroundTasks(StarletteBackgroundTasks):
+    def add_task(
+        self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs
+    ) -> None:
+        task = BackgroundTask(func, *args, **kwargs)
+        self.tasks.append(task)

{starmallow-0.6.2 → starmallow-0.6.4}/starmallow/endpoint.py

@@ -211,6 +211,7 @@ class EndpointMixin:
             kwargs.update({
                 'load_default': None,
                 'required': False,
+                'allow_none': True,  # Even if a default is provided, we should also allow None
             })
             # This does not support Union[A,B,C,None]. Only Union[A,None] and Optional[A]
             model = next((a for a in get_args(type_annotation) if a is not None), None)

{starmallow-0.6.2 → starmallow-0.6.4}/starmallow/request_resolver.py

@@ -8,13 +8,14 @@ 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.background import BackgroundTasks as StarletteBackgroundTasks
 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.background import BackgroundTasks
 from starmallow.params import Param, ParamType, ResolvedParam
 from starmallow.utils import (
     is_async_gen_callable,
@@ -113,7 +114,7 @@ def request_params_to_args(
 async def resolve_basic_args(
     request: Request | WebSocket,
     response: Response,
-    background_tasks: BackgroundTasks,
+    background_tasks: StarletteBackgroundTasks,
     params: Dict[ParamType, Dict[str, Param]],
 ):
     path_values, path_errors = request_params_to_args(
@@ -183,7 +184,7 @@ async def resolve_basic_args(
             values[param_name] = request
         elif lenient_issubclass(param_type, Response):
             values[param_name] = response
-        elif lenient_issubclass(param_type, BackgroundTasks):
+        elif lenient_issubclass(param_type, StarletteBackgroundTasks):
             values[param_name] = background_tasks
 
     return values, errors
@@ -217,7 +218,7 @@ async def call_resolver(
 async def resolve_subparams(
     request: Request | WebSocket,
     response: Response,
-    background_tasks: BackgroundTasks,
+    background_tasks: StarletteBackgroundTasks,
     params: Dict[str, ResolvedParam],
     dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]],
 ) -> Dict[str, Any]:
@@ -250,10 +251,10 @@ async def resolve_subparams(
 async def resolve_params(
     request: Request | WebSocket,
     params: Dict[ParamType, Dict[str, Param]],
-    background_tasks: Optional[BackgroundTasks] = None,
+    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]], BackgroundTasks, Response]:
+) -> Tuple[Dict[str, Any], Dict[str, Union[Any, List, Dict]], StarletteBackgroundTasks, Response]:
     dependency_cache = dependency_cache or {}
 
     if response is None:

{starmallow-0.6.2 → starmallow-0.6.4}/starmallow/routing.py

@@ -96,7 +96,12 @@ def request_response(
                 response = await run_in_threadpool(func, request)
             await response(scope, receive, send)
 
-        await wrap_app_handling_exceptions(app, request)(scope, receive, send)
+        try:
+            await wrap_app_handling_exceptions(app, request)(scope, receive, send)
+        except RuntimeError as e:
+            # This likely means that the exception was thrown by a background task
+            # after the response has been successfully send to the client
+            logger.exception(f'Runtime error occurred: {e}')
 
     return app
 

starmallow-0.6.4/tests/test_annotated.py

@@ -0,0 +1,527 @@
+'''Test Resolved Params'''
+import datetime as dt
+from typing import Annotated, Literal, Optional, Union
+
+import marshmallow as ma
+import marshmallow.fields as mf
+import pytest
+from marshmallow_dataclass import dataclass as ma_dataclass
+from starlette.testclient import TestClient
+
+from starmallow import Body, Header, Path, Query, ResolvedParam, StarMallow
+
+from .utils import assert_json
+
+app = StarMallow()
+
+
+############################################################
+# Models  -  classes and schemas
+############################################################
+# region  -  VS Code folding marker - https://code.visualstudio.com/docs/editor/codebasics#_folding
+def paging_parameters(
+    offset: Annotated[int, Query(0)],
+    limit: Annotated[int, Query()] = 1000,
+):
+    return {"offset": offset, "limit": limit}
+
+
+def search_parameters(q: Annotated[str, Path()]):
+    return {"q": q}
+
+
+# To test nested resolved params
+def searchable_page_parameters(
+    paging_params: Annotated[dict[str, int], ResolvedParam(paging_parameters)],
+    search_params: Annotated[dict[str, str], ResolvedParam(search_parameters)],
+):
+    return {
+        "offset": paging_params["offset"],
+        "limit": paging_params["limit"],
+        "q": search_params["q"],
+    }
+
+
+@ma_dataclass
+class PathParams:
+    item_id: int
+
+
+# For testing with native marshmallow schemas
+class PathParamsSchema(ma.Schema):
+    item_id = mf.Integer()
+
+
+@ma_dataclass
+class MultiPathParams:
+    item_id: int
+    sub_item_id: int
+
+
+@ma_dataclass
+class MultiQueryParams:
+    name: str
+
+
+@ma_dataclass
+class MultiBodyParams:
+    weight: float
+
+
+@ma_dataclass
+class MultiHeaderParams:
+    color: str = 'blue'
+# endregion
+# endregion
+
+
+############################################################
+# Test API
+############################################################
+# region
+@app.get("/paging")
+def get_paging(paging_params: Annotated[dict[str, int], ResolvedParam(paging_parameters)]):
+    return paging_params
+
+
+@app.get("/filtered_paging_1/{q}")
+def get_filtered_paging_1(search_params: Annotated[dict[str, str], ResolvedParam(search_parameters)]):
+    return search_params
+
+
+@app.get("/filtered_paging_2/{q}")
+def get_filtered_paging_2(filtered_paging_params: Annotated[dict[str, int | str], ResolvedParam(searchable_page_parameters)]):
+    return filtered_paging_params
+
+
+@app.post("/optional_with_default")
+def post_optional_with_default(
+    optional_body: Annotated[dt.datetime | None, Body()] = dt.datetime.max,
+):
+    return {'optional_body': optional_body}
+
+
+@app.post('/multi_combo_optional/{item_id}/{sub_item_id}')
+def post_multi_combo_optional(
+    item_id: int,
+    path_params: Annotated[MultiPathParams, Path()],
+    query_params: Annotated[MultiQueryParams | None, Query()],
+    body_params: Annotated[MultiBodyParams | None, Body()],
+    weight_unit: Annotated[Optional[Literal['lbs', 'kg']], Query(title='Weight')],
+    color: Annotated[Union[str, None], Header('blue')],
+    # Tests convert_underscores
+    user_agent: Annotated[Optional[str], Header(None)],
+    # Tests aliasing
+    aliased_header: Annotated[Optional[str], Header(None, alias="myalias")],
+):
+    return {
+        'item_id': item_id,
+        'param_item_id': path_params.item_id,
+        'sub_item': path_params.sub_item_id,
+        # Special None response to signify that the entire object is None
+        'name': query_params.name if query_params is not None else '__NONE__',
+        'weight': body_params.weight if body_params is not None else '__NONE__',
+        'weight_unit': weight_unit,
+        'color': color,
+        'user_agent': user_agent,
+        'aliased_header': aliased_header,
+    }
+# endregion
+
+
+############################################################
+# Tests
+############################################################
+# region
+client = TestClient(app)
+
+openapi_schema = {
+    "openapi": "3.0.2",
+    "info": {"title": "StarMallow", "version": "0.1.0"},
+    "paths": {
+        "/paging": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Get Paging",
+                "operationId": "get_paging_paging_get",
+                "parameters": [
+                    {
+                        "required": False,
+                        "schema": {
+                            "default": 0,
+                            "type": "integer",
+                            "title": "Offset",
+                        },
+                        "name": "offset",
+                        "in": "query",
+                    },
+                    {
+                        "required": False,
+                        "schema": {
+                            "default": 1000,
+                            "type": "integer",
+                            "title": "Limit",
+                        },
+                        "name": "limit",
+                        "in": "query",
+                    },
+                ],
+            },
+        },
+        "/filtered_paging_1/{q}": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Get Filtered Paging 1",
+                "operationId": "get_filtered_paging_1_filtered_paging_1__q__get",
+                "parameters": [
+                    {
+                        "required": True,
+                        "schema": {
+                            "type": "string",
+                            "title": "Q",
+                        },
+                        "name": "q",
+                        "in": "path",
+                    },
+                ],
+            },
+        },
+        "/filtered_paging_2/{q}": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Get Filtered Paging 2",
+                "operationId": "get_filtered_paging_2_filtered_paging_2__q__get",
+                "parameters": [
+                    {
+                        "required": False,
+                        "schema": {
+                            "default": 0,
+                            "type": "integer",
+                            "title": "Offset",
+                        },
+                        "name": "offset",
+                        "in": "query",
+                    },
+                    {
+                        "required": False,
+                        "schema": {
+                            "default": 1000,
+                            "type": "integer",
+                            "title": "Limit",
+                        },
+                        "name": "limit",
+                        "in": "query",
+                    },
+                    {
+                        "required": True,
+                        "schema": {
+                            "type": "string",
+                            "title": "Q",
+                        },
+                        "name": "q",
+                        "in": "path",
+                    },
+                ],
+            },
+        },
+        "/optional_with_default": {
+            "post": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Post Optional With Default",
+                "operationId": "post_optional_with_default_optional_with_default_post",
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                           "schema": {
+                               "$ref": "#/components/schemas/Body_post_optional_with_default_optional_with_default_post",
+                           },
+                        },
+                    },
+                    "required": True,
+                },
+            },
+        },
+        "/multi_combo_optional/{item_id}/{sub_item_id}": {
+            "post": {
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {"application/json": {"schema": {}}},
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError",
+                                },
+                            },
+                        },
+                    },
+                },
+                "summary": "Post Multi Combo Optional",
+                "operationId": "post_multi_combo_optional_multi_combo_optional__item_id___sub_item_id__post",
+                "parameters": [
+                    {
+                        'in': 'query',
+                        'name': 'name',
+                        'required': True,
+                        'schema': {
+                            'title': 'Name',
+                            'type': 'string',
+                        },
+                    },
+                    {
+                        'in': 'query',
+                        'name': 'weight_unit',
+                        'required': False,
+                        'schema': {
+                            "default": None,
+                            'enum': ['lbs', 'kg'],
+                            "nullable": True,
+                            'title': 'Weight',
+                        },
+                    },
+                    {
+                        'in': 'path',
+                        'name': 'item_id',
+                        'required': True,
+                        'schema': {
+                            'title': 'Item Id',
+                            'type': 'integer',
+                        },
+                    },
+                    {
+                        'in': 'path',
+                        'name': 'sub_item_id',
+                        'required': True,
+                        'schema': {
+                            'title': 'Sub Item Id',
+                            'type': 'integer',
+                        },
+                    },
+                    {
+                        'in': 'header',
+                        'name': 'color',
+                        'required': False,
+                        'schema': {
+                            'default': 'blue',
+                            "nullable": True,
+                            'title': 'Color',
+                            'type': 'string',
+                        },
+                    },
+                    {
+                        'in': 'header',
+                        'name': 'user_agent',
+                        'required': False,
+                        'schema': {
+                            "default": None,
+                            "nullable": True,
+                            'title': 'User Agent',
+                            'type': 'string',
+                        },
+                    },
+                    {
+                        'in': 'header',
+                        'name': 'aliased_header',
+                        'required': False,
+                        'schema': {
+                            "default": None,
+                            "nullable": True,
+                            'title': 'Myalias',
+                            'type': 'string',
+                        },
+                    },
+                ],
+                'requestBody': {
+                    'content': {
+                        'application/json': {
+                            'schema': {'$ref': '#/components/schemas/MultiBodyParams'},
+                        },
+                    },
+                    'required': False,
+                },
+            },
+        },
+    },
+    "components": {
+        "schemas": {
+            "Body_post_optional_with_default_optional_with_default_post": {
+                "properties": {
+                    "optional_body": {
+                        "default": "9999-12-31T23:59:59.999999",
+                        "format": "date-time",
+                        "nullable": True,
+                        "title": "Optional Body",
+                        "type": "string",
+                    },
+                },
+                "required": [],
+                "title": "Body_post_optional_with_default_optional_with_default_post",
+                "type": "object",
+            },
+            "HTTPValidationError": {
+                'properties': {
+                    'detail': {
+                        'description': 'Error detail',
+                        'title': 'Detail',
+                    },
+                    'errors': {
+                        'description': 'Exception or error type',
+                        'title': 'Errors',
+                    },
+                    'status_code': {
+                        'description': 'HTTP status code',
+                        'title': 'Status Code',
+                        'type': 'integer',
+                    },
+                },
+                'required': ['detail', 'status_code'],
+                'title': 'HTTPValidationError',
+                'type': 'object',
+            },
+            "MultiBodyParams": {
+                "type": "object",
+                "properties": {
+                    "weight": {
+                        "type": "number",
+                        "title": "Weight",
+                    },
+                },
+                "required": [
+                    "weight",
+                ],
+                "title": "Body Params",
+            },
+        },
+    },
+}
+
+
+@pytest.mark.parametrize(
+    "path,expected_status,expected_response",
+    [
+        ("/paging?limit=50", 200, {"offset": 0, "limit": 50}),
+        ("/filtered_paging_1/name=foobar", 200, {"q": "name=foobar"}),
+        (
+            "/filtered_paging_2/name=foobar?limit=50", 200,
+            {"offset": 0, "limit": 50, "q": "name=foobar"},
+        ),
+        ("/openapi.json", 200, openapi_schema),
+    ],
+)
+def test_get_path(path, expected_status, expected_response):
+    response = client.get(path)
+    assert response.status_code == expected_status
+    assert_json(response.json(), expected_response)
+
+
+@pytest.mark.parametrize(
+    "path,headers,body,expected_status,expected_response",
+    [
+        (
+            "/optional_with_default",
+            {},
+            {},
+            200,
+            {
+                'optional_body': '9999-12-31T23:59:59.999999',
+            },
+        ),
+        (
+            "/optional_with_default",
+            {},
+            {
+                'optional_body': None,
+            },
+            200,
+            {
+                'optional_body': None,
+            },
+        ),
+        (
+            "/multi_combo_optional/5/3",
+            {},
+            None,
+            200,
+            {
+                'item_id': 5,
+                'param_item_id': 5,
+                'sub_item': 3,
+                'name': '__NONE__',
+                'weight': '__NONE__',
+                'weight_unit': None,
+                'color': 'blue',
+                "user_agent": "testclient",
+                "aliased_header": None,
+            },
+        ),
+    ],
+)
+def test_post_path(path, headers, body, expected_status, expected_response):
+    response = client.post(path, headers=headers, json=body)
+    assert response.status_code == expected_status
+    assert_json(response.json(), expected_response)
+
+# endregion

{starmallow-0.6.2 → starmallow-0.6.4}/tests/test_input.py

@@ -913,6 +913,7 @@ openapi_schema = {
                         'required': False,
                         'schema': {
                             'default': 'blue',
+                            "nullable": True,
                             'title': 'Color',
                             'type': 'string',
                         },