wbcore 2.2.1__py2.py3-none-any.whl

wbcore/utils/date_builder/__init__.py

@@ -0,0 +1,18 @@
+from .components import (
+    SecondStart,
+    SecondEnd,
+    MinuteStart,
+    MinuteEnd,
+    HourStart,
+    HourEnd,
+    WeekStart,
+    WeekEnd,
+    MonthStart,
+    MonthEnd,
+    QuarterStart,
+    QuarterEnd,
+    YearStart,
+    YearEnd,
+    Now,
+)
+from .offsets import Second, Minute, Hour, Day, BusinessDay, Week, Month, Quarter, Year

wbcore/utils/date_builder/components.py

@@ -0,0 +1,42 @@
+class Component:
+    _name: str
+
+    def __init__(self, _name: str | None = None):
+        if _name:
+            self._name = _name
+
+    def arithmetic(self, other, operator) -> "Component":
+        return Component(_name=f"{self.name}{operator}{other.name}")
+
+    def __sub__(self, other) -> "Component":
+        return self.arithmetic(other, "-")
+
+    def __add__(self, other) -> "Component":
+        return self.arithmetic(other, "+")
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+
+Now = Component("now")
+SecondStart = Component("second_start")
+SecondEnd = Component("second_end")
+MinuteStart = Component("minute_start")
+MinuteEnd = Component("minute_end")
+HourStart = Component("hour_start")
+HourEnd = Component("hour_end")
+WeekStart = Component("week_start")
+WeekEnd = Component("week_end")
+MonthStart = Component("month_start")
+MonthEnd = Component("month_end")
+QuarterStart = Component("quarter_start")
+QuarterEnd = Component("quarter_end")
+YearStart = Component("year_start")
+YearEnd = Component("year_end")

wbcore/utils/date_builder/offsets.py

@@ -0,0 +1,27 @@
+from .components import Component
+
+
+class Offset(Component):
+    name_part: str
+
+    def __init__(self, name_part: str, amount: int = 1):
+        self.name_part = name_part
+        self.amount = amount
+
+    def __call__(self, amount: int) -> "Offset":
+        return self.__class__(self.name_part, amount)
+
+    @property
+    def name(self) -> str:
+        return f"{self.amount}{self.name_part}"
+
+
+Second = Offset("seconds")
+Minute = Offset("minutes")
+Hour = Offset("hours")
+Day = Offset("days")
+BusinessDay = Offset("bdays")
+Week = Offset("weeks")
+Month = Offset("months")
+Quarter = Offset("quarters")
+Year = Offset("years")

wbcore/utils/deprecations.py

@@ -0,0 +1,11 @@
+import warnings
+
+
+def deprecate_warning(message: str):
+    warnings.simplefilter("always", DeprecationWarning)
+    warnings.warn(
+        message,
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    warnings.simplefilter("default", DeprecationWarning)

wbcore/utils/enum.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class ChoiceEnum(Enum):
+    @classmethod
+    def choices(cls):
+        return [(choice.name, choice.value) for choice in cls]
+
+    @classmethod
+    def model_choices(cls):
+        return [(choice.value, choice.value) for choice in cls]
+
+    @classmethod
+    def names(cls):
+        return [choice.name for choice in cls]
+
+    @classmethod
+    def values(cls):
+        return [choice.value for choice in cls]
+
+    @classmethod
+    def to_dict(cls):
+        return {choice.name: choice.value for choice in cls}

wbcore/utils/figures.py

@@ -0,0 +1,290 @@
+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="",
+            titlefont=dict(color="#000000"),
+            tickfont=dict(color="#000000"),
+            anchor="x",
+            side="right",
+            showline=True,
+            linewidth=1,
+            linecolor="black",
+        ),
+        yaxis_type="log",
+        xaxis=dict(
+            title="",
+            titlefont=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="",
+            titlefont=dict(color="#000000"),
+            tickfont=dict(color="#000000"),
+        ),
+        yaxis=dict(
+            title="",
+            titlefont=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=["#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 i, label in enumerate(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