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

wbportfolio/models/orders/orders.py

@@ -68,6 +68,9 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         help_text="The Ex-Post daily return",
     )
 
+    execution_confirmed = models.BooleanField(default=False, verbose_name="Execution Confirmed")
+    execution_comment = models.TextField(default="", blank=True, verbose_name="Execution Comment")
+
     def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
         warnings = []
 
@@ -93,7 +96,9 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         if not self.price:
             warnings.append(f"No price for {self.underlying_instrument.computed_str}")
         if (
-            not self.underlying_instrument.is_cash and self._target_weight < -1e-8
+            not self.underlying_instrument.is_cash
+            and not self.underlying_instrument.is_cash_equivalent
+            and self._target_weight < -1e-8
         ):  # any value below -1e8 will be considered zero
             warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
         self.desired_target_weight = self._target_weight
@@ -185,27 +190,32 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         ]
         # notification_email_template = "portfolio/email/trade_notification.html"
 
-    def save(self, *args, **kwargs):
+    def pre_save(self):
         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:
+            if self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent:
+                self.price = Decimal("1")
+            else:
+                self.price = self.get_price()
+        if not 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
+        super().pre_save()
+
+    def save(self, *args, **kwargs):
+        self.pre_save()
+        if not self.underlying_instrument.is_investable_universe:
+            self.underlying_instrument.is_investable_universe = True
+            self.underlying_instrument.save()
+
         if self.id:
-            self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+            self.set_type()
         super().save(*args, **kwargs)
 
     @classmethod
@@ -224,6 +234,9 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 else:
                     return Order.Type.SELL
 
+    def set_type(self):
+        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+
     def get_price(self) -> Decimal:
         try:
             return self.underlying_instrument.get_price(self.value_date)

wbportfolio/models/orders/routing.py

@@ -0,0 +1,54 @@
+# TBD: Should this stay a service or should we extend the order proposal model (fat model approach) ?
+from contextlib import suppress
+from typing import TYPE_CHECKING
+
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+
+from wbportfolio.order_routing import ExecutionStatus
+
+if TYPE_CHECKING:
+    from wbportfolio.models import OrderProposal
+
+
+def _should_route_as_draft() -> bool:
+    """Determine whether orders should be routed as drafts."""
+    return getattr(settings, "DEBUG", True) or getattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+
+
+def _update_orders_with_confirmations(order_proposal, confirmations, rebalancing_comment):
+    """Update all orders in the proposal based on confirmed executions."""
+
+
+def execute_orders(order_proposal: "OrderProposal") -> tuple[ExecutionStatus, str]:
+    """
+    Executes the prepared orders of an order proposal via its custodian adapter.
+    Updates execution statuses and handles routing errors gracefully.
+    """
+    orders = order_proposal.prepare_orders_for_execution()
+    as_draft = _should_route_as_draft()
+    adapter = order_proposal.custodian_adapter
+    order_confirmations, rebalancing_comment = adapter.submit_rebalancing(orders, as_draft=as_draft)
+    leftover_orders = order_proposal.orders.all()
+
+    for confirmed in order_confirmations:
+        with suppress(ObjectDoesNotExist):
+            order = leftover_orders.get(id=confirmed.id)
+            order.execution_confirmed = True
+            order.execution_comment = order.comment
+            order.save()
+            leftover_orders = leftover_orders.exclude(id=order.id)
+
+    # Orders without confirmation
+    leftover_orders.update(execution_confirmed=False, execution_comment="No confirmation received from the custodian")
+    return ExecutionStatus.IN_DRAFT if as_draft else ExecutionStatus.PENDING, rebalancing_comment
+
+
+def get_execution_status(order_proposal: "OrderProposal") -> tuple[ExecutionStatus, str]:
+    adapter = order_proposal.custodian_adapter
+    return adapter.get_rebalance_status()
+
+
+def cancel_rebalancing(order_proposal: "OrderProposal") -> bool:
+    adapter = order_proposal.custodian_adapter
+    return adapter.cancel_current_rebalancing()

wbportfolio/models/portfolio.py

@@ -2,7 +2,6 @@ import logging
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
-from math import isclose
 from typing import TYPE_CHECKING, Any, Generator, Iterable
 
 import numpy as np
@@ -22,7 +21,7 @@ from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ActiveObjectManager, DeleteToDisableMixin
-from wbfdm.models import Instrument, InstrumentType
+from wbfdm.models import Cash, Instrument, InstrumentType
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import investable_universe_updated
 
@@ -39,6 +38,7 @@ from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position as PositionDTO
 
 from ..constants import EQUITY_TYPE_KEYS
+from ..order_routing.adapters import BaseCustodianAdapter
 from . import ProductGroup
 
 logger = logging.getLogger("pms")
@@ -263,6 +263,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 dependency_portfolio__is_composition=True,
             ).dependency_portfolio
 
+    @property
+    def is_model(self) -> bool:
+        return PortfolioPortfolioThroughModel.objects.filter(
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+            dependency_portfolio=self,
+        ).exists()
+
     @property
     def imported_assets(self):
         return self.assets.filter(is_estimated=False)
@@ -274,6 +281,30 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         instruments.extend([i for i in Index.objects.filter(portfolios=self)])
         return instruments
 
+    @property
+    def cash_component(self) -> Cash:
+        return Cash.objects.get_or_create(
+            currency=self.currency, defaults={"is_cash": True, "name": self.currency.title}
+        )[0]
+
+    def get_authenticated_custodian_adapter(self, **kwargs) -> BaseCustodianAdapter | None:
+        supported_instruments_for_routing = list(
+            filter(lambda o: o.order_routing_custodian_adapter, self.pms_instruments)
+        )
+        if not supported_instruments_for_routing:
+            raise ValueError("No custodian adapter for this portfolio")
+
+        pms_instrument = supported_instruments_for_routing[
+            0
+        ]  # for simplicity we support only one instrument per portfolio that is allowed to support order routing
+        adapter = import_from_dotted_path(pms_instrument.order_routing_custodian_adapter)(
+            isin=pms_instrument.isin, identifier=pms_instrument.identifier, **kwargs
+        )
+        adapter.authenticate()
+        if not adapter.is_valid():
+            raise ValueError("This portfolio is not valid for rebalancing")
+        return adapter
+
     @property
     def can_be_rebalanced(self):
         return self.is_manageable and not self.is_lookthrough
@@ -337,13 +368,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if not weights:
             weights = self.get_weights(val_date)
         return_date = (val_date + BDay(1)).date()
-        returns = self.builder.returns
-        if (
-            return_date <= date.today()
-            and pd.Timestamp(return_date) not in returns.index
-            or not set(weights.keys()).issubset(set(returns.columns))
-        ):
-            returns = self.load_builder_returns(val_date, return_date, use_dl=use_dl)
+        returns = self.load_builder_returns(val_date, return_date, use_dl=use_dl).copy()
         if pd.Timestamp(return_date) not in returns.index:
             raise ValueError()
         returns = returns.loc[:return_date, :]
@@ -641,11 +666,29 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if automatic_rebalancer := getattr(self, "automatic_rebalancer", None):
             return automatic_rebalancer.get_next_rebalancing_date(start_date)
 
+    def fix_quantization(self, val_date: date):
+        assets = self.assets.filter(date=val_date)
+        total_weighting = assets.aggregate(s=Sum("weighting"))["s"]
+        if quantization_error := Decimal("1") - total_weighting:
+            cash = self.cash_component
+            try:
+                cash_pos = assets.get(underlying_quote=cash)
+                cash_pos.weighting += quantization_error
+            except AssetPosition.DoesNotExist:
+                cash_pos = AssetPosition(
+                    portfolio=self,
+                    underlying_quote=cash,
+                    weighting=quantization_error,
+                    initial_price=Decimal("1"),
+                    date=val_date,
+                    is_estimated=True,
+                )
+            cash_pos.save(create_underlying_quote_price_if_missing=True)
+
     def change_at_date(
         self,
         val_date: date,
-        recompute_weighting: bool = False,
-        force_recompute_weighting: bool = False,
+        fix_quantization: bool = False,
         evaluate_rebalancer: bool = True,
         changed_portfolio: AnalyticPortfolio | None = None,
         broadcast_changes_at_date: bool = True,
@@ -653,28 +696,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     ):
         logger.info(f"change at date for {self} at {val_date}")
 
-        if recompute_weighting:
-            # We normalize weight across the portfolio for a given date
-            qs = self.assets.filter(date=val_date).filter(
-                Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False)
-            )
-            if (self.is_lookthrough or self.is_manageable or force_recompute_weighting) and qs.exists():
-                total_weighting = qs.aggregate(s=Sum("weighting"))["s"]
-                # We check if this actually necessary
-                # (i.e. if the weight is already summed to 100%, it is already normalized)
-                if (
-                    not total_weighting
-                    or not isclose(total_weighting, Decimal(1.0), abs_tol=0.001)
-                    or force_recompute_weighting
-                ):
-                    total_value = qs.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
-                    # TODO we change this because postgres doesn't support join statement in update (and total_value_fx_portfolio is a joined annoted field)
-                    for asset in qs:
-                        if total_value:
-                            asset.weighting = asset._total_value_fx_portfolio / total_value
-                        elif total_weighting:
-                            asset.weighting = asset.weighting / total_weighting
-                        asset.save()
+        if fix_quantization:
+            # We assume all ptf total weight is 100% but quantization error can occur. In that case, we create a cash component and add the weight there.
+            self.fix_quantization(val_date)
 
         # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
         self.estimate_net_asset_values(
@@ -693,8 +717,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if broadcast_changes_at_date:
             self.handle_controlling_portfolio_change_at_date(
                 val_date,
-                recompute_weighting=recompute_weighting,
-                force_recompute_weighting=force_recompute_weighting,
+                fix_quantization=fix_quantization,
                 changed_portfolio=changed_portfolio,
                 **kwargs,
             )
@@ -712,9 +735,20 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             ):
                 rel.portfolio.evaluate_rebalancing(val_date)
             for dependent_portfolio in self.get_child_portfolios(val_date):
-                dependent_portfolio.change_at_date(val_date, **kwargs)
+                # dependent_portfolio.change_at_date(val_date, **kwargs)
                 dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date, **kwargs)
 
+    def get_model_portfolio_relationships(
+        self, val_date: date
+    ) -> Generator[PortfolioPortfolioThroughModel, None, None]:
+        for rel in PortfolioPortfolioThroughModel.objects.filter(
+            dependency_portfolio=self, type=PortfolioPortfolioThroughModel.Type.MODEL
+        ):
+            if rel.portfolio.is_active_at_date(val_date):
+                yield rel
+        for dependent_portfolio in self.get_child_portfolios(val_date):
+            yield from dependent_portfolio.get_model_portfolio_relationships(val_date)
+
     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 order proposal automatically
@@ -770,7 +804,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if not weights:
             previous_date = self.assets.filter(date__lte=start_date).latest("date").date
             _, weights = next(self.drift_weights(previous_date, start_date))
-
         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()
@@ -785,10 +818,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 break
             try:
                 order_proposal = self.order_proposals.get(
-                    trade_date=to_date, rebalancing_model__isnull=True, status="APPROVED"
+                    trade_date=to_date, rebalancing_model__isnull=True, status="APPLIED"
                 )
             except ObjectDoesNotExist:
                 if rebalancer and rebalancer.is_valid(to_date):
+                    rebalancer.portfolio = self  # ensure reference is the same to access cached returns
                     effective_portfolio = PortfolioDTO(
                         positions=[
                             PositionDTO(
@@ -841,12 +875,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             for pos_date, weights in self.drift_weights(from_date, to_date):
                 self.builder.add((pos_date, weights))
             self.builder.bulk_create_positions(delete_leftovers=True)
-            self.builder.schedule_change_at_dates(evaluate_rebalancer=False)
+            self.builder.schedule_change_at_dates()
             self.builder.schedule_metric_computation()
 
     def load_builder_returns(self, from_date: date, to_date: date, use_dl: bool = True) -> pd.DataFrame:
         instruments_ids = list(self.get_weights(from_date).keys())
-        for tp in self.order_proposals.filter(trade_date__gte=from_date, trade_date__lte=to_date, status="APPROVED"):
+        for tp in self.order_proposals.filter(trade_date__gte=from_date, trade_date__lte=to_date):
             instruments_ids.extend(tp.orders.values_list("underlying_instrument", flat=True))
         self.builder.load_returns(
             set(instruments_ids), (from_date - BDay(1)).date(), (to_date + BDay(1)).date(), use_dl=use_dl
@@ -935,9 +969,10 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
             self.builder.add(
                 list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
+                infer_underlying_quote_price=True,
             )
         self.builder.bulk_create_positions(delete_leftovers=True)
-        self.builder.schedule_change_at_dates(evaluate_rebalancer=False)
+        self.builder.schedule_change_at_dates()
         self.builder.schedule_metric_computation()
 
     def update_preferred_classification_per_instrument(self):
@@ -1134,6 +1169,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         index = Index.objects.create(name=self.name, currency=self.currency)
         index.portfolios.all().delete()
         InstrumentPortfolioThroughModel.objects.update_or_create(instrument=index, defaults={"portfolio": self})
+        return index
 
     @classmethod
     def create_model_portfolio(cls, name: str, currency: Currency, with_index: bool = True):

wbportfolio/models/products.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 
 from celery import shared_task
 from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.postgres.constraints import ExclusionConstraint
 from django.contrib.postgres.fields import DateRangeField, RangeOperators
 from django.db import models
@@ -33,6 +34,7 @@ from wbcore.utils.enum import ChoiceEnum
 from wbcrm.models.accounts import Account
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.models.instruments.instruments import InstrumentManager, InstrumentType
+from wbreport.models import Report
 
 from wbportfolio.models.portfolio_relationship import InstrumentPortfolioThroughModel
 
@@ -198,6 +200,8 @@ class FeeProductPercentage(models.Model):
 
 
 class Product(PMSInstrumentAbstractModel):
+    reports = GenericRelation(Report)
+
     share_price = models.PositiveIntegerField(
         default=100,
         verbose_name="Share Price",
@@ -344,6 +348,11 @@ class Product(PMSInstrumentAbstractModel):
 
         self.is_managed = True
 
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.delisted_date and self.delisted_date <= date.today():
+            self.reports.update(is_active=False)
+
     def get_title(self):
         if self.parent:
             return f"{self.parent.name} ({self.name})"

wbportfolio/models/rebalancing.py

@@ -78,7 +78,7 @@ 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_order_proposal_automatically = models.BooleanField(
+    apply_order_proposal_automatically = models.BooleanField(
         default=False, verbose_name="Apply Order Proposal Automatically"
     )
     activation_date = models.DateField(verbose_name="Activation Date")
@@ -108,10 +108,10 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     def is_valid(self, trade_date: date) -> bool:
         if OrderProposal.objects.filter(
             portfolio=self.portfolio,
-            status=OrderProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPLIED,
             trade_date=trade_date,
             rebalancing_model__isnull=True,
-        ).exists():  # if a already approved order proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
+        ).exists():  # if a already applied 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()
@@ -131,7 +131,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 "rebalancing_model": self.rebalancing_model,
             },
         )
-
+        order_proposal.portfolio = self.portfolio
         if order_proposal.rebalancing_model == self.rebalancing_model:
             try:
                 logger.info(
@@ -144,8 +144,8 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                     effective_portfolio=effective_portfolio,
                     **self.parameters,
                 )
-                order_proposal.approve_workflow(
-                    approve_automatically=self.approve_order_proposal_automatically,
+                order_proposal.apply_workflow(
+                    apply_automatically=self.apply_order_proposal_automatically,
                     target_portfolio=target_portfolio,
                     effective_portfolio=effective_portfolio,
                 )

wbportfolio/models/transactions/transactions.py

@@ -92,17 +92,21 @@ class TransactionMixin(models.Model):
     created = models.DateTimeField(auto_now_add=True)
     updated = models.DateTimeField(auto_now=True)
 
-    def save(self, *args, **kwargs):
-        if not getattr(self, "currency", None) and self.underlying_instrument:
+    def pre_save(self):
+        if self.underlying_instrument:
             self.currency = self.underlying_instrument.currency
-        if self.currency_fx_rate is None:
-            self.currency_fx_rate = self.underlying_instrument.currency.convert(
-                self.value_date, self.portfolio.currency, exact_lookup=True
-            )
+
         if self.price is not None and self.price_gross is None:
             self.price_gross = self.price
         elif self.price_gross is not None and self.price is None:
             self.price = self.price_gross
+
+    def save(self, *args, **kwargs):
+        self.pre_save()
+        if self.currency_fx_rate is None:
+            self.currency_fx_rate = self.underlying_instrument.currency.convert(
+                self.value_date, self.portfolio.currency, exact_lookup=True
+            )
         super().save(*args, **kwargs)
 
     class Meta:

wbportfolio/order_routing/__init__.py

@@ -0,0 +1,19 @@
+from django.db.models import TextChoices
+
+class ExecutionStatus(TextChoices):
+    PENDING = "PENDING", "Pending"
+    IN_DRAFT = "IN_DRAFT", "In Draft"
+    COMPLETED = "COMPLETED", "Completed"
+    CANCELLED = "CANCELLED", "Cancelled"
+    REJECTED = "REJECTED", "Rejected"
+    FAILED = "FAILED", "Failed"
+    UNKNOWN = "UNKNOWN", "Unknown"
+
+class RoutingException(Exception):
+    def __init__(self, errors):
+        # messages: a list of strings
+        super().__init__()  # You can pass a summary to the base Exception
+        self.errors = errors
+
+    def __str__(self):
+        return str(self.errors)

wbportfolio/order_routing/adapters/__init__.py

@@ -0,0 +1,57 @@
+from abc import ABC, abstractmethod
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.pms.typing import Order
+
+class BaseCustodianAdapter(ABC):
+
+    def __init__(self, isin: str, **identifiers):
+        self.isin = isin
+
+    @property
+    def errors(self):
+        if not hasattr(self, '_errors'):
+            raise ValueError("is_valid needs to call before accessing errors")
+        return
+    @abstractmethod
+    def authenticate(self) -> bool:
+        """
+        Authenticate or renew tokens with the custodian API.
+        Raises an exception if authentication fails.
+        """
+        pass
+
+    @abstractmethod
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        """
+        Return the rebalance status as a string (in the custodian format)
+        """
+        pass
+
+    @abstractmethod
+    def is_valid(self) -> bool:
+        """
+        Check whether the given isin is valid and can be rebalanced
+        """
+        pass
+
+    @abstractmethod
+    def submit_rebalancing(self, orders: list[Order], as_draft: bool = True) -> tuple[list[Order], str]:
+        """
+        Submit a rebalance order for the certificate.
+        """
+        pass
+
+    @abstractmethod
+    def cancel_current_rebalancing(self) -> bool:
+        """
+        Cancel an existing rebalance order identified by ISIN.
+        """
+        pass
+
+    @abstractmethod
+    def get_current_rebalancing(self) -> list[Order]:
+        """
+        Fetch the current rebalance request details for a certificate.
+        """
+        pass