code refactoring

Author: eadwinCode

ellar/__init__.py

@@ -1,3 +1,3 @@
 """Ellar - Python ASGI web framework for building fast, efficient, and scalable RESTful APIs and server-side applications."""
 
-__version__ = "0.8.0"
+__version__ = "0.8b"

ellar/auth/interceptor.py

@@ -1,7 +1,8 @@
 import typing as t
 from functools import partial
 
-from ellar.common import APIException, EllarInterceptor, IExecutionContext
+from ellar.common import APIException, EllarInterceptor, IExecutionContext, constants
+from ellar.core.services import reflector
 from ellar.di import injectable
 from starlette import status
 
@@ -34,6 +35,12 @@ def _get_policy_instance(
     async def intercept(
         self, context: IExecutionContext, next_interceptor: t.Callable[..., t.Coroutine]
     ) -> t.Any:
+        skip_auth = reflector.get_all_and_override(
+            constants.SKIP_AUTH, context.get_handler(), context.get_class()
+        )
+        if skip_auth is True:
+            return await next_interceptor()
+
         if not context.user.is_authenticated:
             raise self.exception_class(status_code=401)
 

ellar/events/__init__.py

@@ -3,9 +3,14 @@
 app_context_started = EventManager()
 app_context_teardown = EventManager()
 
+request_started = EventManager()
+request_teardown = EventManager()
+
 __all__ = [
     "app_context_started",
     "app_context_teardown",
+    "request_started",
+    "request_teardown",
     "EventHandler",
     "EventManager",
 ]

ellar/openapi/builder.py

@@ -4,8 +4,17 @@
 from ellar.common import IIdentitySchemes
 from ellar.common.compatible import AttributeDict, cached_property
 from ellar.common.constants import GUARDS_KEY
-from ellar.core.routing import ControllerRouteOperation, EllarMount, RouteOperation
-from ellar.openapi.constants import OPENAPI_OPERATION_KEY, OPENAPI_TAG, REF_TEMPLATE
+from ellar.core.routing import (
+    ControllerRouteOperation,
+    EllarControllerMount,
+    RouteOperation,
+)
+from ellar.openapi.constants import (
+    IGNORE_CONTROLLER_TYPE,
+    OPENAPI_OPERATION_KEY,
+    OPENAPI_TAG,
+    REF_TEMPLATE,
+)
 from ellar.pydantic import (
     EmailStr,
     GenerateJsonSchema,
@@ -54,17 +63,20 @@ def _get_openapi_route_document_models(self, app: "App") -> t.List[OpenAPIRoute]
 
         for route in app.routes:
             if (
-                isinstance(route, EllarMount)
+                isinstance(route, EllarControllerMount)
                 and len(route.routes) > 0
                 and route.include_in_schema
-                and route.get_control_type()
+                and route.get_controller_type()
             ):
-                control_type = route.get_control_type()
+                control_type = route.get_controller_type()
                 assert control_type
 
                 openapi_tags = AttributeDict(
                     reflector.get(OPENAPI_TAG, control_type) or {}
                 )
+                ignore_tag = (
+                    reflector.get(IGNORE_CONTROLLER_TYPE, control_type) or False
+                )
                 if route.name:
                     openapi_tags.setdefault("name", route.name)
 
@@ -80,7 +92,7 @@ def _get_openapi_route_document_models(self, app: "App") -> t.List[OpenAPIRoute]
                         ),
                     )
                 )
-                if openapi_tags:
+                if openapi_tags and not ignore_tag:
                     self._build.setdefault("tags", []).append(openapi_tags)
             elif (
                 isinstance(route, (RouteOperation, ControllerRouteOperation))
@@ -126,7 +138,7 @@ def create_document(self, app: "App") -> OpenAPI:
             separate_input_output_schemas=True,
         )
 
-        # mounts: t.List[t.Union[BaseRoute, EllarMount, Mount]] = []
+        # mounts: t.List[t.Union[BaseRoute, EllarControllerMount, Mount]] = []
         # for _, item in app.injector.get_templating_modules().items():
         #     mounts.extend(item.routers)
 

ellar/openapi/docs_ui/redocs.py

@@ -4,7 +4,7 @@
 class ReDocUI(IDocumentationUI):
     @property
     def name(self) -> str:
-        return "swagger"
+        return "redoc"
 
     @property
     def template_name(self) -> str:

ellar/openapi/module.py

@@ -92,7 +92,12 @@ def _get_document() -> OpenAPI:
 
                 document = _get_document
 
-            @router.get(openapi_url, include_in_schema=False, response=OpenAPI)
+            @router.get(
+                openapi_url,
+                include_in_schema=False,
+                response=OpenAPI,
+                name="openapi_schema",
+            )
             @set_metadata(OPENAPI_OPERATION_KEY, True)
             def openapi_schema() -> t.Any:
                 _docs = document
@@ -139,9 +144,9 @@ def _setup_document_manager(
 
             @t.no_type_check
             async def _doc(ctx: IExecutionContext) -> HTMLResponse:
-                request = ctx.switch_to_http_connection().get_request()
+                ctx.switch_to_http_connection().get_request()
                 html_str = render_template_string(
-                    docs_ui.template_string, request, **docs_ui.template_context
+                    docs_ui.template_string, **docs_ui.template_context
                 )
                 return HTMLResponse(html_str)
 

ellar/openapi/route_doc_models.py

@@ -17,7 +17,7 @@
     RouteParameterModelField,
 )
 from ellar.common.shortcuts import normalize_path
-from ellar.core.routing import EllarMount, RouteOperation
+from ellar.core.routing import EllarControllerMount, RouteOperation
 from ellar.core.services.reflector import reflector
 from ellar.openapi.constants import (
     IGNORE_CONTROLLER_TYPE,
@@ -58,7 +58,7 @@ def get_openapi_path(
 class OpenAPIMountDocumentation(OpenAPIRoute):
     def __init__(
         self,
-        mount: t.Union[EllarMount, Mount],
+        mount: t.Union[EllarControllerMount, Mount],
         global_route_models_update: t.Callable[
             ["OpenAPIMountDocumentation", t.Dict], t.Any
         ],
@@ -103,15 +103,20 @@ def _build_routes(self) -> t.List["OpenAPIRouteDocumentation"]:
                         **openapi,
                     )
                 )
-            elif isinstance(route, EllarMount):
+            elif isinstance(route, EllarControllerMount):
                 openapi_tags = AttributeDict(
-                    reflector.get(OPENAPI_TAG, route.get_control_type()) or {}
+                    reflector.get(OPENAPI_TAG, route.get_controller_type()) or {}
+                )
+                ignore_tag = (
+                    reflector.get(IGNORE_CONTROLLER_TYPE, route.get_controller_type())
+                    or False
                 )
-
                 if route.name:
                     openapi_tags.setdefault("name", route.name)
 
-                guards = reflector.get(GUARDS_KEY, route.get_control_type())
+                openapi_tags.update(name=f"{self.tag}:{openapi_tags.name}")
+
+                guards = reflector.get(GUARDS_KEY, route.get_controller_type())
 
                 self._global_route_models_update(
                     OpenAPIMountDocumentation(
@@ -121,7 +126,7 @@ def _build_routes(self) -> t.List["OpenAPIRouteDocumentation"]:
                         global_route_models_update=self._global_route_models_update,
                         path_prefix=self.path_format,
                     ),
-                    openapi_tags,
+                    openapi_tags if not ignore_tag else None,
                 )
         return routes
 

ellar/pydantic/decorator.py

@@ -1,5 +1,6 @@
 import typing as t
 
+from ellar.utils.importer import import_from_string
 from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
 from pydantic.json_schema import JsonSchemaValue
 from pydantic_core import CoreSchema
@@ -44,23 +45,41 @@ def __get_pydantic_core_schema__(
 
 
 class AllowTypeOfSource:
-    def __init__(self, schema: t.Optional[t.Dict[str, t.Any]] = None) -> None:
+    def __init__(
+        self,
+        schema: t.Optional[t.Dict[str, t.Any]] = None,
+        validator: t.Callable[..., bool] = None,
+        error_message: t.Optional[t.Callable[..., str]] = None,
+    ) -> None:
         self._schema = schema
+        self.validator = validator
+        self.error_message = error_message
 
     def __get_pydantic_core_schema__(
         self,
         source: t.Type[t.Any],
         handler: GetCoreSchemaHandler,
     ) -> CoreSchema:
         def validate(value: t.Any, *args: t.Any) -> t.Any:
-            if not isinstance(value, source):
-                raise ValueError(
-                    f"Expected an instance of {source}, got an instance of {type(value)}"
-                )
+            if isinstance(value, str) and len(value.split(":")) == 2:
+                value = import_from_string(value)
+
+            if (self.validator and not self.validator(source, value)) or (
+                not self.validator and not isinstance(value, source)
+            ):
+                self._handle_error(source, value)
             return value
 
         return with_info_plain_validator_function(validate)
 
+    def _handle_error(self, source: t.Any, value: t.Any) -> None:
+        error_message = (
+            f"Expected an instance of {source}, got an instance of {type(value)}"
+            if self.error_message is None
+            else self.error_message(source, value)
+        )
+        raise ValueError(error_message)
+
     def __get_pydantic_json_schema__(
         self, core_schema: CoreSchema, handler: GetJsonSchemaHandler
     ) -> JsonSchemaValue:  # pragma: no cover

ellar/reflect/__init__.py

@@ -1,4 +1,4 @@
 from ._reflect import reflect
-from .constants import REFLECT_TYPE
+from .utils import ensure_target, transfer_metadata
 
-__all__ = ["reflect", "REFLECT_TYPE"]
+__all__ = ["reflect", "ensure_target", "transfer_metadata"]