wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/contrib/metric/viewsets/configs/utils.py

@@ -0,0 +1,137 @@
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.color.enums import WBColor
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.formatting import Condition, Operator
+
+PERFORMANCE_FORMATTING = [
+    dp.FormattingRule(
+        style={"color": WBColor.GREY.value, "fontWeight": "bold"},
+        condition=Condition(Operator("=="), 0),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.RED_DARK.value, "fontWeight": "bold"},
+        condition=Condition(Operator("<"), 0),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.GREEN_DARK.value, "fontWeight": "bold"},
+        condition=Condition(Operator(">"), 0),
+    ),
+]
+
+BORDER_LEFT = dp.FormattingRule(
+    style={
+        "borderLeft": "1px solid #bdc3c7",
+    }
+)
+
+
+def get_performance_fields(with_comparison_performances: bool = False) -> list[dp.Field]:
+    def _get_performance_field(key: str, label: str, show=None):
+        if not with_comparison_performances:
+            return dp.Field(
+                key=f"performance_{key}",
+                label=label,
+                width=100,
+                formatting_rules=PERFORMANCE_FORMATTING,
+            )
+        return dp.Field(
+            key=None,
+            label=label,
+            width=100,
+            show=show,
+            children=[
+                dp.Field(
+                    key=f"performance_{key}",
+                    label="Absolute",
+                    width=100,
+                    formatting_rules=PERFORMANCE_FORMATTING + [BORDER_LEFT],
+                ),
+                dp.Field(
+                    key=f"performance_peer_{key}",
+                    label="vs Peer",
+                    width=100,
+                    formatting_rules=PERFORMANCE_FORMATTING,
+                    show="open",
+                    tooltip=dp.Tooltip(key="peers"),
+                ),
+                dp.Field(
+                    key=f"performance_benchmark_{key}",
+                    label="vs Benchmark",
+                    width=100,
+                    formatting_rules=PERFORMANCE_FORMATTING,
+                    show="open",
+                    tooltip=dp.Tooltip(key="benchmarks"),
+                ),
+            ],
+        )
+
+    return [
+        dp.Field(
+            key=None,
+            label="Rolling",
+            open_by_default=False,
+            children=[
+                _get_performance_field(key="daily", label="Daily"),
+                _get_performance_field(
+                    key="weekly",
+                    label="Weekly",
+                    show="open",
+                ),
+                _get_performance_field(
+                    key="monthly",
+                    label="Monthly",
+                    show="open",
+                ),
+                _get_performance_field(
+                    key="quarterly",
+                    label="Quarterly",
+                    show="open",
+                ),
+                _get_performance_field(
+                    key="yearly",
+                    label="Yearly",
+                    show="open",
+                ),
+            ],
+        ),
+        dp.Field(
+            key=None,
+            label="Performance-To-Date (PTD)",
+            open_by_default=False,
+            children=[
+                _get_performance_field(key="week_to_date", label="Week", show="open"),
+                _get_performance_field(key="month_to_date", label="Month"),
+                _get_performance_field(key="quarter_to_date", label="Quarter", show="open"),
+                _get_performance_field(key="year_to_date", label="Year", show="open"),
+            ],
+        ),
+        dp.Field(
+            key=None,
+            label="Previous Performance",
+            open_by_default=False,
+            show="open",
+            children=[
+                _get_performance_field(key="previous_week_to_date", label="Week", show="open"),
+                _get_performance_field(key="previous_month_to_date", label="Month"),
+                _get_performance_field(key="previous_quarter_to_date", label="Quarter", show="open"),
+                _get_performance_field(key="previous_year_to_date", label="Year", show="open"),
+            ],
+        ),
+        _get_performance_field(key="inception", label="Inception"),
+    ]
+
+
+def get_statistic_field():
+    return dp.Field(
+        key=None,
+        label=_("Fundamentals"),
+        open_by_default=False,
+        children=[
+            dp.Field(key="statistic_price", label="Last Price", width=100),
+            dp.Field(key="statistic_market_capitalization", label="Market Capitalization", width=100),
+            dp.Field(key="statistic_revenue_y_1", label="Revenue Y-1", width=100, show="closed"),
+            dp.Field(key="statistic_revenue_y0", label="Revenue Y", width=100, show="closed"),
+            dp.Field(key="statistic_revenue_y1", label="Revenue Y+1", width=100),
+            dp.Field(key="statistic_volume_50d", label="Avg Volume (3m)", width=100, show="closed"),
+        ],
+    )

wbfdm/contrib/metric/viewsets/mixins.py

@@ -0,0 +1,245 @@
+from datetime import date
+from typing import TYPE_CHECKING, Optional, Type
+
+from django.contrib.contenttypes.models import ContentType
+from django.utils.functional import cached_property
+from wbcore import filters
+from wbcore.metadata.metadata import WBCoreMetadata
+from wbcore.utils.strings import get_aggregate_symbol
+from wbfdm.contrib.metric.models import InstrumentMetric
+from wbfdm.contrib.metric.registry import backend_registry
+from wbfdm.contrib.metric.viewsets.configs.display import (
+    InstrumentMetricPivotedListDisplayConfig,
+)
+
+from ..dto import MetricKey
+
+if TYPE_CHECKING:
+    from django.db.models import Model
+    from wbcore.models import WBModel
+    from wbcore.viewsets import ModelViewSet
+
+    _Base = ModelViewSet
+else:
+    _Base = object
+
+
+class InstrumentMetricMetaData(WBCoreMetadata):
+    def determine_metadata(self, request, view):
+        metadata = super().determine_metadata(request, view)
+        if "filter_fields" in metadata and view.METRIC_SHOW_FILTERS:
+            view_metric_key_choices = backend_registry.get_choices(view.METRIC_KEYS)
+            metric_show_filter_field = filters.BooleanFilter(
+                default=view.METRIC_SHOW_BY_DEFAULT,
+                field_name="metric_show_by_default",
+                required=True,
+                label="Show Metric Keys",
+            )  # TODO implement this as a dependant filter when frontend allows it
+            metric_keys_filter_field = filters.MultipleChoiceFilter(
+                choices=view_metric_key_choices,
+                field_name="metric_keys",
+                required=True,
+                label="Metric Keys",
+                default=list(map(lambda x: x[0], view_metric_key_choices)),
+            )
+            _, metric_show_by_default_rep = metric_show_filter_field.get_representation(
+                request, "Show Metric Keys", view
+            )
+            metadata["filter_fields"]["metric_show_by_default"] = {
+                "label": "Show Metrics",
+                "lookup_expr": [metric_show_by_default_rep],
+            }
+            _, metric_keys_rep = metric_keys_filter_field.get_representation(request, "Metric Keys", view)
+            metadata["filter_fields"]["metric_keys"] = {"label": "Metric Keys", "lookup_expr": [metric_keys_rep]}
+
+        return metadata
+
+
+class InstrumentMetricMixin(_Base):
+    """
+    Mixin to register automatically a set of metrics defines in METRIC_KEYS into a particular view
+    """
+
+    METRIC_KEYS: tuple[MetricKey] | tuple[()] = ()  # The set of MetricKey to inject into the view
+    METRIC_BASKET_LABEL: str = "id"  # The filter path of the basket in the queryset
+    METRIC_INSTRUMENT_LABEL: str | None = None  # The filter path of the instrument in the queryset. (default to None)
+    METRIC_WITH_PREFIXED_KEYS: bool = (
+        False  # Set to True if prefixed metrics needs to be appended to the list of metric keys
+    )
+    METRIC_SHOW_AGGREGATES: bool = True  # set to False if no aggregation needs to be shown for the inserted metrics
+    METRIC_SHOW_BY_DEFAULT: bool = True  # If false, the metric are hidden by default
+    METRIC_SHOW_FILTERS: bool = False
+
+    display_config_class = InstrumentMetricPivotedListDisplayConfig  # Default display class that automatically regised display Fields into the ListDisplay
+    metadata_class = InstrumentMetricMetaData
+
+    @property
+    def metric_date(self) -> date | None:
+        """
+        Property to define at which date the metrics need to be fetched from. Expected to be override
+        """
+        return None
+
+    @property
+    def metric_basket(self) -> Optional["WBModel"]:
+        """
+        Property to define at for which basket the metrics need to be fetched from. Expected to be override
+        """
+        return None
+
+    @property
+    def metric_basket_class(self) -> Type["Model"]:
+        """
+        Define the basket class from which the metrics need to be fetched from.
+
+        Default to `metric_basket.__class__` if `metric_basket`  is defined. Otherwise default to the viewset Model property.
+        """
+        metric_basket_class = self.metric_basket.__class__ if self.metric_basket else self.model
+        if not metric_basket_class:
+            raise ValueError("Metric Basket Class needs to be defined")
+        return metric_basket_class
+
+    @cached_property
+    def metric_basket_content_type(self) -> ContentType:
+        """
+        cached property to store the related basket content type instance
+        """
+        return ContentType.objects.get_for_model(self.metric_basket_class)
+
+    @property
+    def metric_keys(self) -> tuple[MetricKey] | tuple[()]:
+        """
+        Property used to get the list of metric keys. Can be overridden to define custom logic based on the viewset attributes (e.g. request)
+        """
+        if self.request.GET.get("metric_show_by_default", "true") == "false":
+            return ()
+        metric_keys = getattr(self, "METRIC_KEYS", ())
+        if metric_keys_filter_repr := self.request.GET.get("metric_keys"):
+            metric_keys_filter = metric_keys_filter_repr.split(",")
+            metric_keys = tuple(filter(lambda x: x.key in metric_keys_filter, metric_keys))
+        return metric_keys
+
+    @property
+    def metric_instrument_label(self) -> str | None:
+        """
+        Property used to get the list of metric instrument label. Can be overridden to define custom logic based on the viewset attributes (e.g. request)
+        """
+        return getattr(self, "METRIC_INSTRUMENT_LABEL", None)
+
+    @property
+    def metric_basket_label(self) -> str:
+        """
+        Property used to get the list of metric basket label. Can be overridden to define custom logic based on the viewset attributes (e.g. request)
+        """
+        return getattr(self, "METRIC_BASKET_LABEL", "id")
+
+    @cached_property
+    def _metric_serializer_fields(self):
+        """
+        return the set of serializer fields necessary to display the related metric fields
+        """
+        extra_serializer_fields = {}
+        for metric_key in self.metric_keys:
+            metric_backend = backend_registry[metric_key, self.metric_basket_class](self.metric_date)
+            extra_serializer_fields.update(
+                metric_backend.get_serializer_fields(
+                    with_prefixed_key=self.METRIC_WITH_PREFIXED_KEYS, metric_key=metric_key
+                )
+            )
+        return extra_serializer_fields
+
+    def get_ordering_fields(self) -> list[str]:
+        """
+        Inject the metric field keys as ordering fields
+        """
+        ordering_fields = list(super().get_ordering_fields())
+        for metric_field in self._metric_serializer_fields.keys():
+            ordering_fields.append(metric_field)
+        return ordering_fields
+
+    def get_queryset(self):
+        """
+        Annotate the metrics into the viewset queryset
+        """
+        base_qs = super().get_queryset()
+        for metric_key in self.metric_keys:
+            base_qs = InstrumentMetric.annotate_with_metrics(
+                base_qs,
+                metric_key,
+                self.metric_basket_class,
+                self.metric_date,
+                basket_label=self.metric_basket_label,
+                instrument_label=self.metric_instrument_label,
+            )
+        return base_qs
+
+    def get_serializer(self, *args, **kwargs):
+        """
+        Unwrap defined serializer class and inject the metric fields into a new class
+        """
+
+        serializer_class = self.get_serializer_class()
+        kwargs.setdefault("context", self.get_serializer_context())
+
+        BaseMeta = serializer_class.Meta
+        fields = list(getattr(BaseMeta, "fields", ()))
+        read_only_fields = list(getattr(BaseMeta, "read_only_fields", ()))
+        for extra_field in self._metric_serializer_fields.keys():
+            fields.append(extra_field)
+            read_only_fields.append(extra_field)
+
+        Meta = type(str("Meta"), (BaseMeta,), {"fields": fields, "read_only_fields": read_only_fields})
+        new_class = type(
+            serializer_class.__name__,
+            (serializer_class,),
+            {
+                "Meta": Meta,
+                **self._metric_serializer_fields,
+                "SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES": serializer_class,
+            },
+        )
+
+        return new_class(*args, **kwargs)
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        """
+        Automatically register the metric aggregation
+        """
+        aggregates = dict()
+        if self.METRIC_SHOW_AGGREGATES:
+            # we try to inject the instrument metric aggregates automatically
+            keys_map = {key.key: key for key in self.metric_keys}
+            if self.metric_basket and (ct := self.metric_basket_content_type):
+                # for each "general" metric (i.e. without particular instrument attached), we add the raw subfield value as aggregates
+                for metric in InstrumentMetric.objects.filter(
+                    basket_id=self.metric_basket.id,
+                    basket_content_type=ct,
+                    date=self.metric_date,
+                    key__in=keys_map.keys(),
+                    instrument__isnull=True,
+                ):
+                    metric_key = keys_map[metric.key]
+                    for subfield_key, subfield_filter in metric_key.subfields_filter_map.items():
+                        if subfield_key in self._metric_serializer_fields and (
+                            aggregate_fct := metric_key.subfields_map[subfield_key].aggregate
+                        ):
+                            aggregates[subfield_key] = {
+                                get_aggregate_symbol(aggregate_fct.name): metric.metrics.get(subfield_filter)
+                            }
+            # for all the missings keys (not present in the aggregates already), we compute the aggregatation based on the aggregate function given by the MetricField class
+            missing_aggregate_map = {}
+            for metric_key in self.metric_keys:
+                for field_key, field_filter in metric_key.subfields_filter_map.items():
+                    if field_key in self._metric_serializer_fields.keys() and field_key not in aggregates:
+                        missing_aggregate_map[field_key] = metric_key.subfields_map[field_key]
+            missing_aggregate = queryset.aggregate(
+                **{
+                    "agg_" + subfield_key: subfield.aggregate(subfield_key)
+                    for subfield_key, subfield in missing_aggregate_map.items()
+                    if subfield.aggregate is not None
+                }
+            )
+            for k, v in missing_aggregate.items():
+                key = k.replace("agg_", "")
+                aggregates[key] = {get_aggregate_symbol(missing_aggregate_map[key].aggregate.name): v}
+        return aggregates

wbfdm/contrib/metric/viewsets/viewsets.py

@@ -0,0 +1,40 @@
+from django.db.models import Case, Exists, F, IntegerField, OuterRef, When
+from wbcore import viewsets
+from wbfdm.contrib.metric.filters import InstrumentMetricFilterSet
+from wbfdm.contrib.metric.models import InstrumentMetric
+from wbfdm.contrib.metric.serializers import (
+    InstrumentMetricModelSerializer,
+    InstrumentMetricRepresentationSerializer,
+)
+from wbfdm.contrib.metric.viewsets.configs import InstrumentMetricDisplayConfig
+
+
+class InstrumentMetricRepresentationViewSet(viewsets.RepresentationViewSet):
+    ordering = ["-date"]
+    ordering_fields = [
+        "key",
+        "date",
+    ]
+    filterset_class = InstrumentMetricFilterSet
+
+    serializer_class = InstrumentMetricRepresentationSerializer
+    queryset = InstrumentMetric.objects.all()
+
+
+class InstrumentMetricViewSet(viewsets.ModelViewSet):
+    queryset = InstrumentMetric.objects.select_related("basket_content_type", "instrument").annotate(
+        has_children=Exists(InstrumentMetric.objects.filter(parent_metric=OuterRef("pk"))),
+        _group_key=Case(When(has_children=True, then=F("id")), default=None, output_field=IntegerField()),
+    )
+
+    serializer_class = InstrumentMetricModelSerializer
+    filterset_class = InstrumentMetricFilterSet
+
+    display_config_class = InstrumentMetricDisplayConfig
+
+    ordering = ["-date"]
+    ordering_fields = [
+        "key",
+        "date",
+    ]
+    search_fields = ["key", "instrument__computed_str", "basket_repr"]

wbfdm/contrib/msci/client.py

@@ -0,0 +1,92 @@
+from contextlib import suppress
+from datetime import UTC, datetime
+from typing import Generator
+
+import requests
+from django.core.cache import cache as cache_layer
+from django.utils import timezone
+from django.utils.functional import cached_property
+from jwt import decode as jwt_decode
+from jwt.exceptions import DecodeError
+from requests.exceptions import ConnectionError
+
+
+def is_expired(token: str) -> bool:
+    with suppress(DecodeError, KeyError, ValueError):
+        expiry_ts = int(jwt_decode(token, options={"verify_signature": False})["exp"])
+        expiry_datetime = datetime.fromtimestamp(expiry_ts, UTC)
+        return expiry_datetime < timezone.now()
+    return True
+
+
+class MSCIClient:
+    AUTH_SERVER_ULR: str = "https://accounts.msci.com/oauth/token"
+
+    def __init__(self, client_id: str, client_secret: str):
+        self.client_id = client_id
+        self.client_secret = client_secret
+
+    @cached_property
+    def oauth_token(self) -> str:
+        token = cache_layer.get("msci_oauth_token")
+        if not token or is_expired(token):
+            resp = requests.post(
+                self.AUTH_SERVER_ULR,
+                json={
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                    "grant_type": "client_credentials",
+                    "audience": "https://esg/data",
+                },
+            )
+            if resp.status_code == requests.codes.ok:
+                with suppress(KeyError, requests.exceptions.JSONDecodeError):
+                    resp_json = resp.json()
+                    token = resp_json["access_token"]
+                    expires_in = resp_json["expires_in"]
+                    cache_layer.set("msci_oauth_token", token, expires_in)
+        if token:
+            return token
+        raise ConnectionError()
+
+    def esg(self, identifiers: list[str], factors: list[str]) -> Generator[dict[str, str], None, None]:
+        with suppress(ConnectionError):
+            response = requests.post(
+                url="https://api2.msci.com/esg/data/v2.0/issuers",
+                json={
+                    "issuer_identifier_list": identifiers,
+                    "factor_name_list": factors,
+                },
+                headers={"AUTHORIZATION": f"Bearer {self.oauth_token}"},
+            )
+            if response.ok:
+                for row in response.json().get("result", {}).get("issuers", []):
+                    yield row
+
+    def controversies(self, identifiers: list[str], factors: list[str]) -> Generator[dict[str, str], None, None]:
+        next_url = "https://api2.msci.com/esg/data/v2.0/issuers"
+        offset = 0
+        while next_url:
+            with suppress(ConnectionError):
+                response = requests.post(
+                    url=next_url,
+                    json={
+                        "issuer_identifier_list": identifiers,
+                        "factor_name_list": factors,
+                        "limit": 100,
+                        "offset": offset,
+                    },
+                    headers={"AUTHORIZATION": f"Bearer {self.oauth_token}"},
+                )
+
+                if not response.ok:
+                    next_url = None
+                else:
+                    json_res = response.json()
+                    try:
+                        next_url = json_res["paging"]["links"]["next"]
+                    except KeyError:
+                        next_url = None
+                    offset += 100
+                    for row in json_res.get("result", {}).get("issuers", []):
+                        yield row

wbfdm/contrib/msci/dataloaders/esg.py

@@ -0,0 +1,87 @@
+import enum
+from typing import Iterator
+
+from django.conf import settings
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+from wbfdm.dataloaders.protocols import ESGProtocol
+from wbfdm.dataloaders.types import ESGDataDict
+from wbfdm.enums import ESG
+
+from ..client import MSCIClient
+
+
+class MSCIESG(enum.Enum):
+    CARBON_EMISSIONS_SCOPE_1 = "CARBON_EMISSIONS_SCOPE_1"
+    CARBON_EMISSIONS_SCOPE_1_KEY = "CARBON_EMISSIONS_SCOPE_1_KEY"
+    CARBON_EMISSIONS_SCOPE_2 = "CARBON_EMISSIONS_SCOPE_2"
+    CARBON_EMISSIONS_SCOPE_2_KEY = "CARBON_EMISSIONS_SCOPE_2_KEY"
+    CARBON_EMISSIONS_SCOPE_3_TOTAL = "CARBON_EMISSIONS_SCOPE_3_TOTAL"
+    CARBON_EMISSIONS_SCOPE_3_YEAR = "CARBON_EMISSIONS_SCOPE_3_ESTIMATES_YEAR"
+    CARBON_EMISSIONS_SCOPE123 = "CARBON_EMISSIONS_SCOPE123"
+    CARBON_EMISSIONS_SCOPE123_KEY = "CARBON_EMISSIONS_SCOPE123_KEY"
+    CARBON_EMISSIONS_SALES_EUR_SCOPE_ALL = "CARBON_EMISSIONS_SALES_EUR_SCOPE123_INTEN"
+    CARBON_EMISSIONS_SCOPE123_EVIC_EUR = "CARBON_EMISSIONS_EVIC_EUR_SCOPE123_INTEN"
+    CARBON_EMISSIONS_SOURCE = "CARBON_EMISSIONS_SOURCE"
+    CARBON_EMISSIONS_YEAR = "CARBON_EMISSIONS_YEAR"
+    ACTIVE_FF_SECTOR_EXPOSURE = "ACTIVE_FF_SECTOR_EXPOSURE"
+    ACTIVE_FF_SECTOR_EXPOSURE_SOURCE = "ACTIVE_FF_SECTOR_EXPOSURE_SOURCE"
+    ACTIVE_FF_SECTOR_EXPOSURE_YEAR = "ACTIVE_FF_SECTOR_EXPOSURE_YEAR"
+    PCT_NON_RENEW_CONSUMPTION_PRODUCTION = "PCT_NONRENEW_CONSUMP_PROD"
+    PCT_TOTAL_NON_RENEW_CONSUMPTION = "PCT_TOTL_ERGY_CONSUMP_NONRENEW"
+    PCT_TOTAL_NON_RENEW_PRODUCTION = "PCT_TOTL_ERGY_PRODUCT_NONRENEW"
+    TOTAL_RENEW_ENERGY_CONSUMPTION = "TOTL_ERGY_CONSUMP_RENEW_GWH"
+    TOTAL_RENEW_ENERGY_CONSUMPTION_SOURCE = "TOTL_ERGY_CONSUMP_RENEW_GWH_SOURCE"
+    TOTAL_RENEW_ENERGY_CONSUMPTION_YEAR = "TOTL_ERGY_CONSUMP_RENEW_GWH_YEAR"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION = "TOTL_ERGY_CONSUMP_NONRENEW_GWH"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION_SOURCE = "TOTL_ERGY_CONSUMP_NONRENEW_GWH_SOURCE"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION_YEAR = "TOTL_ERGY_CONSUMP_NONRENEW_GWH_YEAR"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION_PRODUCTION = "TOTL_ERGY_CONSUMP_PRODUCT_NONRENEW_GWH"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION_PRODUCTION_SOURCE = "TOTL_ERGY_CONSUMP_PRODUCT_NONRENEW_GWH_SOURCE"
+    TOTAL_NON_RENEW_ENERGY_CONSUMPTION_PRODUCTION_YEAR = "TOTL_ERGY_CONSUMP_PRODUCT_NONRENEW_GWH_YEAR"
+    ENERGY_CONSUMPTION_INTENSITY_EUR = "ENERGY_CONSUMP_INTEN_EUR"
+    ENERGY_CONSUMPTION_INTENSITY_EUR_SOURCE = "ENERGY_CONSUMP_INTEN_EUR_SOURCE"
+    ENERGY_CONSUMPTION_INTENSITY_EUR_YEAR = "ENERGY_CONSUMP_INTEN_EUR_YEAR"
+    TOTAL_ENERGY_CONSUMPTION = "TOTL_ERGY_CONSUMP_GWH"
+    TOTAL_ENERGY_CONSUMPTION_SOURCE = "TOTL_ERGY_CONSUMP_GWH_SOURCE"
+    TOTAL_ENERGY_CONSUMPTION_YEAR = "TOTL_ENRGY_CONSUMP_YEAR"
+    OPS_BIODIV_CONTROVERSITIES = "OPS_PROT_BIODIV_CONTROVS"
+    OPS_BIODIV_AREAS = "OPS_PROT_BIODIV_AREAS"
+    WATER_EMISSIONS = "WATER_EM_EFF_METRIC_TONS"
+    WATER_EMISSIONS_YEAR = "WATER_EM_EFF_METRIC_TONS_YEAR"
+    WATER_EMISSIONS_SOURCE = "WATER_EM_EFF_METRIC_TONS_SOURCE"
+    HAZARD_WASTE = "HAZARD_WASTE_METRIC_TON"
+    HAZARD_WASTE_YEAR = "HAZARD_WASTE_METRIC_TON_YEAR"
+    HAZARD_WASTE_SOURCE = "HAZARD_WASTE_METRIC_TON_SOURCE"
+    OECD_ALIGNMENT = "OECD_ALIGNMENT"
+    LABOR_DDP = "LABOR_DDIL_POL_ILO"
+    COMPLIANCE_GLOBAL_IMPACT = "MECH_UN_GLOBAL_COMPACT"
+    GENDER_PAY_GAP_RATIO = "GENDER_PAY_GAP_RATIO"
+    GENDER_PAY_GAP_RATIO_YEAR = "GENDER_PAY_GAP_YEAR"
+    GENDER_PAY_GAP_RATIO_SOURCE = "GENDER_PAY_GAP_RATIO_SOURCE"
+    PCT_FEMALE_DIRECTORS = "FEMALE_DIRECTORS_PCT"
+    CONTROVERSIAL_WEAPONS = "CONTRO_WEAP_CBLMBW_ANYTIE"
+    CONTROVERSIAL_WEAPONS_SOURCE = "CONTRO_WEAP_CBLMBW_ANYTIE_SOURCE"
+    CVI_FACTOR = "CVI_FACTOR"
+    EVIC_EUR = "EVIC_EUR"
+    NACE_SECTION_CODE = "NACE_SECTION_CODE"
+
+
+class MSCIESGDataloader(ESGProtocol, Dataloader):
+    CACHE_IDENTIFIER_KEY: str = "instrument_id"
+    CACHE_SYMBOL_KEY: str = "factor_code"
+    CACHE_VALUE_KEY: str = "value"
+
+    def esg(self, values: list[ESG]) -> Iterator[ESGDataDict]:
+        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__parameters", "id")}
+            for row in client.esg(list(lookup.keys()), [MSCIESG[value.name].value for value in values]):
+                if instrument_id := lookup.get(row["ISSUER_ISIN"], None):
+                    for value in values:
+                        yield ESGDataDict(
+                            instrument_id=instrument_id,
+                            factor_code=value.value,
+                            value=row.get(MSCIESG[value.name].value, None),
+                        )