wbportfolio 1.49.6__py2.py3-none-any.whl → 1.49.8__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)

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
@@ -254,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,
@@ -339,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.
 
@@ -380,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
 
@@ -414,23 +440,20 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         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()
@@ -486,12 +509,23 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
         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():
             with suppress(ValueError):
-                assets.append(trade.to_asset())
+                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:

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/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/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.6.dist-info → wbportfolio-1.49.8.dist-info}/METADATA

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

{wbportfolio-1.49.6.dist-info → wbportfolio-1.49.8.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=QftWva0GmlStpspcp33TOMZf2t_PTeEhwWdp6xUbQNU,37738
+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,8 +275,8 @@ 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=qpjjQMK7G5sX7iiCnXBt07EH-ztxZz-l842yfYrBLQw,27764
+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
@@ -384,7 +384,7 @@ wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCe
 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=fZ5tx6kByEGXD6nhapYdvk9HOjYlmjhU2w6KlQJ6QE4,4061
-wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=sqC8uT46Znb03ZwWxIJOaFNBENKunfA5U73xjWbdj80,17053
+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
@@ -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
@@ -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.6.dist-info/METADATA,sha256=KMGYS4c7qMFyTTr5hrm23nCftQHaW2JSIRsfp0SetKA,734
-wbportfolio-1.49.6.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.49.6.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.49.6.dist-info/RECORD,,
+wbportfolio-1.49.8.dist-info/METADATA,sha256=tEN7pGOUaI3BhAt-b4IyD7LRCi1jWgqwW6linsZA4zQ,734
+wbportfolio-1.49.8.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.49.8.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.49.8.dist-info/RECORD,,