wbportfolio 1.47.1__py2.py3-none-any.whl → 1.49.0__py2.py3-none-any.whl

wbportfolio/models/transactions/trade_proposals.py

@@ -11,11 +11,13 @@ from django.utils.functional import cached_property
 from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
+from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
-from wbfdm.models.instruments.instruments import Instrument
+from wbcore.utils.models import CloneMixin
+from wbfdm.models.instruments.instruments import Cash, Instrument
 
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
@@ -30,7 +32,7 @@ logger = logging.getLogger("pms")
 SelfTradeProposal = TypeVar("SelfTradeProposal", bound="TradeProposal")
 
 
-class TradeProposal(RiskCheckMixin, WBModel):
+class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     trade_date = models.DateField(verbose_name="Trading Date")
 
     class Status(models.TextChoices):
@@ -76,17 +78,21 @@ class TradeProposal(RiskCheckMixin, WBModel):
     def save(self, *args, **kwargs):
         if not self.trade_date and self.portfolio.assets.exists():
             self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
-        if not self.rebalancing_model and (rebalancer := getattr(self.portfolio, "automatic_rebalancer", None)):
-            self.rebalancing_model = rebalancer.rebalancing_model
         super().save(*args, **kwargs)
         if self.status == TradeProposal.Status.APPROVED:
             self.portfolio.change_at_date(self.trade_date)
 
-    def _get_checked_object_field_name(self) -> str:
-        """
-        Mandatory function from the Riskcheck mixin that returns the field (aka portfolio), representing the object to check the rules against.
-        """
-        return "portfolio"
+    @property
+    def checked_object(self):
+        return self.portfolio
+
+    @property
+    def check_evaluation_date(self):
+        return self.trade_date
+
+    @cached_property
+    def portfolio_total_asset_value(self) -> Decimal:
+        return self.portfolio.get_total_asset_value(self.last_effective_date)
 
     @cached_property
     def validated_trading_service(self) -> TradingService:
@@ -95,8 +101,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
         """
         return TradingService(
             self.trade_date,
-            effective_portfolio=self.portfolio._build_dto(self.trade_date),
-            trades_batch=self._build_dto(),
+            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            target_portfolio=self._build_dto().convert_to_portfolio(),
         )
 
     @cached_property
@@ -149,12 +155,10 @@ class TradeProposal(RiskCheckMixin, WBModel):
         Returns:
             DTO trade object
         """
-        return (
-            TradeBatchDTO(tuple([trade._build_dto() for trade in self.trades.all()])) if self.trades.exists() else None
-        )
+        return TradeBatchDTO(tuple([trade._build_dto() for trade in self.trades.all()]))
 
     # Start tools methods
-    def clone(self, **kwargs) -> SelfTradeProposal:
+    def _clone(self, **kwargs) -> SelfTradeProposal:
         """
         Method to clone self as a new trade proposal. It will automatically shift the trade date if a proposal already exists
         Args:
@@ -176,6 +180,11 @@ class TradeProposal(RiskCheckMixin, WBModel):
             portfolio=self.portfolio,
             creator=self.creator,
         )
+        for trade in self.trades.all():
+            trade.id = None
+            trade.trade_proposal = trade_proposal_clone
+            trade.save()
+
         return trade_proposal_clone
 
     def normalize_trades(self):
@@ -191,7 +200,6 @@ class TradeProposal(RiskCheckMixin, WBModel):
             with suppress(Trade.DoesNotExist):
                 trade = self.trades.get(underlying_instrument_id=underlying_instrument_id)
                 trade.weighting = round(trade_dto.delta_weight, 6)
-                trade.shares = self.estimate_shares(trade)
                 trade.save()
                 total_target_weight += trade._target_weight
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
@@ -202,7 +210,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
             biggest_trade.weighting -= quantize_error
             biggest_trade.save()
 
-    def _get_target_portfolio(self, **kwargs) -> PortfolioDTO:
+    def _get_default_target_portfolio(self, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
             params = {}
             if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
@@ -211,50 +219,57 @@ class TradeProposal(RiskCheckMixin, WBModel):
             return self.rebalancing_model.get_target_portfolio(
                 self.portfolio, self.trade_date, self.last_effective_date, **params
             )
+        if self.trades.exists():
+            return self._build_dto().convert_to_portfolio()
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
 
-    def reset_trades(self, target_portfolio: PortfolioDTO | None = None):
+    def reset_trades(self, target_portfolio: PortfolioDTO | None = None, validate_trade: bool = True):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
         if self.status != TradeProposal.Status.DRAFT:
             raise ValueError("Cannot reset non-draft trade proposal. Revert this trade proposal first.")
         # delete all existing trades
-        self.trades.all().delete()
         last_effective_date = self.last_effective_date
         # Get effective and target portfolio
         effective_portfolio = self.portfolio._build_dto(last_effective_date)
         if not target_portfolio:
-            target_portfolio = self._get_target_portfolio()
-        # if not effective_portfolio:
-        #     effective_portfolio = target_portfolio
-        service = TradingService(
-            self.trade_date,
-            effective_portfolio=effective_portfolio,
-            target_portfolio=target_portfolio,
-        )
-        service.normalize()
-        service.is_valid()
-        for trade_dto in service.validated_trades:
-            instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
-            currency_fx_rate = instrument.currency.convert(
-                last_effective_date, self.portfolio.currency, exact_lookup=True
-            )
-            trade = Trade(
-                underlying_instrument=instrument,
-                transaction_subtype=Trade.Type.BUY if trade_dto.delta_weight > 0 else Trade.Type.SELL,
-                currency=instrument.currency,
-                value_date=last_effective_date,
-                transaction_date=self.trade_date,
-                trade_proposal=self,
-                portfolio=self.portfolio,
-                weighting=trade_dto.delta_weight,
-                status=Trade.Status.DRAFT,
-                currency_fx_rate=currency_fx_rate,
+            target_portfolio = self._get_default_target_portfolio()
+
+        if target_portfolio:
+            service = TradingService(
+                self.trade_date,
+                effective_portfolio=effective_portfolio,
+                target_portfolio=target_portfolio,
             )
-            trade.shares = self.estimate_shares(trade)
-            trade.save()
+            if validate_trade:
+                service.normalize()
+                service.is_valid()
+                trades = service.validated_trades
+            else:
+                trades = service.trades_batch.trades_map.values()
+            for trade_dto in trades:
+                instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
+                currency_fx_rate = instrument.currency.convert(
+                    last_effective_date, self.portfolio.currency, exact_lookup=True
+                )
+                # we cannot do a bulk-create because Trade is a multi table inheritance
+                try:
+                    trade = self.trades.get(underlying_instrument=instrument)
+                except Trade.DoesNotExist:
+                    trade = Trade(
+                        underlying_instrument=instrument,
+                        currency=instrument.currency,
+                        value_date=last_effective_date,
+                        transaction_date=self.trade_date,
+                        trade_proposal=self,
+                        portfolio=self.portfolio,
+                        weighting=trade_dto.delta_weight,
+                        status=Trade.Status.DRAFT,
+                        currency_fx_rate=currency_fx_rate,
+                    )
+                trade.save()
 
     def replay(self):
         last_trade_proposal = self
@@ -263,17 +278,22 @@ class TradeProposal(RiskCheckMixin, WBModel):
             last_trade_proposal.portfolio.assets.filter(
                 date=last_trade_proposal.trade_date
             ).delete()  # we delete the existing position and we reapply the trade proposal
-            if not last_trade_proposal.portfolio.assets.filter(date=last_trade_proposal.trade_date).exists():
-                if last_trade_proposal.status == TradeProposal.Status.APPROVED:
-                    logger.info("Reverting trade proposal ...")
-                    last_trade_proposal.revert()
-                if last_trade_proposal.status == TradeProposal.Status.DRAFT:
-                    logger.info("Submitting trade proposal ...")
-                    last_trade_proposal.submit()
-                if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
-                    logger.info("Approving trade proposal ...")
-                    last_trade_proposal.approve()
-                last_trade_proposal.save()
+            if last_trade_proposal.status == TradeProposal.Status.APPROVED:
+                logger.info("Reverting trade proposal ...")
+                last_trade_proposal.revert()
+            if last_trade_proposal.status == TradeProposal.Status.DRAFT:
+                if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
+                    logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
+                    with suppress(
+                        ValidationError
+                    ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
+                        self.reset_trades()
+                logger.info("Submitting trade proposal ...")
+                last_trade_proposal.submit()
+            if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
+                logger.info("Approving trade proposal ...")
+                last_trade_proposal.approve(replay=False)
+            last_trade_proposal.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()
@@ -283,14 +303,79 @@ class TradeProposal(RiskCheckMixin, WBModel):
             )
             last_trade_proposal = overriding_trade_proposal or next_trade_proposal
 
-    def estimate_shares(self, trade: Trade) -> Decimal | None:
-        if not self.portfolio.only_weighting and (quote := trade.underlying_quote_price):
-            trade_total_value_fx_portfolio = (
-                self.portfolio.get_total_asset_value(trade.value_date) * trade._target_weight
+    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal | None:
+        """
+        Estimates the number of shares for a trade based on the given weight and underlying quote.
+
+        This method calculates the estimated shares by dividing the trade's total value in the portfolio's currency by the price of the underlying quote in the same currency. It handles currency conversion and suppresses any ValueError that might occur during the price retrieval.
+
+        Args:
+            weight (Decimal): The weight of the trade.
+            underlying_quote (Instrument): The underlying instrument for the trade.
+
+        Returns:
+            Decimal | None: The estimated number of shares or None if the calculation fails.
+        """
+        try:
+            # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
+            quote_price = Decimal(underlying_quote.get_price(self.trade_date))
+
+            # Calculate the trade's total value in the portfolio's currency
+            trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
+
+            # Convert the quote price to the portfolio's currency
+            price_fx_portfolio = quote_price * underlying_quote.currency.convert(
+                self.trade_date, self.portfolio.currency, exact_lookup=False
             )
-            price_fx_portfolio = quote.net_value * trade.currency_fx_rate
+
+            # If the price is valid, calculate and return the estimated shares
             if price_fx_portfolio:
                 return trade_total_value_fx_portfolio / price_fx_portfolio
+        except Exception:
+            # Suppress any ValueError and return None if the calculation fails
+            return None
+
+    def get_estimated_target_cash(self, currency: Currency) -> tuple[Decimal, Decimal]:
+        """
+        Estimates the target cash weight and shares for a trade proposal.
+
+        This method calculates the target cash weight by summing the weights of cash trades and adding any leftover weight from non-cash trades. It then estimates the target shares for this cash component if the portfolio is not only weighting-based.
+
+        Args:
+            currency (Currency): The currency for the target currency component
+
+        Returns:
+            tuple[Decimal, Decimal]: A tuple containing the target cash weight and the estimated target shares.
+        """
+        # Retrieve trades with base information
+        trades = self.trades.all().annotate_base_info()
+
+        # Calculate the target cash weight from cash trades
+        target_cash_weight = trades.filter(
+            underlying_instrument__is_cash=True, underlying_instrument__currency=currency
+        ).aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
+        # if the specified currency match the portfolio's currency, we include the weight leftover to this cash compoenent
+        if currency == self.portfolio.currency:
+            # Calculate the total target weight of all trades
+            total_target_weight = trades.aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
+
+            # Add any leftover weight as cash
+            target_cash_weight += Decimal(1) - total_target_weight
+
+        # Initialize target shares to zero
+        total_target_shares = Decimal(0)
+
+        # If the portfolio is not only weighting-based, estimate the target shares for the cash component
+        if not self.portfolio.only_weighting:
+            # Get or create a cash component for the portfolio's currency
+            cash_component = Cash.objects.get_or_create(
+                currency=currency, defaults={"is_cash": True, "name": currency.title}
+            )[0]
+
+            # Estimate the target shares for the cash component
+            total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+
+        return target_cash_weight, total_target_shares
 
     # Start FSM logics
 
@@ -315,9 +400,26 @@ class TradeProposal(RiskCheckMixin, WBModel):
     )
     def submit(self, by=None, description=None, **kwargs):
         self.trades.update(comment="", status=Trade.Status.DRAFT)
+        self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         for trade in self.trades.all():
             trade.submit()
             trade.save()
+
+        # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
+        cash_target_cash_weight, cash_target_cash_shares = self.get_estimated_target_cash(self.portfolio.currency)
+        if cash_target_cash_weight:
+            cash_component = Cash.objects.get_or_create(
+                currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
+            )[0]
+            self.trades.update_or_create(
+                underlying_instrument=cash_component,
+                defaults={
+                    "status": Trade.Status.SUBMIT,
+                    "weighting": cash_target_cash_weight,
+                    "shares": cash_target_cash_shares,
+                },
+            )
+
         self.evaluate_active_rules(
             self.trade_date, self.validated_trading_service.target_portfolio, asynchronously=True
         )
@@ -348,7 +450,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
 
     @property
     def can_be_approved_or_denied(self):
-        return self.has_no_rule_or_all_checked_succeed and self.portfolio.is_manageable
+        return not self.has_non_successful_checks and self.portfolio.is_manageable
 
     @transition(
         field=status,
@@ -370,7 +472,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
             )
         },
     )
-    def approve(self, by=None, description=None, synchronous=False, **kwargs):
+    def approve(self, by=None, description=None, replay: bool = True, **kwargs):
         # We validate trade which will create or update the initial asset positions
         if not self.portfolio.can_be_rebalanced:
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
@@ -379,6 +481,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
         for trade in self.trades.all():
             trade.execute()
             trade.save()
+        if replay and self.portfolio.is_manageable:
+            replay_as_task.delay(self.id)
 
     def can_approve(self):
         errors = dict()
@@ -390,7 +494,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
             errors["portfolio"] = (
                 "The portfolio needs to be a model portfolio in order to approve this trade proposal manually"
             )
-        if self.has_assigned_active_rules and not self.has_all_check_completed_and_succeed:
+        if self.has_non_successful_checks:
             errors["non_field_errors"] = "The pre trades rules did not passed successfully"
         return errors
 
@@ -432,7 +536,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         )
-        and instance.has_all_check_completed,  # we wait for all checks to succeed before proposing the back to draft transition
+        and instance.has_all_check_completed
+        or not instance.checks.exists(),  # we wait for all checks to succeed before proposing the back to draft transition
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,

wbportfolio/models/transactions/trades.py

@@ -136,6 +136,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         REDEMPTION = "REDEMPTION", "Redemption"
         BUY = "BUY", "Buy"
         SELL = "SELL", "Sell"
+        NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
 
     external_identifier2 = models.CharField(
         max_length=255,
@@ -224,7 +225,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         source=Status.DRAFT,
         target=GET_STATE(
             lambda self, **kwargs: (
-                self.Status.SUBMIT if self.underlying_quote_price is not None else self.Status.FAILED
+                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
             ),
             states=[Status.SUBMIT, Status.FAILED],
         ),
@@ -245,7 +246,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        if not self.underlying_quote_price:
+        if not self.last_underlying_quote_price:
             self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     def can_submit(self):
@@ -263,13 +264,15 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     @cached_property
-    def underlying_quote_price(self) -> InstrumentPrice | None:
+    def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
+            # we try t0 first
             return InstrumentPrice.objects.filter_only_valid_prices().get(
-                instrument=self.underlying_instrument, date=self.value_date
+                instrument=self.underlying_instrument, date=self.transaction_date
             )
         except InstrumentPrice.DoesNotExist:
             with suppress(InstrumentPrice.DoesNotExist):
+                # we fall back to the latest price before t0
                 return (
                     InstrumentPrice.objects.filter_only_valid_prices()
                     .filter(instrument=self.underlying_instrument, date__lte=self.value_date)
@@ -296,7 +299,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         },
     )
     def execute(self, **kwargs):
-        if self.underlying_quote_price:
+        if self.last_underlying_quote_price:
             asset, created = AssetPosition.unannotated_objects.update_or_create(
                 underlying_quote=self.underlying_instrument,
                 portfolio_created=None,
@@ -305,9 +308,9 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 defaults={
                     "initial_currency_fx_rate": self.currency_fx_rate,
                     "weighting": self._target_weight,
-                    "initial_price": self.underlying_quote_price.net_value,
+                    "initial_price": self.last_underlying_quote_price.net_value,
                     "initial_shares": None,
-                    "underlying_quote_price": self.underlying_quote_price,
+                    "underlying_quote_price": self.last_underlying_quote_price,
                     "asset_valuation_date": self.transaction_date,
                     "currency": self.currency,
                     "is_estimated": False,
@@ -316,7 +319,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             asset.set_weighting(self._target_weight)
 
     def can_execute(self):
-        if not self.underlying_quote_price:
+        if not self.last_underlying_quote_price:
             return {"underlying_instrument": "Cannot execute a trade without a valid quote price"}
         if not self.portfolio.is_manageable:
             return {"portfolio": "The portfolio needs to be a model portfolio in order to execute this trade manually"}
@@ -487,14 +490,15 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         super().__init__(*args, **kwargs)
         if target_weight is not None:  # if target weight is provided, we guess the corresponding weighting
             self.weighting = Decimal(target_weight) - self._effective_weight
+            self._set_transaction_subtype()
 
     def save(self, *args, **kwargs):
         if self.trade_proposal:
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-            if self._effective_shares:
-                self.shares = self._effective_shares * self.weighting
+            if not self.portfolio.only_weighting:
+                self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
@@ -512,21 +516,9 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.total_value_gross = self.price_gross * self.shares
         self.transaction_type = Transaction.Type.TRADE
 
-        if self.transaction_subtype is None:
+        if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
-            if self.underlying_instrument.instrument_type.key == "product":
-                if self.shares is not None:
-                    if self.shares > 0:
-                        self.transaction_subtype = Trade.Type.SUBSCRIPTION
-                    elif self.shares < 0:
-                        self.transaction_subtype = Trade.Type.REDEMPTION
-            elif self.weighting is not None:
-                if self.weighting > 0:
-                    self.transaction_subtype = Trade.Type.BUY
-                elif self.weighting < 0:
-                    self.transaction_subtype = Trade.Type.SELL
-            else:
-                self.transaction_subtype = Trade.Type.REBALANCE
+            self._set_transaction_subtype()
         if self.id and hasattr(self, "claims"):
             self.claimed_shares = self.trade.claims.filter(status="APPROVED").aggregate(s=Sum("shares"))[
                 "s"
@@ -535,6 +527,23 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.marked_as_internal = True
         super().save(*args, **kwargs)
 
+    def _set_transaction_subtype(self):
+        if self.weighting == 0:
+            self.transaction_subtype = Trade.Type.NO_CHANGE
+        if self.underlying_instrument.instrument_type.key == "product":
+            if self.shares is not None:
+                if self.shares > 0:
+                    self.transaction_subtype = Trade.Type.SUBSCRIPTION
+                elif self.shares < 0:
+                    self.transaction_subtype = Trade.Type.REDEMPTION
+        elif self.weighting is not None:
+            if self.weighting > 0:
+                self.transaction_subtype = Trade.Type.BUY
+            elif self.weighting < 0:
+                self.transaction_subtype = Trade.Type.SELL
+        else:
+            self.transaction_subtype = Trade.Type.REBALANCE
+
     def get_transaction_subtype(self) -> str:
         """
         Return the expected transaction subtype based n
@@ -560,7 +569,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             underlying_instrument=self.underlying_instrument.id,
             effective_weight=self._effective_weight,
             target_weight=self._target_weight,
-            instrument_type=self.underlying_instrument.security_instrument_type,
+            instrument_type=self.underlying_instrument.security_instrument_type.id,
             currency=self.underlying_instrument.currency,
             date=self.transaction_date,
         )

wbportfolio/pms/trading/handler.py

@@ -62,7 +62,7 @@ class TradingService:
         Test the given value against all the validators on the field,
         and either raise a `ValidationError` or simply return.
         """
-        TradeBatch(validated_trades).validate()
+        # TradeBatch(validated_trades).validate()
         if self.effective_portfolio:
             for trade in validated_trades:
                 if (

wbportfolio/pms/typing.py

@@ -70,6 +70,9 @@ class Portfolio:
     def to_df(self):
         return pd.DataFrame([asdict(pos) for pos in self.positions])
 
+    def to_dict(self) -> dict[int, Decimal]:
+        return {underlying_instrument: pos.weighting for underlying_instrument, pos in self.positions_map.items()}
+
     def __len__(self):
         return len(self.positions)
 

wbportfolio/preferences.py

@@ -1,6 +1,11 @@
 from dynamic_preferences.registries import global_preferences_registry
 
 
-def get_monthly_nnm_target(*args, **kwargs):
+def get_monthly_nnm_target(*args, **kwargs) -> int:
     global_preferences = global_preferences_registry.manager()
     return global_preferences["wbportfolio__monthly_nnm_target"]
+
+
+def get_product_termination_notice_period(*args, **kwargs) -> int:
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbportfolio__product_termination_notice_period"]

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/accounts.py

@@ -3,6 +3,7 @@ from typing import Generator
 
 import pandas as pd
 from django.contrib.contenttypes.models import ContentType
+from django.contrib.humanize.templatetags.humanize import intcomma
 from django.db import models
 from wbcompliance.models.risk_management import backend
 from wbcompliance.models.risk_management.dispatch import register
@@ -148,15 +149,22 @@ class RuleBackend(backend.AbstractRuleBackend):
                         report_details = {
                             "Period": f"{cts_generator.start_date:%d.%m.%Y} - {cts_generator.end_date:%d.%m.%Y}",
                         }
+
+                        # create report detail template
                         color = "red" if percentage < 0 else "green"
+                        number_prefix = ""
+
                         if self.field == "AUM":
-                            report_details["AUM Change"] = (
-                                f'<span style="color:{color}">{start_df.loc[breached_obj_id]:.0f} $ → {end_df.loc[breached_obj_id]:.0f} $</span>'
-                            )
+                            key = "AUM Change"
+                            number_prefix = "$"
                         else:
-                            report_details["Shares Change"] = (
-                                f"<span style='color:{color}'>{start_df.loc[breached_obj_id]:.0f} → {end_df.loc[breached_obj_id]:.0f}</span>"
-                            )
+                            key = "Shares Change"
+
+                        template = f'{number_prefix}{{}} → {number_prefix}{{}} <span style="color:{color}"><strong>Δ {number_prefix}{{}}</strong></span>'
+                        start = intcomma(int(start_df.loc[breached_obj_id].round(0)))
+                        end = intcomma(int(end_df.loc[breached_obj_id].round(0)))
+                        diff = intcomma(int((end_df.loc[breached_obj_id] - start_df.loc[breached_obj_id]).round(0)))
+                        report_details[key] = template.format(start, end, diff)
                         report_details["Group By"] = self.group_by.value
                         yield backend.IncidentResult(
                             breached_object=breached_obj,