django-ninja-aio-crud 0.8.3__tar.gz → 0.9.0__tar.gz

{django_ninja_aio_crud-0.8.3 → django_ninja_aio_crud-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 0.8.3
+Version: 0.9.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10

{django_ninja_aio_crud-0.8.3 → django_ninja_aio_crud-0.9.0}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-0.8.3 → django_ninja_aio_crud-0.9.0}/ninja_aio/views.py

@@ -57,15 +57,67 @@ class APIView:
             pass
         """
 
-    def add_views(self):
+    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())
+        return self.api.add_router(f"{self.api_route_path}", self._add_views())
 
 
 class APIViewSet:
+    """
+    A base class for creating API views with CRUD operations.
+
+    This class provides methods for creating, listing, retrieving, updating,
+    and deleting objects of a specified model. It supports pagination,
+    authentication, and custom query parameters.
+
+    ## Attributes:
+        - **model** (`ModelSerializer | Model`): The model for CRUD operations.
+        - **api** (`NinjaAPI`): The API instance to which the views are added.
+        - **schema_in** (`Schema | None`): Schema for input data in create/update operations.
+        - **schema_out** (`Schema | None`): Schema for output data in list/retrieve operations.
+        - **schema_update** (`Schema | None`): Schema for update operations.
+        - **auth** (`list | None`): Authentication classes for the views.
+        - **get_auth** (`list | None`): Authentication for GET requests.
+        - **post_auth** (`list | None`): Authentication for POST requests.
+        - **patch_auth** (`list | None`): Authentication for PATCH requests.
+        - **delete_auth** (`list | None`): Authentication for DELETE requests.
+        - **pagination_class** (`type[AsyncPaginationBase]`): Pagination class to use.
+        - **query_params** (`dict[str, tuple[type, ...]]`): Query parameters for filtering.
+        - **disable** (`list[type[VIEW_TYPES]]`): List of view types to disable.
+        - **api_route_path** (`str`): Base path for the API route.
+        - **list_docs** (`str`): Documentation for the list view.
+        - **create_docs** (`str`): Documentation for the create view.
+        - **retrieve_docs** (`str`): Documentation for the retrieve view.
+        - **update_docs** (`str`): Documentation for the update view.
+        - **delete_docs** (`str`): Documentation for the delete view.
+
+    ## Notes:
+        If the model is a ModelSerializer instance, schemas are generated
+        automatically based on Create, Read, and Update serializers.
+        Override the `views` method to add custom views.
+        Override the `query_params_handler` method to handle query params
+        and return a filtered queryset.
+
+    ## Methods:
+        - **create_view**: Creates a new object.
+        - **list_view**: Lists all objects.
+        - **retrieve_view**: Retrieves an object by its primary key.
+        - **update_view**: Updates an object by its primary key.
+        - **delete_view**: Deletes an object by its primary key.
+        - **views**: Override to add custom views.
+        - **add_views_to_route**: Adds the views to the API route.
+
+    ## Example:
+        class MyModelViewSet(APIViewSet):
+            model = MyModel  # Your Django model
+            api = my_api_instance  # Your NinjaAPI instance
+
+        MyModelViewSet().add_views_to_route()
+    """
+
     model: ModelSerializer | Model
     api: NinjaAPI
     schema_in: Schema | None = None
@@ -80,6 +132,11 @@ class APIViewSet:
     query_params: dict[str, tuple[type, ...]] = {}
     disable: list[type[VIEW_TYPES]] = []
     api_route_path: str = ""
+    list_docs = "List all objects."
+    create_docs = "Create a new object."
+    retrieve_docs = "Retrieve a specific object by its primary key."
+    update_docs = "Update an object by its primary key."
+    delete_docs = "Delete an object by its primary key."
 
     def __init__(self) -> None:
         self.error_codes = ERROR_CODES
@@ -87,10 +144,13 @@ class APIViewSet:
         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.model_verbose_name = self.model._meta.verbose_name.capitalize()
+        self.router_tag = self.model_verbose_name
         self.router = Router(tags=[self.router_tag])
         self.path = "/"
+        self.get_path = ""
         self.path_retrieve = f"{{{self.model_util.model_pk_name}}}/"
+        self.get_path_retrieve = f"/{{{self.model_util.model_pk_name}}}"
         self.api_route_path = (
             self.api_route_path or self.model_util.verbose_name_path_resolver()
         )
@@ -115,13 +175,13 @@ class APIViewSet:
 
     def get_view_auth(self):
         return self._auth_view("get")
-    
+
     def post_view_auth(self):
         return self._auth_view("post")
-    
+
     def patch_view_auth(self):
         return self._auth_view("patch")
-    
+
     def delete_view_auth(self):
         return self._auth_view("delete")
 
@@ -162,9 +222,11 @@ class APIViewSet:
         @self.router.post(
             self.path,
             auth=self.post_view_auth(),
+            summary=f"Create {self.model._meta.verbose_name.capitalize()}",
+            description=self.create_docs,
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def create(request: HttpRequest, data: self.schema_in): # type: ignore
+        async def create(request: HttpRequest, data: self.schema_in):  # type: ignore
             return 201, await self.model_util.create_s(request, data, self.schema_out)
 
         create.__name__ = f"create_{self.model_util.model_name}"
@@ -172,8 +234,10 @@ class APIViewSet:
 
     def list_view(self):
         @self.router.get(
-            self.path,
+            self.get_path,
             auth=self.get_view_auth(),
+            summary=f"List {self.model._meta.verbose_name_plural.capitalize()}",
+            description=self.list_docs,
             response={
                 200: List[self.schema_out],
                 self.error_codes: GenericMessageSchema,
@@ -181,7 +245,8 @@ class APIViewSet:
         )
         @paginate(self.pagination_class)
         async def list(
-            request: HttpRequest, filters: Query[self.filters_schema] = None # type: ignore
+            request: HttpRequest,
+            filters: Query[self.filters_schema] = None,  # type: ignore
         ):
             qs = self.model.objects.select_related()
             if isinstance(self.model, ModelSerializerMeta):
@@ -202,11 +267,13 @@ class APIViewSet:
 
     def retrieve_view(self):
         @self.router.get(
-            self.path_retrieve,
+            self.get_path_retrieve,
             auth=self.get_view_auth(),
+            summary=f"Retrieve {self.model._meta.verbose_name.capitalize()}",
+            description=self.retrieve_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def retrieve(request: HttpRequest, pk: Path[self.path_schema]): # type: ignore
+        async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
             obj = await self.model_util.get_object(request, self._get_pk(pk))
             return await self.model_util.read_s(request, obj, self.schema_out)
 
@@ -217,10 +284,14 @@ class APIViewSet:
         @self.router.patch(
             self.path_retrieve,
             auth=self.patch_view_auth(),
+            summary=f"Update {self.model._meta.verbose_name.capitalize()}",
+            description=self.update_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def update(
-            request: HttpRequest, data: self.schema_update, pk: Path[self.path_schema]  # type: ignore
+            request: HttpRequest,
+            data: self.schema_update,  # type: ignore
+            pk: Path[self.path_schema],  # type: ignore
         ):
             return await self.model_util.update_s(
                 request, data, self._get_pk(pk), self.schema_out
@@ -233,9 +304,11 @@ class APIViewSet:
         @self.router.delete(
             self.path_retrieve,
             auth=self.delete_view_auth(),
+            summary=f"Delete {self.model._meta.verbose_name.capitalize()}",
+            description=self.delete_docs,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        async def delete(request: HttpRequest, pk: Path[self.path_schema]): # type: ignore
+        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))
 
         delete.__name__ = f"delete_{self.model_util.model_name}"
@@ -274,7 +347,7 @@ class APIViewSet:
             pass
         """
 
-    def add_views(self):
+    def _add_views(self):
         if "all" in self.disable:
             self.views()
             return self.router
@@ -290,6 +363,6 @@ class APIViewSet:
 
     def add_views_to_route(self):
         return self.api.add_router(
-            f"{self.api_route_path}/",
-            self.add_views(),
+            f"{self.api_route_path}",
+            self._add_views(),
         )