wbportfolio 1.44.5__py2.py3-none-any.whl → 1.45.0__py2.py3-none-any.whl

wbportfolio/models/transactions/trade_proposals.py

@@ -1,30 +1,32 @@
+import logging
 from contextlib import suppress
-from datetime import timedelta
+from datetime import date, timedelta
+from decimal import Decimal
 from typing import TypeVar
 
-import pandas as pd
 from celery import shared_task
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.db.models.signals import post_save
-from django.dispatch import receiver
-from django.utils import timezone
 from django.utils.functional import cached_property
 from django_fsm import FSMField, transition
-from pandas.tseries.offsets import BDay
+from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
 from wbfdm.models.instruments.instruments import Instrument
+
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import TradeBatch as TradeBatchDTO
 
+from .. import AssetPosition
 from .trades import Trade
 
+logger = logging.getLogger("pms")
+
 SelfTradeProposal = TypeVar("SelfTradeProposal", bound="TradeProposal")
 
 
@@ -39,13 +41,14 @@ class TradeProposal(RiskCheckMixin, WBModel):
 
     comment = models.TextField(default="", verbose_name="Trade Comment", blank=True)
     status = FSMField(default=Status.DRAFT, choices=Status.choices, verbose_name="Status")
-    model_portfolio = models.ForeignKey(
-        "wbportfolio.Portfolio",
+    rebalancing_model = models.ForeignKey(
+        "wbportfolio.RebalancingModel",
+        on_delete=models.SET_NULL,
         blank=True,
         null=True,
-        related_name="model_trade_proposals",
-        on_delete=models.PROTECT,
-        verbose_name="Model Portfolio",
+        related_name="trade_proposals",
+        verbose_name="Rebalancing Model",
+        help_text="Rebalancing Model that generates the target portfolio",
     )
     portfolio = models.ForeignKey(
         "wbportfolio.Portfolio", related_name="trade_proposals", on_delete=models.PROTECT, verbose_name="Portfolio"
@@ -59,6 +62,23 @@ class TradeProposal(RiskCheckMixin, WBModel):
         verbose_name="Owner",
     )
 
+    class Meta:
+        verbose_name = "Trade Proposal"
+        verbose_name_plural = "Trade Proposals"
+        constraints = [
+            models.UniqueConstraint(
+                fields=["portfolio", "trade_date"],
+                name="unique_trade_proposal",
+            ),
+        ]
+
+    def save(self, *args, **kwargs):
+        if not self.trade_date and self.portfolio.assets.exists():
+            self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
+        if not self.rebalancing_model and (rebalancer := getattr(self.portfolio, "automatic_rebalancer", None)):
+            self.rebalancing_model = rebalancer.rebalancing_model
+        super().save(*args, **kwargs)
+
     def _get_checked_object_field_name(self) -> str:
         """
         Mandatory function from the Riskcheck mixin that returns the field (aka portfolio), representing the object to check the rules against.
@@ -76,6 +96,13 @@ class TradeProposal(RiskCheckMixin, WBModel):
             trades_batch=self._build_dto(),
         )
 
+    @cached_property
+    def last_effective_date(self) -> date:
+        try:
+            return self.portfolio.assets.filter(date__lt=self.trade_date).latest("date").date
+        except AssetPosition.DoesNotExist:
+            return (self.trade_date - BDay(1)).date()
+
     @property
     def previous_trade_proposal(self) -> SelfTradeProposal | None:
         future_proposals = TradeProposal.objects.filter(portfolio=self.portfolio).filter(
@@ -94,8 +121,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
             return future_proposals.earliest("trade_date")
         return None
 
-    @cached_property
-    def base_assets(self):
+    @property
+    def base_assets(self) -> dict[int, Decimal]:
         """
         Return a dictionary representation (instrument_id: target weight) of this trade proposal
         Returns:
@@ -104,17 +131,15 @@ class TradeProposal(RiskCheckMixin, WBModel):
         """
         return {
             v["underlying_instrument"]: v["target_weight"]
-            for v in self.trades.filter(status=Trade.Status.EXECUTED).values("underlying_instrument", "target_weight")
+            for v in self.trades.all()
+            .annotate_base_info()
+            .filter(status=Trade.Status.EXECUTED)
+            .values("underlying_instrument", "target_weight")
         }
 
     def __str__(self) -> str:
         return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
 
-    def save(self, *args, **kwargs):
-        if not self.model_portfolio:
-            self.model_portfolio = self.portfolio
-        super().save(*args, **kwargs)
-
     def _build_dto(self) -> TradeBatchDTO:
         """
         Data Transfer Object
@@ -144,17 +169,10 @@ class TradeProposal(RiskCheckMixin, WBModel):
             trade_date=trade_date,
             comment=kwargs.get("comment", self.comment),
             status=TradeProposal.Status.DRAFT,
-            model_portfolio=self.model_portfolio,
+            rebalancing_model=self.rebalancing_model,
             portfolio=self.portfolio,
             creator=self.creator,
         )
-
-        # For all existing trades, copy them to the new trade proposal
-        for trade in self.trades.all():
-            trade.pk = None
-            trade.trade_proposal = trade_proposal_clone
-            trade.transaction_date = trade_proposal_clone.trade_date
-            trade.save()
         return trade_proposal_clone
 
     def normalize_trades(self):
@@ -167,111 +185,96 @@ class TradeProposal(RiskCheckMixin, WBModel):
         leftovers_trades = self.trades.all()
         for _, trade in service.trades_batch.trades_map.items():
             with suppress(Trade.DoesNotExist):
-                self.trades.update_or_create(
-                    id=trade.id,
-                    defaults={
-                        "weighting": trade.delta_weight,
-                        "shares": trade.target_shares,
-                    },
-                )
+                trade = Trade.objects.get(id=trade.id)
+                trade.weighting = trade.delta_weight
+                trade.shares = self.estimate_shares(trade)
+                trade.save()
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
         leftovers_trades.delete()
 
-    def reset_trades(self):
+    def _get_target_portfolio(self, **kwargs) -> PortfolioDTO:
+        if self.rebalancing_model:
+            return self.rebalancing_model.get_target_portfolio(
+                self.portfolio, self.trade_date, self.last_effective_date, **kwargs
+            )
+        # Return the current portfolio by default
+        return self.portfolio._build_dto(self.last_effective_date)
+
+    def reset_trades(self, target_portfolio: PortfolioDTO | None = None):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
+        if self.status != TradeProposal.Status.DRAFT:
+            raise ValueError("Cannot reset non-draft trade proposal. Revert this trade proposal first.")
         # delete all existing trades
         self.trades.all().delete()
-        # recreate them from scratch (if the portfolio has positions)
-        self.create_or_update_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_target_portfolio()
+        # if not effective_portfolio:
+        #     effective_portfolio = target_portfolio
+        service = TradingService(
+            self.trade_date,
+            effective_portfolio=effective_portfolio,
+            target_portfolio=target_portfolio,
+        )
+        service.normalize()
+        service.is_valid()
 
-    def apply_trades(self):
-        # We validate trade which will create or update the initial asset positions
-        self.trades.exclude(status=Trade.Status.SUBMIT).update(status=Trade.Status.SUBMIT)
-        for trade in self.trades.all():
-            trade.execute()
-            trade.save()
-        # We propagate the new portfolio composition until the next trade proposal or today if it doesn't exist yet
-        to_date = self.next_trade_proposal.trade_date if self.next_trade_proposal else timezone.now().date()
-
-        for from_date in pd.date_range(self.trade_date, to_date - timedelta(days=1), freq="B"):
-            to_date = (from_date + BDay(1)).date()
-            self.portfolio.propagate_or_update_assets(
-                from_date.date(),
-                to_date,
-                forward_price=False,
-                base_assets=self.base_assets,
-                delete_existing_assets=True,
+        for trade_dto in service.validated_trades:
+            instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
+            currency_fx_rate = instrument.currency.convert(
+                last_effective_date, self.portfolio.currency, exact_lookup=True
             )
-            self.portfolio.change_at_date(to_date, base_assets=self.base_assets, force_recompute_weighting=True)
-
-    def revert_trades(self):
-        self.trades.exclude(status=Trade.Status.EXECUTED).update(status=Trade.Status.EXECUTED)
-        for trade in self.trades.all():
-            trade.revert()
+            trade = Trade(
+                underlying_instrument=instrument,
+                transaction_subtype=Trade.Type.BUY if trade_dto.delta_weight > 0 else Trade.Type.SELL,
+                currency=instrument.currency,
+                value_date=last_effective_date,
+                transaction_date=self.trade_date,
+                trade_proposal=self,
+                portfolio=self.portfolio,
+                weighting=trade_dto.delta_weight,
+                status=Trade.Status.DRAFT,
+                currency_fx_rate=currency_fx_rate,
+            )
+            trade.shares = self.estimate_shares(trade)
             trade.save()
-        if previous_trade_proposal := self.previous_trade_proposal:
-            previous_trade_proposal.apply_trades()
 
-    def create_or_update_trades(
-        self, target_portfolio: PortfolioDTO = None, effective_portfolio: PortfolioDTO = None, reset: bool = False
-    ):
-        """
-        This function talk to the trading service layer in order to generate a list of valid trades to attach to the proposal
+    def replay(self):
+        trade_proposal = self
+        while trade_proposal and trade_proposal.status == TradeProposal.Status.APPROVED:
+            logger.info(f"Replaying trade proposal {self}")
+            trade_proposal.portfolio.assets.filter(
+                date=trade_proposal.trade_date
+            ).delete()  # we delete the existing position and we reapply the trade proposal
+            if not trade_proposal.portfolio.assets.filter(date=trade_proposal.trade_date).exists():
+                if trade_proposal.status == TradeProposal.Status.APPROVED:
+                    trade_proposal.revert()
+                if trade_proposal.status == TradeProposal.Status.DRAFT:
+                    trade_proposal.submit()
+                if trade_proposal.status == TradeProposal.Status.SUBMIT:
+                    trade_proposal.approve()
+                trade_proposal.save()
+            next_trade_proposal = 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 = trade_proposal.portfolio.batch_portfolio(
+                trade_proposal.trade_date, next_trade_date
+            )
+            trade_proposal = overriding_trade_proposal or next_trade_proposal
 
-        Args:
-            target_portfolio: The target portfolio that the trades needs to execute to. Absence of position means a sell
-            effective_portfolio: The current or effective portfolio to derivative effective weight from. Absence of position means a buy
-            reset: If true, delete the current attached trades
-        """
-        # if the target portfolio is not provided, we try to build it
-        if (
-            not target_portfolio
-            and (assets := self.model_portfolio.assets.filter(date__lte=self.trade_date)).exists()
-            and (latest_pos := assets.latest("date"))
-        ):
-            target_portfolio = self.model_portfolio._build_dto(latest_pos.date)
-
-        # if the effective portfolio is not provided, we try to build it
-        if (
-            not effective_portfolio
-            and (assets := self.portfolio.assets.filter(date__lte=self.trade_date)).exists()
-            and (latest_pos := assets.latest("date"))
-        ):
-            effective_portfolio = self.portfolio._build_dto(latest_pos.date)
-        # Build trades DTO from the attached trades
-        trade_batch = self._build_dto()
-        if target_portfolio or effective_portfolio or trade_batch:
-            service = TradingService(
-                self.trade_date,
-                effective_portfolio=effective_portfolio,
-                target_portfolio=target_portfolio,
-                trades_batch=trade_batch,
+    def estimate_shares(self, trade: Trade) -> Decimal | None:
+        if not self.portfolio.only_weighting and (quote := trade.underlying_quote_price):
+            trade_total_value_fx_portfolio = (
+                self.portfolio.get_total_asset_value(trade.value_date) * trade._target_weight
             )
-            # with suppress(ValidationError):
-            # Normalize the trades and validate it
-            service.normalize()
-            service.is_valid()
-            if reset:
-                self.trades.all().delete()
-            for trade_dto in service.validated_trades:
-                instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
-                t, c = Trade.objects.update_or_create(
-                    underlying_instrument=instrument,
-                    currency=instrument.currency,
-                    transaction_date=self.trade_date,
-                    trade_proposal=self,
-                    portfolio=self.portfolio,
-                    defaults={
-                        "shares": trade_dto.target_shares,
-                        "weighting": trade_dto.delta_weight,
-                        "status": Trade.Status.DRAFT,
-                        "currency_fx_rate": instrument.currency.convert(self.trade_date, self.portfolio.currency),
-                    },
-                )
-
-    # End tools methods
+            price_fx_portfolio = quote.net_value * trade.currency_fx_rate
+            if price_fx_portfolio:
+                return trade_total_value_fx_portfolio / price_fx_portfolio
 
     # Start FSM logics
 
@@ -295,7 +298,10 @@ class TradeProposal(RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.trades.update(status=Trade.Status.SUBMIT)
+        self.trades.update(comment="", status=Trade.Status.DRAFT)
+        for trade in self.trades.all():
+            trade.submit()
+            trade.save()
         self.evaluate_active_rules(
             self.trade_date, self.validated_trading_service.target_portfolio, asynchronously=True
         )
@@ -348,17 +354,28 @@ class TradeProposal(RiskCheckMixin, WBModel):
             )
         },
     )
-    def approve(self, by=None, description=None, **kwargs):
-        apply_trades_proposal_as_task.delay(self.id)
+    def approve(self, by=None, description=None, synchronous=False, **kwargs):
+        # 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
+        for trade in self.trades.all():
+            trade.execute()
+            trade.save()
+        self.portfolio.change_at_date(self.trade_date)
+        # replay_as_task.delay(self.id)
 
     def can_approve(self):
         errors = dict()
+        if not self.portfolio.can_be_rebalanced:
+            errors["non_field_errors"] = "The portfolio does not allow manual rebalanced"
         if self.trades.exclude(status=Trade.Status.SUBMIT).exists():
             errors["non_field_errors"] = "At least one trade needs to be submitted to be able to approve this proposal"
-        if not self.portfolio.is_manageable:
-            errors[
-                "portfolio"
-            ] = "The portfolio needs to be a model portfolio in order to approve this trade proposal manually"
+        if not self.portfolio.can_be_rebalanced:
+            errors["portfolio"] = (
+                "The portfolio needs to be a model portfolio in order to approve this trade proposal manually"
+            )
         if self.has_assigned_active_rules and not self.has_all_check_completed_and_succeed:
             errors["non_field_errors"] = "The pre trades rules did not passed successfully"
         return errors
@@ -421,10 +438,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
         self.checks.delete()
 
     def can_backtodraft(self):
-        errors = dict()
-        if self.trades.exclude(status=Trade.Status.SUBMIT).exists():
-            errors["non_field_errors"] = "All trades need to be submitted before reverting back to draft"
-        return errors
+        pass
 
     @transition(
         field=status,
@@ -448,16 +462,17 @@ class TradeProposal(RiskCheckMixin, WBModel):
     def revert(self, **kwargs):
         with suppress(KeyError):
             del self.__dict__["validated_trading_service"]
-        revert_trade_proposal_as_task.delay(self.id, **kwargs)
+        for trade in self.trades.filter(status=Trade.Status.EXECUTED):
+            trade.revert()
+            trade.save()
+        # replay_as_task.delay(self.id)
 
     def can_revert(self):
         errors = dict()
-        if self.trades.exclude(status=Trade.Status.EXECUTED).exists():
-            errors["non_field_errors"] = "All trades need to be executed before reverting"
-        if not self.portfolio.is_manageable:
-            errors[
-                "portfolio"
-            ] = "The portfolio needs to be a model portfolio in order to revert this trade proposal manually"
+        if not self.portfolio.can_be_rebalanced:
+            errors["portfolio"] = (
+                "The portfolio needs to be a model portfolio in order to revert this trade proposal manually"
+            )
         return errors
 
     # End FSM logics
@@ -478,25 +493,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
     def get_representation_label_key(cls) -> str:
         return "{{_portfolio.name}} ({{trade_date}})"
 
-    class Meta:
-        verbose_name = "Trade Proposal"
-        verbose_name_plural = "Trade Proposals"
-        unique_together = ["portfolio", "trade_date"]
-
-
-@shared_task(queue="portfolio")
-def apply_trades_proposal_as_task(trade_proposal_id):
-    trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
-    trade_proposal.apply_trades()
-
 
 @shared_task(queue="portfolio")
-def revert_trade_proposal_as_task(trade_proposal_id, **kwargs):
+def replay_as_task(trade_proposal_id):
     trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
-    trade_proposal.revert_trades()
-
-
-@receiver(post_save, sender="wbportfolio.TradeProposal")
-def post_save_trade_proposal(sender, instance, created, raw, **kwargs):
-    if created and not raw and instance.portfolio.assets.filter(date__lte=instance.trade_date).exists():
-        instance.create_or_update_trades(reset=True)
+    trade_proposal.replay()