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

wbfdm/models/instruments/mixin/instruments.py

@@ -42,11 +42,14 @@ class InstrumentPMSMixin:
     def get_price(self, val_date: date, price_date_timedelta: int = 3) -> Decimal:
         if self.is_cash:
             return Decimal(1)
-        return self._build_dto(val_date, price_date_timedelta=price_date_timedelta).close
+        return Decimal(self._build_dto(val_date, price_date_timedelta=price_date_timedelta).close)
 
     def _build_dto(self, val_date: date, price_date_timedelta: int = 3) -> PriceDTO:  # for backward compatibility
         try:
-            price = self.valuations.get(date=val_date)
+            try:
+                price = self.valuations.get(date=val_date)
+            except InstrumentPrice.DoesNotExist:
+                price = self.prices.get(date=val_date)
             close = float(price.net_value)
             return PriceDTO(
                 pk=price.id,
@@ -60,7 +63,7 @@ class InstrumentPMSMixin:
                 market_capitalization=price.market_capitalization,
                 outstanding_shares=float(price.outstanding_shares) if price.outstanding_shares else None,
             )
-        except InstrumentPrice.DoesNotExist:
+        except InstrumentPrice.DoesNotExist as e:
             prices = sorted(
                 self.get_prices(from_date=(val_date - BDay(price_date_timedelta)).date(), to_date=val_date),
                 key=lambda x: x["valuation_date"],
@@ -84,7 +87,7 @@ class InstrumentPMSMixin:
                     market_capitalization=p.get("market_capitalization", None),
                     outstanding_shares=p.get("outstanding_shares", None),
                 )
-            raise ValueError("Not price was found")
+            raise ValueError("Not price was found") from e
 
     # Instrument Prices Utility Functions
     @classmethod

wbfdm/models/instruments/options.py

@@ -143,6 +143,9 @@ class OptionAggregate(BaseOptionAbstractModel):
             ),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.instrument} - {self.date} - {self.type}"
+
 
 class Option(BaseOptionAbstractModel):
     import_export_handler_class = OptionImportHandler
@@ -224,3 +227,6 @@ class Option(BaseOptionAbstractModel):
                 fields=["type"],
             ),
         ]
+
+    def __str__(self):
+        return f"{self.contract_identifier} - {self.date} - {self.type}"

wbfdm/models/instruments/private_equities.py

@@ -58,3 +58,6 @@ class Deal(ImportMixin, models.Model):
         null=True,
         help_text="List of URLs used to source the valuation for the Media Mentions source type.",
     )
+
+    def __str__(self) -> str:
+        return f"{self.equity} - {self.date}"

wbfdm/models/instruments/querysets.py

@@ -1,11 +1,15 @@
-import math
+import logging
 from contextlib import suppress
-from datetime import date
+from datetime import date, timedelta
+from decimal import Decimal
 
 import numpy as np
 import pandas as pd
+from django.core.exceptions import MultipleObjectsReturned, ValidationError
+from django.core.validators import DecimalValidator
 from django.db.models import (
     AutoField,
+    Case,
     Exists,
     ExpressionWrapper,
     F,
@@ -13,12 +17,17 @@ from django.db.models import (
     Q,
     QuerySet,
     Subquery,
+    Value,
+    When,
 )
 from django.db.models.functions import Coalesce
-from wbcore.contrib.currency.models import CurrencyFXRates
+from skfolio.preprocessing import prices_to_returns
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 
 from wbfdm.enums import MarketData
 
+logger = logging.getLogger("pms")
+
 
 class InstrumentQuerySet(QuerySet):
     def filter_active_at_date(self, val_date: date):
@@ -88,43 +97,49 @@ class InstrumentQuerySet(QuerySet):
         from wbfdm.models import InstrumentPrice
 
         def _dict_to_object(instrument, row):
-            if (
-                (price_date := row.get("date"))
-                and (close := row.get("close", None))
-                and int(math.log10(close)) + 1 < 10
-            ):
-                try:
+            close = row.get("close", None)
+            price_date = row.get("date")
+            if price_date and close is not None:
+                close = round(Decimal(close), 6)
+                # we validate that close can be inserting into our table<
+                with suppress(ValidationError):
+                    validator = DecimalValidator(16, 6)
+                    validator(close)
                     try:
-                        p = InstrumentPrice.objects.get(instrument=instrument, date=price_date, calculated=False)
-                    except InstrumentPrice.DoesNotExist:
-                        p = InstrumentPrice.objects.get(instrument=instrument, date=price_date, calculated=True)
-                    p.net_value = close
-                    p.gross_value = close
-                    p.calculated = row["calculated"]
-                    p.volume = row.get("volume", p.volume)
-                    p.market_capitalization = row.get("market_capitalization", p.market_capitalization)
-                    p.market_capitalization_consolidated = p.market_capitalization
-                    p.set_dynamic_field(False)
-                    p.id = None
-                    return p
-                except InstrumentPrice.DoesNotExist:
-                    with suppress(CurrencyFXRates.DoesNotExist):
-                        p = InstrumentPrice(
-                            currency_fx_rate_to_usd=CurrencyFXRates.objects.get(
-                                # we need to get the currency rate because we bulk create the object, and thus save is not called
-                                date=price_date,
-                                currency=instrument.currency,
-                            ),
-                            instrument=instrument,
-                            date=price_date,
-                            calculated=row["calculated"],
-                            net_value=close,
-                            gross_value=close,
-                            volume=row.get("volume", None),
-                            market_capitalization=row.get("market_capitalization", None),
-                        )
+                        try:
+                            InstrumentPrice.objects.get(instrument=instrument, date=price_date)
+                        except MultipleObjectsReturned:
+                            InstrumentPrice.objects.get(
+                                instrument=instrument, date=price_date, calculated=False
+                            ).delete()
+                        p = InstrumentPrice.objects.get(instrument=instrument, date=price_date)
+                        p.net_value = close
+                        p.gross_value = close
+                        p.calculated = row["calculated"]
+                        p.volume = row.get("volume", p.volume)
+                        p.market_capitalization = row.get("market_capitalization", p.market_capitalization)
+                        p.market_capitalization_consolidated = p.market_capitalization
                         p.set_dynamic_field(False)
+                        p.id = None
                         return p
+                    except InstrumentPrice.DoesNotExist:
+                        with suppress(CurrencyFXRates.DoesNotExist):
+                            p = InstrumentPrice(
+                                currency_fx_rate_to_usd=CurrencyFXRates.objects.get(
+                                    # we need to get the currency rate because we bulk create the object, and thus save is not called
+                                    date=price_date,
+                                    currency=instrument.currency,
+                                ),
+                                instrument=instrument,
+                                date=price_date,
+                                calculated=row["calculated"],
+                                net_value=close,
+                                gross_value=close,
+                                volume=row.get("volume", None),
+                                market_capitalization=row.get("market_capitalization", None),
+                            )
+                            p.set_dynamic_field(False)
+                            return p
 
         df = pd.DataFrame(
             self.dl.market_data(
@@ -145,15 +160,101 @@ class InstrumentQuerySet(QuerySet):
 
             for instrument_id, dff in df.groupby("instrument_id", group_keys=False, as_index=False):
                 dff = dff.drop(columns=["instrument_id"]).set_index("date").sort_index()
+                if dff.index.duplicated().any():
+                    dff = dff.groupby(level=0).first()
+                    logger.warning(
+                        f"We detected a duplicated index for instrument id {instrument_id}. Please correct the dl parameter which likely introduced this issue."
+                    )
+
                 dff = dff.reindex(pd.date_range(dff.index.min(), dff.index.max(), freq="B"))
+
                 dff[["close", "market_capitalization"]] = dff[["close", "market_capitalization"]].astype(float).ffill()
                 dff.volume = dff.volume.astype(float).fillna(0)
                 dff.calculated = dff.calculated.astype(bool).fillna(
                     True
                 )  # we do not ffill calculated but set the to True to mark them as "estimated"/"not real"
+
                 dff = dff.reset_index(names="date").dropna(subset=["close"])
                 dff = dff.replace([np.inf, -np.inf, np.nan], None)
                 instrument = self.get(id=instrument_id)
+
                 yield from filter(
                     lambda x: x, map(lambda row: _dict_to_object(instrument, row), dff.to_dict("records"))
                 )
+
+    def get_returns_df(
+        self, from_date: date, to_date: date, to_currency: Currency | None = None, use_dl: bool = False
+    ) -> tuple[dict[date, dict[int, float]], pd.DataFrame]:
+        """
+        Utility methods to get instrument returns for a given date range
+
+        Args:
+            from_date: date range lower bound
+            to_date: date range upper bound
+            to_currency: currency to use for returns
+            use_dl: whether to get data straight from the dataloader or use the internal table
+
+        Returns:
+            Return a tuple of the raw prices and the returns dataframe
+        """
+        padded_from_date = from_date - timedelta(days=15)
+        padded_to_date = to_date + timedelta(days=3)
+        logger.info(
+            f"Loading returns from {from_date:%Y-%m-%d} (padded to {padded_from_date:%Y-%m-%d}) to {to_date:%Y-%m-%d} (padded to {padded_to_date:%Y-%m-%d}) for {self.count()} instruments"
+        )
+
+        if use_dl:
+            kwargs = dict(
+                from_date=padded_from_date, to_date=padded_to_date, values=[MarketData.CLOSE], apply_fx_rate=False
+            )
+            if to_currency:
+                kwargs["target_currency"] = to_currency.key
+            df = pd.DataFrame(self.dl.market_data(**kwargs))
+            if df.empty:
+                df = pd.DataFrame(columns=["instrument_id", "fx_rate", "close", "valuation_date"])
+            else:
+                df = df[["instrument_id", "fx_rate", "close", "valuation_date"]]
+        else:
+            from wbfdm.models import InstrumentPrice
+
+            if to_currency:
+                fx_rate = Coalesce(
+                    CurrencyFXRates.get_fx_rates_subquery_for_two_currencies(
+                        "date", "instrument__currency", to_currency
+                    ),
+                    Decimal("1"),
+                )
+            else:
+                fx_rate = Value(Decimal("1"))
+            # annotate fx rate only if the price is not calculated, in that case we assume the instrument is not tradable and we set a forex of None (to be fast forward filled)
+            prices = InstrumentPrice.objects.filter(
+                instrument__in=self, date__gte=padded_from_date, date__lte=padded_to_date
+            ).annotate(fx_rate=Case(When(calculated=False, then=fx_rate), default=None))
+            df = pd.DataFrame(
+                prices.filter_only_valid_prices().values_list("instrument", "fx_rate", "net_value", "date"),
+                columns=["instrument_id", "fx_rate", "close", "valuation_date"],
+            )
+        df = (
+            df.pivot_table(index="valuation_date", columns="instrument_id", values=["fx_rate", "close"], dropna=False)
+            .astype(float)
+            .sort_index()
+        )
+        if not df.empty:
+            ts = pd.bdate_range(df.index.min(), df.index.max(), freq="B")
+            df = df.reindex(ts)
+            df = df.ffill()
+            df.index = pd.to_datetime(df.index)
+            df = df[
+                (df.index <= pd.Timestamp(to_date)) & (df.index >= pd.Timestamp(from_date))
+            ]  # ensure the returned df corresponds to requested date range
+            prices_df = df["close"]
+            if "fx_rate" in df.columns:
+                fx_rate_df = df["fx_rate"].fillna(1.0)
+            else:
+                fx_rate_df = pd.DataFrame(np.ones(prices_df.shape), index=prices_df.index, columns=prices_df.columns)
+            returns = prices_to_returns(fx_rate_df * prices_df, drop_inceptions_nan=False, fill_nan=True)
+
+            return {
+                ts.date(): row for ts, row in prices_df.replace([np.nan], None).to_dict("index").items()
+            }, returns.replace([np.inf, -np.inf, np.nan], 0)
+        return {}, pd.DataFrame()

wbfdm/models/instruments/utils.py

@@ -40,3 +40,8 @@ def re_isin(input: str):
 
 def re_mnemonic(input: str):
     return set(re.findall(START_DELIMITER + r"([A-Z]+:[A-Z]+)" + END_DELIMITER, input))
+
+
+def clean_ric(ric: str, exchange_code: str):
+    # Replace the matched exchange code with the new exchange
+    return re.sub(r"\.\w+$", f".{exchange_code}", ric)

wbfdm/serializers/exchanges.py

@@ -37,4 +37,5 @@ class ExchangeModelSerializer(wb_serializers.ModelSerializer):
             "_city",
             "city",
             "comments",
+            "apply_round_lot_size",
         )

wbfdm/serializers/instruments/__init__.py

@@ -4,6 +4,7 @@ from .instruments import (
     InstrumentRepresentationSerializer,
     InstrumentTypeRepresentationSerializer,
     InvestableUniverseRepresentationSerializer,
+    CompanyRepresentationSerializer,
     ClassifiableInstrumentRepresentationSerializer,
     SecurityRepresentationSerializer,
     InvestableInstrumentRepresentationSerializer,

wbfdm/serializers/instruments/instruments.py

@@ -51,6 +51,13 @@ class ClassifiableInstrumentRepresentationSerializer(InstrumentRepresentationSer
         return filter_params
 
 
+class CompanyRepresentationSerializer(InstrumentRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = super().get_filter_params(request)
+        filter_params["level"] = 0
+        return filter_params
+
+
 class SecurityRepresentationSerializer(InstrumentRepresentationSerializer):
     def get_filter_params(self, request):
         filter_params = super().get_filter_params(request)
@@ -89,14 +96,14 @@ class ManagedInstrumentRepresentationSerializer(InstrumentRepresentationSerializ
 class EquityRepresentationSerializer(InstrumentRepresentationSerializer):
     def get_filter_params(self, request):
         filter_params = super().get_filter_params(request)
-        filter_params["investment_type__key"] = "equity"
+        filter_params["instrument_type__key"] = "equity"
         return filter_params
 
 
 class ProductRepresentationSerializer(InstrumentRepresentationSerializer):
     def get_filter_params(self, request):
         filter_params = super().get_filter_params(request)
-        filter_params["investment_type__key"] = "product"
+        filter_params["instrument_type__key"] = "product"
         return filter_params
 
 

wbfdm/serializers/instruments/mixins.py

@@ -29,9 +29,9 @@ class InstrumentAdditionalResourcesMixin:
             args=[instance.id],
             request=request,
         )
-        additional_resources[
-            "price_and_volume"
-        ] = f'{reverse("wbfdm:market_data-list", args=[instance.id], request=request)}?chart_type=close&indicators=sma_50,sma_100&volume=true'
+        additional_resources["price_and_volume"] = (
+            f'{reverse("wbfdm:market_data-list", args=[instance.id], request=request)}?chart_type=close&indicators=sma_50,sma_100&volume=true'
+        )
 
         additional_resources["classifications_list"] = reverse(
             "wbfdm:instrument-classification-list",

wbfdm/tasks.py

@@ -1,10 +1,12 @@
+from contextlib import suppress
 from datetime import date, timedelta
 
 from celery import shared_task
 from django.db import transaction
-from django.db.models import Q
+from django.db.models import ProtectedError, Q
 from pandas.tseries.offsets import BDay
 from tqdm import tqdm
+from wbcore.utils.cache import mapping
 
 from wbfdm.models import Instrument, InstrumentPrice
 from wbfdm.sync.runner import (  # noqa: F401
@@ -14,6 +16,7 @@ from wbfdm.sync.runner import (  # noqa: F401
     synchronize_instruments,
 )
 
+from .contrib.metric.signals import instrument_metric_updated
 from .signals import investable_universe_updated
 
 
@@ -51,7 +54,6 @@ def update_of_investable_universe_data(
     Instrument.investable_universe.update(
         is_investable_universe=True
     )  # ensure all the investable universe is marked as such
-
     instruments = Instrument.active_objects.filter(is_investable_universe=True, delisted_date__isnull=True).exclude(
         Q(is_managed=True)
         | Q(dl_parameters__market_data__path="wbfdm.contrib.internal.dataloaders.market_data.MarketDataDataloader")
@@ -71,6 +73,7 @@ def update_instrument_metrics_as_task():
     instruments = Instrument.active_objects.filter(is_investable_universe=True)
     for instrument in tqdm(instruments, total=instruments.count()):
         instrument.update_last_valuation_date()
+    instrument_metric_updated.send(sender=Instrument, basket=None, date=None, key=None)
 
 
 @shared_task(queue="portfolio")
@@ -85,6 +88,14 @@ def synchronize_exchanges_as_task():
 
 @shared_task(queue="portfolio")
 def full_synchronization_as_task():
+    # we get all instrument without name or where we would expect a parent and consider them for clean up.
+    qs = Instrument.objects.filter(prices__isnull=True).filter(
+        (Q(name="") & Q(name_repr="")) | (Q(source__in=["qa-ds2-security", "qa-ds2-quote"]) & Q(parent__isnull=True))
+    )
+    for instrument in qs:
+        with suppress(ProtectedError):
+            instrument.delete()
+    mapping.cache_clear()  # we need to clear the mapping cache because we might have deleted parent instruments
     initialize_exchanges()
     initialize_instruments()
     with transaction.atomic():

wbfdm/tests/analysis/financial_analysis/test_statement_with_estimates.py

@@ -384,7 +384,6 @@ class TestStatementWithEstimates:
             "shares_outstanding",
             "market_capitalization",
             "close",
-            "market_capitalization",
             "net_cash",
             "period_end_date",
             "estimate",

wbfdm/tests/models/test_instrument_prices.py

@@ -1,10 +1,8 @@
 from datetime import date
-from decimal import Decimal
 
 import pandas as pd
 import pytest
 from faker import Faker
-from pandas.tseries.offsets import BDay
 from wbcore.models import DynamicDecimalField, DynamicFloatField
 
 from wbfdm.models import Instrument, InstrumentPrice, RelatedInstrumentThroughModel
@@ -168,18 +166,6 @@ class TestInstrumentPriceModel:
         assert isinstance(instrument_price._meta.get_field("gross_value"), DynamicDecimalField)
         assert instrument_price.gross_value == instrument_price.net_value
 
-    @pytest.mark.parametrize("instrument_price__outstanding_shares", [Decimal(10)])
-    def test_compute_outstanding_shares(self, instrument_price, instrument_price_factory):
-        next_price = instrument_price_factory.create(
-            instrument=instrument_price.instrument,
-            date=instrument_price.date + BDay(1),
-            outstanding_shares=None,
-            calculated=instrument_price.calculated,
-        )
-        assert hasattr(instrument_price, "_compute_outstanding_shares")
-        assert isinstance(instrument_price._meta.get_field("outstanding_shares"), DynamicDecimalField)
-        assert next_price.outstanding_shares == instrument_price.outstanding_shares
-
     @pytest.mark.parametrize("instrument_price__volume_50d", [None])
     def test_compute_volume_50d(self, instrument_price, instrument_price_factory):
         assert hasattr(instrument_price, "_compute_volume_50d")

wbfdm/tests/models/test_instruments.py

@@ -38,23 +38,25 @@ class TestInstrumentModel:
         assert res[0]["market_capitalization"] == price.market_capitalization
         assert res[0]["outstanding_shares"] == float(price.outstanding_shares)
 
-    def test_get_price(self, instrument_factory, instrument_price_factory):
+    def test_get_price(self, weekday, instrument_factory, instrument_price_factory):
         instrument = instrument_factory.create()
         other_instrument = instrument_factory.create()
-        price = instrument_price_factory.create(instrument=instrument)
-        price.refresh_from_db()
+        price_calculated = instrument_price_factory.create(date=weekday, instrument=instrument, calculated=True)
+
         instrument_price_factory.create(instrument=other_instrument)  # Noise
-        assert instrument.get_price(price.date) == float(price.net_value)
-        assert instrument.get_price((price.date + BDay(1)).date()) == float(price.net_value)
-        assert instrument.get_price((price.date + BDay(2)).date()) == float(price.net_value)
-        assert instrument.get_price((price.date + BDay(3)).date()) == float(price.net_value)
+        assert instrument.get_price(weekday) == float(price_calculated.net_value)
+        price_real = instrument_price_factory.create(date=weekday, instrument=instrument, calculated=False)
+        assert instrument.get_price(weekday) == float(price_real.net_value)  # we prioritize real price
+        assert instrument.get_price((weekday + BDay(1)).date()) == float(price_real.net_value)
+        assert instrument.get_price((weekday + BDay(2)).date()) == float(price_real.net_value)
+        assert instrument.get_price((weekday + BDay(3)).date()) == float(price_real.net_value)
         with pytest.raises(ValueError):
-            instrument.get_price((price.date + BDay(4)).date())  # for return the latest valid price 3 days earlier.
+            instrument.get_price((weekday + BDay(4)).date())  # for return the latest valid price 3 days earlier.
 
         # if the instrument is considered cash, we always return a value of 1
         instrument.is_cash = True
         instrument.save()
-        assert instrument.get_price(price.date) == Decimal(1)
+        assert instrument.get_price(weekday) == Decimal(1)
 
     def test_extract_daily_performance_df(self):
         tidx = pd.date_range("2016-07-01", periods=4, freq="B")
@@ -205,3 +207,13 @@ class TestInstrumentModel:
         parent.save()
         instrument.refresh_from_db()
         assert instrument.name_repr == "test2"
+
+    def test_clean_ric(self, instrument_factory, exchange_factory):
+        exchange = exchange_factory.create(refinitiv_identifier_code=None)
+        instrument = instrument_factory.create(refinitiv_identifier_code="AAPL.AA", exchange=exchange)
+        assert instrument.refinitiv_identifier_code == "AAPL.AA"
+
+        exchange.refinitiv_identifier_code = "BB"
+        exchange.save()
+        instrument.save()
+        assert instrument.refinitiv_identifier_code == "AAPL.BB"

wbfdm/tests/models/test_queryset.py

@@ -0,0 +1,89 @@
+from datetime import date
+from decimal import Decimal
+
+import pandas as pd
+import pytest
+
+from wbfdm.models import Instrument
+
+
+@pytest.mark.django_db
+class TestInstrumentQueryset:
+    def test_get_returns(self, instrument_factory, instrument_price_factory):
+        v1 = date(2024, 12, 31)
+        v2 = date(2025, 1, 1)
+        v3 = date(2025, 1, 2)
+        v4 = date(2025, 1, 3)
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        i11 = instrument_price_factory.create(date=v1, instrument=i1)
+        i12 = instrument_price_factory.create(date=v2, instrument=i1)
+        i14 = instrument_price_factory.create(date=v4, instrument=i1)
+        i21 = instrument_price_factory.create(date=v1, instrument=i2)
+        i11.refresh_from_db()
+        i12.refresh_from_db()
+        i14.refresh_from_db()
+        prices, returns = Instrument.objects.filter(id__in=[i1.id, i2.id]).get_returns_df(from_date=v1, to_date=v4)
+
+        expected_returns = pd.DataFrame(
+            [[i12.net_value / i11.net_value - 1, 0.0], [0.0, 0.0], [i14.net_value / i12.net_value - 1, 0.0]],
+            index=[v2, v3, v4],
+            columns=[i1.id, i2.id],
+            dtype="float64",
+        )
+        expected_returns.index = pd.to_datetime(expected_returns.index)
+        pd.testing.assert_frame_equal(returns, expected_returns, check_names=False, check_freq=False, atol=1e-6)
+        assert prices[v1][i1.id] == float(i11.net_value)
+        assert prices[v2][i1.id] == float(i12.net_value)
+        assert prices[v3][i1.id] == float(i12.net_value)
+        assert prices[v4][i1.id] == float(i14.net_value)
+        # test that the returned price are ffill
+        assert prices[v1][i2.id] == float(i21.net_value)
+        assert prices[v2][i2.id] == float(i21.net_value)
+        assert prices[v3][i2.id] == float(i21.net_value)
+        assert prices[v4][i2.id] == float(i21.net_value)
+
+    def test_get_returns_fix_forex_on_holiday(
+        self, instrument, instrument_price_factory, currency_fx_rates_factory, currency_factory
+    ):
+        v1 = date(2024, 12, 31)
+        v2 = date(2025, 1, 1)
+        v3 = date(2025, 1, 2)
+
+        target_currency = currency_factory.create()
+        fx_target1 = currency_fx_rates_factory.create(currency=target_currency, date=v1)
+        fx_target2 = currency_fx_rates_factory.create(currency=target_currency, date=v2)  # noqa
+        fx_target3 = currency_fx_rates_factory.create(currency=target_currency, date=v3)
+
+        fx1 = currency_fx_rates_factory.create(currency=instrument.currency, date=v1)
+        fx2 = currency_fx_rates_factory.create(currency=instrument.currency, date=v2)  # noqa
+        fx3 = currency_fx_rates_factory.create(currency=instrument.currency, date=v3)
+
+        i1 = instrument_price_factory.create(net_value=Decimal("100"), date=v1, instrument=instrument)
+        i2 = instrument_price_factory.create(net_value=Decimal("100"), date=v2, instrument=instrument, calculated=True)
+        i3 = instrument_price_factory.create(net_value=Decimal("200"), date=v3, instrument=instrument)
+
+        prices, returns = Instrument.objects.filter(id__in=[instrument.id]).get_returns_df(
+            from_date=v1, to_date=v3, to_currency=target_currency
+        )
+        returns.index = pd.to_datetime(returns.index)
+        assert prices[v1][instrument.id] == float(i1.net_value)
+        assert prices[v2][instrument.id] == float(i2.net_value)
+        assert prices[v3][instrument.id] == float(i3.net_value)
+
+        assert returns.loc[pd.Timestamp(v2), instrument.id] == pytest.approx(
+            float(
+                (i2.net_value * fx_target1.value / fx1.value) / (i1.net_value * fx_target1.value / fx1.value)
+                - Decimal("1")
+            ),
+            abs=10e-8,
+        )  # as v2 as a calculated price, the forex won't apply to it
+        assert returns.loc[pd.Timestamp(v3), instrument.id] == pytest.approx(
+            float(
+                (i3.net_value * fx_target3.value / fx3.value) / (i2.net_value * fx_target1.value / fx1.value)
+                - Decimal("1")
+            ),
+            abs=10e-8,
+        )

wbfdm/viewsets/configs/display/exchanges.py

@@ -35,7 +35,7 @@ class ExchangeDisplayConfig(DisplayViewConfig):
             [
                 ["name", "mic_code", "operating_mic_code", "refinitiv_identifier_code"],
                 [".", "bbg_exchange_codes", "bbg_composite_primary", "bbg_composite"],
-                [repeat_field(2, "country"), "city", "website"],
+                ["country", "city", "website", "apply_round_lot_size"],
                 [repeat_field(2, "opening_time"), repeat_field(2, "closing_time")],
                 [repeat_field(4, "comments")],
             ]

wbfdm/viewsets/configs/display/financial_summary.py

@@ -80,7 +80,7 @@ class FinancialSummaryDisplayViewConfig(DisplayViewConfig):
                 label=col,
                 width=80,
                 formatting_rules=generate_formatting_rules(col),
-                auto_size=False,
+                suppress_auto_size=False,
                 resizable=False,
                 movable=False,
                 menu=False,
@@ -93,7 +93,7 @@ class FinancialSummaryDisplayViewConfig(DisplayViewConfig):
                     key="label",
                     label=" ",
                     width=120,
-                    auto_size=False,
+                    suppress_auto_size=False,
                     resizable=False,
                     movable=False,
                     menu=False,