wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/import_export/handlers/instrument_price.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from typing import List
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+
+MAX_NB_DATES_BEFORE_HISTORICAL_IMPORT = 3
+
+
+class InstrumentPriceImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.InstrumentPrice"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.updated_instruments = set()
+
+    def _deserialize(self, data):
+        if data.get("instrument", None) is None or data.get("date", None) is None:
+            raise DeserializationError("Instrument or Date is empty")
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+
+        instrument = self.instrument_handler.process_object(data["instrument"], only_security=False, read_only=True)[0]
+        if not instrument:
+            raise DeserializationError("Instrument couldn't be found with given data")
+        self.updated_instruments.add(instrument)
+        data["instrument"] = instrument
+        if data.get("net_value", None) is None:
+            # casted_instrument = instrument.get_casted_instrument()
+            # # we try to find the primary field among the data to set the net value from it
+            # if primary_field_value := data.pop(casted_instrument.primary_field, None):
+            #     data["net_value"] = primary_field_value
+            # # in a last case, we try to find the close value and set it as the net value
+            if close := data.pop("close", None):
+                data["net_value"] = close
+        else:
+            if data.get("gross_value", None) is None:
+                data["gross_value"] = data["net_value"]
+
+        # Backward compatibility with refinitiv parser.
+        for forbbiden_field in ["close", "price_index", "yield_redemption", "net_return", "offered_rate"]:
+            data.pop(forbbiden_field, None)
+
+        # We do this to ensure an invalid number won't make the import fails
+        for k, v in data.items():
+            if v and (field := self.model._meta.get_field(k)) and hasattr(field, "max_digits"):
+                try:
+                    field.clean(value=str(round(v, field.decimal_places)), model_instance=None)
+                except ValidationError:
+                    data[k] = None
+
+        if data.get("net_value", None) is None:
+            raise DeserializationError("Net value not set.")
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += f"\nParameter: Instrument={data['instrument']} Date={data['date']}"
+        price = data["instrument"].prices.filter(date=data["date"], calculated=False)
+        if price.exists():
+            return price.first()
+
+    def _post_processing_objects(
+        self,
+        created_objs: List[models.Model],
+        modified_objs: List[models.Model],
+        unmodified_objs: List[models.Model],
+    ):
+        for instrument in self.updated_instruments:
+            instrument.update_last_valuation_date()

wbfdm/import_export/handlers/option.py

@@ -0,0 +1,54 @@
+from contextlib import suppress
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import models
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+
+from .instrument import InstrumentImportHandler
+
+
+class OptionAggregateImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.OptionAggregate"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        instrument = self.instrument_handler.process_object(data["instrument"], read_only=True)[0]
+        if not instrument:
+            raise DeserializationError("Instrument couldn't be found with given data")
+        data["instrument"] = instrument
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        with suppress(ObjectDoesNotExist):
+            return self.model.objects.filter(instrument=data["instrument"], date=data["date"], type=data["type"])
+
+
+class OptionImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.Option"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        data["expiration_date"] = datetime.strptime(data["expiration_date"], "%Y-%m-%d").date()
+        instrument = self.instrument_handler.process_object(data["instrument"], read_only=True)[0]
+        if not instrument:
+            raise DeserializationError("Instrument couldn't be found with given data")
+        data["instrument"] = instrument
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        with suppress(ObjectDoesNotExist):
+            return self.model.objects.filter(
+                instrument=data["instrument"],
+                contract_identifier=data["contract_identifier"],
+                date=data["date"],
+                type=data["type"],
+            )

wbfdm/import_export/handlers/private_equities.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from django.db import models
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+
+from .instrument import InstrumentImportHandler
+
+
+class DealImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.Deal"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        equity = self.instrument_handler.process_object(
+            {**data["equity"], "instrument_type": "private_equity"}, read_only=True
+        )[0]
+        if not equity:
+            raise DeserializationError("Private Equity couldn't be found with given data")
+        data["equity"] = equity
+
+        if investors := data.pop("investors", []):
+            data["investors"] = [
+                self.instrument_handler.process_object(investor_data, read_only=True)[0] for investor_data in investors
+            ]
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        if external_id := data.get("external_id", None):
+            return self.model.objects.filter(external_id=external_id).first()
+        qs = self.model.objects.filter(
+            equity=data["equity"], date=data["date"], transaction_amount=data["transaction_amount"]
+        )
+        if qs.count() == 1:
+            return qs.first()
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        investors = data.pop("investors", None)
+        obj = self.model.objects.create(
+            **data,
+            import_source=self.import_source,
+        )
+        if investors:
+            obj.investors.set([i for i in investors if i])
+        return obj

wbfdm/import_export/parsers/cbinsights/deals.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pandas as pd
+from wbfdm.models import Deal
+
+COLUMNS_MAP = {
+    "dealDate": "date",
+    "fundedOrg": "equity__provider_id",
+    "dealSizeInMillions": "transaction_amount",
+    "investors": "investors",
+    "fundingRound": "funding_round",
+    "fundingRoundCategory": "funding_round_category",
+    "valuationInMillions": "valuation",
+    "valuationIsEstimate": "valuation_estimated",
+    "valuationSourceType": "valuation_source_type",
+    "valuationSourceUrls": "valuation_media_mention_source_urls",
+    "dealId": "external_id",
+}
+
+
+def parse(import_source):
+    def _parse_investors(investors):
+        return [{"provider_id": investor["orgId"]} for investor in investors]
+
+    data = []
+    df = pd.read_json(import_source.file, orient="records")
+
+    df = df.rename(columns=COLUMNS_MAP)
+    df["equity__provider_id"] = df["equity__provider_id"].apply(lambda x: x["orgId"])
+    df["type"] = Deal.Types.DEAL
+    if not df.empty:
+        df["investors"] = df.investors.apply(lambda x: _parse_investors(x))
+        df["valuation"] *= 1e6
+        df["transaction_amount"] *= 1e6
+        df = df.drop(columns=df.columns.difference(COLUMNS_MAP.values()))
+        df = df.replace([np.inf, -np.inf, np.nan], None)
+        df = df[~df["transaction_amount"].isnull()]
+        data.extend(df.to_dict("records"))
+
+    return {"data": data}

wbfdm/import_export/parsers/cbinsights/equities.py

@@ -0,0 +1,56 @@
+import json
+
+from wbcore.contrib.geography.models import Geography
+from wbfdm.models import ClassificationGroup
+
+FIELDS_MAP = {
+    "orgName": "name",
+    "url": "primary_url",
+    "description": "description",
+}
+
+
+def parse(import_source):
+    cbinsight_group = ClassificationGroup.objects.get_or_create(name="CBinsights", max_depth=2)[0]
+    content = json.load(import_source.file)
+
+    data = []
+    for org_data in content:
+        d = {
+            "provider_id": org_data["orgId"],
+            "description": org_data["description"],
+            "name": org_data["orgName"],
+            "primary_url": org_data["url"],
+            "instrument_type": "private_equity",
+        }
+        if summary := org_data.get("orgSummary", None):
+            if additional_urls := summary.get("additionalUrls", None):
+                d["additional_urls"] = additional_urls
+            if alternative_names := summary.get("aliases", None):
+                d["alternative_names"] = alternative_names
+            d["founded_year"] = summary["foundedYear"]
+
+            if (country_name := summary.get("country")) and (
+                country := Geography.countries.get_by_name(country_name.strip())
+            ):
+                d["country"] = country.id
+
+                if city_name := summary.get("city", None):
+                    # We comment this out because looking up the city at import time drastically decrease speed
+                    # if city := Geography.cities.get_by_name(city_name.strip(), parent__parent=country):
+                    #     d["headquarter_city"] = city.id
+                    if (postal_code := summary.get("postalCode", None)) and (street := summary.get("street", None)):
+                        d["headquarter_address"] = f"{street}, {postal_code} {city_name}"
+
+            if sector_id := summary.get("sectorId", None):
+                try:
+                    code_aggregated = f"{int(sector_id):03}"
+                    if industry_id := summary.get("industryId", None):
+                        code_aggregated += f"{int(industry_id):03}"
+                        if subindustry_id := summary.get("subindustryId", None):
+                            code_aggregated += f"{int(subindustry_id):03}"
+                except Exception:
+                    pass
+                d["classifications"] = [{"code_aggregated": code_aggregated, "group": cbinsight_group.id}]
+        data.append(d)
+    return {"data": data}

wbfdm/import_export/parsers/cbinsights/fundamentals.py

@@ -0,0 +1,45 @@
+import json
+
+import pandas as pd
+from django.contrib.contenttypes.models import ContentType
+from wbfdm.models import Instrument
+
+
+def parse(import_source):
+    content = json.load(import_source.file)
+    data = []
+    equity_content_type_id = ContentType.objects.get_for_model(Instrument).id
+    for org_data in content:
+        if (revenue_data := org_data.get("orgRevenue", None)) and not (df := pd.DataFrame(revenue_data)).empty:
+            df = df[["revenueFiscalYear", "revenueMin", "revenueMax"]]
+            df["revenue"] = (df.revenueMin + df.revenueMax) * 1e6 / 2
+            df = df[["revenue", "revenueFiscalYear"]].rename(
+                columns={"revenueFiscalYear": "period__period_year", "revenue": "revenue"}
+            )
+            df = df.groupby("period__period_year").mean().reset_index()
+            df.period__period_year = df.period__period_year.astype(int)
+            df["period__period_type"] = "FiscalPeriod.PeriodTypeChoice.ANNUAL"  # TODO REFACTORING
+            df["period__period_interim"] = True
+            df["period__period_end_date"] = df.period__period_year.apply(lambda x: f"{x}-12-31")
+            df["instrument__provider_id"] = org_data["orgId"]
+            df["instrument__content_type"] = equity_content_type_id
+            data.extend(df.to_dict("records"))
+        elif (
+            (kpi_data := org_data.get("orgKPIs", None))
+            and (last_revenue_max := kpi_data.get("latestRevenueMax", None))
+            and (last_revenue_min := kpi_data.get("latestRevenueMin", None))
+            and (last_revenue_year := kpi_data.get("latestRevenueFiscalYear", None))
+        ):
+            fiscal_year = int(last_revenue_year)
+            data.append(
+                {
+                    "revenue": (last_revenue_max + last_revenue_min) / 2,
+                    "period__period_type": "FiscalPeriod.PeriodTypeChoice.ANNUAL",  # TODO REFACTORING,
+                    "period__period_interim": True,
+                    "period__period_year": fiscal_year,
+                    "period__period_end_date": f"{fiscal_year}-12-31",
+                    "instrument__provider_id": org_data["orgId"],
+                    "instrument__content_type": equity_content_type_id,
+                }
+            )
+    return {"data": data}

wbfdm/import_export/parsers/refinitiv/daily_fundamental.py

@@ -0,0 +1,7 @@
+from wbfdm.import_export.backends.refinitiv.daily_fundamental import DEFAULT_MAPPING
+
+from .utils import parse_daily_fundamental_data
+
+
+def parse(import_source):
+    return parse_daily_fundamental_data(import_source, DEFAULT_MAPPING, extra_normalization_map={"free_cash": 1000})

wbfdm/import_export/parsers/refinitiv/forecast.py

@@ -0,0 +1,7 @@
+from wbfdm.import_export.backends.refinitiv.forecast import DEFAULT_MAPPING
+
+from .utils import parse_daily_fundamental_data
+
+
+def parse(import_source):
+    return parse_daily_fundamental_data(import_source, DEFAULT_MAPPING)

wbfdm/import_export/parsers/refinitiv/fundamental.py

@@ -0,0 +1,9 @@
+from wbfdm.import_export.backends.refinitiv.fundamental import DEFAULT_MAPPING
+
+from .utils import parse_periodic_fundamental_data
+
+
+def parse(import_source):
+    return parse_periodic_fundamental_data(
+        import_source, DEFAULT_MAPPING, extra_normalization_map={"company_tax_rate": 0.01}
+    )

wbfdm/import_export/parsers/refinitiv/geographic_segment.py

@@ -0,0 +1,7 @@
+from wbfdm.import_export.backends.refinitiv.geographic_segment import DEFAULT_MAPPING
+
+from .utils import parse_periodic_fundamental_data
+
+
+def parse(import_source):
+    return parse_periodic_fundamental_data(import_source, DEFAULT_MAPPING)

wbfdm/import_export/parsers/refinitiv/instrument.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pandas as pd
+from wbfdm.import_export.backends.refinitiv.instrument import DEFAULT_MAPPING
+from wbfdm.models import ClassificationGroup
+
+from .utils import get_country, get_exchange
+
+
+def get_instrument_type(_type):
+    if _type == "BD":
+        return "bond"
+    elif _type in ["EQ", "ADR", "ET", "GDR", "INVT", "CF"]:
+        return "equity"
+    elif _type in ["CF"]:
+        return "close_ended_fund"
+    elif _type == "EQIND":
+        return "index"
+    elif _type == "OP":
+        return "option"
+    elif _type == "SWAPS":
+        return "swaps"
+    elif _type == "CMD":
+        return "commodity"
+    elif _type == "INT":
+        return "interest_rate_derivative"
+    elif _type == "FT":
+        return "future"
+
+
+def parse(import_source):
+    # Read Json as dataframe
+    df = pd.read_json(import_source.file, orient="records")
+    # Sanitize df and rename columns to model knowledge's
+    data = list()
+    if not df.empty:
+        df = (
+            df.replace({"NA": None})
+            .rename(columns={**DEFAULT_MAPPING, "Instrument": "instrument"})
+            .set_index("instrument")
+        )
+        df = df.drop(columns=df.columns.difference(DEFAULT_MAPPING.values()))
+        df = df.replace([np.inf, -np.inf, np.nan], None)
+        df["ticker"] = df["ticker"].astype(str)
+        df = df.dropna(how="all", subset=df.columns)
+        df = df.groupby(level=0, axis=1).first()
+        df["inception_date"] = pd.to_datetime(df["inception_date"], format="%Y%m%d", errors="coerce").dt.strftime(
+            "%Y-%m-%d"
+        )
+        df = df.replace([np.inf, -np.inf, np.nan, pd.NaT], None).replace({"None": None}).dropna(how="all")
+        for row in df.to_dict("records"):
+            exchanges = []
+            if exchanges_str := row.pop("exchanges", None):
+                exchanges = [get_exchange(e) for e in exchanges_str.split(" ")]
+            if exchange := row.pop("exchange", None):
+                exchanges.append(get_exchange(exchange))
+            row["instrument_type"] = get_instrument_type(row.get("instrument_type", None))
+            if ticker := row.get("ticker", None):
+                row["ticker"] = ticker.replace("'", "").split("-")[0]
+
+            row["exchanges"] = exchanges
+            row["country"] = get_country(row.get("country", None))
+            classifications = []
+            if gics_classification := row.pop("gics_classification", None):
+                classifications.append(
+                    {
+                        "code_aggregated": gics_classification,
+                        "group": ClassificationGroup.objects.get(is_primary=True).id,
+                    }
+                )
+            if trbc_classification := row.pop("trbc_classification", None):
+                group, created = ClassificationGroup.objects.get_or_create(name="TRBC")
+                classifications.append({"code_aggregated": trbc_classification, "group": group.id})
+            row["classification"] = classifications
+            data.append({k: v for k, v in row.items() if v})
+    return {"data": data}

wbfdm/import_export/parsers/refinitiv/instrument_price.py

@@ -0,0 +1,26 @@
+import numpy as np
+import pandas as pd
+from wbfdm.import_export.backends.refinitiv.instrument_price import DEFAULT_MAPPING
+
+from .utils import _clean_and_return_dict
+
+
+def parse(import_source):
+    # Read Json as dataframe
+    df = pd.read_json(import_source.file, orient="records")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    # Sanitize df and rename columns to model knowledge's
+    df = (
+        df.replace({"NA": None})
+        .rename(columns=DEFAULT_MAPPING)
+        .rename(columns={"Instrument": "instrument", "Dates": "date"})
+    )
+    # Sanitize
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df = df.dropna(how="all", subset=df.columns.difference(["instrument"]))
+
+    df["date"] = pd.to_datetime(df["date"], utc=True, unit="ms")
+    df = df.sort_values(by="date", ascending=True)
+    df["date"] = df["date"].dt.strftime("%Y-%m-%d")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    return {"data": _clean_and_return_dict(df)}

wbfdm/import_export/parsers/refinitiv/utils.py

@@ -0,0 +1,96 @@
+from datetime import date
+
+import numpy as np
+import pandas as pd
+from wbcore.contrib.geography.models import Geography
+
+REPORT_TYPE_MAP = {1: "Q", 2: "6M", 3: "4M", 4: "Y"}
+
+
+def get_exchange(code):
+    return {"mic_code": code}
+
+
+def get_country(code):
+    country = Geography.countries.filter(code_2=code).first()
+    return country.id if country else None
+
+
+def _clean_and_return_dict(df, extra_normalization_map=None):
+    # df = df.groupby(df.columns, axis=1).sum()
+    if extra_normalization_map:
+        for col, den in extra_normalization_map.items():
+            if col in df.columns:
+                df[col] *= den
+    if percent_fields_columns := list(filter(lambda x: "margin" in x, df.columns)):
+        df[percent_fields_columns] = (
+            df[percent_fields_columns] / 100
+        )  # margin/percent type of data are given in base 100 by refinitiv
+    df["instrument"] = df["instrument"].str.replace("^<|>", "", regex=True)
+    df = df.rename(columns={"instrument": "instrument__provider_id"})
+    # df["instrument__refinitiv_identifier_code"] = df["instrument__provider_id"] # We add this for backward compatibility reason
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    return df.to_dict("records")
+
+
+def parse_daily_fundamental_data(import_source, default_mapping, extra_normalization_map=None):
+    df = pd.read_json(import_source.file, orient="records")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    mapping = {**default_mapping, "Instrument": "instrument", "Dates": "date"}
+    df = df.rename(columns=mapping).dropna(how="all", axis=1)
+    df = df.drop(columns=df.columns.difference(mapping.values()))
+    data = list()
+    if not df.empty:
+        df["date"] = pd.to_datetime(df["date"], utc=True, unit="ms")
+        df = df.sort_values(by="date", ascending=True)
+        df.date = df.date.dt.strftime("%Y-%m-%d")
+        data = _clean_and_return_dict(df, extra_normalization_map=extra_normalization_map)
+    return {"data": data}
+
+
+def parse_periodic_fundamental_data(import_source, default_mapping, extra_normalization_map=None):
+    def _get_fiscal_period(_date, frequency):
+        fiscal_period = 0
+        for index, p in enumerate(
+            pd.period_range(start=date(_date.year, 1, 1), end=date(_date.year, 12, 31), freq=frequency)
+        ):
+            if _date >= p.start_time.date() and _date <= p.end_time.date():
+                fiscal_period = index + 1
+        return fiscal_period
+
+    df = pd.read_json(import_source.file, orient="records")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    mapping = {**default_mapping, "Instrument": "instrument", "Dates": "date"}
+    df = df.rename(columns=mapping).dropna(how="all", axis=1)
+
+    df = df.drop(columns=df.columns.difference([*mapping.values(), "period__period_interim"]))
+    df = df.dropna(
+        how="all",
+        subset=df.columns.difference(
+            ["instrument", "date", "period__period_interim", "period__period_end_date", "period__period_type"]
+        ),
+    )
+    df = df.dropna(
+        how="any",
+        subset=df.columns.intersection(["instrument", "date", "period__period_end_date", "period__period_type"]),
+    )
+    data = list()
+    if not df.empty:
+        df["date"] = pd.to_datetime(df["date"], utc=True, unit="ms")
+        df["period__period_end_date"] = pd.to_datetime(df["period__period_end_date"], utc=True)
+        df["period__period_year"] = df.date.dt.year
+        df["period__period_type"] = df["period__period_type"].map(REPORT_TYPE_MAP)
+        df["period__period_type"] = df["period__period_type"].fillna("Q")  # Assuming empty period type is quaterly
+        df["period__period_index"] = df[["date", "period__period_type"]].apply(
+            lambda x: _get_fiscal_period(x["date"].date(), x["period__period_type"]), axis=1
+        )
+        del df["date"]
+
+        df["period__period_end_date"] = df["period__period_end_date"] + pd.offsets.MonthEnd(0)
+        df["period__period_end_date"] = df["period__period_end_date"].dt.strftime("%Y-%m-%d")
+        df = df.sort_values(by="period__period_end_date")
+
+        if "employee_count" in df.columns:
+            df["employee_count"] = df["employee_count"].bfill()
+        data = _clean_and_return_dict(df, extra_normalization_map=extra_normalization_map)
+    return {"data": data}

wbfdm/import_export/resources/classification.py

@@ -0,0 +1,23 @@
+from import_export.widgets import ManyToManyWidget
+from wbfdm.models import Classification, ClassificationGroup
+from wbfdm.preferences import get_default_classification_group
+
+
+class ClassificationManyToManyWidget(ManyToManyWidget):
+    model = Classification
+    field = "code_aggregated"
+
+    def __init__(self, separator=None, field="code_aggregated", primary_classification_group=False, **kwargs):
+        super().__init__(Classification, separator=separator, field=field, **kwargs)
+        self.primary_classification_group = primary_classification_group
+
+    def clean(self, value, row=None, **kwargs):
+        if self.primary_classification_group:
+            primary_classification_group = ClassificationGroup.objects.get(is_primary=True)
+        else:
+            primary_classification_group = get_default_classification_group()
+        queryset = Classification.objects.filter(
+            **{f"{self.field}__icontains": value, "group": primary_classification_group}
+        )
+        if queryset.count() == 1:
+            return queryset

wbfdm/import_export/resources/instrument_prices.py

@@ -0,0 +1,33 @@
+from import_export import fields
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.io.resources import FilterModelResource
+from wbfdm.models import Instrument, InstrumentPrice
+
+
+class InstrumentPriceExportResource(FilterModelResource):
+    """
+    Instrument Price Resource class to use to export instrument price from the viewset
+    """
+
+    instrument = fields.Field(
+        column_name="instrument",
+        attribute="instrument",
+        widget=ForeignKeyWidget(Instrument, field="isin"),
+    )
+
+    class Meta:
+        fields = (
+            "date",
+            "net_value",
+            "gross_value",
+            "market_capitalization",
+            "sharpe_ratio",
+            "correlation",
+            "beta",
+            "outstanding_shares_consolidated",
+            "volume",
+            "volume_50d",
+            "instrument",
+        )
+        export_order = fields
+        model = InstrumentPrice