drf-query-method 0.1.0__py3-none-any.whl

drf_query_method/__init__.py

@@ -0,0 +1,20 @@
+"""Support for the HTTP QUERY method (RFC 10008) in Django REST framework.
+
+This is a stop-gap until DRF supports ``QUERY`` itself
+(encode/django-rest-framework#10091). It mirrors the names used there, so
+moving to DRF's own support means removing this package rather than
+rewriting views.
+
+There are two ways to use it:
+
+* Opt-in classes with the same names as DRF's, for example
+  ``drf_query_method.filters.SearchFilter``, imported in place of DRF's.
+* :func:`patch`, which applies the same behaviour to DRF itself, and to
+  django-filter when it is installed.
+"""
+
+from drf_query_method.methods import add_query_method
+from drf_query_method.params import filter_params
+from drf_query_method.patching import patch, unpatch
+
+__all__ = ["add_query_method", "filter_params", "patch", "unpatch"]

drf_query_method/django_filters.py

@@ -0,0 +1,36 @@
+"""django-filter's DRF backend, reading QUERY request bodies.
+
+Importing this module requires django-filter.
+"""
+
+from django.http import QueryDict
+from django_filters import rest_framework
+
+from drf_query_method.params import filter_params
+
+
+def as_filter_data(params):
+    """Stringify a QUERY body's scalar values, as a query string would deliver them.
+
+    django-filter's widgets expect strings. JSON numbers and booleans become
+    ``"5"`` and ``"True"``, which its fields parse as usual, rather than
+    reaching widgets that call ``.split(",")`` on them.
+    """
+    data = QueryDict(mutable=True)
+    for key, values in params.lists():
+        data.setlist(key, [value if value is None or isinstance(value, str) else str(value) for value in values])
+    return data
+
+
+def get_filterset_kwargs(self, request, queryset, view, original):
+    kwargs = original(self, request, queryset, view)
+    if request.method == "QUERY":
+        kwargs["data"] = as_filter_data(filter_params(request))
+    return kwargs
+
+
+class DjangoFilterBackend(rest_framework.DjangoFilterBackend):
+    def get_filterset_kwargs(self, request, queryset, view):
+        return get_filterset_kwargs(
+            self, request, queryset, view, rest_framework.DjangoFilterBackend.get_filterset_kwargs
+        )

drf_query_method/filters.py

@@ -0,0 +1,38 @@
+"""DRF's ``SearchFilter`` and ``OrderingFilter``, reading QUERY request bodies.
+
+``get_ordering`` is adapted from Django REST framework
+(Copyright Encode OSS Ltd, BSD 3-Clause; see LICENSE).
+"""
+
+from rest_framework import filters
+from rest_framework.fields import CharField
+
+from drf_query_method.params import filter_params
+
+
+def get_search_terms(self, request):
+    """Search terms come from ``?search=...``, or a QUERY request's body, and may be whitespace delimited."""
+    value = filter_params(request).get(self.search_param, "")
+    field = CharField(trim_whitespace=False, allow_blank=True)
+    cleaned_value = field.run_validation(value)
+    return filters.search_smart_split(cleaned_value)
+
+
+def get_ordering(self, request, queryset, view):
+    """Ordering comes from a comma delimited ``?ordering=...``, or a QUERY request's body."""
+    params = filter_params(request).get(self.ordering_param)
+    if params and isinstance(params, str):
+        fields = [param.strip() for param in params.split(",")]
+        ordering = self.remove_invalid_fields(queryset, fields, view, request)
+        if ordering:
+            return ordering
+
+    return self.get_default_ordering(view)
+
+
+class SearchFilter(filters.SearchFilter):
+    get_search_terms = get_search_terms
+
+
+class OrderingFilter(filters.OrderingFilter):
+    get_ordering = get_ordering

drf_query_method/methods.py

@@ -0,0 +1,16 @@
+"""Make Django accept the QUERY method on versions before 6.2."""
+
+from django.views.generic import View
+
+
+def add_query_method() -> None:
+    """Add ``query`` to Django's ``View.http_method_names`` if it is missing.
+
+    Django 6.2 lists ``query`` itself, so this does nothing there. On earlier
+    versions it lets any view, including DRF's, dispatch ``QUERY`` requests to
+    a ``query()`` handler. Earlier versions of Django's CSRF middleware treat
+    ``QUERY`` as unsafe, so session-authenticated ``QUERY`` requests need a
+    CSRF token until Django 6.2.
+    """
+    if "query" not in View.http_method_names:
+        View.http_method_names = [*View.http_method_names, "query"]

drf_query_method/params.py

@@ -0,0 +1,48 @@
+"""The parameters filter backends should read for a request."""
+
+from collections.abc import Mapping
+
+from django.http import QueryDict
+from django.utils.datastructures import MultiValueDict
+from rest_framework.exceptions import ParseError
+
+
+def merge_filter_params(request) -> QueryDict:
+    """Return ``request.query_params`` with a QUERY request's body merged over it.
+
+    For any method other than ``QUERY`` this is ``request.query_params``
+    itself. A ``QUERY`` request carries its query in the request body, so the
+    parsed body is merged over the URL query parameters, and the body wins
+    for any key present in both. List values in a JSON body become multiple
+    values, as repeated query-string parameters do.
+
+    Raises ``ParseError`` (400) when the body is not an object of parameters,
+    such as a JSON array.
+    """
+    if request.method != "QUERY":
+        return request.query_params
+
+    body = request.data
+    if not isinstance(body, Mapping):
+        raise ParseError(f"QUERY request body must be an object of parameters, not {type(body).__name__}.")
+
+    if not isinstance(body, MultiValueDict):
+        body = MultiValueDict({key: value if isinstance(value, list) else [value] for key, value in body.items()})
+
+    params = request.query_params.copy()
+    for key, values in body.lists():
+        params.setlist(key, values)
+    return params
+
+
+def filter_params(request) -> QueryDict:
+    """The parameters filter backends should read for ``request``.
+
+    Uses ``request.filter_params`` when DRF provides it, natively or through
+    :func:`drf_query_method.patch`, and computes it otherwise. Custom filter
+    backends should read their parameters through this rather than
+    ``request.query_params``, so that they support ``QUERY`` requests.
+    """
+    if hasattr(type(request), "filter_params"):
+        return request.filter_params
+    return merge_filter_params(request)

drf_query_method/patching.py

@@ -0,0 +1,107 @@
+"""Apply QUERY support to DRF itself, and to django-filter when installed.
+
+:func:`patch` makes DRF behave as if encode/django-rest-framework#10091 were
+merged, so existing views, routers and settings pick up ``QUERY`` without
+changing imports. Call it once at startup, for example from an
+``AppConfig.ready()``. It does nothing to DRF once DRF supports ``QUERY``
+itself.
+"""
+
+import importlib.util
+
+from drf_query_method.methods import add_query_method
+
+_MISSING = object()
+_applied: list[tuple[object, str, object]] = []
+
+
+def _set(owner, name: str, value) -> None:
+    _applied.append((owner, name, owner.__dict__.get(name, _MISSING)))
+    setattr(owner, name, value)
+
+
+def _patch_drf() -> None:
+    from rest_framework import decorators, filters, permissions, routers, test, viewsets
+    from rest_framework.request import Request
+    from rest_framework.schemas.generators import EndpointEnumerator
+
+    from drf_query_method import filters as query_filters
+    from drf_query_method import permissions as query_permissions
+    from drf_query_method import test as query_test
+    from drf_query_method.params import merge_filter_params
+    from drf_query_method.routers import get_routes_keeping_query_actions, with_query_route
+    from drf_query_method.viewsets import drop_unmapped_query
+
+    _set(Request, "filter_params", property(merge_filter_params))
+    _set(filters.SearchFilter, "get_search_terms", query_filters.get_search_terms)
+    _set(filters.OrderingFilter, "get_ordering", query_filters.get_ordering)
+
+    _set(permissions, "SAFE_METHODS", query_permissions.SAFE_METHODS)
+    for permission_class in (permissions.DjangoModelPermissions, permissions.DjangoObjectPermissions):
+        _set(permission_class, "perms_map", {**permission_class.perms_map, "QUERY": []})
+
+    _set(routers.SimpleRouter, "routes", with_query_route(routers.SimpleRouter.routes))
+    simple_get_routes = routers.SimpleRouter.get_routes
+    _set(
+        routers.SimpleRouter,
+        "get_routes",
+        lambda router, viewset: get_routes_keeping_query_actions(router, viewset, simple_get_routes),
+    )
+
+    def dispatch(self, request, *args, **kwargs):
+        drop_unmapped_query(self)
+        return super(viewsets.ViewSetMixin, self).dispatch(request, *args, **kwargs)
+
+    _set(viewsets.ViewSetMixin, "dispatch", dispatch)
+    _set(decorators.MethodMapper, "query", lambda self, func: self._map("query", func))
+    _set(test.APIRequestFactory, "query", query_test.factory_query)
+    _set(test.APIClient, "query", query_test.client_query)
+
+    get_allowed_methods = EndpointEnumerator.get_allowed_methods
+    _set(
+        EndpointEnumerator,
+        "get_allowed_methods",
+        lambda self, callback: [method for method in get_allowed_methods(self, callback) if method != "QUERY"],
+    )
+
+
+def _patch_django_filter() -> None:
+    from django_filters.rest_framework import DjangoFilterBackend
+
+    from drf_query_method.django_filters import get_filterset_kwargs
+
+    original = DjangoFilterBackend.get_filterset_kwargs
+    _set(
+        DjangoFilterBackend,
+        "get_filterset_kwargs",
+        lambda self, request, queryset, view: get_filterset_kwargs(self, request, queryset, view, original),
+    )
+
+
+def patch() -> None:
+    """Add QUERY support to Django, DRF and django-filter in place.
+
+    Safe to call more than once. On Django versions before 6.2 this also
+    calls :func:`~drf_query_method.add_query_method`, which :func:`unpatch`
+    does not undo.
+    """
+    if _applied:
+        return
+
+    from rest_framework.request import Request
+
+    add_query_method()
+    if not hasattr(Request, "filter_params"):
+        _patch_drf()
+    if importlib.util.find_spec("django_filters") is not None:
+        _patch_django_filter()
+
+
+def unpatch() -> None:
+    """Undo :func:`patch`, mainly for tests."""
+    while _applied:
+        owner, name, original = _applied.pop()
+        if original is _MISSING:
+            delattr(owner, name)
+        else:
+            setattr(owner, name, original)

drf_query_method/permissions.py

@@ -0,0 +1,45 @@
+"""DRF permission classes that treat QUERY as a safe method.
+
+``has_object_permission`` is adapted from Django REST framework
+(Copyright Encode OSS Ltd, BSD 3-Clause; see LICENSE).
+"""
+
+from django.http import Http404
+from rest_framework import permissions
+
+SAFE_METHODS = ("GET", "HEAD", "OPTIONS", "QUERY")
+
+
+class IsAuthenticatedOrReadOnly(permissions.IsAuthenticatedOrReadOnly):
+    def has_permission(self, request, view):
+        return bool(request.method in SAFE_METHODS or (request.user and request.user.is_authenticated))
+
+
+class DjangoModelPermissions(permissions.DjangoModelPermissions):
+    perms_map = {**permissions.DjangoModelPermissions.perms_map, "QUERY": []}
+
+
+class DjangoModelPermissionsOrAnonReadOnly(DjangoModelPermissions):
+    authenticated_users_only = False
+
+
+class DjangoObjectPermissions(permissions.DjangoObjectPermissions):
+    perms_map = {**permissions.DjangoObjectPermissions.perms_map, "QUERY": []}
+
+    def has_object_permission(self, request, view, obj):
+        queryset = self._queryset(view)
+        model_cls = queryset.model
+        user = request.user
+
+        perms = self.get_required_object_permissions(request.method, model_cls)
+        if user.has_perms(perms, obj):
+            return True
+
+        # A user without read permission sees a 404 rather than a 403.
+        if request.method in SAFE_METHODS:
+            raise Http404
+
+        read_perms = self.get_required_object_permissions("GET", model_cls)
+        if not user.has_perms(read_perms, obj):
+            raise Http404
+        return False

drf_query_method/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

drf_query_method/routers.py

@@ -0,0 +1,61 @@
+"""DRF routers that route QUERY to a viewset's ``query()`` on the list route."""
+
+import copy
+
+from rest_framework import routers
+
+
+def _is_list_route(route) -> bool:
+    return isinstance(route, routers.Route) and route.mapping.get("get") == "list"
+
+
+def with_query_route(routes):
+    """Map QUERY to ``query`` on the list route of ``routes``."""
+    return [
+        route._replace(mapping={**route.mapping, "query": "query"}) if _is_list_route(route) else route
+        for route in routes
+    ]
+
+
+def without_query_route(routes):
+    """Remove the QUERY mapping from every route in ``routes``."""
+    return [
+        route._replace(mapping={method: action for method, action in route.mapping.items() if action != "query"})
+        if isinstance(route, routers.Route)
+        else route
+        for route in routes
+    ]
+
+
+def has_query_action(viewset) -> bool:
+    """Whether the viewset already has an ``@action`` named ``query``."""
+    return any(action.__name__ == "query" for action in viewset.get_extra_actions())
+
+
+def get_routes_keeping_query_actions(router, viewset, get_routes):
+    """Call ``get_routes``, leaving QUERY unrouted when the viewset has an ``@action`` named ``query``.
+
+    That action keeps its own route, and DRF would otherwise reject it for
+    clashing with the built-in ``query`` route.
+    """
+    if not has_query_action(viewset):
+        return get_routes(router, viewset)
+
+    router_without_query = copy.copy(router)
+    router_without_query.routes = without_query_route(router.routes)
+    return get_routes(router_without_query, viewset)
+
+
+class QueryRouterMixin:
+    routes = with_query_route(routers.SimpleRouter.routes)
+
+    def get_routes(self, viewset):
+        return get_routes_keeping_query_actions(self, viewset, super(QueryRouterMixin, type(self)).get_routes)  # ty: ignore[unresolved-attribute]
+
+
+class SimpleRouter(QueryRouterMixin, routers.SimpleRouter):
+    pass
+
+
+class DefaultRouter(QueryRouterMixin, routers.DefaultRouter):
+    pass

drf_query_method/test.py

@@ -0,0 +1,41 @@
+"""DRF's test request factory and client, with a ``.query()`` method."""
+
+from rest_framework import test
+
+
+def factory_query(self, path, data=None, format=None, content_type=None, **extra):
+    """Build a QUERY request, encoding ``data`` as ``.post()`` does."""
+    data, content_type = self._encode_data(data, format, content_type)
+    return self.generic("QUERY", path, data, content_type, **extra)
+
+
+def client_query(self, path, data=None, format=None, content_type=None, follow=False, **extra):
+    """Send a QUERY request, encoding ``data`` as ``.post()`` does."""
+    response = factory_query(self, path, data=data, format=format, content_type=content_type, **extra)
+    if follow:
+        response = self._handle_redirects(response, data=data, format=format, content_type=content_type, **extra)
+    return response
+
+
+class APIRequestFactory(test.APIRequestFactory):
+    query = factory_query
+
+
+class APIClient(test.APIClient):
+    query = client_query
+
+
+class APISimpleTestCase(test.APISimpleTestCase):
+    client_class = APIClient
+
+
+class APITransactionTestCase(test.APITransactionTestCase):
+    client_class = APIClient
+
+
+class APITestCase(test.APITestCase):
+    client_class = APIClient
+
+
+class APILiveServerTestCase(test.APILiveServerTestCase):
+    client_class = APIClient

drf_query_method/viewsets.py

@@ -0,0 +1,36 @@
+"""DRF viewsets that only answer QUERY on routes that map it."""
+
+from rest_framework import viewsets
+
+
+def drop_unmapped_query(view) -> None:
+    """Stop a viewset answering QUERY on a route whose actions don't map it.
+
+    A viewset's ``query()`` method has the same name as the QUERY handler, so
+    without this every route of a viewset that defines ``query()`` would
+    answer QUERY, including detail routes.
+    """
+    if "query" not in (getattr(view, "action_map", None) or {}):
+        view.http_method_names = [method for method in view.http_method_names if method != "query"]
+
+
+class QueryViewSetMixin:
+    def dispatch(self, request, *args, **kwargs):
+        drop_unmapped_query(self)
+        return super().dispatch(request, *args, **kwargs)  # ty: ignore[unresolved-attribute]
+
+
+class ViewSet(QueryViewSetMixin, viewsets.ViewSet):
+    pass
+
+
+class GenericViewSet(QueryViewSetMixin, viewsets.GenericViewSet):
+    pass
+
+
+class ReadOnlyModelViewSet(QueryViewSetMixin, viewsets.ReadOnlyModelViewSet):
+    pass
+
+
+class ModelViewSet(QueryViewSetMixin, viewsets.ModelViewSet):
+    pass

drf_query_method-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: drf-query-method
+Version: 0.1.0
+Summary: HTTP QUERY method (RFC 10008) support for Django REST framework.
+Project-URL: bugs, https://github.com/BenA-SA/drf-query-method/issues
+Project-URL: changelog, https://github.com/BenA-SA/drf-query-method/releases
+Project-URL: documentation, https://BenA-SA.github.io/drf-query-method/
+Project-URL: homepage, https://github.com/BenA-SA/drf-query-method
+Author-email: Ben Atkinson <ben@streamlinedanalytics.co.uk>
+Maintainer-email: Ben Atkinson <ben@streamlinedanalytics.co.uk>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Requires-Dist: djangorestframework>=3.16
+Provides-Extra: django-filter
+Requires-Dist: django-filter; extra == 'django-filter'
+Description-Content-Type: text/markdown
+
+# drf-query-method
+
+[![PyPI version](https://img.shields.io/pypi/v/drf-query-method.svg)](https://pypi.org/project/drf-query-method/)
+
+Support for the HTTP `QUERY` method ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008.html)) in Django REST framework.
+
+> [!NOTE]
+> **This is a stop-gap.** Support for `QUERY` has been proposed for Django REST framework itself in
+> [encode/django-rest-framework#10091](https://github.com/encode/django-rest-framework/pull/10091).
+> If it is merged, use DRF's built-in support instead. This package exists so you can use `QUERY` in the
+> meantime, and on Django versions before 6.2. It mirrors the names in that PR (`query()` handlers and
+> `request.filter_params`), so switching over should mean removing this package rather than rewriting your views.
+
+`QUERY` is safe and idempotent like `GET`, but carries a request body like `POST`. It suits searches whose
+parameters are too long or too structured for a URL.
+
+* [GitHub](https://github.com/BenA-SA/drf-query-method/) | [PyPI](https://pypi.org/project/drf-query-method/) | [Documentation](https://BenA-SA.github.io/drf-query-method/)
+* Created by [Ben Atkinson](https://streamlinedanalytics.co.uk) | GitHub [@BenA-SA](https://github.com/BenA-SA) | PyPI [@Ben-SA](https://pypi.org/user/Ben-SA/)
+* BSD 3-Clause License
+
+## Usage
+
+Define a `query()` handler, then call `patch()` once at startup:
+
+```python
+import drf_query_method
+
+drf_query_method.patch()
+
+
+class NoteViewSet(ModelViewSet):
+    ...
+
+    def query(self, request, *args, **kwargs):
+        return self.list(request, *args, **kwargs)
+```
+
+Routers then send `QUERY /notes/` to `query()`, and `SearchFilter`, `OrderingFilter` and django-filter's
+`DjangoFilterBackend` read their parameters from the request body. If you'd rather not patch DRF, import drop-in
+classes with the same names from `drf_query_method` instead. See the [documentation](https://BenA-SA.github.io/drf-query-method/usage/)
+for both approaches, and for sending `QUERY` requests from JavaScript and other clients.
+
+The package is in early development and not yet released.
+
+## Compatibility
+
+* Python 3.10+
+* Django 4.2, 5.0, 5.1, 5.2, 6.0 and 6.1. Django 6.2 adds `QUERY` natively; on earlier versions this package adds it.
+* Django REST framework 3.16+
+* django-filter, optionally
+
+## Installation
+
+```bash
+pip install drf-query-method
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and release instructions.

drf_query_method-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+drf_query_method/__init__.py,sha256=qXQXHtGtBCCGmyWF7Z1BkGJuGDzuKpM-htSYLEVeYPY,795
+drf_query_method/django_filters.py,sha256=BKiQeay-uWMmbSnoVp-XsegNLaKdmi15Ttl4NO5-klw,1285
+drf_query_method/filters.py,sha256=TBsBbOMMkZkKzqdk326Q5zl7zW0hVO5E-O4aQSqzvbs,1350
+drf_query_method/methods.py,sha256=xM_xg0CkXqRMhrGFrZjVLzdPPsQlnsFR8Mec9yy8Z9M,684
+drf_query_method/params.py,sha256=X1JB9idk7hkP6s6map_IVvCVpkM7yfigktqaFUxObnQ,1911
+drf_query_method/patching.py,sha256=tCmSDbWYBaYlj9njuY6wNWM1A1uVWIgMXFYLGgz8N34,4006
+drf_query_method/permissions.py,sha256=AS1fv8pP9afi38OnRmJoyr0Y-AIzwgKZjALzmgLH1VM,1552
+drf_query_method/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+drf_query_method/routers.py,sha256=LICu8HKhVDA_aj0bh5ghAvBP40xkjDSPRRqpQliPv98,1991
+drf_query_method/test.py,sha256=jTGzfZUA0jS-GszkL-l_NfHIqBTkq0fq_irwZ8jCvfM,1286
+drf_query_method/viewsets.py,sha256=fRtTk8wW34MEHysLjW4uXjbGwd6M91CHiuvNwd7QoRI,1095
+drf_query_method-0.1.0.dist-info/METADATA,sha256=73xCRhf0_GC04-JIImO-onu1K0ND_VSF2nIrGFpJ_IU,4116
+drf_query_method-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+drf_query_method-0.1.0.dist-info/licenses/LICENSE,sha256=oBYuNHwE3Dt5IZYkSGjRcgTMS0X3CfC_-ZhlcLUqXI0,3181
+drf_query_method-0.1.0.dist-info/RECORD,,

drf_query_method-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

drf_query_method-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,61 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Ben Atkinson
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+Parts of drf_query_method/filters.py and drf_query_method/permissions.py are
+adapted from Django REST framework, which carries the following licence:
+
+Copyright © 2011-present, Encode OSS Ltd (https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.