Dropped Controller Responses Model and removed py3.6 codes

Author: eadwinCode

ninja_extra/controllers/base.py

@@ -33,7 +33,7 @@
 from ninja_extra.constants import ROUTE_FUNCTION, THROTTLED_FUNCTION
 from ninja_extra.exceptions import APIException, NotFound, PermissionDenied, bad_request
 from ninja_extra.helper import get_function_name
-from ninja_extra.operation import ControllerPathView, Operation
+from ninja_extra.operation import Operation, PathView
 from ninja_extra.permissions import AllowAny, BasePermission
 from ninja_extra.permissions.base import OperationHolderMixin
 from ninja_extra.shortcuts import (
@@ -277,7 +277,7 @@ def __init__(
         # `controller_class` target class that the APIController wraps
         self._controller_class: Optional[Type["ControllerBase"]] = None
         # `_path_operations` a converted dict of APIController route function used by Django-Ninja library
-        self._path_operations: Dict[str, ControllerPathView] = {}
+        self._path_operations: Dict[str, PathView] = {}
         self._controller_class_route_functions: Dict[str, RouteFunction] = {}
         # `permission_classes` a collection of BasePermission Types
         # a fallback if route functions has no permissions definition
@@ -357,7 +357,7 @@ def __call__(self, cls: Type) -> Union[Type, Type["ControllerBase"]]:
         return cls
 
     @property
-    def path_operations(self) -> Dict[str, ControllerPathView]:
+    def path_operations(self) -> Dict[str, PathView]:
         return self._path_operations
 
     def set_api_instance(self, api: "NinjaExtraAPI") -> None:
@@ -410,7 +410,7 @@ def _add_operation_from_route_function(self, route_function: RouteFunction) -> N
                 f"endpoint={get_function_name(route_function.route.view_func)}"
             )
 
-        route_function.operation = self.add_api_operation(  # type: ignore
+        route_function.operation = self.add_api_operation(
             view_func=route_function.as_view, **route_function.route.route_params.dict()
         )
 
@@ -440,7 +440,7 @@ def add_api_operation(
         if self._prefix_has_route_param:
             path = normalize_path("/".join([i for i in (self.prefix, path) if i]))
         if path not in self._path_operations:
-            path_view = ControllerPathView()
+            path_view = PathView()
             self._path_operations[path] = path_view
         else:
             path_view = self._path_operations[path]

ninja_extra/controllers/response.py

@@ -1,103 +1,22 @@
-import sys
 from typing import (
     Any,
-    Dict,
-    Generic,
     Optional,
-    Tuple,
     Type,
-    TypeVar,
     Union,
     no_type_check,
 )
 
 from ninja import Schema
 
 from .. import status
-from ..schemas import DetailSchema, IdSchema, OkSchema
 
-T = TypeVar("T")
-SCHEMA_KEY = "_schema"
 
-if sys.version_info < (3, 7):  # pragma: no cover
-    from typing import GenericMeta  # type: ignore[attr-defined]
-
-    class ControllerResponseMeta(GenericMeta):
-        @no_type_check
-        def __new__(mcls, name: str, bases: Tuple, namespace: Dict, **kwargs: Any):
-            args = kwargs.get("args")
-            if args and args[0].__name__ != "T":
-                t = args[0]
-                origin_schema = namespace.get(SCHEMA_KEY)
-                if origin_schema and hasattr(origin_schema, "__generic_model__"):
-                    schema = origin_schema.__generic_model__[t]
-                else:
-                    schema = origin_schema[t]
-                namespace[SCHEMA_KEY] = schema
-            res = super().__new__(mcls, name, bases, namespace, **kwargs)
-            return res
-
-    class GenericControllerResponse(metaclass=ControllerResponseMeta):
-        @no_type_check
-        def __new__(
-            cls: Type["ControllerResponse[T]"], *args: Any, **kwargs: Any
-        ) -> "ControllerResponse[T]":
-            if cls._gorg is Generic or "_schema" not in cls.__dict__:
-                raise TypeError(
-                    "Type Generic cannot be instantiated; "
-                    "it can be used only as a base class"
-                )
-            return object.__new__(cls)
-
-else:
-    _generic_types_cache: Dict[
-        Tuple[Type[Any], Union[Any, Tuple[Any, ...]]], Type["ControllerResponse"]
-    ] = {}
-    GenericControllerResponseT = TypeVar(
-        "GenericControllerResponseT", bound="GenericControllerResponse"
-    )
-
-    class ControllerResponseMeta(type):
-        pass
-
-    class GenericControllerResponse(metaclass=ControllerResponseMeta):
-        def __new__(  # type:ignore[misc]
-            cls: Type["ControllerResponse[T]"], *args: Any, **kwargs: Any
-        ) -> "ControllerResponse[T]":
-            if "_schema" not in cls.__dict__:
-                raise TypeError(
-                    "Type Generic cannot be instantiated; "
-                    "it can be used only as a base class"
-                )
-            return object.__new__(cls)
-
-        @no_type_check
-        def __class_getitem__(cls: Type[GenericControllerResponseT], item: Any) -> Any:
-            if isinstance(item, tuple):
-                raise TypeError("Tuple Generic Model not supported")
-
-            _key = (cls, item)
-            _cached_value = _generic_types_cache.get(_key)
-            if _cached_value:
-                return _cached_value
-
-            if str(type(item)) == "<class 'typing.TypeVar'>":
-                result = super().__class_getitem__(item)
-            else:
-                new_schema = cls.__dict__.get(SCHEMA_KEY)
-                if hasattr(new_schema, "__generic_model__"):
-                    new_schema = new_schema.__generic_model__[item]
-
-                result = type(
-                    f"{cls.__name__}[{item.__name__}]", (cls,), {SCHEMA_KEY: new_schema}
-                )
-            _generic_types_cache[_key] = result
-            return result
-
-
-class ControllerResponse(GenericControllerResponse, Generic[T]):
+class ControllerResponse:
     status_code: int = status.HTTP_204_NO_CONTENT
-    _schema: Optional[T]
+    _schema: Optional[Any]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        raise RuntimeError("Controller Response are no longer supported.")
 
     @classmethod
     def get_schema(cls) -> Union[Schema, Type[Schema], Any]:  # pragma: no cover
@@ -106,96 +25,11 @@ def get_schema(cls) -> Union[Schema, Type[Schema], Any]:  # pragma: no cover
     def convert_to_schema(self) -> Any:  # pragma: no cover
         raise NotImplementedError
 
+    @no_type_check
+    def __class_getitem__(cls: Type["ControllerResponse"], item: Any) -> Any:
+        raise RuntimeError("Controller Response are no longer supported.")
 
-class Id(ControllerResponse[T]):
-    """
-    Creates a 201 response with id information
-    {
-        id: int| str| UUID4| UUID1| UUID3| UUID5,
-    }
-    Example:
-           Id(423) ==> 201, {id: 423}
-           OR
-           Id[int](424) ==> 201, {id: 424}
-           Id[UUID4]("883a1a3d-7b10-458d-bccc-f9b7219342c9")
-                ==> 201, {id: "883a1a3d-7b10-458d-bccc-f9b7219342c9"}
-    """
-
-    _schema = IdSchema[Any]
-    status_code: int = status.HTTP_201_CREATED
-
-    def __init__(self, id: T) -> None:
-        super(Id, self).__init__()
-        self.id = id
-
-    def convert_to_schema(self) -> Any:
-        return self._schema.from_orm(self)
-
-    @classmethod
-    def get_schema(cls) -> Union[Schema, Type[Schema], Any]:
-        return cls._schema
 
-
-class Ok(ControllerResponse[T]):
-    """
-    Creates a 200 response with a detail information.
-    {
-        detail: str| List[Dict] | List[str] | Dict,
-    }
-
-    Example:
-       Ok('Saved Successfully') ==> 200, {detail: 'Saved Successfully'}
-       OR
-       class ASchema(BaseModel):
-            name: str
-            age: int
-
-       OK[ASchema](ASchema(name='Eadwin', age=18)) ==> 200, {detail: {'name':'Eadwin', 'age': 18}}
-    """
-
-    status_code: int = status.HTTP_200_OK
-    _schema = OkSchema[Any]
-
-    def __init__(self, message: Optional[Any] = None) -> None:
-        super(Ok, self).__init__()
-        self.detail = message or "Action was successful"
-
-    def convert_to_schema(self) -> Any:
-        return self._schema.from_orm(self)
-
-    @classmethod
-    def get_schema(cls) -> Union[Schema, Type[Schema], Any]:
-        return cls._schema
-
-
-class Detail(ControllerResponse[T]):
-    """
-    Creates a custom response with detail information
-    {
-        detail: str| List[Dict] | List[str] | Dict,
-    }
-    Example:
-       Detail('Invalid Request', 404) ==> 404, {detail: 'Invalid Request'}
-       OR
-        class ErrorSchema(BaseModel):
-            message: str
-
-       Detail[ErrorSchema](dict(message='Bad Request'),400) ==> 400, {detail: {'message':'Bad Request'}}
-    """
-
-    status_code: int = status.HTTP_200_OK
-    _schema = DetailSchema[Any]
-
-    def __init__(
-        self, message: Optional[Any] = None, status_code: int = status.HTTP_200_OK
-    ) -> None:
-        super(Detail, self).__init__()
-        self.detail = message or "Action was successful"
-        self.status_code = status_code or self.status_code
-
-    def convert_to_schema(self) -> Any:
-        return self._schema.from_orm(self)
-
-    @classmethod
-    def get_schema(cls) -> Union[Schema, Type[Schema], Any]:
-        return cls._schema
+Detail = ControllerResponse
+Ok = ControllerResponse
+Id = ControllerResponse

ninja_extra/controllers/route/__init__.py

@@ -24,7 +24,6 @@
     ROUTE_FUNCTION,
     ROUTE_METHODS,
 )
-from ninja_extra.controllers.response import ControllerResponse, ControllerResponseMeta
 from ninja_extra.permissions import BasePermission
 from ninja_extra.schemas import RouteParameter
 
@@ -78,20 +77,10 @@ def __init__(
             )
 
         _response = response
-        if (
-            inspect.isclass(response) and type(response) == ControllerResponseMeta
-        ) or isinstance(response, ControllerResponse):
-            response = cast(ControllerResponse, response)
-            _response = {response.status_code: response.get_schema()}
-        elif isinstance(response, list):
+        if isinstance(response, list):
             _response_computed = {}
             for item in response:
-                if (
-                    inspect.isclass(item) and type(item) == ControllerResponseMeta
-                ) or isinstance(item, ControllerResponse):
-                    item = cast(ControllerResponse, item)
-                    _response_computed.update({item.status_code: item.get_schema()})
-                elif isinstance(item, dict):
+                if isinstance(item, dict):
                     _response_computed.update(item)
                 elif isinstance(item, tuple):
                     _response_computed.update({item[0]: item[1]})

ninja_extra/controllers/route/route_functions.py

@@ -6,13 +6,11 @@
 
 from django.http import HttpRequest, HttpResponse
 
-from ninja_extra.controllers.response import ControllerResponse
-
 from ...dependency_resolver import get_injector, service_resolver
 from .context import RouteContext, get_route_execution_context
 
 if TYPE_CHECKING:  # pragma: no cover
-    from ninja_extra.operation import ControllerOperation
+    from ninja_extra.operation import Operation
 
     from ...controllers.base import APIController, ControllerBase
     from ...controllers.route import Route
@@ -31,7 +29,7 @@ def __init__(
         self, route: "Route", api_controller: Optional["APIController"] = None
     ):
         self.route = route
-        self.operation: Optional["ControllerOperation"] = None
+        self.operation: Optional["Operation"] = None
         self.has_request_param = False
         self.api_controller = api_controller
         self.as_view = wraps(route.view_func)(self.get_view_function())
@@ -100,8 +98,8 @@ def _process_view_function_result(self, result: Any) -> Any:
         and creates an api response if result is ControllerResponseSchema
         """
 
-        if result and isinstance(result, ControllerResponse):
-            return result.status_code, result.convert_to_schema()
+        # if result and isinstance(result, ControllerResponse):
+        #     return result.status_code, result.convert_to_schema()
         return result
 
     def _get_controller_instance(self) -> "ControllerBase":