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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.6.1
+Version: 0.6.3
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10
@@ -100,7 +100,7 @@ class Foo(ModelSerializer):
     fields = ["name", "bar"]
 ```
 
-- 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).
+- 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.
 
 ```python
 # models.py
@@ -184,6 +184,35 @@ class Foo(ModelSerializer):
     excludes = ["id", "name"]
     optionals = [("bar", str), ("active", bool)]
 ```
+- If you want to add into ReadSerializer model properties you must define them as customs.
+```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)
+
+  @property
+  def full_name(self):
+    return f"{self.name} example_full_name"
+
+  class ReadSerializer:
+    excludes = ["bar"]
+    customs = [("full_name", str, "")]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    excludes = ["id", "name"]
+    optionals = [("bar", str), ("active", bool)]
+```
+
 
 
 ### APIViewSet

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

@@ -69,7 +69,7 @@ class Foo(ModelSerializer):
     fields = ["name", "bar"]
 ```
 
-- 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).
+- 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.
 
 ```python
 # models.py
@@ -153,6 +153,35 @@ class Foo(ModelSerializer):
     excludes = ["id", "name"]
     optionals = [("bar", str), ("active", bool)]
 ```
+- If you want to add into ReadSerializer model properties you must define them as customs.
+```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)
+
+  @property
+  def full_name(self):
+    return f"{self.name} example_full_name"
+
+  class ReadSerializer:
+    excludes = ["bar"]
+    customs = [("full_name", str, "")]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    excludes = ["id", "name"]
+    optionals = [("bar", str), ("active", bool)]
+```
+
 
 
 ### APIViewSet

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

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

{django_ninja_aio_crud-0.6.1 → django_ninja_aio_crud-0.6.3}/ninja_aio/auth.py

@@ -1,8 +1,8 @@
-from joserfc import jwt, jwk, errors
+from joserfc import jwt, jwk
 from django.http.request import HttpRequest
 from ninja.security.http import HttpBearer
 
-from .exceptions import AuthError, parse_jose_error
+from .exceptions import AuthError
 
 
 class AsyncJwtBearer(HttpBearer):
@@ -16,15 +16,7 @@ class AsyncJwtBearer(HttpBearer):
 
     def validate_claims(self, claims: jwt.Claims):
         jwt_claims = self.get_claims()
-
-        try:
-            jwt_claims.validate(claims)
-        except (
-            errors.InvalidClaimError,
-            errors.MissingClaimError,
-            errors.ExpiredTokenError,
-        ) as exc:
-            raise AuthError(**parse_jose_error(exc), status_code=401)
+        jwt_claims.validate(claims)
 
     async def auth_handler(self, request: HttpRequest):
         """
@@ -35,8 +27,6 @@ class AsyncJwtBearer(HttpBearer):
     async def authenticate(self, request: HttpRequest, token: str):
         try:
             self.dcd = jwt.decode(token, self.jwt_public, algorithms=self.algorithms)
-        except errors.BadSignatureError as exc:
-            raise AuthError(**parse_jose_error(exc), status_code=401)
         except ValueError as exc:
             raise AuthError(", ".join(exc.args), 401)
 

{django_ninja_aio_crud-0.6.1 → django_ninja_aio_crud-0.6.3}/ninja_aio/exceptions.py

@@ -53,8 +53,16 @@ def _pydantic_validation_error(
     return api.create_response(request, error.error, status=error.status_code)
 
 
+def _jose_error(
+    request: HttpRequest, exc: JoseError, api: type[NinjaAPI]
+) -> HttpResponse:
+    error = BaseException(**parse_jose_error(exc), status_code=401)
+    return api.create_response(request, error.error, status=error.status_code)
+
+
 def set_api_exception_handlers(api: type[NinjaAPI]) -> None:
     api.add_exception_handler(BaseException, partial(_default_error, api=api))
+    api.add_exception_handler(JoseError, partial(_jose_error, api=api))
     api.add_exception_handler(
         ValidationError, partial(_pydantic_validation_error, api=api)
     )

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

@@ -51,13 +51,14 @@ class ModelUtil:
         pk: int | str = None,
         filters: dict = None,
         getters: dict = None,
+        with_qs_request=True,
     ):
         get_q = {self.model_pk_name: pk} if pk is not None else {}
         if getters:
             get_q |= getters
 
         obj_qs = self.model.objects.select_related()
-        if isinstance(self.model, ModelSerializerMeta):
+        if isinstance(self.model, ModelSerializerMeta) and with_qs_request:
             obj_qs = await self.model.queryset_request(request)
 
         obj_qs = obj_qs.prefetch_related(*self.get_reverse_relations())
@@ -108,7 +109,9 @@ class ModelUtil:
                     raise SerializeError({k: ". ".join(exc.args)}, 400)
             if isinstance(field_obj, models.ForeignKey):
                 rel_util = ModelUtil(field_obj.related_model)
-                rel: ModelSerializer = await rel_util.get_object(request, v)
+                rel: ModelSerializer = await rel_util.get_object(
+                    request, v, with_qs_request=False
+                )
                 payload |= {k: rel}
         new_payload = {
             k: v for k, v in payload.items() if k not in (customs.keys() or optionals)
@@ -122,14 +125,17 @@ class ModelUtil:
             try:
                 field_obj = getattr(self.model, k).field
             except AttributeError:
-                field_obj = getattr(self.model, k).related
+                try:
+                    field_obj = getattr(self.model, k).related
+                except AttributeError:
+                    pass
             if isinstance(v, dict) and (
                 isinstance(field_obj, models.ForeignKey)
                 or isinstance(field_obj, models.OneToOneField)
             ):
                 rel_util = ModelUtil(field_obj.related_model)
                 rel: ModelSerializer = await rel_util.get_object(
-                    request, list(v.values())[0]
+                    request, list(v.values())[0], with_qs_request=False
                 )
                 if isinstance(field_obj, models.ForeignKey):
                     for rel_k, rel_v in v.items():
@@ -196,6 +202,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class ReadSerializer:
         fields: list[str] = []
         excludes: list[str] = []
+        customs: list[tuple[str, type, Any]] = []
 
     class UpdateSerializer:
         fields: list[str] = []
@@ -257,15 +264,15 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
             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:
+                fields, reverse_rels, excludes, customs = cls.get_schema_out_data()
+                if not fields and not reverse_rels and not excludes and not customs:
                     return None
                 return create_schema(
                     model=cls,
                     name=f"{cls._meta.model_name}SchemaOut",
                     depth=depth,
                     fields=fields,
-                    custom_fields=reverse_rels,
+                    custom_fields=reverse_rels + customs,
                     exclude=excludes,
                 )
         fields = cls.get_fields(s_type)
@@ -367,25 +374,36 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
         reverse_rels = []
         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
-                if field_obj.reverse:
-                    rel_obj: ModelSerializer = field_obj.field.model
-                rel_data = cls.get_reverse_relation_schema(rel_obj, "many", f)
-                reverse_rels.append(rel_data)
-                continue
-            if isinstance(field_obj, ReverseManyToOneDescriptor):
-                rel_obj: ModelSerializer = field_obj.field.model
-                rel_data = cls.get_reverse_relation_schema(rel_obj, "many", f)
-                reverse_rels.append(rel_data)
-                continue
-            if isinstance(field_obj, ReverseOneToOneDescriptor):
-                rel_obj: ModelSerializer = field_obj.related.related_model
-                rel_data = cls.get_reverse_relation_schema(rel_obj, "one", f)
+            if isinstance(
+                field_obj,
+                (
+                    ManyToManyDescriptor,
+                    ReverseManyToOneDescriptor,
+                    ReverseOneToOneDescriptor,
+                ),
+            ):
+                if isinstance(field_obj, ManyToManyDescriptor):
+                    rel_obj: ModelSerializer = field_obj.field.related_model
+                    if field_obj.reverse:
+                        rel_obj = field_obj.field.model
+                    rel_type = "many"
+                elif isinstance(field_obj, ReverseManyToOneDescriptor):
+                    rel_obj = field_obj.field.model
+                    rel_type = "many"
+                else:  # ReverseOneToOneDescriptor
+                    rel_obj = field_obj.related.related_model
+                    rel_type = "one"
+
+                rel_data = cls.get_reverse_relation_schema(rel_obj, rel_type, f)
                 reverse_rels.append(rel_data)
                 continue
             fields.append(f)
-        return fields, reverse_rels, cls.get_excluded_fields("read")
+        return (
+            fields,
+            reverse_rels,
+            cls.get_excluded_fields("read"),
+            cls.get_custom_fields("read"),
+        )
 
     @classmethod
     def is_custom(cls, field: str):

django_ninja_aio_crud-0.6.1/ninja_aio/views.py

@@ -1,271 +0,0 @@
-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
-    auths: 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
-    auths: 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.auths,
-            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.auths,
-            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.auths,
-            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.auths,
-            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.auths,
-            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(),
-        )