django-ninja-aio-crud 2.0.0rc6__py3-none-any.whl → 2.1.0__py3-none-any.whl

{django_ninja_aio_crud-2.0.0rc6.dist-info → django_ninja_aio_crud-2.1.0.dist-info}/METADATA

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

django_ninja_aio_crud-2.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+ninja_aio/__init__.py,sha256=YGWehZQ4d5yVFCd1ax-s61BSkND60Yh383YmUJq-LtY,119
+ninja_aio/api.py,sha256=SS1TYUiFkdYjfJLVy6GI90GOzvIHzPEeL-UcqWFRHkM,1684
+ninja_aio/auth.py,sha256=w9TXDQwJSZzCbncsSwemINTUe1IPZGHnLKiqWTeOoFA,9163
+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=_QV0DySZhCV1otuh1zhrlHgCaFnr5fd64GQrcA-qKoc,564
+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=ispbr5w6WCUdbXmn2LY94zDQ0qb2nDNeTLLNAUBFoDc,17736
+ninja_aio/views/mixins.py,sha256=Jh6BG8Cs823nurVlODlzCquTxKrLH7Pmo5udPqUGZek,11378
+django_ninja_aio_crud-2.1.0.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
+django_ninja_aio_crud-2.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+django_ninja_aio_crud-2.1.0.dist-info/METADATA,sha256=91kIanSvlN_aeRmhZuXZR2pIBXEzUUOuYLJkijzN7QI,8672
+django_ninja_aio_crud-2.1.0.dist-info/RECORD,,

ninja_aio/__init__.py

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

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)):
+        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: jwk.RSAKey = 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: jwk.RSAKey | jwk.ECKey = 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/decorators.py

@@ -143,3 +143,76 @@ 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

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/schemas/helpers.py

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

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
 
 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}

@@ -7,16 +7,16 @@ 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
+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
+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})
 
@@ -103,7 +103,7 @@ 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.
@@ -121,7 +121,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,7 +145,7 @@ 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:
@@ -178,6 +178,7 @@ 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
@@ -277,15 +278,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
@@ -309,7 +313,7 @@ class APIViewSet:
             description=self.create_docs,
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @unique_view(self)
+        @decorate_view(unique_view(self), *self.extra_decorators.create)
         async def create(request: HttpRequest, data: self.schema_in):  # type: ignore
             return 201, await self.model_util.create_s(request, data, self.schema_out)
 
@@ -330,8 +334,11 @@ class APIViewSet:
                 self.error_codes: GenericMessageSchema,
             },
         )
-        @unique_view(self, plural=True)
-        @paginate(self.pagination_class)
+        @decorate_view(
+            paginate(self.pagination_class),
+            unique_view(self, plural=True),
+            *self.extra_decorators.list,
+        )
         async def list(
             request: HttpRequest,
             filters: Query[self.filters_schema] = None,  # type: ignore
@@ -359,7 +366,7 @@ class APIViewSet:
             description=self.retrieve_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @unique_view(self)
+        @decorate_view(unique_view(self), *self.extra_decorators.retrieve)
         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(
@@ -384,7 +391,7 @@ class APIViewSet:
             description=self.update_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        @unique_view(self)
+        @decorate_view(unique_view(self), *self.extra_decorators.update)
         async def update(
             request: HttpRequest,
             data: self.schema_update,  # type: ignore
@@ -408,7 +415,7 @@ class APIViewSet:
             description=self.delete_docs,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        @unique_view(self)
+        @decorate_view(unique_view(self), *self.extra_decorators.delete)
         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))
 
@@ -448,3 +455,31 @@ class APIViewSet:
         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:
+        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:
+        class MyModelWriteOnlyViewSet(WriteOnlyViewSet):
+            model = MyModel
+            api = api
+        MyModelWriteOnlyViewSet().add_views_to_route()
+    """
+
+    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.0rc6.dist-info/RECORD

@@ -1,21 +0,0 @@
-ninja_aio/__init__.py,sha256=YT267RC9JIxwAbuYlHPZtMBAKcfulXoXzTmGwXu0GVU,123
-ninja_aio/api.py,sha256=SS1TYUiFkdYjfJLVy6GI90GOzvIHzPEeL-UcqWFRHkM,1684
-ninja_aio/auth.py,sha256=8jaEp7oEJvUUB9EuyE2fOYk-khyAaekT3i80E7AbgOA,5101
-ninja_aio/decorators.py,sha256=gswkwl1zWSpW8VxGCe8MlgXcHMg6Y7V1f2ertey9Tjo,5522
-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=h_embl52o5WOVbhbB05vkNKEGOm-s4PvdAjy81-6ISw,16424
-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=al1G5-CdB9CF3eIPdZcUSE7vKRJiTU5g1ltoPhI2Onw,2622
-django_ninja_aio_crud-2.0.0rc6.dist-info/licenses/LICENSE,sha256=yrDAYcm0gRp_Qyzo3GQa4BjYjWRkAhGC8QRva__RYq0,1073
-django_ninja_aio_crud-2.0.0rc6.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-django_ninja_aio_crud-2.0.0rc6.dist-info/METADATA,sha256=QKZ7nA93H8coEBeWBC-rSx2J4QIPsA0TjAiuc4tQnmo,8675
-django_ninja_aio_crud-2.0.0rc6.dist-info/RECORD,,