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

wbportfolio/factories/orders/orders.py

@@ -1,8 +1,8 @@
-import random
 from decimal import Decimal
 
 import factory
 from faker import Faker
+from wbfdm.factories import InstrumentPriceFactory
 
 from wbportfolio.models import Order
 
@@ -18,4 +18,12 @@ class OrderFactory(factory.django.DjangoModelFactory):
     fees = Decimal(0.0)
     underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
     shares = factory.Faker("pydecimal", min_value=10, max_value=1000, right_digits=4)
-    price = factory.LazyAttribute(lambda o: random.randint(10, 10000))
+
+    @factory.post_generation
+    def create_price(self, create, extracted, **kwargs):
+        if create:
+            p = InstrumentPriceFactory.create(
+                instrument=self.underlying_instrument, date=self.value_date, calculated=False
+            )
+            self.price = p.net_value
+            self.save()

wbportfolio/filters/assets.py

@@ -400,8 +400,8 @@ class DistributionFilter(wb_filters.FilterSet):
 
     group_by = wb_filters.ChoiceFilter(
         label="Group By",
-        choices=AssetPositionGroupBy.choices(),
-        initial=AssetPositionGroupBy.INDUSTRY.name,
+        choices=AssetPositionGroupBy.choices,
+        initial=AssetPositionGroupBy.INDUSTRY.value,
         method="fake_filter",
         clearable=False,
         required=True,
@@ -427,6 +427,14 @@ class DistributionFilter(wb_filters.FilterSet):
         endpoint=ClassificationGroup.get_representation_endpoint(),
         value_key=ClassificationGroup.get_representation_value_key(),
         label_key=ClassificationGroup.get_representation_label_key(),
+        depends_on=[{"field": "group_by", "options": {"activates_on": [AssetPositionGroupBy.INDUSTRY.value]}}],
+    )
+
+    group_by_classification_height = wb_filters.NumberFilter(
+        method="fake_filter",
+        label="Classification Height",
+        initial=0,
+        depends_on=[{"field": "group_by", "options": {"activates_on": [AssetPositionGroupBy.INDUSTRY.value]}}],
     )
 
     class Meta:

wbportfolio/import_export/handlers/orders.py

@@ -32,7 +32,7 @@ class OrderImportHandler(ImportExportHandler):
         self.order_proposal = OrderProposal.objects.get(id=data.pop("order_proposal_id"))
         weighting = data.get("target_weight", data.get("weighting"))
         shares = data.get("target_shares", data.get("shares", 0))
-        if not weighting:
+        if weighting is None:
             raise DeserializationError("We couldn't figure out the target weight column")
         position_dto = Position(
             underlying_instrument=underlying_instrument.id,

wbportfolio/migrations/0086_orderproposal_total_cash_weight.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.14 on 2025-08-04 09:30
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0085_order_desired_target_weight'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='orderproposal',
+            name='total_cash_weight',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0'), help_text='The desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.', max_digits=5, verbose_name='Total Cash Weight'),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -30,7 +30,6 @@ from pandas._libs.tslibs.offsets import BDay
 from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
 from wbcore.signals import pre_merge
-from wbcore.utils.enum import ChoiceEnum
 from wbfdm.models import Classification, ClassificationGroup, Instrument
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import add_instrument_to_investable_universe
@@ -223,25 +222,12 @@ class AnalyticalAssetPositionManager(DefaultAssetPositionManager):
         )
 
 
-class AssetPositionGroupBy(ChoiceEnum):
-    INDUSTRY = "Industry"
-    COUNTRY = "Country"
-    CURRENCY = "Currency"
-    CASH = "Cash"
-    MARKET_CAPITALIZATION = "Market Cap"
-    LIQUIDITY = "Liquidity"
-
-    @classmethod
-    def get_class_method_group_by(cls, name: str):
-        _map = {
-            "INDUSTRY": "industry",
-            "COUNTRY": AssetPosition.country_group_by,
-            "CURRENCY": AssetPosition.currency_group_by,
-            "CASH": AssetPosition.cash_group_by,
-            "MARKET_CAPITALIZATION": AssetPosition.marketcap_group_by,
-            "LIQUIDITY": AssetPosition.liquidity_group_by,
-        }
-        return _map[name]
+class AssetPositionGroupBy(models.TextChoices):
+    INDUSTRY = "classification", "Industry"
+    INSTRUMENT_TYPE = "instrument_type", "Type"
+    COUNTRY = "country", "Country"
+    CURRENCY = "currency", "Currency"
+    CASH = "is_cash", "Cash"
 
 
 class AssetPosition(ImportMixin, models.Model):

wbportfolio/models/builder.py

@@ -94,7 +94,6 @@ class AssetPositionBuilder:
         val_date: date,
         instrument_id: int,
         weighting: float,
-        infer_underlying_quote_price: bool = False,
         **kwargs,
     ) -> "AssetPosition":
         underlying_quote = self._get_instrument(instrument_id)
@@ -119,9 +118,6 @@ class AssetPositionBuilder:
         )
         parameters.update(kwargs)
         position = AssetPosition(**parameters)
-        position.pre_save(
-            infer_underlying_quote_price=infer_underlying_quote_price
-        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
         return position
 
     def set_return(self, returns: pd.DataFrame):
@@ -151,8 +147,10 @@ class AssetPositionBuilder:
             positions = [(val_date, i, w) for i, w in positions[1].items()]  # unflatten data to make it iterable
         for position in positions:
             if not isinstance(position, AssetPosition):
-                position = self._dict_to_model(*position, infer_underlying_quote_price=infer_underlying_quote_price)
-
+                position = self._dict_to_model(*position)
+            position.pre_save(
+                infer_underlying_quote_price=infer_underlying_quote_price
+            )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
             # Generate unique composite key
             key = (
                 position.underlying_quote.id,

wbportfolio/models/orders/order_proposals.py

@@ -81,6 +81,13 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     min_order_value = models.IntegerField(
         default=0, verbose_name="Minimum Order Value", help_text="Minimum Order Value in the Portfolio currency"
     )
+    total_cash_weight = models.DecimalField(
+        default=Decimal("0"),
+        decimal_places=4,
+        max_digits=5,
+        verbose_name="Total Cash Weight",
+        help_text="The desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
+    )
 
     class Meta:
         verbose_name = "Order Proposal"
@@ -162,6 +169,10 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             currency=self.portfolio.currency, defaults={"is_cash": True, "name": self.portfolio.currency.title}
         )[0]
 
+    @property
+    def total_expected_target_weight(self) -> Decimal:
+        return Decimal("1") - self.total_cash_weight
+
     def get_orders(self):
         base_qs = self.orders.all().annotate(
             last_effective_date=Subquery(
@@ -236,7 +247,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def __str__(self) -> str:
         return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
 
-    def convert_to_portfolio(self, use_effective: bool = False, with_cash: bool = True) -> PortfolioDTO:
+    def convert_to_portfolio(
+        self, use_effective: bool = False, with_cash: bool = True, use_desired_target_weight: bool = False
+    ) -> PortfolioDTO:
         """
         Data Transfer Object
         Returns:
@@ -252,9 +265,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 currency_fx_rate=asset._currency_fx_rate,
             )
         for order in self.get_orders():
+            previous_weight = order._previous_weight
+            if use_desired_target_weight and order.desired_target_weight is not None:
+                delta_weight = order.desired_target_weight - previous_weight
+            else:
+                delta_weight = order.weighting
             portfolio[order.underlying_instrument] = dict(
-                weighting=order._previous_weight,
-                delta_weight=order.weighting,
+                weighting=previous_weight,
+                delta_weight=delta_weight,
                 shares=order._target_shares if not use_effective else order._effective_shares,
                 price=order.price,
                 currency_fx_rate=order.currency_fx_rate,
@@ -272,6 +290,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         for instrument, row in portfolio.items():
             weighting = row["weighting"]
             daily_return = Decimal(last_returns.get(instrument.id, 0))
+
             if not use_effective:
                 drifted_weight = (
                     round(
@@ -297,7 +316,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 )
             )
             total_weighting += weighting
-        if portfolio and with_cash and (cash_weight := Decimal("1") - total_weighting):
+        if portfolio and with_cash and total_weighting and (cash_weight := Decimal("1") - total_weighting):
             cash_position = self.get_estimated_target_cash(target_cash_weight=cash_weight)
             positions.append(cash_position._build_dto())
         return PortfolioDTO(positions)
@@ -332,7 +351,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return order_proposal_clone
 
-    def normalize_orders(self, total_target_weight: Decimal = Decimal("1.0")):
+    def normalize_orders(self):
         """
         Call the trading service with the existing orders and normalize them in order to obtain a total sum target weight of 100%
         The existing order will be modified directly with the given normalization factor
@@ -341,7 +360,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             self.trade_date,
             effective_portfolio=self._get_default_effective_portfolio(),
             target_portfolio=self.convert_to_portfolio(use_effective=False, with_cash=False),
-            total_target_weight=total_target_weight,
+            total_target_weight=self.total_expected_target_weight,
         )
         leftovers_orders = self.orders.all()
         for underlying_instrument_id, order_dto in service.trades_batch.trades_map.items():
@@ -351,14 +370,18 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 order.save()
                 leftovers_orders = leftovers_orders.exclude(id=order.id)
         leftovers_orders.delete()
-        t_weight = self.get_orders().aggregate(models.Sum("target_weight"))["target_weight__sum"] or Decimal("0.0")
-        # we handle quantization error due to the decimal max digits. In that case, we take the biggest order (highest weight) and we remove the quantization error
-        if quantize_error := (t_weight - total_target_weight):
-            biggest_order = self.orders.latest("weighting")
-            biggest_order.weighting -= quantize_error
-            biggest_order.save()
-
-    def _get_default_target_portfolio(self, **kwargs) -> PortfolioDTO:
+        self.fix_quantization()
+
+    def fix_quantization(self):
+        if self.orders.exists():
+            t_weight = self.get_orders().aggregate(models.Sum("target_weight"))["target_weight__sum"] or Decimal("0.0")
+            # we handle quantization error due to the decimal max digits. In that case, we take the biggest order (highest weight) and we remove the quantization error
+            if quantize_error := (t_weight - self.total_expected_target_weight):
+                biggest_order = self.orders.latest("weighting")
+                biggest_order.weighting -= quantize_error
+                biggest_order.save()
+
+    def _get_default_target_portfolio(self, use_desired_target_weight: bool = False, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
             params = {}
             if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
@@ -367,7 +390,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             return self.rebalancing_model.get_target_portfolio(
                 self.portfolio, self.trade_date, self.value_date, **params
             )
-        return self.convert_to_portfolio(use_effective=False)
+        return self.convert_to_portfolio(use_effective=False, use_desired_target_weight=use_desired_target_weight)
 
     def _get_default_effective_portfolio(self):
         return self.convert_to_portfolio(use_effective=True)
@@ -377,7 +400,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         target_portfolio: PortfolioDTO | None = None,
         effective_portfolio: PortfolioRole | None = None,
         validate_order: bool = True,
-        total_target_weight: Decimal = Decimal("1.0"),
+        use_desired_target_weight: bool = False,
     ):
         """
         Will delete all existing orders and recreate them from the method `create_or_update_trades`
@@ -387,7 +410,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         # delete all existing orders
         # Get effective and target portfolio
         if not target_portfolio:
-            target_portfolio = self._get_default_target_portfolio()
+            target_portfolio = self._get_default_target_portfolio(use_desired_target_weight=use_desired_target_weight)
         if not effective_portfolio:
             effective_portfolio = self._get_default_effective_portfolio()
         if target_portfolio:
@@ -395,13 +418,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 self.trade_date,
                 effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
-                total_target_weight=total_target_weight,
+                total_target_weight=self.total_expected_target_weight,
             )
             if validate_order:
                 service.is_valid()
                 orders = service.validated_trades
             else:
                 orders = service.trades_batch.trades_map.values()
+
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
                 currency_fx_rate = instrument.currency.convert(
@@ -425,7 +449,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         currency_fx_rate=currency_fx_rate,
                     )
                 order.price = order.get_price()
-                order.order_type = Order.get_type(weighting, order_dto.previous_weight, order_dto.target_weight)
                 # if we cannot automatically find a price, we consider the stock is invalid and we sell it
                 if not order.price:
                     order.price = Decimal("0.0")
@@ -435,6 +458,12 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         # final sanity check to make sure invalid order with effective and target weight of 0 are automatically removed:
         self.get_orders().filter(target_weight=0, effective_weight=0).delete()
 
+        self.fix_quantization()
+
+        for order in self.get_orders():
+            order.order_type = Order.get_type(weighting, order_dto.previous_weight, order_dto.target_weight)
+            order.save()
+
     def approve_workflow(
         self,
         approve_automatically: bool = True,
@@ -647,13 +676,16 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def submit(self, by=None, description=None, **kwargs):
         orders = []
         orders_validation_warnings = []
-        for order in self.get_orders():
+        qs = self.get_orders()
+        total_target_weight = Decimal("0")
+        for order in qs:
             order_warnings = order.submit(
                 by=by, description=description, portfolio_total_asset_value=self.portfolio_total_asset_value, **kwargs
             )
             if order_warnings:
                 orders_validation_warnings.extend(order_warnings)
             orders.append(order)
+            total_target_weight += order._target_weight
 
         Order.objects.bulk_update(orders, ["shares", "weighting", "desired_target_weight"])
 
@@ -663,6 +695,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             estimated_cash_position._build_dto()
         )
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
+        self.total_cash_weight = Decimal("1") - total_target_weight
         return orders_validation_warnings
 
     def can_submit(self):

wbportfolio/models/orders/orders.py

@@ -205,7 +205,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             if estimated_shares:
                 self.shares = estimated_shares
         if self.id:
-            self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+            self.set_type()
         super().save(*args, **kwargs)
 
     @classmethod
@@ -224,6 +224,9 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 else:
                     return Order.Type.SELL
 
+    def set_type(self):
+        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+
     def get_price(self) -> Decimal:
         try:
             return self.underlying_instrument.get_price(self.value_date)

wbportfolio/models/portfolio.py

@@ -935,6 +935,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
             self.builder.add(
                 list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
+                infer_underlying_quote_price=True,
             )
         self.builder.bulk_create_positions(delete_leftovers=True)
         self.builder.schedule_change_at_dates(evaluate_rebalancer=False)

wbportfolio/models/products.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 
 from celery import shared_task
 from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.postgres.constraints import ExclusionConstraint
 from django.contrib.postgres.fields import DateRangeField, RangeOperators
 from django.db import models
@@ -33,6 +34,7 @@ from wbcore.utils.enum import ChoiceEnum
 from wbcrm.models.accounts import Account
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.models.instruments.instruments import InstrumentManager, InstrumentType
+from wbreport.models import Report
 
 from wbportfolio.models.portfolio_relationship import InstrumentPortfolioThroughModel
 
@@ -198,6 +200,8 @@ class FeeProductPercentage(models.Model):
 
 
 class Product(PMSInstrumentAbstractModel):
+    reports = GenericRelation(Report)
+
     share_price = models.PositiveIntegerField(
         default=100,
         verbose_name="Share Price",
@@ -344,6 +348,11 @@ class Product(PMSInstrumentAbstractModel):
 
         self.is_managed = True
 
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.delisted_date and self.delisted_date <= date.today():
+            self.reports.update(is_active=False)
+
     def get_title(self):
         if self.parent:
             return f"{self.parent.name} ({self.name})"

wbportfolio/pms/trading/handler.py

@@ -87,7 +87,6 @@ class TradingService:
             total_target_weight
         )
         self._effective_portfolio = effective_portfolio
-        self._target_portfolio = target_portfolio
 
     @property
     def errors(self) -> list[str]:

wbportfolio/serializers/orders/order_proposals.py

@@ -1,5 +1,3 @@
-from decimal import Decimal
-
 from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
@@ -26,25 +24,12 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
         queryset=Portfolio.objects.all(), write_only=True, required=False
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
-    total_cash_weight = wb_serializers.DecimalField(
-        default=0,
-        decimal_places=4,
-        max_digits=5,
-        write_only=True,
-        required=False,
-        precision=4,
-        percent=True,
-        label="Target Cash",
-        help_text="Enter the desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
-    )
-
     trade_date = wb_serializers.DateField(
         read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
     )
 
     def create(self, validated_data):
         target_portfolio = validated_data.pop("target_portfolio", None)
-        total_cash_weight = validated_data.pop("total_cash_weight", Decimal("0.0"))
         rebalancing_model = validated_data.get("rebalancing_model", None)
         if request := self.context.get("request"):
             validated_data["creator"] = request.user.profile
@@ -59,9 +44,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
             )
 
         try:
-            obj.reset_orders(
-                target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight
-            )
+            obj.reset_orders(target_portfolio=target_portfolio_dto)
         except ValidationError as e:
             if request := self.context.get("request"):
                 warning(request, str(e), extra_tags="auto_close=0")
@@ -86,6 +69,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     class Meta:
         model = OrderProposal
         only_fsm_transition_on_instance = True
+        percent_fields = ["total_cash_weight"]
         fields = (
             "id",
             "trade_date",

wbportfolio/tests/conftest.py

@@ -70,7 +70,7 @@ from wbportfolio.factories import (
     RebalancerFactory,
     RebalancingModelFactory
 )
-
+from wbreport.factories import ReportFactory, ReportAssetFactory, ReportVersionFactory, ReportClassFactory, ReportCategoryFactory
 from wbcore.tests.conftest import *  # isort:skip
 
 register(AccountFactory)
@@ -147,7 +147,11 @@ register(DailyPortfolioCashFlowFactory)
 
 register(AccountReconciliationFactory)
 register(AccountReconciliationLineFactory)
-
+register(ReportFactory)
+register(ReportAssetFactory)
+register(ReportVersionFactory)
+register(ReportClassFactory)
+register(ReportCategoryFactory)
 
 pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbportfolio"))
 from .signals import *  # noqa: F401

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):
@@ -361,15 +367,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"
@@ -687,3 +690,46 @@ 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.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"

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/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()