Merge pull request #59 from eadwinCode/guard_refactor

Guards Refactor

Author: eadwinCode

ellar/common/__init__.py

@@ -1,19 +1,27 @@
+import typing as t
+
 from ellar.core.params.params import Param, ParamTypes
 from ellar.core.routing import ModuleRouter
 
-from .decorators.base import set_metadata
-from .decorators.command import command
-from .decorators.controller import Controller
-from .decorators.exception import exception_handler
-from .decorators.file import file
-from .decorators.guards import guards
-from .decorators.html import render, template_filter, template_global
-from .decorators.middleware import middleware
-from .decorators.modules import Module
-from .decorators.openapi import openapi_info
-from .decorators.request import on_shutdown, on_startup
-from .decorators.serializer import serializer_filter
-from .decorators.versioning import version
+from .decorators import (
+    Controller,
+    Module,
+    command,
+    exception_handler,
+    extra_args,
+    file,
+    guards,
+    middleware,
+    on_shutdown,
+    on_startup,
+    openapi_info,
+    render,
+    serializer_filter,
+    set_metadata,
+    template_filter,
+    template_global,
+    version,
+)
 from .routing import (
     Body,
     Context,
@@ -91,4 +99,9 @@
     "Http",
     "UploadFile",
     "file",
+    "extra_args",
 ]
+
+
+def __dir__() -> t.List[str]:
+    return sorted(__all__)  # pragma: no cover

ellar/common/decorators/__init__.py

@@ -1,13 +1,40 @@
-from .base import set_metadata  # noqa
-from .command import command  # noqa
-from .controller import Controller  # noqa
-from .exception import exception_handler  # noqa
-from .file import file  # noqa
-from .guards import guards  # noqa
-from .html import render, template_filter, template_global  # noqa
-from .middleware import middleware  # noqa
-from .modules import Module  # noqa
-from .openapi import openapi_info  # noqa
-from .request import on_shutdown, on_startup  # noqa
-from .serializer import serializer_filter  # noqa
-from .versioning import version  # noqa
+import typing as t
+
+from .base import set_metadata
+from .command import command
+from .controller import Controller
+from .exception import exception_handler
+from .extra_args import extra_args
+from .file import file
+from .guards import guards
+from .html import render, template_filter, template_global
+from .middleware import middleware
+from .modules import Module
+from .openapi import openapi_info
+from .request import on_shutdown, on_startup
+from .serializer import serializer_filter
+from .versioning import version
+
+__all__ = [
+    "serializer_filter",
+    "Controller",
+    "version",
+    "guards",
+    "template_filter",
+    "template_global",
+    "file",
+    "render",
+    "on_startup",
+    "exception_handler",
+    "on_shutdown",
+    "command",
+    "set_metadata",
+    "middleware",
+    "openapi_info",
+    "Module",
+    "extra_args",
+]
+
+
+def __dir__() -> t.List[str]:
+    return sorted(__all__)  # pragma: no cover

ellar/common/decorators/base.py

@@ -8,13 +8,12 @@
 def set_metadata(
     meta_key: t.Any,
     meta_value: t.Optional[t.Any] = NOT_SET,
-    default_value: t.Any = None,
 ) -> t.Callable:
     if meta_value is NOT_SET:
         return partial(set_metadata, meta_key)
 
     def _decorator(target: t.Union[t.Callable, t.Any]) -> t.Union[t.Callable, t.Any]:
-        reflect.define_metadata(meta_key, meta_value, target, default_value)
+        reflect.define_metadata(meta_key, meta_value, target)
         return target
 
     return _decorator

ellar/common/decorators/controller.py

@@ -9,9 +9,11 @@
     CONTROLLER_METADATA,
     CONTROLLER_OPERATION_HANDLER_KEY,
     CONTROLLER_WATERMARK,
+    GUARDS_KEY,
     NOT_SET,
     OPERATION_ENDPOINT_KEY,
     REFLECT_TYPE,
+    VERSIONING_KEY,
 )
 from ellar.core import ControllerBase
 from ellar.core.controller import ControllerType
@@ -45,12 +47,19 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
                     operation = reflect.get_metadata(  # type: ignore
                         CONTROLLER_OPERATION_HANDLER_KEY, item
                     )
-                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, operation.endpoint)  # type: ignore
+                endpoint_func = operation.endpoint  # type:ignore
+                if reflect.has_metadata(CONTROLLER_CLASS_KEY, endpoint_func):
+                    raise Exception(
+                        f"{cls.__name__} Controller route tried to be processed more than once."
+                        f"\n-RouteFunction - {endpoint_func}."
+                        f"\n-Controller route function can not be reused once its under a `@Controller` decorator."
+                    )
+
+                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, endpoint_func)
                 reflect.define_metadata(
                     CONTROLLER_OPERATION_HANDLER_KEY,
-                    operation,
+                    [operation],
                     cls,
-                    default_value=[],
                 )
 
 
@@ -144,14 +153,17 @@ def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
         if not isinstance(cls, type):
             raise ImproperConfiguration(f"Controller is a class decorator - {cls}")
 
+        _controller_type = t.cast(t.Type[ControllerBase], cls)
+        new_cls = None
+
         if type(cls) is not ControllerType:
             # We force the cls to inherit from `ControllerBase` by creating another type.
             attrs = {}
             if hasattr(cls, REFLECT_TYPE):
                 attrs.update({REFLECT_TYPE: cls.__dict__[REFLECT_TYPE]})
-            cls = type(cls.__name__, (cls, ControllerBase), attrs)
+            new_cls = type(cls.__name__, (cls, ControllerBase), attrs)
 
-        _controller_type = t.cast(t.Type[ControllerBase], cls)
+            _controller_type = t.cast(t.Type[ControllerBase], new_cls)
 
         _tag = _controller_type.controller_class_name()
 
@@ -168,14 +180,23 @@ def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
                 .replace("controller", "")
             )
 
-        if not reflect.get_metadata(CONTROLLER_WATERMARK, _controller_type):
+        if not reflect.has_metadata(
+            CONTROLLER_WATERMARK, _controller_type
+        ) and not hasattr(cls, "__CONTROLLER_WATERMARK__"):
             reflect.define_metadata(CONTROLLER_WATERMARK, True, _controller_type)
             reflect_all_controller_type_routes(_controller_type)
             injectable(RequestScope)(cls)
 
             for key in CONTROLLER_METADATA.keys:
                 reflect.define_metadata(key, kwargs[key], _controller_type)
 
+            reflect.define_metadata(VERSIONING_KEY, kwargs.version, _controller_type)
+            reflect.define_metadata(GUARDS_KEY, kwargs.guards, _controller_type)
+
+        if new_cls:
+            # if we forced cls to inherit from ControllerBase, we need to block it from been processed
+            setattr(cls, "__CONTROLLER_WATERMARK__", True)
+
         return _controller_type
 
     if callable(prefix):

ellar/common/decorators/extra_args.py

@@ -0,0 +1,18 @@
+import typing as t
+
+from ellar.constants import EXTRA_ROUTE_ARGS_KEY
+from ellar.core.params import ExtraEndpointArg
+
+from .base import set_metadata as set_meta
+
+
+def extra_args(*args: ExtraEndpointArg) -> t.Callable:
+    """
+    =========FUNCTION DECORATOR ==============
+
+    Programmatically adds extra route function parameter.
+    see https://github.com/eadwinCode/ellar/blob/main/tests/test_routing/test_extra_args.py for usages
+    :param args: Collection ExtraEndpointArg
+    :return:
+    """
+    return set_meta(EXTRA_ROUTE_ARGS_KEY, list(args))

ellar/common/decorators/guards.py

@@ -18,4 +18,4 @@ def guards(
     :param _guards: Guard Type or Instance
     :return:
     """
-    return set_meta(GUARDS_KEY, _guards, default_value=[])
+    return set_meta(GUARDS_KEY, list(_guards))

ellar/common/decorators/modules.py

@@ -90,14 +90,14 @@ def Module(
     """
     kwargs = AttributeDict(
         name=name,
-        controllers=controllers,
+        controllers=list(controllers),
         base_directory=base_directory,
         static_folder=static_folder,
-        routers=routers,
-        providers=providers,
+        routers=list(routers),
+        providers=list(providers),
         template_folder=template_folder,
-        modules=modules,
-        commands=commands,
+        modules=list(modules),
+        commands=list(commands),
     )
 
     return partial(

ellar/common/decorators/openapi.py

@@ -33,5 +33,4 @@ def openapi_info(
             deprecated=deprecated,
             tags=tags,
         ),
-        default_value=AttributeDict(),
     )

ellar/common/decorators/versioning.py

@@ -13,6 +13,4 @@ def version(*_version: str) -> t.Callable:
     :param _version: allowed versions
     :return:
     """
-    return set_meta(
-        VERSIONING_KEY, set([str(i) for i in _version]), default_value=set()
-    )
+    return set_meta(VERSIONING_KEY, set([str(i) for i in _version]))

ellar/common/routing/__init__.py

@@ -1,3 +1,5 @@
+import typing as t
+
 from ellar.core.datastructures import UploadFile
 from ellar.core.params import Param, ParamTypes
 from ellar.core.routing import OperationDefinitions
@@ -69,3 +71,7 @@
     "Host",
     "Http",
 ]
+
+
+def __dir__() -> t.List[str]:
+    return sorted(__all__)  # pragma: no cover