wbfdm 1.43.1__py2.py3-none-any.whl

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()

wbfdm/contrib/metric/backends/performances.py

@@ -0,0 +1,265 @@
+from contextlib import suppress
+from datetime import date, timedelta
+from typing import Any, Generator, Iterable
+
+import numpy as np
+import pandas as pd
+from dateutil.relativedelta import relativedelta
+from django.db.models import Avg, BooleanField, DateField, F, QuerySet
+from wbfdm.models import Instrument, InstrumentPrice, RelatedInstrumentThroughModel
+
+from ..decorators import register
+from ..dto import Metric, MetricField, MetricKey
+from .base import BaseDataloader, InstrumentMetricBaseBackend
+
+PERFORMANCE_METRIC = MetricKey(
+    key="performance",
+    label="Performance",
+    subfields=[
+        MetricField(key="daily", label="Daily", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg),
+        MetricField(key="weekly", label="Weekly", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg),
+        MetricField(
+            key="monthly", label="Monthly", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(
+            key="quarterly", label="Quarterly", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(key="yearly", label="Yearly", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg),
+        MetricField(
+            key="week_to_date", label="WTD", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(
+            key="month_to_date", label="MTD", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(
+            key="quarter_to_date", label="QTD", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(
+            key="year_to_date", label="YTD", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+        MetricField(
+            key="previous_week_to_date",
+            label="Previous Week",
+            serializer_kwargs={"percent": True, "precision": 4},
+            aggregate=Avg,
+        ),
+        MetricField(
+            key="previous_month_to_date",
+            label="Previous Month",
+            serializer_kwargs={"percent": True, "precision": 4},
+            aggregate=Avg,
+        ),
+        MetricField(
+            key="previous_quarter_to_date",
+            label="Previous Quarter",
+            serializer_kwargs={"percent": True, "precision": 4},
+            aggregate=Avg,
+        ),
+        MetricField(
+            key="previous_year_to_date",
+            label="Previous Year",
+            serializer_kwargs={"percent": True, "precision": 4},
+            aggregate=Avg,
+        ),
+        MetricField(
+            key="inception", label="Inception", serializer_kwargs={"percent": True, "precision": 4}, aggregate=Avg
+        ),
+    ],
+    extra_subfields=[
+        MetricField(
+            key="is_estimated",
+            label="Estimated",
+            help_text="True if the performance used a estimated price",
+            field_type=BooleanField,
+            aggregate=None,
+        ),
+        MetricField(
+            key="date",
+            label="Performance Date",
+            help_text="The date at which the performances were computed",
+            field_type=DateField,
+            aggregate=None,
+        ),
+    ],
+    additional_prefixes=["benchmark", "peer"],
+)
+
+PERFORMANCE_METRIC_USD = MetricKey(
+    key="performance_usd",
+    label=PERFORMANCE_METRIC.label,
+    subfields=PERFORMANCE_METRIC.subfields,
+    additional_prefixes=PERFORMANCE_METRIC.additional_prefixes,
+)
+
+
+class Dataloader(BaseDataloader):
+    METRIC_KEY = "performance"
+
+    PERFORMANCE_MAP = {
+        "weekly": 7,
+        "monthly": 30,
+        "quarterly": 120,
+        "yearly": 365,
+        "daily": "B",
+        "week_to_date": "W-FRI",
+        "month_to_date": "BME",
+        "quarter_to_date": "BQE",
+        "year_to_date": "BYE",
+    }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.aggregate_callback = (
+            lambda df: df.min() if df.name == "date" else df.mean()
+        )  # we need to not sum the "date" column otherwise pandas crashes
+
+    @classmethod
+    def get_performance_date_map(cls, pivot_date) -> dict[str, date]:
+        pivot_date = pivot_date + timedelta(days=1) - pd.tseries.offsets.BDay(1)
+        return {
+            "weekly": (pivot_date - relativedelta(weeks=1) + timedelta(days=1) - pd.tseries.offsets.BDay(1)).date(),
+            "monthly": (pivot_date - relativedelta(months=1) + timedelta(days=1) - pd.tseries.offsets.BDay(1)).date(),
+            "quarterly": (
+                pivot_date - relativedelta(months=3) + timedelta(days=1) - pd.tseries.offsets.BDay(1)
+            ).date(),
+            "yearly": (pivot_date - relativedelta(years=1) + timedelta(days=1) - pd.tseries.offsets.BDay(1)).date(),
+            "daily": (pivot_date - pd.tseries.offsets.BDay(1)).date(),
+            "week_to_date": (pivot_date - pd.tseries.offsets.Week(1, weekday=4)).date(),
+            "month_to_date": (pivot_date - pd.tseries.offsets.BMonthEnd(1)).date(),
+            "quarter_to_date": (pivot_date - pd.tseries.offsets.BQuarterEnd(1)).date(),
+            "year_to_date": (pivot_date - pd.tseries.offsets.BYearEnd(1)).date(),
+        }
+
+    def get_data(self) -> Iterable[tuple[Instrument, pd.Series, pd.Series]]:
+        """
+        Helper method to return the instrument prices as a pandas Series
+
+        Args:
+            instrument: The instrument to get the prices from
+
+        Returns:
+            a tuple of the prices as Series and the calculated mask (as series as well)
+        """
+
+        qs = (
+            InstrumentPrice.objects.filter(instrument__in=self.basket_objects, date__lte=self.val_date)
+            .annotate_base_data()
+            .annotate(fx_rate=self.fx_rate_expression, price=F("net_value") / F("fx_rate"))
+        )
+        fields = ["instrument", "date", "price", "fx_rate", "calculated"]
+        instruments_map = {i.id: i for i in self.basket_objects}
+
+        if self.min_date:
+            qs = qs.filter(date__gte=self.min_date)
+        else:
+            qs = qs.filter(date__gte=F("instrument__inception_date"))
+        recs = qs.values_list(*fields)
+        df = (
+            pd.DataFrame.from_records(recs, columns=fields)
+            .sort_values(by="calculated")
+            .groupby(["instrument", "date"])
+            .agg("first")
+            .sort_index()
+        )
+        for instrument_id, dff in df.groupby(level=0):
+            dff = dff.droplevel(0)
+            dff = dff.reindex(pd.date_range(dff.index.min(), dff.index.max()), method="ffill")
+            dff.index = pd.to_datetime(dff.index).date
+            yield instruments_map[instrument_id], dff["price"].astype(float), dff["calculated"]
+
+    def _compute(self) -> dict[str, float]:
+        """
+        Compute the performance metrics for all the PERFORMANCE_MAP keys. If the basket is constituted of multiple instrument, take the average of each performance
+
+        Returns:
+            The metrics as dictionary
+        """
+        res = {}
+        if self.val_date:
+            agg_metrics = []
+            is_estimated = False
+            for _, prices_df, calculated_df in self.get_data():
+                if not prices_df.empty and not calculated_df.empty:
+                    metrics = {}
+                    is_estimated = is_estimated or bool(calculated_df.iloc[-1])
+                    for performance, start_date in self.get_performance_date_map(self.val_date).items():
+                        with suppress(KeyError):
+                            if start_price := prices_df.loc[start_date]:
+                                metrics[performance] = round(prices_df.loc[self.val_date] / start_price - 1, 6)
+                            previous_start_date = self.get_performance_date_map(start_date)[performance]
+                            if previous_start_price := prices_df.loc[previous_start_date]:
+                                metrics[f"previous_{performance}"] = round(
+                                    prices_df.loc[start_date] / previous_start_price - 1, 6
+                                )
+
+                    if not prices_df.empty and prices_df.iloc[0]:
+                        metrics["inception"] = round(float(prices_df.iloc[-1] / prices_df.iloc[0] - 1), 6)
+                    agg_metrics.append(metrics)
+            res = (
+                pd.DataFrame(agg_metrics).astype(float).mean(axis=0).replace([np.inf, -np.inf, np.nan], None).to_dict()
+            )
+            res["is_estimated"] = is_estimated
+        return res
+
+
+@register(move_first=True)
+class InstrumentPerformanceMetricBackend(InstrumentMetricBaseBackend):
+    performance = PERFORMANCE_METRIC
+    keys = [PERFORMANCE_METRIC]
+
+    def get_related_instrument_relationships(self, basket) -> QuerySet[RelatedInstrumentThroughModel]:
+        if issubclass(basket.__class__, Instrument):
+            return RelatedInstrumentThroughModel.objects.filter(instrument=basket)
+        return RelatedInstrumentThroughModel.objects.none()
+
+    def compute_metrics(self, basket: Instrument) -> Generator[Metric, None, None]:
+        val_date = self._get_valid_date(basket)
+        metrics = Dataloader(basket, val_date, target_currency_key=self.TARGET_CURRENCY_KEY).compute()
+        instrument_relationships = self.get_related_instrument_relationships(basket)
+        if instrument_relationships.exists():
+            for related_type in [
+                RelatedInstrumentThroughModel.RelatedTypeChoices.BENCHMARK,
+                RelatedInstrumentThroughModel.RelatedTypeChoices.PEER,
+            ]:
+                type_metrics = []
+                for rel in instrument_relationships.filter(related_type=related_type):
+                    type_metrics.append(
+                        Dataloader(
+                            rel.related_instrument, val_date, target_currency_key=self.TARGET_CURRENCY_KEY
+                        ).compute()
+                    )
+
+                type_metrics = pd.DataFrame(type_metrics).mean(axis=0).round(6)
+                for subfield in self.performance.subfields:
+                    if (base_value := metrics.get(subfield.key)) and (type_value := type_metrics.get(subfield.key)):
+                        metrics[f"{related_type.value.lower()}_{subfield.key}"] = round(base_value - type_value, 6)
+        metrics["date"] = val_date
+        yield Metric(
+            metrics=metrics,
+            basket_id=basket.id,
+            basket_content_type_id=self.content_type.id,
+            key=self.performance.key,
+            date=None,
+        )
+
+    def get_serializer_field_attr(self, metric_field: MetricField) -> dict[str, Any]:
+        attrs = super().get_serializer_field_attr(metric_field)
+        pivot_date = self.val_date
+        if not pivot_date:
+            pivot_date = (date.today() - pd.tseries.offsets.BDay(1)).date()
+        if "previous" in metric_field.key:
+            pivot_date = Dataloader.get_performance_date_map(pivot_date)[metric_field.key.replace("previous_", "")]
+
+        with suppress(KeyError):
+            start_date = Dataloader.get_performance_date_map(pivot_date)[metric_field.key.replace("previous_", "")]
+            attrs[
+                "help_text"
+            ] = f"The {metric_field.label} performance is computed from {start_date:%Y-%m-%d} to {pivot_date:%Y-%m-%d}"
+        return attrs
+
+
+@register(move_first=True)
+class InstrumentPerformanceUSDMetricBackend(InstrumentPerformanceMetricBackend):
+    performance = PERFORMANCE_METRIC_USD
+    keys = [PERFORMANCE_METRIC_USD]
+    TARGET_CURRENCY_KEY = "USD"

wbfdm/contrib/metric/backends/statistics.py

@@ -0,0 +1,182 @@
+from contextlib import suppress
+from datetime import date
+from typing import Generator
+
+import pandas as pd
+from django.db.models import Avg, Sum
+from wbcore.serializers.fields.number import DisplayMode
+from wbfdm.enums import Financial, PeriodType, SeriesType
+from wbfdm.models import Instrument, InstrumentPrice
+
+from ..decorators import register
+from ..dto import Metric, MetricField, MetricKey
+from ..exceptions import MetricInvalidParameterException
+from .base import BaseDataloader, InstrumentMetricBaseBackend
+
+STATISTICS_METRIC = MetricKey(
+    key="statistic",
+    label="Statistic",
+    subfields=[
+        MetricField(
+            key="revenue_y_1",
+            label="Revenue Y-1",
+            aggregate=Sum,
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="revenue_y0",
+            label="Revenue Y0",
+            aggregate=Sum,
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="revenue_y1",
+            label="Revenue Y1",
+            aggregate=Sum,
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="market_capitalization",
+            label="Market Capitalization",
+            aggregate=Sum,
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="price",
+            label="Price",
+            aggregate=Avg,
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+        ),
+        MetricField(
+            key="volume_50d",
+            label="Volume 50D",
+            aggregate=Avg,
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+    ],
+)
+
+STATISTICS_METRIC_USD = MetricKey(
+    key="statistic_usd",
+    label=STATISTICS_METRIC.label,
+    subfields=STATISTICS_METRIC.subfields,
+    additional_prefixes=STATISTICS_METRIC.additional_prefixes,
+)
+
+
+class Dataloader(BaseDataloader):
+    METRIC_KEY = "statistic"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.aggregate_callback = {
+            "revenue_y_1": "sum",
+            "revenue_y0": "sum",
+            "revenue_y1": "sum",
+            "market_capitalization": "sum",
+            "price": "mean",
+            "volume_50d": "mean",
+        }
+
+    def _compute(self) -> dict[str, float]:
+        """
+        Compute/fetch the statistics metrics. If the basket is constituted of multiple instrument, take the average of each performance
+
+        Returns:
+            The metrics as dictionary
+        """
+        if self.val_date:
+            pivot_year = self.val_date.year
+            instruments = self.basket_objects
+            df_revenue = pd.DataFrame(
+                instruments.dl.financials(
+                    values=[Financial.REVENUE],
+                    series_type=SeriesType.COMPLETE,
+                    period_type=PeriodType.ANNUAL,
+                    from_year=pivot_year - 1,
+                    to_year=pivot_year + 1,
+                )
+            )
+            if not df_revenue.empty:
+                df_revenue = (
+                    df_revenue.pivot_table(index="instrument_id", columns="year", values="value")
+                    .rename(
+                        columns={pivot_year - 1: "revenue_y_1", pivot_year: "revenue_y0", pivot_year + 1: "revenue_y1"}
+                    )
+                    .astype(float)
+                )
+            df_price = (
+                pd.DataFrame(
+                    InstrumentPrice.objects.filter(instrument__in=instruments, calculated=False, date=self.val_date)
+                    .annotate(fx_rate=self.fx_rate_expression)
+                    .annotate_market_data()
+                    .values_list(
+                        "instrument",
+                        "internal_market_capitalization",
+                        "net_value",
+                        "volume_50d",
+                        "fx_rate",
+                    ),
+                    columns=[
+                        "instrument",
+                        "market_capitalization",
+                        "price",
+                        "volume_50d",
+                        "fx_rate",
+                    ],
+                )
+                .set_index("instrument")
+                .astype(float)
+            )
+            fx_rate = df_price["fx_rate"]
+            df = pd.concat([df_revenue, df_price.drop("fx_rate", axis=1)], axis=1)
+            for key in ["revenue_y_1", "revenue_y0", "revenue_y1", "market_capitalization", "price"]:
+                if key in df.columns:
+                    df[key] = df[key] / fx_rate
+
+            if not df.empty:
+                return (
+                    df.reset_index()
+                    .agg({k: v for k, v in self.aggregate_callback.items() if k in df.columns})
+                    .dropna()
+                    .to_dict()
+                )
+        return dict()
+
+
+@register(move_first=True)
+class InstrumentFinancialStatisticsMetricBackend(InstrumentMetricBaseBackend):
+    statistic = STATISTICS_METRIC
+    keys = [STATISTICS_METRIC]
+
+    def compute_metrics(self, basket: Instrument) -> Generator[Metric, None, None]:
+        val_date = self._get_valid_date(basket)
+        metrics = Dataloader(basket, val_date, target_currency_key=self.TARGET_CURRENCY_KEY).compute()
+        yield Metric(
+            metrics=metrics,
+            basket_id=basket.id,
+            basket_content_type_id=self.content_type.id,
+            key=self.statistic.key,
+            date=None,
+        )
+
+    def _get_valid_date(self, instrument: Instrument) -> date:
+        if self.val_date is None and instrument.last_valuation_date:
+            return instrument.last_valuation_date
+        elif self.val_date:
+            with suppress(InstrumentPrice.DoesNotExist):
+                return instrument.valuations.filter(date__lte=self.val_date).latest("date").date
+        raise MetricInvalidParameterException()
+
+
+@register(move_first=True)
+class InstrumentFinancialStatisticsUSDMetricBackend(InstrumentFinancialStatisticsMetricBackend):
+    statistic = STATISTICS_METRIC_USD
+    keys = [STATISTICS_METRIC_USD]
+    TARGET_CURRENCY_KEY = "USD"

wbfdm/contrib/metric/decorators.py

@@ -0,0 +1,14 @@
+def register(move_first: bool = False, override_backend: bool = False):
+    """
+    Decorator to register the metric backend
+    """
+    from wbfdm.contrib.metric.registry import backend_registry
+
+    def _model_wrapper(backend):
+        for key in backend.keys:
+            backend_registry.set(
+                key, backend.BASKET_MODEL_CLASS, backend, move_first=move_first, override_backend=override_backend
+            )
+        return backend
+
+    return _model_wrapper

wbfdm/contrib/metric/dispatch.py

@@ -0,0 +1,23 @@
+from contextlib import suppress
+from datetime import date
+from typing import Any
+
+
+def compute_metrics(val_date: date, key: str | None = None, basket: Any | None = None, **kwargs):
+    """
+    Compute and process metrics for a given date using the MetricOrchestrator.
+
+    Args:
+        val_date (date): The validation date for the metrics computation.
+        key (Optional[str]): The optional metric backend key to narrow down the set of backends to use. Defaults to None.
+        basket (Optional[Any]): An optional basket to narrow down the backend queryset. Defaults to None.
+        **kwargs: Additional keyword arguments to pass to the MetricOrchestrator.
+
+    Returns:
+        None
+    """
+    from wbfdm.contrib.metric.orchestrators import MetricOrchestrator
+
+    with suppress(KeyError):
+        orchestrator = MetricOrchestrator(val_date, key=key, basket=basket, **kwargs)
+        orchestrator.process()