wbportfolio 1.46.9__tar.gz → 1.46.11__tar.gz

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/PKG-INFO

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

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/models/asset.py

@@ -1,6 +1,6 @@
 from contextlib import suppress
 from datetime import date
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 
 from django.contrib import admin
 from django.db import models
@@ -393,7 +393,9 @@ class AssetPosition(ImportMixin, models.Model):
     analytical_objects = AnalyticalAssetPositionManager()
     unannotated_objects = models.Manager()
 
-    def pre_save(self, create_underlying_quote_price_if_missing: bool = False):
+    def pre_save(
+        self, create_underlying_quote_price_if_missing: bool = False, infer_underlying_quote_price: bool = True
+    ):
         if not self.asset_valuation_date:
             self.asset_valuation_date = self.date
 
@@ -417,10 +419,10 @@ class AssetPosition(ImportMixin, models.Model):
 
         if not getattr(self, "currency", None):
             self.currency = self.underlying_quote.currency
-        if not self.underlying_quote_price:
+        if not self.underlying_quote_price and infer_underlying_quote_price:
             try:
                 # We get only the instrument price (and don't create it) because we don't want to create product instrument price on asset position propagation
-                # Instead, we deciced to opt for a post_save based system that will assign the missing position price when a price is created
+                # Instead, we decided to opt for a post_save based system that will assign the missing position price when a price is created
                 self.underlying_quote_price = InstrumentPrice.objects.get(
                     calculated=False, instrument=self.underlying_quote, date=self.asset_valuation_date
                 )
@@ -468,9 +470,12 @@ class AssetPosition(ImportMixin, models.Model):
         if self.initial_currency_fx_rate is None:
             self.initial_currency_fx_rate = Decimal(1.0)
             if self.currency_fx_rate_portfolio_to_usd and self.currency_fx_rate_instrument_to_usd:
-                self.initial_currency_fx_rate = (
-                    self.currency_fx_rate_portfolio_to_usd.value / self.currency_fx_rate_instrument_to_usd.value
-                )
+                try:
+                    self.initial_currency_fx_rate = (
+                        self.currency_fx_rate_portfolio_to_usd.value / self.currency_fx_rate_instrument_to_usd.value
+                    )
+                except InvalidOperation:
+                    self.initial_currency_fx_rate = Decimal(0.0)
 
     def save(self, *args, create_underlying_quote_price_if_missing: bool = False, **kwargs):
         self.pre_save(create_underlying_quote_price_if_missing=create_underlying_quote_price_if_missing)

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/models/mixins/instruments.py

@@ -65,7 +65,9 @@ class PMSInstrument(Instrument):
         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():
+            if (not self.inception_date or self.inception_date == val_date) and 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]

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/models/portfolio.py

@@ -1,4 +1,5 @@
 import logging
+from collections import defaultdict
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
@@ -26,6 +27,7 @@ from django.db.models import (
 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 pandas._libs.tslibs.offsets import BDay
 from psycopg.types.range import DateRange
 from skfolio.preprocessing import prices_to_returns
@@ -54,6 +56,63 @@ from . import ProductGroup
 logger = logging.getLogger("pms")
 
 
+class PositionDictConverter:
+    """Utility class to load a dictionary of dictionary (dictionary of instrument_id and float per date) into a iterable of assetposition"""
+
+    def __init__(self, portfolio, prices: pd.DataFrame, infer_underlying_quote_price=False):
+        self.portfolio = portfolio
+        self.instruments = {}
+        self.fx_rates = defaultdict(dict)
+        self.prices = prices
+        self.infer_underlying_quote_price = infer_underlying_quote_price
+
+    def _get_instrument(self, instrument_id: int) -> Instrument:
+        try:
+            return self.instruments[instrument_id]
+        except KeyError:
+            instrument = Instrument.objects.get(id=instrument_id)
+            self.instruments[instrument_id] = instrument
+            return instrument
+
+    def _get_fx_rate(self, val_date: date, currency) -> CurrencyFXRates:
+        try:
+            return self.fx_rates[currency][val_date]
+        except KeyError:
+            fx_rate = CurrencyFXRates.objects.get_or_create(
+                currency=currency, date=val_date, defaults={"value": Decimal(0)}
+            )[0]  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
+            self.fx_rates[currency][val_date] = fx_rate
+            return fx_rate
+
+    def dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> AssetPosition:
+        underlying_quote = self._get_instrument(instrument_id)
+        currency_fx_rate_portfolio_to_usd = self._get_fx_rate(val_date, self.portfolio.currency)
+        currency_fx_rate_instrument_to_usd = self._get_fx_rate(val_date, underlying_quote.currency)
+        position = AssetPosition(
+            underlying_quote=underlying_quote,
+            weighting=weighting,
+            date=val_date,
+            asset_valuation_date=val_date,
+            is_estimated=True,
+            portfolio=self.portfolio,
+            currency=underlying_quote.currency,
+            initial_price=self.prices.loc[pd.Timestamp(val_date), instrument_id],
+            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
+            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
+            initial_currency_fx_rate=None,
+            underlying_quote_price=None,
+            underlying_instrument=None,
+        )
+        position.pre_save(
+            infer_underlying_quote_price=self.infer_underlying_quote_price
+        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
+        return position
+
+    def convert(self, positions: dict[date, dict[int, float]]) -> Iterable[AssetPosition]:
+        for val_date, weights in positions.items():
+            yield from map(lambda row: self.dict_to_model(val_date, row[0], row[1]), weights.items())
+
+
 class DefaultPortfolioQueryset(QuerySet):
     def filter_invested_at_date(self, val_date: date) -> QuerySet:
         """
@@ -253,11 +312,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def imported_assets(self):
         return self.assets.filter(is_estimated=False)
 
-    @property
+    @cached_property
     def pms_instruments(self):
-        yield from Product.objects.filter(portfolios=self)
-        yield from ProductGroup.objects.filter(portfolios=self)
-        yield from Index.objects.filter(portfolios=self)
+        instruments = [i for i in Product.objects.filter(portfolios=self)]
+        instruments.extend([i for i in ProductGroup.objects.filter(portfolios=self)])
+        instruments.extend([i for i in Index.objects.filter(portfolios=self)])
+        return instruments
 
     @property
     def can_be_rebalanced(self):
@@ -298,31 +358,28 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         )
 
-    def get_analytic_portfolio(self, val_date: date, with_previous_weights: bool = False) -> AnalyticPortfolio:
+    def get_analytic_portfolio(self, val_date: date, **kwargs) -> tuple[AnalyticPortfolio, pd.DataFrame]:
         """
         Return the analytic portfolio associated with this portfolio at the given date
 
         the analytic portfolio inherit from SKFolio Portfolio and can be used to access all this library methods
         Args:
             val_date: the date to calculate the portfolio for
-            with_previous_weights: If true, excludes the previous weights into the analytic portfolio (might be necessary for some metrics)
 
         Returns:
             The instantiated analytic portfolio
         """
         weights = self.get_weights(val_date)
         instrument_ids = weights.keys()
-        previous_weights = None
-        if with_previous_weights:
-            if previous_date := self.get_latest_asset_position_date(val_date - timedelta(days=1)):
-                previous_weights = self.get_weights(previous_date)
-                instrument_ids = previous_weights.keys()
-        returns = self.get_returns(instrument_ids, (val_date - BDay(3)).date(), val_date)[0]
+        return_date = (val_date + BDay(1)).date()
+        returns, prices = self.get_returns(instrument_ids, (val_date - BDay(2)).date(), return_date, **kwargs)
         returns = returns.fillna(0)  # not sure this is what we want
-        return AnalyticPortfolio(
-            X=returns,
-            weights=weights,
-            previous_weights=previous_weights,
+        return (
+            AnalyticPortfolio(
+                X=returns,
+                weights=weights,
+            ),
+            prices,
         )
 
     def is_invested_at_date(self, val_date: date) -> bool:
@@ -567,10 +624,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def get_child_portfolios(self, val_date: date) -> set["Portfolio"]:
         child_portfolios = set()
-        if pms_instruments := list(self.pms_instruments):
+        instrument_rel = InstrumentPortfolioThroughModel.objects.filter(portfolio=self)
+        if instrument_rel.exists():
             for parent_portfolio in Portfolio.objects.filter(
                 id__in=AssetPosition.unannotated_objects.filter(
-                    date=val_date, underlying_quote__in=pms_instruments
+                    date=val_date, underlying_quote__in=instrument_rel.values("instrument")
                 ).values("portfolio")
             ):
                 child_portfolios.add(parent_portfolio)
@@ -592,27 +650,32 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         evaluate_rebalancer: bool = True,
     ):
         logger.info(f"change at date for {self} at {val_date}")
-        qs = self.assets.filter(date=val_date).filter(
-            Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False)
-        )
 
-        # We normalize weight across the portfolio for a given date
-        if (self.is_lookthrough or self.is_manageable or force_recompute_weighting) and qs.exists():
-            total_weighting = qs.aggregate(s=Sum("weighting"))["s"]
-            # We check if this actually necessary
-            # (i.e. if the weight is already summed to 100%, it is already normalized)
-            if not total_weighting or not isclose(total_weighting, Decimal(1.0), abs_tol=0.001) or recompute_weighting:
-                total_value = qs.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
-                # TODO we change this because postgres doesn't support join statement in update (and total_value_fx_portfolio is a joined annoted field)
-                for asset in qs:
-                    if total_value:
-                        asset.weighting = asset._total_value_fx_portfolio / total_value
-                    elif total_weighting:
-                        asset.weighting = asset.weighting / total_weighting
-                    asset.save()
+        if recompute_weighting:
+            # We normalize weight across the portfolio for a given date
+            qs = self.assets.filter(date=val_date).filter(
+                Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False)
+            )
+            if (self.is_lookthrough or self.is_manageable or force_recompute_weighting) and qs.exists():
+                total_weighting = qs.aggregate(s=Sum("weighting"))["s"]
+                # We check if this actually necessary
+                # (i.e. if the weight is already summed to 100%, it is already normalized)
+                if (
+                    not total_weighting
+                    or not isclose(total_weighting, Decimal(1.0), abs_tol=0.001)
+                    or force_recompute_weighting
+                ):
+                    total_value = qs.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
+                    # TODO we change this because postgres doesn't support join statement in update (and total_value_fx_portfolio is a joined annoted field)
+                    for asset in qs:
+                        if total_value:
+                            asset.weighting = asset._total_value_fx_portfolio / total_value
+                        elif total_weighting:
+                            asset.weighting = asset.weighting / total_weighting
+                        asset.save()
 
         # 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.estimate_net_asset_values((val_date + BDay(1)).date())  # updating weighting in t0 influence nav in t+1
         if evaluate_rebalancer:
             self.evaluate_rebalancing(val_date)
 
@@ -641,17 +704,21 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
 
     def evaluate_rebalancing(self, val_date: date):
-        # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a trade proposal automatically
-        next_business_date = (val_date + BDay(1)).date()
-
         if hasattr(self, "automatic_rebalancer"):
-            logger.info(f"Evaluate Rebalancing for {self} at {next_business_date}")
+            # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a trade proposal automatically
+            next_business_date = (val_date + BDay(1)).date()
+            if self.automatic_rebalancer.is_valid(val_date):  # we evaluate the rebalancer in t0 and t+1
+                logger.info(f"Evaluate Rebalancing for {self} at {val_date}")
+                self.automatic_rebalancer.evaluate_rebalancing(val_date)
             if self.automatic_rebalancer.is_valid(next_business_date):
+                logger.info(f"Evaluate Rebalancing for {self} at {next_business_date}")
                 self.automatic_rebalancer.evaluate_rebalancing(next_business_date)
 
     def estimate_net_asset_values(self, val_date: date):
         for instrument in self.pms_instruments:
-            if net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path:
+            if instrument.is_active_at_date(val_date) and (
+                net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path
+            ):
                 logger.info(f"Estimate NAV of {val_date:%Y-%m-%d} for instrument {instrument}")
                 net_asset_value_computation_method = import_from_dotted_path(net_asset_value_computation_method_path)
                 estimated_net_asset_value = net_asset_value_computation_method(val_date, instrument)
@@ -671,76 +738,32 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         instrument.update_last_valuation_date()
                 instrument.update_last_valuation_date()
 
-    def get_estimated_portfolio_from_weights(
-        self, val_date: date, weights: dict[int, float], prices: dict[int, Decimal] | None = None
-    ) -> Iterable[AssetPosition]:
-        """
-        Given weights and the corresponding instrument price, instantiate asset positions (as AssetPosition object)
-
-        Args:
-            val_date: The positions valuation date
-            weights: The positions weights as dictionary (Instrument IDS as key and weights as values)
-            prices: The prices associated with each position
-
-        Returns:
-            Yield AssetPosition objects.
-        """
-        if prices is None:
-            prices = dict()
-        try:
-            currency_fx_rate_portfolio_to_usd = CurrencyFXRates.objects.get(date=val_date, currency=self.currency)
-        except CurrencyFXRates.DoesNotExist:
-            currency_fx_rate_portfolio_to_usd = None
-        for underlying_quote_id, next_weight in weights.items():
-            underlying_quote = Instrument.objects.get(id=underlying_quote_id)
-            position = AssetPosition(
-                underlying_quote=underlying_quote,
-                weighting=next_weight,
-                date=val_date,
-                asset_valuation_date=val_date,
-                is_estimated=True,
-                portfolio=self,
-                currency=underlying_quote.currency,
-                currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
-                initial_price=prices.get(underlying_quote_id, None),
-                initial_currency_fx_rate=None,
-                currency_fx_rate_instrument_to_usd=None,
-                underlying_quote_price=None,
-                underlying_instrument=None,
-            )
-            position.pre_save()
-            yield position
-
     def batch_portfolio(self, start_date: date, end_date: date):
         """
         Create the cumulative portfolios between the two given dates and stop at the first rebalancing (if any)
 
         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 = []
+
+        weights = self.get_weights(start_date)  # initial weights
+        positions = dict()
         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)
+        returns, prices = self.get_returns(weights.keys(), (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()
             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)
-            positions.extend(
-                self.get_estimated_portfolio_from_weights(
-                    to_date, next_weights, prices.loc[to_date_ts, :].dropna().to_dict()
-                )
-            )
-            analytic_portfolio = AnalyticPortfolio(X=last_returns, weights=next_weights)
+            analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
+            positions[to_date] = analytic_portfolio.get_next_weights()
 
+        positions_generator = PositionDictConverter(self, prices)
+        positions = list(positions_generator.convert(positions))
         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)
@@ -774,18 +797,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             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:
-                weights = analytic_portfolio.get_next_weights(returns.iloc[-1, :].T)
-                positions = list(
-                    map(
-                        lambda a: _parse_position(a),
-                        self.get_estimated_portfolio_from_weights(
-                            to_date, weights, prices.iloc[-1, :].T.dropna().to_dict()
-                        ),
-                    )
-                )
+            analytic_portfolio, to_prices = self.get_analytic_portfolio(from_date)
+            if not to_prices.empty:
+                weights = analytic_portfolio.get_next_weights()
+                positions_generator = PositionDictConverter(
+                    self, to_prices, infer_underlying_quote_price=True
+                ).convert({to_date: weights})
+                positions = list(map(lambda a: _parse_position(a), positions_generator))
                 self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
 
     def get_lookthrough_positions(
@@ -932,8 +950,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             for position in positions:
                 position.portfolio = self
                 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()
+            # self.assets.filter(date__in=update_dates, is_estimated=True).delete()
+            leftover_positions_ids = list(
+                self.assets.filter(date__in=update_dates).values_list("id", flat=True)
+            )  # we need to get the ids otherwise the queryset is reevaluated later
+            logger.info(f"bulk saving {len(positions)} positions ({len(leftover_positions_ids)} leftovers) ...")
             objs = AssetPosition.unannotated_objects.bulk_create(
                 positions,
                 update_fields=[
@@ -951,11 +972,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 ],
                 unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
                 update_conflicts=True,
+                batch_size=10000,
             )
             if delete_leftovers:
-                for leftover_position in leftover_positions:
-                    if leftover_position not in objs:  # this works because __eq__ of a django model use the id field
-                        leftover_position.delete()
+                objs_ids = list(map(lambda x: x.id, objs))
+                leftover_positions_ids = list(filter(lambda i: i not in objs_ids, leftover_positions_ids))
+                logger.info(f"deleting {len(leftover_positions_ids)} leftover positions..")
+                AssetPosition.objects.filter(id__in=leftover_positions_ids).delete()
             for update_date in sorted(update_dates):
                 self.change_at_date(update_date, **kwargs)
 
@@ -972,7 +995,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return self.assets.filter(Q(date=val_date) & ~Q(initial_shares=F("initial_shares_at_custodian"))).exists()
 
     def get_returns(
-        self, instruments: Iterable, from_date: date, to_date: date, ffill_returns: bool = True
+        self,
+        instruments: Iterable,
+        from_date: date,
+        to_date: date,
+        ffill_returns: bool = True,
+        convert_to_portfolio_currency: bool = True,
     ) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
         Utility methods to get instrument returns for a given date range
@@ -988,8 +1016,10 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         prices = InstrumentPrice.objects.filter(
             instrument__in=instruments, date__gte=from_date, date__lte=to_date
         ).annotate(
-            # fx_rate=CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", self.currency),
-            price_fx_portfolio=F("net_value")  # * F("net_value")
+            fx_rate=CurrencyFXRates.get_fx_rates_subquery_for_two_currencies(
+                "date", "instrument__currency", self.currency
+            ),
+            price_fx_portfolio=F("net_value") * F("fx_rate") if convert_to_portfolio_currency else F("net_value"),
         )
         prices_df = (
             pd.DataFrame(
@@ -1187,13 +1217,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
 def default_estimate_net_value(val_date: date, instrument: Instrument) -> float | None:
     portfolio = instrument.portfolio
-    if (
-        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(IndexError):
-            if last_price := instrument.get_latest_price(previous_date):
-                return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
+    if (previous_date := portfolio.get_latest_asset_position_date(val_date - BDay(1), with_estimated=True)) and (
+        last_price := instrument.get_latest_price(previous_date)
+    ):
+        with suppress(IndexError):  # we silent any indexerror introduced by no returns for the past days
+            analytic_portfolio, _ = portfolio.get_analytic_portfolio(previous_date)
+            return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
 @receiver(post_save, sender="wbportfolio.Product")

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/models/transactions/rebalancing.py

@@ -99,11 +99,16 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
-        for valid_datetime in self.get_rrule(trade_date):
-            valid_date = self._get_next_valid_date(valid_datetime.date())
-            if valid_date == trade_date:
+        if TradeProposal.objects.filter(
+            portfolio=self.portfolio, status=TradeProposal.Status.APPROVED, trade_date=trade_date
+        ).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):
+            initial_valid_date = initial_valid_datetime.date()
+            alternative_valid_date = self._get_next_valid_date(initial_valid_date)
+            if trade_date in [alternative_valid_date, initial_valid_date]:
                 return True
-            if valid_date > trade_date:
+            if alternative_valid_date > trade_date:
                 break
         return False
 

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/models/transactions/trade_proposals.py

@@ -79,6 +79,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
         if not self.rebalancing_model and (rebalancer := getattr(self.portfolio, "automatic_rebalancer", None)):
             self.rebalancing_model = rebalancer.rebalancing_model
         super().save(*args, **kwargs)
+        if self.status == TradeProposal.Status.APPROVED:
+            self.portfolio.change_at_date(self.trade_date)
 
     def _get_checked_object_field_name(self) -> str:
         """
@@ -234,7 +236,6 @@ class TradeProposal(RiskCheckMixin, WBModel):
         )
         service.normalize()
         service.is_valid()
-
         for trade_dto in service.validated_trades:
             instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
             currency_fx_rate = instrument.currency.convert(
@@ -378,8 +379,6 @@ class TradeProposal(RiskCheckMixin, WBModel):
         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()

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/pms/analytics/portfolio.py

@@ -16,16 +16,14 @@ class Portfolio(BasePortfolio):
         )
         return df
 
-    def get_next_weights(self, returns: pd.Series) -> dict[int, float]:
+    def get_next_weights(self) -> dict[int, float]:
         """
-        Given the next returns, compute the next weights of this portfolio
-
-        Args:
-            returns: The returns for the next day as a pandas series
+        Given the next returns, compute the drifted weights of this portfolio
 
         Returns:
             A dictionary of weights (instrument ids as keys and weights as values)
         """
+        returns = self.X.iloc[-1, :].T
         weights = self.all_weights_per_observation.iloc[-1, :].T
         if weights.sum() != 0:
             weights /= weights.sum()
@@ -35,7 +33,5 @@ class Portfolio(BasePortfolio):
         return contribution.dropna().to_dict()
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:
-        if self.previous_weights is None:
-            raise ValueError("No previous weights available")
-        expected_returns = self.previous_weights @ self.X.iloc[-1, :].T
+        expected_returns = self.weights @ self.X.iloc[-1, :].T
         return previous_net_asset_value * (1.0 + expected_returns)

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/pms/trading/handler.py

@@ -97,7 +97,7 @@ class TradingService:
             effective_shares = 0
             instrument_type = currency = None
             if effective_pos := effective_portfolio.positions_map.get(instrument, None):
-                effective_weight = target_weight = effective_pos.weighting
+                effective_weight = effective_pos.weighting
                 effective_shares = effective_pos.shares
                 instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
             if target_pos := target_portfolio.positions_map.get(instrument, None):

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -1,5 +1,6 @@
 from decimal import Decimal
 
+import numpy as np
 import pandas as pd
 from django.db.models import Q, QuerySet
 from wbfdm.enums import MarketData
@@ -26,7 +27,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
         self.market_cap_df = pd.DataFrame(
             instruments.dl.market_data(
                 values=[MarketData.MARKET_CAPITALIZATION],
-                exact_date=self.last_effective_date,
+                exact_date=self.trade_date,
                 target_currency=self.TARGET_CURRENCY,
             )
         )
@@ -80,9 +81,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
 
         if not instrument_ids:
             instrument_ids = list(
-                self.portfolio.assets.filter(date=self.last_effective_date).values_list(
-                    "underlying_instrument", flat=True
-                )
+                self.portfolio.assets.filter(date=self.trade_date).values_list("underlying_instrument", flat=True)
             )
 
         return Instrument.objects.filter(id__in=instrument_ids).filter(
@@ -107,14 +106,16 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        market_cap_df = self.market_cap_df.dropna()
-        total_market_cap = market_cap_df.sum()
-
-        for underlying_instrument, market_cap in market_cap_df.to_dict().items():
+        total_market_cap = self.market_cap_df.dropna().sum()
+        for underlying_instrument, market_cap in self.market_cap_df.to_dict().items():
+            if np.isnan(market_cap):
+                weighting = Decimal(0)
+            else:
+                weighting = Decimal(market_cap / total_market_cap)
             positions.append(
                 Position(
                     underlying_instrument=underlying_instrument,
-                    weighting=Decimal(market_cap / total_market_cap),
+                    weighting=weighting,
                     date=self.trade_date,
                 )
             )

{wbportfolio-1.46.9 → wbportfolio-1.46.11}/wbportfolio/serializers/transactions/trade_proposals.py

@@ -46,7 +46,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
             obj.reset_trades(target_portfolio=target_portfolio_dto)
         except ValidationError as e:
             if request := self.context.get("request"):
-                warning(request, str(e))
+                warning(request, str(e), extra_tags="auto_close=0")
         return obj
 
     @wb_serializers.register_only_instance_resource()