wbportfolio 1.44.1__tar.gz → 1.44.3__tar.gz

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/PKG-INFO

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

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/analysis/claims.py

@@ -3,7 +3,8 @@ from typing import TYPE_CHECKING
 import numpy as np
 import pandas as pd
 from django.db import connection
-from django.db.models import DecimalField, ExpressionWrapper, F, OuterRef, Subquery
+from django.db.models import DecimalField, ExpressionWrapper, F, OuterRef, Subquery, DateField
+from django.db.models.functions import Greatest
 from django.template.loader import get_template
 from jinjasql import JinjaSql
 from wbcore.contrib.currency.models import CurrencyFXRates
@@ -47,6 +48,7 @@ class ConsolidatedTradeSummary:
         pivot_label: str,
         classification_group: ClassificationGroup | None = None,
         classification_height: int = 0,
+        date_label: str = "date_considered",
     ):
         self.queryset = queryset.filter(trade__isnull=False, status="APPROVED")
         self.start_date = start_date
@@ -60,6 +62,9 @@ class ConsolidatedTradeSummary:
             fx_rate=CurrencyFXRates.get_fx_rates_subquery("date", lookup_expr="exact"),
             aum=ExpressionWrapper(F("fx_rate") * F("net_value") * F("shares"), output_field=DecimalField()),
             internal_trade=F("trade__marked_as_internal"),
+            date_considered=ExpressionWrapper(
+                Greatest("trade__transaction_date", "date") + 1, output_field=DateField()
+            ),
         )
         self.queryset = Account.annotate_root_account_info(self.queryset)
 
@@ -71,17 +76,17 @@ class ConsolidatedTradeSummary:
             "account",
             "product__parent",
         )
-        self.df = self._prepare_df()
+        self.df = self._prepare_df(date_label)
 
-    def _prepare_df(self) -> pd.DataFrame:
-        columns = ["shares", "date", "product__id", "aum", "internal_trade"]
+    def _prepare_df(self, date_label: str) -> pd.DataFrame:
+        columns = ["shares", date_label, "product__id", "aum", "internal_trade"]
         if self.pivot == "classification_id":
             columns.append("classifications")
         else:
             columns.append(self.pivot)
             columns.append(self.pivot_label)
 
-        df = pd.DataFrame(self.queryset.values_list(*columns), columns=columns)
+        df = pd.DataFrame(self.queryset.values_list(*columns), columns=columns).rename(columns={date_label: "date"})
         if self.pivot == "classification_id":
             df = (
                 df.explode("classifications")
@@ -112,7 +117,7 @@ class ConsolidatedTradeSummary:
                     "net_value",
                     date_name="net_value_date_start",
                     instrument_pk_name="pk",
-                    date_lookup="exact"
+                    date_lookup="exact",
                     # we get all net value (even estimated) to avoir showing None price on holiday
                 ),
                 fx_rate_start=CurrencyFXRates.get_fx_rates_subquery(
@@ -123,7 +128,7 @@ class ConsolidatedTradeSummary:
                     "net_value",
                     date_name="net_value_date_end",
                     instrument_pk_name="pk",
-                    date_lookup="exact"
+                    date_lookup="exact",
                     # we get all net value (even estimated) to avoir showing None price on holiday
                 ),
                 fx_rate_end=CurrencyFXRates.get_fx_rates_subquery(

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/filters/products.py

@@ -22,7 +22,7 @@ class BaseProductFilterSet(InstrumentFilterSet):
         label="Bank",
         queryset=Company.objects.all(),
         endpoint=Company.get_representation_endpoint(),
-        filter_params={"bank_product": True},
+        filter_params={"notnull_related_name": "issues_products"},
         value_key=Company.get_representation_value_key(),
         label_key=Company.get_representation_label_key(),
     )

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/filters/signals.py

@@ -3,32 +3,12 @@ from datetime import date
 from django.db.models import Exists, OuterRef
 from django.dispatch import receiver
 from wbcore import filters as wb_filters
-from wbcore.contrib.directory.filters import CompanyFilter
 from wbcore.signals.filters import add_filters
 from wbfdm.filters import BaseClassifiedInstrumentFilterSet, ClassificationFilter
 from wbfdm.models import InstrumentClassificationThroughModel
 from wbportfolio.models import AssetPosition, Portfolio
 
 
-@receiver(add_filters, sender=CompanyFilter)
-def add_bank_product_filter(sender, request=None, *args, **kwargs):
-    def method_bank(queryset, name, value):
-        if value is True:
-            return queryset.filter(issues_products__isnull=False).distinct()
-        elif value is False:
-            return queryset.filter(issues_products__isnull=True).distinct()
-        return queryset
-
-    return {
-        "bank_product": wb_filters.BooleanFilter(
-            field_name="bank_product",
-            label="Is a Bank",
-            help_text="Filter for companies that are a bank and serve as the custodian of a product in the PMS",
-            method=method_bank,
-        )
-    }
-
-
 @receiver(add_filters, sender=ClassificationFilter)
 def add_portfolio_filter(sender, request=None, *args, **kwargs):
     def _filter_portfolio(queryset, name, value):

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/filters/transactions/__init__.py

@@ -3,6 +3,7 @@ from .claim import (
     ClaimGroupByFilter,
     ConsolidatedTradeSummaryTableFilterSet,
     CumulativeNNMChartFilter,
+    DistributionNNMChartFilter,
     CustomerAPIFilter,
     CustomerClaimFilter,
     CustomerClaimGroupByFilter,

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/filters/transactions/claim.py

@@ -7,6 +7,7 @@ from wbcore.utils.date import current_financial_quarter
 from wbcrm.models.accounts import Account, AccountRole
 from wbfdm.models import Classification, ClassificationGroup
 from wbfdm.preferences import get_default_classification_group
+from wbportfolio.filters.transactions.mixins import OppositeSharesFieldMethodMixin
 from wbportfolio.models import Product, ProductGroup
 from wbportfolio.models.transactions.claim import Claim, ClaimGroupbyChoice
 from wbportfolio.preferences import get_monthly_nnm_target
@@ -81,7 +82,6 @@ class CommissionBaseFilterSet(wb_filters.FilterSet):
         endpoint=Account.get_representation_endpoint(),
         value_key=Account.get_representation_value_key(),
         label_key=Account.get_representation_label_key(),
-        filter_params={"status": "OPEN"},
     )
 
     manager_role = wb_filters.ModelChoiceFilter(
@@ -140,7 +140,23 @@ class CommissionBaseFilterSet(wb_filters.FilterSet):
         return queryset
 
 
-class ClaimFilter(CommissionBaseFilterSet):
+class ClaimFilter(OppositeSharesFieldMethodMixin, CommissionBaseFilterSet):
+    # we have to redefine the mixin fields because django_filters does not allow class extension with mixin
+    opposite_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Shares",
+        method="filter_opposite_shares",
+        lookup_icon="±",
+        lookup_label="Opposite",
+    )
+    opposite_approximate_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Approximite Shares",
+        method="filter_opposite_approximate_shares",
+        lookup_icon="≈±",
+        lookup_label="Opposite Approximate (+- 10%)",
+    )
+
     pending_approval = wb_filters.BooleanFilter(label="Pending Approval", method="boolean_pending_approval")
     linked_trade = wb_filters.BooleanFilter(method="filter_trade_isnotnull", label="Trade Linked")
     in_charge_of_customer = wb_filters.ModelChoiceFilter(
@@ -188,7 +204,7 @@ class ClaimFilter(CommissionBaseFilterSet):
         }
 
 
-class ClaimGroupByFilter(ClaimFilter):
+class ClaimGroupByFilter(CommissionBaseFilterSet):
     pending_approval = in_charge_of_customer = linked_trade = None
 
     only_new_customer = wb_filters.BooleanFilter(method="filter_only_new_customer", label="Only new customers")
@@ -286,6 +302,19 @@ class ConsolidatedTradeSummaryTableFilterSet(PandasFilterSetMixin, ClaimGroupByF
         }
 
 
+class DistributionNNMChartFilter(ClaimGroupByFilter):
+    percent = wb_filters.BooleanFilter(
+        method="fake_filter",
+        default=False,
+        help_text="True if the value are displayed in percentage of the initial total AUM",
+        label="Show percentage",
+    )
+
+    class Meta:
+        model = Claim
+        fields = {}
+
+
 class CumulativeNNMChartFilter(ClaimGroupByFilter):
     groupby_classification_group = group_by = None
 

wbportfolio-1.44.3/wbportfolio/filters/transactions/mixins.py

@@ -0,0 +1,12 @@
+class OppositeSharesFieldMethodMixin:
+    def filter_opposite_shares(self, queryset, name, value):
+        return queryset.filter(shares=value * -1)
+
+    def filter_opposite_approximate_shares(self, queryset, name, value):
+        value = float(value)
+        value_lower_bound = -0.9 * value
+        value_higher_bound = -1.1 * value
+
+        if value > 0:
+            return queryset.filter(shares__lte=value_lower_bound, shares__gte=value_higher_bound)
+        return queryset.filter(shares__lte=value_higher_bound, shares__gte=value_lower_bound)

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/filters/transactions/trades.py

@@ -6,11 +6,27 @@ from wbcrm.models.accounts import Account
 from wbfdm.models import Instrument
 from wbportfolio.models import Product, Trade
 from wbportfolio.models.transactions.claim import Claim
+from .mixins import OppositeSharesFieldMethodMixin
 
 from .transactions import TransactionFilterSet
 
 
-class TradeFilter(TransactionFilterSet):
+class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
+    # we have to redefine the mixin fields because django_filters does not allow class extension with mixin
+    opposite_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Shares",
+        method="filter_opposite_shares",
+        lookup_icon="±",
+        lookup_label="Opposite",
+    )
+    opposite_approximate_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Approximite Shares",
+        method="filter_opposite_approximate_shares",
+        lookup_icon="≈±",
+        lookup_label="Opposite Approximate (+- 10%)",
+    )
     transaction_date = wb_filters.DateRangeFilter(
         method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
@@ -159,34 +175,6 @@ class SubscriptionRedemptionFilterSet(TradeFilter):
         label_key=Product.get_representation_label_key(),
     )
 
-    opposite_shares = wb_filters.NumberFilter(
-        field_name="shares",
-        label="Opposite Shares",
-        method="filter_opposite_shares",
-        lookup_icon="±",
-        lookup_label="Opposite",
-    )
-
-    def filter_opposite_shares(self, queryset, name, value):
-        return queryset.filter(shares=value * -1)
-
-    opposite_approximate_shares = wb_filters.NumberFilter(
-        field_name="shares",
-        label="Opposite Approximite Shares",
-        method="filter_opposite_approximate_shares",
-        lookup_icon="≈±",
-        lookup_label="Opposite Approximate (+- 10%)",
-    )
-
-    def filter_opposite_approximate_shares(self, queryset, name, value):
-        value = float(value)
-        value_lower_bound = -0.9 * value
-        value_higher_bound = -1.1 * value
-
-        if value > 0:
-            return queryset.filter(shares__lte=value_lower_bound, shares__gte=value_higher_bound)
-        return queryset.filter(shares__lte=value_higher_bound, shares__gte=value_lower_bound)
-
     class Meta:
         model = Trade
         fields = {

wbportfolio-1.44.3/wbportfolio/migrations/0072_trade_diff_shares.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.0.10 on 2025-01-28 10:17
+
+import django.db.models.expressions
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0071_alter_trade_options_alter_trade_order'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='trade',
+            name='diff_shares',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('shares'), '-', models.F('claimed_shares')), output_field=models.DecimalField(decimal_places=4, max_digits=15)),
+        ),
+    ]

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/models/asset.py

@@ -416,12 +416,15 @@ class AssetPosition(ImportMixin, models.Model):
                         net_value *= self.currency.convert(
                             self.asset_valuation_date, self.underlying_instrument.currency
                         )
-                    self.underlying_instrument_price = InstrumentPrice.objects.create(
+                    self.underlying_instrument_price = InstrumentPrice(
                         calculated=False,
                         instrument=self.underlying_instrument,
                         date=self.asset_valuation_date,
                         net_value=net_value,
+                        import_source=self.import_source,  # we set the import source to know where this price is coming from
                     )
+                    self.underlying_instrument_price.fill_market_capitalization()
+                    self.underlying_instrument_price.save()
                 else:  # sometime, the asset valuation date does not correspond to a valid market date. In that case, we get the latest valid instrument price for that product
                     self.underlying_instrument_price = (
                         InstrumentPrice.objects.filter(

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/models/portfolio.py

@@ -25,6 +25,7 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 from psycopg.types.range import DateRange
 from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbcore.utils.models import ActiveObjectManager, DeleteToDisableMixin
 from wbfdm.contrib.metric.dispatch import compute_metrics
@@ -232,7 +233,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         verbose_name_plural = "Portfolios"
 
         notification_types = [
-            (
+            create_notification_type(
                 "wbportfolio.portfolio.check_custodian_portfolio",
                 "Check Custodian Portfolio",
                 "Sends a notification when a portfolio does not match with its custodian portfolio",

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/models/portfolio_cash_flow.py

@@ -3,6 +3,7 @@ from decimal import Decimal
 
 from django.db import models
 from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbportfolio.import_export.handlers.portfolio_cash_flow import (
     DailyPortfolioCashFlowImportHandler,
@@ -132,7 +133,7 @@ class DailyPortfolioCashFlow(ImportMixin, WBModel):
         ]
         permissions = [("administrate_dailyportfoliocashflow", "Can administrate Daily Portfolio CashFlow")]
         notification_types = [
-            (
+            create_notification_type(
                 "wbportfolio.dailyportfoliocashflow.notify_rebalance",
                 "Rebalancing suggested",
                 "Sends a notification, when the system suggests to rebalance a portfolio due to being outside of the cash target parameters",
@@ -140,7 +141,7 @@ class DailyPortfolioCashFlow(ImportMixin, WBModel):
                 True,
                 False,
             ),
-            (
+            create_notification_type(
                 "wbportfolio.dailyportfoliocashflow.notify_swingpricing",
                 "Swing Pricing Notification",
                 "Sends a notification, when the system detects a future swing pricing event",

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/models/transactions/trades.py

@@ -21,7 +21,7 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
 from django_fsm import GET_STATE, FSMField, transition
-from ordered_model.models import OrderedModel, OrderedModelManager
+from ordered_model.models import OrderedModel, OrderedModelManager, OrderedModelQuerySet
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
@@ -37,58 +37,65 @@ from wbportfolio.pms.typing import Trade as TradeDTO
 from .transactions import ShareMixin, Transaction
 
 
-class DefaultTradeManager(OrderedModelManager):
-    """This manager is expect to be the trade default manager and annotate by default the effective weight (extracted
-    from the associated portfolio) and the target weight as an addition between the effective weight and the delta weight
-    """
-
-    def get_queryset(self):
-        return (
-            super()
-            .get_queryset()
-            .annotate(
-                last_effective_date=Subquery(
+class TradeQueryset(OrderedModelQuerySet):
+    def annotate_base_info(self):
+        return self.annotate(
+            last_effective_date=Subquery(
+                AssetPosition.objects.filter(
+                    underlying_instrument=OuterRef("underlying_instrument"),
+                    date__lt=OuterRef("transaction_date"),
+                    portfolio=OuterRef("portfolio"),
+                )
+                .order_by("-date")
+                .values("date")[:1]
+            ),
+            effective_weight=Coalesce(
+                Subquery(
                     AssetPosition.objects.filter(
                         underlying_instrument=OuterRef("underlying_instrument"),
-                        date__lt=OuterRef("transaction_date"),
+                        date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
                     )
-                    .order_by("-date")
-                    .values("date")[:1]
-                ),
-                effective_weight=Coalesce(
-                    Subquery(
-                        AssetPosition.objects.filter(
-                            underlying_instrument=OuterRef("underlying_instrument"),
-                            date=OuterRef("last_effective_date"),
-                            portfolio=OuterRef("portfolio"),
-                        )
-                        .values("portfolio")
-                        .annotate(s=Sum("weighting"))
-                        .values("s")[:1]
-                    ),
-                    Decimal(0),
+                    .values("portfolio")
+                    .annotate(s=Sum("weighting"))
+                    .values("s")[:1]
                 ),
-                target_weight=F("effective_weight") + F("weighting"),
-                effective_shares=Coalesce(
-                    Subquery(
-                        AssetPosition.objects.filter(
-                            underlying_instrument=OuterRef("underlying_instrument"),
-                            date=OuterRef("last_effective_date"),
-                            portfolio=OuterRef("portfolio"),
-                        )
-                        .values("portfolio")
-                        .annotate(s=Sum("shares"))
-                        .values("s")[:1]
-                    ),
-                    Decimal(0),
+                Decimal(0),
+            ),
+            target_weight=F("effective_weight") + F("weighting"),
+            effective_shares=Coalesce(
+                Subquery(
+                    AssetPosition.objects.filter(
+                        underlying_instrument=OuterRef("underlying_instrument"),
+                        date=OuterRef("last_effective_date"),
+                        portfolio=OuterRef("portfolio"),
+                    )
+                    .values("portfolio")
+                    .annotate(s=Sum("shares"))
+                    .values("s")[:1]
                 ),
-                target_shares=F("effective_weight") * F("weighting"),
-                diff_shares=F("shares") - F("claimed_shares"),
-            )
+                Decimal(0),
+            ),
+            target_shares=F("effective_weight") * F("weighting"),
         )
 
 
+class DefaultTradeManager(OrderedModelManager):
+    """This manager is expect to be the trade default manager and annotate by default the effective weight (extracted
+    from the associated portfolio) and the target weight as an addition between the effective weight and the delta weight
+    """
+
+    def __init__(self, with_annotation: bool = False, *args, **kwargs):
+        self.with_annotation = with_annotation
+        super().__init__(*args, **kwargs)
+
+    def get_queryset(self) -> TradeQueryset:
+        qs = TradeQueryset(self.model, using=self._db)
+        if self.with_annotation:
+            qs = qs.annotate_base_info()
+        return qs
+
+
 class ValidCustomerTradeManager(DefaultTradeManager):
     def __init__(self, without_internal_trade: bool = False):
         self.without_internal_trade = without_internal_trade
@@ -202,7 +209,13 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         help_text="The number of shares that were claimed.",
         verbose_name="Claimed Shares",
     )
+    diff_shares = models.GeneratedField(
+        expression=F("shares") - F("claimed_shares"),
+        output_field=models.DecimalField(max_digits=15, decimal_places=4),
+        db_persist=True,
+    )
     objects = DefaultTradeManager()
+    annotated_objects = DefaultTradeManager(with_annotation=True)
     valid_customer_trade_objects = ValidCustomerTradeManager()
     valid_external_customer_trade_objects = ValidCustomerTradeManager(without_internal_trade=True)
 
@@ -436,13 +449,6 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     def _target_shares(self) -> Decimal:
         return getattr(self, "target_shares", self._effective_shares * self.weighting)
 
-    @cached_property
-    @admin.display(description="Diff Claims")
-    def _diff_shares(self) -> Decimal:
-        if hasattr(self, "diff_shares"):
-            return self.diff_shares
-        return self.shares - self.claimed_shares
-
     order_with_respect_to = "trade_proposal"
 
     class Meta(OrderedModel.Meta):

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/risk_management/tests/test_accounts.py

@@ -51,46 +51,58 @@ class TestAccountRuleModel:
         account = account_factory.create(owner=entry)
         other_account = account_factory.create()
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval + 2)).date(),
+            date=(weekday - BDay(business_days_interval + 3)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 3)).date()
+            ),
             status="APPROVED",
             shares=100,
         )
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval + 1)).date(),
+            date=(weekday - BDay(business_days_interval + 2)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 2)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop should not be detected
 
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval)).date(),
+            date=(weekday - BDay(business_days_interval + 1)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 1)).date()
+            ),
             status="APPROVED",
             shares=150,
         )
         claim_factory.create(
-            date=weekday,
+            date=(weekday - BDay(1)).date(),
             account=account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(1)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop should be detected
 
         claim_factory.create(
-            date=(weekday - BDay(business_days_interval)).date(),
+            date=(weekday - BDay(business_days_interval + 1)).date(),
             account=other_account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(business_days_interval + 1)).date()
+            ),
             status="APPROVED",
             shares=150,
         )
         claim_factory.create(
-            date=weekday,
+            date=(weekday - BDay(1)).date(),
             account=other_account,
-            trade=customer_trade_factory.create(underlying_instrument=product),
+            trade=customer_trade_factory.create(
+                underlying_instrument=product, transaction_date=(weekday - BDay(1)).date()
+            ),
             status="APPROVED",
             shares=-50,
         )  # this drop is valid but an another account so won't be detected

{wbportfolio-1.44.1 → wbportfolio-1.44.3}/wbportfolio/serializers/transactions/trades.py

@@ -45,11 +45,7 @@ class TradeProposalRepresentationSerializer(wb_serializers.RepresentationSeriali
 
 class TradeRepresentationSerializer(TransactionRepresentationSerializer):
     _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:trade-detail")
-
-    diff_shares = wb_serializers.SerializerMethodField()
-
-    def get_diff_shares(self, obj):
-        return obj._diff_shares
+    diff_shares = wb_serializers.DecimalField(max_digits=15, decimal_places=4)
 
     class Meta:
         model = Trade
@@ -241,7 +237,7 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
         percent_fields = ["effective_weight", "target_weight", "weighting"]
         read_only_fields = (
             "transaction_subtype",
-            "shares"
+            "shares",
             # "underlying_instrument",
             # "_underlying_instrument",
         )