wbportfolio 1.52.5__py2.py3-none-any.whl → 1.53.0__py2.py3-none-any.whl

wbportfolio/factories/portfolios.py

@@ -19,6 +19,7 @@ class PortfolioFactory(factory.django.DjangoModelFactory):
     is_manageable = True
     is_tracked = True
     is_lookthrough = False
+    only_weighting = True
     invested_timespan = DateRange(date.min, date.max)
 
     @factory.post_generation

wbportfolio/migrations/0078_trade_drift_factor.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.0.14 on 2025-07-02 13:10
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0077_remove_transaction_currency_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='trade',
+            name='drift_factor',
+            field=models.DecimalField(decimal_places=6, default=Decimal('1'), help_text='Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return', max_digits=16, verbose_name='Drift Factor'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'),
+                                      help_text='The weight to be multiplied against the target', max_digits=9,
+                                      verbose_name='Weight'),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -693,7 +693,7 @@ class AssetPosition(ImportMixin, models.Model):
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)
 
-    def _build_dto(self, new_weight: Decimal = None) -> PositionDTO:
+    def _build_dto(self, new_weight: Decimal = None, **kwargs) -> PositionDTO:
         """
         Data Transfer Object
         Returns:
@@ -708,7 +708,7 @@ class AssetPosition(ImportMixin, models.Model):
             instrument_type=self.underlying_quote.security_instrument_type.id,
             currency=self.underlying_quote.currency.id,
             country=self.underlying_quote.country.id if self.underlying_quote.country else None,
-            is_cash=self.underlying_quote.is_cash,
+            is_cash=self.underlying_quote.is_cash or self.underlying_quote.is_cash_equivalent,
             primary_classification=(
                 self.underlying_quote.primary_classification.id
                 if self.underlying_quote.primary_classification
@@ -726,6 +726,7 @@ class AssetPosition(ImportMixin, models.Model):
             price=self._price,
             currency_fx_rate=self._currency_fx_rate,
             portfolio_created=self.portfolio_created.id if self.portfolio_created else None,
+            **kwargs,
         )
 
     @cached_property

wbportfolio/models/portfolio.py

@@ -355,8 +355,23 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def _build_dto(self, val_date: date, **extra_kwargs) -> PortfolioDTO:
         "returns the dto representation of this portfolio at the specified date"
+        assets = self.assets.filter(date=val_date, **extra_kwargs)
+        try:
+            drifted_weights = self.get_analytic_portfolio(val_date).get_next_weights()
+        except InvalidAnalyticPortfolio:
+            drifted_weights = {}
         return PortfolioDTO(
-            tuple([pos._build_dto() for pos in self.assets.filter(date=val_date, **extra_kwargs)]),
+            tuple(
+                [
+                    pos._build_dto(
+                        drift_factor=drifted_weights.get(pos.underlying_quote.id, float(pos.weighting))
+                        / float(pos.weighting)
+                        if pos.weighting
+                        else Decimal(1.0)
+                    )
+                    for pos in assets
+                ]
+            ),
         )
 
     def get_weights(self, val_date: date) -> dict[int, float]:
@@ -926,7 +941,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if self.is_composition:
             assets = list(self.get_lookthrough_positions(val_date, **kwargs))
         else:
-            assets = self.assets.filter(date=val_date)
+            assets = list(self.assets.filter(date=val_date))
         return assets
 
     def compute_lookthrough(self, from_date: date, to_date: date | None = None):

wbportfolio/models/transactions/trade_proposals.py

@@ -1,11 +1,11 @@
 import logging
+import math
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from celery import shared_task
-from django.contrib.messages import error, info
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.functional import cached_property
@@ -92,14 +92,14 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         super().save(*args, **kwargs)
 
-    @property
-    def checked_object(self):
-        return self.portfolio
-
     @property
     def check_evaluation_date(self):
         return self.trade_date
 
+    @property
+    def checked_object(self) -> Any:
+        return self.portfolio
+
     @cached_property
     def portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.last_effective_date)
@@ -109,10 +109,13 @@ 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()
+
         return TradingService(
             self.trade_date,
-            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
-            target_portfolio=self._build_dto().convert_to_portfolio(),
+            effective_portfolio=self._get_default_effective_portfolio(),
+            target_portfolio=target_portfolio,
+            total_target_weight=target_portfolio.total_weight,
         )
 
     @cached_property
@@ -197,25 +200,30 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return trade_proposal_clone
 
-    def normalize_trades(self):
+    def normalize_trades(self, total_target_weight: Decimal = Decimal("1.0")):
         """
         Call the trading service with the existing trades and normalize them in order to obtain a total sum target weight of 100%
         The existing trade will be modified directly with the given normalization factor
         """
-        service = TradingService(self.trade_date, trades_batch=self._build_dto())
-        service.normalize()
+        service = TradingService(
+            self.trade_date,
+            effective_portfolio=self._get_default_effective_portfolio(),
+            target_portfolio=self._build_dto().convert_to_portfolio(),
+            total_target_weight=total_target_weight,
+        )
         leftovers_trades = self.trades.all()
-        total_target_weight = Decimal("0.0")
         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.save()
-                total_target_weight += trade._target_weight
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
         leftovers_trades.delete()
+        t_weight = self.trades.all().annotate_base_info().aggregate(models.Sum("target_weight"))[
+            "target_weight__sum"
+        ] or Decimal("0.0")
         # we handle quantization error due to the decimal max digits. In that case, we take the biggest trade (highest weight) and we remove the quantization error
-        if quantize_error := (total_target_weight - Decimal("1.0")):
+        if quantize_error := (t_weight - total_target_weight):
             biggest_trade = self.trades.latest("weighting")
             biggest_trade.weighting -= quantize_error
             biggest_trade.save()
@@ -232,23 +240,31 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if self.trades.exists():
             return self._build_dto().convert_to_portfolio()
         # Return the current portfolio by default
+        return self._get_default_effective_portfolio()
+
+    def _get_default_effective_portfolio(self):
         return self.portfolio._build_dto(self.last_effective_date)
 
-    def reset_trades(self, target_portfolio: PortfolioDTO | None = None, validate_trade: bool = True):
+    def reset_trades(
+        self,
+        target_portfolio: PortfolioDTO | 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`
         """
         # delete all existing trades
         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_default_target_portfolio()
         if target_portfolio:
             service = TradingService(
                 self.trade_date,
-                effective_portfolio=effective_portfolio,
+                effective_portfolio=self._get_default_effective_portfolio(),
                 target_portfolio=target_portfolio,
+                total_target_weight=total_target_weight,
             )
             if validate_trade:
                 service.is_valid()
@@ -262,11 +278,13 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 )
                 # 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,
@@ -276,9 +294,15 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         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 replay(self):
@@ -329,7 +353,7 @@ 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) -> Decimal:
+    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument, quote_price: Decimal) -> Decimal:
         """
         Estimates the number of shares for a trade based on the given weight and underlying quote.
 
@@ -342,23 +366,29 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         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))
+        # 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
 
-            # Calculate the trade's total value in the portfolio's currency
-            trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
+        # 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
-            )
+        # 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
+        )
+
+        # If the price is valid, calculate and return the estimated shares
+        if price_fx_portfolio:
+            return trade_total_value_fx_portfolio / price_fx_portfolio
 
-            # 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:
-            raise ValueError("We couldn't estimate the number of shares")
+    def get_round_lot_size(self, shares: Decimal, underlying_quote: Instrument) -> Decimal:
+        if (round_lot_size := underlying_quote.round_lot_size) != 1 and (
+            not underlying_quote.exchange or underlying_quote.exchange.apply_round_lot_size
+        ):
+            if shares > 0:
+                shares = math.ceil(shares / round_lot_size) * round_lot_size
+            elif abs(shares) > round_lot_size:
+                shares = math.floor(shares / round_lot_size) * round_lot_size
+        return shares
 
     def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
@@ -399,7 +429,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
             # Estimate the target shares for the cash component
             with suppress(ValueError):
-                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component, Decimal("1.0"))
 
         cash_component = Cash.objects.get_or_create(
             currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
@@ -447,46 +477,25 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         trades = []
-        trades_validation_errors = []
+        trades_validation_warnings = []
         for trade in self.trades.all():
-            if not trade.last_underlying_quote_price:
-                trade.status = Trade.Status.FAILED
-                trades_validation_errors.append(
-                    f"Trade failed because no price is found for {trade.underlying_instrument.computed_str} on {trade.transaction_date:%Y-%m-%d}"
-                )
-            else:
-                trade.status = Trade.Status.SUBMIT
+            trade_warnings = trade.submit(
+                by=by, description=description, portfolio_total_asset_value=self.portfolio_total_asset_value, **kwargs
+            )
+            if trade_warnings:
+                trades_validation_warnings.extend(trade_warnings)
             trades.append(trade)
 
-        Trade.objects.bulk_update(trades, ["status"])
+        Trade.objects.bulk_update(trades, ["status", "shares", "weighting"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
-        target_portfolio = self.validated_trading_service.target_portfolio
-        if estimated_cash_position.weighting:
-            if existing_cash_position := target_portfolio.positions_map.get(
-                estimated_cash_position.underlying_quote.id
-            ):
-                existing_cash_position += estimated_cash_position
-            else:
-                target_portfolio.positions_map[estimated_cash_position.underlying_quote.id] = (
-                    estimated_cash_position._build_dto()
-                )
-            target_portfolio = PortfolioDTO(positions=tuple(target_portfolio.positions_map.values()))
+        target_portfolio = self.validated_trading_service.trades_batch.convert_to_portfolio(
+            estimated_cash_position._build_dto()
+        )
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
-
-        if (
-            trades_validation_errors
-            and (fsm_context := getattr(self, "fsm_context", None))
-            and (request := fsm_context.get("request", None))
-        ):
-            msg = f"""The reason for the failed trades are: <ul>
-            {''.join(map(lambda o: '<li>' + o + '</li>', trades_validation_errors))}
-            </ul>
-            """
-            error(request, msg, extra_tags="auto_close=0")
+        return trades_validation_warnings
 
     def can_submit(self):
         errors = dict()
@@ -496,7 +505,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         service = self.validated_trading_service
         try:
             service.is_valid(ignore_error=True)
-            # if service.trades_batch.totat_abs_delta_weight == 0:
+            # if service.trades_batch.total_abs_delta_weight == 0:
             #     errors_list.append(
             #         "There is no change detected in this trade proposal. Please submit at last one valid trade"
             #     )
@@ -542,6 +551,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
         trades = []
         assets = []
+        warnings = []
         # We do not want to create the estimated cash position if there is not trades in the trade proposal (shouldn't be possible anyway)
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
 
@@ -556,13 +566,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         # if there is cash leftover, we create an extra asset position to hold the cash component
         if estimated_cash_position.weighting and len(trades) > 0:
+            warnings.append(
+                f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}"
+            )
             estimated_cash_position.pre_save()
             assets.append(estimated_cash_position)
-            if (fsm_context := getattr(self, "fsm_context", None)) and (request := fsm_context.get("request", None)):
-                info(
-                    request,
-                    f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}",
-                )
 
         Trade.objects.bulk_update(trades, ["status"])
         self.portfolio.bulk_create_positions(
@@ -570,6 +578,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         )
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id, user_id=by.id if by else None)
+        return warnings
 
     def can_approve(self):
         errors = dict()

wbportfolio/models/transactions/trades.py

@@ -53,7 +53,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 .order_by("-date")
                 .values("date")[:1]
             ),
-            effective_weight=Coalesce(
+            _previous_weight=Coalesce(
                 Subquery(
                     AssetPosition.unannotated_objects.filter(
                         underlying_quote=OuterRef("underlying_instrument"),
@@ -66,6 +66,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 ),
                 Decimal(0),
             ),
+            effective_weight=F("_previous_weight") * F("drift_factor"),
             target_weight=F("effective_weight") + F("weighting"),
             effective_shares=Coalesce(
                 Subquery(
@@ -163,8 +164,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     )
 
     weighting = models.DecimalField(
-        max_digits=16,
-        decimal_places=6,
+        max_digits=9,
+        decimal_places=8,
         default=Decimal(0),
         help_text="The weight to be multiplied against the target",
         verbose_name="Weight",
@@ -223,7 +224,13 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         on_delete=models.CASCADE,
         help_text="The Trade Proposal this trade is coming from",
     )
-
+    drift_factor = models.DecimalField(
+        max_digits=16,
+        decimal_places=6,
+        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,
@@ -249,9 +256,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         field=status,
         source=Status.DRAFT,
         target=GET_STATE(
-            lambda self, **kwargs: (
-                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
-            ),
+            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(
@@ -270,8 +275,27 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         },
         on_error="FAILED",
     )
-    def submit(self, by=None, description=None, **kwargs):
-        pass
+    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
@@ -287,6 +311,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def fail(self, **kwargs):
         pass
 
+    # TODO To be removed
     @cached_property
     def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
@@ -343,7 +368,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             )
 
     def can_execute(self):
-        if not self.last_underlying_quote_price:
+        if not self.price:
             return {"underlying_instrument": [_("Cannot execute a trade without a valid quote price")]}
         if not self.portfolio.is_manageable:
             return {
@@ -453,16 +478,14 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     @property
     @admin.display(description="Effective Weight")
     def _effective_weight(self) -> Decimal:
-        return getattr(
-            self,
-            "effective_weight",
-            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),
-        )
+        if hasattr(self, "effective_weight"):
+            return self.effective_weight
+        previous_weight = 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 previous_weight * self.drift_factor
 
     @property
     @admin.display(description="Effective Shares")
@@ -531,19 +554,24 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     def save(self, *args, **kwargs):
         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.portfolio.only_weighting:
-                with suppress(ValueError):
-                    self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
+        if self.price is None:
+            # 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.price is None:
-            # we try to get the price if not provided directly from the underlying instrument
-            with suppress(Exception):
-                self.price = self.underlying_instrument.get_price(self.value_date)
 
         if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
@@ -588,9 +616,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         """
 
     def get_asset(self) -> AssetPosition:
-        last_underlying_quote_price = self.last_underlying_quote_price
-        if not last_underlying_quote_price:
-            raise ValueError("No price found")
         asset = AssetPosition(
             underlying_quote=self.underlying_instrument,
             portfolio_created=None,
@@ -598,9 +623,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             date=self.transaction_date,
             initial_currency_fx_rate=self.currency_fx_rate,
             weighting=self._target_weight,
-            initial_price=self.last_underlying_quote_price.net_value,
+            initial_price=self.price,
             initial_shares=None,
-            underlying_quote_price=self.last_underlying_quote_price,
             asset_valuation_date=self.transaction_date,
             currency=self.currency,
             is_estimated=False,
@@ -609,6 +633,11 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         asset.pre_save()
         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))
+
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)
         super().delete(**kwargs)
@@ -628,9 +657,14 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             underlying_instrument=self.underlying_instrument.id,
             effective_weight=self._effective_weight,
             target_weight=self._target_weight,
+            effective_shares=self._effective_shares,
+            target_shares=self._target_shares,
+            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):