wbportfolio 1.49.5__tar.gz → 1.49.6__tar.gz

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

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

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

@@ -511,7 +511,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.6}/wbportfolio/models/transactions/trade_proposals.py

@@ -80,8 +80,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):
@@ -272,35 +270,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:
         """
@@ -398,11 +404,14 @@ 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)
@@ -475,11 +484,16 @@ 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 = []
         for trade in self.trades.all():
-            trade.execute()
-            trade.save()
+            with suppress(ValueError):
+                assets.append(trade.to_asset())
+            trade.status = Trade.Status.EXECUTED
+            trades.append(trade)
+
+        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 +598,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()

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/models/transactions/trades.py

@@ -299,25 +299,47 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             )
         },
     )
+    def to_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,
+            portfolio=self.portfolio,
+            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_shares=None,
+            underlying_quote_price=self.last_underlying_quote_price,
+            asset_valuation_date=self.transaction_date,
+            currency=self.currency,
+            is_estimated=False,
+        )
+        asset.set_weighting(self._target_weight)
+        asset.pre_save()
+        return asset
+
     def execute(self, **kwargs):
-        if self.last_underlying_quote_price:
-            asset, created = AssetPosition.unannotated_objects.update_or_create(
-                underlying_quote=self.underlying_instrument,
-                portfolio_created=None,
-                portfolio=self.portfolio,
-                date=self.transaction_date,
+        with suppress(ValueError):
+            asset = self.to_asset()
+            AssetPosition.unannotated_objects.update_or_create(
+                underlying_quote=asset.underlying_quote,
+                portfolio_created=asset.portfolio_created,
+                portfolio=asset.portfolio,
+                date=asset.date,
                 defaults={
-                    "initial_currency_fx_rate": self.currency_fx_rate,
-                    "weighting": self._target_weight,
-                    "initial_price": self.last_underlying_quote_price.net_value,
-                    "initial_shares": None,
-                    "underlying_quote_price": self.last_underlying_quote_price,
-                    "asset_valuation_date": self.transaction_date,
-                    "currency": self.currency,
-                    "is_estimated": False,
+                    "initial_currency_fx_rate": asset.initial_currency_fx_rate,
+                    "initial_price": asset.initial_price,
+                    "initial_shares": asset.initial_shares,
+                    "underlying_quote_price": asset.underlying_quote_price,
+                    "asset_valuation_date": asset.asset_valuation_date,
+                    "currency": asset.currency,
+                    "is_estimated": asset.is_estimated,
+                    "weighting": asset.weighting,
                 },
             )
-            asset.set_weighting(self._target_weight)
 
     def can_execute(self):
         if not self.last_underlying_quote_price:
@@ -402,6 +424,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 is_estimated=False,
             )
             asset.set_weighting(asset.weighting - self.weighting)
+            asset.save()
 
     @property
     def product(self):

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/rebalancing/models/composite.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 
 from django.core.exceptions import ObjectDoesNotExist
+from wbfdm.models import InstrumentPrice
 
 from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
@@ -20,7 +21,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
         """
         try:
             latest_trade_proposal = self.portfolio.trade_proposals.filter(
-                status="APPROVED", trade_date__lte=self.trade_date
+                status="APPROVED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]
@@ -33,7 +34,10 @@ class CompositeRebalancing(AbstractRebalancingModel):
             return dict()
 
     def is_valid(self) -> bool:
-        return len(self.base_assets.keys()) > 0
+        return (
+            len(self.base_assets.keys()) > 0
+            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=self.base_assets.keys()).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/rebalancing/models/equally_weighted.py

@@ -1,5 +1,7 @@
 from decimal import Decimal
 
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -7,8 +9,17 @@ from wbportfolio.rebalancing.decorators import register
 
 @register("Equally Weighted Rebalancing")
 class EquallyWeightedRebalancing(AbstractRebalancingModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.assets = self.portfolio.assets.filter(date=self.last_effective_date)
+
     def is_valid(self) -> bool:
-        return self.portfolio.assets.filter(date=self.last_effective_date).exists()
+        return (
+            self.assets.exists()
+            and InstrumentPrice.objects.filter(
+                date=self.trade_date, instrument__in=self.assets.values("underlying_quote")
+            ).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/rebalancing/models/model_portfolio.py

@@ -1,3 +1,5 @@
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -18,11 +20,15 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
             return model_portfolio_rel.dependency_portfolio
 
     def is_valid(self) -> bool:
-        return (
-            self.model_portfolio.assets.filter(date=self.last_effective_date).exists()
-            if self.model_portfolio
-            else False
-        )
+        if model_portfolio := self.model_portfolio:
+            assets = model_portfolio.get_positions(self.last_effective_date)
+            return (
+                assets.exists()
+                and InstrumentPrice.objects.filter(
+                    date=self.trade_date, instrument__in=assets.values("underlying_quote")
+                ).exists()
+            )
+        return False
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -11,11 +11,15 @@ from wbportfolio.models import AssetPosition, TradeProposal
 
 @pytest.mark.django_db
 class TestRebalancingModel:
-    def test_get_target_portfolio(self, rebalancing_model, portfolio, weekday, asset_position_factory):
+    def test_get_target_portfolio(
+        self, rebalancing_model, portfolio, weekday, asset_position_factory, instrument_price_factory
+    ):
+        trade_date = (weekday + BDay(1)).date()
         with pytest.raises(ValidationError):  # trigger value error because rebalancing not valid (no position yet)
-            rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
+            rebalancing_model.get_target_portfolio(portfolio, trade_date, weekday)
         a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=weekday)
         a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=weekday)
+        instrument_price_factory.create(instrument=a1.underlying_quote, date=trade_date)
         target_portfolio = rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
         target_positions = target_portfolio.positions_map
         assert target_positions[a1.underlying_instrument.id].weighting == 0.5

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/tests/rebalancing/test_models.py

@@ -16,9 +16,11 @@ class TestEquallyWeightedRebalancing:
 
         return EquallyWeightedRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
-        asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -38,7 +40,7 @@ class TestModelPortfolioRebalancing:
 
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
@@ -48,7 +50,9 @@ class TestModelPortfolioRebalancing:
             dependency_portfolio=model_portfolio,
             type=PortfolioPortfolioThroughModel.Type.MODEL,
         )
-        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -76,15 +80,15 @@ class TestCompositeRebalancing:
 
         return CompositeRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
 
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
-        TradeFactory.create(
+        t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.7,
@@ -92,23 +96,25 @@ class TestCompositeRebalancing:
         )
         TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.3,
             status=Trade.Status.EXECUTED,
         )
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=t1.underlying_instrument, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.8,
@@ -116,7 +122,7 @@ class TestCompositeRebalancing:
         )
         t2 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.2,

{wbportfolio-1.49.5 → wbportfolio-1.49.6}/wbportfolio/viewsets/configs/display/portfolios.py

@@ -205,13 +205,11 @@ class TopDownPortfolioCompositionPandasDisplayConfig(DisplayViewConfig):
             effective_column_label += f" ({self.view.last_effective_date:%Y-%m-%d})"
         return dp.ListDisplay(
             fields=[
-                dp.Field(key="instrument", label="Instrument"),
+                dp.Field(key="instrument", label="Instrument", pinned="left"),
                 dp.Field(key="rebalancing_weights", label=rebalancing_column_label),
                 dp.Field(key="effective_weights", label=effective_column_label),
             ],
             tree=True,
-            tree_group_pinned="left",
             tree_group_field="instrument",
-            tree_group_label="Instrument",
             tree_group_parent_pointer="parent_row_id",
         )