wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/risk_management/backends/esg_aggregation_portfolio.py

@@ -0,0 +1,64 @@
+from typing import Generator
+
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbcore import serializers as wb_serializers
+from wbfdm.analysis.esg.enums import ESGAggregation
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+from wbfdm.models import Instrument
+
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("ESG Aggregation Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActivePortfolioRelationshipMixin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.esg_aggregation = ESGAggregation[self.esg_aggregation]
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            esg_aggregation = wb_serializers.ChoiceField(
+                choices=ESGAggregation.choices(),
+                default=ESGAggregation.GHG_EMISSIONS_SCOPE_1.name,
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "esg_aggregation",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        esg_data = self.esg_aggregation.get_esg_data(Instrument.objects.filter(id__in=portfolio.positions_map.keys()))
+        df = portfolio.to_df(exclude_cash=True)
+        df["total_value"] = (df["price"] * df["shares"] * df["currency_fx_rate"]).astype(float)
+        df = df[["total_value", "weighting", "underlying_instrument"]].set_index("underlying_instrument")
+        df["weighting"] = df["weighting"] / df["weighting"].sum()
+        dataloader = DataLoader(
+            df["weighting"].astype(float), esg_data, self.evaluation_date, total_value_fx_usd=df["total_value"]
+        )
+        metrics = dataloader.compute(self.esg_aggregation)
+        for threshold in self.thresholds:
+            numerical_range = threshold.numerical_range
+            incident_df = metrics[(metrics >= numerical_range[0]) & (metrics < numerical_range[1])]
+            for instrument_id, metric in incident_df.to_dict().items():
+                instrument = Instrument.objects.get(id=instrument_id)
+                breached_value = metric
+
+                if metric < 0:
+                    breached_value = f'<span style="color:red">{breached_value}</span>'
+                else:
+                    breached_value = f'<span style="color:green">{breached_value}</span>'
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=breached_value,
+                    report_details={"Aggregation": self.esg_aggregation.value},
+                    severity=threshold.severity,
+                )

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -3,7 +3,7 @@ from typing import Generator
 from django.db import models
 from wbcompliance.models.risk_management import backend
 from wbcompliance.models.risk_management.dispatch import register
-from wbcompliance.models.risk_management.rules import RiskIncidentType
+from wbcompliance.models.risk_management.incidents import RiskIncidentType
 from wbcore import serializers as wb_serializers
 from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
@@ -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[
@@ -180,7 +180,7 @@ class RuleBackend(
                             breached_value = f'<span style="color:green">{breached_value}</span>'
                         yield backend.IncidentResult(
                             breached_object=obj,
-                            breached_object_repr=obj_repr,
+                            breached_object_repr=str(obj_repr),
                             breached_value=breached_value,
                             report_details=self.report_details,
                             severity=severity,
@@ -218,7 +218,7 @@ class RuleBackend(
                 obj = Instrument.objects.get(id=pivot_object_id)
                 return obj, str(obj)
             case self.GroupbyChoices.ASSET_TYPE:
-                return None, InstrumentType.objects.get(id=pivot_object_id)
+                return None, InstrumentType.objects.get(id=pivot_object_id).name
             case self.GroupbyChoices.CASH:
                 return None, "Cash"
             case self.GroupbyChoices.COUNTRY:

wbportfolio/risk_management/backends/instrument_list_portfolio.py

@@ -64,10 +64,10 @@ class RuleBackend(ActivePortfolioRelationshipMixin):
         return RuleBackendSerializer
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
-        for instrument_id, weight in portfolio.positions_map.items():
+        for instrument_id in portfolio.positions_map.keys():
             instrument = Instrument.objects.get(id=instrument_id)
-            relationships = self.instruments_relationship.filter(instrument=instrument, validated=True)
-
+            ancestors = instrument.get_ancestors(include_self=True)
+            relationships = self.instruments_relationship.filter(instrument__in=ancestors, validated=True)
             if self.exclude and relationships.exists():
                 report_details = {
                     "Instrument Lists": ", ".join(relationships.values_list("instrument_list__name", flat=True)),

wbportfolio/risk_management/tests/test_esg_aggregation_portfolio.py

@@ -0,0 +1,49 @@
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+
+from wbportfolio.risk_management.backends.esg_aggregation_portfolio import (
+    RuleBackend as ESGAggregationPortfolioBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestEsgAggregationPortfolioRuleModel(PortfolioTestMixin):
+    @patch.object(DataLoader, "compute")
+    def test_eval(
+        self,
+        mock_fct,
+        weekday,
+        asset_position_factory,
+        portfolio,
+    ):
+        parameters = {"esg_aggregation": "GHG_EMISSIONS_SCOPE_1"}
+        backend = ESGAggregationPortfolioBackend(
+            weekday,
+            portfolio,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=0.02, upper=0.03))],  # type: ignore
+        )
+
+        a1 = asset_position_factory.create(
+            date=weekday,
+            portfolio=portfolio,
+        )  # Breached position
+
+        a2 = asset_position_factory.create(
+            date=weekday,
+            portfolio=portfolio,
+        )
+        mock_fct.return_value = pd.Series(index=[a1.underlying_quote.id, a2.underlying_quote.id], data=[0.01, 0.025])
+        incidents = list(backend.check_rule())
+        assert len(incidents) == 1
+        incident = incidents[0]
+        assert incident.breached_object == a2.underlying_quote

wbportfolio/risk_management/tests/test_exposure_portfolio.py

@@ -138,5 +138,5 @@ class TestExposurePortfolioRuleModel(PortfolioTestMixin):
         incidents = list(exposure_portfolio_backend.check_rule())
         assert len(incidents) == 1
         incident = incidents[0]
-        assert incident.breached_object_repr == i1.instrument_type
+        assert incident.breached_object_repr == i1.instrument_type.name
         assert incident.breached_value == '<span style="color:green">+5.00%</span>'

wbportfolio/risk_management/tests/test_stop_loss_instrument.py

@@ -92,7 +92,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
             date=weekday, net_value=500, calculated=False, instrument=benchmark
         )
         RelatedInstrumentThroughModel.objects.create(instrument=product, related_instrument=benchmark, is_primary=True)
-        setattr(stop_loss_instrument_backend, "dynamic_benchmark_type", "PRIMARY_BENCHMARK")
+        stop_loss_instrument_backend.dynamic_benchmark_type = "PRIMARY_BENCHMARK"
 
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 0
@@ -105,7 +105,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
         assert len(res) == 1
         assert res[0].breached_object.id == product.id
 
-        setattr(stop_loss_instrument_backend, "static_benchmark", benchmark)
+        stop_loss_instrument_backend.static_benchmark = benchmark
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 1
         assert res[0].breached_object.id == product.id

wbportfolio/risk_management/tests/test_stop_loss_portfolio.py

@@ -119,7 +119,7 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 0
 
-        setattr(stop_loss_portfolio_backend, "static_benchmark", benchmark)
+        stop_loss_portfolio_backend.static_benchmark = benchmark
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 1
         assert res[0].breached_object.id == instrument.id

wbportfolio/serializers/__init__.py

@@ -27,6 +27,7 @@ from .registers import RegisterModelSerializer, RegisterRepresentationSerializer
 from .roles import PortfolioRoleModelSerializer, PortfolioRoleProjectModelSerializer
 from .signals import *
 from .transactions import *
+from .orders import *
 from .products import (
     ProductRepresentationSerializer,
     ProductCustomerRepresentationSerializer,

wbportfolio/serializers/orders/__init__.py

@@ -0,0 +1,2 @@
+from .order_proposals import OrderProposalModelSerializer, ReadOnlyOrderProposalModelSerializer, OrderProposalRepresentationSerializer
+from .orders import OrderOrderProposalModelSerializer, ReadOnlyOrderOrderProposalModelSerializer, OrderOrderProposalListModelSerializer

wbportfolio/serializers/orders/order_proposals.py

@@ -0,0 +1,115 @@
+from django.contrib.messages import warning
+from django.core.exceptions import ValidationError
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.serializers import CharField, DefaultFromView
+
+from wbportfolio.models import OrderProposal, Portfolio, RebalancingModel
+
+from .. import PortfolioRepresentationSerializer, RebalancingModelRepresentationSerializer
+
+
+class OrderProposalRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:orderproposal-detail")
+
+    class Meta:
+        model = OrderProposal
+        fields = ("id", "trade_date", "status", "_detail")
+
+
+class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
+    _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
+    target_portfolio = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Portfolio.objects.all(), write_only=True, required=False
+    )
+    _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
+    trade_date = wb_serializers.DateField(
+        read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
+    )
+    _creator = PersonRepresentationSerializer(source="creator")
+    _approver = PersonRepresentationSerializer(source="approver")
+    execution_status_repr = wb_serializers.SerializerMethodField(label="Status", field_class=CharField, read_only=True)
+
+    def get_execution_status_repr(self, obj):
+        repr = obj.execution_status
+        if obj.execution_status_detail:
+            repr += f" (Custodian: {obj.execution_status_detail})"
+        return repr
+
+    def create(self, validated_data):
+        target_portfolio = validated_data.pop("target_portfolio", None)
+        rebalancing_model = validated_data.get("rebalancing_model", None)
+        if request := self.context.get("request"):
+            validated_data["creator"] = request.user.profile
+        obj = super().create(validated_data)
+
+        target_portfolio_dto = None
+        if target_portfolio:
+            target_portfolio_dto = target_portfolio._build_dto(obj.trade_date)
+        elif rebalancing_model:
+            target_portfolio_dto = rebalancing_model.get_target_portfolio(
+                obj.portfolio, obj.trade_date, obj.last_effective_date
+            )
+
+        try:
+            obj.reset_orders(target_portfolio=target_portfolio_dto)
+        except ValidationError as e:
+            if request := self.context.get("request"):
+                warning(request, str(e), extra_tags="auto_close=0")
+        return obj
+
+    @wb_serializers.register_only_instance_resource()
+    def additional_resources(self, instance, request, user, **kwargs):
+        res = {}
+        if instance.status == OrderProposal.Status.CONFIRMED:
+            res["replay"] = reverse("wbportfolio:orderproposal-replay", args=[instance.id], request=request)
+        if instance.status == OrderProposal.Status.DRAFT:
+            res["reset"] = reverse("wbportfolio:orderproposal-reset", args=[instance.id], request=request)
+            res["normalize"] = reverse("wbportfolio:orderproposal-normalize", args=[instance.id], request=request)
+        if instance.status == OrderProposal.Status.DRAFT or instance.can_be_confirmed:
+            res["refresh_return"] = reverse(
+                "wbportfolio:orderproposal-refreshreturn", args=[instance.id], request=request
+            )
+        res["orders"] = reverse(
+            "wbportfolio:orderproposal-order-list",
+            args=[instance.id],
+            request=request,
+        )
+        return res
+
+    class Meta:
+        model = OrderProposal
+        only_fsm_transition_on_instance = True
+        percent_fields = ["total_cash_weight"]
+        fields = (
+            "id",
+            "trade_date",
+            "portfolio",
+            "_portfolio",
+            "total_cash_weight",
+            "comment",
+            "status",
+            "min_order_value",
+            "min_weighting",
+            "_rebalancing_model",
+            "rebalancing_model",
+            "target_portfolio",
+            "_target_portfolio",
+            "creator",
+            "approver",
+            "_creator",
+            "_approver",
+            "execution_status",
+            "execution_status_detail",
+            "execution_comment",
+            "execution_status_repr",
+            "_additional_resources",
+        )
+
+
+class ReadOnlyOrderProposalModelSerializer(OrderProposalModelSerializer):
+    class Meta(OrderProposalModelSerializer.Meta):
+        read_only_fields = OrderProposalModelSerializer.Meta.fields

wbportfolio/serializers/orders/orders.py

@@ -0,0 +1,283 @@
+from decimal import Decimal
+
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from rest_framework.validators import UniqueTogetherValidator
+from wbcore import serializers as wb_serializers
+from wbcore.metadata.configs.display.list_display import BaseTreeGroupLevelOption
+from wbfdm.models import Instrument
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
+from wbfdm.serializers.instruments.instruments import (
+    CompanyRepresentationSerializer,
+    SecurityRepresentationSerializer,
+)
+
+from wbportfolio.models import Order, OrderProposal
+
+
+class GetSecurityDefault:
+    requires_context = True
+
+    def __call__(self, serializer_instance):
+        try:
+            instance = serializer_instance.view.get_object()
+            return instance.underlying_instrument.parent or instance.underlying_instrument
+        except Exception:
+            return None
+
+
+class GetCompanyDefault:
+    requires_context = True
+
+    def __call__(self, serializer_instance):
+        try:
+            instance = serializer_instance.view.get_object()
+            security = instance.underlying_instrument.parent or instance.underlying_instrument
+            return security.parent or security
+        except Exception:
+            return None
+
+
+class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
+    underlying_instrument = wb_serializers.SlugRelatedField(read_only=True, slug_field="name")
+    underlying_instrument_isin = wb_serializers.CharField(read_only=True)
+    underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
+    underlying_instrument_refinitiv_identifier_code = wb_serializers.CharField(read_only=True)
+    underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
+    underlying_instrument_exchange = wb_serializers.CharField(read_only=True)
+
+    effective_weight = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        default=0,
+    )
+    target_weight = wb_serializers.DecimalField(
+        max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        required=False,
+    )
+
+    effective_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
+    target_shares = wb_serializers.DecimalField(required=False, max_digits=16, decimal_places=6)
+
+    effective_total_value_fx_portfolio = wb_serializers.DecimalField(
+        read_only=True, max_digits=16, decimal_places=2, default=0
+    )
+    target_total_value_fx_portfolio = wb_serializers.DecimalField(required=False, max_digits=16, decimal_places=2)
+    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)
+    execution_instruction_parameters_repr = wb_serializers.CharField(read_only=True)
+    execution_date = wb_serializers.DateField(read_only=True)
+    execution_price = wb_serializers.FloatField(read_only=True)
+    execution_traded_shares = wb_serializers.FloatField(read_only=True)
+
+    @wb_serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        if (view := request.parser_context.get("view")) and view.order_proposal.status in [
+            OrderProposal.Status.DRAFT,
+            OrderProposal.Status.PENDING,
+            OrderProposal.Status.APPROVED,
+        ]:
+            return {
+                "execution_instruction": reverse(
+                    "wbportfolio:orderproposal-order-changeexecutioninstruction",
+                    args=[view.order_proposal.id, instance.id],
+                    request=request,
+                )
+            }
+        return {}
+
+    def validate(self, data):
+        data.pop("company", None)
+        data.pop("security", None)
+        if self.instance and "underlying_instrument" in data:
+            raise serializers.ValidationError(
+                {
+                    "underlying_instrument": "You cannot modify the underlying instrument other than creating a new entry"
+                }
+            )
+
+        effective_weight = self.instance._effective_weight if self.instance else Decimal(0.0)
+        effective_shares = self.instance._effective_shares if self.instance else Decimal(0.0)
+        portfolio_value = (
+            self.context["view"].order_proposal.portfolio_total_asset_value if "view" in self.context else Decimal(0.0)
+        )
+        if (total_value_fx_portfolio := data.pop("total_value_fx_portfolio", None)) is not None and portfolio_value:
+            data["weighting"] = total_value_fx_portfolio / portfolio_value
+        if (
+            target_total_value_fx_portfolio := data.pop("target_total_value_fx_portfolio", None)
+        ) is not None and portfolio_value:
+            data["target_weight"] = target_total_value_fx_portfolio / portfolio_value
+
+        if data.get("weighting") is not None or data.get("target_weight") is not None:
+            weighting = data.pop("weighting", None)
+            if (target_weight := data.pop("target_weight", None)) is not None:
+                weighting = target_weight - effective_weight
+                data["desired_target_weight"] = target_weight
+            if weighting is not None:
+                data["weighting"] = weighting
+            data.pop("shares", None)
+            data.pop("target_shares", None)
+
+        if data.get("shares") is not None or data.get("target_shares") is not None:
+            shares = data.pop("shares", None)
+            if (target_shares := data.pop("target_shares", None)) is not None:
+                shares = target_shares - effective_shares
+            if shares is not None:
+                data["shares"] = shares
+        return super().validate(data)
+
+    def update(self, instance, validated_data):
+        weighting = validated_data.pop("weighting", None)
+        shares = validated_data.pop("shares", None)
+        portfolio_total_asset_value = instance.order_proposal.portfolio_total_asset_value
+        if weighting is not None:
+            instance.set_weighting(weighting, portfolio_total_asset_value)
+        if shares is not None:
+            instance.set_shares(shares, portfolio_total_asset_value)
+        return super().update(instance, validated_data)
+
+    def create(self, validated_data):
+        weighting = validated_data.pop("weighting", None)
+        shares = validated_data.pop("shares", None)
+        instance = super().create(validated_data)
+        portfolio_total_asset_value = instance.order_proposal.portfolio_total_asset_value
+        if weighting is not None:
+            instance.set_weighting(weighting, portfolio_total_asset_value)
+        if shares is not None:
+            instance.set_shares(shares, portfolio_total_asset_value)
+        instance.save()
+        return instance
+
+    def get_unique_together_validators(self):
+        return [
+            UniqueTogetherValidator(
+                queryset=Order.objects.all(),
+                fields=("order_proposal", "underlying_instrument"),
+                message="This instrument is already in the orders list.",
+            )
+        ]
+
+    class Meta:
+        model = Order
+        percent_fields = ["effective_weight", "target_weight", "weighting", "desired_target_weight"]
+        decorators = {
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "effective_total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "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",
+            "execution_instruction",
+            "execution_instruction_parameters_repr",
+            "execution_date",
+            "execution_price",
+            "execution_traded_shares",
+        )
+        extra_kwargs = {
+            "price": {"required": False},
+        }
+        fields = (
+            "id",
+            "shares",
+            "underlying_instrument",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument_refinitiv_identifier_code",
+            "underlying_instrument_instrument_type",
+            "underlying_instrument_exchange",
+            "order_type",
+            "comment",
+            "effective_weight",
+            "target_weight",
+            "weighting",
+            "order_proposal",
+            "order",
+            "effective_shares",
+            "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
+            "portfolio_currency",
+            "underlying_instrument_currency",
+            "has_warnings",
+            "desired_target_weight",
+            "daily_return",
+            "currency_fx_rate",
+            "price",
+            "execution_status",
+            "execution_instruction",
+            "execution_instruction_parameters",
+            "execution_comment",
+            "execution_instruction_parameters_repr",
+            "execution_date",
+            "execution_price",
+            "execution_traded_shares",
+            "_additional_resources",
+        )
+
+
+class OrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
+    company = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.filter(level=0),
+        required=False,
+        read_only=lambda view: not view.new_mode,
+        default=GetCompanyDefault(),
+    )
+    _company = CompanyRepresentationSerializer(source="company", required=False)
+
+    security = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.filter(is_security=True),
+        required=False,
+        read_only=lambda view: not view.new_mode,
+        default=GetSecurityDefault(),
+    )
+    _security = SecurityRepresentationSerializer(
+        source="security",
+        optional_get_parameters={"company": "parent"},
+        depends_on=[{"field": "company", "options": {}}],
+        required=False,
+        select_first_choice=True,
+    )
+    underlying_instrument = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.all(), label="Quote", read_only=lambda view: not view.new_mode
+    )
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
+        source="underlying_instrument",
+        optional_get_parameters={"security": "parent"},
+        depends_on=[{"field": "security", "options": {}}],
+        tree_config=BaseTreeGroupLevelOption(clear_filter=True, filter_key="parent"),
+        select_first_choice=True,
+    )
+
+    class Meta(OrderOrderProposalListModelSerializer.Meta):
+        fields = list(OrderOrderProposalListModelSerializer.Meta.fields) + [
+            "company",
+            "_company",
+            "security",
+            "_security",
+            "_underlying_instrument",
+        ]
+
+
+class ReadOnlyOrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
+    class Meta(OrderOrderProposalListModelSerializer.Meta):
+        read_only_fields = OrderOrderProposalListModelSerializer.Meta.fields

wbportfolio/serializers/portfolios.py

@@ -34,10 +34,10 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
 
     last_asset_under_management_usd = wb_serializers.FloatField(read_only=True)
     last_positions = wb_serializers.FloatField(read_only=True)
-    last_trade_proposal_date = wb_serializers.DateField(read_only=True)
-    next_expected_trade_proposal_date = wb_serializers.SerializerMethodField(read_only=True)
+    last_order_proposal_date = wb_serializers.DateField(read_only=True)
+    next_expected_order_proposal_date = wb_serializers.SerializerMethodField(read_only=True)
 
-    def get_next_expected_trade_proposal_date(self, obj):
+    def get_next_expected_order_proposal_date(self, obj):
         if (automatic_rebalancer := getattr(obj, "automatic_rebalancer", None)) and (
             _d := automatic_rebalancer.get_next_rebalancing_date(date.today())
         ):
@@ -107,8 +107,8 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             args=[instance.id],
             request=request,
         )
-        additional_resources["trade_proposals"] = reverse(
-            "wbportfolio:portfolio-tradeproposal-list",
+        additional_resources["order_proposals"] = reverse(
+            "wbportfolio:portfolio-orderproposal-list",
             args=[instance.id],
             request=request,
         )
@@ -169,8 +169,8 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "last_position_date",
             "last_asset_under_management_usd",
             "last_positions",
-            "last_trade_proposal_date",
-            "next_expected_trade_proposal_date",
+            "last_order_proposal_date",
+            "next_expected_order_proposal_date",
         )
 
 

wbportfolio/serializers/positions.py

@@ -11,8 +11,8 @@ class AggregatedAssetPositionModelSerializer(wb_serializers.ModelSerializer):
     sum_total_value = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=4)
     weighting = wb_serializers.DecimalField(
         read_only=True,
-        max_digits=6,
-        decimal_places=4,
+        max_digits=9,
+        decimal_places=8,
         percent=True,
         decorators=[{"position": "right", "value": "%"}],
     )