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

wbportfolio/constants.py

@@ -0,0 +1 @@
+EQUITY_TYPE_KEYS = ["american_depository_receipt", "equity"]  # TODO might want to move this into a dynamic preference

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/import_export/parsers/vontobel/valuation_api.py

@@ -10,7 +10,10 @@ def parse(import_source):
     with suppress(KeyError):
         series_data = json.loads(import_source.file.read())["payload"]["series"]
         for series in series_data:
-            isin = series["item"]["priceIdentifier"]
+            try:
+                isin = series["key"]["priceIdentifier"]
+            except KeyError:
+                isin = series["priceIdentifier"]
             if Product.objects.filter(isin=isin).exists():  # ensure the timeseries contain data for products we handle
                 for point in series["points"]:
                     data.append(

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):
@@ -130,9 +126,9 @@ class AssetPositionBuilder:
     def set_prices(self, prices: dict[date, dict[int, float]] | None = None):
         self.prices = prices
 
-    def load_returns(self, instrument_ids: list[int], from_date: date, to_date: date):
+    def load_returns(self, instrument_ids: list[int], from_date: date, to_date: date, use_dl: bool = True):
         self.prices, self.returns = Instrument.objects.filter(id__in=instrument_ids).get_returns_df(
-            from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=True
+            from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=use_dl
         )
 
     def add(
@@ -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,
@@ -221,9 +219,11 @@ class AssetPositionBuilder:
 
             for val_date in self.get_dates():
                 if self.portfolio.is_tracked:
-                    with suppress(KeyError):
+                    try:
                         changed_portfolio = self._get_portfolio(val_date)
-                        self._change_at_date_tasks[val_date] = changed_portfolio
+                    except KeyError:
+                        changed_portfolio = None
+                    self._change_at_date_tasks[val_date] = changed_portfolio
                     self._compute_metrics_tasks.add(val_date)
         self._positions = defaultdict(dict)
 
@@ -237,7 +237,7 @@ class AssetPositionBuilder:
                     for d in self._compute_metrics_tasks
                 ]
             ).apply_async()
-            self._change_at_date_tasks = set()
+            self._change_at_date_tasks = dict()
 
     def schedule_change_at_dates(self, synchronous: bool = True, **task_kwargs):
         from wbportfolio.models.portfolio import trigger_portfolio_change_as_task

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

@@ -38,6 +38,7 @@ from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position as PositionDTO
 
+from ..constants import EQUITY_TYPE_KEYS
 from . import ProductGroup
 
 logger = logging.getLogger("pms")
@@ -337,8 +338,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             weights = self.get_weights(val_date)
         return_date = (val_date + BDay(1)).date()
         returns = self.builder.returns
-        if pd.Timestamp(return_date) not in returns.index or not set(weights.keys()).issubset(set(returns.columns)):
-            returns = self.load_builder_returns(val_date, return_date)
+        if (
+            return_date <= date.today()
+            and pd.Timestamp(return_date) not in returns.index
+            or not set(weights.keys()).issubset(set(returns.columns))
+        ):
+            returns = self.load_builder_returns(val_date, return_date, use_dl=use_dl)
         if pd.Timestamp(return_date) not in returns.index:
             raise ValueError()
         returns = returns.loc[:return_date, :]
@@ -507,7 +512,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             val_date=val_date,
             exclude_cash=True,
             exclude_index=True,
-            extra_filter_parameters={"underlying_instrument__instrument_type": InstrumentType.EQUITY},
+            extra_filter_parameters={"underlying_instrument__instrument_type__key__in": EQUITY_TYPE_KEYS},
             **kwargs,
         )
         if not df.empty:
@@ -520,7 +525,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             val_date=val_date,
             exclude_cash=True,
             exclude_index=True,
-            extra_filter_parameters={"underlying_instrument__instrument_type": InstrumentType.EQUITY},
+            extra_filter_parameters={"underlying_instrument__instrument_type__key__in": EQUITY_TYPE_KEYS},
             **kwargs,
         )
         if not df.empty:
@@ -592,7 +597,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     ) -> pd.DataFrame:
         qs = self._get_assets(with_cash=with_cash).filter(date__gte=start, date__lte=end)
         if only_equity:
-            qs = qs.filter(underlying_instrument__instrument_type=InstrumentType.EQUITY)
+            qs = qs.filter(underlying_instrument__instrument_type__key__in=EQUITY_TYPE_KEYS)
         qs = qs.annotate_hedged_currency_fx_rate(hedged_currency)
         df = Portfolio.get_contribution_df(
             qs.select_related("underlying_instrument").values_list(
@@ -725,7 +730,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         effective_portfolio_date = (val_date - BDay(1)).date()
         with suppress(ValueError):
             if not analytic_portfolio:
-                analytic_portfolio = self.get_analytic_portfolio(effective_portfolio_date)
+                analytic_portfolio = self.get_analytic_portfolio(effective_portfolio_date, use_dl=False)
             for instrument in self.pms_instruments:
                 # we assume that in t-1 we will have a portfolio (with at least estimate position). If we use the latest position date before val_date, we run into the problem of being able to compute nav at every date
                 last_price = instrument.get_latest_price(effective_portfolio_date)
@@ -839,11 +844,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             self.builder.schedule_change_at_dates(evaluate_rebalancer=False)
             self.builder.schedule_metric_computation()
 
-    def load_builder_returns(self, from_date: date, to_date: date) -> pd.DataFrame:
+    def load_builder_returns(self, from_date: date, to_date: date, use_dl: bool = True) -> pd.DataFrame:
         instruments_ids = list(self.get_weights(from_date).keys())
         for tp in self.order_proposals.filter(trade_date__gte=from_date, trade_date__lte=to_date, status="APPROVED"):
             instruments_ids.extend(tp.orders.values_list("underlying_instrument", flat=True))
-        self.builder.load_returns(set(instruments_ids), (from_date - BDay(1)).date(), (to_date + BDay(1)).date())
+        self.builder.load_returns(
+            set(instruments_ids), (from_date - BDay(1)).date(), (to_date + BDay(1)).date(), use_dl=use_dl
+        )
         return self.builder.returns
 
     def get_lookthrough_positions(
@@ -928,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