starmallow 0.6.3__tar.gz → 0.6.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: starmallow
-Version: 0.6.3
+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.3 → starmallow-0.6.4}/starmallow/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.3"
+__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.3 → 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.3 → 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