wbportfolio 1.56.3__py2.py3-none-any.whl → 1.56.5__py2.py3-none-any.whl

wbportfolio/api_clients/ubs.py

@@ -90,7 +90,7 @@ class UBSNeoAPIClient:
         isin = self._validate_isin(isin, test=test)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/submit/{isin}"
         payload = {"items": items}
-        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=10)
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -99,7 +99,7 @@ class UBSNeoAPIClient:
         isin = self._validate_isin(isin)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/savedraft/{isin}"
         payload = {"items": items}
-        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=10)
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -107,14 +107,14 @@ class UBSNeoAPIClient:
         """Cancel a rebalance request."""
         isin = self._validate_isin(isin)
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/cancel/{isin}"
-        response = requests.delete(url, headers=self._get_headers(), timeout=10)
+        response = requests.delete(url, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
     def get_current_rebalance_request(self, isin: str) -> dict:
         """Fetch the current rebalance request for a certificate."""
         url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/currentRebalanceRequest/{isin}"
-        response = requests.get(url, headers=self._get_headers(), timeout=10)
+        response = requests.get(url, headers=self._get_headers(), timeout=60)
         self._raise_for_status(response)
         return self._get_json(response)
 
@@ -130,7 +130,7 @@ class UBSNeoAPIClient:
             url,
             headers=self._get_headers(),
             params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
-            timeout=10,
+            timeout=30,
         )
         self._raise_for_status(response)
         return self._get_json(response)
@@ -141,7 +141,7 @@ class UBSNeoAPIClient:
             url,
             headers=self._get_headers(),
             params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
-            timeout=10,
+            timeout=30,
         )
         self._raise_for_status(response)
         return self._get_json(response)

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/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()
 
 
@@ -243,11 +243,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/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/import_export/handlers/asset_position.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from contextlib import suppress
-from datetime import datetime
+from datetime import datetime, timedelta
 from decimal import Decimal
 from itertools import chain
 from typing import Any, Dict, List, Optional
@@ -31,7 +31,7 @@ class AssetPositionImportHandler(ImportExportHandler):
         self.instrument_price_handler = InstrumentPriceImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
-    def _deserialize(self, data: Dict[str, Any]):
+    def _deserialize(self, data: Dict[str, Any]):  # noqa: C901
         from wbportfolio.models import Portfolio
 
         portfolio_data = data.pop("portfolio", None)
@@ -45,6 +45,10 @@ class AssetPositionImportHandler(ImportExportHandler):
                     data["initial_price"] /= 1000
             data["currency"] = currency
         data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+
+        # ensure that the position falls into a weekday
+        if data["date"].weekday() == 5:
+            data["date"] -= timedelta(days=1)
         if data.get("asset_valuation_date", None):
             data["asset_valuation_date"] = datetime.strptime(data["asset_valuation_date"], "%Y-%m-%d").date()
         else:

wbportfolio/import_export/parsers/natixis/equity.py

@@ -43,16 +43,16 @@ def parse(import_source):
             df = pd.read_excel(import_source.file, engine="openpyxl", sheet_name="Basket Valuation")
         except BadZipFile:
             df = pd.read_excel(import_source.file, engine="xlrd", sheet_name="Basket Valuation")
-        xx, yy = np.where(df == "Ticker")
-        if not xx and not yy:
-            xx, yy = np.where(df == "Code")
-        df = df.iloc[xx[0] :, yy[0] :]
-        df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
-        df["Quotity/Adj. factor"] = 1.0
-        df = df.rename(columns={"Code": "Ticker"})
-
+        xx, yy = np.where(df.isin(["Ticker", "Code"]))
+        if xx.size > 0 and yy.size > 0:
+            df = df.iloc[xx[0] :, yy[0] :]
+            df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+            df["Quotity/Adj. factor"] = 1.0
+            df = df.rename(columns={"Code": "Ticker"})
+        else:
+            return {}
     df = df.rename(columns=FIELD_MAP)
-    df = df.dropna(subset=["initial_price"])
+    df = df.dropna(subset=["initial_price", "Name"], how="any")
     df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
     df["underlying_quote"] = df[["Ticker", "Name", "currency__key"]].apply(
         lambda x: _get_underlying_instrument(*x), axis=1

wbportfolio/models/asset.py

@@ -448,7 +448,10 @@ class AssetPosition(ImportMixin, models.Model):
                     net_value = self.initial_price
                     # in case the position currency and the linked underlying_quote currency don't correspond, we convert the rate accordingly
                     if self.currency != self.underlying_quote.currency:
-                        net_value *= self.currency.convert(self.asset_valuation_date, self.underlying_quote.currency)
+                        with suppress(CurrencyFXRates.DoesNotExist):
+                            net_value *= self.currency.convert(
+                                self.asset_valuation_date, self.underlying_quote.currency
+                            )
                     self.underlying_quote_price = InstrumentPrice.objects.create(
                         calculated=False,
                         instrument=self.underlying_quote,

wbportfolio/models/orders/order_proposals.py

@@ -20,7 +20,7 @@ from django.db.models.functions import Coalesce, Round
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy
 from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
@@ -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")
 
@@ -458,6 +475,27 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 weighting = drifted_weight + row["delta_weight"]
 
             # Assemble the position object
+            trade_date = self.last_effective_date if use_effective else self.trade_date
+            price_data = {}
+            with suppress(InstrumentPrice.DoesNotExist):
+                instrument_price = instrument.valuations.get(date=trade_date)
+                if fx_rate := instrument_price.currency_fx_rate_to_usd:
+                    price_data = {
+                        "volume_usd": instrument_price.volume
+                        * float(instrument_price.net_value)
+                        / float(fx_rate.value)
+                    }
+                    if instrument_price.market_capitalization:
+                        price_data["market_capitalization_usd"] = instrument_price.market_capitalization / float(
+                            fx_rate.value
+                        )
+                    if row["shares"] is not None:
+                        if instrument_price.market_capitalization:
+                            price_data["market_share"] = (
+                                float(row["shares"]) * float(row["price"]) / instrument_price.market_capitalization
+                            )
+                        if instrument_price.volume_50d:
+                            price_data["daily_liquidity"] = float(row["shares"]) / instrument_price.volume_50d / 0.33
             positions.append(
                 PositionDTO(
                     underlying_instrument=instrument.id,
@@ -466,10 +504,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     daily_return=daily_return if use_effective else Decimal("0"),
                     shares=row["shares"],
                     currency=instrument.currency.id,
-                    date=self.last_effective_date if use_effective else self.trade_date,
+                    date=trade_date,
+                    asset_valuation_date=trade_date,
                     is_cash=instrument.is_cash or instrument.is_cash_equivalent,
                     price=row["price"],
                     currency_fx_rate=row["currency_fx_rate"],
+                    exchange=instrument.exchange.id if instrument.exchange else None,
+                    country=instrument.country.id if instrument.country else None,
+                    **price_data,
                 )
             )
             total_weighting += weighting
@@ -584,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()
@@ -601,15 +647,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             portfolio_value = self.portfolio_total_asset_value
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
-                currency_fx_rate = instrument.currency.convert(
-                    self.value_date, self.portfolio.currency, exact_lookup=True
-                )
                 # we cannot do a bulk-create because Order is a multi table inheritance
                 weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
                 daily_return = order_dto.daily_return
                 try:
                     order = self.orders.get(underlying_instrument=instrument)
-                    order.currency_fx_rate = currency_fx_rate
                     order.daily_return = daily_return
                 except Order.DoesNotExist:
                     order = Order(
@@ -618,18 +660,18 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         value_date=self.trade_date,
                         weighting=weighting,
                         daily_return=daily_return,
-                        currency_fx_rate=currency_fx_rate,
                     )
-                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,
@@ -916,7 +958,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             #         "There is no change detected in this order proposal. Please submit at last one valid order"
             #     )
             if len(service.validated_trades) == 0:
-                errors_list.append(_("There is no valid order on this proposal"))
+                errors_list.append(gettext_lazy("There is no valid order on this proposal"))
             if service.errors:
                 errors_list.extend(service.errors)
             if errors_list:
@@ -1043,22 +1085,26 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         orders = self.get_orders()
         if not self.portfolio.can_be_rebalanced:
-            errors["non_field_errors"] = [_("The portfolio does not allow manual rebalanced")]
+            errors["non_field_errors"] = [gettext_lazy("The portfolio does not allow manual rebalanced")]
         if not orders.exists():
             errors["non_field_errors"] = [
-                _("At least one order needs to be submitted to be able to apply this proposal")
+                gettext_lazy("At least one order needs to be submitted to be able to apply this proposal")
             ]
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                [_("The portfolio needs to be a model portfolio in order to apply this order proposal manually")]
+                [
+                    gettext_lazy(
+                        "The portfolio needs to be a model portfolio in order to apply this order proposal manually"
+                    )
+                ]
             ]
         if self.has_non_successful_checks:
-            errors["non_field_errors"] = [_("The pre orders rules did not passed successfully")]
+            errors["non_field_errors"] = [gettext_lazy("The pre orders rules did not passed successfully")]
         if orders.filter(has_warnings=True).filter(
             underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
         ):
             errors["non_field_errors"] = [
-                _("There is warning that needs to be addresses on the orders before approval.")
+                gettext_lazy("There is warning that needs to be addresses on the orders before approval.")
             ]
         return errors
 
@@ -1122,7 +1168,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                _("The portfolio needs to be a model portfolio in order to revert this order proposal manually")
+                gettext_lazy(
+                    "The portfolio needs to be a model portfolio in order to revert this order proposal manually"
+                )
             ]
         return errors
 

wbportfolio/models/orders/orders.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
@@ -7,7 +8,9 @@ from django.db.models import (
     Sum,
 )
 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
@@ -137,12 +140,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         return getattr(
             self,
             "effective_shares",
-            AssetPosition.objects.filter(
-                underlying_quote=self.underlying_instrument,
-                date=self.value_date,
-                portfolio=self.portfolio,
-            ).aggregate(s=Sum("shares"))["s"]
-            or Decimal(0),
+            self.get_effective_shares(),
         )
 
     @property
@@ -164,29 +162,31 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def pre_save(self):
         self.portfolio = self.order_proposal.portfolio
         self.value_date = self.order_proposal.trade_date
+        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()
-        if not self.portfolio.only_weighting:
+            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
@@ -205,14 +205,46 @@ 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.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")
+        if self.order_proposal.portfolio.currency != self.underlying_instrument.currency:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                self.currency_fx_rate = self.underlying_instrument.currency.convert(
+                    self.value_date, self.portfolio.currency, exact_lookup=True
+                )
 
     def set_weighting(self, weighting: Decimal, portfolio_value: Decimal):
         self.weighting = weighting
@@ -242,28 +274,28 @@ 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.order_proposal and not self.portfolio.only_weighting:
-            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
-            if shares != self.shares:
+        if self._target_weight:
+            if self.order_proposal and not self.portfolio.only_weighting:
+                shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
+                if shares != self.shares:
+                    warnings.append(
+                        f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                    )
+                shares = round(shares)  # ensure fractional shares are converted into integer
+                # we need to recompute the delta weight has we changed the number of shares
+                if shares != self.shares:
+                    self.set_shares(shares, portfolio_total_asset_value)
+            if abs(self.weighting) < self.order_proposal.min_weighting:
                 warnings.append(
-                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                    f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
                 )
-            shares = round(shares)  # ensure fractional shares are converted into integer
-            # we need to recompute the delta weight has we changed the number of shares
-            if shares != self.shares:
-                self.set_shares(shares, portfolio_total_asset_value)
-        if abs(self.weighting) < self.order_proposal.min_weighting:
-            warnings.append(
-                f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
-            )
-            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
-        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
-            warnings.append(
-                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
-            )
-            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+            if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
+                warnings.append(
+                    f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
+                )
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
         if not self.price:
             warnings.append(f"No price for {self.underlying_instrument.computed_str}")
         if (

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/risk_management/backends/exposure_portfolio.py

@@ -160,7 +160,7 @@ class RuleBackend(
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
         if not (df := self._filter_df(portfolio.to_df())).empty:
-            df = df[[self.group_by.value, self.field.value]].groupby(self.group_by.value).sum().astype(float)
+            df = df[[self.group_by.value, self.field.value]].dropna().groupby(self.group_by.value).sum().astype(float)
             for threshold in self.thresholds:
                 numerical_range = threshold.numerical_range
                 incident_df = df[

wbportfolio/serializers/orders/orders.py

@@ -66,6 +66,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
     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)
 
     def validate(self, data):
@@ -131,7 +132,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
 
     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}}"
@@ -142,12 +143,17 @@ 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",
             "effective_shares",
             "effective_total_value_fx_portfolio",
             "has_warnings",
+            "desired_target_weight",
+            "daily_return",
+            "currency_fx_rate",
+            "price",
         )
         fields = (
             "id",
@@ -171,9 +177,14 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "effective_total_value_fx_portfolio",
             "target_total_value_fx_portfolio",
             "portfolio_currency",
+            "underlying_instrument_currency",
             "has_warnings",
             "execution_confirmed",
             "execution_comment",
+            "desired_target_weight",
+            "daily_return",
+            "currency_fx_rate",
+            "price",
         )
 
 

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

@@ -157,7 +157,13 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
                         formatting_rules=ORDER_TYPE_FORMATTING_RULES,
                         width=Unit.PIXEL(125),
                     ),
-                    dp.Field(key="comment", label="Comment", width=Unit.PIXEL(250)),
+                    dp.Field(key="comment", label="Comment", show="open", width=Unit.PIXEL(250)),
+                    dp.Field(
+                        key="desired_target_weight", label="Desired Target Weight", show="open", width=Unit.PIXEL(100)
+                    ),
+                    dp.Field(key="daily_return", label="Daily Return", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="currency_fx_rate", label="FX Rate", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="price", label="Price", show="open", width=Unit.PIXEL(100)),
                     dp.Field(key="order", label="Order", show="open", width=Unit.PIXEL(100)),
                 ],
             )

wbportfolio/viewsets/orders/order_proposals.py

@@ -2,7 +2,7 @@ from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
-from django.contrib.messages import info, warning
+from django.contrib.messages import warning
 from django.shortcuts import get_object_or_404
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
@@ -87,8 +87,6 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
 
     def add_messages(self, request, instance: OrderProposal | None = None, **kwargs):
         if instance:
-            if instance.status == OrderProposal.Status.APPROVED and not instance.portfolio.is_manageable:
-                info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
             if instance.status == OrderProposal.Status.PENDING and instance.has_non_successful_checks:
                 warning(
                     request,

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)
@@ -235,6 +235,7 @@ class OrderOrderProposalModelViewSet(
             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"),
+            underlying_instrument_currency=F("underlying_instrument__currency__symbol"),
             security=F("underlying_instrument__parent"),
             company=F("underlying_instrument__parent__parent"),
         ).select_related(

{wbportfolio-1.56.3.dist-info → wbportfolio-1.56.5.dist-info}/METADATA

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

{wbportfolio-1.56.3.dist-info → wbportfolio-1.56.5.dist-info}/RECORD

@@ -30,7 +30,7 @@ wbportfolio/admin/transactions/trades.py,sha256=LanpSm6iaR9cmNvSJwpRFPkOgN46K_Y9
 wbportfolio/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/analysis/claims.py,sha256=wcTniEVdDnmME8LHrYbo-WWpQ5EzNPgAT2KJIGQ0IIA,10688
 wbportfolio/api_clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/api_clients/ubs.py,sha256=DezqTcZ_TJnMsTRQnnHisWCu_Vxx-CtE0pwr_SYQBi0,6742
+wbportfolio/api_clients/ubs.py,sha256=VSNEND87iHEpQgHY-erWAc4QMAa_BzrqYXdK9JHqQFM,6742
 wbportfolio/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/contrib/company_portfolio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/contrib/company_portfolio/admin.py,sha256=roUsuOjYDWX0OGWVBjCcW3MAcwJHJYHnqZ_pLpwakmQ,549
@@ -40,10 +40,10 @@ wbportfolio/contrib/company_portfolio/dynamic_preferences_registry.py,sha256=k69
 wbportfolio/contrib/company_portfolio/factories.py,sha256=LvEYhBURUz3aK5KtTshBZpU66ph_DbLXKKDzf3Sw4Vo,1243
 wbportfolio/contrib/company_portfolio/filters.py,sha256=jLDo3PRhofuqR2EA7G2R2aiAd_pTCZO4BvUZh0AN1HQ,4995
 wbportfolio/contrib/company_portfolio/management.py,sha256=CofBifGGGKfA06uWRDWXY_9y7y-PGNRz3VhsVaDeAz8,857
-wbportfolio/contrib/company_portfolio/models.py,sha256=dfrIR6sI3He1TIHCjdAP3yIZ0cPvc97ZUX_ZzkkhzGg,12943
+wbportfolio/contrib/company_portfolio/models.py,sha256=0YlWZfpBTUy4nCE0FYY6Kqcx3H28-AbeIVXgxcF6hM0,13963
 wbportfolio/contrib/company_portfolio/scripts.py,sha256=wFfc1L-it0UTaBwNFs8hhGARbJoaNzmnlsXh6KEbslU,2497
-wbportfolio/contrib/company_portfolio/serializers.py,sha256=Y4Osxp0M7m_wy7DSbOt7ESfbob8KrfPBCnbzAuEsmmk,12160
-wbportfolio/contrib/company_portfolio/tasks.py,sha256=ZXezolvlj8_b5hvfcjH5IO5tXvwb8goNG8xPfk6YFNA,835
+wbportfolio/contrib/company_portfolio/serializers.py,sha256=i4lXu79Mkr_b4zOO4iQ73Tl6DucLK7Aj9npaG8ox7js,12067
+wbportfolio/contrib/company_portfolio/tasks.py,sha256=nIBTqC36JCakCug7YVt1aBqai5bKDsgZd2HS7Jwpf5U,1384
 wbportfolio/contrib/company_portfolio/urls.py,sha256=eyq6IpaDPG1oL8-AqPS5nC5BeFewKPA1BN_HI7M3i1c,1118
 wbportfolio/contrib/company_portfolio/viewsets.py,sha256=o-_D_bEt283xngDbsMwdRQxFyuK7rfSChI8u5dGYyLM,8312
 wbportfolio/contrib/company_portfolio/configs/__init__.py,sha256=AVH0v-uOJBPRKggz7fO7IpRyVJ1YlQiF-if_cMsOvvM,72
@@ -118,7 +118,7 @@ wbportfolio/import_export/backends/wbfdm/dividend.py,sha256=iAQXnYPXmtG_Jrc8THAJ
 wbportfolio/import_export/backends/wbfdm/mixin.py,sha256=JNtjgqGLson1nu_Chqb8MWyuiF3Ws8ox2vapxIRBYKE,400
 wbportfolio/import_export/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/import_export/handlers/adjustment.py,sha256=6bdTIYFmc8_HFxcdwtnYwglMyCfAD8XrTIrEb2zWY0g,1757
-wbportfolio/import_export/handlers/asset_position.py,sha256=VNfPOmUta5f4YO_nRFvsiVeGaDwzLF1QDhXFQd0fCX4,9137
+wbportfolio/import_export/handlers/asset_position.py,sha256=ruZoAiwhDmJaiD-OVSZGJ66QrObBeU_JySxsxFmZY30,9305
 wbportfolio/import_export/handlers/dividend.py,sha256=34iu1SfnyCVSObklo9eiF-ECTQhSvkiZn2pUmrWOaV4,4408
 wbportfolio/import_export/handlers/fees.py,sha256=RoOaBwnIMzCx5q7qSzCQbS3L_eOa9Y-RSZ_ZG3QHbNo,2507
 wbportfolio/import_export/handlers/orders.py,sha256=GU3_tIy-tAw9aU-ifsnmMZPBB9sqfkFC_S1d9VziTwg,3136
@@ -146,7 +146,7 @@ wbportfolio/import_export/parsers/natixis/d1_fees.py,sha256=RmzwlNqLSlGDp7JMTwHu
 wbportfolio/import_export/parsers/natixis/d1_trade.py,sha256=JsAVgRH2iBo096Spz8ThJOGPpOCPyYrJ9GJ1XnzjBJQ,2092
 wbportfolio/import_export/parsers/natixis/d1_valuation.py,sha256=M12am0ZenUJxkvEGp6tM1HfeukqYS3b6tfbyfC0XwvY,1216
 wbportfolio/import_export/parsers/natixis/dividend.py,sha256=qx8DXu6NXMy1M_iunA4ITM845_6iNd1aoVCdoAKDNsY,1964
-wbportfolio/import_export/parsers/natixis/equity.py,sha256=v5ai-9DyG2fayOzIR21cbwASStXtCobN0Devb1snCLo,3292
+wbportfolio/import_export/parsers/natixis/equity.py,sha256=oitpx_OYrsGbrYodoF37zjNzsigy2pkTRJ_E6TWpPYU,3341
 wbportfolio/import_export/parsers/natixis/fees.py,sha256=oIC9moGm4s-6525q4_Syt4Yexj3SDgB5kYSfcsdzLcY,1666
 wbportfolio/import_export/parsers/natixis/trade.py,sha256=BJum1W0fYe9emHU7RgL-AjHkiclrckQYkG8VkyCnfvM,2579
 wbportfolio/import_export/parsers/natixis/utils.py,sha256=ImBHHLkC621ZrUDWI2p-F3AGElprT1FVb7xkPwKwvx0,2490
@@ -274,7 +274,7 @@ wbportfolio/migrations/0090_dividendtransaction_price_fx_portfolio_and_more.py,s
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=qU4e7HKyh8NL_0Mg92PcbHTewCv7Ya2gei1DMGe1LWE,980
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=g4HDZKCXVXNY3MKfgbyjFuGTARJqTnBMVgT2xb0H7V8,39210
+wbportfolio/models/asset.py,sha256=zVJm3M5FIYYEMLl3mS0GxWfotadRgItOgIpNIto-0jw,39345
 wbportfolio/models/builder.py,sha256=lVYW0iW8-RFL6OEpn1bC4VPUY89dSU1YNuFwC4yGIAo,14027
 wbportfolio/models/custodians.py,sha256=QhSC3mfd6rSPp8wizabLbKmFDrrskZTSkxNdBJMdtCk,3815
 wbportfolio/models/exceptions.py,sha256=EZnqSr5PxikiS4oDknRakEmlninJh_c-tOHRYv3IMjE,57
@@ -299,8 +299,8 @@ wbportfolio/models/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 wbportfolio/models/mixins/instruments.py,sha256=SuMPquQ93D4pZMK-4hQbJtV58_NOyf3wVOctQq7LNXQ,7054
 wbportfolio/models/mixins/liquidity_stress_test.py,sha256=I_pgJ3QVFBtq0SeljJerhtlrZESRDNAe4On6QfMHvXc,58834
 wbportfolio/models/orders/__init__.py,sha256=EH9UacGR3npBMje5FGTeLOh1xqFBh9kc24WbGmBIA3g,69
-wbportfolio/models/orders/order_proposals.py,sha256=UYNuW5PguEjVD0h66vyGjagWlWqq46cpv80BORDiT3U,58281
-wbportfolio/models/orders/orders.py,sha256=-bIle6Ftt_eRfP5R_J2Y4LEh9HqOUF0sbLUxQftd684,11588
+wbportfolio/models/orders/order_proposals.py,sha256=bg0Xv5XKwcSa1cAcGkn4g-krYEBPrpjJ4D5Rh7W0dYU,60716
+wbportfolio/models/orders/orders.py,sha256=zKSMUJV3OqSbqokF2EoxAAGVhP08jZQjayV9IfkNASQ,13188
 wbportfolio/models/orders/routing.py,sha256=7nu7-3zmGsVA3tyymKK_ywY7V7RtKkGcXkyk2V8dXMw,2191
 wbportfolio/models/reconciliations/__init__.py,sha256=MXH5fZIPGDRBgJkO6wVu_NLRs8fkP1im7G6d-h36lQY,127
 wbportfolio/models/reconciliations/account_reconciliation_lines.py,sha256=QP6M7hMcyFbuXBa55Y-azui6Dl_WgbzMntEqWzQkbfM,7394
@@ -322,7 +322,7 @@ wbportfolio/pms/analytics/portfolio.py,sha256=u_S-e6HUQwAyq90gweDmxyTHWrIc5nd84s
 wbportfolio/pms/analytics/utils.py,sha256=EfhKdo9B2ABaUPppb8DgZSqpNkSze8Rjej1xDjv-XcQ,282
 wbportfolio/pms/statistics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/trading/__init__.py,sha256=R_yLKc54sCak8A1cW0O1Aszrcv5KV8mC_3h17Hr20e4,36
-wbportfolio/pms/trading/handler.py,sha256=sGwtwerozgiCVOTeQgJ0Q9g1zzQCPuydkf0aWn6NnGs,8646
+wbportfolio/pms/trading/handler.py,sha256=p56de1nm-QZh7tfQ7uITp1HuVE2XRaGj4T3oYBtp4Iw,8744
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/rebalancing/base.py,sha256=wpeoxdkLz5osxm5mRjkOoML7YkYvwuAlqSLLtHBbWp8,984
 wbportfolio/rebalancing/decorators.py,sha256=162ZmXV2YQGI830LWvEnJ95RexMzHvaCGfcVOnXTOXM,502
@@ -337,7 +337,7 @@ wbportfolio/risk_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 wbportfolio/risk_management/backends/__init__.py,sha256=4N3GYcIb0XgZUQWEHxCejOCRabUtLM6ha9UdOWJKUfI,368
 wbportfolio/risk_management/backends/accounts.py,sha256=VMHwhzeFV2bzobb1RlEJadTVix1lkbbfdpo-zG3YN5c,7988
 wbportfolio/risk_management/backends/controversy_portfolio.py,sha256=aoRt29QGFNWPf_7yr0Dpjv2AwsA0SJpZdNf8NCfe7JY,2843
-wbportfolio/risk_management/backends/exposure_portfolio.py,sha256=yqWodIYNkjelTModuLCV1kRXIRiYa55zKrNzlQ9Irso,10770
+wbportfolio/risk_management/backends/exposure_portfolio.py,sha256=Tumcg47pX4dVTu1L67bSdgPC9QwOwDewLW_xtyKnAKE,10779
 wbportfolio/risk_management/backends/instrument_list_portfolio.py,sha256=PS-OtT0ReFnZ-bsOCtAQhPjhE0Nc5AyEqy4gLya3fhk,4177
 wbportfolio/risk_management/backends/liquidity_risk.py,sha256=OnuUypmN86RDnch1JOb8UJo5j1z1_X7sjazqAo7cbwM,3694
 wbportfolio/risk_management/backends/liquidity_stress_instrument.py,sha256=oitzsaZu-HhYn9Avku3322GtDmf6QGsfyRzGPGZoM1Y,3612
@@ -376,7 +376,7 @@ wbportfolio/serializers/roles.py,sha256=T-9NqTldpvaEMFy-Bib5MB6MeboygEOqcMP61mzz
 wbportfolio/serializers/signals.py,sha256=hD6R4oFtwhvnsJPteytPKy2JwEelmxrapdfoLSnluaE,7053
 wbportfolio/serializers/orders/__init__.py,sha256=PKJRksA1pWsh8nVfGASoB0m3LyUzVRnq1m9VPp90J7k,271
 wbportfolio/serializers/orders/order_proposals.py,sha256=Jxea2-Ze8Id5URv4UV-vTfCQGt11tjR27vRRfCs0gXU,4791
-wbportfolio/serializers/orders/orders.py,sha256=sab4cGfo-zGPz_5W9DuwOqeo_ja0VobZGU01PjcZUHM,9521
+wbportfolio/serializers/orders/orders.py,sha256=7FOjeT-YAACzKjnJ2Ki2ads7wMq2Td8Zy7ot4TvJ8qs,10014
 wbportfolio/serializers/transactions/__init__.py,sha256=-7Pan4n7YI3iDvGXff6okzk4ycEURRxp5n_SHCY_g_I,493
 wbportfolio/serializers/transactions/claim.py,sha256=mEt67F2v8HC6roemDT3S0dD0cZIVl1U9sASbLW3Vpyo,11611
 wbportfolio/serializers/transactions/dividends.py,sha256=ADXf9cXe8rq55lC_a8vIzViGLmQ-yDXkgR54k2m-N0w,1814
@@ -420,7 +420,7 @@ wbportfolio/tests/models/test_roles.py,sha256=4Cn7WyrA2ztJNeWLk5cy9kYo5XLWMbFSvo
 wbportfolio/tests/models/test_splits.py,sha256=0PvW6WunBByDYRhtFV2LbK-DV92q-1s3kn45NvBL5Es,9500
 wbportfolio/tests/models/utils.py,sha256=ORNJq6NMo1Za22jGZXfTfKeNEnTRlfEt_8SJ6xLaQWg,325
 wbportfolio/tests/models/orders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/models/orders/test_order_proposals.py,sha256=Qv8lk2Fehtpgg79JyEZHRGrp02C4uayeRf4EuWeGNSI,36510
+wbportfolio/tests/models/orders/test_order_proposals.py,sha256=LjQCw10kA1C_21sI_Mm1pkvQLd7fEDHSwODcdt6HGpc,36605
 wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/models/transactions/test_claim.py,sha256=NG3BKB-FVcIDgHSJHCjImxgMM3ISVUMl24xUPmEcPec,5570
 wbportfolio/tests/models/transactions/test_fees.py,sha256=tAp18x2wCNQr11LUnLtHNbBDbbX0v1DZnmW7i-cEi5Q,2423
@@ -548,15 +548,15 @@ wbportfolio/viewsets/configs/titles/registers.py,sha256=-C-YeGBhGva48oER6EIQ8CxW
 wbportfolio/viewsets/configs/titles/roles.py,sha256=9LoJa3jgenXJ5UWRlIErTzdbjpSWMKsyJZtv-eDRTK4,739
 wbportfolio/viewsets/configs/titles/trades.py,sha256=29XCLxvY0Xe3a2tjCno3tN2rRXCr9RWpbWnzurJfnYI,1986
 wbportfolio/viewsets/orders/__init__.py,sha256=N8v9jdEXryOzrLlc7ML3iBCO2lmNXph9_TWoQ7PTvi4,195
-wbportfolio/viewsets/orders/order_proposals.py,sha256=nWUlyVN4Ox54nVHyqN2ryHf_BPXuFjrW-FK5sp5WrHA,8333
-wbportfolio/viewsets/orders/orders.py,sha256=O6Mo5t18FEGDLzAZZvgl8PY1STLiLgv1fyYVhupuSSY,11678
+wbportfolio/viewsets/orders/order_proposals.py,sha256=0z85RnnsJPzH_LVBLqLYY1xuFExkYMbc1gSyNjpvD-4,8110
+wbportfolio/viewsets/orders/orders.py,sha256=rZ0u1_FnmtJxUM4dkC3Y4BzS6KY1iZRyuNGXitKAies,11797
 wbportfolio/viewsets/orders/configs/__init__.py,sha256=5MU57JXiKi32_PicHtiNr7YHmMN020FrlF5NFJf_Wds,94
 wbportfolio/viewsets/orders/configs/buttons/__init__.py,sha256=EHzNmAfa0UQFITEF-wxj_s4wn3Y5DE3DCbEUmmvCTIs,106
 wbportfolio/viewsets/orders/configs/buttons/order_proposals.py,sha256=1BPkIYv0-K2DDGa4Gua2_Pxsx7fNurTZ2tYNdL66On0,6495
 wbportfolio/viewsets/orders/configs/buttons/orders.py,sha256=GDO4Y33wkjhDxzpf7B1d_rKzAixegLv5rHam1DV3WkM,290
 wbportfolio/viewsets/orders/configs/displays/__init__.py,sha256=__YJBbz_ZnKpE8WMMDR2PC9Nng-EVlRpGTEQucdrhRA,108
 wbportfolio/viewsets/orders/configs/displays/order_proposals.py,sha256=zLoLEw4N1i_LD0e3hJnxzO8ORN2byFZoCxWnAz8DBx0,7362
-wbportfolio/viewsets/orders/configs/displays/orders.py,sha256=R1oaDTGosL430xnYZpJz7ihnCOCO6eAFhDQz-wGYT24,7611
+wbportfolio/viewsets/orders/configs/displays/orders.py,sha256=JHG7vax5cYWLfeq64U_4SDfBfixfBfE1FPZVBANMFIY,8105
 wbportfolio/viewsets/orders/configs/endpoints/__init__.py,sha256=IB8GEadiEtBDclhkgpcJGXWfCF6qRK_42hxJ4pcdZDU,148
 wbportfolio/viewsets/orders/configs/endpoints/order_proposals.py,sha256=fY3y2YWR9nY-KE8k078NszDsnwOgqOIjHUgLvQjDivU,822
 wbportfolio/viewsets/orders/configs/endpoints/orders.py,sha256=Iic9RWLHiP2zxq6xve99lwVYCSMLX4T2euS7cJh-uOQ,1088
@@ -567,7 +567,7 @@ wbportfolio/viewsets/transactions/claim.py,sha256=Pb1WftoO-w-ZSTbLRhmQubhy7hgd68
 wbportfolio/viewsets/transactions/fees.py,sha256=WT2bWWfgozz4_rpyTKX7dgBBTXD-gu0nlsd2Nk2Zh1Q,7028
 wbportfolio/viewsets/transactions/mixins.py,sha256=WipvJoi5hylkpD0y9VATe30WAcwIHUIroVkK10FYw7k,636
 wbportfolio/viewsets/transactions/trades.py,sha256=xBgOGaJ8aEg-2RxEJ4FDaBs4SGwuLasun3nhpis0WQY,12363
-wbportfolio-1.56.3.dist-info/METADATA,sha256=OBSV7sthodbAftQh-j9KrB9hzIFPcV1j5cLbX6tPwcE,751
-wbportfolio-1.56.3.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.56.3.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.56.3.dist-info/RECORD,,
+wbportfolio-1.56.5.dist-info/METADATA,sha256=RROv2cPMXS4c5q03yrXpQTM5ncGQRYdjH8PR-i62Hfw,751
+wbportfolio-1.56.5.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.56.5.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.56.5.dist-info/RECORD,,