django-ninja-aio-crud 2.0.0__tar.gz → 2.0.0rc2__tar.gz

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/PKG-INFO

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

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/decorators.py

@@ -143,76 +143,3 @@ def unique_view(self: object | str, plural: bool = False):
         return func  # Return original function (no wrapper)
 
     return decorator
-
-
-def decorate_view(*decorators):
-    """
-    Compose and apply multiple decorators to a view (sync or async) without adding an extra wrapper.
-
-    This utility was introduced to support class-based patterns where Django Ninja’s
-    built-in `decorate_view` does not fit well. For APIs implemented with vanilla
-    Django Ninja (function-based style), you should continue using Django Ninja’s
-    native `decorate_view`.
-
-    Behavior:
-    - Applies decorators in the same order as Python’s stacking syntax:
-        @d1
-        @d2
-      is equivalent to: view = d1(d2(view))
-    - Supports both synchronous and asynchronous views.
-    - Ignores None values, enabling conditional decoration.
-    - Does not introduce an additional wrapper; composition depends on each
-      decorator for signature/metadata preservation (e.g., using functools.wraps).
-
-        *decorators: Decorator callables to apply to the target view. Any None values
-            are skipped.
-
-        Callable: A decorator that applies the provided decorators in Python stacking order.
-
-        Method usage in class-based patterns:
-
-    Args:
-        *decorators: Decorator callables to apply to the target view. Any None
-            values are skipped.
-
-    Returns:
-        A decorator that applies the provided decorators in Python stacking order.
-
-    Examples:
-        Basic usage:
-            class MyAPIViewSet(APIViewSet):
-                api = api
-                model = MyModel
-
-                def views(self):
-                    @self.router.get('some-endpoint/')
-                    @decorate_view(authenticate, log_request)
-                    async def some_view(request):
-                        ...
-        
-        Conditional decoration (skips None):
-            class MyAPIViewSet(APIViewSet):
-                api = api
-                model = MyModel
-                cache_dec = cache_page(60) if settings.ENABLE_CACHE else None
-                def views(self):
-                    @self.router.get('data/')
-                    @decorate_view(self.cache_dec, authenticate)
-                    async def data_view(request):
-                        ...
-
-    Notes:
-        - Each decorator is applied in the order provided, with the first decorator
-          wrapping the result of the second, and so on.
-        - Ensure that each decorator is compatible with the view’s sync/async nature.
-    """
-
-    def _decorator(view):
-        wrapped = view
-        for dec in reversed(decorators):
-            if dec is None:
-                continue
-            wrapped = dec(wrapped)
-        return wrapped
-
-    return _decorator

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/helpers/api.py

@@ -38,34 +38,27 @@ class ManyToManyAPI:
     Core behaviors:
         - Dynamically generates per-relation filter schemas for query parameters.
         - Supports custom per-relation query filtering handlers on the parent view set
-          via a `{related_name}_query_params_handler` coroutine for GET list filters.
-        - Supports custom per-relation object resolution for add/remove validation via
-          `{related_name}_query_handler(request, pk, instance)` used during POST to
-          resolve a single related object before mutation.
+            via a `{related_name}_query_params_handler` coroutine.
         - Validates requested add/remove primary keys, producing granular success and
-          error feedback.
+            error feedback.
         - Performs add/remove operations concurrently using asyncio.gather when both
-          types of operations are requested in the same call.
+            types of operations are requested in the same call.
 
     Attributes established at initialization:
         relations: list of M2MRelationSchema defining each relation.
         view_set: The parent APIViewSet instance from which router, pagination, model util,
-                  and path schema are derived.
+                            and path schema are derived.
         router: Ninja router used to register generated endpoints.
         pagination_class: Pagination class used for GET related endpoints.
         path_schema: Pydantic schema used to validate path parameters (e.g., primary key).
         related_model_util: A ModelUtil instance cloned from the parent view set to access
-                            base object retrieval helpers.
+                                                base object retrieval helpers.
         relations_filters_schemas: Mapping of related_name -> generated Pydantic filter schema.
 
     Generated endpoint naming conventions:
         GET   -> get_{base_model_name}_{relation_path}
         POST  -> manage_{base_model_name}_{relation_path}
 
-    Endpoint registration details:
-        - GET: registered at `{retrieve_path}{relation_path}` with pagination; accepts Query filters.
-        - POST: registered at `{retrieve_path}{relation_path}/` (trailing slash) to manage add/remove.
-
     All responses standardize success and error reporting for POST as:
     {
         "results": {"count": int, "details": [str, ...]},
@@ -73,29 +66,25 @@ class ManyToManyAPI:
     }
 
     Concurrency note:
-        - Add and remove operations are executed concurrently when both lists are non-empty,
-          minimizing round-trip latency for bulk mutations.
-        - Uses related_manager.aadd(...) and related_manager.aremove(...) inside asyncio.gather.
+        Add and remove operations are executed concurrently when both lists are non-empty,
+        minimizing round-trip latency for bulk mutations.
 
     Error semantics:
         - Missing related objects: reported individually.
         - Invalid operation context (e.g., removing objects not currently related or adding
-          objects already related) reported per primary key.
+            objects already related) reported per primary key.
         - Successful operations yield a corresponding success detail string per PK.
 
     Security / auth:
         - Each relation may optionally override auth via its schema; otherwise falls back
-          to a default configured on the instance (self.default_auth).
+            to a default configured on the instance (self.default_auth).
 
     Pagination:
         - Applied only to GET related endpoints via @paginate(self.pagination_class).
 
     Extensibility:
         - Provide custom query param handling by defining an async method on the parent
-          view set: `<related_name>_query_params_handler(self, queryset, filters_dict)`.
-        - Provide custom per-PK resolution for POST validation by defining an async method:
-          `<related_name>_query_handler(self, request, pk, instance)` returning a queryset,
-          from which .afirst() is used to resolve the single target object.
+            view set: `<related_name>_query_params_handler(self, queryset, filters_dict)`.
         - Customize relation filtering schema via each relation's `filters` definition.
 
     -----------------------------------------------------------------------
@@ -125,44 +114,28 @@ class ManyToManyAPI:
 
     -----------------------------------------------------------------------
 
-    _get_query_params_handler(related_name)
-    Retrieve an optional per-relation query handler from the parent view set for GET list filters.
-    Naming convention: `<related_name}_query_params_handler`.
-
-    Parameters:
-        related_name (str): The relation's attribute name on the base model.
-
-    Returns:
-        Coroutine | None: Handler to transform or filter the queryset based on query params.
-
-    -----------------------------------------------------------------------
-
     _get_query_handler(related_name)
-    Retrieve an optional per-relation single-object resolution handler from the parent view set
-    used during POST add/remove validation. If present, it receives `(request, pk, instance)` and
-    should return a queryset from which `.afirst()` will resolve the target object.
+    Retrieve an optional per-relation query handler coroutine from the parent view set.
+    Naming convention: `<related_name>_query_params_handler`.
 
     Parameters:
         related_name (str): The relation's attribute name on the base model.
 
     Returns:
-        Coroutine | None: Handler to resolve a single related object by pk.
+        Coroutine | None: Handler to transform or filter the queryset based on query params.
 
     -----------------------------------------------------------------------
 
-    _check_m2m_objs(request, objs_pks, related_model, related_manager, related_name, instance, remove=False)
+    _check_m2m_objs(request, objs_pks, model, related_manager, remove=False)
     Validate requested primary keys for add/remove operations against the current
     relation state. Performs existence checks and logical consistency (e.g., prevents
-    adding already-related objects or removing non-related objects). Uses `_get_query_handler`
-    when available; otherwise falls back to ModelUtil(...).get_objects(...) to resolve by pk.
+    adding already-related objects or removing non-related objects).
 
     Parameters:
         request (HttpRequest): Incoming request context (passed to ModelUtil for access control).
         objs_pks (list): List of primary keys to add or remove.
-        related_model (ModelSerializer | Model): Model class or serializer used to resolve objects.
+        model (ModelSerializer | Model): Model class or serializer used to resolve objects.
         related_manager (QuerySet): Related manager for the base object's M2M field.
-        related_name (str): M2M field name on the base object.
-        instance (ModelSerializer | Model): Base object instance (owner of the relation).
         remove (bool): If True, treat operation as removal validation.
 
     Returns:
@@ -177,7 +150,7 @@ class ManyToManyAPI:
 
     -----------------------------------------------------------------------
 
-    _collect_m2m(request, pks, model, related_manager, related_name, instance, remove=False)
+    _collect_m2m(request, pks, model, related_manager, remove=False)
     Wrapper around _check_m2m_objs that short-circuits on empty PK lists.
 
     Parameters:
@@ -185,8 +158,6 @@ class ManyToManyAPI:
         pks (list): Primary keys proposed for mutation.
         model (ModelSerializer | Model)
         related_manager (QuerySet)
-        related_name (str)
-        instance (ModelSerializer | Model)
         remove (bool): Operation type flag.
 
     Returns:
@@ -194,30 +165,38 @@ class ManyToManyAPI:
 
     -----------------------------------------------------------------------
 
-    _register_get_relation_view(...)
-    Registers the GET endpoint for listing related objects. Applies optional
-    query params handler for filtering. Uses pagination and serializes via `list_read_s`.
-
-    -----------------------------------------------------------------------
-
-    _register_manage_relation_view(...)
-    Registers the POST endpoint for adding/removing related objects. Validates via
-    `_collect_m2m` and executes mutations concurrently using `aadd`/`aremove` with
-    `asyncio.gather`. Aggregates per-PK results and errors into a standardized payload.
-
-    -----------------------------------------------------------------------
-
     _build_views(relation)
     Dynamically define and register the GET and/or POST endpoints for a single M2M
     relation based on the relation's schema flags (get/add/remove). Builds filter
     schemas, resolves path fragments, and binds handlers to the router with unique
     operation IDs.
 
+    Parameters:
+        relation (M2MRelationSchema): Declarative specification for one M2M relation.
+
+    Side effects:
+        - Registers endpoints on self.router.
+        - Creates closures (get_related / manage_related) capturing relation context.
+
+    GET endpoint behavior:
+        - Retrieves base object via related_model_util.
+        - Fetches all related objects; applies optional query handler and filters.
+        - Serializes each related object with rel_util.read_s.
+
+    POST endpoint behavior:
+        - Parses add/remove PK lists.
+        - Validates objects via _collect_m2m.
+        - Performs asynchronous add/remove operations using aadd / aremove.
+        - Aggregates results and errors into standardized response payload.
+
     -----------------------------------------------------------------------
 
     _add_views()
     Iterates over all declared relations and invokes _build_views to attach endpoints.
 
+    Side effects:
+        - Populates router with all required M2M endpoints.
+
     -----------------------------------------------------------------------
 
     Usage Example (conceptual):
@@ -262,56 +241,41 @@ class ManyToManyAPI:
             for data in self.relations
         }
 
-    def _get_query_params_handler(self, related_name: str) -> Coroutine | None:
-        return getattr(self.view_set, f"{related_name}_query_params_handler", None)
-
     def _get_query_handler(self, related_name: str) -> Coroutine | None:
-        return getattr(self.view_set, f"{related_name}_query_handler", None)
+        return getattr(self.view_set, f"{related_name}_query_params_handler", None)
 
     async def _check_m2m_objs(
         self,
         request: HttpRequest,
         objs_pks: list,
-        related_model: ModelSerializer | Model,
+        model: ModelSerializer | Model,
         related_manager: QuerySet,
-        related_name: str,
-        instance: ModelSerializer | Model,
         remove: bool = False,
     ):
         """
         Validate requested add/remove pk list for M2M operations.
         Returns (errors, details, objects_to_process).
-        Uses per-PK query handler if available, else falls back to ModelUtil lookup by pk.
         """
         errors, objs_detail, objs = [], [], []
         rel_objs = [rel_obj async for rel_obj in related_manager.select_related().all()]
-        rel_model_name = related_model._meta.verbose_name.capitalize()
+        rel_model_name = model._meta.verbose_name.capitalize()
         for obj_pk in objs_pks:
-            if query_handler := self._get_query_handler(related_name):
-                rel_obj = await (
-                    await query_handler(
-                        request,
-                        obj_pk,
-                        instance,
-                    )
-                ).afirst()
-            else:
-                rel_obj = await (
-                    await ModelUtil(related_model).get_objects(
-                        request, query_data=ObjectsQuerySchema(filters={"pk": obj_pk})
-                    )
-                ).afirst()
+            rel_obj = await (
+                await ModelUtil(model).get_objects(
+                    request, query_data=ObjectsQuerySchema(filters={"pk": obj_pk})
+                )
+            ).afirst()
             if rel_obj is None:
                 errors.append(f"{rel_model_name} with pk {obj_pk} not found.")
                 continue
             if remove ^ (rel_obj in rel_objs):
                 errors.append(
-                    f"{rel_model_name} with pk {obj_pk} is {'not ' if remove else ''}in {self.related_model_util.model_name}"
+                    f"{rel_model_name} with id {obj_pk} is {'not ' if remove else ''}in {self.related_model_util.model_name}"
                 )
                 continue
             objs.append(rel_obj)
             objs_detail.append(
-                f"{rel_model_name} with pk {obj_pk} successfully {'removed' if remove else 'added'}"
+                f"{rel_model_name} with id {obj_pk} successfully {'removed' if remove else 'added'}"
             )
         return errors, objs_detail, objs
 
@@ -319,22 +283,14 @@ class ManyToManyAPI:
         self,
         request: HttpRequest,
         pks: list,
-        reletad_model: ModelSerializer | Model,
+        model: ModelSerializer | Model,
         related_manager: QuerySet,
-        related_name: str,
-        instance: ModelSerializer | Model,
-        remove: bool = False,
+        remove=False,
     ):
         if not pks:
             return ([], [], [])
         return await self._check_m2m_objs(
-            request,
-            pks,
-            reletad_model,
-            related_manager,
-            related_name,
-            instance,
-            remove=remove,
+            request, pks, model, related_manager, remove=remove
         )
 
     def _register_get_relation_view(
@@ -370,14 +326,16 @@ class ManyToManyAPI:
             related_manager = getattr(obj, related_name)
             related_qs = related_manager.all()
 
-            query_handler = self._get_query_params_handler(related_name)
+            query_handler = self._get_query_handler(related_name)
             if filters is not None and query_handler:
                 if asyncio.iscoroutinefunction(query_handler):
                     related_qs = await query_handler(related_qs, filters.model_dump())
                 else:
                     related_qs = query_handler(related_qs, filters.model_dump())
 
-            return await rel_util.list_read_s(related_schema, request, related_qs)
+            return await rel_util.list_read_s(
+                related_schema, request, related_qs
+            )
 
     def _resolve_action_schema(self, add: bool, remove: bool):
         return self.views_action_map[(add, remove)]
@@ -385,7 +343,7 @@ class ManyToManyAPI:
     def _register_manage_relation_view(
         self,
         *,
-        related_model: ModelSerializer | Model,
+        model,
         related_name: str,
         m2m_auth,
         rel_util: ModelUtil,
@@ -422,21 +380,10 @@ class ManyToManyAPI:
             remove_pks = getattr(data, "remove", []) if m2m_remove else []
 
             add_errors, add_details, add_objs = await self._collect_m2m(
-                request,
-                add_pks,
-                related_model,
-                related_manager,
-                related_name,
-                obj,
+                request, add_pks, model, related_manager
             )
             remove_errors, remove_details, remove_objs = await self._collect_m2m(
-                request,
-                remove_pks,
-                related_model,
-                related_manager,
-                related_name,
-                obj,
-                remove=True,
+                request, remove_pks, model, related_manager, remove=True
             )
 
             tasks = []
@@ -476,7 +423,7 @@ class ManyToManyAPI:
 
         if m2m_add or m2m_remove:
             self._register_manage_relation_view(
-                related_model=model,
+                model=model,
                 related_name=related_name,
                 m2m_auth=m2m_auth,
                 rel_util=rel_util,

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/renders.py

@@ -4,13 +4,11 @@ from typing import Any
 
 import orjson
 from django.http import HttpRequest
-from django.conf import settings
 from ninja.renderers import BaseRenderer
 
 
 class ORJSONRenderer(BaseRenderer):
     media_type = "application/json"
-    option = getattr(settings, "NINJA_AIO_ORJSON_RENDERER_OPTION", None)
 
     def render(self, request: HttpRequest, data: dict, *, response_status):
         try:
@@ -18,13 +16,9 @@ class ORJSONRenderer(BaseRenderer):
             for k, v in old_d.items():
                 if isinstance(v, list):
                     data |= {k: self.render_list(v)}
-            return self.dumps(self.render_dict(data))
+            return orjson.dumps(self.render_dict(data))
         except AttributeError:
-            return self.dumps(data)
-
-    @classmethod
-    def dumps(cls, data: dict) -> bytes:
-        return orjson.dumps(data, option=cls.option)
+            return orjson.dumps(data)
 
     @classmethod
     def render_list(cls, data: list[dict]) -> list[dict]:

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/schemas/helpers.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Type
+from typing import Optional, Type
 
 from ninja import Schema
 from ninja_aio.types import ModelSerializerMeta
@@ -79,12 +79,4 @@ class QuerySchema(ModelQuerySetSchema):
 
 class QueryUtilBaseScopesSchema(BaseModel):
     READ: str = "read"
-    QUERYSET_REQUEST: str = "queryset_request"
-
-
-class DecoratorsSchema(Schema):
-    list: Optional[List] = []
-    retrieve: Optional[List] = []
-    create: Optional[List] = []
-    update: Optional[List] = []
-    delete: Optional[List] = []
+    QUERYSET_REQUEST: str = "queryset_request"

{django_ninja_aio_crud-2.0.0 → django_ninja_aio_crud-2.0.0rc2}/ninja_aio/views.py

@@ -7,7 +7,7 @@ from django.http import HttpRequest
 from django.db.models import Model, QuerySet
 from pydantic import create_model
 
-from ninja_aio.schemas.helpers import ModelQuerySetSchema, QuerySchema, DecoratorsSchema
+from ninja_aio.schemas.helpers import ModelQuerySetSchema, QuerySchema
 
 from .models import ModelSerializer, ModelUtil
 from .schemas import (
@@ -16,7 +16,7 @@ from .schemas import (
 )
 from .helpers.api import ManyToManyAPI
 from .types import ModelSerializerMeta, VIEW_TYPES
-from .decorators import unique_view, decorate_view
+from .decorators import unique_view
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
 
@@ -158,7 +158,6 @@ class APIViewSet:
 
     model: ModelSerializer | Model
     api: NinjaAPI
-    router_tag: str = ""
     schema_in: Schema | None = None
     schema_out: Schema | None = None
     schema_update: Schema | None = None
@@ -178,7 +177,6 @@ class APIViewSet:
     delete_docs = "Delete an object by its primary key."
     m2m_relations: list[M2MRelationSchema] = []
     m2m_auth: list | None = NOT_SET
-    extra_decorators: DecoratorsSchema = DecoratorsSchema()
 
     def __init__(self) -> None:
         self.error_codes = ERROR_CODES
@@ -191,9 +189,7 @@ class APIViewSet:
         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.router_tag = (
-            self.model_verbose_name if not self.router_tag else self.router_tag
-        )
+        self.router_tag = self.model_verbose_name
         self.router = Router(tags=[self.router_tag])
         self.path = "/"
         self.get_path = ""
@@ -310,7 +306,7 @@ class APIViewSet:
             description=self.create_docs,
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.create)
+        @unique_view(self)
         async def create(request: HttpRequest, data: self.schema_in):  # type: ignore
             return 201, await self.model_util.create_s(request, data, self.schema_out)
 
@@ -331,11 +327,8 @@ class APIViewSet:
                 self.error_codes: GenericMessageSchema,
             },
         )
-        @decorate_view(
-            paginate(self.pagination_class),
-            unique_view(self, plural=True),
-            *self.extra_decorators.list,
-        )
+        @unique_view(self, plural=True)
+        @paginate(self.pagination_class)
         async def list(
             request: HttpRequest,
             filters: Query[self.filters_schema] = None,  # type: ignore
@@ -363,7 +356,7 @@ class APIViewSet:
             description=self.retrieve_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.retrieve)
+        @unique_view(self)
         async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
             query_data = self._get_query_data()
             return await self.model_util.read_s(
@@ -388,7 +381,7 @@ class APIViewSet:
             description=self.update_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.update)
+        @unique_view(self)
         async def update(
             request: HttpRequest,
             data: self.schema_update,  # type: ignore
@@ -412,7 +405,7 @@ class APIViewSet:
             description=self.delete_docs,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        @decorate_view(unique_view(self), *self.extra_decorators.delete)
+        @unique_view(self)
         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))
 

django_ninja_aio_crud-2.0.0/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"

django_ninja_aio_crud-2.0.0/.github/workflows/coverage.yml

@@ -1,32 +0,0 @@
-name: Coverage
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test_coverage:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v6
-      - name: Set up Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.10'
-      - name: Install Flit
-        run: pip install flit
-      - name: Install Dependencies
-        run: flit install --symlink
-      - name: Test
-        run: |
-          coverage run -m django test --settings=tests.test_settings
-          coverage report
-          coverage xml
-
-      - name: Coverage
-        uses: codecov/codecov-action@v5.5.1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}