wbportfolio 1.54.23__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/models/builder.py

@@ -1,8 +1,9 @@
 import logging
+import math
 from collections import defaultdict
-from contextlib import suppress
 from datetime import date
-from typing import TYPE_CHECKING
+from decimal import Decimal
+from typing import TYPE_CHECKING, Iterable
 
 import pandas as pd
 from celery import chain, group
@@ -20,6 +21,10 @@ if TYPE_CHECKING:
 logger = logging.getLogger("pms")
 
 
+MINIMUM_DECIMAL = 8
+MIN_STEP = Decimal("0.00000001")
+
+
 class AssetPositionBuilder:
     """
     Efficiently converts position data into AssetPosition models with batch operations
@@ -34,7 +39,6 @@ class AssetPositionBuilder:
 
     _positions: dict[date, dict[tuple[int, int | None], "AssetPosition"]]
 
-    _prices: dict[date, dict[int, float]]
     _fx_rates: dict[date, dict[Currency, CurrencyFXRates]]
     _instruments: dict[int, Instrument]
 
@@ -52,13 +56,24 @@ class AssetPositionBuilder:
         self._change_at_date_tasks = dict()
         self._positions = defaultdict(dict)
 
-    def get_positions(self, **kwargs):
+    def get_positions(self, fix_quantization: bool = True, **kwargs):
         # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
-        for _, positions in self._positions.items():
-            for _, position in positions.items():
-                if not position.portfolio.is_manageable or position.weighting:
+        for positions in self._positions.values():
+            quantization_weight_error = round(
+                Decimal("1") - sum(map(lambda o: o.weighting, positions.values()))
+                if fix_quantization
+                else Decimal("0"),
+                MINIMUM_DECIMAL,
+            )
+            for position in sorted(positions.values(), key=lambda x: x.weighting, reverse=True):
+                if position.weighting:
                     for k, v in kwargs.items():
                         setattr(position, k, v)
+                    # if the total weight is not 100%, we add the quantization leftover to some random position (max 1e-8 per position, thus it is negligible)
+                    if quantization_weight_error:
+                        step = round(Decimal(math.copysign(MIN_STEP, quantization_weight_error)), MINIMUM_DECIMAL)
+                        position.weighting += step
+                        quantization_weight_error -= step
                     yield position
 
     def __bool__(self) -> bool:
@@ -76,12 +91,19 @@ class AssetPositionBuilder:
         try:
             return self._fx_rates[val_date][currency]
         except KeyError:
-            with suppress(CurrencyFXRates.DoesNotExist):
-                fx_rate = CurrencyFXRates.objects.get(
-                    currency=currency, date=val_date
-                )  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
-                self._fx_rates[val_date][currency] = fx_rate
-                return fx_rate
+            if currency.key == "USD":
+                fx_rate = CurrencyFXRates.objects.get_or_create(
+                    currency=currency, date=val_date, defaults={"value": Decimal("1")}
+                )[0]
+            else:
+                try:
+                    fx_rate = CurrencyFXRates.objects.get(
+                        currency=currency, date=val_date
+                    )  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
+                except CurrencyFXRates.DoesNotExist:
+                    fx_rate = CurrencyFXRates.objects.filter(currency=currency, date__lt=val_date).latest("date")
+            self._fx_rates[val_date][currency] = fx_rate
+            return fx_rate
 
     def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
         try:
@@ -103,7 +125,7 @@ class AssetPositionBuilder:
 
         parameters = dict(
             underlying_quote=underlying_quote,
-            weighting=round(weighting, 8),
+            weighting=round(weighting, MINIMUM_DECIMAL),
             date=val_date,
             asset_valuation_date=val_date,
             is_estimated=True,
@@ -120,16 +142,36 @@ class AssetPositionBuilder:
         position = AssetPosition(**parameters)
         return position
 
-    def set_return(self, returns: pd.DataFrame):
-        self.returns = returns
-
-    def set_prices(self, prices: dict[date, dict[int, float]] | None = None):
-        self.prices = prices
-
-    def load_returns(self, instrument_ids: list[int], from_date: date, to_date: date, use_dl: bool = True):
-        self.prices, self.returns = Instrument.objects.filter(id__in=instrument_ids).get_returns_df(
-            from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=use_dl
-        )
+    def load_returns(self, instrument_ids: Iterable[int], from_date: date, to_date: date, use_dl: bool = True):
+        if self.returns.empty:
+            self.prices, self.returns = Instrument.objects.filter(id__in=instrument_ids).get_returns_df(
+                from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=use_dl
+            )
+        else:
+            min_date = min(self.prices.keys())
+            max_date = max(self.prices.keys())
+            if from_date < min_date or to_date > max_date:
+                # we need to refetch everything as we are missing index
+                self.prices, self.returns = Instrument.objects.filter(
+                    id__in=set(instrument_ids).union(set(self.returns.columns))
+                ).get_returns_df(
+                    from_date=min(from_date, min_date),
+                    to_date=max(to_date, max_date),
+                    to_currency=self.portfolio.currency,
+                    use_dl=use_dl,
+                )
+            else:
+                instruments = set(instrument_ids) - set(self.returns.columns)
+                if instruments:
+                    new_prices, new_returns = Instrument.objects.filter(id__in=instruments).get_returns_df(
+                        from_date=min(from_date, min_date),
+                        to_date=max(to_date, max_date),
+                        to_currency=self.portfolio.currency,
+                        use_dl=use_dl,
+                    )
+                    self.returns = self.returns.join(new_returns, how="left").fillna(0)
+                    for d, p in new_prices.items():
+                        self.prices[d].update(p)
 
     def add(
         self,
@@ -163,6 +205,9 @@ class AssetPositionBuilder:
                     position.initial_shares += existing_position.initial_shares
             # ensure the position portfolio is the iterator portfolio (could be different when computing look-through for instance)
             position.portfolio = self.portfolio
+            position.weighting = Decimal(
+                round(position.weighting, 8)
+            )  # set the weight as it will be saved in the db to handle quantization error accordingly
             if position.initial_price is not None and position.initial_currency_fx_rate is not None:
                 self._positions[position.date][key] = position
         return self
@@ -246,7 +291,7 @@ class AssetPositionBuilder:
             tasks = chain(
                 *[
                     trigger_portfolio_change_as_task.si(
-                        self.portfolio.id, d, changed_portfolio=portfolio, **task_kwargs
+                        self.portfolio.id, d, changed_portfolio=portfolio, evaluate_rebalancer=False, **task_kwargs
                     )
                     for d, portfolio in self._change_at_date_tasks.items()
                 ]

wbportfolio/models/mixins/instruments.py

@@ -150,6 +150,13 @@ class PMSInstrumentAbstractModel(PMSInstrument):
         default="wbportfolio.models.portfolio.default_estimate_net_value",
         verbose_name="NAV Computation Method",
     )
+    order_routing_custodian_adapter = models.CharField(
+        blank=True,
+        null=True,
+        max_length=1024,
+        verbose_name="Order Routing Custodian Adapter",
+        help_text="The dotted path to the order routing custodian adapter",
+    )
     risk_scale = models.IntegerField(
         validators=[MinValueValidator(1), MaxValueValidator(7)],
         default=4,