wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/contrib/dsws/client.py

@@ -0,0 +1,285 @@
+import math
+import re
+from datetime import date
+from typing import Generator, List, Optional
+
+import DatastreamPy as dsweb
+import numpy as np
+import pandas as pd
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+
+
+class Client:
+    MAXIMUM_ITEMS_PER_BUNDLE: int = 500
+    MAXIMUM_REQUESTS_PER_BUNDLE: int = 20
+    MAXIMUM_INSTRUMENTS_PER_REQUEST: int = 50
+    MAXIMUM_DATATYPES_PER_REQUEST: int = 50
+    MAXIMUM_ITEMS_PER_REQUEST: int = 100
+    PRICE_ERROR_MARGIN: float = 0.10
+    IBUNIT_DEFAULT_UNIT: float = 1e6
+
+    def __init__(self, username: Optional[str] = None, password: Optional[str] = None):
+        self.connection = dsweb.DataClient(None, username, password)
+        super().__init__()
+
+    @classmethod
+    def get_chunked_list(cls, identifiers: list[str], fields_number: int) -> list[list[str]]:
+        instruments_number = len(identifiers)
+        max_chunks_number = instruments_number * fields_number / cls.MAXIMUM_ITEMS_PER_BUNDLE
+        chunk_size = int(instruments_number / max_chunks_number) - 1
+        res = []
+        for x in range(0, len(identifiers), chunk_size):
+            res.append(identifiers[x : x + chunk_size])
+        return res
+
+    @classmethod
+    def _breakdown_requests(
+        cls, tickers: List[str], symbols: List[str]
+    ) -> Generator[tuple[list[str], list[str]], None, None]:
+        """
+        Helper function to generate tuple of ticker and symbols that respect the API data usage
+        Args:
+            tickers: List of tickers to fetch
+            symbols: Corresponding list of symbol to fetch
+
+        Returns:
+            Yield tuple of list of string
+        """
+        if len(tickers) * len(symbols) > cls.MAXIMUM_ITEMS_PER_BUNDLE:
+            raise ValueError(f"The maximum number of items for a bundle is {cls.MAXIMUM_ITEMS_PER_BUNDLE}")
+
+        if (
+            len(tickers) * len(symbols) <= cls.MAXIMUM_ITEMS_PER_REQUEST
+            and len(tickers) <= cls.MAXIMUM_INSTRUMENTS_PER_REQUEST
+        ):
+            yield tickers, symbols
+        else:
+            nb_tickers = min(
+                math.floor(cls.MAXIMUM_ITEMS_PER_REQUEST / len(symbols)),
+                len(tickers),
+                cls.MAXIMUM_INSTRUMENTS_PER_REQUEST,
+            )
+            yield tickers[0:nb_tickers], symbols
+            yield from cls._breakdown_requests(tickers[nb_tickers:], symbols)
+
+    def get_last_fx_rate(self, base_currency_key: str, target_currency_key: str):
+        last_currency_rate = CurrencyFXRates.objects.latest("date").date
+        try:
+            base_currency = Currency.objects.get(key=base_currency_key)
+            target_currency = Currency.objects.get(key=target_currency_key)
+            return float(base_currency.convert(last_currency_rate, target_currency, exact_lookup=True))
+        except Currency.DoesNotExist:
+            return 1.0
+
+    def _process_raw_requests(self, tickers: list[str], fields: list[str], **extra_client_kwargs) -> pd.DataFrame:
+        """
+        Utility function to fetch data in bulk, aggregate and clean the result
+        Args:
+            tickers: Instruments tickers
+            fields: Symbols
+            **extra_client_kwargs: Extra keyword arguments to be passed down to the client (e.g. frequency)
+
+        Returns:
+            An aggregated and cleaned dataframe with [Dates, Instrument] as index for timeserie and [Instrument] As index for static data
+        """
+        requests_data = list(self._breakdown_requests(tickers, fields))
+        reqs = []
+        if len(requests_data) > self.MAXIMUM_REQUESTS_PER_BUNDLE:
+            raise ValueError(f"number of request exceed {self.MAXIMUM_REQUESTS_PER_BUNDLE}")
+        # Construct the requests bundle
+        for request_tickers, request_symbols in requests_data:
+            # Convert a list of string into a valid string
+            converted_ticker = ",".join(request_tickers)
+            if "start" in extra_client_kwargs or "end" in extra_client_kwargs:
+                reqs.append(
+                    self.connection.post_user_request(tickers=converted_ticker, fields=fields, **extra_client_kwargs)
+                )
+            else:
+                reqs.append(self.connection.post_user_request(tickers=converted_ticker, fields=fields, kind=0))
+        # concat the bundle results
+        res = self.connection.get_bundle_data(bundleRequest=reqs)
+
+        df = pd.DataFrame()
+        if res:
+            if "start" in extra_client_kwargs or "end" in extra_client_kwargs:
+                res = list(filter(lambda subdf: subdf.index.name == "Dates", res))
+            if res:
+                df = pd.concat(res)
+                if df.index.name == "Dates":
+                    df = (
+                        pd.melt(df, ignore_index=False)
+                        .reset_index()
+                        .rename(columns={"value": "Value", "Field": "Datatype"})
+                    )
+                df.Value = df.Value.apply(lambda x: None if str(x).startswith("$$ER") else x)
+                if not df.empty:
+                    df = df[df.Value.notnull()]
+                    df = df.replace({"NA": None})
+                    if "Dates" in df.columns:
+                        df.Dates = pd.to_datetime(df.Dates, utc=True)
+                        indexes = ["Instrument", "Dates"]
+                    else:
+                        indexes = ["Instrument"]
+                    df = pd.pivot_table(
+                        df, values="Value", index=indexes, columns="Datatype", aggfunc="first", dropna=False
+                    )
+        return df
+
+    def _normalize_df_units(
+        self,
+        df: pd.DataFrame,
+        ibes_non_per_share_fields: list[str] | None = None,
+        ibes_currency_based_fields: list[str] | None = None,
+        ibes_fields: list[str] | None = None,
+        **extra_client_kwargs,
+    ) -> pd.DataFrame:
+        """
+        Datastream use arbitrary units for some symbols where the denominator needs to be fetch in two steps:
+        * Using FIELD#U to get the datastream unit
+        * if ibes_non_per_share_fields is provided, fetch for the static symbol IBUNIT and normalized the given columns with the result times a constant (100000)
+        * if ibes_currency_based_fields is provided, fetch for the static symbol IBCUR and normalized the given columns latest found currency rate.
+        This function uses the index named "Instrument" as ticker fields and the columns as symbols. Start, End or Frequency needs to be passed down using the extra_client_kwargs argument
+
+        Args:
+            df: The dataframe to be normalized
+            ibes_non_per_share_fields: Columns that need ibunit normalization. Defaults to None
+            ibes_currency_based_fields: Columns that need IBES Currency conversion from static field IBCUR
+            **extra_client_kwargs: Extra keywords arguments to be passed down to the client (e.g. frequency)
+
+        Returns:
+            A normalized dataframe (e.g. volume are in shares and not a million of shares)
+        """
+        if not ibes_fields:
+            ibes_fields = []
+        df = df.copy()
+        fields = df.columns.unique().tolist()
+        tickers = df.index.get_level_values("Instrument").unique().tolist()
+        dfu = self._process_raw_requests(tickers, list(map(lambda x: x + "#U", fields)), **extra_client_kwargs).fillna(
+            1
+        )
+        dfu = dfu[dfu.index.isin(df.index)]
+        if not dfu.empty:
+            dfu = dfu.rename(columns=lambda x: x.replace("#U", "")).fillna(1)
+            dfu = dfu[dfu.columns.intersection(df.columns)]
+            dff = df[dfu.columns].multiply(dfu, fill_value=1)
+
+            # We do this to ensure that not provided data (nan) are not set with the multiplication with the U matrix
+            dff[df.isnull()] = df[df.isnull()]
+            dff[df.columns.difference(dff.columns)] = df[
+                df.columns.difference(dff.columns)
+            ]  # We ensure that the inital colums from df are appended to the new dataframe if missing from dfu. (happens when the colum has non number values)
+            df = dff
+
+            # If the symbol is computed directly from refinitiv, we need to normalize it as well given the formula (define as the field name)
+            for mav_field in list(filter(lambda x: "MAV#" in x, fields)):
+                re_matches = re.findall(r"X\(([^\)]+)\)", mav_field)
+                if len(re_matches) > 0 and re_matches[0] in dfu.columns:
+                    df.loc[:, mav_field] = df.loc[:, mav_field] * dfu.loc[:, re_matches[0]]
+
+        if ibes_non_per_share_fields:
+            df_ibunit = self.get_static_df(tickers, ["IBUNIT"]).fillna(1)
+            if not df_ibunit.empty:
+                df_ibunit = df_ibunit.set_index("Instrument")["IBUNIT"]
+                df[df.columns.intersection(ibes_non_per_share_fields)] = (
+                    df[df.columns.intersection(ibes_non_per_share_fields)].multiply(
+                        df_ibunit, axis=0, level="Instrument"
+                    )
+                    * self.IBUNIT_DEFAULT_UNIT
+                )
+                ibes_fields = list(set(ibes_fields + ibes_non_per_share_fields))
+        if ibes_currency_based_fields:
+            df_ibcur = self.get_static_df(tickers, ["IBCUR", "ISOCUR"]).replace(
+                "BPN", "GBX"
+            )  # BPN == GBX but our db only support the latter
+            if not df_ibcur.empty:
+                df_ibcur["rate"] = 1
+                different_curr_idx = df_ibcur["IBCUR"] != df_ibcur["ISOCUR"]
+                df_ibcur.loc[different_curr_idx, "rate"] = df_ibcur.loc[different_curr_idx].apply(
+                    lambda x: self.get_last_fx_rate(x["IBCUR"], x["ISOCUR"]), axis=1
+                )
+                df[df.columns.intersection(ibes_currency_based_fields)] = df[
+                    df.columns.intersection(ibes_currency_based_fields)
+                ].multiply(df_ibcur.set_index("Instrument")["rate"], axis=0, level="Instrument")
+                ibes_fields = list(set(ibes_fields + ibes_currency_based_fields))
+        if ibes_fields:
+            df[df.columns.intersection(ibes_fields)] = (
+                df[df.columns.intersection(ibes_fields)] * self.IBUNIT_DEFAULT_UNIT
+            )
+        return df
+
+    def get_static_df(self, tickers: List[str], fields: List[str], **kwargs) -> pd.DataFrame:
+        """
+        Public function to returns a dataframe for static symbols
+
+        Args:
+            tickers: Ticker to fetch
+            fields: Static symbols to fetch
+
+        Returns:
+            A valid dataframe result
+        """
+        # Breakdown tickers and fields into a valid datastream parameters subsets
+        return self._process_raw_requests(tickers, fields).reset_index()
+
+    def get_timeserie_df(
+        self,
+        tickers: List[str],
+        fields: List[str],
+        ibes_non_per_share_fields: Optional[list[str]] = None,
+        ibes_currency_based_fields: Optional[list[str]] = None,
+        ibes_fields: list[str] | None = None,
+        **extra_client_kwargs,
+    ) -> pd.DataFrame:
+        """
+        Public function to get timeserie type data
+        Args:
+            tickers: Instrument tickers
+            fields: Symbols to fetch
+            ibes_non_per_share_fields: Columns that need ibunit normalization. Defaults to None
+            ibes_currency_based_fields: Columns that need IBES Currency conversion from static field IBCUR
+            **extra_client_kwargs: Extra keywords arguments to be passed down to the client (e.g. frequency)
+
+        Returns:
+            The result as a dataframe
+        """
+        if (start := extra_client_kwargs.get("start", None)) and isinstance(start, date):
+            extra_client_kwargs["start"] = start.strftime("%Y-%m-%d")
+        if (end := extra_client_kwargs.get("end", None)) and isinstance(end, date):
+            extra_client_kwargs["end"] = end.strftime("%Y-%m-%d")
+
+        final_df_list = []
+        # Sometime, we get too many fields and therefore, we need to split them based on the maximum number of symbols allowed per request
+        for splited_fields in np.array_split(fields, math.ceil((len(fields) / self.MAXIMUM_DATATYPES_PER_REQUEST))):
+            # Breakdown tickers and fields into a valid datastream parameters subsets
+            df = self._process_raw_requests(tickers, list(splited_fields), **extra_client_kwargs)
+            if not df.empty:
+                df = self._normalize_df_units(
+                    df,
+                    ibes_non_per_share_fields=ibes_non_per_share_fields,
+                    ibes_currency_based_fields=ibes_currency_based_fields,
+                    ibes_fields=ibes_fields,
+                    **extra_client_kwargs,
+                )
+                df = (
+                    df.reset_index()
+                    .rename_axis(None)
+                    .replace([np.inf, -np.inf, np.nan], None)
+                    .dropna(how="all", subset=df.columns.intersection(splited_fields))
+                )
+                if not df.empty:
+                    if "Dates" in df.columns:
+                        df = df.set_index(["Instrument", "Dates"])
+                    else:  # otherwise it's not a timeseries and we set index only on instrument
+                        df = df.set_index(["Instrument"])
+                    final_df_list.append(df)
+        if final_df_list:
+            return pd.concat(final_df_list, axis=1).reset_index()
+        return pd.DataFrame()
+
+    def raw_fetch(
+        self, tickers: List[str], fields: List[str], start: Optional[date] = None, end: Optional[date] = None
+    ):
+        """
+        Utility function to expose the client directly without any modification
+        """
+        return self.connection.get_data(tickers=tickers, fields=fields, start=start, end=end)

wbfdm/contrib/internal/dataloaders/market_data.py

@@ -0,0 +1,87 @@
+from datetime import date
+from decimal import Decimal
+from typing import Iterator
+
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbfdm.dataloaders.protocols import MarketDataProtocol
+from wbfdm.dataloaders.types import MarketDataDict
+from wbfdm.enums import MarketData
+from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+
+MarketDataMap = {
+    "SHARES_OUTSTANDING": "internal_outstanding_shares",
+    "OPEN": "net_value",
+    "CLOSE": "net_value",
+    "HIGH": "net_value",
+    "LOW": "net_value",
+    "BID": "net_value",
+    "ASK": "net_value",
+    "VOLUME": "internal_volume",
+    "MARKET_CAPITALIZATION": "market_capitalization",
+}
+
+DEFAULT_VALUES = [MarketData[name] for name in MarketDataMap.keys()]
+
+
+def _cast_decimal_to_float(value: float | Decimal) -> float:
+    if isinstance(value, Decimal):
+        value = float(value)
+    return value
+
+
+class MarketDataDataloader(MarketDataProtocol, Dataloader):
+    def market_data(
+        self,
+        values: list[MarketData] | None = [MarketData.CLOSE],
+        from_date: date | None = None,
+        to_date: date | None = None,
+        exact_date: date | None = None,
+        calculated: bool | None = None,
+        **kwargs,
+    ) -> Iterator[MarketDataDict]:
+        """Get prices for instruments.
+
+        Args:
+            values (list[MarketData]): List of values to include in the results.
+            from_date (date | None): The starting date for filtering prices. Defaults to None.
+            to_date (date | None): The ending date for filtering prices. Defaults to None.
+            frequency (Frequency): The frequency of the requested data
+
+        Returns:
+            Iterator[MarketDataDict]: An iterator of dictionaries conforming to the DailyValuationDict.
+        """
+        prices = InstrumentPrice.objects.filter(instrument__in=self.entities).annotate_market_data()  # type: ignore
+        if calculated is not None:
+            prices = prices.filter(calculated=calculated)
+        else:
+            prices = prices.filter_only_valid_prices()
+
+        prices = prices.order_by("date")
+        if not values:
+            values = DEFAULT_VALUES
+        values_map = {value.name: MarketDataMap[value.name] for value in values if value.name in MarketDataMap}
+        if exact_date:
+            prices = prices.filter(date=exact_date)
+        else:
+            if from_date:
+                prices = prices.filter(date__gte=from_date)
+            if to_date:
+                prices = prices.filter(date__lte=to_date)
+        for row in prices.filter_only_valid_prices().values(
+            "date",
+            "instrument",
+            "calculated",
+            *set(values_map.values()),
+        ):
+            external_id = row.pop("instrument")
+            val_date = row.pop("date")
+            if row:
+                yield MarketDataDict(
+                    id=f"{external_id}_{val_date}",
+                    valuation_date=val_date,
+                    instrument_id=external_id,
+                    external_id=external_id,
+                    source="wbfdm",
+                    calculated=row["calculated"],
+                    **{MarketData[k].value: _cast_decimal_to_float(row[v]) for k, v in values_map.items()},
+                )

wbfdm/contrib/metric/admin/__init__.py

@@ -0,0 +1,2 @@
+from .metrics import InstrumentMetricModelAdmin, InstrumentMetricGenericInline
+from .instruments import InstrumentModelAdmin

wbfdm/contrib/metric/admin/instruments.py

@@ -0,0 +1,12 @@
+from django.contrib import admin
+from wbfdm.admin.instruments import InstrumentModelAdmin as BaseInstrumentModelAdmin
+from wbfdm.models.instruments import Instrument
+
+from .metrics import InstrumentMetricGenericInline
+
+admin.site.unregister(Instrument)
+
+
+@admin.register(Instrument)
+class InstrumentModelAdmin(BaseInstrumentModelAdmin):
+    inlines = (*BaseInstrumentModelAdmin.inlines, InstrumentMetricGenericInline)

wbfdm/contrib/metric/admin/metrics.py

@@ -0,0 +1,43 @@
+from django.contrib import admin
+from django.contrib.contenttypes.admin import GenericTabularInline
+
+from ..models import InstrumentMetric
+
+
+# Register your models here.
+class InstrumentMetricGenericInline(GenericTabularInline):
+    model = InstrumentMetric
+
+    ordering = ["-date", "key"]
+    ct_field = "basket_content_type"
+    ct_fk_field = "basket_id"
+    raw_id_fields = ["basket_content_type", "instrument", "parent_metric"]
+
+    fields = [
+        "date",
+        "key",
+        "metrics",
+    ]
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).select_related("basket_content_type", "instrument")
+
+
+@admin.register(InstrumentMetric)
+class InstrumentMetricModelAdmin(admin.ModelAdmin):
+    list_filter = ("key",)
+    search_fields = ("instrument__computed_str",)
+    list_display = (
+        "basket_content_type",
+        "basket_id",
+        "instrument",
+        "date",
+        "key",
+    )
+
+    autocomplete_fields = [
+        "basket_content_type",
+        "instrument",
+    ]
+    ordering = ("-date", "-key")
+    raw_id_fields = ["basket_content_type", "instrument", "parent_metric"]

wbfdm/contrib/metric/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+from django.utils.module_loading import autodiscover_modules
+
+
+class MetricConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wbfdm.contrib.metric"
+
+    def ready(self) -> None:
+        autodiscover_modules("metric.backends")

wbfdm/contrib/metric/backends/__init__.py

@@ -0,0 +1,2 @@
+from .performances import InstrumentPerformanceMetricBackend
+from .statistics import InstrumentFinancialStatisticsMetricBackend

wbfdm/contrib/metric/backends/base.py

@@ -0,0 +1,159 @@
+from contextlib import suppress
+from datetime import date
+from decimal import Decimal
+from typing import Any, Generator, Generic, Type, TypeVar
+
+import pandas as pd
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import F, Model, QuerySet, Value
+from rest_framework.serializers import Field
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbfdm.models import Instrument, InstrumentPrice
+
+from ..dto import Metric, MetricField, MetricKey
+from ..exceptions import MetricInvalidParameterException
+
+T = TypeVar("T", bound=Model)
+
+
+class AbstractBackend(Generic[T]):
+    BASKET_MODEL_CLASS: Type[Model]
+    keys: list[MetricKey]
+
+    def __init__(self, val_date: date | None):
+        self.val_date = val_date
+        if not self.BASKET_MODEL_CLASS:
+            raise ValueError("A class implementing AbstractBackend needs to define a BASKET_MODEL_CLASS")
+        self.content_type = ContentType.objects.get_for_model(self.BASKET_MODEL_CLASS)
+
+    def compute_metrics(self, basket: Any) -> Generator[Metric, None, None]:
+        raise NotImplementedError()
+
+    def get_queryset(self) -> QuerySet:
+        return self.BASKET_MODEL_CLASS.objects.all()
+
+    def get_serializer_field_attr(self, metric_field: MetricField) -> dict[str, Any]:
+        """
+        Returns all the serializer attributes for that metric
+
+        We expect the implementing backends to override this method to define custom logics
+        """
+        return {
+            "decorators": metric_field.decorators,
+            "help_text": metric_field.help_text,
+            **metric_field.serializer_kwargs,
+        }
+
+    def get_serializer_fields(
+        self, with_prefixed_key: bool = False, metric_key: MetricKey | None = None
+    ) -> dict[str, Field]:
+        if metric_key is None:
+            metric_keys = self.keys
+        else:
+            metric_keys = [metric_key]
+        fields = {}
+        for metric_key in metric_keys:
+            fields.update(
+                {
+                    field_key: wb_serializers.FloatField(
+                        label=field_title,
+                        read_only=True,
+                        **self.get_serializer_field_attr(metric_key.subfields_map[field_key]),
+                    )
+                    for field_key, field_title in metric_key.get_fields(with_prefixed_key=with_prefixed_key)
+                }
+            )
+            for extra_subfield in metric_key.extra_subfields:
+                fields[
+                    f"{metric_key.key}_{extra_subfield.key}"
+                ] = wb_serializers.ModelSerializer.serializer_field_mapping[extra_subfield.field_type](
+                    read_only=True, label=extra_subfield.label, **self.get_serializer_field_attr(extra_subfield)
+                )
+        return fields
+
+
+class InstrumentMetricBaseBackend(AbstractBackend[Instrument]):
+    BASKET_MODEL_CLASS = Instrument
+    TARGET_CURRENCY_KEY: str | None = None
+
+    def get_queryset(self) -> QuerySet[Instrument]:
+        return super().get_queryset().filter(is_investable_universe=True)
+
+    def _get_valid_date(self, instrument: Instrument) -> date:
+        if self.val_date is None and instrument.last_price_date:
+            return instrument.last_price_date
+        elif self.val_date:
+            with suppress(InstrumentPrice.DoesNotExist):
+                return instrument.prices.filter(date__lte=self.val_date).latest("date").date
+        else:
+            raise MetricInvalidParameterException()
+
+
+class BaseDataloader:
+    METRIC_KEY: str
+
+    def __init__(
+        self,
+        basket,
+        val_date: date | None = None,
+        min_date: date | None = None,
+        target_currency_key: str | None = None,
+        use_cached_metrics_key: str | None = None,
+        basket_objects: QuerySet | None = None,
+    ):
+        self.val_date = val_date
+        self.min_date = min_date
+        self.basket = basket
+        self.use_cached_metrics_key = use_cached_metrics_key
+        self.target_currency_key = target_currency_key
+        self.basket_objects = basket_objects
+        if self.basket_objects is None:
+            self.basket_objects = self._get_basket_basket_objects()
+        self.basket_object_ids = list(map(lambda x: x.id, self.basket_objects))
+        self.aggregate_callback = "mean"
+        if self.target_currency_key == "USD":
+            self.fx_rate_expression = F("currency_fx_rate_to_usd__value")
+        elif self.target_currency_key:
+            self.fx_rate_expression = CurrencyFXRates.get_fx_rates_subquery_for_two_currencies(
+                "date", start_currency="instrument__currency", target_currency=self.target_currency_key
+            )
+        else:
+            self.fx_rate_expression = Value(Decimal(1.0))
+
+    def _get_basket_basket_objects(self) -> QuerySet:
+        """
+        Return an iterable of instrument contains within the basket. Expected to be override for custom logic
+
+        Returns:
+            An iterable of instrument. Default to the basket itself
+        """
+        return Instrument.objects.filter(id=self.basket.id)
+
+    def _compute(self):
+        raise NotImplementedError()
+
+    def compute(self):
+        if self.basket_object_ids:
+            if self.use_cached_metrics_key:
+                from wbfdm.contrib.metric.models import InstrumentMetric
+
+                df = pd.json_normalize(
+                    InstrumentMetric.objects.filter(
+                        basket_content_type=ContentType.objects.get_for_model(self.basket_objects.model),
+                        basket_id__in=self.basket_object_ids,
+                        key=self.use_cached_metrics_key,
+                        date__isnull=True,
+                    ).values_list("metrics", flat=True)
+                )
+                if not df.empty:
+                    if (
+                        "date" in df.columns
+                    ):  # it can happen that the cached metric don't contain a date key value, so we ffill it in case
+                        df["date"] = df["date"].ffill()
+                    if isinstance(self.aggregate_callback, dict):
+                        df = df.agg({k: v for k, v in self.aggregate_callback.items() if k in df.columns})
+                    else:
+                        df = df.agg(self.aggregate_callback)
+                    return df.dropna().to_dict()
+        return self._compute()