asgi-tools 1.1.0__cp310-cp310-musllinux_1_2_aarch64.whl → 1.3.1__cp310-cp310-musllinux_1_2_aarch64.whl

asgi_tools/forms.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from io import BytesIO
 from tempfile import SpooledTemporaryFile
-from typing import TYPE_CHECKING, Callable, Optional
+from typing import TYPE_CHECKING, Callable
 from urllib.parse import unquote_to_bytes
 
 from multidict import MultiDict
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 async def read_formdata(
     request: "Request",
     max_size: int,
-    upload_to: Optional[Callable],
+    upload_to: Callable | None,
     file_memory_limit: int = 1024 * 1024,
 ) -> MultiDict:
     """Read formdata from the given request."""
@@ -43,7 +43,7 @@ async def read_formdata(
 class FormReader:
     """Process querystring form data."""
 
-    __slots__ = "form", "curname", "curvalue", "charset"
+    __slots__ = "charset", "curname", "curvalue", "form"
 
     def __init__(self, charset: str):
         self.charset = charset
@@ -80,18 +80,18 @@ class MultipartReader(FormReader):
     """Process multipart formdata."""
 
     __slots__ = (
-        "form",
+        "charset",
         "curname",
         "curvalue",
-        "charset",
+        "file_memory_limit",
+        "form",
+        "headers",
         "name",
         "partdata",
-        "headers",
         "upload_to",
-        "file_memory_limit",
     )
 
-    def __init__(self, charset: str, upload_to: Optional[Callable], file_memory_limit: int):
+    def __init__(self, charset: str, upload_to: Callable | None, file_memory_limit: int):
         super().__init__(charset)
         self.name = ""
         self.headers: dict[bytes, bytes] = {}
@@ -102,7 +102,7 @@ class MultipartReader(FormReader):
     def init_parser(self, request: "Request", max_size: int) -> BaseParser:
         boundary = request.media.get("boundary", "")
         if not boundary:
-            raise ValueError("Invalid content type boundary")  # noqa: TRY003
+            raise ValueError("Invalid content type boundary")
 
         return MultipartParser(
             boundary,

asgi_tools/middleware.py

@@ -8,7 +8,7 @@ from contextvars import ContextVar
 from functools import partial
 from inspect import isawaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Awaitable, Callable, Final, Mapping, Optional, Union
+from typing import TYPE_CHECKING, Awaitable, Callable, Final, Mapping
 
 from http_router import Router
 
@@ -22,12 +22,12 @@ if TYPE_CHECKING:
     from .types import TASGIApp, TASGIMessage, TASGIReceive, TASGIScope, TASGISend
 
 
-class BaseMiddeware(metaclass=abc.ABCMeta):
+class BaseMiddleware(metaclass=abc.ABCMeta):
     """Base class for ASGI-Tools middlewares."""
 
     scopes: tuple[str, ...] = ("http", "websocket")
 
-    def __init__(self, app: Optional[TASGIApp] = None) -> None:
+    def __init__(self, app: TASGIApp | None = None) -> None:
         """Save ASGI App."""
         self.bind(app)
 
@@ -48,13 +48,17 @@ class BaseMiddeware(metaclass=abc.ABCMeta):
         """Setup the middleware without an initialization."""
         return partial(cls, **params)  # type: ignore[abstract]
 
-    def bind(self, app: Optional[TASGIApp] = None):
+    def bind(self, app: TASGIApp | None = None):
         """Rebind the middleware to an ASGI application if it has been inited already."""
         self.app = app or ResponseError.NOT_FOUND()
         return self
 
 
-class ResponseMiddleware(BaseMiddeware):
+# Backward compatibility
+BaseMiddeware = BaseMiddleware
+
+
+class ResponseMiddleware(BaseMiddleware):
     """Automatically convert ASGI_ apps results into responses :class:`~asgi_tools.Response` and
     send them to server as ASGI_ messages.
 
@@ -121,22 +125,22 @@ class ResponseMiddleware(BaseMiddeware):
             await exc(scope, receive, send)
 
     def send(self, _: TASGIMessage):
-        raise RuntimeError("You can't use send() method in ResponseMiddleware")  # noqa: TRY003
+        raise RuntimeError("You can't use send() method in ResponseMiddleware")
 
-    def bind(self, app: Optional[TASGIApp] = None):
+    def bind(self, app: TASGIApp | None = None):
         """Rebind the middleware to an ASGI application if it has been inited already."""
         self.app = app or to_awaitable(lambda *_: ResponseError.NOT_FOUND())
         return self
 
 
-class RequestMiddleware(BaseMiddeware):
+class RequestMiddleware(BaseMiddleware):
     """Automatically create :class:`asgi_tools.Request` from the scope and pass it to ASGI_ apps.
 
     .. code-block:: python
 
         from asgi_tools import RequestMiddleware, Response
 
-        async def app(request, receive, send):
+        async def app(scope, receive, send):
             content = f"{ request.method } { request.url.path }"
             response = Response(content)
             await response(scope, receive, send)
@@ -150,7 +154,7 @@ class RequestMiddleware(BaseMiddeware):
         return await self.app(Request(scope, receive, send), receive, send)
 
 
-class LifespanMiddleware(BaseMiddeware):
+class LifespanMiddleware(BaseMiddleware):
     """Manage ASGI_ Lifespan events.
 
     :param ignore_errors: Ignore errors from startup/shutdown handlers
@@ -193,12 +197,12 @@ class LifespanMiddleware(BaseMiddeware):
 
     def __init__(
         self,
-        app: Optional[TASGIApp] = None,
+        app: TASGIApp | None = None,
         *,
         logger=logger,
         ignore_errors: bool = False,
-        on_startup: Union[Callable, list[Callable], None] = None,
-        on_shutdown: Union[Callable, list[Callable], None] = None,
+        on_startup: Callable | list[Callable] | None = None,
+        on_shutdown: Callable | list[Callable] | None = None,
     ) -> None:
         """Prepare the middleware."""
         super(LifespanMiddleware, self).__init__(app)
@@ -223,7 +227,7 @@ class LifespanMiddleware(BaseMiddeware):
                 break
 
     def __register__(
-        self, handlers: Union[Callable, list[Callable], None], container: list[Callable]
+        self, handlers: Callable | list[Callable] | None, container: list[Callable]
     ) -> None:
         """Register lifespan handlers."""
         if not handlers:
@@ -243,7 +247,7 @@ class LifespanMiddleware(BaseMiddeware):
         """Use the lifespan middleware as a context manager."""
         await self.run("shutdown")
 
-    async def run(self, event: str, _: Optional[TASGISend] = None):
+    async def run(self, event: str, _: TASGISend | None = None):
         """Run startup/shutdown handlers."""
         assert event in {"startup", "shutdown"}
         handlers = getattr(self, f"__{event}__")
@@ -273,7 +277,7 @@ class LifespanMiddleware(BaseMiddeware):
         self.__register__(fn, self.__shutdown__)
 
 
-class RouterMiddleware(BaseMiddeware):
+class RouterMiddleware(BaseMiddleware):
     r"""Manage routing.
 
     .. code-block:: python
@@ -328,7 +332,7 @@ class RouterMiddleware(BaseMiddeware):
 
     """
 
-    def __init__(self, app: Optional[TASGIApp] = None, router: Optional[Router] = None) -> None:
+    def __init__(self, app: TASGIApp | None = None, router: Router | None = None) -> None:
         """Initialize HTTP router."""
         super().__init__(app)
         self.router = router or Router(validator=callable)
@@ -338,7 +342,7 @@ class RouterMiddleware(BaseMiddeware):
         app, scope["path_params"] = self.__dispatch__(scope)
         return await app(scope, *args)
 
-    def __dispatch__(self, scope: TASGIScope) -> tuple[Callable, Optional[Mapping]]:
+    def __dispatch__(self, scope: TASGIScope) -> tuple[Callable, Mapping | None]:
         """Lookup for a callback."""
         path = f"{scope.get('root_path', '')}{scope['path']}"
         try:
@@ -355,7 +359,7 @@ class RouterMiddleware(BaseMiddeware):
         return self.router.route(*args, **kwargs)
 
 
-class StaticFilesMiddleware(BaseMiddeware):
+class StaticFilesMiddleware(BaseMiddleware):
     """Serve static files.
 
     :param url_prefix:  an URL prefix for static files
@@ -368,7 +372,7 @@ class StaticFilesMiddleware(BaseMiddeware):
         from asgi_tools import StaticFilesMiddleware, ResponseHTML
 
         async def app(scope, receive, send):
-            response = ResponseHTML('OK)
+            response = ResponseHTML('OK')
             await response(scope, receive, send)
 
         # Files from static folder will be served from /static
@@ -380,9 +384,9 @@ class StaticFilesMiddleware(BaseMiddeware):
 
     def __init__(
         self,
-        app: Optional[TASGIApp] = None,
+        app: TASGIApp | None = None,
         url_prefix: str = "/static",
-        folders: Optional[list[Union[str, Path]]] = None,
+        folders: list[str | Path] | None = None,
     ) -> None:
         """Initialize the middleware."""
         super().__init__(app)
@@ -395,10 +399,12 @@ class StaticFilesMiddleware(BaseMiddeware):
         path = scope["path"]
         url_prefix = self.url_prefix
         if path.startswith(url_prefix):
-            response: Optional[Response] = None
+            response: Response | None = None
             filename = path[len(url_prefix) :].strip("/")
             for folder in self.folders:
                 filepath = folder.joinpath(filename).resolve()
+                if folder != filepath.parent:
+                    continue
                 with suppress(ASGIError):
                     response = ResponseFile(filepath, headers_only=scope["method"] == "HEAD")
                     break
@@ -410,10 +416,10 @@ class StaticFilesMiddleware(BaseMiddeware):
             await self.app(scope, receive, send)
 
 
-BACKGROUND_TASK: Final = ContextVar[Optional[Awaitable]]("background_task", default=None)
+BACKGROUND_TASK: Final = ContextVar[list[Awaitable] | None]("background_task", default=None)
 
 
-class BackgroundMiddleware(BaseMiddeware):
+class BackgroundMiddleware(BaseMiddleware):
     """Run background tasks.
 
 
@@ -439,11 +445,14 @@ class BackgroundMiddleware(BaseMiddeware):
     async def __process__(self, scope: TASGIScope, receive: TASGIReceive, send: TASGISend):
         """Run background tasks."""
         await self.app(scope, receive, send)
-        bgtask = BACKGROUND_TASK.get()
-        if bgtask is not None and isawaitable(bgtask):
-            await bgtask
+        for task in BACKGROUND_TASK.get() or []:
+            await task
+
+        BACKGROUND_TASK.set(None)  # Clear the context variable
 
     @staticmethod
     def set_task(task: Awaitable):
         """Set a task for background execution."""
-        BACKGROUND_TASK.set(task)
+        tasks = BACKGROUND_TASK.get() or []
+        tasks.append(task)
+        BACKGROUND_TASK.set(tasks)