django-ninja-aio-crud 2.0.0rc7__py3-none-any.whl → 2.2.0__py3-none-any.whl

{django_ninja_aio_crud-2.0.0rc7.dist-info → django_ninja_aio_crud-2.2.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.0.0rc7
+Version: 2.2.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
-Requires-Python: >=3.10
+Requires-Python: >=3.10, <=3.14
 Description-Content-Type: text/markdown
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet

django_ninja_aio_crud-2.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+ninja_aio/__init__.py,sha256=Jgj89rpJ3n4pkGfoSYm9NYrwBjGzwhiOeU5c6mr-J8Q,119
+ninja_aio/api.py,sha256=tuC7vdvn7s1GkCnSFy9Kn1zv0glZfYptRQVvo8ZRtGQ,2429
+ninja_aio/auth.py,sha256=4sWdFPjKiQgUL1d_CSGDblVjnY5ptP6LQha6XXdluJA,9157
+ninja_aio/decorators.py,sha256=BHoFIiqdIVMFqSxGh-F6WeZFo1xZK4ieDw3dzKfxZIM,8147
+ninja_aio/exceptions.py,sha256=1-iRbrloIyi0CR6Tcrn5YR4_LloA7PPohKIBaxXJ0-8,2596
+ninja_aio/models.py,sha256=aJlo5a64O4o-fB8QESLMUJpoA5kcjRJxPBiAIMxg46k,47652
+ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
+ninja_aio/renders.py,sha256=VtmSliRJyZ6gjyoib8AXMVUBYF1jPNsiceCHujI_mAs,1699
+ninja_aio/types.py,sha256=nFqWEopm7eoEaHRzbi6EyA9WZ5Cneyd602ilFKypeQI,577
+ninja_aio/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ninja_aio/helpers/api.py,sha256=BTe7OL-X7YgWYeXmka8TmN4-gA43FVZhtH7q0dRjYX0,20238
+ninja_aio/helpers/query.py,sha256=tE8RjXvSig-WB_0LRQ0LqoE4G_HMHsu0Na5QzTNIm6U,4262
+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=rmE0D15lJg95Unv8PU44Hbf0VDTcErMCZZFG3D_znTo,2823
+ninja_aio/views/__init__.py,sha256=DEzjWA6y3WF0V10nNF8eEurLNEodgxKzyFd09AqVp3s,148
+ninja_aio/views/api.py,sha256=O_QQBxk-MltU-bPjxOSu5fFpHaDNP5J3Wk6E5rSBgi4,19744
+ninja_aio/views/mixins.py,sha256=Jh6BG8Cs823nurVlODlzCquTxKrLH7Pmo5udPqUGZek,11378
+django_ninja_aio_crud-2.2.0.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
+django_ninja_aio_crud-2.2.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_ninja_aio_crud-2.2.0.dist-info/METADATA,sha256=lJiJIHnNMaKXAM-aOwuKlcAmaJt8oV_wtiDGSFvjjJE,8680
+django_ninja_aio_crud-2.2.0.dist-info/RECORD,,

ninja_aio/__init__.py

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

ninja_aio/api.py

@@ -5,10 +5,13 @@ from ninja.throttling import BaseThrottle
 from ninja import NinjaAPI
 from ninja.openapi.docs import DocsBase, Swagger
 from ninja.constants import NOT_SET, NOT_SET_TYPE
+from django.db import models
 
 from .parsers import ORJSONParser
 from .renders import ORJSONRenderer
 from .exceptions import set_api_exception_handlers
+from .views import APIView, APIViewSet
+from .models import ModelSerializer
 
 
 class NinjaAIO(NinjaAPI):
@@ -49,3 +52,24 @@ class NinjaAIO(NinjaAPI):
     def set_default_exception_handlers(self):
         set_api_exception_handlers(self)
         super().set_default_exception_handlers()
+
+    def view(self, prefix: str, tags: list[str] = None) -> Any:
+        def wrapper(view: type[APIView]):
+            instance = view(api=self, prefix=prefix, tags=tags)
+            instance.add_views_to_route()
+            return instance
+
+        return wrapper
+
+    def viewset(
+        self,
+        model: models.Model | ModelSerializer,
+        prefix: str = None,
+        tags: list[str] = None,
+    ) -> None:
+        def wrapper(viewset: type[APIViewSet]):
+            instance = viewset(api=self, model=model, prefix=prefix, tags=tags)
+            instance.add_views_to_route()
+            return instance
+
+        return wrapper

ninja_aio/auth.py

@@ -1,7 +1,19 @@
+import datetime
+from typing import Optional
+
 from joserfc import jwt, jwk, errors
 from django.http.request import HttpRequest
+from django.utils import timezone
+from django.conf import settings
 from ninja.security.http import HttpBearer
 
+from ninja_aio.types import JwtKeys
+
+JWT_MANDATORY_CLAIMS = [
+    ("iss", "JWT_ISSUER"),
+    ("aud", "JWT_AUDIENCE"),
+]
+
 
 class AsyncJwtBearer(HttpBearer):
     """
@@ -9,8 +21,8 @@ class AsyncJwtBearer(HttpBearer):
     using HTTP Bearer tokens. It decodes and validates JWTs against a configured public key
     and claim registry, then delegates user retrieval to an overridable async handler.
     Attributes:
-        jwt_public (jwk.RSAKey):
-            The RSA public key (JWK format) used to verify the JWT signature.
+        jwt_public (jwk.RSAKey | jwk.ECKey):
+            The public key (JWK format) used to verify the JWT signature.
             Must be set externally before authentication occurs.
         claims (dict[str, dict]):
             A mapping defining expected JWT claims passed to jwt.JWTClaimsRegistry.
@@ -70,7 +82,7 @@ class AsyncJwtBearer(HttpBearer):
         - authenticate -> user object (success) | False (failure)
     """
 
-    jwt_public: jwk.RSAKey
+    jwt_public: JwtKeys
     claims: dict[str, dict]
     algorithms: list[str] = ["RS256"]
 
@@ -105,3 +117,109 @@ class AsyncJwtBearer(HttpBearer):
             return False
 
         return await self.auth_handler(request)
+
+
+def validate_key(key: Optional[JwtKeys], setting_name: str) -> JwtKeys:
+    if key is None:
+        key = getattr(settings, setting_name, None)
+    if key is None:
+        raise ValueError(f"{setting_name} is required")
+    if not isinstance(key, (jwk.RSAKey, jwk.ECKey, jwk.OctKey)):
+        raise ValueError(
+            f"{setting_name} must be an instance of jwk.RSAKey or jwk.ECKey"
+        )
+    return key
+
+
+def validate_mandatory_claims(claims: dict) -> dict:
+    for claim_key, setting_name in JWT_MANDATORY_CLAIMS:
+        if claims.get(claim_key) is not None:
+            continue
+        value = getattr(settings, setting_name, None)
+        if value is None:
+            raise ValueError(f"jwt {claim_key} is required")
+        claims[claim_key] = value
+    return claims
+
+
+def encode_jwt(
+    claims: dict, duration: int, private_key: JwtKeys = None, algorithm: str = None
+) -> str:
+    """
+    Encode and sign a JWT.
+
+    Adds time-based claims and ensures mandatory issuer/audience:
+      - iat: current time (timezone-aware)
+      - nbf: current time
+      - exp: current time + duration (seconds)
+      - iss/aud: from claims if provided; otherwise from settings.JWT_ISSUER and settings.JWT_AUDIENCE
+
+    Parameters:
+      - claims (dict): additional claims to merge into the payload (can override defaults)
+      - duration (int): token lifetime in seconds
+      - private_key (jwk.RSAKey): RSA/EC JWK for signing; defaults to settings.JWT_PRIVATE_KEY
+      - algorithm (str): JWS algorithm (default "RS256")
+
+    Returns:
+      - str: JWT compact string
+
+    Raises:
+      - ValueError: if private_key is missing or not jwk.RSAKey/jwk.ECKey
+      - ValueError: if mandatory claims (iss, aud) are missing and not in settings
+
+    Notes:
+      - Header includes alg, typ=JWT, and kid from the private key (if available).
+      - Uses timezone-aware timestamps from django.utils.timezone.
+    """
+    now = timezone.now()
+    nbf = now
+    pkey = validate_key(private_key, "JWT_PRIVATE_KEY")
+    algorithm = algorithm or "RS256"
+    claims = validate_mandatory_claims(claims)
+    kid_h = {"kid": pkey.kid} if pkey.kid else {}
+    return jwt.encode(
+        header={"alg": algorithm, "typ": "JWT"} | kid_h,
+        claims={
+            "iat": now,
+            "nbf": nbf,
+            "exp": now + datetime.timedelta(seconds=duration),
+        }
+        | claims,
+        key=pkey,
+        algorithms=[algorithm],
+    )
+
+
+def decode_jwt(
+    token: str,
+    public_key: JwtKeys = None,
+    algorithms: list[str] = None,
+) -> jwt.Token:
+    """
+    Decode and verify a JSON Web Token (JWT) using the provided RSA public key.
+    This function decodes the JWT, verifies its signature, and returns the decoded token object.
+    Parameters:
+    - token (str): The JWT string to decode.
+    - public_key (jwk.RSAKey, optional): RSA public key used to verify the token's signature.
+        If not provided, settings.JWT_PUBLIC_KEY will be used. Must be an instance of jwk.RSAKey.
+    - algorithms (list[str], optional): List of permitted algorithms for signature verification.
+        Defaults to ["RS256"] if not provided.
+    Returns:
+    - jwt.Token: The decoded JWT token object containing header and claims.
+    Raises:
+    - ValueError: If no public key is provided or if the provided key is not an instance of jwk.RSAKey.
+    - jose.errors.JoseError: If the token is invalid or fails verification.
+    Notes:
+    - The function uses the specified algorithms to restrict acceptable signing methods.
+    Example:
+        decoded_token = decode_jwt(
+            token=my_jwt,
+            public_key=my_rsa_jwk,
+            algorithms=["RS256"],
+        )
+    """
+    return jwt.decode(
+        token,
+        validate_key(public_key, "JWT_PUBLIC_KEY"),
+        algorithms=algorithms or ["RS256"],
+    )

ninja_aio/helpers/api.py

@@ -4,7 +4,7 @@ from typing import Coroutine
 from django.http import HttpRequest
 from ninja import Path, Query
 from ninja.pagination import paginate
-from ninja_aio.decorators import unique_view
+from ninja_aio.decorators import unique_view, decorate_view
 from ninja_aio.models import ModelSerializer, ModelUtil
 from ninja_aio.schemas.helpers import ObjectsQuerySchema
 from ninja_aio.schemas import (
@@ -357,8 +357,10 @@ class ManyToManyAPI:
             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.related_model_util.model_name}_{rel_path}")
-        @paginate(self.pagination_class)
+        @decorate_view(
+            unique_view(f"get_{self.related_model_util.model_name}_{rel_path}"),
+            paginate(self.pagination_class),
+        )
         async def get_related(
             request: HttpRequest,
             pk: Path[self.path_schema],  # type: ignore

ninja_aio/types.py

@@ -1,12 +1,14 @@
 from typing import Literal
 
+from joserfc import jwk
 from django.db.models import Model
+from typing import TypeAlias
 
 S_TYPES = Literal["read", "create", "update"]
 F_TYPES = Literal["fields", "customs", "optionals", "excludes"]
 SCHEMA_TYPES = Literal["In", "Out", "Patch", "Related"]
 VIEW_TYPES = Literal["list", "retrieve", "create", "update", "delete", "all"]
-
+JwtKeys: TypeAlias = jwk.RSAKey | jwk.ECKey | jwk.OctKey
 
 class ModelSerializerType(type):
     def __repr__(self):

ninja_aio/views/__init__.py

@@ -0,0 +1,3 @@
+from .api import APIView, APIViewSet, ReadOnlyViewSet, WriteOnlyViewSet
+
+__all__ = ["APIView", "APIViewSet", "ReadOnlyViewSet", "WriteOnlyViewSet"]

ninja_aio/{views.py → views/api.py}

@@ -9,28 +9,25 @@ from pydantic import create_model
 
 from ninja_aio.schemas.helpers import ModelQuerySetSchema, QuerySchema, DecoratorsSchema
 
-from .models import ModelSerializer, ModelUtil
-from .schemas import (
+from ninja_aio.models import ModelSerializer, ModelUtil
+from ninja_aio.schemas import (
     GenericMessageSchema,
     M2MRelationSchema,
 )
-from .helpers.api import ManyToManyAPI
-from .types import ModelSerializerMeta, VIEW_TYPES
-from .decorators import unique_view, decorate_view
+from ninja_aio.helpers.api import ManyToManyAPI
+from ninja_aio.types import ModelSerializerMeta, VIEW_TYPES
+from ninja_aio.decorators import unique_view, decorate_view
 
-ERROR_CODES = frozenset({400, 401, 404, 428})
+ERROR_CODES = frozenset({400, 401, 404})
 
 
-class APIView:
-    api: NinjaAPI
-    router_tag: str
-    api_route_path: str
+class API:
+    api: NinjaAPI = None
+    router_tag: str = ""
+    router_tags: list[str] = []
+    api_route_path: str = ""
     auth: list | None = NOT_SET
 
-    def __init__(self) -> None:
-        self.router = Router(tags=[self.router_tag])
-        self.error_codes = ERROR_CODES
-
     def views(self):
         """
         Override this method to add your custom views. For example:
@@ -38,7 +35,7 @@ class APIView:
         async def some_method(request, *args, **kwargs):
             pass
 
-        You can add multilple views just doing:
+        You can add views just doing:
 
         @self.router.get(some_path, response=some_schema)
         async def some_method(request, *args, **kwargs):
@@ -63,20 +60,80 @@ class APIView:
         async def some_method(request, *args, **kwargs):
             pass
         """
+        pass
 
     def _add_views(self):
-        self.views()
-        return self.router
+        raise NotImplementedError("_add_views must be implemented in subclasses")
 
     def add_views_to_route(self):
         return self.api.add_router(f"{self.api_route_path}", self._add_views())
 
 
-class APIViewSet:
+class APIView(API):
+    """
+    Base class to register custom, non-CRUD endpoints on a Ninja Router.
+
+    Usage:
+        @api.view(prefix="/custom", tags=["Custom"])
+        class CustomAPIView(APIView):
+            def views(self):
+                @self.router.get("/hello", response=SomeSchema)
+                async def hello(request):
+                    return SomeSchema(...)
+
+        or
+
+        class CustomAPIView(APIView):
+            api = api
+            api_route_path = "/custom"
+            router_tags = ["Custom"]
+
+            def views(self):
+                @self.router.get("/hello", response=SomeSchema)
+                async def hello(request):
+                    return SomeSchema(...)
+
+
+        CustomAPIView().add_views_to_route()
+
+    Attributes:
+        api: NinjaAPI instance used to mount the router.
+        router_tag: Single tag used if router_tags is not provided.
+        router_tags: List of tags assigned to the router.
+        api_route_path: Base path where the router is mounted.
+        auth: Default auth list or NOT_SET for unauthenticated endpoints.
+        router: Router instance where views are registered.
+        error_codes: Common error codes returned by endpoints.
+
+    Overridable methods:
+        views(): Register your endpoints using self.router.get/post/patch/delete.
+    """
+
+    def __init__(
+        self, api: NinjaAPI = None, prefix: str = None, tags: list[str] = None
+    ) -> None:
+        self.api = api or self.api
+        self.api_route_path = prefix or self.api_route_path
+        self.router_tags = tags or self.router_tags or [self.router_tag]
+        self.router = Router(tags=self.router_tags)
+        self.error_codes = ERROR_CODES
+
+    def _add_views(self):
+        self.views()
+        return self.router
+
+
+class APIViewSet(API):
     """
     Base viewset generating async CRUD + optional M2M endpoints for a Django model.
 
     Usage:
+        @api.viewset(model=MyModel)
+        class MyModelViewSet(APIViewSet):
+            pass
+
+        or
+
         class MyModelViewSet(APIViewSet):
             model = MyModel
             api = api
@@ -103,14 +160,14 @@ class APIViewSet:
             filters = { "field_name": (type, default) }
         A dynamic Pydantic Filters schema is generated and exposed as query params
         on the related GET endpoint: /{pk}/{related_path}?field_name=value.
-        To apply custom filter logic implement an async hook named:
+        To apply custom filter logic implement an hook named:
             <related_name>_query_params_handler(self, queryset, filters_dict)
         It receives the initial related queryset and the validated/dumped filters
         dict, and must return the (optionally) filtered queryset.
 
         Example:
+            @api.viewset(model=models.User)
             class UserViewSet(APIViewSet):
-                model = models.User
                 m2m_relations = [
                     M2MRelationSchema(
                         model=models.Tag,
@@ -121,7 +178,7 @@ class APIViewSet:
                     )
                 ]
 
-                async def tags_query_params_handler(self, queryset, filters):
+                def tags_query_params_handler(self, queryset, filters):
                     name_filter = filters.get("name")
                     if name_filter:
                         queryset = queryset.filter(name__icontains=name_filter)
@@ -145,11 +202,11 @@ class APIViewSet:
 
     Overridable hooks:
         views(): Register extra custom endpoints on self.router.
-        query_params_handler(queryset, filters): Async hook to apply list filters.
+        query_params_handler(queryset, filters): Sync/Async hook to apply list filters.
         <related_name>_query_params_handler(queryset, filters): Async hook for per-M2M filtering.
 
     Error responses:
-        All endpoints may return GenericMessageSchema for codes in ERROR_CODES (400,401,404,428).
+        All endpoints may return GenericMessageSchema for codes in ERROR_CODES (400,401,404).
 
     Internal:
         Dynamic path/filter schemas built with pydantic.create_model.
@@ -157,12 +214,9 @@ 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
-    auth: list | None = NOT_SET
     get_auth: list | None = NOT_SET
     post_auth: list | None = NOT_SET
     patch_auth: list | None = NOT_SET
@@ -170,7 +224,6 @@ class APIViewSet:
     pagination_class: type[AsyncPaginationBase] = PageNumberPagination
     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."
@@ -180,8 +233,16 @@ class APIViewSet:
     m2m_auth: list | None = NOT_SET
     extra_decorators: DecoratorsSchema = DecoratorsSchema()
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        api: NinjaAPI = None,
+        model: Model | ModelSerializer = None,
+        prefix: str = None,
+        tags: list[str] = None,
+    ) -> None:
+        self.api = api or self.api
         self.error_codes = ERROR_CODES
+        self.model = model or self.model
         self.model_util = (
             ModelUtil(self.model)
             if not isinstance(self.model, ModelSerializerMeta)
@@ -191,16 +252,17 @@ 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 = Router(tags=[self.router_tag])
+        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)
         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()
+            self.api_route_path
+            or prefix
+            or self.model_util.verbose_name_path_resolver()
         )
         self.m2m_api = (
             None
@@ -278,15 +340,18 @@ class APIViewSet:
 
     def get_schemas(self):
         """
-        Return (schema_out, schema_in, schema_update), generating them if model is a ModelSerializer.
+        Compute and return (schema_out, schema_in, schema_update).
+
+        - If model is a ModelSerializer (ModelSerializerMeta), auto-generate read/create/update schemas.
+        - Otherwise, return the schemas already set on the viewset (may be None).
         """
-        if isinstance(self.model, ModelSerializerMeta):
-            return (
-                self.model.generate_read_s(),
-                self.model.generate_create_s(),
-                self.model.generate_update_s(),
-            )
-        return self.schema_out, self.schema_in, self.schema_update
+        if not isinstance(self.model, ModelSerializerMeta):
+            return self.schema_out, self.schema_in, self.schema_update
+        return (
+            self.schema_out or self.model.generate_read_s(),
+            self.schema_in or self.model.generate_create_s(),
+            self.schema_update or self.model.generate_update_s(),
+        )
 
     async def query_params_handler(
         self, queryset: QuerySet[ModelSerializer], filters: dict
@@ -447,8 +512,41 @@ class APIViewSet:
 
         return self._set_additional_views()
 
-    def add_views_to_route(self):
-        """
-        Attach router with registered endpoints to the NinjaAPI instance.
-        """
-        return self.api.add_router(f"{self.api_route_path}", self._add_views())
+
+class ReadOnlyViewSet(APIViewSet):
+    """
+    ReadOnly viewset generating async List + Retrieve endpoints for a Django model.
+
+    Usage:
+        @api.viewset(model=MyModel)
+        class MyModelReadOnlyViewSet(ReadOnlyViewSet):
+            pass
+
+        or
+
+        class MyModelReadOnlyViewSet(ReadOnlyViewSet):
+            model = MyModel
+            api = api
+        MyModelReadOnlyViewSet().add_views_to_route()
+    """
+
+    disable = ["create", "update", "delete"]
+
+
+class WriteOnlyViewSet(APIViewSet):
+    """
+    WriteOnly viewset generating async Create + Update + Delete endpoints for a Django model.
+
+    Usage:
+        @api.viewset(model=MyModel)
+        class MyModelWriteOnlyViewSet(WriteOnlyViewSet):
+            pass
+
+        or
+
+        class MyModelWriteOnlyViewSet(WriteOnlyViewSet):
+            model = MyModel
+            api = api
+    """
+
+    disable = ["list", "retrieve"]

ninja_aio/views/mixins.py

@@ -0,0 +1,275 @@
+from ninja_aio.views.api import APIViewSet
+
+
+class IcontainsFilterViewSetMixin(APIViewSet):
+    """
+    Mixin providing a convenience method to apply case-insensitive substring filters
+    to a Django queryset based on request query parameters.
+
+    This mixin is intended for use with viewsets that support asynchronous handling
+    and dynamic filtering. It converts string-type filter values into Django ORM
+    `__icontains` lookups, enabling partial, case-insensitive matches.
+
+    Usage:
+        - Include this mixin in a viewset class that exposes a queryset and
+          passes a dictionary of filters (e.g., from request query params) to
+          `query_params_handler`.
+        - Only string values are considered; non-string values are ignored.
+
+    Example:
+        filters = {"name": "john", "email": "example.com", "age": 30}
+        # Resulting queryset filter:
+        # queryset.filter(name__icontains="john", email__icontains="example.com")
+        # Note: "age" is ignored because its value is not a string.
+
+        Apply `__icontains` filters to the provided queryset based on the given filter
+        dictionary.
+
+        Parameters:
+            queryset (django.db.models.QuerySet):
+                The base queryset to filter.
+            filters (dict[str, Any]):
+                A mapping of field names to desired filter values. Only entries with
+                string values will be transformed into `field__icontains=value`
+                filters. Non-string values are ignored.
+
+        Returns:
+            django.db.models.QuerySet:
+                A queryset filtered with `__icontains` lookups for all string-valued
+                keys in `filters`.
+
+        Notes:
+            - This method is asynchronous to align with async view workflows, but it
+              performs a synchronous queryset filter call typical in Django ORM usage.
+            - Ensure that the fields referenced in `filters` exist on the model
+              associated with `queryset`, otherwise a FieldError may be raised at
+              evaluation time.
+    """
+
+    async def query_params_handler(self, queryset, filters):
+        """
+        Apply icontains filter to the queryset based on provided filters.
+        """
+        base_qs = await super().query_params_handler(queryset, filters)
+        return base_qs.filter(
+            **{
+                f"{key}__icontains": value
+                for key, value in filters.items()
+                if isinstance(value, str)
+            }
+        )
+
+
+class BooleanFilterViewSetMixin(APIViewSet):
+    """
+    Mixin providing boolean-based filtering for Django QuerySets.
+
+    This mixin defines a helper to apply boolean filters from a dictionary of query
+    parameters, selecting only those values that are strictly boolean (True/False)
+    and ignoring any non-boolean entries. It is intended to be used with viewsets
+    that expose queryable endpoints.
+
+    Methods:
+        query_params_handler(queryset, filters):
+            Apply boolean filters to the given queryset based on the provided
+            dictionary. Only keys with boolean values are included in the filter.
+
+            Parameters:
+                queryset (QuerySet): A Django QuerySet to be filtered.
+                filters (dict): A mapping of field names to potential filter values.
+
+            Returns:
+                QuerySet: A new QuerySet filtered by the boolean entries in `filters`.
+
+            Notes:
+                - Non-boolean values in `filters` are ignored.
+                - Keys should correspond to valid model fields or lookups.
+                - This method does not mutate the original queryset; it returns a
+                  filtered clone.
+    """
+
+    async def query_params_handler(self, queryset, filters):
+        """
+        Apply boolean filter to the queryset based on provided filters.
+        """
+        base_qs = await super().query_params_handler(queryset, filters)
+        return base_qs.filter(
+            **{key: value for key, value in filters.items() if isinstance(value, bool)}
+        )
+
+
+class NumericFilterViewSetMixin(APIViewSet):
+    """
+    Mixin providing numeric filtering for Django QuerySets.
+
+    This mixin defines a helper to apply numeric filters from a dictionary of query
+    parameters, selecting only those values that are of numeric type (int or float)
+    and ignoring any non-numeric entries. It is intended to be used with viewsets
+    that expose queryable endpoints.
+
+    Methods:
+        query_params_handler(queryset, filters):
+            Apply numeric filters to the given queryset based on the provided
+            dictionary. Only keys with numeric values are included in the filter.
+
+            Parameters:
+                queryset (QuerySet): A Django QuerySet to be filtered.
+                filters (dict): A mapping of field names to potential filter values.
+
+            Returns:
+                QuerySet: A new QuerySet filtered by the numeric entries in `filters`.
+
+            Notes:
+                - Non-numeric values in `filters` are ignored.
+                - Keys should correspond to valid model fields or lookups.
+                - This method does not mutate the original queryset; it returns a
+                  filtered clone.
+    """
+
+    async def query_params_handler(self, queryset, filters):
+        """
+        Apply numeric filter to the queryset based on provided filters.
+        """
+        base_qs = await super().query_params_handler(queryset, filters)
+        return base_qs.filter(
+            **{
+                key: value
+                for key, value in filters.items()
+                if isinstance(value, (int, float))
+            }
+        )
+
+
+class DateFilterViewSetMixin(APIViewSet):
+    """
+    Mixin enabling date/datetime-based filtering for Django QuerySets.
+
+    Purpose:
+    - Apply dynamic date/datetime filters based on incoming query parameters.
+    - Support customizable comparison operators via `_compare_attr` (e.g., "__gt", "__lt", "__gte", "__lte").
+
+    Behavior:
+    - Filters only entries whose values implement `isoformat` (dates or datetimes).
+    - Builds lookups as "<field><_compare_attr>" with the provided value.
+
+    Attributes:
+    - _compare_attr (str): Django ORM comparison operator suffix to append to field names.
+
+    Notes:
+    - Ensure provided filter values are compatible with the target model fields.
+    - Subclasses should set `_compare_attr` to control comparison semantics.
+    """
+
+    _compare_attr: str = ""
+
+    async def query_params_handler(self, queryset, filters):
+        """
+        Apply date/datetime filters using `_compare_attr`.
+
+        - Delegates to `super().query_params_handler` first.
+        - Applies filters for keys whose values implement `isoformat`.
+
+        Returns:
+        - QuerySet filtered with lookups in the form: field<_compare_attr>=value.
+        """
+        base_qs = await super().query_params_handler(queryset, filters)
+        return base_qs.filter(
+            **{
+                f"{key}{self._compare_attr}": value
+                for key, value in filters.items()
+                if hasattr(value, "isoformat")
+            }
+        )
+
+
+class GreaterDateFilterViewSetMixin(DateFilterViewSetMixin):
+    """
+    Mixin that configures date filtering to return records with dates strictly greater than a given value.
+    This class extends DateFilterViewSetMixin and sets the internal comparison attribute to `__gt`,
+    ensuring that any date-based filtering uses the "greater than" operation.
+    Attributes:
+        _compare_attr (str): The Django ORM comparison operator used for filtering, set to "__gt".
+    Usage:
+        - Include this mixin in a ViewSet to filter queryset results where the specified date field is
+          greater than the provided date value.
+        - Typically used in endpoints that need to fetch items created/updated after a certain timestamp.
+    Example:
+        class MyViewSet(GreaterDateFilterViewSetMixin, ModelViewSet):
+            date_filter_field = "created_at"
+            ...
+        # Filtering will apply: queryset.filter(created_at__gt=<provided_date>)
+    """
+
+    _compare_attr = "__gt"
+
+
+class LessDateFilterViewSetMixin(DateFilterViewSetMixin):
+    """
+    Mixin that configures date filtering to return records with dates strictly less than a given value.
+    This class extends DateFilterViewSetMixin and sets the internal comparison attribute to `__lt`,
+    ensuring that any date-based filtering uses the "less than" operation.
+    Attributes:
+        _compare_attr (str): The Django ORM comparison operator used for filtering, set to "__lt".
+    Usage:
+        - Include this mixin in a ViewSet to filter queryset results where the specified date field is
+          less than the provided date value.
+        - Typically used in endpoints that need to fetch items created/updated before a certain timestamp.
+    Example:
+        class MyViewSet(LessDateFilterViewSetMixin, ModelViewSet):
+            date_filter_field = "created_at"
+            ...
+        # Filtering will apply: queryset.filter(created_at__lt=<provided_date>)
+    """
+
+    _compare_attr = "__lt"
+
+
+class GreaterEqualDateFilterViewSetMixin(DateFilterViewSetMixin):
+    """
+    Mixin for date-based filtering that uses a "greater than or equal to" comparison.
+
+    This mixin extends DateFilterViewSetMixin by setting the internal comparison
+    attribute to "__gte", enabling querysets to be filtered to include records whose
+    date or datetime fields are greater than or equal to the provided value.
+
+    Intended Use:
+    - Apply to Django Ninja or DRF viewsets that support date filtering.
+    - Combine with DateFilterViewSetMixin to standardize date filter behavior.
+
+    Behavior:
+    - When a date filter parameter is present, the queryset is filtered using
+        Django's "__gte" lookup, e.g., MyModel.objects.filter(created_at__gte=value).
+
+    Attributes:
+    - _compare_attr: str
+        The Django ORM comparison operator used for filtering; set to "__gte".
+
+    Notes:
+    - Ensure the target field and provided filter value are compatible (date or datetime).
+    - Timezone-aware comparisons should be handled consistently within the project settings.
+    """
+
+    _compare_attr = "__gte"
+
+
+class LessEqualDateFilterViewSetMixin(DateFilterViewSetMixin):
+    """
+    Mixin for date-based filtering that uses a "less than or equal to" comparison.
+    This mixin extends DateFilterViewSetMixin by setting the internal comparison
+    attribute to "__lte", enabling querysets to be filtered to include records whose
+    date or datetime fields are less than or equal to the provided value.
+    Intended Use:
+    - Apply to Django Ninja or DRF viewsets that support date filtering.
+    - Combine with DateFilterViewSetMixin to standardize date filter behavior.
+    Behavior:
+    - When a date filter parameter is present, the queryset is filtered using
+        Django's "__lte" lookup, e.g., MyModel.objects.filter(created_at__lte=value).
+    Attributes:
+    - _compare_attr: str
+        The Django ORM comparison operator used for filtering; set to "__lte".
+    Notes:
+    - Ensure the target field and provided filter value are compatible (date or datetime).
+    - Timezone-aware comparisons should be handled consistently within the project settings.
+    """
+
+    _compare_attr = "__lte"

django_ninja_aio_crud-2.0.0rc7.dist-info/RECORD

@@ -1,21 +0,0 @@
-ninja_aio/__init__.py,sha256=b0K4gr4xA4QngOZ7PrtTuDcxgyk3yFTNwNxsCObFqug,123
-ninja_aio/api.py,sha256=SS1TYUiFkdYjfJLVy6GI90GOzvIHzPEeL-UcqWFRHkM,1684
-ninja_aio/auth.py,sha256=8jaEp7oEJvUUB9EuyE2fOYk-khyAaekT3i80E7AbgOA,5101
-ninja_aio/decorators.py,sha256=BHoFIiqdIVMFqSxGh-F6WeZFo1xZK4ieDw3dzKfxZIM,8147
-ninja_aio/exceptions.py,sha256=1-iRbrloIyi0CR6Tcrn5YR4_LloA7PPohKIBaxXJ0-8,2596
-ninja_aio/models.py,sha256=aJlo5a64O4o-fB8QESLMUJpoA5kcjRJxPBiAIMxg46k,47652
-ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
-ninja_aio/renders.py,sha256=VtmSliRJyZ6gjyoib8AXMVUBYF1jPNsiceCHujI_mAs,1699
-ninja_aio/types.py,sha256=TJSGlA7bt4g9fvPhJ7gzH5tKbLagPmZUzfgttEOp4xs,468
-ninja_aio/views.py,sha256=8vMFw-8au9O0Hpf-79jvB47PwokCzm7P8UY0DDWpN5A,16786
-ninja_aio/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ninja_aio/helpers/api.py,sha256=kgHxYPfbV6kQbp8Z4qMwQtwFiFIcRAenxI9MDowGtis,20181
-ninja_aio/helpers/query.py,sha256=tE8RjXvSig-WB_0LRQ0LqoE4G_HMHsu0Na5QzTNIm6U,4262
-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=rmE0D15lJg95Unv8PU44Hbf0VDTcErMCZZFG3D_znTo,2823
-django_ninja_aio_crud-2.0.0rc7.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
-django_ninja_aio_crud-2.0.0rc7.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-django_ninja_aio_crud-2.0.0rc7.dist-info/METADATA,sha256=bxFgTP1QMN1oSLPw4fhV3Nu9-U90pNN92FoiVqJq6hY,8675
-django_ninja_aio_crud-2.0.0rc7.dist-info/RECORD,,