wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/contrib/metric/tests/backends/test_performances.py

@@ -0,0 +1,152 @@
+from datetime import timedelta
+from decimal import Decimal
+
+import pandas as pd
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbfdm.models import Instrument, RelatedInstrumentThroughModel
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentPerformanceMetricBackend:
+    def test_compute_metrics(self, weekday, instrument, instrument_price_factory):
+        from wbfdm.contrib.metric.backends.performances import (  # we import locally to avoid database access pytest error
+            InstrumentPerformanceMetricBackend,
+        )
+
+        backend = InstrumentPerformanceMetricBackend(weekday)
+
+        price_today = instrument_price_factory.create(instrument=instrument, calculated=False, date=weekday)
+        price_yesterday = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=weekday - BDay(1)
+        )
+        price_last_week = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=(weekday - timedelta(days=7)) - BDay(0)
+        )
+        price_last_month = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=(weekday - timedelta(days=30)) - BDay(1)
+        )
+        price_last_quarter = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=(weekday - timedelta(days=120)) - BDay(1)
+        )
+        price_last_year = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=(weekday - timedelta(days=365)) - BDay(1)
+        )
+        price_end_last_year = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=weekday - pd.tseries.offsets.BYearEnd(1)
+        )
+        price_inception = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=price_last_year.date - BDay(1)
+        )
+
+        instrument_price_factory.create(
+            instrument=instrument, calculated=True, date=price_inception.date - BDay(1)
+        )  # add noise
+        instrument.inception_date = price_inception.date.date()
+        instrument.save()
+        instrument.update_last_valuation_date()
+        base_metric = next(backend.compute_metrics(instrument))
+
+        # Check base metric metadata
+        assert base_metric.date is None
+        assert base_metric.basket_id == instrument.id
+        assert base_metric.basket_content_type_id == ContentType.objects.get_for_model(Instrument).id
+        assert base_metric.key == "performance"
+        assert base_metric.instrument_id is None
+
+        assert base_metric.metrics["is_estimated"] is False
+        assert base_metric.metrics["daily"] == pytest.approx(
+            float(price_today.net_value / price_yesterday.net_value - Decimal(1)), abs=1e-5
+        )
+        assert base_metric.metrics["weekly"] == pytest.approx(
+            float(price_today.net_value / price_last_week.net_value - Decimal(1)), abs=1e-5
+        )
+        assert base_metric.metrics["monthly"] == pytest.approx(
+            float(price_today.net_value / price_last_month.net_value - Decimal(1)), abs=1e-5
+        )
+        assert base_metric.metrics["quarterly"] == pytest.approx(
+            float(price_today.net_value / price_last_quarter.net_value - Decimal(1)), abs=1e-5
+        )
+
+        assert base_metric.metrics["yearly"] == pytest.approx(
+            float(price_today.net_value / price_last_year.net_value - Decimal(1)), abs=1e-5
+        )
+
+        assert base_metric.metrics["year_to_date"] == pytest.approx(
+            float(price_today.net_value / price_end_last_year.net_value - Decimal(1)), abs=1e-5
+        )
+        assert base_metric.metrics["inception"] == pytest.approx(
+            float(price_today.net_value / price_inception.net_value - Decimal(1)), abs=1e-5
+        )
+
+    def test_compute_metrics_estimated(self, weekday, instrument, instrument_price_factory):
+        from wbfdm.contrib.metric.backends.performances import (  # we import locally to avoid database access pytest error
+            InstrumentPerformanceMetricBackend,
+        )
+
+        backend = InstrumentPerformanceMetricBackend(weekday)
+
+        price_today = instrument_price_factory.create(instrument=instrument, calculated=True, date=weekday)
+        price_yesterday = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=weekday - BDay(1)
+        )
+        instrument.inception_date = price_yesterday.date.date()
+        instrument.save()
+        instrument.update_last_valuation_date()
+        base_metric = next(backend.compute_metrics(instrument))
+
+        assert base_metric.metrics["is_estimated"] is True
+        assert base_metric.metrics["daily"] == pytest.approx(
+            float(price_today.net_value / price_yesterday.net_value - Decimal(1)), abs=1e-5
+        )
+
+    def test_compute_metrics_with_peers(self, weekday, instrument_factory, instrument_price_factory):
+        from wbfdm.contrib.metric.backends.performances import (  # we import locally to avoid database access pytest error
+            InstrumentPerformanceMetricBackend,
+        )
+
+        instrument = instrument_factory.create()
+        peer_1 = instrument_factory.create()
+        RelatedInstrumentThroughModel.objects.create(
+            related_type="PEER", instrument=instrument, related_instrument=peer_1
+        )
+        peer_2 = instrument_factory.create()
+        RelatedInstrumentThroughModel.objects.create(
+            related_type="PEER", instrument=instrument, related_instrument=peer_2
+        )
+
+        backend = InstrumentPerformanceMetricBackend(weekday)
+
+        price_today = instrument_price_factory.create(instrument=instrument, calculated=False, date=weekday)
+        price_yesterday = instrument_price_factory.create(
+            instrument=instrument, calculated=False, date=weekday - BDay(1)
+        )
+        instrument.inception_date = price_yesterday.date.date()
+        instrument.save()
+        peer_1_price_today = instrument_price_factory.create(instrument=peer_1, calculated=False, date=weekday)
+        peer_1_price_yesterday = instrument_price_factory.create(
+            instrument=peer_1, calculated=False, date=weekday - BDay(1)
+        )
+        peer_1.inception_date = peer_1_price_yesterday.date.date()
+        peer_1.save()
+        peer_2_price_today = instrument_price_factory.create(instrument=peer_2, calculated=False, date=weekday)
+        peer_2_price_yesterday = instrument_price_factory.create(
+            instrument=peer_2, calculated=False, date=weekday - BDay(1)
+        )
+        peer_2.inception_date = peer_2_price_yesterday.date.date()
+        peer_2.save()
+        instrument.update_last_valuation_date()
+        peer_1.update_last_valuation_date()
+        peer_2.update_last_valuation_date()
+        base_metric = next(backend.compute_metrics(instrument))
+        daily_instrument_perf = float(price_today.net_value / price_yesterday.net_value - Decimal(1))
+        assert base_metric.metrics["daily"] == pytest.approx(daily_instrument_perf, abs=1e-5)
+        daily_peer_1_perf = float(peer_1_price_today.net_value / peer_1_price_yesterday.net_value - Decimal(1))
+        daily_peer_2_perf = float(peer_2_price_today.net_value / peer_2_price_yesterday.net_value - Decimal(1))
+        avg_daily_peer_perf = (daily_peer_1_perf + daily_peer_2_perf) / 2
+        r = daily_instrument_perf - avg_daily_peer_perf
+        assert base_metric.metrics["peer_daily"] == pytest.approx(r, abs=0.00001)

wbfdm/contrib/metric/tests/backends/test_statistics.py

@@ -0,0 +1,48 @@
+from decimal import Decimal
+from unittest.mock import patch
+
+import pytest
+from faker import Faker
+from wbfdm.dataloaders.proxies import InstrumentDataloaderProxy
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentFinancialStatisticsMetricBackend:
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test_default_daily_statistics(self, mock_fct, weekday, instrument, instrument_price_factory):
+        from wbfdm.contrib.metric.backends.statistics import (  # we import locally to avoid database access pytest error
+            InstrumentFinancialStatisticsMetricBackend,
+        )
+
+        backend = InstrumentFinancialStatisticsMetricBackend(weekday)
+
+        revenue_y_1 = fake.pyfloat()
+        revenue_y0 = fake.pyfloat()
+        revenue_y1 = fake.pyfloat()
+        market_capitalization = fake.pyfloat()
+        price = Decimal(150)
+        volume_50d = fake.pyfloat()
+        instrument_price_factory.create(
+            instrument=instrument,
+            calculated=False,
+            date=weekday,
+            net_value=price,
+            volume_50d=volume_50d,
+            market_capitalization=market_capitalization,
+        )
+        instrument.update_last_valuation_date()
+        mock_fct.return_value = [
+            {"year": weekday.year - 1, "value": revenue_y_1, "instrument_id": instrument.id},
+            {"year": weekday.year, "value": revenue_y0, "instrument_id": instrument.id},
+            {"year": weekday.year + 1, "value": revenue_y1, "instrument_id": instrument.id},
+        ]
+        metrics = next(backend.compute_metrics(instrument)).metrics
+
+        assert metrics["revenue_y_1"] == revenue_y_1
+        assert metrics["revenue_y0"] == revenue_y0
+        assert metrics["revenue_y1"] == revenue_y1
+        assert metrics["market_capitalization"] == market_capitalization
+        assert metrics["price"] == price
+        assert metrics["volume_50d"] == volume_50d

wbfdm/contrib/metric/tests/conftest.py

@@ -0,0 +1,92 @@
+from wbcore.tests.conftest import *  # type: ignore # isort:skip
+from datetime import date
+
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import (
+    InternalUserFactory,
+    SuperUserFactory,
+    UserFactory,
+)
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.directory.factories.entries import (
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EntryFactory,
+    PersonFactory,
+)
+from wbcore.contrib.geography.factories import (
+    CityFactory,
+    ContinentFactory,
+    CountryFactory,
+    StateFactory,
+)
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.contrib.io.factories import (
+    CrontabScheduleFactory,
+    DataBackendFactory,
+    ImportSourceFactory,
+    ParserHandlerFactory,
+    ProviderFactory,
+    SourceFactory,
+)
+from wbfdm.factories import (
+    ClassificationFactory,
+    ClassificationGroupFactory,
+    ExchangeFactory,
+    InstrumentClassificationThroughModelFactory,
+    InstrumentFactory,
+    InstrumentFavoriteGroupFactory,
+    InstrumentListFactory,
+    InstrumentPriceFactory,
+    InstrumentTypeFactory,
+    ParentClassificationFactory,
+    RelatedInstrumentThroughModelFactory,
+)
+
+from ..factories import InstrumentMetricFactory
+
+fake = Faker()
+register(ImportSourceFactory)
+register(DataBackendFactory)
+register(ProviderFactory)
+register(SourceFactory)
+register(ParserHandlerFactory)
+register(CrontabScheduleFactory)
+
+register(ClassificationFactory)
+register(InstrumentClassificationThroughModelFactory)
+register(ParentClassificationFactory)
+register(ClassificationGroupFactory)
+register(ExchangeFactory)
+register(InstrumentFactory)
+register(InstrumentTypeFactory)
+register(InstrumentPriceFactory)
+register(InstrumentFavoriteGroupFactory)
+register(RelatedInstrumentThroughModelFactory)
+register(CurrencyFXRatesFactory)
+register(InstrumentListFactory)
+
+register(CurrencyFactory)
+register(CityFactory)
+register(StateFactory)
+register(CountryFactory)
+register(ContinentFactory)
+
+register(CompanyFactory)
+register(PersonFactory)
+register(InternalUserFactory)
+register(EntryFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+register(UserFactory)
+register(SuperUserFactory, "superuser")
+
+register(InstrumentMetricFactory)
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("metric"))

wbfdm/contrib/metric/tests/test_dto.py

@@ -0,0 +1,73 @@
+import pytest
+from faker import Faker
+
+from ..backends.performances import InstrumentMetricBaseBackend
+from ..dto import MetricField, MetricKey
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestMetricKey:
+    @pytest.fixture
+    def metric_key(self):
+        label = fake.word()
+
+        return MetricKey(
+            key=label.lower(),
+            label=label,
+            additional_prefixes=[fake.word()],
+            subfields=[
+                MetricField(
+                    key=label.lower(),
+                    label=label,
+                    decorators=[{"position": "left", "value": "&", "type": "text"}],
+                    serializer_kwargs={"percent": fake.boolean(), "precision": fake.pyint(min_value=1, max_value=4)},
+                )
+                for label in map(lambda x: fake.word(), range(3))
+            ],
+        )
+
+    def test_get_fields(self, metric_key):
+        fields = list(metric_key.get_fields())
+        assert fields[0] == (
+            f"{metric_key.key}_{metric_key.subfields[0].key}",
+            f"{metric_key.label} {metric_key.subfields[0].label}",
+        )
+        assert fields[1] == (
+            f"{metric_key.key}_{metric_key.subfields[1].key}",
+            f"{metric_key.label} {metric_key.subfields[1].label}",
+        )
+        assert fields[2] == (
+            f"{metric_key.key}_{metric_key.subfields[2].key}",
+            f"{metric_key.label} {metric_key.subfields[2].label}",
+        )
+
+    def test_get_fields_with_prefixed_key(self, metric_key):
+        fields = list(metric_key.get_fields(with_prefixed_key=True))
+        prefix = metric_key.additional_prefixes[0]
+        assert fields[1] == (
+            f"{metric_key.key}_{prefix}_{metric_key.subfields[0].key}",
+            f"{metric_key.label} {metric_key.subfields[0].label} ({prefix.title()})",
+        )
+        assert fields[3] == (
+            f"{metric_key.key}_{prefix}_{metric_key.subfields[1].key}",
+            f"{metric_key.label} {metric_key.subfields[1].label} ({prefix.title()})",
+        )
+        assert fields[5] == (
+            f"{metric_key.key}_{prefix}_{metric_key.subfields[2].key}",
+            f"{metric_key.label} {metric_key.subfields[2].label} ({prefix.title()})",
+        )
+
+    def test_fields_map(self, metric_key):
+        keys = set(map(lambda x: x[0], metric_key.get_fields(with_prefixed_key=True)))
+        assert keys == set(metric_key.subfields_filter_map.keys())
+
+    def test_get_serializer_field_attr(self, weekday, metric_key):
+        metric_field = metric_key.subfields[0]
+        backend = InstrumentMetricBaseBackend(weekday)
+        assert backend.get_serializer_field_attr(metric_field)["percent"] == metric_field.serializer_kwargs["percent"]
+        assert (
+            backend.get_serializer_field_attr(metric_field)["precision"] == metric_field.serializer_kwargs["precision"]
+        )
+        assert backend.get_serializer_field_attr(metric_field)["decorators"] == metric_field.decorators

wbfdm/contrib/metric/tests/test_models.py

@@ -0,0 +1,72 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from wbfdm.models import Instrument
+
+from ..dto import Metric
+from ..models import InstrumentMetric
+from ..registry import backend_registry
+
+
+@pytest.mark.django_db
+class TestInstrumentMetric:
+    def test_save(self, instrument_metric):
+        assert instrument_metric.basket_repr == str(instrument_metric.basket)
+
+    def test_update_or_create_from_metric(self, weekday, instrument_factory):
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+        i3 = instrument_factory.create()
+        key = "key"
+        basket_content_type_id = ContentType.objects.get_for_model(i1).id
+        level1_dto_metric = Metric(
+            basket_id=i1.id,
+            basket_content_type_id=basket_content_type_id,
+            key=key,
+            metrics={"a": "a"},
+            date=weekday,
+        )
+        level1_dto_metric = Metric(
+            basket_id=i2.id,
+            basket_content_type_id=basket_content_type_id,
+            key=key,
+            metrics={"b": "b"},
+            date=weekday,
+            dependency_metrics=[level1_dto_metric],
+        )
+        base_dto_metric = Metric(
+            basket_id=i3.id,
+            basket_content_type_id=basket_content_type_id,
+            key=key,
+            metrics={"c": "c"},
+            date=weekday,
+            dependency_metrics=[level1_dto_metric],
+        )
+        InstrumentMetric.update_or_create_from_metric(base_dto_metric)
+
+        level2_metric = InstrumentMetric.objects.get(
+            basket_id=i1.id, basket_content_type_id=basket_content_type_id, date=weekday, key=key
+        )
+        level1_metric = InstrumentMetric.objects.get(
+            basket_id=i2.id, basket_content_type_id=basket_content_type_id, date=weekday, key=key
+        )
+        base_metric = InstrumentMetric.objects.get(
+            basket_id=i3.id, basket_content_type_id=basket_content_type_id, date=weekday, key=key
+        )
+
+        assert level2_metric.metrics == {"a": "a"}
+        assert level2_metric.parent_metric == level1_metric
+
+        assert level1_metric.metrics == {"b": "b"}
+        assert level1_metric.parent_metric == base_metric
+
+        assert base_metric.metrics == {"c": "c"}
+
+    def test_annotate_with_metrics(self, instrument_metric):
+        qs = Instrument.objects.filter(id=instrument_metric.basket_id)
+        qs = InstrumentMetric.annotate_with_metrics(
+            qs, backend_registry._metric_key_map[instrument_metric.key], Instrument, val_date=instrument_metric.date
+        )
+        for field in instrument_metric.metrics.keys():
+            qs_field = instrument_metric.key + "_" + field
+            res = list(qs.values_list(qs_field, flat=True))[0]
+            assert res == instrument_metric.metrics[field]

wbfdm/contrib/metric/tests/test_tasks.py

@@ -0,0 +1,24 @@
+from unittest.mock import patch
+
+from faker import Faker
+
+from ..dispatch import compute_metrics
+from ..orchestrators import MetricOrchestrator
+from ..tasks import compute_metrics_as_task
+
+fake = Faker()
+
+
+@patch.object(MetricOrchestrator, "process")
+def test_dispatch_compute_metrics(mock_fct):
+    key = "performance"
+    basket = object()
+    val_date = fake.date_object()
+    compute_metrics(val_date, key=key, basket=basket)
+    mock_fct.assert_called_once()
+
+
+@patch.object(MetricOrchestrator, "process")
+def test_periodically_compute_all_metrics(mock_fct):
+    compute_metrics_as_task()
+    mock_fct.assert_called_once()

wbfdm/contrib/metric/tests/test_viewsets.py

@@ -0,0 +1,79 @@
+from datetime import date
+
+import pytest
+from faker import Faker
+from rest_framework.test import APIRequestFactory
+from wbcore import viewsets
+from wbcore.utils.strings import get_aggregate_symbol
+from wbfdm.contrib.metric.backends.performances import (
+    PERFORMANCE_METRIC,
+    InstrumentPerformanceMetricBackend,
+)
+from wbfdm.contrib.metric.models import InstrumentMetric
+from wbfdm.models import Instrument
+from wbfdm.serializers import InstrumentModelSerializer
+
+from ..viewsets.mixins import InstrumentMetricMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestInstrumentMetricMixin:
+    @pytest.fixture
+    def viewset(self, instrument_metric_factory):
+        metric = instrument_metric_factory.create(key="performance")
+
+        class InstrumentWithMetricModelViewSet(InstrumentMetricMixin, viewsets.ModelViewSet):
+            METRIC_KEYS = (PERFORMANCE_METRIC,)
+            METRIC_WITH_PREFIXED_KEYS = fake.boolean()
+            serializer_class = InstrumentModelSerializer
+            queryset = Instrument.objects.all()
+
+            @property
+            def metric_basket(self):
+                return metric.basket
+
+            @property
+            def metric_date(self) -> date | None:
+                return metric.date
+
+        request = APIRequestFactory().get("")
+        return InstrumentWithMetricModelViewSet(request=request, format_kwarg={})
+
+    def test_metric_serializer_fields(self, weekday, viewset):
+        assert (
+            viewset._metric_serializer_fields.keys()
+            == InstrumentPerformanceMetricBackend(weekday)
+            .get_serializer_fields(with_prefixed_key=viewset.METRIC_WITH_PREFIXED_KEYS)
+            .keys()
+        )
+
+    def test_get_ordering_fields(self, viewset):
+        ordering_fields = viewset.get_ordering_fields()
+        for key, _ in PERFORMANCE_METRIC.get_fields(with_prefixed_key=viewset.METRIC_WITH_PREFIXED_KEYS):
+            assert key in ordering_fields
+
+    def test_get_queryset(self, viewset):
+        queryset = viewset.get_queryset()
+        annotations = list(queryset.query.annotations.keys())
+        for key, _ in PERFORMANCE_METRIC.get_fields(with_prefixed_key=viewset.METRIC_WITH_PREFIXED_KEYS):
+            assert key in annotations
+
+    def test_get_serializer(self, viewset):
+        serializer = viewset.get_serializer()
+        for key, _ in PERFORMANCE_METRIC.get_fields(with_prefixed_key=viewset.METRIC_WITH_PREFIXED_KEYS):
+            assert key in serializer.fields
+
+    def test_get_aggregates(self, viewset):
+        queryset = viewset.get_queryset()
+        aggregates = viewset.get_aggregates(queryset, queryset)
+        metric = InstrumentMetric.objects.first()
+        assert metric is not None
+        for key, _ in PERFORMANCE_METRIC.get_fields(with_prefixed_key=viewset.METRIC_WITH_PREFIXED_KEYS):
+            key_filter = PERFORMANCE_METRIC.subfields_filter_map[key]
+            subfield = PERFORMANCE_METRIC.subfields_map[key]
+            assert subfield.aggregate is not None
+
+            if key_filter in metric.metrics:
+                assert aggregates[key] == {get_aggregate_symbol(subfield.aggregate.name): metric.metrics[key_filter]}

wbfdm/contrib/metric/urls.py

@@ -0,0 +1,19 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from . import viewsets
+
+router = WBCoreRouter()
+
+# Representations
+router.register(
+    r"instrumentmetricrepresentation",
+    viewsets.InstrumentMetricRepresentationViewSet,
+    basename="instrumentmetricrepresentation",
+)
+
+router.register(r"instrumentmetric", viewsets.InstrumentMetricViewSet, basename="instrumentmetric")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

wbfdm/contrib/metric/viewsets/__init__.py

@@ -0,0 +1 @@
+from .viewsets import InstrumentMetricRepresentationViewSet, InstrumentMetricViewSet

wbfdm/contrib/metric/viewsets/configs/__init__.py

@@ -0,0 +1 @@
+from .display import InstrumentMetricDisplayConfig

wbfdm/contrib/metric/viewsets/configs/display.py

@@ -0,0 +1,92 @@
+from typing import Any, Optional
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+from wbfdm.contrib.metric.dto import MetricField
+
+
+class InstrumentMetricDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="key", label="Key"),
+                dp.Field(key="date", label="Date"),
+                dp.Field(key="instrument", label="Instrument"),
+                dp.Field(key="parent_metric", label="Parent Metric"),
+            ],
+            tree=True,
+            tree_group_pinned="left",
+            tree_group_field="basket_repr",
+            tree_group_label="Basket",
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_key="parent_metric",
+                    filter_depth=1,
+                    # lookup="id_repr",
+                    clear_filter=True,
+                    list_endpoint=reverse(
+                        "metric:instrumentmetric-list",
+                        args=[],
+                        request=self.request,
+                    ),
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        children_metrics_section = create_simple_section(
+            "children_metrics_section", "Child Metrics", [["children_metrics"]], "children_metrics", collapsed=True
+        )
+        return create_simple_display(
+            [
+                ["basket_content_type", "basket_id", "basket_repr"],
+                ["date", "key", "instrument"],
+                [repeat_field(3, "metrics")],
+                [repeat_field(3, "children_metrics")],
+            ],
+            [children_metrics_section],
+        )
+
+
+class InstrumentMetricPivotedListDisplayConfig(DisplayViewConfig):
+    """
+    Instrument metric Class to register automatically metrics fields into the list display.
+
+    The view attribute is expected to inherit from InstrumentMetricMixin
+    """
+
+    def _get_metric_field_attr(self, field: MetricField) -> dict[str, Any]:
+        attrs = dict(width=75)
+        attrs.update(field.list_display_kwargs)
+        return attrs
+
+    def _get_metric_list_display(self) -> dp.ListDisplay:
+        metrics = []
+
+        for metric_key in self.view.metric_keys:
+            metric_label = metric_key.label
+            fields = []
+            for subfield in metric_key.subfields:
+                field_key = f"{metric_key.key}_{subfield.key}"
+                fields.append(dp.Field(key=field_key, label=subfield.label, **self._get_metric_field_attr(subfield)))
+            metrics.append(dp.Field(key=None, label=metric_label, children=fields))
+
+        return dp.ListDisplay(fields=[dp.Field(label="Metrics", open_by_default=False, key=None, children=metrics)])
+
+    def _get_metadata(self) -> Any:
+        display = self.get_metadata()
+        if "list" in display:
+            list_display = self._get_metric_list_display()
+            if isinstance(list_display, Display):
+                metrics_list_display = list_display.serialize()
+            else:
+                metrics_list_display = dict(list_display or {})
+            display["list"]["fields"].extend(metrics_list_display["fields"])
+        return display

wbfdm/contrib/metric/viewsets/configs/menus.py

@@ -0,0 +1,11 @@
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+INSTRUMENTMETRIC_MENUITEM = MenuItem(
+    label="Metrics",
+    endpoint="metric:instrumentmetric-list",
+    endpoint_get_parameters={"parent_metric__isnull": True},
+    permission=ItemPermission(
+        permissions=["metric.view_instrumentmetric"], method=lambda request: is_internal_user(request.user)
+    ),
+)