Rename PydanticSerializer to Serializer

Author: eadwinCode

ellar/core/conf/app_settings_models.py

@@ -6,7 +6,7 @@
 from starlette.responses import JSONResponse
 
 from ellar.core.versioning import BaseAPIVersioning, DefaultAPIVersioning
-from ellar.serializer import PydanticSerializer, SerializerFilter
+from ellar.serializer import Serializer, SerializerFilter
 
 
 class TVersioning(BaseAPIVersioning):
@@ -37,7 +37,7 @@ def validate(cls: t.Type["Middleware"], v: t.Any) -> t.Any:
         return v
 
 
-class ConfigValidationSchema(PydanticSerializer):
+class ConfigValidationSchema(Serializer):
     _filter = SerializerFilter(
         exclude={
             "EXCEPTION_HANDLERS_DECORATOR",

ellar/core/response/__init__.py

@@ -1,7 +1,7 @@
 from ellar.serializer import (
     BaseSerializer,
-    DataClassSerializer,
-    PydanticSerializer,
+    DataclassSerializer,
+    Serializer,
     serialize_object,
 )
 
@@ -27,8 +27,8 @@
     "PlainTextResponse",
     "RedirectResponse",
     "Response",
-    "PydanticSerializer",
+    "Serializer",
     "BaseSerializer",
-    "DataClassSerializer",
+    "DataclassSerializer",
     "serialize_object",
 ]

ellar/core/response/model/base.py

@@ -11,9 +11,9 @@
 from ellar.exceptions import RequestValidationError
 from ellar.serializer import (
     BaseSerializer,
-    DataClassSerializer,
-    PydanticSerializer,
-    PydanticSerializerBase,
+    DataclassSerializer,
+    Serializer,
+    SerializerBase,
     SerializerFilter,
     convert_dataclass_to_pydantic_model,
     serialize_object,
@@ -156,16 +156,16 @@ def _get_modified_type(
         if not isinstance(outer_type_, type):
             raise Exception(f"{outer_type_} is not a type")
 
-        if issubclass(outer_type_, DataClassSerializer):
+        if issubclass(outer_type_, DataclassSerializer):
             schema_model = outer_type_.get_pydantic_model()
-            cls = type(outer_type_.__name__, (schema_model, PydanticSerializerBase), {})
+            cls = type(outer_type_.__name__, (schema_model, SerializerBase), {})
             return t.cast(t.Type[BaseSerializer], cls)
 
         if isinstance(outer_type_, type) and issubclass(outer_type_, (BaseSerializer,)):
             return outer_type_
 
         if issubclass(outer_type_, BaseModel):
-            cls = type(outer_type_.__name__, (outer_type_, PydanticSerializer), dict())
+            cls = type(outer_type_.__name__, (outer_type_, Serializer), dict())
             return t.cast(t.Type[BaseSerializer], cls)
 
         if is_dataclass(outer_type_):
@@ -180,7 +180,7 @@ def _get_modified_type(
             return outer_type_
 
         attrs = {"__annotations__": getattr(outer_type_, "__annotations__", ())}
-        cls = type(outer_type_.__name__, (outer_type_, PydanticSerializer), attrs)
+        cls = type(outer_type_.__name__, (outer_type_, Serializer), attrs)
 
         return t.cast(t.Type[BaseSerializer], cls)
 

ellar/core/routing/base.py

@@ -20,8 +20,9 @@
 
 class RouteOperationBase:
     _meta: OperationMeta
-
+    path: str
     endpoint: t.Callable
+    methods: t.Set[str]
 
     @t.no_type_check
     def __call__(
@@ -98,4 +99,4 @@ def matches(self, scope: TScope) -> t.Tuple[Match, TScope]:
 
 
 class WebsocketRouteOperationBase(RouteOperationBase, ABC):
-    pass
+    methods: t.Set[str] = {"WS"}  # just to avoid attribute error

ellar/core/routing/controller/decorator.py

@@ -6,20 +6,15 @@
 
 from ellar.constants import NOT_SET
 from ellar.di import RequestScope, injectable
-from ellar.helper import get_name
 
 from .model import ControllerBase, ControllerType
 from .router import ControllerRouter
 
-if t.TYPE_CHECKING:
+if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
     from ellar.core.routing.base import RouteOperationBase
 
 
-class MissingAPIControllerDecoratorException(Exception):
-    pass
-
-
 def get_route_functions(cls: t.Type) -> t.Iterable["RouteOperationBase"]:
     from ellar.core.routing.base import RouteOperationBase
 
@@ -28,20 +23,11 @@ def get_route_functions(cls: t.Type) -> t.Iterable["RouteOperationBase"]:
             yield method
 
 
-def compute_api_route_function(
-    base_cls: t.Type, controller_instance: "ControllerDecorator"
-) -> None:
-    for cls_route_function in get_route_functions(base_cls):
-        controller_instance.add_route(cls_route_function)
-
-
 class ControllerDecorator:
     __slots__ = (
         "_controller_class",
-        "_routes",
-        "_mount",
-        "_tag",
         "_meta",
+        "_router",
     )
 
     def __init__(
@@ -73,8 +59,6 @@ def __init__(
 
         # `controller_class`
         self._controller_class: t.Optional[t.Type[ControllerBase]] = None
-        # `_path_operations`
-        self._routes: t.Dict[str, BaseRoute] = {}
 
         self._meta = dict(
             tag=tag,
@@ -87,11 +71,14 @@ def __init__(
             guards=guards or [],
             include_in_schema=include_in_schema,
         )
-        self._mount: t.Optional[ControllerRouter] = None
+        self._router: t.Optional["ControllerRouter"] = None
 
         if _controller_class:
             self(_controller_class)
 
+    def get_meta(self) -> t.Dict:
+        return self._meta
+
     def __call__(self, cls: t.Type) -> "ControllerDecorator":
         if type(cls) is not ControllerType:
             # We force the cls to inherit from `ControllerBase` by creating another type.
@@ -106,35 +93,38 @@ def __call__(self, cls: t.Type) -> "ControllerDecorator":
         if self._meta["path"] is NOT_SET:
             self._meta["path"] = f"/{tag}"
 
+        if not self._meta["name"]:
+            self._meta["name"] = (
+                str(self._controller_class.controller_class_name())
+                .lower()
+                .replace("controller", "")
+            )
+
+        self._router = ControllerRouter(
+            **self._meta,  # type: ignore
+            controller_type=self.get_controller_type(),
+        )
         bases = inspect.getmro(cls)
         for base_cls in reversed(bases):
             if base_cls not in [ABC, ControllerBase, object]:
-                compute_api_route_function(base_cls, self)
+                self.compute_api_route_function(base_cls)
 
-        cls = injectable(RequestScope)(cls)
+        injectable(RequestScope)(cls)
 
-        if not self._meta["name"]:
-            self._meta["name"] = str(cls.__name__).lower().replace("controller", "")
         return self
 
+    def compute_api_route_function(self, base_cls: t.Type) -> None:
+        for cls_route_function in get_route_functions(base_cls):
+            self.get_router().routes.append(cls_route_function)
+
     def get_controller_type(self) -> t.Type[ControllerBase]:
         assert self._controller_class, "Controller not properly initialised"
         return self._controller_class
 
-    def get_mount(self) -> "ControllerRouter":
-        if not self._mount:
-            self._mount = ControllerRouter(
-                routes=list(self._routes.values()),
-                **self._meta,  # type: ignore
-                controller_type=self.get_controller_type(),
-            )
-        return self._mount
-
-    def add_route(self, cls_route_function: "RouteOperationBase") -> None:
-        self._routes[get_name(cls_route_function.endpoint)] = t.cast(
-            BaseRoute, cls_route_function
-        )
+    def get_router(self) -> "ControllerRouter":
+        assert self._router, "Controller not properly initialised"
+        return self._router
 
     def build_routes(self) -> t.List[BaseRoute]:
-        mount = self.get_mount()
-        return mount.build_routes()
+        router = self.get_router()
+        return router.build_routes()

ellar/core/routing/controller/model.py

@@ -2,29 +2,6 @@
 
 from ellar.core.context import ExecutionContext
 
-if t.TYPE_CHECKING:
-    from ellar.core.routing.base import RouteOperationBase
-    from ellar.core.routing.controller.decorator import ControllerDecorator
-
-
-class MissingAPIControllerDecoratorException(Exception):
-    pass
-
-
-def get_route_functions(cls: t.Type) -> t.Iterable["RouteOperationBase"]:
-    from ellar.core.routing.base import RouteOperationBase
-
-    for method in cls.__dict__.values():
-        if isinstance(method, RouteOperationBase):
-            yield method
-
-
-def compute_api_route_function(
-    base_cls: t.Type, controller_instance: "ControllerDecorator"
-) -> None:
-    for cls_route_function in get_route_functions(base_cls):
-        controller_instance.add_route(cls_route_function)
-
 
 class ControllerType(type):
     _controller_name: t.Optional[str]

ellar/core/routing/controller/route.py

@@ -11,6 +11,8 @@
 
 
 class ControllerRouteOperation(ControllerRouteOperationBase, RouteOperation):
+    methods: t.Set[str]
+
     def build_route_operation(  # type:ignore
         self,
         path_prefix: str = "/",

ellar/core/routing/controller/router.py

@@ -1,21 +1,23 @@
 import typing as t
 
-from starlette.routing import BaseRoute
+from starlette.routing import Router
 
 from ellar.core.guard import GuardCanActivate
 
-from ..router import ModuleRouterBase
+from ..router.module import ModuleRouterBase
+from ..router.route_collections import ModuleRouteCollection
 from .model import ControllerBase
 from .route import ControllerRouteOperation
 from .websocket.route import ControllerWebsocketRouteOperation
 
 
 class ControllerRouter(ModuleRouterBase):
+    routes: ModuleRouteCollection  # type:ignore
+
     def __init__(
         self,
         path: str,
         controller_type: t.Type[ControllerBase],
-        routes: t.Sequence[BaseRoute] = None,
         name: str = None,
         tag: t.Optional[str] = None,
         description: t.Optional[str] = None,
@@ -27,6 +29,8 @@ def __init__(
         ] = None,
         include_in_schema: bool = True,
     ) -> None:
+        app = Router()
+        app.routes = ModuleRouteCollection()  # type:ignore
         super(ControllerRouter, self).__init__(
             path=path,
             tag=tag,
@@ -36,8 +40,8 @@ def __init__(
             external_doc_url=external_doc_url,
             version=version,
             guards=guards,
-            routes=routes,
             include_in_schema=include_in_schema,
+            app=app,
         )
         self.controller_type = controller_type
 

ellar/core/routing/route.py

@@ -48,6 +48,9 @@ def __init__(
 
         assert path.startswith("/"), "Routed paths must start with '/'"
         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
@@ -71,24 +74,29 @@ def build_route_operation(  # type:ignore
         include_in_schema: bool = True,
         **kwargs: t.Any,
     ) -> None:
-        self.path_regex, self.path_format, self.param_convertors = compile_path(
-            f"{path_prefix.rstrip('/')}/{self.path.lstrip('/')}"
-        )
-
-        self.endpoint_parameter_model = self.request_endpoint_args_model(
-            path=self.path_format,
-            endpoint=self.endpoint,
-            operation_unique_id=self.get_operation_unique_id(
-                method=list(self.methods)[0]
-            ),
-            param_converters=self.param_convertors,
-        )
-
-        if self._meta.extra_route_args:
-            self.endpoint_parameter_model.add_extra_route_args(
-                *self._meta.extra_route_args
+        _path_changed = False
+        if path_prefix not in ("", "/") and path_prefix not in self.path:
+            self.path = f"{path_prefix.rstrip('/')}/{self.path.lstrip('/')}"
+            self.path_regex, self.path_format, self.param_convertors = compile_path(
+                self.path
+            )
+            _path_changed = True
+
+        if self.endpoint_parameter_model is NOT_SET or _path_changed:
+            self.endpoint_parameter_model = self.request_endpoint_args_model(
+                path=self.path_format,
+                endpoint=self.endpoint,
+                operation_unique_id=self.get_operation_unique_id(
+                    methods=list(self.methods)
+                ),
+                param_converters=self.param_convertors,
             )
-        self.endpoint_parameter_model.build_model()
+
+            if self._meta.extra_route_args:
+                self.endpoint_parameter_model.add_extra_route_args(
+                    *self._meta.extra_route_args
+                )
+            self.endpoint_parameter_model.build_model()
         self.include_in_schema = include_in_schema
         if name:
             self.name = f"{name}:{self.name}"
@@ -105,9 +113,12 @@ def _load_model(self) -> None:
             route_responses=self._defined_responses  # type: ignore
         )
 
-    def get_operation_unique_id(self, method: str) -> str:
+    def get_operation_unique_id(self, methods: t.Union[t.Sequence[str], str]) -> str:
+        _methods: t.Sequence[str] = (
+            list(methods) if isinstance(methods, set) else [t.cast(str, methods)]
+        )
         return generate_operation_unique_id(
-            name=self.name, path=self.path_format, method=method
+            name=self.name, path=self.path_format, methods=_methods
         )
 
     async def _handle_request(self, context: ExecutionContext) -> None:

ellar/core/routing/router/__init__.py

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