wbportfolio 1.54.22__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 from unittest.mock import call, patch
 
 import pytest
+from django.db.models import Sum
 from faker import Faker
 from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
@@ -50,31 +51,36 @@ class TestOrderProposal:
         )
 
         # Create orders for testing
-        t1 = order_factory.create(
+        o1 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("0.05"),
             portfolio=order_proposal.portfolio,
             underlying_instrument=a1.underlying_quote,
         )
-        t2 = order_factory.create(
+        o2 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("-0.05"),
             portfolio=order_proposal.portfolio,
             underlying_instrument=a2.underlying_quote,
         )
 
+        r1 = o1.price / a1.initial_price - Decimal("1")
+        r2 = o2.price / a2.initial_price - Decimal("1")
+        p_return = a1.weighting * (Decimal("1") + r1) + a2.weighting * (Decimal("1") + r2)
         # Get the validated trading service
-        validated_trading_service = order_proposal.validated_trading_service
+        trades = order_proposal.validated_trading_service.trades_batch.trades_map
+        t1 = trades[a1.underlying_quote.id]
+        t2 = trades[a2.underlying_quote.id]
 
         # 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,
-        }
+        assert t1.previous_weight == a1.weighting
+        assert t2.previous_weight == a2.weighting
+        assert t1.target_weight == pytest.approx(
+            a1.weighting * ((r1 + Decimal("1")) / p_return) + o1.weighting, abs=Decimal("1e-8")
+        )
+        assert t2.target_weight == pytest.approx(
+            a2.weighting * ((r2 + Decimal("1")) / p_return) + o2.weighting, abs=Decimal("1e-8")
+        )
 
     # Test the calculation of the last effective date
     def test_last_effective_date(self, order_proposal, asset_position_factory):
@@ -112,13 +118,13 @@ class TestOrderProposal:
         """
         tp = order_proposal_factory.create()
         tp_previous_submit = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date - BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_previous_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(2)).date()
         )
         tp_next_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(1)).date()
         )
 
         # The previous valid order proposal should be the approved one strictly before the current proposal
@@ -133,13 +139,13 @@ class TestOrderProposal:
         """
         tp = order_proposal_factory.create()
         tp_previous_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_next_submit = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date + BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date + BDay(1)).date()
         )
         tp_next_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(2)).date()
         )
 
         # The next valid order proposal should be the approved one strictly after the current proposal
@@ -249,11 +255,12 @@ class TestOrderProposal:
 
     # Test resetting orders
     def test_reset_orders(
-        self, order_proposal, instrument_factory, cash, instrument_price_factory, asset_position_factory
+        self, order_proposal, instrument_factory, cash_factory, instrument_price_factory, asset_position_factory
     ):
         """
         Verify orders are correctly reset based on effective and target portfolios.
         """
+        cash = cash_factory.create()
         effective_date = order_proposal.last_effective_date
 
         # Create instruments for testing
@@ -361,15 +368,12 @@ class TestOrderProposal:
         assert order_proposal.orders.get(underlying_instrument=i2).weighting == Decimal("-0.3")
         assert order_proposal.orders.get(underlying_instrument=cash).weighting == Decimal("0.5")
 
-    def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory, instrument_price_factory):
+    def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory):
         # create a invalid trade and its price
         invalid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(0))
-        instrument_price_factory.create(date=invalid_trade.value_date, instrument=invalid_trade.underlying_instrument)
 
         # create a valid trade and its price
         valid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(1))
-        instrument_price_factory.create(date=valid_trade.value_date, instrument=valid_trade.underlying_instrument)
-
         order_proposal.reset_orders()
         assert order_proposal.orders.get(underlying_instrument=valid_trade.underlying_instrument).weighting == Decimal(
             "1"
@@ -386,15 +390,15 @@ class TestOrderProposal:
         mock_fct.return_value = iter([])
 
         # Create approved order proposals for testing
-        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPROVED)
+        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPLIED)
         tp1 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPLIED,
             trade_date=(tp0.trade_date + BusinessMonthEnd(1)).date(),
         )
         tp2 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPLIED,
             trade_date=(tp1.trade_date + BusinessMonthEnd(1)).date(),
         )
 
@@ -496,9 +500,10 @@ class TestOrderProposal:
         instrument.exchange.save()
         assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument):
+    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
+        instrument = instrument_factory.create()
         instrument.round_lot_size = 100
         instrument.save()
         trade = order_factory.create(
@@ -515,11 +520,10 @@ class TestOrderProposal:
         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, order_proposal, order_factory, instrument):
+    def test_submit_round_fractional_shares(self, order_proposal, order_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
         trade = order_factory.create(
-            underlying_instrument=instrument,
             shares=5.6,
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
@@ -637,6 +641,7 @@ class TestOrderProposal:
         order_proposal.submit()
         order_proposal.save()
         order_proposal.approve()
+        order_proposal.apply()
         order_proposal.save()
 
         # Final check that weights have been updated to 50%
@@ -648,8 +653,9 @@ class TestOrderProposal:
         )
 
     def test_replay_reset_draft_order_proposal(
-        self, instrument, instrument_price_factory, order_factory, order_proposal_factory
+        self, instrument_factory, instrument_price_factory, order_factory, order_proposal_factory
     ):
+        instrument = instrument_factory.create()
         order_proposal = order_proposal_factory.create(trade_date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(1))
@@ -660,7 +666,8 @@ class TestOrderProposal:
             weighting=1,
         )
         order_proposal.submit()
-        order_proposal.approve(replay=False)
+        order_proposal.approve()
+        order_proposal.apply(replay=False)
         order_proposal.save()
 
         draft_tp = order_proposal_factory.create(portfolio=order_proposal.portfolio, trade_date=date.today() - BDay(1))
@@ -687,3 +694,56 @@ class TestOrderProposal:
         order.save()
         assert order.shares == Decimal(0)
         assert order.weighting == Decimal(0)
+
+    def test_reset_order_use_desired_target_weight(self, order_proposal, order_factory):
+        order1 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.7")
+        )
+        order2 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.3")
+        )
+        order_proposal.submit()
+        order_proposal.approve()
+        order_proposal.apply()
+        order_proposal.save()
+
+        order1.refresh_from_db()
+        order2.refresh_from_db()
+        assert order1.desired_target_weight == Decimal("0.5")
+        assert order2.desired_target_weight == Decimal("0.5")
+        assert order1.weighting == Decimal("0.5")
+        assert order2.weighting == Decimal("0.5")
+
+        order1.desired_target_weight = Decimal("0.7")
+        order2.desired_target_weight = Decimal("0.3")
+        order1.save()
+        order2.save()
+
+        order_proposal.reset_orders(use_desired_target_weight=True)
+        order1.refresh_from_db()
+        order2.refresh_from_db()
+        assert order1.weighting == Decimal("0.7")
+        assert order2.weighting == Decimal("0.3")
+
+    def test_reset_order_proposal_keeps_target_cash_weight(self, order_factory, order_proposal_factory):
+        order_proposal = order_proposal_factory.create(
+            total_cash_weight=Decimal("0.02")
+        )  # create a OP with total cash weight of 2%
+
+        # create orders that total weight account for only 50%
+        order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.3"))
+        order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.2"))
+
+        order_proposal.reset_orders()
+        assert order_proposal.get_orders().aggregate(s=Sum("target_weight"))["s"] == Decimal(
+            "0.98"
+        ), "The total target weight leftover does not equal the stored total cash weight"
+
+    def test_convert_to_portfolio_always_100percent(self, order_proposal, order_factory):
+        o1 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.5"))
+        o2 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.3"))
+
+        portfolio = order_proposal.convert_to_portfolio()
+        assert portfolio.positions_map[o1.underlying_instrument.id].weighting == Decimal("0.5")
+        assert portfolio.positions_map[o2.underlying_instrument.id].weighting == Decimal("0.3")
+        assert portfolio.positions_map[order_proposal.cash_component.id].weighting == Decimal("0.2")

wbportfolio/tests/models/test_imports.py

@@ -137,7 +137,9 @@ class TestImportMixinModel:
         data = {
             "data": [
                 self._serialize_position(
-                    asset_position_factory.build(date=val_date, underlying_instrument=instrument),
+                    asset_position_factory.build(
+                        date=val_date, underlying_instrument=instrument, weighting=Decimal("0.25")
+                    ),
                     product_portfolio,
                     instrument,
                 )
@@ -171,7 +173,7 @@ class TestImportMixinModel:
     def test_import_assetposition_product_group(
         self, import_source, product_group, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         data = {"data": [self._serialize_position(positions, product_group, equity)]}
 
         # Import non existing data
@@ -183,7 +185,7 @@ class TestImportMixinModel:
     def test_import_assetposition_index(
         self, import_source, index, portfolio, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         index.portfolios.add(portfolio)
         data = {"data": [self._serialize_position(positions, index, equity)]}
 

wbportfolio/tests/models/test_portfolios.py

@@ -10,6 +10,7 @@ from django.forms.models import model_to_dict
 from faker import Faker
 from pandas.tseries.offsets import BDay
 from psycopg.types.range import DateRange
+from wbcore.contrib.currency.factories import CurrencyFactory
 from wbcore.contrib.geography.factories import CountryFactory
 
 from wbportfolio.models import (
@@ -106,11 +107,10 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         assert portfolio.get_geographical_breakdown(weekday).shape[0] == 2
 
-    def test_get_currency_exposure(self, portfolio, asset_position_factory, currency_factory, equity_factory, weekday):
+    def test_get_currency_exposure(self, portfolio, asset_position_factory, equity_factory, weekday):
         a1 = asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         asset_position_factory.create(
@@ -118,8 +118,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         assert portfolio.get_currency_exposure(weekday).shape[0] == 2
@@ -253,14 +252,14 @@ class TestPortfolioModel(PortfolioTestMixin):
 
     @patch.object(Portfolio, "estimate_net_asset_values", autospec=True)
     def test_change_at_date(self, mock_estimate_net_asset_values, asset_position_factory, portfolio, weekday):
-        asset_position_factory.create_batch(10, portfolio=portfolio, date=weekday)
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.1"))
+        a2 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.3"))
+        a3 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.5"))
 
-        portfolio.change_at_date(weekday, recompute_weighting=True)
+        portfolio.change_at_date(weekday, fix_quantization=True)
 
-        # test that change at date normalize the weighting
-        total_value = AssetPosition.objects.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
-        for pos in AssetPosition.objects.all():
-            assert float(pos.weighting) == pytest.approx(float(pos.total_value_fx_portfolio / total_value), rel=1e-2)
+        cash_pos = portfolio.assets.get(date=weekday, portfolio=portfolio, underlying_quote=portfolio.cash_component)
+        assert cash_pos.weighting == Decimal("1.0") - (a1.weighting + a2.weighting + a3.weighting)
 
         mock_estimate_net_asset_values.assert_called_once_with(
             portfolio, (weekday + BDay(1)).date(), analytic_portfolio=None
@@ -530,8 +529,9 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert res1
 
     def test_get_total_asset_under_management(
-        self, portfolio, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
+        self, portfolio_factory, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
     ):
+        portfolio = portfolio_factory.create()
         i1 = instrument_factory.create()
         i2 = instrument_factory.create()
         previous_day = (weekday - BDay(5)).date()
@@ -1001,8 +1001,8 @@ class TestPortfolioModel(PortfolioTestMixin):
         fx_portfolio = currency_fx_rates_factory.create(currency=portfolio.currency, date=weekday)
         fx_instrument = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
         instrument_id: int = instrument.id
-        weights = {instrument_id: random.random()}
-        portfolio.builder.set_prices({weekday: {instrument_id: p.net_value}})
+        weights = {instrument_id: Decimal(random.random())}
+        portfolio.builder.prices = {weekday: {instrument_id: p.net_value}}
         portfolio.builder.add((weekday, weights), infer_underlying_quote_price=False)
 
         res = list(portfolio.builder.get_positions())
@@ -1012,7 +1012,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert a.underlying_quote == instrument
         assert a.underlying_quote_price == None
         assert a.initial_price == p.net_value
-        assert a.weighting == pytest.approx(weights[instrument.id], abs=10e-6)
+        assert a.weighting == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
         assert a.currency_fx_rate_instrument_to_usd == fx_instrument
 
@@ -1057,7 +1057,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         except StopIteration as e:
             rebalancing_order_proposal = e.value
             assert rebalancing_order_proposal.trade_date == rebalancing_date
-            assert rebalancing_order_proposal.status == "SUBMIT"
+            assert rebalancing_order_proposal.status == "APPROVED"
 
             # we expect a equally rebalancing (default) so both orders needs to be created
             orders = rebalancing_order_proposal.get_orders()
@@ -1067,8 +1067,8 @@ class TestPortfolioModel(PortfolioTestMixin):
             assert t2._target_weight == Decimal("0.5")
 
             # we approve the rebalancing order proposal
-            assert rebalancing_order_proposal.status == "SUBMIT"
-            rebalancing_order_proposal.approve(replay=False)
+            assert rebalancing_order_proposal.status == "APPROVED"
+            rebalancing_order_proposal.apply(replay=False)
             rebalancing_order_proposal.save()
 
         # check that the rebalancing was applied and position reflect that
@@ -1084,17 +1084,17 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i1)
 
         # check initial creation
-        portfolio.builder.add([a1]).bulk_create_positions(compute_metrics=True)
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False, compute_metrics=True)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a1.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i1
 
-        # check that if we change key value, an already exising position will be updated accordingly
+        # check that if we change key value, an already existing position will be updated accordingly
         a1.weighting = Decimal(0.5)
-        portfolio.builder.add([a1]).bulk_create_positions()
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == Decimal(0.5)
 
         a2 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i2)
-        portfolio.builder.add([a2]).bulk_create_positions()
+        portfolio.builder.add([a2]).bulk_create_positions(fix_quantization=False)
         assert (
             AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i1).weighting
             == a1.weighting
@@ -1105,7 +1105,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
 
         a3 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i3)
-        portfolio.builder.add([a3]).bulk_create_positions(delete_leftovers=True)
+        portfolio.builder.add([a3]).bulk_create_positions(delete_leftovers=True, fix_quantization=False)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a3.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i3
 
@@ -1136,3 +1136,37 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         primary_portfolio.handle_controlling_portfolio_change_at_date(weekday)
         mock_compute_lookthrough.assert_called_once_with(lookthrough_portfolio, weekday)
+
+    def test_get_model_portfolio_relationships(self, portfolio_factory, asset_position_factory, weekday):
+        model_portfolio = portfolio_factory.create()
+        model_index = model_portfolio.get_or_create_index()
+        dependent_portfolio = portfolio_factory.create()
+        re1 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=dependent_portfolio,
+            dependency_portfolio=model_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }
+        parent_portfolio = portfolio_factory.create()
+        child_portfolio = portfolio_factory.create()
+        re2 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=child_portfolio,
+            dependency_portfolio=parent_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }  # child portfolio is not considered in the tree because there is no position yet
+
+        asset_position_factory.create(portfolio=parent_portfolio, underlying_instrument=model_index, date=weekday)
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {re1, re2}
+
+        dependent_portfolio.is_active = False  # disable this portfolio
+        dependent_portfolio.deletion_datetime = weekday - timedelta(days=1)
+        dependent_portfolio.save()
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re2,
+        }

wbportfolio/tests/models/test_products.py

@@ -215,3 +215,14 @@ class TestProductModel(PortfolioTestMixin):
             body=f"The product {product} will be terminated on the {product.delisted_date:%Y-%m-%d}",
             user=internal_user,
         )
+
+    def test_delist_product_disable_report(self, product, report_factory):
+        report = report_factory.create(content_object=product, is_active=True)
+        assert product.delisted_date is None
+        assert report.is_active
+
+        product.delisted_date = datetime.date.today()
+        product.save()
+
+        report.refresh_from_db()
+        assert report.is_active is False

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -47,7 +47,7 @@ class TestRebalancer:
     def test_evaluate_rebalancing(
         self, weekday, rebalancer_factory, asset_position_factory, instrument_factory, instrument_price_factory
     ):
-        rebalancer = rebalancer_factory.create(approve_order_proposal_automatically=True)
+        rebalancer = rebalancer_factory.create(apply_order_proposal_automatically=True)
         trade_date = (weekday + BDay(1)).date()
 
         i1 = instrument_factory.create()
@@ -65,7 +65,7 @@ class TestRebalancer:
         )
         order_proposal = rebalancer.evaluate_rebalancing(trade_date)
         assert order_proposal.orders.count() == 2
-        assert order_proposal.status == OrderProposal.Status.APPROVED
+        assert order_proposal.status == OrderProposal.Status.APPLIED
         assert AssetPosition.objects.get(
             portfolio=rebalancer.portfolio, date=trade_date, underlying_quote=a1.underlying_instrument
         ).weighting == Decimal(0.5)

wbportfolio/tests/rebalancing/test_models.py

@@ -56,9 +56,7 @@ class TestModelPortfolioRebalancing:
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
 
-        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)
+        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -84,7 +82,7 @@ class TestCompositeRebalancing:
         assert not model.is_valid()
 
         order_proposal = OrderProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPLIED
         )
         t1 = OrderFactory.create(
             portfolio=model.portfolio,
@@ -106,7 +104,7 @@ class TestCompositeRebalancing:
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
         order_proposal = OrderProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPLIED
         )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise

wbportfolio/tests/signals.py

@@ -17,8 +17,6 @@ from wbportfolio.viewsets import (
     ClaimEntryModelViewSet,
     CustodianDistributionInstrumentChartViewSet,
     CustomerDistributionInstrumentChartViewSet,
-    DistributionChartViewSet,
-    DistributionTableViewSet,
     NominalProductChartView,
     OrderOrderProposalModelViewSet,
     OrderProposalPortfolioModelViewSet,
@@ -96,14 +94,6 @@ def receive_kwargs_portfolio_role_instrument(sender, *args, **kwargs):
     return {}
 
 
-@receiver(custom_update_kwargs, sender=DistributionChartViewSet)
-@receiver(custom_update_kwargs, sender=DistributionTableViewSet)
-def receive_kwargs_distribution_chart_instrument_id(sender, *args, **kwargs):
-    if instrument_id := kwargs.get("underlying_instrument_id"):
-        return {"instrument_id": instrument_id}
-    return {}
-
-
 @receiver(custom_update_kwargs, sender=ProductPerformanceFeesModelViewSet)
 def receive_kwargs_product_performance_fees(sender, *args, **kwargs):
     CurrencyFXRatesFactory()

wbportfolio/tests/tests.py

@@ -19,6 +19,8 @@ for key, value in default_config.items():
                 "AccountReconciliationLine",
                 "TopDownPortfolioCompositionPandasAPIView",
                 "CompositionModelPortfolioPandasView",
+                "DistributionChartViewSet",
+                "DistributionTableViewSet",
                 # "ClaimModelViewSet",
                 # "ClaimModelSerializer",
             ],

wbportfolio/viewsets/__init__.py

@@ -2,12 +2,16 @@ from .assets import (
     AssetPositionInstrumentModelViewSet,
     AssetPositionModelViewSet,
     AssetPositionPortfolioModelViewSet,
-    AssetPositionUnderlyingInstrumentChartViewSet,
     CashPositionPortfolioPandasAPIView,
     CompositionModelPortfolioPandasView,
-    ContributorPortfolioChartView,
 )
-from .charts import *
+from .charts import (
+    DistributionChartViewSet,
+    DistributionTableViewSet,
+    AssetPositionUnderlyingInstrumentChartViewSet,
+    ContributorPortfolioChartView
+
+)
 from .custodians import CustodianModelViewSet, CustodianRepresentationViewSet
 from .portfolio_relationship import InstrumentPreferedClassificationThroughProductModelViewSet
 from .portfolios import (
@@ -23,7 +27,6 @@ from .positions import (
 )
 from .registers import RegisterModelViewSet, RegisterRepresentationViewSet
 from .roles import PortfolioRoleInstrumentModelViewSet, PortfolioRoleModelViewSet
-from .signals import *
 from .rebalancing import RebalancingModelRepresentationViewSet, RebalancerRepresentationViewSet, RebalancerModelViewSet
 from .transactions import *
 from .orders import *