django-unfold 0.46.0__py3-none-any.whl → 0.48.0__py3-none-any.whl

unfold/contrib/filters/admin/datetime_filters.py

@@ -0,0 +1,212 @@
+from typing import Any
+
+from django.contrib import admin
+from django.contrib.admin.options import ModelAdmin
+from django.contrib.admin.views.main import ChangeList
+from django.core.validators import EMPTY_VALUES
+from django.db.models import Model, QuerySet
+from django.db.models.fields import (
+    DateField,
+    DateTimeField,
+    Field,
+)
+from django.forms import ValidationError
+from django.http import HttpRequest
+
+from unfold.contrib.filters.forms import (
+    RangeDateForm,
+    RangeDateTimeForm,
+)
+from unfold.utils import parse_date_str, parse_datetime_str
+
+
+class RangeDateFilter(admin.FieldListFilter):
+    request = None
+    parameter_name = None
+    form_class = RangeDateForm
+    template = "unfold/filters/filters_date_range.html"
+
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+        if not isinstance(field, DateField):
+            raise TypeError(
+                f"Class {type(self.field)} is not supported for {self.__class__.__name__}."
+            )
+
+        self.request = request
+        if self.parameter_name is None:
+            self.parameter_name = self.field_path
+
+        if self.parameter_name + "_from" in params:
+            value = params.pop(self.field_path + "_from")
+            value = value[0] if isinstance(value, list) else value
+
+            if value not in EMPTY_VALUES:
+                self.used_parameters[self.field_path + "_from"] = value
+
+        if self.parameter_name + "_to" in params:
+            value = params.pop(self.field_path + "_to")
+            value = value[0] if isinstance(value, list) else value
+
+            if value not in EMPTY_VALUES:
+                self.used_parameters[self.field_path + "_to"] = value
+
+    def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet:
+        filters = {}
+
+        value_from = self.used_parameters.get(self.parameter_name + "_from")
+        if value_from not in EMPTY_VALUES:
+            filters.update({self.parameter_name + "__gte": parse_date_str(value_from)})
+
+        value_to = self.used_parameters.get(self.parameter_name + "_to")
+        if value_to not in EMPTY_VALUES:
+            filters.update({self.parameter_name + "__lte": parse_date_str(value_to)})
+
+        try:
+            return queryset.filter(**filters)
+        except (ValueError, ValidationError):
+            return None
+
+    def expected_parameters(self) -> list[str]:
+        return [
+            f"{self.parameter_name}_from",
+            f"{self.parameter_name}_to",
+        ]
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        return (
+            {
+                "request": self.request,
+                "parameter_name": self.parameter_name,
+                "form": self.form_class(
+                    name=self.parameter_name,
+                    data={
+                        self.parameter_name + "_from": self.used_parameters.get(
+                            self.parameter_name + "_from", None
+                        ),
+                        self.parameter_name + "_to": self.used_parameters.get(
+                            self.parameter_name + "_to", None
+                        ),
+                    },
+                ),
+            },
+        )
+
+
+class RangeDateTimeFilter(admin.FieldListFilter):
+    request = None
+    parameter_name = None
+    template = "unfold/filters/filters_datetime_range.html"
+    form_class = RangeDateTimeForm
+
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+        if not isinstance(field, DateTimeField):
+            raise TypeError(
+                f"Class {type(self.field)} is not supported for {self.__class__.__name__}."
+            )
+
+        self.request = request
+        if self.parameter_name is None:
+            self.parameter_name = self.field_path
+
+        if self.parameter_name + "_from_0" in params:
+            value = params.pop(self.field_path + "_from_0")
+            value = value[0] if isinstance(value, list) else value
+            self.used_parameters[self.field_path + "_from_0"] = value
+
+        if self.parameter_name + "_from_1" in params:
+            value = params.pop(self.field_path + "_from_1")
+            value = value[0] if isinstance(value, list) else value
+            self.used_parameters[self.field_path + "_from_1"] = value
+
+        if self.parameter_name + "_to_0" in params:
+            value = params.pop(self.field_path + "_to_0")
+            value = value[0] if isinstance(value, list) else value
+            self.used_parameters[self.field_path + "_to_0"] = value
+
+        if self.parameter_name + "_to_1" in params:
+            value = params.pop(self.field_path + "_to_1")
+            value = value[0] if isinstance(value, list) else value
+            self.used_parameters[self.field_path + "_to_1"] = value
+
+    def expected_parameters(self) -> list[str]:
+        return [
+            f"{self.parameter_name}_from_0",
+            f"{self.parameter_name}_from_1",
+            f"{self.parameter_name}_to_0",
+            f"{self.parameter_name}_to_1",
+        ]
+
+    def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet:
+        filters = {}
+
+        date_value_from = self.used_parameters.get(self.parameter_name + "_from_0")
+        time_value_from = self.used_parameters.get(self.parameter_name + "_from_1")
+
+        date_value_to = self.used_parameters.get(self.parameter_name + "_to_0")
+        time_value_to = self.used_parameters.get(self.parameter_name + "_to_1")
+
+        if date_value_from not in EMPTY_VALUES and time_value_from not in EMPTY_VALUES:
+            filters.update(
+                {
+                    f"{self.parameter_name}__gte": parse_datetime_str(
+                        f"{date_value_from} {time_value_from}"
+                    ),
+                }
+            )
+
+        if date_value_to not in EMPTY_VALUES and time_value_to not in EMPTY_VALUES:
+            filters.update(
+                {
+                    f"{self.parameter_name}__lte": parse_datetime_str(
+                        f"{date_value_to} {time_value_to}"
+                    ),
+                }
+            )
+
+        try:
+            return queryset.filter(**filters)
+        except (ValueError, ValidationError):
+            return None
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        return (
+            {
+                "request": self.request,
+                "parameter_name": self.parameter_name,
+                "form": self.form_class(
+                    name=self.parameter_name,
+                    data={
+                        self.parameter_name + "_from_0": self.used_parameters.get(
+                            self.parameter_name + "_from_0"
+                        ),
+                        self.parameter_name + "_from_1": self.used_parameters.get(
+                            self.parameter_name + "_from_1"
+                        ),
+                        self.parameter_name + "_to_0": self.used_parameters.get(
+                            self.parameter_name + "_to_0"
+                        ),
+                        self.parameter_name + "_to_1": self.used_parameters.get(
+                            self.parameter_name + "_to_1"
+                        ),
+                    },
+                ),
+            },
+        )

unfold/contrib/filters/admin/dropdown_filters.py

@@ -0,0 +1,100 @@
+from collections.abc import Generator
+from typing import Any
+
+from django.contrib import admin
+from django.contrib.admin.views.main import ChangeList
+from django.db.models import Field, Model
+from django.http import HttpRequest
+from django.utils.translation import gettext_lazy as _
+
+from unfold.admin import ModelAdmin
+from unfold.contrib.filters.admin.mixins import (
+    DropdownMixin,
+    MultiValueMixin,
+    ValueMixin,
+)
+from unfold.contrib.filters.forms import DropdownForm
+
+
+class DropdownFilter(admin.SimpleListFilter):
+    template = "unfold/filters/filters_field.html"
+    form_class = DropdownForm
+    all_option = ["", _("All")]
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        return (
+            {
+                "form": self.form_class(
+                    label=_("By %(filter_title)s") % {"filter_title": self.title},
+                    name=self.parameter_name,
+                    choices=[self.all_option, *self.lookup_choices],
+                    data={self.parameter_name: self.value()},
+                    multiple=self.multiple if hasattr(self, "multiple") else False,
+                ),
+            },
+        )
+
+
+class MultipleDropdownFilter(DropdownFilter):
+    multiple = True
+
+    def __init__(
+        self,
+        request: HttpRequest,
+        params: dict[str, Any],
+        model: type[Model],
+        model_admin: ModelAdmin,
+    ) -> None:
+        self.request = request
+        super().__init__(request, params, model, model_admin)
+
+    def value(self) -> list[Any]:
+        return self.request.GET.getlist(self.parameter_name)
+
+
+class ChoicesDropdownFilter(ValueMixin, DropdownMixin, admin.ChoicesFieldListFilter):
+    def choices(self, changelist: ChangeList) -> Generator[dict[str, Any], None, None]:
+        choices = [self.all_option, *self.field.flatchoices]
+
+        yield {
+            "form": self.form_class(
+                label=_("By %(filter_title)s") % {"filter_title": self.title},
+                name=self.lookup_kwarg,
+                choices=choices,
+                data={self.lookup_kwarg: self.value()},
+                multiple=self.multiple if hasattr(self, "multiple") else False,
+            ),
+        }
+
+
+class MultipleChoicesDropdownFilter(MultiValueMixin, ChoicesDropdownFilter):
+    multiple = True
+
+
+class RelatedDropdownFilter(ValueMixin, DropdownMixin, admin.RelatedFieldListFilter):
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+        self.model_admin = model_admin
+
+    def choices(self, changelist: ChangeList) -> Generator[dict[str, Any], None, None]:
+        yield {
+            "form": self.form_class(
+                label=_("By %(filter_title)s") % {"filter_title": self.title},
+                name=self.lookup_kwarg,
+                choices=[self.all_option, *self.lookup_choices],
+                data={self.lookup_kwarg: self.value()},
+                multiple=self.multiple if hasattr(self, "multiple") else False,
+            ),
+        }
+
+
+class MultipleRelatedDropdownFilter(MultiValueMixin, RelatedDropdownFilter):
+    multiple = True

unfold/contrib/filters/admin/mixins.py

@@ -0,0 +1,146 @@
+from collections.abc import Generator
+from typing import Any, Optional
+
+from django.contrib.admin.views.main import ChangeList
+from django.core.validators import EMPTY_VALUES
+from django.db.models import QuerySet
+from django.forms import ValidationError
+from django.http import HttpRequest
+from django.utils.translation import gettext_lazy as _
+
+from unfold.contrib.filters.forms import (
+    AutocompleteDropdownForm,
+    DropdownForm,
+    RangeNumericForm,
+)
+
+
+class ValueMixin:
+    def value(self) -> Optional[str]:
+        return (
+            self.lookup_val[0]
+            if self.lookup_val not in EMPTY_VALUES
+            and isinstance(self.lookup_val, list)
+            and len(self.lookup_val) > 0
+            else self.lookup_val
+        )
+
+
+class MultiValueMixin:
+    def value(self) -> Optional[list[str]]:
+        return (
+            self.lookup_val
+            if self.lookup_val not in EMPTY_VALUES
+            and isinstance(self.lookup_val, list)
+            and len(self.lookup_val) > 0
+            else self.lookup_val
+        )
+
+
+class DropdownMixin:
+    template = "unfold/filters/filters_field.html"
+    form_class = DropdownForm
+    all_option = ["", _("All")]
+
+    def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet:
+        if self.value() not in EMPTY_VALUES:
+            return super().queryset(request, queryset)
+
+        return queryset
+
+
+class RangeNumericMixin:
+    request = None
+    parameter_name = None
+    template = "unfold/filters/filters_numeric_range.html"
+
+    def init_used_parameters(self, params: dict[str, Any]) -> None:
+        if self.parameter_name + "_from" in params:
+            value = params.pop(self.parameter_name + "_from")
+
+            self.used_parameters[self.parameter_name + "_from"] = (
+                value[0] if isinstance(value, list) else value
+            )
+
+        if self.parameter_name + "_to" in params:
+            value = params.pop(self.parameter_name + "_to")
+            self.used_parameters[self.parameter_name + "_to"] = (
+                value[0] if isinstance(value, list) else value
+            )
+
+    def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet:
+        filters = {}
+
+        value_from = self.used_parameters.get(self.parameter_name + "_from", None)
+        if value_from is not None and value_from != "":
+            filters.update(
+                {
+                    self.parameter_name + "__gte": self.used_parameters.get(
+                        self.parameter_name + "_from", None
+                    ),
+                }
+            )
+
+        value_to = self.used_parameters.get(self.parameter_name + "_to", None)
+        if value_to is not None and value_to != "":
+            filters.update(
+                {
+                    self.parameter_name + "__lte": self.used_parameters.get(
+                        self.parameter_name + "_to", None
+                    ),
+                }
+            )
+
+        try:
+            return queryset.filter(**filters)
+        except (ValueError, ValidationError):
+            return None
+
+    def expected_parameters(self) -> list[str]:
+        return [
+            f"{self.parameter_name}_from",
+            f"{self.parameter_name}_to",
+        ]
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        return (
+            {
+                "request": self.request,
+                "parameter_name": self.parameter_name,
+                "form": RangeNumericForm(
+                    name=self.parameter_name,
+                    data={
+                        self.parameter_name + "_from": self.used_parameters.get(
+                            self.parameter_name + "_from", None
+                        ),
+                        self.parameter_name + "_to": self.used_parameters.get(
+                            self.parameter_name + "_to", None
+                        ),
+                    },
+                ),
+            },
+        )
+
+
+class AutocompleteMixin:
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        if "request" in kwargs:
+            self.request = kwargs["request"]
+
+    def choices(
+        self, changelist: ChangeList
+    ) -> Generator[dict[str, AutocompleteDropdownForm], None, None]:
+        yield {
+            "form": self.form_class(
+                request=self.request,
+                label=_("By %(filter_title)s") % {"filter_title": self.title},
+                name=self.lookup_kwarg,
+                choices=(),
+                field=self.field,
+                model_admin=self.model_admin,
+                data={self.lookup_kwarg: self.value()},
+                multiple=self.multiple if hasattr(self, "multiple") else False,
+            ),
+        }

unfold/contrib/filters/admin/numeric_filters.py

@@ -0,0 +1,196 @@
+from typing import Any, Optional
+
+from django.contrib import admin
+from django.contrib.admin.options import ModelAdmin
+from django.contrib.admin.views.main import ChangeList
+from django.core.validators import EMPTY_VALUES
+from django.db.models import Max, Min, Model, QuerySet
+from django.db.models.fields import (
+    AutoField,
+    DecimalField,
+    Field,
+    FloatField,
+    IntegerField,
+)
+from django.forms import ValidationError
+from django.http import HttpRequest
+
+from unfold.contrib.filters.admin.mixins import RangeNumericMixin
+from unfold.contrib.filters.forms import SingleNumericForm, SliderNumericForm
+
+
+class SingleNumericFilter(admin.FieldListFilter):
+    request = None
+    parameter_name = None
+    template = "unfold/filters/filters_numeric_single.html"
+
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+
+        if not isinstance(field, (DecimalField, IntegerField, FloatField, AutoField)):
+            raise TypeError(
+                f"Class {type(self.field)} is not supported for {self.__class__.__name__}."
+            )
+
+        self.request = request
+
+        if self.parameter_name is None:
+            self.parameter_name = self.field_path
+
+        if self.parameter_name in params:
+            value = params.pop(self.parameter_name)
+            value = value[0] if isinstance(value, list) else value
+
+            if value not in EMPTY_VALUES:
+                self.used_parameters[self.parameter_name] = value
+
+    def queryset(
+        self, request: HttpRequest, queryset: QuerySet[Any]
+    ) -> Optional[QuerySet]:
+        if self.value():
+            try:
+                return queryset.filter(**{self.parameter_name: self.value()})
+            except (ValueError, ValidationError):
+                return None
+
+    def value(self) -> Any:
+        return self.used_parameters.get(self.parameter_name, None)
+
+    def expected_parameters(self) -> list[Optional[str]]:
+        return [self.parameter_name]
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        return (
+            {
+                "request": self.request,
+                "parameter_name": self.parameter_name,
+                "form": SingleNumericForm(
+                    name=self.parameter_name, data={self.parameter_name: self.value()}
+                ),
+            },
+        )
+
+
+class RangeNumericListFilter(RangeNumericMixin, admin.SimpleListFilter):
+    def __init__(
+        self,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+    ) -> None:
+        super().__init__(request, params, model, model_admin)
+        if not self.parameter_name:
+            raise ValueError("Parameter name cannot be None")
+
+        self.request = request
+        self.init_used_parameters(params)
+
+    def lookups(
+        self, request: HttpRequest, model_admin: ModelAdmin
+    ) -> tuple[tuple[str, str], ...]:
+        return (("dummy", "dummy"),)
+
+
+class RangeNumericFilter(RangeNumericMixin, admin.FieldListFilter):
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+        if not isinstance(field, (DecimalField, IntegerField, FloatField, AutoField)):
+            raise TypeError(
+                f"Class {type(self.field)} is not supported for {self.__class__.__name__}."
+            )
+
+        self.request = request
+        if self.parameter_name is None:
+            self.parameter_name = self.field_path
+
+        self.init_used_parameters(params)
+
+
+class SliderNumericFilter(RangeNumericFilter):
+    MAX_DECIMALS = 7
+    STEP = None
+
+    template = "unfold/filters/filters_numeric_slider.html"
+    field = None
+    form_class = SliderNumericForm
+
+    def __init__(
+        self,
+        field: Field,
+        request: HttpRequest,
+        params: dict[str, str],
+        model: type[Model],
+        model_admin: ModelAdmin,
+        field_path: str,
+    ) -> None:
+        super().__init__(field, request, params, model, model_admin, field_path)
+
+        self.field = field
+        self.q = model_admin.get_queryset(request)
+
+    def choices(self, changelist: ChangeList) -> tuple[dict[str, Any], ...]:
+        total = self.q.all().count()
+        min_value = self.q.all().aggregate(min=Min(self.parameter_name)).get("min", 0)
+
+        if total > 1:
+            max_value = (
+                self.q.all().aggregate(max=Max(self.parameter_name)).get("max", 0)
+            )
+        else:
+            max_value = None
+
+        if isinstance(self.field, (FloatField, DecimalField)):
+            decimals = self.MAX_DECIMALS
+            step = self.STEP if self.STEP else self._get_min_step(self.MAX_DECIMALS)
+        else:
+            decimals = 0
+            step = self.STEP if self.STEP else 1
+
+        return (
+            {
+                "decimals": decimals,
+                "step": step,
+                "parameter_name": self.parameter_name,
+                "request": self.request,
+                "min": min_value,
+                "max": max_value,
+                "value_from": self.used_parameters.get(
+                    self.parameter_name + "_from", min_value
+                ),
+                "value_to": self.used_parameters.get(
+                    self.parameter_name + "_to", max_value
+                ),
+                "form": self.form_class(
+                    name=self.parameter_name,
+                    data={
+                        self.parameter_name + "_from": self.used_parameters.get(
+                            self.parameter_name + "_from", min_value
+                        ),
+                        self.parameter_name + "_to": self.used_parameters.get(
+                            self.parameter_name + "_to", max_value
+                        ),
+                    },
+                ),
+            },
+        )
+
+    def _get_min_step(self, precision: int) -> float:
+        result_format = f"{{:.{precision - 1}f}}"
+        return float(result_format.format(0) + "1")