wbportfolio 1.52.5__py2.py3-none-any.whl → 1.53.0__py2.py3-none-any.whl

wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -66,11 +66,11 @@ class TestTradeProposal:
         validated_trading_service = trade_proposal.validated_trading_service
 
         # Assert effective and target portfolios are as expected
-        assert validated_trading_service.effective_portfolio.to_dict() == {
+        assert validated_trading_service._effective_portfolio.to_dict() == {
             a1.underlying_quote.id: a1.weighting,
             a2.underlying_quote.id: a2.weighting,
         }
-        assert validated_trading_service.target_portfolio.to_dict() == {
+        assert validated_trading_service._target_portfolio.to_dict() == {
             a1.underlying_quote.id: a1.weighting + t1.weighting,
             a2.underlying_quote.id: a2.weighting + t2.weighting,
         }
@@ -267,15 +267,25 @@ class TestTradeProposal:
         asset_position_factory.create(
             portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i2, weighting=Decimal("0.3")
         )
-        instrument_price_factory.create(instrument=i1, date=effective_date)
-        instrument_price_factory.create(instrument=i2, date=effective_date)
-        instrument_price_factory.create(instrument=i3, date=effective_date)
+        p1 = instrument_price_factory.create(instrument=i1, date=effective_date)
+        p2 = instrument_price_factory.create(instrument=i2, date=effective_date)
+        p3 = instrument_price_factory.create(instrument=i3, date=effective_date)
 
         # build the target portfolio
         target_portfolio = PortfolioDTO(
             positions=(
-                Position(underlying_instrument=i2.id, date=trade_proposal.trade_date, weighting=Decimal("0.4")),
-                Position(underlying_instrument=i3.id, date=trade_proposal.trade_date, weighting=Decimal("0.6")),
+                Position(
+                    underlying_instrument=i2.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.4"),
+                    price=float(p2.net_value),
+                ),
+                Position(
+                    underlying_instrument=i3.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.6"),
+                    price=float(p3.net_value),
+                ),
             )
         )
 
@@ -295,9 +305,24 @@ class TestTradeProposal:
         # 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")),
+                Position(
+                    underlying_instrument=i1.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.2"),
+                    price=float(p1.net_value),
+                ),
+                Position(
+                    underlying_instrument=i2.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.3"),
+                    price=float(p2.net_value),
+                ),
+                Position(
+                    underlying_instrument=i3.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.5"),
+                    price=float(p3.net_value),
+                ),
             )
         )
 
@@ -361,6 +386,8 @@ class TestTradeProposal:
         """
         portfolio = trade_proposal.portfolio
         instrument = instrument_factory.create(currency=portfolio.currency)
+        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=trade_proposal.trade_date)
+        mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
         trade = trade_factory.create(
             trade_proposal=trade_proposal,
             transaction_date=trade_proposal.trade_date,
@@ -368,17 +395,19 @@ class TestTradeProposal:
             underlying_instrument=instrument,
         )
         trade.refresh_from_db()
-        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=trade.transaction_date)
-        mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
 
         # Assert estimated shares are correctly calculated
         assert (
-            trade_proposal.get_estimated_shares(trade.weighting, trade.underlying_instrument)
+            trade_proposal.get_estimated_shares(
+                trade.weighting, trade.underlying_instrument, underlying_quote_price.net_value
+            )
             == Decimal(1_000_000) * trade.weighting / underlying_quote_price.net_value
         )
 
     @patch.object(Portfolio, "get_total_asset_value")
     def test_get_estimated_target_cash(self, mock_fct, trade_proposal, trade_factory, cash_factory):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
         mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
         cash = cash_factory.create(currency=trade_proposal.portfolio.currency)
         trade_factory.create(  # equity trade
@@ -410,3 +439,191 @@ class TestTradeProposal:
         tp2 = trade_proposal_factory.create(portfolio=portfolio, trade_date=tp.trade_date - BDay(1))
         instrument.refresh_from_db()
         assert instrument.inception_date == (tp2.trade_date + BDay(1)).date()
+
+    def test_get_round_lot_size(self, trade_proposal, instrument):
+        # without a round lot size, we expect no normalization of shares
+        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+        instrument.round_lot_size = 100
+        instrument.save()
+
+        # if instrument has a round lot size different than 1, we expect different behavior based on whether shares is positive or negative
+        assert trade_proposal.get_round_lot_size(Decimal(66.0), instrument) == Decimal("100")
+        assert trade_proposal.get_round_lot_size(Decimal(-66.0), instrument) == Decimal(-66.0)
+        assert trade_proposal.get_round_lot_size(Decimal(-120), instrument) == Decimal(-200)
+
+        # exchange can disable rounding based on the lot size
+        instrument.exchange.apply_round_lot_size = False
+        instrument.exchange.save()
+        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+
+    def test_submit_round_lot_size(self, trade_proposal, trade_factory, instrument):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
+        instrument.round_lot_size = 100
+        instrument.save()
+        trade = trade_factory.create(
+            status="DRAFT",
+            underlying_instrument=instrument,
+            shares=70,
+            trade_proposal=trade_proposal,
+            weighting=Decimal("1.0"),
+        )
+        warnings = trade_proposal.submit()
+        trade_proposal.save()
+        assert (
+            len(warnings) == 1
+        )  # ensure that submit returns a warning concerning the rounded trade based on the lot size
+        trade.refresh_from_db()
+        assert trade.shares == 100  # we expect the share to be transformed from 70 to 100 (lot size of 100)
+
+    def test_submit_round_fractional_shares(self, trade_proposal, trade_factory, instrument):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
+        trade = trade_factory.create(
+            status="DRAFT",
+            underlying_instrument=instrument,
+            shares=5.6,
+            trade_proposal=trade_proposal,
+            weighting=Decimal("1.0"),
+        )
+        trade_proposal.submit()
+        trade_proposal.save()
+        trade.refresh_from_db()
+        assert trade.shares == 6  # we expect the fractional share to be rounded
+
+    def test_ex_post(
+        self, instrument_factory, asset_position_factory, instrument_price_factory, trade_proposal_factory, portfolio
+    ):
+        """
+        Tests the ex-post rebalancing mechanism of a portfolio with two instruments.
+        Verifies that weights are correctly recalculated after submitting and approving a trade proposal.
+        """
+
+        # --- Create instruments ---
+        msft = instrument_factory.create(currency=portfolio.currency)
+        apple = instrument_factory.create(currency=portfolio.currency)
+
+        # --- Key dates ---
+        d1 = date(2025, 6, 24)
+        d2 = date(2025, 6, 25)
+        d3 = date(2025, 6, 26)
+        d4 = date(2025, 6, 27)
+
+        # --- Create MSFT prices ---
+        msft_p1 = instrument_price_factory.create(instrument=msft, date=d1, net_value=Decimal("10"))
+        msft_p2 = instrument_price_factory.create(instrument=msft, date=d2, net_value=Decimal("8"))
+        msft_p3 = instrument_price_factory.create(instrument=msft, date=d3, net_value=Decimal("12"))
+        msft_p4 = instrument_price_factory.create(instrument=msft, date=d4, net_value=Decimal("15"))  # noqa
+
+        # Calculate MSFT returns between dates
+        msft_r2 = msft_p2.net_value / msft_p1.net_value - Decimal("1")  # noqa
+        msft_r3 = msft_p3.net_value / msft_p2.net_value - Decimal("1")
+
+        # --- Create Apple prices (stable) ---
+        apple_p1 = instrument_price_factory.create(instrument=apple, date=d1, net_value=Decimal("100"))
+        apple_p2 = instrument_price_factory.create(instrument=apple, date=d2, net_value=Decimal("100"))
+        apple_p3 = instrument_price_factory.create(instrument=apple, date=d3, net_value=Decimal("100"))
+        apple_p4 = instrument_price_factory.create(instrument=apple, date=d4, net_value=Decimal("100"))  # noqa
+
+        # Apple returns (always 0 since price is stable)
+        apple_r2 = apple_p2.net_value / apple_p1.net_value - Decimal("1")  # noqa
+        apple_r3 = apple_p3.net_value / apple_p2.net_value - Decimal("1")
+
+        # --- Create positions on d2 ---
+        msft_a2 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=msft,
+            date=d2,
+            initial_shares=10,
+            weighting=Decimal("0.44"),
+        )
+        apple_a2 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=apple,
+            date=d2,
+            initial_shares=1,
+            weighting=Decimal("0.56"),
+        )
+
+        # Check that initial weights sum to 1
+        total_weight_d2 = msft_a2.weighting + apple_a2.weighting
+        assert total_weight_d2 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
+
+        # --- Calculate total portfolio return between d2 and d3 ---
+        portfolio_r3 = msft_a2.weighting * (Decimal("1.0") + msft_r3) + apple_a2.weighting * (
+            Decimal("1.0") + apple_r3
+        )
+
+        # --- Create positions on d3 with weights adjusted for returns ---
+        msft_a3 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=msft,
+            date=d3,
+            initial_shares=10,
+            weighting=msft_a2.weighting * (Decimal("1.0") + msft_r3) / portfolio_r3,
+        )
+        apple_a3 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=apple,
+            date=d3,
+            initial_shares=1,
+            weighting=apple_a2.weighting * (Decimal("1.0") + apple_r3) / portfolio_r3,
+        )
+
+        # Check that weights on d3 sum to 1
+        total_weight_d3 = msft_a3.weighting + apple_a3.weighting
+        assert total_weight_d3 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
+
+        # --- Create a trade proposal on d3 ---
+        trade_proposal = trade_proposal_factory.create(portfolio=portfolio, trade_date=d3)
+        trade_proposal.reset_trades()
+
+        # Retrieve trades for each instrument
+        trade_msft = trade_proposal.trades.get(underlying_instrument=msft)
+        trade_apple = trade_proposal.trades.get(underlying_instrument=apple)
+
+        # Check that trade weights are initially zero
+        assert trade_msft.weighting == Decimal("0")
+        assert trade_apple.weighting == Decimal("0")
+
+        # --- Adjust trade weights to target 50% each ---
+        target_weight = Decimal("0.5")
+        trade_msft.weighting = target_weight - msft_a3.weighting
+        trade_msft.save()
+
+        trade_apple.weighting = target_weight - apple_a3.weighting
+        trade_apple.save()
+
+        # --- Check drift factors and effective weights ---
+        assert trade_msft.drift_factor == pytest.approx(msft_a3.weighting / msft_a2.weighting, abs=Decimal("1e-6"))
+        assert trade_apple.drift_factor == pytest.approx(apple_a3.weighting / apple_a2.weighting, abs=Decimal("1e-6"))
+
+        assert trade_msft._effective_weight == pytest.approx(msft_a3.weighting, abs=Decimal("1e-6"))
+        assert trade_apple._effective_weight == pytest.approx(apple_a3.weighting, abs=Decimal("1e-6"))
+
+        # Check that the target weight is the sum of drifted weight and adjustment
+        assert trade_msft._target_weight == pytest.approx(
+            msft_a2.weighting * trade_msft.drift_factor + trade_msft.weighting,
+            abs=Decimal("1e-6"),
+        )
+        assert trade_msft._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
+
+        assert trade_apple._target_weight == pytest.approx(
+            apple_a2.weighting * trade_apple.drift_factor + trade_apple.weighting,
+            abs=Decimal("1e-6"),
+        )
+        assert trade_apple._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
+
+        # --- Submit and approve the trade proposal ---
+        trade_proposal.submit()
+        trade_proposal.save()
+        trade_proposal.approve()
+        trade_proposal.save()
+
+        # --- Refresh positions after ex-post rebalancing ---
+        msft_a3.refresh_from_db()
+        apple_a3.refresh_from_db()
+
+        # Final check that weights have been updated to 50%
+        assert msft_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
+        assert apple_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))

wbportfolio/tests/rebalancing/test_models.py

@@ -38,30 +38,24 @@ class TestModelPortfolioRebalancing:
     def model(self, portfolio, weekday):
         from wbportfolio.rebalancing.models import ModelPortfolioRebalancing
 
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=portfolio,
+            dependency_portfolio=PortfolioFactory.create(),
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
     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()
-        model_portfolio = PortfolioFactory.create()
-        PortfolioPortfolioThroughModel.objects.create(
-            portfolio=model.portfolio,
-            dependency_portfolio=model_portfolio,
-            type=PortfolioPortfolioThroughModel.Type.MODEL,
-        )
+
         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):
-        model_portfolio = PortfolioFactory.create()
-        PortfolioPortfolioThroughModel.objects.create(
-            portfolio=model.portfolio,
-            dependency_portfolio=model_portfolio,
-            type=PortfolioPortfolioThroughModel.Type.MODEL,
-        )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         a1 = asset_position_factory(weighting=0.8, portfolio=portfolio.model_portfolio, date=model.last_effective_date)
@@ -91,7 +85,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.7,
+            weighting=Decimal(0.7),
             status=Trade.Status.EXECUTED,
         )
         TradeFactory.create(
@@ -99,7 +93,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.3,
+            weighting=Decimal(0.3),
             status=Trade.Status.EXECUTED,
         )
         assert not model.is_valid()
@@ -117,7 +111,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.8,
+            weighting=Decimal(0.8),
             status=Trade.Status.EXECUTED,
         )
         t2 = TradeFactory.create(
@@ -125,7 +119,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.2,
+            weighting=Decimal(0.2),
             status=Trade.Status.EXECUTED,
         )
         target_portfolio = model.get_target_portfolio()

wbportfolio/viewsets/configs/buttons/trade_proposals.py

@@ -1,7 +1,13 @@
+from wbcore import serializers as wb_serializers
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs import buttons as bt
 from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display import create_simple_display
+
+
+class NormalizeSerializer(wb_serializers.Serializer):
+    total_cash_weight = wb_serializers.FloatField(default=0, precision=4, percent=True)
 
 
 class TradeProposalButtonConfig(ButtonViewConfig):
@@ -41,10 +47,12 @@ class TradeProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.EDIT.icon,
                         label="Normalize Trades",
                         description_fields="""
-                            <p>Make sure all trades normalize to a total target weight of 100%</p>
+                            <p>Make sure all trades normalize to a total target weight of (100 - {{total_cash_weight}})%</p>
                             """,
                         action_label="Normalize Trades",
                         title="Normalize Trades",
+                        serializer=NormalizeSerializer,
+                        instance_display=create_simple_display([["total_cash_weight"]]),
                     ),
                     bt.ActionButton(
                         method=RequestType.PATCH,

wbportfolio/viewsets/configs/display/trade_proposals.py

@@ -77,11 +77,12 @@ class TradeProposalDisplayConfig(DisplayViewConfig):
                     layouts={
                         default(): Layout(
                             grid_template_areas=[
-                                ["status", "status", "status"],
-                                ["trade_date", "rebalancing_model", "target_portfolio"]
+                                ["status", "status"],
+                                ["trade_date", "total_cash_weight"],
+                                ["rebalancing_model", "target_portfolio"]
                                 if self.view.new_mode
-                                else ["trade_date", "rebalancing_model", "rebalancing_model"],
-                                ["comment", "comment", "comment"],
+                                else ["rebalancing_model", "rebalancing_model"],
+                                ["comment", "comment"],
                             ],
                         ),
                     },

wbportfolio/viewsets/configs/display/trades.py

@@ -357,6 +357,42 @@ class TradeTradeProposalDisplayConfig(DisplayViewConfig):
                     ],
                 )
             )
+            fields.append(
+                dp.Field(
+                    label="Total Value",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(
+                            key="effective_total_value_fx_portfolio",
+                            label="Effective Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="target_total_value_fx_portfolio",
+                            label="Target Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="total_value_fx_portfolio",
+                            label="Total Value",
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={"color": WBColor.RED_DARK.value, "fontWeight": "bold"},
+                                    condition=("<", 0),
+                                ),
+                                dp.FormattingRule(
+                                    style={"color": WBColor.GREEN_DARK.value, "fontWeight": "bold"},
+                                    condition=(">", 0),
+                                ),
+                            ],
+                            width=Unit.PIXEL(150),
+                        ),
+                    ],
+                )
+            )
         fields.append(
             dp.Field(
                 label="Information",

wbportfolio/viewsets/transactions/trade_proposals.py

@@ -1,5 +1,6 @@
 from contextlib import suppress
 from datetime import date
+from decimal import Decimal
 
 from django.contrib.messages import info, warning
 from django.shortcuts import get_object_or_404
@@ -106,8 +107,9 @@ class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
     @action(detail=True, methods=["PATCH"])
     def normalize(self, request, pk=None):
         trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        total_cash_weight = Decimal(request.data.get("total_cash_weight", Decimal("0.0")))
         if trade_proposal.status == TradeProposal.Status.DRAFT:
-            trade_proposal.normalize_trades()
+            trade_proposal.normalize_trades(total_target_weight=Decimal("1.0") - total_cash_weight)
             return Response({"send": True})
         return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 

wbportfolio/viewsets/transactions/trades.py

@@ -25,7 +25,6 @@ from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.utils.strings import format_number
 from wbcore.viewsets.mixins import OrderableMixin
 from wbcrm.models import Account
-from wbfdm.models import Cash
 
 from wbportfolio.filters import (
     SubscriptionRedemptionFilterSet,
@@ -395,6 +394,10 @@ class TradeTradeProposalModelViewSet(
     def trade_proposal(self):
         return get_object_or_404(TradeProposal, pk=self.kwargs["trade_proposal_id"])
 
+    @cached_property
+    def portfolio_total_asset_value(self):
+        return self.trade_proposal.portfolio_total_asset_value
+
     def has_import_permission(self, request) -> bool:  # allow import only on draft trade proposal
         return super().has_import_permission(request) and self.trade_proposal.status == TradeProposal.Status.DRAFT
 
@@ -409,46 +412,36 @@ class TradeTradeProposalModelViewSet(
     def get_aggregates(self, queryset, *args, **kwargs):
         agg = {}
         if queryset.exists():
-            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"
-                )
-            ).exclude(currency=self.trade_proposal.portfolio.currency)
-
-            for cash_component in extra_existing_cash_components:
-                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")),
-                sum_target_shares=Sum(F("target_shares")),
-                sum_effective_shares=Sum(F("effective_shares")),
-            )
-            cash_aggregates = queryset.filter(underlying_instrument__is_cash=True).aggregate(
-                sum_effective_weight=Sum(F("effective_weight")),
-                sum_effective_shares=Sum(F("effective_shares")),
+                sum_target_total_value_fx_portfolio=Sum(F("target_total_value_fx_portfolio")),
+                sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
             )
+
             # weights aggregates
-            cash_sum_effective_weight = cash_aggregates["sum_effective_weight"] or Decimal(0)
+            cash_sum_effective_weight = Decimal("1.0") - noncash_aggregates["sum_effective_weight"]
+            cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]
             noncash_sum_effective_weight = noncash_aggregates["sum_effective_weight"] or Decimal(0)
             noncash_sum_target_weight = noncash_aggregates["sum_target_weight"] or Decimal(0)
             sum_buy_weight = queryset.filter(weighting__gte=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
             sum_sell_weight = queryset.filter(weighting__lt=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
 
             # shares aggregates
-            cash_sum_effective_shares = cash_aggregates["sum_effective_shares"] or Decimal(0)
-            noncash_sum_effective_shares = noncash_aggregates["sum_effective_shares"] or Decimal(0)
-            noncash_sum_target_shares = noncash_aggregates["sum_target_shares"] or Decimal(0)
-            sum_buy_shares = queryset.filter(shares__gte=0).aggregate(s=Sum(F("shares")))["s"] or Decimal(0)
-            sum_sell_shares = queryset.filter(shares__lt=0).aggregate(s=Sum(F("shares")))["s"] or Decimal(0)
+            cash_sum_effective_total_value_fx_portfolio = cash_sum_effective_weight * self.portfolio_total_asset_value
+            cash_sum_target_total_value_fx_portfolio = cash_sum_target_cash_weight * self.portfolio_total_asset_value
+            noncash_sum_effective_total_value_fx_portfolio = noncash_aggregates[
+                "sum_effective_total_value_fx_portfolio"
+            ] or Decimal(0)
+            noncash_sum_target_total_value_fx_portfolio = noncash_aggregates[
+                "sum_target_total_value_fx_portfolio"
+            ] or Decimal(0)
+            sum_buy_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__gte=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+            sum_sell_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__lt=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
 
             agg = {
                 "effective_weight": {
@@ -457,29 +450,38 @@ class TradeTradeProposalModelViewSet(
                     "Total": format_number(noncash_sum_effective_weight + cash_sum_effective_weight, decimal=6),
                 },
                 "target_weight": {
-                    "Cash": format_number(cash_target_cash_weight, decimal=6),
+                    "Cash": format_number(cash_sum_target_cash_weight, decimal=6),
                     "Non-Cash": format_number(noncash_sum_target_weight, decimal=6),
-                    "Total": format_number(cash_target_cash_weight + noncash_sum_target_weight, decimal=6),
+                    "Total": format_number(cash_sum_target_cash_weight + noncash_sum_target_weight, decimal=6),
                 },
-                "effective_shares": {
-                    "Cash": format_number(cash_sum_effective_shares, decimal=6),
-                    "Non-Cash": format_number(noncash_sum_effective_shares, decimal=6),
-                    "Total": format_number(cash_sum_effective_shares + noncash_sum_effective_shares, decimal=6),
+                "effective_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_effective_total_value_fx_portfolio + noncash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
                 },
-                "target_shares": {
-                    "Cash": format_number(cash_target_cash_shares, decimal=6),
-                    "Non-Cash": format_number(noncash_sum_target_shares, decimal=6),
-                    "Total": format_number(cash_target_cash_shares + noncash_sum_target_shares, decimal=6),
+                "target_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_target_total_value_fx_portfolio + noncash_sum_target_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
                 },
                 "weighting": {
-                    "Cash Flow": format_number(cash_sum_effective_weight - cash_target_cash_weight, decimal=6),
+                    "Cash Flow": format_number(cash_sum_target_cash_weight - cash_sum_effective_weight, decimal=6),
                     "Buy": format_number(sum_buy_weight, decimal=6),
                     "Sell": format_number(sum_sell_weight, decimal=6),
                 },
-                "shares": {
-                    "Cash Flow": format_number(cash_sum_effective_shares - cash_target_cash_shares, decimal=6),
-                    "Buy": format_number(sum_buy_shares, decimal=6),
-                    "Sell": format_number(sum_sell_shares, decimal=6),
+                "total_value_fx_portfolio": {
+                    "Cash Flow": format_number(
+                        cash_sum_target_total_value_fx_portfolio - cash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                    "Buy": format_number(sum_buy_total_value_fx_portfolio, decimal=6),
+                    "Sell": format_number(sum_sell_total_value_fx_portfolio, decimal=6),
                 },
             }
 
@@ -509,6 +511,7 @@ class TradeTradeProposalModelViewSet(
             qs = super().get_queryset().filter(trade_proposal=self.kwargs["trade_proposal_id"]).annotate_base_info()
         else:
             qs = TradeProposal.objects.none()
+
         return qs.annotate(
             underlying_instrument_isin=F("underlying_instrument__isin"),
             underlying_instrument_ticker=F("underlying_instrument__ticker"),
@@ -520,4 +523,9 @@ class TradeTradeProposalModelViewSet(
                 ),
                 default=F("underlying_instrument__instrument_type__short_name"),
             ),
+            effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
+            target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
+            portfolio_currency=F("portfolio__currency__symbol"),
+            security=F("underlying_instrument__parent"),
+            company=F("underlying_instrument__parent__parent"),
         )

{wbportfolio-1.52.5.dist-info → wbportfolio-1.53.0.dist-info}/METADATA

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