wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/contrib/msci/dataloaders/esg_controversies.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from typing import Iterator
+
+from django.conf import settings
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbfdm.dataloaders.protocols import ESGControversyProtocol
+from wbfdm.dataloaders.types import ESGControversyDataDict
+
+from ..client import MSCIClient
+
+CONTROVERY_ASSESSMENT_MAP = {
+    "Minor": "MINOR",
+    "Moderate": "MODERATE",
+    "Severe": "SEVERE",
+    "Very Severe": "VERY_SEVERE",
+}
+CONTROVERSY_STATUS_MAP = {
+    "Ongoing": "ONGOING",
+    "Partially Concluded": "PARTIALLY_CONCLUDED",
+    "Concluded": "CONCLUDED",
+}
+CONTROVERSY_TYPE_MAP = {
+    "Structural": "STRUCTURAL",
+    "Non-Structural": "NON_STRUCTURAL",
+}
+
+CONTROVERSY_FLAG_MAP = {
+    "Green": "GREEN",
+    "Yellow": "YELLOW",
+    "Orange": "ORANGE",
+    "Red": "RED",
+    "Unknown": "UNKNOWN",
+}
+
+
+class MSCIESGControversyDataloader(ESGControversyProtocol, Dataloader):
+    def esg_controversies(self) -> Iterator[ESGControversyDataDict]:
+        msci_client_id = getattr(settings, "MSCI_CLIENT_ID", None)
+        msci_client_secret = getattr(settings, "MSCI_CLIENT_SECRET", None)
+        if msci_client_id and msci_client_secret:
+            client = MSCIClient(msci_client_id, msci_client_secret)
+            lookup = {k: v for k, v in self.entities.values_list("dl_parameters__esg_controversies__parameters", "id")}
+            factors = [
+                "CONTROVERSY_CASE_ID",
+                "CONTROVERSY_CASE_HEADLINE",
+                "CONTROVERSY_LAST_REVIEWED",
+                "CONTROVERSY_CASE_NARRATIVE",
+                "CONTROVERSY_CASE_SOURCE",
+                "CONTROVERSY_CASE_STATUS",
+                "CONTROVERSY_CASE_TYPE",
+                "CONTROVERSY_CASE_ASSESSMENT",
+                "CONTROVERSY_CASE_COMPANY_RESPONSE",
+                "CONTROVERSY_CASE_DATE_INITIATED",
+                "CONTROVERSY_CASE_FLAG",
+            ]
+            for row in client.controversies(list(lookup.keys()), factors):
+                isin = row.get("CLIENT_IDENTIFIER", "")
+                instrument_id = lookup.get(isin, "")
+
+                headline = row.get("CONTROVERSY_CASE_HEADLINE", "")
+                narrative = row.get("CONTROVERSY_CASE_NARRATIVE", "")
+                reviewed = row.get("CONTROVERSY_LAST_REVIEWED", None)
+                initiated = row.get("CONTROVERSY_CASE_DATE_INITIATED", None)
+                controversy_id = row.get("CONTROVERSY_CASE_ID", f"{isin}-{hash(headline)}")
+                if controversy_id and narrative and headline and isin and instrument_id:
+                    yield ESGControversyDataDict(
+                        id=controversy_id,
+                        instrument_id=instrument_id,
+                        headline=headline,
+                        narrative=narrative,
+                        source=row.get("CONTROVERSY_CASE_SOURCE", ""),
+                        review=datetime.strptime(reviewed, "%Y%m%d").date() if reviewed else None,
+                        initiated=datetime.strptime(initiated, "%Y%m%d").date() if initiated else None,
+                        response=row.get("CONTROVERSY_CASE_COMPANY_RESPONSE", ""),
+                        assessment=CONTROVERY_ASSESSMENT_MAP.get(
+                            row.get("CONTROVERSY_CASE_ASSESSMENT", "Minor"), None
+                        ),
+                        status=CONTROVERSY_STATUS_MAP.get(row.get("CONTROVERSY_CASE_STATUS", "Ongoing"), None),
+                        type=CONTROVERSY_TYPE_MAP.get(row.get("CONTROVERSY_CASE_TYPE", "Structural"), None),
+                        flag=CONTROVERSY_FLAG_MAP.get(row.get("CONTROVERSY_CASE_FLAG", "Green"), None),
+                    )

wbfdm/contrib/msci/sync.py

@@ -0,0 +1,58 @@
+from django.db.models import Q, QuerySet
+from wbfdm.models import Instrument
+from wbfdm.sync.abstract import Sync
+
+
+class MsciInstrumentSync(Sync[Instrument]):
+    ESG_PATH = "wbfdm.contrib.msci.dataloaders.esg.MSCIESGDataloader"
+    ESG_CONTROVERSY_PATH = "wbfdm.contrib.msci.dataloaders.esg_controversies.MSCIESGControversyDataloader"
+
+    def get_updatable_instruments(self) -> QuerySet[Instrument]:
+        return Instrument.objects.filter(
+            Q(isin__isnull=False)
+            & (Q(dl_parameters__esg__isnull=True) | Q(dl_parameters__esg_controversies__isnull=True))
+        )
+
+    def update(self):
+        instruments = []
+
+        for instrument in self.get_updatable_instruments():
+            self._update_dl_parameters(instrument)
+            instruments.append(instrument)
+
+            if len(instruments) % 10000 == 0:
+                Instrument.objects.bulk_update(instruments, ["dl_parameters"])
+                instruments = []
+        Instrument.objects.bulk_update(instruments, ["dl_parameters"])
+
+    def update_or_create_item(self, external_id: int) -> Instrument:
+        raise NotImplementedError(f"The {__class__} is not allowed to create instruments")
+
+    def get_item(self, external_id: int) -> dict:
+        raise NotImplementedError(f"The {__class__} is not allowed to instantiate from remote resources")
+
+    def _update_dl_parameters(self, instrument) -> Instrument:
+        if isin := instrument.isin:
+            instrument.dl_parameters["esg"] = {
+                "path": self.ESG_PATH,
+                "parameters": isin,
+            }
+            instrument.dl_parameters["esg_controversies"] = {
+                "path": self.ESG_CONTROVERSY_PATH,
+                "parameters": isin,
+            }
+        return instrument
+
+    def update_item(self, instrument: Instrument) -> Instrument:
+        self._update_dl_parameters(instrument)
+        instrument.save()
+        return instrument
+
+    def trigger_partial_update(self):
+        instruments_to_update = self.get_updatable_instruments()
+        instruments_to_update_count = instruments_to_update.count()
+        if instruments_to_update_count > 30:
+            self.update()
+        else:
+            for instrument in instruments_to_update:
+                self.update_item(instrument)

wbfdm/contrib/msci/tests/conftest.py

@@ -0,0 +1 @@
+from wbcore.tests.conftest import *  # type: ignore # isort:skip

wbfdm/contrib/msci/tests/test_client.py

@@ -0,0 +1,70 @@
+import time
+from datetime import datetime
+
+import pytest
+from django.core.cache import cache as cache_layer
+from django.utils import timezone
+from faker import Faker
+from jwt import encode
+from requests.exceptions import ConnectionError
+
+from ..client import MSCIClient, is_expired
+
+fake = Faker()
+
+
+class TestMSCIClient:
+    @pytest.fixture()
+    def jwt(self, expiry_date: datetime):
+        payload = {"exp": int(expiry_date.timestamp()), "iat": int(timezone.now().timestamp())}
+        return encode(payload, "secret", algorithm="HS256")
+
+    @pytest.fixture()
+    def msci_client(self):
+        return MSCIClient("username", "password")
+
+    @pytest.mark.parametrize("expiry_date", [fake.past_datetime()])
+    def test_is_expired_true(self, expiry_date, jwt):
+        assert is_expired(jwt)
+
+    @pytest.mark.parametrize("expiry_date", [fake.future_datetime()])
+    def test_is_expired_false(self, expiry_date, jwt):
+        assert not is_expired(jwt)
+
+    def test_oauth_token_not_in_cache(self, requests_mock, msci_client):
+        access_token = fake.word()
+        expiry = fake.pyint(min_value=60)
+        requests_mock.post(MSCIClient.AUTH_SERVER_ULR, json={"access_token": access_token, "expires_in": expiry})
+        t0 = time.time()
+        res = msci_client.oauth_token
+        assert res == access_token
+        assert cache_layer.get("msci_oauth_token") == access_token
+        assert int(cache_layer._expire_info.get(":1:msci_oauth_token")) == int(t0 + expiry)
+
+    @pytest.mark.parametrize("expiry_date", [fake.future_datetime()])
+    def test_oauth_token_in_cache_and_valid(self, requests_mock, msci_client, expiry_date, jwt):
+        requests_mock.post(MSCIClient.AUTH_SERVER_ULR, json={"access_token": fake.word()})
+        cache_layer.set("msci_oauth_token", jwt)
+        assert msci_client.oauth_token == jwt
+
+    @pytest.mark.parametrize("expiry_date", [fake.past_datetime()])
+    def test_oauth_token_in_cache_but_expired(self, requests_mock, msci_client, expiry_date, jwt):
+        requests_mock.post(MSCIClient.AUTH_SERVER_ULR, json={"access_token": fake.word()})
+        cache_layer.set("msci_oauth_token", jwt)
+
+        access_token = fake.word()
+        requests_mock.post(
+            MSCIClient.AUTH_SERVER_ULR, json={"access_token": access_token, "expires_in": fake.pyint(min_value=60)}
+        )
+        assert msci_client.oauth_token == access_token
+
+    def test_oauth_token_connection_error(self, requests_mock, msci_client):
+        cache_layer.clear()
+        # keyerror
+        requests_mock.post(MSCIClient.AUTH_SERVER_ULR, json={"access_token_typo": fake.word()})
+        with pytest.raises(ConnectionError):
+            t = msci_client.oauth_token  # noqa
+
+        requests_mock.post(MSCIClient.AUTH_SERVER_ULR, status_code=500)
+        with pytest.raises(ConnectionError):
+            t = msci_client.oauth_token  # noqa

wbfdm/contrib/qa/apps.py

@@ -0,0 +1,22 @@
+from django.apps import AppConfig
+from django.conf import settings
+from django.core.checks import Warning, register
+
+
+@register()
+def check_qa_db_available(app_configs, **kwargs):
+    warnings = []
+
+    if "qa" not in settings.DATABASES:
+        warnings.append(
+            Warning(
+                "A database with the name qa needs to be installed in order to run QA",
+            )
+        )
+
+    return warnings
+
+
+class QAAppConfig(AppConfig):
+    name = "wbfdm.contrib.qa"
+    verbose_name = "Quantitative Analytics (QA)"

wbfdm/contrib/qa/database_routers.py

@@ -0,0 +1,25 @@
+class QARouter:
+    """
+    QA from Refinitiv is usually served through an external mssql, oracle or snowflake database.
+    We are going to use it in a mostly read-only way, therefore we need a DBRouter that routes
+    all database connections for models from QA to the correct database. The database needs to be
+    registered in the settings of the project like this:
+
+    ```
+    DATABASES = {
+        "default": {}, # This is the default django database
+        "qa": {},  # This is the important database. The name qa is really important here.
+    }
+    ```
+    Afterwards the settings needs to declare this router explicately as one of the `DATABASE_ROUTERS`
+    """
+
+    def db_for_read(self, model, **hints):
+        if model._meta.app_label == "qa":
+            return "qa"
+        return None
+
+    def allow_migrate(self, db, app_label, model_name=None, **hints):
+        if app_label == "qa":
+            return False
+        return None

wbfdm/contrib/qa/dataloaders/adjustments.py

@@ -0,0 +1,56 @@
+from datetime import date
+from itertools import batched  # type: ignore
+from typing import Iterator
+
+from django.db import connections
+from jinjasql import JinjaSql  # type: ignore
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import AdjustmentsProtocol
+from wbfdm.dataloaders.types import AdjustmentDataDict
+
+
+class DatastreamAdjustmentsDataloader(AdjustmentsProtocol, Dataloader):
+    def adjustments(self, from_date: date, to_date: date) -> 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,
+                },
+            )
+            with connections["qa"].cursor() as cursor:
+                cursor.execute(
+                    query,
+                    bind_params,
+                )
+                for row in dictfetchall(cursor):
+                    row["instrument_id"] = lookup[row["external_identifier"]]
+                    yield row

wbfdm/contrib/qa/dataloaders/corporate_actions.py

@@ -0,0 +1,59 @@
+from datetime import date
+from typing import Iterator
+
+from django.db import connections
+from jinjasql import JinjaSql  # type: ignore
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import CorporateActionsProtocol
+from wbfdm.dataloaders.types import CorporateActionDataDict
+
+
+class DatastreamCorporateActionsDataloader(CorporateActionsProtocol, Dataloader):
+    def corporate_actions(
+        self,
+        from_date: date | None = None,
+        to_date: date | None = None,
+    ) -> 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 %}
+            )
+            {% 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,
+            },
+        )
+        with connections["qa"].cursor() as cursor:
+            cursor.execute(
+                query,
+                bind_params,
+            )
+            for row in dictfetchall(cursor):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row

wbfdm/contrib/qa/dataloaders/financials.py

@@ -0,0 +1,83 @@
+from datetime import date
+from itertools import batched  # type: ignore
+from typing import Iterator
+
+from django.db import connections
+from django.template.loader import get_template
+from jinjasql import JinjaSql  # type: ignore
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import FinancialsProtocol
+from wbfdm.dataloaders.types import FinancialDataDict
+from wbfdm.enums import (
+    CalendarType,
+    DataType,
+    EstimateType,
+    Financial,
+    PeriodType,
+    SeriesType,
+)
+
+
+class IBESFinancialsDataloader(FinancialsProtocol, Dataloader):
+    def financials(
+        self,
+        values: list[Financial],
+        from_date: date | None = None,
+        to_date: date | None = None,
+        from_year: int | None = None,
+        to_year: int | None = None,
+        from_index: int | None = None,
+        to_index: int | None = None,
+        from_valid: date | None = None,
+        to_valid: date | None = None,
+        period_type: PeriodType = PeriodType.ANNUAL,
+        calendar_type: CalendarType = CalendarType.FISCAL,
+        series_type: SeriesType = SeriesType.COMPLETE,
+        data_type: DataType = DataType.STANDARDIZED,
+        estimate_type: EstimateType = EstimateType.VALID,
+        target_currency: str | None = None,
+    ) -> Iterator[FinancialDataDict]:
+        lookup = {k: v for k, v in self.entities.values_list("dl_parameters__financials__parameters", "id")}
+        for batch in batched(lookup.keys(), 1000):
+            sql = ""
+            if series_type == SeriesType.COMPLETE:
+                sql = "qa/sql/ibes/complete.sql"
+                if calendar_type == CalendarType.CALENDAR:
+                    sql = "qa/sql/ibes/calendarized.sql"
+
+            elif series_type == SeriesType.FULL_ESTIMATE:
+                sql = "qa/sql/ibes/estimates.sql"
+
+            query, bind_params = JinjaSql(param_style="format").prepare_query(
+                get_template(sql, using="jinja").template,
+                {
+                    "instruments": batch,
+                    "financials": [financial.value for financial in values],
+                    "estimate_type": estimate_type.value,
+                    "from_date": from_date,
+                    "to_date": to_date,
+                    "from_year": from_year,
+                    "to_year": to_year,
+                    "from_index": from_index,
+                    "to_index": to_index,
+                    "from_valid": from_valid,
+                    "to_valid": to_valid,
+                    "period_type": period_type.value,
+                },
+            )
+            with connections["qa"].cursor() as cursor:
+                cursor.execute(
+                    query,
+                    bind_params,
+                )
+                for row in dictfetchall(cursor):
+                    row["instrument_id"] = lookup[row["external_identifier"]]
+                    row["estimate"] = bool(row["estimate"])
+                    row["value"] = row.get("value", None)
+                    row["difference_pct"] = row.get("difference_pct", 0)
+                    row["value_high"] = row.get("value_high", row["value"])
+                    row["value_low"] = row.get("value_low", row["value"])
+                    row["value_amount"] = row.get("value_amount", row["value"])
+                    row["value_stdev"] = row.get("value_stdev", row["value"])
+                    yield row

wbfdm/contrib/qa/dataloaders/market_data.py

@@ -0,0 +1,117 @@
+from datetime import date
+from enum import Enum
+from typing import Iterator
+
+from django.db import connections
+from jinjasql import JinjaSql  # type: ignore
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbfdm.dataloaders.protocols import MarketDataProtocol
+from wbfdm.dataloaders.types import MarketDataDict
+from wbfdm.enums import Frequency, MarketData
+
+
+class DS2MarketData(Enum):
+    OPEN = ("Open_", None)
+    CLOSE = ("Close_", None)
+    HIGH = ("High", None)
+    LOW = ("Low", None)
+    BID = ("Bid", None)
+    ASK = ("Ask", None)
+    VWAP = ("VWAP", None)
+    VOLUME = ("Volume", None)
+    MARKET_CAPITALIZATION = ("ConsolMktVal", 1_000_000)
+    SHARES_OUTSTANDING = ("ConsolNumShrs", 1_000)
+
+
+class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
+    def market_data(
+        self,
+        values: list[MarketData] | None = [MarketData.CLOSE],
+        from_date: date | None = None,
+        to_date: date | None = None,
+        exact_date: date | None = None,
+        frequency: Frequency = Frequency.DAILY,
+        target_currency: str | None = None,
+        **kwargs,
+    ) -> Iterator[MarketDataDict]:
+        """Get market data for instruments.
+
+        Args:
+            queryset (QuerySet["Instrument"]): The queryset of instruments.
+            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.
+        """
+
+        lookup = {
+            f"{k[0]},{k[1]}": v for k, v in self.entities.values_list("dl_parameters__market_data__parameters", "id")
+        }
+        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 %}
+
+            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,
+            },
+        )
+        with connections["qa"].cursor() as cursor:
+            cursor.execute(
+                query,
+                bind_params,
+            )
+            for row in dictfetchall(cursor):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row

wbfdm/contrib/qa/dataloaders/officers.py

@@ -0,0 +1,59 @@
+from typing import Iterator
+
+from django.db import connections
+from jinjasql import JinjaSql  # type: ignore
+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
+
+
+class RKDOfficersDataloader(OfficersProtocol, Dataloader):
+    def officers(
+        self,
+    ) -> 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(
+                    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,
+            )
+            for row in dictfetchall(cursor):
+                row["instrument_id"] = lookup[row["external_identifier"]]
+                yield row