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

wbcore/test/tests.py

@@ -1,7 +1,6 @@
 import pytest
 from django.conf import settings
 from django.db import models
-from django.urls import get_resolver
 
 from wbcore import serializers, viewsets
 from wbcore.pandas.views import PandasAPIViewSet
@@ -24,8 +23,6 @@ This is useful mainly when running tests, or running locally without Celery work
 """
 settings.CELERY_TASK_ALWAYS_EAGER = True
 
-get_resolver().url_patterns
-
 
 def modules_condition(module):
     return not module.startswith(("wbcore", "django", "rest_framework", "dynamic_preferences", "eventtools")) or (
@@ -122,11 +119,11 @@ class GenerateTest:
         def _test_chartviewsets(_self, cvs):
             self.test_chartviewsets(cvs)
 
-        setattr(test_class, "test_models", _test_models)
-        setattr(test_class, "test_serializers", _test_serializers)
-        setattr(test_class, "test_representationviewsets", _test_representationviewsets)
-        setattr(test_class, "test_modelviewsets", _test_modelviewsets)
-        setattr(test_class, "test_pandasviews", _test_pandasviews)
-        setattr(test_class, "test_chartviewsets", _test_chartviewsets)
+        test_class.test_models = _test_models
+        test_class.test_serializers = _test_serializers
+        test_class.test_representationviewsets = _test_representationviewsets
+        test_class.test_modelviewsets = _test_modelviewsets
+        test_class.test_pandasviews = _test_pandasviews
+        test_class.test_chartviewsets = _test_chartviewsets
 
         return test_class

wbcore/test/utils.py

@@ -1,5 +1,6 @@
 import datetime
 import json
+from contextlib import suppress
 from functools import partial
 from typing import Any, Dict
 
@@ -44,7 +45,7 @@ def get_model_factory(model):
             return mfs[0]
 
 
-def get_data_from_factory(instance, viewset, delete=False, update=False, superuser=None, factory=None):
+def get_data_from_factory(instance, viewset, delete=False, update=False, superuser=None, factory=None):  # noqa: C901
     """
     Our goal here is to get the serializer dynamically based on the viewset, use this serializer to generate data for the post and update test.
     """
@@ -113,14 +114,12 @@ def get_data_from_factory(instance, viewset, delete=False, update=False, superus
                     and _field.many_to_one
                     and (_related_fields := _field.related_fields)
                 ):
-                    try:
+                    with suppress(Exception):
                         lh_field, rh_field = _related_fields[0]
                         if isinstance(lh_field, models.fields.AutoField) or isinstance(
                             rh_field, models.fields.AutoField
                         ):
                             data[key] = get_model_factory(dict_fields_models[key].related_model).id
-                    except Exception:
-                        pass
     if update or delete:
         _kwargs = {"user": superuser, "obj_factory": obj_factory}
         if delete:

wbcore/tests/e2e/test_e2e.py

@@ -11,14 +11,14 @@ USER_PASSWORD = "User_Password"
 @pytest.mark.django_db
 class TestE2ELogin:
     def test_login_success(self, live_server, selenium):
-        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)  # noqa
         selenium.get(live_server.url)
         assert not find_element(selenium, "//div[contains(@class, 'sidebar')]")
         login(selenium, user.email, USER_PASSWORD)
         assert find_element(selenium, "//div[contains(@class, 'sidebar')]")
 
     def test_login_failure(self, live_server, selenium):
-        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)  # noqa
         selenium.get(live_server.url)
         assert not find_element(selenium, "//p[@type='error']")
         login(selenium, user.email + "Wrong Name", USER_PASSWORD)

wbcore/tests/test_cache/test_decorators.py

@@ -1,15 +1,12 @@
 import pytest
-from faker import Faker
 
 from wbcore.cache.decorators import cache_table
 from wbcore.cache.registry import periodic_cache_registry
 
-fake = Faker()
-
 
 @pytest.mark.parametrize(
     "timeout, key_prefix, periodic_caching_view_kwargs, periodic_caching_get_parameters",
-    [(fake.pyint(), fake.word(), [{"a": "a"}], [{"b": "b"}])],
+    [(2, "Foo", [{"a": "a"}], [{"b": "b"}])],
 )
 def test_cache_table(timeout, key_prefix, periodic_caching_view_kwargs, periodic_caching_get_parameters):
     @cache_table(
@@ -22,9 +19,9 @@ def test_cache_table(timeout, key_prefix, periodic_caching_view_kwargs, periodic
     class CacheTable:
         pass
 
-    assert getattr(CacheTable, "CACHE_ENABLED") is True
-    assert getattr(CacheTable, "CACHE_TIMEOUT") == timeout
-    assert getattr(CacheTable, "CACHE_KEY_PREFIX") == key_prefix
+    assert CacheTable.CACHE_ENABLED is True
+    assert CacheTable.CACHE_TIMEOUT == timeout
+    assert CacheTable.CACHE_KEY_PREFIX == key_prefix
     cache_entry = periodic_cache_registry.classes[0]
     assert cache_entry.view_class == CacheTable
     assert cache_entry.view_kwargs == periodic_caching_view_kwargs

wbcore/tests/test_configs.py

@@ -1,13 +1,10 @@
 import pytest
 from django.conf import settings
-from faker import Faker
 
 from wbcore.configs.decorators import register_config
 from wbcore.configs.registry import ConfigRegistry
 from wbcore.configs.views import ConfigAPIView
 
-fake = Faker()
-
 
 def test_registry(config_registry: ConfigRegistry):
     configs = config_registry.get_config_dict()
@@ -40,7 +37,7 @@ def test_menu_calendar_config(config_registry: ConfigRegistry):
     assert menu_calendar
 
 
-@pytest.mark.parametrize("text, version", [(fake.sentence(), fake.word())])
+@pytest.mark.parametrize("text, version", [("Foo bar", "Foo")])
 def test_beta_button_config(config_registry: ConfigRegistry, text, version):
     settings.BETA_BUTTON_VERSION = version
     settings.BETA_BUTTON_TEXT = text
@@ -55,7 +52,7 @@ def test_config_registry_decorator():
 
     assert not hasattr(some_callable, "_is_config")
     some_callable = register_config(some_callable)
-    assert getattr(some_callable, "_is_config")
+    assert some_callable._is_config
 
 
 def test_config_view(rf):

wbcore/tests/test_enums.py

@@ -1,6 +1,7 @@
 import pytest
 
-from wbcore.enums import Button, Unit
+from wbcore.enums import Unit
+from wbcore.metadata.configs.buttons.enums import Button
 
 
 class TestUnit:

wbcore/tests/test_fields/test_choice_fields.py

@@ -33,7 +33,7 @@ class TestChoiceField:
         assert self.field.field_type == WBCoreType.SELECT.value
 
     def test_representation(self):
-        choices = [{"label": choice[1], "value": choice[0]} for choice in self.CHOICES]
+        choices = [{"label": choice[1], "value": choice[0], "group": None} for choice in self.CHOICES]
         assert self.field.get_representation(None, "field_name") == (
             "field_name",
             {
@@ -47,3 +47,11 @@ class TestChoiceField:
                 "depends_on": [],
             },
         )
+
+    def test_representation_with_group(self):
+        field = ChoiceField(choices=self.CHOICES, group_key_mapping={"choice1": "group1"})
+        rep = field.get_representation(None, "field_name")[1]
+        assert rep["choices"] == [
+            {"label": "Choice 1", "value": "choice1", "group": "group1"},
+            {"label": "Choice 2", "value": "choice2", "group": None},
+        ]

wbcore/tests/test_fields/test_number_fields.py

@@ -1,15 +1,12 @@
 from decimal import Decimal
 
 import pytest
-from faker import Faker
 from rest_framework.exceptions import ValidationError
 
 from wbcore.serializers import DecimalField, FloatField, IntegerField
 from wbcore.serializers.fields import YearField
 from wbcore.serializers.fields.types import WBCoreType
 
-fake = Faker()
-
 
 class TestIntegerField:
     def setup_method(self):
@@ -44,9 +41,8 @@ class TestIntegerField:
                 "max_digits": 34,
                 "decorators": [],
                 "depends_on": [],
-                "decimal_mark": ".",
-                "delimiter": ",",
                 "signed": True,
+                "disable_formatting": False,
             },
         )
 
@@ -87,9 +83,8 @@ class TestDecimalField:
                 "decorators": [],
                 "depends_on": [],
                 "display_mode": "decimal",
-                "decimal_mark": ".",
-                "delimiter": ",",
                 "signed": True,
+                "disable_formatting": False,
             },
         )
 
@@ -109,9 +104,8 @@ class TestDecimalField:
                 "decorators": [],
                 "depends_on": [],
                 "display_mode": "decimal",
-                "decimal_mark": ".",
-                "delimiter": ",",
                 "signed": True,
+                "disable_formatting": False,
             },
         )
 
@@ -149,9 +143,8 @@ class TestFloatField:
                 "decorators": [],
                 "depends_on": [],
                 "display_mode": "decimal",
-                "decimal_mark": ".",
-                "delimiter": ",",
                 "signed": True,
+                "disable_formatting": False,
             },
         )
 
@@ -163,12 +156,11 @@ class TestYearField:
             "label",
         ),
         [
-            (fake.word(), fake.word()),
+            ("Foo", "Bar"),
         ],
     )
     def test_year_field_values(self, key, label):
-        field = YearField(label=label, precision=2, decimal_mark="*", delimiter=",")
+        field = YearField(label=label, precision=2)
         representation = field.get_representation(None, key)[1]
         assert representation["precision"] == 0
-        assert representation["decimal_mark"] == "."
-        assert representation["delimiter"] == ""
+        assert representation["disable_formatting"]

wbcore/tests/test_fields/test_other_fields.py

@@ -25,9 +25,8 @@ class TestStarRatingField:
                 "decorators": [],
                 "depends_on": [],
                 "display_mode": "decimal",
-                "decimal_mark": "",
-                "delimiter": "",
                 "signed": True,
+                "disable_formatting": True,
             },
         )
 

wbcore/tests/test_filters/test_mixins.py

@@ -14,47 +14,47 @@ class TestWBCoreFilterMixin:
     def view(self):
         return ViewSet()
 
-    @pytest.mark.parametrize("field_name", [fake.word()])
+    @pytest.mark.parametrize("field_name", ["Foo"])
     def test_key_column_name(self, field_name):
         filter_field = CharFilter(column_field_name=field_name, field_name=field_name)
         assert filter_field.key == field_name
 
-    @pytest.mark.parametrize("field_name", [fake.word()])
+    @pytest.mark.parametrize("field_name", ["Foo"])
     def test_key_field_name(self, field_name):
         filter_field = CharFilter(field_name=field_name)
         assert filter_field.key == field_name
 
-    @pytest.mark.parametrize("label", [fake.word()])
+    @pytest.mark.parametrize("label", ["Foo"])
     def test_get_label_with_label(self, label):
         filter_field = CharFilter(label=label)
         assert filter_field.get_label() == label
 
-    @pytest.mark.parametrize("field_name1, field_name2", [(fake.word(), fake.word())])
+    @pytest.mark.parametrize("field_name1, field_name2", [("Foo", "Bar")])
     def test_get_label_without_label(self, field_name1, field_name2):
         field_name = field_name1 + "_" + field_name2
         filter_field = CharFilter(field_name=field_name)
         assert filter_field.get_label() == field_name1.title() + " " + field_name2.title()
 
-    @pytest.mark.parametrize("default", [fake.word()])
-    def test__get_default_with_callable(self, rf, default, view):
-        filter_field = CharFilter(default=lambda f, r, v: default)
-        assert filter_field._get_default(rf, view) == default
+    @pytest.mark.parametrize("initial", ["Foo"])
+    def test__get_initial_with_callable(self, rf, initial, view):
+        filter_field = CharFilter(initial=lambda f, r, v: initial)
+        assert filter_field._get_initial(rf, view) == initial
 
-    @pytest.mark.parametrize("default", [fake.word()])
-    def test__get_default_with_callable_str(self, rf, default, view):
+    @pytest.mark.parametrize("initial", ["Foo"])
+    def test__get_initial_with_callable_str(self, rf, initial, view):
         class CustomFilterField(CharFilter):
-            def custom_default(self, *args):
-                return default
+            def custom_initial(self, *args):
+                return initial
 
-        filter_field = CustomFilterField(default="custom_default")
-        assert filter_field._get_default(rf, view) == default
+        filter_field = CustomFilterField(initial="custom_initial")
+        assert filter_field._get_initial(rf, view) == initial
 
-    @pytest.mark.parametrize("default", [fake.word()])
-    def test__get_default_with_default(self, rf, default, view):
-        filter_field = CharFilter(default=default)
-        assert filter_field._get_default(rf, view) == default
+    @pytest.mark.parametrize("initial", ["Foo"])
+    def test__get_initial_with_initial(self, rf, initial, view):
+        filter_field = CharFilter(initial=initial)
+        assert filter_field._get_initial(rf, view) == initial
 
-    @pytest.mark.parametrize("name", [fake.word()])
+    @pytest.mark.parametrize("name", ["Foo"])
     def test_get_representation(self, name, rf, view):
         filter_field = CharFilter(field_name=name)
         request = rf.get("")
@@ -62,48 +62,48 @@ class TestWBCoreFilterMixin:
         for key in ["label", "key", "label_format"]:
             assert key in rep
 
-    @pytest.mark.parametrize("name, initial", [(fake.word(), fake.word())])
+    @pytest.mark.parametrize("name, initial", [("Foo", "Bar")])
     def test_get_representation_request_initial(self, name, initial, rf, view):
         filter_field = CharFilter(field_name=name)
         rf.GET = {name: initial}
         _, le = filter_field.get_representation(rf, name, view)
         assert le["input_properties"]["initial"] == initial
 
-    @pytest.mark.parametrize("name, default", [(fake.word(), fake.word())])
-    def test_get_representation_field_default(self, name, default, rf, view):
-        filter_field = CharFilter(field_name=name, default=default)
+    @pytest.mark.parametrize("name, initial", [("Foo", "Bar")])
+    def test_get_representation_field_initial(self, name, initial, rf, view):
+        filter_field = CharFilter(field_name=name, initial=initial)
         request = rf.get("")
         _, le = filter_field.get_representation(request, name, view)
-        assert le["input_properties"]["default"] == default
+        assert le["input_properties"]["initial"] == initial
 
-    @pytest.mark.parametrize("name, default, help_text", [(fake.word(), fake.word(), fake.word())])
-    def test_get_help_text(self, name, default, help_text, rf, view):
+    @pytest.mark.parametrize("name, initial, help_text", [("Foo", "Bar", "Sesquipedalophobie")])
+    def test_get_help_text(self, name, initial, help_text, rf, view):
         request = rf.get("")
 
         # assert that no field nor help text nor label returns an empty help_text
-        filter_field = CharFilter(field_name=name, default=default, help_text=None)
+        filter_field = CharFilter(field_name=name, initial=initial, help_text=None)
         assert filter_field.get_representation(request, name, view)[0]["help_text"] is None
 
         # assert that no field nor help text but a label returns an "Filter by {{label}}"
-        filter_field = CharFilter(field_name=name, default=default, help_text=None, label=help_text)
+        filter_field = CharFilter(field_name=name, initial=initial, help_text=None, label=help_text)
         assert filter_field.get_representation(request, name, view)[0]["help_text"] == f"Filter by {help_text}"
 
-        filter_field = CharFilter(field_name=name, default=default, help_text=help_text)
+        filter_field = CharFilter(field_name=name, initial=initial, help_text=help_text)
         assert filter_field.get_representation(request, name, view)[0]["help_text"] == help_text
 
     @patch("wbcore.filters.mixins.get_model_field")
-    @pytest.mark.parametrize("name, default, text", [(fake.word(), fake.word(), fake.word())])
-    def test_get_help_text_from_model_help_text(self, mock_fct, name, default, text, rf, view):
+    @pytest.mark.parametrize("name, initial, text", [("Foo", "Bar", "Sesquipedalophobie")])
+    def test_get_help_text_from_model_help_text(self, mock_fct, name, initial, text, rf, view):
         class Field:
             help_text = text
 
-        class dummy_parent:
-            class _meta:
+        class DummyParent:
+            class _meta:  # noqa
                 model = "tmp"
 
         mock_fct.return_value = Field
 
-        filter_field = CharFilter(field_name=name, default=default, help_text=None)
-        filter_field.parent = dummy_parent()
+        filter_field = CharFilter(field_name=name, initial=initial, help_text=None)
+        filter_field.parent = DummyParent()
         request = rf.get("")
         assert filter_field.get_representation(request, name, view)[0]["help_text"] == text

wbcore/tests/test_list_display.py

@@ -10,7 +10,6 @@ def test_tree_group_open_level_list_display():
             fields=[],
             tree=True,
             tree_group_field="field",
-            tree_group_label="label",
             tree_group_open_level=3,
             tree_group_level_options=[TreeGroupLevelOption(list_endpoint="endpoint")],
         )
@@ -24,7 +23,6 @@ def test_not_tree_group_open_level_list_display():
             fields=[],
             tree=False,
             tree_group_field="field",
-            tree_group_label="label",
             tree_group_open_level=3,
         )
     )

wbcore/tests/test_models/test_mixins.py

@@ -3,7 +3,7 @@ from django.db import models
 from wbcore.models.orderable import OrderableModel
 
 
-class ForeignKeyClass(models.Model):
+class ForeignKeyClass(models.Model):  # noqa
     @classmethod
     def get_endpoint_basename(cls) -> str:
         return "wbcore:foreignkeyclass"

wbcore/tests/test_utils/test_date.py

@@ -4,7 +4,7 @@ import pytest
 from rest_framework.test import APIRequestFactory
 
 from wbcore.utils.date import get_date_interval_from_request, shortcut
-from wbcore.utils.date_builder import *
+from wbcore.utils.date_builder import Day, Now, WeekStart
 
 
 class TestGetDateInterval:

wbcore/tests/test_utils/test_date_builder.py

@@ -3,7 +3,31 @@ from operator import add, sub
 
 import pytest
 
-from wbcore.utils.date_builder import *
+from wbcore.utils.date_builder import (
+    BusinessDay,
+    Day,
+    Hour,
+    HourEnd,
+    HourStart,
+    Minute,
+    MinuteEnd,
+    MinuteStart,
+    Month,
+    MonthEnd,
+    MonthStart,
+    Quarter,
+    QuarterEnd,
+    QuarterStart,
+    Second,
+    SecondEnd,
+    SecondStart,
+    Week,
+    WeekEnd,
+    WeekStart,
+    Year,
+    YearEnd,
+    YearStart,
+)
 
 
 class TestDateBuilder:

wbcore/tests/test_utils/test_primary.py

@@ -36,7 +36,7 @@ class TestPrimaryMixin:
             instance_other
         }  # Test the queryset are all instance related to pivot "other"
 
-    @pytest.mark.parametrize("field", fake.word())
+    @pytest.mark.parametrize("field", ("Foo Bar"))
     def test_saving_primary(self, field):
         initial_instance = TestPrimaryModel.objects.create(primary=False, pivot="main", field=field)
         assert (

wbcore/urls.py

@@ -1,6 +1,8 @@
 from django.urls import include, path
+from dynamic_preferences.api.viewsets import GlobalPreferencesViewSet
 
 from wbcore.cache.views import clear_cache
+from wbcore.contrib.dynamic_preferences.viewsets import UserPreferencesViewSet
 from wbcore.shares.views import ShareAPIView
 
 from .configs.views import ConfigAPIView
@@ -35,6 +37,8 @@ router.register(
     FrontendUserConfigurationModelViewSet,
     basename="frontenduserconfiguration",
 )
+router.register(r"global_preferences", GlobalPreferencesViewSet, basename="global_preferences")
+router.register(r"user_preferences", UserPreferencesViewSet, basename="user_preferences")
 
 router.register(r"version", VersionModelViewSet, basename="version")
 router.register(r"revision", RevisionModelViewSet, basename="revision")

wbcore/utils/date.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from datetime import date, datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, timezone
+from zoneinfo import ZoneInfo, available_timezones
 
 from dateutil import rrule
 from django.utils.dateparse import parse_date
@@ -153,8 +154,11 @@ def get_date_interval_from_request(
 
 
 def get_number_of_hours_between_dates(
-    d1, d2, skip_weekends=True, list_public_holidays=False, hours_range=range(0, 23), granularity=12
+    d1, d2, skip_weekends=True, list_public_holidays=False, hours_range=None, granularity=12
 ):
+    if hours_range is None:
+        hours_range = range(0, 23)
+
     def convert_days_from_hours(hours, granularity, hours_per_day):
         return int(hours / granularity) * granularity / hours_per_day
 
@@ -219,3 +223,15 @@ def get_next_day_timedelta(now: datetime | None = None) -> int:
     if not now:
         now = datetime.now()
     return (datetime.combine(now.date() + timedelta(days=1), time(0, 0, 0)) - now).seconds
+
+
+def get_timezone_choices() -> list[tuple[str, str]]:
+    now_utc = datetime.now(timezone.utc)
+    tz_tuples = []  # a list of (timezone_name, timezone_name (UTC offset))
+    for tz_name in sorted(available_timezones()):
+        tz = ZoneInfo(tz_name)
+        now_in_tz = now_utc.astimezone(tz)
+        offset_str = now_in_tz.strftime("UTC%z")  # gives UTC+HHMM
+        offset_str = offset_str[:-2] + ":" + offset_str[-2:]
+        tz_tuples.append((tz_name, f"{tz_name} ({offset_str})"))
+    return tz_tuples

wbcore/utils/figures.py

@@ -183,7 +183,7 @@ def get_horizontal_barplot(
     df,
     x_label="weighting",
     y_label="aggregated_title",
-    colors=["#B4DAFF"],
+    colors: tuple[str, ...] = ("#B4DAFF",),
     colors_label=None,
     drop_null_x_value: bool = True,
 ):
@@ -204,7 +204,7 @@ def get_horizontal_barplot(
     if colors_label:
         colors = df[colors_label]
     opacity = 1
-    for i, label in enumerate(x_label):
+    for label in x_label:
         data.append(
             go.Bar(
                 name=label,

wbcore/utils/models.py

@@ -1,4 +1,5 @@
 from contextlib import suppress
+from typing import Self
 
 from django.core.exceptions import FieldDoesNotExist, FieldError
 from django.db import models
@@ -12,6 +13,7 @@ from wbcore.contrib.color.enums import WBColor
 from wbcore.contrib.color.fields import ColorField
 from wbcore.contrib.icons import WBIcon
 from wbcore.contrib.icons.models import IconField
+from wbcore.signals import post_clone
 from wbcore.utils.enum import ChoiceEnum
 
 
@@ -105,7 +107,7 @@ class Status(ChoiceEnum):
     @classmethod
     def get_color_map(cls):
         colors = [WBColor.YELLOW_LIGHT.value, WBColor.RED_LIGHT.value, WBColor.GREEN_LIGHT.value]
-        return [choice for choice in zip(cls, colors)]
+        return [choice for choice in zip(cls, colors, strict=False)]
 
 
 class PrimaryMixin(models.Model):
@@ -162,9 +164,8 @@ class PrimaryMixin(models.Model):
             next_primary = qs.first()
             next_primary.primary = True
             next_primary.save()
-            self.primary = False
-            self.save()
         if no_deletion:
+            self.primary = False
             for field_name in self.PRIMARY_ATTR_FIELDS:
                 with suppress(FieldError, FieldDoesNotExist):
                     if self._meta.get_field(field_name).null:  # ensure the field is nullable
@@ -272,5 +273,21 @@ class ResolvableModelMixin(models.Model):
     resolved = models.BooleanField(default=False, verbose_name="Resolved")
 
     def delete(self, *args, **kwargs):
-        assert not self.resolved, "Resolved Entities cannot be deleted."
+        if self.resolved:
+            raise ValueError("Resolved Entities cannot be deleted.")
         super().delete(*args, **kwargs)
+
+
+class CloneMixin(models.Model):
+    # Clone mixin
+
+    def _clone(self, **kwargs) -> Self:
+        raise NotImplementedError()
+
+    def clone(self, **kwargs) -> Self:
+        clone = self._clone(**kwargs)
+        post_clone.send(sender=self.__class__, instance=self, clone=clone, **kwargs)
+        return clone
+
+    class Meta:
+        abstract = True

wbcore/utils/reportlab.py

@@ -0,0 +1,7 @@
+from reportlab.platypus import Paragraph as BaseParagraph
+
+
+class FormattedParagraph(BaseParagraph):
+    def __init__(self, text, *args, **kwargs):
+        text = text.replace("<br>", "<br/>")  # convert the HTML line break into a compatible XML line break tag
+        super().__init__(text, *args, **kwargs)

wbcore/utils/rrules.py

@@ -21,6 +21,8 @@ def convert_rrulestr_to_dict(
         rule_dict["wkst"] = getattr(rrule, wkst)
     if byday := rule_dict.pop("byday", None):
         rule_dict["byweekday"] = [getattr(rrule, day.strip()) for day in byday.split(",")]
+    if bymonthday := rule_dict.pop("bymonthday", None):
+        rule_dict["bymonthday"] = [int(v) for v in bymonthday.split(",")]
     if dtstart:
         rule_dict["dtstart"] = dtstart
     if count:
@@ -46,7 +48,7 @@ def humanize_rrule(rrule_str: rrule) -> str:
     Returns:
         A humanized version of the rrule
     """
-    if not rrule_str._freq:
+    if rrule_str._freq is None:
         raise ValueError("We do no support humanization of rrule without frequency yet")
     text = "Every "
     freq = rrule.FREQNAMES[rrule_str._freq]

wbcore/utils/string_loader.py

@@ -21,7 +21,7 @@ class StringSourceLoader(importlib.abc.SourceLoader):
 
     def exec_module(self, module):
         code = self.source_to_code(self.data, self.get_filename(module.__name__))
-        exec(code, module.__dict__)
+        exec(code, module.__dict__)  # noqa: S102
 
     def get_spec(self):
         return importlib.machinery.ModuleSpec(self.MOD_NAME, self, origin=self.get_filename(self.MOD_NAME))