django-ninja-aio-crud 0.6.3__tar.gz → 0.7.0__tar.gz

{django_ninja_aio_crud-0.6.3 → django_ninja_aio_crud-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.6.3
+Version: 0.7.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10
@@ -472,7 +472,7 @@ api = NinjaAIO()
 class FooAPI(APIViewSet):
   model = Foo
   api = api
-  auths = CustomJWTBearer()
+  auth = CustomJWTBearer()
 
 
 class ExampleSchemaOut(Schema):
@@ -488,10 +488,10 @@ class SumView(APIView):
   api = api
   api_router_path = "numbers-sum/"
   router_tag = "Sum"
-  auths = CustomJWTBearer()
+  auth = CustomJWTBearer()
 
   def views(self):
-    @self.router.post("/", response={200: ExampleSchemaOut}, auth=self.auths)
+    @self.router.post("/", response={200: ExampleSchemaOut}, auth=self.auth)
     async def sum(request: HttpRequest, data: ExampleSchemaIn):
         return 200, {sum: data.n1 + data.n2}
 

{django_ninja_aio_crud-0.6.3 → django_ninja_aio_crud-0.7.0}/README.md

@@ -441,7 +441,7 @@ api = NinjaAIO()
 class FooAPI(APIViewSet):
   model = Foo
   api = api
-  auths = CustomJWTBearer()
+  auth = CustomJWTBearer()
 
 
 class ExampleSchemaOut(Schema):
@@ -457,10 +457,10 @@ class SumView(APIView):
   api = api
   api_router_path = "numbers-sum/"
   router_tag = "Sum"
-  auths = CustomJWTBearer()
+  auth = CustomJWTBearer()
 
   def views(self):
-    @self.router.post("/", response={200: ExampleSchemaOut}, auth=self.auths)
+    @self.router.post("/", response={200: ExampleSchemaOut}, auth=self.auth)
     async def sum(request: HttpRequest, data: ExampleSchemaIn):
         return 200, {sum: data.n1 + data.n2}
 

{django_ninja_aio_crud-0.6.3 → django_ninja_aio_crud-0.7.0}/ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """Django Ninja AIO CRUD - Rest Framework"""
 
-__version__ = "0.6.3"
+__version__ = "0.7.0"
 
 from .api import NinjaAIO
 

{django_ninja_aio_crud-0.6.3 → django_ninja_aio_crud-0.7.0}/ninja_aio/models.py

@@ -11,6 +11,8 @@ from django.db.models.fields.related_descriptors import (
     ReverseManyToOneDescriptor,
     ReverseOneToOneDescriptor,
     ManyToManyDescriptor,
+    ForwardManyToOneDescriptor,
+    ForwardOneToOneDescriptor,
 )
 
 from .exceptions import SerializeError
@@ -99,7 +101,7 @@ class ModelUtil:
             if isinstance(self.model, ModelSerializerMeta):
                 if self.model.is_custom(k):
                     continue
-                if self.model.is_optional(k) and k is None:
+                if self.model.is_optional(k) and v is None:
                     continue
             field_obj = getattr(self.model, k).field
             if isinstance(field_obj, models.BinaryField):
@@ -332,6 +334,41 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
         """
         pass
 
+    @classmethod
+    def get_forward_relation_schema(cls, obj: type["ModelSerializer"], field: str):
+        cls_f = []
+        for rel_f in obj.ReadSerializer.fields:
+            rel_f_obj = getattr(obj, rel_f)
+            if isinstance(
+                rel_f_obj,
+                (
+                    ManyToManyDescriptor,
+                    ReverseManyToOneDescriptor,
+                    ReverseOneToOneDescriptor,
+                ),
+            ):
+                if isinstance(rel_f_obj, ManyToManyDescriptor):
+                    rel_obj: ModelSerializer = rel_f_obj.field.related_model
+                    if rel_f_obj.reverse:
+                        rel_obj = rel_f_obj.field.model
+                elif isinstance(rel_f_obj, ReverseManyToOneDescriptor):
+                    rel_obj = rel_f_obj.field.model
+                else:  # ReverseOneToOneDescriptor
+                    rel_obj = rel_f_obj.related.related_model
+                if not rel_obj == cls:
+                    continue
+                cls_f.append(rel_f)
+                obj.ReadSerializer.fields.remove(rel_f)
+        rel_schema = obj.generate_read_s(depth=0)
+        rel_data = (
+            field,
+            rel_schema | None,
+            None,
+        )
+        if len(cls_f) > 0:
+            obj.ReadSerializer.fields.append(*cls_f)
+        return rel_data
+
     @classmethod
     def get_reverse_relation_schema(
         cls, obj: type["ModelSerializer"], rel_type: type[REL_TYPES], field: str
@@ -372,6 +409,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     def get_schema_out_data(cls):
         fields = []
         reverse_rels = []
+        rels = []
         for f in cls.get_fields("read"):
             field_obj = getattr(cls, f)
             if isinstance(
@@ -394,15 +432,26 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
                     rel_obj = field_obj.related.related_model
                     rel_type = "one"
 
+                if not rel_obj.get_fields("read") or not rel_obj.get_custom_fields("read"):
+                    continue
                 rel_data = cls.get_reverse_relation_schema(rel_obj, rel_type, f)
                 reverse_rels.append(rel_data)
                 continue
+            if isinstance(
+                field_obj, (ForwardOneToOneDescriptor, ForwardManyToOneDescriptor)
+            ):
+                rel_obj = field_obj.field.related_model
+                if not rel_obj.get_fields("read") or not rel_obj.get_custom_fields("read"):
+                    continue
+                rel_data = cls.get_forward_relation_schema(rel_obj, f)
+                rels.append(rel_data)
+                continue
             fields.append(f)
         return (
             fields,
             reverse_rels,
             cls.get_excluded_fields("read"),
-            cls.get_custom_fields("read"),
+            cls.get_custom_fields("read") + rels,
         )
 
     @classmethod

django_ninja_aio_crud-0.7.0/ninja_aio/views.py

@@ -0,0 +1,271 @@
+from typing import List
+
+from ninja import NinjaAPI, Router, Schema, Path, Query
+from ninja.constants import NOT_SET
+from ninja.pagination import paginate, AsyncPaginationBase, PageNumberPagination
+from django.http import HttpRequest
+from django.db.models import Model, QuerySet
+from pydantic import create_model
+
+from .models import ModelSerializer, ModelUtil
+from .schemas import GenericMessageSchema
+from .types import ModelSerializerMeta, VIEW_TYPES
+
+ERROR_CODES = frozenset({400, 401, 404, 428})
+
+
+class APIView:
+    api: NinjaAPI
+    router_tag: str
+    api_route_path: str
+    auth: list | None = NOT_SET
+
+    def __init__(self) -> None:
+        self.router = Router(tags=[self.router_tag])
+        self.error_codes = ERROR_CODES
+
+    def views(self):
+        """
+        Override this method to add your custom views. For example:
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        You can add multilple views just doing:
+
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        If you provided a list of auths you can chose which of your views
+        should be authenticated:
+
+        AUTHENTICATED VIEW:
+
+        @self.router.get(some_path, response=some_schema, auth=self.auths)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        NOT AUTHENTICATED VIEW:
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+        """
+
+    def add_views(self):
+        self.views()
+        return self.router
+
+    def add_views_to_route(self):
+        return self.api.add_router(f"{self.api_route_path}/", self.add_views())
+
+
+class APIViewSet:
+    model: ModelSerializer | Model
+    api: NinjaAPI
+    schema_in: Schema | None = None
+    schema_out: Schema | None = None
+    schema_update: Schema | None = None
+    auth: list | None = NOT_SET
+    pagination_class: type[AsyncPaginationBase] = PageNumberPagination
+    query_params: dict[str, tuple[type, ...]] = {}
+    disable: list[type[VIEW_TYPES]] = []
+
+    def __init__(self) -> None:
+        self.error_codes = ERROR_CODES
+        self.model_util = ModelUtil(self.model)
+        self.schema_out, self.schema_in, self.schema_update = self.get_schemas()
+        self.path_schema = self._generate_path_schema()
+        self.filters_schema = self._generate_filters_schema()
+        self.router_tag = self.model_util.model_name.capitalize()
+        self.router = Router(tags=[self.router_tag])
+        self.path = "/"
+        self.path_retrieve = f"{{{self.model_util.model_pk_name}}}/"
+
+    @property
+    def _crud_views(self):
+        """
+        key: view type (create, list, retrieve, update, delete or all)
+        value: tuple with schema and view method
+        """
+        return {
+            "create": (self.schema_in, self.create_view),
+            "list": (self.schema_out, self.list_view),
+            "retrieve": (self.schema_out, self.retrieve_view),
+            "update": (self.schema_update, self.update_view),
+            "delete": (None, self.delete_view),
+        }
+
+    def _generate_schema(self, fields: dict, name: str) -> Schema:
+        return create_model(f"{self.model_util.model_name}{name}", **fields)
+
+    def _generate_path_schema(self):
+        return self._generate_schema(
+            {self.model_util.model_pk_name: (int | str, ...)}, "PathSchema"
+        )
+
+    def _generate_filters_schema(self):
+        return self._generate_schema(self.query_params, "FiltersSchema")
+
+    def _get_pk(self, data: Schema):
+        return data.model_dump()[self.model_util.model_pk_name]
+
+    def get_schemas(self):
+        if isinstance(self.model, ModelSerializerMeta):
+            return (
+                self.model.generate_read_s(),
+                self.model.generate_create_s(),
+                self.model.generate_update_s(),
+            )
+        return self.schema_out, self.schema_in, self.schema_update
+
+    async def query_params_handler(
+        self, queryset: QuerySet[ModelSerializer], filters: dict
+    ):
+        """
+        Override this method to handle request query params making queries to the database
+        based on filters or any other logic. This method should return a queryset. filters
+        are given already dumped by the schema.
+        """
+        return queryset
+
+    def create_view(self):
+        @self.router.post(
+            self.path,
+            auth=self.auth,
+            response={201: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def create(request: HttpRequest, data: self.schema_in):
+            return 201, await self.model_util.create_s(request, data, self.schema_out)
+
+        create.__name__ = f"create_{self.model_util.model_name}"
+        return create
+
+    def list_view(self):
+        @self.router.get(
+            self.path,
+            auth=self.auth,
+            response={
+                200: List[self.schema_out],
+                self.error_codes: GenericMessageSchema,
+            },
+        )
+        @paginate(self.pagination_class)
+        async def list(
+            request: HttpRequest, filters: Query[self.filters_schema] = None
+        ):
+            qs = self.model.objects.select_related()
+            if isinstance(self.model, ModelSerializerMeta):
+                qs = await self.model.queryset_request(request)
+            rels = self.model_util.get_reverse_relations()
+            if len(rels) > 0:
+                qs = qs.prefetch_related(*rels)
+            if filters is not None:
+                qs = await self.query_params_handler(qs, filters.model_dump())
+            objs = [
+                await self.model_util.read_s(request, obj, self.schema_out)
+                async for obj in qs.all()
+            ]
+            return objs
+
+        list.__name__ = f"list_{self.model_util.verbose_name_view_resolver()}"
+        return list
+
+    def retrieve_view(self):
+        @self.router.get(
+            self.path_retrieve,
+            auth=self.auth,
+            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):
+            obj = await self.model_util.get_object(request, self._get_pk(pk))
+            return await self.model_util.read_s(request, obj, self.schema_out)
+
+        retrieve.__name__ = f"retrieve_{self.model_util.model_name}"
+        return retrieve
+
+    def update_view(self):
+        @self.router.patch(
+            self.path_retrieve,
+            auth=self.auth,
+            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def update(
+            request: HttpRequest, data: self.schema_update, pk: Path[self.path_schema]
+        ):
+            return await self.model_util.update_s(
+                request, data, self._get_pk(pk), self.schema_out
+            )
+
+        update.__name__ = f"update_{self.model_util.model_name}"
+        return update
+
+    def delete_view(self):
+        @self.router.delete(
+            self.path_retrieve,
+            auth=self.auth,
+            response={204: None, self.error_codes: GenericMessageSchema},
+        )
+        async def delete(request: HttpRequest, pk: Path[self.path_schema]):
+            return 204, await self.model_util.delete_s(request, self._get_pk(pk))
+
+        delete.__name__ = f"delete_{self.model_util.model_name}"
+        return delete
+
+    def views(self):
+        """
+        Override this method to add your custom views. For example:
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        You can add multilple views just doing:
+
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        If you provided a list of auths you can chose which of your views
+        should be authenticated:
+
+        AUTHENTICATED VIEW:
+
+        @self.router.get(some_path, response=some_schema, auth=self.auths)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        NOT AUTHENTICATED VIEW:
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+        """
+
+    def add_views(self):
+        if "all" in self.disable:
+            self.views()
+            return self.router
+
+        for views_type, (schema, view) in self._crud_views.items():
+            if views_type not in self.disable and (
+                schema is not None or views_type == "delete"
+            ):
+                view()
+
+        self.views()
+        return self.router
+
+    def add_views_to_route(self):
+        return self.api.add_router(
+            f"{self.model_util.verbose_name_path_resolver()}/",
+            self.add_views(),
+        )