django-ninja-aio-crud 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

{django_ninja_aio_crud-0.3.1.dist-info → django_ninja_aio_crud-0.4.0.dist-info}/METADATA

@@ -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.4.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,12 +130,34 @@ 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)]
+```
 
 ### 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
@@ -157,7 +179,7 @@ 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
@@ -196,7 +218,7 @@ 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
@@ -235,7 +257,7 @@ SumView().add_views_to_route()
 
 - Define models:
 
-```Python
+```python
 # models.py
 class Bar(ModelSerializer):
     name = models.CharField(max_length=30)
@@ -268,7 +290,7 @@ class Foo(ModelSerializer):
 
 - Define views:
 
-```Python
+```python
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
@@ -312,7 +334,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,7 +356,7 @@ class CustomJWTBearer(AsyncJWTBearer):
 
 - Then add it to views.
 
-```Python
+```python
 # views.py
 from ninja import Schema
 from ninja_aio import NinjaAIO
@@ -382,7 +404,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.4.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+ninja_aio/__init__.py,sha256=GPvxFosuQ4fZ9LpbRClXqv8e7BecmVUtj2nvbJyalus,119
+ninja_aio/api.py,sha256=Fe6l3YCy7MW5TY4-Lbl80CFuK2NT2Y7tHfmqPk6Mqak,1735
+ninja_aio/auth.py,sha256=3Pr8llYoCN59ZH3J_2qWmzjXxsy-rpQzXrVfwLfY25Q,1299
+ninja_aio/exceptions.py,sha256=LP9GZpDk1fYMRRgGHSAstcCvgu5uSDLg8PPDANlZGTs,1008
+ninja_aio/models.py,sha256=mIZofuGOsRATYQki7GIuz50OQWfMes41cvOOAAonQA0,13768
+ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
+ninja_aio/renders.py,sha256=mHeKNJtmDhZmgFpS9B6SPn5uZFcyVXrsoMhr149LeW8,1555
+ninja_aio/schemas.py,sha256=EgRkfhnzZqwGvdBmqlZixMtMcoD1ZxV_qzJ3fmaAy20,113
+ninja_aio/types.py,sha256=ZhFqRDP5g2A2er3izx36QjrYJxL_jgusbH7w7mVHNrk,339
+ninja_aio/views.py,sha256=IT6rTCcjXcVYrCi4_uEwnGOGXeWlIB4ZuyXJp8Fsqqc,6971
+django_ninja_aio_crud-0.4.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+django_ninja_aio_crud-0.4.0.dist-info/METADATA,sha256=0yQr4CWufJ7ZtXuhpTOchKQ-yOzG7o-wTaymDV0Tqvc,10832
+django_ninja_aio_crud-0.4.0.dist-info/RECORD,,

ninja_aio/__init__.py

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

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()

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]

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)
+    )

ninja_aio/models.py

@@ -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, ModelSerializerMeta
 
 
 class ModelUtil:
@@ -58,11 +58,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 +80,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,12 +115,9 @@ 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()
@@ -130,11 +136,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,10 +148,7 @@ 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)
 
@@ -161,6 +160,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class CreateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
+        optionals: list[str] = []
 
     class ReadSerializer:
         fields: list[str] = []
@@ -168,6 +168,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class UpdateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
+        optionals: list[str] = []
 
     @property
     def has_custom_fields_create(self):
@@ -181,6 +182,37 @@ 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_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 []
+        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)
+        return any(field in special_f for special_f in special_fields)
+
     @classmethod
     def verbose_name_path_resolver(cls) -> str:
         return "-".join(cls._meta.verbose_name_plural.split(" "))
@@ -284,71 +316,26 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
 
     @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
+    def is_optional(cls, field: str):
+        return cls._is_special_field(
+            "create", field, "optionals"
+        ) or cls._is_special_field("update", field, "optionals")
 
     @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 get_custom_fields(cls, s_type: type[S_TYPES]):
+        return cls._get_special_fields(s_type, "customs")
 
     @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
+    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")
+        ]
 
     @classmethod
     def generate_read_s(cls, depth: int = 1) -> Schema:
@@ -364,78 +351,26 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
 
     @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=cls.CreateSerializer.fields,
-            custom_fields=cls.get_custom_fields("create"),
+            fields=fields,
+            custom_fields=customs,
         )
 
     @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=cls.UpdateSerializer.fields,
-            custom_fields=cls.get_custom_fields("update"),
+            fields=fields,
+            custom_fields=customs,
         )
-
-    @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
-
-    @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)
-
-    @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)

ninja_aio/types.py

@@ -4,6 +4,7 @@ from django.db.models import Model
 
 S_TYPES = Literal["create", "update"]
 REL_TYPES = Literal["many", "one"]
+F_TYPES = Literal["customs", "optionals"]
 
 
 class ModelSerializerType(type):

ninja_aio/views.py

@@ -8,7 +8,6 @@ from django.db.models import Model
 
 from .models import ModelSerializer, ModelUtil
 from .schemas import GenericMessageSchema
-from .exceptions import SerializeError
 from .types import ModelSerializerMeta
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
@@ -136,10 +135,7 @@ class APIViewSet:
             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
+            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}"

django_ninja_aio_crud-0.3.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-ninja_aio/__init__.py,sha256=_tjey_xwfvsIhCY5_zwh_pEW7Iubpix0RnfUSx_x9to,120
-ninja_aio/api.py,sha256=r0BOsZLdH-kqInbbXPmK8HeF-fQz756ih-MSFvfEBXI,1546
-ninja_aio/auth.py,sha256=hGgiblvffpHmmakjaxdNT3G0tq39-Bvc5oLNqjn4qd8,1300
-ninja_aio/exceptions.py,sha256=PPNr1CdC7M7Kx1MtiBGuR4hATYQqEuvxCRU6uSG7rgM,543
-ninja_aio/models.py,sha256=Ni4nO9U2DeWA3STX2wV8Jk5esqgwOSzfW7ZvA4hu1Hg,16500
-ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
-ninja_aio/renders.py,sha256=mHeKNJtmDhZmgFpS9B6SPn5uZFcyVXrsoMhr149LeW8,1555
-ninja_aio/schemas.py,sha256=EgRkfhnzZqwGvdBmqlZixMtMcoD1ZxV_qzJ3fmaAy20,113
-ninja_aio/types.py,sha256=gEHb6O9M07o5DHtxXH_KAcFJdq9lzq3ljmYbNLst8vs,297
-ninja_aio/views.py,sha256=LcUoCyBs4Sbgz8ugcu9nfm30xCKnEnEalROg-mUOCTg,7117
-django_ninja_aio_crud-0.3.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-django_ninja_aio_crud-0.3.1.dist-info/METADATA,sha256=c6tJqkqsYu7iUZdP5X5Rbm2jsGkeZOMAVGlDxtEJCOI,10135
-django_ninja_aio_crud-0.3.1.dist-info/RECORD,,