wbportfolio 1.54.2__py2.py3-none-any.whl → 1.54.4__py2.py3-none-any.whl

wbportfolio/import_export/handlers/trade.py

@@ -195,6 +195,8 @@ class TradeImportHandler(ImportExportHandler):
         modified_objs: list[models.Model],
         unmodified_objs: list[models.Model],
     ):
+        from wbportfolio.models.transactions.trade_proposals import replay_as_task
+
         for instrument in set(
             map(lambda x: x.underlying_instrument, filter(lambda t: t.is_customer_trade, created_objs + modified_objs))
         ):
@@ -203,9 +205,7 @@ class TradeImportHandler(ImportExportHandler):
 
         # if the trade import relates to a trade proposal, we reset the TP after the import to ensure it contains the deleted positions (often forgotten by user)
         for changed_trade_proposal in self.trade_proposals:
-            changed_trade_proposal.reset_trades(
-                target_portfolio=changed_trade_proposal._build_dto().convert_to_portfolio()
-            )
+            replay_as_task.delay(changed_trade_proposal.id)
 
     def _post_processing_updated_object(self, _object):
         if _object.marked_for_deletion:

wbportfolio/migrations/0080_alter_trade_drift_factor_alter_trade_weighting.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.14 on 2025-07-10 09:00
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0079_alter_trade_drift_factor'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='assetposition',
+            name='weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'), help_text='The Weight of the Asset on the price date of the Asset.', max_digits=9, verbose_name='Weight'),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -112,19 +112,20 @@ class AssetPositionIterator:
                 return fx_rate
 
     def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
-        try:
-            return self._prices[val_date][instrument.id]
-        except KeyError:
-            return None
+        with suppress(KeyError):
+            if (_p := self._prices[val_date][instrument.id]) is not None:
+                return _p
+        return None
 
-    def _dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> "AssetPosition":
+    def _dict_to_model(self, val_date: date, instrument_id: int, weighting: float, **kwargs) -> "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)
         price = self._get_price(val_date, underlying_quote)
-        position = AssetPosition(
+
+        parameters = dict(
             underlying_quote=underlying_quote,
-            weighting=weighting,
+            weighting=round(weighting, 8),
             date=val_date,
             asset_valuation_date=val_date,
             is_estimated=True,
@@ -137,15 +138,14 @@ class AssetPositionIterator:
             underlying_quote_price=None,
             underlying_instrument=None,
         )
+        parameters.update(kwargs)
+        position = AssetPosition(**parameters)
         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 add(
-        self,
-        positions: list["AssetPosition"] | tuple[date, dict[int, float]],
-    ):
+    def add(self, positions: list["AssetPosition"] | tuple[date, dict[int, float]], **kwargs):
         """
         Add multiple positions efficiently with batch processing
 
@@ -157,7 +157,7 @@ class AssetPositionIterator:
             positions = [(val_date, i, w) for i, w in positions[1].items()]  # unflatten data to make it iterable
         for position in positions:
             if not isinstance(position, AssetPosition):
-                position = self._dict_to_model(*position)
+                position = self._dict_to_model(*position, **kwargs)
 
             # Generate unique composite key
             key = (
@@ -464,8 +464,8 @@ class AssetPosition(ImportMixin, models.Model):
     # )
 
     weighting = models.DecimalField(
-        decimal_places=6,
-        max_digits=7,
+        decimal_places=8,
+        max_digits=9,
         default=Decimal(0),
         verbose_name="Weight",
         help_text="The Weight of the Asset on the price date of the Asset.",
@@ -693,15 +693,15 @@ class AssetPosition(ImportMixin, models.Model):
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)
 
-    def _build_dto(self, new_weight: Decimal = None, **kwargs) -> PositionDTO:
+    def _build_dto(self, **kwargs) -> PositionDTO:
         """
         Data Transfer Object
         Returns:
             DTO position object
         """
-        return PositionDTO(
+        parameters = dict(
             underlying_instrument=self.underlying_quote.id,
-            weighting=self.weighting if new_weight is None else new_weight,
+            weighting=self.weighting,
             shares=self._shares,
             date=self.date,
             asset_valuation_date=self.asset_valuation_date,
@@ -726,8 +726,9 @@ class AssetPosition(ImportMixin, models.Model):
             price=self._price,
             currency_fx_rate=self._currency_fx_rate,
             portfolio_created=self.portfolio_created.id if self.portfolio_created else None,
-            **kwargs,
         )
+        parameters.update(kwargs)
+        return PositionDTO(**parameters)
 
     @cached_property
     @admin.display(description="Adjusting Factor (adjustment)")

wbportfolio/models/portfolio.py

@@ -18,7 +18,6 @@ from django.db.models import (
     Q,
     QuerySet,
     Sum,
-    Value,
 )
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -26,12 +25,13 @@ from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
 from skfolio.preprocessing import prices_to_returns
-from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.currency.models import Currency
 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.tasks import compute_metrics_as_task
+from wbfdm.enums import MarketData
 from wbfdm.models import Instrument, InstrumentType
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import investable_universe_updated
@@ -45,6 +45,7 @@ from wbportfolio.models.portfolio_relationship import (
 from wbportfolio.models.products import Product
 from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+from wbportfolio.pms.typing import Position as PositionDTO
 
 from . import ProductGroup
 from .exceptions import InvalidAnalyticPortfolio
@@ -54,34 +55,13 @@ if TYPE_CHECKING:
     from wbportfolio.models.transactions.trade_proposals import TradeProposal
 
 
-def get_prices(instrument_ids: list[int], from_date: date, to_date: date) -> dict[date, dict[int, float]]:
-    """
-    Utility to fetch raw prices
-    """
-    prices = InstrumentPrice.objects.filter(instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date)
-    df = (
-        pd.DataFrame(
-            prices.filter_only_valid_prices().values_list("instrument", "net_value", "date"),
-            columns=["instrument", "net_value", "date"],
-        )
-        .pivot_table(index="date", values="net_value", columns="instrument")
-        .astype(float)
-        .sort_index()
-    )
-    ts = pd.bdate_range(df.index.min(), df.index.max(), freq="B")
-    df = df.reindex(ts)
-    df = df.ffill()
-    df.index = pd.to_datetime(df.index)
-    return {ts.date(): row for ts, row in df.to_dict("index").items()}
-
-
 def get_returns(
     instrument_ids: list[int],
     from_date: date,
     to_date: date,
     to_currency: Currency | None = None,
     ffill_returns: bool = True,
-) -> pd.DataFrame:
+) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
     """
     Utility methods to get instrument returns for a given date range
 
@@ -92,31 +72,40 @@ def get_returns(
     Returns:
         Return a tuple of the returns and the last prices series for conveniance
     """
+    # if to_currency:
+    #     fx_rate = CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", to_currency)
+    # else:
+    #     fx_rate = Value(Decimal(1.0))
+    # prices = InstrumentPrice.objects.filter(
+    #     instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date
+    # ).annotate(fx_rate=fx_rate, price_fx_portfolio=F("net_value") * F("fx_rate"))
+    # 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()
+    # )
+    kwargs = dict(from_date=from_date, to_date=to_date, values=[MarketData.CLOSE])
     if to_currency:
-        fx_rate = CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", to_currency)
-    else:
-        fx_rate = Value(Decimal(1.0))
-    prices = InstrumentPrice.objects.filter(
-        instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date
-    ).annotate(fx_rate=fx_rate, price_fx_portfolio=F("net_value") * F("fx_rate"))
-    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()
-    )
+        kwargs["target_currency"] = to_currency.key
+    prices_df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
     if prices_df.empty:
         raise InvalidAnalyticPortfolio()
+    prices_df = prices_df[["instrument_id", "close", "valuation_date"]].pivot(
+        index="valuation_date", columns="instrument_id", values="close"
+    )
     ts = pd.bdate_range(prices_df.index.min(), prices_df.index.max(), freq="B")
     prices_df = prices_df.reindex(ts)
     if ffill_returns:
         prices_df = prices_df.ffill()
     prices_df.index = pd.to_datetime(prices_df.index)
     returns = prices_to_returns(prices_df, drop_inceptions_nan=False, fill_nan=ffill_returns)
-    return returns.replace([np.inf, -np.inf, np.nan], 0)
+    return {ts.date(): row for ts, row in prices_df.replace(np.nan, None).to_dict("index").items()}, returns.replace(
+        [np.inf, -np.inf, np.nan], 0
+    )
 
 
 class DefaultPortfolioQueryset(QuerySet):
@@ -353,26 +342,23 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     instrument.delisted_date = date.today() - timedelta(days=1)
                     instrument.save()
 
-    def _build_dto(self, val_date: date, **extra_kwargs) -> PortfolioDTO:
+    def _build_dto(self, val_date: date, include_drift_factor: bool = False, **extra_kwargs) -> PortfolioDTO:
         "returns the dto representation of this portfolio at the specified date"
         assets = self.assets.filter(date=val_date, **extra_kwargs)
         try:
             drifted_weights = self.get_analytic_portfolio(val_date).get_next_weights()
         except InvalidAnalyticPortfolio:
             drifted_weights = {}
-        return PortfolioDTO(
-            tuple(
-                [
-                    pos._build_dto(
-                        drift_factor=drifted_weights.get(pos.underlying_quote.id, float(pos.weighting))
-                        / float(pos.weighting)
-                        if pos.weighting
-                        else Decimal(1.0)
-                    )
-                    for pos in assets
-                ]
-            ),
-        )
+        positions = []
+        for asset in assets:
+            drift_factor = (
+                Decimal(drifted_weights.get(asset.underlying_quote.id, asset.weighting)) / asset.weighting
+                if asset.weighting
+                else Decimal(1.0)
+            )
+            positions.append(asset._build_dto(drift_factor=drift_factor))
+
+        return PortfolioDTO(positions)
 
     def get_weights(self, val_date: date) -> dict[int, float]:
         """
@@ -410,7 +396,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if not weights:
             weights = self.get_weights(val_date)
         return_date = (val_date + BDay(1)).date()
-        returns = get_returns(
+        _, returns = get_returns(
             list(weights.keys()), (val_date - BDay(2)).date(), return_date, to_currency=self.currency, **kwargs
         )
         if pd.Timestamp(return_date) not in returns.index:
@@ -705,6 +691,10 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             if portfolio := asset.underlying_instrument.portfolio:
                 yield portfolio, asset.weighting
 
+    def get_next_rebalancing_date(self, start_date: date) -> date | None:
+        if automatic_rebalancer := getattr(self, "automatic_rebalancer", None):
+            return automatic_rebalancer.get_next_rebalancing_date(start_date)
+
     def change_at_date(
         self,
         val_date: date,
@@ -756,17 +746,20 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         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
-        ):
-            rel.portfolio.compute_lookthrough(val_date)
-        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.change_at_date(val_date)
-            dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
+        if self.is_tracked:
+            for rel in PortfolioPortfolioThroughModel.objects.filter(
+                dependency_portfolio=self,
+                type=PortfolioPortfolioThroughModel.Type.PRIMARY,
+                portfolio__is_lookthrough=True,
+            ):
+                rel.portfolio.compute_lookthrough(val_date)
+            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.change_at_date(val_date)
+                dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
 
     def evaluate_rebalancing(self, val_date: date):
         if hasattr(self, "automatic_rebalancer"):
@@ -802,7 +795,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     ):  # if price date is the latest instrument price date, we recompute the last valuation data
                         instrument.update_last_valuation_date()
 
-    def drift_weights(self, start_date: date, end_date: date) -> tuple[AssetPositionIterator, "TradeProposal"]:
+    def drift_weights(
+        self, start_date: date, end_date: date, stop_at_rebalancing: bool = False
+    ) -> tuple[AssetPositionIterator, "TradeProposal"]:
         logger.info(f"drift weights for {self} from {start_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
         rebalancer = getattr(self, "automatic_rebalancer", None)
         # Get initial weights
@@ -814,7 +809,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
         # Get returns and prices data for the whole date range
         instrument_ids = list(weights.keys())
-        returns = get_returns(
+
+        prices, returns = get_returns(
             instrument_ids,
             (start_date - BDay(3)).date(),
             end_date,
@@ -822,7 +818,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             ffill_returns=True,
         )
         # Get raw prices to speed up asset position creation
-        prices = get_prices(instrument_ids, (start_date - BDay(3)).date(), end_date)
         # Instantiate the position iterator with the initial weights
         positions = AssetPositionIterator(self, prices=prices)
         last_trade_proposal = None
@@ -830,30 +825,43 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             to_date = to_date_ts.date()
             to_is_active = self.is_active_at_date(to_date)
             logger.info(f"Processing {to_date:%Y-%m-%d}")
+
+            try:
+                last_returns = returns.loc[[to_date_ts], :]
+                analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
+                drifted_weights = analytic_portfolio.get_next_weights()
+            except KeyError:  # if no return for that date, we break and continue
+                drifted_weights = weights
+
             if rebalancer and rebalancer.is_valid(to_date):
-                last_trade_proposal = rebalancer.evaluate_rebalancing(to_date)
-                # if trade proposal/rebalancing is not approved, we cannot continue the drift
-                if last_trade_proposal.status != last_trade_proposal.Status.APPROVED:
+                effective_portfolio = PortfolioDTO(
+                    positions=[
+                        PositionDTO(
+                            date=to_date,
+                            underlying_instrument=i,
+                            weighting=Decimal(w),
+                            drift_factor=Decimal(drifted_weights.get(i, w) / float(w)) if w else Decimal(1.0),
+                        )
+                        for i, w in weights.items()
+                    ]
+                )
+                last_trade_proposal = rebalancer.evaluate_rebalancing(to_date, effective_portfolio=effective_portfolio)
+                if stop_at_rebalancing:
                     break
-                target_portfolio = last_trade_proposal._build_dto().convert_to_portfolio()
                 next_weights = {
-                    underlying_quote_id: float(pos.weighting)
-                    for underlying_quote_id, pos in target_portfolio.positions_map.items()
+                    trade.underlying_instrument: float(trade._target_weight)
+                    for trade in last_trade_proposal.trades.all().annotate_base_info()
                 }
+                positions.add((to_date, next_weights), is_estimated=False)
             else:
-                try:
-                    last_returns = returns.loc[[to_date_ts], :]
-                    analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
-                    next_weights = analytic_portfolio.get_next_weights()
-                except KeyError:  # if no return for that date, we break and continue
-                    next_weights = weights
-            if to_is_active:
-                positions.add((to_date, next_weights))
-            else:
-                positions.add(
-                    (to_date, {underlying_quote_id: 0.0 for underlying_quote_id in weights.keys()})
-                )  # if we have no return or portfolio is not active anymore, we return an emptied portfolio
-                break
+                next_weights = drifted_weights
+                if to_is_active:
+                    positions.add((to_date, next_weights))
+                else:
+                    positions.add(
+                        (to_date, {underlying_quote_id: 0.0 for underlying_quote_id in weights.keys()})
+                    )  # if we have no return or portfolio is not active anymore, we return an emptied portfolio
+                    break
             weights = next_weights
         return positions, last_trade_proposal
 
@@ -1023,6 +1031,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         delete_leftovers: bool = False,
         force_save: bool = False,
         compute_metrics: bool = True,
+        broadcast_changes_at_date: bool = True,
         **kwargs,
     ):
         if positions:
@@ -1071,8 +1080,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         basket_id=self.id,
                         basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id,
                     )
-            for update_date, changed_weights in positions.get_weights().items():
-                self.change_at_date(update_date, changed_weights=changed_weights, **kwargs)
+            if broadcast_changes_at_date:
+                for update_date, changed_weights in positions.get_weights().items():
+                    self.change_at_date(update_date, changed_weights=changed_weights, **kwargs)
 
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):

wbportfolio/models/transactions/rebalancing.py

@@ -43,9 +43,16 @@ class RebalancingModel(models.Model):
         return import_from_dotted_path(self.class_path)
 
     def get_target_portfolio(
-        self, portfolio: Portfolio, trade_date: date, last_effective_date: date, **kwargs
+        self,
+        portfolio: Portfolio,
+        trade_date: date,
+        last_effective_date: date,
+        effective_portfolio: PortfolioDTO | None = None,
+        **kwargs,
     ) -> PortfolioDTO:
-        model = self.model_class(portfolio, trade_date, last_effective_date, **kwargs)
+        model = self.model_class(
+            portfolio, trade_date, last_effective_date, effective_portfolio=effective_portfolio, **kwargs
+        )
         if not model.is_valid():
             raise ValidationError(model.validation_errors)
         return model.get_target_portfolio()
@@ -115,7 +122,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 break
         return False
 
-    def evaluate_rebalancing(self, trade_date: date):
+    def evaluate_rebalancing(self, trade_date: date, effective_portfolio=None):
         trade_proposal, _ = TradeProposal.objects.get_or_create(
             trade_date=trade_date,
             portfolio=self.portfolio,
@@ -126,24 +133,27 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         )
 
         if trade_proposal.rebalancing_model == self.rebalancing_model:
-            trade_proposal.status = TradeProposal.Status.DRAFT
             try:
                 logger.info(
                     f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
                 )
                 target_portfolio = self.rebalancing_model.get_target_portfolio(
-                    self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
+                    self.portfolio,
+                    trade_proposal.trade_date,
+                    trade_proposal.value_date,
+                    effective_portfolio=effective_portfolio,
+                    **self.parameters,
+                )
+                trade_proposal.approve_workflow(
+                    approve_automatically=self.approve_trade_proposal_automatically,
+                    target_portfolio=target_portfolio,
+                    effective_portfolio=effective_portfolio,
                 )
-                trade_proposal.reset_trades(target_portfolio)
-                trade_proposal.submit()
-                if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
-                    trade_proposal.approve(replay=False)
-            except ValidationError:
+            except ValidationError as e:
+                logger.warning(f"Validation error while approving the orders: {e}")
                 # If we encountered a validation error, we set the trade proposal as failed
                 trade_proposal.status = TradeProposal.Status.FAILED
-
             trade_proposal.save()
-
         return trade_proposal
 
     @property