feat!: static handler configuration [WIP]

litestar/_asgi/asgi_router.py

@@ -52,6 +52,7 @@
         "_plain_routes",
         "_registered_routes",
         "_static_routes",
+        "_trie_initialized",
         "app",
         "root_route_map_node",
         "route_handler_index",
@@ -69,6 +70,7 @@
         self._mount_routes: dict[str, RouteTrieNode] = {}
         self._plain_routes: set[str] = set()
         self._registered_routes: set[HTTPRoute | WebSocketRoute | ASGIRoute] = set()
+        self._trie_initialized = False
         self.app = app
         self.root_route_map_node: RouteTrieNode = create_node()
         self.route_handler_index: dict[str, RouteHandlerType] = {}
@@ -94,7 +96,7 @@
             ScopeState.from_scope(scope).exception_handlers = self._app_exception_handlers
             raise
         else:
-            ScopeState.from_scope(scope).exception_handlers = route_handler.resolve_exception_handlers()
+            ScopeState.from_scope(scope).exception_handlers = route_handler.exception_handlers
             scope["route_handler"] = route_handler
             scope["path_template"] = path_template
         await asgi_app(scope, receive, send)
@@ -145,8 +147,16 @@
 
         This map is used in the asgi router to route requests.
         """
-        new_routes = [route for route in self.app.routes if route not in self._registered_routes]
-        for route in new_routes:
+        if self._trie_initialized:
+            self._mount_paths_regex = None
+            self._mount_routes = {}
+            self._plain_routes = set()
+            self._registered_routes = set()
+            self.root_route_map_node = create_node()
+            self.route_handler_index = {}
+            self.route_mapping = defaultdict(list)
+
+        for route in self.app.routes:
             add_route_to_trie(
                 app=self.app,
                 mount_routes=self._mount_routes,

litestar/_asgi/routing_trie/mapping.py

@@ -189,7 +189,7 @@ def build_route_middleware_stack(
     from litestar.routes import HTTPRoute
 
     asgi_handler: ASGIApp = route.handle  # type: ignore[assignment]
-    handler_middleware = route_handler.resolve_middleware()
+    handler_middleware = route_handler.middleware
     has_cached_route = isinstance(route, HTTPRoute) and any(r.cache for r in route.route_handlers)
     has_middleware = (
         app.csrf_config or app.compression_config or has_cached_route or app.allowed_hosts or handler_middleware

litestar/_kwargs/extractors.py

@@ -343,7 +343,7 @@ async def _extract_multipart(
             stream=connection.stream(),
             boundary=connection.content_type[-1].get("boundary", "").encode(),
             multipart_form_part_limit=multipart_form_part_limit,
-            type_decoders=connection.route_handler.resolve_type_decoders(),
+            type_decoders=connection.route_handler.type_decoders,
         )
     else:
         form_values = scope_state.form

litestar/_layers/utils.py

@@ -12,23 +12,23 @@
     from litestar.types.composite_types import ResponseCookies, ResponseHeaders
 
 
-def narrow_response_headers(headers: ResponseHeaders | None) -> Sequence[ResponseHeader] | None:
+def narrow_response_headers(headers: ResponseHeaders | None) -> Sequence[ResponseHeader]:
     """Given :class:`.types.ResponseHeaders` as a :class:`typing.Mapping`, create a list of
     :class:`.datastructures.response_header.ResponseHeader` from it, otherwise return ``headers`` unchanged
     """
     return (
         tuple(ResponseHeader(name=name, value=value) for name, value in headers.items())
         if isinstance(headers, Mapping)
         else headers
-    )
+    ) or ()
 
 
-def narrow_response_cookies(cookies: ResponseCookies | None) -> Sequence[Cookie] | None:
+def narrow_response_cookies(cookies: ResponseCookies | None) -> Sequence[Cookie]:
     """Given :class:`.types.ResponseCookies` as a :class:`typing.Mapping`, create a list of
     :class:`.datastructures.cookie.Cookie` from it, otherwise return ``cookies`` unchanged
     """
     return (
         tuple(Cookie(key=key, value=value) for key, value in cookies.items())
         if isinstance(cookies, Mapping)
         else cookies
-    )
+    ) or ()

litestar/_openapi/datastructures.py

@@ -243,6 +243,6 @@ def add_operation_id(self, operation_id: str) -> None:
         if operation_id in self.operation_ids:
             raise ImproperlyConfiguredException(
                 "operation_ids must be unique, "
-                f"please ensure the value of 'operation_id' is either not set or unique for {operation_id}"
+                f"please ensure the value of 'operation_id' is either not set or unique for {operation_id!r}"
             )
         self.operation_ids.add(operation_id)

litestar/_openapi/parameters.py

@@ -94,8 +94,8 @@ def __init__(
         self.schema_creator = SchemaCreator.from_openapi_context(self.context, prefer_alias=True)
         self.route_handler = route_handler
         self.parameters = ParameterCollection(route_handler)
-        self.dependency_providers = route_handler.resolve_dependencies()
-        self.layered_parameters = route_handler.resolve_layered_parameters()
+        self.dependency_providers = route_handler.dependencies
+        self.layered_parameters = route_handler.parameter_field_definitions
         self.path_parameters = path_parameters
 
     def create_parameter(self, field_definition: FieldDefinition, parameter_name: str) -> Parameter:

litestar/_openapi/path_item.py

@@ -36,7 +36,7 @@ def create_path_item(self) -> PathItem:
             A PathItem instance.
         """
         for http_method, route_handler in self.route.route_handler_map.items():
-            if not route_handler.resolve_include_in_schema():
+            if not route_handler.include_in_schema:
                 continue
 
             operation = self.create_operation_for_handler_method(route_handler, HttpMethod(http_method))
@@ -74,14 +74,14 @@ def create_operation_for_handler_method(
 
         return route_handler.operation_class(
             operation_id=operation_id,
-            tags=route_handler.resolve_tags() or None,
+            tags=sorted(route_handler.tags) if route_handler.tags else None,
             summary=route_handler.summary or SEPARATORS_CLEANUP_PATTERN.sub("", route_handler.handler_name.title()),
             description=self.create_description_for_handler(route_handler),
             deprecated=route_handler.deprecated,
             responses=responses,
             request_body=request_body,
             parameters=parameters or None,  # type: ignore[arg-type]
-            security=route_handler.resolve_security() or None,
+            security=list(route_handler.security) if route_handler.security else None,
         )
 
     def create_operation_id(self, route_handler: HTTPRouteHandler, http_method: HttpMethod) -> str:

litestar/_openapi/plugin.py

@@ -198,7 +198,7 @@ def receive_route(self, route: BaseRoute) -> None:
         if not isinstance(route, HTTPRoute):
             return
 
-        if any(route_handler.resolve_include_in_schema() for route_handler in route.route_handler_map.values()):
+        if any(route_handler.include_in_schema for route_handler in route.route_handler_map.values()):
             # Force recompute the schema if a new route is added
             self._openapi = None
             self.included_routes[route.path] = route

litestar/_openapi/responses.py

@@ -209,7 +209,7 @@ def set_success_response_headers(self, response: OpenAPIResponse) -> None:
         else:
             schema_creator = SchemaCreator.from_openapi_context(self.context, generate_examples=False)
 
-        for response_header in self.route_handler.resolve_response_headers():
+        for response_header in self.route_handler.response_headers:
             header = OpenAPIHeader()
             for attribute_name, attribute_value in (
                 (k, v) for k, v in asdict(response_header).items() if v is not None