wbportfolio 1.54.16__tar.gz → 1.54.18__tar.gz

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/PKG-INFO

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

wbportfolio-1.54.18/wbportfolio/import_export/handlers/orders.py

@@ -0,0 +1,59 @@
+from decimal import Decimal
+from typing import Any, Dict
+
+from django.db import models
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler, ImportState
+from wbcore.contrib.io.utils import nest_row
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+
+from wbportfolio.pms.typing import Portfolio, Position
+
+
+class OrderImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.Order"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.order_proposal = None
+
+    def process_object(
+        self,
+        data: Dict[str, Any],
+        **kwargs,
+    ):
+        from wbportfolio.models import OrderProposal
+
+        data = nest_row(data)
+        underlying_instrument = self.instrument_handler.process_object(
+            data["underlying_instrument"], only_security=False, read_only=True
+        )[0]
+        self.order_proposal = OrderProposal.objects.get(id=data.pop("order_proposal_id"))
+        weighting = data.get("target_weight", data.get("weighting"))
+        shares = data.get("target_shares", data.get("shares", 0))
+        if not weighting:
+            raise DeserializationError("We couldn't figure out the target weight column")
+        position_dto = Position(
+            underlying_instrument=underlying_instrument.id,
+            instrument_type=underlying_instrument.instrument_type.id,
+            weighting=Decimal(weighting),
+            shares=Decimal(shares),
+            currency=underlying_instrument.currency,
+            date=self.order_proposal.trade_date,
+            is_cash=underlying_instrument.is_cash,
+        )
+        return position_dto, ImportState.CREATED
+
+    def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
+        from wbportfolio.models.orders.order_proposals import OrderProposal
+
+        if order_proposal_id := history.get("order_proposal_id"):
+            # if a order proposal is provided, we delete the existing history first as otherwise, it would mess with the target weight computation
+            order_proposal = OrderProposal.objects.get(id=order_proposal_id)
+            order_proposal.orders.all().delete()
+        return self.model.objects.none()
+
+    def _post_processing_objects(self, positions: list[Position], *args, **kwargs):
+        target_portfolio = Portfolio(positions)
+        self.order_proposal.reset_orders(target_portfolio=target_portfolio)

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/wbportfolio/import_export/handlers/trade.py

@@ -25,7 +25,6 @@ class TradeImportHandler(ImportExportHandler):
         self.instrument_handler = InstrumentImportHandler(self.import_source)
         self.register_handler = RegisterImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
-        self.order_proposals = set()
 
     def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
         if (new_register := change_data.get("register")) and (current_register := _object.register):
@@ -35,41 +34,32 @@ class TradeImportHandler(ImportExportHandler):
         return super()._data_changed(_object, change_data, initial_data, **kwargs)
 
     def _deserialize(self, data: Dict[str, Any]):
-        from wbportfolio.models import OrderProposal, Product
+        from wbportfolio.models import Product
 
         if underlying_instrument := data.get("underlying_instrument", None):
             data["underlying_instrument"] = self.instrument_handler.process_object(
                 underlying_instrument, only_security=False, read_only=True
             )[0]
 
-        if order_proposal_id := data.pop("order_proposal_id", None):
-            order_proposal = OrderProposal.objects.get(id=order_proposal_id)
-            self.order_proposals.add(order_proposal)
-            data["value_date"] = order_proposal.last_effective_date
-            data["transaction_date"] = order_proposal.trade_date
-            data["order_proposal"] = order_proposal
-            data["portfolio"] = order_proposal.portfolio
-            data["status"] = "DRAFT"
-        else:
-            if external_id_alternative := data.get("external_id_alternative", None):
-                data["external_id_alternative"] = str(external_id_alternative)
-            if transaction_date_str := data.get("transaction_date", None):
-                data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
-            if value_date_str := data.get("value_date", None):
-                data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
-            if book_date_str := data.get("book_date", None):
-                data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
-            data["portfolio"] = Portfolio._get_or_create_portfolio(
-                self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
-            )
+        if external_id_alternative := data.get("external_id_alternative", None):
+            data["external_id_alternative"] = str(external_id_alternative)
+        if transaction_date_str := data.get("transaction_date", None):
+            data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
+        if value_date_str := data.get("value_date", None):
+            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+        if book_date_str := data.get("book_date", None):
+            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+        data["portfolio"] = Portfolio._get_or_create_portfolio(
+            self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
+        )
 
-            if currency_data := data.get("currency", None):
-                data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
+        if currency_data := data.get("currency", None):
+            data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
 
-            if register_data := data.get("register", None):
-                data["register"] = self.register_handler.process_object(register_data)[0]
+        if register_data := data.get("register", None):
+            data["register"] = self.register_handler.process_object(register_data)[0]
 
-            data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
         if underlying_instrument := data.get("underlying_instrument"):
             if nominal := data.pop("nominal", None):
                 try:
@@ -160,39 +150,30 @@ class TradeImportHandler(ImportExportHandler):
         self.import_source.log += "\nNo trade was successfully matched."
 
     def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
-        from wbportfolio.models.orders.order_proposals import OrderProposal
-
-        if order_proposal_id := history.get("order_proposal_id"):
-            # if a order proposal is provided, we delete the existing history first as otherwise, it would mess with the target weight computation
-            order_proposal = OrderProposal.objects.get(id=order_proposal_id)
-            order_proposal.trades.all().delete()
-            order_proposal.reset_orders()
-            trades = self.model.objects.none()
-        else:
-            trades = self.model.objects.filter(
-                exclude_from_history=False,
-                pending=False,
-                transaction_subtype__in=[
-                    self.model.Type.SUBSCRIPTION,
-                    self.model.Type.REDEMPTION,
-                ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
-            )
-            if transaction_date := history.get("transaction_date"):
-                trades = trades.filter(transaction_date__lte=transaction_date)
-            elif book_date := history.get("book_date"):
-                trades = trades.filter(book_date__lte=book_date)
-            if underlying_instrument_data := history.get("underlying_instrument"):
-                if isinstance(underlying_instrument_data, dict):
-                    trades = trades.filter(
-                        **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
-                    )
-                else:
-                    trades = trades.filter(underlying_instrument__id=underlying_instrument_data)
-
-            elif "underlying_instruments" in history:
-                trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        trades = self.model.objects.filter(
+            exclude_from_history=False,
+            pending=False,
+            transaction_subtype__in=[
+                self.model.Type.SUBSCRIPTION,
+                self.model.Type.REDEMPTION,
+            ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
+        )
+        if transaction_date := history.get("transaction_date"):
+            trades = trades.filter(transaction_date__lte=transaction_date)
+        elif book_date := history.get("book_date"):
+            trades = trades.filter(book_date__lte=book_date)
+        if underlying_instrument_data := history.get("underlying_instrument"):
+            if isinstance(underlying_instrument_data, dict):
+                trades = trades.filter(
+                    **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
+                )
             else:
-                raise ValueError("We cannot estimate history without at least the underlying instrument")
+                trades = trades.filter(underlying_instrument__id=underlying_instrument_data)
+
+        elif "underlying_instruments" in history:
+            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        else:
+            raise ValueError("We cannot estimate history without at least the underlying instrument")
         return trades
 
     def _post_processing_objects(
@@ -201,18 +182,12 @@ class TradeImportHandler(ImportExportHandler):
         modified_objs: list[models.Model],
         unmodified_objs: list[models.Model],
     ):
-        from wbportfolio.models.orders.order_proposals import replay_as_task
-
         for instrument in set(
             map(lambda x: x.underlying_instrument, filter(lambda t: t.is_customer_trade, created_objs + modified_objs))
         ):
             if instrument.instrument_type.key == "product":
                 update_outstanding_shares_as_task.delay(instrument.id)
 
-        # if the trade import relates to a order proposal, we reset the TP after the import to ensure it contains the deleted positions (often forgotten by user)
-        for changed_order_proposal in self.order_proposals:
-            replay_as_task.delay(changed_order_proposal.id)
-
     def _post_processing_updated_object(self, _object):
         if _object.marked_for_deletion:
             _object.marked_for_deletion = False
@@ -231,8 +206,5 @@ class TradeImportHandler(ImportExportHandler):
             self.import_source.log += (
                 f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
             )
-            if trade.order_proposal:
-                trade.delete()
-            else:
-                trade.marked_for_deletion = True
-                trade.save()
+            trade.marked_for_deletion = True
+            trade.save()

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/wbportfolio/models/orders/order_proposals.py

@@ -394,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()
 
@@ -579,7 +578,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         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)
+        total_target_weight = orders.exclude(underlying_instrument__is_cash=True).aggregate(
+            s=models.Sum("target_weight")
+        )["s"] or Decimal(0)
 
         if target_cash_weight is None:
             target_cash_weight = Decimal("1") - total_target_weight

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/wbportfolio/models/orders/orders.py

@@ -9,13 +9,13 @@ from django.db.models import (
 from ordered_model.models import OrderedModel
 from wbcore.contrib.io.mixins import ImportMixin
 
-from wbportfolio.import_export.handlers.trade import TradeImportHandler
+from wbportfolio.import_export.handlers.orders import OrderImportHandler
 from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.transactions.transactions import TransactionMixin
 
 
 class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
-    import_export_handler_class = TradeImportHandler
+    import_export_handler_class = OrderImportHandler
 
     ORDER_WEIGHTING_PRECISION = (
         8  # we need to match the asset position weighting. Skfolio advices using a even smaller number (5)
@@ -145,11 +145,6 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             self, "target_weight", round(self._effective_weight + self.weighting, self.ORDER_WEIGHTING_PRECISION)
         )
 
-    @_target_weight.setter
-    def _target_weight(self, target_weight):
-        self.weighting = Decimal(target_weight) - self._effective_weight
-        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
-
     @property
     @admin.display(description="Target Shares")
     def _target_shares(self) -> Decimal:

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/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))
@@ -423,13 +450,20 @@ class TestOrderProposal:
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
         mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
+        cash = cash_factory.create(currency=order_proposal.portfolio.currency)
         order_factory.create(  # equity trade
             order_proposal=order_proposal,
             value_date=order_proposal.trade_date,
             portfolio=order_proposal.portfolio,
             weighting=Decimal("0.7"),
         )
-
+        order_factory.create(  # cash trade
+            order_proposal=order_proposal,
+            value_date=order_proposal.trade_date,
+            portfolio=order_proposal.portfolio,
+            underlying_instrument=cash,
+            weighting=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")

{wbportfolio-1.54.16 → wbportfolio-1.54.18}/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"
+            )
         )