wbfdm 1.55.1__tar.gz → 1.55.3__tar.gz

{wbfdm-1.55.1 → wbfdm-1.55.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbfdm
-Version: 1.55.1
+Version: 1.55.3
 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.55.3/wbfdm/contrib/qa/dataloaders/fx_rates.py

@@ -0,0 +1,45 @@
+from datetime import date, timedelta
+from typing import Iterator
+
+import pypika as pk
+from django.db import connections
+from pypika import Case
+from pypika import functions as fn
+from pypika.enums import Order, SqlTypes
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+
+from wbfdm.dataloaders.protocols import FXRateProtocol
+from wbfdm.dataloaders.types import FXRateDict
+
+
+class DatastreamFXRatesDataloader(FXRateProtocol, Dataloader):
+    def fx_rates(
+        self,
+        from_date: date,
+        to_date: date,
+        target_currency: str,
+    ) -> Iterator[FXRateDict]:
+        currencies = list(self.entities.values_list("currency__key", flat=True))
+        # Define tables
+        fx_rate = pk.Table("DS2FxRate")
+        fx_code = pk.Table("DS2FxCode")
+
+        # Base query to get data we always need unconditionally
+        query = (
+            pk.MSSQLQuery.from_(fx_rate)
+            # We join on _codes, which removes all instruments not in _codes - implicit where
+            .join(fx_code)
+            .on(fx_rate.ExRateIntCode == fx_code.ExRateIntCode)
+            .where((fx_rate.ExRateDate >= from_date) & (fx_rate.ExRateDate <= to_date + timedelta(days=1)))
+            .where((fx_code.ToCurrCode == target_currency) & fx_code.FromCurrCode.isin(currencies))
+            .orderby(fx_rate.ExRateDate, order=Order.desc)
+            .select(
+                fn.Cast(fx_rate.ExRateDate, SqlTypes.DATE).as_("fx_date"),
+                fn.Concat(fx_code.FromCurrCode, fx_code.ToCurrCode).as_("currency_pair"),
+                (Case().when(fx_code.FromCurrCode == target_currency, 1).else_(1 / fx_rate.midrate)).as_("fx_rate"),
+            )
+        )
+        with connections["qa"].cursor() as cursor:
+            cursor.execute(query.get_sql())
+            yield from dictfetchall(cursor, FXRateDict)

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/contrib/qa/dataloaders/market_data.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from contextlib import suppress
 from datetime import date
 from enum import Enum
@@ -7,13 +8,14 @@ from typing import TYPE_CHECKING, Iterator
 
 import pypika as pk
 from django.db import ProgrammingError, connections
-from pypika import Case, Column, MSSQLQuery
+from pypika import Column, MSSQLQuery
 from pypika import functions as fn
 from pypika.enums import Order, SqlTypes
 from pypika.terms import ValueWrapper
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbcore.contrib.dataloader.utils import dictfetchall
 
+from wbfdm.contrib.qa.dataloaders.fx_rates import DatastreamFXRatesDataloader
 from wbfdm.contrib.qa.dataloaders.utils import create_table
 from wbfdm.dataloaders.protocols import MarketDataProtocol
 from wbfdm.dataloaders.types import MarketDataDict
@@ -60,10 +62,19 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
         Returns:
             Iterator[MarketDataDict]: An iterator of dictionaries conforming to the DailyValuationDict.
         """
-
         lookup = {
             f"{k[0]},{k[1]}": v for k, v in self.entities.values_list("dl_parameters__market_data__parameters", "id")
         }
+        fx_rates = defaultdict(dict)
+        if target_currency:
+            if exact_date:
+                from_date = exact_date
+                to_date = exact_date
+            if from_date and to_date:
+                for fx_rate in DatastreamFXRatesDataloader(self.entities).fx_rates(
+                    from_date, to_date, target_currency
+                ):
+                    fx_rates[fx_rate["currency_pair"]][fx_rate["fx_date"]] = fx_rate["fx_rate"]
 
         # Define tables
         pricing = pk.Table("vw_DS2Pricing")
@@ -90,33 +101,7 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
             .orderby(pricing.MarketDate, order=Order.desc)
         )
 
-        # if a target currency is required, we join on the fx tables and set the currency to the desired one
-        # otherwise we just set the currency to whatever the currency is from the instrument
-        fx_rate = None
-        if target_currency:
-            query = query.select(ValueWrapper(target_currency).as_("currency"))
-            fx_code = pk.Table("DS2FxCode")
-            fx_rate = pk.Table("DS2FxRate")
-            query = (
-                query.select(
-                    (Case().when(pricing.Currency == target_currency, 1).else_(1 / fx_rate.midrate)).as_("fx_rate")
-                )
-                # Join FX code table matching currencies and ensuring SPOT rate type
-                .left_join(fx_code)
-                .on(
-                    (fx_code.FromCurrCode == pricing.Currency)
-                    & (fx_code.ToCurrCode == target_currency)
-                    & (fx_code.RateTypeCode == "SPOT")
-                )
-                # Join FX rate table matching internal code and date
-                .left_join(fx_rate)
-                .on((fx_rate.ExRateIntCode == fx_code.ExRateIntCode) & (fx_rate.ExRateDate == pricing.MarketDate))
-                # We filter out rows which do not have a proper fx rate (we exclude same currency conversions)
-                .where((Case().when(pricing.Currency == target_currency, 1).else_(fx_rate.midrate).isnotnull()))
-            )
-
-        else:
-            query = query.select(pricing.Currency.as_("currency"))
+        query = query.select(pricing.Currency.as_("currency"))
 
         # if market cap or shares outstanding are required we need to join with an additional table
         if MarketData.MARKET_CAPITALIZATION in values or MarketData.SHARES_OUTSTANDING in values:
@@ -130,9 +115,6 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
             )
 
             value = pricing_2.Close_
-            if fx_rate and apply_fx_rate:
-                value /= Case().when(pricing_2.Currency == target_currency, 1).else_(fx_rate.midrate)
-
             query = query.select(value.as_("undadjusted_close"))
             query = query.select(
                 MSSQLQuery.from_(num_shares)
@@ -148,9 +130,6 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
         ):
             ds2_value = DS2MarketData[market_data.name].value
             value = getattr(pricing, ds2_value)
-            if fx_rate and apply_fx_rate and market_data is not MarketData.SHARES_OUTSTANDING:
-                value /= Case().when(pricing.Currency == target_currency, 1).else_(fx_rate.midrate)
-
             query = query.select(value.as_(market_data.value))
 
         # Add conditional where clauses
@@ -189,7 +168,18 @@ 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)
+                if target_currency:
+                    try:
+                        fx_rate = fx_rates[f'{row["currency"]}{target_currency}'][row["valuation_date"]] or 1.0
+                        if apply_fx_rate:
+                            for e in MarketData:
+                                if e != MarketData.SHARES_OUTSTANDING and e.value in row and row[e.value]:
+                                    row[e.value] = row[e.value] * fx_rate
+                            row["currency"] = target_currency
+                        row["fx_rate"] = fx_rate
+                    except KeyError:
+                        # if we don't find the fx rate but we asked for it, we invalid that row and do not return it
+                        continue
                 yield row
 
             cursor.execute(MSSQLQuery.drop_table(mapping).get_sql())

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/contrib/qa/dataloaders/statements.py

@@ -239,9 +239,10 @@ class RKDStatementsDataloader(StatementsProtocol, Dataloader):
     ) -> Iterator[StatementDataDict]:
         lookup = {k: v for k, v in self.entities.values_list("dl_parameters__statements__parameters", "id")}
         sql = reported_sql if data_type is DataType.REPORTED else standardized_sql
-        if financials is None:
+        if not financials:
             financials = []
-        external_codes = [RKDFinancial[fin.name].value for fin in financials if fin in RKDFinancial]
+        external_codes = [RKDFinancial[fin.name].value for fin in financials if fin.name in RKDFinancial.__members__]
+
         query, bind_params = JinjaSql(param_style="format").prepare_query(
             sql,
             {
@@ -266,7 +267,6 @@ class RKDStatementsDataloader(StatementsProtocol, Dataloader):
                 # sometime we get None for the year. We default to the period end date year then
                 row["year"] = int(row["year"] or row["period_end_date"].year)
                 row["instrument_id"] = lookup[row["external_identifier"]]
-
                 if financials:
                     try:
                         row["financial"] = Financial[RKDFinancial(row["external_code"]).name].value

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/dataloaders/protocols.py

@@ -7,6 +7,7 @@ from wbfdm.dataloaders.types import (
     ESGControversyDataDict,
     ESGDataDict,
     FinancialDataDict,
+    FXRateDict,
     MarketDataDict,
     OfficerDataDict,
     ReportDateDataDict,
@@ -36,6 +37,15 @@ class AdjustmentsProtocol(Protocol):
     ) -> Iterator[AdjustmentDataDict]: ...
 
 
+class FXRateProtocol(Protocol):
+    def fx_rates(
+        self,
+        from_date: date,
+        to_date: date,
+        target_currency: str,
+    ) -> Iterator[FXRateDict]: ...
+
+
 class MarketDataProtocol(Protocol):
     def market_data(
         self,

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/dataloaders/proxies.py

@@ -9,6 +9,7 @@ from wbfdm.dataloaders.protocols import (
     ESGControversyProtocol,
     ESGProtocol,
     FinancialsProtocol,
+    FXRateProtocol,
     MarketDataProtocol,
     OfficersProtocol,
     ReportDateProtocol,
@@ -20,6 +21,7 @@ from wbfdm.dataloaders.types import (
     ESGControversyDataDict,
     ESGDataDict,
     FinancialDataDict,
+    FXRateDict,
     MarketDataDict,
     OfficerDataDict,
     ReportDateDataDict,
@@ -53,7 +55,8 @@ def _market_data_row_parser(row):
 
 class InstrumentDataloaderProxy(
     DataloaderProxy[
-        AdjustmentsProtocol
+        FXRateProtocol
+        | AdjustmentsProtocol
         | MarketDataProtocol
         | CorporateActionsProtocol
         | OfficersProtocol
@@ -68,6 +71,15 @@ class InstrumentDataloaderProxy(
         for dl in self.iterate_dataloaders("reporting_dates"):
             yield from dl.reporting_dates(only_next=only_next)
 
+    def fx_rates(
+        self,
+        from_date: date,
+        to_date: date,
+        target_currency: str,
+    ) -> Iterator[FXRateDict]:
+        for dl in self.iterate_dataloaders("fx_rates"):
+            yield from dl.fx_rates(from_date, to_date, target_currency)
+
     def adjustments(self, from_date: date | None = None, to_date: date | None = None) -> Iterator[AdjustmentDataDict]:
         for dl in self.iterate_dataloaders("adjustments"):
             yield from dl.adjustments(from_date=from_date, to_date=to_date)

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/dataloaders/types.py

@@ -26,6 +26,12 @@ class BaseDict(TypedDict):
     currency: NotRequired[str]
 
 
+class FXRateDict(TypedDict):
+    currency_pair: str
+    fx_date: date
+    fx_rate: float
+
+
 class MarketDataDict(BaseDict):
     """
     Represents a dictionary for daily valuation data.

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/tasks.py

@@ -1,8 +1,9 @@
+from contextlib import suppress
 from datetime import date, timedelta
 
 from celery import shared_task
 from django.db import transaction
-from django.db.models import Q
+from django.db.models import ProtectedError, Q
 from pandas.tseries.offsets import BDay
 from tqdm import tqdm
 
@@ -89,7 +90,8 @@ def full_synchronization_as_task():
         (Q(name="") & Q(name_repr="")) | (Q(source__in=["qa-ds2-security", "qa-ds2-quote"]) & Q(parent__isnull=True))
     )
     for instrument in qs:
-        instrument.delete()
+        with suppress(ProtectedError):
+            instrument.delete()
     initialize_exchanges()
     initialize_instruments()
     with transaction.atomic():

{wbfdm-1.55.1 → wbfdm-1.55.3}/wbfdm/viewsets/instruments/instrument_prices.py

@@ -174,22 +174,22 @@ class InstrumentPriceInstrumentStatisticsChartView(InstrumentMixin, viewsets.Cha
 
         if self.instrument.related_instruments.count() > 0:
             reference = self.instrument.related_instruments.first().name_repr
-            risk = self.instrument.primary_risk_instrument.name_repr
             df = pd.DataFrame(queryset.values("date", "sharpe_ratio", "correlation", "beta")).replace(
                 [np.inf, -np.inf], np.nan
             )
 
             if not df.empty:
                 df = df.set_index("date").sort_index().dropna()
-                fig.add_trace(
-                    go.Scatter(
-                        x=df.index,
-                        y=df.sharpe_ratio,
-                        mode="lines",
-                        name=f"Sharpe Ratio ({risk})",
-                        hovertemplate=get_hovertemplate_timeserie(currency=""),
+                if risk_instrument := self.instrument.primary_risk_instrument:
+                    fig.add_trace(
+                        go.Scatter(
+                            x=df.index,
+                            y=df.sharpe_ratio,
+                            mode="lines",
+                            name=f"Sharpe Ratio ({risk_instrument.name_repr})",
+                            hovertemplate=get_hovertemplate_timeserie(currency=""),
+                        )
                     )
-                )
                 fig.add_trace(
                     go.Scatter(
                         x=df.index,