wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/migrations/0092_order_quantization_error_alter_orderproposal_status.py

@@ -0,0 +1,49 @@
+# Generated by Django 5.0.12 on 2025-11-11 10:16
+
+import django_fsm
+import django.db.models.deletion
+from decimal import Decimal
+from django.db import migrations, models
+import django_fsm
+from django.db import migrations
+
+def migrate_status(apps, schema_editor):
+    OrderProposal = apps.get_model("wbportfolio", "OrderProposal")
+    OrderProposal.objects.filter(status="APPLIED").update(status="CONFIRMED")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0091_remove_order_execution_confirmed_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='order',
+            name='quantization_error',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'), max_digits=9, verbose_name='Quantization Error'),
+        ),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='status',
+            field=django_fsm.FSMField(choices=[('DRAFT', 'Draft'), ('PENDING', 'Pending'), ('APPROVED', 'Approved'), ('DENIED', 'Denied'), ('EXECUTION', 'Execution'), ('APPLIED', 'Applied'), ('FAILED', 'Failed')], default='DRAFT', max_length=50, verbose_name='Status'),
+        ),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='status',
+            field=django_fsm.FSMField(
+                choices=[('DRAFT', 'Draft'), ('PENDING', 'Pending'), ('APPROVED', 'Approved'), ('DENIED', 'Denied'),
+                         ('EXECUTION', 'Execution'), ('CONFIRMED', 'Confirmed'), ('FAILED', 'Failed')], default='DRAFT',
+                max_length=50, verbose_name='Status'),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='execution_trade',
+            field=models.OneToOneField(blank=True, help_text='The executed Trade', null=True,
+                                       on_delete=django.db.models.deletion.SET_NULL, related_name='order',
+                                       to='wbportfolio.trade'),
+        ),
+        migrations.RunPython(migrate_status),
+
+    ]

wbportfolio/migrations/0093_remove_portfolioportfoliothroughmodel_unique_primary_and_more.py

@@ -0,0 +1,35 @@
+# Generated by Django 5.0.12 on 2025-11-28 13:11
+
+from django.db import migrations, models
+
+def handle_data(apps, schema_editor):
+    PortfolioPortfolioThroughModel = apps.get_model('wbportfolio', 'PortfolioPortfolioThroughModel')
+    PortfolioPortfolioThroughModel.objects.filter(type="PRIMARY").update(type="LOOK_THROUGH")
+    from wbportfolio.models.portfolio import Portfolio
+    for portfolio in Portfolio.objects.all():
+        if portfolio.assets.exists():
+            val_date = portfolio.assets.latest("date").date
+            for parent_ptf, _ in portfolio.get_parent_portfolios(val_date):
+                PortfolioPortfolioThroughModel.objects.get_or_create(portfolio_id=portfolio.id, dependency_portfolio_id=parent_ptf.id, defaults={"type": "HIERARCHICAL"})
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0092_order_quantization_error_alter_orderproposal_status'),
+    ]
+
+    operations = [
+        migrations.RemoveConstraint(
+            model_name='portfolioportfoliothroughmodel',
+            name='unique_primary',
+        ),
+        migrations.AlterField(
+            model_name='portfolioportfoliothroughmodel',
+            name='type',
+            field=models.CharField(choices=[('LOOK_THROUGH', 'Look-through'), ('MODEL', 'Model'), ('CUSTODIAN', 'Custodian'), ('HIERARCHICAL', 'Hierarchical')], default='LOOK_THROUGH', verbose_name='Type'),
+        ),
+        migrations.AddConstraint(
+            model_name='portfolioportfoliothroughmodel',
+            constraint=models.UniqueConstraint(condition=models.Q(('type', 'LOOK_THROUGH')), fields=('portfolio', 'type'), name='unique_lookthrough'),
+        ),
+        migrations.RunPython(handle_data)
+    ]

wbportfolio/models/__init__.py

@@ -17,5 +17,7 @@ from .portfolio_cash_flow import DailyPortfolioCashFlow
 from .portfolio_swing_pricings import PortfolioSwingPricing
 from .registers import Register
 from .transactions import *
+from .orders import *
 from .reconciliations import AccountReconciliation, AccountReconciliationLine
 from .signals import *
+from .rebalancing import RebalancingModel, Rebalancer

wbportfolio/models/adjustments.py

@@ -212,7 +212,7 @@ def post_adjustment_on_prices(adjustment_id, automatically_confirm_approve_adjus
             adjustment.apply_adjustment_on_assets()
             adjustment.status = Adjustment.Status.APPLIED
         else:
-            for user in User.objects.filter(profile__in=PortfolioRole.portfolio_managers()):
+            for user in User.objects.filter(profile__in=PortfolioRole.portfolio_managers(), is_active=True):
                 send_notification(
                     code="wbportfolio.adjustment.add",
                     title="A new adjustment was imported",

wbportfolio/models/asset.py

@@ -1,10 +1,11 @@
-from collections import defaultdict
+import logging
 from contextlib import suppress
 from datetime import date
 from decimal import Decimal, InvalidOperation
 from typing import TYPE_CHECKING
 
 from django.contrib import admin
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.db.models import (
     Case,
@@ -30,7 +31,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
@@ -43,6 +43,8 @@ from wbportfolio.models.portfolio_relationship import (
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.typing import Position as PositionDTO
 
+logger = logging.getLogger("pms")
+
 MARKETCAP_S = 2_000_000_000
 MARKETCAP_M = 10_000_000_000
 MARKETCAP_L = 50_000_000_000
@@ -55,145 +57,7 @@ HOUR = MINUTE * 60
 DAY = HOUR * 24
 
 if TYPE_CHECKING:
-    from wbportfolio.models.portfolio import Portfolio
-
-
-class AssetPositionIterator:
-    """
-    Efficiently converts position data into AssetPosition models with batch operations
-    and proper dependency management.
-
-    Features:
-    - Bulk database fetching for performance
-    - Thread-safe operations
-    - Clear type hints
-    - Memory-efficient storage
-    """
-
-    positions: dict[tuple[date, int, int | None], "AssetPosition"]
-
-    _prices: dict[date, dict[int, float]]
-    _weights: dict[date, dict[int, float]]
-    _fx_rates: dict[date, dict[Currency, CurrencyFXRates]]
-    _instruments: dict[int, Instrument]
-
-    def __init__(
-        self,
-        portfolio: "Portfolio",
-        prices: dict[date, dict[int, float]] | None = None,
-        infer_underlying_quote_price: bool = False,
-    ):
-        self.portfolio = portfolio
-        self.infer_underlying_quote_price = infer_underlying_quote_price
-        # Initialize data stores with type hints
-        self._instruments = {}
-        self._fx_rates = defaultdict(dict)
-        self._weights = defaultdict(dict)
-        self._prices = prices or defaultdict(dict)
-        self.positions = dict()
-
-    def _get_instrument(self, instrument_id: int) -> Instrument:
-        try:
-            return self._instruments[instrument_id]
-        except KeyError:
-            instrument = Instrument.objects.get(id=instrument_id)
-            self._instruments[instrument_id] = instrument
-            return instrument
-
-    def _get_fx_rate(self, val_date: date, currency: Currency) -> CurrencyFXRates | None:
-        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
-
-    def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
-        try:
-            return self._prices[val_date][instrument.id]
-        except KeyError:
-            return None
-
-    def _dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> "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(
-            underlying_quote=underlying_quote,
-            weighting=weighting,
-            date=val_date,
-            asset_valuation_date=val_date,
-            is_estimated=True,
-            portfolio=self.portfolio,
-            currency=underlying_quote.currency,
-            initial_price=price,
-            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
-            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
-            initial_currency_fx_rate=None,
-            underlying_quote_price=None,
-            underlying_instrument=None,
-        )
-        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]],
-    ):
-        """
-        Add multiple positions efficiently with batch processing
-
-        Args:
-            positions: Iterable of AssetPosition instances or dictionary of weight {instrument_id: weight} that needs to be converted into AssetPosition
-        """
-        if isinstance(positions, tuple):
-            val_date = positions[0]
-            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)
-
-            # Generate unique composite key
-            key = (
-                position.date,
-                position.underlying_quote.id,
-                position.portfolio_created.id if position.portfolio_created else None,
-            )
-            # Merge duplicate positions
-            if existing_position := self.positions.get(key):
-                position.weighting += existing_position.weighting
-                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
-            if position.initial_price is not None and position.initial_currency_fx_rate is not None:
-                self.positions[key] = position
-                self._weights[position.date][position.underlying_quote.id] = float(position.weighting)
-
-        return self
-
-    def get_dates(self) -> list[date]:
-        """Get sorted list of unique dates"""
-        return list(self._weights.keys())
-
-    def get_weights(self) -> dict[date, dict[int, float]]:
-        """Get weight structure with instrument IDs as keys"""
-        return dict(self._weights)
-
-    def __iter__(self):
-        # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
-        yield from filter(lambda a: not a.portfolio.is_manageable or a.weighting, self.positions.values())
-
-    def __getitem__(self, item: tuple[date, Instrument]) -> float:
-        return self._weights[item[0]][item[1].id]
-
-    def __bool__(self) -> bool:
-        return len(self.positions.keys()) > 0
+    pass
 
 
 class AssetPositionDefaultQueryset(QuerySet):
@@ -359,25 +223,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):
@@ -464,8 +315,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.",
@@ -558,7 +409,7 @@ class AssetPosition(ImportMixin, models.Model):
     analytical_objects = AnalyticalAssetPositionManager()
     unannotated_objects = models.Manager()
 
-    def pre_save(
+    def pre_save(  # noqa: C901
         self, create_underlying_quote_price_if_missing: bool = False, infer_underlying_quote_price: bool = True
     ):
         if not self.asset_valuation_date:
@@ -579,12 +430,12 @@ class AssetPosition(ImportMixin, models.Model):
         ):
             try:
                 self.underlying_quote = self.underlying_instrument.children.get(is_primary=True)
-            except:
+            except ObjectDoesNotExist:
                 self.underlying_quote = self.underlying_instrument
 
         if not getattr(self, "currency", None):
             self.currency = self.underlying_quote.currency
-        if not self.underlying_quote_price and infer_underlying_quote_price:
+        if not self.underlying_quote_price and (infer_underlying_quote_price or not self.initial_price):
             try:
                 # We get only the instrument price (and don't create it) because we don't want to create product instrument price on asset position propagation
                 # Instead, we decided to opt for a post_save based system that will assign the missing position price when a price is created
@@ -597,7 +448,10 @@ class AssetPosition(ImportMixin, models.Model):
                     net_value = self.initial_price
                     # in case the position currency and the linked underlying_quote currency don't correspond, we convert the rate accordingly
                     if self.currency != self.underlying_quote.currency:
-                        net_value *= self.currency.convert(self.asset_valuation_date, self.underlying_quote.currency)
+                        with suppress(CurrencyFXRates.DoesNotExist):
+                            net_value *= self.currency.convert(
+                                self.asset_valuation_date, self.underlying_quote.currency
+                            )
                     self.underlying_quote_price = InstrumentPrice.objects.create(
                         calculated=False,
                         instrument=self.underlying_quote,
@@ -652,6 +506,8 @@ class AssetPosition(ImportMixin, models.Model):
                     portfolio_created=self.portfolio_created,
                 )
                 self.initial_shares = previous_pos.initial_shares
+        if self.underlying_quote:
+            self.exchange = self.underlying_quote.exchange
 
     def save(self, *args, create_underlying_quote_price_if_missing: bool = False, **kwargs):
         self.pre_save(create_underlying_quote_price_if_missing=create_underlying_quote_price_if_missing)
@@ -691,22 +547,22 @@ 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) -> 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,
             instrument_type=self.underlying_quote.security_instrument_type.id,
             currency=self.underlying_quote.currency.id,
             country=self.underlying_quote.country.id if self.underlying_quote.country else None,
-            is_cash=self.underlying_quote.is_cash,
+            is_cash=self.underlying_quote.is_cash or self.underlying_quote.is_cash_equivalent,
             primary_classification=(
                 self.underlying_quote.primary_classification.id
                 if self.underlying_quote.primary_classification
@@ -725,6 +581,8 @@ class AssetPosition(ImportMixin, models.Model):
             currency_fx_rate=self._currency_fx_rate,
             portfolio_created=self.portfolio_created.id if self.portfolio_created else None,
         )
+        parameters.update(kwargs)
+        return PositionDTO(**parameters)
 
     @cached_property
     @admin.display(description="Adjusting Factor (adjustment)")