rollback to multiple router instead of resolving all to single router

Author: eadwinCode

ellar/core/routing/base.py

@@ -81,7 +81,7 @@ def get_methods(cls, methods: t.Optional[t.List[str]] = None) -> t.Set[str]:
 
     def matches(self, scope: TScope) -> t.Tuple[Match, TScope]:
         match = super().matches(scope)  # type: ignore
-        if match[0] is not Match.NONE:
+        if match[0] is Match.FULL:
             version_scheme_resolver: "BaseAPIVersioningResolver" = t.cast(
                 "BaseAPIVersioningResolver", scope[SCOPE_API_VERSIONING_RESOLVER]
             )

ellar/core/routing/operation_definitions.py

@@ -256,9 +256,9 @@ def trace(
 
     def http_route(
         self,
-        path: str,
-        methods: t.List[str],
+        path: str = "/",
         *,
+        methods: t.List[str],
         name: str = None,
         include_in_schema: bool = True,
         response: t.Union[

ellar/core/routing/route.py

@@ -97,6 +97,7 @@ def build_route_operation(  # type:ignore
             self.endpoint_parameter_model.build_model()
         self.include_in_schema = include_in_schema
         if name:
+            # necessary for route flattening
             self.name = f"{name}:{self.name}"
 
     def _load_model(self) -> None:

ellar/core/routing/router/__init__.py

@@ -1,11 +1,10 @@
 from .app import ApplicationRouter
 from .module import ModuleMount, ModuleRouter
-from .route_collections import ModuleRouteCollection, RouteCollection
+from .route_collections import RouteCollection
 
 __all__ = [
     "ApplicationRouter",
     "RouteCollection",
     "ModuleRouter",
     "ModuleMount",
-    "ModuleRouteCollection",
 ]

ellar/core/routing/router/module.py

@@ -1,6 +1,7 @@
 import typing as t
+import uuid
 
-from starlette.routing import BaseRoute, Mount as StarletteMount, Route, Router
+from starlette.routing import BaseRoute, Match, Mount as StarletteMount, Route, Router
 from starlette.types import ASGIApp
 
 from ellar.compatible import AttributeDict
@@ -16,14 +17,14 @@
 from ellar.core.routing.route import RouteOperation
 from ellar.core.routing.websocket.route import WebsocketRouteOperation
 from ellar.reflect import reflect
+from ellar.types import TReceive, TScope, TSend
 
 from ..operation_definitions import OperationDefinitions
-from .route_collections import ModuleRouteCollection
+from .route_collections import RouteCollection
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
 
-
 __all__ = ["ModuleMount", "ModuleRouter", "controller_router_factory"]
 
 
@@ -33,7 +34,8 @@ def controller_router_factory(
     openapi = reflect.get_metadata(CONTROLLER_METADATA.OPENAPI, controller) or dict()
     routes = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, controller) or []
     app = Router()
-    app.routes = ModuleRouteCollection(routes)  # type:ignore
+    app.routes = RouteCollection(routes)  # type:ignore
+
     include_in_schema = reflect.get_metadata_or_raise_exception(
         CONTROLLER_METADATA.INCLUDE_IN_SCHEMA, controller
     )
@@ -52,7 +54,7 @@ def controller_router_factory(
             CONTROLLER_METADATA.GUARDS, controller
         ),
         include_in_schema=include_in_schema if include_in_schema is not None else True,
-        **openapi
+        **openapi,
     )
     return router
 
@@ -85,6 +87,7 @@ def __init__(
         ] = (guards or [])
         self._version = set(version or [])
         self._build: bool = False
+        self._current_found_route_key = f"{uuid.uuid4().hex:4}_ModuleMountRoute"
 
     def get_meta(self) -> t.Mapping:
         return self._meta
@@ -115,33 +118,32 @@ def _build_route_operation(self, route: RouteOperation) -> None:
     def _build_ws_route_operation(self, route: WebsocketRouteOperation) -> None:
         route.build_route_operation(path_prefix=self.path, name=self.name)
 
-    def get_flatten_routes(self) -> t.List[BaseRoute]:
-        if not self._build:
-            for route in self.routes:
-                _route: RouteOperation = t.cast(RouteOperation, route)
+    def build_child_routes(self, flatten: bool = False) -> None:
+        for route in self.routes:
+            _route: RouteOperation = t.cast(RouteOperation, route)
+
+            route_versioning = reflect.get_metadata(VERSIONING_KEY, _route.endpoint)
+            route_guards = reflect.get_metadata(GUARDS_KEY, _route.endpoint)
 
-                route_versioning = reflect.get_metadata(VERSIONING_KEY, _route.endpoint)
-                route_guards = reflect.get_metadata(GUARDS_KEY, _route.endpoint)
+            if not route_versioning:
+                reflect.define_metadata(
+                    VERSIONING_KEY,
+                    self._version,
+                    _route.endpoint,
+                    default_value=set(),
+                )
+            if not route_guards:
+                reflect.define_metadata(
+                    GUARDS_KEY,
+                    self._route_guards,
+                    _route.endpoint,
+                    default_value=[],
+                )
+            if flatten:
                 openapi = (
                     reflect.get_metadata(OPENAPI_KEY, _route.endpoint)
                     or AttributeDict()
                 )
-
-                if not route_versioning:
-                    reflect.define_metadata(
-                        VERSIONING_KEY,
-                        self._version,
-                        _route.endpoint,
-                        default_value=set(),
-                    )
-                if not route_guards:
-                    reflect.define_metadata(
-                        GUARDS_KEY,
-                        self._route_guards,
-                        _route.endpoint,
-                        default_value=[],
-                    )
-
                 if isinstance(_route, Route):
                     if not openapi.tags and self._meta.get("tag"):
                         tags = {self._meta.get("tag")}
@@ -151,13 +153,57 @@ def get_flatten_routes(self) -> t.List[BaseRoute]:
                     self._build_route_operation(_route)
                 elif isinstance(_route, WebsocketRouteOperation):
                     self._build_ws_route_operation(_route)
+
+    def get_flatten_routes(self) -> t.List[BaseRoute]:
+        if not self._build:
+            self.build_child_routes(flatten=True)
             self._build = True
         return list(self.routes)
 
+    def matches(self, scope: TScope) -> t.Tuple[Match, TScope]:
+        match, _child_scope = super().matches(scope)
+        if match == Match.FULL:
+            scope_copy = dict(scope)
+            scope_copy.update(_child_scope)
+            partial: t.Optional[RouteOperation] = None
+            partial_scope = dict()
+
+            for route in self.routes:
+                # Determine if any route matches the incoming scope,
+                # and hand over to the matching route if found.
+                match, child_scope = route.matches(scope_copy)
+                if match == Match.FULL:
+                    _child_scope.update(child_scope)
+                    _child_scope[self._current_found_route_key] = route
+                    return Match.FULL, _child_scope
+                elif (
+                    match == Match.PARTIAL
+                    and partial is None
+                    and isinstance(route, RouteOperation)
+                ):
+                    partial = route
+                    partial_scope = dict(_child_scope)
+                    partial_scope.update(child_scope)
+
+            if partial:
+                partial_scope[self._current_found_route_key] = partial
+                return Match.PARTIAL, partial_scope
+
+        return Match.NONE, {}
+
+    async def handle(self, scope: TScope, receive: TReceive, send: TSend) -> None:
+        route = t.cast(t.Optional[Route], scope.get(self._current_found_route_key))
+        if route:
+            del scope[self._current_found_route_key]
+            await route.handle(scope, receive, send)
+            return
+        mount_router = t.cast(Router, self.app)
+        await mount_router.default(scope, receive, send)
+
 
 class ModuleRouter(ModuleMount):
     operation_definition_class: t.Type[OperationDefinitions] = OperationDefinitions
-    routes: ModuleRouteCollection  # type:ignore
+    routes: RouteCollection  # type:ignore
 
     def __init__(
         self,
@@ -172,7 +218,7 @@ def __init__(
         include_in_schema: bool = True,
     ) -> None:
         app = Router()
-        app.routes = ModuleRouteCollection()  # type:ignore
+        app.routes = RouteCollection()  # type:ignore
 
         super(ModuleRouter, self).__init__(
             path=path,

ellar/core/routing/router/route_collections.py

@@ -8,16 +8,48 @@
 from ellar.helper import generate_controller_operation_unique_id
 
 
-class ModuleRouteCollection(t.Sequence[BaseRoute]):
-    __slots__ = ("_routes",)
+class RouteCollection(t.Sequence[BaseRoute]):
+    __slots__ = ("_routes", "_served_routes")
 
     def __init__(self, routes: t.Optional[t.Sequence[BaseRoute]] = None) -> None:
         self._routes: t.Dict[int, BaseRoute] = OrderedDict()
         self.extend([] if routes is None else list(routes))
+        self._served_routes: t.List[BaseRoute] = []
+        self.sort_routes()
 
     @t.no_type_check
     def __getitem__(self, i: int) -> BaseRoute:
-        return list(self._routes.values()).__getitem__(i)
+        return self._served_routes.__getitem__(i)
+
+    def __setitem__(self, i: int, o: BaseRoute) -> None:
+        self._add_operation(o)
+        self.sort_routes()
+
+    def __len__(self) -> int:
+        return len(self._routes)
+
+    def __iter__(self) -> t.Iterator[BaseRoute]:
+        return iter(self._served_routes)
+
+    def append(self, __item: t.Any) -> None:
+        self._add_operation(__item)
+        self.sort_routes()
+
+    def get_routes(self) -> t.List[BaseRoute]:
+        return self._served_routes.copy()
+
+    def extend(self, routes: t.Sequence[BaseRoute]) -> "RouteCollection":
+        for item in routes:
+            self._add_operation(item)
+        self.sort_routes()
+        return self
+
+    def sort_routes(self) -> None:
+        # TODO: flatten the routes for faster look up
+        self._served_routes = list(self._routes.values())
+        self._served_routes.sort(
+            key=lambda e: getattr(e, "path", getattr(e, "host", ""))
+        )
 
     def _add_operation(
         self, operation: t.Union[RouteOperation, WebsocketRouteOperation, BaseRoute]
@@ -50,63 +82,3 @@ def _add_operation(
             # TODO
             """TODO: log warning to user when operations with the same route is found"""
         self._routes[_hash] = operation
-
-    def __setitem__(self, i: int, o: BaseRoute) -> None:
-        self._add_operation(o)
-
-    def __len__(self) -> int:
-        return len(self._routes)
-
-    def __iter__(self) -> t.Iterator[BaseRoute]:
-        return iter(self._routes.values())
-
-    def append(self, __item: t.Any) -> None:
-        self._add_operation(__item)
-
-    def extend(self, routes: t.Sequence[BaseRoute]) -> "ModuleRouteCollection":
-        for item in routes:
-            self.append(item)
-        return self
-
-
-class RouteCollection(ModuleRouteCollection):
-    __slots__ = ("_routes", "_served_routes")
-
-    def __init__(self, routes: t.Optional[t.Sequence[BaseRoute]] = None) -> None:
-        super().__init__(routes)
-        self._served_routes: t.List[BaseRoute] = []
-        self.sort_routes()
-
-    @t.no_type_check
-    def __getitem__(self, i: int) -> BaseRoute:
-        return self._served_routes.__getitem__(i)
-
-    def __setitem__(self, i: int, o: BaseRoute) -> None:
-        super().__setitem__(i, o)
-        self.sort_routes()
-
-    def __len__(self) -> int:
-        return len(self._routes)
-
-    def __iter__(self) -> t.Iterator[BaseRoute]:
-        return iter(self._served_routes)
-
-    def append(self, __item: t.Any) -> None:
-        super().append(__item)
-        self.sort_routes()
-
-    def get_routes(self) -> t.List[BaseRoute]:
-        return self._served_routes.copy()
-
-    def extend(self, routes: t.Sequence[BaseRoute]) -> "RouteCollection":
-        for item in routes:
-            self._add_operation(item)
-        self.sort_routes()
-        return self
-
-    def sort_routes(self) -> None:
-        # TODO: flatten the routes for faster look up
-        self._served_routes = list(self._routes.values())
-        self._served_routes.sort(
-            key=lambda e: getattr(e, "path", getattr(e, "host", ""))
-        )

ellar/core/routing/websocket/route.py

@@ -12,6 +12,7 @@
 from ellar.core.context import ExecutionContext
 from ellar.core.params import WebsocketEndpointArgsModel
 from ellar.exceptions import ImproperConfiguration, WebSocketRequestValidationError
+from ellar.helper import get_name
 from ellar.reflect import reflect
 
 from ..base import WebsocketRouteOperationBase
@@ -65,6 +66,7 @@ def __init__(
         extra_handler_type: t.Optional[t.Type[WebSocketExtraHandler]] = None,
         **handlers_kwargs: t.Any,
     ) -> None:
+        assert path.startswith("/"), "Routed paths must start with '/'"
         self._handlers_kwargs: t.Dict[str, t.Any] = dict(
             encoding=encoding,
             on_receive=None,
@@ -77,7 +79,13 @@ def __init__(
             t.Type[WebSocketExtraHandler]
         ] = extra_handler_type
 
-        super().__init__(path=path, endpoint=endpoint, name=name)
+        self.path = path
+        self.path_regex, self.path_format, self.param_convertors = compile_path(
+            self.path
+        )
+        self.endpoint = endpoint  # type: ignore
+        self.name = get_name(endpoint) if name is None else name
+
         self.endpoint_parameter_model: WebsocketEndpointArgsModel = NOT_SET
 
         reflect.define_metadata(CONTROLLER_OPERATION_HANDLER_KEY, self, self.endpoint)