django-ninja-aio-crud 2.10.1__tar.gz → 2.11.1__tar.gz

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/.github/workflows/docs.yml

@@ -23,6 +23,7 @@ on:
           - "2.8"
           - "2.9"
           - "2.10"
+          - "2.11"
       make_latest:
         description: 'Set as "latest" and default?'
         type: boolean
@@ -49,6 +50,7 @@ on:
           - "2.8"
           - "2.9"
           - "2.10"
+          - "2.11"
       delete_confirm:
         description: 'Confirm deletion of the selected version'
         type: boolean

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/PKG-INFO

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

django_ninja_aio_crud-2.11.1/docs/api/renderers/orjson_renderer.md

@@ -0,0 +1,57 @@
+# ORJSON Renderer
+
+This package uses an internal ORJSON-based renderer that automatically handles JSON serialization with support for special types.
+
+## Configuration
+
+Configure serialization options via Django settings:
+
+```python
+# settings.py
+import orjson
+
+# Single option
+NINJA_AIO_ORJSON_RENDERER_OPTION = orjson.OPT_INDENT_2
+
+# Multiple options (bitwise OR)
+NINJA_AIO_ORJSON_RENDERER_OPTION = (
+    orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS
+)
+```
+
+Notes:
+
+- The value is an orjson option bitmask (e.g., `orjson.OPT_INDENT_2`, `orjson.OPT_NON_STR_KEYS`), and you can combine multiple options using `|`.
+- If not set, the default `orjson.dumps` options are used.
+
+## HttpResponse Passthrough
+
+The renderer automatically detects when you return a Django `HttpResponse` (or any `HttpResponseBase` subclass) and passes it through without JSON serialization. This allows you to return custom responses with different content types.
+
+```python
+from django.http import HttpResponse
+
+@api.get("/public-key")
+def get_public_key(request):
+    return HttpResponse(
+        settings.JWT_PUBLIC_KEY.as_pem(),
+        content_type="application/x-pem-file",
+        status=200,
+    )
+```
+
+This also works with `StreamingHttpResponse` for large files:
+
+```python
+from django.http import StreamingHttpResponse
+
+@api.get("/download")
+def download_file(request):
+    return StreamingHttpResponse(
+        file_iterator(),
+        content_type="application/octet-stream",
+    )
+```
+
+!!! note
+    When returning an `HttpResponse` directly, the response bypasses the renderer entirely. Set the `status` parameter on the `HttpResponse` itself rather than using a tuple return like `return 200, HttpResponse(...)`.

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/docs/api/views/mixins.md

@@ -183,6 +183,89 @@ This enables:
 - `GET /books?author=5` → `queryset.filter(author__id=5)`
 - `GET /books?category_name=fiction` → `queryset.filter(category__name__icontains="fiction")`
 
+## MatchCaseFilterViewSetMixin
+
+Applies conditional filtering based on boolean query parameters, where different filter conditions are applied for `True` and `False` values. This is useful when you need to map a simple boolean API parameter to complex underlying filter logic.
+
+- Behavior: For each `MatchCaseFilterSchema` entry, applies different Django ORM filters based on the boolean value of the query parameter.
+- Configuration: Define `filters_match_cases` as a list of `MatchCaseFilterSchema` objects.
+- Query params are automatically registered from `filters_match_cases`.
+- Supports both `filter()` (include) and `exclude()` operations via the `include` attribute.
+
+Each `MatchCaseFilterSchema` requires:
+
+- `query_param`: The API query parameter name exposed to clients.
+- `cases`: A `BooleanMatchFilterSchema` defining the filter conditions for `True` and `False` cases.
+
+Each `MatchConditionFilterSchema` (used within `BooleanMatchFilterSchema`) requires:
+
+- `query_filter`: A dictionary of Django ORM lookups to apply (e.g., `{"status": "active"}`).
+- `include`: Boolean indicating whether to use `filter()` (True) or `exclude()` (False). Defaults to `True`.
+
+Example - Simple status filtering:
+
+```python
+from ninja_aio.views.mixins import MatchCaseFilterViewSetMixin
+from ninja_aio.views.api import APIViewSet
+from ninja_aio.schemas import (
+    MatchCaseFilterSchema,
+    MatchConditionFilterSchema,
+    BooleanMatchFilterSchema,
+)
+
+class OrderViewSet(MatchCaseFilterViewSetMixin, APIViewSet):
+    model = models.Order
+    api = api
+    filters_match_cases = [
+        MatchCaseFilterSchema(
+            query_param="is_completed",
+            cases=BooleanMatchFilterSchema(
+                true=MatchConditionFilterSchema(
+                    query_filter={"status": "completed"},
+                    include=True,
+                ),
+                false=MatchConditionFilterSchema(
+                    query_filter={"status": "completed"},
+                    include=False,  # excludes completed orders
+                ),
+            ),
+        ),
+    ]
+```
+
+This enables:
+
+- `GET /orders?is_completed=true` → `queryset.filter(status="completed")`
+- `GET /orders?is_completed=false` → `queryset.exclude(status="completed")`
+
+Example - Complex filtering with multiple conditions:
+
+```python
+class TaskViewSet(MatchCaseFilterViewSetMixin, APIViewSet):
+    model = models.Task
+    api = api
+    filters_match_cases = [
+        MatchCaseFilterSchema(
+            query_param="show_active",
+            cases=BooleanMatchFilterSchema(
+                true=MatchConditionFilterSchema(
+                    query_filter={"status__in": ["pending", "in_progress"]},
+                    include=True,
+                ),
+                false=MatchConditionFilterSchema(
+                    query_filter={"status__in": ["completed", "cancelled"]},
+                    include=True,
+                ),
+            ),
+        ),
+    ]
+```
+
+This enables:
+
+- `GET /tasks?show_active=true` → `queryset.filter(status__in=["pending", "in_progress"])`
+- `GET /tasks?show_active=false` → `queryset.filter(status__in=["completed", "cancelled"])`
+
 ## Tips
 
 - Align `query_params` types with expected filter values; prefer Pydantic `date`/`datetime` for date filters so values implement `isoformat`.

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/ninja_aio/renders.py

@@ -3,7 +3,7 @@ from ipaddress import IPv4Address, IPv6Address
 from typing import Any
 
 import orjson
-from django.http import HttpRequest
+from django.http import HttpRequest, HttpResponseBase
 from django.conf import settings
 from ninja.renderers import BaseRenderer
 from pydantic import AnyUrl
@@ -14,6 +14,8 @@ class ORJSONRenderer(BaseRenderer):
     option = getattr(settings, "NINJA_AIO_ORJSON_RENDERER_OPTION", None)
 
     def render(self, request: HttpRequest, data: dict, *, response_status):
+        if isinstance(data, HttpResponseBase):
+            return data
         try:
             old_d = data
             for k, v in old_d.items():

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/ninja_aio/schemas/__init__.py

@@ -5,9 +5,20 @@ from .api import (
     M2MAddSchemaIn,
     M2MRemoveSchemaIn,
     M2MSchemaIn,
+)
+from .filters import (
     RelationFilterSchema,
+    MatchCaseFilterSchema,
+    MatchConditionFilterSchema,
+    BooleanMatchFilterSchema,
+)
+from .helpers import (
+    M2MRelationSchema,
+    QuerySchema,
+    ModelQuerySetSchema,
+    ObjectQuerySchema,
+    ObjectsQuerySchema,
 )
-from .helpers import M2MRelationSchema, QuerySchema, ModelQuerySetSchema, ObjectQuerySchema, ObjectsQuerySchema
 
 __all__ = [
     "GenericMessageSchema",
@@ -22,4 +33,7 @@ __all__ = [
     "ObjectQuerySchema",
     "ObjectsQuerySchema",
     "RelationFilterSchema",
+    "MatchCaseFilterSchema",
+    "MatchConditionFilterSchema",
+    "BooleanMatchFilterSchema",
 ]

django_ninja_aio_crud-2.11.1/ninja_aio/schemas/api.py

@@ -0,0 +1,24 @@
+from ninja import Schema
+
+
+class M2MDetailSchema(Schema):
+    count: int
+    details: list[str]
+
+
+class M2MSchemaOut(Schema):
+    errors: M2MDetailSchema
+    results: M2MDetailSchema
+
+
+class M2MAddSchemaIn(Schema):
+    add: list = []
+
+
+class M2MRemoveSchemaIn(Schema):
+    remove: list = []
+
+
+class M2MSchemaIn(Schema):
+    add: list = []
+    remove: list = []

django_ninja_aio_crud-2.11.1/ninja_aio/schemas/filters.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from ninja import Schema
+
+
+class FilterSchema(Schema):
+    """
+    Schema for configuring basic filters in FilterViewSetMixin.
+
+    Attributes:
+        filter_type: A tuple of (type, default_value) used to generate the query parameter
+            field in the filters schema. Example: (str, None) for optional string filter.
+        query_param: The name of the query parameter exposed in the API endpoint.
+            This is what clients will use in requests (e.g., ?name=example).
+    """
+
+    filter_type: tuple[type, Any]
+    query_param: str
+
+
+class MatchConditionFilterSchema(Schema):
+    """
+    Schema for configuring match condition filters in MatchConditionFilterViewSetMixin.
+    Attributes:
+        query_filter: The Django ORM lookup to apply (e.g., "status", "category__name").
+        include: Whether to include records matching the condition (default: True).
+    """
+    query_filter: dict[str, Any]
+    include: bool = True
+
+
+class BooleanMatchFilterSchema(Schema):
+    """
+    Schema for configuring boolean match filters in BooleanMatchFilterViewSetMixin.
+
+    Attributes:
+        true: MatchConditionFilterSchema for when the boolean filter is True.
+        false: MatchConditionFilterSchema for when the boolean filter is False.
+    """
+
+    true: MatchConditionFilterSchema
+    false: MatchConditionFilterSchema
+
+
+class RelationFilterSchema(FilterSchema):
+    """
+    Schema for configuring relation-based filters in RelationFilterViewSetMixin.
+
+    Attributes:
+        filter_type: A tuple of (type, default_value) used to generate the query parameter
+            field in the filters schema. Example: (int, None) for optional integer filter.
+        query_param: The name of the query parameter exposed in the API endpoint.
+            This is what clients will use in requests (e.g., ?author_id=5).
+        query_filter: The Django ORM lookup to apply (e.g., "author__id", "category__slug").
+    """
+
+    query_filter: str
+
+
+class MatchCaseFilterSchema(FilterSchema):
+    """
+    Schema for configuring match-case filters in MatchCaseFilterViewSetMixin.
+
+    Attributes:
+        filter_type: A tuple of (type, default_value) used to generate the query parameter
+            field in the filters schema. Defaults to (bool, None) for optional boolean filter.
+        query_param: The name of the query parameter exposed in the API endpoint.
+            This is what clients will use in requests (e.g., ?is_active=true).
+        cases: A BooleanMatchFilterSchema defining the filter conditions for True and False cases.
+    """
+
+    filter_type: tuple[type, Any] = (bool, None)
+    cases: BooleanMatchFilterSchema

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/ninja_aio/views/api.py

@@ -314,6 +314,14 @@ class APIViewSet(API):
     def _check_relations_filters(self, filter: str):
         return filter in getattr(self, "relations_filters_fields", [])
 
+    def _check_match_cases_filters(self, filter: str):
+        return filter in getattr(self, "filters_match_cases_fields", [])
+
+    def _is_special_filter(self, filter: str):
+        return self._check_relations_filters(filter) or self._check_match_cases_filters(
+            filter
+        )
+
     def _auth_view(self, view_type: str):
         """
         Resolve auth for a specific HTTP verb; falls back to self.auth if NOT_SET.

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/ninja_aio/views/mixins.py

@@ -1,5 +1,5 @@
 from ninja_aio.views.api import APIViewSet
-from ninja_aio.schemas import RelationFilterSchema
+from ninja_aio.schemas import RelationFilterSchema, MatchCaseFilterSchema
 
 
 class IcontainsFilterViewSetMixin(APIViewSet):
@@ -56,7 +56,7 @@ class IcontainsFilterViewSetMixin(APIViewSet):
             **{
                 f"{key}__icontains": value
                 for key, value in filters.items()
-                if isinstance(value, str) and not self._check_relations_filters(key)
+                if isinstance(value, str) and not self._is_special_filter(key)
             }
         )
 
@@ -98,7 +98,7 @@ class BooleanFilterViewSetMixin(APIViewSet):
             **{
                 key: value
                 for key, value in filters.items()
-                if isinstance(value, bool) and not self._check_relations_filters(key)
+                if isinstance(value, bool) and not self._is_special_filter(key)
             }
         )
 
@@ -140,8 +140,7 @@ class NumericFilterViewSetMixin(APIViewSet):
             **{
                 key: value
                 for key, value in filters.items()
-                if isinstance(value, (int, float))
-                and not self._check_relations_filters(key)
+                if isinstance(value, (int, float)) and not self._is_special_filter(key)
             }
         )
 
@@ -183,8 +182,7 @@ class DateFilterViewSetMixin(APIViewSet):
             **{
                 f"{key}{self._compare_attr}": value
                 for key, value in filters.items()
-                if hasattr(value, "isoformat")
-                and not self._check_relations_filters(key)
+                if hasattr(value, "isoformat") and not self._is_special_filter(key)
             }
         )
 
@@ -346,3 +344,70 @@ class RelationFilterViewSetMixin(APIViewSet):
             if value is not None:
                 rel_filters[rel_filter.query_filter] = value
         return base_qs.filter(**rel_filters) if rel_filters else base_qs
+
+
+class MatchCaseFilterViewSetMixin(APIViewSet):
+    """
+    Mixin providing match-case filtering for Django QuerySets.
+    This mixin applies filters based on boolean query parameters defined in
+    MatchCaseFilterSchema entries. Each entry specifies different filter conditions
+    for True and False cases.
+    Attributes:
+        filters_match_cases: List of MatchCaseFilterSchema defining the match-case filters.
+            Each schema specifies:
+            - query_param: The API query parameter name (e.g., "is_active")
+            - cases: A BooleanMatchFilterSchema with 'true' and 'false' MatchConditionFilterSchema
+    Example:
+        class UserViewSet(MatchCaseFilterViewSetMixin, APIViewSet):
+            filters_match_cases = [
+                MatchCaseFilterSchema(
+                    query_param="is_active",
+                    cases=BooleanMatchFilterSchema(
+                        true=MatchConditionFilterSchema(
+                            query_filter={"status": "active"},
+                            include=True,
+                        ),
+                        false=MatchConditionFilterSchema(
+                            query_filter={"status": "inactive"},
+                            include=True,
+                        ),
+                    ),
+                ),
+            ]
+        # GET /users?is_active=true -> queryset.filter(status="active")
+        # GET /users?is_active=false -> queryset.filter(status="inactive")
+    Notes:
+        - If the query parameter is not provided, no filtering is applied for that case.
+        - This mixin automatically registers query_params from filters_match_cases.
+    """
+
+    filters_match_cases: list[MatchCaseFilterSchema] = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.query_params = {
+            **cls.query_params,
+            **{
+                filter_match.query_param: filter_match.filter_type
+                for filter_match in cls.filters_match_cases
+            },
+        }
+
+    @property
+    def filters_match_cases_fields(self):
+        return [filter_match.query_param for filter_match in self.filters_match_cases]
+
+    async def query_params_handler(self, queryset, filters):
+        base_qs = await super().query_params_handler(queryset, filters)
+        for filter_match in self.filters_match_cases:
+            value = filters.get(filter_match.query_param)
+            if value is not None:
+                case_filter = (
+                    filter_match.cases.true if value else filter_match.cases.false
+                )
+                lookup = case_filter.query_filter
+                if case_filter.include:
+                    base_qs = base_qs.filter(**lookup)
+                else:
+                    base_qs = base_qs.exclude(**lookup)
+        return base_qs

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/tests/core/test_renderer_parser.py

@@ -1,6 +1,7 @@
 import base64
 from ipaddress import IPv4Address, IPv6Address
 
+from django.http import HttpResponse, StreamingHttpResponse
 from django.test import TestCase, tag
 import orjson
 from ninja_aio.renders import ORJSONRenderer
@@ -73,3 +74,25 @@ class ORJSONRendererParserTestCase(TestCase):
         rendered = self.renderer.render(DummyRequest(), int_data, response_status=200)
         decoded = orjson.loads(rendered)
         self.assertEqual(decoded, 42)
+
+    def test_renderer_http_response_passthrough(self):
+        """Test that renderer returns HttpResponse as-is without serialization."""
+        response = HttpResponse(
+            b"-----BEGIN PUBLIC KEY-----\ntest\n-----END PUBLIC KEY-----",
+            content_type="application/x-pem-file",
+            status=200,
+        )
+        rendered = self.renderer.render(DummyRequest(), response, response_status=200)
+        self.assertIs(rendered, response)
+        self.assertEqual(rendered.content, b"-----BEGIN PUBLIC KEY-----\ntest\n-----END PUBLIC KEY-----")
+        self.assertEqual(rendered["Content-Type"], "application/x-pem-file")
+
+    def test_renderer_streaming_http_response_passthrough(self):
+        """Test that renderer returns StreamingHttpResponse as-is."""
+        response = StreamingHttpResponse(
+            iter([b"chunk1", b"chunk2"]),
+            content_type="application/octet-stream",
+        )
+        rendered = self.renderer.render(DummyRequest(), response, response_status=200)
+        self.assertIs(rendered, response)
+        self.assertEqual(rendered["Content-Type"], "application/octet-stream")

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/tests/test_app/models.py

@@ -82,6 +82,7 @@ class TestModelSerializer(BaseTestModelSerializer):
     age = models.PositiveIntegerField(default=0)
     active = models.BooleanField(default=True)
     active_from = models.DateTimeField(auto_now_add=True)
+    status = models.CharField(max_length=20, default="pending")
 
 
 class TestModelSerializerReverseForeignKey(BaseTestModelSerializer):

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/tests/test_app/views.py

@@ -1,6 +1,11 @@
 import datetime
 from ninja_aio.views import mixins
-from ninja_aio.schemas import RelationFilterSchema
+from ninja_aio.schemas import (
+    RelationFilterSchema,
+    MatchCaseFilterSchema,
+    MatchConditionFilterSchema,
+    BooleanMatchFilterSchema,
+)
 
 from tests.generics.views import GenericAPIViewSet
 from tests.test_app import models, schema, serializers
@@ -178,3 +183,62 @@ class TestModelSerializerForeignKeyRelationFilterAPI(
             filter_type=(str, None),
         ),
     ]
+
+
+# ==========================================================
+#                  MATCH CASE FILTER MIXIN APIS
+# ==========================================================
+
+
+class TestModelSerializerMatchCaseFilterAPI(
+    GenericAPIViewSet,
+    mixins.MatchCaseFilterViewSetMixin,
+):
+    """
+    ViewSet for testing MatchCaseFilterViewSetMixin.
+    Uses status field to filter by 'is_approved' boolean query param.
+    """
+
+    model = models.TestModelSerializer
+    filters_match_cases = [
+        MatchCaseFilterSchema(
+            query_param="is_approved",
+            cases=BooleanMatchFilterSchema(
+                true=MatchConditionFilterSchema(
+                    query_filter={"status": "approved"},
+                    include=True,
+                ),
+                false=MatchConditionFilterSchema(
+                    query_filter={"status": "approved"},
+                    include=False,
+                ),
+            ),
+        ),
+    ]
+
+
+class TestModelSerializerMatchCaseExcludeFilterAPI(
+    GenericAPIViewSet,
+    mixins.MatchCaseFilterViewSetMixin,
+):
+    """
+    ViewSet for testing MatchCaseFilterViewSetMixin with exclude behavior.
+    Uses status field to filter by 'hide_pending' boolean query param.
+    """
+
+    model = models.TestModelSerializer
+    filters_match_cases = [
+        MatchCaseFilterSchema(
+            query_param="hide_pending",
+            cases=BooleanMatchFilterSchema(
+                true=MatchConditionFilterSchema(
+                    query_filter={"status": "pending"},
+                    include=False,  # exclude pending when True
+                ),
+                false=MatchConditionFilterSchema(
+                    query_filter={"status": "pending"},
+                    include=True,  # include only pending when False
+                ),
+            ),
+        ),
+    ]

{django_ninja_aio_crud-2.10.1 → django_ninja_aio_crud-2.11.1}/tests/views/test_viewset.py

@@ -971,3 +971,163 @@ class DetailSchemaFallbackTestCase(TestCase):
         retrieve_schema = self.viewset._get_retrieve_schema()
         # The retrieve schema should be the detail schema (which is the fallback)
         self.assertEqual(retrieve_schema, self.viewset.schema_detail)
+
+
+# ==========================================================
+#               MATCH CASE FILTER MIXIN TESTS
+# ==========================================================
+
+
+@tag("match_case_filter_mixin")
+class MatchCaseFilterViewSetMixinTestCase(
+    BaseTests.ModelSerializerViewSetTestCaseBase,
+    Tests.ViewSetTestCase,
+):
+    """Test MatchCaseFilterViewSetMixin functionality."""
+
+    namespace = "test_match_case_filter_mixin_viewset"
+    model = models.TestModelSerializer
+    viewset = views.TestModelSerializerMatchCaseFilterAPI()
+
+    async def _drop_all_objects(self):
+        await self.model.objects.all().adelete()
+
+    async def test_match_case_filter_true_includes(self):
+        """Test filtering with True value includes matching records."""
+        await self._drop_all_objects()
+        obj_approved = await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        await self.model.objects.acreate(
+            name="rejected_item", description="desc", status="rejected"
+        )
+        # Filter with is_approved=True should return only approved items
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {"is_approved": True},
+        )
+        self.assertEqual(await res.acount(), 1)
+        self.assertEqual(await res.afirst(), obj_approved)
+
+    async def test_match_case_filter_false_excludes(self):
+        """Test filtering with False value excludes matching records."""
+        await self._drop_all_objects()
+        obj_approved = await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        obj_pending = await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        obj_rejected = await self.model.objects.acreate(
+            name="rejected_item", description="desc", status="rejected"
+        )
+        # Filter with is_approved=False should exclude approved items
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {"is_approved": False},
+        )
+        self.assertEqual(await res.acount(), 2)
+        results = [obj async for obj in res]
+        self.assertIn(obj_pending, results)
+        self.assertIn(obj_rejected, results)
+        self.assertNotIn(obj_approved, results)
+
+    async def test_match_case_filter_none_no_filtering(self):
+        """Test that None filter value doesn't apply any filtering."""
+        await self._drop_all_objects()
+        await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        await self.model.objects.acreate(
+            name="rejected_item", description="desc", status="rejected"
+        )
+        # Filter with None should return all objects
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {"is_approved": None},
+        )
+        self.assertEqual(await res.acount(), 3)
+
+    async def test_match_case_filter_empty_filters(self):
+        """Test that empty filters dict returns all objects."""
+        await self._drop_all_objects()
+        await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {},
+        )
+        self.assertEqual(await res.acount(), 2)
+
+    def test_query_params_registered(self):
+        """Test that filters_match_cases are properly registered in query_params."""
+        self.assertIn("is_approved", self.viewset.query_params)
+        self.assertEqual(self.viewset.query_params["is_approved"], (bool, None))
+
+    def test_filters_match_cases_fields_property(self):
+        """Test that filters_match_cases_fields property returns correct list."""
+        self.assertEqual(self.viewset.filters_match_cases_fields, ["is_approved"])
+
+
+@tag("match_case_filter_mixin_exclude")
+class MatchCaseFilterViewSetMixinExcludeTestCase(TestCase):
+    """Test MatchCaseFilterViewSetMixin with exclude behavior."""
+
+    model = models.TestModelSerializer
+    viewset = views.TestModelSerializerMatchCaseExcludeFilterAPI()
+
+    async def _drop_all_objects(self):
+        await self.model.objects.all().adelete()
+
+    async def test_match_case_exclude_true(self):
+        """Test filtering with True value excludes matching records."""
+        await self._drop_all_objects()
+        obj_approved = await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        obj_pending = await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        obj_rejected = await self.model.objects.acreate(
+            name="rejected_item", description="desc", status="rejected"
+        )
+        # Filter with hide_pending=True should exclude pending items
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {"hide_pending": True},
+        )
+        self.assertEqual(await res.acount(), 2)
+        results = [obj async for obj in res]
+        self.assertIn(obj_approved, results)
+        self.assertIn(obj_rejected, results)
+        self.assertNotIn(obj_pending, results)
+
+    async def test_match_case_exclude_false_includes_only(self):
+        """Test filtering with False value includes only matching records."""
+        await self._drop_all_objects()
+        await self.model.objects.acreate(
+            name="approved_item", description="desc", status="approved"
+        )
+        obj_pending = await self.model.objects.acreate(
+            name="pending_item", description="desc", status="pending"
+        )
+        await self.model.objects.acreate(
+            name="rejected_item", description="desc", status="rejected"
+        )
+        # Filter with hide_pending=False should include only pending items
+        res = await self.viewset.query_params_handler(
+            self.model.objects.all(),
+            {"hide_pending": False},
+        )
+        self.assertEqual(await res.acount(), 1)
+        self.assertEqual(await res.afirst(), obj_pending)

django_ninja_aio_crud-2.10.1/docs/api/renderers/orjson_renderer.md

@@ -1,20 +0,0 @@
-# ORJSON renderer option
-
-This package uses an internal ORJSON-based renderer. Configure serialization options via Django settings:
-
-```python
-# settings.py
-import orjson
-
-# Single option
-NINJA_AIO_ORJSON_RENDERER_OPTION = orjson.OPT_INDENT_2
-
-# Multiple options (bitwise OR)
-NINJA_AIO_ORJSON_RENDERER_OPTION = (
-    orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS
-)
-```
-
-Notes:
-- The value is an orjson option bitmask (e.g., `orjson.OPT_INDENT_2`, `orjson.OPT_NON_STR_KEYS`), and you can combine multiple options using `|`.
-- If not set, the default `orjson.dumps` options are used.

django_ninja_aio_crud-2.10.1/ninja_aio/schemas/api.py

@@ -1,43 +0,0 @@
-from typing import Any
-
-from ninja import Schema
-
-
-class M2MDetailSchema(Schema):
-    count: int
-    details: list[str]
-
-
-class M2MSchemaOut(Schema):
-    errors: M2MDetailSchema
-    results: M2MDetailSchema
-
-
-class M2MAddSchemaIn(Schema):
-    add: list = []
-
-
-class M2MRemoveSchemaIn(Schema):
-    remove: list = []
-
-
-class M2MSchemaIn(Schema):
-    add: list = []
-    remove: list = []
-
-
-class RelationFilterSchema(Schema):
-    """
-    Schema for configuring relation-based filters in RelationFilterViewSetMixin.
-
-    Attributes:
-        filter_type: A tuple of (type, default_value) used to generate the query parameter
-            field in the filters schema. Example: (int, None) for optional integer filter.
-        query_param: The name of the query parameter exposed in the API endpoint.
-            This is what clients will use in requests (e.g., ?author_id=5).
-        query_filter: The Django ORM lookup to apply (e.g., "author__id", "category__slug").
-    """
-
-    filter_type: tuple[type, Any]
-    query_param: str
-    query_filter: str