django-ninja-aio-crud 2.4.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

{django_ninja_aio_crud-2.4.0.dist-info → django_ninja_aio_crud-2.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.4.0
+Version: 2.5.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10, <3.15
@@ -48,6 +48,7 @@ Provides-Extra: test
 
 ## ✨ Features
 
+- Serializer (Meta-driven) first-class: dynamic schemas for existing Django models without inheriting ModelSerializer
 - Async CRUD ViewSets (create, list, retrieve, update, delete)
 - Automatic Pydantic schemas from `ModelSerializer` (read/create/update)
 - Dynamic query params (runtime schema via `pydantic.create_model`)
@@ -61,17 +62,35 @@ Provides-Extra: test
 
 ---
 
-## 📦 Installation
+## 🚀 Quick Start (Serializer)
 
-```bash
-pip install django-ninja-aio-crud
+If you already have Django models, start with the Meta-driven Serializer for instant CRUD without changing model base classes.
+
+```python
+from ninja_aio.models import serializers
+from ninja_aio.views import APIViewSet
+from ninja_aio import NinjaAIO
+from . import models
+
+class BookSerializer(serializers.Serializer):
+    class Meta:
+        model = models.Book
+        schema_in = serializers.SchemaModelConfig(fields=["title", "published"])
+        schema_out = serializers.SchemaModelConfig(fields=["id", "title", "published"])
+        schema_update = serializers.SchemaModelConfig(optionals=[("title", str), ("published", bool)])
+
+api = NinjaAIO()
+
+@api.viewset(models.Book)
+class BookViewSet(APIViewSet):
+    serializer_class = BookSerializer
 ```
 
-Add to your project’s dependencies and ensure Django Ninja is installed.
+Visit `/docs` → CRUD endpoints ready.
 
 ---
 
-## 🚀 Quick Start
+## 🚀 Quick Start (ModelSerializer)
 
 models.py
 
@@ -264,29 +283,7 @@ class BookViewSet(APIViewSet):
 
 ## Meta-driven Serializer (for vanilla Django models)
 
-If you already have Django models and don't want to inherit from ModelSerializer, use the Meta-driven Serializer to generate dynamic schemas and integrate with APIViewSet.
-
-Example:
-
-```python
-from ninja_aio.models import serializers
-from . import models
-
-class BookSerializer(serializers.Serializer):
-    class Meta:
-        model = models.Book
-        schema_in = serializers.SchemaModelConfig(fields=["title", "published"])
-        schema_out = serializers.SchemaModelConfig(fields=["id", "title", "published"])
-        schema_update = serializers.SchemaModelConfig(optionals=[("title", str), ("published", bool)])
-
-@api.viewset(models.Book)
-class BookViewSet(APIViewSet):
-    serializer_class = BookSerializer
-```
-
-- Works without modifying existing models
-- Supports nested relations via relations_serializers
-- APIViewSet will auto-generate missing schemas from the serializer
+Moved above as the primary quick start.
 
 ---
 

{django_ninja_aio_crud-2.4.0.dist-info → django_ninja_aio_crud-2.5.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ninja_aio/__init__.py,sha256=Ms2GNzuORIvMqPlxF2wzxTHgoQBL_OpaeqByF4LtwhI,119
+ninja_aio/__init__.py,sha256=LBFfoQaFXisUD0DcYa1xZV-zyiAJqx_3QAY-hyxB6OA,119
 ninja_aio/api.py,sha256=tuC7vdvn7s1GkCnSFy9Kn1zv0glZfYptRQVvo8ZRtGQ,2429
 ninja_aio/auth.py,sha256=4sWdFPjKiQgUL1d_CSGDblVjnY5ptP6LQha6XXdluJA,9157
 ninja_aio/exceptions.py,sha256=_3xFqfFCOfrrMhSA0xbMqgXy8R0UQjhXaExrFvaDAjY,3891
@@ -12,18 +12,18 @@ ninja_aio/factory/__init__.py,sha256=IdH2z1ZZpv_IqonaDfVo7IsMzkgop6lHqz42RphUYBU
 ninja_aio/factory/operations.py,sha256=OgWGqq4WJ4arSQrH9FGAby9kx-HTdS7MOITxHdYMk18,12051
 ninja_aio/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ninja_aio/helpers/api.py,sha256=YMzuZ4-ZpUrJBQIabE26gb_GYwsH2rVosWRE95YfdPQ,20775
-ninja_aio/helpers/query.py,sha256=YJMdEonCuqx1XjmszCK74mg5hcUPh84ynXrsuoSQdNA,4519
+ninja_aio/helpers/query.py,sha256=lzaH-htswoJVRT-W736HGMkpMba1VmN98TBLv5cZx9Q,4549
 ninja_aio/models/__init__.py,sha256=L3UQnQAlKoI3F7jinadL-Nn55hkPvnSRPYW0JtnbWFo,114
-ninja_aio/models/serializers.py,sha256=wFEG6QrOPN4TiDEIRkOxExIKkjAQ0I432czaELZZxdI,25110
-ninja_aio/models/utils.py,sha256=PkvdByNuZKnTzQhdkbqZuG6CEIMIZTCO4QkCUgvqBjs,28776
+ninja_aio/models/serializers.py,sha256=-6NsyTJBdUQl3fkAusC7Kx_2keMRV7CNI9yAlH_fQns,29340
+ninja_aio/models/utils.py,sha256=P-YfbVyzUfxm_s1BrgSd6Zs0HIGdZ79PU1qM0Ud9-Xs,30492
 ninja_aio/schemas/__init__.py,sha256=iLBwHg0pmL9k_UkIui5Q8QIl_gO4fgxSv2JHxDzqnSI,549
 ninja_aio/schemas/api.py,sha256=-VwXhBRhmMsZLIAmWJ-P7tB5klxXS75eukjabeKKYsc,360
 ninja_aio/schemas/generics.py,sha256=frjJsKJMAdM_NdNKv-9ddZNGxYy5PNzjIRGtuycgr-w,112
 ninja_aio/schemas/helpers.py,sha256=W6IeHi5Tmbjh3FXwDYqjqlLBTVj5uTYq3_JVkNUWayo,7355
 ninja_aio/views/__init__.py,sha256=DEzjWA6y3WF0V10nNF8eEurLNEodgxKzyFd09AqVp3s,148
-ninja_aio/views/api.py,sha256=AQWtu8oI9R0blk-PW8BpwXLuejj1Z8vqpoNqlU_WrGs,20953
+ninja_aio/views/api.py,sha256=xdzxM1XOPTZmGrRxlIz1QH4UKgxRfg9ls-geatTJrXI,21179
 ninja_aio/views/mixins.py,sha256=Jh6BG8Cs823nurVlODlzCquTxKrLH7Pmo5udPqUGZek,11378
-django_ninja_aio_crud-2.4.0.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
-django_ninja_aio_crud-2.4.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-django_ninja_aio_crud-2.4.0.dist-info/METADATA,sha256=qRTfA6me4WsclgqfdyVKL7nPOfv3rRasiLNQdVUeZpM,9988
-django_ninja_aio_crud-2.4.0.dist-info/RECORD,,
+django_ninja_aio_crud-2.5.0.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
+django_ninja_aio_crud-2.5.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_ninja_aio_crud-2.5.0.dist-info/METADATA,sha256=Gyk2TCPm3oQaT9YsZrXC7btzZzmDmntKyk_wz0M6Hfg,9963
+django_ninja_aio_crud-2.5.0.dist-info/RECORD,,

ninja_aio/__init__.py

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

ninja_aio/helpers/query.py

@@ -1,4 +1,4 @@
-from ninja_aio.types import ModelSerializerMeta
+from ninja_aio.models.serializers import Serializer, ModelSerializer
 from ninja_aio.schemas.helpers import (
     ModelQuerySetSchema,
     QueryUtilBaseScopesSchema,
@@ -52,7 +52,7 @@ class QueryUtil:
 
     SCOPES: QueryUtilBaseScopesSchema
 
-    def __init__(self, model: ModelSerializerMeta):
+    def __init__(self, model: ModelSerializer | Serializer):
         """Initialize QueryUtil, resolving base and extra scope configurations for a model."""
         self.model = model
         self._configuration = getattr(self.model, "QuerySet", None)

ninja_aio/models/serializers.py

@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, List, Optional
+from typing import Any, List, Optional
 import warnings
 
 from django.conf import settings
@@ -19,7 +19,6 @@ from ninja_aio.schemas.helpers import (
     ModelQuerySetSchema,
     ModelQuerySetExtraSchema,
 )
-from ninja_aio.helpers.query import QueryUtil
 
 
 class BaseSerializer:
@@ -36,6 +35,28 @@ class BaseSerializer:
     - _get_relations_serializers(): optional mapping of relation field -> serializer (may be empty)
     """
 
+    class QuerySet:
+        """
+        Configuration container describing how to build query schemas for a model.
+        Purpose
+        -------
+        Describes which fields and extras are available when querying for model
+        instances. A factory/metaclass can read this configuration to generate
+        Pydantic / Ninja query schemas.
+        Attributes
+        ----------
+        read : ModelQuerySetSchema
+            Schema configuration for read operations.
+        queryset_request : ModelQuerySetSchema
+            Schema configuration for queryset_request hook.
+        extras : list[ModelQuerySetExtraSchema]
+            Additional computed / synthetic query parameters.
+        """
+
+        read = ModelQuerySetSchema()
+        queryset_request = ModelQuerySetSchema()
+        extras: list[ModelQuerySetExtraSchema] = []
+
     @classmethod
     def _get_fields(cls, s_type: type[S_TYPES], f_type: type[F_TYPES]):
         # Subclasses provide implementation.
@@ -199,9 +220,10 @@ class BaseSerializer:
         reverse_rels: list[tuple] = []
         rels: list[tuple] = []
         relations_serializers = cls._get_relations_serializers() or {}
+        model = cls._get_model()
 
         for f in cls.get_fields("read"):
-            field_obj = getattr(cls._get_model(), f)
+            field_obj = getattr(model, f)
             is_reverse = isinstance(
                 field_obj,
                 (
@@ -217,7 +239,7 @@ class BaseSerializer:
             # If explicit relation serializers are declared, require mapping presence.
             if (
                 is_reverse
-                and not isinstance(cls._get_model(), ModelSerializerMeta)
+                and not isinstance(model, ModelSerializerMeta)
                 and f not in relations_serializers
                 and not getattr(settings, "NINJA_AIO_TESTING", False)
             ):
@@ -393,41 +415,17 @@ class ModelSerializer(models.Model, BaseSerializer, metaclass=ModelSerializerMet
     lifecycle hooks and query utilities.
     """
 
-    util: ClassVar
-    query_util: ClassVar[QueryUtil]
-
-    class Meta:
-        abstract = True
-
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
         from ninja_aio.models.utils import ModelUtil
+        from ninja_aio.helpers.query import QueryUtil
 
         # Bind a ModelUtil instance to the subclass for convenient access
         cls.util = ModelUtil(cls)
         cls.query_util = QueryUtil(cls)
 
-    class QuerySet:
-        """
-        Configuration container describing how to build query schemas for a model.
-        Purpose
-        -------
-        Describes which fields and extras are available when querying for model
-        instances. A factory/metaclass can read this configuration to generate
-        Pydantic / Ninja query schemas.
-        Attributes
-        ----------
-        read : ModelQuerySetSchema
-            Schema configuration for read operations.
-        queryset_request : ModelQuerySetSchema
-            Schema configuration for queryset_request hook.
-        extras : list[ModelQuerySetExtraSchema]
-            Additional computed / synthetic query parameters.
-        """
-
-        read = ModelQuerySetSchema()
-        queryset_request = ModelQuerySetSchema()
-        extras: list[ModelQuerySetExtraSchema] = []
+    class Meta:
+        abstract = True
 
     class CreateSerializer:
         """Configuration container describing how to build a create (input) schema for a model.
@@ -674,20 +672,26 @@ class Serializer(BaseSerializer):
     schema components during read schema generation.
     """
 
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        from ninja_aio.models.utils import ModelUtil
+        from ninja_aio.helpers.query import QueryUtil
+
+        cls.model = cls._get_model()
+        cls.schema_in = cls.generate_create_s()
+        cls.schema_out = cls.generate_read_s()
+        cls.schema_update = cls.generate_update_s()
+        cls.schema_related = cls.generate_related_s()
+        cls.util = ModelUtil(cls._get_model(), serializer_class=cls)
+        cls.query_util = QueryUtil(cls)
+
     class Meta:
         model: models.Model = None
-        schema_in: SchemaModelConfig = None
-        schema_out: SchemaModelConfig = None
-        schema_update: SchemaModelConfig = None
+        schema_in: Optional[SchemaModelConfig] = None
+        schema_out: Optional[SchemaModelConfig] = None
+        schema_update: Optional[SchemaModelConfig] = None
         relations_serializers: dict[str, "Serializer"] = {}
 
-    def __init__(self):
-        self.model = self._validate_model()
-        self.schema_in = self.generate_create_s()
-        self.schema_out = self.generate_read_s()
-        self.schema_update = self.generate_update_s()
-        self.schema_related = self.generate_related_s()
-
     @classmethod
     def _get_meta_data(cls, attr_name: str) -> Any:
         return getattr(cls.Meta, attr_name, None)
@@ -702,7 +706,7 @@ class Serializer(BaseSerializer):
         return relations_serializers or {}
 
     @classmethod
-    def _get_schema_meta(cls, schema_type: str) -> SchemaModelConfig:
+    def _get_schema_meta(cls, schema_type: str) -> SchemaModelConfig | None:
         match schema_type:
             case "in":
                 return cls._get_meta_data("schema_in")
@@ -710,7 +714,8 @@ class Serializer(BaseSerializer):
                 return cls._get_meta_data("schema_out")
             case "update":
                 return cls._get_meta_data("schema_update")
-        return None
+            case _:
+                return None
 
     @classmethod
     def _validate_model(cls):
@@ -733,6 +738,151 @@ class Serializer(BaseSerializer):
             return []
         return getattr(schema, f_type, []) or []
 
+
     @classmethod
     async def queryset_request(cls, request: HttpRequest):
-        return cls._get_model()._default_manager.all()
+        return cls.query_util.apply_queryset_optimizations(
+            queryset=cls.model._default_manager.all(),
+            scope=cls.query_util.SCOPES.QUERYSET_REQUEST,
+        )
+
+    async def post_create(self, instance: models.Model) -> None:
+        """
+        Async hook executed after first persistence (create path).
+        """
+        pass
+
+    async def custom_actions(self, payload: dict[str, Any], instance: models.Model):
+        """
+        Async hook for reacting to provided custom (synthetic) fields.
+
+        Parameters
+        ----------
+        payload : dict
+            Custom field name/value pairs.
+        """
+        pass
+
+    async def save(self, instance: models.Model) -> models.Model:
+        """
+        Async helper to save a model instance with lifecycle hooks.
+
+        Parameters
+        ----------
+        instance : models.Model
+            The model instance to save.
+        """
+        creation = instance._state.adding
+        if creation:
+            self.on_create_before_save(instance)
+        self.before_save(instance)
+        await instance.asave()
+        if creation:
+            self.on_create_after_save(instance)
+        self.after_save(instance)
+        return instance
+
+    async def create(self, payload: dict[str, Any]) -> models.Model:
+        """
+        Create a new model instance from the provided payload.
+
+        Parameters
+        ----------
+        payload : dict
+            Input data.
+
+        Returns
+        -------
+        models.Model
+            Created model instance.
+        """
+        instance: models.Model = self.model(**payload)
+        return await self.save(instance)
+
+    async def update(
+        self, instance: models.Model, payload: dict[str, Any]
+    ) -> models.Model:
+        """
+        Update an existing model instance with the provided payload.
+
+        Parameters
+        ----------
+        instance : models.Model
+            The model instance to update.
+        payload : dict
+            Input data.
+
+        Returns
+        -------
+        models.Model
+            Updated model instance.
+        """
+        for attr, value in payload.items():
+            setattr(instance, attr, value)
+        return await self.save(instance)
+
+    async def model_dump(self, instance: models.Model) -> dict[str, Any]:
+        """
+        Serialize a model instance to a dictionary using the Out schema.
+
+        Parameters
+        ----------
+        instance : models.Model
+            The model instance to serialize.
+
+        Returns
+        -------
+        dict
+            Serialized data.
+        """
+        return await self.model_util.read_s(schema=self.schema_out, instance=instance)
+
+    async def models_dump(
+        self, instances: models.QuerySet[models.Model]
+    ) -> list[dict[str, Any]]:
+        """
+        Serialize a list of model instances to a list of dictionaries using the Out schema.
+
+        Parameters
+        ----------
+        instances : list[models.Model]
+            The list of model instances to serialize.
+
+        Returns
+        -------
+        list[dict]
+            List of serialized data.
+        """
+        return await self.model_util.list_read_s(
+            schema=self.schema_out, instances=instances
+        )
+
+    def after_save(self, instance: models.Model):
+        """
+        Sync hook executed after any save (create or update).
+        """
+        pass
+
+    def before_save(self, instance: models.Model):
+        """
+        Sync hook executed before any save (create or update).
+        """
+        pass
+
+    def on_create_after_save(self, instance: models.Model):
+        """
+        Sync hook executed only after initial creation save.
+        """
+        pass
+
+    def on_create_before_save(self, instance: models.Model):
+        """
+        Sync hook executed only before initial creation save.
+        """
+        pass
+
+    def on_delete(self, instance: models.Model):
+        """
+        Sync hook executed after delete.
+        """
+        pass

ninja_aio/models/utils.py

@@ -22,6 +22,7 @@ from ninja_aio.exceptions import SerializeError, NotFoundError
 from ninja_aio.models.serializers import ModelSerializer
 from ninja_aio.types import ModelSerializerMeta
 from ninja_aio.schemas.helpers import (
+    ModelQuerySetSchema,
     QuerySchema,
     ObjectQuerySchema,
     ObjectsQuerySchema,
@@ -112,6 +113,18 @@ class ModelUtil:
             raise ConfigError(
                 "ModelUtil cannot accept both model and serializer_class if the model is a ModelSerializer."
             )
+        self.serializer: Serializer = serializer_class() if serializer_class else None
+
+    @property
+    def with_serializer(self) -> bool:
+        """
+        Indicates if a serializer_class is associated.
+
+        Returns
+        -------
+        bool
+        """
+        return self.serializer_class is not None
 
     @property
     def pk_field_type(self):
@@ -445,6 +458,23 @@ class ModelUtil:
 
         return queryset
 
+    def _get_read_optimizations(self) -> ModelQuerySetSchema:
+        """
+        Retrieve read optimizations from model or serializer class.
+
+        Returns
+        -------
+        ModelQuerySetSchema
+            Read optimization configuration.
+        """
+        if isinstance(self.model, ModelSerializerMeta):
+            return getattr(self.model.QuerySet, "read", ModelQuerySetSchema())
+        if self.with_serializer:
+            return getattr(
+                self.serializer_class.QuerySet, "read", ModelQuerySetSchema()
+            )
+        return ModelQuerySetSchema()
+
     def get_reverse_relations(self) -> list[str]:
         """
         Discover reverse relation names for safe prefetching.
@@ -454,7 +484,9 @@ class ModelUtil:
         list[str]
             Relation attribute names.
         """
-        reverse_rels = []
+        reverse_rels = self._get_read_optimizations().prefetch_related.copy()
+        if reverse_rels:
+            return reverse_rels
         for f in self.serializable_fields:
             field_obj = getattr(self.model, f)
             if isinstance(field_obj, ManyToManyDescriptor):
@@ -476,7 +508,9 @@ class ModelUtil:
         list[str]
             Relation attribute names.
         """
-        select_rels = []
+        select_rels = self._get_read_optimizations().select_related.copy()
+        if select_rels:
+            return select_rels
         for f in self.serializable_fields:
             field_obj = getattr(self.model, f)
             if isinstance(field_obj, ForwardManyToOneDescriptor):
@@ -615,7 +649,8 @@ class ModelUtil:
         """
         payload = data.model_dump(mode="json")
 
-        is_serializer = isinstance(self.model, ModelSerializerMeta)
+        is_serializer = isinstance(self.model, ModelSerializerMeta) or self.with_serializer
+        serializer = self.serializer if self.with_serializer else self.model
 
         # Collect custom and optional fields (only if ModelSerializerMeta)
         customs: dict[str, Any] = {}
@@ -624,10 +659,10 @@ class ModelUtil:
             customs = {
                 k: v
                 for k, v in payload.items()
-                if self.model.is_custom(k) and k not in self.model_fields
+                if serializer.is_custom(k) and k not in self.model_fields
             }
             optionals = [
-                k for k, v in payload.items() if self.model.is_optional(k) and v is None
+                k for k, v in payload.items() if serializer.is_optional(k) and v is None
             ]
 
         skip_keys = set()
@@ -636,8 +671,8 @@ class ModelUtil:
             skip_keys = {
                 k
                 for k, v in payload.items()
-                if (self.model.is_custom(k) and k not in self.model_fields)
-                or (self.model.is_optional(k) and v is None)
+                if (serializer.is_custom(k) and k not in self.model_fields)
+                or (serializer.is_optional(k) and v is None)
             }
 
         # Process payload fields
@@ -674,10 +709,19 @@ class ModelUtil:
             Serialized created object.
         """
         payload, customs = await self.parse_input_data(request, data)
-        pk = (await self.model.objects.acreate(**payload)).pk
+        pk = (
+            (await self.model.objects.acreate(**payload)).pk
+            if not self.with_serializer
+            else (await self.serializer.create(payload)).pk
+        )
         obj = await self.get_object(request, pk)
         if isinstance(self.model, ModelSerializerMeta):
             await asyncio.gather(obj.custom_actions(customs), obj.post_create())
+        if self.with_serializer:
+            await asyncio.gather(
+                self.serializer.custom_actions(customs, obj),
+                self.serializer.post_create(obj),
+            )
         return await self.read_s(obj_schema, request, obj)
 
     async def _read_s(
@@ -871,7 +915,11 @@ class ModelUtil:
                 setattr(obj, k, v)
         if isinstance(self.model, ModelSerializerMeta):
             await obj.custom_actions(customs)
-        await obj.asave()
+        if self.with_serializer:
+            await self.serializer.custom_actions(customs, obj)
+            await self.serializer.save(obj)
+        else:
+            await obj.asave()
         updated_object = await self.get_object(request, pk)
         return await self.read_s(obj_schema, request, updated_object)
 

ninja_aio/views/api.py

@@ -17,7 +17,7 @@ from ninja_aio.schemas import (
 )
 from ninja_aio.helpers.api import ManyToManyAPI
 from ninja_aio.types import ModelSerializerMeta, VIEW_TYPES
-from ninja_aio.decorators import unique_view, decorate_view
+from ninja_aio.decorators import unique_view, decorate_view, aatomic
 from ninja_aio.models import serializers
 
 ERROR_CODES = frozenset({400, 401, 404})
@@ -241,6 +241,8 @@ class APIViewSet(API):
     m2m_relations: list[M2MRelationSchema] = []
     m2m_auth: list | None = NOT_SET
     extra_decorators: DecoratorsSchema = DecoratorsSchema()
+    model_verbose_name: str = ""
+    model_verbose_name_plural: str = ""
 
     def __init__(
         self,
@@ -260,7 +262,13 @@ class APIViewSet(API):
         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.model_verbose_name = self.model._meta.verbose_name.capitalize()
+        self.model_verbose_name = (
+            self.model_verbose_name or self.model._meta.verbose_name.capitalize()
+        )
+        self.model_verbose_name_plural = (
+            self.model_verbose_name_plural
+            or self.model._meta.verbose_name_plural.capitalize()
+        )
         self.router_tag = self.router_tag or self.model_verbose_name
         self.router_tags = self.router_tags or tags or [self.router_tag]
         self.router = Router(tags=self.router_tags)
@@ -400,11 +408,11 @@ class APIViewSet(API):
         @self.router.post(
             self.path,
             auth=self.post_view_auth(),
-            summary=f"Create {self.model._meta.verbose_name.capitalize()}",
+            summary=f"Create {self.model_verbose_name}",
             description=self.create_docs,
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.create)
+        @decorate_view(aatomic, unique_view(self), *self.extra_decorators.create)
         async def create(request: HttpRequest, data: self.schema_in):  # type: ignore
             return 201, await self.model_util.create_s(request, data, self.schema_out)
 
@@ -418,7 +426,7 @@ class APIViewSet(API):
         @self.router.get(
             self.get_path,
             auth=self.get_view_auth(),
-            summary=f"List {self.model._meta.verbose_name_plural.capitalize()}",
+            summary=f"List {self.model_verbose_name_plural}",
             description=self.list_docs,
             response={
                 200: List[self.schema_out],
@@ -453,7 +461,7 @@ class APIViewSet(API):
         @self.router.get(
             self.get_path_retrieve,
             auth=self.get_view_auth(),
-            summary=f"Retrieve {self.model._meta.verbose_name.capitalize()}",
+            summary=f"Retrieve {self.model_verbose_name}",
             description=self.retrieve_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
@@ -478,11 +486,11 @@ class APIViewSet(API):
         @self.router.patch(
             self.path_retrieve,
             auth=self.patch_view_auth(),
-            summary=f"Update {self.model._meta.verbose_name.capitalize()}",
+            summary=f"Update {self.model_verbose_name}",
             description=self.update_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.update)
+        @decorate_view(aatomic, unique_view(self), *self.extra_decorators.update)
         async def update(
             request: HttpRequest,
             data: self.schema_update,  # type: ignore
@@ -502,11 +510,11 @@ class APIViewSet(API):
         @self.router.delete(
             self.path_retrieve,
             auth=self.delete_view_auth(),
-            summary=f"Delete {self.model._meta.verbose_name.capitalize()}",
+            summary=f"Delete {self.model_verbose_name}",
             description=self.delete_docs,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.delete)
+        @decorate_view(aatomic, unique_view(self), *self.extra_decorators.delete)
         async def delete(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
             return 204, await self.model_util.delete_s(request, self._get_pk(pk))