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

wbportfolio/serializers/orders/order_proposals.py

@@ -64,12 +64,15 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     @wb_serializers.register_only_instance_resource()
     def additional_resources(self, instance, request, user, **kwargs):
         res = {}
-        if instance.status == OrderProposal.Status.APPLIED:
+        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)
-            res["deleteall"] = reverse("wbportfolio:orderproposal-deleteall", 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],
@@ -90,6 +93,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
             "comment",
             "status",
             "min_order_value",
+            "min_weighting",
             "_rebalancing_model",
             "rebalancing_model",
             "target_portfolio",

wbportfolio/serializers/orders/orders.py

@@ -1,6 +1,8 @@
 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
@@ -10,7 +12,7 @@ from wbfdm.serializers.instruments.instruments import (
     SecurityRepresentationSerializer,
 )
 
-from wbportfolio.models import Order
+from wbportfolio.models import Order, OrderProposal
 
 
 class GetSecurityDefault:
@@ -44,32 +46,50 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
     underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
     underlying_instrument_exchange = wb_serializers.CharField(read_only=True)
 
-    target_weight = wb_serializers.DecimalField(
+    effective_weight = wb_serializers.DecimalField(
+        read_only=True,
         max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
         decimal_places=Order.ORDER_WEIGHTING_PRECISION,
-        required=False,
         default=0,
     )
-    effective_weight = wb_serializers.DecimalField(
-        read_only=True,
+    target_weight = wb_serializers.DecimalField(
         max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
         decimal_places=Order.ORDER_WEIGHTING_PRECISION,
-        default=0,
+        required=False,
     )
 
     effective_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
-    target_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)
 
-    total_value_fx_portfolio = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=2, default=0)
     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(
-        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)
@@ -80,21 +100,71 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
                     "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)
-        weighting = data.get("weighting", self.instance.weighting if self.instance else Decimal(0.0))
-        if (target_weight := data.pop("target_weight", None)) is not None:
-            weighting = target_weight - effective_weight
-            data["desired_target_weight"] = target_weight
-        if weighting >= 0:
-            data["order_type"] = "BUY"
-        else:
-            data["order_type"] = "SELL"
-        data["weighting"] = weighting
+        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"]
+        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}}"
@@ -105,17 +175,26 @@ 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",
-            "shares",
             "effective_shares",
-            "target_shares",
-            "total_value_fx_portfolio",
             "effective_total_value_fx_portfolio",
-            "target_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",
@@ -138,9 +217,21 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "effective_total_value_fx_portfolio",
             "target_total_value_fx_portfolio",
             "portfolio_currency",
+            "underlying_instrument_currency",
             "has_warnings",
-            "execution_confirmed",
+            "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",
         )
 
 
@@ -164,6 +255,7 @@ class OrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
         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
@@ -173,6 +265,7 @@ class OrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
         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):

wbportfolio/serializers/transactions/claim.py

@@ -49,8 +49,8 @@ class ClaimAPIModelSerializer(serializers.ModelSerializer):
             if "isin" in request.data:
                 try:
                     data["product"] = Product.objects.get(isin=request.data["isin"])
-                except Product.DoesNotExist:
-                    raise ValidationError({"isin": "A product with this ISIN does not exist."})
+                except Product.DoesNotExist as e:
+                    raise ValidationError({"isin": "A product with this ISIN does not exist."}) from e
         if trade := data.get("trade", None):
             if not trade.is_claimable:
                 raise ValidationError({"trade": "Only a claimable trade can be selected"})

wbportfolio/tasks.py

@@ -1,12 +1,12 @@
 from contextlib import suppress
 from datetime import date, timedelta
 
+from celery import shared_task
 from django.db.models import ProtectedError, Q
+from tqdm import tqdm
+from wbfdm.models import Controversy, Instrument
 
-from wbportfolio.models import Portfolio, Trade
-from wbportfolio.models.products import Product
-
-from .fdm.tasks import *  # noqa
+from wbportfolio.models import AssetPosition, Portfolio, Product, Trade
 
 
 @shared_task(queue="portfolio")
@@ -49,3 +49,41 @@ def update_preferred_classification_per_instrument_and_portfolio_as_task():
 # - propagate (or update) t-2 asset positions into t-1
 # - Synchronize wbportfolio at t-1
 # - Compute Instrument Price estimate at t-1
+
+
+@shared_task(queue="portfolio")
+def synchronize_portfolio_controversies():
+    active_portfolios = Portfolio.objects.filter_active_and_tracked()
+    qs = (
+        AssetPosition.objects.filter(portfolio__in=active_portfolios)
+        .values("underlying_instrument")
+        .distinct("underlying_instrument")
+    )
+    objs = {}
+    securities = Instrument.objects.filter(id__in=qs.values("underlying_instrument"))
+    securities_mapping = {security.id: security.get_root() for security in securities}
+    for controversy in securities.dl.esg_controversies():
+        instrument = securities_mapping[controversy["instrument_id"]]
+        obj = Controversy.dict_to_model(controversy, instrument)
+        objs[obj.external_id] = obj
+
+    Controversy.objects.bulk_create(
+        objs.values(),
+        update_fields=[
+            "instrument",
+            "headline",
+            "description",
+            "source",
+            "direct_involvement",
+            "company_response",
+            "review",
+            "initiated",
+            "flag",
+            "status",
+            "type",
+            "severity",
+        ],
+        unique_fields=["external_id"],
+        update_conflicts=True,
+        batch_size=10000,
+    )