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

wbcore/contrib/notifications/viewsets/notification_types.py

@@ -1,3 +1,4 @@
+from django.db.models import Case, Value, When
 from django.db.models.query import F, QuerySet
 from rest_framework import status
 from rest_framework.request import Request
@@ -13,7 +14,8 @@ from wbcore.contrib.notifications.serializers import (
     NotificationTypeSettingModelSerializer,
 )
 
-from .configs.notification_types import NotificationTypeSettingDisplayConfig
+from ...icons import WBIcon
+from .configs.notification_types import NotificationTypeSettingDisplayConfig, NotificationTypeSettingEndpointConfig
 
 
 class NotificationTypeRepresentationViewSet(viewsets.RepresentationViewSet):
@@ -25,6 +27,7 @@ class NotificationTypeSettingModelViewSet(viewsets.ModelViewSet):
     queryset = NotificationTypeSetting.objects.all()
     serializer_class = NotificationTypeSettingModelSerializer
 
+    endpoint_config_class = NotificationTypeSettingEndpointConfig
     display_config_class = NotificationTypeSettingDisplayConfig
 
     search_fields = ["notification_type__title", "notification_type__help_text"]
@@ -37,5 +40,12 @@ class NotificationTypeSettingModelViewSet(viewsets.ModelViewSet):
 
     def get_queryset(self) -> QuerySet[NotificationTypeSetting]:
         return (
-            super().get_queryset().filter(user=self.request.user).annotate(help_text=F("notification_type__help_text"))
+            super()
+            .get_queryset()
+            .filter(user=self.request.user)
+            .annotate(
+                help_text=F("notification_type__help_text"),
+                locked=F("notification_type__is_lock"),
+                locked_icon=Case(When(locked=True, then=Value(WBIcon.LOCK.icon)), default=Value(None)),
+            )
         )

wbcore/contrib/pandas/fields.py

@@ -1,6 +1,8 @@
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import List
+from typing import List, Literal
+
+import pandas as pd
 
 from wbcore.serializers.fields.types import DisplayMode
 
@@ -24,6 +26,9 @@ class _BaseField:
                 base[_attr] = attr
         return base
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return value
+
 
 @dataclass
 class PKField(_BaseField):
@@ -34,11 +39,17 @@ class PKField(_BaseField):
 class CharField(_BaseField):
     type: str = "text"
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("string", errors="ignore")
+
 
 @dataclass
 class DateField(_BaseField):
     type: str = "date"
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return pd.to_datetime(super().to_representation(value)).dt.strftime("%Y-%m-%d")
+
 
 @dataclass
 class DateRangeField(_BaseField):
@@ -54,6 +65,9 @@ class BooleanField(_BaseField):
 class TextField(_BaseField):
     type: str = "texteditor"
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("string", errors="ignore")
+
 
 @dataclass
 class EmojiRatingField(_BaseField):
@@ -64,43 +78,44 @@ class EmojiRatingField(_BaseField):
 class FloatField(_BaseField):
     type: str = "number"
     precision: int = 2
-    delimiter: str = ","
-    decimal_mark: str = "."
     percent: bool = False
     display_mode: DisplayMode = None
+    disable_formatting: bool = False
 
     def to_dict(self):
         base = super().to_dict()
         base.update(
             {
                 "precision": self.precision,
-                "delimiter": self.delimiter,
-                "decimal_mark": self.decimal_mark,
             }
         )
         if self.percent:
             base["type"] = "percent"
         if self.display_mode:
             base["display_mode"] = self.display_mode.value
+        base["disable_formatting"] = self.disable_formatting
         return base
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("float", errors="ignore")
+
 
 @dataclass
 class IntegerField(FloatField):
     type: str = "number"
     precision: int = 0
 
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("Int64", errors="ignore")
+
 
 @dataclass
 class YearField(IntegerField):
     precision: int = 0
-    delimiter: str = ""
-    decimal_mark: str = "."
+    disable_formatting: bool = True
 
     def __post_init__(self):
         self.precision = 0
-        self.delimiter = ""
-        self.decimal_mark = "."
 
 
 @dataclass
@@ -116,12 +131,25 @@ class JsonField(_BaseField):
 @dataclass
 class SparklineField(ListField):
     type: str = "sparkline"
+    dimension: Literal["single"] | Literal["double"] = (
+        "single"  # "single" for data [y1, y2, y3... ] or "double" if contain already the X axis as [[x1, y1], [x2, y2], ... ]
+    )
 
     def to_dict(self):
         rv = super().to_dict()
-        rv["sparkline_type"] = "column"
+        rv["sparkline_type"] = "bar"
         return rv
 
+    def _sanitize_row(self, row):
+        if not row:
+            row = [[]]  # if row is [] or null, we default to an empty list of list
+        if self.dimension == "single":  # This ensure that the returned data format contains a list of tuple of x,y
+            row = list(map(lambda o: (o[0], o[1]), enumerate(row)))
+        return row
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).apply(lambda x: self._sanitize_row(x))
+
 
 @dataclass(unsafe_hash=True)
 class PandasFields:

wbcore/contrib/pandas/filters.py

@@ -44,7 +44,10 @@ class PandasDjangoFilterBackend(DjangoFilterBackend):
                         if isinstance(_filter, wb_filters.NumberFilter):
                             try:
                                 conditions.append(
-                                    self.lookups_operator[lookup_expr](df[_filter.field_name], float(value))
+                                    self.lookups_operator[lookup_expr](
+                                        df[_filter.field_name],
+                                        float(value) if not _filter.percent else float(value) / 100,
+                                    )
                                 )
                             except ValueError:
                                 pass

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/tests/test_fields/test_number_fields.py

@@ -1,10 +1,7 @@
 import pytest
-from faker import Faker
 
 from wbcore.contrib.pandas.fields import YearField as PandasYearField
 
-fake = Faker()
-
 
 class TestPandasYearField:
     @pytest.mark.parametrize(
@@ -13,12 +10,10 @@ class TestPandasYearField:
             "label",
         ),
         [
-            (fake.word(), fake.word()),
+            ("Foo", "Bar"),
         ],
     )
     def test_pandas_year_field_values(self, key, label):
-        field = PandasYearField(key=key, label=label, precision=2, decimal_mark="*", delimiter=",")
+        field = PandasYearField(key=key, label=label, precision=2)
         representation = field.to_dict()
         assert representation["precision"] == 0
-        assert representation["decimal_mark"] == "."
-        assert representation["delimiter"] == ""

wbcore/contrib/pandas/utils.py

@@ -141,7 +141,7 @@ def override_number_to_integer_without_decorations(df: DataFrame, *conditions, f
                     value="number",
                     precision=0,
                     displayMode="decimal",
-                    delimiter="",
+                    disable_formatting=True,
                 )
             ]
         }

wbcore/contrib/pandas/views.py

@@ -1,4 +1,5 @@
 import json
+from contextlib import suppress
 from functools import cached_property
 
 import numpy as np
@@ -39,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:
@@ -58,15 +59,13 @@ class PandasMixin(CacheMixin):
         pd_fields = self.get_pandas_fields(self.request)
         # Ensure the returned data satisfy the primitive field type
         for field in pd_fields.fields:
+            if isinstance(field, fields.PKField) and field.key not in df.columns:
+                with suppress(
+                    IndexError
+                ):  # if df is empty with an empty multi-index, the pandas subrountine fails with an IndexError
+                    df = df.reset_index(names=field.key)
             if field.key in df.columns:
-                if isinstance(field, fields.FloatField):
-                    df[field.key] = df[field.key].astype("float", errors="ignore")
-                if isinstance(field, fields.CharField) or isinstance(field, fields.TextField):
-                    df[field.key] = df[field.key].astype("string", errors="ignore")
-                if isinstance(field, fields.IntegerField):
-                    df[field.key] = df[field.key].astype("Int64", errors="ignore")
-                elif isinstance(field, fields.DateField):
-                    df[field.key] = pd.to_datetime(df[field.key])
+                df.loc[:, field.key] = field.to_representation(df[field.key])
         with pd.option_context("future.no_silent_downcasting", True):
             return (
                 df.drop(columns=df.columns.difference(pd_fields.to_dict().keys()))
@@ -81,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):
@@ -111,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/factories/transition.py

@@ -7,20 +7,21 @@ from wbcore.contrib.workflow.models import Transition
 
 @factory.django.mute_signals(signals.post_save)
 class TransitionFactory(factory.django.DjangoModelFactory):
-    name = factory.Faker("text", max_nb_chars=128)
-    to_step = factory.SubFactory("wbcore.contrib.workflow.factories.RandomChildStepFactory")
-    from_step = factory.SubFactory("wbcore.contrib.workflow.factories.RandomChildStepFactory")
-    icon = factory.Iterator(WBIcon.values)
-
-    @classmethod
-    def _create(cls, model_class, *args, **kwargs):
-        # Both steps need to belong to the same workflow
-        if (from_step := kwargs.get("from_step")) and (to_step := kwargs.get("to_step")):
-            if kwargs["from_step"].workflow != kwargs["to_step"].workflow:
-                from_step.workflow = to_step.workflow
-                from_step.save()
-                kwargs["from_step"] = from_step
-        return super()._create(model_class, *args, **kwargs)
-
     class Meta:
         model = Transition
+        exclude = ("_workflow",)
+
+    _workflow = factory.SubFactory("wbcore.contrib.workflow.factories.WorkflowFactory")
+
+    from_step = factory.SubFactory(
+        "wbcore.contrib.workflow.factories.StartStepFactory",
+        workflow=factory.SelfAttribute(".._workflow"),
+    )
+    to_step = factory.SubFactory(
+        "wbcore.contrib.workflow.factories.FinishStepFactory",
+        workflow=factory.SelfAttribute(".._workflow"),
+    )
+
+    icon = factory.Iterator(WBIcon.values)
+
+    name = factory.Sequence(lambda n: f"Transition #{n}")