wbportfolio 1.48.0__py2.py3-none-any.whl → 1.49.1__py2.py3-none-any.whl

wbportfolio/rebalancing/models/composite.py

@@ -2,6 +2,7 @@ from decimal import Decimal
 
 from django.core.exceptions import ObjectDoesNotExist
 
+from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -11,11 +12,23 @@ from wbportfolio.rebalancing.decorators import register
 class CompositeRebalancing(AbstractRebalancingModel):
     @property
     def base_assets(self) -> dict[int, Decimal]:
+        """
+        Return a dictionary representation (instrument_id: target weight) of this trade proposal
+        Returns:
+            A dictionary representation
+
+        """
         try:
             latest_trade_proposal = self.portfolio.trade_proposals.filter(
                 status="APPROVED", trade_date__lte=self.trade_date
             ).latest("trade_date")
-            return latest_trade_proposal.base_assets
+            return {
+                v["underlying_instrument"]: v["target_weight"]
+                for v in latest_trade_proposal.trades.all()
+                .annotate_base_info()
+                .filter(status=Trade.Status.EXECUTED)
+                .values("underlying_instrument", "target_weight")
+            }
         except ObjectDoesNotExist:
             return dict()
 

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -101,6 +101,24 @@ class RuleBackend(
             )
             _classifications = ClassificationRepresentationSerializer(many=True, source="parameters__classifications")
 
+            extra_filter_field = wb_serializers.ChoiceField(
+                choices=cls.Field.choices,
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field",
+                help_text="Specify if we need to narrow done the position applying a filter on that field and the corresponding range",
+            )
+            extra_filter_field_lower_bound = wb_serializers.FloatField(
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field Lower bound",
+            )
+            extra_filter_field_upper_bound = wb_serializers.FloatField(
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field Lower bound",
+            )
+
             @classmethod
             def get_parameter_fields(cls):
                 return [
@@ -111,6 +129,9 @@ class RuleBackend(
                     "currencies",
                     "countries",
                     "classifications",
+                    "extra_filter_field",
+                    "extra_filter_field_lower_bound",
+                    "extra_filter_field_upper_bound",
                 ]
 
         return RuleBackendSerializer
@@ -131,6 +152,10 @@ class RuleBackend(
             repr["Only Countries"] = ", ".join(map(lambda o: o.code_2, self.countries))
         if self.classifications:
             repr["Only Classifications"] = ", ".join(map(lambda o: o.name, self.classifications))
+        if self.extra_filter_field:
+            repr["Extra Filter Field"] = (
+                f"{self.extra_filter_field}=[{self.extra_filter_field_lower_bound},{self.extra_filter_field_upper_bound}["
+            )
         return repr
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
@@ -180,7 +205,11 @@ class RuleBackend(
                     & df["primary_classification"].isin(list(map(lambda o: o.id, self.classifications)))
                 )
             ]
-
+        if self.extra_filter_field:
+            if (lower_bound := self.extra_filter_field_lower_bound) is not None:
+                df = df[df[self.extra_filter_field] >= lower_bound]
+            if (upper_bound := self.extra_filter_field_upper_bound) is not None:
+                df = df[df[self.extra_filter_field] < upper_bound]
         return df
 
     def _get_obj_repr(self, pivot_object_id) -> tuple[models.Model | None, str]:

wbportfolio/risk_management/tests/test_exposure_portfolio.py

@@ -93,3 +93,50 @@ class TestExposurePortfolioRuleModel(PortfolioTestMixin):
             ExposurePortfolioRuleBackend.GroupbyChoices.FAVORITE_CLASSIFICATION,
         ]:
             assert incidents[0].breached_object == classification
+
+    def test_exposure_rule_with_extra_filter_field(
+        self, weekday, portfolio, asset_position_factory, instrument_price_factory, instrument_factory
+    ):
+        parameters = {
+            "group_by": "instrument_type",
+            "field": ExposurePortfolioRuleBackend.Field.WEIGHTING.value,
+            "extra_filter_field": "market_capitalization_usd",
+            "extra_filter_field_lower_bound": 1000.0,
+            "extra_filter_field_upper_bound": 10000.0,
+        }
+        exposure_portfolio_backend = ExposurePortfolioRuleBackend(
+            weekday,
+            portfolio,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=0.05, upper=None))],  # type: ignore
+        )
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create(instrument_type=i1.instrument_type)
+        i3 = instrument_factory.create(instrument_type=i1.instrument_type)
+        instrument_price_factory.create(instrument=i1, date=weekday, market_capitalization=1000)
+        instrument_price_factory.create(instrument=i2, date=weekday, market_capitalization=9999)
+        instrument_price_factory.create(instrument=i3, date=weekday, market_capitalization=10001)
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.025,
+            underlying_instrument=i1,
+            portfolio=portfolio,
+        )
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.025,
+            underlying_instrument=i2,
+            portfolio=portfolio,
+        )
+
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.95,
+            underlying_instrument=i3,
+            portfolio=portfolio,
+        )
+        incidents = list(exposure_portfolio_backend.check_rule())
+        assert len(incidents) == 1
+        incident = incidents[0]
+        assert incident.breached_object_repr == i1.instrument_type
+        assert incident.breached_value == '<span style="color:green">+5.00%</span>'

wbportfolio/serializers/portfolios.py

@@ -1,7 +1,10 @@
+from datetime import date
+
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
 from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
 from wbcore.contrib.directory.models import BankingContact
+from wbfdm.serializers import InstrumentRepresentationSerializer
 
 from wbportfolio.models import Portfolio, PortfolioPortfolioThroughModel
 from wbportfolio.serializers.rebalancing import RebalancerRepresentationSerializer
@@ -21,12 +24,25 @@ class PortfolioRepresentationSerializer(wb_serializers.RepresentationSerializer)
 
 class PortfolioModelSerializer(wb_serializers.ModelSerializer):
     _currency = CurrencyRepresentationSerializer(source="currency")
+    _hedged_currency = CurrencyRepresentationSerializer(source="hedged_currency")
     _depends_on = PortfolioRepresentationSerializer(source="depends_on", many=True)
     automatic_rebalancer = wb_serializers.PrimaryKeyRelatedField(read_only=True)
     _automatic_rebalancer = RebalancerRepresentationSerializer(source="automatic_rebalancer")
+    _instruments = InstrumentRepresentationSerializer(source="instruments", many=True)
 
     create_index = wb_serializers.BooleanField(write_only=True, default=False)
 
+    last_asset_under_management_usd = wb_serializers.FloatField(read_only=True)
+    last_positions = wb_serializers.FloatField(read_only=True)
+    last_trade_proposal_date = wb_serializers.DateField(read_only=True)
+    next_expected_trade_proposal_date = wb_serializers.SerializerMethodField(read_only=True)
+
+    def get_next_expected_trade_proposal_date(self, obj):
+        if (automatic_rebalancer := getattr(obj, "automatic_rebalancer", None)) and (
+            _d := automatic_rebalancer.get_next_rebalancing_date(date.today())
+        ):
+            return _d.strftime("%Y-%m-%d")
+
     def create(self, validated_data):
         create_index = validated_data.pop("create_index", False)
         obj = super().create(validated_data)
@@ -133,8 +149,12 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "updated_at",
             "_depends_on",
             "depends_on",
+            "_instruments",
+            "instruments",
             "_currency",
             "currency",
+            "_hedged_currency",
+            "hedged_currency",
             "automatic_rebalancer",
             "_automatic_rebalancer",
             "invested_timespan",
@@ -145,6 +165,12 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "is_composition",
             "_additional_resources",
             "create_index",
+            "initial_position_date",
+            "last_position_date",
+            "last_asset_under_management_usd",
+            "last_positions",
+            "last_trade_proposal_date",
+            "next_expected_trade_proposal_date",
         )
 
 

wbportfolio/serializers/transactions/trades.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 from rest_framework import serializers
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
 
 from wbportfolio.models import PortfolioRole, Trade, TradeProposal
 from wbportfolio.models.transactions.claim import Claim
@@ -212,6 +213,14 @@ class TradeModelSerializer(TransactionModelSerializer):
 
 
 class TradeTradeProposalModelSerializer(TradeModelSerializer):
+    underlying_instrument_isin = wb_serializers.CharField(read_only=True)
+    underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
+    underlying_instrument_refinitiv_identifier_code = wb_serializers.CharField(read_only=True)
+    underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
+        source="underlying_instrument", label_key="name"
+    )
+
     status = wb_serializers.ChoiceField(default=Trade.Status.DRAFT, choices=Trade.Status.choices)
     target_weight = wb_serializers.DecimalField(max_digits=16, decimal_places=6, required=False, default=0)
     effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
@@ -249,6 +258,10 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
         fields = (
             "id",
             "shares",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument_refinitiv_identifier_code",
+            "underlying_instrument_instrument_type",
             "underlying_instrument",
             "_underlying_instrument",
             "transaction_subtype",

wbportfolio/tests/models/test_portfolios.py

@@ -33,7 +33,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert portfolio.id is not None
 
     def test_str(self, portfolio):
-        assert str(portfolio) == f"{portfolio.id:06} ({portfolio.name})"
+        assert str(portfolio) == f"{portfolio.id:06}: {portfolio.name}"
 
     def test_get_assets(self, portfolio, product, cash, asset_position_factory):
         asset_position_factory.create_batch(4, portfolio=portfolio, underlying_instrument=product)
@@ -1062,7 +1062,7 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         # we approve the rebalancing trade proposal
         assert rebalancing_trade_proposal.status == "SUBMIT"
-        rebalancing_trade_proposal.approve()
+        rebalancing_trade_proposal.approve(no_replay=True)
         rebalancing_trade_proposal.save()
 
         # check that the rebalancing was applied and position reflect that

wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -0,0 +1,381 @@
+# Import necessary modules
+from datetime import date, timedelta
+from decimal import Decimal
+from unittest.mock import call, patch
+
+import pytest
+from faker import Faker
+from pandas._libs.tslibs.offsets import BDay, MonthEnd
+
+from wbportfolio.models import Portfolio, RebalancingModel, TradeProposal
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+from wbportfolio.pms.typing import Position
+
+fake = Faker()
+
+
+# Mark tests to use Django's database
+@pytest.mark.django_db
+class TestTradeProposal:
+    # Test that the checked object is correctly set to the portfolio
+    def test_checked_object(self, trade_proposal):
+        """
+        Verify that the checked object is the portfolio associated with the trade proposal.
+        """
+        assert trade_proposal.checked_object == trade_proposal.portfolio
+
+    # Test that the evaluation date matches the trade date
+    def test_check_evaluation_date(self, trade_proposal):
+        """
+        Ensure the evaluation date is the same as the trade date.
+        """
+        assert trade_proposal.check_evaluation_date == trade_proposal.trade_date
+
+    # Test the validated trading service functionality
+    def test_validated_trading_service(self, trade_proposal, asset_position_factory, trade_factory):
+        """
+        Validate that the effective and target portfolios are correctly calculated.
+        """
+        effective_date = (trade_proposal.trade_date - BDay(1)).date()
+
+        # Create asset positions for testing
+        a1 = asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
+        )
+        a2 = asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
+        )
+
+        # Create trades for testing
+        t1 = trade_factory.create(
+            trade_proposal=trade_proposal,
+            weighting=Decimal("0.05"),
+            portfolio=trade_proposal.portfolio,
+            transaction_date=trade_proposal.trade_date,
+            underlying_instrument=a1.underlying_quote,
+        )
+        t2 = trade_factory.create(
+            trade_proposal=trade_proposal,
+            weighting=Decimal("-0.05"),
+            portfolio=trade_proposal.portfolio,
+            transaction_date=trade_proposal.trade_date,
+            underlying_instrument=a2.underlying_quote,
+        )
+
+        # Get the validated trading service
+        validated_trading_service = trade_proposal.validated_trading_service
+
+        # Assert effective and target portfolios are as expected
+        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() == {
+            a1.underlying_quote.id: a1.weighting + t1.weighting,
+            a2.underlying_quote.id: a2.weighting + t2.weighting,
+        }
+
+    # Test the calculation of the last effective date
+    def test_last_effective_date(self, trade_proposal, asset_position_factory):
+        """
+        Verify the last effective date is correctly determined based on asset positions.
+        """
+        # Without any positions, it should be the day before the trade date
+        assert (
+            trade_proposal.last_effective_date == (trade_proposal.trade_date - BDay(1)).date()
+        ), "Last effective date without position should be t-1"
+
+        # Create an asset position before the trade date
+        a1 = asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=(trade_proposal.trade_date - BDay(5)).date()
+        )
+        a_noise = asset_position_factory.create(portfolio=trade_proposal.portfolio, date=trade_proposal.trade_date)  # noqa
+
+        # The last effective date should still be the day before the trade date due to caching
+        assert (
+            trade_proposal.last_effective_date == (trade_proposal.trade_date - BDay(1)).date()
+        ), "last effective date is cached, so it won't change as is"
+
+        # Reset the cache property to recalculate
+        del trade_proposal.last_effective_date
+
+        # Now it should be the date of the latest position before the trade date
+        assert (
+            trade_proposal.last_effective_date == a1.date
+        ), "last effective date is the latest position strictly lower than trade date"
+
+    # Test finding the previous trade proposal
+    def test_previous_trade_proposal(self, trade_proposal_factory):
+        """
+        Ensure the previous trade proposal is correctly identified as the last approved proposal before the current one.
+        """
+        tp = trade_proposal_factory.create()
+        tp_previous_submit = trade_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=TradeProposal.Status.SUBMIT, trade_date=(tp.trade_date - BDay(1)).date()
+        )
+        tp_previous_approve = trade_proposal_factory.create(
+            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(2)).date()
+        )
+        tp_next_approve = trade_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(1)).date()
+        )
+
+        # The previous valid trade proposal should be the approved one strictly before the current proposal
+        assert (
+            tp.previous_trade_proposal == tp_previous_approve
+        ), "the previous valid trade proposal is the strictly before and approved trade proposal"
+
+    # Test finding the next trade proposal
+    def test_next_trade_proposal(self, trade_proposal_factory):
+        """
+        Verify the next trade proposal is correctly identified as the first approved proposal after the current one.
+        """
+        tp = trade_proposal_factory.create()
+        tp_next_submit = trade_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=TradeProposal.Status.SUBMIT, trade_date=(tp.trade_date + BDay(1)).date()
+        )
+        tp_next_approve = trade_proposal_factory.create(
+            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(2)).date()
+        )
+        tp_previous_approve = trade_proposal_factory.create(  # noqa
+            portfolio=tp.portfolio, status=TradeProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(1)).date()
+        )
+
+        # The next valid trade proposal should be the approved one strictly after the current proposal
+        assert (
+            tp.next_trade_proposal == tp_next_approve
+        ), "the next valid trade proposal is the strictly after and approved trade proposal"
+
+    # Test getting the default target portfolio
+    def test__get_default_target_portfolio(self, trade_proposal, asset_position_factory):
+        """
+        Ensure the default target portfolio is set to the effective portfolio from the day before the trade date.
+        """
+        effective_date = (trade_proposal.trade_date - BDay(1)).date()
+
+        # Create asset positions for testing
+        a1 = asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.3")
+        )
+        a2 = asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, weighting=Decimal("0.7")
+        )
+        asset_position_factory.create(portfolio=trade_proposal.portfolio, date=trade_proposal.trade_date)  # noise
+
+        # The default target portfolio should match the effective portfolio
+        assert trade_proposal._get_default_target_portfolio().to_dict() == {
+            a1.underlying_quote.id: a1.weighting,
+            a2.underlying_quote.id: a2.weighting,
+        }
+
+    # Test getting the default target portfolio with a rebalancing model
+    @patch.object(RebalancingModel, "get_target_portfolio")
+    def test__get_default_target_portfolio_with_rebalancer_model(self, mock_fct, trade_proposal, rebalancer_factory):
+        """
+        Verify that the target portfolio is correctly obtained from a rebalancing model.
+        """
+        # Expected target portfolio from the rebalancing model
+        expected_target_portfolio = PortfolioDTO(
+            positions=(Position(underlying_instrument=1, weighting=Decimal(1), date=trade_proposal.trade_date),)
+        )
+        mock_fct.return_value = expected_target_portfolio
+
+        # Create a rebalancer for testing
+        rebalancer = rebalancer_factory.create(
+            portfolio=trade_proposal.portfolio, parameters={"rebalancer_parameter": "A"}
+        )
+        trade_proposal.rebalancing_model = rebalancer.rebalancing_model
+        trade_proposal.save()
+
+        # Additional keyword arguments for the rebalancing model
+        extra_kwargs = {"test": "test"}
+
+        # Combine rebalancer parameters with extra keyword arguments
+        expected_kwargs = rebalancer.parameters
+        expected_kwargs.update(extra_kwargs)
+
+        # Assert the target portfolio matches the expected output from the rebalancing model
+        assert (
+            trade_proposal._get_default_target_portfolio(**extra_kwargs) == expected_target_portfolio
+        ), "We expect the target portfolio to be whatever is returned by the rebalancer model"
+        mock_fct.assert_called_once_with(
+            trade_proposal.portfolio, trade_proposal.trade_date, trade_proposal.last_effective_date, **expected_kwargs
+        )
+
+    # Test normalizing trades
+    def test_normalize_trades(self, trade_proposal, trade_factory):
+        """
+        Ensure trades are normalized to sum up to 1, handling quantization errors.
+        """
+        # Create trades for testing
+        t1 = trade_factory.create(
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=trade_proposal.portfolio,
+            weighting=Decimal(0.2),
+        )
+        t2 = trade_factory.create(
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=trade_proposal.portfolio,
+            weighting=Decimal(0.26),
+        )
+        t3 = trade_factory.create(
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=trade_proposal.portfolio,
+            weighting=Decimal(0.14),
+        )
+
+        # Normalize trades
+        trade_proposal.normalize_trades()
+
+        # Refresh trades from the database
+        t1.refresh_from_db()
+        t2.refresh_from_db()
+        t3.refresh_from_db()
+
+        # Expected normalized weights
+        normalized_t1_weight = Decimal("0.333333")
+        normalized_t2_weight = Decimal("0.433333")
+        normalized_t3_weight = Decimal("0.233333")
+
+        # Calculate quantization error
+        quantize_error = Decimal(1) - (normalized_t1_weight + normalized_t2_weight + normalized_t3_weight)
+
+        # Assert quantization error exists and weights are normalized correctly
+        assert quantize_error
+        assert t1.weighting == normalized_t1_weight
+        assert t2.weighting == normalized_t2_weight + quantize_error  # Add quantize error to the largest position
+        assert t3.weighting == normalized_t3_weight
+
+    # Test resetting trades
+    def test_reset_trades(self, trade_proposal, instrument_factory, asset_position_factory):
+        """
+        Verify trades are correctly reset based on effective and target portfolios.
+        """
+        effective_date = trade_proposal.last_effective_date
+
+        # Create instruments for testing
+        i1 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
+        i2 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
+        i3 = instrument_factory.create(currency=trade_proposal.portfolio.currency)
+
+        # Build initial effective portfolio constituting only from two positions of i1 and i2
+        asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i1, weighting=Decimal("0.7")
+        )
+        asset_position_factory.create(
+            portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i2, weighting=Decimal("0.3")
+        )
+
+        # 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")),
+            )
+        )
+
+        # Reset trades
+        trade_proposal.reset_trades(target_portfolio=target_portfolio)
+
+        # Get trades for each instrument
+        t1 = trade_proposal.trades.get(underlying_instrument=i1)
+        t2 = trade_proposal.trades.get(underlying_instrument=i2)
+        t3 = trade_proposal.trades.get(underlying_instrument=i3)
+
+        # Assert trade weights are correctly reset
+        assert t1.weighting == Decimal("-0.7")
+        assert t2.weighting == Decimal("0.1")
+        assert t3.weighting == Decimal("0.6")
+
+    # Test replaying trade proposals
+    @patch.object(Portfolio, "batch_portfolio")
+    def test_replay(self, mock_fct, trade_proposal_factory):
+        """
+        Ensure replaying trade proposals correctly calls batch_portfolio for each period.
+        """
+        mock_fct.return_value = None
+
+        # Create approved trade proposals for testing
+        tp0 = trade_proposal_factory.create(status=TradeProposal.Status.APPROVED)
+        tp1 = trade_proposal_factory.create(
+            portfolio=tp0.portfolio,
+            status=TradeProposal.Status.APPROVED,
+            trade_date=(tp0.trade_date + MonthEnd(1)).date(),
+        )
+        tp2 = trade_proposal_factory.create(
+            portfolio=tp0.portfolio,
+            status=TradeProposal.Status.APPROVED,
+            trade_date=(tp1.trade_date + MonthEnd(1)).date(),
+        )
+
+        # Replay trade proposals
+        tp0.replay()
+
+        # Expected calls to batch_portfolio
+        expected_calls = [
+            call(tp0.trade_date, tp1.trade_date - timedelta(days=1)),
+            call(tp1.trade_date, tp2.trade_date - timedelta(days=1)),
+            call(tp2.trade_date, date.today()),
+        ]
+
+        # Assert batch_portfolio was called as expected
+        mock_fct.assert_has_calls(expected_calls)
+
+        # Test stopping replay on a non-approved proposal
+        tp1.status = TradeProposal.Status.FAILED
+        tp1.save()
+        expected_calls = [call(tp0.trade_date, tp1.trade_date - timedelta(days=1))]
+        mock_fct.assert_has_calls(expected_calls)
+
+    # Test estimating shares for a trade
+    @patch.object(Portfolio, "get_total_asset_value")
+    def test_get_estimated_shares(
+        self, mock_fct, trade_proposal, trade_factory, instrument_price_factory, instrument_factory
+    ):
+        """
+        Verify shares estimation based on trade weighting and instrument price.
+        """
+        portfolio = trade_proposal.portfolio
+        instrument = instrument_factory.create(currency=portfolio.currency)
+        trade = trade_factory.create(
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=portfolio,
+            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)
+            == 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):
+        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
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=trade_proposal.portfolio,
+            weighting=Decimal("0.7"),
+        )
+        trade_factory.create(  # cash trade
+            trade_proposal=trade_proposal,
+            transaction_date=trade_proposal.trade_date,
+            portfolio=trade_proposal.portfolio,
+            underlying_instrument=cash,
+            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")

wbportfolio/tests/models/transactions/test_trades.py

@@ -3,6 +3,7 @@ from decimal import Decimal
 
 import pytest
 from faker import Faker
+from pandas._libs.tslibs.offsets import BDay
 
 from wbportfolio.models import Product, Trade
 
@@ -203,3 +204,16 @@ class TestTradeInstrumentPrice:
         subscription_trade1.refresh_from_db()
         assert subscription_trade1.internal_trade == internal_trade
         assert subscription_trade1.marked_as_internal is True
+
+    def test_last_underlying_quote_price(self, weekday, trade_factory, instrument_price_factory):
+        trade = trade_factory.create(transaction_date=weekday, value_date=(weekday - BDay(1)).date())
+        assert trade.last_underlying_quote_price is None
+        del trade.last_underlying_quote_price
+
+        # test that underlying quote price returns any price found at transaction_date, or then at value_date (in that order)
+        p0 = instrument_price_factory.create(instrument=trade.underlying_instrument, date=trade.value_date)
+        assert trade.last_underlying_quote_price == p0
+        del trade.last_underlying_quote_price
+
+        p1 = instrument_price_factory.create(instrument=trade.underlying_instrument, date=trade.transaction_date)
+        assert trade.last_underlying_quote_price == p1

wbportfolio/tests/signals.py

@@ -2,10 +2,10 @@ from django.dispatch import receiver
 from wbcore.contrib.currency.factories import CurrencyFXRatesFactory
 from wbcore.contrib.directory.factories import CompanyFactory
 from wbcore.test.signals import custom_update_kwargs, get_custom_factory
+from wbfdm.factories import InstrumentPriceFactory
 
 from wbportfolio.factories import (
     CustomerTradeFactory,
-    InstrumentPriceFactory,
     ProductFactory,
     ProductPortfolioRoleFactory,
     TradeProposalFactory,