wbportfolio 1.56.4__tar.gz → 1.56.6__tar.gz

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

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

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/contrib/company_portfolio/configs/display.py

@@ -67,9 +67,15 @@ class CompanyModelDisplay(BaseCompanyModelDisplay):
         list_display = super().get_list_display()
         list_display.fields = (
             *list_display.fields[:5],
-            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
-            dp.Field(key="asset_under_management", label="AUM"),
-            dp.Field(key="potential", label="Potential"),
+            dp.Field(
+                key=None,
+                label=_("AUM"),
+                children=[
+                    dp.Field(key="invested_assets_under_management_usd", label="AUM Invested", width=100),
+                    dp.Field(key="asset_under_management", label="AUM", width=100),
+                    dp.Field(key="potential", label="Potential", width=100),
+                ],
+            ),
             *list_display.fields[5:],
         )
         return list_display
@@ -140,9 +146,15 @@ class PersonModelDisplay(BasePersonModelDisplay):
 
         list_display.fields = (
             *list_display.fields[:7],
-            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
-            dp.Field(key="asset_under_management", label="AUM"),
-            dp.Field(key="potential", label="Potential"),
+            dp.Field(
+                key=None,
+                label=_("AUM"),
+                children=[
+                    dp.Field(key="invested_assets_under_management_usd", label="AUM Invested", width=100),
+                    dp.Field(key="asset_under_management", label="AUM", width=100),
+                    dp.Field(key="potential", label="Potential", width=100),
+                ],
+            ),
             *list_display.fields[7:],
         )
         return list_display

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/contrib/company_portfolio/models.py

@@ -3,6 +3,7 @@ from datetime import date
 from decimal import Decimal
 
 from django.conf import settings
+from django.core.cache import cache
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -16,7 +17,12 @@ from wbportfolio.models import Claim, Product
 
 
 def get_total_assets_under_management(val_date: date) -> Decimal:
-    return sum([product.get_total_aum_usd(val_date) for product in Product.active_objects.all()])
+    cache_key = f"total_assets_under_management:{val_date.isoformat()}"
+    return cache.get_or_set(
+        cache_key,
+        lambda: sum([product.get_total_aum_usd(val_date) for product in Product.active_objects.all()]),
+        60 * 60 * 24,
+    )
 
 
 def get_lost_client_customer_status():
@@ -44,9 +50,8 @@ class Updater:
         self.val_date = val_date
         self.total_assets_under_management = get_total_assets_under_management(val_date)
 
-    def update_company_data(self, company):
+    def update_company_data(self, company_portfolio_data) -> tuple[str, str]:
         # save company portfolio data
-        company_portfolio_data = CompanyPortfolioData.objects.get_or_create(company=company)[0]
         if (
             invested_assets_under_management_usd := company_portfolio_data.get_assets_under_management_usd(
                 self.val_date
@@ -55,19 +60,11 @@ class Updater:
             company_portfolio_data.invested_assets_under_management_usd = invested_assets_under_management_usd
         if (potential := company_portfolio_data.get_potential(self.val_date)) is not None:
             company_portfolio_data.potential = potential
-        company_portfolio_data.save()
 
         # update the company object itself
-        if (tier := company_portfolio_data.get_tiering(self.total_assets_under_management)) is not None:
-            company.tier = tier
-        company.customer_status = company_portfolio_data.get_customer_status()
-        company.save()
-
-    # def update_all_companies(self, val_date: date):
-    #     for company in tqdm(qs, total=qs.count()):
-    #         with suppress(CompanyPortfolioData.DoesNotExist):
-    #             company_portfolio = CompanyPortfolioData.objects.get(company=company)
-    #             company_portfolio.update_data(date.today())
+        tier = company_portfolio_data.get_tiering(self.total_assets_under_management)
+        customer_status = company_portfolio_data.get_customer_status()
+        return customer_status, tier
 
 
 class CompanyPortfolioData(models.Model):
@@ -104,14 +101,6 @@ class CompanyPortfolioData(models.Model):
         verbose_name="AUM",
         help_text="The Assets under Management (AUM) that is managed by this company or this person's primary employer.",
     )
-    invested_assets_under_management_usd = models.DecimalField(
-        max_digits=17,
-        decimal_places=2,
-        null=True,
-        blank=True,
-        help_text="The invested Assets under Management (AUM).",
-        verbose_name="Invested AUM ($)",
-    )
 
     investment_discretion = models.CharField(
         max_length=21,
@@ -120,10 +109,6 @@ class CompanyPortfolioData(models.Model):
         help_text="What discretion this company or this person's primary employer has to invest its assets.",
         verbose_name="Investment Discretion",
     )
-
-    potential = models.DecimalField(
-        decimal_places=2, max_digits=19, null=True, blank=True, help_text=potential_help_text
-    )
     potential_currency = models.ForeignKey(
         to="currency.Currency",
         related_name="wbportfolio_potential_currencies",
@@ -132,6 +117,25 @@ class CompanyPortfolioData(models.Model):
         on_delete=models.PROTECT,
     )
 
+    # Dynamic fields
+    invested_assets_under_management_usd = models.DecimalField(
+        max_digits=17,
+        decimal_places=2,
+        null=True,
+        blank=True,
+        help_text="The invested Assets under Management (AUM).",
+        verbose_name="Invested AUM ($)",
+    )
+
+    potential = models.DecimalField(
+        decimal_places=2, max_digits=19, null=True, blank=True, help_text=potential_help_text
+    )
+
+    def update(self):
+        with suppress(CurrencyFXRates.DoesNotExist):
+            val_date = CurrencyFXRates.objects.latest("date").date
+            self.company.customer_status, self.company.tier = Updater(val_date).update_company_data(self)
+
     def get_assets_under_management_usd(self, val_date: date) -> Decimal:
         return Claim.objects.filter(status=Claim.Status.APPROVED).filter_for_customer(
             self.company
@@ -140,16 +144,17 @@ class CompanyPortfolioData(models.Model):
         )["invested_aum_usd"] or Decimal(0)
 
     def _get_default_potential(self, val_date: date) -> Decimal:
-        with suppress(CurrencyFXRates.DoesNotExist):
-            fx = CurrencyFXRates.objects.get(currency=self.assets_under_management_currency, date=val_date).value
+        if self.assets_under_management:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                fx = CurrencyFXRates.objects.get(currency=self.assets_under_management_currency, date=val_date).value
 
-            aum_usd = self.assets_under_management / fx
-            aum_potential = Decimal(0)
-            for asset_allocation in self.company.asset_allocations.all():
-                aum_potential += aum_usd * asset_allocation.percent * asset_allocation.max_investment
-            invested_aum = self.invested_assets_under_management_usd or Decimal(0.0)
+                aum_usd = self.assets_under_management / fx
+                aum_potential = Decimal(0)
+                for asset_allocation in self.company.asset_allocations.all():
+                    aum_potential += aum_usd * asset_allocation.percent * asset_allocation.max_investment
+                invested_aum = self.invested_assets_under_management_usd or Decimal(0.0)
 
-            return aum_potential - invested_aum
+                return aum_potential - invested_aum
 
     def get_potential(self, val_date: date) -> Decimal:
         if module_path := getattr(settings, "PORTFOLIO_COMPANY_DATA_POTENTIAL_METHOD", None):
@@ -225,11 +230,6 @@ class CompanyPortfolioData(models.Model):
         verbose_name_plural = "Company Portfolio Data"
 
 
-@receiver(post_save, sender="directory.Company")
-def create_company_portfolio_data(sender, instance, created, **kwargs):
-    CompanyPortfolioData.objects.get_or_create(company=instance)
-
-
 class AssetAllocationType(WBModel):
     name = models.CharField(max_length=255)
     default_max_investment = models.DecimalField(
@@ -329,3 +329,33 @@ class GeographicFocus(models.Model):
     @classmethod
     def get_representation_label_key(cls):
         return "{{company}}: {{percent}} {{country}}"
+
+
+@receiver(post_save, sender=AssetAllocation)
+@receiver(post_save, sender=GeographicFocus)
+def post_save_company_data(sender, instance, created, **kwargs):
+    company = instance.company
+    portfolio_data, created = CompanyPortfolioData.objects.get_or_create(company=company)
+    if not created:
+        portfolio_data.update()
+        portfolio_data.save()
+        portfolio_data.company.save()
+
+
+@receiver(post_save, sender="directory.Company")
+def handle_company_portfolio_data(sender, instance, created, **kwargs):
+    # create default asset allocation type (equity 50/50)
+    if not instance.asset_allocations.exists():
+        equity_asset_type = AssetAllocationType.objects.get_or_create(name="Equity")[0]
+        AssetAllocation.objects.create(
+            company=instance,
+            asset_type=equity_asset_type,
+            percent=0.5,
+            max_investment=0.5,
+        )
+    if created:
+        portfolio_data, created = CompanyPortfolioData.objects.get_or_create(company=instance)
+        if not created:
+            portfolio_data.update()
+            portfolio_data.save()
+            portfolio_data.company.save()

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/contrib/company_portfolio/serializers.py

@@ -91,7 +91,7 @@ def update_portfolio_data(company_portfolio_data, portfolio_data):
 
     if investment_discretion := portfolio_data["investment_discretion"]:
         company_portfolio_data.investment_discretion = investment_discretion
-
+    company_portfolio_data.update()
     company_portfolio_data.save()
 
 
@@ -103,22 +103,11 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
         read_only=True,
         **_get_assets_under_management_kwargs(field_name="invested_assets_under_management_usd"),
     )
-    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs())
-    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
-        required=False,
-        queryset=Currency.objects.all(),
-        default=None,
-        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
-    )
+
     assets_under_management_currency_repr = serializers.CharField(read_only=True, required=False)
-    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+
     potential = serializers.DecimalField(**_get_potential_kwargs())
-    potential_currency = serializers.PrimaryKeyRelatedField(
-        required=False,
-        queryset=Currency.objects.all(),
-        label=CompanyPortfolioData.potential_currency.field.verbose_name,
-    )
-    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
+    investment_discretion = serializers.ChoiceField(**_get_investment_discretion_kwargs())
 
     # Not sure why read_only_fields does not work...
     tier = serializers.ChoiceField(
@@ -144,10 +133,6 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
             "asset_under_management",  # TODO: add an s after asset - After removing this field from the base model
             "assets_under_management_currency_repr",
             "invested_assets_under_management_usd",
-            "potential_currency",
-            "_potential_currency",
-            "assets_under_management_currency",
-            "_assets_under_management_currency",
             "investment_discretion",
             "potential",
             "tier",
@@ -156,6 +141,19 @@ class CompanyPortfolioDataMixin(serializers.ModelSerializer):
 
 class CompanyModelSerializer(CompanyPortfolioDataMixin, BaseCompanyModelSerializer):
     SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
+    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        default=None,
+        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
+    )
+    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+    potential_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        label=CompanyPortfolioData.potential_currency.field.verbose_name,
+    )
+    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
 
     def update(self, instance, validated_data):
         validated_data, portfolio_data = get_portfolio_data(validated_data)
@@ -209,6 +207,20 @@ class CompanyModelListSerializer(CompanyPortfolioDataMixin, BaseCompanyModelList
 class PersonModelSerializer(CompanyPortfolioDataMixin, BasePersonModelSerializer):
     SERIALIZER_CLASS_FOR_REMOTE_ADDITIONAL_RESOURCES = BasePersonModelSerializer
 
+    assets_under_management_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        default=None,
+        label=CompanyPortfolioData.assets_under_management_currency.field.verbose_name,
+    )
+    _assets_under_management_currency = CurrencyRepresentationSerializer(source="assets_under_management_currency")
+    potential_currency = serializers.PrimaryKeyRelatedField(
+        required=False,
+        queryset=Currency.objects.all(),
+        label=CompanyPortfolioData.potential_currency.field.verbose_name,
+    )
+    _potential_currency = CurrencyRepresentationSerializer(source="potential_currency")
+
     asset_under_management = serializers.DecimalField(
         **_get_assets_under_management_kwargs(field_name="assets_under_management"),
         read_only=True,
@@ -243,11 +255,9 @@ class PersonModelListSerializer(CompanyPortfolioDataMixin, BasePersonModelListSe
 
 
 class AssetAllocationTypeRepresentationSerializer(serializers.RepresentationSerializer):
-    _detail = serializers.HyperlinkField(reverse_name="company_portfolio:assetallocationtyperepresentation-detail")
-
     class Meta:
         model = AssetAllocationType
-        fields = ("id", "name", "_detail")
+        fields = ("id", "name")
 
 
 class AssetAllocationTypeModelSerializer(serializers.ModelSerializer):

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/contrib/company_portfolio/tasks.py

@@ -19,5 +19,16 @@ def update_all_portfolio_data(val_date: date | None = None):
         has_account=Exists(Account.objects.filter(owner=OuterRef("pk"))),
         has_portfolio_data=Exists(CompanyPortfolioData.objects.filter(company=OuterRef("pk"))),
     )
+    company_objs = []
+    portfolio_data_objs = []
     for company in tqdm(qs, total=qs.count()):
-        updater.update_company_data(company)
+        portfolio_data = CompanyPortfolioData.objects.get_or_create(company=company)[0]
+        company.customer_status, company.tier = updater.update_company_data(portfolio_data)
+        portfolio_data_objs.append(portfolio_data)
+        company_objs.append(company)
+    if company_objs:
+        Company.objects.bulk_update(company_objs, ["customer_status", "tier"])
+    if portfolio_data_objs:
+        CompanyPortfolioData.objects.bulk_update(
+            portfolio_data_objs, ["invested_assets_under_management_usd", "potential"]
+        )

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

@@ -172,7 +172,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @cached_property
     def portfolio_total_asset_value(self) -> Decimal:
-        return self.portfolio.get_total_asset_value(self.last_effective_date)
+        return self.get_portfolio_total_asset_value()
 
     @cached_property
     def validated_trading_service(self) -> TradingService:
@@ -248,6 +248,25 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         # TODO make this dynamically configurable
         return "MARKET_ON_CLOSE"
 
+    def get_portfolio_total_asset_value(self):
+        return self.portfolio.get_total_asset_value(self.last_effective_date)
+        # return self.orders.annotate(
+        #     effective_shares=Coalesce(
+        #         Subquery(
+        #             AssetPosition.objects.filter(
+        #                 underlying_quote=OuterRef("underlying_instrument"),
+        #                 date=self.last_effective_date,
+        #                 portfolio=self.portfolio,
+        #             )
+        #             .values("portfolio")
+        #             .annotate(s=Sum("shares"))
+        #             .values("s")[:1]
+        #         ),
+        #         Decimal(0),
+        #     ),
+        #     effective_total_value_fx_portfolio=F("effective_shares") * F("currency_fx_rate") * F("price"),
+        # ).aggregate(s=Sum("effective_total_value_fx_portfolio"))["s"] or Decimal(0.0)
+
     def get_orders(self):
         # TODO Issue here: the cash is subqueried on the portfolio, on portfolio such as the fund, there is multiple cash component, that we exclude in the orders (and use a unique cash position instead)
         # so the subquery returns the previous position (probably USD), but is missing the other cash aggregation. We need to find a way to handle that properly
@@ -428,7 +447,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         # 3. Prepare a mapping from instrument IDs to weights for analytic calculations.
         previous_weights = {instrument.id: float(info["weighting"]) for instrument, info in portfolio.items()}
-
         # 4. Attempt to fetch analytic returns and portfolio contribution. Default on error.
         try:
             last_returns, contribution = self.portfolio.get_analytic_portfolio(
@@ -437,7 +455,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             last_returns = last_returns.to_dict()
         except ValueError:
             last_returns, contribution = {}, 1
-
         positions = []
         total_weighting = Decimal("0")
 
@@ -609,12 +626,16 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             target_portfolio = self._get_default_target_portfolio(use_desired_target_weight=use_desired_target_weight)
         if not effective_portfolio:
             effective_portfolio = self._get_default_effective_portfolio()
+        if use_desired_target_weight:
+            total_target_weight = target_portfolio.total_weight
+        else:
+            total_target_weight = self.total_expected_target_weight
         if target_portfolio:
             service = TradingService(
                 self.trade_date,
                 effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
-                total_target_weight=self.total_expected_target_weight,
+                total_target_weight=total_target_weight,
             )
             if validate_order:
                 service.is_valid()
@@ -640,16 +661,17 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         weighting=weighting,
                         daily_return=daily_return,
                     )
-                order.pre_save()
-                order.set_weighting(weighting, portfolio_value)
-                order.desired_target_weight = order_dto.target_weight
                 order.order_type = Order.get_type(
                     weighting, round(order_dto.previous_weight, 8), round(order_dto.target_weight, 8)
                 )
-                # # if we cannot automatically find a price, we consider the stock is invalid and we sell it
-                # if not order.price and order.weighting > 0:
-                #     order.price = Decimal("0.0")
-                #     order.weighting = -order_dto.effective_weight
+                order.pre_save()
+                order.set_weighting(weighting, portfolio_value)
+                order.desired_target_weight = order_dto.target_weight
+
+                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                if not order.price and order.weighting > 0:
+                    order.price = Decimal("0.0")
+                    order.weighting = -order_dto.effective_weight
                 objs.append(order)
             Order.objects.bulk_create(
                 objs,

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

@@ -10,6 +10,7 @@ from django.db.models import (
 from ordered_model.models import OrderedModel
 from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
+from wbfdm.models import Instrument
 
 from wbportfolio.import_export.handlers.orders import OrderImportHandler
 from wbportfolio.models.asset import AssetPosition
@@ -164,27 +165,28 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         self.set_currency_fx_rate()
 
         if not self.price:
-            # we try to get the price if not provided directly from the underlying instrument
-            if self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent:
-                self.price = Decimal("1")
-            else:
-                self.price = self.get_price()
+            self.set_price()
         if not self.portfolio.only_weighting and not self.shares:
             estimated_shares = self.order_proposal.get_estimated_shares(
                 self.weighting, self.underlying_instrument, self.price
             )
             if estimated_shares:
                 self.shares = estimated_shares
+        if effective_shares := self.get_effective_shares():
+            if self.order_type == self.Type.SELL:
+                self.shares = -effective_shares
+            else:
+                self.shares = max(self.shares, -effective_shares)
         super().pre_save()
 
     def save(self, *args, **kwargs):
+        if self.id:
+            self.set_type()
         self.pre_save()
         if not self.underlying_instrument.is_investable_universe:
             self.underlying_instrument.is_investable_universe = True
             self.underlying_instrument.save()
 
-        if self.id:
-            self.set_type()
         super().save(*args, **kwargs)
 
     @classmethod
@@ -203,21 +205,38 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 else:
                     return Order.Type.SELL
 
-    def get_price(self) -> Decimal:
-        try:
-            return self.underlying_instrument.get_price(self.value_date)
-        except ValueError:
-            return Decimal("0")
-
     def get_effective_shares(self) -> Decimal:
         return AssetPosition.objects.filter(
             underlying_quote=self.underlying_instrument,
-            date=self.value_date,
+            date=self.order_proposal.last_effective_date,
             portfolio=self.portfolio,
         ).aggregate(s=Sum("shares"))["s"] or Decimal("0")
 
     def set_type(self):
-        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+        effective_weight = self._effective_weight
+        self.order_type = self.get_type(self.weighting, effective_weight, effective_weight + self.weighting)
+
+    def set_price(self):
+        daily_return = last_price = Decimal("0")
+
+        effective_date = self.order_proposal.last_effective_date
+        if self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent:
+            last_price = Decimal("1")
+        else:
+            prices, returns = Instrument.objects.filter(id=self.underlying_instrument.id).get_returns_df(
+                from_date=effective_date,
+                to_date=self.value_date,
+                to_currency=self.order_proposal.portfolio.currency,
+                use_dl=True,
+            )
+            with suppress(IndexError):
+                daily_return = Decimal(returns.iloc[-1, 0])
+            with suppress(KeyError):
+                last_price = Decimal(
+                    prices.get(self.value_date, prices[effective_date])[self.underlying_instrument.id]
+                )
+        self.daily_return = daily_return
+        self.price = last_price
 
     def set_currency_fx_rate(self):
         self.currency_fx_rate = Decimal("1")
@@ -235,8 +254,6 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             self.shares = total_value / price_fx_portfolio
         else:
             self.shares = Decimal("0")
-        if effective_shares := self.get_effective_shares():
-            self.shares = max(self.shares, -effective_shares)
 
     def set_shares(self, shares: Decimal, portfolio_value: Decimal):
         if portfolio_value:
@@ -257,7 +274,6 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
 
     def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
         warnings = []
-
         # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
         if self._target_weight:
             if self.order_proposal and not self.portfolio.only_weighting:

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/pms/trading/handler.py

@@ -145,17 +145,20 @@ class TradingService:
             previous_weight = target_weight = 0
             effective_shares = target_shares = 0
             daily_return = 0
+            price = Decimal("0")
             is_cash = False
             if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
                 previous_weight = effective_pos.weighting
                 effective_shares = effective_pos.shares
                 daily_return = effective_pos.daily_return
                 is_cash = effective_pos.is_cash
+                price = effective_pos.price
             if target_pos := target_portfolio.positions_map.get(instrument_id, None):
                 target_weight = target_pos.weighting
                 is_cash = target_pos.is_cash
                 if target_pos.shares is not None:
                     target_shares = target_pos.shares
+                price = target_pos.price
             trade = Trade(
                 underlying_instrument=instrument_id,
                 previous_weight=previous_weight,
@@ -165,7 +168,7 @@ class TradingService:
                 date=self.trade_date,
                 instrument_type=pos.instrument_type,
                 currency=pos.currency,
-                price=Decimal(pos.price) if pos.price is not None else Decimal("0"),
+                price=Decimal(price) if price else Decimal("0"),
                 currency_fx_rate=Decimal(pos.currency_fx_rate),
                 daily_return=Decimal(daily_return),
                 portfolio_contribution=effective_portfolio.portfolio_contribution,

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

@@ -132,7 +132,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
 
     class Meta:
         model = Order
-        percent_fields = ["effective_weight", "target_weight", "weighting", "daily_return", "desired_target_weight"]
+        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}}"
@@ -155,6 +155,9 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "currency_fx_rate",
             "price",
         )
+        extra_kwargs = {
+            "price": {"required": False},
+        }
         fields = (
             "id",
             "shares",

{wbportfolio-1.56.4 → wbportfolio-1.56.6}/wbportfolio/tests/models/orders/test_order_proposals.py

@@ -422,7 +422,7 @@ class TestOrderProposal:
         mock_fct.assert_has_calls(expected_calls)
 
     # Test estimating shares for a trade
-    @patch.object(Portfolio, "get_total_asset_value")
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
     def test_get_estimated_shares(
         self, mock_fct, order_proposal, order_factory, instrument_price_factory, instrument_factory
     ):
@@ -449,7 +449,7 @@ class TestOrderProposal:
             == Decimal(1_000_000) * trade.weighting / underlying_quote_price.net_value
         )
 
-    @patch.object(Portfolio, "get_total_asset_value")
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
     def test_get_estimated_target_cash(self, mock_fct, order_proposal, order_factory, cash_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
@@ -500,7 +500,7 @@ class TestOrderProposal:
         instrument.exchange.save()
         assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    @patch.object(Portfolio, "get_total_asset_value")
+    @patch.object(OrderProposal, "get_portfolio_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)
@@ -528,8 +528,10 @@ 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)
 
-    @patch.object(Portfolio, "get_total_asset_value")
-    def test_submit_round_fractional_shares(self, mock_fct, instrument_price_factory, order_proposal, order_factory):
+    @patch.object(OrderProposal, "get_portfolio_total_asset_value")
+    def test_submit_round_fractional_shares(
+        self, mock_fct, instrument_price_factory, order_proposal, order_factory, asset_position_factory
+    ):
         initial_shares = Decimal("5.6")
         price = instrument_price_factory.create(date=order_proposal.trade_date)
         net_value = round(price.net_value, 4)
@@ -538,6 +540,7 @@ class TestOrderProposal:
 
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
+
         trade = order_factory.create(
             shares=Decimal("5.6"),
             order_proposal=order_proposal,

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

@@ -92,10 +92,10 @@ class OrderOrderProposalModelViewSet(
                 sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
             )
             # weights aggregates
-            cash_sum_effective_weight = (
-                self.order_proposal.total_effective_portfolio_weight - noncash_aggregates["sum_effective_weight"]
+            cash_sum_effective_weight = self.order_proposal.total_effective_portfolio_weight - (
+                noncash_aggregates["sum_effective_weight"] or Decimal(0)
             )
-            cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]
+            cash_sum_target_cash_weight = Decimal("1.0") - (noncash_aggregates["sum_target_weight"] or Decimal(0))
             noncash_sum_effective_weight = noncash_aggregates["sum_effective_weight"] or Decimal(0)
             noncash_sum_target_weight = noncash_aggregates["sum_target_weight"] or Decimal(0)
             sum_buy_weight = queryset.filter(weighting__gte=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)