wbcore 1.59.9__py2.py3-none-any.whl

wbcore/utils/figures.py

@@ -0,0 +1,286 @@
+import functools
+import operator
+
+import pandas as pd
+import plotly.graph_objects as go
+
+
+def get_hovertemplate_timeserie(is_percent=False, currency="$"):
+    if is_percent:
+        return "%{x|%Y-%m-%d}, <b>%{y:.4%}</b>"
+    else:
+        return f"%{{x|%Y-%m-%d}}, <b>%{{y:.4s}}{currency}</b>"
+
+
+def get_default_timeserie_figure(fig=None, add_rangeslider=True, is_legend_horizontal=True):
+    if not fig:
+        fig = go.Figure()
+    fig.update_layout(
+        margin=dict(l=10, r=10, t=10, b=10),
+        # paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor="rgba(0,0,0,0)",
+        yaxis=dict(showline=True, linewidth=1, linecolor="black"),
+        xaxis=dict(
+            linewidth=0.5,
+            showgrid=True,
+            gridcolor="lightgray",
+            gridwidth=1,
+            type="date",
+            # showspikes=True,
+            # spikethickness=1,
+            zeroline=True,
+            showline=True,
+            linecolor="grey",
+            ticks="outside",
+            tickwidth=1,
+            tickcolor="black",
+            ticklen=10,
+            tickangle=45,
+            tickformatstops=[
+                go.layout.xaxis.Tickformatstop(dtickrange=[86400000, 604800000], value="%e %b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=[604800000, "M1"], value="%e %b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=["M1", "M12"], value="%b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=["M12", None], value="%Y"),
+            ],
+            rangeselector=dict(
+                buttons=list(
+                    [
+                        dict(count=1, label="1m", step="month", stepmode="backward"),
+                        dict(count=6, label="6m", step="month", stepmode="backward"),
+                        dict(count=1, label="1y", step="year", stepmode="backward"),
+                        dict(count=1, label="YTD", step="year", stepmode="todate"),
+                        dict(step="all"),
+                    ]
+                ),
+            ),
+        ),
+        autosize=True,
+        hovermode="x unified",
+    )
+    fig.update_layout(hovermode="closest", hoverlabel_namelength=-1)
+    fig.update_xaxes(showspikes=True)
+    fig.update_yaxes(showspikes=True)
+    if add_rangeslider:
+        fig.update_layout(xaxis_rangeslider_visible=True)
+    if is_legend_horizontal:
+        fig.update_layout(legend_orientation="h")
+    return fig
+
+
+def get_timeseries_chart(x_data, y_data, red, green, blue):
+    fig = go.Figure(
+        [
+            go.Scatter(
+                x=x_data,
+                y=y_data,
+                fill="tozeroy",
+                line=dict(color=f"rgb({red}, {green}, {blue})", width=1),
+                fillcolor=f"rgba({red}, {green}, {blue}, 0.1)",
+            )
+        ]
+    )
+    fig.update_layout(
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        yaxis=dict(
+            title=dict(text="", font=dict(color="#000000")),
+            tickfont=dict(color="#000000"),
+            anchor="x",
+            side="right",
+            showline=True,
+            linewidth=1,
+            linecolor="black",
+        ),
+        yaxis_type="log",
+        xaxis=dict(
+            title=dict(text="", font=dict(color="#000000")),
+            tickfont=dict(color="#000000"),
+            showline=True,
+            linewidth=0.5,
+            linecolor="black",
+            showgrid=True,
+            gridcolor="lightgray",
+            gridwidth=1,
+        ),
+        autosize=True,
+        xaxis_rangeslider_visible=True,
+    )
+
+    return fig
+
+
+def get_factsheet_timeseries_chart(df, color="rgb(120,214,255)", fillcolor="rgba(120,214,255, 0.5)", log_scale=True):
+    df = df.sort_index()
+    df.index = pd.to_datetime(df.index)
+    trace = go.Scatter(x=df.index, y=df.iloc[:, 0], fill="tonexty", line=dict(color=color, width=1))
+    fig = go.Figure()
+    fig.add_trace(trace)
+
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=0, b=0),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        xaxis=dict(
+            showgrid=True,
+            zeroline=True,
+            gridwidth=1,
+            showline=True,
+            gridcolor="grey",
+            linewidth=1,
+            linecolor="grey",
+            ticks="outside",
+            tickwidth=1,
+            tickcolor="black",
+            ticklen=10,
+            tickangle=45,
+            tickformatstops=[
+                go.layout.xaxis.Tickformatstop(dtickrange=[86400000, 604800000], value="%e %b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=[604800000, "M1"], value="%e %b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=["M1", "M12"], value="%b %y"),
+                go.layout.xaxis.Tickformatstop(dtickrange=["M12", None], value="%Y"),
+            ],
+            rangeselector=dict(
+                buttons=list(
+                    [
+                        dict(count=1, label="1m", step="month", stepmode="backward"),
+                        dict(count=6, label="6m", step="month", stepmode="backward"),
+                        dict(count=1, label="1y", step="year", stepmode="backward"),
+                        dict(count=1, label="YTD", step="year", stepmode="todate"),
+                        dict(step="all"),
+                    ]
+                ),
+                x=0,
+                xanchor="left",
+                y=1.1,
+                yanchor="top",
+            ),
+            rangeslider=dict(visible=True),
+            type="date",
+            title=dict(text="", font=dict(color="#000000")),
+            tickfont=dict(color="#000000"),
+        ),
+        yaxis=dict(
+            title=dict(text="", font=dict(color="#000000")),
+            tickfont=dict(color="#000000"),
+            anchor="x",
+            side="right",
+            autorange=True,
+            fixedrange=False,
+            showgrid=False,
+            zeroline=False,
+        ),
+    )
+    if log_scale:
+        fig.update_layout(yaxis=dict(type="log"))
+    return fig
+
+
+def get_horizontal_barplot(
+    df,
+    x_label="weighting",
+    y_label="aggregated_title",
+    colors: tuple[str, ...] = ("#B4DAFF",),
+    colors_label=None,
+    drop_null_x_value: bool = True,
+):
+    df = df.dropna(how="any")
+    if len(df.shape) == 1:
+        df = df.sort_values(ascending=True)
+        df = df.reset_index()
+        df.columns = [y_label, x_label]
+
+    if not isinstance(x_label, list):
+        x_label = [x_label]
+
+    if drop_null_x_value:
+        df = df[functools.reduce(operator.and_, [df[label] != 0 for label in x_label])]
+
+    data = []
+    df = df.sort_values(by=[x_label[0]], ascending=False)
+    if colors_label:
+        colors = df[colors_label]
+    opacity = 1
+    for label in x_label:
+        data.append(
+            go.Bar(
+                name=label,
+                x=df.loc[:, label],
+                y=df.loc[:, y_label],
+                opacity=opacity,
+                orientation="h",
+                marker=dict(color=colors),
+            )
+        )
+        opacity -= 1 / (len(x_label) + 1)
+
+    fig = go.Figure(data=data)
+
+    fig.update_layout(
+        barmode="group",
+        yaxis_autorange="reversed",
+        xaxis=dict(showgrid=False, showline=False, zeroline=False, tickformat=".1%"),
+        yaxis=dict(
+            showgrid=False,
+            showline=False,
+            zeroline=False,
+        ),
+        margin=dict(b=0, r=20, l=20, t=0, pad=20),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        # autosize=False,
+        font=dict(family="roboto", size=12, color="black"),
+    )
+    height = df.shape[0] * 40
+    if height != 0:
+        fig.update_layout(height=max(height, 100))
+
+    return fig
+
+
+def get_piechart(
+    df,
+    x_label="weighting",
+    y_label="aggregated_title",
+    hoverinfo="label+text",
+    max_number_label=3,
+    height=280,
+    with_legend=True,
+    default_normalize=True,
+    colors_map=None,
+    colors_label=None,
+):
+    df = df.sort_values(by=[x_label], ascending=False)
+    values = df[x_label]
+    label = df[y_label]
+    if default_normalize:
+        values = df.loc[(df[x_label] > 0), x_label]
+        label = df.loc[(df[x_label] > 0), y_label]
+
+    text = values.map("{:,.1%}".format)
+    fig = go.Figure(data=[go.Pie(direction="clockwise", labels=label, values=values.abs(), text=text)])
+    fig.update_traces(hoverinfo=hoverinfo, textinfo="none", textfont_size=8)
+    if colors_map:
+        fig.update_traces(marker=dict(colors=colors_map))
+    elif colors_label:
+        fig.update_traces(marker=dict(colors=df[colors_label]))
+    fig.update_layout(
+        margin=go.layout.Margin(b=0, l=0, r=0, t=0, pad=0),
+        # showlegend=False,
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+    )
+    if with_legend:
+        fig.update_layout(
+            height=height,
+            legend=go.layout.Legend(
+                x=0,
+                y=-1,
+                yanchor="bottom",
+                xanchor="left",
+                bgcolor="rgba(0,0,0,0)",
+                font=dict(family="roboto", size=11, color="black"),
+            ),
+        )
+    else:
+        fig.update_layout(showlegend=False)
+    return fig

wbcore/utils/html.py

@@ -0,0 +1,8 @@
+import re
+
+from inscriptis import get_text
+
+
+def convert_html2text(html):
+    mail_text = get_text(html)
+    return re.sub("[\n]+", "\n", mail_text).strip()

wbcore/utils/importlib.py

@@ -0,0 +1,13 @@
+from importlib import import_module
+from typing import Callable, Type, Union
+
+
+def import_from_dotted_path(path: str) -> Union[Type, Callable]:
+    *module_path, name = path.split(".")
+    return getattr(import_module(".".join(module_path)), name)
+
+
+def parse_signal_received_for_module(receiver_response) -> tuple[str, any]:
+    for receiver, response in receiver_response:
+        if response:
+            yield receiver.__module__.split(".", 1)[0], response

wbcore/utils/itertools.py

@@ -0,0 +1,40 @@
+from typing import Dict, Generator, Iterable, Type
+
+
+def get_inheriting_subclasses(
+    _class, only_leaf: bool = True, only_managed_model_classes: bool = True
+) -> Generator[Type, None, None]:
+    """
+    Utility function to yield all inheriting subclasses. Useful to get all children classes for instance.
+
+    Args:
+        _class: The class to yield the subclasses from
+        only_leaf: If True, returns only the leaf nodes (Default: True)
+        only_managed_model_classes: If True, returns only the class implementing the managed Django model (Default: True)
+    Returns:
+        Generator of classes
+    """
+    subclasses = _class.__subclasses__()
+    for subclass in subclasses:
+        yield from get_inheriting_subclasses(subclass, True, only_managed_model_classes)
+    if (not only_leaf or len(_class.__subclasses__()) == 0) and (
+        not only_managed_model_classes
+        or (
+            only_managed_model_classes
+            and (_meta := getattr(_class, "_meta", None))
+            and _meta.managed
+            and hasattr(_class, "objects")
+        )
+    ):
+        yield _class
+
+
+def uniquify_dict_iterable(iterable: Iterable[Dict], unique_key: str) -> Iterable[Dict]:
+    keys = list()
+    for item in iterable:
+        if key := item.get(unique_key):
+            if key not in keys:
+                keys.append(key)
+                yield item
+        else:
+            yield item

wbcore/utils/models.py

@@ -0,0 +1,293 @@
+from contextlib import suppress
+from typing import Self
+
+from django.core.exceptions import FieldDoesNotExist, FieldError
+from django.db import models
+from django.db.models.signals import post_delete, pre_delete
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from ordered_model.models import OrderedModelManager
+from rest_framework.fields import get_attribute
+
+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
+
+
+def get_and_update_or_create(model, filter_params, defaults):
+    """get or create with default values applied to existing instances
+
+    {model}.objects.get_or_create(*{filter_params}, defaults={defaults})
+
+    Arguments:
+        model {django.db.models.Model} -- The model the queryset gets applied to
+        filter_params {dict} -- The parameters that the queryset gets filter against
+        defaults {dict} -- The default values that will be applied to the instance (create, update)
+
+    Returns:
+        django.db.models.Model -- The created/updated instance of the model
+    """
+
+    instance, created = model.objects.get_or_create(**filter_params, defaults=defaults)
+    if not created:
+        model.objects.filter(id=instance.id).update(**defaults)
+        instance = model.objects.get(id=instance.id)
+        instance.save()
+    return instance
+
+
+class NoGroupBySubquery(models.Subquery):
+    """Same as the default django subquery, however does not perform a group by"""
+
+    def get_group_by_cols(self):
+        return []
+
+
+class NoGroupByExpressionWrapper(models.ExpressionWrapper):
+    def get_group_by_cols(self):
+        return []
+
+
+class ComplexToStringMixin(models.Model):
+    """Mixin that allows to store a complex to string method in the database"""
+
+    COMPUTED_STR_RECOMPUTE_PERIODICALLY: bool = True
+    COMPUTED_STR_RECOMPUTE_ON_SAVE: bool = True
+    COMPUTED_STR_MAX_LENGTH: int = 512
+
+    class Meta:
+        abstract = True
+
+    computed_str = models.CharField(max_length=COMPUTED_STR_MAX_LENGTH, null=True, blank=True, verbose_name=_("Name"))
+
+    def compute_str(self):
+        raise NotImplementedError
+
+    def __str__(self):
+        if self.computed_str:
+            return self.computed_str
+        return ""
+
+    def save(self, *args, **kwargs):
+        if self.COMPUTED_STR_RECOMPUTE_ON_SAVE or not self.id:
+            self.computed_str = self.compute_str()
+
+        if (
+            self.computed_str and len(self.computed_str) > self.COMPUTED_STR_MAX_LENGTH
+        ):  # ensure computed str does not exceed the provided max length
+            self.computed_str = (
+                self.computed_str[: self.COMPUTED_STR_MAX_LENGTH - 3] + "..."
+            )  # we materialize the fact that we pruned the computed str with ...
+
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{computed_str}}"
+
+
+class LabelKeyMixin:
+    @classmethod
+    def get_label_key(cls):
+        if hasattr(cls, "LABEL_KEY"):
+            return cls.LABEL_KEY
+        raise AssertionError(
+            f"You need to implement the get_label_key method in the class {cls} or remove the LabelKeyMixin from {cls}."
+        )
+
+
+class Status(ChoiceEnum):
+    PENDING = _("Pending")
+    DENIED = _("Denied")
+    APPROVED = _("Approved")
+
+    @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, strict=False)]
+
+
+class PrimaryMixin(models.Model):
+    """
+    Ensures that there is only one entry with primary=True
+    for models with a foreign key field to a different model and a primary field.
+    """
+
+    PRIMARY_ATTR_FIELDS: list = []  # define the list of fields that needs to introduce uniqueness
+    primary = models.BooleanField(default=False, verbose_name="Primary")
+
+    @property
+    def can_update_primary_field(self) -> bool:
+        """
+        Check if any of the primary fields have non-None values for updating.
+
+        This property evaluates whether any of the primary fields defined in
+        `PRIMARY_ATTR_FIELDS` have non-None values in the current instance.
+        It is useful to determine if the primary fields can be updated.
+
+        Returns:
+            bool: True if any primary field has a non-None value, False otherwise.
+        """
+        return any([get_attribute(self, field.split(".")) is not None for field in self.PRIMARY_ATTR_FIELDS])
+
+    def get_related_queryset(self):
+        """
+        Retrieve a queryset of related objects based on primary attributes.
+
+        This method generates a queryset for related objects of the same model
+        by filtering on primary attributes. Primary attributes are defined in
+        the class attribute `PRIMARY_ATTR_FIELDS`.
+
+        Returns:
+            QuerySet: A Django QuerySet containing related objects.
+
+        """
+        return self._meta.model.objects.filter(
+            **{field.replace(".", "__"): get_attribute(self, field.split(".")) for field in self.PRIMARY_ATTR_FIELDS}
+        )
+
+    def save(self, *args, **kwargs):
+        if self.can_update_primary_field:
+            related_qs = self.get_related_queryset()
+            if self.primary:
+                related_qs = related_qs.exclude(id=self.id)  # if self id is None, it will not exclude anything
+                related_qs.update(primary=False)
+            elif not related_qs.filter(primary=True).exists():
+                self.primary = True
+        super().save(*args, **kwargs)
+
+    def delete(self, no_deletion=True, **kwargs):
+        if self.primary and (qs := self.get_related_queryset().exclude(id=self.id)).exists():
+            next_primary = qs.first()
+            next_primary.primary = True
+            next_primary.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
+                        setattr(
+                            self, field_name, None
+                        )  # We don't delete the object, we just un-assign the entry to "hide" it
+            self.save()
+        else:
+            super().delete(**kwargs)
+
+    class Meta:
+        abstract = True
+
+
+class DefaultMixin(models.Model):
+    """
+    Ensures that there is only one instance with default=True.
+    """
+
+    default = models.BooleanField(
+        verbose_name=_("Default"),
+        default=False,
+    )
+
+    def save(self, *args, **kwargs):
+        if hasattr(self, "default"):
+            if self.default:
+                self._meta.model.objects.all().update(default=False)
+            elif self._meta.model.objects.all().count() == 0:
+                self.default = True
+        return super().save(*args, **kwargs)
+
+    class Meta:
+        abstract = True
+
+
+class ActiveObjectManager(OrderedModelManager):
+    def get_queryset(self):
+        try:
+            return super().get_queryset().filter(is_active=True)
+        except FieldError:
+            return super().get_queryset()
+
+
+class DeleteToDisableMixin(models.Model):
+    AUTOMATICALLY_CLEAN_SOFT_DELETED_OBJECTS = False
+
+    is_active = models.BooleanField(default=True)
+    deletion_datetime = models.DateTimeField(blank=True, null=True)
+
+    objects = ActiveObjectManager()
+    all_objects = models.Manager()
+
+    def delete(self, using=None, no_deletion=True, **kwargs):
+        if no_deletion:
+            pre_delete.send(
+                sender=self.__class__,
+                instance=self,
+            )
+            self.is_active = False
+            self.deletion_datetime = timezone.now()
+            self.save()
+            post_delete.send(sender=self.__class__, instance=self, using=using)
+        else:
+            super().delete(using=using, **kwargs)
+
+    class Meta:
+        abstract = True
+
+
+def get_object(model_class: models.Model, object_id: int):
+    if issubclass(model_class, DeleteToDisableMixin):
+        objects = model_class.all_objects
+    else:
+        objects = model_class.objects
+    return objects.get(id=object_id)
+
+
+class CalendarItemTypeMixin(models.Model):
+    color = ColorField(
+        verbose_name=_("Color"),
+        default="#000000",
+        unique=False,
+        blank=False,
+        null=False,
+    )
+
+    icon = IconField(
+        max_length=128,
+        unique=False,
+        verbose_name=_("Icon"),
+        blank=False,
+        null=False,
+        default=WBIcon.EVENT.value,
+    )
+
+    class Meta:
+        abstract = True
+
+
+class ResolvableModelMixin(models.Model):
+    class Meta:
+        abstract = True
+
+    resolved = models.BooleanField(default=False, verbose_name="Resolved")
+
+    def delete(self, *args, **kwargs):
+        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