wbportfolio 1.49.5__tar.gz → 1.49.7__tar.gz

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.49.5
+Version: 1.49.7
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/filters/__init__.py

@@ -9,6 +9,7 @@ from .assets import (  # ProductAllocationEquityFilter, AssetPositionAPIFilter,
     CashPositionPortfolioFilterSet,
     CompositionModelPortfolioPandasFilter,
     ContributionChartFilter,
+    CompositionContributionChartFilter,
     DistributionFilter,
 )
 from .custodians import CustodianFilterSet

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/filters/assets.py

@@ -462,6 +462,10 @@ class ContributionChartFilter(wb_filters.FilterSet):
         fields = {}
 
 
+class CompositionContributionChartFilter(ContributionChartFilter):
+    show_lookthrough = wb_filters.BooleanFilter(label="Show Lookthrough", default=False, method="fake_filter")
+
+
 class AssetPositionUnderlyingInstrumentChartFilter(DateFilterMixin, wb_filters.FilterSet):
     portfolio = wb_filters.ModelMultipleChoiceFilter(
         label="Portfolios",

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/filters/positions.py

@@ -3,15 +3,17 @@ import datetime as dt
 from django.db.models import TextChoices
 from pandas.tseries.offsets import BDay
 from wbcore import filters as wb_filters
-from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.geography.models import Geography
 from wbcore.pandas.filterset import PandasFilterSetMixin
 from wbcore.utils.date import current_financial_month
+from wbfdm.models import Classification, Instrument
 
 from wbportfolio.filters.assets import (
     DateFilterMixin,
     get_latest_end_quarter_date_asset_position,
 )
-from wbportfolio.models import AssetPosition
+from wbportfolio.models import AssetPosition, Portfolio
 
 
 class GroupbyChoice(TextChoices):
@@ -33,16 +35,21 @@ class GroupbyChoice(TextChoices):
             "PREFERRED_CLASSIFICATION": "classification_id",
         }[name]
 
-    @classmethod
-    def get_repr(cls, name: str) -> str:
-        return {
-            "UNDERLYING_INSTRUMENT": "underlying_instrument__name_repr",
-            "CURRENCY": "underlying_instrument__currency__key",
-            "COUNTRY": "underlying_instrument__country__name",
-            "PORTFOLIO": "portfolio__name",
-            "PRIMARY_CLASSIFICATION": "classification_title",
-            "PREFERRED_CLASSIFICATION": "classification_title",
-        }[name]
+    def get_repr(self, ids: list[int]) -> dict[int, str]:
+        match self:
+            case GroupbyChoice.UNDERLYING_INSTRUMENT:
+                return dict(Instrument.objects.filter(id__in=ids).values_list("id", "name_repr"))
+            case GroupbyChoice.CURRENCY:
+                return dict(Currency.objects.filter(id__in=ids).values_list("id", "key"))
+            case GroupbyChoice.COUNTRY:
+                return dict(Geography.countries.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PORTFOLIO:
+                return dict(Portfolio.objects.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PRIMARY_CLASSIFICATION:
+                return dict(Classification.objects.filter(id__in=ids).values_list("id", "name"))
+            case GroupbyChoice.PREFERRED_CLASSIFICATION:
+                return dict(Classification.objects.filter(id__in=ids).values_list("id", "name"))
+        raise ValueError("invalid self value")
 
 
 def get_latest_date_based_on_multiple_models(field, request, view):

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/models/asset.py

@@ -24,7 +24,7 @@ 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 wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
 from wbcore.signals import pre_merge
 from wbcore.utils.enum import ChoiceEnum
@@ -77,6 +77,24 @@ class AssetPositionDefaultQueryset(QuerySet):
             classification_title=Subquery(base_qs.values(ref_title)[:1]),
         )
 
+    def annotate_hedged_currency_fx_rate(self, hedged_currency: Currency | None) -> QuerySet:
+        return self.annotate(
+            _is_hedged=Case(
+                When(
+                    underlying_instrument__currency__isnull=False,
+                    underlying_instrument__currency=hedged_currency,
+                    then=Value(True),
+                ),
+                default=Value(False),
+                output_field=models.BooleanField(),
+            ),
+            hedged_currency_fx_rate=Case(
+                When(_is_hedged=True, then=Value(Decimal(1.0))),
+                default=F("currency_fx_rate"),
+                output_field=models.BooleanField(),
+            ),
+        )
+
 
 class DefaultAssetPositionManager(models.Manager):
     def annotate_classification_for_group(
@@ -93,7 +111,10 @@ class DefaultAssetPositionManager(models.Manager):
             classification_group, classification_height=classification_height
         )
 
-    def get_queryset(self) -> QuerySet["AssetPosition"]:
+    def annotate_hedged_currency_fx_rate(self, hedged_currency: Currency | None) -> QuerySet:
+        return self.get_queryset().annotate_hedged_currency_fx_rate(hedged_currency)
+
+    def get_queryset(self) -> AssetPositionDefaultQueryset:
         return AssetPositionDefaultQueryset(self.model).annotate(
             adjusting_factor=Coalesce(
                 F("applied_adjustment__cumulative_factor") * F("applied_adjustment__factor"), Decimal(1.0)
@@ -511,7 +532,6 @@ class AssetPosition(ImportMixin, models.Model):
                 self.initial_shares = new_weighting * self.get_portfolio_total_asset_value()
             else:
                 self.initial_shares = (new_weighting / self.weighting) * self.initial_shares
-        self.save()
 
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/models/portfolio.py

@@ -13,16 +13,12 @@ from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.fields import DateRangeField
 from django.db import models
 from django.db.models import (
-    BooleanField,
-    Case,
     Exists,
     F,
     OuterRef,
     Q,
     QuerySet,
     Sum,
-    Value,
-    When,
 )
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -629,11 +625,28 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         return df
 
-    def get_portfolio_contribution_df(self, start, end, with_cash=True, hedged_currency=None, only_equity=False):
+    def get_portfolio_contribution_df(
+        self,
+        start: date,
+        end: date,
+        with_cash: bool = True,
+        hedged_currency: Currency | None = None,
+        only_equity: bool = False,
+    ) -> pd.DataFrame:
         qs = self._get_assets(with_cash=with_cash).filter(date__gte=start, date__lte=end)
         if only_equity:
             qs = qs.filter(underlying_instrument__instrument_type=InstrumentType.EQUITY)
-        return Portfolio.get_contribution_df(qs, hedged_currency=hedged_currency)
+        qs = qs.annotate_hedged_currency_fx_rate(hedged_currency)
+        df = Portfolio.get_contribution_df(
+            qs.select_related("underlying_instrument").values_list(
+                "date", "price", "hedged_currency_fx_rate", "underlying_instrument", "weighting"
+            )
+        )
+        df = df.rename(columns={"group_key": "underlying_instrument"})
+        df["underlying_instrument__name_repr"] = df["underlying_instrument"].map(
+            dict(Instrument.objects.filter(id__in=df["underlying_instrument"]).values_list("id", "name_repr"))
+        )
+        return df
 
     def check_related_portfolio_at_date(self, val_date: date, related_portfolio: "Portfolio"):
         assets = AssetPosition.objects.filter(
@@ -730,6 +743,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         ):
             rel.portfolio.evaluate_rebalancing(val_date)
         for dependent_portfolio in self.get_child_portfolios(val_date):
+            dependent_portfolio.change_at_date(val_date)
             dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
 
     def evaluate_rebalancing(self, val_date: date):
@@ -1088,104 +1102,68 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return returns.replace([np.inf, -np.inf, np.nan], 0), prices_df.replace([np.inf, -np.inf, np.nan], None)
 
     @classmethod
-    def get_contribution_df(
-        cls,
-        qs,
-        need_normalize=False,
-        groupby_label_id="underlying_instrument",
-        groubpy_label_title="underlying_instrument__name_repr",
-        currency_fx_rate_label="currency_fx_rate",
-        hedged_currency=None,
-    ):
-        # qs = AssetPosition.annotate_underlying_instrument(qs)
-        weight_label = "weighting" if not need_normalize else "total_value_fx_portfolio"
-        qs = qs.annotate(
-            is_hedged=Case(
-                When(
-                    underlying_instrument__currency__isnull=False,
-                    underlying_instrument__currency=hedged_currency,
-                    then=Value(True),
-                ),
-                default=Value(False),
-                output_field=BooleanField(),
-            ),
-            coalesce_currency_fx_rate=Case(
-                When(is_hedged=True, then=Value(Decimal(1.0))),
-                default=F(currency_fx_rate_label),
-                output_field=models.BooleanField(),
-            ),
-        ).select_related("underlying_instrument")
+    def get_contribution_df(cls, data, need_normalize: bool = False):
         df = pd.DataFrame(
-            qs.values_list(
-                "date",
-                "price",
-                "coalesce_currency_fx_rate",
-                groupby_label_id,
-                groubpy_label_title,
-                weight_label,
-            ),
+            data,
             columns=[
                 "date",
                 "price",
-                "coalesce_currency_fx_rate",
-                groupby_label_id,
-                groubpy_label_title,
-                weight_label,
+                "currency_fx_rate",
+                "group_key",
+                "value",
             ],
         )
         if not df.empty:
-            df = df[df[weight_label] != 0]
+            df = df[df["value"] != 0]
             df.date = pd.to_datetime(df.date)
-            df["price_fx_portfolio"] = df.price * df.coalesce_currency_fx_rate
+            df["price_fx_portfolio"] = df.price * df.currency_fx_rate
 
-            df[["price", "price_fx_portfolio", weight_label, "coalesce_currency_fx_rate"]] = df[
-                ["price", "price_fx_portfolio", weight_label, "coalesce_currency_fx_rate"]
+            df[["price", "price_fx_portfolio", "value", "currency_fx_rate"]] = df[
+                ["price", "price_fx_portfolio", "value", "currency_fx_rate"]
             ].astype("float")
 
-            df[groupby_label_id] = df[groupby_label_id].fillna(0)
-            df[groubpy_label_title] = df[groubpy_label_title].fillna("N/A")
-            df_static = df[[groupby_label_id, groubpy_label_title]].groupby(groupby_label_id, dropna=False).first()
+            df["group_key"] = df["group_key"].fillna(0)
 
             df = (
                 df[
                     [
-                        groupby_label_id,
+                        "group_key",
                         "date",
                         "price",
                         "price_fx_portfolio",
-                        weight_label,
-                        "coalesce_currency_fx_rate",
+                        "value",
+                        "currency_fx_rate",
                     ]
                 ]
-                .groupby(["date", groupby_label_id], dropna=False)
+                .groupby(["date", "group_key"], dropna=False)
                 .agg(
                     {
                         "price": "mean",
                         "price_fx_portfolio": "mean",
-                        weight_label: "sum",
-                        "coalesce_currency_fx_rate": "mean",
+                        "value": "sum",
+                        "currency_fx_rate": "mean",
                     }
                 )
                 .reset_index()
                 .set_index("date")
                 .sort_index()
             )
-            df[weight_label] = df[weight_label].fillna(0)
+            df["value"] = df["value"].fillna(0)
             value = df.pivot_table(
                 index="date",
-                columns=[groupby_label_id],
-                values=weight_label,
+                columns=["group_key"],
+                values="value",
                 fill_value=0,
                 aggfunc="sum",
             )
             weights_ = value
             if need_normalize:
-                total_value_price = df[weight_label].groupby("date", dropna=False).sum()
+                total_value_price = df["value"].groupby("date", dropna=False).sum()
                 weights_ = value.divide(total_value_price, axis=0)
             prices_usd = (
                 df.pivot_table(
                     index="date",
-                    columns=[groupby_label_id],
+                    columns=["group_key"],
                     values="price_fx_portfolio",
                     aggfunc="mean",
                 )
@@ -1196,8 +1174,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             rates_fx = (
                 df.pivot_table(
                     index="date",
-                    columns=[groupby_label_id],
-                    values="coalesce_currency_fx_rate",
+                    columns=["group_key"],
+                    values="currency_fx_rate",
                     aggfunc="mean",
                 )
                 .replace(0, np.nan)
@@ -1220,7 +1198,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
             res = pd.concat(
                 [
-                    df_static,
                     monthly_perf_prices,
                     monthly_perf_rates_fx,
                     contributions_prices,
@@ -1233,8 +1210,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 axis=1,
             ).reset_index()
             res.columns = [
-                groupby_label_id,
-                groubpy_label_title,
+                "group_key",
                 "performance_total",
                 "performance_forex",
                 "contribution_total",

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/models/transactions/rebalancing.py

@@ -95,12 +95,15 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         while TradeProposal.objects.filter(
             portfolio=self.portfolio, status=TradeProposal.Status.FAILED, trade_date=pivot_date
         ).exists():
-            pivot_date += BDay(1)
+            pivot_date = (pivot_date + BDay(1)).date()
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
         if TradeProposal.objects.filter(
-            portfolio=self.portfolio, status=TradeProposal.Status.APPROVED, trade_date=trade_date
+            portfolio=self.portfolio,
+            status=TradeProposal.Status.APPROVED,
+            trade_date=trade_date,
+            rebalancing_model__isnull=True,
         ).exists():  # if a already approved trade proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
             return False
         for initial_valid_datetime in self.get_rrule(trade_date):
@@ -121,12 +124,13 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 "rebalancing_model": self.rebalancing_model,
             },
         )
-        logger.info(
-            f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
-        )
+
         if trade_proposal.rebalancing_model == self.rebalancing_model:
             trade_proposal.status = TradeProposal.Status.DRAFT
             try:
+                logger.info(
+                    f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
+                )
                 target_portfolio = self.rebalancing_model.get_target_portfolio(
                     self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
                 )

{wbportfolio-1.49.5 → wbportfolio-1.49.7}/wbportfolio/models/transactions/trade_proposals.py

@@ -18,6 +18,7 @@ from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
 from wbcore.utils.models import CloneMixin
+from wbfdm.models import InstrumentPrice
 from wbfdm.models.instruments.instruments import Cash, Instrument
 
 from wbportfolio.models.roles import PortfolioRole
@@ -80,8 +81,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if not self.trade_date and self.portfolio.assets.exists():
             self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
         super().save(*args, **kwargs)
-        if self.status == TradeProposal.Status.APPROVED:
-            self.portfolio.change_at_date(self.trade_date)
 
     @property
     def checked_object(self):
@@ -256,6 +255,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 # we cannot do a bulk-create because Trade is a multi table inheritance
                 try:
                     trade = self.trades.get(underlying_instrument=instrument)
+                    trade.weighting = trade_dto.delta_weight
+                    trade.currency_fx_rate = currency_fx_rate
+                    trade.status = Trade.Status.DRAFT
                 except Trade.DoesNotExist:
                     trade = Trade(
                         underlying_instrument=instrument,
@@ -272,35 +274,43 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     def replay(self):
         last_trade_proposal = self
+        last_trade_proposal_created = False
         while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
-            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)
-            last_trade_proposal.save()
+            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)
+                last_trade_proposal.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
+
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()
             )
             overriding_trade_proposal = last_trade_proposal.portfolio.batch_portfolio(
                 last_trade_proposal.trade_date, next_trade_date
             )
-            last_trade_proposal = overriding_trade_proposal or next_trade_proposal
+            if overriding_trade_proposal:
+                last_trade_proposal_created = True
+                last_trade_proposal = overriding_trade_proposal
+            else:
+                last_trade_proposal_created = False
+                last_trade_proposal = next_trade_proposal
 
     def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal:
         """
@@ -333,7 +343,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         except Exception:
             raise ValueError("We couldn't estimate the number of shares")
 
-    def get_estimated_target_cash(self, currency: Currency) -> tuple[Decimal, Decimal]:
+    def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
         Estimates the target cash weight and shares for a trade proposal.
 
@@ -374,7 +384,29 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             with suppress(ValueError):
                 total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
 
-        return target_cash_weight, total_target_shares
+        cash_component = Cash.objects.get_or_create(
+            currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
+        )[0]
+        # otherwise, we create a new position
+        underlying_quote_price = InstrumentPrice.objects.get_or_create(
+            instrument=cash_component,
+            date=self.trade_date,
+            calculated=False,
+            defaults={"net_value": Decimal(1)},
+        )[0]
+        return AssetPosition(
+            underlying_quote=cash_component,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.trade_date,
+            weighting=target_cash_weight,
+            initial_price=underlying_quote_price.net_value,
+            initial_shares=total_target_shares,
+            asset_valuation_date=self.trade_date,
+            underlying_quote_price=underlying_quote_price,
+            currency=cash_component.currency,
+            is_estimated=False,
+        )
 
     # Start FSM logics
 
@@ -398,30 +430,30 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.trades.update(comment="", status=Trade.Status.DRAFT)
         self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
+        trades = []
         for trade in self.trades.all():
-            trade.submit()
-            trade.save()
+            trade.status = Trade.Status.SUBMIT
+            trade.comment = ""
+            trades.append(trade)
+
+        Trade.objects.bulk_update(trades, ["status", "comment"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
-        cash_target_cash_weight, cash_target_cash_shares = self.get_estimated_target_cash(self.portfolio.currency)
-        if cash_target_cash_weight:
-            cash_component = Cash.objects.get_or_create(
-                currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
-            )[0]
-            self.trades.update_or_create(
-                underlying_instrument=cash_component,
-                defaults={
-                    "status": Trade.Status.SUBMIT,
-                    "weighting": cash_target_cash_weight,
-                    "shares": cash_target_cash_shares,
-                },
-            )
+        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()))
 
-        self.evaluate_active_rules(
-            self.trade_date, self.validated_trading_service.target_portfolio, asynchronously=True
-        )
+        self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
 
     def can_submit(self):
         errors = dict()
@@ -475,11 +507,27 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # We validate trade which will create or update the initial asset positions
         if not self.portfolio.can_be_rebalanced:
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
-        self.trades.update(status=Trade.Status.SUBMIT)
-        self.portfolio.assets.filter(date=self.trade_date).delete()  # we delete position to avoid having leftovers
+        trades = []
+        assets = []
+        # 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)
+
         for trade in self.trades.all():
-            trade.execute()
-            trade.save()
+            with suppress(ValueError):
+                asset = trade.to_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)
+            trade.status = Trade.Status.EXECUTED
+            trades.append(trade)
+
+        # 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:
+            estimated_cash_position.pre_save()
+            assets.append(estimated_cash_position)
+
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id)
 
@@ -584,10 +632,22 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def revert(self, **kwargs):
         with suppress(KeyError):
             del self.__dict__["validated_trading_service"]
-        for trade in self.trades.filter(status=Trade.Status.EXECUTED):
-            trade.revert()
-            trade.save()
-        # replay_as_task.delay(self.id)
+        trades = []
+        assets = []
+        for trade in self.trades.all():
+            trade.status = Trade.Status.DRAFT
+            trades.append(trade)
+            with suppress(AssetPosition.DoesNotExist):
+                asset = AssetPosition.unannotated_objects.get(
+                    underlying_quote=trade.underlying_instrument,
+                    portfolio=trade.portfolio,
+                    date=trade.transaction_date,
+                    is_estimated=False,
+                )
+                asset.set_weighting(asset.weighting - trade.weighting)
+                assets.append(asset)
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
 
     def can_revert(self):
         errors = dict()