django-ninja-aio-crud 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

ninja_aio/renders.py

@@ -1,5 +1,6 @@
 import base64
 from ipaddress import IPv4Address, IPv6Address
+from typing import Any
 
 import orjson
 from django.http import HttpRequest
@@ -28,27 +29,19 @@ class ORJSONRenderer(BaseRenderer):
         return cls.parse_data(data)
 
     @classmethod
-    def parse_data(cls, data: dict):
-        for k, v in data.items():
-            if isinstance(v, bytes):
-                data |= {k: base64.b64encode(v).decode()}
-                continue
-            if isinstance(v, (IPv4Address, IPv6Address)):
-                data |= {k: str(v)}
-                continue
-            if isinstance(v, dict):
-                for k_rel, v_rel in v.items():
-                    if isinstance(v_rel, bytes):
-                        v |= {k_rel: base64.b64encode(v_rel).decode()}
-                    if isinstance(v_rel, (IPv4Address, IPv6Address)):
-                        v |= {k_rel: str(v_rel)}
-                data |= {k: v}
-            if isinstance(v, list):
-                for index_rel, f_rel in enumerate(v):
-                    for k_rel, v_rel in f_rel.items():
-                        if isinstance(v_rel, bytes):
-                            v[index_rel] |= {k_rel: base64.b64encode(v_rel).decode()}
-                        if isinstance(v_rel, (IPv4Address, IPv6Address)):
-                            v[index_rel] |= {k_rel: str(v_rel)}
-                data |= {k: v}
-        return data
+    def transform(cls, value):
+        if isinstance(value, bytes):
+            return base64.b64encode(value).decode()
+        if isinstance(value, (IPv4Address, IPv6Address)):
+            return str(value)
+        if isinstance(value, dict):
+            return {k: cls.transform(v) for k, v in value.items()}
+        if isinstance(value, list):
+            return [cls.transform(item) for item in value]
+        return value
+
+    @classmethod
+    def parse_data(cls, data: dict | Any):
+        if not isinstance(data, dict):
+            return cls.transform(data)
+        return {k: cls.transform(v) for k, v in data.items()}

ninja_aio/schemas.py

@@ -3,7 +3,7 @@ from typing import Optional, Type
 from ninja import Schema
 from .models import ModelSerializer
 from django.db.models import Model
-from pydantic import BaseModel, RootModel, ConfigDict
+from pydantic import BaseModel, RootModel, ConfigDict, model_validator
 
 
 class GenericMessageSchema(RootModel[dict[str, str]]):
@@ -63,5 +63,20 @@ class M2MRelationSchema(BaseModel):
     path: Optional[str] = ""
     auth: Optional[list] = None
     filters: Optional[dict[str, tuple]] = None
+    related_schema: Optional[Type[Schema]] = None
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_related_schema(cls, data):
+        related_schema = data.get("related_schema")
+        if related_schema is not None:
+            return data
+        model = data.get("model")
+        if not issubclass(model, ModelSerializer):
+            raise ValueError(
+                "related_schema must be provided if model is not a ModelSerializer",
+            )
+        data["related_schema"] = model.generate_related_s()
+        return data

ninja_aio/views.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import List
 
 from ninja import NinjaAPI, Router, Schema, Path, Query
@@ -11,12 +10,9 @@ from pydantic import create_model
 from .models import ModelSerializer, ModelUtil
 from .schemas import (
     GenericMessageSchema,
-    M2MSchemaOut,
-    M2MSchemaIn,
-    M2MAddSchemaIn,
-    M2MRemoveSchemaIn,
     M2MRelationSchema,
 )
+from .helpers import ManyToManyAPI
 from .types import ModelSerializerMeta, VIEW_TYPES
 from .decorators import unique_view
 
@@ -186,7 +182,6 @@ 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.m2m_filters_schemas = self._generate_m2m_filters_schemas()
         self.model_verbose_name = self.model._meta.verbose_name.capitalize()
         self.router_tag = self.model_verbose_name
         self.router = Router(tags=[self.router_tag])
@@ -197,6 +192,11 @@ class APIViewSet:
         self.api_route_path = (
             self.api_route_path or self.model_util.verbose_name_path_resolver()
         )
+        self.m2m_api = (
+            None
+            if not self.m2m_relations
+            else ManyToManyAPI(relations=self.m2m_relations, view_set=self)
+        )
 
     @property
     def _crud_views(self):
@@ -250,18 +250,6 @@ class APIViewSet:
         """
         return self._generate_schema(self.query_params, "FiltersSchema")
 
-    def _generate_m2m_filters_schemas(self):
-        """
-        Build per-relation filters schemas for M2M endpoints.
-        """
-        return {
-            m2m_data.related_name: self._generate_schema(
-                {} if not m2m_data.filters else m2m_data.filters,
-                f"{self.model_util.model_name}{m2m_data.related_name.capitalize()}FiltersSchema",
-            )
-            for m2m_data in self.m2m_relations
-        }
-
     def _get_pk(self, data: Schema):
         """
         Extract pk from a path schema instance.
@@ -294,6 +282,7 @@ class APIViewSet:
         """
         Register create endpoint.
         """
+
         @self.router.post(
             self.path,
             auth=self.post_view_auth(),
@@ -311,6 +300,7 @@ class APIViewSet:
         """
         Register list endpoint with pagination and optional filters.
         """
+
         @self.router.get(
             self.get_path,
             auth=self.get_view_auth(),
@@ -347,6 +337,7 @@ class APIViewSet:
         """
         Register retrieve endpoint.
         """
+
         @self.router.get(
             self.get_path_retrieve,
             auth=self.get_view_auth(),
@@ -365,6 +356,7 @@ class APIViewSet:
         """
         Register update endpoint.
         """
+
         @self.router.patch(
             self.path_retrieve,
             auth=self.patch_view_auth(),
@@ -388,6 +380,7 @@ class APIViewSet:
         """
         Register delete endpoint.
         """
+
         @self.router.delete(
             self.path_retrieve,
             auth=self.delete_view_auth(),
@@ -406,174 +399,13 @@ class APIViewSet:
         Override to register custom non-CRUD endpoints on self.router.
         Use auth=self.auth or verb specific auth attributes if needed.
         """
+        pass
 
-    async def _check_m2m_objs(
-        self,
-        request: HttpRequest,
-        objs_pks: list,
-        model: ModelSerializer | Model,
-        related_manager: QuerySet,
-        remove: bool = False,
-    ):
-        """
-        Validate requested add/remove pk list for M2M operations.
-        Returns (errors, details, objects_to_process).
-        """
-        errors, objs_detail, objs = [], [], []
-        rel_objs = [rel_obj async for rel_obj in related_manager.select_related().all()]
-        rel_model_name = model._meta.verbose_name.capitalize()
-        for obj_pk in objs_pks:
-            rel_obj = await (
-                await ModelUtil(model).get_object(request, 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 id {obj_pk} is {'not ' if remove else ''}in {self.model_util.model_name}"
-                )
-                continue
-            objs.append(rel_obj)
-            objs_detail.append(
-                f"{rel_model_name} with id {obj_pk} successfully {'removed' if remove else 'added'}"
-            )
-        return errors, objs_detail, objs
-
-    def _m2m_views(self):
-        """
-        Register M2M get/manage endpoints for each relation in m2m_relations.
-        Supports optional per-relation filters and custom query handler:
-        <related_name>_query_params_handler.
-        """
-        for m2m_data in self.m2m_relations:
-            model = m2m_data.model
-            related_name = m2m_data.related_name
-            m2m_auth = m2m_data.auth or self.m2m_auth
-            rel_util = ModelUtil(model)
-            rel_path = (
-                rel_util.verbose_name_path_resolver()
-                if not m2m_data.path
-                else m2m_data.path
-            )
-            m2m_add = m2m_data.add
-            m2m_remove = m2m_data.remove
-            m2m_get = m2m_data.get
-            filters_schema = self.m2m_filters_schemas.get(related_name)
-            if m2m_get:
-
-                @self.router.get(
-                    f"{self.path_retrieve}{rel_path}",
-                    response={
-                        200: List[model.generate_related_s(),],
-                        self.error_codes: GenericMessageSchema,
-                    },
-                    auth=m2m_auth,
-                    summary=f"Get {rel_util.model._meta.verbose_name_plural.capitalize()}",
-                    description=f"Get all related {rel_util.model._meta.verbose_name_plural.capitalize()}",
-                )
-                @unique_view(f"get_{self.model_util.model_name}_{rel_path}")
-                @paginate(self.pagination_class)
-                async def get_related(
-                    request: HttpRequest,
-                    pk: Path[self.path_schema],  # type: ignore
-                    filters: Query[filters_schema] = None # type: ignore
-                ):
-                    obj = await self.model_util.get_object(request, self._get_pk(pk))
-                    related_manager = getattr(obj, related_name)
-                    related_qs = related_manager.all()
-                    if (
-                        filters is not None
-                        and (
-                            query_handler := getattr(
-                                self,
-                                f"{m2m_data.related_name}_query_params_handler",
-                                None,
-                            )
-                        )
-                        is not None
-                    ):
-                        related_qs = await query_handler(
-                            related_qs, filters.model_dump()
-                        )
-                    related_objs = [
-                        await rel_util.read_s(
-                            request, rel_obj, model.generate_related_s()
-                        )
-                        async for rel_obj in related_qs
-                    ]
-                    return related_objs
-
-            if m2m_add or m2m_remove:
-                summary = f"{'Add or Remove' if m2m_add and m2m_remove else 'Add' if m2m_add else 'Remove'} {rel_util.model._meta.verbose_name_plural.capitalize()}"
-                description = f"{'Add or remove' if m2m_add and m2m_remove else 'Add' if m2m_add else 'Remove'} {rel_util.model._meta.verbose_name_plural.capitalize()}"
-                schema_in = (
-                    M2MSchemaIn
-                    if m2m_add and m2m_remove
-                    else M2MAddSchemaIn
-                    if m2m_add
-                    else M2MRemoveSchemaIn
-                )
-
-                @self.router.post(
-                    f"{self.path_retrieve}{rel_path}/",
-                    response={
-                        200: M2MSchemaOut,
-                        self.error_codes: GenericMessageSchema,
-                    },
-                    auth=m2m_auth,
-                    summary=summary,
-                    description=description,
-                )
-                @unique_view(f"manage_{self.model_util.model_name}_{rel_path}")
-                async def manage_related(
-                    request: HttpRequest,
-                    pk: Path[self.path_schema],  # type: ignore
-                    data: schema_in,  # type: ignore
-                ):
-                    obj = await self.model_util.get_object(request, self._get_pk(pk))
-                    related_manager: QuerySet = getattr(obj, related_name)
-                    add_errors, add_details, add_objs = [], [], []
-                    remove_errors, remove_details, remove_objs = [], [], []
-
-                    if m2m_add and hasattr(data, "add"):
-                        (
-                            add_errors,
-                            add_details,
-                            add_objs,
-                        ) = await self._check_m2m_objs(
-                            request, data.add, model, related_manager
-                        )
-                    if m2m_remove and hasattr(data, "remove"):
-                        (
-                            remove_errors,
-                            remove_details,
-                            remove_objs,
-                        ) = await self._check_m2m_objs(
-                            request,
-                            data.remove,
-                            model,
-                            related_manager,
-                            remove=True,
-                        )
-
-                    await asyncio.gather(
-                        related_manager.aadd(*add_objs),
-                        related_manager.aremove(*remove_objs),
-                    )
-                    results = add_details + remove_details
-                    errors = add_errors + remove_errors
-
-                    return {
-                        "results": {
-                            "count": len(results),
-                            "details": results,
-                        },
-                        "errors": {
-                            "count": len(errors),
-                            "details": errors,
-                        },
-                    }
+    def _set_additional_views(self):
+        self.views()
+        if self.m2m_api is not None:
+            self.m2m_api._add_views()
+        return self.router
 
     def _add_views(self):
         """
@@ -581,10 +413,7 @@ class APIViewSet:
         If 'all' in disable only CRUD is skipped; M2M + custom still added.
         """
         if "all" in self.disable:
-            if self.m2m_relations:
-                self._m2m_views()
-            self.views()
-            return self.router
+            return self._set_additional_views()
 
         for views_type, (schema, view) in self._crud_views.items():
             if views_type not in self.disable and (
@@ -592,10 +421,7 @@ class APIViewSet:
             ):
                 view()
 
-        self.views()
-        if self.m2m_relations:
-            self._m2m_views()
-        return self.router
+        return self._set_additional_views()
 
     def add_views_to_route(self):
         """