wbfdm 1.49.5__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbfdm/admin/exchanges.py

@@ -43,7 +43,7 @@ class ExchangeModelAdmin(admin.ModelAdmin):
                     ("operating_mic_code", "operating_mic_name"),
                     ("bbg_exchange_codes", "bbg_composite_primary", "bbg_composite"),
                     ("refinitiv_identifier_code", "refinitiv_mnemonic"),
-                    ("country", "website"),
+                    ("country", "website", "apply_round_lot_size"),
                     ("comments",),
                 )
             },

wbfdm/admin/instruments.py

@@ -50,8 +50,8 @@ class InstrumentModelAdmin(admin.ModelAdmin):
             {
                 "fields": (
                     ("name", "name_repr", "computed_str"),
-                    ("parent", "instrument_type"),
-                    ("is_cash", "is_security", "is_managed", "is_investable_universe", "is_primary"),
+                    ("parent", "instrument_type", "is_primary"),
+                    ("is_cash", "is_security", "is_managed", "is_cash_equivalent", "is_investable_universe"),
                     ("inception_date", "delisted_date"),
                     ("primary_url", "additional_urls"),
                     (
@@ -69,6 +69,7 @@ class InstrumentModelAdmin(admin.ModelAdmin):
                     ("currency", "country", "headquarter_city", "headquarter_address"),
                     (
                         "exchange",
+                        "round_lot_size",
                         "import_source",
                         "base_color",
                     ),

wbfdm/analysis/financial_analysis/change_point_detection.py

@@ -0,0 +1,88 @@
+import pandas as pd
+import ruptures as rpt
+
+
+def outlier_detection(series, z_threshold=3, window=11) -> pd.Series:
+    """
+    Enhanced detection with volatility-adjusted thresholds and trend validation
+    """
+    # Compute rolling volatility metrics
+    series = series.sort_index().dropna()
+
+    returns = series.pct_change()
+    series = series[returns != 0]
+    series = series[series > 0.1]  # we exclude penny stock
+    rolling_mean = series.rolling(window, center=True).mean()
+    rolling_std = series.rolling(window, center=True).std()
+    # Calculate Z-scores
+    z_scores = (series - rolling_mean) / rolling_std
+    candidates = z_scores.abs() > z_threshold
+
+    return series[candidates]
+
+
+def statistical_change_point_detection(
+    df: pd.Series,
+    pen: int = 10,
+    model: str = "l2",
+    threshold: float = 0.7,
+    min_size: int = 30,
+    min_threshold: float = 1.0,
+) -> pd.Series:
+    """Detects abnormal changes in a time series using Pelt change point detection.
+
+    Analyzes a pandas Series using ruptures' Pelt algorithm to identify statistical
+    change points, then validates them using percentage change and minimum value thresholds.
+
+    Args:
+        df: Input time series as pandas Series. Should be numeric and ordered by time.
+        pen: Penalty value for change point detection (higher values reduce sensitivity).
+            Default: 5.
+        model: Cost function model for change point detection. Supported values:
+            'l1' (least absolute deviation), 'l2' (least squared deviation).
+            Default: 'l1'.
+        threshold: Minimum percentage change (0-1) between consecutive segments to
+            consider as abnormal. Default: 0.7 (70%).
+        min_size: Minimum number of samples between change points. Default: 30.
+        min_threshold: Minimum mean value required in both segments to validate
+            a change point (avoids flagging low-value fluctuations). Default: 1.0.
+
+    Returns:
+        tuple[bool, list[int]]: Contains:
+            - bool: True if any validated abnormal changes detected
+            - list[int]: Indices of validated change points (empty if none)
+
+    Example:
+        >>> ts = pd.Series([1.0, 1.1, 1.2, 3.0, 3.1, 3.2])
+        >>> detected, points = detect_abnormal_changes(ts, threshold=0.5)
+        >>> print(detected, points)
+        True [3]
+
+    Note:
+        Base on https://medium.com/@enginsorhun/decoding-market-shifts-detecting-structural-breaks-ii-2b77bdafd064.
+    """
+    changes = []
+
+    if len(df) < min_size:
+        return df.iloc[changes]
+
+    df = df.sort_index()
+
+    # Initialize and fit Pelt model
+    algo = rpt.Pelt(model=model, min_size=min_size).fit(df.values)
+    change_points = algo.predict(pen=pen)
+
+    # If no changes detected
+    if len(change_points) == 0:
+        return (False, [])
+
+    # Calculate percentage changes between segments
+    segments = [1] + change_points
+
+    for i in range(1, len(segments) - 1):
+        previous_segment = df.iloc[segments[i - 1] : segments[i] - 1].mean()
+        next_segment = df.iloc[segments[i] : segments[i + 1] - 1].mean()
+        pct_change = abs(next_segment - previous_segment) / previous_segment
+        if next_segment > min_threshold and previous_segment > min_threshold and pct_change > threshold:
+            changes.append(segments[i])
+    return df.iloc[changes]

wbfdm/analysis/financial_analysis/statement_with_estimates.py

@@ -230,7 +230,7 @@ class StatementWithEstimates:
             df[Financial.ENTERPRISE_VALUE.value] = (
                 df.get(MarketData.MARKET_CAPITALIZATION.value, empty_series)
                 + df.get(Financial.NET_DEBT.value, empty_series)
-                - df.get(Financial.CASH_EQUIVALENTS, empty_series)
+                - df.get(Financial.CASH_EQUIVALENTS.value, empty_series)
             )
 
             # Calculate a couple of variables
@@ -251,7 +251,7 @@ class StatementWithEstimates:
             df["price_sales_ratio"] = pd.concat(
                 [
                     yearly_df.get(MarketData.MARKET_CAPITALIZATION.value, yearly_empty_series)
-                    / yearly_df.get(Financial.GROSS_PROFIT.value, yearly_empty_series),
+                    / yearly_df.get(Financial.REVENUE.value, yearly_empty_series),
                     quarterly_df.get(MarketData.MARKET_CAPITALIZATION.value, quarterly_empty_series)
                     / quarterly_df.get(Financial.REVENUE.value, quarterly_empty_series)
                     .rolling(4, min_periods=1)
@@ -305,7 +305,7 @@ class StatementWithEstimates:
                 df.get(Financial.EBIT.value, empty_series) / df.get(Financial.REVENUE.value, empty_series) * 100
             )
             df["net_income_margin"] = (
-                df.get(Financial.NET_INCOME_REPORTED, empty_series)
+                df.get(Financial.NET_INCOME_REPORTED.value, empty_series)
                 / df.get(Financial.REVENUE.value, empty_series)
                 * 100
             )
@@ -344,7 +344,7 @@ class StatementWithEstimates:
             )
 
             df["price_to_tangible_bv_ratio"] = df.get(MarketData.CLOSE.value, empty_series) / df.get(
-                Financial.TANGIBLE_BOOK_VALUE_PER_SHARE, empty_series
+                Financial.TANGIBLE_BOOK_VALUE_PER_SHARE.value, empty_series
             )
             df["cash_shares_ratio"] = df.get(Financial.CASH_AND_SHORT_TERM_INVESTMENT.value, empty_series) / df.get(
                 Financial.DILUTED_WEIGHTED_AVG_SHARES.value, empty_series
@@ -359,7 +359,7 @@ class StatementWithEstimates:
                 Financial.STOCK_COMPENSATION.value, empty_series
             ) / df.get(Financial.EMPLOYEES.value, empty_series)
 
-            df["net_cash"] = df.get(Financial.CASH_EQUIVALENTS, empty_series) - df.get(
+            df["net_cash"] = df.get(Financial.CASH_EQUIVALENTS.value, empty_series) - df.get(
                 Financial.CURRENT_LIABILITIES.value, empty_series
             )
             df[Financial.EBIT.value] = df.get(Financial.EBIT.value, empty_series)
@@ -404,7 +404,6 @@ class StatementWithEstimates:
                 "stock_compensation_employee_ratio",
                 Financial.CAPEX.value,
                 Financial.SHARES_OUTSTANDING.value,
-                MarketData.MARKET_CAPITALIZATION.value,
                 MarketData.CLOSE.value,
                 MarketData.MARKET_CAPITALIZATION.value,
                 "net_cash",

wbfdm/analysis/financial_analysis/utils.py

@@ -133,6 +133,12 @@ class Loader:
                 self.errors["missing_data"].append(
                     "We could not find any market data covering the financial statement period"
                 )
+            ## TODO We might want to still exclude them from the final df but keep them for the estimate that used these
+            ## we actually want to keep the market data in the forecast column, because they are used for other statistic computation
+            # df.loc[df.index.get_level_values("estimate"), market_data_df.columns.difference(["period_end_date"])] = (
+            #     None
+            # )
+
         return df.rename_axis("financial", axis="columns")
 
     def _annotate_statement_data(self, df: pd.DataFrame, statement_values: list[Financial]) -> pd.DataFrame:

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/contrib/dsws/dataloaders/market_data.py

@@ -5,6 +5,7 @@ from typing import Iterator
 from DatastreamPy import DSUserObjectFault
 from django.conf import settings
 from pandas.tseries.offsets import BDay
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 from wbfdm.dataloaders.protocols import MarketDataProtocol
 from wbfdm.dataloaders.types import MarketDataDict
@@ -23,17 +24,20 @@ FIELD_MAP = {
     "volume": "VO",
     "outstanding_shares": "NOSH",
     "market_capitalization": "MV",
+    "market_capitalization_consolidated": "MVC",
 }
 
 
 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,
         frequency: Frequency = Frequency.DAILY,
+        target_currency: str | None = None,
+        apply_fx_rate: bool = True,
         **kwargs,
     ) -> Iterator[MarketDataDict]:
         """Get prices for instruments.
@@ -55,6 +59,12 @@ class DSWSMarketDataDataloader(MarketDataProtocol, Dataloader):
                 "id",
             )
         }
+        instruments = {entity.id: entity for entity in self.entities}
+        try:
+            target_currency = Currency.objects.get(key=target_currency)
+        except Currency.DoesNotExist:
+            target_currency = None
+
         if (dsws_username := getattr(settings, "REFINITIV_DATASTREAM_USERNAME", None)) and (
             dsws_password := getattr(settings, "REFINITIV_DATASTREAM_PASSWORD", None)
         ):
@@ -80,13 +90,31 @@ class DSWSMarketDataDataloader(MarketDataProtocol, Dataloader):
                     for row in df.to_dict("records"):
                         jsondate = row["Dates"].date()
                         external_id = row["Instrument"]
-
-                        data = {}
+                        fx_rate = 1.0
+                        if target_currency:
+                            instrument = instruments[default_lookup[external_id]["id"]]
+                            if instrument.currency != target_currency:
+                                with suppress(CurrencyFXRates.DoesNotExist):
+                                    fx_rate = float(instrument.currency.convert(jsondate, target_currency))
+                        data = dict(fx_rate=fx_rate)
                         for market_value in values:
                             data[market_value.value] = row.get(FIELD_MAP[market_value.value], None)
+                            if (
+                                apply_fx_rate
+                                and data[market_value.value]
+                                and market_value.value
+                                not in [
+                                    MarketData.MARKET_CAPITALIZATION.value,
+                                    MarketData.VOLUME.value,
+                                    MarketData.VWAP.value,
+                                ]
+                            ):
+                                data[market_value.value] *= fx_rate
+
                         with suppress(KeyError):
                             if default_symbol := default_lookup[external_id].get("symbol", None):
                                 data["close"] = row[default_symbol]
+
                             yield MarketDataDict(
                                 id=f"{default_lookup[external_id]['id']}_{jsondate}",
                                 valuation_date=jsondate,

wbfdm/contrib/internal/dataloaders/market_data.py

@@ -2,11 +2,14 @@ from datetime import date
 from decimal import Decimal
 from typing import Iterator
 
+from django.db.models import Case, Value, When
+from django.db.models.functions import Coalesce
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.dataloader.dataloaders import Dataloader
 
 from wbfdm.dataloaders.protocols import MarketDataProtocol
 from wbfdm.dataloaders.types import MarketDataDict
-from wbfdm.enums import MarketData
+from wbfdm.enums import Frequency, MarketData
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 
 MarketDataMap = {
@@ -19,6 +22,7 @@ MarketDataMap = {
     "ASK": "net_value",
     "VOLUME": "internal_volume",
     "MARKET_CAPITALIZATION": "market_capitalization",
+    "MARKET_CAPITALIZATION_CONSOLIDATED": "market_capitalization",
 }
 
 DEFAULT_VALUES = [MarketData[name] for name in MarketDataMap.keys()]
@@ -33,11 +37,13 @@ def _cast_decimal_to_float(value: float | Decimal) -> float:
 class MarketDataDataloader(MarketDataProtocol, Dataloader):
     def market_data(
         self,
-        values: list[MarketData] | None = [MarketData.CLOSE],
+        values: list[MarketData] | None = None,
         from_date: date | None = None,
         to_date: date | None = None,
         exact_date: date | None = None,
-        calculated: bool | None = None,
+        frequency: Frequency = Frequency.DAILY,
+        target_currency: str | None = None,
+        apply_fx_rate: bool = True,
         **kwargs,
     ) -> Iterator[MarketDataDict]:
         """Get prices for instruments.
@@ -51,16 +57,31 @@ class MarketDataDataloader(MarketDataProtocol, Dataloader):
         Returns:
             Iterator[MarketDataDict]: An iterator of dictionaries conforming to the DailyValuationDict.
         """
-        prices = InstrumentPrice.objects.filter(instrument__in=self.entities).annotate_market_data()  # type: ignore
+        if not values:
+            values = DEFAULT_VALUES
+        values_map = {value.name: MarketDataMap[value.name] for value in values if value.name in MarketDataMap}
+        calculated = kwargs.get("calculated", None)
+        try:
+            target_currency = Currency.objects.get(key=target_currency)
+        except Currency.DoesNotExist:
+            target_currency = None
+        fx_rate = (
+            Coalesce(
+                CurrencyFXRates.get_fx_rates_subquery_for_two_currencies(
+                    "date", "instrument__currency", target_currency
+                ),
+                Value(Decimal("1")),
+            )
+            if target_currency
+            else Value(Decimal("1"))
+        )
+
+        prices = InstrumentPrice.objects.filter(instrument__in=self.entities)
         if calculated is not None:
             prices = prices.filter(calculated=calculated)
         else:
             prices = prices.filter_only_valid_prices()
 
-        prices = prices.order_by("date")
-        if not values:
-            values = DEFAULT_VALUES
-        values_map = {value.name: MarketDataMap[value.name] for value in values if value.name in MarketDataMap}
         if exact_date:
             prices = prices.filter(date=exact_date)
         else:
@@ -68,15 +89,27 @@ class MarketDataDataloader(MarketDataProtocol, Dataloader):
                 prices = prices.filter(date__gte=from_date)
             if to_date:
                 prices = prices.filter(date__lte=to_date)
-        for row in prices.filter_only_valid_prices().values(
+        prices = prices.annotate_market_data().annotate(
+            fx_rate=Case(When(calculated=False, then=fx_rate), default=None)
+        )
+
+        for row in prices.order_by("date").values(
             "date",
             "instrument",
             "calculated",
+            "fx_rate",
             *set(values_map.values()),
         ):
             external_id = row.pop("instrument")
             val_date = row.pop("date")
             if row:
+                fx_rate = row["fx_rate"]
+                if apply_fx_rate and fx_rate is not None:
+                    if row.get("net_value"):
+                        row["net_value"] = row["net_value"] * fx_rate
+                    if row.get("market_capitalization"):
+                        row["market_capitalization"] = row["market_capitalization"] * float(fx_rate)
+                    fx_rate = _cast_decimal_to_float(fx_rate)
                 yield MarketDataDict(
                     id=f"{external_id}_{val_date}",
                     valuation_date=val_date,
@@ -84,5 +117,6 @@ class MarketDataDataloader(MarketDataProtocol, Dataloader):
                     external_id=external_id,
                     source="wbfdm",
                     calculated=row["calculated"],
+                    fx_rate=fx_rate,
                     **{MarketData[k].value: _cast_decimal_to_float(row[v]) for k, v in values_map.items()},
                 )

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/contrib/metric/backends/statistics.py

@@ -3,7 +3,7 @@ from datetime import date
 from typing import Generator
 
 import pandas as pd
-from django.db.models import Avg, Sum
+from django.db.models import Sum
 from wbcore.serializers.fields.number import DisplayMode
 
 from wbfdm.enums import Financial, PeriodType, SeriesType
@@ -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(
@@ -21,7 +21,6 @@ STATISTICS_METRIC = MetricKey(
         MetricField(
             key="revenue_y_1",
             label="Revenue Y-1",
-            aggregate=Sum,
             list_display_kwargs={"show": "open"},
             decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
             serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
@@ -29,14 +28,12 @@ STATISTICS_METRIC = MetricKey(
         MetricField(
             key="revenue_y0",
             label="Revenue Y0",
-            aggregate=Sum,
             decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
             serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
         ),
         MetricField(
             key="revenue_y1",
             label="Revenue Y1",
-            aggregate=Sum,
             list_display_kwargs={"show": "open"},
             decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
             serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
@@ -44,20 +41,17 @@ STATISTICS_METRIC = MetricKey(
         MetricField(
             key="market_capitalization",
             label="Market Capitalization",
-            aggregate=Sum,
             decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
             serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
         ),
         MetricField(
             key="price",
             label="Price",
-            aggregate=Avg,
             decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
         ),
         MetricField(
             key="volume_50d",
             label="Volume 50D",
-            aggregate=Avg,
             serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
         ),
     ],
@@ -65,9 +59,49 @@ STATISTICS_METRIC = MetricKey(
 
 STATISTICS_METRIC_USD = MetricKey(
     key="statistic_usd",
-    label=STATISTICS_METRIC.label,
-    subfields=STATISTICS_METRIC.subfields,
-    additional_prefixes=STATISTICS_METRIC.additional_prefixes,
+    label="Statistic (USD)",
+    subfields=[
+        MetricField(
+            key="revenue_y_1",
+            label="Revenue Y-1",
+            aggregate=Sum,
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="revenue_y0",
+            label="Revenue Y0",
+            aggregate=Sum,
+            decorators=[{"position": "left", "value": "$"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="revenue_y1",
+            label="Revenue Y1",
+            aggregate=Sum,
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="market_capitalization",
+            label="Market Capitalization",
+            aggregate=Sum,
+            decorators=[{"position": "left", "value": "$"}],
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+        MetricField(
+            key="price",
+            label="Price",
+            decorators=[{"position": "left", "value": "{{currency_symbol}}"}],
+        ),
+        MetricField(
+            key="volume_50d",
+            label="Volume 50D",
+            serializer_kwargs={"display_mode": DisplayMode.SHORTENED},
+        ),
+    ],
 )
 
 
@@ -137,7 +171,7 @@ class Dataloader(BaseDataloader):
             )
             fx_rate = df_price["fx_rate"]
             df = pd.concat([df_revenue, df_price.drop("fx_rate", axis=1)], axis=1)
-            for key in ["revenue_y_1", "revenue_y0", "revenue_y1", "market_capitalization", "price"]:
+            for key in ["revenue_y_1", "revenue_y0", "revenue_y1", "market_capitalization"]:
                 if key in df.columns:
                     df[key] = df[key] / fx_rate
 
@@ -173,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/contrib/metric/dispatch.py

@@ -2,6 +2,8 @@ from contextlib import suppress
 from datetime import date
 from typing import Any
 
+from wbfdm.contrib.metric.signals import instrument_metric_updated
+
 
 def compute_metrics(val_date: date, key: str | None = None, basket: Any | None = None, **kwargs):
     """
@@ -21,3 +23,4 @@ def compute_metrics(val_date: date, key: str | None = None, basket: Any | None =
     with suppress(KeyError):
         orchestrator = MetricOrchestrator(val_date, key=key, basket=basket, **kwargs)
         orchestrator.process()
+        instrument_metric_updated.send(sender=basket.__class__, basket=basket, key=key, val_date=val_date)

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/contrib/metric/filters.py

@@ -7,7 +7,25 @@ from wbfdm.contrib.metric.models import InstrumentMetric
 from .registry import backend_registry
 
 
+def get_metrics_content_type(request, view):
+    return {
+        "id__in": list(
+            InstrumentMetric.objects.values_list("basket_content_type", flat=True).distinct("basket_content_type")
+        )
+    }
+
+
 class InstrumentMetricFilterSet(filters.FilterSet):
+    parent_metric = filters.ModelChoiceFilter(
+        label="Parent",
+        queryset=InstrumentMetric.objects.all(),
+        endpoint=InstrumentMetric.get_representation_endpoint(),
+        value_key=InstrumentMetric.get_representation_value_key(),
+        label_key=InstrumentMetric.get_representation_label_key(),
+        hidden=True,
+    )
+    parent_metric__isnull = filters.BooleanFilter(field_name="parent_metric", lookup_expr="isnull", hidden=True)
+
     key = filters.ChoiceFilter(choices=backend_registry.get_choices(), label="Key")
     basket_content_type = filters.ModelChoiceFilter(
         queryset=ContentType.objects.all(),
@@ -15,6 +33,7 @@ class InstrumentMetricFilterSet(filters.FilterSet):
         value_key="id",
         label_key="{{app_label}} | {{model}}",
         label=_("Basket Content Type"),
+        filter_params=get_metrics_content_type,
     )
 
     class Meta:

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/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/contrib/metric/signals.py

@@ -0,0 +1,7 @@
+from django.db.models.signals import ModelSignal
+
+# this signal is triggered whenever all instruments metrics are updated. Temporary solution until we rework the framework for more dynamicity
+
+instrument_metric_updated = ModelSignal(
+    use_caching=True
+)  # the sender model is the type model class being updated (e.g. Instrument), expect a "basket", "key" and "val_date" keyword argument (null if all are updated)

wbfdm/contrib/metric/tasks.py

@@ -3,7 +3,7 @@ from datetime import date
 from celery import shared_task
 from django.contrib.contenttypes.models import ContentType
 
-from wbfdm.contrib.metric.orchestrators import MetricOrchestrator
+from wbfdm.contrib.metric.dispatch import compute_metrics
 
 
 @shared_task(queue="portfolio")
@@ -24,5 +24,4 @@ def compute_metrics_as_task(
     basket = None
     if basket_content_type_id and basket_id:
         basket = ContentType.objects.get(id=basket_content_type_id).get_object_for_this_type(pk=basket_id)
-    routine = MetricOrchestrator(val_date, key=key, basket=basket, **kwargs)
-    routine.process()
+    compute_metrics(val_date=val_date, key=key, basket=basket, **kwargs)