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

wbportfolio/migrations/0087_product_order_routing_custodian_adapter.py

@@ -0,0 +1,94 @@
+# Generated by Django 5.0.14 on 2025-08-11 14:01
+
+import django.db.models.deletion
+import django_fsm
+from django.db import migrations, models
+
+def migrate_approve_to_apply(apps, schema_editor):
+    OrderProposal = apps.get_model("wbportfolio", "OrderProposal")
+    OrderProposal.objects.filter(status="APPROVED").update(status="APPLIED")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0086_orderproposal_total_cash_weight'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='product',
+            name='order_routing_custodian_adapter',
+            field=models.CharField(blank=True, help_text='The dotted path to the order routing custodian adapter', max_length=1024, null=True, verbose_name='Order Routing Custodian Adapter'),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='execution_comment',
+            field=models.TextField(blank=True, default='', verbose_name='Execution Comment'),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='execution_confirmed',
+            field=models.BooleanField(default=False, verbose_name='Execution Confirmed'),
+        ),
+        migrations.AddField(
+            model_name='orderproposal',
+            name='approver',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT,
+                                    related_name='approver_order_proposals', to='directory.person',
+                                    verbose_name='Approver'),
+        ),
+        migrations.AddField(
+            model_name='orderproposal',
+            name='execution_comment',
+            field=models.CharField(blank=True, default='', verbose_name='Execution Comment'),
+        ),
+        migrations.AddField(
+            model_name='orderproposal',
+            name='execution_status',
+            field=models.CharField(blank=True, choices=[('PENDING', 'Pending'), ('IN_DRAFT', 'In Draft'),
+                                                        ('COMPLETED', 'Completed'), ('CANCELLED', 'Cancelled'),
+                                                        ('REJECTED', 'Rejected'), ('FAILED', 'Failed'),
+                                                        ('UNKNOWN', 'Unknown')], default='',
+                                   verbose_name='Execution Status'),
+        ),
+        migrations.AddField(
+            model_name='orderproposal',
+            name='execution_status_detail',
+            field=models.CharField(blank=True, default='', verbose_name='Execution Status Detail'),
+        ),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='status',
+            field=django_fsm.FSMField(choices=[('DRAFT', 'Draft'), ('SUBMIT', 'Pending'), ('APPROVED', 'Approved'),
+                                               ('PENDING_EXECUTION', 'Pending Execution'), ('EXECUTED', 'Executed'),
+                                               ('DENIED', 'Denied'), ('FAILED', 'Failed')], default='DRAFT',
+                                      max_length=50, verbose_name='Status'),
+        ),
+        migrations.AddField(
+            model_name='index',
+            name='order_routing_custodian_adapter',
+            field=models.CharField(blank=True, help_text='The dotted path to the order routing custodian adapter',
+                                   max_length=1024, null=True, verbose_name='Order Routing Custodian Adapter'),
+        ),
+        migrations.AddField(
+            model_name='productgroup',
+            name='order_routing_custodian_adapter',
+            field=models.CharField(blank=True, help_text='The dotted path to the order routing custodian adapter',
+                                   max_length=1024, null=True, verbose_name='Order Routing Custodian Adapter'),
+        ),
+        migrations.RenameField(
+            model_name='rebalancer',
+            old_name='approve_order_proposal_automatically',
+            new_name='apply_order_proposal_automatically',
+        ),
+        migrations.RunPython(migrate_approve_to_apply),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='status',
+            field=django_fsm.FSMField(
+                choices=[('DRAFT', 'Draft'), ('PENDING', 'Pending'), ('APPROVED', 'Approved'), ('DENIED', 'Denied'),
+                         ('APPLIED', 'Applied'), ('EXECUTION', 'Execution'), ('FAILED', 'Failed')], default='DRAFT',
+                max_length=50, verbose_name='Status'),
+        ),
+    ]

wbportfolio/migrations/0088_orderproposal_total_effective_portfolio_contribution.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.14 on 2025-08-18 08:34
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0087_product_order_routing_custodian_adapter'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='orderproposal',
+            name='total_effective_portfolio_contribution',
+            field=models.DecimalField(decimal_places=16, default=Decimal('1'), max_digits=19),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -30,7 +30,6 @@ from pandas._libs.tslibs.offsets import BDay
 from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
 from wbcore.signals import pre_merge
-from wbcore.utils.enum import ChoiceEnum
 from wbfdm.models import Classification, ClassificationGroup, Instrument
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import add_instrument_to_investable_universe
@@ -223,25 +222,12 @@ class AnalyticalAssetPositionManager(DefaultAssetPositionManager):
         )
 
 
-class AssetPositionGroupBy(ChoiceEnum):
-    INDUSTRY = "Industry"
-    COUNTRY = "Country"
-    CURRENCY = "Currency"
-    CASH = "Cash"
-    MARKET_CAPITALIZATION = "Market Cap"
-    LIQUIDITY = "Liquidity"
-
-    @classmethod
-    def get_class_method_group_by(cls, name: str):
-        _map = {
-            "INDUSTRY": "industry",
-            "COUNTRY": AssetPosition.country_group_by,
-            "CURRENCY": AssetPosition.currency_group_by,
-            "CASH": AssetPosition.cash_group_by,
-            "MARKET_CAPITALIZATION": AssetPosition.marketcap_group_by,
-            "LIQUIDITY": AssetPosition.liquidity_group_by,
-        }
-        return _map[name]
+class AssetPositionGroupBy(models.TextChoices):
+    INDUSTRY = "classification", "Industry"
+    INSTRUMENT_TYPE = "instrument_type", "Type"
+    COUNTRY = "country", "Country"
+    CURRENCY = "currency", "Currency"
+    CASH = "is_cash", "Cash"
 
 
 class AssetPosition(ImportMixin, models.Model):

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:
@@ -94,7 +116,6 @@ class AssetPositionBuilder:
         val_date: date,
         instrument_id: int,
         weighting: float,
-        infer_underlying_quote_price: bool = False,
         **kwargs,
     ) -> "AssetPosition":
         underlying_quote = self._get_instrument(instrument_id)
@@ -104,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,
@@ -119,21 +140,38 @@ class AssetPositionBuilder:
         )
         parameters.update(kwargs)
         position = AssetPosition(**parameters)
-        position.pre_save(
-            infer_underlying_quote_price=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 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,
@@ -151,8 +189,10 @@ class AssetPositionBuilder:
             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, infer_underlying_quote_price=infer_underlying_quote_price)
-
+                position = self._dict_to_model(*position)
+            position.pre_save(
+                infer_underlying_quote_price=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
             # Generate unique composite key
             key = (
                 position.underlying_quote.id,
@@ -165,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
@@ -248,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,