django-unfold 0.46.0__tar.gz → 0.47.0__tar.gz

{django_unfold-0.46.0 → django_unfold-0.47.0}/PKG-INFO

@@ -1,11 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-unfold
-Version: 0.46.0
+Version: 0.47.0
 Summary: Modern Django admin theme for seamless interface development
-Home-page: https://unfoldadmin.com
 License: MIT
 Keywords: django,admin,tailwind,theme
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
 Classifier: Intended Audience :: Developers
@@ -13,13 +12,13 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: django (>=3.2)
+Project-URL: Homepage, https://unfoldadmin.com
 Project-URL: Repository, https://github.com/unfoldadmin/django-unfold
 Description-Content-Type: text/markdown
 
@@ -52,7 +51,7 @@ Have you decided to start using Unfold but don’t have time to make the switch
 - **Sidebar:** Simplifies the creation of sidebar navigation with icons, collapsibles, and more.
 - **Dark mode:** Supports both light and dark mode versions.
 - **Actions:** Offers multiple ways to define actions within different parts of the admin interface.
-- **Filters:** Custom dropdowns, numeric, datetime, and text fields.
+- **Filters:** Custom dropdowns, autocomplete, numeric, datetime, and text fields.
 - **Dashboard:** Includes helpers for creating custom dashboard pages.
 - **Components:** Reusable UI components such as cards, buttons, and charts.
 - **WYSIWYG widget:** Built-in support for WYSIWYG (Trix).

{django_unfold-0.46.0 → django_unfold-0.47.0}/README.md

@@ -27,7 +27,7 @@ Have you decided to start using Unfold but don’t have time to make the switch
 - **Sidebar:** Simplifies the creation of sidebar navigation with icons, collapsibles, and more.
 - **Dark mode:** Supports both light and dark mode versions.
 - **Actions:** Offers multiple ways to define actions within different parts of the admin interface.
-- **Filters:** Custom dropdowns, numeric, datetime, and text fields.
+- **Filters:** Custom dropdowns, autocomplete, numeric, datetime, and text fields.
 - **Dashboard:** Includes helpers for creating custom dashboard pages.
 - **Components:** Reusable UI components such as cards, buttons, and charts.
 - **WYSIWYG widget:** Built-in support for WYSIWYG (Trix).

{django_unfold-0.46.0 → django_unfold-0.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-unfold"
-version = "0.46.0"
+version = "0.47.0"
 description = "Modern Django admin theme for seamless interface development"
 license = "MIT"
 readme = "README.md"
@@ -11,7 +11,6 @@ packages = [{ include = "unfold", from = "src" }]
 keywords = ["django", "admin", "tailwind", "theme"]
 classifiers = [
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -24,7 +23,7 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.8"
+python = ">=3.9"
 django = ">=3.2"
 
 [tool.poetry.group.test.dependencies]
@@ -39,7 +38,6 @@ python-semantic-release = "^8.7"
 [tool.ruff]
 fix = true
 line-length = 88
-target-version = "py38"
 
 [tool.ruff.lint]
 select = [

{django_unfold-0.46.0 → django_unfold-0.47.0}/src/unfold/admin.py

@@ -1,6 +1,6 @@
 import copy
 from functools import update_wrapper
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 from django import forms
 from django.contrib.admin import ModelAdmin as BaseModelAdmin
@@ -272,9 +272,9 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
     def _filter_unfold_actions_by_permissions(
         self,
         request: HttpRequest,
-        actions: List[UnfoldAction],
+        actions: list[UnfoldAction],
         object_id: Optional[Union[int, str]] = None,
-    ) -> List[UnfoldAction]:
+    ) -> list[UnfoldAction]:
         """Filter out any Unfold actions that the user doesn't have access to."""
         filtered_actions = []
         for action in actions:
@@ -299,12 +299,12 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
 
         return filtered_actions
 
-    def get_actions_list(self, request: HttpRequest) -> List[UnfoldAction]:
+    def get_actions_list(self, request: HttpRequest) -> list[UnfoldAction]:
         return self._filter_unfold_actions_by_permissions(
             request, self._get_base_actions_list()
         )
 
-    def _get_base_actions_list(self) -> List[UnfoldAction]:
+    def _get_base_actions_list(self) -> list[UnfoldAction]:
         """
         Returns all available list global actions, prior to any filtering
         """
@@ -312,23 +312,23 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
 
     def get_actions_detail(
         self, request: HttpRequest, object_id: int
-    ) -> List[UnfoldAction]:
+    ) -> list[UnfoldAction]:
         return self._filter_unfold_actions_by_permissions(
             request, self._get_base_actions_detail(), object_id
         )
 
-    def _get_base_actions_detail(self) -> List[UnfoldAction]:
+    def _get_base_actions_detail(self) -> list[UnfoldAction]:
         """
         Returns all available detail actions, prior to any filtering
         """
         return [self.get_unfold_action(action) for action in self.actions_detail or []]
 
-    def get_actions_row(self, request: HttpRequest) -> List[UnfoldAction]:
+    def get_actions_row(self, request: HttpRequest) -> list[UnfoldAction]:
         return self._filter_unfold_actions_by_permissions(
             request, self._get_base_actions_row()
         )
 
-    def _get_base_actions_row(self) -> List[UnfoldAction]:
+    def _get_base_actions_row(self) -> list[UnfoldAction]:
         """
         Returns all available row actions, prior to any filtering
         """
@@ -336,12 +336,12 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
 
     def get_actions_submit_line(
         self, request: HttpRequest, object_id: int
-    ) -> List[UnfoldAction]:
+    ) -> list[UnfoldAction]:
         return self._filter_unfold_actions_by_permissions(
             request, self._get_base_actions_submit_line(), object_id
         )
 
-    def _get_base_actions_submit_line(self) -> List[UnfoldAction]:
+    def _get_base_actions_submit_line(self) -> list[UnfoldAction]:
         """
         Returns all available submit row actions, prior to any filtering
         """
@@ -349,7 +349,7 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
             self.get_unfold_action(action) for action in self.actions_submit_line or []
         ]
 
-    def get_custom_urls(self) -> Tuple[Tuple[str, str, View], ...]:
+    def get_custom_urls(self) -> tuple[tuple[str, str, View], ...]:
         """
         Method to get custom views for ModelAdmin with their urls
 
@@ -358,7 +358,7 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
         """
         return () if self.custom_urls is None else self.custom_urls
 
-    def get_urls(self) -> List[URLPattern]:
+    def get_urls(self) -> list[URLPattern]:
         urls = super().get_urls()
 
         def wrap(view):
@@ -409,7 +409,6 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
         )
 
     def _path_from_custom_url(self, custom_url) -> URLPattern:
-        # TODO: wrap()
         return path(
             custom_url[0],
             self.admin_site.admin_view(custom_url[2]),
@@ -422,7 +421,7 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
         request: HttpRequest,
         object_id: Optional[str] = None,
         form_url: str = "",
-        extra_context: Optional[Dict[str, bool]] = None,
+        extra_context: Optional[dict[str, bool]] = None,
     ) -> Any:
         if extra_context is None:
             extra_context = {}
@@ -451,7 +450,7 @@ class ModelAdmin(ModelAdminMixin, BaseModelAdmin):
         return super().changeform_view(request, object_id, form_url, extra_context)
 
     def changelist_view(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, str]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, str]] = None
     ) -> TemplateResponse:
         if extra_context is None:
             extra_context = {}

{django_unfold-0.46.0 → django_unfold-0.47.0}/src/unfold/checks.py

@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any
 
 from django.contrib.admin.checks import ModelAdminChecks
 from django.contrib.admin.options import BaseModelAdmin
@@ -8,18 +8,18 @@ from .dataclasses import UnfoldAction
 
 
 class UnfoldModelAdminChecks(ModelAdminChecks):
-    def check(self, admin_obj: BaseModelAdmin, **kwargs) -> List[checks.Error]:
+    def check(self, admin_obj: BaseModelAdmin, **kwargs) -> list[checks.Error]:
         return [
             *super().check(admin_obj, **kwargs),
             *self._check_unfold_action_permission_methods(admin_obj),
         ]
 
-    def _check_unfold_action_permission_methods(self, obj: Any) -> List[checks.Error]:
+    def _check_unfold_action_permission_methods(self, obj: Any) -> list[checks.Error]:
         """
         Actions with an allowed_permission attribute require the ModelAdmin to
         implement a has_<perm>_permission() method for each permission.
         """
-        actions: List[UnfoldAction] = [
+        actions: list[UnfoldAction] = [
             *obj._get_base_actions_list(),
             *obj._get_base_actions_detail(),
             *obj._get_base_actions_row(),

{django_unfold-0.46.0 → django_unfold-0.47.0}/src/unfold/components.py

@@ -1,13 +1,13 @@
-from typing import Any, Dict, Optional, Type
+from typing import Any, Optional
 
 from django.http import HttpRequest
 
 
 class ComponentRegistry:
-    _registry: Dict[str, Type] = {}
+    _registry: dict[str, type] = {}
 
     @classmethod
-    def register_class(cls, component_cls: Type) -> None:
+    def register_class(cls, component_cls: type) -> None:
         if not issubclass(component_cls, BaseComponent):
             raise ValueError(
                 f"Class '{component_cls.__name__}' must inherit from BaseComponent."
@@ -21,7 +21,7 @@ class ComponentRegistry:
         cls._registry[class_name] = component_cls
 
     @classmethod
-    def get_class(cls, class_name: str) -> Optional[Type]:
+    def get_class(cls, class_name: str) -> Optional[type]:
         return cls._registry.get(class_name)
 
     @classmethod
@@ -34,7 +34,7 @@ class ComponentRegistry:
         return component_cls(**kwargs)
 
 
-def register_component(cls: Type) -> Type:
+def register_component(cls: type) -> type:
     ComponentRegistry.register_class(cls)
     return cls
 

django_unfold-0.47.0/src/unfold/contrib/filters/admin/__init__.py

@@ -0,0 +1,43 @@
+from unfold.contrib.filters.admin.autocomplete_filters import (
+    AutocompleteSelectFilter,
+    AutocompleteSelectMultipleFilter,
+)
+from unfold.contrib.filters.admin.datetime_filters import (
+    RangeDateFilter,
+    RangeDateTimeFilter,
+)
+from unfold.contrib.filters.admin.dropdown_filters import (
+    ChoicesDropdownFilter,
+    DropdownFilter,
+    MultipleChoicesDropdownFilter,
+    MultipleDropdownFilter,
+    MultipleRelatedDropdownFilter,
+    RelatedDropdownFilter,
+)
+from unfold.contrib.filters.admin.numeric_filters import (
+    RangeNumericFilter,
+    RangeNumericListFilter,
+    SingleNumericFilter,
+    SliderNumericFilter,
+)
+from unfold.contrib.filters.admin.text_filters import FieldTextFilter, TextFilter
+
+__all__ = [
+    "ChoicesDropdownFilter",
+    "MultipleChoicesDropdownFilter",
+    "DropdownFilter",
+    "RelatedDropdownFilter",
+    "MultipleDropdownFilter",
+    "MultipleRelatedDropdownFilter",
+    "FieldTextFilter",
+    "TextFilter",
+    "RangeDateFilter",
+    "RangeDateFilter",
+    "RangeDateTimeFilter",
+    "SingleNumericFilter",
+    "RangeNumericFilter",
+    "RangeNumericListFilter",
+    "SliderNumericFilter",
+    "AutocompleteSelectFilter",
+    "AutocompleteSelectMultipleFilter",
+]

django_unfold-0.47.0/src/unfold/contrib/filters/admin/autocomplete_filters.py

@@ -0,0 +1,16 @@
+from unfold.contrib.filters.admin.dropdown_filters import (
+    MultipleRelatedDropdownFilter,
+    RelatedDropdownFilter,
+)
+from unfold.contrib.filters.admin.mixins import AutocompleteMixin
+from unfold.contrib.filters.forms import AutocompleteDropdownForm
+
+
+class AutocompleteSelectFilter(AutocompleteMixin, RelatedDropdownFilter):
+    form_class = AutocompleteDropdownForm
+
+
+class AutocompleteSelectMultipleFilter(
+    AutocompleteMixin, MultipleRelatedDropdownFilter
+):
+    form_class = AutocompleteDropdownForm

django_unfold-0.47.0/src/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"
+                        ),
+                    },
+                ),
+            },
+        )

django_unfold-0.47.0/src/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