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

wbportfolio/models/transactions/trades.py

@@ -28,6 +28,7 @@ from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
 from wbcore.signals.models import pre_collection
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+
 from wbportfolio.import_export.handlers.trade import TradeImportHandler
 from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.custodians import Custodian
@@ -42,8 +43,7 @@ class TradeQueryset(OrderedModelQuerySet):
         return self.annotate(
             last_effective_date=Subquery(
                 AssetPosition.objects.filter(
-                    underlying_instrument=OuterRef("underlying_instrument"),
-                    date__lt=OuterRef("transaction_date"),
+                    date__lte=OuterRef("value_date"),
                     portfolio=OuterRef("portfolio"),
                 )
                 .order_by("-date")
@@ -52,7 +52,7 @@ class TradeQueryset(OrderedModelQuerySet):
             effective_weight=Coalesce(
                 Subquery(
                     AssetPosition.objects.filter(
-                        underlying_instrument=OuterRef("underlying_instrument"),
+                        underlying_quote=OuterRef("underlying_instrument"),
                         date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
                     )
@@ -66,7 +66,7 @@ class TradeQueryset(OrderedModelQuerySet):
             effective_shares=Coalesce(
                 Subquery(
                     AssetPosition.objects.filter(
-                        underlying_instrument=OuterRef("underlying_instrument"),
+                        underlying_quote=OuterRef("underlying_instrument"),
                         date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
                     )
@@ -76,7 +76,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 ),
                 Decimal(0),
             ),
-            target_shares=F("effective_weight") * F("weighting"),
+            target_shares=F("effective_shares") + F("shares"),
         )
 
 
@@ -222,7 +222,12 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     @transition(
         field=status,
         source=Status.DRAFT,
-        target=Status.SUBMIT,
+        target=GET_STATE(
+            lambda self, **kwargs: (
+                self.Status.SUBMIT if self.underlying_quote_price is not None else self.Status.FAILED
+            ),
+            states=[Status.SUBMIT, Status.FAILED],
+        ),
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         ),
@@ -237,40 +242,44 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
             )
         },
+        on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        pass
+        if not self.underlying_quote_price:
+            self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     def can_submit(self):
         pass
 
     @transition(
         field=status,
-        source=Status.SUBMIT,
+        source=Status.DRAFT,
         target=Status.FAILED,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         ),
     )
     def fail(self, **kwargs):
-        pass
+        self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     @cached_property
-    def underlying_instrument_price(self) -> InstrumentPrice | None:
+    def underlying_quote_price(self) -> InstrumentPrice | None:
         try:
-            return self.underlying_instrument.valuations.get(date=self.transaction_date)
+            return InstrumentPrice.objects.filter_only_valid_prices().get(
+                instrument=self.underlying_instrument, date=self.value_date
+            )
         except InstrumentPrice.DoesNotExist:
-            return None
+            with suppress(InstrumentPrice.DoesNotExist):
+                return (
+                    InstrumentPrice.objects.filter_only_valid_prices()
+                    .filter(instrument=self.underlying_instrument, date__lte=self.value_date)
+                    .latest("date")
+                )
 
     @transition(
         field=status,
         source=Status.SUBMIT,
-        target=GET_STATE(
-            lambda self, **kwargs: (
-                self.Status.EXECUTED if self.underlying_instrument_price is not None else self.Status.FAILED
-            ),
-            states=[Status.EXECUTED, Status.FAILED],
-        ),
+        target=Status.EXECUTED,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         ),
@@ -285,30 +294,30 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
             )
         },
-        on_error="FAILED",
     )
     def execute(self, **kwargs):
-        if self.underlying_instrument_price:
+        if self.underlying_quote_price:
             asset, created = AssetPosition.unannotated_objects.update_or_create(
-                underlying_instrument=self.underlying_instrument,
+                underlying_quote=self.underlying_instrument,
+                portfolio_created=None,
                 portfolio=self.portfolio,
                 date=self.transaction_date,
-                is_estimated=False,
                 defaults={
                     "initial_currency_fx_rate": self.currency_fx_rate,
                     "weighting": self._target_weight,
-                    "initial_price": self.underlying_instrument_price.net_value,
+                    "initial_price": self.underlying_quote_price.net_value,
                     "initial_shares": None,
-                    "underlying_instrument_price": self.underlying_instrument_price,
+                    "underlying_quote_price": self.underlying_quote_price,
                     "asset_valuation_date": self.transaction_date,
                     "currency": self.currency,
+                    "is_estimated": False,
                 },
             )
             asset.set_weighting(self._target_weight)
-        else:
-            self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     def can_execute(self):
+        if not self.underlying_quote_price:
+            return {"underlying_instrument": "Cannot execute a trade without a valid quote price"}
         if not self.portfolio.is_manageable:
             return {"portfolio": "The portfolio needs to be a model portfolio in order to execute this trade manually"}
 
@@ -381,7 +390,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     def revert(self, to_date=None, **kwargs):
         with suppress(AssetPosition.DoesNotExist):
             asset = AssetPosition.objects.get(
-                underlying_instrument=self.underlying_instrument,
+                underlying_quote=self.underlying_instrument,
                 portfolio=self.portfolio,
                 date=self.transaction_date,
                 is_estimated=False,
@@ -404,7 +413,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             return self.last_effective_date
         elif (
             assets := AssetPosition.objects.filter(
-                underlying_instrument=self.underlying_instrument,
+                underlying_quote=self.underlying_instrument,
                 date__lt=self.transaction_date,
                 portfolio=self.portfolio,
             )
@@ -418,7 +427,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self,
             "effective_weight",
             AssetPosition.objects.filter(
-                underlying_instrument=self.underlying_instrument,
+                underlying_quote=self.underlying_instrument,
                 date=self._last_effective_date,
                 portfolio=self.portfolio,
             ).aggregate(s=Sum("weighting"))["s"]
@@ -432,7 +441,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self,
             "effective_shares",
             AssetPosition.objects.filter(
-                underlying_instrument=self.underlying_instrument,
+                underlying_quote=self.underlying_instrument,
                 date=self.transaction_date,
                 portfolio=self.portfolio,
             ).aggregate(s=Sum("shares"))["s"]
@@ -447,7 +456,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     @cached_property
     @admin.display(description="Target Shares")
     def _target_shares(self) -> Decimal:
-        return getattr(self, "target_shares", self._effective_shares * self.weighting)
+        return getattr(self, "target_shares", self._effective_shares + self.shares)
 
     order_with_respect_to = "trade_proposal"
 
@@ -475,12 +484,19 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         # notification_email_template = "portfolio/email/trade_notification.html"
 
     def save(self, *args, **kwargs):
+        if self.trade_proposal:
+            self.portfolio = self.trade_proposal.portfolio
+            self.transaction_date = self.trade_proposal.trade_date
+            self.value_date = self.trade_proposal.last_effective_date
+            if self._effective_shares:
+                self.shares = self._effective_shares * self.weighting
+
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
         if self.price is None:
             # we try to get the price if not provided directly from the underlying instrument
             with suppress(InstrumentPrice.DoesNotExist):
-                self.price = self.underlying_instrument.valuations.get(date=self.transaction_date).net_value
+                self.price = self.underlying_instrument.valuations.get(date=self.value_date).net_value
         if self.price is not None and self.price_gross is None:
             self.price_gross = self.price
 
@@ -489,12 +505,6 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
 
         if self.price_gross is not None and self.shares is not None and self.total_value_gross is None:
             self.total_value_gross = self.price_gross * self.shares
-
-        if self.trade_proposal:
-            self.portfolio = self.trade_proposal.portfolio
-            self.transaction_date = self.trade_proposal.trade_date
-            if effective_shares := self._effective_shares:
-                self.shares = effective_shares * self.weighting
         self.transaction_type = Transaction.Type.TRADE
 
         if self.transaction_subtype is None:
@@ -516,8 +526,6 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.claimed_shares = self.trade.claims.filter(status="APPROVED").aggregate(s=Sum("shares"))[
                 "s"
             ] or Decimal(0)
-        if self.trade_proposal and self.trade_proposal.status == "DRAFT":
-            self.status = self.Status.DRAFT
         if self.internal_trade:
             self.marked_as_internal = True
         super().save(*args, **kwargs)

wbportfolio/models/transactions/transactions.py

@@ -111,25 +111,19 @@ class Transaction(ImportMixin, models.Model):
     comment = models.TextField(default="", verbose_name="Comment", blank=True)
 
     def save(self, *args, **kwargs):
+        if not self.value_date:
+            self.value_date = self.transaction_date
+        if not self.book_date:
+            self.book_date = self.transaction_date
+
         if not getattr(self, "currency", None) and self.underlying_instrument:
             self.currency = self.underlying_instrument.currency
         if not self.currency_fx_rate:
             self.currency_fx_rate = self.underlying_instrument.currency.convert(
-                self.transaction_date, self.portfolio.currency, exact_lookup=True
+                self.value_date, self.portfolio.currency, exact_lookup=True
             )
         if not self.transaction_type:
             self.transaction_type = self.__class__.__name__
-        if not self.value_date:
-            self.value_date = self.transaction_date
-            # try:
-            #     # we try to find the next valid date (i.e. the one with position on the underlying instrument"
-            #     self.value_date = (
-            #         self.underlying_instrument.valuations.filter(date__gt=self.transaction_date).earliest("date").date
-            #     )
-            # except ObjectDoesNotExist:
-            #     self.value_date = (self.transaction_date + BDay(1)).date()
-        if not self.book_date:
-            self.book_date = self.transaction_date
         if (
             self.total_value is not None
             and self.currency_fx_rate is not None

wbportfolio/models/utils.py

@@ -1,4 +1,5 @@
 from wbfdm.models import Instrument
+
 from wbportfolio.models import Index, Product
 
 

wbportfolio/pms/analytics/portfolio.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from skfolio import Portfolio as BasePortfolio
+
+
+class Portfolio(BasePortfolio):
+    def get_next_weights(self, returns: pd.Series) -> 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
+
+        Returns:
+            A dictionary of weights (instrument ids as keys and weights as values)
+        """
+        weights = self.weights_per_observation.iloc[-1, :].T
+        if weights.sum() != 0:
+            weights /= weights.sum()
+        contribution = weights * (returns + 1.0)
+        if contribution.sum() != 0:
+            contribution /= contribution.sum()
+        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
+        return previous_net_asset_value * (1.0 + expected_returns)

wbportfolio/pms/trading/handler.py

@@ -2,6 +2,7 @@ from datetime import date
 from decimal import Decimal
 
 from django.core.exceptions import ValidationError
+
 from wbportfolio.pms.typing import Portfolio, Trade, TradeBatch
 
 
@@ -19,17 +20,15 @@ class TradingService:
         trades_batch: TradeBatch | None = None,
         total_value: Decimal = None,
     ):
-        if not target_portfolio and not trades_batch:
-            raise ValueError("Either target positions or trades needs to be provided")
         self.total_value = total_value
         self.trade_date = trade_date
+        if target_portfolio is None:
+            target_portfolio = Portfolio(positions=())
+        if effective_portfolio is None:
+            effective_portfolio = Portfolio(positions=())
         # If effective portfoolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
-        if effective_portfolio and trades_batch:
-            trades_batch = self.build_trade_batch(effective_portfolio, trades_batch=trades_batch)
+        trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio, trades_batch=trades_batch)
         # if no trade but a effective portfolio is provided, we get the trade batch only from the effective portofolio (and the target portfolio if provided, but optional. Without it, the trade delta weight will be 0 )
-        elif not trades_batch and effective_portfolio:
-            # If no trade batch is provided but effetive_portfolio is, we estimate the trade from the given portfolios
-            trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio=target_portfolio)
         # Finally, we compute the target portfolio
         if trades_batch and not target_portfolio:
             target_portfolio = trades_batch.convert_to_portfolio()
@@ -75,7 +74,7 @@ class TradingService:
     def build_trade_batch(
         self,
         effective_portfolio: Portfolio,
-        target_portfolio: Portfolio | None = None,
+        target_portfolio: Portfolio,
         trades_batch: TradeBatch | None = None,
     ) -> TradeBatch:
         """
@@ -89,25 +88,24 @@ class TradingService:
         Returns: The normalized trades batch
         """
         instruments = list(effective_portfolio.positions_map.keys())
-        if target_portfolio:
-            instruments.extend(list(target_portfolio.positions_map.keys()))
+        instruments.extend(list(target_portfolio.positions_map.keys()))
         if trades_batch:
             instruments.extend(list(trades_batch.trades_map.keys()))
         _trades: list[Trade] = []
         for instrument in set(instruments):
             effective_weight = target_weight = 0
-            effective_shares = target_shares = 0
+            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_shares = target_shares = effective_pos.shares
+                effective_shares = effective_pos.shares
                 instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
-            if target_portfolio and (target_pos := target_portfolio.positions_map.get(instrument, None)):
+            if target_pos := target_portfolio.positions_map.get(instrument, None):
                 target_weight = target_pos.weighting
-                target_shares = target_pos.shares
+                instrument_type, currency = target_pos.instrument_type, target_pos.currency
             if trades_batch and (trade := trades_batch.trades_map.get(instrument, None)):
                 effective_weight, target_weight = trade.effective_weight, trade.target_weight
-                effective_shares, target_shares = trade.effective_shares, trade.target_shares
+                effective_shares = trade.effective_shares
                 instrument_type, currency = trade.instrument_type, trade.currency
 
             _trades.append(
@@ -116,7 +114,6 @@ class TradingService:
                     effective_weight=effective_weight,
                     target_weight=target_weight,
                     effective_shares=effective_shares,
-                    target_shares=target_shares,
                     date=self.trade_date,
                     instrument_type=instrument_type,
                     currency=currency,

wbportfolio/pms/typing.py

@@ -17,11 +17,11 @@ class Valuation:
 @dataclass(frozen=True)
 class Position:
     underlying_instrument: int
-    instrument_type: int
     weighting: Decimal
-    currency: int
     date: date_lib
 
+    currency: int | None = None
+    instrument_type: int | None = None
     asset_valuation_date: date_lib | None = None
     portfolio_created: int = None
     exchange: int = None
@@ -48,7 +48,7 @@ class Position:
 
 @dataclass(frozen=True)
 class Portfolio:
-    positions: tuple[Position]
+    positions: tuple[Position] | tuple
     positions_map: dict[Position] = field(init=False, repr=False)
 
     def __post_init__(self):
@@ -62,7 +62,7 @@ class Portfolio:
 
     @cached_property
     def total_weight(self):
-        return round(sum([pos.weighting for pos in self.positions]), 4)
+        return round(sum([pos.weighting for pos in self.positions]), 6)
 
     @cached_property
     def total_shares(self):
@@ -86,16 +86,12 @@ class Trade:
     target_weight: Decimal
     id: int | None = None
     effective_shares: Decimal = None
-    target_shares: Decimal = None
 
     def __add__(self, other):
         return Trade(
             underlying_instrument=self.underlying_instrument,
             effective_weight=self.effective_weight + other.effective_weight,
             target_weight=self.target_weight + other.target_weight,
-            target_shares=self.target_shares + other.target_shares
-            if (self.target_shares is not None and other.target_shares is not None)
-            else None,
             effective_shares=self.effective_shares + other.effective_shares
             if (self.effective_shares is not None and other.effective_shares is not None)
             else None,
@@ -106,7 +102,6 @@ class Trade:
                 not in [
                     "effective_weight",
                     "target_weight",
-                    "target_shares",
                     "effective_shares",
                     "underlying_instrument",
                 ]
@@ -118,22 +113,16 @@ class Trade:
         return self.target_weight - self.effective_weight
 
     def validate(self):
-        if self.effective_weight < 0 or self.effective_weight > 1.0:
-            raise ValidationError("Effective Weight needs to be in range [0, 1]")
-        if self.target_weight < 0 or self.target_weight > 1.0:
-            raise ValidationError("Target Weight needs to be in range [0, 1]")
+        return True
+        # if self.effective_weight < 0 or self.effective_weight > 1.0:
+        #     raise ValidationError("Effective Weight needs to be in range [0, 1]")
+        # if self.target_weight < 0 or self.target_weight > 1.0:
+        #     raise ValidationError("Target Weight needs to be in range [0, 1]")
 
     def normalize_target(self, total_target_weight: Decimal):
         t = Trade(
             target_weight=self.target_weight / total_target_weight if total_target_weight else self.target_weight,
-            target_shares=self.target_shares / total_target_weight
-            if (self.target_shares and total_target_weight)
-            else self.target_shares,
-            **{
-                f.name: getattr(self, f.name)
-                for f in fields(Trade)
-                if f.name not in ["target_weight", "target_shares"]
-            },
+            **{f.name: getattr(self, f.name) for f in fields(Trade) if f.name not in ["target_weight"]},
         )
         return t
 
@@ -154,15 +143,11 @@ class TradeBatch:
 
     @cached_property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades]), 4)
+        return round(sum([trade.target_weight for trade in self.trades]), 6)
 
     @cached_property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades]), 4)
-
-    @cached_property
-    def total_shares(self) -> Decimal:
-        return sum([trade.target_shares for trade in self.trades if trade.target_shares is not None]) or Decimal(0)
+        return round(sum([trade.effective_weight for trade in self.trades]), 6)
 
     @cached_property
     def totat_abs_delta_weight(self) -> Decimal:
@@ -175,7 +160,7 @@ class TradeBatch:
         return len(self.trades)
 
     def validate(self):
-        if float(self.total_target_weight) != 1.0:  # we do that to remove decimal over precision
+        if round(float(self.total_target_weight), 4) != 1:  # we do that to remove decimal over precision
             raise ValidationError(f"Total Weight cannot be different than 1 ({float(self.total_target_weight)})")
 
     def convert_to_portfolio(self):
@@ -186,7 +171,6 @@ class TradeBatch:
                     underlying_instrument=trade.underlying_instrument,
                     instrument_type=trade.instrument_type,
                     weighting=trade.target_weight,
-                    shares=trade.target_shares,
                     currency=trade.currency,
                     date=trade.date,
                 )

wbportfolio/rebalancing/base.py

@@ -0,0 +1,16 @@
+from datetime import date
+
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+
+class AbstractRebalancingModel:
+    def __init__(self, portfolio, trade_date: date, last_effective_date: date):
+        self.portfolio = portfolio
+        self.trade_date = trade_date
+        self.last_effective_date = last_effective_date
+
+    def is_valid(self) -> bool:
+        return True
+
+    def get_target_portfolio(self, **kwargs) -> PortfolioDTO:
+        raise NotImplementedError()

wbportfolio/rebalancing/decorators.py

@@ -0,0 +1,17 @@
+def register(model_name: str):
+    """
+    Decorator to include when a backend need automatic registration
+    """
+    from wbportfolio.models.transactions.rebalancing import RebalancingModel
+
+    def _decorator(backend_class):
+        defaults = {
+            "name": model_name,
+        }
+        RebalancingModel.objects.update_or_create(
+            class_path=backend_class.__module__ + "." + backend_class.__name__,
+            defaults=defaults,
+        )
+        return backend_class
+
+    return _decorator

wbportfolio/rebalancing/models/__init__.py

@@ -0,0 +1,3 @@
+from .composite import CompositeRebalancing
+from .model_portfolio import ModelPortfolioRebalancing
+from .equally_weighted import EquallyWeightedRebalancing

wbportfolio/rebalancing/models/composite.py

@@ -0,0 +1,31 @@
+from decimal import Decimal
+
+from django.core.exceptions import ObjectDoesNotExist
+
+from wbportfolio.pms.typing import Portfolio, Position
+from wbportfolio.rebalancing.base import AbstractRebalancingModel
+from wbportfolio.rebalancing.decorators import register
+
+
+@register("Composite Rebalancing")
+class CompositeRebalancing(AbstractRebalancingModel):
+    @property
+    def base_assets(self) -> dict[int, Decimal]:
+        try:
+            latest_trade_proposal = self.portfolio.trade_proposals.filter(
+                status="APPROVED", trade_date__lte=self.trade_date
+            ).latest("trade_date")
+            return latest_trade_proposal.base_assets
+        except ObjectDoesNotExist:
+            return dict()
+
+    def is_valid(self) -> bool:
+        return len(self.base_assets.keys()) > 0
+
+    def get_target_portfolio(self, **kwargs) -> Portfolio:
+        positions = []
+        for underlying_instrument, weighting in self.base_assets.items():
+            positions.append(
+                Position(underlying_instrument=underlying_instrument, weighting=weighting, date=self.trade_date)
+            )
+        return Portfolio(positions=tuple(positions))

wbportfolio/rebalancing/models/equally_weighted.py

@@ -0,0 +1,21 @@
+from decimal import Decimal
+
+from wbportfolio.pms.typing import Portfolio
+from wbportfolio.rebalancing.base import AbstractRebalancingModel
+from wbportfolio.rebalancing.decorators import register
+
+
+@register("Equally Weighted Rebalancing")
+class EquallyWeightedRebalancing(AbstractRebalancingModel):
+    def is_valid(self) -> bool:
+        return self.portfolio.assets.filter(date=self.last_effective_date).exists()
+
+    def get_target_portfolio(self, **kwargs) -> Portfolio:
+        positions = []
+        assets = self.portfolio.assets.filter(date=self.last_effective_date)
+        nb_assets = assets.count()
+        for asset in assets:
+            asset.date = self.trade_date
+            asset.asset_valuation_date = self.trade_date
+            positions.append(asset._build_dto(new_weight=Decimal(1 / nb_assets)))
+        return Portfolio(positions=tuple(positions))

wbportfolio/rebalancing/models/model_portfolio.py

@@ -0,0 +1,35 @@
+from wbportfolio.pms.typing import Portfolio
+from wbportfolio.rebalancing.base import AbstractRebalancingModel
+from wbportfolio.rebalancing.decorators import register
+
+
+@register("Model Portfolio Rebalancing")
+class ModelPortfolioRebalancing(AbstractRebalancingModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def model_portfolio_rel(self):
+        return self.portfolio.dependency_through.filter(type="MODEL").first()
+
+    @property
+    def model_portfolio(self):
+        if model_portfolio_rel := self.model_portfolio_rel:
+            return model_portfolio_rel.dependency_portfolio
+
+    def is_valid(self) -> bool:
+        return (
+            self.model_portfolio.assets.filter(date=self.last_effective_date).exists()
+            if self.model_portfolio
+            else False
+        )
+
+    def get_target_portfolio(self, **kwargs) -> Portfolio:
+        positions = []
+        assets = self.model_portfolio.get_positions(self.last_effective_date)
+
+        for asset in assets:
+            asset.date = self.trade_date
+            asset.asset_valuation_date = self.trade_date
+            positions.append(asset._build_dto())
+        return Portfolio(positions=tuple(positions))

wbportfolio/reports/monthly_position_report.py

@@ -54,7 +54,7 @@ class ReportClass(ReportMixin):
                             "portfolio": instrument.name,
                             "isin": position.underlying_instrument.isin,
                             "title": position.underlying_instrument.name_repr,
-                            "instrument_type": position.underlying_instrument.security_instrument_type.short_name,
+                            "instrument_type": position.underlying_instrument.instrument_type.short_name,
                             "weight": float(position.weighting),
                             "date": position.date.strftime("%Y-%m-%d"),
                         }