wbfdm 2.2.4__py2.py3-none-any.whl → 2.2.5__py2.py3-none-any.whl

wbfdm/backends/dto.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass
+class PriceDTO:
+    pk: str
+    instrument: int
+    date: date
+    open: float
+    close: float
+    high: float
+    low: float
+    volume: float
+    market_capitalization: float
+    outstanding_shares: float
+
+    @property
+    def net_value(self) -> float:
+        return self.close
+
+
+@dataclass
+class AdjustmentDTO:
+    pk: str
+    date: date
+    adjustment_factor: float
+    cumulative_adjustment_factor: float
+
+
+@dataclass
+class DividendDTO:
+    pk: str
+    rate: float
+    ex_dividend_date: date
+    payment_date: date

wbfdm/contrib/dsws/dataloaders/market_data.py

@@ -0,0 +1,130 @@
+from contextlib import suppress
+from datetime import date
+from typing import Iterator
+
+from DatastreamPy import DSUserObjectFault
+from django.conf import settings
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbfdm.dataloaders.protocols import MarketDataProtocol
+from wbfdm.dataloaders.types import MarketDataDict
+from wbfdm.enums import Frequency, MarketData
+
+from ..client import Client
+
+FIELD_MAP = {
+    "close": "P",
+    "open": "PO",
+    "high": "PH",
+    "low": "PL",
+    "bid": "PB",
+    "ask": "PA",
+    "vwap": "VWAP",
+    "volume": "VO",
+    "outstanding_shares": "NOSH",
+    "market_capitalization": "MV",
+}
+
+
+class DSWSMarketDataDataloader(MarketDataProtocol, Dataloader):
+    def market_data(
+        self,
+        values: list[MarketData] = [MarketData.CLOSE],
+        from_date: date | None = None,
+        to_date: date | None = None,
+        exact_date: date | None = None,
+        frequency: Frequency = Frequency.DAILY,
+        **kwargs,
+    ) -> Iterator[MarketDataDict]:
+        """Get prices for instruments.
+
+        Args:
+            values (list[MarketData]): List of values to include in the results.
+            from_date (date | None): The starting date for filtering prices. Defaults to None.
+            to_date (date | None): The ending date for filtering prices. Defaults to None.
+            frequency (Frequency): The frequency of the requested data
+
+        Returns:
+            Iterator[MarketDataDict]: An iterator of dictionaries conforming to the DailyValuationDict.
+        """
+        default_lookup = {
+            k: {"id": p, "symbol": v}
+            for k, v, p in self.entities.values_list(
+                "dl_parameters__market_data__parameters__identifier",
+                "dl_parameters__market_data__parameters__price_symbol",
+                "id",
+            )
+        }
+        if (dsws_username := getattr(settings, "REFINITIV_DATASTREAM_USERNAME", None)) and (
+            dsws_password := getattr(settings, "REFINITIV_DATASTREAM_PASSWORD", None)
+        ):
+            with suppress(DSUserObjectFault):
+                client = Client(username=dsws_username, password=dsws_password)
+                default_fields = list(set(map(lambda x: x[1]["symbol"], default_lookup.items())))
+                values_fields = [FIELD_MAP[v.value] for v in values if v.value in FIELD_MAP]
+                fields = list(set(default_fields + values_fields))
+                identifiers = list(default_lookup.keys())
+                parameters: dict[str, str | list[str] | date] = {}
+                if exact_date:
+                    parameters["start"] = exact_date
+                    parameters["end"] = (exact_date + BDay(1)).date()
+                else:
+                    if from_date:
+                        parameters["start"] = from_date.strftime("%Y-%m-%d")
+                    if to_date:
+                        parameters["end"] = to_date.strftime("%Y-%m-%d")
+                for chunked_identifiers in client.get_chunked_list(identifiers, len(fields)):
+                    df = client.get_timeserie_df(chunked_identifiers, fields, **parameters)
+                    for row in df.to_dict("records"):
+                        jsondate = row["Dates"].date()
+                        external_id = row["Instrument"]
+
+                        data = {}
+                        for market_value in values:
+                            data[market_value.value] = row.get(FIELD_MAP[market_value.value], None)
+                        with suppress(KeyError):
+                            if default_symbol := default_lookup[external_id].get("symbol", None):
+                                data["close"] = row[default_symbol]
+                            yield MarketDataDict(
+                                id=f"{default_lookup[external_id]['id']}_{jsondate}",
+                                valuation_date=jsondate,
+                                instrument_id=default_lookup[external_id]["id"],
+                                external_id=external_id,
+                                source="refinitiv-dsws",
+                                **data,
+                                # **{value: field for value, field in zip_longest(values, fields[1:])},
+                            )
+
+    def get_adjustments(
+        self,
+        from_date: date | None = None,
+        to_date: date | None = None,
+        exact_date: date | None = None,
+    ):
+        lookup = dict(self.entities.values_list("external_id", "id"))
+        if (dsws_username := getattr(settings, "REFINITIV_DATASTREAM_USERNAME", None)) and (
+            dsws_password := getattr(settings, "REFINITIV_DATASTREAM_PASSWORD", None)
+        ):
+            with suppress(DSUserObjectFault):
+                client = Client(username=dsws_username, password=dsws_password)
+                identifiers = list(lookup.keys())
+                parameters: dict[str, str | list[str]] = {}
+                if from_date:
+                    parameters["start"] = from_date.strftime("%Y-%m-%d")
+                if to_date:
+                    parameters["end"] = to_date.strftime("%Y-%m-%d")
+                for chunked_identifiers in client.get_chunked_list(identifiers, 1):
+                    df = client.get_timeserie_df(chunked_identifiers, ["AX"], **parameters)
+                    for row in df.to_dict("records"):
+                        jsondate = row["Dates"].date()
+                        del row["Dates"]
+                        external_id = row["Instrument"]
+                        del row["Instrument"]
+                        yield {
+                            "id": f"{lookup[external_id]}_{jsondate}",
+                            "adjustment_date": jsondate,
+                            "instrument_id": lookup[external_id],
+                            "external_id": external_id,
+                            "source": "refinitiv-dsws",
+                            "adjustment_factor": row["AX"],
+                        }

wbfdm/contrib/qa/sync/exchanges.py

@@ -0,0 +1,70 @@
+import pytz
+from django.conf import settings
+from django.db import connections
+from django.db.models import Max
+from wbcore.contrib.dataloader.utils import dictfetchall, dictfetchone
+from wbcore.contrib.geography.models import Geography
+from wbcore.utils.cache import mapping
+from wbfdm.models import Exchange
+from wbfdm.sync.abstract import Sync
+
+
+class QAExchangeSync(Sync[Exchange]):
+    SOURCE = "qa-ds2-exchange"
+
+    def update(self):
+        sql = "SELECT ExchIntCode AS source_id, ExchName AS name, ExchCtryCode AS country_id, ExchMnem AS refinitiv_mnemonic FROM DS2Exchange"
+        Exchange.objects.bulk_create(
+            map(
+                lambda data: Exchange(
+                    source=self.SOURCE,
+                    source_id=data["source_id"],
+                    name=data["name"],
+                    country_id=mapping(Geography.countries, "code_2").get(data["country_id"]),
+                    refinitiv_mnemonic=data["refinitiv_mnemonic"],
+                ),
+                dictfetchall(connections["qa"].cursor().execute(sql)),
+            ),
+            update_conflicts=True,
+            update_fields=["name", "country", "refinitiv_mnemonic"],
+            unique_fields=["source", "source_id"],
+        )
+
+    def update_or_create_item(self, external_id: int) -> Exchange:
+        defaults = self.get_item(external_id)
+        defaults["country_id"] = mapping(Geography.countries, "code_2").get(defaults["country_id"])
+        exchange, _ = Exchange.objects.update_or_create(
+            source=self.SOURCE,
+            source_id=external_id,
+            defaults=defaults,
+        )
+        return exchange
+
+    def update_item(self, item: Exchange) -> Exchange:
+        return self.update_or_create_item(item.source_id)
+
+    def get_item(self, external_id: int) -> dict:
+        sql = "SELECT ExchName AS name, ExchCtryCode AS country_id, ExchMnem AS refinitiv_mnemonic FROM DS2Exchange WHERE ExchIntCode = %s"
+        return dictfetchone(connections["qa"].cursor().execute(sql, (external_id,)))
+
+    def trigger_partial_update(self):
+        max_last_updated = (
+            Exchange.objects.filter(source=self.SOURCE)
+            .aggregate(max_last_updated=Max("last_updated"))
+            .get("max_last_updated")
+        )
+        if max_last_updated is None:
+            self.update()
+        else:
+            with connections["qa"].cursor() as cursor:
+                cursor.execute(
+                    "SELECT MAX(last_user_update) FROM sys.dm_db_index_usage_stats WHERE OBJECT_NAME(object_id) = 'DS2Exchange_changes'"
+                )
+                max_last_updated_qa = (
+                    pytz.timezone(settings.TIME_ZONE).localize(result[0]) if (result := cursor.fetchone()) else None
+                )
+                if max_last_updated_qa and max_last_updated_qa > max_last_updated:
+                    for _, exchange_id in cursor.execute(
+                        "SELECT UpdateFlag_, ExchIntCode FROM DS2Exchange_changes"
+                    ).fetchall():
+                        self.update_or_create_item(exchange_id)

wbfdm/contrib/qa/sync/instruments.py

@@ -0,0 +1,94 @@
+from django.db import connections
+from wbfdm.contrib.qa.sync.utils import (
+    get_item,
+    trigger_partial_update,
+    update_instruments,
+    update_or_create_item,
+)
+from wbfdm.models import Instrument
+from wbfdm.sync.abstract import Sync
+
+
+class QACompanySync(Sync[Instrument]):
+    SOURCE = "qa-ds2-company"
+
+    def update(self, **kwargs):
+        update_instruments("qa/sql/companies.sql", **kwargs)
+
+    def update_or_create_item(self, external_id: int) -> Instrument:
+        return update_or_create_item(external_id, self.get_item, self.SOURCE)
+
+    def update_item(self, item: Instrument) -> Instrument:
+        return self.update_or_create_item(item.source_id)
+
+    def get_item(self, external_id: int) -> dict:
+        return get_item(external_id, "qa/sql/companies.sql")
+
+    def trigger_partial_update(self):
+        trigger_partial_update(
+            Instrument.objects.filter(source=self.SOURCE),
+            "last_update",
+            "DsCmpyCode",
+            "DS2Company_changes",
+            self.update,
+            self.update_or_create_item,
+        )
+
+
+class QAInstrumentSync(Sync[Instrument]):
+    SOURCE = "qa-ds2-security"
+
+    def update(self, **kwargs):
+        update_instruments("qa/sql/instruments.sql", parent_source="qa-ds2-company", **kwargs)
+
+    def update_or_create_item(self, external_id: int) -> Instrument:
+        return update_or_create_item(external_id, self.get_item, self.SOURCE, "qa-ds2-company")
+
+    def update_item(self, item: Instrument) -> Instrument:
+        return self.update_or_create_item(item.source_id)
+
+    def get_item(self, external_id: int) -> dict:
+        return get_item(external_id, "qa/sql/instruments.sql")
+
+    def trigger_partial_update(self):
+        trigger_partial_update(
+            Instrument.objects.filter(source=self.SOURCE),
+            "last_update",
+            "DsSecCode",
+            "DS2Security_changes",
+            self.update,
+            self.update_or_create_item,
+        )
+
+
+class QAQuoteSync(Sync[Instrument]):
+    SOURCE = "qa-ds2-quote"
+
+    def update(self, **kwargs):
+        count = connections["qa"].cursor().execute("SELECT COUNT(*) FROM DS2ExchQtInfo").fetchone()[0]
+        for offset in range(0, count, 100_000):
+            update_instruments(
+                "qa/sql/quotes.sql",
+                parent_source="qa-ds2-security",
+                context={"offset": offset, "batch": 100_000},
+                **kwargs,
+            )
+
+    def update_or_create_item(self, external_id: int) -> Instrument:
+        return update_or_create_item(external_id, self.get_item, self.SOURCE, "qa-ds2-security")
+
+    def update_item(self, item: Instrument) -> Instrument:
+        return self.update_or_create_item(item.source_id)
+
+    def get_item(self, external_id: int) -> dict:
+        return get_item(external_id, "qa/sql/quotes.sql")
+
+    def trigger_partial_update(self):
+        trigger_partial_update(
+            Instrument.objects.filter(source=self.SOURCE),
+            "last_update",
+            "CONCAT(InfoCode, '-', ExchIntCode)",
+            "DS2ExchQtInfo_changes",
+            self.update,
+            self.update_or_create_item,
+        )

wbfdm/contrib/qa/sync/utils.py

@@ -0,0 +1,241 @@
+from contextlib import suppress
+from typing import Callable
+
+import pytz
+from django.conf import settings
+from django.db import connections
+from django.db.models import Max, QuerySet
+from django.template.loader import get_template
+from jinjasql import JinjaSql  # type: ignore
+from tqdm import tqdm
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.dataloader.utils import dictfetchall, dictfetchone
+from wbcore.contrib.geography.models import Geography
+from wbcore.utils.cache import mapping
+from wbfdm.models.exchanges.exchanges import Exchange
+from wbfdm.models.instruments.instruments import Instrument, InstrumentType
+
+BATCH_SIZE: int = 10000
+instrument_type_map = {
+    "ADR": "american_depository_receipt",
+    "CF": "close_ended_fund",
+    "EQ": "equity",
+    "ET": "exchange_traded_fund",
+    "ETC": "exchange_traded_commodity",
+    "ETN": "exchange_traded_note",
+    "EWT": "warrant",
+    "GDR": "global_depository_receipt",
+    "GNSH": "genussschein",
+    "INVT": "investment_trust",
+    "NVDR": "non_voting_depository_receipt",
+    "PREF": "preference_share",
+    "UT": "abc",
+}
+
+
+def get_dataloader_parameters(
+    quote_code: str | None = None,
+    exchange_code: str | None = None,
+    rkd_code: str | None = None,
+    ibes_code: str | None = None,
+) -> dict:
+    dataloader_parameters = dict()
+    if quote_code:
+        dataloader_parameters["adjustments"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.adjustments.DatastreamAdjustmentsDataloader",
+            "parameters": quote_code,
+        }
+        dataloader_parameters["corporate_actions"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.corporate_actions.DatastreamCorporateActionsDataloader",
+            "parameters": quote_code,
+        }
+        if exchange_code:
+            dataloader_parameters["market_data"] = {
+                "path": "wbfdm.contrib.qa.dataloaders.market_data.DatastreamMarketDataDataloader",
+                "parameters": [
+                    quote_code,
+                    exchange_code,
+                ],
+            }
+
+    if rkd_code:
+        dataloader_parameters["officers"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.officers.RKDOfficersDataloader",
+            "parameters": rkd_code,
+        }
+        dataloader_parameters["statements"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.statements.RKDStatementsDataloader",
+            "parameters": rkd_code,
+        }
+
+    if ibes_code:
+        dataloader_parameters["financials"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.financials.IBESFinancialsDataloader",
+            "parameters": ibes_code,
+        }
+        dataloader_parameters["reporting_dates"] = {
+            "path": "wbfdm.contrib.qa.dataloaders.reporting_dates.IbesReportingDateDataloader",
+            "parameters": ibes_code,
+        }
+
+    return dataloader_parameters
+
+
+def convert_data(data, parent_source: str | None = None) -> dict:
+    if len(data.keys()) == 0:
+        return data
+    data["country_id"] = mapping(Geography.countries, "code_2").get(data["country_id"])
+    data["currency_id"] = mapping(Currency.objects).get(data["currency_id"])
+    if instrument_type_id := data.pop("instrument_type_id"):
+        try:
+            data["instrument_type_id"] = mapping(InstrumentType.objects)[
+                instrument_type_map.get(instrument_type_id, instrument_type_id)
+            ]
+        except KeyError:
+            data["instrument_type_id"] = InstrumentType.objects.get_or_create(
+                key=instrument_type_id.lower(),
+                defaults={"name": instrument_type_id.title(), "short_name": instrument_type_id.title()},
+            )[0].pk
+    data["exchange_id"] = mapping(Exchange.objects, "source_id", source="qa-ds2-exchange").get(
+        str(data["exchange_code"])
+    )
+    data["dl_parameters"] = get_dataloader_parameters(
+        data.pop("quote_code"), data.pop("exchange_code"), data.pop("rkd_code"), data.pop("ibes_code")
+    )
+    data["additional_urls"] = urls.split(",") if (urls := data.get("additional_urls")) else []
+    if parent_source:
+        data["parent_id"] = mapping(Instrument.objects, "source_id", source=parent_source).get(str(data["parent_id"]))
+    if (is_primary := data.get("is_primary")) and isinstance(is_primary, str):
+        data["is_primary"] = is_primary.lower().strip() == "y"
+    data.pop("phone")
+    return data
+
+
+def get_instrument_from_data(data, parent_source: str | None = None) -> Instrument | None:
+    if len(data.keys()) == 0:
+        return None
+    instrument = Instrument(**convert_data(data, parent_source))
+    instrument.pre_save()
+    instrument.computed_str = instrument.compute_str()
+    if (
+        instrument.name and instrument.currency and instrument.instrument_type
+    ):  # we return an instrument only if it contains the basic name, currency and type
+        return instrument
+
+
+def _bulk_create_instruments_chunk(instruments: list[Instrument], update_unique_identifiers: bool = False):
+    update_fields = [
+        "name",
+        "dl_parameters",
+        "description",
+        "country",
+        "currency",
+        "parent",
+        "primary_url",
+        "additional_urls",
+        "headquarter_address",
+        "inception_date",
+        "delisted_date",
+        "exchange",
+        "instrument_type",
+        "computed_str",
+        "search_vector",
+        "trigram_search_vector",
+        "is_primary",
+    ]
+    bulk_update_kwargs = {"update_conflicts": True}
+    if update_unique_identifiers:
+        update_fields.extend(
+            [
+                "refinitiv_identifier_code",
+                "refinitiv_mnemonic_code",
+                "isin",
+                "sedol",
+                "valoren",
+                "cusip",
+            ]
+        )
+        bulk_update_kwargs = {"ignore_conflicts": True}
+    Instrument.objects.bulk_create(
+        instruments, update_fields=update_fields, unique_fields=["source", "source_id"], **bulk_update_kwargs
+    )
+
+
+def update_instruments(sql_name: str, parent_source: str | None = None, context=None, debug: bool = False, **kwargs):
+    template = get_template(sql_name, using="jinja").template  # type: ignore
+    if context is None:
+        context = {}
+    query, params = JinjaSql(param_style="format").prepare_query(template, context)
+    instruments = []
+
+    gen = dictfetchall(connections["qa"].cursor().execute(query, params))
+    if debug:
+        gen = tqdm(gen)
+    # we update in batch to be sure to not exhaust resources
+    for row in gen:
+        with suppress(TypeError):  # we don't fail if the given data doesn't satisfy the schema
+            if instrument := get_instrument_from_data(row, parent_source=parent_source):
+                instruments.append(instrument)
+
+        if len(instruments) >= BATCH_SIZE:
+            _bulk_create_instruments_chunk(instruments, **kwargs)
+            instruments = []
+
+    _bulk_create_instruments_chunk(instruments, **kwargs)
+
+
+def update_or_create_item(
+    external_id: int, get_item: Callable, source: str, parent_source: str | None = None
+) -> Instrument:
+    defaults = convert_data(get_item(external_id), parent_source=parent_source)
+
+    dl_parameters = defaults.pop("dl_parameters", {})
+    defaults.pop("source", None)
+    defaults.pop("source_id", None)
+
+    instrument, _ = Instrument.objects.update_or_create(
+        source=source,
+        source_id=external_id,
+        defaults=defaults,
+    )
+
+    for key, value in dl_parameters.items():
+        instrument.dl_parameters[key] = value
+
+    instrument.save()
+
+    return instrument
+
+
+def get_item(external_id: int, template_name: str) -> dict:
+    template = get_template(template_name, using="jinja").template  # type: ignore
+    query, params = JinjaSql(param_style="format").prepare_query(template, {"source_id": external_id})
+    return dictfetchone(connections["qa"].cursor().execute(query, params))
+
+
+def trigger_partial_update(
+    queryset: QuerySet,
+    last_update_field: str,
+    id_field: str,
+    table_change_name: str,
+    update: Callable,
+    update_or_create_item: Callable,
+):
+    max_last_updated = queryset.aggregate(max_last_updated=Max(last_update_field)).get("max_last_updated")
+
+    if max_last_updated is None:
+        update()
+
+    else:
+        with connections["qa"].cursor() as cursor:
+            cursor.execute(
+                f"SELECT MAX(last_user_update) FROM sys.dm_db_index_usage_stats WHERE OBJECT_NAME(object_id) = '{table_change_name}'"
+            )
+            max_last_updated_qa = (
+                pytz.timezone(settings.TIME_ZONE).localize(result[0]) if (result := cursor.fetchone()) else None
+            )
+            if max_last_updated_qa and max_last_updated_qa > max_last_updated:
+                for _, security_id in cursor.execute(
+                    f"SELECT UpdateFlag_, {id_field} FROM {table_change_name}"
+                ).fetchall():
+                    update_or_create_item(security_id)

{wbfdm-2.2.4.dist-info → wbfdm-2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wbfdm
-Version: 2.2.4
+Version: 2.2.5
 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-2.2.4.dist-info → wbfdm-2.2.5.dist-info}/RECORD

@@ -34,9 +34,11 @@ wbfdm/analysis/financial_analysis/utils.py,sha256=ko88qzmt0zv0D1xjvK4OU5VRF7Uu45
 wbfdm/analysis/technical_analysis/__init__.py,sha256=nQdpDl2okzWID6UT7fyfl36RSLNO1ZZzxRt_mkGVVkY,50
 wbfdm/analysis/technical_analysis/technical_analysis.py,sha256=MkK5HrLz9_TCVAv4qDDZjx6EIqsvusMYB7ybg3MvSsg,4961
 wbfdm/analysis/technical_analysis/traces.py,sha256=1wzmW7JcQXki0q14TdG36tacZpIFJ_bO4KHx_5TgNxc,6371
+wbfdm/backends/dto.py,sha256=5IdeGVsrk8trEi9rqtq-zisqiEDE_VLBP8RxlfZZnjk,596
 wbfdm/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbfdm/contrib/dsws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbfdm/contrib/dsws/client.py,sha256=DFsKj8LultW1MlTlxl1EHuzuZW7UcIIy25v0L2HM5Z4,13788
+wbfdm/contrib/dsws/dataloaders/market_data.py,sha256=TVL0Vzmg8hDzjbqBWx1342dvT_qC5gVp8E4i3hVcivA,6003
 wbfdm/contrib/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbfdm/contrib/internal/dataloaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbfdm/contrib/internal/dataloaders/market_data.py,sha256=V-kCHgQZVgLkxAmB0xp0BOV48xkcl_YoQzFokKSoL3M,3259
@@ -101,6 +103,9 @@ wbfdm/contrib/qa/dataloaders/market_data.py,sha256=gAzy00nhFWqABG7kjvCfvpyYnehWI
 wbfdm/contrib/qa/dataloaders/officers.py,sha256=QfsMbnlWOhvJc4jyPHJX3STqIwOUqlCCoZddELc405E,2268
 wbfdm/contrib/qa/dataloaders/reporting_dates.py,sha256=Nq83u7eAhsPe9b4ePI5xcgvWEgW1XwHLyVzxpbgcdnQ,2492
 wbfdm/contrib/qa/dataloaders/statements.py,sha256=tE5ux6bFmAezivssRkm3cNW51lJLoAjHbUao1gR4JMM,10093
+wbfdm/contrib/qa/sync/exchanges.py,sha256=831-0bqxq4LaHEkyvMGfEBkNFm5LyLCSpjZbPdTEF0A,3079
+wbfdm/contrib/qa/sync/instruments.py,sha256=8aTQVJ_cw1phe4FWikn79pjCfUijaTcwkdhQCtSXKH0,3156
+wbfdm/contrib/qa/sync/utils.py,sha256=TYZY3QB75POUmme1U71yo6WPzf4AXs4pWpFdI1Hq2GY,8936
 wbfdm/dataloaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbfdm/dataloaders/cache.py,sha256=K9BeVxT7p-BMvjurINt18bfrUDccp840uIjfDBLJRNk,4841
 wbfdm/dataloaders/protocols.py,sha256=wCBHWPkTGVHMcAJU6VkuwisKyvMNJt1jTsSerJDuX2M,3024
@@ -332,6 +337,6 @@ wbfdm/viewsets/statements/__init__.py,sha256=odxtFYUDICPmz8WCE3nx93EvKZLSPBEI4d7
 wbfdm/viewsets/statements/statements.py,sha256=AVU5A7p63uWITEcMDl95iKyN-fBO5RwJlbxHrJZvz7o,4083
 wbfdm/viewsets/technical_analysis/__init__.py,sha256=qtCIBg0uSiZeJq_1tEQFilnorMBkMe6uCMfqar6-cLE,77
 wbfdm/viewsets/technical_analysis/monthly_performances.py,sha256=8VgafjW4efEJKTfBqUvAu-EG2eNawl2Cmh9QFt4sN8w,3973
-wbfdm-2.2.4.dist-info/METADATA,sha256=JIbraZTIjo-ujAWzcnRAK21MtcJ1lE5jUsSYyCMjb10,667
-wbfdm-2.2.4.dist-info/WHEEL,sha256=aO3RJuuiFXItVSnAUEmQ0yRBvv9e1sbJh68PtuQkyAE,105
-wbfdm-2.2.4.dist-info/RECORD,,
+wbfdm-2.2.5.dist-info/METADATA,sha256=qNsybSbkZC6nDfL1NlItisKlgveNge-_jZ3pp7x1_No,667
+wbfdm-2.2.5.dist-info/WHEEL,sha256=aO3RJuuiFXItVSnAUEmQ0yRBvv9e1sbJh68PtuQkyAE,105
+wbfdm-2.2.5.dist-info/RECORD,,