wbfdm 1.54.20__tar.gz → 1.54.22__tar.gz

{wbfdm-1.54.20 → wbfdm-1.54.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbfdm
-Version: 1.54.20
+Version: 1.54.22
 Summary: The workbench module ensures rapid access to diverse financial data (market, fundamental, forecasts, ESG), with features for storing instruments, classifying them, and conducting financial analysis.
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: roman==4.*

{wbfdm-1.54.20 → wbfdm-1.54.22}/wbfdm/contrib/qa/dataloaders/market_data.py

@@ -189,7 +189,7 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
 
                 if MarketData.SHARES_OUTSTANDING in values:
                     row["outstanding_shares"] = (row["market_capitalization"] / row["close"]) if row["close"] else None
-
+                row["fx_rate"] = row.get("fx_rate", 1.0)
                 yield row
 
             cursor.execute(MSSQLQuery.drop_table(mapping).get_sql())

{wbfdm-1.54.20 → wbfdm-1.54.22}/wbfdm/models/instruments/instruments.py

@@ -139,6 +139,12 @@ class InstrumentManager(TreeManager):
     def filter_active_at_date(self, val_date: date):
         return self.get_queryset().filter_active_at_date(val_date)
 
+    def get_instrument_prices_from_market_data(self, **kwargs):
+        return self.get_queryset().get_instrument_prices_from_market_data(**kwargs)
+
+    def get_returns_df(self, **kwargs) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
+        return self.get_queryset().get_returns_df(**kwargs)
+
 
 class SecurityInstrumentManager(InstrumentManager):
     def get_queryset(self) -> InstrumentQuerySet:

{wbfdm-1.54.20 → wbfdm-1.54.22}/wbfdm/models/instruments/querysets.py

@@ -1,6 +1,6 @@
 import logging
 from contextlib import suppress
-from datetime import date
+from datetime import date, timedelta
 from decimal import Decimal
 
 import numpy as np
@@ -9,6 +9,7 @@ from django.core.exceptions import MultipleObjectsReturned, ValidationError
 from django.core.validators import DecimalValidator
 from django.db.models import (
     AutoField,
+    Case,
     Exists,
     ExpressionWrapper,
     F,
@@ -16,9 +17,12 @@ from django.db.models import (
     Q,
     QuerySet,
     Subquery,
+    Value,
+    When,
 )
 from django.db.models.functions import Coalesce
-from wbcore.contrib.currency.models import CurrencyFXRates
+from skfolio.preprocessing import prices_to_returns
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 
 from wbfdm.enums import MarketData
 
@@ -177,3 +181,80 @@ class InstrumentQuerySet(QuerySet):
                 yield from filter(
                     lambda x: x, map(lambda row: _dict_to_object(instrument, row), dff.to_dict("records"))
                 )
+
+    def get_returns_df(
+        self, from_date: date, to_date: date, to_currency: Currency | None = None, use_dl: bool = False
+    ) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
+        """
+        Utility methods to get instrument returns for a given date range
+
+        Args:
+            from_date: date range lower bound
+            to_date: date range upper bound
+            to_currency: currency to use for returns
+            use_dl: whether to get data straight from the dataloader or use the internal table
+
+        Returns:
+            Return a tuple of the raw prices and the returns dataframe
+        """
+        padded_from_date = from_date - timedelta(days=15)
+        padded_to_date = to_date + timedelta(days=3)
+        logger.info(
+            f"Loading returns from {from_date:%Y-%m-%d} (padded to {padded_from_date:%Y-%m-%d}) to {to_date:%Y-%m-%d} (padded to {padded_to_date:%Y-%m-%d})"
+        )
+
+        if use_dl:
+            kwargs = dict(
+                from_date=padded_from_date, to_date=padded_to_date, values=[MarketData.CLOSE], apply_fx_rate=False
+            )
+            if to_currency:
+                kwargs["target_currency"] = to_currency.key
+            df = pd.DataFrame(self.dl.market_data(**kwargs))
+            if df.empty:
+                df = pd.DataFrame(columns=["instrument_id", "fx_rate", "close", "valuation_date"])
+            else:
+                df = df[["instrument_id", "fx_rate", "close", "valuation_date"]]
+        else:
+            from wbfdm.models import InstrumentPrice
+
+            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"))
+            # annotate fx rate only if the price is not calculated, in that case we assume the instrument is not tradable and we set a forex of None (to be fast forward filled)
+            prices = InstrumentPrice.objects.filter(
+                instrument__in=self, date__gte=padded_from_date, date__lte=padded_to_date
+            ).annotate(fx_rate=Case(When(calculated=False, then=fx_rate), default=None))
+            df = pd.DataFrame(
+                prices.filter_only_valid_prices().values_list("instrument", "fx_rate", "net_value", "date"),
+                columns=["instrument_id", "fx_rate", "close", "valuation_date"],
+            )
+        df = (
+            df.pivot_table(index="valuation_date", columns="instrument_id", values=["fx_rate", "close"], dropna=False)
+            .astype(float)
+            .sort_index()
+        )
+        if not df.empty:
+            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)
+            df = df[
+                (df.index <= pd.Timestamp(to_date)) & (df.index >= pd.Timestamp(from_date))
+            ]  # ensure the returned df corresponds to requested date range
+            prices_df = df["close"]
+
+            if "fx_rate" in df.columns:
+                fx_rate_df = df["fx_rate"].fillna(1.0)
+            else:
+                fx_rate_df = pd.DataFrame(np.ones(prices_df.shape), index=prices_df.index, columns=prices_df.columns)
+            returns = prices_to_returns(fx_rate_df * prices_df, drop_inceptions_nan=False, fill_nan=True)
+            return {ts.date(): row for ts, row in prices_df.to_dict("index").items()}, returns.replace(
+                [np.inf, -np.inf, np.nan], 0
+            )
+        return {}, pd.DataFrame()

wbfdm-1.54.22/wbfdm/tests/models/test_queryset.py

@@ -0,0 +1,89 @@
+from datetime import date
+from decimal import Decimal
+
+import pandas as pd
+import pytest
+
+from wbfdm.models import Instrument
+
+
+@pytest.mark.django_db
+class TestInstrumentQueryset:
+    def test_get_returns(self, instrument_factory, instrument_price_factory):
+        v1 = date(2024, 12, 31)
+        v2 = date(2025, 1, 1)
+        v3 = date(2025, 1, 2)
+        v4 = date(2025, 1, 3)
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        i11 = instrument_price_factory.create(date=v1, instrument=i1)
+        i12 = instrument_price_factory.create(date=v2, instrument=i1)
+        i14 = instrument_price_factory.create(date=v4, instrument=i1)
+        i21 = instrument_price_factory.create(date=v1, instrument=i2)
+        i11.refresh_from_db()
+        i12.refresh_from_db()
+        i14.refresh_from_db()
+        prices, returns = Instrument.objects.filter(id__in=[i1.id, i2.id]).get_returns_df(from_date=v1, to_date=v4)
+
+        expected_returns = pd.DataFrame(
+            [[i12.net_value / i11.net_value - 1, 0.0], [0.0, 0.0], [i14.net_value / i12.net_value - 1, 0.0]],
+            index=[v2, v3, v4],
+            columns=[i1.id, i2.id],
+            dtype="float64",
+        )
+        expected_returns.index = pd.to_datetime(expected_returns.index)
+        pd.testing.assert_frame_equal(returns, expected_returns, check_names=False, check_freq=False, atol=1e-6)
+        assert prices[v1][i1.id] == float(i11.net_value)
+        assert prices[v2][i1.id] == float(i12.net_value)
+        assert prices[v3][i1.id] == float(i12.net_value)
+        assert prices[v4][i1.id] == float(i14.net_value)
+        # test that the returned price are ffill
+        assert prices[v1][i2.id] == float(i21.net_value)
+        assert prices[v2][i2.id] == float(i21.net_value)
+        assert prices[v3][i2.id] == float(i21.net_value)
+        assert prices[v4][i2.id] == float(i21.net_value)
+
+    def test_get_returns_fix_forex_on_holiday(
+        self, instrument, instrument_price_factory, currency_fx_rates_factory, currency_factory
+    ):
+        v1 = date(2024, 12, 31)
+        v2 = date(2025, 1, 1)
+        v3 = date(2025, 1, 2)
+
+        target_currency = currency_factory.create()
+        fx_target1 = currency_fx_rates_factory.create(currency=target_currency, date=v1)
+        fx_target2 = currency_fx_rates_factory.create(currency=target_currency, date=v2)  # noqa
+        fx_target3 = currency_fx_rates_factory.create(currency=target_currency, date=v3)
+
+        fx1 = currency_fx_rates_factory.create(currency=instrument.currency, date=v1)
+        fx2 = currency_fx_rates_factory.create(currency=instrument.currency, date=v2)  # noqa
+        fx3 = currency_fx_rates_factory.create(currency=instrument.currency, date=v3)
+
+        i1 = instrument_price_factory.create(net_value=Decimal("100"), date=v1, instrument=instrument)
+        i2 = instrument_price_factory.create(net_value=Decimal("100"), date=v2, instrument=instrument, calculated=True)
+        i3 = instrument_price_factory.create(net_value=Decimal("200"), date=v3, instrument=instrument)
+
+        prices, returns = Instrument.objects.filter(id__in=[instrument.id]).get_returns_df(
+            from_date=v1, to_date=v3, to_currency=target_currency
+        )
+        returns.index = pd.to_datetime(returns.index)
+        assert prices[v1][instrument.id] == float(i1.net_value)
+        assert prices[v2][instrument.id] == float(i2.net_value)
+        assert prices[v3][instrument.id] == float(i3.net_value)
+
+        assert returns.loc[pd.Timestamp(v2), instrument.id] == pytest.approx(
+            float(
+                (i2.net_value * fx_target1.value / fx1.value) / (i1.net_value * fx_target1.value / fx1.value)
+                - Decimal("1")
+            ),
+            abs=10e-8,
+        )  # as v2 as a calculated price, the forex won't apply to it
+        assert returns.loc[pd.Timestamp(v3), instrument.id] == pytest.approx(
+            float(
+                (i3.net_value * fx_target3.value / fx3.value) / (i2.net_value * fx_target1.value / fx1.value)
+                - Decimal("1")
+            ),
+            abs=10e-8,
+        )