wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/import_export/backends/refinitiv/instrument_price.py

@@ -0,0 +1,77 @@
+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 BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+from .utils import Controller
+
+DEFAULT_MAPPING = {
+    "MV": "market_capitalization",
+    "MVC": "market_capitalization_consolidated",
+    "VO": "volume",
+    "MAV#(X(VO),-50D,R)": "volume_50d",
+    "BETA": "beta",
+    "NOSH": "outstanding_shares",
+    "IBNOSH": "outstanding_shares_consolidated",
+    "P": "close",
+    "PI": "price_index",
+    "RY": "yield_redemption",
+    "NR": "net_return",
+    "IO": "offered_rate",
+}
+
+MUTUAL_FUND_TIMEDELTA_DAY_SHIFT = 7
+
+
+@register("Instrument Price", 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(2)).date())
+
+        delayed_instrument_ids = list(
+            filter(
+                lambda x: True,
+                obj_external_ids,
+            )
+        )
+        obj_external_ids = list(filter(lambda v: v not in delayed_instrument_ids, obj_external_ids))
+        # we get all active instruments even these were we are not suppose to fetch prices.
+        fields = list(DEFAULT_MAPPING.keys())
+        if obj_external_ids or delayed_instrument_ids:
+            df_list = []
+            if obj_external_ids:
+                df_list.append(
+                    self.controller.get_data(obj_external_ids, fields, start, execution_date, ibes_fields=["IBNOSH"])
+                )
+            if delayed_instrument_ids:
+                # we need to get mutual fund price in a different batch because there is a price delay and the windows approach can't handle it otherwise
+                df_list.append(
+                    self.controller.get_data(
+                        delayed_instrument_ids,
+                        fields,
+                        start - BDay(MUTUAL_FUND_TIMEDELTA_DAY_SHIFT),
+                        execution_date,
+                        ibes_fields=["IBNOSH"],
+                    )
+                )
+            df = pd.concat(df_list, axis=0, ignore_index=True)
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                file_name = f"instrument_price_{start:%Y-%m-%d}-{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                yield file_name, content_file

wbfdm/import_export/backends/refinitiv/mixin.py

@@ -0,0 +1,29 @@
+from datetime import date
+
+from django.db import models
+from wbfdm.models.instruments import Instrument
+
+
+class DataBackendMixin:
+    def is_object_valid(self, obj: models.Model) -> bool:
+        return (
+            super().is_object_valid(obj)
+            and obj.is_active_at_date(date.today())
+            and (obj.refinitiv_identifier_code or obj.isin or obj.refinitiv_mnemonic_code)
+        )
+
+    def get_default_queryset(self):
+        privates_equities = Instrument.objects.filter(instrument_type__key="private_equity")
+        return Instrument.objects.exclude(id__in=privates_equities.values("id"))
+
+    def get_provider_id(self, obj: models.Model) -> str:
+        if perm_id := self.controller.fetch_perm_id(
+            instrument_ric=obj.refinitiv_identifier_code,
+            instrument_isin=obj.isin,
+            instrument_mnemonic=obj.refinitiv_mnemonic_code,
+        ):
+            return perm_id
+        elif (
+            obj.refinitiv_identifier_code
+        ):  # We default to the RIC in case permID can't be found because some instrument don't have any
+            return obj.refinitiv_identifier_code

wbfdm/import_export/backends/refinitiv/utils/__init__.py

@@ -0,0 +1 @@
+from .controller import Controller

wbfdm/import_export/backends/refinitiv/utils/controller.py

@@ -0,0 +1,182 @@
+from datetime import date
+
+import pandas as pd
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from pandas.tseries.offsets import QuarterEnd, YearEnd
+from tqdm import tqdm
+from wbcore.contrib.io.models import ImportedObjectProviderRelationship, Provider
+from wbfdm.contrib.dsws.client import Client
+from wbfdm.models.instruments.instruments import Instrument
+
+REPORT_TYPE_MAP = {"QTR": "Q", "TRI": "4M", "SAN": "6M", "ANN": "Y"}
+
+
+class Controller:
+    def __init__(self, client_username: str, client_password: str):
+        self.provider = Provider.objects.get(key="refinitiv")
+        self.client = Client(username=client_username, password=client_password)
+
+    @classmethod
+    def _wrap_identifier_in_bracklet(cls, perm_ids: list[str]) -> list[str]:
+        return [f"<{perm_id}>" for perm_id in perm_ids]
+
+    def get_start_and_end_date_for_interim(self, perm_id: str, end: date, start: date | None = None) -> date | None:
+        if not start:
+            start = end - QuarterEnd(1)
+        if rel := ImportedObjectProviderRelationship.objects.filter(
+            provider=self.provider,
+            provider_identifier=perm_id,
+            content_type=ContentType.objects.get_for_model(Instrument),
+        ).first():
+            instrument = rel.content_object
+            fundamentals = instrument.fundamentals.order_by("-period__period_year", "-period__period_index")
+            # Not an historical import, it's a bulk one, we need to get the next fiscal period to fetch
+            if fundamentals.exists() and (fiscal_period := fundamentals.first().period):
+                start = fiscal_period.calendar_period.end_time.date()
+
+        return (start + QuarterEnd(0)).date(), (
+            end + QuarterEnd(0) + QuarterEnd(1)
+        ).date()  # We always refetch since the beginning of the quarter
+
+    @classmethod
+    def get_start_date_for_annual(cls, end: date, start: date | None = None) -> date:
+        if not start:
+            start = end
+        return (start - YearEnd(1)).date(), (
+            end + YearEnd(0)
+        ).date()  # We always refetch since the beginning of the quarter
+
+    def get_frequency(self, instrument: str) -> str:
+        try:
+            res = self.client.get_static_df([instrument], ["IBEFPD"])
+            if not res.empty:
+                return REPORT_TYPE_MAP[res.set_index("Instrument").loc[instrument, "IBEFPD"]]
+        except Exception:
+            return "Q"
+
+    def fetch_perm_id(
+        self,
+        instrument_ric: str = None,
+        instrument_isin: str = None,
+        instrument_mnemonic: str = None,
+        perm_id_symbols: list[str] = ["QPID", "IPID"],
+    ) -> str | None:
+        def _process_ticker(ticker):
+            if not (df := self.client.get_static_df(tickers=[ticker], fields=perm_id_symbols)).empty:
+                for perm_id in perm_id_symbols:
+                    if identifier := df[perm_id].iloc[0]:
+                        return identifier
+
+        res = None
+        if instrument_ric:
+            res = _process_ticker(f"<{instrument_ric}>")
+        if instrument_mnemonic and not res:
+            res = _process_ticker(instrument_mnemonic)
+        if instrument_isin and not res:
+            res = _process_ticker(instrument_isin)
+        return res
+
+    def get_data(
+        self,
+        identifiers: list[str],
+        fields: list[str],
+        start: date | None = None,
+        end: date | None = None,
+        wrap_tickers_into_brackets: bool = True,
+        **extra_client_kwargs,
+    ) -> pd.DataFrame:
+        df_list = []
+        chunked_identifiers = self.client.get_chunked_list(identifiers, len(fields))
+
+        if settings.DEBUG:
+            chunked_identifiers = tqdm(chunked_identifiers, total=len(chunked_identifiers))
+
+        frequency = extra_client_kwargs.pop("freq", "D")
+        for perm_ids in chunked_identifiers:
+            if wrap_tickers_into_brackets:
+                perm_ids = self._wrap_identifier_in_bracklet(perm_ids)
+            if start or end:
+                dff = self.client.get_timeserie_df(
+                    perm_ids, fields, start=start, end=end, freq=frequency, **extra_client_kwargs
+                )
+                df_list.append(dff)
+            else:
+                df_list.append(self.client.get_static_df(perm_ids, fields, **extra_client_kwargs))
+        if df_list:
+            return pd.concat(df_list, axis=0)
+        return pd.DataFrame()
+
+    def get_interim_fundamental_data(
+        self,
+        identifiers: list[str],
+        annual_fields: list[str],
+        initial_start: date | None = None,
+        initial_end: date | None = None,
+        wrap_tickers_into_brackets: bool = True,
+        **extra_client_kwargs,
+    ) -> pd.DataFrame:
+        df_list = []
+        interim_fields_map = {field + "A" if field[0:2] == "WC" else field: field for field in annual_fields}
+        if settings.DEBUG:
+            identifiers = tqdm(identifiers, total=len(identifiers))
+
+        for instrument_perm_id in identifiers:
+            start = initial_start  # copy start argument
+            end = initial_end  # copy end argument
+
+            start, end = self.get_start_and_end_date_for_interim(instrument_perm_id, end, start=start)
+            if start and end:
+                perm_ids = [instrument_perm_id]
+                if wrap_tickers_into_brackets:
+                    perm_ids = self._wrap_identifier_in_bracklet(perm_ids)
+                # frequency = self.get_frequency(identifiers[0])
+                df = self.client.get_timeserie_df(
+                    perm_ids,
+                    list(interim_fields_map.keys()),
+                    start=start,
+                    end=end,
+                    **extra_client_kwargs,
+                )
+                if not df.empty:
+                    df_list.append(df)
+        if df_list:
+            df = pd.concat(df_list, axis=0).dropna(how="all")
+            df["period__period_interim"] = True
+            return df.rename(columns=interim_fields_map)
+        return pd.DataFrame()
+
+    def get_annual_fundamental_data(
+        self,
+        identifiers: list[str],
+        annual_fields: list[str],
+        initial_start: date | None = None,
+        initial_end: date | None = None,
+        wrap_tickers_into_brackets: bool = True,
+        **extra_client_kwargs,
+    ) -> pd.DataFrame:
+        df_list = []
+        start, end = self.get_start_date_for_annual(initial_end, start=initial_start)
+        chunked_identifiers = self.client.get_chunked_list(identifiers, len(annual_fields))
+        if settings.DEBUG:
+            chunked_identifiers = tqdm(chunked_identifiers, total=len(chunked_identifiers))
+        for perm_ids in chunked_identifiers:
+            if wrap_tickers_into_brackets:
+                perm_ids = self._wrap_identifier_in_bracklet(perm_ids)
+            df = self.client.get_timeserie_df(
+                perm_ids,
+                annual_fields,
+                start=start,
+                end=end,
+                freq="Y",
+                **extra_client_kwargs,
+            )
+            if not df.empty:
+                df_list.append(df)
+
+        if df_list:
+            df = pd.concat(df_list, axis=0).dropna(how="all")
+            df["WC05200"] = 4
+            df["period__period_interim"] = False
+            return df
+        return pd.DataFrame()

wbfdm/import_export/handlers/instrument.py

@@ -0,0 +1,253 @@
+import operator
+from contextlib import suppress
+from datetime import datetime
+from functools import reduce
+from typing import Any, Dict, Optional
+
+from django.contrib.postgres.search import TrigramSimilarity
+from django.core.exceptions import MultipleObjectsReturned
+from django.db import IntegrityError, models
+from django.db.models import Q
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler, ImportState
+from wbfdm.models.exchanges import Exchange
+
+
+class InstrumentLookup:
+    ORDERED_KEYS = [
+        "instrument_type",
+        "isin",
+        "refinitiv_identifier_code",
+        "refinitiv_mnemonic_code",
+        "identifier",
+        "ticker",
+    ]
+
+    def __init__(self, model, trigram_similarity_min_score: float = 0.8):
+        self.cache = {}
+        self.model = model
+        self.trigram_similarity_min_score = trigram_similarity_min_score
+
+    @classmethod
+    def _get_cache_key(cls, **data):
+        if data:
+            return "-".join([f"{k}:{data.get(k, None)}" for k in cls.ORDERED_KEYS if data.get(k, None) is not None])
+
+    def _lookup_instrument(
+        self,
+        instrument_type=None,
+        currency=None,
+        exchange=None,
+        name=None,
+        only_investable_universe: bool = False,
+        exact_lookup: bool = False,
+        **identifiers,
+    ):
+        identifiers = {k: v for k, v in identifiers.items() if v is not None}
+        # General lookup, we try to gracefully find the instrument based on all available identifier fields
+        cache_key = self._get_cache_key(**identifiers)
+        if cache_key and cache_key in self.cache:
+            return self.cache[cache_key]
+
+        instrument = None
+
+        # We need to lookup ticker because some provider gives us ticker with or without space in it
+        if only_investable_universe:
+            instruments = self.model.objects.filter(is_investable_universe=True)
+        else:
+            instruments = self.model.objects.filter(is_security=True)
+
+        # Try exact lookup on the filtered out universe
+        for identifier_key in [
+            "isin",
+            "refinitiv_identifier_code",
+            "refinitiv_mnemonic_code",
+            "sedol",
+            "cusip",
+            "ticker",
+            "identifier",
+        ]:
+            if identifier := identifiers.get(identifier_key, None):
+                with suppress(self.model.DoesNotExist, MultipleObjectsReturned):
+                    identifier = str(identifier)
+                    if (
+                        identifier_key != "refinitiv_identifier_code"
+                    ):  # RIC cannot be uppercased because its symbology implies meaning for lowercase characters
+                        identifier = identifier.upper()
+                    instrument = instruments.get(**{identifier_key: identifier})
+                    break
+
+        if not instrument and not exact_lookup:
+            if instrument_type:
+                if isinstance(instrument_type, str):  # in case we receive a key as instrument type
+                    instruments = instruments.filter(instrument_type__key=instrument_type)
+                else:  # in case we receive a primary key as instrument type
+                    instruments = instruments.filter(instrument_type=instrument_type)
+            lookup_fields = [
+                "isin",
+                "refinitiv_identifier_code",
+                "refinitiv_mnemonic_code",
+                "refinitiv_ticker",
+                "identifier",
+                "ticker",
+            ]
+
+            conditions = []
+            for field in lookup_fields:
+                if field_value := identifiers.get(field, None):
+                    conditions.append(Q(**{f"{field}": field_value}))
+                    if field == "isin":
+                        conditions.append(Q(old_isins__contains=[field_value]))
+            if conditions:
+                instruments = instruments.filter(reduce(operator.or_, conditions))
+            if currency or exchange:
+                instruments_tmp = instruments
+                if exchange:
+                    instruments_tmp = instruments_tmp.filter(exchange=exchange)
+                if currency:
+                    instruments_tmp = instruments_tmp.filter(currency=currency)
+                if instruments_tmp.count() >= 1:
+                    instruments = instruments_tmp
+            # last chance
+            if name and instruments.count() > 1:
+                instruments = instruments.annotate(similarity_score=TrigramSimilarity("name", name))
+                if instruments.filter(similarity_score__gt=self.trigram_similarity_min_score).count() == 1:
+                    instruments = instruments.filter(similarity_score__gt=self.trigram_similarity_min_score)
+            if instruments.count() == 1:
+                instrument = instruments.first()
+            elif instrument_type and identifiers:
+                # if instrument type was provided but we still didn't find the security, we try without the instrument type in case it was mislabeled
+                instrument = self._lookup_instrument(
+                    only_investable_universe=only_investable_universe,
+                    exact_lookup=exact_lookup,
+                    currency=currency,
+                    exchange=exchange,
+                    **identifiers,
+                )
+            if not instrument and name and identifiers:
+                # Sometime, identifier provided emptied the queryset of possible instruments. In a last chance approach, we try to only look for security with the given name
+                instrument = self._lookup_instrument(
+                    only_investable_universe=only_investable_universe,
+                    exact_lookup=exact_lookup,
+                    instrument_type=instrument_type,
+                    currency=currency,
+                    exchange=exchange,
+                    name=name,
+                )
+        if instrument:
+            self.cache[cache_key] = instrument
+        return instrument
+
+    def lookup(self, only_security: bool = False, exact_lookup: bool = False, **lookup_kwargs):
+        # To speed up lookup process, we try to get the quote from the investable universe first
+        security = self._lookup_instrument(only_investable_universe=True, exact_lookup=exact_lookup, **lookup_kwargs)
+        if not security:
+            security = self._lookup_instrument(
+                only_investable_universe=False, exact_lookup=exact_lookup, **lookup_kwargs
+            )
+        if not only_security and security:
+            quotes = security.children.all()
+            if quotes.exists():
+                # We try to find the quote for that security based on the given exchange (if provided). Otherwise, we default to the security primary exchange
+                exchange = lookup_kwargs.get("exchange")
+                if exchange and quotes.filter(exchange=exchange).exists():
+                    return quotes.filter(exchange=exchange).first()
+                else:
+                    return quotes.filter(is_primary=True).first()
+        return security
+
+
+class InstrumentImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.Instrument"
+    allow_update_save_failure = True
+    exclude_update_fields = ["name", "isin", "country"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_lookup = InstrumentLookup(self.model)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        from wbfdm.models import Classification, InstrumentType
+
+        if isinstance(data, int):
+            data = dict(id=data)
+        if data.get("currency", None):
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+        if instrument_type := data.get("instrument_type", None):
+            if isinstance(instrument_type, str):
+                data["instrument_type"] = InstrumentType.objects.get_or_create(
+                    key=instrument_type,
+                    defaults={"name": instrument_type.title(), "short_name": instrument_type.title()},
+                )[0]
+            elif isinstance(instrument_type, int):
+                data["instrument_type"] = InstrumentType.objects.get(id=instrument_type)
+        if data.get("country", None):
+            data["country"] = Geography.dict_to_model(data["country"])
+        if data.get("headquarter_city", None):
+            data["headquarter_city"] = Geography.dict_to_model(data["headquarter_city"], level=Geography.Level.CITY)
+        if inception_date := data.get("inception_date", None):
+            data["inception_date"] = datetime.strptime(inception_date, "%Y-%m-%d").date()
+        if classifications := data.pop("classifications", None):
+            data["classifications"] = [Classification.dict_to_model(c) for c in classifications]
+        if (exchange_data := data.pop("exchange", None)) and isinstance(exchange_data, dict):
+            sanitized_dict = {k: v for k, v in exchange_data.items() if v is not None}
+            if sanitized_dict:
+                data["exchange"] = Exchange.dict_to_model(sanitized_dict)
+
+    def _get_instance(
+        self,
+        data: Dict[str, Any],
+        history: Optional[models.QuerySet] = None,
+        only_security: bool = False,
+        **kwargs,
+    ) -> models.Model:
+        if isinstance(data, self.model):
+            return data
+        if instrument_id := data.pop("id", None):
+            try:
+                return self.model.objects.get(id=instrument_id)
+            except self.model.DoesNotExist:
+                raise DeserializationError("Instrument id does not match an existing instrument")
+        else:
+            return self.instrument_lookup.lookup(only_security=only_security, **data)
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        from wbfdm.models.instruments.instruments import Instrument
+
+        if not data.get("name", None):
+            raise DeserializationError("Can't create an instrument without at least a name")
+        classifications = data.pop("classifications", None)
+        try:
+            obj = Instrument.objects.create(
+                **data,
+                import_source=self.import_source,
+            )
+            if classifications:
+                obj.classifications.set([c for c in classifications if c])
+            return obj
+        except IntegrityError:
+            self.import_source.log += f"\nError while creating new instrument with data {data}"
+
+        return None
+
+    def process_object(self, underlying_instrument_data, **kwargs):
+        if underlying_instrument_data:
+            if isinstance(underlying_instrument_data, self.model):
+                return underlying_instrument_data, ImportState.UNMODIFIED
+            if isinstance(underlying_instrument_data, int):
+                underlying_instrument_data = dict(id=underlying_instrument_data)
+        return super().process_object(
+            underlying_instrument_data,
+            include_update_fields=[
+                "isin",
+                "ticker",
+                "refinitiv_mnemonic_code",
+                "refinitiv_identifier_code",
+                "country",
+                "exchange",
+            ],
+            **kwargs,
+        )

wbfdm/import_export/handlers/instrument_list.py

@@ -0,0 +1,101 @@
+from collections import defaultdict
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from django.contrib.auth.models import Permission
+from django.db import models
+from django.db.models import Q
+from slugify import slugify
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbcore.contrib.notifications.dispatch import send_notification
+
+from .instrument import InstrumentImportHandler
+
+
+class InstrumentListImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbfdm.InstrumentListThroughModel"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if from_date := data.get("from_date", None):
+            data["from_date"] = datetime.strptime(from_date, "%Y-%m-%d").date()
+        if to_date := data.get("to_date", None):
+            data["to_date"] = datetime.strptime(to_date, "%Y-%m-%d").date()
+        if instrument_list_data := data.pop("instrument_list", None):
+            if isinstance(instrument_list_data, int):
+                data["instrument_list"] = self.model.instrument_list.get_queryset().get(id=instrument_list_data)
+            elif isinstance(instrument_list_data, dict) and "name" in instrument_list_data:
+                data["instrument_list"] = self.model.instrument_list.get_queryset().get_or_create(
+                    identifier=instrument_list_data.pop("identifier", slugify(instrument_list_data["name"])),
+                    **instrument_list_data,
+                )[0]
+        if instrument_data := data.pop("instrument", None):
+            data["instrument"] = self.instrument_handler.process_object(
+                instrument_data, only_security=True, read_only=True
+            )[0]
+        # we try to automatically match the instrument name against a already known matched row
+        if instrument_str := data.get("instrument_str"):
+            already_existing_rows = self.model.objects.filter(
+                instrument__isnull=False,
+                instrument_str=instrument_str,
+                instrument_list=data.get("instrument_list", None),
+            )
+            if already_existing_rows.count() == 1:
+                data["instrument"] = already_existing_rows.first().instrument
+        if "instrument_list" not in data:
+            raise DeserializationError("Instrument List not find in this row")
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        if instrument := data.get("instrument", None):
+            return self.model.objects.filter(
+                instrument=instrument,
+                instrument_list=data["instrument_list"],
+            ).first()
+
+    def _post_processing_objects(
+        self,
+        created_objs: List[models.Model],
+        modified_objs: List[models.Model],
+        unmodified_objs: List[models.Model],
+    ):
+        objs = modified_objs + unmodified_objs + created_objs
+        lists = set(map(lambda x: x.instrument_list, objs))
+        leftovers_objs = self.model.objects.filter(instrument_list__in=lists)
+        for obj in objs:
+            leftovers_objs = leftovers_objs.exclude(id=obj.id)
+        leftovers_objs.delete()
+
+        instrument_dict = defaultdict(list)
+        for obj in modified_objs + created_objs:
+            instrument_dict[obj.instrument_list].append(obj)
+        for instrument_list, items in instrument_dict.items():
+            if items:
+                report = """
+                <p>List of instrument added or modified:</p>
+                <ul>
+                """
+                for item in items:
+                    if item.instrument:
+                        report += f"<li>{item.instrument_str} (automatically link to {item.instrument}</li>"
+                    else:
+                        report += f"<li>{item.instrument_str}</li>"
+                report += "</ul>"
+                perm = Permission.objects.get(codename="administrate_instrumentlist")
+                for user in (
+                    User.objects.filter(is_active=True)
+                    .filter(Q(groups__permissions=perm) | Q(user_permissions=perm))
+                    .distinct()
+                ):
+                    send_notification(
+                        code="wbfdm.instrument_list_add",
+                        name=f"Instruments have been added or modified into the instrument list {instrument_list.name}",
+                        body=report,
+                        user=user,
+                        reverse_name="wbfdm:instrumentlist-detail",
+                        reverse_args=[instrument_list.id],
+                    )