wbportfolio 1.54.19__py2.py3-none-any.whl → 1.54.21__py2.py3-none-any.whl

wbportfolio/models/orders/orders.py

@@ -38,7 +38,13 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         help_text="The number of shares that were traded.",
         verbose_name="Shares",
     )
-
+    desired_target_weight = models.DecimalField(
+        max_digits=9,
+        decimal_places=ORDER_WEIGHTING_PRECISION,
+        default=Decimal(0),
+        help_text="Desired Target Weight (for compliance and audit)",
+        verbose_name="Desired Target Weight",
+    )
     weighting = models.DecimalField(
         max_digits=9,
         decimal_places=ORDER_WEIGHTING_PRECISION,
@@ -64,6 +70,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     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)
@@ -77,11 +84,19 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 self.shares = shares
                 if portfolio_total_asset_value:
                     self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
-
+        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
+            warnings.append(
+                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
+            )
+            self.shares = Decimal("0")
+            self.weighting = Decimal("0")
         if not self.price:
             warnings.append(f"No price for {self.underlying_instrument.computed_str}")
-        if self._target_weight < 1e-8:  # any value below -1e8 will be considered zero
+        if (
+            not self.underlying_instrument.is_cash 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
         return warnings
 
     @property
@@ -209,24 +224,6 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 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)

wbportfolio/models/portfolio.py

@@ -3,34 +3,31 @@ from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
 from math import isclose
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any, Generator, Iterable
 
 import numpy as np
 import pandas as pd
 from celery import shared_task
-from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.fields import DateRangeField
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
-from django.db.models import Case, Exists, F, OuterRef, Q, QuerySet, Sum, Value, When
-from django.db.models.functions import Coalesce
+from django.db.models import Exists, F, OuterRef, Q, QuerySet, Sum
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
-from skfolio.preprocessing import prices_to_returns
-from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.currency.models import Currency
 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.contrib.metric.tasks import compute_metrics_as_task
-from wbfdm.enums import MarketData
 from wbfdm.models import Instrument, InstrumentType
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import investable_universe_updated
 
-from wbportfolio.models.asset import AssetPosition, AssetPositionIterator
+from wbportfolio.models.asset import AssetPosition
+from wbportfolio.models.builder import AssetPositionBuilder
 from wbportfolio.models.indexes import Index
 from wbportfolio.models.portfolio_relationship import (
     InstrumentPortfolioThroughModel,
@@ -42,82 +39,14 @@ from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position as PositionDTO
 
 from . import ProductGroup
-from .exceptions import InvalidAnalyticPortfolio
 
 logger = logging.getLogger("pms")
 if TYPE_CHECKING:
-    from wbportfolio.models.orders.order_proposals import OrderProposal
+    pass
 
 MARKET_HOLIDAY_MAX_DURATION = 15
 
 
-def get_returns(
-    instrument_ids: list[int],
-    from_date: date,
-    to_date: date,
-    to_currency: Currency | None = None,
-    use_dl: bool = False,
-) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
-    """
-    Utility methods to get instrument returns for a given date range
-
-    Args:
-        from_date: date range lower bound
-        to_date: date range upper bound
-        to_currency: currency to use for returns
-        use_dl: whether to get data straight from the dataloader or use the internal table
-
-    Returns:
-        Return a tuple of the raw prices and the returns dataframe
-    """
-    if use_dl:
-        kwargs = dict(from_date=from_date, to_date=to_date, values=[MarketData.CLOSE], apply_fx_rate=False)
-        if to_currency:
-            kwargs["target_currency"] = to_currency.key
-        df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
-        if df.empty:
-            raise InvalidAnalyticPortfolio()
-        df = df[["instrument_id", "fx_rate", "close", "valuation_date"]]
-    else:
-        if to_currency:
-            fx_rate = Coalesce(
-                CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", to_currency),
-                Decimal("1"),
-            )
-        else:
-            fx_rate = Value(Decimal("1"))
-        # annotate fx rate only if the price is not calculated, in that case we assume the instrument is not tradable and we set a forex of None (to be fast forward filled)
-        prices = InstrumentPrice.objects.filter(
-            instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date
-        ).annotate(fx_rate=Case(When(calculated=False, then=fx_rate), default=None))
-        df = pd.DataFrame(
-            prices.filter_only_valid_prices().values_list("instrument", "fx_rate", "net_value", "date"),
-            columns=["instrument_id", "fx_rate", "close", "valuation_date"],
-        )
-    if df.empty:
-        raise InvalidAnalyticPortfolio()
-    df = (
-        df.pivot_table(index="valuation_date", columns="instrument_id", values=["fx_rate", "close"], dropna=False)
-        .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
-    )
-
-
 class DefaultPortfolioQueryset(QuerySet):
     def filter_invested_at_date(self, val_date: date) -> QuerySet:
         """
@@ -217,6 +146,7 @@ class PortfolioPortfolioThroughModel(models.Model):
 
 class Portfolio(DeleteToDisableMixin, WBModel):
     assets: models.QuerySet[AssetPosition]
+    builder: AssetPositionBuilder
 
     name = models.CharField(
         max_length=255,
@@ -305,6 +235,10 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     objects = DefaultPortfolioManager()
     tracked_objects = ActiveTrackedPortfolioManager()
 
+    def __init__(self, *args, **kwargs):
+        self.builder = AssetPositionBuilder(self)
+        super().__init__(*args, **kwargs)
+
     @property
     def primary_portfolio(self):
         with suppress(PortfolioPortfolioThroughModel.DoesNotExist):
@@ -358,7 +292,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         try:
             last_returns, _ = self.get_analytic_portfolio(val_date, use_dl=True).get_contributions()
             last_returns = last_returns.to_dict()
-        except InvalidAnalyticPortfolio:
+        except ValueError:
             last_returns = {}
         positions = []
         for asset in assets:
@@ -387,7 +321,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         )
 
     def get_analytic_portfolio(
-        self, val_date: date, weights: dict[int, float] | None = None, use_dl: bool = False, **kwargs
+        self, val_date: date, weights: dict[int, float] | None = None, use_dl: bool = True, **kwargs
     ) -> AnalyticPortfolio:
         """
         Return the analytic portfolio associated with this portfolio at the given date
@@ -402,16 +336,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if not weights:
             weights = self.get_weights(val_date)
         return_date = (val_date + BDay(1)).date()
-        _, returns = get_returns(
-            list(weights.keys()),
-            (val_date - BDay(MARKET_HOLIDAY_MAX_DURATION)).date(),
-            return_date,
-            to_currency=self.currency,
-            use_dl=use_dl,
-            **kwargs,
-        )
+        returns = self.builder.returns
+        if 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)
         if pd.Timestamp(return_date) not in returns.index:
-            raise InvalidAnalyticPortfolio()
+            raise ValueError()
+        returns = returns.loc[:return_date, :]
         returns = returns.fillna(0)  # not sure this is what we want
         return AnalyticPortfolio(
             X=returns,
@@ -712,7 +642,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         recompute_weighting: bool = False,
         force_recompute_weighting: bool = False,
         evaluate_rebalancer: bool = True,
-        changed_weights: dict[int, float] | None = None,
+        changed_portfolio: AnalyticPortfolio | None = None,
         broadcast_changes_at_date: bool = True,
         **kwargs,
     ):
@@ -743,7 +673,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
         # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
         self.estimate_net_asset_values(
-            (val_date + BDay(1)).date(), weights=changed_weights
+            (val_date + BDay(1)).date(), analytic_portfolio=changed_portfolio
         )  # updating weighting in t0 influence nav in t+1
         if evaluate_rebalancer:
             self.evaluate_rebalancing(val_date)
@@ -760,7 +690,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 val_date,
                 recompute_weighting=recompute_weighting,
                 force_recompute_weighting=force_recompute_weighting,
-                changed_weights=changed_weights,
+                changed_portfolio=changed_portfolio,
                 **kwargs,
             )
 
@@ -771,7 +701,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 type=PortfolioPortfolioThroughModel.Type.PRIMARY,
                 portfolio__is_lookthrough=True,
             ):
-                rel.portfolio.compute_lookthrough(val_date, **kwargs)
+                rel.portfolio.compute_lookthrough(val_date)
             for rel in PortfolioPortfolioThroughModel.objects.filter(
                 dependency_portfolio=self, type=PortfolioPortfolioThroughModel.Type.MODEL
             ):
@@ -791,97 +721,102 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 logger.info(f"Evaluate Rebalancing for {self} at {next_business_date}")
                 self.automatic_rebalancer.evaluate_rebalancing(next_business_date)
 
-    def estimate_net_asset_values(self, val_date: date, weights: dict[int | float] | None = None):
-        for instrument in self.pms_instruments:
-            if instrument.is_active_at_date(val_date) and (
-                net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path
-            ):
-                logger.info(f"Estimate NAV of {val_date:%Y-%m-%d} for instrument {instrument}")
-                net_asset_value_computation_method = import_from_dotted_path(net_asset_value_computation_method_path)
-                estimated_net_asset_value = net_asset_value_computation_method(val_date, instrument, weights=weights)
-                if estimated_net_asset_value is not None:
-                    InstrumentPrice.objects.update_or_create(
-                        instrument=instrument,
-                        date=val_date,
-                        calculated=True,
-                        defaults={
-                            "gross_value": estimated_net_asset_value,
-                            "net_value": estimated_net_asset_value,
-                        },
+    def estimate_net_asset_values(self, val_date: date, analytic_portfolio: AnalyticPortfolio | None = None):
+        effective_portfolio_date = (val_date - BDay(1)).date()
+        with suppress(ValueError):
+            if not analytic_portfolio:
+                analytic_portfolio = self.get_analytic_portfolio(effective_portfolio_date)
+            for instrument in self.pms_instruments:
+                # we assume that in t-1 we will have a portfolio (with at least estimate position). If we use the latest position date before val_date, we run into the problem of being able to compute nav at every date
+                last_price = instrument.get_latest_price(effective_portfolio_date)
+                if (
+                    instrument.is_active_at_date(val_date)
+                    and (net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path)
+                    and last_price
+                ):
+                    logger.info(f"Estimate NAV of {val_date:%Y-%m-%d} for instrument {instrument}")
+                    net_asset_value_computation_method = import_from_dotted_path(
+                        net_asset_value_computation_method_path
                     )
-                    if (
-                        val_date == instrument.last_price_date
-                    ):  # if price date is the latest instrument price date, we recompute the last valuation data
-                        instrument.update_last_valuation_date()
+                    estimated_net_asset_value = net_asset_value_computation_method(last_price, analytic_portfolio)
+                    if estimated_net_asset_value is not None:
+                        InstrumentPrice.objects.update_or_create(
+                            instrument=instrument,
+                            date=val_date,
+                            calculated=True,
+                            defaults={
+                                "gross_value": estimated_net_asset_value,
+                                "net_value": estimated_net_asset_value,
+                            },
+                        )
+                        if (
+                            val_date == instrument.last_price_date
+                        ):  # if price date is the latest instrument price date, we recompute the last valuation data
+                            instrument.update_last_valuation_date()
 
     def drift_weights(
         self, start_date: date, end_date: date, stop_at_rebalancing: bool = False
-    ) -> tuple[AssetPositionIterator, "OrderProposal"]:
+    ) -> Generator[tuple[date, dict[int, float]], None, models.Model]:
         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
         weights = self.get_weights(start_date)  # initial weights
         if not weights:
             previous_date = self.assets.filter(date__lte=start_date).latest("date").date
-            drifted_positions, _ = self.drift_weights(previous_date, start_date)
-            weights = drifted_positions.get_weights()[start_date]
-
-        # Get returns and prices data for the whole date range
-        instrument_ids = list(weights.keys())
-
-        prices, returns = get_returns(
-            instrument_ids,
-            (start_date - BDay(MARKET_HOLIDAY_MAX_DURATION)).date(),
-            end_date,
-            to_currency=self.currency,
-            use_dl=True,
-        )
-        # Get raw prices to speed up asset position creation
-        # Instantiate the position iterator with the initial weights
-        positions = AssetPositionIterator(self, prices=prices)
+            _, 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()
             to_is_active = self.is_active_at_date(to_date)
             logger.info(f"Processing {to_date:%Y-%m-%d}")
-
+            order_proposal = None
             try:
-                last_returns = returns.loc[[to_date_ts], :]
+                last_returns = self.builder.returns.loc[[to_date_ts], :]
                 analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
                 drifted_weights = analytic_portfolio.get_next_weights()
             except KeyError:  # if no return for that date, we break and continue
-                drifted_weights = weights
-            if rebalancer and rebalancer.is_valid(to_date):
-                effective_portfolio = PortfolioDTO(
-                    positions=[
-                        PositionDTO(
-                            date=to_date,
-                            underlying_instrument=i,
-                            weighting=Decimal(w),
-                            daily_return=Decimal(last_returns.iloc[-1][i]),
-                        )
-                        for i, w in weights.items()
-                    ]
+                break
+            try:
+                order_proposal = self.order_proposals.get(
+                    trade_date=to_date, rebalancing_model__isnull=True, status="APPROVED"
                 )
-                last_order_proposal = rebalancer.evaluate_rebalancing(to_date, effective_portfolio=effective_portfolio)
+            except ObjectDoesNotExist:
+                if rebalancer and rebalancer.is_valid(to_date):
+                    effective_portfolio = PortfolioDTO(
+                        positions=[
+                            PositionDTO(
+                                date=to_date,
+                                underlying_instrument=i,
+                                weighting=Decimal(w),
+                                daily_return=Decimal(last_returns.iloc[-1][i]),
+                            )
+                            for i, w in weights.items()
+                        ]
+                    )
+                    order_proposal = rebalancer.evaluate_rebalancing(to_date, effective_portfolio=effective_portfolio)
+            if order_proposal:
+                last_order_proposal = order_proposal
                 if stop_at_rebalancing:
                     break
                 next_weights = {
                     trade.underlying_instrument.id: float(trade._target_weight)
-                    for trade in last_order_proposal.get_orders()
+                    for trade in order_proposal.get_orders()
                 }
-                positions.add((to_date, next_weights), is_estimated=False)
+                yield to_date, next_weights
             else:
                 next_weights = drifted_weights
                 if to_is_active:
-                    positions.add((to_date, next_weights))
+                    yield to_date, next_weights
                 else:
-                    positions.add(
-                        (to_date, {underlying_quote_id: 0.0 for underlying_quote_id in weights.keys()})
+                    yield (
+                        to_date,
+                        {underlying_quote_id: 0.0 for underlying_quote_id in weights.keys()},
                     )  # if we have no return or portfolio is not active anymore, we return an emptied portfolio
                     break
             weights = next_weights
-        return positions, last_order_proposal
+        return last_order_proposal
 
     def propagate_or_update_assets(self, from_date: date, to_date: date):
         """
@@ -897,10 +832,19 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if (
             not self.is_lookthrough and not is_target_portfolio_imported and self.is_active_at_date(from_date)
         ):  # we cannot propagate a new portfolio for untracked, or look-through or already imported or inactive portfolios
-            positions, _ = self.drift_weights(from_date, to_date)
-            self.bulk_create_positions(
-                positions, delete_leftovers=True, compute_metrics=True, evaluate_rebalancer=False
-            )
+            self.load_builder_returns(from_date, to_date)
+            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_metric_computation()
+
+    def load_builder_returns(self, from_date: date, to_date: date) -> 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"):
+            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())
+        return self.builder.returns
 
     def get_lookthrough_positions(
         self,
@@ -970,12 +914,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             assets = list(self.assets.filter(date=val_date))
         return assets
 
-    def compute_lookthrough(self, from_date: date, to_date: date | None = None, **kwargs):
+    def compute_lookthrough(self, from_date: date, to_date: date | None = None):
         if not self.primary_portfolio or not self.is_lookthrough:
             raise ValueError(
                 "Lookthrough position can only be computed on lookthrough portfolio with a primary portfolio"
             )
-        positions = AssetPositionIterator(self)
         if not to_date:
             to_date = from_date
         for from_date in pd.date_range(from_date, to_date, freq="B").date:
@@ -983,10 +926,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             portfolio_total_asset_value = (
                 self.primary_portfolio.get_total_asset_under_management(from_date) if not self.only_weighting else None
             )
-            positions.add(
+            self.builder.add(
                 list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
             )
-        self.bulk_create_positions(positions, delete_leftovers=True, **kwargs)
+        self.builder.bulk_create_positions(delete_leftovers=True)
+        self.builder.schedule_change_at_dates(evaluate_rebalancer=False)
+        self.builder.schedule_metric_computation()
 
     def update_preferred_classification_per_instrument(self):
         # Function to automatically assign Preferred instrument based on the assets' underlying instruments of the
@@ -1043,64 +988,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def get_representation_label_key(cls):
         return "{{name}}"
 
-    def bulk_create_positions(
-        self,
-        positions: AssetPositionIterator,
-        delete_leftovers: bool = False,
-        force_save: bool = False,
-        compute_metrics: bool = False,
-        **kwargs,
-    ):
-        if positions:
-            # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
-            # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
-            # change completely the trades of a portfolio model and drift it.
-
-            dates = positions.get_dates()
-            self.assets.filter(date__in=dates, is_estimated=True).delete()
-
-            if self.is_tracked or force_save:  # if the portfolio is not "tracked", we do no drift weights
-                leftover_positions_ids = list(
-                    self.assets.filter(date__in=dates).values_list("id", flat=True)
-                )  # we need to get the ids otherwise the queryset is reevaluated later
-                positions_list = list(positions)
-                logger.info(
-                    f"bulk saving {len(positions_list)} positions ({len(leftover_positions_ids)} leftovers) ..."
-                )
-                objs = AssetPosition.unannotated_objects.bulk_create(
-                    positions_list,
-                    update_fields=[
-                        "weighting",
-                        "initial_price",
-                        "initial_currency_fx_rate",
-                        "initial_shares",
-                        "currency_fx_rate_instrument_to_usd",
-                        "currency_fx_rate_portfolio_to_usd",
-                        "underlying_quote_price",
-                        "portfolio",
-                        "portfolio_created",
-                        "underlying_instrument",
-                    ],
-                    unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
-                    update_conflicts=True,
-                    batch_size=10000,
-                )
-                if delete_leftovers:
-                    objs_ids = list(map(lambda x: x.id, objs))
-                    leftover_positions_ids = list(filter(lambda i: i not in objs_ids, leftover_positions_ids))
-                    logger.info(f"deleting {len(leftover_positions_ids)} leftover positions..")
-                    AssetPosition.objects.filter(id__in=leftover_positions_ids).delete()
-            if compute_metrics and self.is_tracked:
-                for val_date in dates:
-                    compute_metrics_as_task.delay(
-                        val_date,
-                        basket_id=self.id,
-                        basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id,
-                    )
-            for update_date, changed_weights in positions.get_weights().items():
-                kwargs.pop("changed_weights", None)
-                self.change_at_date(update_date, changed_weights=changed_weights, **kwargs)
-
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):
         if isinstance(portfolio_data, int):
@@ -1253,20 +1140,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return portfolio
 
 
-def default_estimate_net_value(
-    val_date: date, instrument: Instrument, weights: dict[int, float] | None = None
-) -> float | None:
-    portfolio: Portfolio = instrument.portfolio
-    previous_val_date = (val_date - BDay(1)).date()
-    if not weights:
-        weights = portfolio.get_weights(previous_val_date)
-    # we assume that in t-1 we will have a portfolio (with at least estimate position). If we use the latest position date before val_date, we run into the problem of being able to compute nav at every date
-    if weights and (last_price := instrument.get_latest_price(previous_val_date)):
-        with suppress(
-            IndexError, InvalidAnalyticPortfolio
-        ):  # we silent any indexerror introduced by no returns for the past days
-            analytic_portfolio = portfolio.get_analytic_portfolio(previous_val_date, weights=weights)
-            return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
+def default_estimate_net_value(last_price: Decimal, analytic_portfolio: AnalyticPortfolio) -> float | None:
+    with suppress(IndexError, ValueError):  # we silent any indexerror introduced by no returns for the past days
+        return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
 @receiver(post_save, sender="wbportfolio.PortfolioPortfolioThroughModel")

wbportfolio/serializers/orders/order_proposals.py

@@ -92,6 +92,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
             "total_cash_weight",
             "comment",
             "status",
+            "min_order_value",
             "portfolio",
             "_rebalancing_model",
             "rebalancing_model",

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -383,7 +383,7 @@ class TestOrderProposal:
         """
         Ensure replaying order proposals correctly calls drift_weights for each period.
         """
-        mock_fct.return_value = None, None
+        mock_fct.return_value = iter([])
 
         # Create approved order proposals for testing
         tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPROVED)
@@ -672,3 +672,18 @@ class TestOrderProposal:
         assert Order.objects.get(
             order_proposal=draft_tp, underlying_instrument=trade.underlying_instrument
         ).weighting == Decimal("0")
+
+    def test_order_submit_bellow_minimum_allowed_order_value(self, order_factory):
+        order = order_factory.create(price=Decimal(1), weighting=Decimal(1), shares=Decimal(999))
+        order.submit()
+        order.save()
+        assert order.shares == Decimal(999)
+        assert order.weighting == Decimal(1)
+
+        order.order_proposal.min_order_value = Decimal(1000)
+        order.order_proposal.save()
+
+        order.submit()
+        order.save()
+        assert order.shares == Decimal(0)
+        assert order.weighting == Decimal(0)