wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/analysis/financial_analysis/utils.py

@@ -0,0 +1,316 @@
+from collections import defaultdict
+from contextlib import suppress
+from datetime import date
+
+import pandas as pd
+from wbcore.pandas.utils import (
+    override_number_to_percent,
+    override_number_to_x,
+    override_number_with_currency,
+)
+from wbfdm.enums import CalendarType, Financial, MarketData, PeriodType
+from wbfdm.models import Instrument
+from wbfdm.utils import rename_period_index_level_to_repr
+
+
+class Loader:
+    """
+    Utility Class to load financial data into a Pandas dataframe with year and interim as index.
+    """
+
+    def __init__(
+        self,
+        instrument: Instrument,
+        values: list[Financial],
+        calendar_type: CalendarType = CalendarType.FISCAL,
+        market_data_values: list[MarketData] | None = None,
+        statement_values: list[Financial] | None = None,
+    ):
+        self.instrument = instrument
+        self.calendar_type = calendar_type
+        self.values = values
+        self.market_data_values = (
+            market_data_values  # specify if any extra market data needs to be merged into the dataframe
+        )
+        self.statement_values = (
+            statement_values  # specify if any extra statement needs to be merged into the dataframe
+        )
+        self.errors: dict[str, list[str]] = defaultdict(list)
+
+    def load(self) -> pd.DataFrame:
+        """
+        entry function of the class, loads the data into the dataframe and normalize it
+        """
+        return self._normalize_df(*self._get_base_df())
+
+    def _get_base_df(self) -> tuple[pd.DataFrame, pd.Series]:
+        """
+        Private method to load data into a dataframe and returns the resulting data with index [year, interim] and "financials" as columns. The source pandas series is returned as second argument
+
+        Returns:
+            a tuple of dataframe and series
+        """
+        # Get the base dataframe from a dataloader
+        df = pd.DataFrame(
+            Instrument.objects.filter(id=self.instrument.id).dl.financials(
+                values=self.values,
+                period_type=PeriodType.ALL,
+                from_year=date.today().year - 5,
+                calendar_type=self.calendar_type,
+            )
+        )
+        if df.empty:
+            self.errors["missing_data"].append("Missing financial data")
+            df = pd.DataFrame(
+                columns=[
+                    "year",
+                    "interim",
+                    "period_type",
+                    "estimate",
+                    "period_end_date",
+                    "source",
+                    "financial",
+                    "value",
+                ]
+            )
+
+        df["period_end_date"] = pd.to_datetime(df["period_end_date"])
+        source_df = (
+            df[["year", "interim", "period_type", "source"]].groupby(["year", "interim", "period_type"]).first().source
+        )
+        # Pivot the data around
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate", "period_end_date"],
+            columns="financial",
+            values="value",
+        )
+        allowed_columns: list[str] = [v.value for v in self.values]
+        if self.statement_values and not df.empty:
+            df = self._annotate_statement_data(df, self.statement_values)
+            allowed_columns.extend([v.value for v in self.statement_values])
+        # If market data should be included here, we need to annotate it and afterwards rename the column axis
+        if self.market_data_values and not df.empty:
+            df = self._annotate_market_data(df, self.market_data_values)
+            allowed_columns.extend([v.value for v in self.market_data_values])
+        df = df[[value for value in allowed_columns if value in df.columns]]
+        return df, source_df
+
+    # UTILS METHODS
+
+    def _annotate_market_data(self, df: pd.DataFrame, market_data_values: list[MarketData]) -> pd.DataFrame:
+        """
+        Annotate the given market data into the given dataframe
+
+        Args:
+            df: a Pandas dataframe to annotate extra data into
+            market_data_values:  a list of MarketData objects
+
+        Returns:
+            The extended dataframe with market data
+        """
+        # We need to reset the indexes as we merge based on columns
+        market_data_df = pd.DataFrame(
+            Instrument.objects.filter(id=self.instrument.id).dl.market_data(
+                from_date=df.index.get_level_values("period_end_date").min() if not df.empty else None,
+                target_currency=self.instrument.currency.key,
+            )
+        )
+        values = [mdv.value for mdv in market_data_values]
+        # We convert the period_end_date column to a native datetime object to allow for merges based on backwards data
+        if not market_data_df.empty:
+            market_data_df["period_end_date"] = pd.to_datetime(market_data_df["valuation_date"])
+            market_data_df = market_data_df[["period_end_date", *values]].sort_values("period_end_date")
+            df = pd.merge_asof(
+                left=df.reset_index().sort_values(by="period_end_date"),
+                right=market_data_df,
+                on="period_end_date",
+                direction="backward",
+            ).set_index(["year", "interim", "period_type", "estimate", "period_end_date"])
+            if df[values].dropna().empty:
+                self.errors["missing_data"].append(
+                    "We could not find any market data covering the financial statement period"
+                )
+        return df.rename_axis("financial", axis="columns")
+
+    def _annotate_statement_data(self, df: pd.DataFrame, statement_values: list[Financial]) -> pd.DataFrame:
+        """
+        Annotate the given statement into the given dataframe
+
+        Args:
+            df: a Pandas dataframe to annotate extra data into
+            statement_values:  a list of Financial objects
+
+        Returns:
+            The extended dataframe with statement
+        """
+        statement_df = pd.DataFrame(
+            Instrument.objects.filter(id=self.instrument.id).dl.statements(
+                financials=statement_values, from_year=date.today().year - 5
+            ),
+        )
+
+        if not statement_df.empty:
+            statement_df["period_end_date"] = pd.to_datetime(statement_df["period_end_date"])
+            statement_df = statement_df.pivot_table(
+                index=["year", "interim", "period_end_date"], columns="financial", values="value"
+            )
+            statement_df = statement_df.ffill()
+            df = pd.merge(
+                how="left",
+                left=df.reset_index().sort_values(by="period_end_date"),
+                right=statement_df,
+                on=["year", "interim"],
+            ).set_index(["year", "interim", "period_type", "estimate", "period_end_date"])
+        else:
+            self.errors["missing_data"].append("No statement data")
+
+        return df.rename_axis("financial", axis="columns")
+
+    def _normalize_df(self, df: pd.DataFrame, source_df: pd.Series) -> pd.DataFrame:
+        """
+        This private method takes a dataframe and it's related source (a source per index), reset the index to be only (year, interim) and detect any possible duplicated row.
+
+        If a duplicate is detected, we appends the attribute `errors` with the duplicated index and take the first one
+
+        Finally, we rename the index into a more human readable format and make sure the the yearly row is present for every year of data
+
+        Args:
+            df: the DataFrame to normalize
+            source_df: The Series holding the source info for all the DataFrame index
+
+        Returns:
+            A normalized DataFrame
+        """
+
+        def _ensure_yearly_row_exists(row):
+            row["interim"] = row["interim"].astype(int)
+            if row[row["interim"] == 0].empty:
+                row = pd.concat(
+                    [
+                        pd.DataFrame(
+                            [
+                                {
+                                    "year": row.name,
+                                    "interim": 0,
+                                    "period_type": "Y",
+                                    "estimate": True,
+                                    "period_end_date": row["period_end_date"].max(),
+                                }
+                            ]
+                        ),
+                        row,
+                    ],
+                    axis=0,
+                )
+            return row
+
+        new_index = (
+            df.index.to_frame(index=False)
+            .groupby(["year"], group_keys=False, as_index=False)
+            .apply(lambda row: _ensure_yearly_row_exists(row), include_groups=True)
+            .reset_index(drop=True)
+        )
+        df = df.reindex(new_index)
+
+        df = df.sort_index().reset_index(
+            level=[3, 4], names=["year", "interim", "period_type", "estimate", "period_end_date"]
+        )
+        # detect duplicates, gracefully handle it by taking the first but log the error for further usage
+        index_duplicated = df.index.duplicated()
+        if index_duplicated.any():
+            for year, interim, period_type in df.index[index_duplicated]:
+                interim_info = f"{year} Interim {period_type}{interim}"
+                with suppress(KeyError):
+                    if source := source_df.loc[(year, interim, period_type), "source"]:
+                        interim_info += f" [{source.upper()}]"
+                self.errors["duplicated_interims"].append(interim_info)
+
+            # remove duplicated index
+            df = df[~index_duplicated]
+
+        df = rename_period_index_level_to_repr(df)
+
+        return df
+
+
+class FinancialAnalysisResult:
+    """
+    Wrapper class to help present a multi index pivoted dataframe with (year, interim) as index and financials as columns into a transposed DataFrame for Tree view
+
+    This transposed dataframe is available under the attribute `formatted_df`
+    """
+
+    FINANCIAL_MAP = {**MarketData.name_mapping(), **Financial.name_mapping()}
+
+    def __init__(
+        self,
+        df,
+        ordering: list[str] | None = None,
+        ignore_group_keys: list[Financial] | None = None,
+        override_number_with_currency: str | None = None,
+        override_number_with_currency_financials: list[str] | None = None,
+        override_number_to_x_financials: list[str] | None = None,
+        override_number_to_percent_financials: list[str] | None = None,
+        errors: dict[str, list[str]] | None = None,
+    ):
+        self.df = df
+        self.columns = list(self.df.drop(columns=["estimate", "period_end_date"]).columns)
+
+        if ordering:
+            ordering.extend(["estimate", "period_end_date"])
+            allowed_columns = list(self.FINANCIAL_MAP.keys())
+            self.df = self.df[[col for col in ordering if col in self.df.columns]]
+            allowed_columns.extend(ordering)
+            self.df = self.df.drop(columns=self.df.columns.difference(allowed_columns))
+
+        if not ignore_group_keys:
+            ignore_group_keys = []
+        self.ignore_group_keys = ignore_group_keys
+        self.override_number_with_currency = override_number_with_currency
+        self.override_number_with_currency_financials = override_number_with_currency_financials
+        self.override_number_to_x_financials = override_number_to_x_financials
+        self.override_number_to_percent_financials = override_number_to_percent_financials
+        self.errors = errors
+
+        self.formatted_df, self.estimated_mapping = self._get_formatted_df()
+
+    def _get_formatted_df(self) -> tuple[pd.DataFrame, dict[str, bool]]:
+        # Transpose and reset the index twice to create an artificial index-column
+        df = self.df.copy()
+
+        # Flatten and Rename index into year-interim format
+        df.index = df.index.map(lambda index: f"{index[0]}-{index[1]}")
+
+        # store the estimate per index
+        estimated_mapping = df["estimate"].to_dict()
+
+        df = df.drop(columns=["estimate", "period_end_date"])
+
+        # get the group keys minus the one ignored
+        group_keys = [col if col not in self.ignore_group_keys and col in Financial else None for col in df.columns]
+
+        # Transpose table
+        df = df.T.reset_index().reset_index()
+
+        df["_group_key"] = group_keys
+
+        if "financial" in df.columns:
+            # set the _overriding columns to define extra decorator for the frontend
+            if self.override_number_with_currency and self.override_number_with_currency_financials:
+                override_number_with_currency(
+                    df,
+                    self.override_number_with_currency,
+                    *list(map(lambda x: df["financial"] == x, self.override_number_with_currency_financials)),
+                )
+            if self.override_number_to_x_financials:
+                override_number_to_x(
+                    df, *list(map(lambda x: df["financial"] == x, self.override_number_to_x_financials))
+                )
+            if self.override_number_to_percent_financials:
+                override_number_to_percent(
+                    df, *list(map(lambda x: df["financial"] == x, self.override_number_to_percent_financials))
+                )
+            # Rename Financials into their verbose representation
+            df.financial = df.financial.map(self.FINANCIAL_MAP)
+
+        return df.rename(columns={"index": "id"}), estimated_mapping

wbfdm/analysis/technical_analysis/__init__.py

@@ -0,0 +1 @@
+from .technical_analysis import TechnicalAnalysis

wbfdm/analysis/technical_analysis/technical_analysis.py

@@ -0,0 +1,138 @@
+from datetime import date, timedelta
+from typing import TYPE_CHECKING, Literal
+
+import pandas as pd
+from pandas.tseries.offsets import BDay
+from stockstats import StockDataFrame
+from wbfdm.analysis.technical_analysis.traces import TechnicalAnalysisTraceFactory
+from wbfdm.enums import MarketData
+
+if TYPE_CHECKING:
+    from wbfdm.models import Instrument
+
+
+class TechnicalAnalysis:
+    def __init__(self, instrument: "Instrument", sdf: StockDataFrame):
+        self.instrument = instrument
+        self._sdf = sdf
+
+    def trace_factory(self) -> TechnicalAnalysisTraceFactory:
+        return TechnicalAnalysisTraceFactory(self)
+
+    @property
+    def instrument_name(self):
+        return self.instrument.name
+
+    @classmethod
+    def init_from_dataloader(cls, instrument: "Instrument", dataloader):
+        try:
+            return cls(
+                instrument,
+                StockDataFrame.retype(
+                    pd.DataFrame(dataloader)
+                    .rename(columns={"valuation_date": "date"})
+                    .set_index("date")
+                    .sort_index()
+                    .bfill()
+                ),
+            )
+        except KeyError:
+            return cls(instrument, StockDataFrame(columns=["date", "close", "volume", "calculated"]))
+
+    @classmethod
+    def init_full_from_instrument(
+        cls, instrument: "Instrument", from_date: date | None = None, to_date: date | None = None
+    ):
+        return cls.init_from_dataloader(
+            instrument,
+            instrument.__class__.objects.filter(id=instrument.id).dl.market_data(from_date=from_date, to_date=to_date),
+        )
+
+    @classmethod
+    def init_close_from_instrument(
+        cls, instrument: "Instrument", from_date: date | None = None, to_date: date | None = None
+    ):
+        return cls.init_from_dataloader(
+            instrument,
+            instrument.__class__.objects.filter(id=instrument.id).dl.market_data(
+                values=[MarketData.CLOSE], from_date=from_date, to_date=to_date
+            ),
+        )
+
+    def add_sma(self, window, field="close"):
+        self._sdf[[f"{field}_{window}_sma"]]
+
+    def add_roc(self, window, field="close"):
+        self._sdf[[f"{field}_{window}_roc"]]
+
+    def add_shift(self, window, field="close"):
+        self._sdf[[f"{field}_{window}_s"]]
+
+    def add_delta(self, window, field="close"):
+        self._sdf[[f"{field}_{window}_d"]]
+
+    def add_drawdown(self, field="close"):
+        self._sdf["drawdown"] = self._sdf[field] - self._sdf[field].cummax()
+
+    def add_macd(self):
+        self._sdf[["macd", "macdh", "macds"]]
+
+    def add_bollinger(self, window=14):
+        self._sdf[[f"boll_{window}", f"boll_ub_{window}", f"boll_lb_{window}"]]
+        self._sdf.bfill()
+
+    def add_energy_index(self):
+        self._sdf[["cr", "cr-ma1", "cr-ma2", "cr-ma3"]]
+
+    def add_williams_index(self, window=14):
+        self._sdf[[f"wr_{window}"]]
+
+    def add_volume_variation_index(self, window=26):
+        self._sdf[[f"vr_{window}"]]
+
+    def add_return(self, return_type: Literal["log"] | Literal["normal"] = "normal"):
+        if return_type == "log":
+            self._sdf[["log-ret"]]
+        elif return_type == "normal":
+            self._sdf["ret"] = (self._sdf["close"] - self._sdf["close_-1_s"]) / self._sdf["close_-1_s"]
+
+    def add_cumulative_return(self, return_type: Literal["log"] | Literal["normal"] = "normal"):
+        if return_type == "log":
+            self._sdf["cum-log-ret"] = (1 + self._sdf[["log-ret"]]).cumprod() - 1
+        elif return_type == "normal":
+            self.add_return("normal")
+            self._sdf["cum-ret"] = (1 + self._sdf[["ret"]]).cumprod() - 1
+
+    def get_performance_between_dates(self, from_date: date, to_date: date | None = None) -> float:
+        if to_date is None:
+            to_date = date.today()
+
+        close = self.df[(self.df.index >= (pd.Timestamp(from_date) - BDay(1)).date()) & (self.df.index <= to_date)][
+            "close"
+        ]
+        if close.empty:
+            return 0
+        return (close[-1] - close[0]) / close[0]
+
+    def get_performance_year_to_date(self) -> float:
+        return self.get_performance_between_dates(from_date=date.today().replace(month=1, day=1))
+
+    def get_performance_months(self, months: int) -> float:
+        return self.get_performance_between_dates(from_date=date.today() - timedelta(30 * months))
+
+    def get_performances_dataframe(self, freq: Literal["Y"] | Literal["ME"]) -> pd.DataFrame:
+        df = self.df
+        df.index = pd.to_datetime(df.index)
+        df = df.groupby(pd.Grouper(freq=freq)).last()
+        df["performance"] = df["close"].pct_change()
+        return df[["close", "performance"]]
+
+    def get_annual_performances_dataframe(self):
+        return self.get_performances_dataframe("Y")
+
+    def get_monthly_performances_dataframe(self):
+        return self.get_performances_dataframe("ME")
+
+    @property
+    def df(self):
+        return self._sdf

wbfdm/analysis/technical_analysis/traces.py

@@ -0,0 +1,165 @@
+from contextlib import suppress
+from typing import TYPE_CHECKING, Iterable, TypeVar
+
+import pandas as pd
+from plotly import graph_objects as go
+
+from ..utils import normalize_series
+
+if TYPE_CHECKING:
+    from wbfdm.analysis.technical_analysis.technical_analysis import TechnicalAnalysis
+
+
+T = TypeVar("T", bound=go.Candlestick | go.Ohlc)
+
+
+class TechnicalAnalysisTraceFactory:
+    def __init__(self, ta: "TechnicalAnalysis"):
+        self.ta = ta
+
+    def _line_trace(
+        self,
+        key: str,
+        prefix: str,
+        base_series: pd.Series | None = None,
+        percent_format: bool = False,
+        line_options: dict | None = None,
+        show_estimates: bool = False,
+    ) -> go.Scatter:
+        # Parametrization
+        series = self.ta.df[key]
+
+        # get the calculated time series. By default all value are considered non estimated
+        calculated = pd.Series(False, index=self.ta.df.index)
+        with suppress(KeyError, UserWarning):
+            if show_estimates:
+                calculated = self.ta.df["calculated"]
+
+        if not (series := normalize_series(series, base_series=base_series)).empty:
+            inception_date = series.loc[~calculated].index.min()
+            real_series = series.loc[series.index >= inception_date]
+
+            # Prepare chart options
+            name = str(self.ta.instrument)
+            line_options = line_options if line_options else {}
+            text = []
+
+            format_template = "{y:.2%}" if percent_format else "{y:.2f}"
+            hovertemplate = "<b>" + prefix + "</b>: %" + format_template
+            # If a base series is present, we add a line into the hover template to show the difference
+            if base_series is not None and not base_series.empty:
+                hovertemplate += "<br>∆ : %{text}"
+                text = [format_template.format(y=y) for y in (real_series - base_series).dropna().values]
+
+            yield go.Scatter(
+                x=real_series.index,
+                y=real_series,
+                line=line_options,
+                name=name,
+                legendgroup=name,
+                hovertemplate=hovertemplate,
+                text=text,
+            )
+            # If data happens before the inception date, we consider them as estimated/backtesting data
+            backtesting_series = series.loc[series.index < inception_date]
+            if not backtesting_series.empty:
+                yield go.Scatter(
+                    x=backtesting_series.index,
+                    y=backtesting_series,
+                    line={**line_options, "dash": "dashdot"},
+                    name="Estimated " + name,
+                    legendgroup=name,
+                )
+
+    def _ohlc_trace(self, graph_object: type[T]) -> Iterable[T]:
+        df = self.ta.df
+        name = str(self.ta.instrument)
+        yield graph_object(
+            x=df["close"].index,
+            close=df["close"].values,
+            open=df["open"].values,
+            high=df["high"].values,
+            low=df["low"].values,
+            name=name,
+            legendgroup=name,
+        )
+
+    def performance_summary_trace(self, bar_options: dict | None = None, **kwargs) -> go.Bar:
+        summaries = {
+            "36 Months": self.ta.get_performance_months(months=36),
+            "24 Months": self.ta.get_performance_months(months=24),
+            "12 Months": self.ta.get_performance_months(months=12),
+            "YTD": self.ta.get_performance_year_to_date(),
+            "6 Months": self.ta.get_performance_months(months=6),
+            "3 Months": self.ta.get_performance_months(months=3),
+            "1 Months": self.ta.get_performance_months(months=1),
+        }
+
+        yield go.Bar(
+            x=list(reversed(summaries.keys())),
+            y=list(reversed(summaries.values())),
+            text=list(map(lambda x: f"{x:.2%}", reversed(summaries.values()))),
+            textposition="auto",
+            marker=bar_options,
+        )
+
+    def volume_trace(self) -> go.Bar:
+        df = self.ta.df
+        df["color_volume"] = "green"
+        df.loc[df.volume < 0, "color_volume"] = "red"
+        bar_chart_name = "Inflow/Outflow" if self.ta.instrument.is_managed else "Volume"
+        return go.Bar(
+            x=df.index,
+            y=df["volume"],
+            name=bar_chart_name,
+            hovertemplate="<b>" + bar_chart_name + "</b><br>%{x}<br>%{y:.4s}<extra></extra>",
+            marker={"color": df.color_volume, "opacity": 0.4},
+            yaxis="y2",
+        )
+
+    def close_trace(
+        self,
+        base_series: pd.Series | None = None,
+        line_options: dict | None = None,
+        show_estimates: bool = False,
+        **kwargs,
+    ) -> go.Scatter:
+        yield from self._line_trace(
+            "close", "Close", base_series=base_series, line_options=line_options, show_estimates=show_estimates
+        )
+
+    def sma_trace(
+        self, window: int, base_series: pd.Series | None = None, line_options: dict | None = None, **kwargs
+    ) -> go.Scatter:
+        self.ta.add_sma(window)
+        yield from self._line_trace(
+            f"close_{window}_sma", f"SMA {window}", base_series=base_series, line_options=line_options
+        )
+
+    def return_trace(
+        self, base_series: pd.Series | None = None, line_options: dict | None = None, **kwargs
+    ) -> go.Scatter:
+        self.ta.add_cumulative_return()
+        yield from self._line_trace(
+            "cum-ret", "Return", percent_format=True, base_series=base_series, line_options=line_options
+        )
+
+    def log_return_trace(
+        self, base_series: pd.Series | None = None, line_options: dict | None = None, **kwargs
+    ) -> go.Scatter:
+        self.ta.add_cumulative_return("log")
+        yield from self._line_trace(
+            "cum-log-ret", "Log-Return", percent_format=True, base_series=base_series, line_options=line_options
+        )
+
+    def drawdown_trace(
+        self, base_series: pd.Series | None = None, line_options: dict | None = None, **kwargs
+    ) -> go.Scatter:
+        self.ta.add_drawdown()
+        yield from self._line_trace("drawdown", "Drawdown", base_series=base_series, line_options=line_options)
+
+    def candlestick_trace(self, **kwargs) -> go.Candlestick:
+        yield from self._ohlc_trace(go.Candlestick)
+
+    def ohlc_trace(self, **kwargs) -> go.Ohlc:
+        yield from self._ohlc_trace(go.Ohlc)

wbfdm/analysis/utils.py

@@ -0,0 +1,32 @@
+from contextlib import suppress
+
+import pandas as pd
+
+
+def normalize_series(series: pd.Series, base_series: pd.Series | None = None) -> pd.Series:
+    """
+    Normalize the given time series by aligning and adjusting its values based on a base series.
+
+    Args:
+        series (pd.Series): The time series to be normalized.
+        base_series (pd.Series | None): The base time series for alignment and normalization.
+            If None, no alignment or normalization is performed.
+
+    Returns:
+        pd.Series: The normalized time series.
+
+    Note:
+        - If base_series is provided, the function aligns the series with the base_series and normalizes
+          the values based on the first value of both series.
+        - If the series index is older than the base series index, the function trims the series accordingly.
+        - If the first value of the series is zero or if the base series first value is zero, no normalization
+          is performed.
+    """
+    if base_series is not None and not base_series.empty:
+        with suppress(KeyError, IndexError):
+            # Ensure the series is not older than the the base serie
+            series = series.loc[series.index >= base_series.index.min()]
+            # if a base serie is provided and normalization is possible, we align the timeseries
+            if series.iloc[0] != 0 and (normalize_factor := base_series.iloc[0]):
+                series = series / series.iloc[0] * normalize_factor
+    return series

wbfdm/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+class WBFDMAppConfig(AppConfig):
+    name = "wbfdm"
+
+    def ready(self):
+        from wbfdm.management import initialize_task
+
+        post_migrate.connect(
+            initialize_task,
+            dispatch_uid="wbfdm.initialize_task",
+        )