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

wbportfolio/migrations/0084_orderproposal_min_order_value.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0.14 on 2025-07-30 14:25
+
+from django.db import migrations, models
+from decimal import Decimal
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0083_order_alter_trade_options_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='orderproposal',
+            name='min_order_value',
+            field=models.IntegerField(default=0, help_text='Minimum Order Value in the Portfolio currency', verbose_name='Minimum Order Value'),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='desired_target_weight',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'),
+                                      help_text='Desired Target Weight (for compliance and audit)', max_digits=9,
+                                      verbose_name='Desired Target Weight'),
+        ),
+    ]

wbportfolio/migrations/0085_order_desired_target_weight.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.0.14 on 2025-07-30 14:40
+
+from decimal import Decimal
+from django.db import migrations, models
+from tqdm import tqdm
+
+def migrate_desired_target_weight(apps, schema_editor):
+    from wbportfolio.models.orders import Order, OrderProposal
+    objs = []
+    qs = OrderProposal.objects.filter(orders__isnull=False).distinct()
+    for op in tqdm(qs, total=qs.count()):
+        for o in op.get_orders():
+            o.desired_target_weight = o._target_weight
+            objs.append(o)
+    Order.objects.bulk_update(objs, ["desired_target_weight"], batch_size=10000)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0084_orderproposal_min_order_value'),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_desired_target_weight)
+    ]

wbportfolio/models/asset.py

@@ -1,4 +1,4 @@
-from collections import defaultdict
+import logging
 from contextlib import suppress
 from datetime import date
 from decimal import Decimal, InvalidOperation
@@ -43,6 +43,8 @@ from wbportfolio.models.portfolio_relationship import (
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.typing import Position as PositionDTO
 
+logger = logging.getLogger("pms")
+
 MARKETCAP_S = 2_000_000_000
 MARKETCAP_M = 10_000_000_000
 MARKETCAP_L = 50_000_000_000
@@ -55,146 +57,7 @@ HOUR = MINUTE * 60
 DAY = HOUR * 24
 
 if TYPE_CHECKING:
-    from wbportfolio.models.portfolio import Portfolio
-
-
-class AssetPositionIterator:
-    """
-    Efficiently converts position data into AssetPosition models with batch operations
-    and proper dependency management.
-
-    Features:
-    - Bulk database fetching for performance
-    - Thread-safe operations
-    - Clear type hints
-    - Memory-efficient storage
-    """
-
-    positions: dict[tuple[date, int, int | None], "AssetPosition"]
-
-    _prices: dict[date, dict[int, float]]
-    _weights: dict[date, dict[int, float]]
-    _fx_rates: dict[date, dict[Currency, CurrencyFXRates]]
-    _instruments: dict[int, Instrument]
-
-    def __init__(
-        self,
-        portfolio: "Portfolio",
-        prices: dict[date, dict[int, float]] | None = None,
-        infer_underlying_quote_price: bool = False,
-    ):
-        self.portfolio = portfolio
-        self.infer_underlying_quote_price = infer_underlying_quote_price
-        # Initialize data stores with type hints
-        self._instruments = {}
-        self._fx_rates = defaultdict(dict)
-        self._weights = defaultdict(dict)
-        self._prices = prices or defaultdict(dict)
-        self.positions = dict()
-
-    def _get_instrument(self, instrument_id: int) -> Instrument:
-        try:
-            return self._instruments[instrument_id]
-        except KeyError:
-            instrument = Instrument.objects.get(id=instrument_id)
-            self._instruments[instrument_id] = instrument
-            return instrument
-
-    def _get_fx_rate(self, val_date: date, currency: Currency) -> CurrencyFXRates | None:
-        try:
-            return self._fx_rates[val_date][currency]
-        except KeyError:
-            with suppress(CurrencyFXRates.DoesNotExist):
-                fx_rate = CurrencyFXRates.objects.get(
-                    currency=currency, date=val_date
-                )  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
-                self._fx_rates[val_date][currency] = fx_rate
-                return fx_rate
-
-    def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
-        try:
-            return self._prices[val_date][instrument.id]
-        except KeyError:
-            return None
-
-    def _dict_to_model(self, val_date: date, instrument_id: int, weighting: float, **kwargs) -> "AssetPosition":
-        underlying_quote = self._get_instrument(instrument_id)
-        currency_fx_rate_portfolio_to_usd = self._get_fx_rate(val_date, self.portfolio.currency)
-        currency_fx_rate_instrument_to_usd = self._get_fx_rate(val_date, underlying_quote.currency)
-        price = self._get_price(val_date, underlying_quote)
-
-        parameters = dict(
-            underlying_quote=underlying_quote,
-            weighting=round(weighting, 8),
-            date=val_date,
-            asset_valuation_date=val_date,
-            is_estimated=True,
-            portfolio=self.portfolio,
-            currency=underlying_quote.currency,
-            initial_price=price,
-            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
-            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
-            initial_currency_fx_rate=None,
-            underlying_quote_price=None,
-            underlying_instrument=None,
-        )
-        parameters.update(kwargs)
-        position = AssetPosition(**parameters)
-        position.pre_save(
-            infer_underlying_quote_price=self.infer_underlying_quote_price
-        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
-        return position
-
-    def add(self, positions: list["AssetPosition"] | tuple[date, dict[int, float]], **kwargs):
-        """
-        Add multiple positions efficiently with batch processing
-
-        Args:
-            positions: Iterable of AssetPosition instances or dictionary of weight {instrument_id: weight} that needs to be converted into AssetPosition
-        """
-        if isinstance(positions, tuple):
-            val_date = positions[0]
-            positions = [(val_date, i, w) for i, w in positions[1].items()]  # unflatten data to make it iterable
-        for position in positions:
-            if not isinstance(position, AssetPosition):
-                position = self._dict_to_model(*position, **kwargs)
-
-            # Generate unique composite key
-            key = (
-                position.date,
-                position.underlying_quote.id,
-                position.portfolio_created.id if position.portfolio_created else None,
-            )
-            # Merge duplicate positions
-            if existing_position := self.positions.get(key):
-                position.weighting += existing_position.weighting
-                if existing_position.initial_shares:
-                    position.initial_shares += existing_position.initial_shares
-            # ensure the position portfolio is the iterator portfolio (could be different when computing look-through for instance)
-            position.portfolio = self.portfolio
-            if position.initial_price is not None and position.initial_currency_fx_rate is not None:
-                self.positions[key] = position
-                self._weights[position.date][position.underlying_quote.id] = float(position.weighting)
-
-        return self
-
-    def get_dates(self) -> list[date]:
-        """Get sorted list of unique dates"""
-        return list(self._weights.keys())
-
-    def get_weights(self) -> dict[date, dict[int, float]]:
-        """Get weight structure with instrument IDs as keys"""
-        return dict(self._weights)
-
-    def __iter__(self):
-        # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
-        yield from filter(lambda a: not a.portfolio.is_manageable or a.weighting, self.positions.values())
-
-    def __getitem__(self, item: tuple[date, Instrument]) -> float:
-        return self._weights[item[0]][item[1].id]
-
-    def __bool__(self) -> bool:
-        return len(self.positions.keys()) > 0
+    pass
 
 
 class AssetPositionDefaultQueryset(QuerySet):

wbportfolio/models/builder.py

@@ -0,0 +1,258 @@
+import logging
+from collections import defaultdict
+from contextlib import suppress
+from datetime import date
+from typing import TYPE_CHECKING
+
+import pandas as pd
+from celery import chain, group
+from django.contrib.contenttypes.models import ContentType
+from pandas._libs.tslibs.offsets import BDay
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbfdm.contrib.metric.tasks import compute_metrics_as_task
+from wbfdm.models import Instrument
+
+from wbportfolio.models.asset import AssetPosition
+from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
+
+if TYPE_CHECKING:
+    from wbportfolio.models import Portfolio
+logger = logging.getLogger("pms")
+
+
+class AssetPositionBuilder:
+    """
+    Efficiently converts position data into AssetPosition models with batch operations
+    and proper dependency management.
+
+    Features:
+    - Bulk database fetching for performance
+    - Thread-safe operations
+    - Clear type hints
+    - Memory-efficient storage
+    """
+
+    _positions: dict[date, dict[tuple[int, int | None], "AssetPosition"]]
+
+    _prices: dict[date, dict[int, float]]
+    _fx_rates: dict[date, dict[Currency, CurrencyFXRates]]
+    _instruments: dict[int, Instrument]
+
+    def __init__(
+        self,
+        portfolio: "Portfolio",
+    ):
+        self.portfolio = portfolio
+        # Initialize data stores with type hints
+        self._instruments = {}
+        self._fx_rates = defaultdict(dict)
+        self.prices = defaultdict(dict)
+        self.returns = pd.DataFrame()
+        self._compute_metrics_tasks = set()
+        self._change_at_date_tasks = dict()
+        self._positions = defaultdict(dict)
+
+    def get_positions(self, **kwargs):
+        # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
+        for _, positions in self._positions.items():
+            for _, position in positions.items():
+                if not position.portfolio.is_manageable or position.weighting:
+                    for k, v in kwargs.items():
+                        setattr(position, k, v)
+                    yield position
+
+    def __bool__(self) -> bool:
+        return len(self._positions.keys()) > 0
+
+    def _get_instrument(self, instrument_id: int) -> Instrument:
+        try:
+            return self._instruments[instrument_id]
+        except KeyError:
+            instrument = Instrument.objects.get(id=instrument_id)
+            self._instruments[instrument_id] = instrument
+            return instrument
+
+    def _get_fx_rate(self, val_date: date, currency: Currency) -> CurrencyFXRates | None:
+        try:
+            return self._fx_rates[val_date][currency]
+        except KeyError:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                fx_rate = CurrencyFXRates.objects.get(
+                    currency=currency, date=val_date
+                )  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
+                self._fx_rates[val_date][currency] = fx_rate
+                return fx_rate
+
+    def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
+        try:
+            return self.prices[val_date][instrument.id]
+        except KeyError:
+            return None
+
+    def _dict_to_model(
+        self,
+        val_date: date,
+        instrument_id: int,
+        weighting: float,
+        infer_underlying_quote_price: bool = False,
+        **kwargs,
+    ) -> "AssetPosition":
+        underlying_quote = self._get_instrument(instrument_id)
+        currency_fx_rate_portfolio_to_usd = self._get_fx_rate(val_date, self.portfolio.currency)
+        currency_fx_rate_instrument_to_usd = self._get_fx_rate(val_date, underlying_quote.currency)
+        price = self._get_price(val_date, underlying_quote)
+
+        parameters = dict(
+            underlying_quote=underlying_quote,
+            weighting=round(weighting, 8),
+            date=val_date,
+            asset_valuation_date=val_date,
+            is_estimated=True,
+            portfolio=self.portfolio,
+            currency=underlying_quote.currency,
+            initial_price=price,
+            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
+            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
+            initial_currency_fx_rate=None,
+            underlying_quote_price=None,
+            underlying_instrument=None,
+        )
+        parameters.update(kwargs)
+        position = AssetPosition(**parameters)
+        position.pre_save(
+            infer_underlying_quote_price=infer_underlying_quote_price
+        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
+        return position
+
+    def set_return(self, returns: pd.DataFrame):
+        self.returns = returns
+
+    def set_prices(self, prices: dict[date, dict[int, float]] | None = None):
+        self.prices = prices
+
+    def load_returns(self, instrument_ids: list[int], from_date: date, to_date: date):
+        self.prices, self.returns = Instrument.objects.filter(id__in=instrument_ids).get_returns_df(
+            from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=True
+        )
+
+    def add(
+        self,
+        positions: list["AssetPosition"] | tuple[date, dict[int, float]],
+        infer_underlying_quote_price: bool = False,
+    ):
+        """
+        Add multiple positions efficiently with batch processing
+
+        Args:
+            positions: Iterable of AssetPosition instances or dictionary of weight {instrument_id: weight} that needs to be converted into AssetPosition
+        """
+        if isinstance(positions, tuple):
+            val_date = positions[0]
+            positions = [(val_date, i, w) for i, w in positions[1].items()]  # unflatten data to make it iterable
+        for position in positions:
+            if not isinstance(position, AssetPosition):
+                position = self._dict_to_model(*position, infer_underlying_quote_price=infer_underlying_quote_price)
+
+            # Generate unique composite key
+            key = (
+                position.underlying_quote.id,
+                position.portfolio_created.id if position.portfolio_created else None,
+            )
+            # Merge duplicate positions
+            if existing_position := self._positions[position.date].get(key):
+                position.weighting += existing_position.weighting
+                if existing_position.initial_shares:
+                    position.initial_shares += existing_position.initial_shares
+            # ensure the position portfolio is the iterator portfolio (could be different when computing look-through for instance)
+            position.portfolio = self.portfolio
+            if position.initial_price is not None and position.initial_currency_fx_rate is not None:
+                self._positions[position.date][key] = position
+        return self
+
+    def get_dates(self) -> list[date]:
+        """Get sorted list of unique dates"""
+        return list(sorted(self._positions.keys()))
+
+    def _get_portfolio(self, val_date: date) -> AnalyticPortfolio:
+        """Get weight structure with instrument IDs as keys"""
+        positions = self._positions[val_date]
+        next_returns = self.returns.loc[[(val_date + BDay(1)).date()], :]
+        weights = dict(map(lambda row: (row[1].underlying_quote.id, float(row[1].weighting)), positions.items()))
+        return AnalyticPortfolio(weights=weights, X=next_returns)
+
+    def bulk_create_positions(self, delete_leftovers: bool = False, force_save: bool = False, **kwargs):
+        positions = list(self.get_positions(**kwargs))
+
+        # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
+        # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
+        # change completely the trades of a portfolio model and drift it.
+        dates = self.get_dates()
+        self.portfolio.assets.filter(date__in=dates, is_estimated=True).delete()
+
+        if len(positions) > 0:
+            if self.portfolio.is_tracked or force_save:  # if the portfolio is not "tracked", we do no drift weights
+                leftover_positions_ids = list(
+                    self.portfolio.assets.filter(date__in=dates).values_list("id", flat=True)
+                )  # we need to get the ids otherwise the queryset is reevaluated later
+                logger.info(f"bulk saving {len(positions)} positions ({len(leftover_positions_ids)} leftovers) ...")
+                objs = AssetPosition.unannotated_objects.bulk_create(
+                    positions,
+                    update_fields=[
+                        "weighting",
+                        "initial_price",
+                        "initial_currency_fx_rate",
+                        "initial_shares",
+                        "currency_fx_rate_instrument_to_usd",
+                        "currency_fx_rate_portfolio_to_usd",
+                        "underlying_quote_price",
+                        "portfolio",
+                        "portfolio_created",
+                        "underlying_instrument",
+                    ],
+                    unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
+                    update_conflicts=True,
+                    batch_size=10000,
+                )
+                if delete_leftovers:
+                    objs_ids = list(map(lambda x: x.id, objs))
+                    leftover_positions_ids = list(filter(lambda i: i not in objs_ids, leftover_positions_ids))
+                    logger.info(f"deleting {len(leftover_positions_ids)} leftover positions..")
+                    AssetPosition.objects.filter(id__in=leftover_positions_ids).delete()
+
+            for val_date in self.get_dates():
+                if self.portfolio.is_tracked:
+                    with suppress(KeyError):
+                        changed_portfolio = self._get_portfolio(val_date)
+                        self._change_at_date_tasks[val_date] = changed_portfolio
+                    self._compute_metrics_tasks.add(val_date)
+        self._positions = defaultdict(dict)
+
+    def schedule_metric_computation(self):
+        if self._compute_metrics_tasks:
+            basket_id = self.portfolio.id
+            basket_content_type_id = ContentType.objects.get_by_natural_key("wbportfolio", "portfolio").id
+            group(
+                *[
+                    compute_metrics_as_task.si(d, basket_id=basket_id, basket_content_type_id=basket_content_type_id)
+                    for d in self._compute_metrics_tasks
+                ]
+            ).apply_async()
+            self._change_at_date_tasks = set()
+
+    def schedule_change_at_dates(self, synchronous: bool = True, **task_kwargs):
+        from wbportfolio.models.portfolio import trigger_portfolio_change_as_task
+
+        if self._change_at_date_tasks:
+            tasks = chain(
+                *[
+                    trigger_portfolio_change_as_task.si(
+                        self.portfolio.id, d, changed_portfolio=portfolio, **task_kwargs
+                    )
+                    for d, portfolio in self._change_at_date_tasks.items()
+                ]
+            )
+            if synchronous:
+                tasks.apply()
+            else:
+                tasks.apply_async()
+            self._change_at_date_tasks = dict()

wbportfolio/models/orders/order_proposals.py

@@ -33,8 +33,7 @@ from wbcore.utils.models import CloneMixin
 from wbfdm.models import InstrumentPrice
 from wbfdm.models.instruments.instruments import Cash, Instrument
 
-from wbportfolio.models.asset import AssetPosition, AssetPositionIterator
-from wbportfolio.models.exceptions import InvalidAnalyticPortfolio
+from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
@@ -79,6 +78,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         on_delete=models.PROTECT,
         verbose_name="Owner",
     )
+    min_order_value = models.IntegerField(
+        default=0, verbose_name="Minimum Order Value", help_text="Minimum Order Value in the Portfolio currency"
+    )
 
     class Meta:
         verbose_name = "Order Proposal"
@@ -218,6 +220,12 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         ),
                         default=models.F("effective_weight"),
                     ),
+                    target_weight=models.Case(
+                        models.When(
+                            id=largest_order.id, then=models.F("target_weight") + models.Value(Decimal(quant_error))
+                        ),
+                        default=models.F("target_weight"),
+                    ),
                 )
         return orders.annotate(
             has_warnings=models.Case(
@@ -257,7 +265,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 self.value_date, weights=previous_weights, use_dl=True
             ).get_contributions()
             last_returns = last_returns.to_dict()
-        except InvalidAnalyticPortfolio:
+        except ValueError:
             last_returns, portfolio_contribution = {}, 1
         positions = []
         total_weighting = Decimal("0")
@@ -456,14 +464,20 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             if approve_automatically and self.portfolio.can_be_rebalanced:
                 self.approve(replay=False)
 
-    def replay(self, broadcast_changes_at_date: bool = True):
+    def replay(self, broadcast_changes_at_date: bool = True, reapply_order_proposal: bool = False):
         last_order_proposal = self
         last_order_proposal_created = False
+        self.portfolio.load_builder_returns(self.trade_date, date.today())
         while last_order_proposal and last_order_proposal.status == OrderProposal.Status.APPROVED:
-            logger.info(f"Replaying order proposal {last_order_proposal}")
+            last_order_proposal.portfolio = self.portfolio  # we set the same ptf reference
             if not last_order_proposal_created:
-                last_order_proposal.approve_workflow(silent_exception=True, force_reset_order=True)
-                last_order_proposal.save()
+                if reapply_order_proposal:
+                    logger.info(f"Replaying order proposal {last_order_proposal}")
+                    last_order_proposal.approve_workflow(silent_exception=True, force_reset_order=True)
+                    last_order_proposal.save()
+                else:
+                    logger.info(f"Resetting order proposal {last_order_proposal}")
+                    last_order_proposal.reset_orders()
                 if last_order_proposal.status != OrderProposal.Status.APPROVED:
                     break
             next_order_proposal = last_order_proposal.next_order_proposal
@@ -478,21 +492,17 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             else:
                 next_trade_date = date.today()
             next_trade_date = min(next_trade_date, date.today())
-            positions, overriding_order_proposal = self.portfolio.drift_weights(
+            gen = self.portfolio.drift_weights(
                 last_order_proposal.trade_date, next_trade_date, stop_at_rebalancing=True
             )
+            try:
+                while True:
+                    self.portfolio.builder.add(next(gen))
+            except StopIteration as e:
+                overriding_order_proposal = e.value
 
-            # self.portfolio.assets.filter(
-            #     date__gt=last_order_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 order proposal during replay
-            self.portfolio.bulk_create_positions(
-                positions,
+            self.portfolio.builder.bulk_create_positions(
                 delete_leftovers=True,
-                compute_metrics=False,
-                broadcast_changes_at_date=broadcast_changes_at_date,
-                evaluate_rebalancer=False,
             )
             for draft_tp in OrderProposal.objects.filter(
                 portfolio=self.portfolio,
@@ -507,6 +517,8 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             else:
                 last_order_proposal_created = False
                 last_order_proposal = next_order_proposal
+        if broadcast_changes_at_date:
+            self.portfolio.builder.schedule_change_at_dates(synchronous=False, evaluate_rebalancer=False)
 
     def invalidate_future_order_proposal(self):
         # Delete all future automatic order proposals and set the manual one into a draft state
@@ -576,7 +588,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         total_target_weight = orders.exclude(underlying_instrument__is_cash=True).aggregate(
             s=models.Sum("target_weight")
         )["s"] or Decimal(0)
-
         if target_cash_weight is None:
             target_cash_weight = Decimal("1") - total_target_weight
 
@@ -644,7 +655,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 orders_validation_warnings.extend(order_warnings)
             orders.append(order)
 
-        Order.objects.bulk_update(orders, ["shares", "weighting"])
+        Order.objects.bulk_update(orders, ["shares", "weighting", "desired_target_weight"])
 
         # If we estimate cash on this order proposal, we make sure to create the corresponding cash component
         estimated_cash_position = self.get_estimated_target_cash()
@@ -704,30 +715,25 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         # We validate order 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.")
-        assets = []
         warnings = []
         # We do not want to create the estimated cash position if there is not orders in the order proposal (shouldn't be possible anyway)
         estimated_cash_position = self.get_estimated_target_cash()
+        assets = {}
         for order in self.get_orders():
             with suppress(ValueError):
-                asset = order.get_asset()
                 # we add the corresponding asset only if it is not the cache position (already included in estimated_cash_position)
-                if asset.underlying_quote != estimated_cash_position.underlying_quote:
-                    assets.append(asset)
+                if order.underlying_instrument != estimated_cash_position.underlying_quote:
+                    assets[order.underlying_instrument.id] = order._target_weight
 
         # if there is cash leftover, we create an extra asset position to hold the cash component
         if estimated_cash_position.weighting and len(assets) > 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)
-
-        self.portfolio.bulk_create_positions(
-            AssetPositionIterator(self.portfolio).add(assets, is_estimated=False),
-            evaluate_rebalancer=False,
-            force_save=True,
-            **kwargs,
+            assets[estimated_cash_position.underlying_quote.id] = estimated_cash_position.weighting
+
+        self.portfolio.builder.add((self.trade_date, assets)).bulk_create_positions(
+            force_save=True, is_estimated=False
         )
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id, user_id=by.id if by else None, broadcast_changes_at_date=False)
@@ -748,7 +754,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             ]
         if self.has_non_successful_checks:
             errors["non_field_errors"] = [_("The pre orders rules did not passed successfully")]
-        if orders.filter(has_warnings=True):
+        if orders.filter(has_warnings=True).exclude(underlying_instrument__is_cash=True):
             errors["non_field_errors"] = [
                 _("There is warning that needs to be addresses on the orders before approval.")
             ]