rest-filters 0.1.0__tar.gz

rest_filters-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+.venv
+__pycache__/
+*.pyc

rest_filters-0.1.0/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

rest_filters-0.1.0/.idea/drf-filter.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.12 (drf-filter)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

rest_filters-0.1.0/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,54 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="CssUnknownProperty" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="myCustomPropertiesEnabled" value="true" />
+      <option name="myIgnoreVendorSpecificProperties" value="false" />
+      <option name="myCustomPropertiesList">
+        <value>
+          <list size="1">
+            <item index="0" class="java.lang.String" itemvalue="paddint-top" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="DockerFileAssignments" enabled="false" level="ERROR" enabled_by_default="false" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="HtmlUnknownAttribute" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="myValues">
+        <value>
+          <list size="1">
+            <item index="0" class="java.lang.String" itemvalue="value" />
+          </list>
+        </value>
+      </option>
+      <option name="myCustomValuesEnabled" value="true" />
+    </inspection_tool>
+    <inspection_tool class="PyAttributeOutsideInitInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ourVersions">
+        <value>
+          <list size="2">
+            <item index="0" class="java.lang.String" itemvalue="3.12" />
+            <item index="1" class="java.lang.String" itemvalue="3.11" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyMethodMayBeStaticInspection" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="3">
+            <item index="0" class="java.lang.String" itemvalue="zope-interface" />
+            <item index="1" class="java.lang.String" itemvalue="prompt-toolkit" />
+            <item index="2" class="java.lang.String" itemvalue="typing-extensions" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyRedundantParenthesesInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="myIgnoreTupleInReturn" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

rest_filters-0.1.0/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

rest_filters-0.1.0/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.11 (django-sozluk)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (drf-filter)" project-jdk-type="Python SDK" />
+</project>

rest_filters-0.1.0/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/drf-filter.iml" filepath="$PROJECT_DIR$/.idea/drf-filter.iml" />
+    </modules>
+  </component>
+</project>

rest_filters-0.1.0/.idea/ruff.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RuffConfigService">
+    <option name="globalRuffExecutablePath" value="$PROJECT_DIR$/../pypackages/bin/ruff" />
+    <option name="projectRuffExecutablePath" value="$PROJECT_DIR$/.venv/bin/ruff" />
+    <option name="runRuffOnSave" value="true" />
+    <option name="useRuffFormat" value="true" />
+  </component>
+</project>

rest_filters-0.1.0/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

rest_filters-0.1.0/.idea/workspace.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="036fc8c0-6a78-4c9e-8607-871c8fafbce2" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 0
+}</component>
+  <component name="ProjectId" id="2plHSYRbsl55LSV0DzU8zKTArqh" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+    <option name="sortByType" value="true" />
+    <option name="sortKey" value="BY_TYPE" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/Users/suayip/Projects/drf-filter&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;com.koxudaxi.ruff.RuffConfigurable&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  }
+}</component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-1d06a55b98c1-0b3e54e931b4-JavaScript-PY-241.19072.16" />
+        <option value="bundled-python-sdk-8336bb23522e-2767605e8bc2-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-241.19072.16" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="036fc8c0-6a78-4c9e-8607-871c8fafbce2" name="Changes" comment="" />
+      <created>1733333741225</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1733333741225</updated>
+      <workItem from="1733333742261" duration="9945000" />
+      <workItem from="1733412373669" duration="11445000" />
+      <workItem from="1733509131420" duration="6023000" />
+      <workItem from="1733569377429" duration="1942000" />
+      <workItem from="1733775621847" duration="6629000" />
+      <workItem from="1733863470564" duration="4487000" />
+      <workItem from="1734120683127" duration="4258000" />
+      <workItem from="1734270684001" duration="1921000" />
+      <workItem from="1734273029203" duration="2179000" />
+      <workItem from="1734291472802" duration="5672000" />
+      <workItem from="1734373962690" duration="2451000" />
+      <workItem from="1734378243117" duration="3884000" />
+      <workItem from="1734459938142" duration="12963000" />
+      <workItem from="1734629741407" duration="2081000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

rest_filters-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: mixed-line-ending
+        args: [ '--fix=lf' ]
+      - id: end-of-file-fixer
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: 'v0.8.4'
+    hooks:
+      - id: ruff
+      - id: ruff-format

rest_filters-0.1.0/.suayip

@@ -0,0 +1,24 @@
+# Django Settings ve What can be be a setting? (blank, known params)
+# modelviewset factory oluşturup ordan kaymaca?
+
+# 2.
+# sort
+# OrderingFilter() ? (idk)
+# maybe just do all that in Meta?
+# e.g., ordering = {"default": "field", } idk.. []
+
+# -1.
+# big todo: filteset metaclass for Meta>Options creation
+# where we do checks to ensure integrity. we also need to
+# implement introspect() {param: serializer} thing so that
+# we can derive fields and also serializer for sanity checks
+# and also schema generation.
+# ^^ we need to do this because we would like to introspect filterset
+# before initiating it. that how Options.fields wil work too
+
+# 0. BONUS: `invalid_query_param` or `%s_query_param`
+# code usage? and maybe add as a setting as well
+
+# help_text, start writing tests
+
+# extend_known_parameters?

rest_filters-0.1.0/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2025, Şuayip Üzülmez
+All rights reserved.
+
+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.

rest_filters-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: rest-filters
+Version: 0.1.0
+Project-URL: Homepage, https://github.com/realsuayip/rest-filters
+Project-URL: Bug Tracker, https://github.com/realsuayip/rest-filters/issues
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: django>=3.2
+Requires-Dist: djangorestframework>=3.14.0

rest_filters-0.1.0/README.md

@@ -0,0 +1 @@
+WIP

rest_filters-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["rest_filters"]
+
+[project]
+name = "rest-filters"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "django>=3.2",
+    "djangorestframework>=3.14.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/realsuayip/rest-filters"
+"Bug Tracker" = "https://github.com/realsuayip/rest-filters/issues"
+
+[tool.ruff]
+target-version = "py312"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle errors
+    "W", # pycodestyle warnings
+    "F", # pyflakes
+    "C", # flake8-comprehensions
+    "B", # flake8-bugbear
+    "RUF", # Ruff-specific
+    "C4", # flake8-comprehensions
+    "C90", # mccabe
+    "I", # isort
+]
+fixable = ["I"]
+ignore = ["B904"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+section-order = [
+    "future",
+    "standard-library",
+    "django",
+    "rest_framework",
+    "third-party",
+    "first-party",
+    "local-folder",
+]
+
+[tool.ruff.lint.isort.sections]
+django = ["django"]
+rest_framework = ["rest_framework"]
+
+[tool.lint.mccabe]
+max-complexity = 10
+
+[tool.mypy]
+strict = true

rest_filters-0.1.0/rest_filters/backends.py

@@ -0,0 +1,455 @@
+from __future__ import annotations
+
+import functools
+import operator
+from collections import defaultdict
+from collections.abc import Sequence
+from difflib import get_close_matches
+from typing import Any, Generic, Literal, TypeVar
+
+from django.db import models
+from django.db.models import Q, QuerySet
+from django.http.request import QueryDict
+from django.utils.translation import gettext
+
+from rest_framework import filters, serializers
+from rest_framework.exceptions import ValidationError
+from rest_framework.fields import SkipField, empty
+from rest_framework.request import Request
+from rest_framework.settings import api_settings
+from rest_framework.views import APIView
+
+from rest_filters.utils import fill_q_template, merge_errors
+
+_MT_co = TypeVar("_MT_co", bound=models.Model, covariant=True)
+
+StrOrPromise = str
+
+
+class Entry:
+    def __init__(
+        self,
+        *,
+        group: str = "chain",
+        aliases: dict[str, Any] | None = None,
+        value: Any,
+        expression: Any,
+    ):
+        self.group = group
+        self.aliases = aliases
+        self.value = value
+        self.expression = expression
+
+    def __repr__(self) -> str:
+        return "Entry(group=%r, aliases=%r, value=%r, expression=%r)" % (
+            self.group,
+            self.aliases,
+            self.value,
+            self.expression,
+        )
+
+
+class Filter:
+    def __init__(
+        self,
+        f: serializers.Field = None,
+        /,
+        *,
+        field: str | None = None,
+        lookup: str = "exact",
+        template: Q | None = None,
+        group: str | None = None,
+        distinct: bool = False,
+        negate: bool = False,
+        method: str | None = None,
+        aliases: dict[str, Any] | None = None,
+        param: str | None = None,
+        children: list[Filter] | None = None,
+        namespace: bool = False,
+        blank: Literal["keep", "omit"] = "omit",
+    ) -> None:
+        self._field = field
+        self.lookup = lookup or "exact"
+        self.template = template
+
+        # todo needs tons of other checks
+        if group is not None and not group.isidentifier():
+            raise ValueError("Group names must be valid Python identifiers")
+
+        if blank not in ("keep", "omit"):
+            raise ValueError("blank must either be 'keep' or 'omit'")
+
+        self._group = group
+        self.aliases = aliases  # not functional
+
+        self.negate = negate
+        self.distinct = distinct  # not functional, todo allow list<str> also
+
+        self.blank = blank
+        self.method = method
+        self._param = param
+        self._serializer = f
+        self._filterset: FilterSet | None = None
+
+        self.namespace = namespace
+        self.parent: Filter | None = None
+        self.children = children or []
+        for child in self.children:
+            child.bind(self)
+
+        if not self.children and self.namespace:
+            raise ValueError("Namespace filters are required to have child filters")
+
+    def __repr__(self) -> str:
+        return "%s(param=%r, group=%r, serializer=%r)" % (
+            self.__class__.__name__,
+            self.get_param_name(),
+            self.get_group(),
+            self.get_serializer(),
+        )
+
+    def __set_name__(self, owner: FilterSet, name: str) -> None:
+        self.name = name
+
+    def bind(self, parent: Filter) -> None:
+        self.parent = parent
+
+        if self._param is None:
+            raise ValueError("param needs to be set for child filters")
+
+    def get_group(self) -> str:
+        if self._group is not None:
+            return self._group
+        elif self.parent is not None:
+            return self.parent.get_group()
+        return "chain"
+
+    def get_field_name(self):
+        if self.parent and self._field is None:
+            return self.parent.get_field_name()
+        return self._field or self.name
+
+    def get_param_name(self) -> str:
+        name = self._param or self.name
+        if self.parent is not None:
+            namespace = self.parent.get_param_name()
+            return f"{namespace}.{name}"
+        return name
+
+    def get_query_value(self, query_dict: QueryDict) -> str | empty:
+        param = self.get_param_name()
+        return query_dict.get(param, empty)
+
+    def get_serializer(self) -> serializers.Field:
+        if self._serializer is not None:
+            return self._serializer
+        elif self.parent is not None:
+            return self.parent.get_serializer()
+        raise ValueError("Serializer field is not set for this filter")
+
+    def get_filterset(self) -> FilterSet:
+        if self.parent:
+            return self.parent.get_filterset()
+        return self._filterset
+
+    def parse_value(self, value: str | empty) -> Any:
+        if value is not empty:
+            value = serializers.CharField(allow_blank=True).run_validation(value)
+            if self.blank == "omit" and value == "":
+                value = empty
+        filterset, param = self.get_filterset(), self.get_param_name()
+        serializer = filterset.get_serializer(param) or self.get_serializer()
+        serializer.default = filterset.get_default(param, serializer.default)
+        return serializer.run_validation(value)
+
+    def resolve_entry_attrs(self, value: Any) -> Entry:
+        if self.template is not None:
+            expression = fill_q_template(self.template, value=value)
+        else:
+            field = self.get_field_name()
+            lookup = f"{field}__{self.lookup}"
+            expression = Q(**{lookup: value})
+        if self.negate:
+            expression = ~expression
+        return Entry(
+            group=self.get_group(),
+            aliases=self.aliases,
+            value=value,
+            expression=expression,
+        )
+
+    def resolve_entry(self, query_dict: QueryDict) -> Entry | None:
+        try:
+            value = self.parse_value(self.get_query_value(query_dict))
+        except SkipField:
+            return None
+
+        if self.method is not None:
+            param = self.get_param_name()
+            result = getattr(self.get_filterset(), self.method)(param, value)
+            if isinstance(result, Entry):
+                return result
+            return Entry(group=self.get_group(), value=value, expression=result)
+        return self.resolve_entry_attrs(value)
+
+    def get_all_children(self) -> list[Filter]:
+        children = []
+        for child in self.children:
+            children.append(child)
+            children.extend(child.get_all_children())
+        return children
+
+    def resolve(
+        self, query_dict: QueryDict
+    ) -> tuple[dict[str, Entry | None], dict[str, Any]]:
+        entries, errors = {}, {}
+        for instance in [self, *self.get_all_children()]:
+            if instance.namespace:
+                continue
+            param = instance.get_param_name()
+            try:
+                entry = instance.resolve_entry(query_dict)
+            except ValidationError as err:
+                errors[param] = err.detail
+            else:
+                entries[param] = entry
+        return entries, errors
+
+
+class Constraint:
+    def __init__(
+        self,
+        *,
+        fields: Sequence[str],
+        message: StrOrPromise = "",
+        method: str | None = None,
+    ) -> None:
+        self.fields = fields
+        self.message = message
+        self.method = method
+        self.filterset: FilterSet | None = None
+
+    def get_message(self, **kwargs: Any) -> dict[str, Any]:
+        message = self.message or gettext(
+            "%(constraint)s failed for fields: %(fields)s"
+        ) % {
+            "constraint": self.__class__.__name__,
+            "fields": ", ".join(f'"{field}"' for field in self.fields),
+        }
+        return {api_settings.NON_FIELD_ERRORS_KEY: [message]}
+
+    def check(self, **kwargs: Any) -> bool:
+        assert self.method, "Missing method for constraint"
+        assert self.filterset, "Missing filterset for constraint"
+        return getattr(self.filterset, self.method)(**kwargs)
+
+
+class MutuallyExclusive(Constraint):
+    def __init__(
+        self,
+        *,
+        fields: Sequence[str],
+        **kwargs: Any,
+    ) -> None:
+        assert len(fields) > 1, "Provide 2 or more fields for this constraint"
+        super().__init__(fields=fields, **kwargs)
+
+    def get_message(self, **kwargs: Any) -> dict[str, Any]:
+        if self.message:
+            return super().get_message(**kwargs)
+        return {
+            api_settings.NON_FIELD_ERRORS_KEY: [
+                gettext(
+                    "Following fields are mutually exclusive,"
+                    " you may only provide one of them: %(fields)s"
+                )
+                % {
+                    "fields": ", ".join(
+                        f'"{field}"' for field in self.fields if field in kwargs
+                    )
+                }
+            ]
+        }
+
+    def check(self, **kwargs: Any) -> bool:
+        return sum(field in kwargs for field in self.fields) <= 1
+
+
+class MutuallyInclusive(Constraint):
+    def __init__(
+        self,
+        *,
+        fields: Sequence[str],
+        **kwargs: Any,
+    ) -> None:
+        assert len(fields) > 1, "Provide 2 or more fields for this constraint"
+        super().__init__(fields=fields, **kwargs)
+
+    def get_message(self, **kwargs: Any) -> dict[str, Any]:
+        if self.message:
+            return super().get_message(**kwargs)
+        return {
+            api_settings.NON_FIELD_ERRORS_KEY: [
+                gettext(
+                    "Following fields are mutually inclusive,"
+                    " you must provide them all at once or none of them: %(fields)s"
+                )
+                % {"fields": ", ".join(f'"{field}"' for field in self.fields)}
+            ]
+        }
+
+    def check(self, **kwargs: Any) -> bool:
+        fields = [field in kwargs for field in self.fields]
+        return all(fields) if any(fields) else True
+
+
+class Options:
+    def __init__(
+        self,
+        *,
+        fields: Sequence[str] | None = None,
+        known_parameters: Sequence[str] | None = None,
+        constraints: Sequence[Constraint] | None = None,
+        combinators: dict[str, Any] | None = None,
+    ) -> None:
+        self.fields = fields  # todo not functional
+        self.known_parameters = known_parameters or []
+        self.constraints = constraints or []
+        self.combinators = combinators or {}
+
+
+class FilterSet(Generic[_MT_co]):
+    def __init__(
+        self, request: Request, queryset: QuerySet[_MT_co], view: APIView
+    ) -> None:
+        self.request = request
+        self.queryset = queryset
+        self.view = view
+        self.options = self.get_options()
+
+    def get_options(self) -> Options:
+        if meta := getattr(self, "Meta", None):
+            args = ("fields", "known_parameters", "constraints", "combinators")
+            return Options(**{arg: getattr(meta, arg, None) for arg in args})
+        return Options()
+
+    def get_groups(self) -> dict[str, dict[str, Entry]]:
+        params = self.request.query_params
+        fields = self.get_fields()
+        groupdict, valuedict, errordict = defaultdict(dict), {}, {}
+        known = [*self.options.known_parameters]
+        for _, field in fields.items():
+            field._filterset = self
+            entries, errors = field.resolve(params)
+            known.extend((*entries, *errors))
+            for param, entry in entries.items():
+                if entry is not None:
+                    groupdict[entry.group][param] = entry
+                    valuedict[param] = entry.value
+            for param, error in errors.items():
+                errordict[param] = error
+                valuedict[param] = empty
+        unknown = [field for field in params if field not in known]
+        merge_errors(errordict, self.handle_constraints(valuedict))
+        errordict |= self.handle_unknown_parameters(unknown, known)
+        self.handle_errors(errordict)
+        return groupdict
+
+    def filter_group(
+        self,
+        queryset: QuerySet[_MT_co],
+        name: str,
+        entries: dict[str, Entry],
+    ) -> QuerySet[_MT_co]:
+        merge = getattr(self, f"merge_{name}", None)
+        if merge is not None:
+            entry = merge(entries)
+            return queryset.filter(entry.expression)
+        return queryset.filter(self.get_default_group_expression(name, entries))
+
+    def get_default_group_expression(
+        self, group: str, entries: dict[str, Entry]
+    ) -> Any:
+        combinator = self.options.combinators.get(group, operator.and_)
+        expressions = (entry.expression for entry in entries.values())
+        return functools.reduce(combinator, expressions)
+
+    def get_queryset(self) -> QuerySet[_MT_co]:
+        queryset = self.queryset
+        groupdict = self.get_groups()
+
+        for entry in groupdict.pop("chain", {}).values():
+            queryset = queryset.filter(entry.expression)
+
+        for name, entries in groupdict.items():
+            queryset = self.filter_group(queryset, name, entries)
+        return queryset
+
+    @classmethod
+    def get_fields(cls) -> dict[str, Filter]:
+        return {
+            name: attr for name, attr in vars(cls).items() if isinstance(attr, Filter)
+        }
+
+    def get_default(self, param: str, default: Any) -> Any:
+        return default
+
+    def get_serializer(self, param: str) -> serializers.Field | None:
+        return None
+
+    def get_constraints(self) -> Sequence[Constraint]:
+        return self.options.constraints
+
+    def handle_constraints(self, valuedict: dict[str, Any]) -> dict[str, Any]:
+        errors = {}
+        constraints = self.get_constraints()
+        for constraint in constraints:
+            constraint.filterset = self
+            if not constraint.check(**valuedict):
+                message = constraint.get_message(**valuedict)
+                merge_errors(errors, message)
+        return errors
+
+    def handle_unknown_parameters(
+        self, unknown: list[str], known: list[str]
+    ) -> dict[str, Any]:
+        fields = {}
+        for param in unknown:
+            matches = get_close_matches(param, known)
+            if not matches:
+                fields[param] = [gettext("This query parameter does not exist.")]
+            elif len(matches) == 1:
+                fields[param] = [
+                    gettext(
+                        "This query parameter does not exist."
+                        ' Did you mean "%(param)s"?'
+                    )
+                    % {"param": matches[0]}
+                ]
+            else:
+                possibilities = ", ".join(f'"{match}"' for match in matches)
+                fields[param] = [
+                    gettext(
+                        "This query parameter does not exist."
+                        " Did you mean one of these: %(possibilities)s?"
+                    )
+                    % {"possibilities": possibilities}
+                ]
+        return fields
+
+    def handle_errors(self, errordict: dict[str, Any]) -> None:
+        raise serializers.ValidationError(errordict)
+
+
+class FilterBackend(filters.BaseFilterBackend):
+    def get_filterset_class(self, request, queryset, view):
+        # todo def get_filterset_class
+        return view.filterset_classes.get(view.action)
+
+    def get_filterset(self, request, queryset, view):
+        klass = self.get_filterset_class(request, queryset, view)
+        return klass(request, queryset, view)
+
+    def filter_queryset(self, request, queryset, view):
+        filterset = self.get_filterset(request, queryset, view)
+        return filterset.get_queryset()

rest_filters-0.1.0/rest_filters/utils.py

@@ -0,0 +1,36 @@
+from typing import Any
+
+from django.db.models import Q
+
+
+def fill_q_template(template: Q, *, value: Any) -> Q:
+    conditions = []
+    for child in template.children:
+        if isinstance(child, Q):
+            conditions.append(fill_q_template(child, value=value))
+        else:
+            if isinstance(child, tuple):
+                field, value = child
+                raise ValueError(
+                    "Q objects should not specify values in templates, got"
+                    " Q(%(field)s=%(value)r), expected Q(%(field)r)."
+                    " If you would like to do more complex queries, use `method`"
+                    " argument." % {"field": field, "value": value}
+                )
+            conditions.append((child, value))
+    return Q(
+        *conditions,
+        _connector=template.connector,
+        _negated=template.negated,
+    )
+
+
+def merge_errors(
+    source: dict[str, Any],
+    errors: dict[str, Any],
+) -> None:
+    for key, detail in errors.items():
+        if isinstance(source.get(key), list):
+            source[key].extend(detail)
+        else:
+            source[key] = detail