wbportfolio 1.54.10__tar.gz → 1.54.11__tar.gz

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/PKG-INFO

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

wbportfolio-1.54.11/wbportfolio/migrations/0081_alter_trade_drift_factor.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.14 on 2025-07-16 12:39
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0080_alter_trade_drift_factor_alter_trade_weighting'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='trade',
+            name='drift_factor',
+            field=models.DecimalField(decimal_places=16, default=Decimal('1'), help_text='Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return', max_digits=19, verbose_name='Drift Factor'),
+        ),
+    ]

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/models/portfolio.py

@@ -18,14 +18,16 @@ from django.db.models import (
     Q,
     QuerySet,
     Sum,
+    Value,
 )
+from django.db.models.functions import Coalesce
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
 from skfolio.preprocessing import prices_to_returns
-from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbcore.utils.importlib import import_from_dotted_path
@@ -63,6 +65,7 @@ def get_returns(
     to_date: date,
     to_currency: Currency | None = None,
     ffill_returns: bool = True,
+    use_dl: bool = False,
 ) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
     """
     Utility methods to get instrument returns for a given date range
@@ -70,46 +73,53 @@ def get_returns(
     Args:
         from_date: date range lower bound
         to_date: date range upper bound
+        to_currency: currency to use for returns
+        ffill_returns: whether to ffill returns and prices
+        use_dl: whether to get data straight from the dataloader or use the internal table
 
     Returns:
-        Return a tuple of the returns and the last prices series for conveniance
+        Return a tuple of the raw prices and the returns dataframe
     """
-    # if to_currency:
-    #     fx_rate = CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", to_currency)
-    # else:
-    #     fx_rate = Value(Decimal(1.0))
-    # prices = InstrumentPrice.objects.filter(
-    #     instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date
-    # ).annotate(fx_rate=fx_rate, price_fx_portfolio=F("net_value") * F("fx_rate"))
-    # prices_df = (
-    #     pd.DataFrame(
-    #         prices.filter_only_valid_prices().values_list("instrument", "price_fx_portfolio", "date"),
-    #         columns=["instrument", "price_fx_portfolio", "date"],
-    #     )
-    #     .pivot_table(index="date", values="price_fx_portfolio", columns="instrument")
-    #     .astype(float)
-    #     .sort_index()
-    # )
-    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
-    df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
+    if use_dl:
+        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
+        df = pd.DataFrame(Instrument.objects.filter(id__in=instrument_ids).dl.market_data(**kwargs))
+        if df.empty:
+            raise InvalidAnalyticPortfolio()
+        df = df[["instrument_id", "fx_rate", "close", "valuation_date"]]
+    else:
+        if to_currency:
+            fx_rate = Coalesce(
+                CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", to_currency),
+                Decimal("1"),
+            )
+        else:
+            fx_rate = Value(Decimal("1"))
+        prices = InstrumentPrice.objects.filter(
+            instrument__in=instrument_ids, date__gte=from_date, date__lte=to_date
+        ).annotate(fx_rate=fx_rate)
+        df = pd.DataFrame(
+            prices.filter_only_valid_prices().values_list("instrument", "fx_rate", "net_value", "date"),
+            columns=["instrument_id", "fx_rate", "close", "valuation_date"],
+        )
+
     if df.empty:
         raise InvalidAnalyticPortfolio()
-    df = df[["instrument_id", "fx_rate", "close", "valuation_date"]].pivot(
-        index="valuation_date", columns="instrument_id", values=["fx_rate", "close"]
+    df = (
+        df.pivot_table(index="valuation_date", columns="instrument_id", values=["fx_rate", "close"])
+        .astype(float)
+        .sort_index()
     )
     ts = pd.bdate_range(df.index.min(), df.index.max(), freq="B")
     df = df.reindex(ts)
     if ffill_returns:
         df = df.ffill()
     df.index = pd.to_datetime(df.index)
-
     prices_df = df["close"]
     fx_rate_df = df["fx_rate"]
-
     returns = prices_to_returns(fx_rate_df * 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(
+    return {ts.date(): row for ts, row in prices_df.to_dict("index").items()}, returns.replace(
         [np.inf, -np.inf, np.nan], 0
     )
 
@@ -833,6 +843,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             end_date,
             to_currency=self.currency,
             ffill_returns=True,
+            use_dl=True,
         )
         # Get raw prices to speed up asset position creation
         # Instantiate the position iterator with the initial weights
@@ -849,7 +860,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 drifted_weights = analytic_portfolio.get_next_weights()
             except KeyError:  # if no return for that date, we break and continue
                 drifted_weights = weights
-
             if rebalancer and rebalancer.is_valid(to_date):
                 effective_portfolio = PortfolioDTO(
                     positions=[

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/models/transactions/trade_proposals.py

@@ -366,6 +366,8 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         trade.weighting = -trade_dto.effective_weight
 
                     trade.save()
+        # final sanity check to make sure invalid trade with effective and target weight of 0 are automatically removed:
+        self.trades.all().annotate_base_info().filter(target_weight=0, effective_weight=0).delete()
 
     def approve_workflow(
         self,

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/models/transactions/trades.py

@@ -230,8 +230,10 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         help_text="The Trade Proposal this trade is coming from",
     )
     drift_factor = models.DecimalField(
-        max_digits=16,
-        decimal_places=TRADE_WEIGHTING_PRECISION,
+        max_digits=TRADE_WEIGHTING_PRECISION * 2
+        + 3,  # we don't expect any drift factor to be in the order of magnitude greater than 1000
+        decimal_places=TRADE_WEIGHTING_PRECISION
+        * 2,  # we need a higher precision for this factor to avoid float inprecision
         default=Decimal(1.0),
         verbose_name="Drift Factor",
         help_text="Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return",

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/pms/analytics/portfolio.py

@@ -16,10 +16,10 @@ class Portfolio(BasePortfolio):
         )
         return df
 
-    def get_next_weights(self) -> dict[int, float]:
+    def get_next_weights(self, round_precision: int = 8) -> dict[int, float]:
         """
         Given the next returns, compute the drifted weights of this portfolio
-
+            round_precision: Round the weight to the given round number and ensure the total weight reflects this. Default to 8 decimals
         Returns:
             A dictionary of weights (instrument ids as keys and weights as values)
         """
@@ -29,7 +29,12 @@ class Portfolio(BasePortfolio):
         next_weights = weights * (returns + 1.0) / portfolio_returns
         next_weights = next_weights.dropna()
         next_weights = next_weights / next_weights.sum()
-        return next_weights.to_dict()
+        if round_precision and not next_weights.empty:
+            next_weights = next_weights.round(round_precision)
+            quantization_error = 1.0 - next_weights.sum()
+            largest_weight = next_weights.idxmax()
+            next_weights.loc[largest_weight] = next_weights.loc[largest_weight] + quantization_error
+        return {i: round(w, round_precision) for i, w in next_weights.items()}  # handle float precision manually
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:
         expected_returns = self.weights @ self.X.iloc[-1, :].T

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -336,6 +336,26 @@ class TestTradeProposal:
         assert t2.weighting == Decimal("0")
         assert t3.weighting == Decimal("0.5")
 
+    def test_reset_trades_remove_invalid_trades(self, trade_proposal, trade_factory, instrument_price_factory):
+        # create a invalid trade and its price
+        invalid_trade = trade_factory.create(trade_proposal=trade_proposal, weighting=0)
+        instrument_price_factory.create(
+            date=invalid_trade.transaction_date, instrument=invalid_trade.underlying_instrument
+        )
+
+        # create a valid trade and its price
+        valid_trade = trade_factory.create(trade_proposal=trade_proposal, weighting=1.0)
+        instrument_price_factory.create(
+            date=valid_trade.transaction_date, instrument=valid_trade.underlying_instrument
+        )
+
+        trade_proposal.reset_trades()
+        assert trade_proposal.trades.get(underlying_instrument=valid_trade.underlying_instrument).weighting == Decimal(
+            "1"
+        )
+        with pytest.raises(Trade.DoesNotExist):
+            trade_proposal.trades.get(underlying_instrument=invalid_trade.underlying_instrument)
+
     # Test replaying trade proposals
     @patch.object(Portfolio, "drift_weights")
     def test_replay(self, mock_fct, trade_proposal_factory):

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/tests/pms/test_analytics.py

@@ -16,9 +16,27 @@ def test_get_next_weights():
     portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
     next_weights = portfolio.get_next_weights()
 
-    assert next_weights[0] == pytest.approx(w0 * (r0 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-6)
-    assert next_weights[1] == pytest.approx(w1 * (r1 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-6)
-    assert next_weights[2] == pytest.approx(w2 * (r2 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-6)
+    assert next_weights[0] == pytest.approx(w0 * (r0 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+    assert next_weights[1] == pytest.approx(w1 * (r1 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+    assert next_weights[2] == pytest.approx(w2 * (r2 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1)), abs=10e-8)
+
+
+def test_get_next_weights_solve_quantization_error():
+    w0 = 0.33333334
+    w1 = 0.33333333
+    w2 = 0.33333333
+    weights = [w0, w1, w2]
+    returns = [1.0, 1.0, 1.0]  # no returns
+    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
+    next_weights = portfolio.get_next_weights(round_precision=8)  # no rounding as number are all 8 decimals
+    assert sum(next_weights.values()) == 1.0
+    next_weights = portfolio.get_next_weights(
+        round_precision=7
+    )  # we expect the weight to be rounded to 6 decimals, which would lead to a total sum of 0.999999
+
+    assert next_weights[0] == 0.3333334
+    assert next_weights[1] == 0.3333333
+    assert next_weights[2] == 0.3333333
 
 
 def test_get_estimate_net_value():

{wbportfolio-1.54.10 → wbportfolio-1.54.11}/wbportfolio/viewsets/assets.py

@@ -133,7 +133,7 @@ class AssetPositionModelViewSet(
             weighting = queryset.aggregate(s=Sum(F("weighting")))["s"]
             aggregates.update(
                 {
-                    "weighting": {"Σ": format_number(weighting, decimal=4)},
+                    "weighting": {"Σ": format_number(weighting, decimal=8)},
                     "total_value_fx_usd": {"Σ": format_number(total_value_fx_usd)},
                 }
             )
@@ -204,7 +204,7 @@ class AssetPositionPortfolioModelViewSet(InstrumentMetricMixin, AssetPositionMod
         total_value_fx_portfolio = queryset.aggregate(s=Sum(F("total_value_fx_portfolio")))["s"]
         aggregates = super().get_aggregates(queryset, paginated_queryset)
         aggregates["total_value_fx_portfolio"] = {"Σ": format_number(total_value_fx_portfolio)}
-        aggregates["weighting"] = {"Σ": format_number(weighting, decimal=4)}
+        aggregates["weighting"] = {"Σ": format_number(weighting, decimal=8)}
         return aggregates
 
     def get_queryset(self):