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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.3.1
-Summary: Django Ninja AIO CRUD - Rest Framework 
+Version: 0.5.0
+Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -73,7 +73,7 @@ pip install django-ninja-aio-crud
 ### ModelSerializer
 
 - You can serialize your models using ModelSerializer and made them inherit from it. In your models.py import ModelSerializer
-```Python
+```python
 # models.py
 from django.db import models
 from ninja_aio.models import ModelSerializer
@@ -95,7 +95,7 @@ class Foo(ModelSerializer):
 
 - ReadSerializer, CreateSerializer, UpdateSerializer are used to define which fields would be included in runtime schemas creation. You can also specify custom fields and handle their function by overriding custom_actions ModelSerializer's method(custom fields are only available for Create and Update serializers).
 
-```Python
+```python
 # models.py
 from django.db import models
 from ninja_aio.models import ModelSerializer
@@ -130,17 +130,63 @@ class Foo(ModelSerializer):
 
 - post create method is a custom method that comes out to handle actions which will be excuted after that the object is created. It can be used, indeed, for example to handle custom fields' actions.
 
+- You can also define optional fields for you Create and Update serializers (remember to give your optional fields a default). To declare an optional fields you have to give the field type too.
+```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:
+    fields = ["id", "name", "bar"]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    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.
 
-```Python
+```python
 # 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
 
@@ -157,13 +203,11 @@ FooAPI().add_views_to_route()
 
 - and that's it, your model CRUD will be automatically created. You can also add custom views to CRUD overriding the built-in method "views".
 
-```Python
+```python
 # views.py
 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
 
@@ -189,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()
 ```
 
@@ -196,13 +261,11 @@ FooAPI().add_views_to_route()
 
 - View class to code generic views class based. In your views.py import APIView class.
 
-```Python
+```python
 # views.py
 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()
 
@@ -235,7 +298,7 @@ SumView().add_views_to_route()
 
 - Define models:
 
-```Python
+```python
 # models.py
 class Bar(ModelSerializer):
     name = models.CharField(max_length=30)
@@ -268,12 +331,10 @@ class Foo(ModelSerializer):
 
 - Define views:
 
-```Python
+```python
 # 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
 
@@ -312,7 +373,7 @@ BarAPI().add_views_to_route()
 
 - AsyncJWTBearer built-in class is an authenticator class which use joserfc module. It cames out with authenticate method which validate given claims. Override auth handler method to write your own authentication method. Default algorithms used is RS256. a jwt Token istance is set as class atribute so you can use it by self.dcd.  
 
-```Python
+```python
 from ninja_aio.auth import AsyncJWTBearer
 from django.conf import settings
 from django.http import HttpRequest
@@ -334,13 +395,11 @@ class CustomJWTBearer(AsyncJWTBearer):
 
 - Then add it to views.
 
-```Python
+```python
 # views.py
 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
 
@@ -382,7 +441,7 @@ SumView().add_views_to_route()
 
 - By default APIViewSet list view uses Django Ninja built-in AsyncPagination class "PageNumberPagination". You can customize and assign it to APIViewSet class. To make your custom pagination consult **<a href="https://django-ninja.dev/guides/response/pagination/#async-pagination">Django Ninja pagination documentation</a>**.
 
-```Python
+```python
 # views.py
 
 class FooAPI(APIViewSet):

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

@@ -44,7 +44,7 @@ pip install django-ninja-aio-crud
 ### ModelSerializer
 
 - You can serialize your models using ModelSerializer and made them inherit from it. In your models.py import ModelSerializer
-```Python
+```python
 # models.py
 from django.db import models
 from ninja_aio.models import ModelSerializer
@@ -66,7 +66,7 @@ class Foo(ModelSerializer):
 
 - ReadSerializer, CreateSerializer, UpdateSerializer are used to define which fields would be included in runtime schemas creation. You can also specify custom fields and handle their function by overriding custom_actions ModelSerializer's method(custom fields are only available for Create and Update serializers).
 
-```Python
+```python
 # models.py
 from django.db import models
 from ninja_aio.models import ModelSerializer
@@ -101,17 +101,63 @@ class Foo(ModelSerializer):
 
 - post create method is a custom method that comes out to handle actions which will be excuted after that the object is created. It can be used, indeed, for example to handle custom fields' actions.
 
+- You can also define optional fields for you Create and Update serializers (remember to give your optional fields a default). To declare an optional fields you have to give the field type too.
+```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:
+    fields = ["id", "name", "bar"]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    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.
 
-```Python
+```python
 # 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
 
@@ -128,13 +174,11 @@ FooAPI().add_views_to_route()
 
 - and that's it, your model CRUD will be automatically created. You can also add custom views to CRUD overriding the built-in method "views".
 
-```Python
+```python
 # views.py
 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
 
@@ -160,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()
 ```
 
@@ -167,13 +232,11 @@ FooAPI().add_views_to_route()
 
 - View class to code generic views class based. In your views.py import APIView class.
 
-```Python
+```python
 # views.py
 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()
 
@@ -206,7 +269,7 @@ SumView().add_views_to_route()
 
 - Define models:
 
-```Python
+```python
 # models.py
 class Bar(ModelSerializer):
     name = models.CharField(max_length=30)
@@ -239,12 +302,10 @@ class Foo(ModelSerializer):
 
 - Define views:
 
-```Python
+```python
 # 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
 
@@ -283,7 +344,7 @@ BarAPI().add_views_to_route()
 
 - AsyncJWTBearer built-in class is an authenticator class which use joserfc module. It cames out with authenticate method which validate given claims. Override auth handler method to write your own authentication method. Default algorithms used is RS256. a jwt Token istance is set as class atribute so you can use it by self.dcd.  
 
-```Python
+```python
 from ninja_aio.auth import AsyncJWTBearer
 from django.conf import settings
 from django.http import HttpRequest
@@ -305,13 +366,11 @@ class CustomJWTBearer(AsyncJWTBearer):
 
 - Then add it to views.
 
-```Python
+```python
 # views.py
 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
 
@@ -353,7 +412,7 @@ SumView().add_views_to_route()
 
 - By default APIViewSet list view uses Django Ninja built-in AsyncPagination class "PageNumberPagination". You can customize and assign it to APIViewSet class. To make your custom pagination consult **<a href="https://django-ninja.dev/guides/response/pagination/#async-pagination">Django Ninja pagination documentation</a>**.
 
-```Python
+```python
 # views.py
 
 class FooAPI(APIViewSet):

django_ninja_aio_crud-0.5.0/ninja_aio/__init__.py

@@ -0,0 +1,7 @@
+"""Django Ninja AIO CRUD - Rest Framework"""
+
+__version__ = "0.5.0"
+
+from .api import NinjaAIO
+
+__all__ = ["NinjaAIO"]

{django_ninja_aio_crud-0.3.1 → django_ninja_aio_crud-0.5.0}/ninja_aio/api.py

@@ -8,6 +8,7 @@ from ninja.constants import NOT_SET, NOT_SET_TYPE
 
 from .parsers import ORJSONParser
 from .renders import ORJSONRenderer
+from .exceptions import set_api_exception_handlers
 
 
 class NinjaAIO(NinjaAPI):
@@ -19,14 +20,14 @@ class NinjaAIO(NinjaAPI):
         openapi_url: str | None = "/openapi.json",
         docs: DocsBase = Swagger(),
         docs_url: str | None = "/docs",
-        docs_decorator = None,
+        docs_decorator=None,
         servers: list[dict[str, Any]] | None = None,
         urls_namespace: str | None = None,
         csrf: bool = False,
-        auth: Sequence[Any]| NOT_SET_TYPE = NOT_SET,
+        auth: Sequence[Any] | NOT_SET_TYPE = NOT_SET,
         throttle: BaseThrottle | list[BaseThrottle] | NOT_SET_TYPE = NOT_SET,
         default_router: Router | None = None,
-        openapi_extra: dict[str, Any] | None = None
+        openapi_extra: dict[str, Any] | None = None,
     ):
         super().__init__(
             title=title,
@@ -45,4 +46,8 @@ class NinjaAIO(NinjaAPI):
             openapi_extra=openapi_extra,
             renderer=ORJSONRenderer(),
             parser=ORJSONParser(),
-        )
+        )
+
+    def set_default_exception_handlers(self):
+        set_api_exception_handlers(self)
+        super().set_default_exception_handlers()

{django_ninja_aio_crud-0.3.1 → django_ninja_aio_crud-0.5.0}/ninja_aio/auth.py

@@ -5,7 +5,6 @@ from ninja.security.http import HttpBearer
 from .exceptions import AuthError
 
 
-
 class AsyncJwtBearer(HttpBearer):
     jwt_public: jwk.RSAKey
     claims: dict[str, dict]

{django_ninja_aio_crud-0.3.1 → django_ninja_aio_crud-0.5.0}/ninja_aio/exceptions.py

@@ -1,3 +1,8 @@
+from functools import partial
+from ninja import NinjaAPI
+from django.http import HttpRequest, HttpResponse
+
+
 class BaseException(Exception):
     error: str | dict = ""
     status_code: int = 400
@@ -22,3 +27,15 @@ class SerializeError(BaseException):
 
 class AuthError(BaseException):
     pass
+
+
+def _default_serialize_error(
+    request: HttpRequest, exc: SerializeError, api: "NinjaAPI"
+) -> HttpResponse:
+    return api.create_response(request, exc.error, status=exc.status_code)
+
+
+def set_api_exception_handlers(api: type[NinjaAPI]) -> None:
+    api.add_exception_handler(
+        SerializeError, partial(_default_serialize_error, api=api)
+    )

{django_ninja_aio_crud-0.3.1 → 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, 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()
@@ -58,11 +61,18 @@ class ModelUtil:
     async def parse_input_data(self, request: HttpRequest, data: Schema):
         payload = data.model_dump()
         customs = {}
+        optionals = []
         if isinstance(self.model, ModelSerializerMeta):
             customs = {k: v for k, v in payload.items() if self.model.is_custom(k)}
+            optionals = [
+                k for k, v in payload.items() if self.model.is_optional(k) and v is None
+            ]
         for k, v in payload.items():
-            if isinstance(self.model, ModelSerializerMeta) and self.model.is_custom(k):
-                continue
+            if isinstance(self.model, ModelSerializerMeta):
+                if self.model.is_custom(k):
+                    continue
+                if self.model.is_optional(k) and k is None:
+                    continue
             field_obj = getattr(self.model, k).field
             if isinstance(field_obj, models.BinaryField):
                 try:
@@ -73,7 +83,9 @@ class ModelUtil:
                 rel_util = ModelUtil(field_obj.related_model)
                 rel: ModelSerializer = await rel_util.get_object(request, v)
                 payload |= {k: rel}
-        new_payload = {k: v for k, v in payload.items() if k not in customs}
+        new_payload = {
+            k: v for k, v in payload.items() if k not in (customs.keys() or optionals)
+        }
         return new_payload, customs
 
     async def parse_output_data(self, request: HttpRequest, data: Schema):
@@ -106,16 +118,13 @@ class ModelUtil:
         return payload
 
     async def create_s(self, request: HttpRequest, data: Schema, obj_schema: Schema):
-        try:
-            payload, customs = await self.parse_input_data(request, data)
-            pk = (await self.model.objects.acreate(**payload)).pk
-            obj = await self.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
+        payload, customs = await self.parse_input_data(request, data)
+        pk = (await self.model.objects.acreate(**payload)).pk
+        obj = await self.get_object(request, pk)
         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,
@@ -130,11 +139,7 @@ class ModelUtil:
     async def update_s(
         self, request: HttpRequest, data: Schema, pk: int | str, obj_schema: Schema
     ):
-        try:
-            obj = await self.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
-
+        obj = await self.get_object(request, pk)
         payload, customs = await self.parse_input_data(request, data)
         for k, v in payload.items():
             if v is not None:
@@ -146,12 +151,9 @@ class ModelUtil:
         return await self.read_s(request, updated_object, obj_schema)
 
     async def delete_s(self, request: HttpRequest, pk: int | str):
-        try:
-            obj = await self.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
+        obj = await self.get_object(request, pk)
         await obj.adelete()
-        return HttpResponse(status=204)
+        return None
 
 
 class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
@@ -161,13 +163,18 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class CreateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
+        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[tuple[str, type]] = []
+        excludes: list[str] = []
 
     @property
     def has_custom_fields_create(self):
@@ -181,6 +188,74 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     def has_custom_fields(self):
         return self.has_custom_fields_create or self.has_custom_fields_update
 
+    @property
+    def has_optional_fields_create(self):
+        return hasattr(self.CreateSerializer, "optionals")
+
+    @property
+    def has_optional_fields_update(self):
+        return hasattr(self.UpdateSerializer, "optionals")
+
+    @property
+    def has_optional_fields(self):
+        return self.has_optional_fields_create or self.has_optional_fields_update
+
+    @classmethod
+    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_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(" "))
@@ -260,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
@@ -280,162 +355,47 @@ 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):
-        customs = cls.get_custom_fields("create") or []
-        customs.extend(cls.get_custom_fields("update") or [])
-        return any(field in custom_f for custom_f in customs)
+        return cls._is_special_field(
+            "create", field, "customs"
+        ) or cls._is_special_field("update", field, "customs")
 
     @classmethod
-    async def parse_input_data(cls, request: HttpRequest, data: Schema):
-        payload = data.model_dump()
-        customs = {k: v for k, v in payload.items() if cls.is_custom(k)}
-        for k, v in payload.items():
-            if cls.is_custom(k):
-                continue
-            field_obj = getattr(cls, k).field
-            if isinstance(field_obj, models.BinaryField):
-                try:
-                    payload |= {k: base64.b64decode(v)}
-                except Exception as exc:
-                    raise SerializeError({k: ". ".join(exc.args)}, 400)
-            if isinstance(field_obj, models.ForeignKey):
-                rel: ModelSerializer = await field_obj.related_model.get_object(
-                    request, v
-                )
-                payload |= {k: rel}
-        new_payload = {k: v for k, v in payload.items() if k not in customs}
-        return new_payload, customs
-
-    @classmethod
-    async def parse_output_data(cls, request: HttpRequest, data: Schema):
-        olds_k: list[dict] = []
-        payload = data.model_dump()
-        for k, v in payload.items():
-            try:
-                field_obj = getattr(cls, k).field
-            except AttributeError:
-                field_obj = getattr(cls, k).related
-            if isinstance(v, dict) and (
-                isinstance(field_obj, models.ForeignKey)
-                or isinstance(field_obj, models.OneToOneField)
-            ):
-                rel: ModelSerializer = await field_obj.related_model.get_object(
-                    request, list(v.values())[0]
-                )
-                if isinstance(field_obj, models.ForeignKey):
-                    for rel_k, rel_v in v.items():
-                        field_rel_obj = getattr(rel, rel_k)
-                        if isinstance(field_rel_obj, models.ForeignKey):
-                            olds_k.append({rel_k: rel_v})
-                    for obj in olds_k:
-                        for old_k, old_v in obj.items():
-                            v.pop(old_k)
-                            v |= {f"{old_k}_id": old_v}
-                    olds_k = []
-                payload |= {k: rel}
-        return payload
+    def is_optional(cls, field: str):
+        return cls._is_special_field(
+            "create", field, "optionals"
+        ) or cls._is_special_field("update", field, "optionals")
 
     @classmethod
     def get_custom_fields(cls, s_type: type[S_TYPES]):
-        try:
-            match s_type:
-                case "create":
-                    customs = cls.CreateSerializer.customs
-                case "update":
-                    customs = cls.UpdateSerializer.customs
-        except AttributeError:
-            return None
-        return customs
+        return cls._get_fields(s_type, "customs")
 
     @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,
-        )
-
+    def get_optional_fields(cls, s_type: type[S_TYPES]):
+        return [
+            (field, field_type, None)
+            for field, field_type in cls._get_fields(s_type, "optionals")
+        ]
+    
     @classmethod
-    def generate_create_s(cls) -> Schema:
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaIn",
-            fields=cls.CreateSerializer.fields,
-            custom_fields=cls.get_custom_fields("create"),
-        )
-
+    def get_excluded_fields(cls, s_type: type[S_TYPES]):
+        return cls._get_fields(s_type, "excludes")
+    
     @classmethod
-    def generate_update_s(cls) -> Schema:
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaPatch",
-            fields=cls.UpdateSerializer.fields,
-            custom_fields=cls.get_custom_fields("update"),
-        )
+    def get_fields(cls, s_type: type[S_TYPES]):
+        return cls._get_fields(s_type, "fields")
 
     @classmethod
-    async def get_object(cls, request: HttpRequest, pk: int | str):
-        q = {cls._meta.pk.attname: pk}
-        try:
-            obj = (
-                await (await cls.queryset_request(request))
-                .prefetch_related(*cls.get_reverse_relations())
-                .aget(**q)
-            )
-        except ObjectDoesNotExist:
-            raise SerializeError({cls._meta.model_name: "not found"}, 404)
-        return obj
-
-    @classmethod
-    async def create_s(cls, request: HttpRequest, data: Schema):
-        try:
-            payload, customs = await cls.parse_input_data(request, data)
-            pk = (await cls.objects.acreate(**payload)).pk
-            obj = await cls.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
-        payload |= customs
-        await obj.custom_actions(payload)
-        await obj.post_create()
-        return await cls.read_s(request, obj)
-
-    @classmethod
-    async def read_s(cls, request: HttpRequest, obj: type["ModelSerializer"]):
-        schema = cls.generate_read_s().from_orm(obj)
-        try:
-            data = await cls.parse_output_data(request, schema)
-        except SerializeError as e:
-            return e.status_code, e.error
-        return data
+    def generate_read_s(cls, depth: int = 1) -> Schema:
+        return cls._generate_model_schema("Out", depth)
 
     @classmethod
-    async def update_s(cls, request: HttpRequest, data: Schema, pk: int | str):
-        try:
-            obj = await cls.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
-
-        payload, customs = await cls.parse_input_data(request, data)
-        for k, v in payload.items():
-            if v is not None:
-                setattr(obj, k, v)
-        await obj.custom_actions(customs)
-        await obj.asave()
-        updated_object = await cls.get_object(request, pk)
-        return await cls.read_s(request, updated_object)
+    def generate_create_s(cls) -> Schema:
+        return cls._generate_model_schema("In")
 
     @classmethod
-    async def delete_s(cls, request: HttpRequest, pk: int | str):
-        try:
-            obj = await cls.get_object(request, pk)
-        except SerializeError as e:
-            return e.status_code, e.error
-        await obj.adelete()
-        return HttpResponse(status=204)
+    def generate_update_s(cls) -> Schema:
+        return cls._generate_model_schema("Patch")

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

@@ -2,9 +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["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.3.1 → django_ninja_aio_crud-0.5.0}/ninja_aio/views.py

@@ -1,15 +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 .exceptions import SerializeError
-from .types import ModelSerializerMeta
+from .types import ModelSerializerMeta, VIEW_TYPES
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
 
@@ -56,7 +56,6 @@ class APIView:
         async def some_method(request, *args, **kwargs):
             pass
         """
-        pass
 
     def add_views(self):
         self.views()
@@ -74,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(
@@ -99,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(
@@ -118,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 = [
@@ -127,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(
@@ -135,14 +157,12 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def retrieve(request: HttpRequest, pk: int | str):
-            try:
-                obj = await self.model_util.get_object(request, pk)
-            except SerializeError as e:
-                return e.status_code, e.error
+        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(
@@ -150,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(
@@ -161,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):
         """
@@ -198,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
 

django_ninja_aio_crud-0.3.1/ninja_aio/__init__.py

@@ -1,7 +0,0 @@
-""" Django Ninja AIO CRUD - Rest Framework """
-
-__version__ = "0.3.1"
-
-from .api import NinjaAIO
-
-__all__ = ["NinjaAIO"]