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

wbcore/enums.py

@@ -12,56 +12,6 @@ class RequestType(Enum):
     HEAD = "head"
 
 
-class Button(Enum):
-    # Buttons
-    REFRESH = "refresh"
-    NEW = "new"
-    DELETE = "delete"
-
-    # Buttons and Create Buttons
-    SAVE = "save"
-    SAVE_AND_CLOSE = "saveandclose"
-    SAVE_AND_NEW = "saveandnew"
-
-    # Create Buttons
-    RESET = "reset"
-
-    # Custom Buttons
-    DROPDOWN = "dropdown"
-    HYPERLINK = "hyperlink"
-    WIDGET = "widget"
-    ACTION = "action"
-
-    @classmethod
-    def buttons(cls):
-        return [
-            cls.REFRESH.value,
-            cls.NEW.value,
-            cls.DELETE.value,
-            cls.SAVE.value,
-            cls.SAVE_AND_CLOSE.value,
-            cls.SAVE_AND_NEW.value,
-        ]
-
-    @classmethod
-    def create_buttons(cls):
-        return [
-            cls.SAVE.value,
-            cls.SAVE_AND_CLOSE.value,
-            cls.SAVE_AND_NEW.value,
-            cls.RESET.value,
-        ]
-
-    @classmethod
-    def custom_buttons(cls):
-        return [
-            cls.DROPDOWN.value,
-            cls.HYPERLINK.value,
-            cls.WIDGET.value,
-            cls.ACTION.value,
-        ]
-
-
 class WidgetType(Enum):
     LIST = "list"
     INSTANCE = "instance"
@@ -89,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/choices.py

@@ -47,16 +47,14 @@ class MultipleChoiceFilter(WBCoreChoiceFilterMixin, django_filters.MultipleChoic
     field_class = WBCoreMultipleChoiceField
     filter_type = "select"
 
-    def _validate_default_with_request(self, default, request, name):
-        if request_default := request.GET.get(name):
-            return request_default.split(",")
-        return default
+    def _validate_initial_with_request(self, initial, request, name):
+        if request_initial := request.GET.get(name):
+            return request_initial.split(",")
+        return initial
 
     def get_representation(self, request, name, view):
         representation, lookup_expr = super().get_representation(request, name, view)
         lookup_expr["input_properties"]["multiple"] = True
-        if (default := lookup_expr["input_properties"].get("default")) and not isinstance(default, list):
-            lookup_expr["input_properties"]["default"] = [default]
         if (initial := lookup_expr["input_properties"].get("initial")) and not isinstance(initial, list):
             lookup_expr["input_properties"]["initial"] = [initial]
         return representation, lookup_expr

wbcore/filters/fields/content_type.py

@@ -1,3 +1,4 @@
+import json
 import operator
 from functools import reduce
 
@@ -14,6 +15,12 @@ class MultipleChoiceContentTypeFilter(WBCoreFilterMixin, django_filters.Filter):
     field_class = ContentTypeMultiValueField
     filter_type = "text"
 
+    def _validate_initial_with_request(self, initial, request, name):
+        initial = super()._validate_initial_with_request(initial, request, name)
+        if initial:
+            initial = json.dumps(initial)
+        return initial
+
     def __init__(self, object_id_label="object_id", content_type_label="content_type", **kwargs):
         self.object_id_label = object_id_label
         self.content_type_label = content_type_label
@@ -22,13 +29,17 @@ class MultipleChoiceContentTypeFilter(WBCoreFilterMixin, django_filters.Filter):
     def filter(self, qs, value):
         if value in EMPTY_VALUES:
             return qs
-        if self.distinct:
-            qs = qs.distinct()
         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)
         ]
-        return 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
@@ -28,10 +31,10 @@ class ShortcutAndPerformanceMixin(WBCoreFilterMixin):
 
     def get_representation(self, request, name, view):
         representation, lookup_expr = super().get_representation(request, name, view)
-        representation["performance_mode"] = self.performance_mode
+        lookup_expr["input_properties"]["performance_mode"] = self.performance_mode
 
         if self.shortcuts:
-            representation["shortcuts"] = self.shortcuts
+            lookup_expr["input_properties"]["shortcuts"] = self.shortcuts
 
         return representation, lookup_expr
 
@@ -39,54 +42,76 @@ class ShortcutAndPerformanceMixin(WBCoreFilterMixin):
 class DateRangeFilter(ShortcutAndPerformanceMixin, django_filters.Filter):
     field_class = DateRangeField
     filter_type = "daterange"
-    default_format = "%Y-%m-%d"
+    initial_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:
+    @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:
             lower = upper = None
-            if isinstance(default, tuple):
-                lower, upper = default
+            if isinstance(initial, tuple):
+                lower, upper = initial
 
-                # if the default is a tuple of components, we need to convert them to string
+                # if the initial 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
+            elif hasattr(initial, "lower") and hasattr(initial, "upper"):
+                lower, upper = initial.lower, initial.upper
+            initial = f'{lower.strftime(self.initial_format) if lower else ""},{upper.strftime(self.initial_format) if upper else ""}'
+        return initial
 
     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
+            initial = representation["initial"].pop(self.lookup_expr)
+            lookup_expr["input_properties"]["initial"]["exact"] = initial
 
         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
-    default_format = "%Y-%m-%dT%H:%M:%S%z"
+    initial_format = "%Y-%m-%dT%H:%M:%S%z"
+    filter_type = "datetimerange"

wbcore/filters/fields/models.py

@@ -14,6 +14,11 @@ from wbcore.filters.mixins import WBCoreFilterMixin
 class ModelChoiceFilterMixin(WBCoreFilterMixin):
     MULTIPLE: bool = False
 
+    def _validate_initial_with_request(self, initial, request, name):
+        if request_default := request.GET.get(name):
+            return request_default.split(",")
+        return initial
+
     @classmethod
     def get_parsed_values(cls, queryset, value_ids: int | str | Iterable[int]):
         if isinstance(value_ids, str):
@@ -28,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)
@@ -45,19 +50,21 @@ class ModelChoiceFilterMixin(WBCoreFilterMixin):
         url = reverse(self.endpoint, request=request)
         if self.filter_params:
             if callable(self.filter_params):
-                url += f"?{urlencode(self.filter_params(request, view))}"
+                filter_params = self.filter_params(request, view)
             else:
-                url += f"?{urlencode(self.filter_params)}"
+                filter_params = self.filter_params
+            # we need to convert any list into comma seperated string
+            for key, value in filter_params.items():
+                if isinstance(value, list):
+                    filter_params[key] = ",".join(map(lambda x: str(x), value))
+
+            url += f"?{urlencode(filter_params, doseq=True)}"
         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)
@@ -86,12 +93,14 @@ class ModelMultipleChoiceFilter(ModelChoiceFilterMixin, django_filters.ModelMult
         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)
 
+        # django filter sets it to True by default. In our case, the fitlering will happen on primary keys, so we do not expect any duplicate. Furthermore, for table without explicit unique constraint, using "distinct" leads to unexpected results (i.e. row with same value are dropped)
+        self.distinct = False
+
 
 class ModelChoiceFilter(ModelChoiceFilterMixin, django_filters.ModelChoiceFilter):
     class SimpleModelChoiceField(ModelChoiceField):

wbcore/filters/fields/numbers.py

@@ -1,23 +1,25 @@
 import django_filters
 
 from wbcore.filters.mixins import WBCoreFilterMixin
+from wbcore.serializers import WBCoreType
 
 
 class NumberFilter(WBCoreFilterMixin, django_filters.NumberFilter):
     filter_type = "number"
 
-    def __init__(self, precision: int = 0, percent: bool = False, delimiter=",", decimal_mark=".", *args, **kwargs):
+    def __init__(self, precision: int = 0, percent: bool = False, disable_formatting: bool = False, *args, **kwargs):
         self.precision = precision
         self.percent = percent
-        self.delimiter = delimiter
-        self.decimal_mark = decimal_mark
+        self.disable_formatting = disable_formatting
         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
+        lookup_expr["input_properties"]["precision"] = self.precision
+        if self.percent:  # TODO: Discuss with Christoph if this is necessary like this
+            lookup_expr["input_properties"]["type"] = WBCoreType.PERCENT.value
+            lookup_expr["input_properties"]["precision"] = max(self.precision - 2, 0)
+        lookup_expr["input_properties"]["disable_formatting"] = self.disable_formatting
         return representation, lookup_expr
 
     def filter(self, qs, value):
@@ -29,8 +31,7 @@ class NumberFilter(WBCoreFilterMixin, django_filters.NumberFilter):
 class YearFilter(NumberFilter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.delimiter = ""
-        self.decimal_mark = "."
+        self.disable_formatting = True
 
 
 class RangeSelectFilter(NumberFilter):

wbcore/filters/filterset.py

@@ -1,15 +1,19 @@
 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
 from django.db import models
+from django.db.models import GeneratedField
 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.models.fields import YearField
 from wbcore.signals.filters import add_filters
 
 from .utils import check_required_filters
@@ -26,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):
@@ -63,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},
@@ -83,6 +88,7 @@ class FilterSet(DjangoFilterSet, metaclass=CustomFilterSetMetaClass):
         models.DecimalField: {"filter_class": fields.NumberFilter},
         DateTimeRangeField: {"filter_class": fields.DateTimeRangeFilter},
         DateRangeField: {"filter_class": fields.DateRangeFilter},
+        YearField: {"filter_class": fields.YearFilter},
         # models.DurationField: {"filter_class": DurationFilter},
         # models.SmallIntegerField: {"filter_class": NumberFilter},
         # models.AutoField: {"filter_class": NumberFilter},
@@ -165,11 +171,13 @@ 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
     def filter_for_lookup(cls, field, lookup_type):
+        if isinstance(field, GeneratedField):
+            return cls.filter_for_lookup(field.output_field, lookup_type)
         if lookup_type == "exact" and getattr(field, "choices", None):
             filter_class, params = fields.ChoiceFilter, {"choices": field.choices}
         else:
@@ -191,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():
@@ -206,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

@@ -1,5 +1,7 @@
+import warnings
 from contextlib import suppress
 
+from django.core.exceptions import ValidationError
 from django_filters.utils import get_model_field
 
 from .lookups import get_lookup_icon, get_lookup_label
@@ -7,18 +9,31 @@ 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)
+        default = kwargs.pop("default", None)
+        if default is not None:
+            self.initial = default
+            self.required = True
+            warnings.warn(
+                "The use of default will be deprecated in favour of the equivalent 'initial' and 'required=True'",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        else:
+            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.allow_empty_initial = kwargs.pop("allow_empty_initial", False)
         self.label_format = kwargs.pop(
             "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", [])
@@ -34,25 +49,28 @@ class WBCoreFilterMixin:
         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)
+    def _get_initial(self, request, view):
+        # We consider the case where initial is a boolean with value False.
+        if callable(self.initial):
+            initial = self.initial(self, request, view)
         elif (
-            isinstance(self.default, str)
-            and (callable_default := getattr(self, self.default, None))
-            and (callable(callable_default))
+            isinstance(self.initial, str)
+            and (callable_initial := getattr(self, self.initial, None))
+            and (callable(callable_initial))
         ):
-            default = callable_default(self, request, view)
+            initial = callable_initial(self, request, view)
         else:
-            default = self.default
+            initial = self.initial
 
-        return default
+        return initial
 
-    def _validate_default_with_request(self, default, request, name):
+    def _validate_initial_with_request(self, initial, request, name):
         if request_default := request.GET.get(name):
-            return request_default
-        return default
+            try:
+                return self.field.to_python(request_default)
+            except ValidationError:
+                return None
+        return initial
 
     def get_help_text(self) -> str:
         if self.help_text:
@@ -65,9 +83,6 @@ class WBCoreFilterMixin:
             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,
@@ -79,34 +94,18 @@ 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,
             },
         }
-        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
+        initial = self._get_initial(request, view)
+        if (overridden_initial := self._validate_initial_with_request(initial, request, name)) is not None:
+            initial = overridden_initial
 
-        if initial is not None:
+        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
-            # assert representation["default"] != {}, "If a filter is required, it needs at least one default value"
+        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)