wbportfolio 1.46.14__tar.gz → 1.47.1__tar.gz

{wbportfolio-1.46.14 → wbportfolio-1.47.1}/PKG-INFO

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

{wbportfolio-1.46.14 → wbportfolio-1.47.1}/wbportfolio/models/portfolio.py

@@ -85,33 +85,38 @@ class PositionDictConverter:
             self.fx_rates[currency][val_date] = fx_rate
             return fx_rate
 
-    def dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> AssetPosition:
+    def dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> AssetPosition | None:
         underlying_quote = self._get_instrument(instrument_id)
         currency_fx_rate_portfolio_to_usd = self._get_fx_rate(val_date, self.portfolio.currency)
         currency_fx_rate_instrument_to_usd = self._get_fx_rate(val_date, underlying_quote.currency)
-        position = AssetPosition(
-            underlying_quote=underlying_quote,
-            weighting=weighting,
-            date=val_date,
-            asset_valuation_date=val_date,
-            is_estimated=True,
-            portfolio=self.portfolio,
-            currency=underlying_quote.currency,
-            initial_price=self.prices.loc[pd.Timestamp(val_date), instrument_id],
-            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
-            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
-            initial_currency_fx_rate=None,
-            underlying_quote_price=None,
-            underlying_instrument=None,
-        )
-        position.pre_save(
-            infer_underlying_quote_price=self.infer_underlying_quote_price
-        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
-        return position
+        initial_price = self.prices.loc[pd.Timestamp(val_date), instrument_id]
+        # if we cannot find a price for the instrument, we return an empty position
+        if initial_price is not None:
+            position = AssetPosition(
+                underlying_quote=underlying_quote,
+                weighting=weighting,
+                date=val_date,
+                asset_valuation_date=val_date,
+                is_estimated=True,
+                portfolio=self.portfolio,
+                currency=underlying_quote.currency,
+                initial_price=self.prices.loc[pd.Timestamp(val_date), instrument_id],
+                currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
+                currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
+                initial_currency_fx_rate=None,
+                underlying_quote_price=None,
+                underlying_instrument=None,
+            )
+            position.pre_save(
+                infer_underlying_quote_price=self.infer_underlying_quote_price
+            )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
+            return position
 
     def convert(self, positions: dict[date, dict[int, float]]) -> Iterable[AssetPosition]:
         for val_date, weights in positions.items():
-            yield from map(lambda row: self.dict_to_model(val_date, row[0], row[1]), weights.items())
+            yield from filter(
+                lambda x: x, map(lambda row: self.dict_to_model(val_date, row[0], row[1]), weights.items())
+            )
 
 
 class DefaultPortfolioQueryset(QuerySet):
@@ -371,9 +376,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             The instantiated analytic portfolio
         """
         weights = self.get_weights(val_date)
-        instrument_ids = weights.keys()
         return_date = (val_date + BDay(1)).date()
-        returns, prices = self.get_returns(instrument_ids, (val_date - BDay(2)).date(), return_date, **kwargs)
+        returns, prices = self.get_returns((val_date - BDay(2)).date(), return_date, **kwargs)
         if pd.Timestamp(return_date) not in returns.index:
             raise InvalidAnalyticPortfolio()
         returns = returns.fillna(0)  # not sure this is what we want
@@ -753,7 +757,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         next_trade_proposal = None
         rebalancing_date = None
         logger.info(f"compute next weights in batch for {self} from {start_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
-        returns, prices = self.get_returns(weights.keys(), (start_date - BDay(3)).date(), end_date, ffill_returns=True)
+        returns, prices = self.get_returns((start_date - BDay(3)).date(), end_date, ffill_returns=True)
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
             logger.info(f"Processing {to_date:%Y-%m-%d}")
@@ -767,7 +771,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 positions[to_date] = weights
             except KeyError:  # if no return for that date, we break and continue
                 break
-
         positions_generator = PositionDictConverter(self, prices)
         positions = list(positions_generator.convert(positions))
         self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False, evaluate_rebalancer=False)
@@ -1003,7 +1006,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def get_returns(
         self,
-        instruments: Iterable,
         from_date: date,
         to_date: date,
         ffill_returns: bool = True,
@@ -1013,13 +1015,17 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         Utility methods to get instrument returns for a given date range
 
         Args:
-            instruments: instrument to get the returns from
             from_date: date range lower bound
             to_date: date range upper bound
 
         Returns:
             Return a tuple of the returns and the last prices series for conveniance
         """
+        instruments = list(
+            self.assets.filter(date__gte=from_date, date__lte=to_date)
+            .values_list("underlying_quote", flat=True)
+            .distinct("underlying_quote")
+        )
         prices = InstrumentPrice.objects.filter(
             instrument__in=instruments, date__gte=from_date, date__lte=to_date
         ).annotate(
@@ -1044,7 +1050,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if ffill_returns:
             prices_df = prices_df.ffill()
         returns = prices_to_returns(prices_df, drop_inceptions_nan=False, fill_nan=ffill_returns)
-        return returns.replace([np.inf, -np.inf, np.nan], 0), prices_df
+        return returns.replace([np.inf, -np.inf, np.nan], 0), prices_df.replace([np.inf, -np.inf, np.nan], None)
 
     @classmethod
     def get_contribution_df(

{wbportfolio-1.46.14 → wbportfolio-1.47.1}/wbportfolio/tests/models/test_portfolios.py

@@ -1118,7 +1118,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         res = list(Portfolio.objects.all().to_dependency_iterator(weekday))
         assert res == [index_portfolio, dependency_portfolio, dependant_portfolio, undependant_portfolio]
 
-    def test_get_returns(self, instrument_factory, instrument_price_factory, portfolio):
+    def test_get_returns(self, instrument_factory, instrument_price_factory, asset_position_factory, portfolio):
         v1 = date(2025, 1, 1)
         v2 = date(2025, 1, 2)
         v3 = date(2025, 1, 3)
@@ -1129,17 +1129,17 @@ class TestPortfolioModel(PortfolioTestMixin):
         i11 = instrument_price_factory.create(date=v1, instrument=i1)
         i12 = instrument_price_factory.create(date=v2, instrument=i1)
         i13 = instrument_price_factory.create(date=v3, instrument=i1)
+        asset_position_factory.create(date=v1, portfolio=portfolio, underlying_instrument=i1)
+        asset_position_factory.create(date=v3, portfolio=portfolio, underlying_instrument=i2)
         i11.refresh_from_db()
         i12.refresh_from_db()
         i13.refresh_from_db()
-        returns, _ = portfolio.get_returns(
-            [i1.id, i2.id], from_date=v1, to_date=v3, convert_to_portfolio_currency=False
-        )
+        returns, _ = portfolio.get_returns(from_date=v1, to_date=v3, convert_to_portfolio_currency=False)
 
         expected_returns = pd.DataFrame(
-            [[i12.net_value / i11.net_value - 1], [i13.net_value / i12.net_value - 1]],
+            [[i12.net_value / i11.net_value - 1, 0.0], [i13.net_value / i12.net_value - 1, 0.0]],
             index=[v2, v3],
-            columns=[i1.id],
+            columns=[i1.id, i2.id],
             dtype="float64",
         )
         expected_returns.index = pd.to_datetime(expected_returns.index)

{wbportfolio-1.46.14 → wbportfolio-1.47.1}/wbportfolio/viewsets/configs/menu/portfolios.py

@@ -1,11 +1,9 @@
 from wbcore.menus import ItemPermission, MenuItem
 
-from wbportfolio.permissions import is_portfolio_manager
-
 PortfolioMenuItem = MenuItem(
     label="Portfolios",
     endpoint="wbportfolio:portfolio-list",
-    permission=ItemPermission(method=is_portfolio_manager, permissions=["wbportfolio.view_portfolio"]),
+    permission=ItemPermission(permissions=["wbportfolio.view_portfolio"]),
 )
 
 
@@ -13,5 +11,5 @@ ModelPortfolioMenuItem = MenuItem(
     label="Managed Portfolios",
     endpoint="wbportfolio:portfolio-list",
     endpoint_get_parameters={"is_manageable": True},
-    permission=ItemPermission(method=is_portfolio_manager, permissions=["wbportfolio.view_portfolio"]),
+    permission=ItemPermission(permissions=["wbportfolio.view_portfolio"]),
 )

{wbportfolio-1.46.14 → wbportfolio-1.47.1}/wbportfolio/viewsets/transactions/trades.py

@@ -411,7 +411,7 @@ class TradeTradeProposalModelViewSet(
         return TradeTradeProposalModelSerializer
 
     def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
-        if queryset is not None:
+        if queryset is not None and queryset.exists():
             total_target_weight = queryset.aggregate(c=Sum(F("target_weight")))["c"] or Decimal(0)
             if round(total_target_weight, 3) != 1:
                 warning(request, "The total target weight does not equals to 1")