wbportfolio 1.52.5__py2.py3-none-any.whl → 1.52.6__py2.py3-none-any.whl

wbportfolio/models/asset.py

@@ -708,7 +708,7 @@ class AssetPosition(ImportMixin, models.Model):
             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

wbportfolio/models/portfolio.py

@@ -926,7 +926,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if self.is_composition:
             assets = list(self.get_lookthrough_positions(val_date, **kwargs))
         else:
-            assets = self.assets.filter(date=val_date)
+            assets = list(self.assets.filter(date=val_date))
         return assets
 
     def compute_lookthrough(self, from_date: date, to_date: date | None = None):

wbportfolio/models/transactions/trade_proposals.py

@@ -2,10 +2,9 @@ import logging
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from celery import shared_task
-from django.contrib.messages import error, info
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.functional import cached_property
@@ -92,14 +91,14 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         super().save(*args, **kwargs)
 
-    @property
-    def checked_object(self):
-        return self.portfolio
-
     @property
     def check_evaluation_date(self):
         return self.trade_date
 
+    @property
+    def checked_object(self) -> Any:
+        return self.portfolio
+
     @cached_property
     def portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.last_effective_date)
@@ -109,10 +108,13 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         This property holds the validated trading services and cache it.This property expect to be set only if is_valid return True
         """
+        target_portfolio = self._build_dto().convert_to_portfolio()
+
         return TradingService(
             self.trade_date,
             effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
-            target_portfolio=self._build_dto().convert_to_portfolio(),
+            target_portfolio=target_portfolio,
+            total_target_weight=target_portfolio.total_weight,
         )
 
     @cached_property
@@ -197,25 +199,30 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return trade_proposal_clone
 
-    def normalize_trades(self):
+    def normalize_trades(self, total_target_weight: Decimal = Decimal("1.0")):
         """
         Call the trading service with the existing trades and normalize them in order to obtain a total sum target weight of 100%
         The existing trade will be modified directly with the given normalization factor
         """
-        service = TradingService(self.trade_date, trades_batch=self._build_dto())
-        service.normalize()
+        service = TradingService(
+            self.trade_date,
+            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            target_portfolio=self._build_dto().convert_to_portfolio(),
+            total_target_weight=total_target_weight,
+        )
         leftovers_trades = self.trades.all()
-        total_target_weight = Decimal("0.0")
         for underlying_instrument_id, trade_dto in service.trades_batch.trades_map.items():
             with suppress(Trade.DoesNotExist):
                 trade = self.trades.get(underlying_instrument_id=underlying_instrument_id)
                 trade.weighting = round(trade_dto.delta_weight, 6)
                 trade.save()
-                total_target_weight += trade._target_weight
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
         leftovers_trades.delete()
+        t_weight = self.trades.all().annotate_base_info().aggregate(models.Sum("target_weight"))[
+            "target_weight__sum"
+        ] or Decimal("0.0")
         # we handle quantization error due to the decimal max digits. In that case, we take the biggest trade (highest weight) and we remove the quantization error
-        if quantize_error := (total_target_weight - Decimal("1.0")):
+        if quantize_error := (t_weight - total_target_weight):
             biggest_trade = self.trades.latest("weighting")
             biggest_trade.weighting -= quantize_error
             biggest_trade.save()
@@ -234,7 +241,12 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
 
-    def reset_trades(self, target_portfolio: PortfolioDTO | None = None, validate_trade: bool = True):
+    def reset_trades(
+        self,
+        target_portfolio: PortfolioDTO | None = None,
+        validate_trade: bool = True,
+        total_target_weight: Decimal = Decimal("1.0"),
+    ):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
@@ -249,6 +261,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 self.trade_date,
                 effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
+                total_target_weight=total_target_weight,
             )
             if validate_trade:
                 service.is_valid()
@@ -279,6 +292,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         status=Trade.Status.DRAFT,
                         currency_fx_rate=currency_fx_rate,
                     )
+                trade.price = trade.get_price()
+                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                if trade.price is None:
+                    trade.price = Decimal("0.0")
+                    trade.weighting = -trade_dto.effective_weight
                 trade.save()
 
     def replay(self):
@@ -329,7 +347,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 last_trade_proposal_created = False
                 last_trade_proposal = next_trade_proposal
 
-    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal:
+    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument, quote_price: Decimal) -> Decimal:
         """
         Estimates the number of shares for a trade based on the given weight and underlying quote.
 
@@ -342,23 +360,19 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         Returns:
             Decimal | None: The estimated number of shares or None if the calculation fails.
         """
-        try:
-            # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
-            quote_price = Decimal(underlying_quote.get_price(self.trade_date))
+        # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
 
-            # Calculate the trade's total value in the portfolio's currency
-            trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
+        # Calculate the trade's total value in the portfolio's currency
+        trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
 
-            # Convert the quote price to the portfolio's currency
-            price_fx_portfolio = quote_price * underlying_quote.currency.convert(
-                self.trade_date, self.portfolio.currency, exact_lookup=False
-            )
+        # Convert the quote price to the portfolio's currency
+        price_fx_portfolio = quote_price * underlying_quote.currency.convert(
+            self.trade_date, self.portfolio.currency, exact_lookup=False
+        )
 
-            # If the price is valid, calculate and return the estimated shares
-            if price_fx_portfolio:
-                return trade_total_value_fx_portfolio / price_fx_portfolio
-        except Exception:
-            raise ValueError("We couldn't estimate the number of shares")
+        # If the price is valid, calculate and return the estimated shares
+        if price_fx_portfolio:
+            return trade_total_value_fx_portfolio / price_fx_portfolio
 
     def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
@@ -399,7 +413,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
             # Estimate the target shares for the cash component
             with suppress(ValueError):
-                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component, Decimal("1.0"))
 
         cash_component = Cash.objects.get_or_create(
             currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
@@ -447,46 +461,23 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         trades = []
-        trades_validation_errors = []
+        trades_validation_warnings = []
         for trade in self.trades.all():
-            if not trade.last_underlying_quote_price:
-                trade.status = Trade.Status.FAILED
-                trades_validation_errors.append(
-                    f"Trade failed because no price is found for {trade.underlying_instrument.computed_str} on {trade.transaction_date:%Y-%m-%d}"
-                )
-            else:
-                trade.status = Trade.Status.SUBMIT
+            trade_warnings = trade.submit(by=by, description=description, **kwargs)
+            if trade_warnings:
+                trades_validation_warnings.extend(trade_warnings)
             trades.append(trade)
 
-        Trade.objects.bulk_update(trades, ["status"])
+        Trade.objects.bulk_update(trades, ["status", "shares", "weighting"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
-        target_portfolio = self.validated_trading_service.target_portfolio
-        if estimated_cash_position.weighting:
-            if existing_cash_position := target_portfolio.positions_map.get(
-                estimated_cash_position.underlying_quote.id
-            ):
-                existing_cash_position += estimated_cash_position
-            else:
-                target_portfolio.positions_map[estimated_cash_position.underlying_quote.id] = (
-                    estimated_cash_position._build_dto()
-                )
-            target_portfolio = PortfolioDTO(positions=tuple(target_portfolio.positions_map.values()))
+        target_portfolio = self.validated_trading_service.trades_batch.convert_to_portfolio(
+            estimated_cash_position._build_dto()
+        )
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
-
-        if (
-            trades_validation_errors
-            and (fsm_context := getattr(self, "fsm_context", None))
-            and (request := fsm_context.get("request", None))
-        ):
-            msg = f"""The reason for the failed trades are: <ul>
-            {''.join(map(lambda o: '<li>' + o + '</li>', trades_validation_errors))}
-            </ul>
-            """
-            error(request, msg, extra_tags="auto_close=0")
+        return trades_validation_warnings
 
     def can_submit(self):
         errors = dict()
@@ -496,7 +487,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         service = self.validated_trading_service
         try:
             service.is_valid(ignore_error=True)
-            # if service.trades_batch.totat_abs_delta_weight == 0:
+            # if service.trades_batch.total_abs_delta_weight == 0:
             #     errors_list.append(
             #         "There is no change detected in this trade proposal. Please submit at last one valid trade"
             #     )
@@ -542,6 +533,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
         trades = []
         assets = []
+        warnings = []
         # We do not want to create the estimated cash position if there is not trades in the trade proposal (shouldn't be possible anyway)
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
 
@@ -556,13 +548,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         # if there is cash leftover, we create an extra asset position to hold the cash component
         if estimated_cash_position.weighting and len(trades) > 0:
+            warnings.append(
+                f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}"
+            )
             estimated_cash_position.pre_save()
             assets.append(estimated_cash_position)
-            if (fsm_context := getattr(self, "fsm_context", None)) and (request := fsm_context.get("request", None)):
-                info(
-                    request,
-                    f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}",
-                )
 
         Trade.objects.bulk_update(trades, ["status"])
         self.portfolio.bulk_create_positions(
@@ -570,6 +560,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         )
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id, user_id=by.id if by else None)
+        return warnings
 
     def can_approve(self):
         errors = dict()

wbportfolio/models/transactions/trades.py

@@ -249,9 +249,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         field=status,
         source=Status.DRAFT,
         target=GET_STATE(
-            lambda self, **kwargs: (
-                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
-            ),
+            lambda self, **kwargs: (self.Status.SUBMIT if self.price else self.Status.FAILED),
             states=[Status.SUBMIT, Status.FAILED],
         ),
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
@@ -271,7 +269,12 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        pass
+        errors = []
+        if not self.price:
+            errors.append(
+                f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
+            )
+        return errors
 
     def can_submit(self):
         pass
@@ -287,6 +290,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def fail(self, **kwargs):
         pass
 
+    # TODO To be removed
     @cached_property
     def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
@@ -343,7 +347,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             )
 
     def can_execute(self):
-        if not self.last_underlying_quote_price:
+        if not self.price:
             return {"underlying_instrument": [_("Cannot execute a trade without a valid quote price")]}
         if not self.portfolio.is_manageable:
             return {
@@ -531,19 +535,22 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     def save(self, *args, **kwargs):
         if self.trade_proposal:
+            if not self.underlying_instrument.is_investable_universe:
+                self.underlying_instrument.is_investable_universe = True
+                self.underlying_instrument.save()
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-            if not self.portfolio.only_weighting:
-                with suppress(ValueError):
-                    self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
+        if self.price is None:
+            # we try to get the price if not provided directly from the underlying instrument
+            self.price = self.get_price()
+        if self.trade_proposal and not self.portfolio.only_weighting:
+            self.shares = self.trade_proposal.get_estimated_shares(
+                self.weighting, self.underlying_instrument, self.price
+            )
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
-        if self.price is None:
-            # we try to get the price if not provided directly from the underlying instrument
-            with suppress(Exception):
-                self.price = self.underlying_instrument.get_price(self.value_date)
 
         if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
@@ -588,9 +595,6 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         """
 
     def get_asset(self) -> AssetPosition:
-        last_underlying_quote_price = self.last_underlying_quote_price
-        if not last_underlying_quote_price:
-            raise ValueError("No price found")
         asset = AssetPosition(
             underlying_quote=self.underlying_instrument,
             portfolio_created=None,
@@ -598,9 +602,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             date=self.transaction_date,
             initial_currency_fx_rate=self.currency_fx_rate,
             weighting=self._target_weight,
-            initial_price=self.last_underlying_quote_price.net_value,
+            initial_price=self.price,
             initial_shares=None,
-            underlying_quote_price=self.last_underlying_quote_price,
             asset_valuation_date=self.transaction_date,
             currency=self.currency,
             is_estimated=False,
@@ -609,6 +612,11 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         asset.pre_save()
         return asset
 
+    def get_price(self) -> Decimal | None:
+        if self.value_date:
+            with suppress(ValueError):
+                return Decimal(self.underlying_instrument.get_price(self.value_date))
+
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)
         super().delete(**kwargs)
@@ -631,6 +639,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             instrument_type=self.underlying_instrument.security_instrument_type.id,
             currency=self.underlying_instrument.currency,
             date=self.transaction_date,
+            is_cash=self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent,
         )
 
     def get_alternative_valid_trades(self, share_delta: float = 0):

wbportfolio/pms/trading/handler.py

@@ -17,25 +17,20 @@ class TradingService:
         trade_date: date,
         effective_portfolio: Portfolio | None = None,
         target_portfolio: Portfolio | None = None,
-        trades_batch: TradeBatch | None = None,
-        total_value: Decimal = None,
+        total_target_weight: Decimal = Decimal("1.0"),
     ):
-        self.total_value = total_value
         self.trade_date = trade_date
         if target_portfolio is None:
             target_portfolio = Portfolio(positions=())
         if effective_portfolio is None:
             effective_portfolio = Portfolio(positions=())
-        # If effective portfoolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
-        trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio, trades_batch=trades_batch)
-        # if no trade but a effective portfolio is provided, we get the trade batch only from the effective portofolio (and the target portfolio if provided, but optional. Without it, the trade delta weight will be 0 )
-        # Finally, we compute the target portfolio
-        if trades_batch and not target_portfolio:
-            target_portfolio = trades_batch.convert_to_portfolio()
+        # If effective portfolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
+        self.trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio).normalize(
+            total_target_weight
+        )
 
-        self.trades_batch = trades_batch
-        self.effective_portfolio = effective_portfolio
-        self.target_portfolio = target_portfolio
+        self._effective_portfolio = effective_portfolio
+        self._target_portfolio = target_portfolio
 
     @property
     def errors(self) -> list[str]:
@@ -62,12 +57,11 @@ class TradingService:
         Test the given value against all the validators on the field,
         and either raise a `ValidationError` or simply return.
         """
-        # TradeBatch(validated_trades).validate()
-        if self.effective_portfolio:
+        if self._effective_portfolio:
             for trade in validated_trades:
                 if (
                     trade.effective_weight
-                    and trade.underlying_instrument not in self.effective_portfolio.positions_map
+                    and trade.underlying_instrument not in self._effective_portfolio.positions_map
                 ):
                     raise ValidationError("All effective position needs to be matched with a validated trade")
 
@@ -75,7 +69,6 @@ class TradingService:
         self,
         effective_portfolio: Portfolio,
         target_portfolio: Portfolio,
-        trades_batch: TradeBatch | None = None,
     ) -> TradeBatch:
         """
         Given combination of effective portfolio and either a trades batch or a target portfolio, ensure all theres variables are set
@@ -87,39 +80,35 @@ class TradingService:
 
         Returns: The normalized trades batch
         """
-        instruments = list(effective_portfolio.positions_map.keys())
-        instruments.extend(list(target_portfolio.positions_map.keys()))
-        if trades_batch:
-            instruments.extend(list(trades_batch.trades_map.keys()))
-        _trades: list[Trade] = []
-        for instrument in set(instruments):
-            effective_weight = target_weight = 0
-            effective_shares = 0
-            instrument_type = currency = None
-            if effective_pos := effective_portfolio.positions_map.get(instrument, None):
-                effective_weight = effective_pos.weighting
-                effective_shares = effective_pos.shares
-                instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
-            if target_pos := target_portfolio.positions_map.get(instrument, None):
-                target_weight = target_pos.weighting
-                instrument_type, currency = target_pos.instrument_type, target_pos.currency
-            if trades_batch and (trade := trades_batch.trades_map.get(instrument, None)):
-                effective_weight, target_weight = trade.effective_weight, trade.target_weight
-                effective_shares = trade.effective_shares
-                instrument_type, currency = trade.instrument_type, trade.currency
-
-            _trades.append(
-                Trade(
-                    underlying_instrument=instrument,
-                    effective_weight=effective_weight,
-                    target_weight=target_weight,
-                    effective_shares=effective_shares,
-                    date=self.trade_date,
-                    instrument_type=instrument_type,
-                    currency=currency,
+        instruments = effective_portfolio.positions_map.copy()
+        instruments.update(target_portfolio.positions_map)
+
+        trades: list[Trade] = []
+        for instrument_id, pos in instruments.items():
+            if not pos.is_cash:
+                effective_weight = target_weight = 0
+                effective_shares = 0
+                instrument_type = currency = None
+                if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
+                    effective_weight = effective_pos.weighting
+                    effective_shares = effective_pos.shares
+                    instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
+                if target_pos := target_portfolio.positions_map.get(instrument_id, None):
+                    target_weight = target_pos.weighting
+                    instrument_type, currency = target_pos.instrument_type, target_pos.currency
+
+                trades.append(
+                    Trade(
+                        underlying_instrument=instrument_id,
+                        effective_weight=effective_weight,
+                        target_weight=target_weight,
+                        effective_shares=effective_shares,
+                        date=self.trade_date,
+                        instrument_type=instrument_type,
+                        currency=currency,
+                    )
                 )
-            )
-        return TradeBatch(tuple(_trades))
+        return TradeBatch(tuple(trades))
 
     def is_valid(self, ignore_error: bool = False) -> bool:
         """
@@ -151,11 +140,3 @@ class TradingService:
                 raise ValidationError(self.errors)
 
         return not bool(self._errors)
-
-    def normalize(self):
-        """
-        Normalize the instantiate trades batch so that the target weight is 100%
-        """
-        self.trades_batch = TradeBatch(
-            [trade.normalize_target(self.trades_batch.total_target_weight) for trade in self.trades_batch.trades]
-        )

wbportfolio/pms/typing.py

@@ -48,7 +48,7 @@ class Position:
 @dataclass(frozen=True)
 class Portfolio:
     positions: tuple[Position] | tuple
-    positions_map: dict[Position] = field(init=False, repr=False)
+    positions_map: dict[int, Position] = field(init=False, repr=False)
 
     def __post_init__(self):
         positions_map = {}
@@ -80,7 +80,7 @@ class Portfolio:
 @dataclass(frozen=True)
 class Trade:
     underlying_instrument: int
-    instrument_type: str
+    instrument_type: int
     currency: int
     date: date_lib
 
@@ -88,6 +88,7 @@ class Trade:
     target_weight: Decimal
     id: int | None = None
     effective_shares: Decimal = None
+    is_cash: bool = False
 
     def __add__(self, other):
         return Trade(
@@ -121,9 +122,9 @@ class Trade:
         # if self.target_weight < 0 or self.target_weight > 1.0:
         #     raise ValidationError("Target Weight needs to be in range [0, 1]")
 
-    def normalize_target(self, total_target_weight: Decimal):
+    def normalize_target(self, factor: Decimal):
         t = Trade(
-            target_weight=self.target_weight / total_target_weight if total_target_weight else self.target_weight,
+            target_weight=self.target_weight * factor,
             **{f.name: getattr(self, f.name) for f in fields(Trade) if f.name not in ["target_weight"]},
         )
         return t
@@ -145,15 +146,15 @@ class TradeBatch:
 
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades]), 6)
+        return round(sum([trade.target_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades]), 6)
+        return round(sum([trade.effective_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
-    def totat_abs_delta_weight(self) -> Decimal:
-        return sum([abs(trade.delta_weight) for trade in self.trades])
+    def total_abs_delta_weight(self) -> Decimal:
+        return sum([abs(trade.delta_weight) for trade in self.trades], Decimal("0"))
 
     def __add__(self, other):
         return TradeBatch(tuple(self.trades + other.trades))
@@ -165,7 +166,7 @@ class TradeBatch:
         if round(float(self.total_target_weight), 4) != 1:  # we do that to remove decimal over precision
             raise ValidationError(f"Total Weight cannot be different than 1 ({float(self.total_target_weight)})")
 
-    def convert_to_portfolio(self):
+    def convert_to_portfolio(self, *extra_positions):
         positions = []
         for instrument, trade in self.trades_map.items():
             positions.append(
@@ -175,6 +176,23 @@ class TradeBatch:
                     weighting=trade.target_weight,
                     currency=trade.currency,
                     date=trade.date,
+                    is_cash=trade.is_cash,
                 )
             )
+        for position in extra_positions:
+            if position.weighting:
+                positions.append(position)
         return Portfolio(tuple(positions))
+
+    def normalize(self, total_target_weight: Decimal = Decimal("1.0")):
+        """
+        Normalize the instantiate trades batch so that the target weight is 100%
+        """
+        normalization_factor = (
+            total_target_weight / self.total_target_weight if self.total_target_weight else Decimal("0.0")
+        )
+        normalized_trades = []
+        for trade in self.trades:
+            normalized_trades.append(trade.normalize_target(normalization_factor))
+        tb = TradeBatch(normalized_trades)
+        return tb

wbportfolio/rebalancing/models/model_portfolio.py

@@ -16,25 +16,22 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
 
     @property
     def model_portfolio(self):
-        if model_portfolio_rel := self.model_portfolio_rel:
-            return model_portfolio_rel.dependency_portfolio
+        return self.model_portfolio_rel.dependency_portfolio if self.model_portfolio_rel else None
+
+    @property
+    def assets(self):
+        return self.model_portfolio.get_positions(self.last_effective_date) if self.model_portfolio else []
 
     def is_valid(self) -> bool:
-        if model_portfolio := self.model_portfolio:
-            assets = model_portfolio.get_positions(self.last_effective_date)
-            return (
-                assets.exists()
-                and InstrumentPrice.objects.filter(
-                    date=self.trade_date, instrument__in=assets.values("underlying_quote")
-                ).exists()
-            )
-        return False
+        instruments = list(map(lambda o: o.underlying_quote, self.assets))
+        return (
+            len(self.assets) > 0
+            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=instruments).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        assets = self.model_portfolio.get_positions(self.last_effective_date)
-
-        for asset in assets:
+        for asset in self.assets:
             asset.date = self.trade_date
             asset.asset_valuation_date = self.trade_date
             positions.append(asset._build_dto())

wbportfolio/serializers/transactions/trade_proposals.py

@@ -1,3 +1,5 @@
+from decimal import Decimal
+
 from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
@@ -16,6 +18,17 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
+    total_cash_weight = wb_serializers.DecimalField(
+        default=0,
+        decimal_places=4,
+        max_digits=5,
+        write_only=True,
+        required=False,
+        precision=4,
+        percent=True,
+        label="Target Cash",
+        help_text="Enter the desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
+    )
 
     trade_date = wb_serializers.DateField(
         read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
@@ -23,6 +36,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
 
     def create(self, validated_data):
         target_portfolio = validated_data.pop("target_portfolio", None)
+        total_cash_weight = validated_data.pop("total_cash_weight", Decimal("0.0"))
         rebalancing_model = validated_data.get("rebalancing_model", None)
         if request := self.context.get("request"):
             validated_data["creator"] = request.user.profile
@@ -32,7 +46,9 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         if target_portfolio and not rebalancing_model and (last_effective_date := obj.last_effective_date):
             target_portfolio_dto = target_portfolio._build_dto(last_effective_date)
         try:
-            obj.reset_trades(target_portfolio=target_portfolio_dto)
+            obj.reset_trades(
+                target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight
+            )
         except ValidationError as e:
             if request := self.context.get("request"):
                 warning(request, str(e), extra_tags="auto_close=0")
@@ -60,6 +76,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         fields = (
             "id",
             "trade_date",
+            "total_cash_weight",
             "comment",
             "status",
             "portfolio",

wbportfolio/serializers/transactions/trades.py

@@ -320,6 +320,16 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
     effective_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
     target_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
 
+    total_value_fx_portfolio = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=2, default=0)
+    effective_total_value_fx_portfolio = wb_serializers.DecimalField(
+        read_only=True, max_digits=16, decimal_places=2, default=0
+    )
+    target_total_value_fx_portfolio = wb_serializers.DecimalField(
+        read_only=True, max_digits=16, decimal_places=2, default=0
+    )
+
+    portfolio_currency = wb_serializers.CharField(read_only=True)
+
     def validate(self, data):
         data.pop("company", None)
         data.pop("security", None)
@@ -331,6 +341,8 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
             )
         effective_weight = self.instance._effective_weight if self.instance else Decimal(0.0)
         weighting = data.get("weighting", self.instance.weighting if self.instance else Decimal(0.0))
+        if (target_weight := data.pop("target_weight", None)) is not None:
+            weighting = target_weight - effective_weight
         if (target_weight := data.pop("target_weight", None)) is not None:
             weighting = target_weight - effective_weight
         if weighting >= 0:
@@ -343,14 +355,25 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
     class Meta:
         model = Trade
         percent_fields = ["effective_weight", "target_weight", "weighting"]
+        decorators = {
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "effective_total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "target_total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+        }
         read_only_fields = (
             "transaction_subtype",
             "shares",
-            # "underlying_instrument",
-            # "_underlying_instrument",
-            "shares",
             "effective_shares",
             "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
         )
         fields = (
             "id",
@@ -375,6 +398,10 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
             "order",
             "effective_shares",
             "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
+            "portfolio_currency",
         )
 
 

wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -66,11 +66,11 @@ class TestTradeProposal:
         validated_trading_service = trade_proposal.validated_trading_service
 
         # Assert effective and target portfolios are as expected
-        assert validated_trading_service.effective_portfolio.to_dict() == {
+        assert validated_trading_service._effective_portfolio.to_dict() == {
             a1.underlying_quote.id: a1.weighting,
             a2.underlying_quote.id: a2.weighting,
         }
-        assert validated_trading_service.target_portfolio.to_dict() == {
+        assert validated_trading_service._target_portfolio.to_dict() == {
             a1.underlying_quote.id: a1.weighting + t1.weighting,
             a2.underlying_quote.id: a2.weighting + t2.weighting,
         }
@@ -361,6 +361,8 @@ class TestTradeProposal:
         """
         portfolio = trade_proposal.portfolio
         instrument = instrument_factory.create(currency=portfolio.currency)
+        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=trade_proposal.trade_date)
+        mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
         trade = trade_factory.create(
             trade_proposal=trade_proposal,
             transaction_date=trade_proposal.trade_date,
@@ -368,12 +370,12 @@ class TestTradeProposal:
             underlying_instrument=instrument,
         )
         trade.refresh_from_db()
-        underlying_quote_price = instrument_price_factory.create(instrument=instrument, date=trade.transaction_date)
-        mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
 
         # Assert estimated shares are correctly calculated
         assert (
-            trade_proposal.get_estimated_shares(trade.weighting, trade.underlying_instrument)
+            trade_proposal.get_estimated_shares(
+                trade.weighting, trade.underlying_instrument, underlying_quote_price.net_value
+            )
             == Decimal(1_000_000) * trade.weighting / underlying_quote_price.net_value
         )
 

wbportfolio/tests/rebalancing/test_models.py

@@ -38,30 +38,24 @@ class TestModelPortfolioRebalancing:
     def model(self, portfolio, weekday):
         from wbportfolio.rebalancing.models import ModelPortfolioRebalancing
 
+        PortfolioPortfolioThroughModel.objects.create(
+            portfolio=portfolio,
+            dependency_portfolio=PortfolioFactory.create(),
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
     def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
-        model_portfolio = PortfolioFactory.create()
-        PortfolioPortfolioThroughModel.objects.create(
-            portfolio=model.portfolio,
-            dependency_portfolio=model_portfolio,
-            type=PortfolioPortfolioThroughModel.Type.MODEL,
-        )
+
         a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
         assert not model.is_valid()
         instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
-        model_portfolio = PortfolioFactory.create()
-        PortfolioPortfolioThroughModel.objects.create(
-            portfolio=model.portfolio,
-            dependency_portfolio=model_portfolio,
-            type=PortfolioPortfolioThroughModel.Type.MODEL,
-        )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         a1 = asset_position_factory(weighting=0.8, portfolio=portfolio.model_portfolio, date=model.last_effective_date)
@@ -91,7 +85,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.7,
+            weighting=Decimal(0.7),
             status=Trade.Status.EXECUTED,
         )
         TradeFactory.create(
@@ -99,7 +93,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.3,
+            weighting=Decimal(0.3),
             status=Trade.Status.EXECUTED,
         )
         assert not model.is_valid()
@@ -117,7 +111,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.8,
+            weighting=Decimal(0.8),
             status=Trade.Status.EXECUTED,
         )
         t2 = TradeFactory.create(
@@ -125,7 +119,7 @@ class TestCompositeRebalancing:
             transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
-            weighting=0.2,
+            weighting=Decimal(0.2),
             status=Trade.Status.EXECUTED,
         )
         target_portfolio = model.get_target_portfolio()

wbportfolio/viewsets/configs/buttons/trade_proposals.py

@@ -1,7 +1,13 @@
+from wbcore import serializers as wb_serializers
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs import buttons as bt
 from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display import create_simple_display
+
+
+class NormalizeSerializer(wb_serializers.Serializer):
+    total_cash_weight = wb_serializers.FloatField(default=0, precision=4, percent=True)
 
 
 class TradeProposalButtonConfig(ButtonViewConfig):
@@ -41,10 +47,12 @@ class TradeProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.EDIT.icon,
                         label="Normalize Trades",
                         description_fields="""
-                            <p>Make sure all trades normalize to a total target weight of 100%</p>
+                            <p>Make sure all trades normalize to a total target weight of (100 - {{total_cash_weight}})%</p>
                             """,
                         action_label="Normalize Trades",
                         title="Normalize Trades",
+                        serializer=NormalizeSerializer,
+                        instance_display=create_simple_display([["total_cash_weight"]]),
                     ),
                     bt.ActionButton(
                         method=RequestType.PATCH,

wbportfolio/viewsets/configs/display/trade_proposals.py

@@ -77,11 +77,12 @@ class TradeProposalDisplayConfig(DisplayViewConfig):
                     layouts={
                         default(): Layout(
                             grid_template_areas=[
-                                ["status", "status", "status"],
-                                ["trade_date", "rebalancing_model", "target_portfolio"]
+                                ["status", "status"],
+                                ["trade_date", "total_cash_weight"],
+                                ["rebalancing_model", "target_portfolio"]
                                 if self.view.new_mode
-                                else ["trade_date", "rebalancing_model", "rebalancing_model"],
-                                ["comment", "comment", "comment"],
+                                else ["rebalancing_model", "rebalancing_model"],
+                                ["comment", "comment"],
                             ],
                         ),
                     },

wbportfolio/viewsets/configs/display/trades.py

@@ -357,6 +357,42 @@ class TradeTradeProposalDisplayConfig(DisplayViewConfig):
                     ],
                 )
             )
+            fields.append(
+                dp.Field(
+                    label="Total Value",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(
+                            key="effective_total_value_fx_portfolio",
+                            label="Effective Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="target_total_value_fx_portfolio",
+                            label="Target Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="total_value_fx_portfolio",
+                            label="Total Value",
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={"color": WBColor.RED_DARK.value, "fontWeight": "bold"},
+                                    condition=("<", 0),
+                                ),
+                                dp.FormattingRule(
+                                    style={"color": WBColor.GREEN_DARK.value, "fontWeight": "bold"},
+                                    condition=(">", 0),
+                                ),
+                            ],
+                            width=Unit.PIXEL(150),
+                        ),
+                    ],
+                )
+            )
         fields.append(
             dp.Field(
                 label="Information",

wbportfolio/viewsets/transactions/trade_proposals.py

@@ -1,5 +1,6 @@
 from contextlib import suppress
 from datetime import date
+from decimal import Decimal
 
 from django.contrib.messages import info, warning
 from django.shortcuts import get_object_or_404
@@ -106,8 +107,9 @@ class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
     @action(detail=True, methods=["PATCH"])
     def normalize(self, request, pk=None):
         trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        total_cash_weight = Decimal(request.data.get("total_cash_weight", Decimal("0.0")))
         if trade_proposal.status == TradeProposal.Status.DRAFT:
-            trade_proposal.normalize_trades()
+            trade_proposal.normalize_trades(total_target_weight=Decimal("1.0") - total_cash_weight)
             return Response({"send": True})
         return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 

wbportfolio/viewsets/transactions/trades.py

@@ -25,7 +25,6 @@ from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.utils.strings import format_number
 from wbcore.viewsets.mixins import OrderableMixin
 from wbcrm.models import Account
-from wbfdm.models import Cash
 
 from wbportfolio.filters import (
     SubscriptionRedemptionFilterSet,
@@ -395,6 +394,10 @@ class TradeTradeProposalModelViewSet(
     def trade_proposal(self):
         return get_object_or_404(TradeProposal, pk=self.kwargs["trade_proposal_id"])
 
+    @cached_property
+    def portfolio_total_asset_value(self):
+        return self.trade_proposal.portfolio_total_asset_value
+
     def has_import_permission(self, request) -> bool:  # allow import only on draft trade proposal
         return super().has_import_permission(request) and self.trade_proposal.status == TradeProposal.Status.DRAFT
 
@@ -409,46 +412,36 @@ class TradeTradeProposalModelViewSet(
     def get_aggregates(self, queryset, *args, **kwargs):
         agg = {}
         if queryset.exists():
-            cash_target_position = self.trade_proposal.get_estimated_target_cash(
-                self.trade_proposal.portfolio.currency
-            )
-            cash_target_cash_weight, cash_target_cash_shares = (
-                cash_target_position.weighting,
-                cash_target_position.initial_shares,
-            )
-            extra_existing_cash_components = Cash.objects.filter(
-                id__in=self.trade_proposal.trades.filter(underlying_instrument__is_cash=True).values(
-                    "underlying_instrument"
-                )
-            ).exclude(currency=self.trade_proposal.portfolio.currency)
-
-            for cash_component in extra_existing_cash_components:
-                extra_cash_position = self.trade_proposal.get_estimated_target_cash(cash_component.currency)
-                cash_target_cash_weight += extra_cash_position.weighting
-                cash_target_cash_shares += extra_cash_position.initial_shares
             noncash_aggregates = queryset.filter(underlying_instrument__is_cash=False).aggregate(
                 sum_target_weight=Sum(F("target_weight")),
                 sum_effective_weight=Sum(F("effective_weight")),
-                sum_target_shares=Sum(F("target_shares")),
-                sum_effective_shares=Sum(F("effective_shares")),
-            )
-            cash_aggregates = queryset.filter(underlying_instrument__is_cash=True).aggregate(
-                sum_effective_weight=Sum(F("effective_weight")),
-                sum_effective_shares=Sum(F("effective_shares")),
+                sum_target_total_value_fx_portfolio=Sum(F("target_total_value_fx_portfolio")),
+                sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
             )
+
             # weights aggregates
-            cash_sum_effective_weight = cash_aggregates["sum_effective_weight"] or Decimal(0)
+            cash_sum_effective_weight = Decimal("1.0") - noncash_aggregates["sum_effective_weight"]
+            cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]
             noncash_sum_effective_weight = noncash_aggregates["sum_effective_weight"] or Decimal(0)
             noncash_sum_target_weight = noncash_aggregates["sum_target_weight"] or Decimal(0)
             sum_buy_weight = queryset.filter(weighting__gte=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
             sum_sell_weight = queryset.filter(weighting__lt=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
 
             # shares aggregates
-            cash_sum_effective_shares = cash_aggregates["sum_effective_shares"] or Decimal(0)
-            noncash_sum_effective_shares = noncash_aggregates["sum_effective_shares"] or Decimal(0)
-            noncash_sum_target_shares = noncash_aggregates["sum_target_shares"] or Decimal(0)
-            sum_buy_shares = queryset.filter(shares__gte=0).aggregate(s=Sum(F("shares")))["s"] or Decimal(0)
-            sum_sell_shares = queryset.filter(shares__lt=0).aggregate(s=Sum(F("shares")))["s"] or Decimal(0)
+            cash_sum_effective_total_value_fx_portfolio = cash_sum_effective_weight * self.portfolio_total_asset_value
+            cash_sum_target_total_value_fx_portfolio = cash_sum_target_cash_weight * self.portfolio_total_asset_value
+            noncash_sum_effective_total_value_fx_portfolio = noncash_aggregates[
+                "sum_effective_total_value_fx_portfolio"
+            ] or Decimal(0)
+            noncash_sum_target_total_value_fx_portfolio = noncash_aggregates[
+                "sum_target_total_value_fx_portfolio"
+            ] or Decimal(0)
+            sum_buy_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__gte=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+            sum_sell_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__lt=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
 
             agg = {
                 "effective_weight": {
@@ -457,29 +450,38 @@ class TradeTradeProposalModelViewSet(
                     "Total": format_number(noncash_sum_effective_weight + cash_sum_effective_weight, decimal=6),
                 },
                 "target_weight": {
-                    "Cash": format_number(cash_target_cash_weight, decimal=6),
+                    "Cash": format_number(cash_sum_target_cash_weight, decimal=6),
                     "Non-Cash": format_number(noncash_sum_target_weight, decimal=6),
-                    "Total": format_number(cash_target_cash_weight + noncash_sum_target_weight, decimal=6),
+                    "Total": format_number(cash_sum_target_cash_weight + noncash_sum_target_weight, decimal=6),
                 },
-                "effective_shares": {
-                    "Cash": format_number(cash_sum_effective_shares, decimal=6),
-                    "Non-Cash": format_number(noncash_sum_effective_shares, decimal=6),
-                    "Total": format_number(cash_sum_effective_shares + noncash_sum_effective_shares, decimal=6),
+                "effective_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_effective_total_value_fx_portfolio + noncash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
                 },
-                "target_shares": {
-                    "Cash": format_number(cash_target_cash_shares, decimal=6),
-                    "Non-Cash": format_number(noncash_sum_target_shares, decimal=6),
-                    "Total": format_number(cash_target_cash_shares + noncash_sum_target_shares, decimal=6),
+                "target_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_target_total_value_fx_portfolio + noncash_sum_target_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
                 },
                 "weighting": {
-                    "Cash Flow": format_number(cash_sum_effective_weight - cash_target_cash_weight, decimal=6),
+                    "Cash Flow": format_number(cash_sum_target_cash_weight - cash_sum_effective_weight, decimal=6),
                     "Buy": format_number(sum_buy_weight, decimal=6),
                     "Sell": format_number(sum_sell_weight, decimal=6),
                 },
-                "shares": {
-                    "Cash Flow": format_number(cash_sum_effective_shares - cash_target_cash_shares, decimal=6),
-                    "Buy": format_number(sum_buy_shares, decimal=6),
-                    "Sell": format_number(sum_sell_shares, decimal=6),
+                "total_value_fx_portfolio": {
+                    "Cash Flow": format_number(
+                        cash_sum_target_total_value_fx_portfolio - cash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                    "Buy": format_number(sum_buy_total_value_fx_portfolio, decimal=6),
+                    "Sell": format_number(sum_sell_total_value_fx_portfolio, decimal=6),
                 },
             }
 
@@ -509,6 +511,7 @@ class TradeTradeProposalModelViewSet(
             qs = super().get_queryset().filter(trade_proposal=self.kwargs["trade_proposal_id"]).annotate_base_info()
         else:
             qs = TradeProposal.objects.none()
+
         return qs.annotate(
             underlying_instrument_isin=F("underlying_instrument__isin"),
             underlying_instrument_ticker=F("underlying_instrument__ticker"),
@@ -520,4 +523,7 @@ class TradeTradeProposalModelViewSet(
                 ),
                 default=F("underlying_instrument__instrument_type__short_name"),
             ),
+            effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
+            target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
+            portfolio_currency=F("portfolio__currency__symbol"),
         )

{wbportfolio-1.52.5.dist-info → wbportfolio-1.52.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.52.5
+Version: 1.52.6
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.52.5.dist-info → wbportfolio-1.52.6.dist-info}/RECORD

@@ -250,11 +250,11 @@ wbportfolio/migrations/0077_remove_transaction_currency_and_more.py,sha256=Yf4a3
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=HSpa5xwh_MHQaBpNrq9E0CbdEE5Iq-pDLIsPzZ-TRTg,904
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=MgEdE1AZQAxHDQX6iVCr1zD9QbsIn95OQzOHoTKjAEg,45446
+wbportfolio/models/asset.py,sha256=WwbLjpGHzz17yJxrkuTP4MbErqcTJMlKkDrQI92p5II,45490
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/exceptions.py,sha256=3ix0tWUO-O6jpz8f07XIwycw2x3JFRoWzjwil8FVA2Q,52
 wbportfolio/models/indexes.py,sha256=gvW4K9U9Bj8BmVCqFYdWiXvDWhjHINRON8XhNsZUiQY,639
-wbportfolio/models/portfolio.py,sha256=afk2XnVxMIiAmLPrDIGDbeOyhvdDzXs7K-MCaUKKKyc,56275
+wbportfolio/models/portfolio.py,sha256=yQ8cqAZLOMwsiejC9RzOLoqLDV5q5ZWYWMOc2BlcHdw,56281
 wbportfolio/models/portfolio_cash_flow.py,sha256=uElG7IJUBY8qvtrXftOoskX6EA-dKgEG1JJdvHeWV7g,7336
 wbportfolio/models/portfolio_cash_targets.py,sha256=WmgG-etPisZsh2yaFQpz7EkpvAudKBEzqPsO715w52U,1498
 wbportfolio/models/portfolio_relationship.py,sha256=ZGECiPZiLdlk4uSamOrEfuzO0hduK6OMKJLUSnh5_kc,5190
@@ -281,16 +281,16 @@ wbportfolio/models/transactions/claim.py,sha256=SF2FlwG6SRVmA_hT0NbXah5-fYejccWK
 wbportfolio/models/transactions/dividends.py,sha256=mmOdGWR35yndUMoCuG24Y6BdtxDhSk2gMQ-8LVguqzg,1890
 wbportfolio/models/transactions/fees.py,sha256=wJtlzbBCAq1UHvv0wqWTE2BEjCF5RMtoaSDS3kODFRo,7112
 wbportfolio/models/transactions/rebalancing.py,sha256=obzgewWKOD4kJbCoF5fhtfDk502QkbrjPKh8T9KDGew,7355
-wbportfolio/models/transactions/trade_proposals.py,sha256=b1VbgR91-3LFq08iNnafcTjvsDboimU7ZRpf5jtQk7w,32234
-wbportfolio/models/transactions/trades.py,sha256=wTOa0Wu4OejO3CeeJnwvPzoDUVWMsHRbyEA7QllaLRs,31231
+wbportfolio/models/transactions/trade_proposals.py,sha256=Jd7rfiE42Qtqp9VXQ448OF9m_DKoFR8ISjSh-1TDi8o,31592
+wbportfolio/models/transactions/trades.py,sha256=og8R4Sg7LCRQsuX09uYjZXq9q4VsUb0j8W8iCTyx0pQ,31571
 wbportfolio/models/transactions/transactions.py,sha256=XTcUeMUfkf5XTSZaR2UAyGqCVkOhQYk03_vzHLIgf8Q,3807
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/pms/typing.py,sha256=b2pBWYt1E8ok-Kqm0lEFIakSnWJ6Ib57z-VX3C3gkQc,6081
+wbportfolio/pms/typing.py,sha256=qcqEs94HA7qNB631LErV7FVQ4ytYBLetuPDcilrnlW0,6798
 wbportfolio/pms/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/analytics/portfolio.py,sha256=vE0KA6Z037bUdmBTkYuBqXElt80nuYObNzY_kWvxEZY,1360
 wbportfolio/pms/statistics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/trading/__init__.py,sha256=R_yLKc54sCak8A1cW0O1Aszrcv5KV8mC_3h17Hr20e4,36
-wbportfolio/pms/trading/handler.py,sha256=EzvCP8NNzd0jjE3ilCupbmFBCaojKvlrbq7n_JirahU,7151
+wbportfolio/pms/trading/handler.py,sha256=ORvtwAG2VX1GvNvNE2HnDvS-4UNrgBwCMPydnfphtY0,5992
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/rebalancing/base.py,sha256=NwTGZtBm1f35gj5Jp6iTyyFvDT1GSIztN990cKBvYzQ,637
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
@@ -298,7 +298,7 @@ wbportfolio/rebalancing/models/__init__.py,sha256=AQjG7Tu5vlmhqncVoYOjpBKU2UIvgo
 wbportfolio/rebalancing/models/composite.py,sha256=XEgK3oMurrE_d_l5uN0stBKRrtvnKQzRWyXNXuBYfmc,1818
 wbportfolio/rebalancing/models/equally_weighted.py,sha256=FCpSKOs49ckNYVgoYIiHB0BqPT9OeCMuFoet4Ixbp-Y,1210
 wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=6ZsR8iJg6l89CsxHqoxJSXlTaj8Pmb8_bFPrXhnxaRs,5295
-wbportfolio/rebalancing/models/model_portfolio.py,sha256=DNg9vEDYDUwXTOnIpk26FQSPHC0qxkuvW2sJWX0VodQ,1489
+wbportfolio/rebalancing/models/model_portfolio.py,sha256=Dk3tw9u3WG1jCP3V2-R05GS4-DmDBBtxH4h6p7pRe4g,1393
 wbportfolio/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/reports/monthly_position_report.py,sha256=e7BzjDd6eseUOwLwQJXKvWErQ58YnCsznHU2VtR6izM,2981
 wbportfolio/risk_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -346,8 +346,8 @@ wbportfolio/serializers/transactions/__init__.py,sha256=oAfidhjjCKP0exeHbzJgGuBd
 wbportfolio/serializers/transactions/claim.py,sha256=kC4E2RZRrpd9i8tGfoiV-gpWDk3ikR5F1Wf0v_IGIvw,11599
 wbportfolio/serializers/transactions/dividends.py,sha256=ADXf9cXe8rq55lC_a8vIzViGLmQ-yDXkgR54k2m-N0w,1814
 wbportfolio/serializers/transactions/fees.py,sha256=3mBzs6vdfST9roeQB-bmLJhipY7i5jBtAXjoTTE-GOg,2388
-wbportfolio/serializers/transactions/trade_proposals.py,sha256=fiGpL6za5ERLtdbud5wrciCVXHX6-3SjeF8Zaa6Zhzg,3410
-wbportfolio/serializers/transactions/trades.py,sha256=Rhv0UezIpnDxWmj5v9dQECfS0un7yQUIpnkOtD6z6YY,15452
+wbportfolio/serializers/transactions/trade_proposals.py,sha256=ufYBYiSttz5KAlAaaXbnf98oUFT_qNfxF_VUM4ClXE8,4072
+wbportfolio/serializers/transactions/trades.py,sha256=JtL2jrvIjBVsmB2N5ngw_1UyzK7BbxGK5yuNTCRSfkU,16815
 wbportfolio/static/wbportfolio/css/macro_review.css,sha256=FAVVO8nModxwPXcTKpcfzVxBGPZGJVK1Xn-0dkSfGyc,233
 wbportfolio/static/wbportfolio/markdown/documentation/account_holding_reconciliation.md,sha256=MabxOvOne8s5gl6osDoow6-3ghaXLAYg9THWpvy6G5I,921
 wbportfolio/static/wbportfolio/markdown/documentation/aggregate_asset_position_liquidity.md,sha256=HEgXB7uqmqfty-GBCCXYxrAN-teqmxWuqDLK_liKWVc,1090
@@ -387,12 +387,12 @@ wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCe
 wbportfolio/tests/models/transactions/test_claim.py,sha256=NG3BKB-FVcIDgHSJHCjImxgMM3ISVUMl24xUPmEcPec,5570
 wbportfolio/tests/models/transactions/test_fees.py,sha256=tAp18x2wCNQr11LUnLtHNbBDbbX0v1DZnmW7i-cEi5Q,2423
 wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=fZ5tx6kByEGXD6nhapYdvk9HOjYlmjhU2w6KlQJ6QE4,4061
-wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=UB8Dvs7nT42D_uznuLyzni7PYiY-dabLCDXmV2W_yb4,18928
+wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=ERGDbniHctEnIG5yFLkrZX2Jw1jEew5rWceVKuKskto,18997
 wbportfolio/tests/models/transactions/test_trades.py,sha256=vqvOqUY_uXvBp8YOKR0Wq9ycA2oeeEBhO3dzV7sbXEU,9863
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=fAuY1zcXibttFpBh2GhKVyzdYfi1kz_b7SPa9xZQXY0,1086
 wbportfolio/tests/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/rebalancing/test_models.py,sha256=_gT_7UtpOWceDwT7FbTUW6P6ZpCVLBpgXWM0goIljWc,8090
+wbportfolio/tests/rebalancing/test_models.py,sha256=4rSb05xKH881ft12G0B8ZSeFgJvutKcW_7vFgVQa0DI,7813
 wbportfolio/tests/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/serializers/test_claims.py,sha256=vQrg73xQXRFEgvx3KI9ivFre_wpBFzdO0p0J13PkvdY,582
 wbportfolio/tests/viewsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -436,7 +436,7 @@ wbportfolio/viewsets/configs/buttons/products.py,sha256=bHOs2ftfaLbIbJ7E8yFqQqSu
 wbportfolio/viewsets/configs/buttons/reconciliations.py,sha256=lw4r22GHpqKPUF1MrB6P9dOkL-FHe5iiBJ0--f8D74E,3145
 wbportfolio/viewsets/configs/buttons/registers.py,sha256=aS89TsYHql83k-NHojOrLDqtBpnpsUUO8x63PiMfrXM,445
 wbportfolio/viewsets/configs/buttons/signals.py,sha256=6sKBQI_eDvZuZR5bUUwvur5R67A3oChAGxPfayWUelE,2739
-wbportfolio/viewsets/configs/buttons/trade_proposals.py,sha256=eZBfYk5ZhancCVcu7bvRKPGBKTl_tGlgz6BZrGPpPxQ,2953
+wbportfolio/viewsets/configs/buttons/trade_proposals.py,sha256=Os5jT-aL0jMNkdm2sJpGRZvY4OzreR6Ah7eHex_6zB4,3383
 wbportfolio/viewsets/configs/buttons/trades.py,sha256=bPOqqwdgadSUbU9l5aSirqr5UAMFe2AiFNsXLRsKwn8,2535
 wbportfolio/viewsets/configs/display/__init__.py,sha256=jJqSCCAfw_vjbcsIkzKr39LdAZA810LUBfSH1EA7MAI,2086
 wbportfolio/viewsets/configs/display/adjustments.py,sha256=jIOEc23OCYBguLaZRlZxC916kocYT35ZV9Jsiocs9nk,3334
@@ -456,8 +456,8 @@ wbportfolio/viewsets/configs/display/rebalancing.py,sha256=yw9X1Nf2-V_KP_mCX4pVK
 wbportfolio/viewsets/configs/display/reconciliations.py,sha256=YvMAuwmpX0HExvGsuf5UvcRQxe4eMo1iyNJX68GGC_k,6021
 wbportfolio/viewsets/configs/display/registers.py,sha256=1np75exIk5rfct6UkVN_RnfJ9ozvIkcWJgFV4_4rJns,3182
 wbportfolio/viewsets/configs/display/roles.py,sha256=SFUyCdxSlHZ3NsMrJmpVBSlg-XKGaEFteV89nyLMMAQ,1815
-wbportfolio/viewsets/configs/display/trade_proposals.py,sha256=sRLSUjKlarBhnTwg7tX_Juldor3beswJlyvZfFPvNEk,4315
-wbportfolio/viewsets/configs/display/trades.py,sha256=PbGI8Sjs8YMBLfeYdgXRbv_tvel2aV3dB-7oZXnLwz4,17587
+wbportfolio/viewsets/configs/display/trade_proposals.py,sha256=gM5CuUmNcVtwJHYE9Myg-RR_WmAc6VDJztwUqQ1uZ7g,4335
+wbportfolio/viewsets/configs/display/trades.py,sha256=ZYZ2ceE4Hyw2SpQjW00VDnzGz7Wlu3jjPoK_J2GZLyk,19181
 wbportfolio/viewsets/configs/endpoints/__init__.py,sha256=KR3AsSxl71VAVkYBRVowgs3PZB8vaKa34WHHUvC-2MY,2807
 wbportfolio/viewsets/configs/endpoints/adjustments.py,sha256=KRZLqv4ZeB27d-_s7Qlqj9LI3I9WFJkjc6Mw8agDueE,606
 wbportfolio/viewsets/configs/endpoints/assets.py,sha256=B8W6ATQQfT292TllE4sUDYv5wHUCo99HEqymJuMtFAc,1909
@@ -517,9 +517,9 @@ wbportfolio/viewsets/transactions/claim.py,sha256=Pb1WftoO-w-ZSTbLRhmQubhy7hgd68
 wbportfolio/viewsets/transactions/fees.py,sha256=WT2bWWfgozz4_rpyTKX7dgBBTXD-gu0nlsd2Nk2Zh1Q,7028
 wbportfolio/viewsets/transactions/mixins.py,sha256=WipvJoi5hylkpD0y9VATe30WAcwIHUIroVkK10FYw7k,636
 wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQVTN2MH1kG_yCeVkmyK8k,1263
-wbportfolio/viewsets/transactions/trade_proposals.py,sha256=rCJoJSL11qpjxciX25Q5ZU3ewELyyDBUPXcj4Z88Vdg,6037
-wbportfolio/viewsets/transactions/trades.py,sha256=wCyTTyVKjYuMRsrFcmwD3_yggWxCNm-mdoYzVnhGP0U,21727
-wbportfolio-1.52.5.dist-info/METADATA,sha256=eHgs5EUj3Ss3i8U5cBrhqUW-4kXfD6umFAiF2Gq8aHw,702
-wbportfolio-1.52.5.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.52.5.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.52.5.dist-info/RECORD,,
+wbportfolio/viewsets/transactions/trade_proposals.py,sha256=zdb9yqyAE1-hcMmxxN3CYePWoPVWIW3WP3v8agErDeY,6210
+wbportfolio/viewsets/transactions/trades.py,sha256=DcfiJReBnnR6oBgNKZyBYWhXurtxJG_DCzxq5WCionA,22025
+wbportfolio-1.52.6.dist-info/METADATA,sha256=9YI1D7f4Omg3dI2yJs8v_cUOHJ4cdzujpm3l7QfGh38,702
+wbportfolio-1.52.6.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.52.6.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.52.6.dist-info/RECORD,,