wbportfolio 1.54.15__tar.gz → 1.54.17__tar.gz

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/PKG-INFO

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

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/wbportfolio/models/orders/order_proposals.py

@@ -24,7 +24,6 @@ from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
 from wbcore.contrib.authentication.models import User
-from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.icons import WBIcon
 from wbcore.contrib.notifications.dispatch import send_notification
 from wbcore.enums import RequestType
@@ -188,6 +187,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             effective_weight=Round(
                 F("contribution") / Value(portfolio_contribution), precision=Order.ORDER_WEIGHTING_PRECISION
             ),
+            tmp_effective_weight=F("contribution") / Value(portfolio_contribution),
             target_weight=Round(F("effective_weight") + F("weighting"), precision=Order.ORDER_WEIGHTING_PRECISION),
             effective_shares=Coalesce(
                 Subquery(
@@ -206,7 +206,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         )
         total_effective_weight = orders.aggregate(s=models.Sum("effective_weight"))["s"] or Decimal("1")
         with suppress(Order.DoesNotExist):
-            largest_order = orders.latest("weighting")
+            largest_order = orders.latest("effective_weight")
             if quant_error := Decimal("1") - total_effective_weight:
                 orders = orders.annotate(
                     effective_weight=models.Case(
@@ -226,7 +226,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def __str__(self) -> str:
         return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
 
-    def convert_to_portfolio(self, use_effective: bool = False) -> PortfolioDTO:
+    def convert_to_portfolio(self, use_effective: bool = False, with_cash: bool = True) -> PortfolioDTO:
         """
         Data Transfer Object
         Returns:
@@ -258,6 +258,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         except InvalidAnalyticPortfolio:
             last_returns, portfolio_contribution = {}, 1
         positions = []
+        total_weighting = Decimal("0")
         for instrument, row in portfolio.items():
             weighting = row["weighting"]
             daily_return = Decimal(last_returns.get(instrument.id, 0))
@@ -285,6 +286,10 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     currency_fx_rate=row["currency_fx_rate"],
                 )
             )
+            total_weighting += weighting
+        if with_cash and (cash_weight := Decimal("1") - total_weighting):
+            cash_position = self.get_estimated_target_cash(target_cash_weight=cash_weight)
+            positions.append(cash_position._build_dto())
         return PortfolioDTO(positions)
 
     # Start tools methods
@@ -325,7 +330,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         service = TradingService(
             self.trade_date,
             effective_portfolio=self._get_default_effective_portfolio(),
-            target_portfolio=self.convert_to_portfolio(),
+            target_portfolio=self.convert_to_portfolio(use_effective=False, with_cash=False),
             total_target_weight=total_target_weight,
         )
         leftovers_orders = self.orders.all()
@@ -352,7 +357,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             return self.rebalancing_model.get_target_portfolio(
                 self.portfolio, self.trade_date, self.value_date, **params
             )
-        return self.convert_to_portfolio()
+        return self.convert_to_portfolio(use_effective=False)
 
     def _get_default_effective_portfolio(self):
         return self.convert_to_portfolio(use_effective=True)
@@ -389,35 +394,34 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 orders = service.trades_batch.trades_map.values()
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
-                if not instrument.is_cash:  # we do not save order that includes cash component
-                    currency_fx_rate = instrument.currency.convert(
-                        self.value_date, self.portfolio.currency, exact_lookup=True
+                currency_fx_rate = instrument.currency.convert(
+                    self.value_date, self.portfolio.currency, exact_lookup=True
+                )
+                # we cannot do a bulk-create because Order is a multi table inheritance
+                weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
+                daily_return = order_dto.daily_return
+                try:
+                    order = self.orders.get(underlying_instrument=instrument)
+                    order.weighting = weighting
+                    order.currency_fx_rate = currency_fx_rate
+                    order.daily_return = daily_return
+                except Order.DoesNotExist:
+                    order = Order(
+                        underlying_instrument=instrument,
+                        order_proposal=self,
+                        value_date=self.trade_date,
+                        weighting=weighting,
+                        daily_return=daily_return,
+                        currency_fx_rate=currency_fx_rate,
                     )
-                    # we cannot do a bulk-create because Order is a multi table inheritance
-                    weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
-                    daily_return = order_dto.daily_return
-                    try:
-                        order = self.orders.get(underlying_instrument=instrument)
-                        order.weighting = weighting
-                        order.currency_fx_rate = currency_fx_rate
-                        order.daily_return = daily_return
-                    except Order.DoesNotExist:
-                        order = Order(
-                            underlying_instrument=instrument,
-                            order_proposal=self,
-                            value_date=self.trade_date,
-                            weighting=weighting,
-                            daily_return=daily_return,
-                            currency_fx_rate=currency_fx_rate,
-                        )
-                    order.price = order.get_price()
-                    order.order_type = Order.get_type(weighting, order_dto.previous_weight, order_dto.target_weight)
-                    # if we cannot automatically find a price, we consider the stock is invalid and we sell it
-                    if not order.price:
-                        order.price = Decimal("0.0")
-                        order.weighting = -order_dto.effective_weight
-
-                    order.save()
+                order.price = order.get_price()
+                order.order_type = Order.get_type(weighting, order_dto.previous_weight, order_dto.target_weight)
+                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                if not order.price:
+                    order.price = Decimal("0.0")
+                    order.weighting = -order_dto.effective_weight
+
+                order.save()
         # final sanity check to make sure invalid order with effective and target weight of 0 are automatically removed:
         self.get_orders().filter(target_weight=0, effective_weight=0).delete()
 
@@ -455,8 +459,8 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         last_order_proposal = self
         last_order_proposal_created = False
         while last_order_proposal and last_order_proposal.status == OrderProposal.Status.APPROVED:
+            logger.info(f"Replaying order proposal {last_order_proposal}")
             if not last_order_proposal_created:
-                logger.info(f"Replaying order proposal {last_order_proposal}")
                 last_order_proposal.approve_workflow(
                     silent_exception=True,
                     force_reset_order=True,
@@ -557,50 +561,43 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 shares = math.floor(shares / round_lot_size) * round_lot_size
         return shares
 
-    def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
+    def get_estimated_target_cash(self, target_cash_weight: Decimal | None = None) -> AssetPosition:
         """
         Estimates the target cash weight and shares for a order proposal.
 
         This method calculates the target cash weight by summing the weights of cash orders and adding any leftover weight from non-cash orders. It then estimates the target shares for this cash component if the portfolio is not only weighting-based.
 
         Args:
-            currency (Currency): The currency for the target currency component
+            target_cash_weight (Decimal): the expected target cash weight (Optional). If not provided, we estimate from the existing orders
 
         Returns:
             tuple[Decimal, Decimal]: A tuple containing the target cash weight and the estimated target shares.
         """
         # Retrieve orders with base information
         orders = self.get_orders()
+        currency = self.portfolio.currency
 
-        # Calculate the target cash weight from cash orders
-        target_cash_weight = orders.filter(
-            underlying_instrument__is_cash=True, underlying_instrument__currency=currency
-        ).aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
-        # if the specified currency match the portfolio's currency, we include the weight leftover to this cash compoenent
-        if currency == self.portfolio.currency:
-            # Calculate the total target weight of all orders
-            total_target_weight = orders.aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
+        # Calculate the total target weight of all orders
+        total_target_weight = orders.exclude(underlying_instrument__is_cash=True).aggregate(
+            s=models.Sum("target_weight")
+        )["s"] or Decimal(0)
 
-            # Add any leftover weight as cash
-            target_cash_weight += Decimal(1) - total_target_weight
+        if target_cash_weight is None:
+            target_cash_weight = Decimal("1") - total_target_weight
 
         # Initialize target shares to zero
         total_target_shares = Decimal(0)
 
+        # Get or create a cash component for the portfolio's currency
+        cash_component = Cash.objects.get_or_create(
+            currency=currency, defaults={"is_cash": True, "name": currency.title}
+        )[0]
         # If the portfolio is not only weighting-based, estimate the target shares for the cash component
         if not self.portfolio.only_weighting:
-            # Get or create a cash component for the portfolio's currency
-            cash_component = Cash.objects.get_or_create(
-                currency=currency, defaults={"is_cash": True, "name": currency.title}
-            )[0]
-
             # Estimate the target shares for the cash component
             with suppress(ValueError):
                 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}
-        )[0]
         # otherwise, we create a new position
         underlying_quote_price = InstrumentPrice.objects.get_or_create(
             instrument=cash_component,
@@ -657,7 +654,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         Order.objects.bulk_update(orders, ["shares", "weighting"])
 
         # If we estimate cash on this order proposal, we make sure to create the corresponding cash component
-        estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
+        estimated_cash_position = self.get_estimated_target_cash()
         target_portfolio = self.validated_trading_service.trades_batch.convert_to_portfolio(
             estimated_cash_position._build_dto()
         )
@@ -717,7 +714,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         assets = []
         warnings = []
         # We do not want to create the estimated cash position if there is not orders in the order proposal (shouldn't be possible anyway)
-        estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
+        estimated_cash_position = self.get_estimated_target_cash()
         for order in self.get_orders():
             with suppress(ValueError):
                 asset = order.get_asset()

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/wbportfolio/pms/trading/handler.py

@@ -143,33 +143,32 @@ class TradingService:
 
         trades: list[Trade] = []
         for instrument_id, pos in instruments.items():
-            if not pos.is_cash:
-                previous_weight = target_weight = 0
-                effective_shares = target_shares = 0
-                daily_return = 0
-                if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
-                    previous_weight = effective_pos.weighting
-                    effective_shares = effective_pos.shares
-                    daily_return = effective_pos.daily_return
-                if target_pos := target_portfolio.positions_map.get(instrument_id, None):
-                    target_weight = target_pos.weighting
-                    if target_pos.shares is not None:
-                        target_shares = target_pos.shares
-                trade = Trade(
-                    underlying_instrument=instrument_id,
-                    previous_weight=previous_weight,
-                    target_weight=target_weight,
-                    effective_shares=effective_shares,
-                    target_shares=target_shares,
-                    date=self.trade_date,
-                    instrument_type=pos.instrument_type,
-                    currency=pos.currency,
-                    price=Decimal(pos.price) if pos.price is not None else Decimal("0"),
-                    currency_fx_rate=Decimal(pos.currency_fx_rate),
-                    daily_return=Decimal(daily_return),
-                    portfolio_contribution=effective_portfolio.portfolio_contribution,
-                )
-                trades.append(trade)
+            previous_weight = target_weight = 0
+            effective_shares = target_shares = 0
+            daily_return = 0
+            if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
+                previous_weight = effective_pos.weighting
+                effective_shares = effective_pos.shares
+                daily_return = effective_pos.daily_return
+            if target_pos := target_portfolio.positions_map.get(instrument_id, None):
+                target_weight = target_pos.weighting
+                if target_pos.shares is not None:
+                    target_shares = target_pos.shares
+            trade = Trade(
+                underlying_instrument=instrument_id,
+                previous_weight=previous_weight,
+                target_weight=target_weight,
+                effective_shares=effective_shares,
+                target_shares=target_shares,
+                date=self.trade_date,
+                instrument_type=pos.instrument_type,
+                currency=pos.currency,
+                price=Decimal(pos.price) if pos.price is not None else Decimal("0"),
+                currency_fx_rate=Decimal(pos.currency_fx_rate),
+                daily_return=Decimal(daily_return),
+                portfolio_contribution=effective_portfolio.portfolio_contribution,
+            )
+            trades.append(trade)
         return TradeBatch(trades)
 
     def is_valid(self, ignore_error: bool = False) -> bool:

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/wbportfolio/serializers/orders/order_proposals.py

@@ -23,7 +23,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
     _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
     target_portfolio = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
+        queryset=Portfolio.objects.all(), write_only=True, required=False
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
     total_cash_weight = wb_serializers.DecimalField(
@@ -51,8 +51,13 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
         obj = super().create(validated_data)
 
         target_portfolio_dto = None
-        if target_portfolio and not rebalancing_model:
+        if target_portfolio:
             target_portfolio_dto = target_portfolio._build_dto(obj.trade_date)
+        elif rebalancing_model:
+            target_portfolio_dto = rebalancing_model.get_target_portfolio(
+                obj.portfolio, obj.trade_date, obj.last_effective_date
+            )
+
         try:
             obj.reset_orders(
                 target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/wbportfolio/tests/models/orders/test_order_proposals.py

@@ -248,7 +248,9 @@ class TestOrderProposal:
         assert t3.weighting == normalized_t3_weight
 
     # Test resetting orders
-    def test_reset_orders(self, order_proposal, instrument_factory, instrument_price_factory, asset_position_factory):
+    def test_reset_orders(
+        self, order_proposal, instrument_factory, cash, instrument_price_factory, asset_position_factory
+    ):
         """
         Verify orders are correctly reset based on effective and target portfolios.
         """
@@ -334,6 +336,31 @@ class TestOrderProposal:
         assert t2.weighting == Decimal("0")
         assert t3.weighting == Decimal("0.5")
 
+        # assert cash position creates a proper order
+        # build the target portfolio
+        target_portfolio_with_cash = PortfolioDTO(
+            [
+                Position(
+                    underlying_instrument=i1.id,
+                    date=order_proposal.trade_date,
+                    weighting=Decimal("0.5"),
+                    price=float(p1.net_value),
+                ),
+                Position(
+                    underlying_instrument=cash.id,
+                    date=order_proposal.trade_date,
+                    weighting=Decimal("0.5"),
+                    price=1.0,
+                ),
+            ]
+        )
+        order_proposal.reset_orders(target_portfolio=target_portfolio_with_cash)
+
+        # Assert existing trade weights are correctly updated
+        assert order_proposal.orders.get(underlying_instrument=i1).weighting == Decimal("-0.2")
+        assert order_proposal.orders.get(underlying_instrument=i2).weighting == Decimal("-0.3")
+        assert order_proposal.orders.get(underlying_instrument=cash).weighting == Decimal("0.5")
+
     def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory, instrument_price_factory):
         # create a invalid trade and its price
         invalid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(0))
@@ -437,9 +464,8 @@ class TestOrderProposal:
             underlying_instrument=cash,
             weighting=Decimal("0.2"),
         )
-
-        target_cash_position = order_proposal.get_estimated_target_cash(order_proposal.portfolio.currency)
-        assert target_cash_position.weighting == Decimal("0.2") + Decimal("1.0") - (Decimal("0.7") + Decimal("0.2"))
+        target_cash_position = order_proposal.get_estimated_target_cash()
+        assert target_cash_position.weighting == Decimal("0.3")
         assert target_cash_position.initial_shares == Decimal(1_000_000) * Decimal("0.3")
 
     def test_order_proposal_update_inception_date(self, order_proposal_factory, portfolio, instrument_factory):

{wbportfolio-1.54.15 → wbportfolio-1.54.17}/wbportfolio/viewsets/orders/orders.py

@@ -198,22 +198,26 @@ class OrderOrderProposalModelViewSet(
             return Order.objects.none()
 
     def get_queryset(self):
-        return self.orders.annotate(
-            underlying_instrument_isin=F("underlying_instrument__isin"),
-            underlying_instrument_ticker=F("underlying_instrument__ticker"),
-            underlying_instrument_refinitiv_identifier_code=F("underlying_instrument__refinitiv_identifier_code"),
-            underlying_instrument_instrument_type=Case(
-                When(
-                    underlying_instrument__parent__is_security=True,
-                    then=F("underlying_instrument__parent__instrument_type__short_name"),
+        return (
+            self.orders.exclude(underlying_instrument__is_cash=True)
+            .annotate(
+                underlying_instrument_isin=F("underlying_instrument__isin"),
+                underlying_instrument_ticker=F("underlying_instrument__ticker"),
+                underlying_instrument_refinitiv_identifier_code=F("underlying_instrument__refinitiv_identifier_code"),
+                underlying_instrument_instrument_type=Case(
+                    When(
+                        underlying_instrument__parent__is_security=True,
+                        then=F("underlying_instrument__parent__instrument_type__short_name"),
+                    ),
+                    default=F("underlying_instrument__instrument_type__short_name"),
                 ),
-                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"),
-            security=F("underlying_instrument__parent"),
-            company=F("underlying_instrument__parent__parent"),
-        ).select_related(
-            "underlying_instrument", "underlying_instrument__parent", "underlying_instrument__parent__parent"
+                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"),
+                security=F("underlying_instrument__parent"),
+                company=F("underlying_instrument__parent__parent"),
+            )
+            .select_related(
+                "underlying_instrument", "underlying_instrument__parent", "underlying_instrument__parent__parent"
+            )
         )