wbportfolio 1.46.1__tar.gz → 1.46.2__tar.gz

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/PKG-INFO

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

wbportfolio-1.46.2/wbportfolio/apps.py

@@ -0,0 +1,21 @@
+from django.apps import AppConfig
+from django.apps import apps as global_apps
+from django.db import DEFAULT_DB_ALIAS
+from django.db.models.signals import post_migrate
+from django.utils.module_loading import autodiscover_modules
+
+
+class WbportfolioConfig(AppConfig):
+    name = "wbportfolio"
+
+    def ready(self):
+        def autodiscover_backends(
+            app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs
+        ):
+            # we wrap the autodiscover into a post_migrate receiver because we expect db calls
+            autodiscover_modules("rebalancing")
+
+        post_migrate.connect(
+            autodiscover_backends,
+            dispatch_uid="wbportfolio.autodiscover_rebalancing",
+        )

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/import_export/handlers/trade.py

@@ -1,6 +1,4 @@
-import math
 from datetime import datetime
-from decimal import Decimal
 from typing import Any, Dict, Optional
 
 from django.db import models
@@ -28,43 +26,45 @@ class TradeImportHandler(ImportExportHandler):
 
     def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
         if (new_register := change_data.get("register")) and (current_register := _object.register):
-            # we remplace the register only if the new one gives us more information
+            # we replace the register only if the new one gives us more information
             if new_register.register_reference == current_register.global_register_reference:
                 del change_data["register"]
         return super()._data_changed(_object, change_data, initial_data, **kwargs)
 
     def _deserialize(self, data: Dict[str, Any]):
-        if external_identifier2 := data.get("external_identifier2", None):
-            data["external_identifier2"] = str(external_identifier2)
-        if transaction_date_str := data.get("transaction_date", None):
-            data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
-        if value_date_str := data.get("value_date", None):
-            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
-        if book_date_str := data.get("book_date", None):
-            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+        from wbportfolio.models.transactions.trade_proposals import TradeProposal
+
         if underlying_instrument := data.get("underlying_instrument", None):
             data["underlying_instrument"] = self.instrument_handler.process_object(
                 underlying_instrument, only_security=False, read_only=True
             )[0]
-        data["portfolio"] = Portfolio._get_or_create_portfolio(
-            self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
-        )
-        if currency_data := data.get("currency", None):
-            data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
 
-        if register_data := data.get("register", None):
-            data["register"] = self.register_handler.process_object(register_data)[0]
+        if trade_proposal_id := data.pop("trade_proposal_id", None):
+            trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
+            data["value_date"] = trade_proposal.last_effective_date
+            data["transaction_date"] = trade_proposal.trade_date
+            data["trade_proposal"] = trade_proposal
+            data["portfolio"] = trade_proposal.portfolio
+            data["status"] = "DRAFT"
+        else:
+            if external_identifier2 := data.get("external_identifier2", None):
+                data["external_identifier2"] = str(external_identifier2)
+            if transaction_date_str := data.get("transaction_date", None):
+                data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
+            if value_date_str := data.get("value_date", None):
+                data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+            if book_date_str := data.get("book_date", None):
+                data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+            data["portfolio"] = Portfolio._get_or_create_portfolio(
+                self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
+            )
+            if currency_data := data.get("currency", None):
+                data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
 
-        for field in self.model._meta.get_fields():
-            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
-                q = 1 / (math.pow(10, 4))
-                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+            if register_data := data.get("register", None):
+                data["register"] = self.register_handler.process_object(register_data)[0]
 
-        if "total_value" in data:
-            data["total_value"] = data["price"] * data["shares"]
-        if "total_value_fx_portfolio" in data:
-            data["total_value_fx_portfolio"] = data["price"] * data["shares"] * data["currency_fx_rate"]
-        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+            data["marked_for_deletion"] = data.get("marked_for_deletion", False)
 
     def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
         if "transaction_date" not in data:  # we might get only book date and not transaction date
@@ -81,7 +81,7 @@ class TradeImportHandler(ImportExportHandler):
             dates_lookup = {"book_date": book_date}
         else:
             raise DeserializationError("date lookup is missing from data")
-        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data['shares']}"
+        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data.get('shares')} Weighting={data.get('weighting')}"
 
         if history.exists():
             queryset = history
@@ -89,10 +89,10 @@ class TradeImportHandler(ImportExportHandler):
             queryset = self.model.objects.filter(marked_for_deletion=False)
 
         queryset = queryset.filter(
-            models.Q(underlying_instrument=data["underlying_instrument"])
-            & models.Q(**dates_lookup)
-            & models.Q(shares=data["shares"])
+            models.Q(underlying_instrument=data["underlying_instrument"]) & models.Q(**dates_lookup)
         )
+        if "shares" in data:
+            queryset = queryset.filter(shares=data["shares"])
 
         if _id := data.get("id", None):
             self.import_source.log += f"ID {_id} provided -> Load CustomerTrade"
@@ -108,7 +108,7 @@ class TradeImportHandler(ImportExportHandler):
         if portfolio := data.get("portfolio", None):
             queryset = queryset.filter(portfolio=portfolio)
         if queryset.exists():
-            if bank := data["bank"]:
+            if bank := data.get("bank"):
                 self.import_source.log += (
                     f"\n{queryset.count()} Trades found. The bank will tried to be matched against {bank}"
                 )
@@ -138,24 +138,27 @@ class TradeImportHandler(ImportExportHandler):
         self.import_source.log += "\nNo trade was successfully matched."
 
     def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
-        trades = self.model.objects.filter(
-            exclude_from_history=False,
-            pending=False,
-            transaction_subtype__in=[
-                self.model.Type.SUBSCRIPTION,
-                self.model.Type.REDEMPTION,
-            ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
-        )
-        if transaction_date := history.get("transaction_date"):
-            trades = trades.filter(transaction_date__lte=transaction_date)
-        elif book_date := history.get("book_date"):
-            trades = trades.filter(book_date__lte=book_date)
-        if "underlying_instrument" in history:
-            trades = trades.filter(underlying_instrument__id=history["underlying_instrument"])
-        elif "underlying_instruments" in history:
-            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        if trade_proposal_id := history.get("trade_proposal_id"):
+            trades = self.model.objects.filter(trade_proposal_id=trade_proposal_id)
         else:
-            raise ValueError("We cannot estimate history without at least the underlying instrument")
+            trades = self.model.objects.filter(
+                exclude_from_history=False,
+                pending=False,
+                transaction_subtype__in=[
+                    self.model.Type.SUBSCRIPTION,
+                    self.model.Type.REDEMPTION,
+                ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
+            )
+            if transaction_date := history.get("transaction_date"):
+                trades = trades.filter(transaction_date__lte=transaction_date)
+            elif book_date := history.get("book_date"):
+                trades = trades.filter(book_date__lte=book_date)
+            if "underlying_instrument" in history:
+                trades = trades.filter(underlying_instrument__id=history["underlying_instrument"])
+            elif "underlying_instruments" in history:
+                trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+            else:
+                raise ValueError("We cannot estimate history without at least the underlying instrument")
         return trades
 
     def _post_processing_objects(
@@ -188,5 +191,8 @@ class TradeImportHandler(ImportExportHandler):
             self.import_source.log += (
                 f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
             )
-            trade.marked_for_deletion = True
-            trade.save()
+            if trade.trade_proposal:
+                trade.delete()
+            else:
+                trade.marked_for_deletion = True
+                trade.save()

wbportfolio-1.46.2/wbportfolio/import_export/resources/trades.py

@@ -0,0 +1,66 @@
+import rstr
+from faker import Faker
+from import_export import fields
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.io.resources import FilterModelResource
+from wbfdm.models import Instrument
+
+from wbportfolio.models import Trade, TradeProposal
+
+fake = Faker()
+
+
+class TradeProposalTradeResource(FilterModelResource):
+    """
+    Trade Resource class to use to import trade from the trade proposal
+    """
+
+    def __init__(self, **kwargs):
+        self.trade_proposal = TradeProposal.objects.get(pk=kwargs["trade_proposal_id"])
+        super().__init__(**kwargs)
+
+    def before_import(self, dataset, **kwargs):
+        Trade.objects.filter(trade_proposal=self.trade_proposal).delete()
+
+    def get_or_init_instance(self, instance_loader, row):
+        try:
+            return Trade.objects.get(
+                trade_proposal=self.trade_proposal, underlying_instrument=row["underlying_instrument"]
+            )
+        except Trade.DoesNotExist:
+            return Trade(
+                trade_proposal=self.trade_proposal,
+                underlying_instrument=row["underlying_instrument"],
+                transaction_subtype=Trade.Type.BUY if row["weighting"] > 0 else Trade.Type.SELL,
+                currency=row["underlying_instrument"].currency,
+                transaction_date=self.trade_proposal.trade_date,
+                portfolio=self.trade_proposal.portfolio,
+                weighting=row["weighting"],
+                status=Trade.Status.DRAFT,
+            )
+
+    DUMMY_FIELD_MAP = {
+        "underlying_instrument": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "weighting": 1.0,
+        "shares": 1000.2536,
+        "comment": lambda: fake.sentence(),
+        "order": 1,
+    }
+    underlying_instrument = fields.Field(
+        column_name="underlying_instrument",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="isin"),
+    )
+
+    class Meta:
+        import_id_fields = ("underlying_instrument",)
+        fields = (
+            "id",
+            "underlying_instrument",
+            "weighting",
+            "shares",
+            "comment",
+            "order",
+        )
+        export_order = fields
+        model = Trade

wbportfolio-1.46.2/wbportfolio/migrations/0074_alter_rebalancer_frequency_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.0.12 on 2025-02-14 13:10
+
+import django_fsm
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0073_remove_product_price_computation_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='rebalancer',
+            name='frequency',
+            field=models.CharField(default='RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=1', help_text='The Evaluation Frequency in RRULE format', max_length=256, verbose_name='Evaluation Frequency'),
+        ),
+        migrations.AlterField(
+            model_name='tradeproposal',
+            name='status',
+            field=django_fsm.FSMField(choices=[('DRAFT', 'Draft'), ('SUBMIT', 'Submit'), ('APPROVED', 'Approved'), ('DENIED', 'Denied'), ('FAILED', 'Failed')], default='DRAFT', max_length=50, verbose_name='Status'),
+        ),
+    ]

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/models/mixins/instruments.py

@@ -61,6 +61,15 @@ class PMSInstrument(Instrument):
     def nominal_value(self, val_date):
         return self.total_shares(val_date) * self.share_price
 
+    def get_latest_price(self, val_date: date) -> InstrumentPrice | None:
+        try:
+            return InstrumentPrice.objects.filter_only_valid_prices().get(instrument=self, date=val_date)
+        except InstrumentPrice.DoesNotExist:
+            if not self.inception_date or not self.prices.filter(date__lte=val_date).exists():
+                return InstrumentPrice.objects.get_or_create(
+                    instrument=self, date=val_date, defaults={"calculated": False, "net_value": self.issue_price}
+                )[0]
+
     def get_latest_valid_price(self, val_date: Optional[date] = None) -> models.Model:
         qs = self.valuations.exclude(net_value=0)
         if val_date and qs.filter(date__lte=val_date).exists():

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/models/portfolio.py

@@ -112,7 +112,7 @@ class ActiveTrackedPortfolioManager(DefaultPortfolioManager):
         return (
             super()
             .get_queryset()
-            .annotate(asset_exists=Exists(AssetPosition.objects.filter(portfolio=OuterRef("pk"))))
+            .annotate(asset_exists=Exists(AssetPosition.unannotated_objects.filter(portfolio=OuterRef("pk"))))
             .filter(asset_exists=True, is_tracked=True)
         )
 
@@ -558,7 +558,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return Portfolio.get_contribution_df(qs, hedged_currency=hedged_currency)
 
     def check_related_portfolio_at_date(self, val_date: date, related_portfolio: "Portfolio"):
-        assets = AssetPosition.objects.filter(
+        assets = AssetPosition.unannotated_objects.filter(
             date=val_date, underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
         ).values("underlying_instrument", "shares")
         assets1 = assets.filter(portfolio=self)
@@ -569,9 +569,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         child_portfolios = set()
         if pms_instruments := list(self.pms_instruments):
             for parent_portfolio in Portfolio.objects.filter(
-                id__in=AssetPosition.objects.filter(date=val_date, underlying_quote__in=pms_instruments).values(
-                    "portfolio"
-                )
+                id__in=AssetPosition.unannotated_objects.filter(
+                    date=val_date, underlying_quote__in=pms_instruments
+                ).values("portfolio")
             ):
                 child_portfolios.add(parent_portfolio)
         return child_portfolios
@@ -589,6 +589,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         recompute_weighting: bool = False,
         force_recompute_weighting: bool = False,
         compute_metrics: bool = False,
+        evaluate_rebalancer: bool = True,
     ):
         logger.info(f"change at date for {self} at {val_date}")
         qs = self.assets.filter(date=val_date).filter(
@@ -612,7 +613,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
         # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
         self.estimate_net_asset_values(val_date)
-        self.evaluate_rebalancing(val_date)
+        if evaluate_rebalancer:
+            self.evaluate_rebalancing(val_date)
 
         self.updated_at = timezone.now()
         self.save()
@@ -716,17 +718,19 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         Returns: The trade proposal generated by the rebalancing, if any (otherwise None)
         """
         analytic_portfolio = self.get_analytic_portfolio(start_date)
+        rebalancer = getattr(self, "automatic_rebalancer", None)
         initial_assets = analytic_portfolio.assets
         positions = []
         next_trade_proposal = None
         rebalancing_date = None
+        logger.info(f"compute next weights in batch for {self} from {start_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
         returns, prices = self.get_returns(initial_assets, (start_date - BDay(3)).date(), end_date, ffill_returns=True)
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
-            if rebalancer := getattr(self, "automatic_rebalancer", None):
-                if rebalancer.is_valid(to_date):
-                    rebalancing_date = to_date
-                    break
+            logger.info(f"Processing {to_date:%Y-%m-%d}")
+            if rebalancer and rebalancer.is_valid(to_date):
+                rebalancing_date = to_date
+                break
             # with suppress(IndexError):
             last_returns = returns.loc[[to_date_ts], :]
             next_weights = analytic_portfolio.get_next_weights(last_returns.iloc[-1, :].T)
@@ -737,7 +741,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
             analytic_portfolio = AnalyticPortfolio(X=last_returns, weights=next_weights)
 
-        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False)
+        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False, evaluate_rebalancer=False)
         if rebalancing_date:
             next_trade_proposal = rebalancer.evaluate_rebalancing(rebalancing_date)
 
@@ -759,7 +763,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             # function to handle the position modification after instantiation
             if from_is_active and not to_is_active:
                 asset.weighting = Decimal(0.0)
-            asset.initial_shares = AssetPosition.objects.filter(
+            asset.initial_shares = AssetPosition.unannotated_objects.filter(
                 date=from_date, underlying_quote=asset.underlying_quote, portfolio=self
             ).aggregate(sum_shares=Sum("initial_shares"))["sum_shares"]
             return asset
@@ -769,6 +773,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if (
             self.is_tracked and not self.is_lookthrough and not is_target_portfolio_imported and from_is_active
         ):  # we cannot propagate a new portfolio for untracked, or look-through or already imported or inactive portfolios
+            logger.info(f"computing next weight for {self} from {from_date:%Y-%m-%d} to {to_date:%Y-%m-%d}")
             analytic_portfolio = self.get_analytic_portfolio(from_date)
             returns, prices = self.get_returns(analytic_portfolio.assets, (from_date - BDay(3)).date(), to_date)
             if not returns.empty:
@@ -929,7 +934,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 update_dates.add(position.date)
             self.assets.filter(date__in=update_dates, is_estimated=True).delete()
             leftover_positions = self.assets.filter(date__in=update_dates).all()
-            objs = AssetPosition.objects.bulk_create(
+            objs = AssetPosition.unannotated_objects.bulk_create(
                 positions,
                 update_fields=[
                     "weighting",
@@ -1186,16 +1191,9 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
         previous_date := portfolio.get_latest_asset_position_date(val_date - BDay(1), with_estimated=True)
     ) and portfolio.assets.filter(date=val_date).exists():
         analytic_portfolio = portfolio.get_analytic_portfolio(val_date, with_previous_weights=True)
-        with suppress(InstrumentPrice.DoesNotExist, IndexError):
-            if not instrument.prices.filter(date__lte=previous_date).exists():
-                previous_net_asset_value = instrument.issue_price
-            else:
-                previous_net_asset_value = (
-                    InstrumentPrice.objects.filter_only_valid_prices()
-                    .get(instrument=instrument, date=previous_date)
-                    .net_value
-                )
-            return analytic_portfolio.get_estimate_net_value(float(previous_net_asset_value))
+        with suppress(IndexError):
+            if last_price := instrument.get_latest_price(previous_date):
+                return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
 @receiver(post_save, sender="wbportfolio.Product")
@@ -1240,10 +1238,10 @@ def batch_recompute_lookthrough_as_task(portfolio_id: int, start: date, end: dat
 @receiver(investable_universe_updated, sender="wbfdm.Instrument")
 def update_portfolio_after_investable_universe(*args, end_date: date | None = None, **kwargs):
     if not end_date:
-        end_date = (date.today() - BDay(1)).date()
+        end_date = date.today()
+    end_date = (end_date + timedelta(days=1) - BDay(1)).date()  # shift in case of business day
     from_date = (end_date - BDay(1)).date()
     for portfolio in Portfolio.tracked_objects.filter(is_lookthrough=False).to_dependency_iterator(from_date):
-        logger.info(f"computing next weight for {portfolio} from {from_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
         try:
             portfolio.propagate_or_update_assets(from_date, end_date)
         except Exception as e:

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/models/transactions/rebalancing.py

@@ -1,3 +1,4 @@
+import logging
 from datetime import date
 
 from dateutil import rrule
@@ -18,6 +19,8 @@ from wbportfolio.models.transactions.trade_proposals import TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 
+logger = logging.getLogger("pms")
+
 
 class RebalancingModel(models.Model):
     name = models.CharField(max_length=64, verbose_name="Name")
@@ -44,7 +47,7 @@ class RebalancingModel(models.Model):
     ) -> PortfolioDTO:
         model = self.model_class(portfolio, trade_date, last_effective_date, **kwargs)
         if not model.is_valid():
-            raise ValidationError("Rebalacing cannot applied for these parameters")
+            raise ValidationError(model.validation_errors)
         return model.get_target_portfolio()
 
     @classmethod
@@ -74,7 +77,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     activation_date = models.DateField(verbose_name="Activation Date")
     frequency = models.CharField(
         default="RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=1",
-        max_length=56,
+        max_length=256,
         verbose_name=_("Evaluation Frequency"),
         help_text=_("The Evaluation Frequency in RRULE format"),
     )
@@ -113,6 +116,9 @@ 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:

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/models/transactions/trade_proposals.py

@@ -195,8 +195,12 @@ class TradeProposal(RiskCheckMixin, WBModel):
 
     def _get_target_portfolio(self, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
+            params = {}
+            if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
+                params.update(rebalancer.parameters)
+            params.update(kwargs)
             return self.rebalancing_model.get_target_portfolio(
-                self.portfolio, self.trade_date, self.last_effective_date, **kwargs
+                self.portfolio, self.trade_date, self.last_effective_date, **params
             )
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
@@ -245,28 +249,31 @@ class TradeProposal(RiskCheckMixin, WBModel):
             trade.save()
 
     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
+        last_trade_proposal = self
+        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 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
+            if not last_trade_proposal.portfolio.assets.filter(date=last_trade_proposal.trade_date).exists():
+                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:
+                    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()
+                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 = trade_proposal.portfolio.batch_portfolio(
-                trade_proposal.trade_date, next_trade_date
+            overriding_trade_proposal = last_trade_proposal.portfolio.batch_portfolio(
+                last_trade_proposal.trade_date, next_trade_date
             )
-            trade_proposal = overriding_trade_proposal or next_trade_proposal
+            last_trade_proposal = overriding_trade_proposal or next_trade_proposal
 
     def estimate_shares(self, trade: Trade) -> Decimal | None:
         if not self.portfolio.only_weighting and (quote := trade.underlying_quote_price):

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/models/transactions/trades.py

@@ -42,7 +42,7 @@ class TradeQueryset(OrderedModelQuerySet):
     def annotate_base_info(self):
         return self.annotate(
             last_effective_date=Subquery(
-                AssetPosition.objects.filter(
+                AssetPosition.unannotated_objects.filter(
                     date__lte=OuterRef("value_date"),
                     portfolio=OuterRef("portfolio"),
                 )
@@ -51,7 +51,7 @@ class TradeQueryset(OrderedModelQuerySet):
             ),
             effective_weight=Coalesce(
                 Subquery(
-                    AssetPosition.objects.filter(
+                    AssetPosition.unannotated_objects.filter(
                         underlying_quote=OuterRef("underlying_instrument"),
                         date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
@@ -389,7 +389,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     )
     def revert(self, to_date=None, **kwargs):
         with suppress(AssetPosition.DoesNotExist):
-            asset = AssetPosition.objects.get(
+            asset = AssetPosition.unannotated_objects.get(
                 underlying_quote=self.underlying_instrument,
                 portfolio=self.portfolio,
                 date=self.transaction_date,
@@ -412,7 +412,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         if hasattr(self, "last_effective_date"):
             return self.last_effective_date
         elif (
-            assets := AssetPosition.objects.filter(
+            assets := AssetPosition.unannotated_objects.filter(
                 underlying_quote=self.underlying_instrument,
                 date__lt=self.transaction_date,
                 portfolio=self.portfolio,
@@ -426,7 +426,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         return getattr(
             self,
             "effective_weight",
-            AssetPosition.objects.filter(
+            AssetPosition.unannotated_objects.filter(
                 underlying_quote=self.underlying_instrument,
                 date=self._last_effective_date,
                 portfolio=self.portfolio,

{wbportfolio-1.46.1 → wbportfolio-1.46.2}/wbportfolio/rebalancing/base.py

@@ -4,6 +4,10 @@ from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
 
 class AbstractRebalancingModel:
+    @property
+    def validation_errors(self) -> str:
+        return getattr(self, "_validation_errors", "Rebalacing cannot applied for these parameters")
+
     def __init__(self, portfolio, trade_date: date, last_effective_date: date, **kwargs):
         self.portfolio = portfolio
         self.trade_date = trade_date