wbcore 1.54.10__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/contrib/io/tests/test_backends.py

@@ -117,7 +117,7 @@ class TestBackend:
         with sftpserver.serve_content(VFS):
             import_credential = import_credential_factory.create(
                 username="user",
-                password="password",
+                password="password",  # noqa
                 additional_resources={
                     "host": sftpserver.host,
                     "port": sftpserver.port,

wbcore/contrib/io/tests/test_imports.py

@@ -128,7 +128,7 @@ class TestImportSourceModel:
         assert model.name != comparison_model.name
 
     def test_process_wrongly_formatted_import_data(self, handler, import_source):
-        with pytest.raises(Exception):
+        with pytest.raises(KeyError):
             handler.process(dict(a=1, b="b"))
 
     def test_process_basic(self, handler, import_source, parser_handler_factory):

wbcore/contrib/io/viewset_mixins.py

@@ -51,8 +51,8 @@ class ImportExportDRFMixin(ImportExportMixin):
     def model(self):
         try:
             return getattr(self.queryset, "model", None)
-        except AttributeError:
-            raise ParseError("Malformed Queryset")
+        except AttributeError as e:
+            raise ParseError("Malformed Queryset") from e
 
     @cached_property
     def opts(self):
@@ -84,12 +84,12 @@ class ImportExportDRFMixin(ImportExportMixin):
         with suppress(AttributeError, AssertionError):
             # we have to mocky patch the action to be "list" because sometime we differentiate the serializer to use
             previous_action = getattr(self, "action", "list")
-            setattr(self, "action", "list")
+            self.action = "list"
             serializer_class = getattr(
                 self, "serializer_class", self.get_serializer_class()
             )  # we prioritize the default serializer class attribute
             resource_kwargs["serializer_class_path"] = serializer_class.__module__ + "." + serializer_class.__name__
-            setattr(self, "action", previous_action)
+            self.action = previous_action
         return resource_kwargs
 
     def _get_data_for_export(self, request, queryset, *args, **kwargs) -> tablib.Dataset:

wbcore/contrib/notifications/dispatch.py

@@ -1,5 +1,6 @@
 from typing import Iterable
 
+from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.db import transaction
@@ -43,22 +44,32 @@ def send_notification(
     if isinstance(users, User):
         users = [users]
     for user in users:
-        notification_user_settings = NotificationTypeSetting.objects.filter(
-            notification_type__code=code,
-            user=user,
-        )
-        if user.is_active and notification_user_settings.exists():
+        notification_type = NotificationType.objects.get(code=code)
+        if (
+            user.is_active
+            and NotificationTypeSetting.objects.filter(notification_type=notification_type, user=user).exists()
+        ):
             if not endpoint:
                 endpoint = reverse(reverse_name, reverse_args, reverse_kwargs) if reverse_name else None
             notification = Notification.objects.create(
                 title=title,
                 body=body,
                 user=user,
-                notification_type=NotificationType.objects.get(code=code),
+                notification_type=notification_type,
                 endpoint=endpoint,
                 sent=timezone.now(),
             )
-            transaction.on_commit(lambda: send_notification_task.delay(notification.pk))
+            transaction.on_commit(
+                lambda notification_pk=notification.pk: send_notification_task.delay(notification_pk)
+            )
+
+
+@shared_task()
+def send_notification_as_task(code, title, body, user_id, **kwargs):
+    if not isinstance(user_id, list):
+        user_id = [user_id]
+    user = User.objects.filter(id__in=user_id)
+    send_notification(code, title, body, user, **kwargs)
 
 
 @receiver(handle_widget_sharing)

wbcore/contrib/pandas/filterset.py

@@ -16,12 +16,13 @@ class PandasFilterSetMixin:
                 queryset = self.filters[name].filter(queryset, value)
             except FieldError:
                 pass
-            assert isinstance(queryset, models.QuerySet), (
-                "Expected '%s.%s' to return a QuerySet, but got a %s instead."
-                % (
-                    type(self).__name__,
-                    name,
-                    type(queryset).__name__,
+            if not isinstance(queryset, models.QuerySet):
+                raise AssertionError(
+                    "Expected '%s.%s' to return a QuerySet, but got a %s instead."
+                    % (
+                        type(self).__name__,
+                        name,
+                        type(queryset).__name__,
+                    )
                 )
-            )
         return queryset

wbcore/contrib/pandas/views.py

@@ -40,8 +40,8 @@ class PandasMixin(CacheMixin):
     @cached_property
     def df(self) -> pd.DataFrame:
         if not hasattr(self, "_df"):
-            setattr(self, "_df", self._get_dataframe())
-        return getattr(self, "_df")
+            self._df = self._get_dataframe()
+        return self._df
 
     # BASIC DATAFRAME GENERATION FRAMEWORK METHODS
     def filter_queryset(self, queryset: QuerySet) -> QuerySet:
@@ -80,11 +80,13 @@ class PandasMixin(CacheMixin):
             )
 
     def get_queryset(self):
-        assert hasattr(self, "queryset"), "Either specify a queryset or implement the get_queryset method."
+        if not hasattr(self, "queryset"):
+            raise AssertionError("Either specify a queryset or implement the get_queryset method.")
         return self.queryset
 
     def get_dataframe(self, request, queryset, **kwargs):
-        assert self.get_pandas_fields(request), "No pandas_fields specified"
+        if not self.get_pandas_fields(request):
+            raise AssertionError("No pandas_fields specified")
         return pd.DataFrame(queryset.values(*self.get_pandas_fields(request).to_dict().keys()))
 
     def manipulate_dataframe(self, df):
@@ -110,7 +112,7 @@ class PandasMixin(CacheMixin):
             df = pd.DataFrame(
                 columns=[field.key for field in self.get_pandas_fields(self.request).fields]
             )  # if queryset is empty, we make sure the returning df contains all the columns to avoid keyerrors exception
-        setattr(self, "_df", df)
+        self._df = df
         df = self.filter_dataframe(df, **kwargs)
         return df
 

wbcore/contrib/tags/models/tags.py

@@ -17,7 +17,7 @@ class ManagedMixin(models.Model):
         abstract = True
 
 
-class Tag(ManagedMixin, ComplexToStringMixin, WBModel):
+class Tag(ComplexToStringMixin, ManagedMixin):
     title = models.CharField(max_length=255)
 
     slug = models.CharField(max_length=255, null=True, blank=True)
@@ -35,6 +35,9 @@ class Tag(ManagedMixin, ComplexToStringMixin, WBModel):
         verbose_name = "Tag"
         verbose_name_plural = "Tags"
 
+    def __str__(self) -> str:
+        return super().__str__()
+
     @classmethod
     def get_endpoint_basename(cls):
         return "wbcore:tags:tag"

wbcore/contrib/workflow/factories/display.py

@@ -12,9 +12,9 @@ fake = Faker()
 def _generate_grid_areas() -> list[list[str]]:
     outer_list = []
     inner_list_length = random.randint(1, 5)
-    for k in range(random.randint(1, 5)):
+    for _ in range(random.randint(1, 5)):
         inner_list = []
-        for i in range(inner_list_length):
+        for _ in range(inner_list_length):
             inner_list.append(random.choice(PersonModelSerializer.Meta.fields))
         outer_list.append(inner_list)
     return outer_list

wbcore/contrib/workflow/models/data.py

@@ -28,7 +28,10 @@ class Data(WBModel):
                 serializers.DateTimeField(),
                 serializers.BooleanField(),
             ]
-            return {data_type: serializer_field for data_type, serializer_field in zip(cls, serializer_fields)}
+            return {
+                data_type: serializer_field
+                for data_type, serializer_field in zip(cls, serializer_fields, strict=False)
+            }
 
         @classmethod
         def get_cast_mapping(cls) -> dict:
@@ -39,7 +42,7 @@ class Data(WBModel):
                 datetime.strptime,
                 bool,
             ]
-            return {data_type: cast_callable for data_type, cast_callable in zip(cls, cast_callables)}
+            return {data_type: cast_callable for data_type, cast_callable in zip(cls, cast_callables, strict=False)}
 
     workflow = models.ForeignKey(
         to="workflow.Workflow",
@@ -176,8 +179,8 @@ class Data(WBModel):
                 format_str = "%d.%m.%Y %H:%M:%S"
             try:
                 casted_object = data_object.strftime(format_str)
-            except AttributeError:
-                raise ValueError(gettext("Date(time) type selected but no date(time) object provided!"))
+            except AttributeError as e:
+                raise ValueError(gettext("Date(time) type selected but no date(time) object provided!")) from e
 
         elif data_type == cls.DataType.BOOL:
             if data_object is True:

wbcore/contrib/workflow/models/process.py

@@ -27,7 +27,7 @@ class Process(WBModel):
                 WBColor.GREEN_LIGHT.value,
                 WBColor.RED_LIGHT.value,
             ]
-            return [choice for choice in zip(cls, colors)]
+            return [choice for choice in zip(cls, colors, strict=False)]
 
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False, verbose_name=_("UUID"))
     workflow = models.ForeignKey(
@@ -124,7 +124,7 @@ class ProcessStep(WBModel):
                 WBColor.RED_LIGHT.value,
                 WBColor.GREY.value,
             ]
-            return [choice for choice in zip(cls, colors)]
+            return [choice for choice in zip(cls, colors, strict=False)]
 
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False, verbose_name=_("UUID"))
     process = models.ForeignKey(

wbcore/contrib/workflow/serializers/data.py

@@ -43,7 +43,7 @@ class DataModelSerializer(wb_serializers.ModelSerializer):
             if data_type:
                 try:
                     Data.cast_value_to_datatype(data_type, default)
-                except ValueError:
+                except ValueError as e:
                     if data_type == Data.DataType.DATE:
                         raise ValidationError(
                             {
@@ -51,7 +51,7 @@ class DataModelSerializer(wb_serializers.ModelSerializer):
                                     "Invalid default value for this data type. Please use a date formatted to 'day.month.year'."
                                 )
                             }
-                        )
+                        ) from None
                     elif data_type == Data.DataType.DATETIME:
                         raise ValidationError(
                             {
@@ -59,8 +59,8 @@ class DataModelSerializer(wb_serializers.ModelSerializer):
                                     "Invalid default value for this data type. Please use a datetime formatted to 'day.month.year hour:minute:second' in the 24h format."
                                 )
                             }
-                        )
-                    raise ValidationError({"default": _("Invalid default value for this data type.")})
+                        ) from None
+                    raise ValidationError({"default": _("Invalid default value for this data type.")}) from e
 
         return data
 
@@ -99,7 +99,7 @@ class DataValueModelSerializer(wb_serializers.ModelSerializer):
         if data_obj and value:
             try:
                 Data.cast_value_to_datatype(data_obj.data_type, value)
-            except ValueError:
+            except ValueError as e:
                 if data_obj.data_type == Data.DataType.DATE:
                     raise ValidationError(
                         {
@@ -107,7 +107,7 @@ class DataValueModelSerializer(wb_serializers.ModelSerializer):
                                 "Invalid value for this data type. Please use a date formatted to 'day.month.year'."
                             )
                         }
-                    )
+                    ) from None
                 elif data_obj.data_type == Data.DataType.DATETIME:
                     raise ValidationError(
                         {
@@ -115,8 +115,8 @@ class DataValueModelSerializer(wb_serializers.ModelSerializer):
                                 "Invalid value for this data type. Please use a datetime formatted to 'day.month.year hour:minute:second' in the 24h format."
                             )
                         }
-                    )
-                raise ValidationError({"value": _("Invalid value for this data type.")})
+                    ) from None
+                raise ValidationError({"value": _("Invalid value for this data type.")}) from e
 
         return data
 

wbcore/contrib/workflow/tests/test_models/test_condition.py

@@ -10,7 +10,7 @@ class TestCondition:
     def test_errors_satisfied_not_called(self, condition_factory):
         condition = condition_factory()
         with pytest.raises(ValueError):
-            condition.errors
+            assert condition.errors == []
 
     def test_errors(self, condition_factory):
         condition = condition_factory()

wbcore/contrib/workflow/workflows/assignees.py

@@ -59,14 +59,14 @@ def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
             # We redistribute each occurrence number between all of the other list items to increase their probability
             redistributed_list: list[int] = [0 for i in range(group_user_count)]
             for index, elem in enumerate(number_of_past_assignee_occurrences):
-                for index2, elem2 in enumerate(redistributed_list):
+                for index2 in range(len(redistributed_list)):
                     if not index2 == index:
                         redistributed_list[index2] += elem / (group_user_count - 1) if elem else 0
             # Transform the list of absolute values into percentages
             new_weights: list[float] = [x / sum(redistributed_list) for x in redistributed_list]
-            new_assignee: User = choices(group_member_list, weights=new_weights)[0]
+            new_assignee: User = choices(group_member_list, weights=new_weights)[0]  # noqa
         else:
-            new_assignee: User = choices(group_member_list)[0]
+            new_assignee: User = choices(group_member_list)[0]  # noqa
         return new_assignee
 
     process_step.step.get_casted_step().set_failed(
@@ -79,7 +79,7 @@ def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
 @register_assignee("Random Group Member")
 def random_group_member(process_step: ProcessStep, **kwargs) -> User | None:
     if (group := process_step.group) and group.user_set.exists():
-        return group.user_set.all()[randint(0, group.user_set.count() - 1)]
+        return group.user_set.all()[randint(0, group.user_set.count() - 1)]  # noqa
 
     process_step.step.get_casted_step().set_failed(
         process_step,

wbcore/dynamic_preferences_registry.py

@@ -5,6 +5,7 @@ from dynamic_preferences.types import IntegerPreference, StringPreference
 from dynamic_preferences.users.registries import user_preferences_registry
 
 from wbcore.contrib.dynamic_preferences.types import ChoicePreference, LanguageChoicePreference
+from wbcore.utils.date import get_timezone_choices
 
 wbcore = Section("wbcore")
 
@@ -50,8 +51,21 @@ class LanguagePreference(LanguageChoicePreference):
 
 
 @user_preferences_registry.register
-class DateFormatPreference(ChoicePreference):
+class TimezonePreference(ChoicePreference):
     weight = 0
+    # Value is a IANA timezone name
+    choices = get_timezone_choices()
+    section = wbcore
+    name = "timezone"
+    default = "Europe/Berlin"
+
+    verbose_name = _("Timezone")
+    help_text = _("Pick the timezone in which you want the workbench's dates to be displayed in.")
+
+
+@user_preferences_registry.register
+class DateFormatPreference(ChoicePreference):
+    weight = 1
     choices = [
         ("DD.MM.YYYY", "13.04.2007"),
         ("DD/MM/YYYY", "13/04/2007"),
@@ -77,7 +91,7 @@ class DateFormatPreference(ChoicePreference):
 
 @user_preferences_registry.register
 class TimeFormatPreference(ChoicePreference):
-    weight = 1
+    weight = 2
     choices = [
         ("HH:mm", "14:05"),
         ("hh:mm", "02:05"),
@@ -100,18 +114,18 @@ class TimeFormatPreference(ChoicePreference):
 
 @user_preferences_registry.register
 class NumberFormatPreference(ChoicePreference):
-    weight = 2
-    # Value is a BCP 47 language tag
+    weight = 3
+    # Value is a BCP 47 region subtag
     choices = [
-        ("en-US", "1,234,567.89"),
-        ("fr-FR", "1\u202f234\u202f567,89"),
-        ("de-DE", "1.234.567,89"),
-        ("de-CH", "1’234’567.89"),
+        ("US", "1,234,567.89"),
+        ("FR", "1\u202f234\u202f567,89"),
+        ("DE", "1.234.567,89"),
+        ("CH", "1’234’567.89"),
     ]
 
     section = wbcore
     name = "number_format"
-    default = "en-US"
+    default = "US"
 
     verbose_name = _("Number Format")
     help_text = _("Choose how you want numbers to appear throughout the Workbench.")

wbcore/enums.py

@@ -39,7 +39,8 @@ class Unit(Enum):
         return (float(_value), self.value)
 
     def unit(self, _value: Union[float, str, int]):
-        assert isinstance(_value, (float, str, int)), "_value needs to be one of str, float or int"
+        if not isinstance(_value, (float, str, int)):
+            raise AssertionError("_value needs to be one of str, float or int")
 
         return f"{float(_value)}{self.value}"
 

wbcore/filters/fields/content_type.py

@@ -29,16 +29,17 @@ class MultipleChoiceContentTypeFilter(WBCoreFilterMixin, django_filters.Filter):
     def filter(self, qs, value):
         if value in EMPTY_VALUES:
             return qs
-
         conditions = [
             (
                 Q(**{self.content_type_label: ContentType.objects.get_for_model(val)})
                 & Q(**{self.object_id_label: val.id})
             )
-            for val in value
+            for val in filter(None, value)
         ]
-        qs = qs.filter(reduce(operator.or_, conditions))
-
+        if conditions:
+            qs = qs.filter(reduce(operator.or_, conditions))
+        else:
+            qs = qs.none()
         if self.distinct:
             qs = qs.distinct()
         return qs

wbcore/filters/fields/datetime.py

@@ -1,6 +1,9 @@
 from contextlib import suppress
 
 import django_filters
+from django.contrib.postgres.fields import RangeField
+from django_filters.constants import EMPTY_VALUES
+from django_filters.utils import get_model_field
 
 from wbcore.filters.mixins import WBCoreFilterMixin
 from wbcore.forms import DateRangeField, DateTimeRangeField
@@ -45,6 +48,13 @@ class DateRangeFilter(ShortcutAndPerformanceMixin, django_filters.Filter):
         kwargs.setdefault("lookup_expr", "overlap")
         super().__init__(*args, **kwargs)
 
+    @property
+    def is_range(self) -> bool:
+        if hasattr(self, "model"):
+            field = get_model_field(self.model, self.field_name)
+            return issubclass(field.__class__, RangeField)
+        return False
+
     def _get_initial(self, *args):
         initial = super()._get_initial(*args)
         if initial is not None:
@@ -70,23 +80,38 @@ class DateRangeFilter(ShortcutAndPerformanceMixin, django_filters.Filter):
 
         return representation, lookup_expr
 
-    @classmethod
-    def base_date_range_filter_method(cls, queryset, field_name, value):
+    def filter(self, qs, value):
+        if value in EMPTY_VALUES:
+            return qs
         if value:
+            lower, upper = value.lower, value.upper
             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
+            is_field_range = self.is_range
+            if lower:
+                if is_field_range:
+                    filters[f"{self.field_name}__startswith__gte"] = lower
+                else:
+                    filters[f"{self.field_name}__gte"] = lower
+
+            if upper:
+                if is_field_range:
+                    filters[f"{self.field_name}__endswith__lte"] = upper
+                else:
+                    filters[f"{self.field_name}__lte"] = upper
+
+            if self.exclude:
+                qs = qs.exclude(**filters)
+            else:
+                qs = qs.filter(**filters)
+        return qs
 
 
 class FinancialPerformanceDateRangeFilter(DateRangeFilter):
     def __init__(self, *args, **kwargs):
-        super().__init__(performance_mode=True, shortcuts=financial_performance_shortcuts, *args, **kwargs)
+        super().__init__(*args, performance_mode=True, shortcuts=financial_performance_shortcuts, **kwargs)
 
 
 class DateTimeRangeFilter(DateRangeFilter):
     field_class = DateTimeRangeField
     initial_format = "%Y-%m-%dT%H:%M:%S%z"
+    filter_type = "datetimerange"

wbcore/filters/fields/models.py

@@ -33,8 +33,8 @@ class ModelChoiceFilterMixin(WBCoreFilterMixin):
                         "value": value_id,
                         "label": str(queryset.get(id=value_id)),
                     }
-                except ObjectDoesNotExist:
-                    raise ParseError("Filter value invalid")
+                except ObjectDoesNotExist as e:
+                    raise ParseError("Filter value invalid") from e
 
     def get_representation(self, request, name, view):
         representation, lookup_expr = super().get_representation(request, name, view)

wbcore/filters/filterset.py

@@ -1,5 +1,7 @@
 import logging
+from collections import OrderedDict
 from contextlib import suppress
+from copy import copy
 
 from django.contrib.postgres.fields import DateRangeField, DateTimeRangeField
 from django.core.exceptions import FieldError
@@ -28,8 +30,8 @@ def _is_number(field):
 
 
 class CustomFilterSetMetaClass(FilterSetMetaclass):
-    def __new__(cls, name, bases, attrs):
-        new_class = super().__new__(cls, name, bases, attrs)
+    def __new__(cls, *args, **kwargs):
+        new_class = super().__new__(cls, *args, **kwargs)
         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):
@@ -65,6 +67,7 @@ class CustomFilterSetMetaClass(FilterSetMetaclass):
 
 
 class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
+    DEFAULT_EXCLUDE_FILTER_LOOKUP: str = "exclude"
     FILTER_DEFAULTS = {
         models.BooleanField: {"filter_class": fields.BooleanFilter},
         models.NullBooleanField: {"filter_class": fields.BooleanFilter},
@@ -168,7 +171,7 @@ class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
         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)
+                    remote_filter.column_field_name = remote_filter_key
                     self.filters[remote_filter_key] = remote_filter
 
     @classmethod
@@ -196,12 +199,12 @@ class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
 
     @classmethod
     def get_filters(cls):
-        filters = super().get_filters()
+        filters = dict(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)
+                    remote_filter.column_field_name = remote_filter_key
                     filters[remote_filter_key] = remote_filter
 
         for field, help_text in getattr(cls, "help_texts", {}).items():
@@ -211,7 +214,20 @@ class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
         for field, values in cls.get_dependency_map():
             for value in values:
                 filters[field].depends_on.append({"field": value, "options": {}})
-        return filters
+
+        excluding_fields = {}
+        for name, field in filters.items():
+            # if allow_exclude is true, we add a copy of the field with the parameter exclude=True
+            # (to use `exclude` queryset method instead of `filter`) and add this with the suffix __{cls.DEFAULT_EXCLUDE_FILTER_LOOKUP}
+            if field.allow_exclude:
+                excluding_field = copy(field)
+                excluding_field.exclude = True
+                excluding_field.excluded_filter = True
+                excluding_field.hidden = True
+                excluding_field.required = False
+                excluding_fields[f"{name}__{cls.DEFAULT_EXCLUDE_FILTER_LOOKUP}"] = excluding_field
+        filters.update(excluding_fields)
+        return OrderedDict(filters)
 
     def extract_required_field_labels(self):
         return [label for label, filter in self.base_filters.items() if getattr(filter, "required", False)]

wbcore/filters/mixins.py

@@ -30,6 +30,10 @@ class WBCoreFilterMixin:
             "label_format",
             getattr(self, "default_label_format", "{{field_label}} {{operation_icon}}  {{value_label}}"),
         )
+        self.allow_exclude = kwargs.pop(
+            "allow_exclude", kwargs.get("method") is None
+        )  # if False, we will not automatically add a similar filter "opposite" filter
+        self.excluded_filter = kwargs.pop("excluded_filter", False)
         self.lookup_icon = kwargs.pop("lookup_icon", None)
         self.lookup_label = kwargs.pop("lookup_label", None)
         self.depends_on = kwargs.pop("depends_on", [])
@@ -90,6 +94,7 @@ class WBCoreFilterMixin:
             "icon": get_lookup_icon(self.lookup_expr) if self.lookup_icon is None else self.lookup_icon,
             "key": name,
             "hidden": self.hidden,
+            "allow_exclude": self.allow_exclude,
             "input_properties": {
                 "type": self.filter_type,
             },
@@ -101,7 +106,6 @@ class WBCoreFilterMixin:
         if initial is not None or self.allow_empty_initial:
             lookup_expr["input_properties"]["initial"] = initial
 
-        if self.required:
-            lookup_expr["input_properties"]["required"] = True
+        lookup_expr["input_properties"]["required"] = self.required
         representation["depends_on"] = self.depends_on
         return representation, lookup_expr

wbcore/forms.py

@@ -3,7 +3,7 @@ from urllib.parse import unquote
 
 from django import forms
 from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import ValidationError
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.forms import modelformset_factory
 from django.forms.models import BaseModelFormSet
 from psycopg.types.range import DateRange, TimestamptzRange
@@ -39,10 +39,10 @@ def nonrelated_inlineformset_factory(
     """
     FormSet factory that sets an explicit queryset on new classes.
     """
-    FormSet = modelformset_factory(model, formset=formset, **kwargs)
-    FormSet.real_queryset = queryset
-    FormSet.save_new_instance = save_new_instance
-    return FormSet
+    form = modelformset_factory(model, formset=formset, **kwargs)
+    form.real_queryset = queryset
+    form.save_new_instance = save_new_instance
+    return form
 
 
 class ContentTypeMultiValueField(forms.fields.MultiValueField):
@@ -68,7 +68,7 @@ class ContentTypeMultiValueField(forms.fields.MultiValueField):
         try:
             content_type = ContentType.objects.get_for_id(content_type_id)
             return content_type.get_object_for_this_type(id=object_id)
-        except (ContentType.DoesNotExist, content_type.model_class().DoesNotExist):
+        except ObjectDoesNotExist:
             return None
 
 

wbcore/fsm/markdown_extensions.py

@@ -27,5 +27,5 @@ class FSMPreprocessor(Preprocessor):
 
 
 class FSMExtension(Extension):
-    def extendMarkdown(self, md, md_globals):
+    def extendMarkdown(self, md, md_globals):  # noqa
         md.preprocessors.register(FSMPreprocessor(), "wbcore-fsm", 100)