wbportfolio 1.49.5__py2.py3-none-any.whl → 1.49.7__py2.py3-none-any.whl

wbportfolio/filters/__init__.py

@@ -9,6 +9,7 @@ from .assets import (  # ProductAllocationEquityFilter, AssetPositionAPIFilter,
     CashPositionPortfolioFilterSet,
     CompositionModelPortfolioPandasFilter,
     ContributionChartFilter,
+    CompositionContributionChartFilter,
     DistributionFilter,
 )
 from .custodians import CustodianFilterSet

wbportfolio/filters/assets.py

@@ -462,6 +462,10 @@ class ContributionChartFilter(wb_filters.FilterSet):
         fields = {}
 
 
+class CompositionContributionChartFilter(ContributionChartFilter):
+    show_lookthrough = wb_filters.BooleanFilter(label="Show Lookthrough", default=False, method="fake_filter")
+
+
 class AssetPositionUnderlyingInstrumentChartFilter(DateFilterMixin, wb_filters.FilterSet):
     portfolio = wb_filters.ModelMultipleChoiceFilter(
         label="Portfolios",

wbportfolio/filters/positions.py

@@ -3,15 +3,17 @@ import datetime as dt
 from django.db.models import TextChoices
 from pandas.tseries.offsets import BDay
 from wbcore import filters as wb_filters
-from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.geography.models import Geography
 from wbcore.pandas.filterset import PandasFilterSetMixin
 from wbcore.utils.date import current_financial_month
+from wbfdm.models import Classification, Instrument
 
 from wbportfolio.filters.assets import (
     DateFilterMixin,
     get_latest_end_quarter_date_asset_position,
 )
-from wbportfolio.models import AssetPosition
+from wbportfolio.models import AssetPosition, Portfolio
 
 
 class GroupbyChoice(TextChoices):
@@ -33,16 +35,21 @@ class GroupbyChoice(TextChoices):
             "PREFERRED_CLASSIFICATION": "classification_id",
         }[name]
 
-    @classmethod
-    def get_repr(cls, name: str) -> str:
-        return {
-            "UNDERLYING_INSTRUMENT": "underlying_instrument__name_repr",
-            "CURRENCY": "underlying_instrument__currency__key",
-            "COUNTRY": "underlying_instrument__country__name",
-            "PORTFOLIO": "portfolio__name",
-            "PRIMARY_CLASSIFICATION": "classification_title",
-            "PREFERRED_CLASSIFICATION": "classification_title",
-        }[name]
+    def get_repr(self, ids: list[int]) -> dict[int, str]:
+        match self:
+            case GroupbyChoice.UNDERLYING_INSTRUMENT:
+                return dict(Instrument.objects.filter(id__in=ids).values_list("id", "name_repr"))
+            case GroupbyChoice.CURRENCY:
+                return dict(Currency.objects.filter(id__in=ids).values_list("id", "key"))
+            case GroupbyChoice.COUNTRY:
+                return dict(Geography.countries.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PORTFOLIO:
+                return dict(Portfolio.objects.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PRIMARY_CLASSIFICATION:
+                return dict(Classification.objects.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PREFERRED_CLASSIFICATION:
+                return dict(Classification.objects.filter(id__in=ids).values_list("id", "name"))
+        raise ValueError("invalid self value")
 
 
 def get_latest_date_based_on_multiple_models(field, request, view):

wbportfolio/models/asset.py

@@ -24,7 +24,7 @@ from django.db.models.functions import Coalesce
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
-from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
 from wbcore.signals import pre_merge
 from wbcore.utils.enum import ChoiceEnum
@@ -77,6 +77,24 @@ class AssetPositionDefaultQueryset(QuerySet):
             classification_title=Subquery(base_qs.values(ref_title)[:1]),
         )
 
+    def annotate_hedged_currency_fx_rate(self, hedged_currency: Currency | None) -> QuerySet:
+        return self.annotate(
+            _is_hedged=Case(
+                When(
+                    underlying_instrument__currency__isnull=False,
+                    underlying_instrument__currency=hedged_currency,
+                    then=Value(True),
+                ),
+                default=Value(False),
+                output_field=models.BooleanField(),
+            ),
+            hedged_currency_fx_rate=Case(
+                When(_is_hedged=True, then=Value(Decimal(1.0))),
+                default=F("currency_fx_rate"),
+                output_field=models.BooleanField(),
+            ),
+        )
+
 
 class DefaultAssetPositionManager(models.Manager):
     def annotate_classification_for_group(
@@ -93,7 +111,10 @@ class DefaultAssetPositionManager(models.Manager):
             classification_group, classification_height=classification_height
         )
 
-    def get_queryset(self) -> QuerySet["AssetPosition"]:
+    def annotate_hedged_currency_fx_rate(self, hedged_currency: Currency | None) -> QuerySet:
+        return self.get_queryset().annotate_hedged_currency_fx_rate(hedged_currency)
+
+    def get_queryset(self) -> AssetPositionDefaultQueryset:
         return AssetPositionDefaultQueryset(self.model).annotate(
             adjusting_factor=Coalesce(
                 F("applied_adjustment__cumulative_factor") * F("applied_adjustment__factor"), Decimal(1.0)
@@ -511,7 +532,6 @@ class AssetPosition(ImportMixin, models.Model):
                 self.initial_shares = new_weighting * self.get_portfolio_total_asset_value()
             else:
                 self.initial_shares = (new_weighting / self.weighting) * self.initial_shares
-        self.save()
 
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)

wbportfolio/models/portfolio.py

@@ -13,16 +13,12 @@ from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.fields import DateRangeField
 from django.db import models
 from django.db.models import (
-    BooleanField,
-    Case,
     Exists,
     F,
     OuterRef,
     Q,
     QuerySet,
     Sum,
-    Value,
-    When,
 )
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -629,11 +625,28 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         return df
 
-    def get_portfolio_contribution_df(self, start, end, with_cash=True, hedged_currency=None, only_equity=False):
+    def get_portfolio_contribution_df(
+        self,
+        start: date,
+        end: date,
+        with_cash: bool = True,
+        hedged_currency: Currency | None = None,
+        only_equity: bool = False,
+    ) -> pd.DataFrame:
         qs = self._get_assets(with_cash=with_cash).filter(date__gte=start, date__lte=end)
         if only_equity:
             qs = qs.filter(underlying_instrument__instrument_type=InstrumentType.EQUITY)
-        return Portfolio.get_contribution_df(qs, hedged_currency=hedged_currency)
+        qs = qs.annotate_hedged_currency_fx_rate(hedged_currency)
+        df = Portfolio.get_contribution_df(
+            qs.select_related("underlying_instrument").values_list(
+                "date", "price", "hedged_currency_fx_rate", "underlying_instrument", "weighting"
+            )
+        )
+        df = df.rename(columns={"group_key": "underlying_instrument"})
+        df["underlying_instrument__name_repr"] = df["underlying_instrument"].map(
+            dict(Instrument.objects.filter(id__in=df["underlying_instrument"]).values_list("id", "name_repr"))
+        )
+        return df
 
     def check_related_portfolio_at_date(self, val_date: date, related_portfolio: "Portfolio"):
         assets = AssetPosition.objects.filter(
@@ -730,6 +743,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         ):
             rel.portfolio.evaluate_rebalancing(val_date)
         for dependent_portfolio in self.get_child_portfolios(val_date):
+            dependent_portfolio.change_at_date(val_date)
             dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
 
     def evaluate_rebalancing(self, val_date: date):
@@ -1088,104 +1102,68 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return returns.replace([np.inf, -np.inf, np.nan], 0), prices_df.replace([np.inf, -np.inf, np.nan], None)
 
     @classmethod
-    def get_contribution_df(
-        cls,
-        qs,
-        need_normalize=False,
-        groupby_label_id="underlying_instrument",
-        groubpy_label_title="underlying_instrument__name_repr",
-        currency_fx_rate_label="currency_fx_rate",
-        hedged_currency=None,
-    ):
-        # qs = AssetPosition.annotate_underlying_instrument(qs)
-        weight_label = "weighting" if not need_normalize else "total_value_fx_portfolio"
-        qs = qs.annotate(
-            is_hedged=Case(
-                When(
-                    underlying_instrument__currency__isnull=False,
-                    underlying_instrument__currency=hedged_currency,
-                    then=Value(True),
-                ),
-                default=Value(False),
-                output_field=BooleanField(),
-            ),
-            coalesce_currency_fx_rate=Case(
-                When(is_hedged=True, then=Value(Decimal(1.0))),
-                default=F(currency_fx_rate_label),
-                output_field=models.BooleanField(),
-            ),
-        ).select_related("underlying_instrument")
+    def get_contribution_df(cls, data, need_normalize: bool = False):
         df = pd.DataFrame(
-            qs.values_list(
-                "date",
-                "price",
-                "coalesce_currency_fx_rate",
-                groupby_label_id,
-                groubpy_label_title,
-                weight_label,
-            ),
+            data,
             columns=[
                 "date",
                 "price",
-                "coalesce_currency_fx_rate",
-                groupby_label_id,
-                groubpy_label_title,
-                weight_label,
+                "currency_fx_rate",
+                "group_key",
+                "value",
             ],
         )
         if not df.empty:
-            df = df[df[weight_label] != 0]
+            df = df[df["value"] != 0]
             df.date = pd.to_datetime(df.date)
-            df["price_fx_portfolio"] = df.price * df.coalesce_currency_fx_rate
+            df["price_fx_portfolio"] = df.price * df.currency_fx_rate
 
-            df[["price", "price_fx_portfolio", weight_label, "coalesce_currency_fx_rate"]] = df[
-                ["price", "price_fx_portfolio", weight_label, "coalesce_currency_fx_rate"]
+            df[["price", "price_fx_portfolio", "value", "currency_fx_rate"]] = df[
+                ["price", "price_fx_portfolio", "value", "currency_fx_rate"]
             ].astype("float")
 
-            df[groupby_label_id] = df[groupby_label_id].fillna(0)
-            df[groubpy_label_title] = df[groubpy_label_title].fillna("N/A")
-            df_static = df[[groupby_label_id, groubpy_label_title]].groupby(groupby_label_id, dropna=False).first()
+            df["group_key"] = df["group_key"].fillna(0)
 
             df = (
                 df[
                     [
-                        groupby_label_id,
+                        "group_key",
                         "date",
                         "price",
                         "price_fx_portfolio",
-                        weight_label,
-                        "coalesce_currency_fx_rate",
+                        "value",
+                        "currency_fx_rate",
                     ]
                 ]
-                .groupby(["date", groupby_label_id], dropna=False)
+                .groupby(["date", "group_key"], dropna=False)
                 .agg(
                     {
                         "price": "mean",
                         "price_fx_portfolio": "mean",
-                        weight_label: "sum",
-                        "coalesce_currency_fx_rate": "mean",
+                        "value": "sum",
+                        "currency_fx_rate": "mean",
                     }
                 )
                 .reset_index()
                 .set_index("date")
                 .sort_index()
             )
-            df[weight_label] = df[weight_label].fillna(0)
+            df["value"] = df["value"].fillna(0)
             value = df.pivot_table(
                 index="date",
-                columns=[groupby_label_id],
-                values=weight_label,
+                columns=["group_key"],
+                values="value",
                 fill_value=0,
                 aggfunc="sum",
             )
             weights_ = value
             if need_normalize:
-                total_value_price = df[weight_label].groupby("date", dropna=False).sum()
+                total_value_price = df["value"].groupby("date", dropna=False).sum()
                 weights_ = value.divide(total_value_price, axis=0)
             prices_usd = (
                 df.pivot_table(
                     index="date",
-                    columns=[groupby_label_id],
+                    columns=["group_key"],
                     values="price_fx_portfolio",
                     aggfunc="mean",
                 )
@@ -1196,8 +1174,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             rates_fx = (
                 df.pivot_table(
                     index="date",
-                    columns=[groupby_label_id],
-                    values="coalesce_currency_fx_rate",
+                    columns=["group_key"],
+                    values="currency_fx_rate",
                     aggfunc="mean",
                 )
                 .replace(0, np.nan)
@@ -1220,7 +1198,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
             res = pd.concat(
                 [
-                    df_static,
                     monthly_perf_prices,
                     monthly_perf_rates_fx,
                     contributions_prices,
@@ -1233,8 +1210,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 axis=1,
             ).reset_index()
             res.columns = [
-                groupby_label_id,
-                groubpy_label_title,
+                "group_key",
                 "performance_total",
                 "performance_forex",
                 "contribution_total",

wbportfolio/models/transactions/rebalancing.py

@@ -95,12 +95,15 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         while TradeProposal.objects.filter(
             portfolio=self.portfolio, status=TradeProposal.Status.FAILED, trade_date=pivot_date
         ).exists():
-            pivot_date += BDay(1)
+            pivot_date = (pivot_date + BDay(1)).date()
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
         if TradeProposal.objects.filter(
-            portfolio=self.portfolio, status=TradeProposal.Status.APPROVED, trade_date=trade_date
+            portfolio=self.portfolio,
+            status=TradeProposal.Status.APPROVED,
+            trade_date=trade_date,
+            rebalancing_model__isnull=True,
         ).exists():  # if a already approved trade proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
             return False
         for initial_valid_datetime in self.get_rrule(trade_date):
@@ -121,12 +124,13 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 "rebalancing_model": self.rebalancing_model,
             },
         )
-        logger.info(
-            f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
-        )
+
         if trade_proposal.rebalancing_model == self.rebalancing_model:
             trade_proposal.status = TradeProposal.Status.DRAFT
             try:
+                logger.info(
+                    f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
+                )
                 target_portfolio = self.rebalancing_model.get_target_portfolio(
                     self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
                 )

wbportfolio/models/transactions/trade_proposals.py

@@ -18,6 +18,7 @@ from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
 from wbcore.utils.models import CloneMixin
+from wbfdm.models import InstrumentPrice
 from wbfdm.models.instruments.instruments import Cash, Instrument
 
 from wbportfolio.models.roles import PortfolioRole
@@ -80,8 +81,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if not self.trade_date and self.portfolio.assets.exists():
             self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
         super().save(*args, **kwargs)
-        if self.status == TradeProposal.Status.APPROVED:
-            self.portfolio.change_at_date(self.trade_date)
 
     @property
     def checked_object(self):
@@ -256,6 +255,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 # we cannot do a bulk-create because Trade is a multi table inheritance
                 try:
                     trade = self.trades.get(underlying_instrument=instrument)
+                    trade.weighting = trade_dto.delta_weight
+                    trade.currency_fx_rate = currency_fx_rate
+                    trade.status = Trade.Status.DRAFT
                 except Trade.DoesNotExist:
                     trade = Trade(
                         underlying_instrument=instrument,
@@ -272,35 +274,43 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     def replay(self):
         last_trade_proposal = self
+        last_trade_proposal_created = False
         while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
-            logger.info(f"Replaying trade proposal {last_trade_proposal}")
-            last_trade_proposal.portfolio.assets.filter(
-                date=last_trade_proposal.trade_date
-            ).delete()  # we delete the existing position and we reapply the trade proposal
-            if last_trade_proposal.status == TradeProposal.Status.APPROVED:
-                logger.info("Reverting trade proposal ...")
-                last_trade_proposal.revert()
-            if last_trade_proposal.status == TradeProposal.Status.DRAFT:
-                if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
-                    logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
-                    with suppress(
-                        ValidationError
-                    ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
-                        self.reset_trades()
-                logger.info("Submitting trade proposal ...")
-                last_trade_proposal.submit()
-            if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
-                logger.info("Approving trade proposal ...")
-                last_trade_proposal.approve(replay=False)
-            last_trade_proposal.save()
+            if not last_trade_proposal_created:
+                logger.info(f"Replaying trade proposal {last_trade_proposal}")
+                last_trade_proposal.portfolio.assets.filter(
+                    date=last_trade_proposal.trade_date
+                ).delete()  # we delete the existing position and we reapply the trade proposal
+                if last_trade_proposal.status == TradeProposal.Status.APPROVED:
+                    logger.info("Reverting trade proposal ...")
+                    last_trade_proposal.revert()
+                if last_trade_proposal.status == TradeProposal.Status.DRAFT:
+                    if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
+                        logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
+                        with suppress(
+                            ValidationError
+                        ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
+                            self.reset_trades()
+                    logger.info("Submitting trade proposal ...")
+                    last_trade_proposal.submit()
+                if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
+                    logger.info("Approving trade proposal ...")
+                    last_trade_proposal.approve(replay=False)
+                last_trade_proposal.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
+
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()
             )
             overriding_trade_proposal = last_trade_proposal.portfolio.batch_portfolio(
                 last_trade_proposal.trade_date, next_trade_date
             )
-            last_trade_proposal = overriding_trade_proposal or next_trade_proposal
+            if overriding_trade_proposal:
+                last_trade_proposal_created = True
+                last_trade_proposal = overriding_trade_proposal
+            else:
+                last_trade_proposal_created = False
+                last_trade_proposal = next_trade_proposal
 
     def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal:
         """
@@ -333,7 +343,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         except Exception:
             raise ValueError("We couldn't estimate the number of shares")
 
-    def get_estimated_target_cash(self, currency: Currency) -> tuple[Decimal, Decimal]:
+    def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
         Estimates the target cash weight and shares for a trade proposal.
 
@@ -374,7 +384,29 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             with suppress(ValueError):
                 total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
 
-        return target_cash_weight, total_target_shares
+        cash_component = Cash.objects.get_or_create(
+            currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
+        )[0]
+        # otherwise, we create a new position
+        underlying_quote_price = InstrumentPrice.objects.get_or_create(
+            instrument=cash_component,
+            date=self.trade_date,
+            calculated=False,
+            defaults={"net_value": Decimal(1)},
+        )[0]
+        return AssetPosition(
+            underlying_quote=cash_component,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.trade_date,
+            weighting=target_cash_weight,
+            initial_price=underlying_quote_price.net_value,
+            initial_shares=total_target_shares,
+            asset_valuation_date=self.trade_date,
+            underlying_quote_price=underlying_quote_price,
+            currency=cash_component.currency,
+            is_estimated=False,
+        )
 
     # Start FSM logics
 
@@ -398,30 +430,30 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.trades.update(comment="", status=Trade.Status.DRAFT)
         self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
+        trades = []
         for trade in self.trades.all():
-            trade.submit()
-            trade.save()
+            trade.status = Trade.Status.SUBMIT
+            trade.comment = ""
+            trades.append(trade)
+
+        Trade.objects.bulk_update(trades, ["status", "comment"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
-        cash_target_cash_weight, cash_target_cash_shares = self.get_estimated_target_cash(self.portfolio.currency)
-        if cash_target_cash_weight:
-            cash_component = Cash.objects.get_or_create(
-                currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
-            )[0]
-            self.trades.update_or_create(
-                underlying_instrument=cash_component,
-                defaults={
-                    "status": Trade.Status.SUBMIT,
-                    "weighting": cash_target_cash_weight,
-                    "shares": cash_target_cash_shares,
-                },
-            )
+        estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
+        target_portfolio = self.validated_trading_service.target_portfolio
+        if estimated_cash_position.weighting:
+            if existing_cash_position := target_portfolio.positions_map.get(
+                estimated_cash_position.underlying_quote.id
+            ):
+                existing_cash_position += estimated_cash_position
+            else:
+                target_portfolio.positions_map[estimated_cash_position.underlying_quote.id] = (
+                    estimated_cash_position._build_dto()
+                )
+            target_portfolio = PortfolioDTO(positions=tuple(target_portfolio.positions_map.values()))
 
-        self.evaluate_active_rules(
-            self.trade_date, self.validated_trading_service.target_portfolio, asynchronously=True
-        )
+        self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
 
     def can_submit(self):
         errors = dict()
@@ -475,11 +507,27 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # We validate trade which will create or update the initial asset positions
         if not self.portfolio.can_be_rebalanced:
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
-        self.trades.update(status=Trade.Status.SUBMIT)
-        self.portfolio.assets.filter(date=self.trade_date).delete()  # we delete position to avoid having leftovers
+        trades = []
+        assets = []
+        # We do not want to create the estimated cash position if there is not trades in the trade proposal (shouldn't be possible anyway)
+        estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
+
         for trade in self.trades.all():
-            trade.execute()
-            trade.save()
+            with suppress(ValueError):
+                asset = trade.to_asset()
+                # we add the corresponding asset only if it is not the cache position (already included in estimated_cash_position)
+                if asset.underlying_quote != estimated_cash_position.underlying_quote:
+                    assets.append(asset)
+            trade.status = Trade.Status.EXECUTED
+            trades.append(trade)
+
+        # if there is cash leftover, we create an extra asset position to hold the cash component
+        if estimated_cash_position.weighting and len(trades) > 0:
+            estimated_cash_position.pre_save()
+            assets.append(estimated_cash_position)
+
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id)
 
@@ -584,10 +632,22 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def revert(self, **kwargs):
         with suppress(KeyError):
             del self.__dict__["validated_trading_service"]
-        for trade in self.trades.filter(status=Trade.Status.EXECUTED):
-            trade.revert()
-            trade.save()
-        # replay_as_task.delay(self.id)
+        trades = []
+        assets = []
+        for trade in self.trades.all():
+            trade.status = Trade.Status.DRAFT
+            trades.append(trade)
+            with suppress(AssetPosition.DoesNotExist):
+                asset = AssetPosition.unannotated_objects.get(
+                    underlying_quote=trade.underlying_instrument,
+                    portfolio=trade.portfolio,
+                    date=trade.transaction_date,
+                    is_estimated=False,
+                )
+                asset.set_weighting(asset.weighting - trade.weighting)
+                assets.append(asset)
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
 
     def can_revert(self):
         errors = dict()

wbportfolio/models/transactions/trades.py

@@ -299,25 +299,47 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             )
         },
     )
+    def to_asset(self) -> AssetPosition:
+        last_underlying_quote_price = self.last_underlying_quote_price
+        if not last_underlying_quote_price:
+            raise ValueError("No price found")
+        asset = AssetPosition(
+            underlying_quote=self.underlying_instrument,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.transaction_date,
+            initial_currency_fx_rate=self.currency_fx_rate,
+            weighting=self._target_weight,
+            initial_price=self.last_underlying_quote_price.net_value,
+            initial_shares=None,
+            underlying_quote_price=self.last_underlying_quote_price,
+            asset_valuation_date=self.transaction_date,
+            currency=self.currency,
+            is_estimated=False,
+        )
+        asset.set_weighting(self._target_weight)
+        asset.pre_save()
+        return asset
+
     def execute(self, **kwargs):
-        if self.last_underlying_quote_price:
-            asset, created = AssetPosition.unannotated_objects.update_or_create(
-                underlying_quote=self.underlying_instrument,
-                portfolio_created=None,
-                portfolio=self.portfolio,
-                date=self.transaction_date,
+        with suppress(ValueError):
+            asset = self.to_asset()
+            AssetPosition.unannotated_objects.update_or_create(
+                underlying_quote=asset.underlying_quote,
+                portfolio_created=asset.portfolio_created,
+                portfolio=asset.portfolio,
+                date=asset.date,
                 defaults={
-                    "initial_currency_fx_rate": self.currency_fx_rate,
-                    "weighting": self._target_weight,
-                    "initial_price": self.last_underlying_quote_price.net_value,
-                    "initial_shares": None,
-                    "underlying_quote_price": self.last_underlying_quote_price,
-                    "asset_valuation_date": self.transaction_date,
-                    "currency": self.currency,
-                    "is_estimated": False,
+                    "initial_currency_fx_rate": asset.initial_currency_fx_rate,
+                    "initial_price": asset.initial_price,
+                    "initial_shares": asset.initial_shares,
+                    "underlying_quote_price": asset.underlying_quote_price,
+                    "asset_valuation_date": asset.asset_valuation_date,
+                    "currency": asset.currency,
+                    "is_estimated": asset.is_estimated,
+                    "weighting": asset.weighting,
                 },
             )
-            asset.set_weighting(self._target_weight)
 
     def can_execute(self):
         if not self.last_underlying_quote_price:
@@ -402,6 +424,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 is_estimated=False,
             )
             asset.set_weighting(asset.weighting - self.weighting)
+            asset.save()
 
     @property
     def product(self):

wbportfolio/rebalancing/models/composite.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 
 from django.core.exceptions import ObjectDoesNotExist
+from wbfdm.models import InstrumentPrice
 
 from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
@@ -20,7 +21,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
         """
         try:
             latest_trade_proposal = self.portfolio.trade_proposals.filter(
-                status="APPROVED", trade_date__lte=self.trade_date
+                status="APPROVED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]
@@ -33,7 +34,10 @@ class CompositeRebalancing(AbstractRebalancingModel):
             return dict()
 
     def is_valid(self) -> bool:
-        return len(self.base_assets.keys()) > 0
+        return (
+            len(self.base_assets.keys()) > 0
+            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=self.base_assets.keys()).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/rebalancing/models/equally_weighted.py

@@ -1,5 +1,7 @@
 from decimal import Decimal
 
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -7,8 +9,17 @@ from wbportfolio.rebalancing.decorators import register
 
 @register("Equally Weighted Rebalancing")
 class EquallyWeightedRebalancing(AbstractRebalancingModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.assets = self.portfolio.assets.filter(date=self.last_effective_date)
+
     def is_valid(self) -> bool:
-        return self.portfolio.assets.filter(date=self.last_effective_date).exists()
+        return (
+            self.assets.exists()
+            and InstrumentPrice.objects.filter(
+                date=self.trade_date, instrument__in=self.assets.values("underlying_quote")
+            ).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/rebalancing/models/model_portfolio.py

@@ -1,3 +1,5 @@
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -18,11 +20,15 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
             return model_portfolio_rel.dependency_portfolio
 
     def is_valid(self) -> bool:
-        return (
-            self.model_portfolio.assets.filter(date=self.last_effective_date).exists()
-            if self.model_portfolio
-            else False
-        )
+        if model_portfolio := self.model_portfolio:
+            assets = model_portfolio.get_positions(self.last_effective_date)
+            return (
+                assets.exists()
+                and InstrumentPrice.objects.filter(
+                    date=self.trade_date, instrument__in=assets.values("underlying_quote")
+                ).exists()
+            )
+        return False
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -11,11 +11,15 @@ from wbportfolio.models import AssetPosition, TradeProposal
 
 @pytest.mark.django_db
 class TestRebalancingModel:
-    def test_get_target_portfolio(self, rebalancing_model, portfolio, weekday, asset_position_factory):
+    def test_get_target_portfolio(
+        self, rebalancing_model, portfolio, weekday, asset_position_factory, instrument_price_factory
+    ):
+        trade_date = (weekday + BDay(1)).date()
         with pytest.raises(ValidationError):  # trigger value error because rebalancing not valid (no position yet)
-            rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
+            rebalancing_model.get_target_portfolio(portfolio, trade_date, weekday)
         a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=weekday)
         a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=weekday)
+        instrument_price_factory.create(instrument=a1.underlying_quote, date=trade_date)
         target_portfolio = rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
         target_positions = target_portfolio.positions_map
         assert target_positions[a1.underlying_instrument.id].weighting == 0.5

wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -5,7 +5,7 @@ from unittest.mock import call, patch
 
 import pytest
 from faker import Faker
-from pandas._libs.tslibs.offsets import BDay, MonthEnd
+from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
 from wbportfolio.models import Portfolio, RebalancingModel, TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
@@ -290,6 +290,25 @@ class TestTradeProposal:
         assert t2.weighting == Decimal("0.1")
         assert t3.weighting == Decimal("0.6")
 
+        # build the target portfolio
+        new_target_portfolio = PortfolioDTO(
+            positions=(
+                Position(underlying_instrument=i1.id, date=trade_proposal.trade_date, weighting=Decimal("0.2")),
+                Position(underlying_instrument=i2.id, date=trade_proposal.trade_date, weighting=Decimal("0.3")),
+                Position(underlying_instrument=i3.id, date=trade_proposal.trade_date, weighting=Decimal("0.5")),
+            )
+        )
+
+        trade_proposal.reset_trades(target_portfolio=new_target_portfolio)
+        # Refetch the trades for each instrument
+        t1.refresh_from_db()
+        t2.refresh_from_db()
+        t3.refresh_from_db()
+        # Assert existing trade weights are correctly updated
+        assert t1.weighting == Decimal("-0.5")
+        assert t2.weighting == Decimal("0")
+        assert t3.weighting == Decimal("0.5")
+
     # Test replaying trade proposals
     @patch.object(Portfolio, "batch_portfolio")
     def test_replay(self, mock_fct, trade_proposal_factory):
@@ -303,12 +322,12 @@ class TestTradeProposal:
         tp1 = trade_proposal_factory.create(
             portfolio=tp0.portfolio,
             status=TradeProposal.Status.APPROVED,
-            trade_date=(tp0.trade_date + MonthEnd(1)).date(),
+            trade_date=(tp0.trade_date + BusinessMonthEnd(1)).date(),
         )
         tp2 = trade_proposal_factory.create(
             portfolio=tp0.portfolio,
             status=TradeProposal.Status.APPROVED,
-            trade_date=(tp1.trade_date + MonthEnd(1)).date(),
+            trade_date=(tp1.trade_date + BusinessMonthEnd(1)).date(),
         )
 
         # Replay trade proposals
@@ -374,8 +393,6 @@ class TestTradeProposal:
             weighting=Decimal("0.2"),
         )
 
-        target_cash_weight, total_target_shares = trade_proposal.get_estimated_target_cash(
-            trade_proposal.portfolio.currency
-        )
-        assert target_cash_weight == Decimal("0.2") + Decimal("1.0") - (Decimal("0.7") + Decimal("0.2"))
-        assert total_target_shares == Decimal(1_000_000) * Decimal("0.3")
+        target_cash_position = trade_proposal.get_estimated_target_cash(trade_proposal.portfolio.currency)
+        assert target_cash_position.weighting == Decimal("0.2") + Decimal("1.0") - (Decimal("0.7") + Decimal("0.2"))
+        assert target_cash_position.initial_shares == Decimal(1_000_000) * Decimal("0.3")

wbportfolio/tests/rebalancing/test_models.py

@@ -16,9 +16,11 @@ class TestEquallyWeightedRebalancing:
 
         return EquallyWeightedRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
-        asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -38,7 +40,7 @@ class TestModelPortfolioRebalancing:
 
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
@@ -48,7 +50,9 @@ class TestModelPortfolioRebalancing:
             dependency_portfolio=model_portfolio,
             type=PortfolioPortfolioThroughModel.Type.MODEL,
         )
-        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -76,15 +80,15 @@ class TestCompositeRebalancing:
 
         return CompositeRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
 
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
-        TradeFactory.create(
+        t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.7,
@@ -92,23 +96,25 @@ class TestCompositeRebalancing:
         )
         TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.3,
             status=Trade.Status.EXECUTED,
         )
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=t1.underlying_instrument, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.8,
@@ -116,7 +122,7 @@ class TestCompositeRebalancing:
         )
         t2 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.2,

wbportfolio/viewsets/assets.py

@@ -14,6 +14,7 @@ from wbcore.filters import DjangoFilterBackend
 from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.serializers import decorator
+from wbcore.utils.date import get_date_interval_from_request
 from wbcore.utils.figures import (
     get_default_timeserie_figure,
     get_hovertemplate_timeserie,
@@ -28,6 +29,7 @@ from wbportfolio.filters import (
     AssetPositionPortfolioFilter,
     AssetPositionUnderlyingInstrumentChartFilter,
     CashPositionPortfolioFilterSet,
+    CompositionContributionChartFilter,
     CompositionModelPortfolioPandasFilter,
     ContributionChartFilter,
 )
@@ -354,19 +356,50 @@ class ContributorPortfolioChartView(UserPortfolioRequestPermissionMixin, viewset
     title_config_class = ContributorPortfolioChartTitleConfig
     endpoint_config_class = ContributorPortfolioChartEndpointConfig
 
+    @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.kwargs["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()
-        hedged_currency = (
-            Currency.objects.get(id=self.request.GET["hedged_currency"])
-            if "hedged_currency" in self.request.GET
-            else None
-        )
-        df = Portfolio.get_contribution_df(queryset, hedged_currency=hedged_currency)
+        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:
+            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.apply(lambda x: Instrument.objects.get(id=x).name_repr)
+
+            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]
 

wbportfolio/viewsets/configs/display/portfolios.py

@@ -205,13 +205,11 @@ class TopDownPortfolioCompositionPandasDisplayConfig(DisplayViewConfig):
             effective_column_label += f" ({self.view.last_effective_date:%Y-%m-%d})"
         return dp.ListDisplay(
             fields=[
-                dp.Field(key="instrument", label="Instrument"),
+                dp.Field(key="instrument", label="Instrument", pinned="left"),
                 dp.Field(key="rebalancing_weights", label=rebalancing_column_label),
                 dp.Field(key="effective_weights", label=effective_column_label),
             ],
             tree=True,
-            tree_group_pinned="left",
             tree_group_field="instrument",
-            tree_group_label="Instrument",
             tree_group_parent_pointer="parent_row_id",
         )

wbportfolio/viewsets/positions.py

@@ -120,7 +120,6 @@ class AssetPositionPandasView(
             groupby_classification_height = int(request.GET.get("groupby_classification_height", "0"))
 
             groupby_id = GroupbyChoice.get_id(groupby.name)
-            grouby_repr = GroupbyChoice.get_repr(groupby.name)
             if groupby == GroupbyChoice.PRIMARY_CLASSIFICATION:
                 queryset = queryset.annotate_classification_for_group(
                     primary_classification_group, classification_height=groupby_classification_height, unique=True
@@ -135,18 +134,15 @@ class AssetPositionPandasView(
                     primary_classification_group, classification_height=groupby_classification_height
                 )
             df = Portfolio.get_contribution_df(
-                queryset,
+                queryset.values_list("date", "price", "currency_fx_rate_usd", groupby_id, "weighting"),
                 need_normalize=True,
-                groupby_label_id=groupby_id,
-                groubpy_label_title=grouby_repr,
-                currency_fx_rate_label="currency_fx_rate_usd",
             )
             df = df.rename(
                 columns={
-                    groupby_id: "id",
-                    grouby_repr: "title",
+                    "group_key": "id",
                 }
             )
+            df["title"] = df["id"].map(groupby.get_repr(df["id"]))
             if groupby == GroupbyChoice.UNDERLYING_INSTRUMENT.value:
                 df_market_shares = pd.DataFrame(
                     queryset.values("market_share", "date", "underlying_instrument")
@@ -164,7 +160,10 @@ class AssetPositionPandasView(
         return df
 
     def manipulate_dataframe(self, df):
-        return df.where(pd.notnull(df), 0)
+        if "titl" in df.columns:
+            df["title"] = df["title"].fillna("N/A").astype(str)
+        # df[df["title"].isnull()] = "N/A"
+        return df.fillna(0)
 
 
 class AggregatedAssetPositionLiquidityPandasView(InternalUserPermissionMixin, ExportPandasAPIViewSet):

wbportfolio/viewsets/transactions/trades.py

@@ -407,9 +407,13 @@ class TradeTradeProposalModelViewSet(
     def get_aggregates(self, queryset, *args, **kwargs):
         agg = {}
         if queryset.exists():
-            cash_target_cash_weight, cash_target_cash_shares = self.trade_proposal.get_estimated_target_cash(
+            cash_target_position = self.trade_proposal.get_estimated_target_cash(
                 self.trade_proposal.portfolio.currency
             )
+            cash_target_cash_weight, cash_target_cash_shares = (
+                cash_target_position.weighting,
+                cash_target_position.initial_shares,
+            )
             extra_existing_cash_components = Cash.objects.filter(
                 id__in=self.trade_proposal.trades.filter(underlying_instrument__is_cash=True).values(
                     "underlying_instrument"
@@ -417,11 +421,9 @@ class TradeTradeProposalModelViewSet(
             ).exclude(currency=self.trade_proposal.portfolio.currency)
 
             for cash_component in extra_existing_cash_components:
-                extra_cash_target_cash_weight, extra_cash_target_cash_shares = (
-                    self.trade_proposal.get_estimated_target_cash(cash_component.currency)
-                )
-                cash_target_cash_weight += extra_cash_target_cash_weight
-                cash_target_cash_shares += extra_cash_target_cash_shares
+                extra_cash_position = self.trade_proposal.get_estimated_target_cash(cash_component.currency)
+                cash_target_cash_weight += extra_cash_position.weighting
+                cash_target_cash_shares += extra_cash_position.initial_shares
             noncash_aggregates = queryset.filter(underlying_instrument__is_cash=False).aggregate(
                 sum_target_weight=Sum(F("target_weight")),
                 sum_effective_weight=Sum(F("effective_weight")),
@@ -487,7 +489,7 @@ class TradeTradeProposalModelViewSet(
         return TradeTradeProposalModelSerializer
 
     def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
-        if queryset is not None and queryset.exists():
+        if queryset is not None and queryset.exists() and self.trade_proposal.status != TradeProposal.Status.APPROVED:
             total_target_weight = queryset.aggregate(c=Sum(F("target_weight")))["c"] or Decimal(0)
             if round(total_target_weight, 3) != 1:
                 warning(

{wbportfolio-1.49.5.dist-info → wbportfolio-1.49.7.dist-info}/METADATA

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

{wbportfolio-1.49.5.dist-info → wbportfolio-1.49.7.dist-info}/RECORD

@@ -74,14 +74,14 @@ wbportfolio/factories/trades.py,sha256=-14d_ABN9FEoXb4wm9-YjYHfP2cCEANNM45cMRZtQ
 wbportfolio/factories/transactions.py,sha256=jZqTNRpW344DSYjV5tAqU5y30Kc7GRGbZ3BN9hacKpQ,995
 wbportfolio/fdm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/fdm/tasks.py,sha256=59hXt3TOJaM8KpUaKdBNAGsO7NFMHaAlNA0T3FTUau0,533
-wbportfolio/filters/__init__.py,sha256=ygkjTc5ZZOkzqwKi4fJ6K_ryx2IclgAKY5MeVGfEY_0,1334
-wbportfolio/filters/assets.py,sha256=NlZO9o7UzQPGEt3nbpRKwSiEt0GSeV77OMcx2igwdfU,17934
+wbportfolio/filters/__init__.py,sha256=m44CdyYMtku8rMGyiX8KSmMdvyqaElKW4UMkEqOC1VM,1374
+wbportfolio/filters/assets.py,sha256=gpCwxlje1mY9IGlxfvQyNgyE5RcT-r3B2tI14hB92X4,18114
 wbportfolio/filters/assets_and_net_new_money_progression.py,sha256=dgI3WWlfYjaDg15-C4Sh2HQoY0kQh9mQUWxn4SAPLnM,1403
 wbportfolio/filters/custodians.py,sha256=pStQgPQPhPpnt57_V7BuXbFXmRiZBEAiEeMFuQmt2NE,287
 wbportfolio/filters/esg.py,sha256=sQ5HwiUlhfKeFqJ2O5koXyTscpN21UKRUSi8d90jSlI,688
 wbportfolio/filters/performances.py,sha256=fAMb8HkWSmBl1xg5P4MZ8WJsV5x7uCcBf7ETHdfXjkI,7325
 wbportfolio/filters/portfolios.py,sha256=IqkDj3POQ1MHGZO9k7TNuhf5fZ_yR9vPPcMFELkQsnQ,1469
-wbportfolio/filters/positions.py,sha256=ENUEtrlGIJSUEe8bhgebXp0ZHskPDM2Nh5qT72_sbTc,7900
+wbportfolio/filters/positions.py,sha256=ERdcTCNw7peGstKSl3W5t1wlSUM8a3anoesoycohF98,8548
 wbportfolio/filters/products.py,sha256=_QFL3I132q-3JUDji_Wh2Qkv45DKnQrR3N8_luGK0K0,6492
 wbportfolio/filters/roles.py,sha256=-0tOl-WJDqwXAfcJePpkjQfZB9o13I99euem5XGpMjk,920
 wbportfolio/filters/signals.py,sha256=3GrsxPwZg-6bvvZ222VfF212yNTJYQP4n5hWIEnTtpA,3144
@@ -245,11 +245,11 @@ wbportfolio/migrations/0076_alter_dividendtransaction_price_and_more.py,sha256=4
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=IIS_PNRxyX2Dcvyk1bcQOUzFt0B9SPC0WlM88CXqj04,881
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=yf4vBPfN1eZlWXG9SowQwr5-goG8rO1yYDitHDLZCBs,37758
+wbportfolio/models/asset.py,sha256=H4UvrEstrCCbRG_poF68Ih4JFgHE08guMkyhNCZ7QFQ,38636
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/exceptions.py,sha256=3ix0tWUO-O6jpz8f07XIwycw2x3JFRoWzjwil8FVA2Q,52
 wbportfolio/models/indexes.py,sha256=iLYF2gzNzX4GLj_Nh3fybUcAQ1TslnT0wgQ6mN164QI,728
-wbportfolio/models/portfolio.py,sha256=NxJVUtIUxmm_iHnO9UU0_HWmGOwExTz5NZRzHdehhj0,59718
+wbportfolio/models/portfolio.py,sha256=dUj1iPZke17qYk2zSSL-6Mcjr7cKAoq_wIrZtEmTmLg,58666
 wbportfolio/models/portfolio_cash_flow.py,sha256=2blPiXSw7dbhUVd-7LcxDBb4v0SheNOdvRK3MFYiChA,7273
 wbportfolio/models/portfolio_cash_targets.py,sha256=WmgG-etPisZsh2yaFQpz7EkpvAudKBEzqPsO715w52U,1498
 wbportfolio/models/portfolio_relationship.py,sha256=mMb18UMRWg9kx_9uIPkMktwORuXXLjKdgRPQQvB6fVE,5486
@@ -275,9 +275,9 @@ wbportfolio/models/transactions/claim.py,sha256=hcx_tJ9luf2-s1qqsUZXtoDEuxFyty2A
 wbportfolio/models/transactions/dividends.py,sha256=92-jG8bZN9nU9oDubpu-UDH43Ri7kVjhqE_esOSmOzo,471
 wbportfolio/models/transactions/expiry.py,sha256=vnNHdcC1hf2HP4rAbmoGgOfagBYKNFytqOwzOI0MlVI,144
 wbportfolio/models/transactions/fees.py,sha256=ffvqo8I4A0l5rLi00jJ6sGot0jmnkoxaNsbDzdPLwCg,5712
-wbportfolio/models/transactions/rebalancing.py,sha256=nrBi6x6PssCtkLtOpV-2OoAHDUKnnYyrM6xH1PmnjSo,7240
-wbportfolio/models/transactions/trade_proposals.py,sha256=9ggUkwzDgMKa8cC8dNZ4IHlleiGpRN0WU-oXGDSiuaw,26730
-wbportfolio/models/transactions/trades.py,sha256=P9cSTEpZBsqKBvw25XY_RNctTiOBEzCvcuy0r8IkedE,28013
+wbportfolio/models/transactions/rebalancing.py,sha256=obzgewWKOD4kJbCoF5fhtfDk502QkbrjPKh8T9KDGew,7355
+wbportfolio/models/transactions/trade_proposals.py,sha256=a4bxSn6xGuURwsE-WqCJN5gBdwu9TpCf2E8kKn4_RiY,29659
+wbportfolio/models/transactions/trades.py,sha256=NA_hUpFKQ4H-w3B0gMZ5IFkZo6WJTH2S7GBUQC1jUpU,28922
 wbportfolio/models/transactions/transactions.py,sha256=fWoDf0TSV0L0gLUDOQpCRLzjMt1H4MUvUHGEaMsilCc,7027
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/typing.py,sha256=b2pBWYt1E8ok-Kqm0lEFIakSnWJ6Ib57z-VX3C3gkQc,6081
@@ -290,10 +290,10 @@ wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 wbportfolio/rebalancing/base.py,sha256=NwTGZtBm1f35gj5Jp6iTyyFvDT1GSIztN990cKBvYzQ,637
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
 wbportfolio/rebalancing/models/__init__.py,sha256=AQjG7Tu5vlmhqncVoYOjpBKU2UIvgo9FuP2_jD2w-UI,232
-wbportfolio/rebalancing/models/composite.py,sha256=uyF1n3NAFprnAZ3Gl5pNJl0GajelqJspC2NufZ7Tf0s,1636
-wbportfolio/rebalancing/models/equally_weighted.py,sha256=U29MOHJMQMIg7Y7W_8t5K3nXjaznzt4ArIxQSiv0Xok,863
+wbportfolio/rebalancing/models/composite.py,sha256=XEgK3oMurrE_d_l5uN0stBKRrtvnKQzRWyXNXuBYfmc,1818
+wbportfolio/rebalancing/models/equally_weighted.py,sha256=FCpSKOs49ckNYVgoYIiHB0BqPT9OeCMuFoet4Ixbp-Y,1210
 wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=6ZsR8iJg6l89CsxHqoxJSXlTaj8Pmb8_bFPrXhnxaRs,5295
-wbportfolio/rebalancing/models/model_portfolio.py,sha256=XQdvs03-0M9YUnL4DidwZC4E6k-ANCNcZ--T_aaOXTQ,1233
+wbportfolio/rebalancing/models/model_portfolio.py,sha256=DNg9vEDYDUwXTOnIpk26FQSPHC0qxkuvW2sJWX0VodQ,1489
 wbportfolio/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/reports/monthly_position_report.py,sha256=e7BzjDd6eseUOwLwQJXKvWErQ58YnCsznHU2VtR6izM,2981
 wbportfolio/risk_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -383,13 +383,13 @@ wbportfolio/tests/models/utils.py,sha256=ORNJq6NMo1Za22jGZXfTfKeNEnTRlfEt_8SJ6xL
 wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/models/transactions/test_claim.py,sha256=NG3BKB-FVcIDgHSJHCjImxgMM3ISVUMl24xUPmEcPec,5570
 wbportfolio/tests/models/transactions/test_fees.py,sha256=1gp_h_CCC4Z_cWHUgrZCjGAxYuT2u8FZdw0krDpESiY,2801
-wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=H1UbxPm-oa00-JJXbBxNutdTKvXXJmuATTab2XsXp44,3900
-wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=sqC8uT46Znb03ZwWxIJOaFNBENKunfA5U73xjWbdj80,17053
+wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=fZ5tx6kByEGXD6nhapYdvk9HOjYlmjhU2w6KlQJ6QE4,4061
+wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=P05F1RC53xjkp8BFq8D57k-86eAOkRQw6doLVX5SQlM,17945
 wbportfolio/tests/models/transactions/test_trades.py,sha256=vqvOqUY_uXvBp8YOKR0Wq9ycA2oeeEBhO3dzV7sbXEU,9863
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=fAuY1zcXibttFpBh2GhKVyzdYfi1kz_b7SPa9xZQXY0,1086
 wbportfolio/tests/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/rebalancing/test_models.py,sha256=qyZkNG1WF1lZdYwvjUElkkNey8b5ZMGSlWpzxujCuNg,7549
+wbportfolio/tests/rebalancing/test_models.py,sha256=_gT_7UtpOWceDwT7FbTUW6P6ZpCVLBpgXWM0goIljWc,8090
 wbportfolio/tests/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/serializers/test_claims.py,sha256=vQrg73xQXRFEgvx3KI9ivFre_wpBFzdO0p0J13PkvdY,582
 wbportfolio/tests/viewsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -400,7 +400,7 @@ wbportfolio/tests/viewsets/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 wbportfolio/tests/viewsets/transactions/test_claims.py,sha256=QEZfMAW07dyoZ63t2umSwGOqvaTULfYfbN_F4ZoSAcw,6368
 wbportfolio/viewsets/__init__.py,sha256=3kUaQ66ybvROwejd3bEcSt4XKzfOlPDaeoStMvlz7qY,2294
 wbportfolio/viewsets/adjustments.py,sha256=5hWCjxSgUIsrPOmJKoDYK3gywdMTI0aYDorEj1FXRVc,1429
-wbportfolio/viewsets/assets.py,sha256=CrAMuyJDyUcSZlckrhy5D6-vVRXD7I4EG9C3ZKA5Z08,22735
+wbportfolio/viewsets/assets.py,sha256=FgJhBK13tAkrDyTiWsgnIT0Oq39mlvJTQSq1ztopQhY,24172
 wbportfolio/viewsets/assets_and_net_new_money_progression.py,sha256=Jl4vEQP4N2OFL5IGBXoKcj-0qaPviU0I8npvQLw4Io0,4464
 wbportfolio/viewsets/custodians.py,sha256=CTFqkqVP1R3AV7lhdvcdICxB5DfwDYCyikNSI5kbYEo,2322
 wbportfolio/viewsets/esg.py,sha256=27MxxdXQH3Cq_1UEYmcrF7htUOg6i81fUpbVQXAAKJI,6985
@@ -410,7 +410,7 @@ wbportfolio/viewsets/portfolio_cash_targets.py,sha256=CvHlrDE8qnnnfRpTYnFu-Uu15M
 wbportfolio/viewsets/portfolio_relationship.py,sha256=RGyvxd8NfFEs8YdqEvVD3VbrISvAO5UtCTlocSIuWQw,2109
 wbportfolio/viewsets/portfolio_swing_pricing.py,sha256=-57l3WLQZRslIV67OT0ucHE5JXTtTtLvd3t7MppdVn8,357
 wbportfolio/viewsets/portfolios.py,sha256=1POzE9jrt2iLVMnIY_BWDr0A_zpOlO3Z8tM80TaXkhk,14454
-wbportfolio/viewsets/positions.py,sha256=MDf_0x9La2qE6qjaIqBtfV5VC0RfJ1chZIim45Emk10,13198
+wbportfolio/viewsets/positions.py,sha256=2rzFHB_SI09rXC_EYi58G_eqvzONbk8z61JDkkjt3Ew,13207
 wbportfolio/viewsets/product_groups.py,sha256=YvmuXPPy98K1J_rz6YPsx9gNK-tCS2P-wc1uRYgfyo0,2399
 wbportfolio/viewsets/product_performance.py,sha256=dRfRgifjGS1RgZSu9uJRM0SmB7eLnNUkPuqARMO4gyo,28371
 wbportfolio/viewsets/products.py,sha256=1KXUDXdNmBFYjQcvJkwUCnjIOKZT0cAk_XTihMKRWvw,20459
@@ -444,7 +444,7 @@ wbportfolio/viewsets/configs/display/esg.py,sha256=W8uetCPN2TjHtU2kvQjKOmkq7uoaY
 wbportfolio/viewsets/configs/display/fees.py,sha256=_8HDJADh5bA5VMVPkhKObPmNNdPHWR8Oz23PEgd04F0,5834
 wbportfolio/viewsets/configs/display/portfolio_cash_flow.py,sha256=CS_UGhKZSXnX-0SZ0RXzbG1WMJm6NX3GUljwIa4RWBk,5025
 wbportfolio/viewsets/configs/display/portfolio_relationship.py,sha256=8DvsYWFCX29qj5wUf1wCtjlPwzKRd_E7JDuo_CopaJ0,1294
-wbportfolio/viewsets/configs/display/portfolios.py,sha256=HFUFYajD7l-7WhwsxEeBp8QvJ5ZZY03EA8Am-DQ6f6w,10726
+wbportfolio/viewsets/configs/display/portfolios.py,sha256=FDL0wucfqnyehrPg_vJqZ1JJ_1S37C_TAbON165-07w,10660
 wbportfolio/viewsets/configs/display/positions.py,sha256=yolWLxzGPIpSQSiVhVQChURqbomPt5kSjkYrmXT1Mik,3123
 wbportfolio/viewsets/configs/display/product_groups.py,sha256=PwI-A0_ofShT2pub9-C1HqreiqpHxKMHd51JYwEzvbM,2500
 wbportfolio/viewsets/configs/display/product_performance.py,sha256=6Mme48JBn_okwClR44dBK2OK26ejvdasDvBa5DI33_0,10070
@@ -519,9 +519,9 @@ wbportfolio/viewsets/transactions/fees.py,sha256=7VUXIogmRrXCz_D9tvDiiTae0t5j09W
 wbportfolio/viewsets/transactions/mixins.py,sha256=WipvJoi5hylkpD0y9VATe30WAcwIHUIroVkK10FYw7k,636
 wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQVTN2MH1kG_yCeVkmyK8k,1263
 wbportfolio/viewsets/transactions/trade_proposals.py,sha256=iQpC_Thbj56SmM05vPRsF1JZguGBDaTUH3I-_iCHCV0,5958
-wbportfolio/viewsets/transactions/trades.py,sha256=xeEzx7GP34aBNPlDmiUmT86labsbb8_f1U2RCN1Jatg,21494
+wbportfolio/viewsets/transactions/trades.py,sha256=-yJ4j8NJTu2VWyhCq5BXGNND_925Ietoxx9k07SLVh0,21634
 wbportfolio/viewsets/transactions/transactions.py,sha256=ixDp-nsNA8t_A06rBCT19hOMJHy0iRmdz1XKdV1OwAs,4450
-wbportfolio-1.49.5.dist-info/METADATA,sha256=5rVe6Q67fXJTmyNtQe8MP7cfiBkqOQ7z-sRlfgU5f-U,734
-wbportfolio-1.49.5.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.49.5.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.49.5.dist-info/RECORD,,
+wbportfolio-1.49.7.dist-info/METADATA,sha256=0ZEA14Z_uhIVWclnAduNyf2USQ1Oowir18aoAdikcdA,734
+wbportfolio-1.49.7.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.49.7.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.49.7.dist-info/RECORD,,