wbfdm 1.55.9__tar.gz → 1.56.0__tar.gz

{wbfdm-1.55.9 → wbfdm-1.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbfdm
-Version: 1.55.9
+Version: 1.56.0
 Summary: The workbench module ensures rapid access to diverse financial data (market, fundamental, forecasts, ESG), with features for storing instruments, classifying them, and conducting financial analysis.
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: roman==4.*

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/dsws/client.py

@@ -3,7 +3,7 @@ import re
 from datetime import date, datetime
 from typing import Generator, List, Optional
 
-import DatastreamPy as dsweb
+import DatastreamPy as dsweb  # noqa
 import numpy as np
 import pandas as pd
 import pytz
@@ -13,7 +13,7 @@ from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 
 
 class CachedTokenDataClient(dsweb.DataClient):
-    def _get_token(self, isProxy=False):
+    def _get_token(self, isProxy=False):  # noqa
         if (token := cache.get("dsws_token")) and (token_expiry := cache.get("dsws_token_expiry")):
             self.token = token
             self.tokenExpiry = timezone.make_aware(datetime.fromtimestamp(token_expiry), timezone=pytz.UTC)
@@ -102,7 +102,7 @@ class Client:
         if len(requests_data) > self.MAXIMUM_REQUESTS_PER_BUNDLE:
             raise ValueError(f"number of request exceed {self.MAXIMUM_REQUESTS_PER_BUNDLE}")
         # Construct the requests bundle
-        for request_tickers, request_symbols in requests_data:
+        for request_tickers, _ in requests_data:
             # Convert a list of string into a valid string
             converted_ticker = ",".join(request_tickers)
             if "start" in extra_client_kwargs or "end" in extra_client_kwargs:

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/dsws/dataloaders/market_data.py

@@ -30,7 +30,7 @@ FIELD_MAP = {
 class DSWSMarketDataDataloader(MarketDataProtocol, Dataloader):
     def market_data(
         self,
-        values: list[MarketData] = [MarketData.CLOSE],
+        values: list[MarketData] | None = None,
         from_date: date | None = None,
         to_date: date | None = None,
         exact_date: date | None = None,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/internal/dataloaders/market_data.py

@@ -36,7 +36,7 @@ def _cast_decimal_to_float(value: float | Decimal) -> float:
 class MarketDataDataloader(MarketDataProtocol, Dataloader):
     def market_data(
         self,
-        values: list[MarketData] = [MarketData.CLOSE],
+        values: list[MarketData] | None = None,
         from_date: date | None = None,
         to_date: date | None = None,
         exact_date: date | None = None,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/backends/base.py

@@ -13,7 +13,7 @@ from wbcore.contrib.currency.models import CurrencyFXRates
 from wbfdm.models import Instrument, InstrumentPrice
 
 from ..dto import Metric, MetricField, MetricKey
-from ..exceptions import MetricInvalidParameterException
+from ..exceptions import MetricInvalidParameterError
 from .utils import get_today
 
 T = TypeVar("T", bound=Model)
@@ -94,7 +94,7 @@ class InstrumentMetricBaseBackend(AbstractBackend[Instrument]):
                 [val_date, (get_today() - pd.tseries.offsets.BDay(1)).date()]
             )  # ensure that value date is at least lower than today (otherwise, we might compute performance for intraday, which we do not want yet
         else:
-            raise MetricInvalidParameterException()
+            raise MetricInvalidParameterError()
 
 
 class BaseDataloader:

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/backends/statistics.py

@@ -11,7 +11,7 @@ from wbfdm.models import Instrument, InstrumentPrice
 
 from ..decorators import register
 from ..dto import Metric, MetricField, MetricKey
-from ..exceptions import MetricInvalidParameterException
+from ..exceptions import MetricInvalidParameterError
 from .base import BaseDataloader, InstrumentMetricBaseBackend
 
 STATISTICS_METRIC = MetricKey(
@@ -207,7 +207,7 @@ class InstrumentFinancialStatisticsMetricBackend(InstrumentMetricBaseBackend):
         elif self.val_date:
             with suppress(InstrumentPrice.DoesNotExist):
                 return instrument.valuations.filter(date__lte=self.val_date).latest("date").date
-        raise MetricInvalidParameterException()
+        raise MetricInvalidParameterError()
 
 
 @register(move_first=True)

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/exceptions.py

@@ -1,4 +1,4 @@
-class MetricInvalidParameterException(Exception):
+class MetricInvalidParameterError(Exception):
     """
     If instantiated backend parameters are invalid, the orchestrator or backend itself are expected to raise that exception
     """

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/models.py

@@ -48,6 +48,12 @@ class InstrumentMetric(models.Model):
         self.basket_repr = str(self.basket)
         super().save(*args, **kwargs)
 
+    def __str__(self) -> str:
+        repr = f"{self.basket} - {self.key}"
+        if self.date:
+            repr += f"({self.date})"
+        return repr
+
     @classmethod
     def update_or_create_from_metric(cls, metric: Metric, parent_instrument_metric: Self | None = None):
         """

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/orchestrators.py

@@ -8,7 +8,7 @@ from tqdm import tqdm
 
 from .backends.base import AbstractBackend
 from .dto import Metric
-from .exceptions import MetricInvalidParameterException
+from .exceptions import MetricInvalidParameterError
 from .models import InstrumentMetric
 from .registry import backend_registry
 
@@ -73,9 +73,9 @@ class MetricOrchestrator:
         if debug:
             # if debug mode is enabled, we wrap the parameters list into a tqdm generator
             parameters = tqdm(parameters)
-        for parameters in parameters:
-            with suppress(MetricInvalidParameterException):
-                yield from parameters[0].compute_metrics(parameters[1])
+        for param in parameters:
+            with suppress(MetricInvalidParameterError):
+                yield from param[0].compute_metrics(param[1])
 
     def process(self, debug: bool = False):
         """

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/metric/viewsets/mixins.py

@@ -185,19 +185,19 @@ class InstrumentMetricMixin(_Base):
         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", ()))
+        base_meta = serializer_class.Meta
+        fields = list(getattr(base_meta, "fields", ()))
+        read_only_fields = list(getattr(base_meta, "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})
+        meta = type(str("Meta"), (base_meta,), {"fields": fields, "read_only_fields": read_only_fields})
         new_class = type(
             serializer_class.__name__,
             (serializer_class,),
             {
-                "Meta": Meta,
+                "Meta": meta,
                 **self._metric_serializer_fields,
                 "SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES": serializer_class,
             },
@@ -233,7 +233,7 @@ class InstrumentMetricMixin(_Base):
             # 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():
+                for field_key in metric_key.subfields_filter_map.keys():
                     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(

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/msci/client.py

@@ -38,6 +38,7 @@ class MSCIClient:
                     "grant_type": "client_credentials",
                     "audience": "https://esg/data",
                 },
+                timeout=10,
             )
             if resp.status_code == requests.codes.ok:
                 with suppress(KeyError, requests.exceptions.JSONDecodeError):
@@ -58,6 +59,7 @@ class MSCIClient:
                     "factor_name_list": factors,
                 },
                 headers={"AUTHORIZATION": f"Bearer {self.oauth_token}"},
+                timeout=10,
             )
             if response.ok:
                 for row in response.json().get("result", {}).get("issuers", []):
@@ -78,6 +80,7 @@ class MSCIClient:
                         "offset": offset,
                     },
                     headers={"AUTHORIZATION": f"Bearer {self.oauth_token}"},
+                    timeout=10,
                 )
 
                 if not response.ok:

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/database_routers.py

@@ -20,6 +20,6 @@ class QARouter:
         return None
 
     def allow_migrate(self, db, app_label, model_name=None, **hints):
-        if app_label == "qa":
+        if db == "qa":
             return False
         return None

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/dataloaders/adjustments.py

@@ -57,7 +57,8 @@ class DatastreamAdjustmentsDataloader(AdjustmentsProtocol, Dataloader):
                     pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
                 )
                 for batch in batched(lookup.keys(), 1000):
-                    cursor.execute(f"insert into #ds2infocode values {",".join(map(lambda x: f"({x})", batch))};")
+                    placeholders = ",".join(map(lambda x: f"({x})", batch))
+                    cursor.execute("insert into #ds2infocode values %s;", (placeholders,))
 
             cursor.execute(query.get_sql())
 

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/dataloaders/corporate_actions.py

@@ -58,7 +58,8 @@ class DatastreamCorporateActionsDataloader(CorporateActionsProtocol, Dataloader)
                     pk.MSSQLQuery.create_table(infocode).columns(pk.Column("infocode", SqlTypes.INTEGER)).get_sql()
                 )
                 for batch in batched(lookup.keys(), 1000):
-                    cursor.execute(f"insert into #ds2infocode values {','.join(map(lambda x: f'({x})', batch))};")
+                    placeholders = ",".join(map(lambda x: f"({x})", batch))
+                    cursor.execute("insert into #ds2infocode values %s;", (placeholders,))
 
             cursor.execute(query.get_sql())
             for row in dictfetchall(cursor, CorporateActionDataDict):

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/dataloaders/market_data.py

@@ -39,9 +39,9 @@ class DS2MarketData(Enum):
 
 
 class DatastreamMarketDataDataloader(MarketDataProtocol, Dataloader):
-    def market_data(
+    def market_data(  # noqa: C901
         self,
-        values: list[MarketData] = [MarketData.CLOSE],
+        values: list[MarketData] | None = None,
         from_date: date | None = None,
         to_date: date | None = None,
         exact_date: date | None = None,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/dataloaders/officers.py

@@ -60,7 +60,7 @@ class RKDOfficersDataloader(OfficersProtocol, Dataloader):
                 )
                 for batch in batched(lookup.keys(), 1000):
                     placeholders = ",".join(map(lambda x: f"('{x}')", batch))
-                    cursor.execute(f"insert into #rkd_codes values {placeholders};")
+                    cursor.execute("insert into #rkd_codes values %s;", (placeholders,))
 
             cursor.execute(query.get_sql())
 

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/contrib/qa/sync/utils.py

@@ -148,12 +148,15 @@ def _delist_existing_duplicates(instrument: Instrument) -> None:
 
     for identifier_field in unique_identifiers:
         if identifier := getattr(instrument, identifier_field):
-            with suppress(Instrument.DoesNotExist):
-                duplicate = Instrument.objects.get(
-                    is_security=True, delisted_date__isnull=True, **{identifier_field: identifier}
-                )
-                duplicate.delisted_date = date.today() - timedelta(days=1)
-                duplicate.save()
+            if instrument.delisted_date:  # if delisted, we unset the identifier that can lead to constraint error
+                setattr(instrument, identifier_field, None)
+            else:
+                with suppress(Instrument.DoesNotExist):
+                    duplicate = Instrument.objects.get(
+                        is_security=True, delisted_date__isnull=True, **{identifier_field: identifier}
+                    )
+                    duplicate.delisted_date = date.today() - timedelta(days=1)
+                    duplicate.save()
 
 
 def _save_single_instrument(instrument: Instrument) -> None:
@@ -211,7 +214,7 @@ def _bulk_create_instruments_chunk(instruments: list[Instrument], update_unique_
         )
     except IntegrityError:
         # we caught an integrity error on the bulk save, so we try to save one by one
-        logger.info(
+        logger.error(
             "we detected an integrity error while bulk saving instruments. We save them one by one and delist the already existing instrument from the db if we can. "
         )
         for instrument in instruments:
@@ -290,14 +293,16 @@ def trigger_partial_update(
     else:
         with connections["qa"].cursor() as cursor:
             cursor.execute(
-                f"SELECT MAX(last_user_update) FROM sys.dm_db_index_usage_stats WHERE OBJECT_NAME(object_id) = '{table_change_name}'"
+                "SELECT MAX(last_user_update) FROM sys.dm_db_index_usage_stats WHERE OBJECT_NAME(object_id) = %S'",
+                (table_change_name,),
             )
             max_last_updated_qa = (
                 pytz.timezone(settings.TIME_ZONE).localize(result[0]) if (result := cursor.fetchone()) else None
             )
             if max_last_updated_qa and max_last_updated_qa > max_last_updated:
                 for _, security_id in cursor.execute(
-                    f"SELECT UpdateFlag_, {id_field} FROM {table_change_name}"
+                    "SELECT UpdateFlag_, %s FROM %s",
+                    (id_field, table_change_name),
                 ).fetchall():
                     try:
                         update_or_create_item(security_id)

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/dataloaders/protocols.py

@@ -49,7 +49,7 @@ class FXRateProtocol(Protocol):
 class MarketDataProtocol(Protocol):
     def market_data(
         self,
-        values: list[MarketData] = [MarketData.CLOSE],
+        values: list[MarketData] | None = None,
         from_date: date | None = None,
         to_date: date | None = None,
         exact_date: date | None = None,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/figures/financials/financial_analysis_charts.py

@@ -115,13 +115,7 @@ class FinancialAnalysisGenerator:
         self.instruments_repr_map = {i.id: i.name_repr for i in self.instruments}
         self.currency_map = {i.id: i.currency.id for i in self.instruments}
 
-    def build_df(
-        self,
-        instrument_prices_field_names: list[str] = [],
-        fundamental_field_names: list[str] = [],
-        forecast_field_names: list[str] = [],
-        daily_fundamental_field_names: list[str] = [],
-    ):
+    def build_df(self, **kwargs):
         """
         Used to returns a df with all the variables passed in four separate lists
 
@@ -239,7 +233,7 @@ class FinancialAnalysisGenerator:
     @staticmethod
     def clean_data(
         df: pd.DataFrame,
-        var_list: list[str] = [],
+        var_list: list[str],
         drop_negative=True,
         q_low: float = 0.05,
         q_high: float = 0.95,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/filters/instrument_prices.py

@@ -26,7 +26,6 @@ class FakeDateRange(wb_filters.FilterSet):
 
 class InstrumentPriceFilterSet(wb_filters.FilterSet):
     date = wb_filters.FinancialPerformanceDateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
         required=True,
         clearable=False,

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/filters/instruments.py

@@ -138,7 +138,7 @@ class InstrumentFilterSet(TagFilterMixin, InstrumentFavoriteGroupFilterSet):
             if "parent" in data:
                 data.pop("classifications", None)  # remove classifications in case we are navigating the tree
                 data.pop("level", None)
-        super().__init__(data=data, *args, **kwargs)
+        super().__init__(*args, data=data, **kwargs)
 
     class Meta:
         model = Instrument

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/import_export/backends/cbinsights/utils/client.py

@@ -7,11 +7,11 @@ from celery import shared_task
 from tqdm import tqdm
 
 
-class RateLimitException(Exception):
+class RateLimitError(Exception):
     pass
 
 
-class CreditLimitException(Exception):
+class CreditLimitError(Exception):
     pass
 
 
@@ -38,17 +38,18 @@ class Client:
             url,
             params={**params, **{"nextPageToken": next_page_token}} if next_page_token else params,
             headers={"authorization": self.jwt_header_value},
+            timeout=10,
         )
         if resp.status_code != 200:
             if resp.status_code == 429:
-                raise RateLimitException()
+                raise RateLimitError()
             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()
+                raise CreditLimitError()
 
         return resp.json()
 
@@ -72,11 +73,11 @@ class Client:
                 resp = self._request(data_url, params=params, next_page_token=next_page_token)
                 yield resp
                 next_page_token = resp["nextPageToken"]
-            except RateLimitException:
+            except RateLimitError:
                 time.sleep(self.rate_limit_sleep)
                 retry += 1
         if retry >= 5:
-            raise RateLimitException()
+            raise RateLimitError()
 
     def _chunk_paginated_request(self, data_url, org_ids, extra_params, endpoint, debug: bool = False):
         data = []
@@ -96,8 +97,7 @@ class Client:
         auth_url = "https://api.cbinsights.com/v1/authorize"
 
         auth_resp = requests.get(
-            auth_url,
-            params={"clientId": self.client_id, "clientSecret": self.client_secret},
+            auth_url, params={"clientId": self.client_id, "clientSecret": self.client_secret}, timeout=10
         )
 
         if auth_resp.status_code != 200:

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/import_export/backends/refinitiv/utils/controller.py

@@ -61,7 +61,7 @@ class Controller:
         instrument_ric: str = None,
         instrument_isin: str = None,
         instrument_mnemonic: str = None,
-        perm_id_symbols: list[str] = ["QPID", "IPID"],
+        perm_id_symbols: tuple[str, ...] = ("QPID", "IPID"),
     ) -> str | None:
         def _process_ticker(ticker):
             if not (df := self.client.get_static_df(tickers=[ticker], fields=perm_id_symbols)).empty:

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/import_export/handlers/instrument.py

@@ -46,7 +46,7 @@ class InstrumentLookup:
         cache_key = self._get_cache_key(**kwargs)
         self.cache[cache_key] = instrument
 
-    def _lookup_security(
+    def _lookup_security(  # noqa: C901
         self,
         instrument_type=None,
         currency=None,
@@ -57,7 +57,6 @@ class InstrumentLookup:
         **identifiers,
     ):
         identifiers = {k: v for k, v in identifiers.items() if v is not None}
-
         instrument = None
 
         # We need to lookup ticker because some provider gives us ticker with or without space in it
@@ -113,33 +112,41 @@ class InstrumentLookup:
                     conditions.append(Q(**{f"{field}": field_value}))
                     if field == "isin":
                         conditions.append(Q(old_isins__contains=[field_value]))
+                    if field == "ticker":
+                        conditions.append(Q(ticker__regex=rf"^{field_value}([A-Za-z]?|\.?[A-Za-z])$"))
+                        conditions.append(Q(refinitiv_mnemonic_code=f"@{field_value}"))
+
             if conditions:
                 instruments = instruments.filter(reduce(operator.or_, conditions))
-
-            if currency:  # if currency is provides, we use it as validator
+            if (
+                currency and instruments.filter(currency=currency).exists()
+            ):  # if currency is provides, we use it as validator
                 instruments = instruments.filter(currency=currency)
-
             if exchange:
                 instruments_tmp = instruments.filter(exchange=exchange)
                 if instruments_tmp.exists():
                     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:
+            elif instrument_type and (name or 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_security(
                     only_investable_universe=only_investable_universe,
                     exact_lookup=exact_lookup,
                     currency=currency,
                     exchange=exchange,
+                    name=name,
                     **identifiers,
                 )
-            if not instrument and name and identifiers:
+            if not instrument and identifiers:
+                identifiers.pop(list(identifiers.keys())[0])
                 # 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_security(
                     only_investable_universe=only_investable_universe,
@@ -148,6 +155,7 @@ class InstrumentLookup:
                     currency=currency,
                     exchange=exchange,
                     name=name,
+                    **identifiers,
                 )
         if instrument and only_investable_universe and not instrument.is_security and instrument.parent:
             instrument = instrument.parent
@@ -237,8 +245,8 @@ class InstrumentImportHandler(ImportExportHandler):
         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")
+            except self.model.DoesNotExist as e:
+                raise DeserializationError("Instrument id does not match an existing instrument") from e
         else:
             return self.instrument_lookup.lookup(only_security=only_security, **data)
 

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/import_export/parsers/cbinsights/equities.py

@@ -1,4 +1,5 @@
 import json
+from contextlib import suppress
 
 from wbcore.contrib.geography.models import Geography
 
@@ -44,14 +45,12 @@ def parse(import_source):
                         d["headquarter_address"] = f"{street}, {postal_code} {city_name}"
 
             if sector_id := summary.get("sectorId", None):
-                try:
+                with suppress(Exception):
                     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-1.55.9 → wbfdm-1.56.0}/wbfdm/jinja2.py

@@ -3,5 +3,6 @@ from jinjasql import JinjaSql  # type: ignore
 
 
 def get_environment(**options):
-    env = Environment(**options)
+    # we except only SQL template, so we need to not escape special characters (possible XSS attack for HTML template)
+    env = Environment(**options)  # noqa: S701
     return JinjaSql(env=env, param_style="format").env

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/models/esg/controversies.py

@@ -56,6 +56,9 @@ class Controversy(models.Model):
     review = models.DateField(verbose_name="Reviewed", null=True, blank=True)
     initiated = models.DateField(verbose_name="initiated", null=True, blank=True)
 
+    def __str__(self) -> str:
+        return f"{self.headline} ({self.instrument})"
+
     @classmethod
     def dict_to_model(cls, controversy: dict[str, Any], instrument) -> Self:
         return Controversy(

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/models/fields.py

@@ -23,7 +23,7 @@ class CompositeKey(models.AutoField):
     def __init__(self, columns: list[str], db_column_ref: str | None = None, *args, **kwargs):
         self.columns = columns
         self.db_column_ref = db_column_ref
-        super().__init__(primary_key=True, *args, **kwargs)
+        super().__init__(*args, primary_key=True, **kwargs)
 
     def contribute_to_class(self, cls, name, private_only=False):
         self.set_attributes_from_name(name)
@@ -108,7 +108,7 @@ class Exact(models.Lookup):
 
         lookups = [
             lookup_class(field.get_col(self.lhs.alias), self.rhs[column])
-            for lookup_class, field, column in zip(lookup_classes, fields, self.lhs.field.columns)
+            for lookup_class, field, column in zip(lookup_classes, fields, self.lhs.field.columns, strict=False)
         ]
 
         value_constraint = WhereNode()

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/models/fk_fields.py

@@ -93,7 +93,7 @@ class CompositeForeignKey(ForeignObject):
             kwargs["on_delete"] = self.override_on_delete(kwargs["on_delete"])
 
         kwargs["to_fields"], kwargs["from_fields"] = zip(
-            *((k, v.value) for k, v in self._raw_fields.items() if v.is_local_field)
+            *((k, v.value) for k, v in self._raw_fields.items() if v.is_local_field), strict=False
         )
         super().__init__(to, **kwargs)
 
@@ -220,7 +220,7 @@ class CompositeForeignKey(ForeignObject):
 
     def _check_nullifequal_fields_exists(self):
         res = []
-        for field_name, value in self.null_if_equal:
+        for field_name, _ in self.null_if_equal:
             try:
                 self.model._meta.get_field(field_name)
             except FieldDoesNotExist:
@@ -269,7 +269,7 @@ class CompositeForeignKey(ForeignObject):
 
         return OrderedDict(
             (k, (v if isinstance(v, CompositePart) else LocalFieldValue(v)))
-            for k, v in (to_fields.items() if isinstance(to_fields, dict) else zip(to_fields, to_fields))
+            for k, v in (to_fields.items() if isinstance(to_fields, dict) else zip(to_fields, to_fields, strict=False))
         )
 
     def db_type(self, connection):

{wbfdm-1.55.9 → wbfdm-1.56.0}/wbfdm/models/instruments/instrument_relationships.py

@@ -162,6 +162,9 @@ class RelatedInstrumentThroughModel(models.Model):
     class Meta:
         unique_together = ("instrument", "related_instrument", "is_primary", "related_type")
 
+    def __str__(self) -> str:
+        return f"{self.instrument} - {self.related_instrument} ({self.related_type})"
+
     def save(self, *args, **kwargs):
         qs = RelatedInstrumentThroughModel.objects.filter(
             instrument=self.instrument, related_type=self.related_type, is_primary=True