wbportfolio 1.55.9__py2.py3-none-any.whl → 1.56.0__py2.py3-none-any.whl

wbportfolio/models/transactions/trades.py

@@ -194,6 +194,7 @@ class Trade(TransactionMixin, ImportMixin, models.Model):
         # notification_email_template = "portfolio/email/trade_notification.html"
 
     def save(self, *args, **kwargs):
+        self.pre_save()
         if abs(self.weighting) < 10e-6:
             self.weighting = Decimal("0")
         if not self.price:

wbportfolio/models/transactions/transactions.py

@@ -71,6 +71,22 @@ class TransactionMixin(models.Model):
         ),
         db_persist=True,
     )
+    price_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
+    price_gross_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price_gross"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
     total_value_fx_portfolio = models.GeneratedField(
         expression=models.F("currency_fx_rate") * models.F("price") * models.F("shares"),
         output_field=models.DecimalField(
@@ -100,14 +116,10 @@ class TransactionMixin(models.Model):
             self.price_gross = self.price
         elif self.price_gross is not None and self.price is None:
             self.price = self.price_gross
-
-    def save(self, *args, **kwargs):
-        self.pre_save()
         if self.currency_fx_rate is None:
             self.currency_fx_rate = self.underlying_instrument.currency.convert(
                 self.value_date, self.portfolio.currency, exact_lookup=True
             )
-        super().save(*args, **kwargs)
 
     class Meta:
         abstract = True

wbportfolio/pms/typing.py

@@ -269,7 +269,7 @@ class TradeBatch:
 
     def convert_to_portfolio(self, use_effective: bool = False, *extra_positions):
         positions = []
-        for instrument, trade in self.trades_map.items():
+        for trade in self.trades_map.values():
             positions.append(
                 Position(
                     underlying_instrument=trade.underlying_instrument,

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -108,11 +108,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
                 return df.any()
             else:
                 if missing_exchanges.exists():
-                    setattr(
-                        self,
-                        "_validation_errors",
-                        f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}",
-                    )
+                    self._validation_errors = f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}"
                 return df.all()
         return False
 

wbportfolio/risk_management/backends/controversy_portfolio.py

@@ -44,7 +44,7 @@ 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)
             if (
                 controversies := Controversy.objects.filter(

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -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,7 +64,7 @@ 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)
 

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/orders/orders.py

@@ -44,29 +44,26 @@ 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)
     has_warnings = wb_serializers.BooleanField(read_only=True)
@@ -81,17 +78,57 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
                 }
             )
         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") or data.get("target_weight"):
+            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") or data.get("target_shares"):
+            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
+
     class Meta:
         model = Order
         percent_fields = ["effective_weight", "target_weight", "weighting"]
@@ -108,12 +145,8 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
         }
         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",
         )
         fields = (

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/tests/models/orders/test_order_proposals.py

@@ -500,17 +500,25 @@ class TestOrderProposal:
         instrument.exchange.save()
         assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument_factory):
+    @patch.object(Portfolio, "get_total_asset_value")
+    def test_submit_round_lot_size(self, mock_fct, order_proposal, instrument_price_factory, order_factory):
+        initial_shares = Decimal("70")
+        price = instrument_price_factory.create(date=order_proposal.trade_date)
+        net_value = round(price.net_value, 4)
+        portfolio_value = initial_shares * net_value
+        mock_fct.return_value = portfolio_value
+
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
-        instrument = instrument_factory.create()
+        instrument = price.instrument
         instrument.round_lot_size = 100
         instrument.save()
         trade = order_factory.create(
-            underlying_instrument=instrument,
-            shares=70,
+            shares=initial_shares,
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
+            underlying_instrument=price.instrument,
+            price=net_value,
         )
         warnings = order_proposal.submit()
         order_proposal.save()
@@ -520,18 +528,31 @@ class TestOrderProposal:
         trade.refresh_from_db()
         assert trade.shares == 100  # we expect the share to be transformed from 70 to 100 (lot size of 100)
 
-    def test_submit_round_fractional_shares(self, order_proposal, order_factory):
+    @patch.object(Portfolio, "get_total_asset_value")
+    def test_submit_round_fractional_shares(self, mock_fct, instrument_price_factory, order_proposal, order_factory):
+        initial_shares = Decimal("5.6")
+        price = instrument_price_factory.create(date=order_proposal.trade_date)
+        net_value = round(price.net_value, 4)
+        portfolio_value = initial_shares * net_value
+        mock_fct.return_value = portfolio_value
+
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
         trade = order_factory.create(
-            shares=5.6,
+            shares=Decimal("5.6"),
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
+            underlying_instrument=price.instrument,
+            price=net_value,
         )
         order_proposal.submit()
         order_proposal.save()
         trade.refresh_from_db()
         assert trade.shares == 6  # we expect the fractional share to be rounded
+        assert trade.weighting == round((trade.shares * net_value) / portfolio_value, 8)
+        assert trade.weighting == round(
+            Decimal("1") + ((Decimal("6") - initial_shares) * net_value) / portfolio_value, 8
+        )  # we expect the weighting to be updated accrodingly
 
     def test_ex_post(
         self, instrument_factory, asset_position_factory, instrument_price_factory, order_proposal_factory, portfolio
@@ -719,7 +740,6 @@ class TestOrderProposal:
         order_proposal.approve()
         order_proposal.apply()
         order_proposal.save()
-
         assert order_proposal.portfolio.assets.get(
             date=order_proposal.trade_date, underlying_quote=o1.underlying_instrument
         ).weighting == Decimal("0.8")

wbportfolio/tests/models/test_portfolios.py

@@ -924,13 +924,13 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
         assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
-        expected_X = pd.DataFrame(
+        expected_x = pd.DataFrame(
             [[float(p11.net_value / p10.net_value - Decimal(1)), float(p21.net_value / p20.net_value - Decimal(1))]],
             columns=[i1.id, i2.id],
             index=[(weekday + BDay(1)).date()],
         )
-        expected_X.index = pd.to_datetime(expected_X.index)
-        pd.testing.assert_frame_equal(analytic_portfolio.X, expected_X, check_names=False, check_freq=False)
+        expected_x.index = pd.to_datetime(expected_x.index)
+        pd.testing.assert_frame_equal(analytic_portfolio.X, expected_x, check_names=False, check_freq=False)
 
     def test_get_total_asset_value(self, weekday, portfolio, asset_position_factory):
         a1 = asset_position_factory.create(date=weekday, portfolio=portfolio)
@@ -1010,7 +1010,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert len(res) == 1
         assert a.date == weekday
         assert a.underlying_quote == instrument
-        assert a.underlying_quote_price == None
+        assert a.underlying_quote_price is None
         assert a.initial_price == p.net_value
         assert a.weighting == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
@@ -1053,7 +1053,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert next(gen)[0] == middle_date, "Drifting weight with a non automatic rebalancer stops the iteration"
         try:
             next(gen)
-            assert False, "the next iteration should stop and return the rebalancing"
+            raise AssertionError("the next iteration should stop and return the rebalancing")
         except StopIteration as e:
             rebalancing_order_proposal = e.value
             assert rebalancing_order_proposal.trade_date == rebalancing_date

wbportfolio/tests/models/test_splits.py

@@ -14,10 +14,6 @@ fake = Faker()
 
 @pytest.mark.django_db
 class TestAdjustmentModel:
-    @pytest.fixture()
-    def applied_adjustment(self):
-        return AdjustmentFactory.create(status=Adjustment.Status.APPLIED)
-
     @pytest.fixture()
     def old_adjustment(self):
         return AdjustmentFactory.create(status=Adjustment.Status.PENDING, date=fake.past_date())
@@ -205,7 +201,7 @@ class TestAdjustmentModel:
         post_adjustment_on_prices(adjustment.id)
         a1.refresh_from_db()
         adjustment.refresh_from_db()
-        a1.applied_adjustment == adjustment
+        assert a1.applied_adjustment == adjustment
         assert adjustment.status == Adjustment.Status.APPLIED
 
     @patch("wbportfolio.models.adjustments.send_notification")
@@ -230,5 +226,4 @@ class TestAdjustmentModel:
         mock_check_fct.return_value = False
         post_adjustment_on_prices(adjustment.id)
         adjustment.refresh_from_db()
-        mock_delay_fct.call_args[0] == user_porftolio_manager.id
         assert adjustment.status == Adjustment.Status.PENDING

wbportfolio/tests/viewsets/test_products.py

@@ -23,6 +23,7 @@ class TestProductModelViewSet:
             portfolio_factory.create_batch(4, invested_timespan=DateRange(date.min, date.max))
             + portfolio_factory.create_batch(2, invested_timespan=DateRange(date.min, date.max)),
             product_factory.create_batch(6),
+            strict=False,
         ):
             InstrumentPortfolioThroughModel.objects.update_or_create(
                 instrument=product, defaults={"portfolio": portfolio}

wbportfolio/viewsets/charts/assets.py

@@ -101,7 +101,9 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
             columns = {}
             level_representations = self.classification_group.get_levels_representation()
             for key, label in zip(
-                reversed(self.classification_group.get_fields_names(sep="_")), reversed(level_representations[1:])
+                reversed(self.classification_group.get_fields_names(sep="_")),
+                reversed(level_representations[1:]),
+                strict=False,
             ):
                 columns[key] = label
             columns["label"] = "Classification"
@@ -158,6 +160,7 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
         return df.reset_index(names="id")
 
     def manipulate_dataframe(self, df):
+        df["id"] = df["id"].fillna(-1)
         if self.group_by == AssetPositionGroupBy.INDUSTRY:
             if not PortfolioRole.is_analyst(self.request.user.profile, portfolio=self.portfolio):
                 df["equity"] = ""
@@ -169,8 +172,8 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
                 dict(Classification.objects.filter(id__in=df["classification"].dropna()).values_list("id", "name"))
             )
         elif self.group_by == AssetPositionGroupBy.CASH:
-            df.loc[df["id"] == True, "label"] = "Cash"
-            df.loc[df["id"] == False, "label"] = "Non-Cash"
+            df.loc[df["id"], "label"] = "Cash"
+            df.loc[~df["id"], "label"] = "Non-Cash"
         elif self.group_by == AssetPositionGroupBy.COUNTRY:
             df["label"] = df["id"].map(dict(Geography.objects.filter(id__in=df["id"]).values_list("id", "name")))
         elif self.group_by == AssetPositionGroupBy.CURRENCY:
@@ -180,6 +183,7 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
             df["label"] = df["id"].map(
                 dict(InstrumentType.objects.filter(id__in=df["id"]).values_list("id", "short_name"))
             )
+        df.loc[df["id"] == -1, "label"] = "N/A"
         df.sort_values(by="weighting", ascending=False, inplace=True)
         return df
 
@@ -307,7 +311,7 @@ class ContributorPortfolioChartView(UserPortfolioRequestPermissionMixin, viewset
 
             text_forex = df_forex.contribution_forex.apply(lambda x: f"{x:,.2%}")
             text_equity = contribution_equity.apply(lambda x: f"{x:,.2%}")
-            setattr(self, "nb_rows", df.shape[0])
+            self.nb_rows = df.shape[0]
             fig.add_trace(
                 go.Bar(
                     y=df.instrument_id,

wbportfolio/viewsets/configs/buttons/mixins.py

@@ -7,7 +7,7 @@ from wbfdm.models.instruments import Instrument
 
 class InstrumentButtonMixin:
     @classmethod
-    def add_instrument_request_button(self, request=None, view=None, pk=None, **kwargs):
+    def add_instrument_request_button(cls, request=None, view=None, pk=None, **kwargs):
         buttons = [
             bt.WidgetButton(key="assets", label="Implemented Portfolios (Assets)"),
             # bt.WidgetButton(
@@ -44,7 +44,7 @@ class InstrumentButtonMixin:
         )
 
     @classmethod
-    def add_transactions_request_button(self, request=None, view=None, pk=None, **kwargs):
+    def add_transactions_request_button(cls, request=None, view=None, pk=None, **kwargs):
         return bt.DropDownButton(
             label="Transactions",
             icon=WBIcon.UNFOLD.icon,

wbportfolio/viewsets/configs/display/reconciliations.py

@@ -49,14 +49,14 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
         ]
         editable = [dp.FormattingRule(style={"fontWeight": "bold"})]
         equal = [dp.FormattingRule(condition=("==", False, "is_equal"), style={"backgroundColor": "orange"})]
-        borderLeft = [
+        border_left = [
             dp.FormattingRule(
                 style={
                     "borderLeft": "1px solid #bdc3c7",
                 }
             )
         ]
-        borderRight = [
+        border_right = [
             dp.FormattingRule(
                 style={
                     "borderRight": "1px solid #bdc3c7",
@@ -111,7 +111,7 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
                             key="shares_external",
                             label="Shares",
                             width=90,
-                            formatting_rules=[*equal, *editable, *borderLeft],
+                            formatting_rules=[*equal, *editable, *border_left],
                         ),
                         dp.Field(
                             key="nominal_value_external",
@@ -128,7 +128,7 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
                             key="assets_under_management_external",
                             label="AuM",
                             width=120,
-                            formatting_rules=[*equal, *borderRight],
+                            formatting_rules=[*equal, *border_right],
                         ),
                     ],
                 ),

wbportfolio/viewsets/orders/orders.py

@@ -173,9 +173,27 @@ class OrderOrderProposalModelViewSet(
     def get_serializer_class(self):
         if self.order_proposal.status != OrderProposal.Status.DRAFT:
             return ReadOnlyOrderOrderProposalModelSerializer
-        elif not self.new_mode and "pk" not in self.kwargs:
-            return OrderOrderProposalListModelSerializer
-        return OrderOrderProposalModelSerializer
+        if not self.new_mode and "pk" not in self.kwargs:
+            serializer_base_class = OrderOrderProposalListModelSerializer
+        else:
+            serializer_base_class = OrderOrderProposalModelSerializer
+        if not self.order_proposal.portfolio_total_asset_value:
+
+            class OnlyWeightSerializerClass(serializer_base_class):
+                class Meta(serializer_base_class.Meta):
+                    read_only_fields = (
+                        "order_type",
+                        "effective_shares",
+                        "effective_total_value_fx_portfolio",
+                        "has_warnings",
+                        "shares",
+                        "target_shares",
+                        "total_value_fx_portfolio",
+                        "target_total_value_fx_portfolio",
+                    )
+
+            return OnlyWeightSerializerClass
+        return serializer_base_class
 
     def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
         if self.orders.exists() and self.order_proposal.status in [
@@ -214,7 +232,7 @@ class OrderOrderProposalModelViewSet(
                 default=F("underlying_instrument__instrument_type__short_name"),
             ),
             underlying_instrument_exchange=F("underlying_instrument__exchange__name"),
-            effective_total_value_fx_portfolio=F("previous_weight") * Value(self.portfolio_total_asset_value),
+            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"),
             security=F("underlying_instrument__parent"),

{wbportfolio-1.55.9.dist-info → wbportfolio-1.56.0.dist-info}/METADATA

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