wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/viewsets/assets_and_net_new_money_progression.py

@@ -0,0 +1,117 @@
+from datetime import date, datetime
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from wbcore import viewsets
+from wbcrm.models.accounts import Account
+from wbportfolio.analysis.claims import get_assets_and_net_new_money_progression
+from wbportfolio.filters import AssetsAndNetNewMoneyProgressionFilterSet
+from wbportfolio.models.products import Product
+from wbportfolio.models.transactions.claim import Claim
+
+from .configs import AssetAndNetNewMoneyProgressionChartTitleConfig
+
+
+class AssetAndNetNewMoneyProgressionChartViewSet(viewsets.ChartViewSet):
+    queryset = Claim.objects.all()
+
+    filterset_class = AssetsAndNetNewMoneyProgressionFilterSet
+
+    title_config_class = AssetAndNetNewMoneyProgressionChartTitleConfig
+
+    def get_plotly(self, queryset) -> "go.Figure":
+        if "period" not in self.request.GET:
+            from_date = date(2023, 12, 31)
+            to_date = date(2024, 6, 30)
+        else:
+            from_date, to_date = self.request.GET["period"].split(",")
+            from_date = datetime.strptime(from_date, "%Y-%m-%d").date()
+            to_date = datetime.strptime(to_date, "%Y-%m-%d").date()
+
+        account_id = self.request.GET.get("account", None)
+        product_id = self.request.GET.get("product", None)
+
+        name = f"Progression: {from_date:%d.%m.%Y}-{to_date:%d.%m.%Y}"
+
+        account_tree_id = None
+        el = list()
+        if account_id:
+            account = Account.objects.get(id=account_id)
+            account_tree_id = account.tree_id  # type: ignore
+            el.append(str(account))
+
+        if product_id:
+            el.append(str(Product.objects.get(id=product_id)))
+
+        if len(el) > 0:
+            name += f" ({", ".join(el)})"
+
+        data = get_assets_and_net_new_money_progression(
+            from_date=from_date, to_date=to_date, account_tree_id=account_tree_id, product_id=product_id
+        )
+        df = pd.DataFrame(data)
+
+        # Compute performance of each month
+        df["performance"] = df["total_assets"] - df["total_assets"].shift(1) - df["net_new_money"]
+
+        # Compute the x label
+        df["x"] = df[["year", "month"]].apply(lambda row: "-".join(row.values.astype(str)), axis=1)
+
+        # Implode the pivoted table to have a list of values
+        df = df.melt(id_vars=["x", "year", "month"], value_vars=["net_new_money", "performance", "total_assets"])
+
+        # Sort by year, then month, then variable to have everything in the right order
+        df = df.sort_values(["year", "month", "variable"])
+
+        # Remove the first two rows, as they are the NNM and Performance of the previous month, which we do not want to display
+        df = df.iloc[2:]
+
+        # Create a pattern to have the measure for the waterfall chart
+        df["measure"] = np.tile(["absolute", "relative", "relative"], len(df) // 3 + 1)[: len(df)]
+
+        # We reset the index and drop all columns we don't need
+        # IMPORTANT: Do not drop year and month, even though we
+        # don't need it - we will loose the ordering
+        df = df.reset_index()[["x", "year", "month", "variable", "value", "measure"]]
+
+        # Rename things, to have it pretty in the chart
+        df["variable"] = (
+            df["variable"]
+            .str.replace("net_new_money", "NNM")
+            .replace("total_assets", "AuM")
+            .replace("performance", "Performance")
+        )
+        df.iloc[0, 0] = ""
+        df.iloc[0, 3] = "Initial AuM"
+        df.iloc[-1, 3] = "Final AuM"
+
+        # Create the figure and show it
+        fig = go.Figure()
+        fig.add_trace(
+            go.Waterfall(
+                name=name,
+                orientation="v",
+                measure=df["measure"],
+                x=[df["x"], df["variable"]],
+                y=df["value"],
+                text=list(map(lambda x: f"{x/1_000_000:,.0f}" if x is not None else "0", df["value"])),
+                decreasing={"marker": {"color": "#FF6961"}},
+                increasing={"marker": {"color": "#77DD77"}},
+                totals={"marker": {"color": "#D3D3D3"}},
+            )
+        )
+        fig.update_layout(
+            template="plotly_white",
+            margin=dict(l=10, r=10, t=0, b=40),
+            showlegend=True,
+            legend={
+                "orientation": "h",
+                "yanchor": "bottom",
+                "y": 1,
+                "xanchor": "center",
+                "x": 0.5,
+            },
+        )
+
+        return fig

wbportfolio/viewsets/charts/__init__.py

@@ -0,0 +1 @@
+from .assets import DistributionChartViewSet, DistributionTableViewSet

wbportfolio/viewsets/charts/assets.py

@@ -0,0 +1,247 @@
+import datetime as dt
+
+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.utils.functional import cached_property
+from wbcore import viewsets
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.filters import DjangoFilterBackend
+from wbcore.pandas import fields as pf
+from wbfdm.models import (
+    ClassificationGroup,
+    Instrument,
+    InstrumentClassificationThroughModel,
+)
+from wbportfolio.filters.assets import DistributionFilter
+from wbportfolio.models import (
+    AssetPosition,
+    AssetPositionGroupBy,
+    Portfolio,
+    PortfolioRole,
+)
+
+from ..configs.buttons.assets import (
+    DistributionChartButtonConfig,
+    DistributionTableButtonConfig,
+)
+from ..configs.display.assets import DistributionTableDisplayConfig
+from ..configs.endpoints.assets import (
+    DistributionChartEndpointConfig,
+    DistributionTableEndpointConfig,
+)
+from ..configs.titles.assets import (
+    DistributionChartTitleConfig,
+    DistributionTableTitleConfig,
+)
+
+
+class AbstractDistributionMixin:
+    AUTORESIZE = False
+    queryset = AssetPosition.objects.all()
+    filterset_class = DistributionFilter
+    filter_backends = (DjangoFilterBackend,)
+
+    @cached_property
+    def classification_group(self):
+        try:
+            return ClassificationGroup.objects.get(id=self.request.GET.get("group_by_classification_group"))
+        except ClassificationGroup.DoesNotExist:
+            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()
+
+    @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_security_instrument_type_key="equity").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 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)
+        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 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"))
+            )
+        return df
+
+
+class DistributionChartViewSet(AbstractDistributionMixin, viewsets.ChartViewSet):
+    title_config_class = DistributionChartTitleConfig
+    endpoint_config_class = DistributionChartEndpointConfig
+    button_config_class = DistributionChartButtonConfig
+
+    @staticmethod
+    def pie_chart(df: pd.DataFrame) -> go.Figure:
+        fig = go.Figure()
+        if not df.empty:
+            fig.add_pie(
+                labels=df.index,
+                values=df.weighting.mul(100),
+                marker=dict(colors=px.colors.qualitative.Plotly[: df.shape[0]], line=dict(color="#000000", width=2)),
+                hovertemplate="<b>%{label}</b><extra></extra>",
+            )
+        return fig
+
+    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}")
+        return fig
+
+
+class DistributionTableViewSet(AbstractDistributionMixin, ExportPandasAPIViewSet):
+    endpoint_config_class = DistributionTableEndpointConfig
+    display_config_class = DistributionTableDisplayConfig
+    title_config_class = DistributionTableTitleConfig
+    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
+        else:
+            val_date = dt.date.today()
+        return val_date
+
+    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"))
+                )
+                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
+
+    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

wbportfolio/viewsets/configs/__init__.py

@@ -0,0 +1,6 @@
+from .buttons import *
+from .display import *
+from .endpoints import *
+from .menu import *
+from .previews import *
+from .titles import *

wbportfolio/viewsets/configs/buttons/__init__.py

@@ -0,0 +1,23 @@
+from .adjustments import AdjustmentButtonConfig
+from .assets import (
+    AssetPositionButtonConfig,
+    AssetPositionInstrumentButtonConfig,
+    AssetPositionPortfolioButtonConfig,
+    DistributionChartButtonConfig,
+    DistributionTableButtonConfig,
+)
+from .claims import ClaimTradeButtonConfig, ConsolidatedTradeSummaryButtonConfig
+
+from .custodians import CustodianButtonConfig
+from .fees import FeesButtonConfig
+from .portfolios import ModelPortfolioButtonConfig, PortfolioButtonConfig
+from .products import ProductButtonConfig, ProductCustomerButtonConfig
+from .registers import RegisterButtonConfig
+from .trades import (
+    TradeButtonConfig,
+    TradeInstrumentButtonConfig,
+    TradeProposalButtonConfig,
+    TradeTradeProposalButtonConfig,
+)
+from .reconciliations import AccountReconciliationButtonViewConfig, AccountReconciliationLineButtonViewConfig
+from .signals import *

wbportfolio/viewsets/configs/buttons/adjustments.py

@@ -0,0 +1,13 @@
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class AdjustmentButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self):
+        return {
+            bt.WidgetButton(key="detection_table", label="Detection Table", icon=WBIcon.DATA_GRID.icon),
+        }
+
+    def get_custom_instance_buttons(self):
+        return self.get_custom_list_instance_buttons()

wbportfolio/viewsets/configs/buttons/assets.py

@@ -0,0 +1,145 @@
+from contextlib import suppress
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbportfolio.models.portfolio import Portfolio, PortfolioPortfolioThroughModel
+
+
+class AssetPositionButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self):
+        return set()
+
+    def get_custom_instance_buttons(self):
+        return set()
+
+
+class AssetPositionPortfolioButtonConfig(AssetPositionButtonConfig):
+    def get_custom_buttons(self):
+        btns = []
+        with suppress(Portfolio.DoesNotExist):
+            portfolio = Portfolio.objects.get(id=self.view.kwargs.get("portfolio_id", None))
+            btns.append(
+                bt.WidgetButton(
+                    endpoint=reverse(
+                        "wbportfolio:portfolio-contributor-list", args=[portfolio.id], request=self.request
+                    ),
+                    label="Contributor",
+                )
+            )
+            btns.append(
+                bt.WidgetButton(
+                    endpoint=(
+                        reverse(
+                            "wbportfolio:portfolio-distributionchart-list",
+                            args=[portfolio.id],
+                            request=self.request,
+                        )
+                    ),
+                    label="Distribution Charts",
+                )
+            )
+            btns.append(
+                bt.WidgetButton(
+                    endpoint=(
+                        reverse(
+                            "wbportfolio:portfolio-esgaggregation-list",
+                            args=[portfolio.id],
+                            request=self.request,
+                        )
+                    ),
+                    label="ESG Aggregation",
+                )
+            )
+            cash_management_btns = []
+
+            if portfolio.daily_cashflows.all().exists():
+                cash_management_btns.append(
+                    bt.WidgetButton(
+                        label="Cash Flow",
+                        endpoint=reverse(
+                            "wbportfolio:portfolio-portfoliocashflow-list",
+                            args=[portfolio.id],
+                            request=self.request,
+                        ),
+                    )
+                )
+
+            if portfolio.bank_accounts.all().exists():
+                bank_account_ids = map(lambda i: str(i), portfolio.bank_accounts.all().values_list("id", flat=True))
+                base_url = reverse("wbaccounting:futurecashflow-list", request=self.request)
+                cash_flow_url = f"{base_url}?banking_contact={", ".join(bank_account_ids)}"
+                cash_management_btns.append(
+                    bt.WidgetButton(
+                        label="Bank Accounts",
+                        endpoint=cash_flow_url,
+                    )
+                )
+
+            if len(cash_management_btns) > 0:
+                btns.append(
+                    bt.DropDownButton(
+                        label="Cash Management",
+                        buttons=cash_management_btns,
+                    )
+                )
+            for rel in PortfolioPortfolioThroughModel.objects.filter(portfolio=portfolio):
+                dependency_portfolio = rel.dependency_portfolio
+                if dependency_portfolio.assets.exists():
+                    btns.append(
+                        bt.WidgetButton(
+                            endpoint=(
+                                reverse(
+                                    "wbportfolio:portfolio-asset-list",
+                                    args=[dependency_portfolio.id],
+                                    request=self.request,
+                                )
+                            ),
+                            label=f"{PortfolioPortfolioThroughModel.Type[rel.type].label} Portfolio",
+                        )
+                    )
+        return set(btns)
+
+
+class AssetPositionInstrumentButtonConfig(AssetPositionButtonConfig):
+    def get_custom_buttons(self):
+        if instrument_id := self.view.kwargs.get("instrument_id", None):
+            return {
+                bt.WidgetButton(
+                    endpoint=reverse(
+                        "wbportfolio:instrument-assetpositionchart-list", args=[instrument_id], request=self.request
+                    ),
+                    label="Portfolio Allocation ",
+                ),
+            }
+        return set()
+
+
+class DistributionChartButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        if portfolio_id := self.view.kwargs.get("portfolio_id", None):
+            return {
+                bt.WidgetButton(
+                    endpoint=(
+                        f"{reverse('wbportfolio:portfolio-distributiontable-list', args=[portfolio_id], request=self.request)}"
+                        f"?group_by={self.request.GET.get('group_by')}"
+                    ),
+                    label="Table Form",
+                ),
+            }
+        return set()
+
+
+class DistributionTableButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        if portfolio_id := self.view.kwargs.get("portfolio_id", None):
+            return {
+                bt.WidgetButton(
+                    endpoint=(
+                        f"{reverse('wbportfolio:portfolio-distributionchart-list', args=[portfolio_id], request=self.request)}"
+                        f"?group_by={self.request.GET.get('group_by')}"
+                    ),
+                    label="Chart Form",
+                ),
+            }
+        return set()

wbportfolio/viewsets/configs/buttons/claims.py

@@ -0,0 +1,83 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.utils.urls import get_urlencode_endpoint
+from wbcrm.models.accounts import Account
+from wbcrm.serializers.accounts import TerminalAccountRepresentationSerializer
+
+
+class TransferTradeSerializer(serializers.Serializer):
+    transfer_date = serializers.DateField(label="Transfer Date", required=True)
+    from_account = serializers.PrimaryKeyRelatedField(
+        queryset=Account.objects.all(), label="From Account", required=True
+    )
+    _from_account = TerminalAccountRepresentationSerializer(source="from_account")
+
+    to_account = serializers.PrimaryKeyRelatedField(queryset=Account.objects.all(), label="To Account", required=True)
+    _to_account = TerminalAccountRepresentationSerializer(source="to_account")
+
+
+class QuickClaimSerializer(serializers.Serializer):
+    account = serializers.PrimaryKeyRelatedField(queryset=Account.objects.all(), label="Account", required=True)
+    _account = TerminalAccountRepresentationSerializer(source="account")
+
+
+class ConsolidatedTradeSummaryButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        return {
+            bt.WidgetButton(
+                endpoint=get_urlencode_endpoint(
+                    reverse(
+                        "wbportfolio:consolidatedtradesummarydistributionchart-list", args=[], request=self.request
+                    ),
+                    self.request.GET,
+                ),
+                label="Distribution NNM Chart",
+            ),
+            bt.WidgetButton(
+                endpoint=get_urlencode_endpoint(
+                    reverse("wbportfolio:cumulativennmchart-list", args=[], request=self.request), self.request.GET
+                ),
+                label="Cumulative NNM Chart",
+            ),
+        }
+
+
+class ClaimTradeButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        return {
+            bt.ActionButton(
+                method=RequestType.POST,
+                action_label="Trade transferred.",
+                endpoint=reverse(
+                    "wbportfolio:trade-claim-transfer-trade", request=self.request, args=[self.view.kwargs["trade_id"]]
+                ),
+                description_fields="Do you want to transfer this trade?",
+                label="Transfer Trade",
+                icon=WBIcon.DEAL.icon,
+                confirm_config=bt.ButtonConfig(label="Transfer"),
+                cancel_config=bt.ButtonConfig(label="Cancel"),
+                serializer=TransferTradeSerializer,
+                instance_display=create_simple_display([["transfer_date"], ["from_account"], ["to_account"]]),
+            ),
+            bt.ActionButton(
+                method=RequestType.POST,
+                action_label="Trade claimed.",
+                endpoint=reverse(
+                    "wbportfolio:trade-claim-quick-claim", request=self.request, args=[self.view.kwargs["trade_id"]]
+                ),
+                description_fields="Do you want to quick claim this trade?",
+                label="Quick Claim",
+                icon=WBIcon.EURO.icon,
+                confirm_config=bt.ButtonConfig(label="Claim"),
+                cancel_config=bt.ButtonConfig(label="Cancel"),
+                serializer=QuickClaimSerializer,
+                instance_display=create_simple_display([["account"]]),
+            ),
+        }