wbportfolio 1.54.14__py2.py3-none-any.whl → 1.54.16__py2.py3-none-any.whl

wbportfolio/models/orders/orders.py

@@ -0,0 +1,243 @@
+from datetime import date
+from decimal import Decimal
+
+from django.contrib import admin
+from django.db import models
+from django.db.models import (
+    Sum,
+)
+from ordered_model.models import OrderedModel
+from wbcore.contrib.io.mixins import ImportMixin
+
+from wbportfolio.import_export.handlers.trade import TradeImportHandler
+from wbportfolio.models.asset import AssetPosition
+from wbportfolio.models.transactions.transactions import TransactionMixin
+
+
+class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
+    import_export_handler_class = TradeImportHandler
+
+    ORDER_WEIGHTING_PRECISION = (
+        8  # we need to match the asset position weighting. Skfolio advices using a even smaller number (5)
+    )
+    currency = None
+
+    class Type(models.TextChoices):
+        REBALANCE = "REBALANCE", "Rebalance"
+        DECREASE = "DECREASE", "Decrease"
+        INCREASE = "INCREASE", "Increase"
+        BUY = "BUY", "Buy"
+        SELL = "SELL", "Sell"
+        NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
+
+    order_type = models.CharField(max_length=32, default=Type.BUY, choices=Type.choices, verbose_name="Trade Type")
+    shares = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        default=Decimal("0.0"),
+        help_text="The number of shares that were traded.",
+        verbose_name="Shares",
+    )
+
+    weighting = models.DecimalField(
+        max_digits=9,
+        decimal_places=ORDER_WEIGHTING_PRECISION,
+        default=Decimal(0),
+        help_text="The weight to be multiplied against the target",
+        verbose_name="Weight",
+    )
+    order_proposal = models.ForeignKey(
+        to="wbportfolio.OrderProposal",
+        related_name="orders",
+        on_delete=models.CASCADE,
+        help_text="The Order Proposal this trade is coming from",
+    )
+    daily_return = models.DecimalField(
+        max_digits=ORDER_WEIGHTING_PRECISION * 2
+        + 3,  # we don't expect any drift factor to be in the order of magnitude greater than 1000
+        decimal_places=ORDER_WEIGHTING_PRECISION
+        * 2,  # we need a higher precision for this factor to avoid float inprecision
+        default=Decimal(0.0),
+        verbose_name="Daily Return",
+        help_text="The Ex-Post daily return",
+    )
+
+    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
+        warnings = []
+        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
+        if self.order_proposal and not self.portfolio.only_weighting:
+            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
+            if shares != self.shares:
+                warnings.append(
+                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                )
+            shares = round(shares)  # ensure fractional shares are converted into integer
+            # we need to recompute the delta weight has we changed the number of shares
+            if shares != self.shares:
+                self.shares = shares
+                if portfolio_total_asset_value:
+                    self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
+
+        if not self.price:
+            warnings.append(f"No price for {self.underlying_instrument.computed_str}")
+        if abs(self._target_weight) < 1e-8:
+            warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
+        return warnings
+
+    @property
+    def product(self):
+        from wbportfolio.models.products import Product
+
+        try:
+            return Product.objects.get(id=self.underlying_instrument.id)
+        except Product.DoesNotExist:
+            return None
+
+    @property
+    @admin.display(description="Last Effective Date")
+    def _last_effective_date(self) -> date:
+        if hasattr(self, "last_effective_date"):
+            return self.last_effective_date
+        elif (
+            assets := AssetPosition.unannotated_objects.filter(
+                date__lt=self.value_date,
+                portfolio=self.portfolio,
+            )
+        ).exists():
+            return assets.latest("date").date
+
+    @property
+    @admin.display(description="Effective Weight")
+    def _previous_weight(self) -> Decimal:
+        if hasattr(self, "previous_weight"):
+            return self.previous_weight
+        return AssetPosition.unannotated_objects.filter(
+            underlying_quote=self.underlying_instrument,
+            date=self._last_effective_date,
+            portfolio=self.portfolio,
+        ).aggregate(s=Sum("weighting"))["s"] or Decimal(0)
+
+    @property
+    @admin.display(description="Effective Weight")
+    def _effective_weight(self) -> Decimal:
+        if hasattr(self, "effective_weight"):
+            return self.effective_weight
+        return self.order_proposal.get_orders().get(id=self.id).effective_weight
+
+    @property
+    @admin.display(description="Effective Shares")
+    def _effective_shares(self) -> Decimal:
+        return getattr(
+            self,
+            "effective_shares",
+            AssetPosition.objects.filter(
+                underlying_quote=self.underlying_instrument,
+                date=self.value_date,
+                portfolio=self.portfolio,
+            ).aggregate(s=Sum("shares"))["s"]
+            or Decimal(0),
+        )
+
+    @property
+    @admin.display(description="Target Weight")
+    def _target_weight(self) -> Decimal:
+        return getattr(
+            self, "target_weight", round(self._effective_weight + self.weighting, self.ORDER_WEIGHTING_PRECISION)
+        )
+
+    @_target_weight.setter
+    def _target_weight(self, target_weight):
+        self.weighting = Decimal(target_weight) - self._effective_weight
+        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+
+    @property
+    @admin.display(description="Target Shares")
+    def _target_shares(self) -> Decimal:
+        return getattr(self, "target_shares", self._effective_shares + self.shares)
+
+    order_with_respect_to = "order_proposal"
+
+    class Meta(OrderedModel.Meta):
+        verbose_name = "Order"
+        verbose_name_plural = "Orders"
+        indexes = [
+            models.Index(fields=["order_proposal"]),
+            models.Index(fields=["underlying_instrument", "value_date"]),
+            models.Index(fields=["portfolio", "underlying_instrument", "value_date"]),
+            models.Index(fields=["order_proposal", "underlying_instrument"]),
+            # models.Index(fields=["date", "underlying_instrument"]),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["order_proposal", "underlying_instrument"],
+                name="unique_order",
+            ),
+        ]
+        # notification_email_template = "portfolio/email/trade_notification.html"
+
+    def save(self, *args, **kwargs):
+        self.portfolio = self.order_proposal.portfolio
+        self.value_date = self.order_proposal.trade_date
+
+        if abs(self.weighting) < 10e-6:
+            self.weighting = Decimal("0")
+        if not self.underlying_instrument.is_investable_universe:
+            self.underlying_instrument.is_investable_universe = True
+            self.underlying_instrument.save()
+
+        if not self.price:
+            # we try to get the price if not provided directly from the underlying instrument
+            self.price = self.get_price()
+        if self.portfolio.only_weighting:
+            estimated_shares = self.order_proposal.get_estimated_shares(
+                self.weighting, self.underlying_instrument, self.price
+            )
+            if estimated_shares:
+                self.shares = estimated_shares
+        if self.id:
+            self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_type(cls, weighting, effective_weight, target_weight) -> Type:
+        if weighting == 0:
+            return Order.Type.NO_CHANGE
+        elif weighting is not None:
+            if weighting > 0:
+                if abs(effective_weight) > 1e-8:
+                    return Order.Type.INCREASE
+                else:
+                    return Order.Type.BUY
+            elif weighting < 0:
+                if abs(target_weight) > 1e-8:
+                    return Order.Type.DECREASE
+                else:
+                    return Order.Type.SELL
+
+    def get_asset(self) -> AssetPosition:
+        asset = AssetPosition(
+            underlying_quote=self.underlying_instrument,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.value_date,
+            initial_currency_fx_rate=self.currency_fx_rate,
+            weighting=self._target_weight,
+            initial_price=self.price,
+            initial_shares=None,
+            asset_valuation_date=self.value_date,
+            currency=self.currency,
+            is_estimated=False,
+        )
+        asset.set_weighting(self._target_weight)
+        asset.pre_save()
+        return asset
+
+    def get_price(self) -> Decimal:
+        try:
+            return self.underlying_instrument.get_price(self.value_date)
+        except ValueError:
+            return Decimal("0")
+
+    def __str__(self):
+        ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
+        return f"{ticker}{self.weighting}"

wbportfolio/models/portfolio.py

@@ -46,7 +46,7 @@ from .exceptions import InvalidAnalyticPortfolio
 
 logger = logging.getLogger("pms")
 if TYPE_CHECKING:
-    from wbportfolio.models.transactions.trade_proposals import TradeProposal
+    from wbportfolio.models.orders.order_proposals import OrderProposal
 
 MARKET_HOLIDAY_MAX_DURATION = 15
 
@@ -101,16 +101,17 @@ def get_returns(
         .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)
     prices_df = df["close"]
+
     if "fx_rate" in df.columns:
         fx_rate_df = df["fx_rate"].fillna(1.0)
     else:
         fx_rate_df = pd.DataFrame(np.ones(prices_df.shape), index=prices_df.index, columns=prices_df.columns)
-
     returns = prices_to_returns(fx_rate_df * prices_df, drop_inceptions_nan=False, fill_nan=True)
     return {ts.date(): row for ts, row in prices_df.to_dict("index").items()}, returns.replace(
         [np.inf, -np.inf, np.nan], 0
@@ -273,7 +274,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     is_manageable = models.BooleanField(
         default=False,
-        help_text="True if the portfolio can be manually modified (e.g. Trade proposal be submitted or total weight recomputed)",
+        help_text="True if the portfolio can be manually modified (e.g. Order Proposal be submitted or total weight recomputed)",
     )
     is_tracked = models.BooleanField(
         default=True,
@@ -355,17 +356,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         "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, use_dl=True).get_next_weights()
+            last_returns, _ = self.get_analytic_portfolio(val_date, use_dl=True).get_contributions()
+            last_returns = last_returns.to_dict()
         except InvalidAnalyticPortfolio:
-            drifted_weights = {}
+            last_returns = {}
         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))
+            positions.append(asset._build_dto(daily_return=last_returns.get(asset.underlying_quote.id, Decimal("0"))))
 
         return PortfolioDTO(positions)
 
@@ -447,7 +444,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             create_notification_type(
                 "wbportfolio.portfolio.replay_done",
                 "Portfolio Replay finished",
-                "Sends a notification when a the requested trade proposal replay is done",
+                "Sends a notification when a the requested order proposal replay is done",
                 True,
                 True,
                 True,
@@ -784,7 +781,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def evaluate_rebalancing(self, val_date: date):
         if hasattr(self, "automatic_rebalancer"):
-            # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a trade proposal automatically
+            # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a order proposal automatically
             next_business_date = (val_date + BDay(1)).date()
             if self.automatic_rebalancer.is_valid(val_date):  # we evaluate the rebalancer in t0 and t+1
                 logger.info(f"Evaluate Rebalancing for {self} at {val_date}")
@@ -818,7 +815,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def drift_weights(
         self, start_date: date, end_date: date, stop_at_rebalancing: bool = False
-    ) -> tuple[AssetPositionIterator, "TradeProposal"]:
+    ) -> tuple[AssetPositionIterator, "OrderProposal"]:
         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
@@ -841,7 +838,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         # Get raw prices to speed up asset position creation
         # Instantiate the position iterator with the initial weights
         positions = AssetPositionIterator(self, prices=prices)
-        last_trade_proposal = None
+        last_order_proposal = None
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
             to_is_active = self.is_active_at_date(to_date)
@@ -860,17 +857,17 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                             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),
+                            daily_return=Decimal(last_returns.iloc[-1][i]),
                         )
                         for i, w in weights.items()
                     ]
                 )
-                last_trade_proposal = rebalancer.evaluate_rebalancing(to_date, effective_portfolio=effective_portfolio)
+                last_order_proposal = rebalancer.evaluate_rebalancing(to_date, effective_portfolio=effective_portfolio)
                 if stop_at_rebalancing:
                     break
                 next_weights = {
                     trade.underlying_instrument: float(trade._target_weight)
-                    for trade in last_trade_proposal.trades.all().annotate_base_info()
+                    for trade in last_order_proposal.get_orders()
                 }
                 positions.add((to_date, next_weights), is_estimated=False)
             else:
@@ -883,7 +880,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     )  # 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
+        return positions, last_order_proposal
 
     def propagate_or_update_assets(self, from_date: date, to_date: date):
         """

wbportfolio/models/{transactions/rebalancing.py → rebalancing.py}

@@ -14,8 +14,8 @@ from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ComplexToStringMixin
 from wbcore.utils.rrules import convert_rrulestr_to_dict, humanize_rrule
 
+from wbportfolio.models.orders.order_proposals import OrderProposal
 from wbportfolio.models.portfolio import Portfolio
-from wbportfolio.models.transactions.trade_proposals import TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 
@@ -78,8 +78,8 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         RebalancingModel, on_delete=models.PROTECT, related_name="rebalancers", verbose_name="Rebalancing Model"
     )
     parameters = models.JSONField(default=dict, verbose_name="Parameters", blank=True)
-    approve_trade_proposal_automatically = models.BooleanField(
-        default=False, verbose_name="Apply Trade Proposal Automatically"
+    approve_order_proposal_automatically = models.BooleanField(
+        default=False, verbose_name="Apply Order Proposal Automatically"
     )
     activation_date = models.DateField(verbose_name="Activation Date")
     frequency = models.CharField(
@@ -99,19 +99,19 @@ class Rebalancer(ComplexToStringMixin, models.Model):
 
     def _get_next_valid_date(self, valid_date: date) -> date:
         pivot_date = valid_date
-        while TradeProposal.objects.filter(
-            portfolio=self.portfolio, status=TradeProposal.Status.FAILED, trade_date=pivot_date
+        while OrderProposal.objects.filter(
+            portfolio=self.portfolio, status=OrderProposal.Status.FAILED, trade_date=pivot_date
         ).exists():
             pivot_date = (pivot_date + BDay(1)).date()
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
-        if TradeProposal.objects.filter(
+        if OrderProposal.objects.filter(
             portfolio=self.portfolio,
-            status=TradeProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPROVED,
             trade_date=trade_date,
             rebalancing_model__isnull=True,
-        ).exists():  # if a already approved trade proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
+        ).exists():  # if a already approved order proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
             return False
         for initial_valid_datetime in self.get_rrule(trade_date):
             initial_valid_date = initial_valid_datetime.date()
@@ -123,7 +123,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         return False
 
     def evaluate_rebalancing(self, trade_date: date, effective_portfolio=None):
-        trade_proposal, _ = TradeProposal.objects.get_or_create(
+        order_proposal, _ = OrderProposal.objects.get_or_create(
             trade_date=trade_date,
             portfolio=self.portfolio,
             defaults={
@@ -132,29 +132,29 @@ class Rebalancer(ComplexToStringMixin, models.Model):
             },
         )
 
-        if trade_proposal.rebalancing_model == self.rebalancing_model:
+        if order_proposal.rebalancing_model == self.rebalancing_model:
             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_proposal.trade_date,
-                    trade_proposal.value_date,
+                    order_proposal.trade_date,
+                    order_proposal.value_date,
                     effective_portfolio=effective_portfolio,
                     **self.parameters,
                 )
-                trade_proposal.approve_workflow(
-                    approve_automatically=self.approve_trade_proposal_automatically,
+                order_proposal.approve_workflow(
+                    approve_automatically=self.approve_order_proposal_automatically,
                     target_portfolio=target_portfolio,
                     effective_portfolio=effective_portfolio,
                 )
             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
+                # If we encountered a validation error, we set the order proposal as failed
+                order_proposal.status = OrderProposal.Status.FAILED
+            order_proposal.save()
+        return order_proposal
 
     @property
     def rrule(self):

wbportfolio/models/transactions/__init__.py

@@ -1,6 +1,4 @@
 from .claim import Claim
 from .dividends import DividendTransaction
 from .fees import FeeCalculation, Fees
-from .trade_proposals import TradeProposal
-from .rebalancing import RebalancingModel, Rebalancer
 from .trades import Trade