wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/viewsets/financial_analysis/financial_metric_analysis.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from django.utils.functional import cached_property
+from rest_framework.exceptions import ParseError
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.pandas.utils import override_number_to_percent
+from wbcore.serializers.fields.types import DisplayMode
+from wbfdm.analysis.financial_analysis.financial_metric_analysis import (
+    financial_metric_estimate_analysis,
+    financial_metric_growths,
+)
+from wbfdm.enums import Financial
+from wbfdm.filters import GroupKeyFinancialsFilterSet
+from wbfdm.models.instruments import Instrument
+from wbfdm.viewsets.configs.display.statement_with_estimates import (
+    StatementWithEstimatesDisplayViewConfig,
+)
+from wbfdm.viewsets.configs.endpoints.statements import StatementsEndpointViewConfig
+from wbfdm.viewsets.configs.titles.statement_with_estimates import (
+    StatementTitleViewConfig,
+)
+
+from ..mixins import InstrumentMixin
+
+
+class FinancialMetricAnalysisPandasViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    queryset = Instrument.objects.none()
+    display_config_class = StatementWithEstimatesDisplayViewConfig
+    endpoint_config_class = StatementsEndpointViewConfig
+    title_config_class = StatementTitleViewConfig
+    filterset_class = GroupKeyFinancialsFilterSet
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_pandas_fields(self, request):
+        return pf.PandasFields(
+            fields=[
+                *[pf.FloatField(key=field, label=field, display_mode=DisplayMode.SHORTENED) for field in self.columns],
+                pf.PKField(key="id", label="ID"),
+                pf.CharField(key="financial", label="Financial"),
+                pf.JsonField(key="_overwrites", label="Overwrites"),
+            ]
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        if group_keys := request.GET.get("group_keys"):
+            try:
+                financial = Financial(group_keys.lower())
+            except ValueError:
+                raise ParseError()
+            df, self._estimate_mapping, self._columns = financial_metric_estimate_analysis(
+                queryset.first().id, financial
+            )
+            empty_row = pd.Series([None], dtype="float64", name="empty_row")
+            df_growth = financial_metric_growths(queryset.first().id, financial)
+
+            df = pd.concat([df_growth, df, empty_row]).dropna(how="all")
+            if "financial" in df.columns:
+                override_number_to_percent(df, df["financial"].str.contains("(%)"))
+
+            df = df.rename(columns={"index": "id"})
+            return df
+
+        return pd.DataFrame()
+
+    @cached_property
+    def columns(self):
+        if not hasattr(self, "_columns"):
+            self.get_dataframe(self.request, self.get_queryset())
+        return self._columns
+
+    @property
+    def year_columns(self):
+        yield from filter(lambda col: "Y" in col, self.columns)
+
+    @property
+    def interim_columns(self):
+        yield from filter(lambda col: "Y" not in col, self.columns)
+
+    @cached_property
+    def estimate_mapping(self):
+        if not hasattr(self, "_estimate_mapping"):
+            self.get_dataframe(self.request, self.get_queryset())
+        return self._estimate_mapping

wbfdm/viewsets/financial_analysis/financial_ratio_analysis.py

@@ -0,0 +1,85 @@
+from contextlib import suppress
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from wbcore import viewsets
+from wbcore.utils.date import get_date_interval_from_request
+from wbfdm.analysis.financial_analysis.financial_ratio_analysis import (
+    FinancialRatio,
+    get_financial_ratios,
+)
+from wbfdm.filters import FinancialRatioFilterSet
+from wbfdm.models.instruments import Instrument
+
+from ..configs import ValuationRatioChartTitleConfig
+from ..mixins import InstrumentMixin
+
+
+class ValuationRatioChartViewSet(InstrumentMixin, viewsets.ChartViewSet):
+    queryset = Instrument.objects.all()
+    filterset_class = FinancialRatioFilterSet
+    title_config_class = ValuationRatioChartTitleConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(id=self.instrument.id)
+
+    def get_plotly(self, queryset):
+        pd.options.plotting.backend = "plotly"
+
+        ratios = [FinancialRatio.PE, FinancialRatio.PS, FinancialRatio.PB, FinancialRatio.PFCF]
+        ttm = False if self.request.GET.get("ttm", "true") == "false" else True
+        start, end = get_date_interval_from_request(self.request, date_range_fieldname="period")
+
+        df = get_financial_ratios(
+            self.instrument.id,
+            ratios,
+            from_date=start,
+            to_date=end,
+            ttm=ttm,
+        )
+        fig = go.Figure()
+        colors = iter(px.colors.qualitative.T10)
+
+        for ratio, color in zip(ratios, colors):
+            with suppress(AttributeError):
+                series = getattr(df, ratio.value)
+
+                fig.add_trace(
+                    go.Scatter(
+                        x=series.index,
+                        y=series,
+                        line=dict(color=color),
+                        name=f"{ratio.label} {'TTM' if ttm else 'FTM'}",
+                        legendgroup=f"{ratio.label} {'TTM' if ttm else 'FTM'}",
+                        visible="legendonly" if ratio != FinancialRatio.PE else True,
+                    ),
+                )
+
+        # fig = df.plot()
+        fig.update_layout(
+            template="plotly_white",
+            legend=dict(x=0.02, y=0.98, bgcolor="rgba(0,0,0,0)"),
+            margin=dict(l=0, r=0, t=0, b=0),
+            showlegend=True,
+        )
+
+        for i, d in enumerate(fig.data):
+            with suppress(AttributeError, IndexError, TypeError, OverflowError):
+                if (v := d.y[-1]) and not np.isnan(v):
+                    fig.add_scatter(
+                        x=[d.x[-1]],
+                        y=[v],
+                        name=d.name,
+                        mode="markers+text",
+                        text=round(v),
+                        textfont=dict(color=d.line.color),
+                        textposition="middle right",
+                        marker=dict(color=d.line.color, size=12, symbol="circle"),
+                        legendgroup=d.name,
+                        showlegend=False,
+                        visible="legendonly" if i != 0 else True,
+                    )
+
+        return fig

wbfdm/viewsets/financial_analysis/statement_with_estimates.py

@@ -0,0 +1,145 @@
+from contextlib import suppress
+
+import numpy as np
+from django.conf import settings
+from django.contrib.messages import warning
+from django.utils.functional import cached_property
+from wbcore.cache.decorators import cache_table
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.serializers.fields.types import DisplayMode
+from wbcore.utils.date import get_next_day_timedelta
+from wbfdm.analysis.financial_analysis.statement_with_estimates import (
+    StatementWithEstimates,
+)
+from wbfdm.enums import CalendarType
+from wbfdm.filters import StatementWithEstimateFilter
+from wbfdm.models.instruments import Instrument
+from wbfdm.viewsets.configs.display.statement_with_estimates import (
+    StatementWithEstimatesDisplayViewConfig,
+)
+from wbfdm.viewsets.configs.endpoints.statements import StatementsEndpointViewConfig
+from wbfdm.viewsets.configs.titles.statement_with_estimates import (
+    StatementTitleViewConfig,
+)
+
+from ..mixins import InstrumentMixin
+
+
+@cache_table(
+    timeout=lambda view: get_next_day_timedelta(),
+    key_prefix=lambda view: f"_{view.instrument.id}_{view.financial_analysis_key}_{view.calendar_type}",
+)
+class StatementWithEstimatesPandasViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    queryset = Instrument.objects.none()
+    display_config_class = StatementWithEstimatesDisplayViewConfig
+    endpoint_config_class = StatementsEndpointViewConfig
+    title_config_class = StatementTitleViewConfig
+    filterset_class = StatementWithEstimateFilter
+
+    financial_analysis_mapping = {
+        "income": ("income_statement_with_estimate", "Income Statement"),
+        "balancesheet": ("balance_sheet_with_estimate", "Balance Sheet"),
+        "cashflow": ("cash_flow_statement_with_estimate", "Cash Flow Statement"),
+        "ratios": ("ratios_with_estimate", "Ratios"),
+        "summary": ("summary_with_estimate", "Summary"),
+        "margins": ("margins_with_estimates", "Margins"),
+        "cashflow-ratios": ("cashflow_ratios_with_estimates", "Cashflow Ratios"),
+        "asset-turnover-ratios": ("asset_turnover_with_estimates", "Asset-Turnover Ratios"),
+        "credit": ("credit_with_estimates", "Credit"),
+        "long-term-solvency": ("long_term_solvency_with_estimates", "Long-term Solvency"),
+        "short-term-liquidity": ("short_term_liquidity_with_estimates", "Short-term Liquidity"),
+    }
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_pandas_fields(self, request):
+        return pf.PandasFields(
+            fields=[
+                *[pf.FloatField(key=field, label=field, display_mode=DisplayMode.SHORTENED) for field in self.columns],
+                pf.PKField(key="id", label="ID"),
+                pf.CharField(key="financial", label="Financial"),
+                pf.CharField(key="_group_key", label="Group Key"),
+                pf.JsonField(key="_overwrites", label="Overwrites"),
+                pf.SparklineField(key="progress", label="Yearly Trend"),
+            ]
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        statement_with_estimate = StatementWithEstimates(self.instrument, calendar_type=self.calendar_type)
+        financial_analysis_result = getattr(
+            statement_with_estimate, self.financial_analysis_mapping[self.financial_analysis_key][0]
+        )
+        df = financial_analysis_result.formatted_df
+
+        year_columns = list(filter(lambda col: "Y" in col, df.columns))
+        if year_columns:
+            df["progress"] = df[year_columns].replace([np.inf, -np.inf, np.nan], None).apply(list, axis=1)
+
+        self.extra_cache_kwargs["_estimate_mapping"] = financial_analysis_result.estimated_mapping
+        self.extra_cache_kwargs["_columns"] = df.columns
+        self.extra_cache_kwargs["_errors"] = financial_analysis_result.errors
+
+        if financial_analysis_result.errors.get("duplicated_interims", []) and not settings.DEBUG:
+            with suppress(ModuleNotFoundError):
+                from sentry_sdk import capture_message
+
+                capture_message(
+                    f"Duplicate index detected for instrument {self.instrument} (id: {self.instrument.id})",
+                    level="error",
+                )
+        return df
+
+    def add_messages(self, request, instance=None, **kwargs):
+        if self.errors:
+            message = """
+            <p>While gathering the financial data, we detected the following issues from the data vendor:</p>
+            <ul>
+            """
+            if duplicated_interim := self.errors.get("duplicated_interim", []):
+                message += f"""
+                <li>Duplicated data for for interim period <strong>{', '.join(duplicated_interim)}</strong>
+                    <ul>
+                    <li>First available data was used and the rest was ignored
+                    </li>
+                    </ul>
+                </li>
+                """
+            if missing_data := self.errors.get("missing_data", []):
+                for error in missing_data:
+                    message += f"<li>{error}</li>"
+            message += "</ul>"
+            warning(request, message, extra_tags="auto_close=0")
+
+    # Cached attributes as properties
+    @cached_property
+    def calendar_type(self):
+        return CalendarType(self.request.GET.get("calendar_type", CalendarType.FISCAL.value))
+
+    @cached_property
+    def financial_analysis_key(self):
+        return self.kwargs.get("statement", "income")
+
+    @cached_property
+    def estimate_mapping(self):
+        return getattr(self, "_estimate_mapping", {})
+
+    @cached_property
+    def errors(self):
+        return getattr(self, "_errors", {})
+
+    @cached_property
+    def columns(self):
+        return self.df.columns
+
+    def get_ordering_fields(self):
+        return self.columns
+
+    @cached_property
+    def year_columns(self):
+        return list(filter(lambda col: "Y" in col, self.columns))
+
+    @cached_property
+    def interim_columns(self):
+        return list(filter(lambda col: "Y" not in col, self.columns))

wbfdm/viewsets/instruments/__init__.py

@@ -0,0 +1,80 @@
+from django.conf import settings
+from wbcore.utils.importlib import import_from_dotted_path
+from .instruments import (
+    InstrumentModelViewSet,
+    InstrumentRepresentationViewSet,
+    InstrumentTypeRepresentationViewSet,
+    ChildrenInstrumentModelViewSet,
+)
+from .instrument_prices import (
+    InstrumentPriceModelViewSet,
+    InstrumentPriceInstrumentModelViewSet,
+    InstrumentPriceInstrumentStatisticsChartView,
+    FinancialStatisticsInstrumentPandasView,
+    InstrumentPriceInstrumentDistributionReturnsChartView,
+    BestAndWorstReturnsInstrumentPandasView,
+)
+
+from .classifications import (
+    ClassificationClassificationGroupModelViewSet,
+    ClassificationGroupModelViewSet,
+    ClassificationGroupRepresentationViewSet,
+    ClassificationIcicleChartView,
+    ClassificationInstrumentThroughInstrumentModelViewSet,
+    ClassificationRepresentationViewSet,
+    ClassificationTreeChartView,
+    InstrumentClassificationThroughInstrumentModelViewSet,
+    InstrumentClassificationThroughModelViewSet,
+)
+from .financials_analysis import (
+    CashFlowAnalysisInstrumentBarChartViewSet,
+    CashFlowAnalysisInstrumentTableViewSet,
+    EarningsInstrumentChartViewSet,
+    FinancialsGraphInstrumentChartViewSet,
+    NetDebtAndEbitdaInstrumentChartViewSet,
+    ProfitabilityRatiosInstrumentChartViewSet,
+    SummaryTableInstrumentChartViewSet,
+    ValuationRatiosChartView,
+)
+from .instrument_lists import (
+    InstrumentListModelViewSet,
+    InstrumentListRepresentationModelViewSet,
+    InstrumentListThroughModelViewSet,
+    InstrumentListThroughModelInstrumentListViewSet,
+    InstrumentListThroughModelInstrumentViewSet,
+)
+
+from .instrument_requests import (
+    InstrumentRequestModelViewSet,
+    InstrumentRequestRepresentationViewSet,
+)
+from .instruments_relationships import (
+    InstrumentClassificationRelatedInstrumentModelViewSet,
+    InstrumentClassificationRelatedInstrumentRepresentationViewSet,
+    InstrumentFavoriteGroupModelViewSet,
+    InstrumentFavoriteGroupRepresentationViewSet,
+    RelatedInstrumentThroughInstrumentModelViewSet,
+)
+
+
+ClassificationModelViewSet = import_from_dotted_path(
+    getattr(
+        settings,
+        "DEFAULT_CLASSIFICATION_MODEL_VIEWSET",
+        "wbfdm.viewsets.instruments.classifications.ClassificationModelViewSet",
+    )
+)
+ChildClassificationParentClassificationModelViewSet = import_from_dotted_path(
+    getattr(
+        settings,
+        "DEFAULT_PARENT_CLASSIFICATION_MODEL_VIEWSET",
+        "wbfdm.viewsets.instruments.classifications.ChildClassificationParentClassificationModelViewSet",
+    )
+)
+ClassifiedInstrumentModelViewSet = import_from_dotted_path(
+    getattr(
+        settings,
+        "DEFAULT_CLASSIFICATION_INSTRUMENT_MODEL_VIEWSET",
+        "wbfdm.viewsets.instruments.instruments_relationships.ClassifiedInstrumentModelViewSet",
+    )
+)

wbfdm/viewsets/instruments/classifications.py

@@ -0,0 +1,279 @@
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from django.db.models import Count, Value
+from django.db.models.expressions import OuterRef, Subquery
+from django.db.models.functions import Coalesce
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from reversion.views import RevisionMixin
+from wbcore import viewsets
+from wbcore.cache.decorators import cache_table
+from wbcore.filters import DjangoFilterBackend
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.date import get_next_day_timedelta
+from wbfdm.filters import (
+    ClassificationFilter,
+    ClassificationTreeChartFilter,
+    InstrumentClassificationThroughModelViewFilterSet,
+)
+from wbfdm.models import (
+    Classification,
+    ClassificationGroup,
+    InstrumentClassificationThroughModel,
+)
+from wbfdm.serializers import (
+    ClassificationGroupModelSerializer,
+    ClassificationGroupRepresentationSerializer,
+    ClassificationModelSerializer,
+    ClassificationRepresentationSerializer,
+    InstrumentClassificationThroughModelSerializer,
+)
+from wbfdm.viewsets.configs import (
+    ChildClassificationParentClassificationTitleConfig,
+    ClassificationButtonConfig,
+    ClassificationClassificationGroupEndpointConfig,
+    ClassificationClassificationGroupTitleConfig,
+    ClassificationDisplayConfig,
+    ClassificationEndpointConfig,
+    ClassificationGroupButtonConfig,
+    ClassificationGroupDisplayConfig,
+    ClassificationGroupTitleConfig,
+    ClassificationIcicleChartEndpointConfig,
+    ClassificationIcicleChartTitleConfig,
+    ClassificationInstrumentThroughInstrumentModelEndpointConfig,
+    ClassificationParentClassificationEndpointConfig,
+    ClassificationTitleConfig,
+    ClassificationTreeChartEndpointConfig,
+    ClassificationTreeChartTitleConfig,
+    InstrumentClassificationThroughDisplayConfig,
+    InstrumentClassificationThroughEndpointConfig,
+    InstrumentClassificationThroughInstrumentModelEndpointConfig,
+    InstrumentClassificationThroughTitleConfig,
+)
+
+from ..mixins import InstrumentMixin
+
+
+class ClassificationRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbfdm:classification"
+    queryset = Classification.objects.all()
+    serializer_class = ClassificationRepresentationSerializer
+
+    filterset_class = ClassificationFilter
+    ordering_fields = ["code_aggregated"]
+    ordering = ["code_aggregated"]
+    search_fields = ["code_aggregated", "name"]
+
+
+class ClassificationGroupRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbfdm:classificationgrouprepresentation"
+    queryset = ClassificationGroup.objects.all()
+    serializer_class = ClassificationGroupRepresentationSerializer
+
+    filterset_fields = {"is_primary": ["exact"], "max_depth": ["gte", "exact", "lte"]}
+    ordering_fields = ["name"]
+    ordering = ["name"]
+    search_fields = ["name"]
+
+
+class ClassificationModelViewSet(InternalUserPermissionMixin, RevisionMixin, viewsets.ModelViewSet):
+    IDENTIFIER = "wbfdm:classification"
+
+    queryset = Classification.objects.select_related("parent", "group")
+    serializer_class = ClassificationModelSerializer
+    filterset_class = ClassificationFilter
+
+    ordering_fields = (
+        "name",
+        "code_aggregated",
+        "level_representation",
+    )
+    ordering = ("level_representation", "name")
+    search_fields = ("name", "group__name", "parent__name", "code_aggregated")
+
+    endpoint_config_class = ClassificationEndpointConfig
+    display_config_class = ClassificationDisplayConfig
+    title_config_class = ClassificationTitleConfig
+    button_config_class = ClassificationButtonConfig
+
+
+class ClassificationClassificationGroupModelViewSet(ClassificationModelViewSet):
+    endpoint_config_class = ClassificationClassificationGroupEndpointConfig
+    title_config_class = ClassificationClassificationGroupTitleConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(group=self.kwargs["group_id"], level=0)
+
+
+class ChildClassificationParentClassificationModelViewSet(ClassificationModelViewSet):
+    endpoint_config_class = ClassificationParentClassificationEndpointConfig
+    title_config_class = ChildClassificationParentClassificationTitleConfig
+
+    def get_queryset(self):
+        parent = Classification.objects.get(id=self.kwargs["parent_id"])
+        return super().get_queryset().filter(parent=self.kwargs["parent_id"], level=parent.level + 1)
+
+
+class ClassificationGroupModelViewSet(InternalUserPermissionMixin, RevisionMixin, viewsets.ModelViewSet):
+    IDENTIFIER = "wbfdm:classificationgroup"
+
+    queryset = ClassificationGroup.objects.all()
+    serializer_class = ClassificationGroupModelSerializer
+    filterset_fields = {"is_primary": ["exact"], "max_depth": ["gte", "exact", "lte"]}
+    ordering_fields = ("name",)
+    ordering = ("name",)
+    search_fields = ("name",)
+
+    display_config_class = ClassificationGroupDisplayConfig
+    title_config_class = ClassificationGroupTitleConfig
+    button_config_class = ClassificationGroupButtonConfig
+
+
+class AbstractClassificationChartView(viewsets.ChartViewSet):
+    filter_backends = (DjangoFilterBackend,)
+    queryset = Classification.objects.all()
+    filterset_class = ClassificationTreeChartFilter
+
+    @cached_property
+    def aggregation_type(self) -> str:
+        return self.request.GET.get("aggregation_type", "classification_count")
+
+    @cached_property
+    def classification_group(self) -> ClassificationGroup:
+        return ClassificationGroup.objects.get(id=self.kwargs["group_id"])
+
+    @cached_property
+    def top_level(self) -> int:
+        top_level = 0
+        if top_classification_id := self.request.GET.get("top_classification", None):
+            top_level = Classification.objects.get(id=top_classification_id).level
+        return top_level
+
+    def get_df(self, queryset) -> tuple[pd.DataFrame, list[str]]:
+        _range = self.classification_group.max_depth + 1 - self.top_level
+        df = pd.DataFrame(columns=[self.aggregation_type])
+        level_representation = []
+        if queryset.exists():
+            df = pd.DataFrame(
+                queryset.values(*[f"{'parent__' * height}name" for height in range(_range)], self.aggregation_type)
+            ).fillna(0)
+
+            level_representation = self.classification_group.get_levels_representation()[:_range]
+            df.columns = [*level_representation, self.aggregation_type]
+        return df, level_representation
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(height=0, group=self.classification_group)
+            .annotate(
+                instrument_count=Coalesce(
+                    Subquery(
+                        InstrumentClassificationThroughModel.objects.filter(classification=OuterRef("pk"))
+                        .values("classification")
+                        .annotate(c=Count("classification"))
+                        .values("c")[:1]
+                    ),
+                    0,
+                ),
+                classification_count=Value(1),
+            )
+        )
+
+    def get_plotly(self, queryset):
+        return go.Figure()
+
+
+@cache_table(
+    timeout=get_next_day_timedelta(),
+    key_prefix=lambda view: f"{view.classification_group.id}_{view.aggregation_type}_{view.top_level}",
+    periodic_caching=True,
+    periodic_caching_view_kwargs=lambda: [
+        {"group_id": group_id} for group_id in ClassificationGroup.objects.values_list("id", flat=True)
+    ],
+    periodic_caching_get_parameters=[
+        {"aggregation_type": "classification_count"},
+        {"aggregation_type": "instrument_count"},
+    ],
+)
+class ClassificationTreeChartView(AbstractClassificationChartView):
+    IDENTIFIER = "wbfdm:classificationgroup-tree"
+    title_config_class = ClassificationTreeChartTitleConfig
+    endpoint_config_class = ClassificationTreeChartEndpointConfig
+
+    def get_plotly(self, queryset):
+        df, level_representation = self.get_df(queryset)
+        fig = px.treemap(df, path=[*level_representation[::-1]], values=self.aggregation_type, branchvalues="total")
+        fig.update_traces(root_color="lightgrey", hovertemplate=f"{self.aggregation_type}: %{{value}}")
+        fig.update_layout(margin=dict(t=25, l=25, r=25, b=25))
+        return fig
+
+
+@cache_table(
+    timeout=get_next_day_timedelta(),
+    key_prefix=lambda view: f"{view.classification_group.id}_{view.aggregation_type}_{view.top_level}",
+    periodic_caching=True,
+    periodic_caching_view_kwargs=lambda: [
+        {"group_id": group_id} for group_id in ClassificationGroup.objects.values_list("id", flat=True)
+    ],
+    periodic_caching_get_parameters=[
+        {"aggregation_type": "classification_count"},
+        {"aggregation_type": "instrument_count"},
+    ],
+)
+class ClassificationIcicleChartView(AbstractClassificationChartView):
+    IDENTIFIER = "wbfdm:classificationgroup-iciclechart"
+    title_config_class = ClassificationIcicleChartTitleConfig
+    endpoint_config_class = ClassificationIcicleChartEndpointConfig
+
+    def get_plotly(self, queryset):
+        df, level_representation = self.get_df(queryset)
+        fig = px.icicle(df, path=[*level_representation[::-1]], values=self.aggregation_type)
+        fig.update_traces(
+            root_color="lightgrey", tiling=dict(orientation="v"), hovertemplate=f"{self.aggregation_type}: %{{value}}"
+        )
+        fig.update_layout(margin=dict(t=25, l=25, r=25, b=25))
+        return fig
+
+
+class InstrumentClassificationThroughModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    serializer_class = InstrumentClassificationThroughModelSerializer
+    queryset = InstrumentClassificationThroughModel.objects.select_related(
+        "instrument",
+        "classification",
+    ).prefetch_related("related_instruments", "tags")
+    search_fields = ("classification__name", "classification__code_aggregated")
+    ordering_fields = ordering = ["classification__name"]
+
+    filterset_class = InstrumentClassificationThroughModelViewFilterSet
+    display_config_class = InstrumentClassificationThroughDisplayConfig
+    endpoint_config_class = InstrumentClassificationThroughEndpointConfig
+    title_config_class = InstrumentClassificationThroughTitleConfig
+
+
+class InstrumentClassificationThroughInstrumentModelViewSet(
+    InstrumentMixin, InstrumentClassificationThroughModelViewSet
+):
+    endpoint_config_class = InstrumentClassificationThroughInstrumentModelEndpointConfig
+    search_fields = ["classification__computed_str"]
+    ordering_fields = ordering = ["classification__computed_str"]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(instrument__in=self.instrument.get_family())
+
+
+class ClassificationInstrumentThroughInstrumentModelViewSet(InstrumentClassificationThroughModelViewSet):
+    search_fields = ["instrument__computed_str"]
+    ordering_fields = ordering = ["instrument__computed_str"]
+
+    endpoint_config_class = ClassificationInstrumentThroughInstrumentModelEndpointConfig
+
+    def get_queryset(self):
+        classification = get_object_or_404(Classification, id=self.kwargs["classification_id"])
+        return (
+            super()
+            .get_queryset()
+            .filter(classification__in=classification.get_descendants(include_self=True).values("id"))
+        )