wbportfolio 1.44.2__tar.gz → 1.44.3__tar.gz

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.44.2
+Version: 1.44.3
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/analysis/claims.py

@@ -3,7 +3,8 @@ from typing import TYPE_CHECKING
 import numpy as np
 import pandas as pd
 from django.db import connection
-from django.db.models import DecimalField, ExpressionWrapper, F, OuterRef, Subquery
+from django.db.models import DecimalField, ExpressionWrapper, F, OuterRef, Subquery, DateField
+from django.db.models.functions import Greatest
 from django.template.loader import get_template
 from jinjasql import JinjaSql
 from wbcore.contrib.currency.models import CurrencyFXRates
@@ -47,6 +48,7 @@ class ConsolidatedTradeSummary:
         pivot_label: str,
         classification_group: ClassificationGroup | None = None,
         classification_height: int = 0,
+        date_label: str = "date_considered",
     ):
         self.queryset = queryset.filter(trade__isnull=False, status="APPROVED")
         self.start_date = start_date
@@ -60,6 +62,9 @@ class ConsolidatedTradeSummary:
             fx_rate=CurrencyFXRates.get_fx_rates_subquery("date", lookup_expr="exact"),
             aum=ExpressionWrapper(F("fx_rate") * F("net_value") * F("shares"), output_field=DecimalField()),
             internal_trade=F("trade__marked_as_internal"),
+            date_considered=ExpressionWrapper(
+                Greatest("trade__transaction_date", "date") + 1, output_field=DateField()
+            ),
         )
         self.queryset = Account.annotate_root_account_info(self.queryset)
 
@@ -71,17 +76,17 @@ class ConsolidatedTradeSummary:
             "account",
             "product__parent",
         )
-        self.df = self._prepare_df()
+        self.df = self._prepare_df(date_label)
 
-    def _prepare_df(self) -> pd.DataFrame:
-        columns = ["shares", "date", "product__id", "aum", "internal_trade"]
+    def _prepare_df(self, date_label: str) -> pd.DataFrame:
+        columns = ["shares", date_label, "product__id", "aum", "internal_trade"]
         if self.pivot == "classification_id":
             columns.append("classifications")
         else:
             columns.append(self.pivot)
             columns.append(self.pivot_label)
 
-        df = pd.DataFrame(self.queryset.values_list(*columns), columns=columns)
+        df = pd.DataFrame(self.queryset.values_list(*columns), columns=columns).rename(columns={date_label: "date"})
         if self.pivot == "classification_id":
             df = (
                 df.explode("classifications")
@@ -112,7 +117,7 @@ class ConsolidatedTradeSummary:
                     "net_value",
                     date_name="net_value_date_start",
                     instrument_pk_name="pk",
-                    date_lookup="exact"
+                    date_lookup="exact",
                     # we get all net value (even estimated) to avoir showing None price on holiday
                 ),
                 fx_rate_start=CurrencyFXRates.get_fx_rates_subquery(
@@ -123,7 +128,7 @@ class ConsolidatedTradeSummary:
                     "net_value",
                     date_name="net_value_date_end",
                     instrument_pk_name="pk",
-                    date_lookup="exact"
+                    date_lookup="exact",
                     # we get all net value (even estimated) to avoir showing None price on holiday
                 ),
                 fx_rate_end=CurrencyFXRates.get_fx_rates_subquery(

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/filters/products.py

@@ -22,7 +22,7 @@ class BaseProductFilterSet(InstrumentFilterSet):
         label="Bank",
         queryset=Company.objects.all(),
         endpoint=Company.get_representation_endpoint(),
-        filter_params={"bank_product": True},
+        filter_params={"notnull_related_name": "issues_products"},
         value_key=Company.get_representation_value_key(),
         label_key=Company.get_representation_label_key(),
     )

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/filters/signals.py

@@ -3,32 +3,12 @@ from datetime import date
 from django.db.models import Exists, OuterRef
 from django.dispatch import receiver
 from wbcore import filters as wb_filters
-from wbcore.contrib.directory.filters import CompanyFilter
 from wbcore.signals.filters import add_filters
 from wbfdm.filters import BaseClassifiedInstrumentFilterSet, ClassificationFilter
 from wbfdm.models import InstrumentClassificationThroughModel
 from wbportfolio.models import AssetPosition, Portfolio
 
 
-@receiver(add_filters, sender=CompanyFilter)
-def add_bank_product_filter(sender, request=None, *args, **kwargs):
-    def method_bank(queryset, name, value):
-        if value is True:
-            return queryset.filter(issues_products__isnull=False).distinct()
-        elif value is False:
-            return queryset.filter(issues_products__isnull=True).distinct()
-        return queryset
-
-    return {
-        "bank_product": wb_filters.BooleanFilter(
-            field_name="bank_product",
-            label="Is a Bank",
-            help_text="Filter for companies that are a bank and serve as the custodian of a product in the PMS",
-            method=method_bank,
-        )
-    }
-
-
 @receiver(add_filters, sender=ClassificationFilter)
 def add_portfolio_filter(sender, request=None, *args, **kwargs):
     def _filter_portfolio(queryset, name, value):

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/filters/transactions/__init__.py

@@ -3,6 +3,7 @@ from .claim import (
     ClaimGroupByFilter,
     ConsolidatedTradeSummaryTableFilterSet,
     CumulativeNNMChartFilter,
+    DistributionNNMChartFilter,
     CustomerAPIFilter,
     CustomerClaimFilter,
     CustomerClaimGroupByFilter,

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/filters/transactions/claim.py

@@ -82,7 +82,6 @@ class CommissionBaseFilterSet(wb_filters.FilterSet):
         endpoint=Account.get_representation_endpoint(),
         value_key=Account.get_representation_value_key(),
         label_key=Account.get_representation_label_key(),
-        filter_params={"status": "OPEN"},
     )
 
     manager_role = wb_filters.ModelChoiceFilter(
@@ -205,7 +204,7 @@ class ClaimFilter(OppositeSharesFieldMethodMixin, CommissionBaseFilterSet):
         }
 
 
-class ClaimGroupByFilter(ClaimFilter):
+class ClaimGroupByFilter(CommissionBaseFilterSet):
     pending_approval = in_charge_of_customer = linked_trade = None
 
     only_new_customer = wb_filters.BooleanFilter(method="filter_only_new_customer", label="Only new customers")
@@ -303,6 +302,19 @@ class ConsolidatedTradeSummaryTableFilterSet(PandasFilterSetMixin, ClaimGroupByF
         }
 
 
+class DistributionNNMChartFilter(ClaimGroupByFilter):
+    percent = wb_filters.BooleanFilter(
+        method="fake_filter",
+        default=False,
+        help_text="True if the value are displayed in percentage of the initial total AUM",
+        label="Show percentage",
+    )
+
+    class Meta:
+        model = Claim
+        fields = {}
+
+
 class CumulativeNNMChartFilter(ClaimGroupByFilter):
     groupby_classification_group = group_by = None
 

wbportfolio-1.44.3/wbportfolio/migrations/0072_trade_diff_shares.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.10 on 2025-01-28 10:17
+
+import django.db.models.expressions
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0071_alter_trade_options_alter_trade_order'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='trade',
+            name='diff_shares',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('shares'), '-', models.F('claimed_shares')), output_field=models.DecimalField(decimal_places=4, max_digits=15)),
+        ),
+    ]

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/models/asset.py

@@ -416,12 +416,15 @@ class AssetPosition(ImportMixin, models.Model):
                         net_value *= self.currency.convert(
                             self.asset_valuation_date, self.underlying_instrument.currency
                         )
-                    self.underlying_instrument_price = InstrumentPrice.objects.create(
+                    self.underlying_instrument_price = InstrumentPrice(
                         calculated=False,
                         instrument=self.underlying_instrument,
                         date=self.asset_valuation_date,
                         net_value=net_value,
+                        import_source=self.import_source,  # we set the import source to know where this price is coming from
                     )
+                    self.underlying_instrument_price.fill_market_capitalization()
+                    self.underlying_instrument_price.save()
                 else:  # sometime, the asset valuation date does not correspond to a valid market date. In that case, we get the latest valid instrument price for that product
                     self.underlying_instrument_price = (
                         InstrumentPrice.objects.filter(

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/models/portfolio.py

@@ -25,6 +25,7 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 from psycopg.types.range import DateRange
 from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbcore.utils.models import ActiveObjectManager, DeleteToDisableMixin
 from wbfdm.contrib.metric.dispatch import compute_metrics
@@ -232,7 +233,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         verbose_name_plural = "Portfolios"
 
         notification_types = [
-            (
+            create_notification_type(
                 "wbportfolio.portfolio.check_custodian_portfolio",
                 "Check Custodian Portfolio",
                 "Sends a notification when a portfolio does not match with its custodian portfolio",

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/models/portfolio_cash_flow.py

@@ -3,6 +3,7 @@ from decimal import Decimal
 
 from django.db import models
 from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbportfolio.import_export.handlers.portfolio_cash_flow import (
     DailyPortfolioCashFlowImportHandler,
@@ -132,7 +133,7 @@ class DailyPortfolioCashFlow(ImportMixin, WBModel):
         ]
         permissions = [("administrate_dailyportfoliocashflow", "Can administrate Daily Portfolio CashFlow")]
         notification_types = [
-            (
+            create_notification_type(
                 "wbportfolio.dailyportfoliocashflow.notify_rebalance",
                 "Rebalancing suggested",
                 "Sends a notification, when the system suggests to rebalance a portfolio due to being outside of the cash target parameters",
@@ -140,7 +141,7 @@ class DailyPortfolioCashFlow(ImportMixin, WBModel):
                 True,
                 False,
             ),
-            (
+            create_notification_type(
                 "wbportfolio.dailyportfoliocashflow.notify_swingpricing",
                 "Swing Pricing Notification",
                 "Sends a notification, when the system detects a future swing pricing event",

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/models/transactions/trades.py

@@ -21,7 +21,7 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
 from django_fsm import GET_STATE, FSMField, transition
-from ordered_model.models import OrderedModel, OrderedModelManager
+from ordered_model.models import OrderedModel, OrderedModelManager, OrderedModelQuerySet
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
@@ -37,58 +37,65 @@ from wbportfolio.pms.typing import Trade as TradeDTO
 from .transactions import ShareMixin, Transaction
 
 
-class DefaultTradeManager(OrderedModelManager):
-    """This manager is expect to be the trade default manager and annotate by default the effective weight (extracted
-    from the associated portfolio) and the target weight as an addition between the effective weight and the delta weight
-    """
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .annotate(
-                last_effective_date=Subquery(
+class TradeQueryset(OrderedModelQuerySet):
+    def annotate_base_info(self):
+        return self.annotate(
+            last_effective_date=Subquery(
+                AssetPosition.objects.filter(
+                    underlying_instrument=OuterRef("underlying_instrument"),
+                    date__lt=OuterRef("transaction_date"),
+                    portfolio=OuterRef("portfolio"),
+                )
+                .order_by("-date")
+                .values("date")[:1]
+            ),
+            effective_weight=Coalesce(
+                Subquery(
                     AssetPosition.objects.filter(
                         underlying_instrument=OuterRef("underlying_instrument"),
-                        date__lt=OuterRef("transaction_date"),
+                        date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
                     )
-                    .order_by("-date")
-                    .values("date")[:1]
-                ),
-                effective_weight=Coalesce(
-                    Subquery(
-                        AssetPosition.objects.filter(
-                            underlying_instrument=OuterRef("underlying_instrument"),
-                            date=OuterRef("last_effective_date"),
-                            portfolio=OuterRef("portfolio"),
-                        )
-                        .values("portfolio")
-                        .annotate(s=Sum("weighting"))
-                        .values("s")[:1]
-                    ),
-                    Decimal(0),
+                    .values("portfolio")
+                    .annotate(s=Sum("weighting"))
+                    .values("s")[:1]
                 ),
-                target_weight=F("effective_weight") + F("weighting"),
-                effective_shares=Coalesce(
-                    Subquery(
-                        AssetPosition.objects.filter(
-                            underlying_instrument=OuterRef("underlying_instrument"),
-                            date=OuterRef("last_effective_date"),
-                            portfolio=OuterRef("portfolio"),
-                        )
-                        .values("portfolio")
-                        .annotate(s=Sum("shares"))
-                        .values("s")[:1]
-                    ),
-                    Decimal(0),
+                Decimal(0),
+            ),
+            target_weight=F("effective_weight") + F("weighting"),
+            effective_shares=Coalesce(
+                Subquery(
+                    AssetPosition.objects.filter(
+                        underlying_instrument=OuterRef("underlying_instrument"),
+                        date=OuterRef("last_effective_date"),
+                        portfolio=OuterRef("portfolio"),
+                    )
+                    .values("portfolio")
+                    .annotate(s=Sum("shares"))
+                    .values("s")[:1]
                 ),
-                target_shares=F("effective_weight") * F("weighting"),
-                diff_shares=F("shares") - F("claimed_shares"),
-            )
+                Decimal(0),
+            ),
+            target_shares=F("effective_weight") * F("weighting"),
         )
 
 
+class DefaultTradeManager(OrderedModelManager):
+    """This manager is expect to be the trade default manager and annotate by default the effective weight (extracted
+    from the associated portfolio) and the target weight as an addition between the effective weight and the delta weight
+    """
+
+    def __init__(self, with_annotation: bool = False, *args, **kwargs):
+        self.with_annotation = with_annotation
+        super().__init__(*args, **kwargs)
+
+    def get_queryset(self) -> TradeQueryset:
+        qs = TradeQueryset(self.model, using=self._db)
+        if self.with_annotation:
+            qs = qs.annotate_base_info()
+        return qs
+
+
 class ValidCustomerTradeManager(DefaultTradeManager):
     def __init__(self, without_internal_trade: bool = False):
         self.without_internal_trade = without_internal_trade
@@ -202,7 +209,13 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         help_text="The number of shares that were claimed.",
         verbose_name="Claimed Shares",
     )
+    diff_shares = models.GeneratedField(
+        expression=F("shares") - F("claimed_shares"),
+        output_field=models.DecimalField(max_digits=15, decimal_places=4),
+        db_persist=True,
+    )
     objects = DefaultTradeManager()
+    annotated_objects = DefaultTradeManager(with_annotation=True)
     valid_customer_trade_objects = ValidCustomerTradeManager()
     valid_external_customer_trade_objects = ValidCustomerTradeManager(without_internal_trade=True)
 
@@ -436,13 +449,6 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     def _target_shares(self) -> Decimal:
         return getattr(self, "target_shares", self._effective_shares * self.weighting)
 
-    @cached_property
-    @admin.display(description="Diff Claims")
-    def _diff_shares(self) -> Decimal:
-        if hasattr(self, "diff_shares"):
-            return self.diff_shares
-        return self.shares - self.claimed_shares
-
     order_with_respect_to = "trade_proposal"
 
     class Meta(OrderedModel.Meta):

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/risk_management/tests/test_accounts.py

@@ -51,46 +51,58 @@ class TestAccountRuleModel:
         account = account_factory.create(owner=entry)
         other_account = account_factory.create()
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval + 2)).date(),
+            date=(weekday - BDay(business_days_interval + 3)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 3)).date()
+            ),
             status="APPROVED",
             shares=100,
         )
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval + 1)).date(),
+            date=(weekday - BDay(business_days_interval + 2)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 2)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop should not be detected
 
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval)).date(),
+            date=(weekday - BDay(business_days_interval + 1)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 1)).date()
+            ),
             status="APPROVED",
             shares=150,
         )
         claim_factory.create(
-            date=weekday,
+            date=(weekday - BDay(1)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(1)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop should be detected
 
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval)).date(),
+            date=(weekday - BDay(business_days_interval + 1)).date(),
             account=other_account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 1)).date()
+            ),
             status="APPROVED",
             shares=150,
         )
         claim_factory.create(
-            date=weekday,
+            date=(weekday - BDay(1)).date(),
             account=other_account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(1)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop is valid but an another account so won't be detected

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/serializers/transactions/trades.py

@@ -45,11 +45,7 @@ class TradeProposalRepresentationSerializer(wb_serializers.RepresentationSeriali
 
 class TradeRepresentationSerializer(TransactionRepresentationSerializer):
     _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:trade-detail")
-
-    diff_shares = wb_serializers.SerializerMethodField()
-
-    def get_diff_shares(self, obj):
-        return obj._diff_shares
+    diff_shares = wb_serializers.DecimalField(max_digits=15, decimal_places=4)
 
     class Meta:
         model = Trade
@@ -241,7 +237,7 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
         percent_fields = ["effective_weight", "target_weight", "weighting"]
         read_only_fields = (
             "transaction_subtype",
-            "shares"
+            "shares",
             # "underlying_instrument",
             # "_underlying_instrument",
         )

{wbportfolio-1.44.2 → wbportfolio-1.44.3}/wbportfolio/viewsets/transactions/claim.py

@@ -46,7 +46,6 @@ from wbfdm.preferences import get_default_classification_group
 from wbportfolio.analysis.claims import ConsolidatedTradeSummary
 from wbportfolio.filters import (
     ClaimFilter,
-    ClaimGroupByFilter,
     ConsolidatedTradeSummaryTableFilterSet,
     CumulativeNNMChartFilter,
     CustomerAPIFilter,
@@ -54,6 +53,7 @@ from wbportfolio.filters import (
     CustomerClaimGroupByFilter,
     NegativeTermimalAccountPerProductFilterSet,
     ProfitAndLossPandasFilter,
+    DistributionNNMChartFilter,
 )
 from wbportfolio.models import Product, Trade
 from wbportfolio.models.transactions.claim import Claim, ClaimGroupbyChoice
@@ -607,10 +607,18 @@ class ConsolidatedTradeSummaryTableView(ClaimPermissionMixin, ExportPandasAPIVie
     def get_filterset_class(self, request):
         profile = request.user.profile
         if profile.is_internal or request.user.is_superuser:
-            return ClaimGroupByFilter
+            return ConsolidatedTradeSummaryTableFilterSet
         return CustomerClaimGroupByFilter
 
 
+def _sanitize_df(df: pd.DataFrame, normalization_factor: pd.Series | None = None) -> pd.DataFrame:
+    df = df.replace({0: np.nan})
+    scalar_columns = df.columns.difference(["title", "id"])
+    if normalization_factor is not None:
+        df[scalar_columns] = df[scalar_columns].div(normalization_factor.replace({0: np.nan}), axis=0)
+    return df.dropna(axis=0, how="all", subset=scalar_columns)
+
+
 class ConsolidatedTradeSummaryDistributionChart(ConsolidatedTradeSummaryTableView):
     WIDGET_TYPE = WidgetType.CHART.value
     IDENTIFIER = "wbportfolio:consolidatedtradesummarydistributionchart"
@@ -618,7 +626,13 @@ class ConsolidatedTradeSummaryDistributionChart(ConsolidatedTradeSummaryTableVie
     title_config_class = ConsolidatedTradeSummaryDistributionChartTitleConfig
     endpoint_config_class = ConsolidatedTradeSummaryDistributionChartEndpointConfig
     button_config_class = None
-    filterset_class = ClaimGroupByFilter
+
+    def get_filterset_class(self, request):
+        return DistributionNNMChartFilter
+
+    @cached_property
+    def is_percent(self) -> bool:
+        return self.request.GET.get("percent", "false") == "true"
 
     # TODO This is not really optimal. We need to change it at some point
     def list(self, request, *args, **kwargs):
@@ -642,36 +656,46 @@ class ConsolidatedTradeSummaryDistributionChart(ConsolidatedTradeSummaryTableVie
     def get_plotly(self, df):
         fig = go.Figure()
         # create the groupby NNM distribution histogram
-        df = df.sort_values(by="title")
-        for nnm_monthly_colum in self.nnm_monthly_columns:
-            if len(self.nnm_monthly_columns) == 1 and hasattr(self, "df_nnm_neg") and hasattr(self, "df_nnm_pos"):
-                if nnm_monthly_colum[0] in self.df_nnm_neg.columns:
+        df = df.sort_values(by="title").set_index("id")
+        normalization_factor = None
+        if self.is_percent:
+            normalization_factor = df["sum_aum_start"]
+        nnm_monthly_columns = dict(self.nnm_monthly_columns)
+        df = _sanitize_df(
+            df.drop(columns=df.columns.difference(["title", *nnm_monthly_columns.keys(), "sum_nnm_total"])),
+            normalization_factor=normalization_factor,
+        )
+        for key, label in nnm_monthly_columns.items():
+            if len(nnm_monthly_columns.keys()) == 1 and hasattr(self, "df_nnm_neg") and hasattr(self, "df_nnm_pos"):
+                df_nnm_pos = _sanitize_df(self.df_nnm_pos.set_index("id"), normalization_factor)
+                df_nnm_neg = _sanitize_df(self.df_nnm_neg.set_index("id"), normalization_factor)
+                if key in df_nnm_neg.columns:
                     fig.add_trace(
                         go.Histogram(
                             histfunc="sum",
-                            y=self.df_nnm_neg[nnm_monthly_colum[0]],
-                            x=self.df_nnm_neg["title"],
-                            name=nnm_monthly_colum[1] + " (Negative)",
+                            y=df_nnm_neg[key],
+                            x=df_nnm_neg["title"],
+                            name=label + " (Negative)",
                             marker_color="#FF6961",
                         )
                     )
-                if nnm_monthly_colum[0] in self.df_nnm_pos.columns:
+                if key in df_nnm_pos.columns:
                     fig.add_trace(
                         go.Histogram(
                             histfunc="sum",
-                            y=self.df_nnm_pos[nnm_monthly_colum[0]],
-                            x=self.df_nnm_pos["title"],
-                            name=nnm_monthly_colum[1] + " (Positive)",
+                            y=df_nnm_pos[key],
+                            x=df_nnm_pos["title"],
+                            name=label + " (Positive)",
                             marker_color="#77DD77",
                         )
                     )
-            if nnm_monthly_colum[0] in df.columns:
-                figure_kwargs = {"name": nnm_monthly_colum[1]}
-                if len(self.nnm_monthly_columns) == 1:
+            if key in df.columns:
+                figure_kwargs = {"name": label}
+                if len(nnm_monthly_columns.keys()) == 1:
                     figure_kwargs["marker_color"] = "#D3D3D3"
-                    figure_kwargs["name"] = nnm_monthly_colum[1] + " (Total)"
-                fig.add_trace(go.Histogram(histfunc="sum", y=df[nnm_monthly_colum[0]], x=df["title"], **figure_kwargs))
-        if len(self.nnm_monthly_columns) > 1:
+                    figure_kwargs["name"] = label + " (Total)"
+                fig.add_trace(go.Histogram(histfunc="sum", y=df[key], x=df["title"], **figure_kwargs))
+        if len(nnm_monthly_columns.keys()) > 1:
             fig.add_trace(
                 go.Histogram(
                     histfunc="sum",
@@ -692,6 +716,8 @@ class ConsolidatedTradeSummaryDistributionChart(ConsolidatedTradeSummaryTableVie
                 "x": 0.5,
             },
         )
+        if self.is_percent:
+            fig.update_yaxes(tickformat=".2%")
         return fig