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

wbcore/metadata/configs/endpoints.py

@@ -1,10 +1,12 @@
 import re
 
+from django.urls import NoReverseMatch, resolve
 from rest_framework.reverse import reverse
 
 from wbcore.enums import WidgetType
 from wbcore.utils.urls import get_parse_endpoint, get_urlencode_endpoint
 
+from ...utils.deprecations import deprecate_warning
 from .base import WBCoreViewConfig
 
 
@@ -16,6 +18,11 @@ class EndpointViewConfig(WBCoreViewConfig):
     DELETE_PK_FIELD = "id"
     UPDATE_PK_FIELD = "id"
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if hasattr(self, "get_list_endpoint"):
+            deprecate_warning("get_list_endpoint might be deprecated in a future version of wbcore.")
+
     def get_endpoint(self, **kwargs):
         model = self.view.get_model()
         basename_method_name = (
@@ -57,11 +64,11 @@ class EndpointViewConfig(WBCoreViewConfig):
                 return endpoint
         return None
 
-    def get_list_endpoint(self, **kwargs):
-        return self.get_endpoint(is_list=True)
-
     def _get_list_endpoint(self):
-        return self.get_list_endpoint()
+        try:
+            return reverse(resolve(self.request.path).view_name, kwargs=self.view.kwargs, request=self.request)
+        except NoReverseMatch:
+            return None
 
     def get_delete_endpoint(self, **kwargs):
         return self.get_endpoint()

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,18 +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 (
-                        not field.hidden
-                        and name not in hidden_fields
-                        and (res := field.get_representation(self.request, name, self.view))
-                    ):
-                        representation, lookup_expr = res
-                        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/metadata/configs/identifiers.py

@@ -7,7 +7,9 @@ class IdentifierViewConfig(WBCoreViewConfig):
 
     # TODO: This does not yet work on the frontend, but should
     def get_metadata(self) -> str | None:
-        if identifier := getattr(self.view, "IDENTIFIER", None):
+        if (get_identifier := getattr(self.view, "get_identifier", None)) and callable(get_identifier):
+            return self.view.get_identifier(self.request)
+        elif identifier := getattr(self.view, "IDENTIFIER", None):
             return identifier
 
         content_type = self.view.get_content_type()  # type: ignore

wbcore/metadata/tests/test_buttons.py

@@ -1,7 +1,6 @@
 import random
 
 import pytest
-from faker import Faker
 
 from wbcore import serializers as wb_serializers
 from wbcore.contrib.icons import WBIcon
@@ -16,17 +15,15 @@ from wbcore.metadata.configs.buttons.enums import ButtonDefaultColor, HyperlinkT
 from wbcore.metadata.configs.display.instance_display import create_simple_display
 from wbcore.metadata.utils import prefix_key
 
-fake = Faker()
-
 
 class TestDropDownButton:
     @pytest.fixture()
     def button(self):
         return DropDownButton(
             icon=random.choice(list(WBIcon)).icon,
-            title=fake.sentence(),
+            title="Foo Bar",
             color=random.choice(list(ButtonDefaultColor)).value,
-            buttons=[WidgetButton(key=fake.word(), label=fake.sentence())],
+            buttons=[WidgetButton(key="Foo", label="Foo Bar")],
         )
 
     def test_serialize(self, rf, button):
@@ -38,7 +35,7 @@ class TestDropDownButton:
         assert serialized_btn["buttons"] == [button.buttons[0].serialize(rf)]
         assert serialized_btn["type"] == DropDownButton.button_type.value
 
-    @pytest.mark.parametrize("key_prefix", [fake.word()])
+    @pytest.mark.parametrize("key_prefix", ["Foo"])
     def test_serialize_with_prefix(self, rf, button, key_prefix):
         serialized_btn = button.serialize(rf, key_prefix=key_prefix)
         nested_button = button.buttons[0]
@@ -62,18 +59,18 @@ class TestWidgetButton:
     def key_button(self):
         return self.button_class(
             icon=random.choice(list(WBIcon)).icon,
-            title=fake.sentence(),
+            title="Foo Bar",
             color=random.choice(list(ButtonDefaultColor)).value,
-            key=fake.word(),
+            key="Foo",
         )
 
     @pytest.fixture()
     def endpoint_button(self):
         return self.button_class(
             icon=random.choice(list(WBIcon)).icon,
-            title=fake.sentence(),
+            title="Foo Bar",
             color=random.choice(list(ButtonDefaultColor)).value,
-            endpoint=fake.url(),
+            endpoint="www.foo.com",
         )
 
     def test_serialize(self, rf, key_button):
@@ -85,7 +82,7 @@ class TestWidgetButton:
         assert serialized_btn["key"] == key_button.key
         assert serialized_btn["type"] == self.button_class.button_type.value
 
-    @pytest.mark.parametrize("key_prefix", [fake.word()])
+    @pytest.mark.parametrize("key_prefix", ["Foo"])
     def test_serialize_with_prefix(self, rf, key_button, key_prefix):
         serialized_btn = key_button.serialize(rf, key_prefix=key_prefix)
 
@@ -152,15 +149,15 @@ class TestActionButtonButton(TestHyperlinkButtonutton):
 
         return ActionButton(
             icon=random.choice(list(WBIcon)).icon,
-            title=fake.sentence(),
+            title="Foo Bar",
             color=random.choice(list(ButtonDefaultColor)).value,
-            key=fake.word(),
+            key="Foo",
             method=random.choice(list(RequestType)),
-            action_label=fake.word(),
-            description_fields=fake.sentence(),
+            action_label="Foo",
+            description_fields="Foo Bar",
             instance_display=create_simple_display([["field"]]),
             serializer=BaseSerializer,
-            identifiers=(fake.word(),),
+            identifiers=("Foo",),
         )
 
     def test_serialize(self, rf, key_button):

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/pagination.py

@@ -61,5 +61,4 @@ class CursorPagination(EndlessPaginationMixin, InitialPaginationMixin, paginatio
         return super()._get_position_from_instance(instance, new_ordering)
 
 
-class LimitOffsetPagination(EndlessPaginationMixin, InitialPaginationMixin, pagination.LimitOffsetPagination):
-    ...
+class LimitOffsetPagination(EndlessPaginationMixin, InitialPaginationMixin, pagination.LimitOffsetPagination): ...

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/release_notes/display.py

@@ -3,6 +3,7 @@ from typing import Optional
 from django.utils.translation import gettext as _
 
 from wbcore.contrib.icons import WBIcon
+from wbcore.enums import Unit
 from wbcore.metadata.configs import display as dp
 from wbcore.metadata.configs.display.instance_display.shortcuts import (
     Display,
@@ -16,19 +17,12 @@ class ReleaseNoteDisplayConfig(DisplayViewConfig):
     def get_list_display(self) -> Optional[dp.ListDisplay]:
         return dp.ListDisplay(
             fields=[
+                dp.Field(key="user_read_icon", label=" ", width=Unit.PIXEL(40)),
                 dp.Field(key="module", label=_("Module")),
                 dp.Field(key="version", label=_("Version")),
                 dp.Field(key="release_date", label=_("Release Date")),
                 dp.Field(key="summary", label=_("Summary")),
             ],
-            formatting=[
-                dp.Formatting(
-                    column="user_read",
-                    formatting_rules=[
-                        dp.FormattingRule(icon=WBIcon.VIEW.icon, condition=("==", True)),
-                    ],
-                ),
-            ],
             legends=[
                 dp.Legend(
                     key="read_unread",

wbcore/release_notes/serializers.py

@@ -5,15 +5,8 @@ from .models import ReleaseNote
 
 class ReleaseNoteModelSerializer(serializers.ModelSerializer):
     user_read = serializers.BooleanField()
+    user_read_icon = serializers.IconSelectField()
 
     class Meta:
         model = ReleaseNote
-        fields = (
-            "id",
-            "version",
-            "release_date",
-            "module",
-            "summary",
-            "notes",
-            "user_read",
-        )
+        fields = ("id", "version", "release_date", "module", "summary", "notes", "user_read", "user_read_icon")

wbcore/release_notes/viewsets.py

@@ -1,9 +1,10 @@
-from django.db.models import Exists, OuterRef, Q
+from django.db.models import Case, Exists, OuterRef, Q, Value, When
 from rest_framework.decorators import action
 from rest_framework.response import Response
 
 from wbcore import viewsets
 
+from ..contrib.icons import WBIcon
 from .buttons import ReleaseNotesButtonConfig
 from .display import ReleaseNoteDisplayConfig
 from .filters import ReleaseNoteFilterSet
@@ -26,7 +27,12 @@ class ReleaseNoteReadOnlyModelViewSet(viewsets.ReadOnlyModelViewSet):
         return (
             super()
             .get_queryset()
-            .annotate(user_read=Exists(ReleaseNote.objects.filter(id=OuterRef("id"), read_by=self.request.user)))
+            .annotate(
+                user_read=Exists(ReleaseNote.objects.filter(id=OuterRef("id"), read_by=self.request.user)),
+                user_read_icon=Case(
+                    When(user_read=True, then=Value(WBIcon.VIEW.icon)), default=Value(WBIcon.IGNORE.icon)
+                ),
+            )
         )
 
     def retrieve(self, request, *args, **kwargs):

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

@@ -1,5 +1,6 @@
 from .fields import (
     AdditionalResourcesField,
+    IconSelectField,
     BooleanField,
     CharField,
     ChoiceField,
@@ -7,6 +8,7 @@ from .fields import (
     ColorPickerField,
     DateField,
     DateRangeField,
+    TimeRange,
     DateTimeField,
     DateTimeRangeField,
     DecimalField,

wbcore/serializers/fields/__init__.py

@@ -1,12 +1,13 @@
 from wbcore.contrib.icons.serializers import IconSelectField
 
 from .boolean import BooleanField
-from .choice import ChoiceField, MultipleChoiceField
+from .choice import ChoiceField, MultipleChoiceField, LanguageChoiceField
 from .datetime import (
     DateField,
     DateRangeField,
     DateTimeField,
     DateTimeRangeField,
+    TimeRange,
     DurationField,
     TimeField,
     TimeZoneField,

wbcore/serializers/fields/boolean.py

@@ -17,7 +17,7 @@ class BooleanField(WBCoreSerializerFieldMixin, serializers.BooleanField):
         color: str | Iterable[str] | None = None,
         active_background_color: str | Iterable[str] | None = None,
         active_color: str | Iterable[str] | None = None,
-        **kwargs
+        **kwargs,
     ):
         self.labels = labels
         self.values = values

wbcore/serializers/fields/choice.py

@@ -5,22 +5,42 @@ from .mixins import WBCoreSerializerFieldMixin
 from .types import WBCoreType
 
 
-class ChoiceField(WBCoreSerializerFieldMixin, serializers.ChoiceField):
+class ChoiceMixin:
+    choices: dict[str, str]
+
+    def __init__(self, *args, group_key_mapping: dict[str, str] | None = None, **kwargs):
+        """
+
+        Args:
+            group_key_mapping (dict[str, str] | None, optional): An optional mapping that provides
+                a group for every choice value to group the choices in the drop down by. Defaults to None.
+        """
+        self.group_key_mapping = group_key_mapping or dict()
+        super().__init__(*args, **kwargs)
+
+    def _get_choices_representation(self):
+        return [
+            {"group": self.group_key_mapping.get(value), "value": value, "label": label}
+            for value, label in self.choices.items()
+        ]
+
+
+class ChoiceField(WBCoreSerializerFieldMixin, ChoiceMixin, serializers.ChoiceField):
     field_type = WBCoreType.SELECT.value
 
     def get_representation(self, request, field_name) -> tuple[str, dict]:
         key, representation = super().get_representation(request, field_name)
-        representation["choices"] = [{"value": k, "label": v} for k, v in self.choices.items()]
+        representation["choices"] = self._get_choices_representation()
         return key, representation
 
 
-class MultipleChoiceField(ListFieldMixin, WBCoreSerializerFieldMixin, serializers.MultipleChoiceField):
+class MultipleChoiceField(ListFieldMixin, WBCoreSerializerFieldMixin, ChoiceMixin, serializers.MultipleChoiceField):
     field_type = WBCoreType.SELECT.value
 
     def get_representation(self, request, field_name) -> tuple[str, dict]:
         key, representation = super().get_representation(request, field_name)
         representation["multiple"] = True
-        representation["choices"] = [{"value": k, "label": v} for k, v in self.choices.items()]
+        representation["choices"] = self._get_choices_representation()
         return key, representation
 
     def to_internal_value(self, data):
@@ -34,3 +54,7 @@ class MultipleChoiceField(ListFieldMixin, WBCoreSerializerFieldMixin, serializer
         if isinstance(data, set):
             data = list(data)
         return data
+
+
+class LanguageChoiceField(ChoiceField):
+    field_type = WBCoreType.LANGUAGE.value

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
 
@@ -49,13 +50,9 @@ class DateRangeField(RangeMixin, ShortcutMixin, serializers.DateField):
         self.outward_bounds_transform = outward_bounds_transform  # Allow to specify another bound representation than the default and used for db (]. If specified, will switch the range around to and from the serializer
         self.inward_bounds_transform = inward_bounds_transform
         if self.outward_bounds_transform not in ["[]", "[)", "()", "(]"]:
-            raise ValueError(
-                f"Outward bound transform {self.outward_bounds_transform} is not a valid choice"
-            )
+            raise ValueError(f"Outward bound transform {self.outward_bounds_transform} is not a valid choice")
         if self.inward_bounds_transform not in ["[]", "[)", "()", "(]"]:
-            raise ValueError(
-                f"Inward bound transform {self.inward_bounds_transform} is not a valid choice"
-            )
+            raise ValueError(f"Inward bound transform {self.inward_bounds_transform} is not a valid choice")
 
         super().__init__(*args, **kwargs)
 
@@ -70,9 +67,7 @@ class DateRangeField(RangeMixin, ShortcutMixin, serializers.DateField):
         Returns:
             The shifted bound
         """
-        bound_transform = (
-            self.inward_bounds_transform if inward else self.outward_bounds_transform
-        )
+        bound_transform = self.inward_bounds_transform if inward else self.outward_bounds_transform
         if lower and bound_transform[0] == "(":
             lower = lower + timedelta(days=1) if inward else lower - timedelta(days=1)
         if upper and bound_transform[1] == "]":
@@ -84,54 +79,70 @@ class DateTimeRangeField(RangeMixin, ShortcutMixin, serializers.DateTimeField):
     field_type = WBCoreType.DATETIMERANGE.value
     internal_field = TimestamptzRange
 
-    def __init__(
-        self, *args, lower_time_choices=None, upper_time_choices=None, **kwargs
-    ):
+    def __init__(self, *args, lower_time_choices=None, upper_time_choices=None, **kwargs):
         self.lower_time_choices = lower_time_choices
         if (
             self.lower_time_choices
             and not isinstance(self.lower_time_choices, list)
             and not callable(self.lower_time_choices)
         ):
-            raise ValueError(
-                "lower_time_choices can only be a static list or a callable."
-            )
+            raise ValueError("lower_time_choices can only be a static list or a callable.")
         self.upper_time_choices = upper_time_choices
         if (
             self.upper_time_choices
             and not isinstance(self.upper_time_choices, list)
             and not callable(self.upper_time_choices)
         ):
-            raise ValueError(
-                "upper_time_choices can only be a static list or a callable."
-            )
+            raise ValueError("upper_time_choices can only be a static list or a callable.")
         super().__init__(*args, **kwargs)
 
     def get_representation(self, request, field_name) -> tuple[str, dict]:
         key, representation = super().get_representation(request, field_name)
         if self.lower_time_choices is not None:
             if callable(self.lower_time_choices):
-                representation["lower_time_choices"] = self.lower_time_choices(
-                    self, request
-                )
+                representation["lower_time_choices"] = self.lower_time_choices(self, request)
             else:
                 representation["lower_time_choices"] = self.lower_time_choices
 
         if self.upper_time_choices is not None:
             if callable(self.upper_time_choices):
-                representation["upper_time_choices"] = self.upper_time_choices(
-                    self, request
-                )
+                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 DurationField(
-    NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DurationField
-):
+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
 
     def __init__(self, *args, **kwargs):
@@ -144,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
@@ -154,11 +165,9 @@ 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}'"
-            )
+            raise ValueError(f"Unrecognized value for kwarg 'choices_display' of '{choices_display}'")
 
         self.choices = choices
         super().__init__(*args, **kwargs)

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

@@ -35,9 +35,6 @@ class ListFieldMixin:
         return super().run_validation(data)
 
 
-list
-
-
 class ListField(ListFieldMixin, WBCoreSerializerFieldMixin, serializers.ListField):
     field_type = WBCoreType.LIST.value
 
@@ -101,7 +98,7 @@ class SparklineField(WBCoreSerializerFieldMixin, serializers.ListField):
         return key, representation
 
     def to_representation(self, obj):
-        representation = {}
+        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