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

wbportfolio/models/portfolio.py

@@ -1,12 +1,14 @@
+import logging
 from contextlib import suppress
-from datetime import date, datetime, timedelta
+from datetime import date, timedelta
 from decimal import Decimal
 from math import isclose
-from typing import Any
+from typing import Any, Iterable
 
 import numpy as np
 import pandas as pd
 from celery import shared_task
+from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.fields import DateRangeField
 from django.db import models
 from django.db.models import (
@@ -23,14 +25,20 @@ from django.db.models import (
 )
 from django.db.models.signals import post_save
 from django.dispatch import receiver
+from django.utils import timezone
+from pandas._libs.tslibs.offsets import BDay
 from psycopg.types.range import DateRange
-from wbcore.contrib.currency.models import CurrencyFXRates
+from skfolio.preprocessing import prices_to_returns
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
+from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ActiveObjectManager, DeleteToDisableMixin
-from wbfdm.contrib.metric.dispatch import compute_metrics
-from wbfdm.models import Instrument
+from wbfdm.contrib.metric.tasks import compute_metrics_as_task
+from wbfdm.models import Instrument, InstrumentType
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+from wbfdm.signals import investable_universe_updated
+
 from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.indexes import Index
 from wbportfolio.models.portfolio_relationship import (
@@ -38,9 +46,12 @@ from wbportfolio.models.portfolio_relationship import (
     PortfolioInstrumentPreferredClassificationThroughModel,
 )
 from wbportfolio.models.products import Product
+from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
-from .utils import get_casted_portfolio_instrument
+from . import ProductGroup
+
+logger = logging.getLogger("pms")
 
 
 class DefaultPortfolioQueryset(QuerySet):
@@ -48,7 +59,44 @@ class DefaultPortfolioQueryset(QuerySet):
         """
         Filter the queryset to get only portfolio invested at the given date
         """
-        return self.filter(invested_timespan__startswith__lte=val_date, invested_timespan__endswith__gt=val_date)
+        return self.filter(
+            (Q(invested_timespan__startswith__lte=val_date) | Q(invested_timespan__startswith__isnull=True))
+            & (Q(invested_timespan__endswith__gt=val_date) | Q(invested_timespan__endswith__isnull=True))
+        )
+
+    def to_dependency_iterator(self, val_date: date) -> Iterable["Portfolio"]:
+        """
+        A method to sort the given queryset to return undependable portfolio first. This is very useful if a routine needs to be applied sequentially on portfolios by order of dependence.
+        """
+        MAX_ITERATIONS: int = (
+            5  # in order to avoid circular dependency and infinite loop, we need to stop recursion at a max depth
+        )
+        remaining_portfolios = set(self)
+
+        def _iterator(p, iterator_counter=0):
+            iterator_counter += 1
+            parent_portfolios = remaining_portfolios & set(
+                map(lambda o: o[0], p.get_parent_portfolios(val_date))
+            )  # get composition parent portfolios
+            dependency_relationships = PortfolioPortfolioThroughModel.objects.filter(
+                portfolio=p, dependency_portfolio__in=remaining_portfolios
+            )  # get dependency portfolios
+            if iterator_counter >= MAX_ITERATIONS or (
+                not dependency_relationships.exists() and not bool(parent_portfolios)
+            ):  # if not dependency portfolio or parent portfolio that remained, then we yield
+                remaining_portfolios.remove(p)
+                yield p
+            else:
+                # otherwise, we iterate of the dependency portfolio first
+                deps_portfolios = parent_portfolios.union(
+                    set([r.dependency_portfolio for r in dependency_relationships])
+                )
+                for deps_p in deps_portfolios:
+                    yield from _iterator(deps_p, iterator_counter=iterator_counter)
+
+        while len(remaining_portfolios) > 0:
+            portfolio = next(iter(remaining_portfolios))
+            yield from _iterator(portfolio)
 
 
 class DefaultPortfolioManager(ActiveObjectManager):
@@ -73,8 +121,6 @@ class PortfolioPortfolioThroughModel(models.Model):
     class Type(models.TextChoices):
         PRIMARY = "PRIMARY", "Primary"
         MODEL = "MODEL", "Model"
-        BENCHMARK = "BENCHMARK", "Benchmark"
-        INDEX = "INDEX", "Index"
         CUSTODIAN = "CUSTODIAN", "Custodian"
 
     portfolio = models.ForeignKey("wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="dependency_through")
@@ -83,6 +129,9 @@ class PortfolioPortfolioThroughModel(models.Model):
     )
     type = models.CharField(choices=Type.choices, default=Type.PRIMARY, verbose_name="Type")
 
+    def __str__(self):
+        return f"{self.portfolio} dependant on {self.dependency_portfolio} ({self.Type[self.type].label})"
+
     class Meta:
         constraints = [
             models.UniqueConstraint(fields=["portfolio", "type"], name="unique_primary", condition=Q(type="PRIMARY")),
@@ -126,14 +175,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         verbose_name="The portfolios this portfolio depends on",
     )
 
-    portfolio_synchronization = models.ForeignKey(
-        "wbportfolio.PortfolioSynchronization",
-        null=True,
-        blank=True,
-        on_delete=models.SET_NULL,
-        related_name="portfolios",
-        verbose_name="Portfolio Synchronization Method",
-    )
     preferred_instrument_classifications = models.ManyToManyField(
         "wbfdm.Instrument",
         limit_choices_to=(models.Q(instrument_type__is_classifiable=True) & models.Q(level=0)),
@@ -161,20 +202,27 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     )
     is_tracked = models.BooleanField(
         default=True,
-        help_text="True if the internal updating mechanism (e.g., Propagation, Synchronization etc...) needs to apply to this portfolio",
+        help_text="True if the internal updating mechanism (e.g., Next weights or Look-Through computation, rebalancing etc...) needs to apply to this portfolio",
     )
     only_weighting = models.BooleanField(
         default=False,
         help_text="Indicates that this portfolio is only utilizing weights and disregards shares, e.g. a model portfolio",
     )
-
-    last_synchronization = models.DateTimeField(blank=True, null=True, verbose_name="Last Synchronization Date")
+    is_lookthrough = models.BooleanField(
+        default=False,
+        help_text="Indicates that this portfolio is a look-through portfolio",
+    )
+    is_composition = models.BooleanField(
+        default=False, help_text="If true, this portfolio is a composition of other portfolio"
+    )
+    updated_at = models.DateTimeField(blank=True, null=True, verbose_name="Updated At")
     bank_accounts = models.ManyToManyField(
         to="directory.BankingContact",
         related_name="wbportfolio_portfolios",
         through="wbportfolio.PortfolioBankAccountThroughModel",
         blank=True,
     )
+
     objects = DefaultPortfolioManager()
     tracked_objects = ActiveTrackedPortfolioManager()
 
@@ -193,16 +241,28 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             ).dependency_portfolio
 
     @property
-    def benchmark_portfolio(self):
+    def composition_portfolio(self):
         with suppress(PortfolioPortfolioThroughModel.DoesNotExist):
             return PortfolioPortfolioThroughModel.objects.get(
-                portfolio=self, type=PortfolioPortfolioThroughModel.Type.BENCHMARK
+                portfolio=self,
+                type=PortfolioPortfolioThroughModel.Type.MODEL,
+                dependency_portfolio__is_composition=True,
             ).dependency_portfolio
 
     @property
     def imported_assets(self):
         return self.assets.filter(is_estimated=False)
 
+    @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)
+
+    @property
+    def can_be_rebalanced(self):
+        return self.is_tracked and self.is_manageable and not self.is_lookthrough
+
     def delete(self, **kwargs):
         super().delete(**kwargs)
         # We check if for all linked instruments, this portfolio was the last active one (if yes, we disable the instrument)
@@ -212,10 +272,57 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     instrument.delisted_date = date.today() - timedelta(days=1)
                     instrument.save()
 
-    def _build_dto(self, val_date: date, **extra_filter_kwargs) -> PortfolioDTO:
+    def _build_dto(self, val_date: date, **extra_kwargs) -> PortfolioDTO:
         "returns the dto representation of this portfolio at the specified date"
         return PortfolioDTO(
-            tuple([pos._build_dto() for pos in self.assets.filter(date=val_date, **extra_filter_kwargs)])
+            tuple([pos._build_dto() for pos in self.assets.filter(date=val_date, **extra_kwargs)]),
+        )
+
+    def get_weights(self, val_date: date) -> dict[int, float]:
+        """
+        A convenience utility method to returns the portfolio weights for this portfolio as a dictionary (instrument id as key and weights as value)
+
+        Args:
+            val_date: The date at which to return the weights for this portfolio
+
+        Returns:
+            A dictionary containing the weights for this portfolio
+        """
+        return dict(
+            map(
+                lambda r: (r[0], float(r[1])),
+                self.assets.filter(date=val_date)
+                .values("underlying_quote")
+                .annotate(sum_weight=Sum("weighting"))
+                .values_list("underlying_quote", "sum_weight"),
+            )
+        )
+
+    def get_analytic_portfolio(self, val_date: date, with_previous_weights: bool = False) -> AnalyticPortfolio:
+        """
+        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]
+        returns = returns.fillna(0)  # not sure this is what we want
+        return AnalyticPortfolio(
+            X=returns,
+            weights=weights,
+            previous_weights=previous_weights,
         )
 
     def is_invested_at_date(self, val_date: date) -> bool:
@@ -243,22 +350,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             ),
         ]
 
-    @classmethod
-    def create_model_portfolio(cls, name, currency, portfolio_synchronization=None, index_parameters=dict()):
-        portfolio = cls.objects.create(
-            is_manageable=True,
-            name=name,
-            currency=currency,
-            portfolio_synchronization=portfolio_synchronization,
-        )
-        if index_parameters:
-            index = Index.objects.create(name=name, currency=currency, **index_parameters)
-            index.portfolios.all().delete()
-            InstrumentPortfolioThroughModel.objects.update_or_create(
-                instrument=index, defaults={"portfolio": portfolio}
-            )
-        return portfolio
-
     def is_active_at_date(self, val_date: date) -> bool:
         """
         Return if the base instrument has a total aum greater than 0
@@ -271,7 +362,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         return active_portfolio
 
-    def get_aum(self, val_date: date) -> Decimal:
+    def get_total_asset_value(self, val_date: date) -> Decimal:
         """
         Return the total asset under management of the portfolio at the specified valuation date
         Args:
@@ -281,7 +372,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         """
         return self.assets.filter(date=val_date).aggregate(s=Sum("total_value_fx_portfolio"))["s"] or Decimal(0.0)
 
-    def get_total_value(self, val_date):
+    def get_total_asset_under_management(self, val_date):
         from wbportfolio.models.transactions.trades import Trade
 
         trades = Trade.valid_customer_trade_objects.filter(portfolio=self, transaction_date__lte=val_date)
@@ -330,7 +421,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def get_holding(self, val_date, exclude_cash=True, exclude_index=True):
         qs = self._get_assets(with_cash=not exclude_cash).filter(date=val_date, weighting__gt=0)
         if exclude_index:
-            qs = qs.exclude(underlying_security_instrument_type_key="index")
+            qs = qs.exclude(underlying_instrument__instrument_type=InstrumentType.INDEX)
         return (
             qs.values("underlying_instrument__name")
             .annotate(total_value_fx_portfolio=Sum("total_value_fx_portfolio"), weighting=Sum("weighting"))
@@ -350,7 +441,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if exclude_index:
             # We exclude only index that are not considered as cash. Setting exclude_cash to true convers this case.
             qs = qs.exclude(
-                Q(underlying_security_instrument_type_key="index") & Q(underlying_instrument__is_cash=False)
+                Q(underlying_instrument__instrument_type=InstrumentType.INDEX)
+                & Q(underlying_instrument__is_cash=False)
             )
         if extra_filter_parameters:
             qs = qs.filter(**extra_filter_parameters)
@@ -384,7 +476,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             val_date=val_date,
             exclude_cash=True,
             exclude_index=True,
-            extra_filter_parameters={"underlying_security_instrument_type_key": "equity"},
+            extra_filter_parameters={"underlying_instrument__instrument_type": InstrumentType.EQUITY},
             **kwargs,
         )
         if not df.empty:
@@ -397,7 +489,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             val_date=val_date,
             exclude_cash=True,
             exclude_index=True,
-            extra_filter_parameters={"underlying_security_instrument_type_key": "equity"},
+            extra_filter_parameters={"underlying_instrument__instrument_type": InstrumentType.EQUITY},
             **kwargs,
         )
         if not df.empty:
@@ -462,33 +554,49 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def get_portfolio_contribution_df(self, start, end, with_cash=True, hedged_currency=None, only_equity=False):
         qs = self._get_assets(with_cash=with_cash).filter(date__gte=start, date__lte=end)
         if only_equity:
-            qs = qs.filter(underlying_security_instrument_type_key="equity")
+            qs = qs.filter(underlying_instrument__instrument_type=InstrumentType.EQUITY)
         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(
             date=val_date, underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
-        ).values("underlying_instrument__parent", "shares")
+        ).values("underlying_instrument", "shares")
         assets1 = assets.filter(portfolio=self)
         assets2 = assets.filter(portfolio=related_portfolio)
         return assets1.difference(assets2)
 
+    def get_child_portfolios(self, val_date: date) -> set["Portfolio"]:
+        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"
+                )
+            ):
+                child_portfolios.add(parent_portfolio)
+        return child_portfolios
+
+    def get_parent_portfolios(self, val_date: date) -> set["Portfolio"]:
+        for asset in self.assets.filter(date=val_date, underlying_instrument__portfolios__isnull=False).distinct(
+            "underlying_instrument"
+        ):
+            if portfolio := asset.underlying_instrument.portfolio:
+                yield portfolio, asset.weighting
+
     def change_at_date(
         self,
         val_date: date,
         recompute_weighting: bool = False,
         force_recompute_weighting: bool = False,
-        synchronize: bool = True,
-        **sync_kwargs,
+        compute_metrics: bool = False,
     ):
-        qs = (
-            self.assets.filter(date=val_date)
-            .filter(Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False))
-            .distinct()
+        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.portfolio_synchronization or self.is_manageable or force_recompute_weighting) and qs.exists():
+        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)
@@ -501,283 +609,257 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     elif total_weighting:
                         asset.weighting = asset.weighting / total_weighting
                     asset.save()
-        if synchronize:
-            for dependent_portfolio in self.dependent_portfolios.exclude(id=self.id).distinct():
-                # Check if the dependent portfolio has a synchronization method and has assets at the specified date
-                if (synchronization := dependent_portfolio.portfolio_synchronization) and (
-                    dependent_portfolio.assets.filter(date__gte=val_date).exists()
-                ):
-                    # If this is true, we want to apply the synchronization at every synchronization period
-                    # (scheduled crontab) from val_date to now.
-                    if synchronization.propagate_history:
-                        for _d in synchronization.dates_range(
-                            val_date, dependent_portfolio.assets.latest("date").date, filter_daily=True
-                        ):
-                            synchronization.synchronize_as_task_si(
-                                dependent_portfolio, _d, override_execution_datetime_validity=True
-                            ).apply_async()
-                    # Otherwise, we simply call a unique task for that date
-                    else:
-                        synchronization.synchronize_as_task_si(
-                            dependent_portfolio, val_date, override_execution_datetime_validity=True
-                        ).apply_async()
-
-            # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
-            for instrument in self.instruments.all():
-                if price_computation := getattr(
-                    get_casted_portfolio_instrument(instrument), "price_computation", None
-                ):
-                    inception_date = instrument.inception_date
-                    if isinstance(inception_date, datetime):
-                        inception_date = inception_date.date()
-
-                    if isinstance(val_date, datetime):
-                        val_date = val_date.date()
-
-                    if inception_date is None or inception_date > val_date:
-                        instrument.inception_date = val_date
-                        instrument.save()
-                    price_computation.compute(instrument, val_date, override_execution_datetime_validity=True)
-            compute_metrics(val_date, basket=self)
-
-    def propagate_or_update_assets(
-        self,
-        from_date: date,
-        to_date: date,
-        forward_price: bool | None = True,
-        base_assets: dict[str, str] | None = None,
-        delete_existing_assets: bool | None = False,
-    ):
-        # we don't propagate on already imported portfolio by default
-        is_target_portfolio_imported = self.assets.filter(date=to_date, is_estimated=False).exists()
-        if not base_assets:
-            base_assets = dict()
 
-        def _get_next_asset_valuation_date(current_asset_valuation_date):
-            return (current_asset_valuation_date + pd.offsets.BDay(np.busday_count(from_date, to_date))).date()
+        # 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)
+
+        self.updated_at = timezone.now()
+        self.save()
+
+        if compute_metrics:
+            compute_metrics_as_task.delay(
+                val_date, basket_id=self.id, basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id
+            )
+        self.handle_controlling_portfolio_change_at_date(val_date)
+
+    def handle_controlling_portfolio_change_at_date(self, val_date: date):
+        for rel in PortfolioPortfolioThroughModel.objects.filter(
+            dependency_portfolio=self, type=PortfolioPortfolioThroughModel.Type.PRIMARY, portfolio__is_lookthrough=True
+        ):
+            portfolio_total_asset_value = (
+                self.get_total_asset_under_management(val_date) if not self.only_weighting else None
+            )
+            rel.portfolio.compute_lookthrough(val_date, portfolio_total_asset_value=portfolio_total_asset_value)
+        for rel in PortfolioPortfolioThroughModel.objects.filter(
+            dependency_portfolio=self, type=PortfolioPortfolioThroughModel.Type.MODEL
+        ):
+            rel.portfolio.evaluate_rebalancing(val_date)
+        for dependent_portfolio in self.get_child_portfolios(val_date):
+            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 self.automatic_rebalancer.is_valid(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:
+                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)
+                if estimated_net_asset_value is not None:
+                    InstrumentPrice.objects.update_or_create(
+                        instrument=instrument,
+                        date=val_date,
+                        calculated=True,
+                        defaults={
+                            "gross_value": estimated_net_asset_value,
+                            "net_value": estimated_net_asset_value,
+                        },
+                    )
+                    if (
+                        val_date == instrument.prices.latest("date").date
+                    ):  # if price date is the latest instrument price date, we recompute the last valuation data
+                        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)
+        initial_assets = analytic_portfolio.assets
+        positions = []
+        next_trade_proposal = None
+        rebalancing_date = None
+        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
+            # 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)
+
+        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False)
+        if rebalancing_date:
+            next_trade_proposal = rebalancer.evaluate_rebalancing(rebalancing_date)
 
-        last_fx_date = CurrencyFXRates.objects.filter(date__lte=to_date).latest("date").date
-        fx_rates = CurrencyFXRates.objects.filter(date=last_fx_date)
-        assets = self.assets.filter(date=from_date)
+        return next_trade_proposal
 
+    def propagate_or_update_assets(self, from_date: date, to_date: date):
+        """
+        Create a new portfolio at `to_date` based on the portfolio in `from_date`.
+
+        Args:
+            from_date: The date to propagate the portfolio from
+            to_date:  The date to create the new portfolio at
+
+        """
         from_is_active = self.is_active_at_date(from_date)
         to_is_active = self.is_active_at_date(to_date)
-        # # We check is the current assets are already stored and if there is no already stored valid assets
-        # # With this, we ensure that we don't overwrite imported asset position with propagated ones.
-        # assets_positions_next_day_count = self.assets.filter(date=to_date).count()
-        if assets.exists() or base_assets:
-            # Remove already existing assets
-            if delete_existing_assets:
-                self.assets.filter(date=to_date).delete()
-            asset_list = list()
-            # If base_assets is provided,
-            # we assume that the portfolio composition is injected by this list of dictionary
-            if base_assets:
-                base_assets = (
-                    base_assets
-                    if isinstance(base_assets, dict)
-                    else {asset_id: Decimal(1 / len(base_assets)) for asset_id in base_assets}
-                )
 
-            remaining_base_assets = base_assets.copy()
-            # Loop over existing assets and construct the propagation assets list
-            for asset in assets.all():
-                # if a composition is provided, we ensure that existing assets don't deviate from it
-                if (base_assets and asset.underlying_instrument.id in base_assets.keys()) or not base_assets:
-                    next_asset_valuation_date = _get_next_asset_valuation_date(asset.asset_valuation_date)
-                    with suppress(ValueError):
-                        asset_list.append(
-                            {
-                                "initial_price": (
-                                    asset.initial_price
-                                    if asset._price is not None
-                                    else asset.underlying_instrument.get_price(from_date)
-                                ),
-                                "asset_valuation_date": next_asset_valuation_date,
-                                "weighting": asset.weighting,
-                                "next_initial_price": asset.underlying_instrument.get_price(next_asset_valuation_date),
-                                "underlying_instrument": asset.underlying_instrument,
-                                "exchange": asset.exchange,
-                                "portfolio": asset.portfolio,
-                                "portfolio_created": asset.portfolio_created,
-                                "currency": asset.currency,
-                                "initial_shares": asset.initial_shares,
-                            }
-                        )
-                remaining_base_assets.pop(asset.underlying_instrument.id, None)
-            # We ensure that the propagation assets list contains the proposed composition
-            for asset_id, weighting in remaining_base_assets.items():
-                instrument = Instrument.objects.get(id=asset_id)
-                with suppress(ValueError):
-                    asset_list.append(
-                        {
-                            "underlying_instrument": instrument,
-                            "initial_price": instrument.get_price(from_date),
-                            "next_initial_price": instrument.get_price(to_date),
-                            "asset_valuation_date": to_date,
-                            "initial_shares": None,
-                            "portfolio": self,
-                            "currency": instrument.currency,
-                            "weighting": weighting,
-                        }
+        def _parse_position(asset: AssetPosition) -> AssetPosition:
+            # 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(
+                date=from_date, underlying_quote=asset.underlying_quote, portfolio=self
+            ).aggregate(sum_shares=Sum("initial_shares"))["sum_shares"]
+            return asset
+
+        # we don't propagate on already imported portfolio by default
+        is_target_portfolio_imported = self.assets.filter(date=to_date, is_estimated=False).exists()
+        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
+            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()
+                        ),
                     )
+                )
+                self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
 
-            df = pd.DataFrame(asset_list)
-            if not df.empty:
-                df[["initial_price", "weighting", "next_initial_price"]] = df[
-                    ["initial_price", "weighting", "next_initial_price"]
-                ].astype("float")
-                idxx = pd.isnull(df["initial_price"]) & ~pd.isnull(df["next_initial_price"])
-                df.loc[idxx, "initial_price"] = df.loc[idxx, "next_initial_price"]
-                if forward_price:
-                    idx = pd.isnull(df["next_initial_price"])
-                    df.loc[idx, "next_initial_price"] = df.loc[idx, "initial_price"]
-                df = df.dropna(axis=0, subset=["next_initial_price", "initial_price"])
-                # Normalize weight to 100%. Exclude portfolio were sum of weight equals 0 (e.g. short/long portfolio)
-                if df.weighting.sum() != 0:
-                    df["weighting"] /= df.weighting.sum()
-                df.loc[:, "perf"] = df.loc[:, "next_initial_price"] / df.loc[:, "initial_price"]
-                df["contribution"] = df.perf * df.weighting
-                df.loc[:, "next_weighting"] = df.contribution
-
-                if df.contribution.sum() != 0:
-                    df.loc[:, "next_weighting"] /= df.contribution.sum()
-
-                # Normalize next weighting
-                if df.next_weighting.sum() != 0:
-                    df.next_weighting /= df.next_weighting.sum()
-                df = df.replace([np.inf, -np.inf, np.nan], None)
-                df.loc[(df["next_weighting"] < -1) | (df["next_weighting"] > 1), "next_weighting"] = df.loc[
-                    (df["next_weighting"] < -1) | (df["next_weighting"] > 1), "weighting"
-                ]  # if the next weighting is not including within -1 and 1 range, we default to the initial weighting
-                if not df.empty:
-                    for row in df.to_dict("records"):
-                        weighting = Decimal(row["next_weighting"]) if row["next_weighting"] else row["weighting"]
-                        if from_is_active and not to_is_active:
-                            weighting = Decimal(0.0)
-                        try:
-                            initial_currency_fx_rate = (
-                                fx_rates.get(currency=self.currency).value
-                                / fx_rates.get(currency=row["currency"]).value
-                            )
-                        except CurrencyFXRates.DoesNotExist:
-                            initial_currency_fx_rate = Decimal(1)
-                        defaults = {
-                            "initial_currency_fx_rate": initial_currency_fx_rate,
-                            "weighting": weighting,
-                            "initial_price": Decimal(row["next_initial_price"]),
-                            "initial_shares": row["initial_shares"],
-                            "asset_valuation_date": row["asset_valuation_date"],
-                            "is_estimated": True,
-                        }
-                        get_parameters = {
-                            "underlying_instrument": row["underlying_instrument"],
-                            "portfolio": self,
-                            "currency": row["currency"],
-                            "date": to_date,
-                        }
-                        if exchange := row.get("exchange", None):
-                            get_parameters["exchange"] = exchange
-                        if portfolio_created := row.get("portfolio_created", None):
-                            get_parameters["portfolio_created"] = portfolio_created
-                        # We check if an asset position already exists and if so, if it is estimated
-                        # (otherwise we don't propagate it)
-                        if _asset := AssetPosition.objects.filter(**get_parameters).first():
-                            _asset.underlying_instrument_price = None  # we unset the previously linked underlying instrument price in case it was linked to the wrong underlying price (e.g too early)
-                            if not from_is_active and not to_is_active:
-                                _asset.delete()
-                            elif not is_target_portfolio_imported and _asset.is_estimated:
-                                for k, v in defaults.items():
-                                    setattr(_asset, k, v)
-                                _asset.save()
-                        elif from_is_active and to_is_active and not is_target_portfolio_imported:
-                            AssetPosition.objects.create(**get_parameters, **defaults)
-
-    def import_positions_at_date(self, portfolio: PortfolioDTO, val_date: date, post_processing: bool = False):
-        if not portfolio:
-            return
-        left_over_positions = self.assets.filter(date=val_date)
-
-        # We convert the positions into a dataframe in order to handle positions that are considered duplicates
-        # In that case, we sum up fields such as weighting and shares.
-        # Position are assumed serialized otherwise the groupby on dataframe can't handle django object
-        index_columns = ["portfolio_id", "date", "underlying_instrument_id", "portfolio_created_id"]
-        float_columns = [
-            "weighting",
-            "initial_currency_fx_rate",
-            "initial_shares",
-            "initial_price",
-        ]
-        df = portfolio.to_df().rename(
-            columns={
-                "currency_fx_rate": "initial_currency_fx_rate",
-                "shares": "initial_shares",
-                "price": "initial_price",
-                "currency": "currency_id",
-                "underlying_instrument": "underlying_instrument_id",
-                "portfolio_created": "portfolio_created_id",
-                "exchange": "exchange_id",
-            }
-        )
-        df["portfolio_id"] = self.id
-        df = df[index_columns + float_columns + ["is_estimated", "currency_id"]]
-        df[float_columns] = df[float_columns].astype("float")
-        df = df.groupby(index_columns, as_index=False, dropna=False).agg(
-            {
-                **{field: "first" for field in df.columns.difference(index_columns + float_columns)},
-                "weighting": "sum",
-                "initial_shares": "sum",
-                "initial_currency_fx_rate": "mean",
-                "initial_price": "mean",
-            }
-        )
-        df = df.replace([np.inf, -np.inf, np.nan], None)
-
-        for position in df.to_dict("records"):
-            obj, _ = AssetPosition.unannotated_objects.update_or_create(
-                portfolio_id=position["portfolio_id"],
-                date=position["date"],
-                underlying_instrument_id=position["underlying_instrument_id"],
-                portfolio_created_id=position["portfolio_created_id"],
-                defaults=position,
-            )
-            left_over_positions = left_over_positions.exclude(id=obj.id)
-        left_over_positions.delete()
-        if post_processing:
-            trigger_portfolio_change_as_task.delay(self.id, val_date)
-
-    def resynchronize_history(self, from_date: date, to_date: date, instrument: Instrument | None = None):
-        if (synchronisation_method := self.portfolio_synchronization) and self.assets.exists():
-            if not from_date:
-                from_date = self.assets.earliest("date").date
-            if not to_date:
-                to_date = self.assets.latest("date").date
-            # loop over every week day and trigger synchronization task in order
-            if to_date <= from_date:
-                raise ValueError("bound needs to be valid")
-            for sync_datetime in synchronisation_method.dates_range(from_date, to_date, filter_daily=True):
-                synchronisation_method.synchronize(
-                    self, sync_datetime.date(), override_execution_datetime_validity=True
+    def get_lookthrough_positions(
+        self,
+        sync_date: date,
+        portfolio_total_asset_value: Decimal | None = None,
+        with_intermediary_position: bool = False,
+    ):
+        """Recursively calculates the look-through position for a portfolio
+
+        Arguments:
+            sync_date {datetime.date} -- The date on which the assets will be computed
+            portfolio_total_value: {Decimal} -- The total value of the portfolio (needed to compute initial shares)
+        """
+
+        def _crawl_portfolio(
+            parent_portfolio,
+            adjusted_weighting,
+            adjusted_currency_fx_rate,
+            adjusted_is_estimated,
+            portfolio_created=None,
+        ):
+            for position in parent_portfolio.assets.filter(date=sync_date):
+                position.id = None
+                position.weighting = adjusted_weighting * position.weighting
+                position.initial_currency_fx_rate = adjusted_currency_fx_rate * position.currency_fx_rate
+                position.is_estimated = (adjusted_is_estimated or position.is_estimated) and not (
+                    position.weighting == 1.0
                 )
-        if instrument:
-            price_computation_method = None
-            try:
-                price_computation_method = Product.objects.get(id=instrument.id).price_computation
-            except Product.DoesNotExist:
-                with suppress(Index.DoesNotExist):
-                    price_computation_method = Index.objects.get(id=instrument.id).price_computation
-            if price_computation_method and instrument.prices.exists():
-                if to_date <= from_date:
-                    raise ValueError("bound needs to be valid")
-                if not from_date:
-                    from_date = instrument.prices.earliest("date").date
-                if not to_date:
-                    to_date = instrument.prices.latest("date").date
-                # loop over every week day and trigger synchronization task in order
-                for sync_datetime in price_computation_method.dates_range(from_date, to_date, filter_daily=True):
-                    price_computation_method.compute(
-                        instrument, sync_datetime.date(), override_execution_datetime_validity=True
+                position.portfolio_created = portfolio_created
+                position.parent_portfolio = parent_portfolio
+                position.initial_shares = None
+                if portfolio_total_asset_value:
+                    position.initial_shares = (position.weighting * portfolio_total_asset_value) / (
+                        position.price * position.currency_fx_rate
+                    )
+                if child_portfolio := position.underlying_quote.primary_portfolio:
+                    if with_intermediary_position:
+                        yield position
+                    yield from _crawl_portfolio(
+                        child_portfolio,
+                        position.weighting,
+                        position.currency_fx_rate,
+                        position.is_estimated,
+                        portfolio_created=child_portfolio,
                     )
+                elif position.weighting:  # we do not yield postion with weight 0 because of issue with certain multi-thematic portfolios which contain duplicates
+                    yield position
+
+        yield from _crawl_portfolio(self, Decimal(1.0), Decimal(1.0), False)
+
+    def get_positions(self, val_date: date, **kwargs) -> Iterable[AssetPosition]:
+        if self.is_composition:
+            assets = list(self.get_lookthrough_positions(val_date, **kwargs))
+        else:
+            assets = self.assets.filter(date=val_date)
+        return assets
+
+    def compute_lookthrough(self, sync_date: date, portfolio_total_asset_value: Decimal | None = None):
+        if not self.primary_portfolio or not self.is_lookthrough:
+            raise ValueError(
+                "Lookthrough position can only be computed on lookthrough portfolio with a primary portfolio"
+            )
+        logger.info(f"Compute Look-Through for {self} at {sync_date}")
+        positions = self.primary_portfolio.get_lookthrough_positions(sync_date, portfolio_total_asset_value)
+        self.bulk_create_positions(list(positions), delete_leftovers=True, compute_metrics=True)
+
+    def batch_recompute_lookthrough(self, from_date: date, to_date: date):
+        if not self.primary_portfolio or not self.is_lookthrough:
+            raise ValueError(
+                "Lookthrough position can only be computed on lookthrough portfolio with a primary portfolio"
+            )
+        positions = []
+        for val_date in pd.date_range(from_date, to_date, freq="B").date:
+            portfolio_total_asset_value = (
+                self.get_total_asset_under_management(val_date) if not self.only_weighting else None
+            )
+            positions.extend(self.primary_portfolio.get_lookthrough_positions(val_date, portfolio_total_asset_value))
+        self.bulk_create_positions(list(positions), delete_leftovers=True, compute_metrics=False)
 
     def update_preferred_classification_per_instrument(self):
         # Function to automatically assign Preferred instrument based on the assets' underlying instruments of the
@@ -834,6 +916,39 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def get_representation_label_key(cls):
         return "{{name}}"
 
+    def bulk_create_positions(self, positions: list[AssetPosition], delete_leftovers: bool = False, **kwargs):
+        if positions:
+            update_dates = set()
+            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()
+            objs = AssetPosition.objects.bulk_create(
+                positions,
+                update_fields=[
+                    "weighting",
+                    "initial_price",
+                    "initial_currency_fx_rate",
+                    "initial_shares",
+                    "currency_fx_rate_instrument_to_usd",
+                    "currency_fx_rate_portfolio_to_usd",
+                    "underlying_quote_price",
+                    "is_estimated",
+                    "portfolio",
+                    "portfolio_created",
+                    "underlying_instrument",
+                ],
+                unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
+                update_conflicts=True,
+            )
+            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()
+            for update_date in sorted(update_dates):
+                self.change_at_date(update_date, **kwargs)
+
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):
         if isinstance(portfolio_data, int):
@@ -846,12 +961,48 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def check_share_diff(self, val_date: date) -> bool:
         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
+    ) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Utility methods to get instrument returns for a given date range
+
+        Args:
+            instruments: instrument to get the returns from
+            from_date: date range lower bound
+            to_date: date range upper bound
+
+        Returns:
+            Return a tuple of the returns and the last prices series for conveniance
+        """
+        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")
+        )
+        prices_df = (
+            pd.DataFrame(
+                prices.filter_only_valid_prices().values_list("instrument", "price_fx_portfolio", "date"),
+                columns=["instrument", "price_fx_portfolio", "date"],
+            )
+            .pivot_table(index="date", values="price_fx_portfolio", columns="instrument")
+            .astype(float)
+            .sort_index()
+        )
+        ts = pd.bdate_range(from_date, to_date, freq="B")
+        prices_df = prices_df.reindex(ts)
+        if ffill_returns:
+            prices_df = prices_df.ffill()
+        returns = prices_to_returns(prices_df, drop_inceptions_nan=False, fill_nan=ffill_returns)
+        return returns.replace([np.inf, -np.inf, np.nan], 0), prices_df
+
     @classmethod
     def get_contribution_df(
         cls,
         qs,
         need_normalize=False,
-        groupby_label_id="underlying_security",
+        groupby_label_id="underlying_instrument",
         groubpy_label_title="underlying_instrument__name_repr",
         currency_fx_rate_label="currency_fx_rate",
         hedged_currency=None,
@@ -875,7 +1026,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             ),
         ).select_related("underlying_instrument")
         df = pd.DataFrame(
-            qs.values(
+            qs.values_list(
                 "date",
                 "price",
                 "coalesce_currency_fx_rate",
@@ -1007,10 +1158,43 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             return res.replace([np.inf, -np.inf, np.nan], 0)
         return pd.DataFrame()
 
+    def get_or_create_index(self):
+        index = Index.objects.create(name=self.name, currency=self.currency)
+        index.portfolios.all().delete()
+        InstrumentPortfolioThroughModel.objects.update_or_create(instrument=index, defaults={"portfolio": self})
+
+    @classmethod
+    def create_model_portfolio(cls, name: str, currency: Currency, with_index: bool = True):
+        portfolio = cls.objects.create(
+            is_manageable=True,
+            name=name,
+            currency=currency,
+        )
+        if with_index:
+            portfolio.get_or_create_index()
+        return portfolio
+
+
+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(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))
+
 
 @receiver(post_save, sender="wbportfolio.Product")
 @receiver(post_save, sender="wbportfolio.ProductGroup")
-@receiver(post_save, sender="wbportfolio.Index")
 def post_product_creation(sender, instance, created, raw, **kwargs):
     if not raw and (created or not InstrumentPortfolioThroughModel.objects.filter(instrument=instance).exists()):
         portfolio = Portfolio.objects.create(
@@ -1021,11 +1205,19 @@ def post_product_creation(sender, instance, created, raw, **kwargs):
         InstrumentPortfolioThroughModel.objects.get_or_create(instrument=instance, defaults={"portfolio": portfolio})
 
 
-@shared_task(queue="portfolio")
-def resynchronize_history_as_task(portfolio_id: int, from_date: date, to_date: date, instrument_id: int | None = None):
-    portfolio = Portfolio.objects.get(id=portfolio_id)
-    instrument = Instrument.objects.get(id=instrument_id) if instrument_id else None
-    portfolio.resynchronize_history(from_date, to_date, instrument=instrument)
+@receiver(post_save, sender="wbportfolio.PortfolioPortfolioThroughModel")
+def post_portfolio_relationship_creation(sender, instance, created, raw, **kwargs):
+    if (
+        not raw
+        and created
+        and instance.portfolio.is_lookthrough
+        and instance.type == PortfolioPortfolioThroughModel.Type.PRIMARY
+    ):
+        with suppress(AssetPosition.DoesNotExist):
+            earliest_primary_position_date = instance.dependency_portfolio.assets.earliest("date").date
+            batch_recompute_lookthrough_as_task.delay(
+                instance.portfolio.id, earliest_primary_position_date, date.today()
+            )
 
 
 @shared_task(queue="portfolio")
@@ -1035,6 +1227,20 @@ def trigger_portfolio_change_as_task(portfolio_id, val_date, **kwargs):
 
 
 @shared_task(queue="portfolio")
-def propagate_or_update_portfolio_assets_as_task(portfolio_id, from_date, to_date, **kwargs):
+def batch_recompute_lookthrough_as_task(portfolio_id: int, start: date, end: date):
     portfolio = Portfolio.objects.get(id=portfolio_id)
-    portfolio.propagate_or_update_assets(from_date, to_date, **kwargs)
+    portfolio.batch_recompute_lookthrough(start, end)
+
+
+@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()
+    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:
+            logger.error(f"Exception while propagating portfolio assets {portfolio}: {e}")
+        portfolio.estimate_net_asset_values(end_date)