wbcore 2.2.1__py2.py3-none-any.whl

wbcore/filters/fields/datetime.py

@@ -0,0 +1,91 @@
+from contextlib import suppress
+
+import django_filters
+from wbcore.filters.mixins import WBCoreFilterMixin
+from wbcore.forms import DateRangeField, DateTimeRangeField
+from wbcore.utils.date import financial_performance_shortcuts
+from wbcore.utils.date_builder.components import Component
+
+
+class TimeFilter(WBCoreFilterMixin, django_filters.TimeFilter):
+    filter_type = "time"
+
+
+class DateTimeFilter(WBCoreFilterMixin, django_filters.DateTimeFilter):
+    filter_type = "datetime"
+
+
+class DateFilter(WBCoreFilterMixin, django_filters.DateFilter):
+    filter_type = "date"
+
+
+class ShortcutAndPerformanceMixin(WBCoreFilterMixin):
+    def __init__(self, shortcuts: list | None = None, performance_mode: bool = False, *args, **kwargs):
+        self.shortcuts = shortcuts
+        self.performance_mode = performance_mode
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        representation["performance_mode"] = self.performance_mode
+
+        if self.shortcuts:
+            representation["shortcuts"] = self.shortcuts
+
+        return representation, lookup_expr
+
+
+class DateRangeFilter(ShortcutAndPerformanceMixin, django_filters.Filter):
+    field_class = DateRangeField
+    filter_type = "daterange"
+    default_format = "%Y-%m-%d"
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("lookup_expr", "overlap")
+        super().__init__(*args, **kwargs)
+
+    def _get_default(self, *args):
+        default = super()._get_default(*args)
+        if default is not None:
+            lower = upper = None
+            if isinstance(default, tuple):
+                lower, upper = default
+
+                # if the default is a tuple of components, we need to convert them to string
+                if isinstance(lower, Component) and isinstance(upper, Component):
+                    return f"{lower},{upper}"
+
+            elif hasattr(default, "lower") and hasattr(default, "upper"):
+                lower, upper = default.lower, default.upper
+            default = f'{lower.strftime(self.default_format) if lower else ""},{upper.strftime(self.default_format) if upper else ""}'
+        return default
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        representation["lookup_expr"] = {"exact": self.field_name}
+        with suppress(KeyError):  # TODO frontend needs to support both exact and overlaps lookup
+            default = representation["default"].pop(self.lookup_expr)
+            representation["default"]["exact"] = default
+
+        return representation, lookup_expr
+
+    @classmethod
+    def base_date_range_filter_method(cls, queryset, field_name, value):
+        if value:
+            filters = {}
+            if value.lower:
+                filters[f"{field_name}__gte"] = value.lower
+            if value.upper:
+                filters[f"{field_name}__lte"] = value.upper
+            return queryset.filter(**filters)
+        return queryset
+
+
+class FinancialPerformanceDateRangeFilter(DateRangeFilter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(performance_mode=True, shortcuts=financial_performance_shortcuts, *args, **kwargs)
+
+
+class DateTimeRangeFilter(DateRangeFilter):
+    field_class = DateTimeRangeField
+    default_format = "%Y-%m-%dT%H:%M:%S%z"

wbcore/filters/fields/models.py

@@ -0,0 +1,113 @@
+from typing import Iterable
+
+import django_filters
+from django.core.exceptions import ObjectDoesNotExist
+from django.forms.widgets import SelectMultiple, TextInput
+from django.utils.http import urlencode
+from django_filters.fields import ModelChoiceField, ModelMultipleChoiceField
+from rest_framework.exceptions import ParseError
+from rest_framework.reverse import reverse
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class ModelChoiceFilterMixin(WBCoreFilterMixin):
+    MULTIPLE: bool = False
+
+    @classmethod
+    def get_parsed_values(cls, queryset, value_ids: int | str | Iterable[int]):
+        if isinstance(value_ids, str):
+            value_ids = value_ids.split(",")
+        elif isinstance(value_ids, int):
+            value_ids = [value_ids]
+
+        if isinstance(value_ids, list):
+            for value_id in value_ids:
+                try:
+                    yield {
+                        "value": value_id,
+                        "label": str(queryset.get(id=value_id)),
+                    }
+                except ObjectDoesNotExist:
+                    raise ParseError("Filter value invalid")
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        lookup_expr["input_properties"]["multiple"] = self.MULTIPLE
+
+        queryset = self.get_queryset(request)
+
+        if hasattr(queryset.model, "get_label_key"):
+            label_key = queryset.model.get_label_key()
+        else:
+            label_key = self.label_key
+
+        url = reverse(self.endpoint, request=request)
+        if self.filter_params:
+            if callable(self.filter_params):
+                url += f"?{urlencode(self.filter_params(request, view))}"
+            else:
+                url += f"?{urlencode(self.filter_params)}"
+        lookup_expr["input_properties"]["endpoint"] = {
+            "url": url,
+            "value_key": self.value_key,
+            "label_key": label_key,
+        }
+
+        if default_ids := lookup_expr["input_properties"].get("default", None):
+            values = self.get_parsed_values(queryset, default_ids)
+            lookup_expr["input_properties"]["default"] = list(values) if self.MULTIPLE else next(values)
+
+        if initial_ids := lookup_expr["input_properties"].get("initial", None):
+            values = self.get_parsed_values(queryset, initial_ids)
+            lookup_expr["input_properties"]["initial"] = list(values) if self.MULTIPLE else next(values)
+
+        return representation, lookup_expr
+
+
+class ModelMultipleChoiceFilter(ModelChoiceFilterMixin, django_filters.ModelMultipleChoiceFilter):
+    class SimpleModelMultipleChoiceField(ModelMultipleChoiceField):
+        """
+        field class that define a simple text input as widget (instead of select). This is necessary in order to use the
+        browsable api for model with a lot of items. Without it, the widget would load all the queryset option and will probably destroy the performance
+        """
+
+        class SimpleSelectMultiple(SelectMultiple):
+            template_name = "django/forms/widgets/text.html"
+
+        widget = SimpleSelectMultiple
+
+    MULTIPLE: bool = True
+    field_class = SimpleModelMultipleChoiceField
+    filter_type = "select"
+
+    def __init__(self, *args, **kwargs):
+        self.endpoint = kwargs.pop("endpoint", None)
+        self.filter_params = kwargs.pop("filter_params", None)
+        self.value_key = kwargs.pop("value_key", None)
+        self.label_key = kwargs.pop("label_key", None)
+
+        # TODO: This is monkeypatched. Make sure that the CSVWidget is set here and only here!
+        if "widget" not in kwargs:
+            kwargs["widget"] = django_filters.widgets.CSVWidget
+        super().__init__(*args, **kwargs)
+
+
+class ModelChoiceFilter(ModelChoiceFilterMixin, django_filters.ModelChoiceFilter):
+    class SimpleModelChoiceField(ModelChoiceField):
+        """
+        field class that define a simple text input as widget (instead of select). This is necessary in order to use the
+        browsable api for model with a lot of items. Without it, the widget would load all the queryset option and will probably destroy the performance
+        """
+
+        widget = TextInput
+
+    field_class = SimpleModelChoiceField
+    filter_type = "select"
+    MULTIPLE: bool = False
+
+    def __init__(self, *args, **kwargs):
+        self.endpoint = kwargs.pop("endpoint", None)
+        self.value_key = kwargs.pop("value_key", None)
+        self.filter_params = kwargs.pop("filter_params", None)
+        self.label_key = kwargs.pop("label_key", None)
+        super().__init__(*args, **kwargs)

wbcore/filters/fields/multiple_lookups.py

@@ -0,0 +1,19 @@
+from django_filters import Filter
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class MultipleLookupFilter(WBCoreFilterMixin):
+    def __init__(self, field_class, lookup_expr, **kwargs):
+        self.field_class = field_class
+        self.lookup_expr = lookup_expr
+        self.kwargs = kwargs
+
+    def get_filters(self, field_name) -> dict[str, Filter]:
+        filters = dict()
+        for lookup_expr in self.lookup_expr:
+            filters[f"{field_name}__{lookup_expr}"] = self.field_class(
+                lookup_expr=lookup_expr,
+                **self.kwargs,
+            )
+
+        return filters

wbcore/filters/fields/numbers.py

@@ -0,0 +1,46 @@
+import django_filters
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class NumberFilter(WBCoreFilterMixin, django_filters.NumberFilter):
+    filter_type = "number"
+
+    def __init__(self, precision: int = 0, percent: bool = False, delimiter=",", decimal_mark=".", *args, **kwargs):
+        self.precision = precision
+        self.percent = percent
+        self.delimiter = delimiter
+        self.decimal_mark = decimal_mark
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        representation["precision"] = self.precision
+        representation["delimiter"] = self.delimiter
+        representation["decimal_mark"] = self.decimal_mark
+        return representation, lookup_expr
+
+    def filter(self, qs, value):
+        if self.percent and value is not None:
+            value /= 100
+        return super().filter(qs, value)
+
+
+class YearFilter(NumberFilter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.delimiter = ""
+        self.decimal_mark = "."
+
+
+class RangeSelectFilter(NumberFilter):
+    filter_type = "rangeselect"
+
+    def __init__(self, precision=2, *args, **kwargs):
+        self.precision = precision
+        self.color = kwargs.pop("color", "rgb(133, 144, 162)")
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        lookup_expr["input_properties"]["color"] = self.color
+        return representation, lookup_expr

wbcore/filters/fields/text.py

@@ -0,0 +1,6 @@
+import django_filters
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class CharFilter(WBCoreFilterMixin, django_filters.CharFilter):
+    filter_type = "text"

wbcore/filters/filterset.py

@@ -0,0 +1,217 @@
+import logging
+
+from django.contrib.postgres.fields import DateRangeField, DateTimeRangeField
+from django.db import models
+from django.db.models.fields.related import ManyToManyRel, ManyToOneRel, OneToOneRel
+from django_filters.filterset import FilterSetMetaclass, remote_queryset, settings
+from django_filters.rest_framework import FilterSet as DjangoFilterSet
+from wbcore.filters import fields
+from wbcore.filters.fields.multiple_lookups import MultipleLookupFilter
+from wbcore.signals.filters import add_filters
+
+from .utils import check_required_filters
+
+logger = logging.getLogger(__name__)
+
+
+def _is_number(field):
+    return (
+        issubclass(field.__class__, models.DecimalField)
+        or issubclass(field.__class__, models.FloatField)
+        or issubclass(field.__class__, models.IntegerField)
+    )
+
+
+class CustomFilterSetMetaClass(FilterSetMetaclass):
+    def __new__(cls, name, bases, attrs):
+        new_class = super().__new__(cls, name, bases, attrs)
+        if _meta := getattr(new_class, "Meta", None):
+            for parent_field_name, child_fields in getattr(_meta, "flatten_fields", dict()).items():
+                if remote_field := getattr(_meta.model._meta.get_field(parent_field_name), "remote_field", None):
+                    for child_field_name, lookup_exps in child_fields.items():
+                        child_field = remote_field.model._meta.get_field(child_field_name)
+                        if _is_number(child_field):
+                            nested_field_name = f"{parent_field_name}__{child_field_name}"
+                            for lookup_exp in lookup_exps:
+                                new_class.base_filters[f"{nested_field_name}__{lookup_exp}"] = fields.NumberFilter(
+                                    field_name=nested_field_name,
+                                    lookup_expr=lookup_exp,
+                                    precision=2,
+                                    label=child_field.verbose_name,
+                                )
+
+                        # TODO extend with other filter fields type
+        return new_class
+
+    @classmethod
+    def get_declared_filters(cls, bases, attrs):
+        filters = super().get_declared_filters(bases, attrs)
+
+        multi_filters: list[tuple[str, MultipleLookupFilter]] = [
+            (filter_name, attrs.pop(filter_name))
+            for filter_name, obj in list(attrs.items())
+            if isinstance(obj, MultipleLookupFilter)
+        ]
+
+        for field_name, filter in multi_filters:
+            filters |= filter.get_filters(field_name)
+
+        return filters
+
+
+class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
+    FILTER_DEFAULTS = {
+        models.BooleanField: {"filter_class": fields.BooleanFilter},
+        models.NullBooleanField: {"filter_class": fields.BooleanFilter},
+        models.CharField: {"filter_class": fields.CharFilter},
+        models.TextField: {"filter_class": fields.CharFilter},
+        models.SlugField: {"filter_class": fields.CharFilter},
+        models.EmailField: {"filter_class": fields.CharFilter},
+        models.FilePathField: {"filter_class": fields.CharFilter},
+        models.UUIDField: {"filter_class": fields.CharFilter},
+        models.URLField: {"filter_class": fields.CharFilter},
+        models.GenericIPAddressField: {"filter_class": fields.CharFilter},
+        models.CommaSeparatedIntegerField: {"filter_class": fields.CharFilter},
+        models.DateField: {"filter_class": fields.DateFilter},
+        models.DateTimeField: {"filter_class": fields.DateTimeFilter},
+        models.TimeField: {"filter_class": fields.TimeFilter},
+        models.IntegerField: {"filter_class": fields.NumberFilter},
+        models.FloatField: {"filter_class": fields.NumberFilter},
+        models.DecimalField: {"filter_class": fields.NumberFilter},
+        DateTimeRangeField: {"filter_class": fields.DateTimeRangeFilter},
+        DateRangeField: {"filter_class": fields.DateRangeFilter},
+        # models.DurationField: {"filter_class": DurationFilter},
+        # models.SmallIntegerField: {"filter_class": NumberFilter},
+        # models.AutoField: {"filter_class": NumberFilter},
+        # models.PositiveIntegerField: {"filter_class": NumberFilter},
+        # models.PositiveSmallIntegerField: {"filter_class": NumberFilter},
+        # models.UUIDField: {"filter_class": UUIDFilter},
+        # Forward relationships
+        models.OneToOneField: {
+            "filter_class": fields.ModelChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+                "to_field_name": f.remote_field.field_name,
+                "null_label": settings.NULL_CHOICE_LABEL if f.null else None,
+            },
+        },
+        models.ForeignKey: {
+            "filter_class": fields.ModelChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+                "to_field_name": f.remote_field.field_name,
+                "null_label": settings.NULL_CHOICE_LABEL if f.null else None,
+            },
+        },
+        models.ManyToManyField: {
+            "filter_class": fields.ModelMultipleChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+            },
+        },
+        # Reverse relationships
+        OneToOneRel: {
+            "filter_class": fields.ModelChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+                "null_label": settings.NULL_CHOICE_LABEL if f.null else None,
+            },
+        },
+        ManyToOneRel: {
+            "filter_class": fields.ModelMultipleChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+            },
+        },
+        ManyToManyRel: {
+            "filter_class": fields.ModelMultipleChoiceFilter,
+            "extra": lambda f: {
+                "queryset": remote_queryset(f),
+                "endpoint": f.related_model.get_representation_endpoint(),
+                "value_key": f.related_model.get_representation_value_key(),
+                "label_key": f.related_model.get_representation_label_key(),
+            },
+        },
+    }
+
+    @classmethod
+    def filter_class_for_remote_filter(cls):
+        if hasattr(cls, "get_filter_class_for_remote_filter") and callable(cls.get_filter_class_for_remote_filter()):
+            return cls.get_filter_class_for_remote_filter()
+        return cls
+
+    def __init__(self, data=None, queryset=None, *, request=None, prefix=None, view=None):
+        super().__init__(data=data, queryset=queryset, request=request, prefix=prefix)
+        remote_filters = add_filters.send(sender=self.filter_class_for_remote_filter(), request=request)
+        self.view = view
+        for _, res in remote_filters:
+            if res:
+                for remote_filter_key, remote_filter in res.items():
+                    setattr(remote_filter, "column_field_name", remote_filter_key)
+                    self.filters[remote_filter_key] = remote_filter
+
+    @classmethod
+    def filter_for_lookup(cls, field, lookup_type):
+        if lookup_type == "exact" and getattr(field, "choices", None):
+            filter_class, params = fields.ChoiceFilter, {"choices": field.choices}
+        else:
+            filter_class, params = super().filter_for_lookup(field, lookup_type)
+
+        # Check if it is a decimal field:
+        if hasattr(field, "decimal_places"):
+            params["precision"] = field.decimal_places
+
+        if hasattr(field, "verbose_name"):
+            params["label"] = field.verbose_name
+
+        return filter_class, params
+
+    @classmethod
+    def get_dependency_map(cls):
+        if hasattr(cls, "Meta"):
+            yield from getattr(cls.Meta, "dependency_map", dict()).items()
+
+    @classmethod
+    def get_filters(cls):
+        filters = super().get_filters()
+        remote_filters = add_filters.send(sender=cls.filter_class_for_remote_filter())
+        for _, res in remote_filters:
+            if res:
+                for remote_filter_key, remote_filter in res.items():
+                    setattr(remote_filter, "column_field_name", remote_filter_key)
+                    filters[remote_filter_key] = remote_filter
+
+        for field, help_text in getattr(cls, "help_texts", {}).items():
+            filters[field].help_text = help_text
+
+        # Get dependency map specified in Meta and append the argument accordingly
+        for field, values in cls.get_dependency_map():
+            for value in values:
+                filters[field].depends_on.append({"field": value, "options": {}})
+        return filters
+
+    def extract_required_field_labels(self):
+        return [label for label, filter in self.base_filters.items() if getattr(filter, "required", False)]
+
+    def filter_queryset(self, queryset):
+        queryset = super().filter_queryset(queryset)
+        check_required_filters(self.request, self.view, self)
+        return queryset
+
+    def fake_filter(self, queryset, name, value):
+        return queryset

wbcore/filters/lookups.py

@@ -0,0 +1,41 @@
+LOOKUP_EXPRESSION_MAPPING = {
+    "exact": ("Equals", "="),
+    "iexact": ("Equals (case-insensitive)", "≈"),
+    "contains": ("Contains", "[=]"),
+    "icontains": ("Contains (case-insensitive)", "[≈]"),
+    "startswith": ("Starts with", "=]"),
+    "istartswith": ("Starts with (case-insensitive)", "≈]"),
+    "endswith": ("Ends with", "[="),
+    "iendswith": ("Ends with (case-insensitive)", "[≈"),
+    "regex": ("Regex", "r="),
+    "iregex": ("Regex (case-insensitive)", "r≈"),
+    "in": ("In", "∈"),
+    "gte": ("Greater than or Equal", ">="),
+    "lte": ("Less than or Equal", "<="),
+    "gt": ("Greater than", ">"),
+    "lt": ("Less than", "<"),
+    "overlap": ("Overlaps", "="),
+    "isnull": ("Is Null", "Is Null"),
+}
+
+
+ALL_TEXT_LOOKUPS = [
+    "exact",
+    "iexact",
+    "contains",
+    "icontains",
+    "startswith",
+    "istartswith",
+    "endswith",
+    "iendswith",
+    "regex",
+    "iregex",
+]
+
+
+def get_lookup_label(lookup_expr: str) -> str:
+    return LOOKUP_EXPRESSION_MAPPING.get(lookup_expr, (lookup_expr, lookup_expr))[0]
+
+
+def get_lookup_icon(lookup_expr: str) -> str:
+    return LOOKUP_EXPRESSION_MAPPING.get(lookup_expr, (lookup_expr, lookup_expr))[1]

wbcore/filters/mixins.py

@@ -0,0 +1,112 @@
+from contextlib import suppress
+
+from django_filters.utils import get_model_field
+
+from .lookups import get_lookup_icon, get_lookup_label
+
+
+class WBCoreFilterMixin:
+    def __init__(self, *args, **kwargs):
+        self.default = kwargs.pop("default", None)
+        self.initial = kwargs.pop("initial", None)
+        self.required = kwargs.pop("required", False)
+        self.clearable = kwargs.pop("clearable", True)  # TODO: Take away
+        self.hidden = kwargs.pop("hidden", False)
+        self.column_field_name = kwargs.pop("column_field_name", None)
+        self.help_text = kwargs.pop("help_text", None)
+        self.allow_empty_default = kwargs.pop("allow_empty_default", False)
+        self.label_format = kwargs.pop(
+            "label_format",
+            getattr(self, "default_label_format", "{{field_label}} {{operation_icon}}  {{value_label}}"),
+        )
+        self.lookup_icon = kwargs.pop("lookup_icon", None)
+        self.lookup_label = kwargs.pop("lookup_label", None)
+        self.depends_on = kwargs.pop("depends_on", [])
+        super().__init__(*args, **kwargs)
+
+    @property
+    def key(self):
+        return self.column_field_name if self.column_field_name else self.field_name
+
+    def get_label(self):
+        if self.label is None:  # if label is not provided we gracefully convert the field name into capitalized label
+            return self.field_name.replace("_", " ").title()
+        else:
+            return self.label
+
+    def _get_default(self, request, view):
+        # We consider the case where default is a boolean with value False.
+        if callable(self.default):
+            default = self.default(self, request, view)
+        elif (
+            isinstance(self.default, str)
+            and (callable_default := getattr(self, self.default, None))
+            and (callable(callable_default))
+        ):
+            default = callable_default(self, request, view)
+        else:
+            default = self.default
+
+        return default
+
+    def _validate_default_with_request(self, default, request, name):
+        if request_default := request.GET.get(name):
+            return request_default
+        return default
+
+    def get_help_text(self) -> str:
+        if self.help_text:
+            return self.help_text
+        with suppress(AttributeError):
+            field = get_model_field(self.parent._meta.model, self.field_name)
+            if field.help_text:
+                return field.help_text
+        if self.label:
+            return "Filter by " + self.label
+
+    def get_representation(self, request, name, view):
+        if self.hidden:
+            return {}
+
+        representation = {
+            "key": self.key,
+            "label_format": self.label_format,
+            "label": self.get_label(),
+            "help_text": self.get_help_text(),
+        }
+        lookup_expr = {
+            "label": get_lookup_label(self.lookup_expr) if self.lookup_label is None else self.lookup_label,
+            "icon": get_lookup_icon(self.lookup_expr) if self.lookup_icon is None else self.lookup_icon,
+            "key": name,
+            "hidden": self.hidden,
+            "input_properties": {
+                "type": self.filter_type,
+            },
+        }
+        default = self._get_default(request, view)
+        if default is not None or self.allow_empty_default:
+            lookup_expr["input_properties"]["default"] = default
+
+        initial = None
+        if callable(self.initial):
+            initial = self.initial(self, request, view)
+        elif (
+            isinstance(self.initial, str)
+            and (callable_initial := getattr(self, self.initial, None))
+            and (callable(callable_initial))
+        ):
+            initial = callable_initial(self, request, view)
+        else:
+            initial = self.initial
+
+        if _initial := self._validate_default_with_request(initial, request, name):
+            initial = _initial
+
+        if initial is not None:
+            lookup_expr["input_properties"]["initial"] = initial
+
+        if self.required:
+            lookup_expr["input_properties"]["required"] = True
+            # assert representation["default"] != {}, "If a filter is required, it needs at least one default value"
+        representation["depends_on"] = self.depends_on
+        return representation, lookup_expr

wbcore/filters/utils.py

@@ -0,0 +1,21 @@
+import os
+
+from django_filters.constants import EMPTY_VALUES
+
+from .defaults import RequiredFilterMissing
+
+
+def check_required_filters(request, view, filter):
+    if "PYTEST_CURRENT_TEST" not in os.environ and getattr(view, "action", "list") == "list":
+        errors = []
+        for required_field in [
+            label for label, filter in filter.base_filters.items() if getattr(filter, "required", False)
+        ]:
+            if filter.form.cleaned_data.get(required_field, None) in EMPTY_VALUES:
+                errors.append(required_field)
+        if errors:
+            raise RequiredFilterMissing(
+                detail={
+                    "filter_errors": {field: ["This filter is required. Please specify a value"] for field in errors},
+                }
+            )