wbportfolio 1.54.5__tar.gz → 1.54.7__tar.gz

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/PKG-INFO

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

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/models/asset.py

@@ -112,10 +112,10 @@ class AssetPositionIterator:
                 return fx_rate
 
     def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
-        with suppress(KeyError):
-            if (_p := self._prices[val_date][instrument.id]) is not None:
-                return _p
-        return None
+        try:
+            return self._prices[val_date][instrument.id]
+        except KeyError:
+            return None
 
     def _dict_to_model(self, val_date: date, instrument_id: int, weighting: float, **kwargs) -> "AssetPosition":
         underlying_quote = self._get_instrument(instrument_id)
@@ -585,7 +585,7 @@ class AssetPosition(ImportMixin, models.Model):
 
         if not getattr(self, "currency", None):
             self.currency = self.underlying_quote.currency
-        if not self.underlying_quote_price and infer_underlying_quote_price:
+        if not self.underlying_quote_price and (infer_underlying_quote_price or not self.initial_price):
             try:
                 # We get only the instrument price (and don't create it) because we don't want to create product instrument price on asset position propagation
                 # Instead, we decided to opt for a post_save based system that will assign the missing position price when a price is created

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/models/portfolio.py

@@ -88,22 +88,28 @@ def get_returns(
     #     .astype(float)
     #     .sort_index()
     # )
-    kwargs = dict(from_date=from_date, to_date=to_date, values=[MarketData.CLOSE])
+    kwargs = dict(from_date=from_date, to_date=to_date, values=[MarketData.CLOSE], apply_fx_rate=False)
     if to_currency:
         kwargs["target_currency"] = to_currency.key
-    prices_df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
-    if prices_df.empty:
+    df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
+    if df.empty:
         raise InvalidAnalyticPortfolio()
-    prices_df = prices_df[["instrument_id", "close", "valuation_date"]].pivot(
+    fx_rate_df = df[["instrument_id", "fx_rate", "valuation_date"]].pivot(
+        index="valuation_date", columns="instrument_id", values="fx_rate"
+    )
+
+    prices_df = df[["instrument_id", "close", "valuation_date"]].pivot(
         index="valuation_date", columns="instrument_id", values="close"
     )
-    ts = pd.bdate_range(prices_df.index.min(), prices_df.index.max(), freq="B")
-    prices_df = prices_df.reindex(ts)
+    price_fx_portfolio_df = fx_rate_df * prices_df
+
+    ts = pd.bdate_range(price_fx_portfolio_df.index.min(), price_fx_portfolio_df.index.max(), freq="B")
+    price_fx_portfolio_df = price_fx_portfolio_df.reindex(ts)
     if ffill_returns:
-        prices_df = prices_df.ffill()
-    prices_df.index = pd.to_datetime(prices_df.index)
-    returns = prices_to_returns(prices_df, drop_inceptions_nan=False, fill_nan=ffill_returns)
-    return {ts.date(): row for ts, row in prices_df.replace(np.nan, None).to_dict("index").items()}, returns.replace(
+        price_fx_portfolio_df = price_fx_portfolio_df.ffill()
+    price_fx_portfolio_df.index = pd.to_datetime(price_fx_portfolio_df.index)
+    returns = prices_to_returns(price_fx_portfolio_df, drop_inceptions_nan=False, fill_nan=ffill_returns)
+    return {dt: row for dt, row in prices_df.replace(np.nan, None).to_dict("index").items()}, returns.replace(
         [np.inf, -np.inf, np.nan], 0
     )
 
@@ -702,6 +708,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         force_recompute_weighting: bool = False,
         evaluate_rebalancer: bool = True,
         changed_weights: dict[int, float] | None = None,
+        **kwargs,
     ):
         logger.info(f"change at date for {self} at {val_date}")
 
@@ -743,23 +750,29 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 self.initial_position_date = val_date
         self.save()
 
-        self.handle_controlling_portfolio_change_at_date(val_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):
+    def handle_controlling_portfolio_change_at_date(self, val_date: date, **kwargs):
         if self.is_tracked:
             for rel in PortfolioPortfolioThroughModel.objects.filter(
                 dependency_portfolio=self,
                 type=PortfolioPortfolioThroughModel.Type.PRIMARY,
                 portfolio__is_lookthrough=True,
             ):
-                rel.portfolio.compute_lookthrough(val_date)
+                rel.portfolio.compute_lookthrough(val_date, **kwargs)
             for rel in PortfolioPortfolioThroughModel.objects.filter(
                 dependency_portfolio=self, type=PortfolioPortfolioThroughModel.Type.MODEL
             ):
                 rel.portfolio.evaluate_rebalancing(val_date)
             for dependent_portfolio in self.get_child_portfolios(val_date):
-                dependent_portfolio.change_at_date(val_date)
-                dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
+                dependent_portfolio.change_at_date(val_date, **kwargs)
+                dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date, **kwargs)
 
     def evaluate_rebalancing(self, val_date: date):
         if hasattr(self, "automatic_rebalancer"):
@@ -952,7 +965,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             assets = list(self.assets.filter(date=val_date))
         return assets
 
-    def compute_lookthrough(self, from_date: date, to_date: date | None = None):
+    def compute_lookthrough(self, from_date: date, to_date: date | None = None, **kwargs):
         if not self.primary_portfolio or not self.is_lookthrough:
             raise ValueError(
                 "Lookthrough position can only be computed on lookthrough portfolio with a primary portfolio"
@@ -968,7 +981,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             positions.add(
                 list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
             )
-        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
+        self.bulk_create_positions(positions, delete_leftovers=True, **kwargs)
 
     def update_preferred_classification_per_instrument(self):
         # Function to automatically assign Preferred instrument based on the assets' underlying instruments of the
@@ -1030,7 +1043,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         positions: AssetPositionIterator,
         delete_leftovers: bool = False,
         force_save: bool = False,
-        compute_metrics: bool = True,
+        compute_metrics: bool = False,
         broadcast_changes_at_date: bool = True,
         **kwargs,
     ):

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/models/transactions/trade_proposals.py

@@ -361,7 +361,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         )
                     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:
+                    if not trade.price:
                         trade.price = Decimal("0.0")
                         trade.weighting = -trade_dto.effective_weight
 
@@ -403,9 +403,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
             if not last_trade_proposal_created:
                 logger.info(f"Replaying trade proposal {last_trade_proposal}")
-                last_trade_proposal.portfolio.assets.filter(
-                    date=self.trade_date
-                ).all().delete()  # we delete the existing position and we reapply the trade proposal
                 last_trade_proposal.approve_workflow(
                     silent_exception=True,
                     force_reset_trade=force_reset_trade,
@@ -442,6 +439,13 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 broadcast_changes_at_date=broadcast_changes_at_date,
                 evaluate_rebalancer=False,
             )
+            for draft_tp in TradeProposal.objects.filter(
+                portfolio=self.portfolio,
+                trade_date__gt=last_trade_proposal.trade_date,
+                trade_date__lte=next_trade_date,
+                status=TradeProposal.Status.DRAFT,
+            ):
+                draft_tp.reset_trades()
             if overriding_trade_proposal:
                 last_trade_proposal_created = True
                 last_trade_proposal = overriding_trade_proposal

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/models/transactions/trades.py

@@ -574,7 +574,7 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-        if self.price is None:
+        if not self.price:
             # 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:
@@ -647,9 +647,11 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         asset.pre_save()
         return asset
 
-    def get_price(self) -> Decimal | None:
-        with suppress(ValueError):
-            return Decimal.from_float(self.underlying_instrument.get_price(self.transaction_date))
+    def get_price(self) -> Decimal:
+        try:
+            return self.underlying_instrument.get_price(self.transaction_date)
+        except ValueError:
+            return Decimal("0")
 
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/serializers/transactions/trades.py

@@ -315,9 +315,20 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
     )
 
     status = wb_serializers.ChoiceField(default=Trade.Status.DRAFT, choices=Trade.Status.choices)
-    weighting = wb_serializers.DecimalField(max_digits=7, decimal_places=6)
-    target_weight = wb_serializers.DecimalField(max_digits=7, decimal_places=6, required=False, default=0)
-    effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=7, decimal_places=6, default=0)
+
+    target_weight = wb_serializers.DecimalField(
+        max_digits=Trade.TRADE_WEIGHTING_PRECISION + 1,
+        decimal_places=Trade.TRADE_WEIGHTING_PRECISION,
+        required=False,
+        default=0,
+    )
+    effective_weight = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=Trade.TRADE_WEIGHTING_PRECISION + 1,
+        decimal_places=Trade.TRADE_WEIGHTING_PRECISION,
+        default=0,
+    )
+
     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)
 

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/tests/models/test_portfolios.py

@@ -282,7 +282,13 @@ class TestPortfolioModel(PortfolioTestMixin):
         dependent_portfolio.depends_on.add(base_portfolio)
         base_portfolio.change_at_date(weekday)
 
-        mock_compute_lookthrough.assert_called_once_with(dependent_portfolio, weekday)
+        mock_compute_lookthrough.assert_called_once_with(
+            dependent_portfolio,
+            weekday,
+            recompute_weighting=False,
+            force_recompute_weighting=False,
+            changed_weights=None,
+        )
 
     def test_is_active_at_date(
         self,
@@ -1083,7 +1089,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i1)
 
         # check initial creation
-        portfolio.bulk_create_positions(AssetPositionIterator(portfolio).add([a1]))
+        portfolio.bulk_create_positions(AssetPositionIterator(portfolio).add([a1]), compute_metrics=True)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a1.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i1
 

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -7,7 +7,7 @@ import pytest
 from faker import Faker
 from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
-from wbportfolio.models import Portfolio, RebalancingModel, TradeProposal
+from wbportfolio.models import Portfolio, RebalancingModel, Trade, TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position
 
@@ -273,7 +273,7 @@ class TestTradeProposal:
 
         # build the target portfolio
         target_portfolio = PortfolioDTO(
-            positions=(
+            [
                 Position(
                     underlying_instrument=i2.id,
                     date=trade_proposal.trade_date,
@@ -286,7 +286,7 @@ class TestTradeProposal:
                     weighting=Decimal("0.6"),
                     price=float(p3.net_value),
                 ),
-            )
+            ]
         )
 
         # Reset trades
@@ -304,7 +304,7 @@ class TestTradeProposal:
 
         # build the target portfolio
         new_target_portfolio = PortfolioDTO(
-            positions=(
+            [
                 Position(
                     underlying_instrument=i1.id,
                     date=trade_proposal.trade_date,
@@ -323,7 +323,7 @@ class TestTradeProposal:
                     weighting=Decimal("0.5"),
                     price=float(p3.net_value),
                 ),
-            )
+            ]
         )
 
         trade_proposal.reset_trades(target_portfolio=new_target_portfolio)
@@ -626,5 +626,31 @@ class TestTradeProposal:
         assert msft_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
         assert apple_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
 
-    def test_invalid_future_trade_proposal(self, trade_proposal):
-        pass
+    def test_replay_reset_draft_trade_proposal(
+        self, instrument, instrument_price_factory, trade_factory, trade_proposal_factory
+    ):
+        trade_proposal = trade_proposal_factory.create(
+            status=TradeProposal.Status.DRAFT, trade_date=date.today() - BDay(2)
+        )
+        instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(2))
+        instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(1))
+        instrument_price_factory.create(instrument=instrument, date=date.today())
+        trade = trade_factory.create(
+            underlying_instrument=instrument,
+            trade_proposal=trade_proposal,
+            weighting=1,
+            status=TradeProposal.Status.DRAFT,
+        )
+        trade_proposal.submit()
+        trade_proposal.approve(replay=False)
+        trade_proposal.save()
+
+        draft_tp = trade_proposal_factory.create(portfolio=trade_proposal.portfolio, trade_date=date.today() - BDay(1))
+        assert not Trade.objects.filter(trade_proposal=draft_tp).exists()
+
+        trade_proposal.replay()
+
+        assert Trade.objects.filter(trade_proposal=draft_tp).count() == 1
+        assert Trade.objects.get(
+            trade_proposal=draft_tp, underlying_instrument=trade.underlying_instrument
+        ).weighting == Decimal("0")

{wbportfolio-1.54.5 → wbportfolio-1.54.7}/wbportfolio/viewsets/transactions/trade_proposals.py

@@ -99,8 +99,7 @@ class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
     def reset(self, request, pk=None):
         trade_proposal = get_object_or_404(TradeProposal, pk=pk)
         if trade_proposal.status == TradeProposal.Status.DRAFT:
-            trade_proposal.trades.all().delete()
-            trade_proposal.reset_trades(force_reset_trade=True)
+            trade_proposal.reset_trades()
             return Response({"send": True})
         return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)