django-ninja-aio-crud 0.4.0__tar.gz → 0.5.0__tar.gz

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.4.0
+Version: 0.5.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10
@@ -153,6 +153,32 @@ class Foo(ModelSerializer):
     optionals = [[("bar", str), ("active", bool)]
 ```
 
+- Instead of declaring your fields maybe you want to exclude some of them. Declaring "excludes" attribute into serializers will exclude the given fields. (You can declare only one between "fields" and "excludes").
+
+```python
+# models.py
+from django.db import models
+from ninja_aio.models import ModelSerializer
+
+
+class Foo(ModelSerializer):
+  name = models.CharField(max_length=30)
+  bar = models.CharField(max_length=30, default="")
+  active = models.BooleanField(default=False)
+
+  class ReadSerializer:
+    excludes = ["bar"]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    excludes = ["id", "name"]
+    optionals = [[("bar", str), ("active", bool)]
+```
+
+
 ### APIViewSet
 
 - View class used to automatically generate CRUD views. in your views.py import APIViewSet and define your api using NinjaAIO class. NinjaAIO class uses built-in parser and renderer which use orjson for data serialization.
@@ -161,8 +187,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -184,8 +208,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -211,6 +233,27 @@ class FooAPI(APIViewSet):
         return 200, {sum: data.n1 + data.n2}
 
 
+FooAPI().add_views_to_route()
+```
+
+- You can also choose to disable any operation from crud by declaring "disbale" attribute. You can give "all" to disable every crud operation except for additional views.
+
+```python
+# views.py
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+
+from .models import Foo
+
+api = NinjaAIO()
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+  disable = ["retrieve", "update"]
+
+
 FooAPI().add_views_to_route()
 ```
 
@@ -223,8 +266,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 api = NinjaAIO()
 
@@ -294,8 +335,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo, Bar
 
@@ -361,8 +400,6 @@ class CustomJWTBearer(AsyncJWTBearer):
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet, APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/README.md

@@ -124,6 +124,32 @@ class Foo(ModelSerializer):
     optionals = [[("bar", str), ("active", bool)]
 ```
 
+- Instead of declaring your fields maybe you want to exclude some of them. Declaring "excludes" attribute into serializers will exclude the given fields. (You can declare only one between "fields" and "excludes").
+
+```python
+# models.py
+from django.db import models
+from ninja_aio.models import ModelSerializer
+
+
+class Foo(ModelSerializer):
+  name = models.CharField(max_length=30)
+  bar = models.CharField(max_length=30, default="")
+  active = models.BooleanField(default=False)
+
+  class ReadSerializer:
+    excludes = ["bar"]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    excludes = ["id", "name"]
+    optionals = [[("bar", str), ("active", bool)]
+```
+
+
 ### APIViewSet
 
 - View class used to automatically generate CRUD views. in your views.py import APIViewSet and define your api using NinjaAIO class. NinjaAIO class uses built-in parser and renderer which use orjson for data serialization.
@@ -132,8 +158,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -155,8 +179,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -182,6 +204,27 @@ class FooAPI(APIViewSet):
         return 200, {sum: data.n1 + data.n2}
 
 
+FooAPI().add_views_to_route()
+```
+
+- You can also choose to disable any operation from crud by declaring "disbale" attribute. You can give "all" to disable every crud operation except for additional views.
+
+```python
+# views.py
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+
+from .models import Foo
+
+api = NinjaAIO()
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+  disable = ["retrieve", "update"]
+
+
 FooAPI().add_views_to_route()
 ```
 
@@ -194,8 +237,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 api = NinjaAIO()
 
@@ -265,8 +306,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo, Bar
 
@@ -332,8 +371,6 @@ class CustomJWTBearer(AsyncJWTBearer):
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet, APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/ninja_aio/models.py

@@ -5,7 +5,7 @@ from ninja.schema import Schema
 from ninja.orm import create_schema
 
 from django.db import models
-from django.http import HttpResponse, HttpRequest
+from django.http import HttpRequest
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models.fields.related_descriptors import (
     ReverseManyToOneDescriptor,
@@ -14,7 +14,7 @@ from django.db.models.fields.related_descriptors import (
 )
 
 from .exceptions import SerializeError
-from .types import S_TYPES, REL_TYPES, F_TYPES, ModelSerializerMeta
+from .types import S_TYPES, REL_TYPES, F_TYPES, SCHEMA_TYPES, ModelSerializerMeta
 
 
 class ModelUtil:
@@ -24,12 +24,15 @@ class ModelUtil:
     @property
     def serializable_fields(self):
         if isinstance(self.model, ModelSerializerMeta):
-            return self.model.ReadSerializer.fields
+            return self.model.get_fields("read")
         return [field.name for field in self.model._meta.get_fields()]
 
     def verbose_name_path_resolver(self) -> str:
         return "-".join(self.model._meta.verbose_name_plural.split(" "))
 
+    def verbose_name_view_resolver(self) -> str:
+        return self.model._meta.verbose_name_plural.replace(" ", "")
+
     async def get_object(self, request: HttpRequest, pk: int | str):
         q = {self.model._meta.pk.attname: pk}
         obj_qs = self.model.objects.select_related()
@@ -121,7 +124,7 @@ class ModelUtil:
         if isinstance(self.model, ModelSerializerMeta):
             await obj.custom_actions(customs)
             await obj.post_create()
-        return 201, await self.read_s(request, obj, obj_schema)
+        return await self.read_s(request, obj, obj_schema)
 
     async def read_s(
         self,
@@ -150,7 +153,7 @@ class ModelUtil:
     async def delete_s(self, request: HttpRequest, pk: int | str):
         obj = await self.get_object(request, pk)
         await obj.adelete()
-        return HttpResponse(status=204)
+        return None
 
 
 class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
@@ -160,15 +163,18 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class CreateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
-        optionals: list[str] = []
+        optionals: list[tuple[str, type]] = []
+        excludes: list[str] = []
 
     class ReadSerializer:
         fields: list[str] = []
+        excludes: list[str] = []
 
     class UpdateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
-        optionals: list[str] = []
+        optionals: list[tuple[str, type]] = []
+        excludes: list[str] = []
 
     @property
     def has_custom_fields_create(self):
@@ -195,24 +201,61 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
         return self.has_optional_fields_create or self.has_optional_fields_update
 
     @classmethod
-    def _get_special_fields(cls, s_type: type[S_TYPES], f_type: type[F_TYPES]):
-        try:
-            match s_type:
-                case "create":
-                    fields = getattr(cls.CreateSerializer, f_type)
-                case "update":
-                    fields = getattr(cls.UpdateSerializer, f_type)
-        except AttributeError:
-            return []
+    def _get_fields(cls, s_type: type[S_TYPES], f_type: type[F_TYPES]):
+        match s_type:
+            case "create":
+                fields = getattr(cls.CreateSerializer, f_type, [])
+            case "update":
+                fields = getattr(cls.UpdateSerializer, f_type, [])
+            case "read":
+                fields = getattr(cls.ReadSerializer, f_type, [])
         return fields
 
     @classmethod
     def _is_special_field(
         cls, s_type: type[S_TYPES], field: str, f_type: type[F_TYPES]
     ):
-        special_fields = cls._get_special_fields(s_type, f_type)
+        special_fields = cls._get_fields(s_type, f_type)
         return any(field in special_f for special_f in special_fields)
 
+    @classmethod
+    def _generate_model_schema(
+        cls,
+        schema_type: type[SCHEMA_TYPES],
+        depth: int = None,
+    ) -> Schema:
+        match schema_type:
+            case "In":
+                s_type = "create"
+            case "Patch":
+                s_type = "update"
+            case "Out":
+                fields, reverse_rels, excludes = cls.get_schema_out_data()
+                if not fields and not reverse_rels and not excludes:
+                    return None
+                return create_schema(
+                    model=cls,
+                    name=f"{cls._meta.model_name}SchemaOut",
+                    depth=depth,
+                    fields=fields,
+                    custom_fields=reverse_rels,
+                    exclude=excludes,
+                )
+        fields = cls.get_fields(s_type)
+        customs = cls.get_custom_fields(s_type) + cls.get_optional_fields(s_type)
+        excludes = cls.get_excluded_fields(s_type)
+        return (
+            create_schema(
+                model=cls,
+                name=f"{cls._meta.model_name}Schema{schema_type}",
+                fields=fields,
+                custom_fields=customs,
+                exclude=excludes,
+            )
+            if fields or customs or excludes
+            else None
+        )
+
     @classmethod
     def verbose_name_path_resolver(cls) -> str:
         return "-".join(cls._meta.verbose_name_plural.split(" "))
@@ -292,7 +335,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     def get_schema_out_data(cls):
         fields = []
         reverse_rels = []
-        for f in cls.ReadSerializer.fields:
+        for f in cls.get_fields("read"):
             field_obj = getattr(cls, f)
             if isinstance(field_obj, ManyToManyDescriptor):
                 rel_obj: ModelSerializer = field_obj.field.related_model
@@ -312,7 +355,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
                 reverse_rels.append(rel_data)
                 continue
             fields.append(f)
-        return fields, reverse_rels
+        return fields, reverse_rels, cls.get_excluded_fields("read")
 
     @classmethod
     def is_custom(cls, field: str):
@@ -328,49 +371,31 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
 
     @classmethod
     def get_custom_fields(cls, s_type: type[S_TYPES]):
-        return cls._get_special_fields(s_type, "customs")
+        return cls._get_fields(s_type, "customs")
 
     @classmethod
     def get_optional_fields(cls, s_type: type[S_TYPES]):
         return [
             (field, field_type, None)
-            for field, field_type in cls._get_special_fields(s_type, "optionals")
+            for field, field_type in cls._get_fields(s_type, "optionals")
         ]
+    
+    @classmethod
+    def get_excluded_fields(cls, s_type: type[S_TYPES]):
+        return cls._get_fields(s_type, "excludes")
+    
+    @classmethod
+    def get_fields(cls, s_type: type[S_TYPES]):
+        return cls._get_fields(s_type, "fields")
 
     @classmethod
     def generate_read_s(cls, depth: int = 1) -> Schema:
-        fields, reverse_rels = cls.get_schema_out_data()
-        customs = [custom for custom in reverse_rels]
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaOut",
-            depth=depth,
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("Out", depth)
 
     @classmethod
     def generate_create_s(cls) -> Schema:
-        fields = getattr(cls.CreateSerializer, "fields", []) + [
-            field[0] for field in cls.get_optional_fields("create")
-        ]
-        customs = cls.get_custom_fields("create") + cls.get_optional_fields("create")
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaIn",
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("In")
 
     @classmethod
     def generate_update_s(cls) -> Schema:
-        fields = getattr(cls.UpdateSerializer, "fields", []) + [
-            field[0] for field in cls.get_optional_fields("update")
-        ]
-        customs = cls.get_custom_fields("update") + cls.get_optional_fields("update")
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaPatch",
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("Patch")

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/ninja_aio/types.py

@@ -2,10 +2,11 @@ from typing import Literal
 
 from django.db.models import Model
 
-S_TYPES = Literal["create", "update"]
+S_TYPES = Literal["read", "create", "update"]
 REL_TYPES = Literal["many", "one"]
-F_TYPES = Literal["customs", "optionals"]
-
+F_TYPES = Literal["fields", "customs", "optionals", "excludes"]
+SCHEMA_TYPES = Literal["In", "Out", "Patch"]
+VIEW_TYPES = Literal["list", "retrieve", "create", "update", "delete", "all"]
 
 class ModelSerializerType(type):
     def __repr__(self):

{django_ninja_aio_crud-0.4.0 → django_ninja_aio_crud-0.5.0}/ninja_aio/views.py

@@ -1,14 +1,15 @@
 from typing import List
 
-from ninja import NinjaAPI, Router, Schema
+from ninja import NinjaAPI, Router, Schema, Path
 from ninja.constants import NOT_SET
 from ninja.pagination import paginate, AsyncPaginationBase, PageNumberPagination
 from django.http import HttpRequest
 from django.db.models import Model
+from pydantic import create_model
 
 from .models import ModelSerializer, ModelUtil
 from .schemas import GenericMessageSchema
-from .types import ModelSerializerMeta
+from .types import ModelSerializerMeta, VIEW_TYPES
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
 
@@ -55,7 +56,6 @@ class APIView:
         async def some_method(request, *args, **kwargs):
             pass
         """
-        pass
 
     def add_views(self):
         self.views()
@@ -73,23 +73,45 @@ class APIViewSet:
     schema_update: Schema | None = None
     auths: list | None = NOT_SET
     pagination_class: type[AsyncPaginationBase] = PageNumberPagination
+    disable: list[type[VIEW_TYPES]] = []
 
     def __init__(self) -> None:
         self.router = Router(tags=[self.model._meta.model_name.capitalize()])
         self.path = "/"
-        self.path_retrieve = f"{self.model._meta.pk.attname}/"
+        self.path_retrieve = f"{{{self.model._meta.pk.attname}}}/"
         self.error_codes = ERROR_CODES
         self.model_util = ModelUtil(self.model)
-        self.schema_out, self.schema_update, self.schema_in = self.get_schemas()
+        self.schema_out, self.schema_in, self.schema_update = self.get_schemas()
+        self.path_schema = self._create_path_schema()
+
+    @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 _create_path_schema(self):
+        fields = {
+            self.model._meta.pk.attname: (str | int , ...),
+        }
+        return create_model(f"{self.model._meta.model_name}PathSchema", **fields)
 
     def get_schemas(self):
         if isinstance(self.model, ModelSerializerMeta):
             return (
                 self.model.generate_read_s(),
-                self.model.generate_update_s(),
                 self.model.generate_create_s(),
+                self.model.generate_update_s(),
             )
-        return self.schema_out, self.schema_update, self.schema_in
+        return self.schema_out, self.schema_in, self.schema_update
 
     def create_view(self):
         @self.router.post(
@@ -98,9 +120,10 @@ class APIViewSet:
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def create(request: HttpRequest, data: self.schema_in):
-            return await self.model_util.create_s(request, data, self.schema_out)
+            return 201, await self.model_util.create_s(request, data, self.schema_out)
 
         create.__name__ = f"create_{self.model._meta.model_name}"
+        return create
 
     def list_view(self):
         @self.router.get(
@@ -117,7 +140,6 @@ class APIViewSet:
             if isinstance(self.model, ModelSerializerMeta):
                 qs = await self.model.queryset_request(request)
             rels = self.model_util.get_reverse_relations()
-            print(rels)
             if len(rels) > 0:
                 qs = qs.prefetch_related(*rels)
             objs = [
@@ -126,7 +148,8 @@ class APIViewSet:
             ]
             return objs
 
-        list.__name__ = f"list_{self.model._meta.verbose_name_plural}"
+        list.__name__ = f"list_{self.model_util.verbose_name_view_resolver()}"
+        return list
 
     def retrieve_view(self):
         @self.router.get(
@@ -134,11 +157,12 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def retrieve(request: HttpRequest, pk: int | str):
+        async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):
             obj = await self.model_util.get_object(request, pk)
             return await self.model_util.read_s(request, obj, self.schema_out)
 
         retrieve.__name__ = f"retrieve_{self.model._meta.model_name}"
+        return retrieve
 
     def update_view(self):
         @self.router.patch(
@@ -146,10 +170,11 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def update(request: HttpRequest, data: self.schema_update, pk: int | str):
+        async def update(request: HttpRequest, data: self.schema_update, pk: Path[self.path_schema]):
             return await self.model_util.update_s(request, data, pk, self.schema_out)
 
         update.__name__ = f"update_{self.model._meta.model_name}"
+        return update
 
     def delete_view(self):
         @self.router.delete(
@@ -157,10 +182,11 @@ class APIViewSet:
             auth=self.auths,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        async def delete(request: HttpRequest, pk: int | str):
-            return await self.model_util.delete_s(request, pk)
+        async def delete(request: HttpRequest, pk: Path[self.path_schema]):
+            return 204, await self.model_util.delete_s(request, pk)
 
         delete.__name__ = f"delete_{self.model._meta.model_name}"
+        return delete
 
     def views(self):
         """
@@ -194,14 +220,18 @@ class APIViewSet:
         async def some_method(request, *args, **kwargs):
             pass
         """
-        pass
 
     def add_views(self):
-        self.create_view()
-        self.list_view()
-        self.retrieve_view()
-        self.update_view()
-        self.delete_view()
+        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