wbportfolio 1.46.12__tar.gz → 1.46.14__tar.gz

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

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

wbportfolio-1.46.14/wbportfolio/models/exceptions.py

@@ -0,0 +1,2 @@
+class InvalidAnalyticPortfolio(Exception):
+    pass

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

@@ -52,6 +52,7 @@ from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
 from . import ProductGroup
+from .exceptions import InvalidAnalyticPortfolio
 
 logger = logging.getLogger("pms")
 
@@ -373,6 +374,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         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)
+        if pd.Timestamp(return_date) not in returns.index:
+            raise InvalidAnalyticPortfolio()
         returns = returns.fillna(0)  # not sure this is what we want
         return (
             AnalyticPortfolio(
@@ -733,10 +736,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         },
                     )
                     if (
-                        val_date == instrument.prices.latest("date").date
+                        val_date == instrument.last_price_date
                     ):  # if price date is the latest instrument price date, we recompute the last valuation data
                         instrument.update_last_valuation_date()
-                instrument.update_last_valuation_date()
 
     def batch_portfolio(self, start_date: date, end_date: date):
         """
@@ -758,9 +760,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             if rebalancer and rebalancer.is_valid(to_date):
                 rebalancing_date = to_date
                 break
-            last_returns = returns.loc[[to_date_ts], :]
-            analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
-            positions[to_date] = analytic_portfolio.get_next_weights()
+            try:
+                last_returns = returns.loc[[to_date_ts], :]
+                analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
+                weights = analytic_portfolio.get_next_weights()
+                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))
@@ -797,14 +803,15 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             self.is_tracked and not self.is_lookthrough and not is_target_portfolio_imported and from_is_active
         ):  # we cannot propagate a new portfolio for untracked, or look-through or already imported or inactive portfolios
             logger.info(f"computing next weight for {self} from {from_date:%Y-%m-%d} to {to_date:%Y-%m-%d}")
-            analytic_portfolio, to_prices = self.get_analytic_portfolio(from_date)
-            if not to_prices.empty:
-                weights = analytic_portfolio.get_next_weights()
-                positions_generator = PositionDictConverter(
-                    self, to_prices, infer_underlying_quote_price=True
-                ).convert({to_date: weights})
-                positions = list(map(lambda a: _parse_position(a), positions_generator))
-                self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
+            with suppress(InvalidAnalyticPortfolio):
+                analytic_portfolio, to_prices = self.get_analytic_portfolio(from_date)
+                if not to_prices.empty:
+                    weights = analytic_portfolio.get_next_weights()
+                    positions_generator = PositionDictConverter(
+                        self, to_prices, infer_underlying_quote_price=True
+                    ).convert({to_date: weights})
+                    positions = list(map(lambda a: _parse_position(a), positions_generator))
+                    self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
 
     def get_lookthrough_positions(
         self,
@@ -1030,7 +1037,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             .astype(float)
             .sort_index()
         )
-        ts = pd.bdate_range(from_date, to_date, freq="B")
+        if prices_df.empty:
+            raise InvalidAnalyticPortfolio()
+        ts = pd.bdate_range(prices_df.index.min(), prices_df.index.max(), freq="B")
         prices_df = prices_df.reindex(ts)
         if ffill_returns:
             prices_df = prices_df.ffill()
@@ -1225,7 +1234,9 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
             last_price := instrument.get_latest_price(previous_val_date)
         )
     ):
-        with suppress(IndexError):  # we silent any indexerror introduced by no returns for the past days
+        with suppress(
+            IndexError, InvalidAnalyticPortfolio
+        ):  # we silent any indexerror introduced by no returns for the past days
             analytic_portfolio, _ = portfolio.get_analytic_portfolio(previous_val_date)
             return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
@@ -1275,9 +1286,10 @@ def update_portfolio_after_investable_universe(*args, end_date: date | None = No
         end_date = date.today()
     end_date = (end_date + timedelta(days=1) - BDay(1)).date()  # shift in case of business day
     from_date = (end_date - BDay(1)).date()
-    for portfolio in Portfolio.tracked_objects.filter(is_lookthrough=False).to_dependency_iterator(from_date):
-        try:
-            portfolio.propagate_or_update_assets(from_date, end_date)
-        except Exception as e:
-            logger.error(f"Exception while propagating portfolio assets {portfolio}: {e}")
+    for portfolio in Portfolio.tracked_objects.all().to_dependency_iterator(from_date):
+        if not portfolio.is_lookthrough:
+            try:
+                portfolio.propagate_or_update_assets(from_date, end_date)
+            except Exception as e:
+                logger.error(f"Exception while propagating portfolio assets {portfolio}: {e}")
         portfolio.estimate_net_asset_values(end_date)

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

@@ -428,8 +428,10 @@ class TestPortfolioModel(PortfolioTestMixin):
         next_day = (weekday + BDay(1)).date()
 
         portfolio = active_product.portfolio
-        instrument_price_factory.create(date=(weekday - BDay(1)).date(), instrument=instrument)
+        portfolio.currency = instrument.currency
+        portfolio.save()
 
+        instrument_price_factory.create(date=(weekday - BDay(1)).date(), instrument=instrument)
         a1 = asset_position_factory.create(
             portfolio=portfolio, date=weekday, underlying_instrument=instrument, currency=instrument.currency
         )
@@ -1016,41 +1018,45 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert a
 
     def test_batch_portfolio_with_rebalancer(
-        self, weekday, rebalancer_factory, portfolio, asset_position_factory, instrument_price_factory
+        self,
+        weekday,
+        rebalancer_factory,
+        portfolio,
+        asset_position_factory,
+        instrument_price_factory,
+        instrument_factory,
     ):
         middle_date = (weekday + BDay(1)).date()
         rebalancing_date = (middle_date + BDay(1)).date()
 
-        a1 = asset_position_factory.create(date=weekday, portfolio=portfolio, weighting=0.7)
-        a2 = asset_position_factory.create(date=weekday, portfolio=portfolio, weighting=0.3)
-
-        instrument_price_factory.create(instrument=a1.underlying_instrument, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=a1.underlying_instrument, date=weekday)
-        instrument_price_factory.create(instrument=a1.underlying_instrument, date=middle_date)
-        instrument_price_factory.create(instrument=a1.underlying_instrument, date=rebalancing_date)
-        instrument_price_factory.create(instrument=a2.underlying_instrument, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=a2.underlying_instrument, date=weekday)
-        instrument_price_factory.create(instrument=a2.underlying_instrument, date=middle_date)
-        instrument_price_factory.create(instrument=a2.underlying_instrument, date=rebalancing_date)
+        i1 = instrument_factory.create(currency=portfolio.currency)
+        i2 = instrument_factory.create(currency=portfolio.currency)
+        asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i1, weighting=0.7)
+        asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i2, weighting=0.3)
+
+        instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(instrument=i1, date=weekday)
+        instrument_price_factory.create(instrument=i1, date=middle_date)
+        instrument_price_factory.create(instrument=i1, date=rebalancing_date)
+        instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(instrument=i2, date=weekday)
+        instrument_price_factory.create(instrument=i2, date=middle_date)
+        instrument_price_factory.create(instrument=i2, date=rebalancing_date)
 
         rebalancer_factory.create(portfolio=portfolio, frequency="RRULE:FREQ=DAILY;", activation_date=rebalancing_date)
         rebalancing_trade_proposal = portfolio.batch_portfolio(weekday, rebalancing_date)
 
         # check that the position before the rebalancing date were created
-        assert portfolio.assets.get(date=middle_date, underlying_instrument=a1.underlying_instrument)
-        assert portfolio.assets.get(date=middle_date, underlying_instrument=a2.underlying_instrument)
+        assert portfolio.assets.get(date=middle_date, underlying_instrument=i1)
+        assert portfolio.assets.get(date=middle_date, underlying_instrument=i2)
         with pytest.raises(
             AssetPosition.DoesNotExist
         ):  # there is no asset position because the rebalancing stopped it:
             portfolio.assets.get(date=rebalancing_date)
 
         # we expect a equally rebalancing (default) so both trades needs to be created
-        t1 = rebalancing_trade_proposal.trades.get(
-            transaction_date=rebalancing_date, underlying_instrument=a1.underlying_instrument
-        )
-        t2 = rebalancing_trade_proposal.trades.get(
-            transaction_date=rebalancing_date, underlying_instrument=a2.underlying_instrument
-        )
+        t1 = rebalancing_trade_proposal.trades.get(transaction_date=rebalancing_date, underlying_instrument=i1)
+        t2 = rebalancing_trade_proposal.trades.get(transaction_date=rebalancing_date, underlying_instrument=i2)
         assert t1._target_weight == Decimal("0.5")
         assert t2._target_weight == Decimal("0.5")
 
@@ -1060,12 +1066,8 @@ class TestPortfolioModel(PortfolioTestMixin):
         rebalancing_trade_proposal.save()
 
         # check that the rebalancing was applied and position reflect that
-        assert portfolio.assets.get(
-            date=rebalancing_date, underlying_instrument=a1.underlying_instrument
-        ).weighting == Decimal("0.5")
-        assert portfolio.assets.get(
-            date=rebalancing_date, underlying_instrument=a2.underlying_instrument
-        ).weighting == Decimal("0.5")
+        assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i1).weighting == Decimal("0.5")
+        assert portfolio.assets.get(date=rebalancing_date, underlying_instrument=i2).weighting == Decimal("0.5")
 
     def test_bulk_create_positions(self, portfolio, weekday, asset_position_factory, instrument_factory):
         portfolio.is_manageable = False