wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/import_export/backends/cbinsights/utils/client.py

@@ -0,0 +1,217 @@
+import time
+from datetime import date, datetime
+from typing import Optional
+
+import requests
+from celery import shared_task
+from tqdm import tqdm
+
+
+class RateLimitException(Exception):
+    pass
+
+
+class CreditLimitException(Exception):
+    pass
+
+
+class Client:
+    MAX_ORG_IDS_SIZE = 100
+
+    def __init__(
+        self, client_id: str, client_secret: str, limit: Optional[int] = 10, rate_limit_sleep: Optional[int] = 60
+    ):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.limit = limit
+        self.rate_limit_sleep = rate_limit_sleep
+        super().__init__()
+
+    def connect(self):
+        token = self._fetch_authorization_token()
+        self.jwt_header_value = f"Bearer {token}"
+
+    def _request(self, url, params=None, next_page_token=None):
+        if not params:
+            params = dict()
+        resp = requests.get(
+            url,
+            params={**params, **{"nextPageToken": next_page_token}} if next_page_token else params,
+            headers={"authorization": self.jwt_header_value},
+        )
+        if resp.status_code != 200:
+            if resp.status_code == 429:
+                raise RateLimitException()
+            raise requests.ConnectionError(
+                f"unexpected error from api\nstatus_code: {resp.status_code}\nerror: {resp.text}"
+            )
+
+        if credits_remaining_str := resp.headers.get("x-cbinsights-credits-remaining", None):
+            if int(credits_remaining_str) <= 0:
+                raise CreditLimitException()
+
+        return resp.json()
+
+    def _paginated_request(
+        self,
+        data_url: str,
+        extra_params=None,
+        last_update_time: Optional[datetime] = None,
+    ):
+        params = {"limit": self.limit}
+        if last_update_time:
+            params["lastUpdateTime"] = last_update_time.isoformat()
+        if extra_params:
+            params.update(extra_params)
+        resp = self._request(data_url, params=params)
+        yield resp
+        next_page_token = resp["nextPageToken"]
+        retry = 0
+        while next_page_token and retry < 5:
+            try:
+                resp = self._request(data_url, params=params, next_page_token=next_page_token)
+                yield resp
+                next_page_token = resp["nextPageToken"]
+            except RateLimitException:
+                time.sleep(self.rate_limit_sleep)
+                retry += 1
+        if retry >= 5:
+            raise RateLimitException()
+
+    def _chunk_paginated_request(self, data_url, org_ids, extra_params, endpoint, debug: bool = False):
+        data = []
+        ranges = list(range(0, len(org_ids), self.MAX_ORG_IDS_SIZE))
+        gen = tqdm(ranges, total=len(ranges)) if debug else ranges
+        for x in gen:
+            ids = org_ids[x : x + 100]
+            for res in self._paginated_request(
+                data_url,
+                extra_params={"orgIds": ",".join(map(str, ids)), **extra_params},
+            ):
+                if _data := res.get(endpoint, None):
+                    data.extend(_data)
+        return data
+
+    def _fetch_authorization_token(self):
+        auth_url = "https://api.cbinsights.com/v1/authorize"
+
+        auth_resp = requests.get(
+            auth_url,
+            params={"clientId": self.client_id, "clientSecret": self.client_secret},
+        )
+
+        if auth_resp.status_code != 200:
+            raise Exception(
+                f"unexpected error from api\nstatus_code: {auth_resp.status_code}\nerror: {auth_resp.text}"
+            )
+
+        token = auth_resp.json()["token"]
+
+        return token
+
+    def _get_tasks_signatures(self, org_ids, last_update_time, data_url):
+        return [
+            fetch_datapoint_by_id_asynchronously.s(self.jwt_header_value, data_url.format(org_id), limit=self.limit)
+            for org_id in org_ids
+        ]
+
+    def fetch_credit_logs(self):
+        return self._request("https://api.cbinsights.com/v1/credits")["creditLogs"]
+
+    def fetch_organizations(
+        self,
+        org_ids: list[str],
+        include_datapacks: Optional[str] = "orgSummary,orgKPIs,orgRevenue",
+        last_update_time: date = None,
+        debug: bool = False,
+        **kwargs,
+    ):
+        extra_params = {"include": include_datapacks, **kwargs}
+        if last_update_time:
+            extra_params["lastUpdateTime"] = last_update_time.isoformat()
+        return self._chunk_paginated_request(
+            "https://api.cbinsights.com/v1/organizations", org_ids, extra_params, "organizations", debug=debug
+        )
+
+    def fetch_deals(
+        self,
+        org_ids: list[str],
+        start: date = None,
+        end: date = None,
+        last_update_time: date = None,
+        debug: bool = False,
+        **extra_params,
+    ):
+        if start:
+            extra_params["minDealDate"] = start.isoformat()
+        if end:
+            extra_params["maxDealDate"] = end.isoformat()
+        if last_update_time:
+            extra_params["lastUpdateTime"] = last_update_time.isoformat()
+        return self._chunk_paginated_request(
+            "https://api.cbinsights.com/v1/deals", org_ids, extra_params, "deals", debug=debug
+        )
+
+    # Sub deals utility functions.
+    def fetch_fundings_for_id(self, org_id: str):
+        data = []
+        for res in self._paginated_request(f"https://api.cbinsights.com/v1/organizations/{org_id}/fundings"):
+            if fundings_data := res.get("fundings", None):
+                data.extend(fundings_data)
+        return data
+
+    def fetch_investments_for_id(self, org_id: str):
+        data = []
+        for res in self._paginated_request(f"https://api.cbinsights.com/v1/organizations/{org_id}/investments"):
+            if investments_data := res.get("investments", None):
+                data.extend(investments_data)
+        return data
+
+    def fetch_portfolioexits_for_id(self, org_id: str):
+        data = []
+        for res in self._paginated_request(f"https://api.cbinsights.com/v1/organizations/{org_id}/portfolioExits"):
+            if portfolioexits_data := res.get("portfolioExits", None):
+                data.extend(portfolioexits_data)
+        return data
+
+    def fetch_org_id(self, org_name, org_urls: list[str]) -> int:
+        org_id = None
+        i = 0
+        while not org_id and i < len(org_urls):
+            params = {"url": org_urls[i], "orgName": org_name}
+            try:
+                hits = self._request(
+                    "https://api.cbinsights.com/v1/organizations/lookup",
+                    params={k: v for k, v in params.items() if v},
+                )["hits"]
+                if len(hits) > 0:
+                    org_id = hits[0]["orgId"]
+            except requests.ConnectionError as e:
+                print(e)  # noqa: T201
+            i += 1
+        return org_id
+
+
+@shared_task(
+    queue="importexport",
+    autoretry_for=(Exception,),
+    exponential_backoff=2,
+    retry_kwargs={"max_retries": 2},
+    retry_jitter=False,
+)
+def fetch_datapoint_by_id_asynchronously(
+    jwt_header_value,
+    data_url,
+    last_update_time: Optional[datetime] = None,
+    limit: Optional[int] = 10,
+    rate_limit_sleep: Optional[int] = 60,
+):
+    params = {"limit": limit}
+    if last_update_time:
+        params["lastUpdateTime"] = last_update_time.isoformat()
+    data = []
+
+    resp = Client._request(jwt_header_value, data_url, params=params)
+    data.append(resp)
+
+    return data

wbfdm/import_export/backends/refinitiv/__init__.py

@@ -0,0 +1,5 @@
+from .daily_fundamental import *
+from .fiscal_period import *
+from .forecast import *
+from .fundamental import *
+from .instrument import *

wbfdm/import_export/backends/refinitiv/daily_fundamental.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {"DWFC": "free_cash", "EPS": "eps_ttm", "EPS1FD12": "eps_ftw"}
+
+
+@register("Daily Fundamental", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", (execution_date - BDay(1)).date())
+
+        fields = list(DEFAULT_MAPPING.keys())
+        if obj_external_ids:
+            df = self.controller.get_data(obj_external_ids, fields, start, execution_date)
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                file_name = f"daily_fundamental_{start:%Y-%m-%d}-{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                yield file_name, content_file

wbfdm/import_export/backends/refinitiv/fiscal_period.py

@@ -0,0 +1,63 @@
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+import pandas as pd
+from django.db import models
+from pandas.tseries.offsets import YearEnd
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {
+    "IBEFPD": "period_type",  # Expected
+    "IBQ1EEDT": "period_end_date",  # Expected Q1
+    "IBQ1ERDT": "expected_report_date",  # Expected Q1
+    "IBQ2EEDT": "period_end_date",  # Expected Q2
+    "IBQ2ERDT": "expected_report_date",  # Expected Q2
+    "IBFPD": "period_type",  # Company/Actual
+    "IBQ1ENDT": "period_end_date",  # Company/Actual Q1
+    "IBQ1CRDT": "expected_report_date",  # Company/Actual Q1
+    "IBQ2ENDT": "period_end_date",  # Company/Actual Q2
+    "IBQ2CRDT": "expected_report_date",  # Company/Actual Q1
+}
+
+
+@register("Fiscal Period", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    CHUNK_SIZE = 20
+
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+        if obj_external_ids:
+            df = self.controller.get_data(obj_external_ids, list(DEFAULT_MAPPING.keys()))
+            if not df.empty:
+                df_last_year_end = self.controller.get_data(
+                    obj_external_ids,
+                    ["WC05350", "WC05351"],
+                    start=(execution_date - YearEnd(1)).date(),
+                    end=(execution_date + YearEnd(0)).date(),
+                    freq="Y",
+                )
+                # We do this to gather the last fiscal year end date to forward to the parser in order for figuring out what is the actual period index
+                if not df_last_year_end.empty:
+                    df_last_year_end = df_last_year_end.sort_values(by="WC05350").groupby(["Instrument"]).last()
+                    df = pd.concat(
+                        [df.set_index("Instrument"), df_last_year_end[df_last_year_end.columns.difference(["Dates"])]],
+                        axis=1,
+                    ).reset_index(names="Instrument")
+                df = df.dropna(how="all", subset=df.columns.difference(["Instrument", "Dates"]))
+                if not df.empty:
+                    content_file = BytesIO()
+                    df.to_json(content_file, orient="records")
+                    file_name = f"fiscal_periods_{datetime.timestamp(execution_time)}.json"
+                    yield file_name, content_file

wbfdm/import_export/backends/refinitiv/forecast.py

@@ -0,0 +1,178 @@
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {
+    "SAL1MN": "revenue_y1",
+    "SAL2MN": "revenue_y2",
+    "SAL3MN": "revenue_y3",
+    "SAL4MN": "revenue_y4",
+    "SAL5MN": "revenue_y5",
+    "GRM1MN": "gross_profit_margin_without_depreciation_y1",
+    "GRM2MN": "gross_profit_margin_without_depreciation_y2",
+    "GRM3MN": "gross_profit_margin_without_depreciation_y3",
+    "GRM4MN": "gross_profit_margin_without_depreciation_y4",
+    "GRM5MN": "gross_profit_margin_without_depreciation_y5",
+    "NER1MN": "reported_net_profit_y1",
+    "NER2MN": "reported_net_profit_y2",
+    "NER3MN": "reported_net_profit_y3",
+    "NER4MN": "reported_net_profit_y4",
+    "NER5MN": "reported_net_profit_y5",
+    "INC1MN": "adjusted_net_profit_y1",
+    "INC2MN": "adjusted_net_profit_y2",
+    "INC3MN": "adjusted_net_profit_y3",
+    "INC4MN": "adjusted_net_profit_y4",
+    "INC5MN": "adjusted_net_profit_y5",
+    "EBD1MN": "ebitda_y1",
+    "EBD2MN": "ebitda_y2",
+    "EBD3MN": "ebitda_y3",
+    "EBD4MN": "ebitda_y4",
+    "EBD5MN": "ebitda_y5",
+    "EBT1MN": "ebit_y1",
+    "EBT2MN": "ebit_y2",
+    "EBT3MN": "ebit_y3",
+    "EBT4MN": "ebit_y4",
+    "EBT5MN": "ebit_y5",
+    "NDT1MN": "net_debt_y1",
+    "NDT2MN": "net_debt_y2",
+    "NDT3MN": "net_debt_y3",
+    "NDT4MN": "net_debt_y4",
+    "NDT5MN": "net_debt_y5",
+    "EVT1MN": "entreprise_value_y1",
+    "EVT2MN": "entreprise_value_y2",
+    "EVT3MN": "entreprise_value_y3",
+    "EVT4MN": "entreprise_value_y4",
+    "EVT5MN": "entreprise_value_y5",
+    "FCF1MN": "free_cash_flow_y1",
+    "FCF2MN": "free_cash_flow_y2",
+    "FCF3MN": "free_cash_flow_y3",
+    "FCF4MN": "free_cash_flow_y4",
+    "FCF5MN": "free_cash_flow_y5",
+    "EPS1MN": "eps_y1",
+    "EPS2MN": "eps_y2",
+    "EPS3MN": "eps_y3",
+    "EPS4MN": "eps_y4",
+    "EPS5MN": "eps_y5",
+    "CAP1MN": "capital_expenditures_y1",
+    "CAP2MN": "capital_expenditures_y2",
+    "CAP3MN": "capital_expenditures_y3",
+    "CAP4MN": "capital_expenditures_y4",
+    "CAP5MN": "capital_expenditures_y5",
+    "BPS1MN": "expected_book_value_per_share_y1",
+    "BPS2MN": "expected_book_value_per_share_y2",
+    "BPS3MN": "expected_book_value_per_share_y3",
+    "BPS4MN": "expected_book_value_per_share_y4",
+    "BPS5MN": "expected_book_value_per_share_y5",
+}
+
+PER_SHARE_FIELDS = [
+    "EPS1MN",
+    "EPS2MN",
+    "EPS3MN",
+    "EPS4MN",
+    "EPS5MN",
+    "BPS1MN",
+    "BPS2MN",
+    "BPS3MN",
+    "BPS4MN",
+    "BPS5MN",
+    "FCF1MN",
+    "FCF2MN",
+    "FCF3MN",
+    "FCF4MN",
+    "FCF5MN",
+    "GRM1MN",
+    "GRM2MN",
+    "GRM3MN",
+    "GRM4MN",
+    "GRM5MN",
+]
+
+
+CURRENCY_BASED_FIELDS = [
+    "SAL1MN",
+    "SAL2MN",
+    "SAL3MN",
+    "SAL4MN",
+    "SAL5MN",
+    "NER1MN",
+    "NER2MN",
+    "NER3MN",
+    "NER4MN",
+    "NER5MN",
+    "INC1MN",
+    "INC2MN",
+    "INC3MN",
+    "INC4MN",
+    "INC5MN",
+    "EBD1MN",
+    "EBD2MN",
+    "EBD3MN",
+    "EBD4MN",
+    "EBD5MN",
+    "EBT1MN",
+    "EBT2MN",
+    "EBT3MN",
+    "EBT4MN",
+    "EBT5MN",
+    "NDT1MN",
+    "NDT2MN",
+    "NDT3MN",
+    "NDT4MN",
+    "NDT5MN",
+    "EVT1MN",
+    "EVT2MN",
+    "EVT3MN",
+    "EVT4MN",
+    "EVT5MN",
+    "CAP1MN",
+    "CAP2MN",
+    "CAP3MN",
+    "CAP4MN",
+    "CAP5MN",
+    "FCF1MN",
+    "FCF2MN",
+    "FCF3MN",
+    "FCF4MN",
+    "FCF5MN",
+]
+
+
+@register("Forecast", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", (execution_date - BDay(1)).date())
+
+        fields = list(DEFAULT_MAPPING.keys())
+        if obj_external_ids:
+            df = self.controller.get_data(
+                obj_external_ids,
+                fields,
+                start,
+                execution_date,
+                ibes_non_per_share_fields=list(filter(lambda x: x not in PER_SHARE_FIELDS, fields)),
+                ibes_currency_based_fields=CURRENCY_BASED_FIELDS,
+            )
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                file_name = (
+                    f"forecast_{start:%Y-%m-%d}-{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                )
+                yield file_name, content_file

wbfdm/import_export/backends/refinitiv/fundamental.py

@@ -0,0 +1,103 @@
+from datetime import datetime
+from io import BytesIO
+from typing import List, Optional
+
+import pandas as pd
+from django.db import models
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {
+    # Income Statement
+    "WC01001": "revenue",
+    "WC01051": "cost_of_good_sold_without_depreciation",
+    "WC18198": "ebitda",
+    "WC18191": "ebit",
+    "WC01651": "net_profit",
+    "WC08346": "company_tax_rate",
+    "WC01201": "cost_research_development",
+    "WC01251": "interest_expense",
+    "WC01101": "sga",
+    # Balance Sheet
+    "WC03501": "shareholder_equity",
+    "WC02999": "total_assets",
+    "WC03101": "current_liabilities",
+    "WC03351": "total_liabilities",
+    "WC03255": "total_debt",
+    "WC02003": "cash_and_cash_equivalents",
+    "WC02005": "cash_and_short_term_investments",
+    "WC18199": "net_debt",
+    "WC02051": "receivables",
+    "WC02101": "inventories",
+    "WC03040": "payables",
+    "WC02201": "current_assets",
+    "WC07011": "employee_count",
+    "WC18100": "entreprise_value",
+    "WC03151": "working_capital",
+    "WC05491": "book_value_per_share",
+    "WC10010": "eps",
+    "WC10030": "diluted_eps",
+    "WC01151": "deprecation_and_amortization",
+    # Annual data
+    "WC04870": "investment_cash",
+    "WC04860": "cash_from_operation",
+    "WC04890": "financing_cash",
+    "WC04601": "capital_expenditures",
+    "WC05350": "period__period_end_date",
+    "WC05200": "period__period_type",
+    # 'WC19109': "net_profit",
+    # 'WC19110': "net_profit",
+    # 'WC19111': "net_profit",
+    # 'WC19112': "net_profit",
+}
+
+ANNUAL_FIELDS = ["WC04870", "WC04890", "WC04860", "WC04601"]
+
+
+@register("Fundamental", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    CHUNK_SIZE = 10
+    FISCAL_INTERVAL = 1
+
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        fields: List[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+
+        if not fields:
+            fields = list(DEFAULT_MAPPING.keys())
+        if obj_external_ids:
+            df_interim = self.controller.get_interim_fundamental_data(
+                obj_external_ids,
+                fields,
+                initial_start=kwargs.get("start", None),
+                initial_end=execution_date,
+            )
+            df_annual = self.controller.get_annual_fundamental_data(
+                obj_external_ids,
+                fields,
+                initial_start=kwargs.get("start", None),
+                initial_end=execution_date,
+            )
+            df = pd.concat([df_interim, df_annual], axis=0)
+            df = df.dropna(
+                how="all",
+                subset=df.columns.difference(["Instrument", "Dates", "period__period_interim", "WC05200", "WC05350"]),
+            )
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                if start := kwargs.get("start", execution_date):
+                    file_name = f"fundamental_{start:%Y-%m-%d}_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                else:
+                    file_name = f"fundamental_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                yield file_name, content_file

wbfdm/import_export/backends/refinitiv/geographic_segment.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from io import BytesIO
+
+from wbcore.contrib.io.backends import register
+
+from .fundamental import DataBackend as ParentDataBackend
+
+DEFAULT_MAPPING = {
+    "WC19601": "segment_1_sales",
+    "WC19600 ": "segment_1_description",
+    "WC19611": "segment_2_sales",
+    "WC19610 ": "segment_2_description",
+    "WC19621": "segment_3_sales",
+    "WC19620 ": "segment_3_description",
+}
+
+
+@register("Geographic Segment", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(ParentDataBackend):
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        yield from super().get_files(
+            execution_time,
+            obj_external_ids=obj_external_ids,
+            fields=list(DEFAULT_MAPPING.keys()),
+            filename="geographic_segment",
+            **kwargs,
+        )

wbfdm/import_export/backends/refinitiv/instrument.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {
+    "ISOCUR": "currency__key",
+    "RIC": "refinitiv_identifier_code",
+    "MNEM": "refinitiv_mnemonic_code",
+    "ISIN": "isin",
+    "GGISO": "country",
+    # "NPCUR": "currency__key",
+    "BNAM": "borrower",
+    "ITYP": "issuer_type",
+    "EXCHB": "exchanges",
+    "CTYP": "coupon_type",
+    "BTYP": "bond_type",
+    "WC06092": "description",
+    "SEGM": "exchange",
+    "NAME": "name",
+    "WC05601": "ticker",
+    "GDIGC": "gics_classification",
+    "TR5": "trbc_classification",
+    "TYPE": "instrument_type",
+    "WC18272": "inception_date",
+    "WC18273": "inception_date",
+    "WC07015": "delisted_date",
+}
+
+
+@register("Instrument", provider_key="refinitiv", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    CHUNK_SIZE = 20
+
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        if obj_external_ids:
+            df = self.controller.get_data(obj_external_ids, list(DEFAULT_MAPPING.keys()))
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                file_name = f"instrument_{datetime.timestamp(execution_time)}.json"
+                yield file_name, content_file