wbportfolio 1.54.22__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/viewsets/charts/assets.py

@@ -1,23 +1,41 @@
 import datetime as dt
+from collections import defaultdict
+from contextlib import suppress
+from decimal import Decimal
 
-import numpy as np
 import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
-from django.db.models import QuerySet
-from django.shortcuts import get_object_or_404
+from django.db.models import F, Prefetch
 from django.utils.functional import cached_property
+from plotly.subplots import make_subplots
+from rest_framework.request import Request
 from wbcore import viewsets
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.geography.models import Geography
 from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.contrib.pandas import fields as pf
 from wbcore.filters import DjangoFilterBackend
-from wbcore.pandas import fields as pf
+from wbcore.utils.date import get_date_interval_from_request
+from wbcore.utils.figures import (
+    get_default_timeserie_figure,
+    get_hovertemplate_timeserie,
+)
+from wbcore.utils.strings import format_number
 from wbfdm.models import (
+    Classification,
     ClassificationGroup,
     Instrument,
     InstrumentClassificationThroughModel,
+    InstrumentType,
 )
 
-from wbportfolio.filters.assets import DistributionFilter
+from wbportfolio.filters.assets import (
+    AssetPositionUnderlyingInstrumentChartFilter,
+    CompositionContributionChartFilter,
+    ContributionChartFilter,
+    DistributionFilter,
+)
 from wbportfolio.models import (
     AssetPosition,
     AssetPositionGroupBy,
@@ -25,27 +43,46 @@ from wbportfolio.models import (
     PortfolioRole,
 )
 
-from ...constants import EQUITY_TYPE_KEYS
 from ..configs.buttons.assets import (
     DistributionChartButtonConfig,
     DistributionTableButtonConfig,
 )
 from ..configs.display.assets import DistributionTableDisplayConfig
 from ..configs.endpoints.assets import (
+    AssetPositionUnderlyingInstrumentChartEndpointConfig,
+    ContributorPortfolioChartEndpointConfig,
     DistributionChartEndpointConfig,
     DistributionTableEndpointConfig,
 )
 from ..configs.titles.assets import (
+    AssetPositionUnderlyingInstrumentChartTitleConfig,
+    ContributorPortfolioChartTitleConfig,
     DistributionChartTitleConfig,
     DistributionTableTitleConfig,
 )
+from ..mixins import UserPortfolioRequestPermissionMixin
 
 
-class AbstractDistributionMixin:
-    AUTORESIZE = False
+class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
     queryset = AssetPosition.objects.all()
     filterset_class = DistributionFilter
     filter_backends = (DjangoFilterBackend,)
+    request: Request
+
+    @cached_property
+    def group_by(self) -> AssetPositionGroupBy:
+        try:
+            return AssetPositionGroupBy(self.request.GET.get("group_by", "classification"))
+        except ValueError:
+            return AssetPositionGroupBy.INDUSTRY
+
+    @cached_property
+    def val_date(self) -> dt.date:
+        if validity_date_repr := self.request.GET.get("date"):
+            val_date = dt.datetime.strptime(validity_date_repr, "%Y-%m-%d")
+        else:
+            val_date = dt.date.today()
+        return val_date
 
     @cached_property
     def classification_group(self):
@@ -55,71 +92,95 @@ class AbstractDistributionMixin:
             return ClassificationGroup.objects.get(is_primary=True)
 
     @cached_property
-    def classification_field_names(self):
-        return [f"classification__{field_name}__name" for field_name in self.classification_group.get_fields_names()]
-
-    @cached_property
-    def classification_levels_representation(self):
-        return self.classification_group.get_levels_representation()
+    def classification_height(self) -> int:
+        return int(self.request.GET.get("group_by_classification_height", "0"))
 
     @cached_property
-    def classification_columns_map(self):
-        return dict(
-            zip(["classification__name", *self.classification_field_names], self.classification_levels_representation)
-        )
-
-    def _generate_classification_df(self, queryset):
-        df = pd.DataFrame(
-            queryset.filter(underlying_instrument__instrument_type__key__in=EQUITY_TYPE_KEYS).values(
-                "weighting", "underlying_instrument"
-            ),
-            columns=["weighting", "underlying_instrument"],
-        )
-        df.underlying_instrument = df.underlying_instrument.map(
-            dict(
-                Instrument.objects.filter(id__in=df.underlying_instrument)
-                .annotate_base_data()
-                .values_list("id", "root")
-            )
-        )
-        df = df.groupby("underlying_instrument").sum()
-        classifications = InstrumentClassificationThroughModel.objects.filter(
-            classification__group=self.classification_group, instrument__in=df.index
-        )
-        df_classification = pd.DataFrame(
-            classifications.values(
-                "instrument",
-                "classification__name",
-                *self.classification_field_names,
-            )
-        )
-        if df_classification.empty:
-            return pd.DataFrame()
-        return pd.concat([df, df_classification.groupby("instrument").first()], axis=1).replace(
-            [np.inf, -np.inf, np.nan], "N/A"
-        )
+    def columns_map(self) -> dict:
+        if self.group_by == AssetPositionGroupBy.INDUSTRY:
+            columns = {}
+            level_representations = self.classification_group.get_levels_representation()
+            for key, label in zip(
+                reversed(self.classification_group.get_fields_names(sep="_")), reversed(level_representations[1:])
+            ):
+                columns[key] = label
+            columns["label"] = "Classification"
+            columns["equity"] = "Instrument"
+        else:
+            columns = {"label": "Label"}
+        return columns
 
     def get_queryset(self):
-        portfolio = get_object_or_404(Portfolio, id=self.kwargs["portfolio_id"])
-        if (
-            PortfolioRole.is_analyst(self.request.user.profile, portfolio=portfolio)
-            or self.request.user.profile.is_internal
-        ):
-            return super().get_queryset().filter(portfolio=portfolio)
+        profile = self.request.user.profile
+        if PortfolioRole.is_analyst(profile, portfolio=self.portfolio) or profile.is_internal:
+            return AssetPosition.objects.filter(portfolio=self.portfolio)
         return AssetPosition.objects.none()
 
-    @staticmethod
-    def dataframe_group_by_instrument(df: pd.DataFrame) -> pd.DataFrame:
-        if df.empty:
-            return pd.DataFrame()
-        return df.groupby("aggregated_title").sum().sort_values(by="weighting", ascending=False)
+    def get_dataframe(self, request, queryset, **kwargs) -> pd.DataFrame:
+        instruments = defaultdict(Decimal)
+        for asset in self.portfolio.get_positions(self.val_date):
+            if self.group_by != AssetPositionGroupBy.INDUSTRY:
+                group_field = getattr(asset.underlying_instrument, self.group_by.value)
+            else:
+                group_field = asset.underlying_instrument.get_root()
+            group_field = getattr(group_field, "id", group_field)
+            instruments[group_field] += asset.weighting
+        df = pd.DataFrame.from_dict(instruments, orient="index", columns=["weighting"])
+        if self.group_by == AssetPositionGroupBy.INDUSTRY:
+            classifications = InstrumentClassificationThroughModel.objects.filter(
+                instrument__in=instruments.keys(), classification__group=self.classification_group
+            )
+            field_names = {
+                field_name.replace("__", "_"): F(f"classification__{field_name}__name")
+                for field_name in self.classification_group.get_fields_names()
+            }
+            classifications = (
+                classifications.annotate(**field_names)
+                .select_related(
+                    *[f"classification__{field_name}" for field_name in self.classification_group.get_fields_names()]
+                )
+                .prefetch_related(
+                    "tags",
+                    Prefetch("instrument", queryset=Instrument.objects.filter(classifications_through__isnull=False)),
+                )
+            )
+            df_classification = (
+                pd.DataFrame(
+                    classifications.values_list("instrument", "classification", *field_names.keys()),
+                    columns=["id", "classification", *field_names.keys()],
+                )
+                .groupby("id")
+                .first()
+            )
+            df = pd.concat([df, df_classification], axis=1)
+        if df.weighting.sum():  # normalize
+            df.weighting /= df.weighting.sum()
+        return df.reset_index(names="id")
 
-    def dataframe_groupby_with_class_method(self, qs: QuerySet, class_method: classmethod):
-        df = pd.DataFrame()
-        if qs.exists():
-            df = self.dataframe_group_by_instrument(
-                pd.DataFrame(class_method(qs).values("weighting", "aggregated_title"))
+    def manipulate_dataframe(self, df):
+        if self.group_by == AssetPositionGroupBy.INDUSTRY:
+            if not PortfolioRole.is_analyst(self.request.user.profile, portfolio=self.portfolio):
+                df["equity"] = ""
+            else:
+                df["equity"] = df["id"].map(
+                    dict(Instrument.objects.filter(id__in=df["id"]).values_list("id", "computed_str"))
+                )
+            df["label"] = df["classification"].map(
+                dict(Classification.objects.filter(id__in=df["classification"].dropna()).values_list("id", "name"))
+            )
+        elif self.group_by == AssetPositionGroupBy.CASH:
+            df.loc[df["id"] == True, "label"] = "Cash"
+            df.loc[df["id"] == False, "label"] = "Non-Cash"
+        elif self.group_by == AssetPositionGroupBy.COUNTRY:
+            df["label"] = df["id"].map(dict(Geography.objects.filter(id__in=df["id"]).values_list("id", "name")))
+        elif self.group_by == AssetPositionGroupBy.CURRENCY:
+            currencies = dict(map(lambda o: (o.id, str(o)), Currency.objects.filter(id__in=df["id"])))
+            df["label"] = df["id"].map(currencies)
+        elif self.group_by == AssetPositionGroupBy.INSTRUMENT_TYPE:
+            df["label"] = df["id"].map(
+                dict(InstrumentType.objects.filter(id__in=df["id"]).values_list("id", "short_name"))
             )
+        df.sort_values(by="weighting", ascending=False, inplace=True)
         return df
 
 
@@ -142,39 +203,17 @@ class DistributionChartViewSet(AbstractDistributionMixin, viewsets.ChartViewSet)
 
     def get_plotly(self, queryset):
         fig = go.Figure()
-        group_by = self.request.GET.get("group_by", "COUNTRY")
-        class_method = AssetPositionGroupBy.get_class_method_group_by(name=group_by)
-        queryset_without_cash = queryset.exclude(underlying_instrument__is_cash=True)
-        if group_by not in ["INDUSTRY", "CURRENCY"]:
-            df = self.dataframe_groupby_with_class_method(qs=queryset_without_cash, class_method=class_method)
-            fig = self.pie_chart(df=df)
-        elif group_by == "CURRENCY":
-            df = self.dataframe_groupby_with_class_method(qs=queryset, class_method=class_method)
-            fig = self.pie_chart(df=df)
-        else:
-            df = self._generate_classification_df(queryset_without_cash)
-            if not df.empty:
-                df["weighting"] = df.weighting / df.weighting.sum()
-                df.weighting = df.weighting.astype("float")
-                df = df.reset_index().rename(
-                    columns={**self.classification_columns_map, "weighting": "weight", "index": "Equity"}
-                )
-
-                levels = [*self.classification_levels_representation[::-1], "Equity"]
-                df["Equity"] = df["Equity"].map(
-                    dict(Instrument.objects.filter(id__in=df["Equity"]).values_list("id", "name_repr"))
-                )
-                portfolio = Portfolio.objects.get(id=self.kwargs["portfolio_id"])
-                if not PortfolioRole.is_analyst(self.request.user.profile, portfolio=portfolio):
-                    del df["Equity"]
-                    levels.remove("Equity")
-                fig = px.sunburst(
-                    df,
-                    path=levels,
-                    values="weight",
-                    hover_data={"weight": ":.2%"},
-                )
-                fig.update_traces(hovertemplate="<b>%{label}</b><br>Weight = %{customdata:.3p}")
+        df = self.manipulate_dataframe(self.get_dataframe(self.request, queryset))
+        df = df.dropna(how="any")
+        if not df.empty:
+            levels = list(self.columns_map.keys())
+            fig = px.sunburst(
+                df,
+                path=levels,
+                values="weighting",
+                hover_data={"weighting": ":.2%"},
+            )
+        fig.update_traces(hovertemplate="<b>%{label}</b><br>Weight = %{customdata:.3p}")
         return fig
 
 
@@ -185,65 +224,212 @@ class DistributionTableViewSet(AbstractDistributionMixin, ExportPandasAPIViewSet
     button_config_class = DistributionTableButtonConfig
 
     def get_pandas_fields(self, request):
-        if self.request.GET.get("group_by") != "INDUSTRY":
-            fields = [
-                pf.PKField(key="aggregate_field", label=""),
-            ]
-        else:
-            fields = [
-                pf.PKField(key="id", label="IDS"),
-                pf.CharField(key="equity", label="Equity"),
-            ]
-            for level_rep in self.classification_levels_representation:
-                fields.append(pf.CharField(key=level_rep, label=level_rep))
-        fields.extend([pf.FloatField(key="weighting", label="Weight", precision=2, percent=True)])
-        return pf.PandasFields(fields=tuple(fields))
-
-    def get_date_filter(self):
-        if date_str := self.request.GET.get("date", None):
-            val_date = dt.datetime.strptime(date_str, "%Y-%m-%d").date()
-        elif super().get_queryset().exists():
-            val_date = AssetPosition.objects.latest("date").date
+        fields = [
+            pf.PKField(key="id", label="id"),
+            pf.FloatField(key="weighting", label="Weight", precision=2, percent=True),
+        ]
+        for key, label in self.columns_map.items():
+            fields.append(pf.CharField(key=key, label=label))
+        return pf.PandasFields(fields=fields)
+
+    def get_aggregates(self, request, df):
+        return {"weighting": {"Σ": format_number(df["weighting"].sum())}}
+
+
+# ##### CHART VIEWS #####
+
+
+class ContributorPortfolioChartView(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
+    filterset_class = ContributionChartFilter
+    filter_backends = (DjangoFilterBackend,)
+    IDENTIFIER = "wbportfolio:portfolio-contributor"
+    queryset = AssetPosition.objects.all()
+
+    title_config_class = ContributorPortfolioChartTitleConfig
+    endpoint_config_class = ContributorPortfolioChartEndpointConfig
+
+    ROW_HEIGHT: int = 20
+
+    @property
+    def min_height(self):
+        if hasattr(self, "nb_rows"):
+            return self.nb_rows * self.ROW_HEIGHT
+        return "300px"
+
+    @cached_property
+    def hedged_currency(self) -> Currency | None:
+        if "hedged_currency" in self.request.GET:
+            with suppress(Currency.DoesNotExist):
+                return Currency.objects.get(pk=self.request.GET["hedged_currency"])
+
+    @cached_property
+    def show_lookthrough(self) -> bool:
+        return self.portfolio.is_composition and self.request.GET.get("show_lookthrough", "false").lower() == "true"
+
+    def get_filterset_class(self, request):
+        if self.portfolio.is_composition:
+            return CompositionContributionChartFilter
+        return ContributionChartFilter
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        data = []
+        if self.show_lookthrough:
+            d1, d2 = get_date_interval_from_request(self.request)
+            for _d in pd.date_range(d1, d2):
+                for pos in self.portfolio.get_lookthrough_positions(_d.date()):
+                    data.append(
+                        [
+                            pos.date,
+                            pos.initial_price,
+                            pos.initial_currency_fx_rate,
+                            pos.underlying_instrument_id,
+                            pos.weighting,
+                        ]
+                    )
         else:
-            val_date = dt.date.today()
-        return val_date
+            data = queryset.annotate_hedged_currency_fx_rate(self.hedged_currency).values_list(
+                "date", "price", "hedged_currency_fx_rate", "underlying_instrument", "weighting"
+            )
+        df = Portfolio.get_contribution_df(data).rename(columns={"group_key": "underlying_instrument"})
+        if not df.empty:
+            df = df[["contribution_total", "contribution_forex", "underlying_instrument"]].sort_values(
+                by="contribution_total", ascending=True
+            )
+
+            df["instrument_id"] = df.underlying_instrument.map(
+                dict(Instrument.objects.filter(id__in=df["underlying_instrument"]).values_list("id", "name_repr"))
+            )
+            df_forex = df[["instrument_id", "contribution_forex"]]
+            df_forex = df_forex[df_forex.contribution_forex != 0]
+
+            contribution_equity = df.contribution_total - df.contribution_forex
+
+            text_forex = df_forex.contribution_forex.apply(lambda x: f"{x:,.2%}")
+            text_equity = contribution_equity.apply(lambda x: f"{x:,.2%}")
+            setattr(self, "nb_rows", df.shape[0])
+            fig.add_trace(
+                go.Bar(
+                    y=df.instrument_id,
+                    x=contribution_equity,
+                    name="Contribution Equity",
+                    orientation="h",
+                    marker=dict(
+                        color="rgba(247,110,91,0.6)",
+                        line=dict(color="rgb(247,110,91,1.0)", width=2),
+                    ),
+                    text=text_equity.values,
+                    textposition="auto",
+                )
+            )
+            fig.add_trace(
+                go.Bar(
+                    y=df_forex.instrument_id,
+                    x=df_forex.contribution_forex,
+                    name="Contribution Forex",
+                    orientation="h",
+                    marker=dict(
+                        color="rgba(58, 71, 80, 0.6)",
+                        line=dict(color="rgba(58, 71, 80, 1.0)", width=2),
+                    ),
+                    text=text_forex.values,
+                    textposition="outside",
+                )
+            )
+            fig.update_layout(
+                barmode="relative",
+                xaxis=dict(showgrid=False, showline=False, zeroline=False, tickformat=".2%"),
+                yaxis=dict(showgrid=False, showline=False, zeroline=False, tickmode="linear"),
+                margin=dict(b=0, r=20, l=20, t=0, pad=20),
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                font=dict(family="roboto", size=12, color="black"),
+                bargap=0.3,
+            )
+            # fig = get_horizontal_barplot(df, x_label="contribution_total", y_label="name")
+        return fig
+
+    def parse_figure_dict(self, figure_dict: dict[str, any]) -> dict[str, any]:
+        figure_dict = super().parse_figure_dict(figure_dict)
+        figure_dict["style"]["minHeight"] = self.min_height
+        return figure_dict
+
+    def get_queryset(self):
+        if self.has_portfolio_access:
+            return super().get_queryset().filter(portfolio=self.portfolio)
+        return AssetPosition.objects.none()
+
+
+class AssetPositionUnderlyingInstrumentChartViewSet(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
+    IDENTIFIER = "wbportfolio:assetpositionchart"
+
+    queryset = AssetPosition.objects.all()
+
+    title_config_class = AssetPositionUnderlyingInstrumentChartTitleConfig
+    endpoint_config_class = AssetPositionUnderlyingInstrumentChartEndpointConfig
+    filterset_class = AssetPositionUnderlyingInstrumentChartFilter
 
     def get_queryset(self):
-        val_date = self.get_date_filter()
-        queryset = super().get_queryset().filter(date=val_date)
-        return queryset
-
-    def get_dataframe(self, request, queryset, **kwargs):
-        group_by = self.request.GET.get("group_by", "COUNTRY")
-        class_method = AssetPositionGroupBy.get_class_method_group_by(name=group_by)
-        queryset_without_cash = queryset.exclude(underlying_instrument__is_cash=True)
-        if group_by not in ["INDUSTRY", "CURRENCY"]:
-            df = self.dataframe_groupby_with_class_method(qs=queryset_without_cash, class_method=class_method)
-        elif group_by == "CURRENCY":
-            df = self.dataframe_groupby_with_class_method(qs=queryset, class_method=class_method)
-        else:  # group_by == "INDUSTRY"
-            df = self._generate_classification_df(queryset_without_cash)
-
-            if not df.empty:
-                df.weighting /= df.weighting.sum()
-                df = df.reset_index().rename(columns={**self.classification_columns_map, "index": "equity"})
-                df["equity"] = df["equity"].map(
-                    dict(Instrument.objects.filter(id__in=df["equity"]).values_list("id", "name_repr"))
+        return AssetPosition.objects.filter(underlying_quote__in=self.instrument.get_descendants(include_self=True))
+
+    def get_plotly(self, queryset):
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+        fig = get_default_timeserie_figure(fig)
+        if queryset.exists():
+            df_weight = pd.DataFrame(queryset.values("date", "weighting", "portfolio__name"))
+            df_weight = df_weight.where(pd.notnull(df_weight), 0)
+            df_weight = df_weight.groupby(["date", "portfolio__name"]).sum().reset_index()
+            min_date = df_weight["date"].min()
+            max_date = df_weight["date"].max()
+
+            df_price = (
+                pd.DataFrame(
+                    self.instrument.prices.filter_only_valid_prices()
+                    .annotate_base_data()
+                    .filter(date__gte=min_date, date__lte=max_date)
+                    .values_list("date", "net_value_usd"),
+                    columns=["date", "price_fx_usd"],
                 )
-                for level in self.classification_levels_representation:
-                    tmp = df.groupby(by=level).weighting.sum().astype(float).mul(100).round(1)
-                    df = df.join(tmp, on=level, rsuffix=f"_{level}")
-                    df[level] += " (" + df[f"weighting_{level}"].astype(str) + "%)"
-                portfolio = Portfolio.objects.get(id=self.request.GET.get("portfolio"))
-                if not PortfolioRole.is_analyst(self.request.user.profile, portfolio=portfolio):
-                    df[["weighting", "equity"]] = None
-                    df.drop_duplicates(inplace=True)
-        return df
+                .set_index("date")
+                .sort_index()
+            )
 
-    def manipulate_dataframe(self, df):
-        if not df.empty:
-            df.sort_values(by="weighting", ascending=False, inplace=True)
-            if df.weighting.sum() != 1:  # normalize
-                df.weighting /= df.weighting.sum()
-            df = df.reset_index(names="aggregate_field" if self.request.GET.get("group_by") != "INDUSTRY" else "id")
-        return df
+            fig.add_trace(
+                go.Scatter(
+                    x=df_price.index, y=df_price.price_fx_usd, mode="lines", marker_color="green", name="Price"
+                ),
+                secondary_y=False,
+            )
+
+            df_weight = pd.DataFrame(queryset.values("date", "weighting", "portfolio__name"))
+            df_weight = df_weight.where(pd.notnull(df_weight), 0)
+            df_weight = df_weight.groupby(["date", "portfolio__name"]).sum().reset_index()
+            for portfolio_name, df_tmp in df_weight.groupby("portfolio__name"):
+                fig.add_trace(
+                    go.Scatter(
+                        x=df_tmp.date,
+                        y=df_tmp.weighting,
+                        hovertemplate=get_hovertemplate_timeserie(is_percent=True),
+                        mode="lines",
+                        name=f"Allocation: {portfolio_name}",
+                    ),
+                    secondary_y=True,
+                )
+
+            # Set x-axis title
+            fig.update_xaxes(title_text="Date")
+            # Set y-axes titles
+            fig.update_yaxes(
+                title_text="<b>Price</b>",
+                secondary_y=False,
+                titlefont=dict(color="green"),
+                tickfont=dict(color="green"),
+            )
+            fig.update_yaxes(
+                title_text="<b>Portfolio Allocation (%)</b>",
+                secondary_y=True,
+                titlefont=dict(color="blue"),
+                tickfont=dict(color="blue"),
+            )
+
+        return fig

wbportfolio/viewsets/configs/buttons/products.py

@@ -1,15 +1,18 @@
+from rest_framework.reverse import reverse
 from wbcore.contrib.icons import WBIcon
 from wbcore.metadata.configs import buttons as bt
 from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
 from wbfdm.viewsets.configs.buttons.instruments import InstrumentButtonViewConfig
 
+from wbportfolio.models import Product
+
 
 class ProductButtonConfig(ButtonViewConfig):
     def get_custom_list_instance_buttons(self):
         return self.get_custom_instance_buttons()
 
     def get_custom_instance_buttons(self):
-        return {
+        buttons = [
             bt.DropDownButton(
                 label="Commission",
                 icon=WBIcon.UNFOLD.icon,
@@ -35,7 +38,34 @@ class ProductButtonConfig(ButtonViewConfig):
                     ),
                 ],
             ),
-        }
+        ]
+        if product_id := self.view.kwargs.get("pk", None):
+            product = Product.objects.get(id=product_id)
+            report_buttons = []
+            for report in product.reports.filter(is_active=True):
+                tmp_buttons = []
+                if primary_version := report.primary_version:
+                    tmp_buttons.append(
+                        bt.HyperlinkButton(
+                            label="Public Report",
+                            endpoint=reverse(
+                                "public_report:report_version", args=[primary_version.lookup], request=self.request
+                            ),
+                        ),
+                    )
+                    if self.request.user.profile.is_internal or self.request.user.is_superuser:
+                        tmp_buttons.append(
+                            bt.WidgetButton(
+                                label="Widget",
+                                endpoint=reverse("wbreport:report-detail", args=[report.id], request=self.request),
+                            ),
+                        )
+                if tmp_buttons:
+                    report_buttons.append(bt.DropDownButton(label=str(report), buttons=tmp_buttons))
+            if report_buttons:
+                buttons.append(bt.DropDownButton(label="Reports", buttons=report_buttons))
+
+        return set(buttons)
 
 
 class ProductCustomerButtonConfig(ButtonViewConfig):

wbportfolio/viewsets/configs/display/assets.py

@@ -234,22 +234,9 @@ class CompositionModelPortfolioPandasDisplayConfig(DisplayViewConfig):
 
 class DistributionTableDisplayConfig(DisplayViewConfig):
     def get_list_display(self) -> Optional[dp.ListDisplay]:
-        if group_by := self.request.GET.get("group_by", ""):
-            group_by = group_by.title().replace("_", " ")
-
-        if group_by != "Industry":
-            fields = [
-                dp.Field(key="aggregate_field", label=group_by),
-                dp.Field(key="weighting", label="Weight"),
-            ]
-        else:
-            fields = []
-            for level_rep in self.view.classification_levels_representation:
-                fields.append(dp.Field(key=level_rep, label=level_rep))
-            fields.extend(
-                [
-                    dp.Field(key="equity", label="Equity"),
-                    dp.Field(key="weighting", label="Weight"),
-                ]
-            )
-        return dp.ListDisplay(fields=tuple(fields))
+        fields = [
+            dp.Field(key="weighting", label="Weighting"),
+        ]
+        for k, v in reversed(self.view.columns_map.items()):
+            fields.append(dp.Field(key=k, label=v))
+        return dp.ListDisplay(fields=fields)