wbportfolio 1.54.3__py2.py3-none-any.whl → 1.54.4__py2.py3-none-any.whl

wbportfolio/models/transactions/trade_proposals.py

@@ -7,7 +7,9 @@ from typing import Any, TypeVar
 
 from celery import shared_task
 from django.core.exceptions import ValidationError
-from django.db import models
+from django.db import DatabaseError, models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
 from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 from django_fsm import FSMField, transition
@@ -27,9 +29,10 @@ from wbfdm.models.instruments.instruments import Cash, Instrument
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
-from wbportfolio.pms.typing import TradeBatch as TradeBatchDTO
+from wbportfolio.pms.typing import Position as PositionDTO
 
 from ..asset import AssetPosition, AssetPositionIterator
+from ..exceptions import InvalidAnalyticPortfolio
 from .trades import Trade
 
 logger = logging.getLogger("pms")
@@ -109,7 +112,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         This property holds the validated trading services and cache it.This property expect to be set only if is_valid return True
         """
-        target_portfolio = self._build_dto().convert_to_portfolio()
+        target_portfolio = self.convert_to_portfolio()
 
         return TradingService(
             self.trade_date,
@@ -123,7 +126,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         try:
             return self.portfolio.assets.filter(date__lt=self.trade_date).latest("date").date
         except AssetPosition.DoesNotExist:
-            return (self.trade_date - BDay(1)).date()
+            return self.value_date
+
+    @cached_property
+    def value_date(self) -> date:
+        return (self.trade_date - BDay(1)).date()
 
     @property
     def previous_trade_proposal(self) -> SelfTradeProposal | None:
@@ -162,13 +169,61 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def __str__(self) -> str:
         return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
 
-    def _build_dto(self) -> TradeBatchDTO:
+    def convert_to_portfolio(self, use_effective: bool = False) -> PortfolioDTO:
         """
         Data Transfer Object
         Returns:
             DTO trade object
         """
-        return TradeBatchDTO(tuple([trade._build_dto() for trade in self.trades.all()]))
+        portfolio = {}
+        for asset in self.portfolio.assets.filter(date=self.last_effective_date):
+            portfolio[asset.underlying_quote] = dict(
+                shares=asset._shares,
+                weighting=asset.weighting,
+                delta_weight=Decimal("0"),
+                price=asset._price,
+                currency_fx_rate=asset._currency_fx_rate,
+            )
+        for trade in self.trades.all().annotate_base_info():
+            portfolio[trade.underlying_instrument] = dict(
+                weighting=trade._previous_weight,
+                delta_weight=trade.weighting,
+                shares=trade._target_shares if not use_effective else trade._effective_shares,
+                price=trade.price,
+                currency_fx_rate=trade.currency_fx_rate,
+            )
+
+        previous_weights = dict(map(lambda r: (r[0].id, float(r[1]["weighting"])), portfolio.items()))
+        try:
+            drifted_weights = self.portfolio.get_analytic_portfolio(
+                self.value_date, weights=previous_weights
+            ).get_next_weights()
+        except InvalidAnalyticPortfolio:
+            drifted_weights = {}
+        positions = []
+        for instrument, row in portfolio.items():
+            weighting = row["weighting"]
+            try:
+                drift_factor = Decimal(drifted_weights.pop(instrument.id)) / weighting if weighting else Decimal("1")
+            except KeyError:
+                drift_factor = Decimal("1")
+            if not use_effective:
+                weighting = weighting * drift_factor + row["delta_weight"]
+            positions.append(
+                PositionDTO(
+                    underlying_instrument=instrument.id,
+                    instrument_type=instrument.instrument_type.id,
+                    weighting=weighting,
+                    drift_factor=drift_factor if use_effective else Decimal("1"),
+                    shares=row["shares"],
+                    currency=instrument.currency.id,
+                    date=self.last_effective_date if use_effective else self.trade_date,
+                    is_cash=instrument.is_cash or instrument.is_cash_equivalent,
+                    price=row["price"],
+                    currency_fx_rate=row["currency_fx_rate"],
+                )
+            )
+        return PortfolioDTO(positions)
 
     # Start tools methods
     def _clone(self, **kwargs) -> SelfTradeProposal:
@@ -208,14 +263,14 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         service = TradingService(
             self.trade_date,
             effective_portfolio=self._get_default_effective_portfolio(),
-            target_portfolio=self._build_dto().convert_to_portfolio(),
+            target_portfolio=self.convert_to_portfolio(),
             total_target_weight=total_target_weight,
         )
         leftovers_trades = self.trades.all()
         for underlying_instrument_id, trade_dto in service.trades_batch.trades_map.items():
             with suppress(Trade.DoesNotExist):
                 trade = self.trades.get(underlying_instrument_id=underlying_instrument_id)
-                trade.weighting = round(trade_dto.delta_weight, 6)
+                trade.weighting = round(trade_dto.delta_weight, Trade.TRADE_WEIGHTING_PRECISION)
                 trade.save()
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
         leftovers_trades.delete()
@@ -235,34 +290,39 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 params.update(rebalancer.parameters)
             params.update(kwargs)
             return self.rebalancing_model.get_target_portfolio(
-                self.portfolio, self.trade_date, self.last_effective_date, **params
+                self.portfolio, self.trade_date, self.value_date, **params
             )
         if self.trades.exists():
-            return self._build_dto().convert_to_portfolio()
+            return self.convert_to_portfolio()
         # Return the current portfolio by default
-        return self._get_default_effective_portfolio()
+        return self.convert_to_portfolio(use_effective=False)
 
     def _get_default_effective_portfolio(self):
-        return self.portfolio._build_dto(self.last_effective_date)
+        return self.convert_to_portfolio(use_effective=True)
 
     def reset_trades(
         self,
         target_portfolio: PortfolioDTO | None = None,
+        effective_portfolio: PortfolioRole | None = None,
         validate_trade: bool = True,
         total_target_weight: Decimal = Decimal("1.0"),
     ):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
+        if self.rebalancing_model:
+            self.trades.all().delete()
         # delete all existing trades
-        last_effective_date = self.last_effective_date
         # Get effective and target portfolio
         if not target_portfolio:
             target_portfolio = self._get_default_target_portfolio()
+        if not effective_portfolio:
+            effective_portfolio = self._get_default_effective_portfolio()
+
         if target_portfolio:
             service = TradingService(
                 self.trade_date,
-                effective_portfolio=self._get_default_effective_portfolio(),
+                effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
                 total_target_weight=total_target_weight,
             )
@@ -273,78 +333,109 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 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
-                weighting = round(trade_dto.delta_weight, 6)
-                drift_factor = trade_dto.drift_factor
-                try:
-                    trade = self.trades.get(underlying_instrument=instrument)
-                    trade.weighting = weighting
-                    trade.currency_fx_rate = currency_fx_rate
-                    trade.status = Trade.Status.DRAFT
-                    trade.drift_factor = drift_factor
-                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=weighting,
-                        drift_factor=drift_factor,
-                        status=Trade.Status.DRAFT,
-                        currency_fx_rate=currency_fx_rate,
+                if not instrument.is_cash:  # we do not save trade that includes cash component
+                    currency_fx_rate = instrument.currency.convert(
+                        self.value_date, self.portfolio.currency, exact_lookup=True
                     )
-                trade.price = trade.get_price()
-                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
-                if trade.price is None:
-                    trade.price = Decimal("0.0")
-                    trade.weighting = -trade_dto.effective_weight
-                trade.save()
-
-    def replay(self):
+                    # we cannot do a bulk-create because Trade is a multi table inheritance
+                    weighting = round(trade_dto.delta_weight, Trade.TRADE_WEIGHTING_PRECISION)
+                    drift_factor = trade_dto.drift_factor
+                    try:
+                        trade = self.trades.get(underlying_instrument=instrument)
+                        trade.weighting = weighting
+                        trade.currency_fx_rate = currency_fx_rate
+                        trade.status = Trade.Status.DRAFT
+                        trade.drift_factor = drift_factor
+                    except Trade.DoesNotExist:
+                        trade = Trade(
+                            underlying_instrument=instrument,
+                            currency=instrument.currency,
+                            value_date=self.value_date,
+                            transaction_date=self.trade_date,
+                            trade_proposal=self,
+                            portfolio=self.portfolio,
+                            weighting=weighting,
+                            drift_factor=drift_factor,
+                            status=Trade.Status.DRAFT,
+                            currency_fx_rate=currency_fx_rate,
+                        )
+                    trade.price = trade.get_price()
+                    # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                    if trade.price is None:
+                        trade.price = Decimal("0.0")
+                        trade.weighting = -trade_dto.effective_weight
+
+                    trade.save()
+
+    def approve_workflow(
+        self,
+        approve_automatically: bool = True,
+        silent_exception: bool = False,
+        force_reset_trade: bool = False,
+        **reset_trades_kwargs,
+    ):
+        if self.status == TradeProposal.Status.APPROVED:
+            logger.info("Reverting trade proposal ...")
+            self.revert()
+        if self.status == TradeProposal.Status.DRAFT:
+            if (
+                self.rebalancing_model or force_reset_trade
+            ):  # 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("Resetting trades ...")
+                try:  # 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(**reset_trades_kwargs)
+                except (ValidationError, DatabaseError) as e:
+                    self.status = TradeProposal.Status.FAILED
+                    if not silent_exception:
+                        raise ValidationError(e)
+                    return
+            logger.info("Submitting trade proposal ...")
+            self.submit()
+        if self.status == TradeProposal.Status.SUBMIT:
+            logger.info("Approving trade proposal ...")
+            if approve_automatically and self.portfolio.can_be_rebalanced:
+                self.approve(replay=False)
+
+    def replay(self, force_reset_trade: bool = False, broadcast_changes_at_date: bool = True):
         last_trade_proposal = self
         last_trade_proposal_created = False
         while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
             if not last_trade_proposal_created:
                 logger.info(f"Replaying trade proposal {last_trade_proposal}")
                 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 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)
+                    date=self.trade_date
+                ).all().delete()  # we delete the existing position and we reapply the trade proposal
+                last_trade_proposal.approve_workflow(silent_exception=True, force_reset_trade=force_reset_trade)
                 last_trade_proposal.save()
+                if last_trade_proposal.status != TradeProposal.Status.APPROVED:
+                    break
             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()
-            )
+            if next_trade_proposal:
+                next_trade_date = next_trade_proposal.trade_date - timedelta(days=1)
+            elif next_expected_rebalancing_date := self.portfolio.get_next_rebalancing_date(
+                last_trade_proposal.trade_date
+            ):
+                next_trade_date = (
+                    next_expected_rebalancing_date + timedelta(days=7)
+                )  # we don't know yet if rebalancing is valid and can be executed on `next_expected_rebalancing_date`, so we add safety window of 7 days
+            else:
+                next_trade_date = date.today()
+            next_trade_date = min(next_trade_date, date.today())
             positions, overriding_trade_proposal = self.portfolio.drift_weights(
-                last_trade_proposal.trade_date, next_trade_date
+                last_trade_proposal.trade_date, next_trade_date, stop_at_rebalancing=True
             )
-            self.portfolio.assets.filter(
-                date__gt=last_trade_proposal.trade_date, date__lte=next_trade_date, is_estimated=False
-            ).update(
-                is_estimated=True
-            )  # ensure that we reset non estimated position leftover to estimated between trade proposal during replay
+
+            # self.portfolio.assets.filter(
+            #     date__gt=last_trade_proposal.trade_date, date__lte=next_trade_date, is_estimated=False
+            # ).update(
+            #     is_estimated=True
+            # )  # ensure that we reset non estimated position leftover to estimated between trade proposal during replay
             self.portfolio.bulk_create_positions(
-                positions, delete_leftovers=True, compute_metrics=False, evaluate_rebalancer=False
+                positions,
+                delete_leftovers=True,
+                compute_metrics=False,
+                broadcast_changes_at_date=broadcast_changes_at_date,
+                evaluate_rebalancer=False,
             )
             if overriding_trade_proposal:
                 last_trade_proposal_created = True
@@ -353,7 +444,20 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 last_trade_proposal_created = False
                 last_trade_proposal = next_trade_proposal
 
-    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument, quote_price: Decimal) -> Decimal:
+    def invalidate_future_trade_proposal(self):
+        # Delete all future automatic trade proposals and set the manual one into a draft state
+        self.portfolio.trade_proposals.filter(
+            trade_date__gt=self.trade_date, rebalancing_model__isnull=False, comment="Automatic rebalancing"
+        ).delete()
+        for future_trade_proposal in self.portfolio.trade_proposals.filter(
+            trade_date__gt=self.trade_date, status=TradeProposal.Status.APPROVED
+        ):
+            future_trade_proposal.revert()
+            future_trade_proposal.save()
+
+    def get_estimated_shares(
+        self, weight: Decimal, underlying_quote: Instrument, quote_price: Decimal
+    ) -> Decimal | None:
         """
         Estimates the number of shares for a trade based on the given weight and underlying quote.
 
@@ -574,7 +678,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         Trade.objects.bulk_update(trades, ["status"])
         self.portfolio.bulk_create_positions(
-            AssetPositionIterator(self.portfolio).add(assets), evaluate_rebalancer=False, force_save=True
+            AssetPositionIterator(self.portfolio).add(assets, is_estimated=False),
+            evaluate_rebalancer=False,
+            force_save=True,
         )
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id, user_id=by.id if by else None)
@@ -687,8 +793,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         ).delete()  # we delete the existing portfolio as it has been reverted
         for trade in self.trades.all():
             trade.status = Trade.Status.DRAFT
+            trade.drift_factor = Decimal("1")
             trades.append(trade)
-        Trade.objects.bulk_update(trades, ["status"])
+        Trade.objects.bulk_update(trades, ["status", "drift_factor"])
 
     def can_revert(self):
         errors = dict()
@@ -717,6 +824,15 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         return "{{_portfolio.name}} ({{trade_date}})"
 
 
+@receiver(post_save, sender="wbportfolio.TradeProposal")
+def post_fail_trade_proposal(sender, instance: TradeProposal, created, raw, **kwargs):
+    # if we have a trade proposal in a fail state, we ensure that all future existing trade proposal are either deleted (automatic one) or set back to draft
+    if not raw and instance.status == TradeProposal.Status.FAILED:
+        # we delete all trade proposal that have a rebalancing model and are marked as "automatic" (quite hardcoded yet)
+        instance.invalidate_future_trade_proposal()
+        instance.invalidate_future_trade_proposal()
+
+
 @shared_task(queue="portfolio")
 def replay_as_task(trade_proposal_id, user_id: int | None = None):
     trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)

wbportfolio/models/transactions/trades.py

@@ -53,7 +53,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 .order_by("-date")
                 .values("date")[:1]
             ),
-            _previous_weight=Coalesce(
+            previous_weight=Coalesce(
                 Subquery(
                     AssetPosition.unannotated_objects.filter(
                         underlying_quote=OuterRef("underlying_instrument"),
@@ -66,8 +66,10 @@ class TradeQueryset(OrderedModelQuerySet):
                 ),
                 Decimal(0),
             ),
-            effective_weight=Round(F("_previous_weight") * F("drift_factor"), precision=8),
-            target_weight=Round(F("effective_weight") + F("weighting"), precision=8),
+            effective_weight=Round(
+                F("previous_weight") * F("drift_factor"), precision=Trade.TRADE_WEIGHTING_PRECISION
+            ),
+            target_weight=Round(F("effective_weight") + F("weighting"), precision=Trade.TRADE_WEIGHTING_PRECISION),
             effective_shares=Coalesce(
                 Subquery(
                     AssetPosition.objects.filter(
@@ -125,6 +127,9 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     import_export_handler_class = TradeImportHandler
 
     TRADE_WINDOW_INTERVAL = 7
+    TRADE_WEIGHTING_PRECISION = (
+        8  # we need to match the assetposition weighting. Skfolio advices using a even smaller number (5)
+    )
 
     class Status(models.TextChoices):
         DRAFT = "DRAFT", "Draft"
@@ -165,7 +170,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     weighting = models.DecimalField(
         max_digits=9,
-        decimal_places=8,
+        decimal_places=TRADE_WEIGHTING_PRECISION,
         default=Decimal(0),
         help_text="The weight to be multiplied against the target",
         verbose_name="Weight",
@@ -226,7 +231,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     )
     drift_factor = models.DecimalField(
         max_digits=16,
-        decimal_places=8,
+        decimal_places=TRADE_WEIGHTING_PRECISION,
         default=Decimal(1.0),
         verbose_name="Drift Factor",
         help_text="Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return",
@@ -324,7 +329,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 # 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)
+                    .filter(instrument=self.underlying_instrument, date__lte=self.transaction_date)
                     .latest("date")
                 )
 
@@ -468,7 +473,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             return self.last_effective_date
         elif (
             assets := AssetPosition.unannotated_objects.filter(
-                underlying_quote=self.underlying_instrument,
                 date__lte=self.value_date,
                 portfolio=self.portfolio,
             )
@@ -477,15 +481,21 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     @property
     @admin.display(description="Effective Weight")
-    def _effective_weight(self) -> Decimal:
-        if hasattr(self, "effective_weight"):
-            return self.effective_weight
-        previous_weight = AssetPosition.unannotated_objects.filter(
+    def _previous_weight(self) -> Decimal:
+        if hasattr(self, "previous_weight"):
+            return self.previous_weight
+        return AssetPosition.unannotated_objects.filter(
             underlying_quote=self.underlying_instrument,
             date=self._last_effective_date,
             portfolio=self.portfolio,
         ).aggregate(s=Sum("weighting"))["s"] or Decimal(0)
-        return round(previous_weight * self.drift_factor, 8)
+
+    @property
+    @admin.display(description="Effective Weight")
+    def _effective_weight(self) -> Decimal:
+        if hasattr(self, "effective_weight"):
+            return self.effective_weight
+        return round(self._previous_weight * self.drift_factor, self.TRADE_WEIGHTING_PRECISION)
 
     @property
     @admin.display(description="Effective Shares")
@@ -504,7 +514,9 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     @property
     @admin.display(description="Target Weight")
     def _target_weight(self) -> Decimal:
-        return getattr(self, "target_weight", round(self._effective_weight + self.weighting, 8))
+        return getattr(
+            self, "target_weight", round(self._effective_weight + self.weighting, self.TRADE_WEIGHTING_PRECISION)
+        )
 
     @property
     @admin.display(description="Target Shares")
@@ -553,6 +565,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             self._set_type()
 
     def save(self, *args, **kwargs):
+        if abs(self.weighting) < 10e-6:
+            self.weighting = Decimal("0")
         if self.trade_proposal:
             if not self.underlying_instrument.is_investable_universe:
                 self.underlying_instrument.is_investable_universe = True
@@ -634,9 +648,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         return asset
 
     def get_price(self) -> Decimal | None:
-        if self.value_date:
-            with suppress(ValueError):
-                return Decimal(self.underlying_instrument.get_price(self.value_date))
+        with suppress(ValueError):
+            return Decimal.from_float(self.underlying_instrument.get_price(self.transaction_date))
 
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)
@@ -646,19 +659,23 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
         return f"{ticker}{self.shares} ({self.bank})"
 
-    def _build_dto(self) -> TradeDTO:
+    def _build_dto(self, drift_factor: Decimal = None) -> TradeDTO:
         """
         Data Transfer Object
         Returns:
             DTO trade object
+
         """
+        if not drift_factor:
+            drift_factor = self.drift_factor
         return TradeDTO(
             id=self.id,
             underlying_instrument=self.underlying_instrument.id,
-            effective_weight=self._effective_weight,
-            target_weight=self._target_weight,
+            previous_weight=self._previous_weight,
+            target_weight=self._previous_weight * drift_factor + self.weighting,
             effective_shares=self._effective_shares,
             target_shares=self._target_shares,
+            drift_factor=drift_factor,
             currency_fx_rate=self.currency_fx_rate,
             price=self.price,
             instrument_type=self.underlying_instrument.security_instrument_type.id,

wbportfolio/pms/analytics/portfolio.py

@@ -25,12 +25,11 @@ class Portfolio(BasePortfolio):
         """
         returns = self.X.iloc[-1, :].T
         weights = self.all_weights_per_observation.iloc[-1, :].T
-        if weights.sum() != 0:
-            weights /= weights.sum()
-        contribution = weights * (returns + 1.0)
-        if contribution.sum() != 0:
-            contribution /= contribution.sum()
-        return contribution.dropna().to_dict()
+        portfolio_returns = (weights * (returns + 1.0)).sum()
+        next_weights = weights * (returns + 1.0) / portfolio_returns
+        next_weights = next_weights.dropna()
+        next_weights = next_weights / next_weights.sum()
+        return next_weights.to_dict()
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:
         expected_returns = self.weights @ self.X.iloc[-1, :].T

wbportfolio/pms/trading/handler.py

@@ -86,7 +86,6 @@ class TradingService:
         self.trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio).normalize(
             total_target_weight
         )
-
         self._effective_portfolio = effective_portfolio
         self._target_portfolio = target_portfolio
 
@@ -144,34 +143,32 @@ class TradingService:
         trades: list[Trade] = []
         for instrument_id, pos in instruments.items():
             if not pos.is_cash:
-                effective_weight = target_weight = 0
+                previous_weight = target_weight = 0
                 effective_shares = target_shares = 0
                 drift_factor = 1.0
                 if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
-                    effective_weight = effective_pos.weighting
+                    previous_weight = effective_pos.weighting
                     effective_shares = effective_pos.shares
                     drift_factor = effective_pos.drift_factor
                 if target_pos := target_portfolio.positions_map.get(instrument_id, None):
                     target_weight = target_pos.weighting
                     if target_pos.shares is not None:
                         target_shares = target_pos.shares
-
-                trades.append(
-                    Trade(
-                        underlying_instrument=instrument_id,
-                        effective_weight=effective_weight,
-                        target_weight=target_weight,
-                        effective_shares=effective_shares,
-                        target_shares=target_shares,
-                        date=self.trade_date,
-                        instrument_type=pos.instrument_type,
-                        currency=pos.currency,
-                        price=Decimal(pos.price),
-                        currency_fx_rate=Decimal(pos.currency_fx_rate),
-                        drift_factor=Decimal(drift_factor),
-                    )
+                trade = Trade(
+                    underlying_instrument=instrument_id,
+                    previous_weight=previous_weight,
+                    target_weight=target_weight,
+                    effective_shares=effective_shares,
+                    target_shares=target_shares,
+                    date=self.trade_date,
+                    instrument_type=pos.instrument_type,
+                    currency=pos.currency,
+                    price=Decimal(pos.price) if pos.price is not None else Decimal("0"),
+                    currency_fx_rate=Decimal(pos.currency_fx_rate),
+                    drift_factor=Decimal(drift_factor),
                 )
-        return TradeBatch(tuple(trades))
+                trades.append(trade)
+        return TradeBatch(trades)
 
     def is_valid(self, ignore_error: bool = False) -> bool:
         """