wbportfolio 1.54.13__py2.py3-none-any.whl → 1.54.15__py2.py3-none-any.whl

wbportfolio/models/transactions/trades.py

@@ -1,9 +1,7 @@
-from contextlib import suppress
-from datetime import date, timedelta
+from datetime import timedelta
 from decimal import Decimal
 
 from celery import shared_task
-from django.contrib import admin
 from django.db import models
 from django.db.models import (
     Case,
@@ -16,17 +14,10 @@ from django.db.models import (
     Sum,
     When,
 )
-from django.db.models.functions import Coalesce, Round
+from django.db.models.functions import Coalesce
 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 GET_STATE, FSMField, transition
-from ordered_model.models import OrderedModel, OrderedModelManager, OrderedModelQuerySet
-from wbcore.contrib.icons import WBIcon
 from wbcore.contrib.io.mixins import ImportMixin
-from wbcore.enums import RequestType
-from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.signals import pre_merge
 from wbcore.signals.models import pre_collection
 from wbfdm.models import Instrument
@@ -34,76 +25,12 @@ from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import add_instrument_to_investable_universe
 
 from wbportfolio.import_export.handlers.trade import TradeImportHandler
-from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.custodians import Custodian
-from wbportfolio.models.roles import PortfolioRole
-from wbportfolio.pms.typing import Trade as TradeDTO
 
 from .transactions import TransactionMixin
 
 
-class TradeQueryset(OrderedModelQuerySet):
-    def annotate_base_info(self):
-        return self.annotate(
-            last_effective_date=Subquery(
-                AssetPosition.unannotated_objects.filter(
-                    date__lte=OuterRef("value_date"),
-                    portfolio=OuterRef("portfolio"),
-                )
-                .order_by("-date")
-                .values("date")[:1]
-            ),
-            previous_weight=Coalesce(
-                Subquery(
-                    AssetPosition.unannotated_objects.filter(
-                        underlying_quote=OuterRef("underlying_instrument"),
-                        date=OuterRef("last_effective_date"),
-                        portfolio=OuterRef("portfolio"),
-                    )
-                    .values("portfolio")
-                    .annotate(s=Sum("weighting"))
-                    .values("s")[:1]
-                ),
-                Decimal(0),
-            ),
-            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(
-                        underlying_quote=OuterRef("underlying_instrument"),
-                        date=OuterRef("last_effective_date"),
-                        portfolio=OuterRef("portfolio"),
-                    )
-                    .values("portfolio")
-                    .annotate(s=Sum("shares"))
-                    .values("s")[:1]
-                ),
-                Decimal(0),
-            ),
-            target_shares=F("effective_shares") + F("shares"),
-        )
-
-
-class DefaultTradeManager(OrderedModelManager):
-    """This manager is expect to be the trade default manager and annotate by default the effective weight (extracted
-    from the associated portfolio) and the target weight as an addition between the effective weight and the delta weight
-    """
-
-    def __init__(self, with_annotation: bool = False, *args, **kwargs):
-        self.with_annotation = with_annotation
-        super().__init__(*args, **kwargs)
-
-    def get_queryset(self) -> TradeQueryset:
-        qs = TradeQueryset(self.model, using=self._db)
-        if self.with_annotation:
-            qs = qs.annotate_base_info()
-        return qs
-
-
-class ValidCustomerTradeManager(DefaultTradeManager):
+class ValidCustomerTradeManager(models.Manager):
     def __init__(self, without_internal_trade: bool = False):
         self.without_internal_trade = without_internal_trade
         super().__init__()
@@ -123,20 +50,10 @@ class ValidCustomerTradeManager(DefaultTradeManager):
         return qs
 
 
-class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
+class Trade(TransactionMixin, ImportMixin, 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"
-        SUBMIT = "SUBMIT", "Submit"
-        EXECUTED = "EXECUTED", "Executed"
-        CONFIRMED = "CONFIRMED", "Confirmed"
-        FAILED = "FAILED", "Failed"
 
     class Type(models.TextChoices):
         REBALANCE = "REBALANCE", "Rebalance"
@@ -151,7 +68,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     transaction_subtype = models.CharField(
         max_length=32, default=Type.BUY, choices=Type.choices, verbose_name="Trade Type"
     )
-    status = FSMField(default=Status.CONFIRMED, choices=Status.choices, verbose_name="Status")
     transaction_date = models.DateField(
         verbose_name="Trade Date",
         help_text="The date that this transaction was traded.",
@@ -170,7 +86,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     weighting = models.DecimalField(
         max_digits=9,
-        decimal_places=TRADE_WEIGHTING_PRECISION,
+        decimal_places=8,
         default=Decimal(0),
         help_text="The weight to be multiplied against the target",
         verbose_name="Weight",
@@ -221,23 +137,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         related_name="trades",
         on_delete=models.PROTECT,
     )
-    trade_proposal = models.ForeignKey(
-        to="wbportfolio.TradeProposal",
-        null=True,
-        blank=True,
-        related_name="trades",
-        on_delete=models.CASCADE,
-        help_text="The Trade Proposal this trade is coming from",
-    )
-    drift_factor = models.DecimalField(
-        max_digits=TRADE_WEIGHTING_PRECISION * 2
-        + 3,  # we don't expect any drift factor to be in the order of magnitude greater than 1000
-        decimal_places=TRADE_WEIGHTING_PRECISION
-        * 2,  # we need a higher precision for this factor to avoid float inprecision
-        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",
-    )
     external_id = models.CharField(
         max_length=255,
         null=True,
@@ -254,211 +153,10 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     )
 
     # Manager
-    objects = DefaultTradeManager()
-    annotated_objects = DefaultTradeManager(with_annotation=True)
+    objects = models.Manager()
     valid_customer_trade_objects = ValidCustomerTradeManager()
     valid_external_customer_trade_objects = ValidCustomerTradeManager(without_internal_trade=True)
 
-    @transition(
-        field=status,
-        source=Status.DRAFT,
-        target=GET_STATE(
-            lambda self, **kwargs: (self.Status.SUBMIT if self.price else self.Status.FAILED),
-            states=[Status.SUBMIT, Status.FAILED],
-        ),
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:trade",),
-                icon=WBIcon.SEND.icon,
-                key="submit",
-                label="Submit",
-                action_label="Submit",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-        on_error="FAILED",
-    )
-    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
-        warnings = []
-        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
-        if self.trade_proposal and not self.portfolio.only_weighting:
-            shares = self.trade_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
-            if shares != self.shares:
-                warnings.append(
-                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
-                )
-            shares = round(shares)  # ensure fractional shares are converted into integer
-            # we need to recompute the delta weight has we changed the number of shares
-            if shares != self.shares:
-                self.shares = shares
-                if portfolio_total_asset_value:
-                    self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
-
-        if not self.price:
-            warnings.append(
-                f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
-            )
-        return warnings
-
-    def can_submit(self):
-        pass
-
-    @transition(
-        field=status,
-        source=Status.DRAFT,
-        target=Status.FAILED,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-    )
-    def fail(self, **kwargs):
-        pass
-
-    # TODO To be removed
-    @cached_property
-    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.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.transaction_date)
-                    .latest("date")
-                )
-
-    @transition(
-        field=status,
-        source=Status.SUBMIT,
-        target=Status.EXECUTED,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:trade",),
-                icon=WBIcon.CONFIRM.icon,
-                key="execute",
-                label="Execute",
-                action_label="Execute",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-    )
-    def execute(self, **kwargs):
-        with suppress(ValueError):
-            asset = self.get_asset()
-            AssetPosition.unannotated_objects.update_or_create(
-                underlying_quote=asset.underlying_quote,
-                portfolio_created=asset.portfolio_created,
-                portfolio=asset.portfolio,
-                date=asset.date,
-                defaults={
-                    "initial_currency_fx_rate": asset.initial_currency_fx_rate,
-                    "initial_price": asset.initial_price,
-                    "initial_shares": asset.initial_shares,
-                    "underlying_quote_price": asset.underlying_quote_price,
-                    "asset_valuation_date": asset.asset_valuation_date,
-                    "currency": asset.currency,
-                    "is_estimated": asset.is_estimated,
-                    "weighting": asset.weighting,
-                },
-            )
-
-    def can_execute(self):
-        if not self.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")]
-            }
-
-    @transition(
-        field=status,
-        source=Status.EXECUTED,
-        target=Status.CONFIRMED,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:trade",),
-                icon=WBIcon.CONFIRM.icon,
-                key="confirm",
-                label="Confirm",
-                action_label="Confirme",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-    )
-    def confirm(self, by=None, description=None, **kwargs):
-        pass
-
-    def can_confirm(self):
-        pass
-
-    @transition(
-        field=status,
-        source=Status.SUBMIT,
-        target=Status.DRAFT,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:trade",),
-                icon=WBIcon.UNDO.icon,
-                key="backtodraft",
-                label="Back to Draft",
-                action_label="backtodraft",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-    )
-    def backtodraft(self, **kwargs):
-        pass
-
-    @transition(
-        field=status,
-        source=Status.EXECUTED,
-        target=Status.DRAFT,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        ),
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:trade",),
-                icon=WBIcon.UNDO.icon,
-                key="revert",
-                label="Revert",
-                action_label="revert",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-    )
-    def revert(self, to_date=None, **kwargs):
-        with suppress(AssetPosition.DoesNotExist):
-            asset = AssetPosition.unannotated_objects.get(
-                underlying_quote=self.underlying_instrument,
-                portfolio=self.portfolio,
-                date=self.transaction_date,
-                is_estimated=False,
-            )
-            asset.set_weighting(asset.weighting - self.weighting)
-            asset.save()
-
     @property
     def product(self):
         from wbportfolio.models.products import Product
@@ -468,77 +166,12 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         except Product.DoesNotExist:
             return None
 
-    @property
-    @admin.display(description="Last Effective Date")
-    def _last_effective_date(self) -> date:
-        if hasattr(self, "last_effective_date"):
-            return self.last_effective_date
-        elif (
-            assets := AssetPosition.unannotated_objects.filter(
-                date__lte=self.value_date,
-                portfolio=self.portfolio,
-            )
-        ).exists():
-            return assets.latest("date").date
-
-    @property
-    @admin.display(description="Effective Weight")
-    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)
-
-    @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")
-    def _effective_shares(self) -> Decimal:
-        return getattr(
-            self,
-            "effective_shares",
-            AssetPosition.objects.filter(
-                underlying_quote=self.underlying_instrument,
-                date=self.transaction_date,
-                portfolio=self.portfolio,
-            ).aggregate(s=Sum("shares"))["s"]
-            or Decimal(0),
-        )
-
-    @property
-    @admin.display(description="Target Weight")
-    def _target_weight(self) -> Decimal:
-        return getattr(
-            self, "target_weight", round(self._effective_weight + self.weighting, self.TRADE_WEIGHTING_PRECISION)
-        )
-
-    @_target_weight.setter
-    def _target_weight(self, target_weight):
-        self.weighting = Decimal(target_weight) - self._effective_weight
-        self._set_type()
-
-    @property
-    @admin.display(description="Target Shares")
-    def _target_shares(self) -> Decimal:
-        return getattr(self, "target_shares", self._effective_shares + self.shares)
-
-    order_with_respect_to = "trade_proposal"
-
-    class Meta(OrderedModel.Meta):
+    class Meta:
         verbose_name = "Trade"
         verbose_name_plural = "Trades"
         indexes = [
             models.Index(fields=["underlying_instrument", "transaction_date"]),
             models.Index(fields=["portfolio", "underlying_instrument", "transaction_date"]),
-            # models.Index(fields=["date", "underlying_instrument"]),
         ]
         constraints = [
             models.CheckConstraint(
@@ -557,38 +190,20 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 ),
                 name="internal_trade_set_only_for_subred",
             ),
-            models.UniqueConstraint(
-                fields=["portfolio", "transaction_date", "underlying_instrument"],
-                name="unique_manual_trade",
-                condition=Q(trade_proposal__isnull=False),
-            ),
         ]
         # notification_email_template = "portfolio/email/trade_notification.html"
 
     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
-                self.underlying_instrument.save()
-            self.portfolio = self.trade_proposal.portfolio
-            self.transaction_date = self.trade_proposal.trade_date
-            self.value_date = self.trade_proposal.last_effective_date
         if not self.price:
             # we try to get the price if not provided directly from the underlying instrument
             self.price = self.get_price()
-        if self.trade_proposal and not self.portfolio.only_weighting:
-            estimated_shares = self.trade_proposal.get_estimated_shares(
-                self.weighting, self.underlying_instrument, self.price
-            )
-            if estimated_shares:
-                self.shares = estimated_shares
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
 
-        if self.transaction_subtype is None or self.trade_proposal:
+        if self.transaction_subtype is None:
             # if subtype not provided, we extract it automatically from the existing data.
             self._set_type()
         if self.id and hasattr(self, "claims"):
@@ -612,42 +227,12 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                     self.transaction_subtype = Trade.Type.REDEMPTION
         elif self.weighting is not None:
             if self.weighting > 0:
-                if self._effective_weight:
-                    self.transaction_subtype = Trade.Type.INCREASE
-                else:
-                    self.transaction_subtype = Trade.Type.BUY
+                self.transaction_subtype = Trade.Type.INCREASE
             elif self.weighting < 0:
-                if self._target_weight:
-                    self.transaction_subtype = Trade.Type.DECREASE
-                else:
-                    self.transaction_subtype = Trade.Type.SELL
+                self.transaction_subtype = Trade.Type.DECREASE
         else:
             self.transaction_subtype = Trade.Type.REBALANCE
 
-    def get_type(self) -> str:
-        """
-        Return the expected transaction subtype based n
-
-        """
-
-    def get_asset(self) -> AssetPosition:
-        asset = AssetPosition(
-            underlying_quote=self.underlying_instrument,
-            portfolio_created=None,
-            portfolio=self.portfolio,
-            date=self.transaction_date,
-            initial_currency_fx_rate=self.currency_fx_rate,
-            weighting=self._target_weight,
-            initial_price=self.price,
-            initial_shares=None,
-            asset_valuation_date=self.transaction_date,
-            currency=self.currency,
-            is_estimated=False,
-        )
-        asset.set_weighting(self._target_weight)
-        asset.pre_save()
-        return asset
-
     def get_price(self) -> Decimal:
         try:
             return self.underlying_instrument.get_price(self.transaction_date)
@@ -662,31 +247,6 @@ 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, 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,
-            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,
-            currency=self.underlying_instrument.currency,
-            date=self.transaction_date,
-            is_cash=self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent,
-        )
-
     def get_alternative_valid_trades(self, share_delta: float = 0):
         return Trade.objects.filter(
             Q(underlying_instrument=self.underlying_instrument)

wbportfolio/pms/analytics/portfolio.py

@@ -2,6 +2,8 @@ import numpy as np
 import pandas as pd
 from skfolio import Portfolio as BasePortfolio
 
+from .utils import fix_quantization_error
+
 
 class Portfolio(BasePortfolio):
     @property
@@ -16,6 +18,12 @@ class Portfolio(BasePortfolio):
         )
         return df
 
+    def get_contributions(self) -> tuple[pd.Series, float]:
+        returns = self.X.iloc[-1, :].T
+        weights = self.all_weights_per_observation.iloc[-1, :].T
+        portfolio_returns = (weights * (returns + 1.0)).sum()
+        return returns, portfolio_returns
+
     def get_next_weights(self, round_precision: int = 8) -> dict[int, float]:
         """
         Given the next returns, compute the drifted weights of this portfolio
@@ -23,17 +31,13 @@ class Portfolio(BasePortfolio):
         Returns:
             A dictionary of weights (instrument ids as keys and weights as values)
         """
-        returns = self.X.iloc[-1, :].T
+        returns, portfolio_returns = self.get_contributions()
         weights = self.all_weights_per_observation.iloc[-1, :].T
-        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()
         if round_precision and not next_weights.empty:
-            next_weights = next_weights.round(round_precision)
-            quantization_error = 1.0 - next_weights.sum()
-            largest_weight = next_weights.idxmax()
-            next_weights.loc[largest_weight] = next_weights.loc[largest_weight] + quantization_error
+            next_weights = fix_quantization_error(next_weights, round_precision)
         return {i: round(w, round_precision) for i, w in next_weights.items()}  # handle float precision manually
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:

wbportfolio/pms/analytics/utils.py

@@ -0,0 +1,9 @@
+import pandas as pd
+
+
+def fix_quantization_error(df: pd.Series, round_precision: int):
+    df = df.round(round_precision)
+    quantization_error = 1.0 - df.sum()
+    largest_weight = df.idxmax()
+    df.loc[largest_weight] = df.loc[largest_weight] + quantization_error
+    return df

wbportfolio/pms/trading/handler.py

@@ -117,7 +117,7 @@ class TradingService:
         if self._effective_portfolio:
             for trade in validated_trades:
                 if (
-                    trade.effective_weight
+                    trade.previous_weight
                     and trade.underlying_instrument not in self._effective_portfolio.positions_map
                 ):
                     raise ValidationError("All effective position needs to be matched with a validated trade")
@@ -137,6 +137,7 @@ class TradingService:
 
         Returns: The normalized trades batch
         """
+
         instruments = effective_portfolio.positions_map.copy()
         instruments.update(target_portfolio.positions_map)
 
@@ -145,11 +146,11 @@ class TradingService:
             if not pos.is_cash:
                 previous_weight = target_weight = 0
                 effective_shares = target_shares = 0
-                drift_factor = 1.0
+                daily_return = 0
                 if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
                     previous_weight = effective_pos.weighting
                     effective_shares = effective_pos.shares
-                    drift_factor = effective_pos.drift_factor
+                    daily_return = effective_pos.daily_return
                 if target_pos := target_portfolio.positions_map.get(instrument_id, None):
                     target_weight = target_pos.weighting
                     if target_pos.shares is not None:
@@ -165,7 +166,8 @@ class TradingService:
                     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),
+                    daily_return=Decimal(daily_return),
+                    portfolio_contribution=effective_portfolio.portfolio_contribution,
                 )
                 trades.append(trade)
         return TradeBatch(trades)