wbfdm 1.43.2__py2.py3-none-any.whl → 1.44.1__py2.py3-none-any.whl

wbfdm/analysis/financial_analysis/utils.py

@@ -25,6 +25,7 @@ class Loader:
         calendar_type: CalendarType = CalendarType.FISCAL,
         market_data_values: list[MarketData] | None = None,
         statement_values: list[Financial] | None = None,
+        period_type: PeriodType = PeriodType.ALL,
     ):
         self.instrument = instrument
         self.calendar_type = calendar_type
@@ -35,6 +36,7 @@ class Loader:
         self.statement_values = (
             statement_values  # specify if any extra statement needs to be merged into the dataframe
         )
+        self.period_type = period_type
         self.errors: dict[str, list[str]] = defaultdict(list)
 
     def load(self) -> pd.DataFrame:
@@ -54,9 +56,9 @@ class Loader:
         df = pd.DataFrame(
             Instrument.objects.filter(id=self.instrument.id).dl.financials(
                 values=self.values,
-                period_type=PeriodType.ALL,
                 from_year=date.today().year - 5,
                 calendar_type=self.calendar_type,
+                period_type=self.period_type,
             )
         )
         if df.empty:

wbfdm/contrib/qa/dataloaders/adjustments.py

@@ -1,56 +1,69 @@
+from contextlib import suppress
 from datetime import date
-from itertools import batched  # type: ignore
+from itertools import batched
 from typing import Iterator
 
-from django.db import connections
-from jinjasql import JinjaSql  # type: ignore
+from django.db import ProgrammingError, connections
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.contrib.qa.dataloaders.utils import SOURCE_DS2
 from wbfdm.dataloaders.protocols import AdjustmentsProtocol
 from wbfdm.dataloaders.types import AdjustmentDataDict
 
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes, Order
+from pypika.terms import LiteralValue
+
 
 class DatastreamAdjustmentsDataloader(AdjustmentsProtocol, Dataloader):
-    def adjustments(self, from_date: date, to_date: date) -> Iterator[AdjustmentDataDict]:
+    def adjustments(self, from_date: date | None = None, to_date: date | None = None) -> Iterator[AdjustmentDataDict]:
         lookup = {k: v for k, v in self.entities.values_list("dl_parameters__adjustments__parameters", "id")}
 
-        sql = """
-            SELECT
-                InfoCode as external_identifier,
-                CONCAT(InfoCode, '_', CONVERT(DATE, AdjDate)) as id,
-                CONVERT(DATE, AdjDate) as adjustment_date,
-                CONVERT(DATE, EndAdjDate) as adjustment_end_date,
-                'qa-ds2' as source,
-                AdjFactor as adjustment_factor,
-                CumAdjFactor as cumulative_adjustment_factor
-
-            FROM Ds2Adj
-            WHERE
-            AdjType = 2
-            AND (
-                {% for instrument in instruments %}
-                    InfoCode = {{instrument}} {% if not loop.last %} OR {% endif %}
-                {% endfor %}
-            )
-            {% if from_date %} AND AdjDate >= {{ from_date }} {% endif %}
-            {% if to_date %} AND AdjDate <= {{ to_date }} {% endif %}
-
-            ORDER BY AdjDate DESC
-        """
-        for batch in batched(lookup.keys(), 1000):
-            query, bind_params = JinjaSql(param_style="format").prepare_query(
-                sql,
-                {
-                    "instruments": batch,
-                    "from_date": from_date,
-                    "to_date": to_date,
-                },
+        adj = pk.Table("DS2Adj")
+        adj_date = fn.Cast(adj.AdjDate, SqlTypes.DATE).as_("adjustment_date")
+        adj_end_date = fn.Cast(adj.EndAdjDate, SqlTypes.DATE).as_("adjustment_end_date")
+
+        infocode = pk.Table("#ds2infocode")
+
+        query = (
+            pk.MSSQLQuery.select(
+                adj.InfoCode.as_("external_identifier"),
+                fn.Concat(adj.InfoCode, "_", adj_date).as_("id"),
+                adj_date,
+                adj_end_date,
+                SOURCE_DS2,
+                adj.AdjFactor.as_("adjustment_factor"),
+                adj.CumAdjFactor.as_("cumulative_adjustement_factor"),
             )
-            with connections["qa"].cursor() as cursor:
+            .from_(adj)
+            .where(adj.AdjType == 2)
+            .where(adj.InfoCode.isin([LiteralValue("select infocode from #ds2infocode")]))
+            .orderby(adj.AdjDate, order=Order.desc)
+        )
+
+        if from_date:
+            query = query.where(adj.AdjDate >= from_date)
+
+        if to_date:
+            query = query.where(adj.AdjDate <= to_date)
+
+        with connections["qa"].cursor() as cursor:
+            # we suppress an error here, because if the temporary table already exists
+            # then we do not want to fail. It should not fail, but if a previous run did
+            # not clean up the table properly, then at least we do not get stuck here
+            with suppress(ProgrammingError):
                 cursor.execute(
-                    query,
-                    bind_params,
+                    pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
                 )
-                for row in dictfetchall(cursor):
-                    row["instrument_id"] = lookup[row["external_identifier"]]
-                    yield row
+                for batch in batched(lookup.keys(), 1000):
+                    cursor.execute(f"insert into #ds2infocode values {",".join(map(lambda x: f"({x})", batch))};")
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, AdjustmentDataDict):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row
+
+            # here we remove the temporary table again to avoid data spillage
+            # cursor.execute(pk.MSSQLQuery.drop_table(infocode).get_sql())

wbfdm/contrib/qa/dataloaders/corporate_actions.py

@@ -1,13 +1,20 @@
+from contextlib import suppress
 from datetime import date
+from itertools import batched
 from typing import Iterator
 
-from django.db import connections
-from jinjasql import JinjaSql  # type: ignore
+from django.db import ProgrammingError, connections
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.contrib.qa.dataloaders.utils import SOURCE_DS2
 from wbfdm.dataloaders.protocols import CorporateActionsProtocol
 from wbfdm.dataloaders.types import CorporateActionDataDict
 
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes
+from pypika.terms import LiteralValue
+
 
 class DatastreamCorporateActionsDataloader(CorporateActionsProtocol, Dataloader):
     def corporate_actions(
@@ -17,43 +24,46 @@ class DatastreamCorporateActionsDataloader(CorporateActionsProtocol, Dataloader)
     ) -> Iterator[CorporateActionDataDict]:
         lookup = {k: v for k, v in self.entities.values_list("dl_parameters__corporate_actions__parameters", "id")}
 
-        sql = """
-            SELECT
-                InfoCode as external_identifier,
-                CONCAT(InfoCode, '_', CONVERT(DATE, EffectiveDate)) as id,
-                CONVERT(DATE, EffectiveDate) as valuation_date,
-                'qa-ds2' as source,
-                ActionTypeCode as action_code,
-                EventStatusCode as event_code,
-                NumOldShares as old_shares,
-                NumNewShares as new_shares,
-                ISOCurrCode as currency
-
-            FROM Ds2CapEvent
-            WHERE (
-                {% for instrument in instruments %}
-                    InfoCode = {{instrument}} {% if not loop.last %} OR {% endif %}
-                {% endfor %}
+        cap_event = pk.Table("Ds2CapEvent")
+        effective_date = fn.Cast(cap_event.EffectiveDate, SqlTypes.DATE)
+        infocode = pk.Table("#ds2infocode")
+
+        query = (
+            pk.MSSQLQuery.select(
+                cap_event.InfoCode.as_("external_identifier"),
+                fn.Concat(cap_event.InfoCode, "_", effective_date).as_("id"),
+                effective_date.as_("valuation_date"),
+                SOURCE_DS2,
+                cap_event.ActionTypeCode.as_("action_code"),
+                cap_event.EventStatusCode.as_("event_code"),
+                cap_event.NumOldShares.as_("old_shares"),
+                cap_event.NumNewShares.as_("new_shares"),
+                cap_event.ISOCurrCode.as_("currency"),
             )
-            {% if from_date %} AND EffectiveDate >= {{ from_date }} {% endif %}
-            {% if to_date %} AND EffectiveDate <= {{ to_date }} {% endif %}
-
-            ORDER BY EffectiveDate DESC
-        """
-
-        query, bind_params = JinjaSql(param_style="format").prepare_query(
-            sql,
-            {
-                "instruments": self.entities.values_list("dl_parameters__corporate_actions__parameters", flat=True),
-                "from_date": from_date,
-                "to_date": to_date,
-            },
+            .from_(cap_event)
+            .where(cap_event.InfoCode.isin([LiteralValue("select infocode from #ds2infocode")]))
+            .orderby(cap_event.EffectiveDate, order=pk.Order.desc)
         )
+
+        if from_date:
+            query = query.where(cap_event.EffectiveDate >= from_date)
+
+        if to_date:
+            query = query.where(cap_event.EffectiveDate <= to_date)
+
         with connections["qa"].cursor() as cursor:
-            cursor.execute(
-                query,
-                bind_params,
-            )
-            for row in dictfetchall(cursor):
+            # Create temporary table if it doesn't exist
+            with suppress(ProgrammingError):
+                cursor.execute(
+                    pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
+                )
+                for batch in batched(lookup.keys(), 1000):
+                    cursor.execute(f"insert into #ds2infocode values {','.join(map(lambda x: f'({x})', batch))};")
+
+            cursor.execute(query.get_sql())
+            for row in dictfetchall(cursor, CorporateActionDataDict):
                 row["instrument_id"] = lookup[row["external_identifier"]]
                 yield row
+
+            # Clean up temporary table
+            cursor.execute(pk.MSSQLQuery.drop_table(infocode).get_sql())

wbfdm/contrib/qa/dataloaders/market_data.py

@@ -1,12 +1,19 @@
+from contextlib import suppress
+from functools import reduce
+from itertools import batched
 from datetime import date
 from enum import Enum
 from typing import Iterator
+import pypika as pk
+from pypika import Column, MSSQLQuery, functions as fn
+from pypika.enums import SqlTypes, Order
+from pypika.terms import ValueWrapper, LiteralValue
 
-from django.db import connections
-from jinjasql import JinjaSql  # type: ignore
+from django.db import ProgrammingError, connections
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbcore.contrib.dataloader.utils import dictfetchall
 from wbfdm.dataloaders.protocols import MarketDataProtocol
+from wbfdm.contrib.qa.dataloaders.utils import create_table
 from wbfdm.dataloaders.types import MarketDataDict
 from wbfdm.enums import Frequency, MarketData
 
@@ -53,65 +60,83 @@ class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
         }
         value_mapping = [(DS2MarketData[x.name].value, x.value) for x in values or []]
 
-        sql = """
-            SELECT
-                CONCAT(pricing.InfoCode, ',', ExchIntCode) as external_identifier,
-                CONCAT(pricing.InfoCode, ',', ExchIntCode, '_', CONVERT(DATE, MarketDate)) as id,
-                CONVERT(DATE, MarketDate) as valuation_date,
-                'qa-ds2' as source,
-                {% if target_currency %}
-                '{{ target_currency|sqlsafe }}' as 'currency',
-                {% else %}
-                Currency as 'currency',
-                {% endif %}
-                {% for value in values %}
-                {% if target_currency %}
-                    COALESCE(fx_rate.midrate, 1) *
-                {% endif %}
-                {{ value[0][0] | sqlsafe }}{% if value[0][1] %} * {{ value[0][1] | sqlsafe }}{% endif %} as '{{ value[1] | sqlsafe }}'{% if not loop.last %}, {% endif %}
-                {% endfor %}
-            FROM vw_Ds2Pricing as pricing
-            LEFT JOIN DS2MktVal as market_val
-                ON pricing.InfoCode = market_val.InfoCode
-                AND pricing.MarketDate = market_val.ValDate
-            {% if target_currency %}
-            LEFT JOIN Ds2FxCode as fx_code
-                ON fx_code.FromCurrCode = '{{target_currency|sqlsafe}}'
-                AND fx_code.ToCurrCode = pricing.Currency
-                AND fx_code.RateTypeCode = 'SPOT'
-            LEFT JOIN Ds2FxRate as fx_rate
-                ON fx_rate.ExRateIntCode = fx_code.ExRateIntCode
-                AND fx_rate.ExRateDate = pricing.MarketDate
-            {% endif %}
-
-            WHERE (
-                {% for instrument in instruments %}
-                    (pricing.InfoCode = {{instrument[0]}} AND ExchIntCode = {{instrument[1]}}) {% if not loop.last %} OR {% endif %}
-                {% endfor %}
-            )
-            AND AdjType = 2
-            {% if from_date %} AND MarketDate >= {{ from_date }} {% endif %}
-            {% if to_date %} AND MarketDate <= {{ to_date }} {% endif %}
-            {% if exact_date %} AND MarketDate = {{ exact_date }} {% endif %}
+        # Define tables
+        pricing = pk.Table("vw_DS2Pricing")
+        market_val = pk.Table("DS2MktVal")
+        fx_code = pk.Table("DS2FxCode")
+        fx = pk.Table("DS2FxRate")
 
-            ORDER BY MarketDate DESC
-        """
-        query, bind_params = JinjaSql(param_style="format").prepare_query(
-            sql,
-            {
-                "instruments": self.entities.values_list("dl_parameters__market_data__parameters", flat=True),
-                "values": value_mapping,
-                "from_date": from_date,
-                "to_date": to_date,
-                "exact_date": exact_date,
-                "target_currency": target_currency,
-            },
+        mapping, create_mapping_table = create_table(
+            "#ds2infoexchcode", Column("InfoCode", SqlTypes.INTEGER), Column("ExchIntCode", SqlTypes.INTEGER)
         )
-        with connections["qa"].cursor() as cursor:
-            cursor.execute(
-                query,
-                bind_params,
+
+        # Base query to get data we always need unconditionally
+        query = (
+            pk.MSSQLQuery.from_(pricing)
+            .select(
+                fn.Concat(pricing.InfoCode, ",", pricing.ExchIntCode).as_("external_identifier"),
+                fn.Concat(
+                    pricing.InfoCode, ",", pricing.ExchIntCode, "_", fn.Cast(pricing.MarketDate, SqlTypes.DATE)
+                ).as_("id"),
+                fn.Cast(pricing.MarketDate, SqlTypes.DATE).as_("valuation_date"),
+                ValueWrapper("qa-ds2").as_("source"),
+            )
+            .left_join(market_val)
+            .on((pricing.InfoCode == market_val.InfoCode) & (pricing.MarketDate == market_val.ValDate))
+            # We join on _codes, which removes all instruments not in _codes - implicit where
+            .join(mapping)
+            .on((pricing.InfoCode == mapping.InfoCode) & (pricing.ExchIntCode == mapping.ExchIntCode))
+            .where(pricing.AdjType == 2)
+            .orderby(pricing.MarketDate, order=Order.desc)
+        )
+
+        # If we need to convert to a target currency, we need the fx rate table and multiply all values with the fx rate
+        if target_currency:
+            query = (
+                query.select(
+                    ValueWrapper(target_currency).as_("currency"),
+                    *[
+                        (LiteralValue(value[0][0]) * fn.Coalesce(fx.midrate, 1)).as_(value[1])
+                        for value in value_mapping
+                    ],
+                )
+                .left_join(fx_code)
+                .on(
+                    (fx_code.FromCurrCode == target_currency)
+                    & (fx_code.ToCurrCode == pricing.Currency)
+                    & (fx_code.RateTypeCode == "SPOT")
+                )
+                .left_join(fx)
+                .on((fx_code.ExRateIntCode == fx.ExRateIntCode) & (fx.ExRateDate == pricing.MarketDate))
+            )
+        else:
+            query = query.select(
+                pricing.Currency.as_("currency"),
+                *[LiteralValue(value[0][0]).as_(value[1]) for value in value_mapping],
             )
-            for row in dictfetchall(cursor):
+
+        # Add conditional where clauses
+        if from_date:
+            query = query.where(pricing.MarketDate >= from_date)
+
+        if to_date:
+            query = query.where(pricing.MarketDate <= to_date)
+
+        if exact_date:
+            query = query.where(pricing.MarketDate == exact_date)
+
+        with connections["qa"].cursor() as cursor:
+            with suppress(ProgrammingError):
+                cursor.execute(create_mapping_table.get_sql())
+                for batch in batched(
+                    self.entities.values_list("dl_parameters__market_data__parameters", flat=True), 1000
+                ):
+                    cursor.execute(reduce(lambda x, y: x.insert(y), batch, MSSQLQuery.into(mapping)).get_sql())
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, MarketDataDict):
                 row["instrument_id"] = lookup[row["external_identifier"]]
                 yield row
+
+            cursor.execute(MSSQLQuery.drop_table(mapping).get_sql())

wbfdm/contrib/qa/dataloaders/officers.py

@@ -1,11 +1,20 @@
 from typing import Iterator
 
-from django.db import connections
-from jinjasql import JinjaSql  # type: ignore
+from django.db import connections, ProgrammingError
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbcore.contrib.dataloader.utils import dictfetchall
 from wbfdm.dataloaders.protocols import OfficersProtocol
 from wbfdm.dataloaders.types import OfficerDataDict
+from itertools import batched
+from contextlib import suppress
+
+import pypika as pk
+from pypika import functions as fn
+from pypika.enums import SqlTypes
+from pypika.terms import LiteralValue
+
+
+from pypika.analytics import RowNumber
 
 
 class RKDOfficersDataloader(OfficersProtocol, Dataloader):
@@ -14,46 +23,52 @@ class RKDOfficersDataloader(OfficersProtocol, Dataloader):
     ) -> Iterator[OfficerDataDict]:
         lookup = {k: v for k, v in self.entities.values_list("dl_parameters__officers__parameters", "id")}
 
-        sql = """
-            SELECT
-                CONCAT(designation.Code, '-', ROW_NUMBER() OVER (ORDER BY officer.OfficerRank)) as id,
-                designation.Code as external_identifier,
-                designation.Title as position,
-                CONCAT(
+        # Define tables
+        designation = pk.Table("RKDFndCmpOffTitleChg")
+        officer = pk.Table("RKDFndCmpOfficer")
+        temp_codes = pk.Table("#rkd_codes")
+
+        # Build the query
+        query = (
+            pk.MSSQLQuery.select(
+                fn.Concat(designation.Code, "-", RowNumber().orderby(officer.OfficerRank)).as_("id"),
+                designation.Code.as_("external_identifier"),
+                designation.Title.as_("position"),
+                fn.Concat(
                     officer.Prefix,
-                    ' ',
+                    " ",
                     officer.FirstName,
-                    ' ',
+                    " ",
                     officer.LastName,
-                    CASE
-                        WHEN officer.Suffix IS NOT NULL THEN CONCAT(', ', officer.Suffix)
-                        ELSE ''
-                    END
-                ) as name,
-                officer.Age as age,
-                officer.Sex as sex,
-                CONVERT(DATE, designation.DesgStartDt) as start
-            FROM RKDFndCmpOffTitleChg AS designation
-            JOIN RKDFndCmpOfficer AS officer
-                ON designation.Code = officer.Code
-                AND designation.OfficerID = officer.Officerid
-
-            WHERE
-                designation.Code in (
-                {% for instrument in instruments %}
-                    {{instrument}} {% if not loop.last %}, {% endif %}
-                {% endfor %})
-                AND DesgEndDt IS NULL
-
-            ORDER BY
-                officer.OfficerRank
-        """
-        query, bind_params = JinjaSql(param_style="format").prepare_query(sql, {"instruments": lookup.keys()})
-        with connections["qa"].cursor() as cursor:
-            cursor.execute(
-                query,
-                bind_params,
+                    pk.Case().when(officer.Suffix.isnull(), "").else_(fn.Concat(", ", officer.Suffix)),
+                ).as_("name"),
+                officer.Age.as_("age"),
+                officer.Sex.as_("sex"),
+                fn.Cast(designation.DesgStartDt, SqlTypes.DATE).as_("start"),
             )
-            for row in dictfetchall(cursor):
+            .from_(designation)
+            .join(officer)
+            .on((designation.Code == officer.Code) & (designation.OfficerID == officer.Officerid))
+            .where(designation.Code.isin([LiteralValue("select code from #rkd_codes")]))
+            .where(designation.DesgEndDt.isnull())
+            .orderby(officer.OfficerRank)
+        )
+
+        with connections["qa"].cursor() as cursor:
+            # Create and populate temporary table
+            with suppress(ProgrammingError):
+                cursor.execute(
+                    pk.MSSQLQuery.create_table(temp_codes).columns(pk.Column("code", SqlTypes.INTEGER)).get_sql()
+                )
+                for batch in batched(lookup.keys(), 1000):
+                    placeholders = ",".join(map(lambda x: f"('{x}')", batch))
+                    cursor.execute(f"insert into #rkd_codes values {placeholders};")
+
+            cursor.execute(query.get_sql())
+
+            for row in dictfetchall(cursor, OfficerDataDict):
                 row["instrument_id"] = lookup[row["external_identifier"]]
                 yield row
+
+            # Clean up temporary table
+            cursor.execute(pk.MSSQLQuery.drop_table(temp_codes).get_sql())

wbfdm/contrib/qa/dataloaders/utils.py

@@ -0,0 +1,22 @@
+from typing import TYPE_CHECKING
+
+from pypika.terms import ValueWrapper
+from pypika import Column, MSSQLQuery, Table
+
+if TYPE_CHECKING:
+    from pypika.terms import Term
+    from pypika.queries import CreateQueryBuilder
+
+
+def compile_source(source: str) -> "Term":
+    return ValueWrapper(source).as_("source")
+
+
+SOURCE_DS2 = compile_source("qa-ds2")
+SOURCE_RKD = compile_source("qa-rkd")
+SOURCE_IBES = compile_source("qa-ibes")
+
+
+def create_table(tablename: "str", *columns: "Column") -> tuple[Table, "CreateQueryBuilder"]:
+    table = Table(tablename)
+    return table, MSSQLQuery.create_table(table).columns(*columns)

wbfdm/dataloaders/protocols.py

@@ -27,13 +27,13 @@ from wbfdm.enums import (
 
 
 class ReportDateProtocol(Protocol):
-    def reporting_dates(self, only_next: bool = True) -> Iterator[ReportDateDataDict]:
-        ...
+    def reporting_dates(self, only_next: bool = True) -> Iterator[ReportDateDataDict]: ...
 
 
 class AdjustmentsProtocol(Protocol):
-    def adjustments(self, from_date: date, to_date: date) -> Iterator[AdjustmentDataDict]:
-        ...
+    def adjustments(
+        self, from_date: date | None = None, to_date: date | None = None
+    ) -> Iterator[AdjustmentDataDict]: ...
 
 
 class MarketDataProtocol(Protocol):
@@ -45,20 +45,17 @@ class MarketDataProtocol(Protocol):
         exact_date: date | None = None,
         frequency: Frequency = Frequency.DAILY,
         target_currency: str | None = None,
-    ) -> Iterator[MarketDataDict]:
-        ...
+    ) -> Iterator[MarketDataDict]: ...
 
 
 class CorporateActionsProtocol(Protocol):
     def corporate_actions(
         self, from_date: date | None = None, to_date: date | None = None
-    ) -> Iterator[CorporateActionDataDict]:
-        ...
+    ) -> Iterator[CorporateActionDataDict]: ...
 
 
 class OfficersProtocol(Protocol):
-    def officers(self) -> Iterator[OfficerDataDict]:
-        ...
+    def officers(self) -> Iterator[OfficerDataDict]: ...
 
 
 class StatementsProtocol(Protocol):
@@ -73,8 +70,7 @@ class StatementsProtocol(Protocol):
         data_type: DataType = DataType.STANDARDIZED,
         financials: list[Financial] | None = None,
         target_currency: str | None = None,
-    ) -> Iterator[StatementDataDict]:
-        ...
+    ) -> Iterator[StatementDataDict]: ...
 
 
 class FinancialsProtocol(Protocol):
@@ -95,18 +91,15 @@ class FinancialsProtocol(Protocol):
         data_type: DataType = DataType.STANDARDIZED,
         estimate_type: EstimateType = EstimateType.VALID,
         target_currency: str | None = None,
-    ) -> Iterator[FinancialDataDict]:
-        ...
+    ) -> Iterator[FinancialDataDict]: ...
 
 
 class ESGControversyProtocol(Protocol):
-    def esg_controversies(self) -> Iterator[ESGControversyDataDict]:
-        ...
+    def esg_controversies(self) -> Iterator[ESGControversyDataDict]: ...
 
 
 class ESGProtocol(Protocol):
     def esg(
         self,
         values: list[ESG],
-    ) -> Iterator[ESGDataDict]:
-        ...
+    ) -> Iterator[ESGDataDict]: ...

wbfdm/dataloaders/proxies.py

@@ -67,7 +67,7 @@ class InstrumentDataloaderProxy(
         for dl in self.iterate_dataloaders("reporting_dates"):
             yield from dl.reporting_dates(only_next=only_next)
 
-    def adjustments(self, from_date: date, to_date: date) -> Iterator[AdjustmentDataDict]:
+    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/dataloaders/types.py

@@ -33,6 +33,8 @@ class MarketDataDict(BaseDict):
     Attributes:
         valuation_date: date
             The date of valuation.
+        external_identifier: str
+            The external identifier of the instrument
         open: float | None
             The opening value (if available).
         close: float | None
@@ -52,6 +54,7 @@ class MarketDataDict(BaseDict):
     """
 
     valuation_date: date
+    external_identifier: str
 
     open: NotRequired[float]
     close: NotRequired[float]

wbfdm/enums.py

@@ -50,12 +50,12 @@ class Financial(ChoiceEnum):
     NET_INCOME_BEFORE_TAXES = "pbt"
     NET_INCOME = "net_income"
     EPS = "eps"
-    FREE_CASH_FLOW = "fcf"
+    FREE_CASH_FLOW = "free_cash_flow"
     EBITDA = "ebitda"
     EBITDA_PER_SHARE = "ebitda_sh"
     NET_DEBT = "net_debt"
     ENTERPRISE_VALUE = "ev"
-    SHARES_OUTSTANDING = "outstanding_shares"
+    SHARES_OUTSTANDING = "shares_outstanding"
     COST_OF_GOODS_SOLD = "cogs"
     GROSS_PROFIT_MARGIN = "gross_profit_margin"
     SELLING_MARKETING_EXPENSES = "selling_marketing_expenses"
@@ -79,7 +79,7 @@ class Financial(ChoiceEnum):
     CASH_FLOW_FROM_OPERATIONS = "cash_flow_from_operations"
     CAPEX = "capex"
     CASH_FLOW_FROM_INVESTING = "cash_flow_from_investing"
-    FREE_CASH_FLOW_PER_SHARE = "fcf_per_share"
+    FREE_CASH_FLOW_PER_SHARE = "free_cash_flow_per_share"
     TOTAL_DIVIDENDS = "total_dividends"
     CASH_FLOW_FROM_FINANCING = "cash_flow_from_financing"
     CASH_FLOW_PER_SHARE = "cash_flow_per_share"