wbportfolio 1.54.18__tar.gz → 1.54.19__tar.gz

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

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

{wbportfolio-1.54.18 → wbportfolio-1.54.19}/wbportfolio/import_export/handlers/orders.py

@@ -55,5 +55,17 @@ class OrderImportHandler(ImportExportHandler):
         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)
+        total_weight = sum(map(lambda p: p.weighting, positions))
+        if cash_weight := Decimal("1") - total_weight:
+            cash_component = self.order_proposal.cash_component
+            positions.append(
+                Position(
+                    underlying_instrument=cash_component.id,
+                    instrument_type=cash_component.instrument_type.id,
+                    weighting=cash_weight,
+                    currency=cash_component.currency,
+                    date=self.order_proposal.trade_date,
+                    is_cash=cash_component.is_cash,
+                )
+            )
+        self.order_proposal.reset_orders(target_portfolio=Portfolio(positions))

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

@@ -91,14 +91,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         ]
 
     def save(self, *args, **kwargs):
-        if not self.trade_date and self.portfolio.assets.exists():
-            self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
-
         # if a order proposal is created before the existing earliest order proposal, we automatically shift the linked instruments inception date to allow automatic NAV computation since the new inception date
         if not self.portfolio.order_proposals.filter(trade_date__lt=self.trade_date).exists():
-            new_inception_date = (self.trade_date + BDay(1)).date()
-            self.portfolio.instruments.filter(inception_date__gt=new_inception_date).update(
-                inception_date=new_inception_date
+            # we need to set the inception date as the first order proposal trade date (and thus, the first position date). We expect a NAV at 100 then
+            self.portfolio.instruments.filter(inception_date__gt=self.trade_date).update(
+                inception_date=self.trade_date
             )
         super().save(*args, **kwargs)
 
@@ -157,6 +154,12 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             return future_proposals.earliest("trade_date")
         return None
 
+    @property
+    def cash_component(self) -> Cash:
+        return Cash.objects.get_or_create(
+            currency=self.portfolio.currency, defaults={"is_cash": True, "name": self.portfolio.currency.title}
+        )[0]
+
     def get_orders(self):
         base_qs = self.orders.all().annotate(
             last_effective_date=Subquery(
@@ -215,7 +218,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         ),
                         default=models.F("effective_weight"),
                     ),
-                    target_weight=models.F("effective_weight") + models.F("weighting"),
                 )
         return orders.annotate(
             has_warnings=models.Case(
@@ -287,7 +289,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 )
             )
             total_weighting += weighting
-        if with_cash and (cash_weight := Decimal("1") - total_weighting):
+        if portfolio and 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)
@@ -430,7 +432,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         approve_automatically: bool = True,
         silent_exception: bool = False,
         force_reset_order: bool = False,
-        broadcast_changes_at_date: bool = True,
         **reset_order_kwargs,
     ):
         if self.status == OrderProposal.Status.APPROVED:
@@ -453,7 +454,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         if self.status == OrderProposal.Status.SUBMIT:
             logger.info("Approving order proposal ...")
             if approve_automatically and self.portfolio.can_be_rebalanced:
-                self.approve(replay=False, broadcast_changes_at_date=broadcast_changes_at_date)
+                self.approve(replay=False)
 
     def replay(self, broadcast_changes_at_date: bool = True):
         last_order_proposal = self
@@ -461,11 +462,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         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:
-                last_order_proposal.approve_workflow(
-                    silent_exception=True,
-                    force_reset_order=True,
-                    broadcast_changes_at_date=broadcast_changes_at_date,
-                )
+                last_order_proposal.approve_workflow(silent_exception=True, force_reset_order=True)
                 last_order_proposal.save()
                 if last_order_proposal.status != OrderProposal.Status.APPROVED:
                     break
@@ -575,8 +572,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         # Retrieve orders with base information
         orders = self.get_orders()
-        currency = self.portfolio.currency
-
         # Calculate the total target weight of all orders
         total_target_weight = orders.exclude(underlying_instrument__is_cash=True).aggregate(
             s=models.Sum("target_weight")
@@ -589,9 +584,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         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]
+        cash_component = self.cash_component
         # If the portfolio is not only weighting-based, estimate the target shares for the cash component
         if not self.portfolio.only_weighting:
             # Estimate the target shares for the cash component

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

@@ -80,7 +80,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
         if not self.price:
             warnings.append(f"No price for {self.underlying_instrument.computed_str}")
-        if abs(self._target_weight) < 1e-8:
+        if self._target_weight < 1e-8:  # any value below -1e8 will be considered zero
             warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
         return warnings
 

{wbportfolio-1.54.18 → wbportfolio-1.54.19}/wbportfolio/models/portfolio.py

@@ -713,6 +713,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         force_recompute_weighting: bool = False,
         evaluate_rebalancer: bool = True,
         changed_weights: dict[int, float] | None = None,
+        broadcast_changes_at_date: bool = True,
         **kwargs,
     ):
         logger.info(f"change at date for {self} at {val_date}")
@@ -754,14 +755,14 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             if not self.initial_position_date or self.initial_position_date > val_date:
                 self.initial_position_date = val_date
         self.save()
-
-        self.handle_controlling_portfolio_change_at_date(
-            val_date,
-            recompute_weighting=recompute_weighting,
-            force_recompute_weighting=force_recompute_weighting,
-            changed_weights=changed_weights,
-            **kwargs,
-        )
+        if broadcast_changes_at_date:
+            self.handle_controlling_portfolio_change_at_date(
+                val_date,
+                recompute_weighting=recompute_weighting,
+                force_recompute_weighting=force_recompute_weighting,
+                changed_weights=changed_weights,
+                **kwargs,
+            )
 
     def handle_controlling_portfolio_change_at_date(self, val_date: date, **kwargs):
         if self.is_tracked:
@@ -866,7 +867,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 if stop_at_rebalancing:
                     break
                 next_weights = {
-                    trade.underlying_instrument: float(trade._target_weight)
+                    trade.underlying_instrument.id: float(trade._target_weight)
                     for trade in last_order_proposal.get_orders()
                 }
                 positions.add((to_date, next_weights), is_estimated=False)
@@ -1048,7 +1049,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         delete_leftovers: bool = False,
         force_save: bool = False,
         compute_metrics: bool = False,
-        broadcast_changes_at_date: bool = True,
         **kwargs,
     ):
         if positions:
@@ -1097,10 +1097,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         basket_id=self.id,
                         basket_content_type_id=ContentType.objects.get_for_model(Portfolio).id,
                     )
-            if broadcast_changes_at_date:
-                for update_date, changed_weights in positions.get_weights().items():
-                    kwargs.pop("changed_weights", None)
-                    self.change_at_date(update_date, changed_weights=changed_weights, **kwargs)
+            for update_date, changed_weights in positions.get_weights().items():
+                kwargs.pop("changed_weights", None)
+                self.change_at_date(update_date, changed_weights=changed_weights, **kwargs)
 
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):

{wbportfolio-1.54.18 → wbportfolio-1.54.19}/wbportfolio/tests/models/orders/test_order_proposals.py

@@ -474,11 +474,11 @@ class TestOrderProposal:
         instrument.portfolios.add(portfolio)
         tp = order_proposal_factory.create(portfolio=portfolio)
         instrument.refresh_from_db()
-        assert instrument.inception_date == (tp.trade_date + BDay(1)).date()
+        assert instrument.inception_date == tp.trade_date
 
-        tp2 = order_proposal_factory.create(portfolio=portfolio, trade_date=tp.trade_date - BDay(1))
+        tp2 = order_proposal_factory.create(portfolio=portfolio, trade_date=(tp.trade_date - BDay(1)).date())
         instrument.refresh_from_db()
-        assert instrument.inception_date == (tp2.trade_date + BDay(1)).date()
+        assert instrument.inception_date == tp2.trade_date
 
     def test_get_round_lot_size(self, order_proposal, instrument):
         # without a round lot size, we expect no normalization of shares

{wbportfolio-1.54.18 → wbportfolio-1.54.19}/wbportfolio/viewsets/assets.py

@@ -484,9 +484,24 @@ class AssetPositionUnderlyingInstrumentChartViewSet(UserPortfolioRequestPermissi
         fig = make_subplots(specs=[[{"secondary_y": True}]])
         fig = get_default_timeserie_figure(fig)
         if queryset.exists():
-            df_price = (pd.DataFrame(queryset.values("date", "price_fx_usd"))).groupby("date").first()
+            df_weight = pd.DataFrame(queryset.values("date", "weighting", "portfolio__name"))
+            df_weight = df_weight.where(pd.notnull(df_weight), 0)
+            df_weight = df_weight.groupby(["date", "portfolio__name"]).sum().reset_index()
+            min_date = df_weight["date"].min()
+            max_date = df_weight["date"].max()
+
+            df_price = (
+                pd.DataFrame(
+                    self.instrument.prices.filter_only_valid_prices()
+                    .annotate_base_data()
+                    .filter(date__gte=min_date, date__lte=max_date)
+                    .values_list("date", "net_value_usd"),
+                    columns=["date", "price_fx_usd"],
+                )
+                .set_index("date")
+                .sort_index()
+            )
 
-            df_price = df_price.where(pd.notnull(df_price), 0)
             fig.add_trace(
                 go.Scatter(
                     x=df_price.index, y=df_price.price_fx_usd, mode="lines", marker_color="green", name="Price"

{wbportfolio-1.54.18 → wbportfolio-1.54.19}/wbportfolio/viewsets/orders/orders.py

@@ -91,7 +91,6 @@ class OrderOrderProposalModelViewSet(
                 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 = Decimal("1.0") - noncash_aggregates["sum_effective_weight"]
             cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]