wbportfolio 1.49.10__tar.gz → 1.49.11__tar.gz

{wbportfolio-1.49.10 → wbportfolio-1.49.11}/PKG-INFO

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

{wbportfolio-1.49.10 → wbportfolio-1.49.11}/wbportfolio/models/asset.py

@@ -88,7 +88,7 @@ class AssetPositionIterator:
         # Initialize data stores with type hints
         self._instruments = {}
         self._fx_rates = defaultdict(dict)
-        self._weights = dict()
+        self._weights = defaultdict(dict)
         self._prices = prices or defaultdict(dict)
         self.positions = dict()
 
@@ -121,7 +121,6 @@ class AssetPositionIterator:
         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)
         price = self._get_price(val_date, underlying_quote)
-
         position = AssetPosition(
             underlying_quote=underlying_quote,
             weighting=weighting,
@@ -173,10 +172,8 @@ class AssetPositionIterator:
             position.portfolio = self.portfolio
             if position.initial_price is not None:
                 self.positions[key] = position
-                try:
-                    self._weights[position.date][position.underlying_quote.id] += float(position.weighting)
-                except KeyError:
-                    self._weights[position.date] = {position.underlying_quote.id: float(position.weighting)}
+                self._weights[position.date][position.underlying_quote.id] = float(position.weighting)
+
         return self
 
     def get_dates(self) -> list[date]:
@@ -185,7 +182,7 @@ class AssetPositionIterator:
 
     def get_weights(self) -> dict[date, dict[int, float]]:
         """Get weight structure with instrument IDs as keys"""
-        return self._weights
+        return dict(self._weights)
 
     def __iter__(self):
         # return an iterable excluding the position without a valid weighting

{wbportfolio-1.49.10 → wbportfolio-1.49.11}/wbportfolio/models/portfolio.py

@@ -54,7 +54,24 @@ if TYPE_CHECKING:
     from wbportfolio.models.transactions.trade_proposals import TradeProposal
 
 
-def to_dict(df: pd.DataFrame) -> dict[date, dict[int, float]]:
+def get_prices(instrument_ids: list[int], from_date: date, to_date: date) -> dict[date, dict[int, float]]:
+    """
+    Utility to fetch raw prices
+    """
+    prices = InstrumentPrice.objects.filter(instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date)
+    df = (
+        pd.DataFrame(
+            prices.filter_only_valid_prices().values_list("instrument", "net_value", "date"),
+            columns=["instrument", "net_value", "date"],
+        )
+        .pivot_table(index="date", values="net_value", columns="instrument")
+        .astype(float)
+        .sort_index()
+    )
+    ts = pd.bdate_range(df.index.min(), df.index.max(), freq="B")
+    df = df.reindex(ts)
+    df = df.ffill()
+    df.index = pd.to_datetime(df.index)
     return {ts.date(): row for ts, row in df.to_dict("index").items()}
 
 
@@ -64,7 +81,7 @@ def get_returns(
     to_date: date,
     to_currency: Currency | None = None,
     ffill_returns: bool = True,
-) -> tuple[pd.DataFrame, pd.DataFrame]:
+) -> pd.DataFrame:
     """
     Utility methods to get instrument returns for a given date range
 
@@ -99,7 +116,7 @@ def get_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 returns.replace([np.inf, -np.inf, np.nan], 0), prices_df.replace([np.inf, -np.inf, np.nan], None)
+    return returns.replace([np.inf, -np.inf, np.nan], 0)
 
 
 class DefaultPortfolioQueryset(QuerySet):
@@ -364,7 +381,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def get_analytic_portfolio(
         self, val_date: date, weights: dict[int, float] | None = None, **kwargs
-    ) -> tuple[AnalyticPortfolio, pd.DataFrame]:
+    ) -> AnalyticPortfolio:
         """
         Return the analytic portfolio associated with this portfolio at the given date
 
@@ -378,18 +395,15 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if not weights:
             weights = self.get_weights(val_date)
         return_date = (val_date + BDay(1)).date()
-        returns, prices = get_returns(
+        returns = get_returns(
             list(weights.keys()), (val_date - BDay(2)).date(), return_date, to_currency=self.currency, **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(
-                X=returns,
-                weights=weights,
-            ),
-            prices,
+        return AnalyticPortfolio(
+            X=returns,
+            weights=weights,
         )
 
     def is_invested_at_date(self, val_date: date) -> bool:
@@ -781,15 +795,18 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             weights = drifted_positions.get_weights()[start_date]
 
         # Get returns and prices data for the whole date range
-        returns, prices = get_returns(
-            list(weights.keys()),
+        instrument_ids = list(weights.keys())
+        returns = get_returns(
+            instrument_ids,
             (start_date - BDay(3)).date(),
             end_date,
             to_currency=self.currency,
             ffill_returns=True,
         )
+        # Get raw prices to speed up asset position creation
+        prices = get_prices(instrument_ids, (start_date - BDay(3)).date(), end_date)
         # Instantiate the position iterator with the initial weights
-        positions = AssetPositionIterator(self, prices=to_dict(prices))
+        positions = AssetPositionIterator(self, prices=prices)
         last_trade_proposal = None
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
@@ -883,10 +900,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
                 setattr(position, "path", path)
                 position.initial_shares = None
-                if portfolio_total_asset_value:
-                    position.initial_shares = (position.weighting * portfolio_total_asset_value) / (
-                        position.price * position.currency_fx_rate
-                    )
+                if portfolio_total_asset_value and (price_fx_portfolio := position.price * position.currency_fx_rate):
+                    position.initial_shares = (position.weighting * portfolio_total_asset_value) / price_fx_portfolio
                 if child_portfolio := position.underlying_quote.primary_portfolio:
                     if with_intermediary_position:
                         yield position
@@ -1191,7 +1206,7 @@ def default_estimate_net_value(
         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, weights=weights)
+            analytic_portfolio = portfolio.get_analytic_portfolio(previous_val_date, weights=weights)
             return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 

{wbportfolio-1.49.10 → wbportfolio-1.49.11}/wbportfolio/tests/models/test_portfolios.py

@@ -925,7 +925,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         a2.refresh_from_db()
 
-        analytic_portfolio, _ = portfolio.get_analytic_portfolio(weekday)
+        analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
         assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
         expected_X = pd.DataFrame(
             [[float(p11.net_value / p10.net_value - Decimal(1)), float(p21.net_value / p20.net_value - Decimal(1))]],
@@ -1139,7 +1139,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         i11.refresh_from_db()
         i12.refresh_from_db()
         i13.refresh_from_db()
-        returns, _ = get_returns([i1.id, i2.id], from_date=v1, to_date=v3)
+        returns = get_returns([i1.id, i2.id], from_date=v1, to_date=v3)
 
         expected_returns = pd.DataFrame(
             [[i12.net_value / i11.net_value - 1, 0.0], [i13.net_value / i12.net_value - 1, 0.0]],