wbportfolio 1.56.2__tar.gz → 1.56.4__tar.gz

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.56.2
+Version: 1.56.4
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/api_clients/ubs.py

@@ -90,7 +90,7 @@ class UBSNeoAPIClient:
         isin = self._validate_isin(isin, test=test)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/submit/{isin}"
         payload = {"items": items}
-        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=10)
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -99,7 +99,7 @@ class UBSNeoAPIClient:
         isin = self._validate_isin(isin)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/savedraft/{isin}"
         payload = {"items": items}
-        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=10)
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -107,14 +107,14 @@ class UBSNeoAPIClient:
         """Cancel a rebalance request."""
         isin = self._validate_isin(isin)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/cancel/{isin}"
-        response = requests.delete(url, headers=self._get_headers(), timeout=10)
+        response = requests.delete(url, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
     def get_current_rebalance_request(self, isin: str) -> dict:
         """Fetch the current rebalance request for a certificate."""
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/currentRebalanceRequest/{isin}"
-        response = requests.get(url, headers=self._get_headers(), timeout=10)
+        response = requests.get(url, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -130,7 +130,7 @@ class UBSNeoAPIClient:
             url,
             headers=self._get_headers(),
             params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
-            timeout=10,
+            timeout=30,
         )
         self._raise_for_status(response)
         return self._get_json(response)
@@ -141,7 +141,7 @@ class UBSNeoAPIClient:
             url,
             headers=self._get_headers(),
             params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
-            timeout=10,
+            timeout=30,
         )
         self._raise_for_status(response)
         return self._get_json(response)

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/import_export/handlers/asset_position.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from contextlib import suppress
-from datetime import datetime
+from datetime import datetime, timedelta
 from decimal import Decimal
 from itertools import chain
 from typing import Any, Dict, List, Optional
@@ -31,7 +31,7 @@ class AssetPositionImportHandler(ImportExportHandler):
         self.instrument_price_handler = InstrumentPriceImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
-    def _deserialize(self, data: Dict[str, Any]):
+    def _deserialize(self, data: Dict[str, Any]):  # noqa: C901
         from wbportfolio.models import Portfolio
 
         portfolio_data = data.pop("portfolio", None)
@@ -45,6 +45,10 @@ class AssetPositionImportHandler(ImportExportHandler):
                     data["initial_price"] /= 1000
             data["currency"] = currency
         data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+
+        # ensure that the position falls into a weekday
+        if data["date"].weekday() == 5:
+            data["date"] -= timedelta(days=1)
         if data.get("asset_valuation_date", None):
             data["asset_valuation_date"] = datetime.strptime(data["asset_valuation_date"], "%Y-%m-%d").date()
         else:

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/import_export/parsers/natixis/equity.py

@@ -43,16 +43,16 @@ def parse(import_source):
             df = pd.read_excel(import_source.file, engine="openpyxl", sheet_name="Basket Valuation")
         except BadZipFile:
             df = pd.read_excel(import_source.file, engine="xlrd", sheet_name="Basket Valuation")
-        xx, yy = np.where(df == "Ticker")
-        if not xx and not yy:
-            xx, yy = np.where(df == "Code")
-        df = df.iloc[xx[0] :, yy[0] :]
-        df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
-        df["Quotity/Adj. factor"] = 1.0
-        df = df.rename(columns={"Code": "Ticker"})
-
+        xx, yy = np.where(df.isin(["Ticker", "Code"]))
+        if xx.size > 0 and yy.size > 0:
+            df = df.iloc[xx[0] :, yy[0] :]
+            df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+            df["Quotity/Adj. factor"] = 1.0
+            df = df.rename(columns={"Code": "Ticker"})
+        else:
+            return {}
     df = df.rename(columns=FIELD_MAP)
-    df = df.dropna(subset=["initial_price"])
+    df = df.dropna(subset=["initial_price", "Name"], how="any")
     df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
     df["underlying_quote"] = df[["Ticker", "Name", "currency__key"]].apply(
         lambda x: _get_underlying_instrument(*x), axis=1

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/models/asset.py

@@ -448,7 +448,10 @@ class AssetPosition(ImportMixin, models.Model):
                     net_value = self.initial_price
                     # in case the position currency and the linked underlying_quote currency don't correspond, we convert the rate accordingly
                     if self.currency != self.underlying_quote.currency:
-                        net_value *= self.currency.convert(self.asset_valuation_date, self.underlying_quote.currency)
+                        with suppress(CurrencyFXRates.DoesNotExist):
+                            net_value *= self.currency.convert(
+                                self.asset_valuation_date, self.underlying_quote.currency
+                            )
                     self.underlying_quote_price = InstrumentPrice.objects.create(
                         calculated=False,
                         instrument=self.underlying_quote,

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/models/orders/order_proposals.py

@@ -20,7 +20,7 @@ from django.db.models.functions import Coalesce, Round
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy
 from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
@@ -458,6 +458,27 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 weighting = drifted_weight + row["delta_weight"]
 
             # Assemble the position object
+            trade_date = self.last_effective_date if use_effective else self.trade_date
+            price_data = {}
+            with suppress(InstrumentPrice.DoesNotExist):
+                instrument_price = instrument.valuations.get(date=trade_date)
+                if fx_rate := instrument_price.currency_fx_rate_to_usd:
+                    price_data = {
+                        "volume_usd": instrument_price.volume
+                        * float(instrument_price.net_value)
+                        / float(fx_rate.value)
+                    }
+                    if instrument_price.market_capitalization:
+                        price_data["market_capitalization_usd"] = instrument_price.market_capitalization / float(
+                            fx_rate.value
+                        )
+                    if row["shares"] is not None:
+                        if instrument_price.market_capitalization:
+                            price_data["market_share"] = (
+                                float(row["shares"]) * float(row["price"]) / instrument_price.market_capitalization
+                            )
+                        if instrument_price.volume_50d:
+                            price_data["daily_liquidity"] = float(row["shares"]) / instrument_price.volume_50d / 0.33
             positions.append(
                 PositionDTO(
                     underlying_instrument=instrument.id,
@@ -466,10 +487,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     daily_return=daily_return if use_effective else Decimal("0"),
                     shares=row["shares"],
                     currency=instrument.currency.id,
-                    date=self.last_effective_date if use_effective else self.trade_date,
+                    date=trade_date,
+                    asset_valuation_date=trade_date,
                     is_cash=instrument.is_cash or instrument.is_cash_equivalent,
                     price=row["price"],
                     currency_fx_rate=row["currency_fx_rate"],
+                    exchange=instrument.exchange.id if instrument.exchange else None,
+                    country=instrument.country.id if instrument.country else None,
+                    **price_data,
                 )
             )
             total_weighting += weighting
@@ -601,15 +626,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             portfolio_value = self.portfolio_total_asset_value
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
-                currency_fx_rate = instrument.currency.convert(
-                    self.value_date, self.portfolio.currency, exact_lookup=True
-                )
                 # we cannot do a bulk-create because Order is a multi table inheritance
                 weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
                 daily_return = order_dto.daily_return
                 try:
                     order = self.orders.get(underlying_instrument=instrument)
-                    order.currency_fx_rate = currency_fx_rate
                     order.daily_return = daily_return
                 except Order.DoesNotExist:
                     order = Order(
@@ -618,7 +639,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         value_date=self.trade_date,
                         weighting=weighting,
                         daily_return=daily_return,
-                        currency_fx_rate=currency_fx_rate,
                     )
                 order.pre_save()
                 order.set_weighting(weighting, portfolio_value)
@@ -916,7 +936,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             #         "There is no change detected in this order proposal. Please submit at last one valid order"
             #     )
             if len(service.validated_trades) == 0:
-                errors_list.append(_("There is no valid order on this proposal"))
+                errors_list.append(gettext_lazy("There is no valid order on this proposal"))
             if service.errors:
                 errors_list.extend(service.errors)
             if errors_list:
@@ -1043,22 +1063,26 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         orders = self.get_orders()
         if not self.portfolio.can_be_rebalanced:
-            errors["non_field_errors"] = [_("The portfolio does not allow manual rebalanced")]
+            errors["non_field_errors"] = [gettext_lazy("The portfolio does not allow manual rebalanced")]
         if not orders.exists():
             errors["non_field_errors"] = [
-                _("At least one order needs to be submitted to be able to apply this proposal")
+                gettext_lazy("At least one order needs to be submitted to be able to apply this proposal")
             ]
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                [_("The portfolio needs to be a model portfolio in order to apply this order proposal manually")]
+                [
+                    gettext_lazy(
+                        "The portfolio needs to be a model portfolio in order to apply this order proposal manually"
+                    )
+                ]
             ]
         if self.has_non_successful_checks:
-            errors["non_field_errors"] = [_("The pre orders rules did not passed successfully")]
+            errors["non_field_errors"] = [gettext_lazy("The pre orders rules did not passed successfully")]
         if orders.filter(has_warnings=True).filter(
             underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
         ):
             errors["non_field_errors"] = [
-                _("There is warning that needs to be addresses on the orders before approval.")
+                gettext_lazy("There is warning that needs to be addresses on the orders before approval.")
             ]
         return errors
 
@@ -1122,7 +1146,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                _("The portfolio needs to be a model portfolio in order to revert this order proposal manually")
+                gettext_lazy(
+                    "The portfolio needs to be a model portfolio in order to revert this order proposal manually"
+                )
             ]
         return errors
 

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/models/orders/orders.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
@@ -7,6 +8,7 @@ from django.db.models import (
     Sum,
 )
 from ordered_model.models import OrderedModel
+from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
 
 from wbportfolio.import_export.handlers.orders import OrderImportHandler
@@ -137,12 +139,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         return getattr(
             self,
             "effective_shares",
-            AssetPosition.objects.filter(
-                underlying_quote=self.underlying_instrument,
-                date=self.value_date,
-                portfolio=self.portfolio,
-            ).aggregate(s=Sum("shares"))["s"]
-            or Decimal(0),
+            self.get_effective_shares(),
         )
 
     @property
@@ -164,6 +161,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def pre_save(self):
         self.portfolio = self.order_proposal.portfolio
         self.value_date = self.order_proposal.trade_date
+        self.set_currency_fx_rate()
 
         if not self.price:
             # we try to get the price if not provided directly from the underlying instrument
@@ -171,7 +169,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 self.price = Decimal("1")
             else:
                 self.price = self.get_price()
-        if not self.portfolio.only_weighting:
+        if not self.portfolio.only_weighting and not self.shares:
             estimated_shares = self.order_proposal.get_estimated_shares(
                 self.weighting, self.underlying_instrument, self.price
             )
@@ -211,9 +209,24 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         except ValueError:
             return Decimal("0")
 
+    def get_effective_shares(self) -> Decimal:
+        return AssetPosition.objects.filter(
+            underlying_quote=self.underlying_instrument,
+            date=self.value_date,
+            portfolio=self.portfolio,
+        ).aggregate(s=Sum("shares"))["s"] or Decimal("0")
+
     def set_type(self):
         self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
 
+    def set_currency_fx_rate(self):
+        self.currency_fx_rate = Decimal("1")
+        if self.order_proposal.portfolio.currency != self.underlying_instrument.currency:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                self.currency_fx_rate = self.underlying_instrument.currency.convert(
+                    self.value_date, self.portfolio.currency, exact_lookup=True
+                )
+
     def set_weighting(self, weighting: Decimal, portfolio_value: Decimal):
         self.weighting = weighting
         price_fx_portfolio = self.price * self.currency_fx_rate
@@ -222,6 +235,8 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             self.shares = total_value / price_fx_portfolio
         else:
             self.shares = Decimal("0")
+        if effective_shares := self.get_effective_shares():
+            self.shares = max(self.shares, -effective_shares)
 
     def set_shares(self, shares: Decimal, portfolio_value: Decimal):
         if portfolio_value:
@@ -244,26 +259,27 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         warnings = []
 
         # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
-        if self.order_proposal and not self.portfolio.only_weighting:
-            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
-            if shares != self.shares:
+        if self._target_weight:
+            if self.order_proposal and not self.portfolio.only_weighting:
+                shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
+                if shares != self.shares:
+                    warnings.append(
+                        f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                    )
+                shares = round(shares)  # ensure fractional shares are converted into integer
+                # we need to recompute the delta weight has we changed the number of shares
+                if shares != self.shares:
+                    self.set_shares(shares, portfolio_total_asset_value)
+            if abs(self.weighting) < self.order_proposal.min_weighting:
                 warnings.append(
-                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                    f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
                 )
-            shares = round(shares)  # ensure fractional shares are converted into integer
-            # we need to recompute the delta weight has we changed the number of shares
-            if shares != self.shares:
-                self.set_shares(shares, portfolio_total_asset_value)
-        if abs(self.weighting) < self.order_proposal.min_weighting:
-            warnings.append(
-                f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
-            )
-            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
-        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
-            warnings.append(
-                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
-            )
-            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+            if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
+                warnings.append(
+                    f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
+                )
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
         if not self.price:
             warnings.append(f"No price for {self.underlying_instrument.computed_str}")
         if (

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -160,7 +160,7 @@ class RuleBackend(
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
         if not (df := self._filter_df(portfolio.to_df())).empty:
-            df = df[[self.group_by.value, self.field.value]].groupby(self.group_by.value).sum().astype(float)
+            df = df[[self.group_by.value, self.field.value]].dropna().groupby(self.group_by.value).sum().astype(float)
             for threshold in self.thresholds:
                 numerical_range = threshold.numerical_range
                 incident_df = df[

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/serializers/orders/orders.py

@@ -66,6 +66,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
     total_value_fx_portfolio = wb_serializers.DecimalField(required=False, max_digits=16, decimal_places=2)
 
     portfolio_currency = wb_serializers.CharField(read_only=True)
+    underlying_instrument_currency = wb_serializers.CharField(read_only=True)
     has_warnings = wb_serializers.BooleanField(read_only=True)
 
     def validate(self, data):
@@ -131,7 +132,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
 
     class Meta:
         model = Order
-        percent_fields = ["effective_weight", "target_weight", "weighting"]
+        percent_fields = ["effective_weight", "target_weight", "weighting", "daily_return", "desired_target_weight"]
         decorators = {
             "total_value_fx_portfolio": wb_serializers.decorator(
                 decorator_type="text", position="left", value="{{portfolio_currency}}"
@@ -142,12 +143,17 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "target_total_value_fx_portfolio": wb_serializers.decorator(
                 decorator_type="text", position="left", value="{{portfolio_currency}}"
             ),
+            "price": wb_serializers.decorator(position="left", value="{{underlying_instrument_currency}}"),
         }
         read_only_fields = (
             "order_type",
             "effective_shares",
             "effective_total_value_fx_portfolio",
             "has_warnings",
+            "desired_target_weight",
+            "daily_return",
+            "currency_fx_rate",
+            "price",
         )
         fields = (
             "id",
@@ -171,9 +177,14 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "effective_total_value_fx_portfolio",
             "target_total_value_fx_portfolio",
             "portfolio_currency",
+            "underlying_instrument_currency",
             "has_warnings",
             "execution_confirmed",
             "execution_comment",
+            "desired_target_weight",
+            "daily_return",
+            "currency_fx_rate",
+            "price",
         )
 
 

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/viewsets/orders/configs/displays/orders.py

@@ -157,7 +157,13 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
                         formatting_rules=ORDER_TYPE_FORMATTING_RULES,
                         width=Unit.PIXEL(125),
                     ),
-                    dp.Field(key="comment", label="Comment", width=Unit.PIXEL(250)),
+                    dp.Field(key="comment", label="Comment", show="open", width=Unit.PIXEL(250)),
+                    dp.Field(
+                        key="desired_target_weight", label="Desired Target Weight", show="open", width=Unit.PIXEL(100)
+                    ),
+                    dp.Field(key="daily_return", label="Daily Return", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="currency_fx_rate", label="FX Rate", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="price", label="Price", show="open", width=Unit.PIXEL(100)),
                     dp.Field(key="order", label="Order", show="open", width=Unit.PIXEL(100)),
                 ],
             )

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/viewsets/orders/order_proposals.py

@@ -2,7 +2,7 @@ from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
-from django.contrib.messages import info, warning
+from django.contrib.messages import warning
 from django.shortcuts import get_object_or_404
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
@@ -87,8 +87,6 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
 
     def add_messages(self, request, instance: OrderProposal | None = None, **kwargs):
         if instance:
-            if instance.status == OrderProposal.Status.APPROVED and not instance.portfolio.is_manageable:
-                info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
             if instance.status == OrderProposal.Status.PENDING and instance.has_non_successful_checks:
                 warning(
                     request,

{wbportfolio-1.56.2 → wbportfolio-1.56.4}/wbportfolio/viewsets/orders/orders.py

@@ -235,6 +235,7 @@ class OrderOrderProposalModelViewSet(
             effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
             target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
             portfolio_currency=F("portfolio__currency__symbol"),
+            underlying_instrument_currency=F("underlying_instrument__currency__symbol"),
             security=F("underlying_instrument__parent"),
             company=F("underlying_instrument__parent__parent"),
         ).select_related(