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

wbcore/fsm/mixins.py

@@ -23,15 +23,15 @@ def get_method(transition, fsm_field_name):
 class FSMViewSetMixinMetaclass(type):
     """Metaclass for dynamically creating all FSM Routes"""
 
-    def __new__(cls, name, bases, dct):
-        _class = super().__new__(cls, name, bases, dct)
+    def __new__(cls, *args, **kwargs):
+        _class = super().__new__(cls, *args, **kwargs)
 
         # The class needs the field FSM_MODELFIELDS to know which transitions it needs to add
         if hasattr(_class, "get_model"):
             model = _class.get_model()
 
             if model:
-                setattr(_class, "FSM_BUTTONS", getattr(_class, "FSM_BUTTONS", set()))
+                _class.FSM_BUTTONS = getattr(_class, "FSM_BUTTONS", set())
                 # The model potentially has multiple FSMFields, which needs to be iterated over
                 for field in filter(lambda f: isinstance(f, FSMField), model._meta.fields):
                     # Get all transitions, by calling the partialmethod defined by django-fsm
@@ -112,7 +112,10 @@ class FSMViewSetMixin(metaclass=FSMViewSetMixinMetaclass):
                         post_action_method(by=request.user)
                     # we extend the framework to allow action to successfully return but notify any possible warning. We use the message framework to communicate these warnings to the user
                     if warnings:
-                        html = "<ul>" + "".join(f"<li>{e}</li>" for e in warnings) + "</ul>"
+                        if isinstance(warnings, list):
+                            html = "<ul>" + "".join(f"<li>{e}</li>" for e in warnings) + "</ul>"
+                        else:
+                            html = "<p>" + warnings + "</p>"
                         warning(request, html, extra_tags="auto_close=0")
 
             serializer = serializer_class(instance=obj, context=serializer_context)

wbcore/markdown/models.py

@@ -17,7 +17,15 @@ class Asset(models.Model):
     file = models.FileField(max_length=256, upload_to=upload_to)
     content_type = models.CharField(max_length=32, null=True, blank=True)
     file_url_name = models.CharField(max_length=1024, null=True, blank=True)
+
     # public = models.BooleanField(default=True)
+    class Meta:
+        verbose_name = _("Asset")
+        verbose_name_plural = _("Assets")
+        db_table = "bridger_asset"
+
+    def __str__(self) -> str:
+        return str(self.id)
 
     @property
     def filename(self):
@@ -25,11 +33,6 @@ class Asset(models.Model):
             return f"{self.id}{suffix}"
         return self.id
 
-    class Meta:
-        verbose_name = _("Asset")
-        verbose_name_plural = _("Assets")
-        db_table = "bridger_asset"
-
 
 @receiver(models.signals.pre_save, sender="wbcore.Asset")
 def generate_content_type(sender, instance, **kwargs):

wbcore/metadata/configs/buttons/bases.py

@@ -24,8 +24,8 @@ class ButtonConfig:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert self.label or self.icon, "Either label or icon has to be defined."
+        if not self.label and not self.icon:
+            raise ValueError("No label or icon specified")
 
     def __iter__(self):
         if iter := getattr(super(), "__iter__", None):
@@ -57,8 +57,8 @@ class ButtonTypeMixin:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert hasattr(self, "button_type"), "button_type cannot be None."
+        if not hasattr(self, "button_type"):
+            raise TypeError("button_type cannot be None.")
 
     def __iter__(self):
         if iter := getattr(super(), "__iter__", None):
@@ -82,8 +82,8 @@ class ButtonUrlMixin:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert bool(self.key) != bool(self.endpoint), "Either key or endpoint has to be defined. (Not both)"
+        if bool(self.key) == bool(self.endpoint):
+            raise ValueError("Either key or endpoint has to be defined. (Not both)")
 
     def __iter__(self):
         if iter := getattr(super(), "__iter__", None):

wbcore/metadata/configs/buttons/buttons.py

@@ -23,7 +23,8 @@ class DropDownButton(ButtonTypeMixin, ButtonConfig):
         if hasattr(super(), "__post_init__"):
             super().__post_init__()
         self.buttons = tuple(self.buttons)
-        assert isinstance(self.buttons, tuple)
+        if not isinstance(self.buttons, tuple):
+            raise TypeError(f"{type(self.buttons)} is not a tuple")
 
     def serialize(self, request, **kwargs):
         res = super().serialize(request, **kwargs)

wbcore/metadata/configs/buttons/view_config.py

@@ -29,7 +29,9 @@ class ButtonViewConfig(WBCoreViewConfig):
         Returns:
             Yield the serialized button, without duplicates and appends the module prefix to the remote button
         """
-        base_buttons = list(zip([None] * len(base_buttons), base_buttons))  # append an empty perfix for base buttons
+        base_buttons = list(
+            zip([None] * len(base_buttons), base_buttons, strict=False)
+        )  # append an empty perfix for base buttons
         for prefix, btn in parse_signal_received_for_module(remote_resources):
             base_buttons.append((prefix, btn))
 
@@ -54,14 +56,14 @@ class ButtonViewConfig(WBCoreViewConfig):
     FSM_WEIGHT = 100
 
     def get_fsm_buttons(self) -> set:
-        if self.FSM_DROPDOWN and (FSM_BUTTONS := getattr(self.view, "FSM_BUTTONS")) and len(FSM_BUTTONS) > 0:
+        if self.FSM_DROPDOWN and (fsm_buttons := self.view.FSM_BUTTONS) and len(fsm_buttons) > 0:
             return {
                 DropDownButton(
                     label=self.FSM_DROPDOWN_LABEL,
                     icon=self.FSM_DROPDOWN_ICON,
                     title=self.FSM_DROPDOWN_LABEL,
                     weight=self.FSM_WEIGHT,
-                    buttons=tuple(FSM_BUTTONS),
+                    buttons=tuple(fsm_buttons),
                 )
             }
         return getattr(self.view, "FSM_BUTTONS", set())

wbcore/metadata/configs/display/display.py

@@ -41,8 +41,8 @@ class Operator(Enum):
         operator_dict = {o.value: o for o in cls}
         try:
             return operator_dict[op]
-        except KeyError:
-            raise InvalidOperatorError(f"`{op}` is not a valid operator")
+        except KeyError as e:
+            raise InvalidOperatorError(f"`{op}` is not a valid operator") from e
 
 
 def fr(fractions: int) -> str:

wbcore/metadata/configs/display/formatting.py

@@ -9,8 +9,8 @@ class Condition:
     value: str | float | int | bool
 
     def __post_init__(self) -> None:
-        if self.operator == Operator.EXISTS:
-            assert isinstance(self.value, bool), f"{Operator.EXISTS.value} is only compatible with bool"
+        if self.operator == Operator.EXISTS and not isinstance(self.value, bool):
+            raise TypeError(f"{Operator.EXISTS.value} is only compatible with bool")
 
 
 @dataclass(unsafe_hash=True)
@@ -19,7 +19,8 @@ class FormattingRule:
     condition: Condition | tuple | list[tuple] | None = None
 
     def __post_init__(self) -> None:
-        assert self.style, "style cannot both be None."
+        if not self.style:
+            raise ValueError("Style cannot be empty")
 
     def __iter__(self):
         yield "style", self.style
@@ -38,10 +39,8 @@ class Formatting:
     column: str | None = None
 
     def __post_init__(self) -> None:
-        if self.column is None:
-            assert all(
-                [not bool(rule.condition) for rule in self.formatting_rules]
-            ), "Specifying conditions, without a reference column is not possible."
+        if self.column is None and not all([not bool(rule.condition) for rule in self.formatting_rules]):
+            raise ValueError("Specifying conditions, without a reference column is not possible.")
 
     def __iter__(self):
         yield "column", self.column

wbcore/metadata/configs/display/list_display.py

@@ -59,8 +59,9 @@ class Field:
     size_to_fit: bool = True
 
     def __post_init__(self):
-        if not self.key and len(self.children) == 0:
-            self.key = slugify(str(self.label))  # we cast to str explicitly in case label is in a translation wrapper
+        self.identifier = (
+            self.key if self.key else slugify(str(self.label))
+        )  # we cast to str explicitly in case label is in a translation wrapper
 
     def iterate_leaf_fields(self, aggregated_parent_label: str = ""):
         label = self.label
@@ -73,7 +74,7 @@ class Field:
             yield self.key, label
 
     def serialize(self, parent_identifier: str | None = None):
-        identifier = parent_identifier + "_" + self.key if parent_identifier else self.key
+        identifier = parent_identifier + "_" + self.identifier if parent_identifier else self.identifier
         repr = {
             "identifier": identifier,
             "key": self.key,
@@ -144,10 +145,8 @@ class Legend:
     key: str | None = None
 
     def __post_init__(self):
-        if self.key:
-            assert all(
-                [item.value is not None for item in self.items]
-            ), "If key is set, all items need to specify a value."
+        if self.key and not all([item.value is not None for item in self.items]):
+            raise ValueError("If key is set, all items need to specify a value.")
 
     def __iter__(self):
         if self.label:

wbcore/metadata/configs/display/models.py

@@ -10,6 +10,9 @@ class Preset(models.Model):
     display_identifier = models.CharField(max_length=512)
     display = models.JSONField(null=True, blank=True)
 
+    def __str__(self) -> str:
+        return f"{self.title} - {self.user} ({self.display_identifier})"
+
 
 class AppliedPreset(models.Model):
     user = models.ForeignKey(to=get_user_model(), related_name="applied_presets", on_delete=models.CASCADE)
@@ -18,3 +21,6 @@ class AppliedPreset(models.Model):
         to=Preset, related_name="applied_presets", on_delete=models.SET_NULL, null=True, blank=True
     )
     display = models.JSONField(null=True, blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.display_identifier_path} ({self.user})"

wbcore/metadata/configs/fields.py

@@ -10,8 +10,13 @@ class FieldsViewConfig(WBCoreViewConfig):
     def get_metadata(self) -> dict:
         fields = defaultdict(dict)
         if (serializer_class := getattr(self.view, "get_serializer", None)) and (serializer := serializer_class()):
+            related_key_fields = []
             for field_name, field in serializer.fields.items():
                 field_key, field_representation = field.get_representation(self.request, field_name)
+                # we need to get the representation of the related field last so that the key update properly (priority to the related field values)
+                if "related_key" in field_representation:
+                    related_key_fields.append((field_key, field_representation))
+                fields[field_key].update(field_representation)
+            for field_key, field_representation in related_key_fields:
                 fields[field_key].update(field_representation)
-
         return fields

wbcore/metadata/configs/filter_fields.py

@@ -25,16 +25,17 @@ class FilterFieldsViewConfig(WBCoreViewConfig):
                     hidden_fields.extend(getattr(filterset_class_meta, "hidden_fields", []))
                     filters.update(getattr(filterset_class_meta, "df_fields", {}))
                 for name, field in filters.items():
-                    field.parent = filterset
-                    if res := field.get_representation(self.request, name, self.view):
-                        representation, lookup_expr = res
-                        if name in hidden_fields:
-                            lookup_expr["hidden"] = True
-                        if field.key in filter_fields:
-                            filter_fields[field.key]["lookup_expr"].append(lookup_expr)
-                        else:
-                            filter_fields[field.key] = representation
-                            filter_fields[field.key]["lookup_expr"] = [lookup_expr]
-                            filter_fields[field.key]["label"] = field.label
+                    if not field.excluded_filter:
+                        field.parent = filterset
+                        if res := field.get_representation(self.request, name, self.view):
+                            representation, lookup_expr = res
+                            if name in hidden_fields:
+                                lookup_expr["hidden"] = True
+                            if field.key in filter_fields:
+                                filter_fields[field.key]["lookup_expr"].append(lookup_expr)
+                            else:
+                                filter_fields[field.key] = representation
+                                filter_fields[field.key]["lookup_expr"] = [lookup_expr]
+                                filter_fields[field.key]["label"] = field.label
 
         return filter_fields

wbcore/models/fields.py

@@ -5,10 +5,10 @@ from django.db.models import DecimalField, Field, FloatField, PositiveIntegerFie
 class AbstractDynamicField(Field):
     dependencies = []
 
-    def __init__(self, *args, dependencies=list(), **kwargs):
+    def __init__(self, *args, dependencies: list | None = None, **kwargs):
         blank = kwargs.pop("blank", True)
         null = kwargs.pop("null", True)
-        self.dependencies = dependencies
+        self.dependencies = dependencies if dependencies else []
         super().__init__(*args, blank=blank, null=null, **kwargs)
 
 

wbcore/permissions/permissions.py

@@ -1,5 +1,5 @@
 from rest_framework import permissions
-from rest_framework.permissions import BasePermission
+from rest_framework.permissions import IsAuthenticated
 
 from wbcore.enums import WidgetType
 
@@ -40,7 +40,7 @@ class RestAPIModelPermissions(permissions.DjangoModelPermissions):
         return request.user.has_perms(perms)
 
 
-class IsInternalUser(BasePermission):
+class IsInternalUser(IsAuthenticated):
     def has_permission(self, request, view) -> bool:
         return is_internal_user(request.user, True)
 

wbcore/permissions/utils.py

@@ -17,10 +17,10 @@ def perm_to_permission(perm: str) -> Permission:
     """
     try:
         app_label, codename = perm.split(".", 1)
-    except IndexError:
+    except IndexError as e:
         raise AttributeError(
             "The format of identifier string permission (perm) is wrong. " "It should be in 'app_label.codename'."
-        )
+        ) from e
     else:
         permission = Permission.objects.get(content_type__app_label=app_label, codename=codename)
         return permission

wbcore/reversion/viewsets/titles.py

@@ -1,4 +1,7 @@
+from contextlib import suppress
+
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils.translation import gettext as _
 
 from wbcore.metadata.configs.titles import TitleViewConfig
@@ -9,10 +12,8 @@ class VersionTitleConfig(TitleViewConfig):
         if (content_type_id := self.view.request.GET.get("content_type", None)) and (
             object_id := self.view.request.GET.get("object_id", None)
         ):
-            try:
+            with suppress(ObjectDoesNotExist):
                 content_type = ContentType.objects.get(id=content_type_id)
                 obj = content_type.model_class().objects.get(id=object_id)
                 return _("Versions For {obj}").format(obj=str(obj))
-            except Exception:
-                pass
         return _("Versions")

wbcore/serializers/__init__.py

@@ -8,6 +8,7 @@ from .fields import (
     ColorPickerField,
     DateField,
     DateRangeField,
+    TimeRange,
     DateTimeField,
     DateTimeRangeField,
     DecimalField,

wbcore/serializers/fields/__init__.py

@@ -7,6 +7,7 @@ from .datetime import (
     DateRangeField,
     DateTimeField,
     DateTimeRangeField,
+    TimeRange,
     DurationField,
     TimeField,
     TimeZoneField,

wbcore/serializers/fields/datetime.py

@@ -1,8 +1,9 @@
-from datetime import timedelta
+from datetime import date, datetime, timedelta
 
 import pytz
-from psycopg.types.range import DateRange, TimestamptzRange
+from psycopg.types.range import DateRange, TimestampRange, TimestamptzRange
 from rest_framework import serializers
+from rest_framework.settings import api_settings
 from timezone_field.choices import standard, with_gmt_offset
 from timezone_field.rest_framework import TimeZoneSerializerField
 
@@ -108,11 +109,39 @@ class DateTimeRangeField(RangeMixin, ShortcutMixin, serializers.DateTimeField):
                 representation["upper_time_choices"] = self.upper_time_choices(self, request)
             else:
                 representation["upper_time_choices"] = self.upper_time_choices
-        if timezone := getattr(self, "timezone", None):
-            representation["timezone"] = str(timezone)
         return key, representation
 
 
+class TimeRange(RangeMixin, ShortcutMixin, serializers.TimeField):
+    field_type = WBCoreType.TIMERANGE.value
+    internal_field = TimestampRange
+
+    def __init__(self, *args, timerange_fields: tuple[str, str] | None = None, **kwargs):
+        self.timerange_fields = timerange_fields
+        super().__init__(*args, **kwargs)
+        self.default_date_repr = date.min.strftime(getattr(self, "format", api_settings.DATE_FORMAT))
+        if self.timerange_fields:
+            self.source = "*"
+
+    def _transform_range(self, lower, upper, **kwargs):
+        if isinstance(lower, datetime):
+            lower = lower.time()
+        if isinstance(upper, datetime):
+            upper = upper.time()
+        return lower, upper
+
+    def get_attribute(self, instance):
+        if self.timerange_fields:
+            return [getattr(instance, self.timerange_fields[0]), getattr(instance, self.timerange_fields[1])]
+        return super().get_attribute(instance)
+
+    def to_internal_value(self, data):
+        ts_range = super().to_internal_value(data)
+        if self.timerange_fields:
+            return dict(zip(self.timerange_fields, (ts_range.lower, ts_range.upper), strict=False))
+        return ts_range
+
+
 class DurationField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DurationField):
     field_type = WBCoreType.DURATION.value
 
@@ -126,7 +155,7 @@ class TimeZoneField(WBCoreSerializerFieldMixin, TimeZoneSerializerField):
 
     def __init__(self, choices=None, choices_display=None, *args, **kwargs):
         if choices:
-            values, displays = zip(*choices)
+            values, displays = zip(*choices, strict=False)
         else:
             values = pytz.common_timezones
             displays = None
@@ -136,7 +165,7 @@ class TimeZoneField(WBCoreSerializerFieldMixin, TimeZoneSerializerField):
         elif choices_display == "STANDARD":
             choices = standard(values)
         elif choices_display is None:
-            choices = zip(values, displays) if displays else standard(values)
+            choices = zip(values, displays, strict=False) if displays else standard(values)
         else:
             raise ValueError(f"Unrecognized value for kwarg 'choices_display' of '{choices_display}'")
 

wbcore/serializers/fields/fields.py

@@ -91,7 +91,7 @@ class DynamicButtonField(WBCoreSerializerFieldMixin, serializers.ReadOnlyField):
             )
             for prefix, btns in dynamic_buttons:
                 for btn in btns:
-                    setattr(btn, "prefix_key", prefix)
+                    btn.prefix_key = prefix
                     buttons.append(btn.serialize(request))
             if (view := self.parent.context.get("view", None)) and not (getattr(view, "action", "list") == "list"):
                 for _, button_func in getmembers(self.parent.__class__, _is_instance_dynamic_button):

wbcore/serializers/fields/fsm.py

@@ -8,7 +8,7 @@ class FSMStatusField(CharField):
     def __init__(self, *args, **kwargs):
         self.choices = kwargs.pop("choices")
         read_only = kwargs.pop("read_only", True)
-        super().__init__(read_only=read_only, *args, **kwargs)
+        super().__init__(*args, read_only=read_only, **kwargs)
 
     def get_representation(self, request, field_name) -> tuple[str, dict]:
         key, representation = super().get_representation(request, field_name)

wbcore/serializers/fields/list.py

@@ -100,5 +100,5 @@ class SparklineField(WBCoreSerializerFieldMixin, serializers.ListField):
     def to_representation(self, obj):
         representation = [[]]  # if row is [] or null, we default to an empty list of list
         if (x_data := getattr(obj, self.x_data_label, None)) and (y_data := getattr(obj, self.y_data_label, None)):
-            representation = zip(x_data, y_data)
+            representation = zip(x_data, y_data, strict=False)
         return representation

wbcore/serializers/fields/mixins.py

@@ -10,8 +10,10 @@ logger = logging.getLogger(__name__)
 
 
 def decorator(position: str, value: str, decorator_type: str = "icon") -> dict:
-    assert position in ("left", "right"), "Decorator Position can only be right or left"
-    assert decorator_type in ("icon", "text"), "Decorator Type can only be icon or text"
+    if position not in ("left", "right"):
+        raise ValueError("Decorator Position can only be right or left")
+    if decorator_type not in ("icon", "text"):
+        raise ValueError("Decorator Type can only be icon or text")
     return {"position": position, "value": value, "type": decorator_type}
 
 
@@ -31,6 +33,8 @@ class WBCoreSerializerFieldMixin:
         read_only=False,
         copyable=None,
         related_key=None,
+        on_unsatisfied_deps="read_only",
+        clear_dependent_fields=True,
         **kwargs,
     ):
         if not decorators:
@@ -48,6 +52,8 @@ class WBCoreSerializerFieldMixin:
             self._callable_read_only = read_only
             read_only = True
         self.related_key = related_key
+        self.on_unsatisfied_deps = on_unsatisfied_deps
+        self.clear_dependent_fields = clear_dependent_fields
         super().__init__(*args, read_only=read_only, **kwargs)
 
     def _evaluate_read_only(self, field_name, parent):
@@ -105,10 +111,8 @@ class WBCoreSerializerFieldMixin:
 
         default = getattr(self, "default", None)
         if default is None or default == empty or default == NOT_PROVIDED:
-            try:
+            with suppress(Exception):  # TODO Add some explicit exception handling
                 default = self.parent.Meta.model._meta._forward_fields_map[field_name].default
-            except Exception:  # TODO Add some explicit exception handling
-                pass
 
         if default is not None and default != empty and default != NOT_PROVIDED:
             if callable(default):
@@ -131,6 +135,10 @@ class WBCoreSerializerFieldMixin:
             representation["math"] = self.math
         if self.copyable:
             representation["copyable"] = self.copyable
+        if self.on_unsatisfied_deps != "read_only":
+            representation["on_unsatisfied_deps"] = self.on_unsatisfied_deps
+        if self.clear_dependent_fields is not True:
+            representation["clear_dependent_fields"] = self.clear_dependent_fields
         return field_name, representation
 
     def validate_empty_values(self, data):

wbcore/serializers/fields/related.py

@@ -29,7 +29,7 @@ class WBCoreManyRelatedField(ListFieldMixin, WBCoreSerializerFieldMixin, ManyRel
         self.child_relation.context["view"] = self.view
         self.child_relation._evaluate_read_only(field_name, parent)
         if not self.child_relation.read_only and hasattr(self.child_relation, "_queryset"):
-            setattr(self.child_relation, "queryset", self.child_relation._queryset)
+            self.child_relation.queryset = self.child_relation._queryset
 
     def get_representation(self, request: Request, field_name: str) -> tuple[str, dict]:
         key, representation = self.child_relation.get_representation(request, field_name)
@@ -58,7 +58,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
     )
 
     def __init__(self, *args, queryset=None, read_only=False, **kwargs):
-        self.field_type = kwargs.pop("field_type", WBCoreType.SELECT.value)
+        self.field_type = kwargs.pop("field_type", WBCoreType.PRIMARY_KEY.value)
         if callable(read_only) and queryset is not None:
             self._queryset = queryset  # we unset any given queryset to be compliant with the RelatedField assertion
             queryset = None
@@ -72,7 +72,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
         super().bind(field_name, parent)
         # In case we had to unset the queryset attribute because read_only was a callable, we reinstate it here.
         if not self.read_only and hasattr(self, "_queryset"):
-            setattr(self, "queryset", self._queryset)
+            self.queryset = self._queryset
 
     @classmethod
     def many_init(cls, *args, **kwargs):
@@ -103,7 +103,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
         # In case we annotate the representation, we need to ensure that the value is an object
         if isinstance(value, (list, tuple, set)):
             return [self.to_representation(d) for d in value]
-        try:
+        with suppress(Exception):  # TODO: investigate what exception are we expecting here
             if isinstance(value, str):
                 try:
                     value = int(value)
@@ -112,8 +112,6 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
             if isinstance(value, int):
                 value = PKOnlyObject(value)
             return super().to_representation(value)
-        except Exception:
-            pass
         return None
 
     def get_queryset(self):

wbcore/serializers/fields/text.py

@@ -54,7 +54,7 @@ class CodeField(CharField):
         try:
             compile(data, "", "exec")
         except Exception as e:
-            raise ValidationError(_("Compiling script failed with the exception: {}".format(e)))
+            raise ValidationError(_("Compiling script failed with the exception: {}".format(e))) from e
         return super().to_internal_value(data)
 
 

wbcore/serializers/fields/types.py

@@ -14,6 +14,7 @@ class WBCoreType(Enum):
     DATETIMERANGE = "datetimerange"
     DATE = "date"
     DATERANGE = "daterange"
+    TIMERANGE = "timerange"
     DURATION = "duration"
     TIME = "time"
     PRIMARY_KEY = "primary_key"

wbcore/serializers/serializers.py

@@ -49,8 +49,8 @@ def validate_nested_representation(instance, value):
 
 
 class WBCoreSerializerMetaClass(SerializerMetaclass):
-    def __new__(cls, name, bases, dct):
-        _class = super().__new__(cls, name, bases, dct)
+    def __new__(cls, *args, **kwargs):  # noqa: C901
+        _class = super().__new__(cls, *args, **kwargs)
 
         if _meta := getattr(_class, "Meta", None):
             model = _meta.model
@@ -334,6 +334,7 @@ class RepresentationSerializer(WBCoreSerializerFieldMixin, ModelSerializer):
             getattr(self, "optional_get_parameters", None),
         )
         self.tree_config = tree_config
+        self.select_first_choice = kwargs.pop("select_first_choice", getattr(self, "select_first_choice", None))
         super().__init__(*args, **kwargs)
 
     def to_representation(self, value):
@@ -410,6 +411,9 @@ class RepresentationSerializer(WBCoreSerializerFieldMixin, ModelSerializer):
             },
         }
 
+        if self.select_first_choice:
+            representation["select_first_choice"] = True
+
         if self.help_text:
             representation["help_text"] = self.help_text
 

wbcore/tasks.py

@@ -45,7 +45,7 @@ def recompute_computed_str(debug: bool = False):
     When this task is executed, it will loop over all objects that inherit from ComplexToStringMixin and compare their current computed_str value with the expected one.
     If different, the expected one is saved in place.
     """
-    BULK_SIZE = 1000
+    bulk_size = 1000
     for subclass in get_inheriting_subclasses(ComplexToStringMixin):
         if getattr(subclass, "COMPUTED_STR_RECOMPUTE_PERIODICALLY", True):
             objs = []
@@ -59,7 +59,7 @@ def recompute_computed_str(debug: bool = False):
                     if new_computed_str != instance.computed_str:
                         instance.computed_str = new_computed_str
                         objs.append(instance)
-                    if len(objs) % BULK_SIZE == 0:
+                    if len(objs) % bulk_size == 0:
                         subclass.objects.bulk_update(objs, ["computed_str"])
                         objs = []
             if objs:

wbcore/templates/wbcore/email_base_template.html

@@ -208,7 +208,7 @@
             width: 100%;
         }
         .fixed {
-            width: 500px;
+            width: 750px;
         }
         #body-table {
             width: 100%;
@@ -248,8 +248,8 @@
         }
         #body-table .content-row > .body-content {
             background-color: #fff;
-            padding-right: 30px;
-            padding-left: 30px;
+            padding-right: 15px;
+            padding-left: 15px;
         }
         #body-table #spacer-row > .spacer-left,
         #body-table #spacer-row > .spacer-middle,