wbfdm 2.2.1__py2.py3-none-any.whl

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

wbfdm/contrib/metric/dto.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Any, Optional, Type
+
+from django.db.models import Aggregate, FloatField, Sum
+
+
+@dataclass
+class MetricField:
+    """
+    A DTO Class to represent the metric subfield computed by metric backend for a given Metric Key.
+
+    list_display_kwargs: Contains keyword argument to be inserted in a dp.Field
+    """
+
+    key: str
+    label: str
+    list_display_kwargs: dict[str, Any] = field(default_factory=dict)
+    aggregate: Type[Aggregate] | None = Sum
+    serializer_kwargs: dict[str, Any] = field(default_factory=dict)
+    field_type: type = FloatField
+    decorators: list[dict[str, str]] = field(
+        default_factory=list
+    )  # Set into a wbcore decorator accordingly (e.g. to show the metric into a specific currency)
+    help_text: str | None = None  # define if the field needs to show a particular help text
+
+
+@dataclass
+class MetricKey:
+    """
+    a DTO class to represent the metric generated by a metric backend. It contains general information regarding the type of field the metric stored (e.g. Is percent? precision? etc..)
+    """
+
+    key: str
+    label: str
+    subfields: list[MetricField]
+    extra_subfields: list[MetricField] = field(default_factory=list)
+    additional_prefixes: list[str] = field(
+        default_factory=list
+    )  # Define the optional category/groups stored in the metric json (e.g if a variable "x" is stored as well as "past_x", a prefix would be "past")
+    subfields_map: dict[str, MetricField] = field(init=False)
+    subfields_filter_map: dict[str, str] = field(init=False)
+
+    def __post_init__(self):
+        subfields_map = dict()
+        subfields_filter_map = dict()
+        for subfield in self.subfields:
+            subfields_map[f"{self.key}_{subfield.key}"] = subfield
+            subfields_filter_map[f"{self.key}_{subfield.key}"] = subfield.key
+            for prefix in self.additional_prefixes:
+                subfields_map[f"{self.key}_{prefix}_{subfield.key}"] = subfield
+                subfields_filter_map[f"{self.key}_{prefix}_{subfield.key}"] = f"{prefix}_{subfield.key}"
+        object.__setattr__(self, "subfields_map", subfields_map)
+        object.__setattr__(self, "subfields_filter_map", subfields_filter_map)
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def get_fields(self, with_prefixed_key: bool = False):
+        """
+        Returns a generator of key identifier and metric label containing in that metric
+
+        Args:
+            with_prefixed_key: Default to False. If True yield also the prefixed fields
+
+        Returns:
+            a generator of tuple of strings
+        """
+        for subfield in self.subfields:
+            yield f"{self.key}_{subfield.key}", f"{self.label} {subfield.label}"
+            if with_prefixed_key:
+                for prefix in self.additional_prefixes:
+                    yield f"{self.key}_{prefix}_{subfield.key}", f"{self.label} {subfield.label} ({prefix.title()})"
+
+
+@dataclass
+class Metric:
+    """
+    A DTO class to hold the metrics values computed by a metric backend. The object will be parsed by an orchestrator into a InstrumentMetric object
+    """
+
+    basket_id: int
+    basket_content_type_id: int
+    key: str
+    metrics: dict
+    date: Optional[date] = None
+    instrument_id: int | None = None
+    dependency_metrics: list["Metric"] = field(default_factory=list)

wbfdm/contrib/metric/exceptions.py

@@ -0,0 +1,6 @@
+class MetricInvalidParameterException(Exception):
+    """
+    If instantiated backend parameters are invalid, the orchestrator or backend itself are expected to raise that exception
+    """
+
+    pass

wbfdm/contrib/metric/factories.py

@@ -0,0 +1,33 @@
+import factory
+from django.contrib.contenttypes.models import ContentType
+from faker import Faker
+from wbfdm.contrib.metric.models import InstrumentMetric
+from wbfdm.factories import InstrumentFactory
+from wbfdm.models import Instrument
+
+from .registry import backend_registry
+
+fake = Faker()
+
+
+def _get_metrics(key: str):
+    backend = backend_registry[key, Instrument]
+    metrics = {}
+    for sub_field in backend.keys[0].subfields:
+        metrics[sub_field.key] = fake.pyfloat()
+    return metrics
+
+
+class InstrumentMetricFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = InstrumentMetric
+        # django_get_or_create = ["basket_content_type", "basket_id", "instrument", "date", "key"]
+
+    basket = factory.SubFactory(InstrumentFactory)
+    basket_content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(Instrument))
+    basket_id = factory.LazyAttribute(lambda o: o.basket.id)
+
+    date = factory.Faker("date_object")
+    key = factory.Iterator(backend_registry.keys())
+    metrics = factory.LazyAttribute(lambda o: _get_metrics(o.key))
+    parent_metric = None

wbfdm/contrib/metric/filters.py

@@ -0,0 +1,28 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+from wbcore import filters
+from wbfdm.contrib.metric.models import InstrumentMetric
+
+from .registry import backend_registry
+
+
+class InstrumentMetricFilterSet(filters.FilterSet):
+    key = filters.ChoiceFilter(choices=backend_registry.get_choices(), label="Key")
+    basket_content_type = filters.ModelChoiceFilter(
+        queryset=ContentType.objects.all(),
+        endpoint="wbcore:contenttyperepresentation-list",
+        value_key="id",
+        label_key="{{app_label}} | {{model}}",
+        label=_("Basket Content Type"),
+    )
+
+    class Meta:
+        model = InstrumentMetric
+        fields = {
+            "basket_content_type": ["exact"],
+            "basket_id": ["exact"],
+            "instrument": ["exact"],
+            "key": ["exact"],
+            "date": ["lte", "gte", "exact"],
+            "parent_metric": ["exact", "isnull"],
+        }