wbportfolio 1.46.1__py2.py3-none-any.whl → 1.46.3__py2.py3-none-any.whl

wbportfolio/apps.py

@@ -1,5 +1,21 @@
 from django.apps import AppConfig
+from django.apps import apps as global_apps
+from django.db import DEFAULT_DB_ALIAS
+from django.db.models.signals import post_migrate
+from django.utils.module_loading import autodiscover_modules
 
 
 class WbportfolioConfig(AppConfig):
     name = "wbportfolio"
+
+    def ready(self):
+        def autodiscover_backends(
+            app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs
+        ):
+            # we wrap the autodiscover into a post_migrate receiver because we expect db calls
+            autodiscover_modules("rebalancing")
+
+        post_migrate.connect(
+            autodiscover_backends,
+            dispatch_uid="wbportfolio.autodiscover_rebalancing",
+        )

wbportfolio/import_export/handlers/asset_position.py

@@ -53,13 +53,6 @@ class AssetPositionImportHandler(ImportExportHandler):
             underlying_quote_data, only_security=False, read_only=True
         )[0]
 
-        # number type deserialization and sanitization
-        # ensure the provided Decimal field are of type Decimal
-        decimal_fields = ["initial_currency_fx_rate", "initial_price", "initial_shares", "weighting"]
-        for field in decimal_fields:
-            if not (value := data.get(field, None)) is None:
-                data[field] = Decimal(value)
-
         # Ensure that for shares and weighting, a None value default to 0
         if "initial_shares" in data and data["initial_shares"] is None:
             data["initial_shares"] = Decimal(0)
@@ -81,6 +74,13 @@ class AssetPositionImportHandler(ImportExportHandler):
                 except ValueError:
                     raise DeserializationError("Price not provided but can not be found automatically")
 
+        # number type deserialization and sanitization
+        # ensure the provided Decimal field are of type Decimal
+        decimal_fields = ["initial_currency_fx_rate", "initial_price", "initial_shares", "weighting"]
+        for field in decimal_fields:
+            if not (value := data.get(field, None)) is None:
+                data[field] = Decimal(value)
+
     def _process_raw_data(self, data: Dict[str, Any]):
         if prices := data.get("prices", None):
             self.import_source.log += "Instrument Prices found: Importing"

wbportfolio/import_export/handlers/trade.py

@@ -1,6 +1,4 @@
-import math
 from datetime import datetime
-from decimal import Decimal
 from typing import Any, Dict, Optional
 
 from django.db import models
@@ -28,43 +26,45 @@ class TradeImportHandler(ImportExportHandler):
 
     def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
         if (new_register := change_data.get("register")) and (current_register := _object.register):
-            # we remplace the register only if the new one gives us more information
+            # we replace the register only if the new one gives us more information
             if new_register.register_reference == current_register.global_register_reference:
                 del change_data["register"]
         return super()._data_changed(_object, change_data, initial_data, **kwargs)
 
     def _deserialize(self, data: Dict[str, Any]):
-        if external_identifier2 := data.get("external_identifier2", None):
-            data["external_identifier2"] = str(external_identifier2)
-        if transaction_date_str := data.get("transaction_date", None):
-            data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
-        if value_date_str := data.get("value_date", None):
-            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
-        if book_date_str := data.get("book_date", None):
-            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+        from wbportfolio.models.transactions.trade_proposals import TradeProposal
+
         if underlying_instrument := data.get("underlying_instrument", None):
             data["underlying_instrument"] = self.instrument_handler.process_object(
                 underlying_instrument, only_security=False, read_only=True
             )[0]
-        data["portfolio"] = Portfolio._get_or_create_portfolio(
-            self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
-        )
-        if currency_data := data.get("currency", None):
-            data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
 
-        if register_data := data.get("register", None):
-            data["register"] = self.register_handler.process_object(register_data)[0]
+        if trade_proposal_id := data.pop("trade_proposal_id", None):
+            trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
+            data["value_date"] = trade_proposal.last_effective_date
+            data["transaction_date"] = trade_proposal.trade_date
+            data["trade_proposal"] = trade_proposal
+            data["portfolio"] = trade_proposal.portfolio
+            data["status"] = "DRAFT"
+        else:
+            if external_identifier2 := data.get("external_identifier2", None):
+                data["external_identifier2"] = str(external_identifier2)
+            if transaction_date_str := data.get("transaction_date", None):
+                data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
+            if value_date_str := data.get("value_date", None):
+                data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+            if book_date_str := data.get("book_date", None):
+                data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+            data["portfolio"] = Portfolio._get_or_create_portfolio(
+                self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
+            )
+            if currency_data := data.get("currency", None):
+                data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
 
-        for field in self.model._meta.get_fields():
-            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
-                q = 1 / (math.pow(10, 4))
-                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+            if register_data := data.get("register", None):
+                data["register"] = self.register_handler.process_object(register_data)[0]
 
-        if "total_value" in data:
-            data["total_value"] = data["price"] * data["shares"]
-        if "total_value_fx_portfolio" in data:
-            data["total_value_fx_portfolio"] = data["price"] * data["shares"] * data["currency_fx_rate"]
-        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+            data["marked_for_deletion"] = data.get("marked_for_deletion", False)
 
     def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
         if "transaction_date" not in data:  # we might get only book date and not transaction date
@@ -81,7 +81,7 @@ class TradeImportHandler(ImportExportHandler):
             dates_lookup = {"book_date": book_date}
         else:
             raise DeserializationError("date lookup is missing from data")
-        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data['shares']}"
+        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data.get('shares')} Weighting={data.get('weighting')}"
 
         if history.exists():
             queryset = history
@@ -89,10 +89,10 @@ class TradeImportHandler(ImportExportHandler):
             queryset = self.model.objects.filter(marked_for_deletion=False)
 
         queryset = queryset.filter(
-            models.Q(underlying_instrument=data["underlying_instrument"])
-            & models.Q(**dates_lookup)
-            & models.Q(shares=data["shares"])
+            models.Q(underlying_instrument=data["underlying_instrument"]) & models.Q(**dates_lookup)
         )
+        if "shares" in data:
+            queryset = queryset.filter(shares=data["shares"])
 
         if _id := data.get("id", None):
             self.import_source.log += f"ID {_id} provided -> Load CustomerTrade"
@@ -108,7 +108,7 @@ class TradeImportHandler(ImportExportHandler):
         if portfolio := data.get("portfolio", None):
             queryset = queryset.filter(portfolio=portfolio)
         if queryset.exists():
-            if bank := data["bank"]:
+            if bank := data.get("bank"):
                 self.import_source.log += (
                     f"\n{queryset.count()} Trades found. The bank will tried to be matched against {bank}"
                 )
@@ -138,24 +138,27 @@ class TradeImportHandler(ImportExportHandler):
         self.import_source.log += "\nNo trade was successfully matched."
 
     def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
-        trades = self.model.objects.filter(
-            exclude_from_history=False,
-            pending=False,
-            transaction_subtype__in=[
-                self.model.Type.SUBSCRIPTION,
-                self.model.Type.REDEMPTION,
-            ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
-        )
-        if transaction_date := history.get("transaction_date"):
-            trades = trades.filter(transaction_date__lte=transaction_date)
-        elif book_date := history.get("book_date"):
-            trades = trades.filter(book_date__lte=book_date)
-        if "underlying_instrument" in history:
-            trades = trades.filter(underlying_instrument__id=history["underlying_instrument"])
-        elif "underlying_instruments" in history:
-            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        if trade_proposal_id := history.get("trade_proposal_id"):
+            trades = self.model.objects.filter(trade_proposal_id=trade_proposal_id)
         else:
-            raise ValueError("We cannot estimate history without at least the underlying instrument")
+            trades = self.model.objects.filter(
+                exclude_from_history=False,
+                pending=False,
+                transaction_subtype__in=[
+                    self.model.Type.SUBSCRIPTION,
+                    self.model.Type.REDEMPTION,
+                ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
+            )
+            if transaction_date := history.get("transaction_date"):
+                trades = trades.filter(transaction_date__lte=transaction_date)
+            elif book_date := history.get("book_date"):
+                trades = trades.filter(book_date__lte=book_date)
+            if "underlying_instrument" in history:
+                trades = trades.filter(underlying_instrument__id=history["underlying_instrument"])
+            elif "underlying_instruments" in history:
+                trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+            else:
+                raise ValueError("We cannot estimate history without at least the underlying instrument")
         return trades
 
     def _post_processing_objects(
@@ -188,5 +191,8 @@ class TradeImportHandler(ImportExportHandler):
             self.import_source.log += (
                 f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
             )
-            trade.marked_for_deletion = True
-            trade.save()
+            if trade.trade_proposal:
+                trade.delete()
+            else:
+                trade.marked_for_deletion = True
+                trade.save()

wbportfolio/import_export/resources/trades.py

@@ -5,7 +5,7 @@ from import_export.widgets import ForeignKeyWidget
 from wbcore.contrib.io.resources import FilterModelResource
 from wbfdm.models import Instrument
 
-from wbportfolio.models import Trade
+from wbportfolio.models import Trade, TradeProposal
 
 fake = Faker()
 
@@ -15,6 +15,30 @@ class TradeProposalTradeResource(FilterModelResource):
     Trade Resource class to use to import trade from the trade proposal
     """
 
+    def __init__(self, **kwargs):
+        self.trade_proposal = TradeProposal.objects.get(pk=kwargs["trade_proposal_id"])
+        super().__init__(**kwargs)
+
+    def before_import(self, dataset, **kwargs):
+        Trade.objects.filter(trade_proposal=self.trade_proposal).delete()
+
+    def get_or_init_instance(self, instance_loader, row):
+        try:
+            return Trade.objects.get(
+                trade_proposal=self.trade_proposal, underlying_instrument=row["underlying_instrument"]
+            )
+        except Trade.DoesNotExist:
+            return Trade(
+                trade_proposal=self.trade_proposal,
+                underlying_instrument=row["underlying_instrument"],
+                transaction_subtype=Trade.Type.BUY if row["weighting"] > 0 else Trade.Type.SELL,
+                currency=row["underlying_instrument"].currency,
+                transaction_date=self.trade_proposal.trade_date,
+                portfolio=self.trade_proposal.portfolio,
+                weighting=row["weighting"],
+                status=Trade.Status.DRAFT,
+            )
+
     DUMMY_FIELD_MAP = {
         "underlying_instrument": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
         "weighting": 1.0,
@@ -29,7 +53,7 @@ class TradeProposalTradeResource(FilterModelResource):
     )
 
     class Meta:
-        import_id_fields = ("id",)
+        import_id_fields = ("underlying_instrument",)
         fields = (
             "id",
             "underlying_instrument",

wbportfolio/migrations/0074_alter_rebalancer_frequency_and_more.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.0.12 on 2025-02-14 13:10
+
+import django_fsm
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0073_remove_product_price_computation_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='rebalancer',
+            name='frequency',
+            field=models.CharField(default='RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=1', help_text='The Evaluation Frequency in RRULE format', max_length=256, verbose_name='Evaluation Frequency'),
+        ),
+        migrations.AlterField(
+            model_name='tradeproposal',
+            name='status',
+            field=django_fsm.FSMField(choices=[('DRAFT', 'Draft'), ('SUBMIT', 'Submit'), ('APPROVED', 'Approved'), ('DENIED', 'Denied'), ('FAILED', 'Failed')], default='DRAFT', max_length=50, verbose_name='Status'),
+        ),
+    ]

wbportfolio/models/mixins/instruments.py

@@ -61,6 +61,15 @@ class PMSInstrument(Instrument):
     def nominal_value(self, val_date):
         return self.total_shares(val_date) * self.share_price
 
+    def get_latest_price(self, val_date: date) -> InstrumentPrice | None:
+        try:
+            return InstrumentPrice.objects.filter_only_valid_prices().get(instrument=self, date=val_date)
+        except InstrumentPrice.DoesNotExist:
+            if not self.inception_date or not self.prices.filter(date__lte=val_date).exists():
+                return InstrumentPrice.objects.get_or_create(
+                    instrument=self, date=val_date, defaults={"calculated": False, "net_value": self.issue_price}
+                )[0]
+
     def get_latest_valid_price(self, val_date: Optional[date] = None) -> models.Model:
         qs = self.valuations.exclude(net_value=0)
         if val_date and qs.filter(date__lte=val_date).exists():

wbportfolio/models/portfolio.py

@@ -112,7 +112,7 @@ class ActiveTrackedPortfolioManager(DefaultPortfolioManager):
         return (
             super()
             .get_queryset()
-            .annotate(asset_exists=Exists(AssetPosition.objects.filter(portfolio=OuterRef("pk"))))
+            .annotate(asset_exists=Exists(AssetPosition.unannotated_objects.filter(portfolio=OuterRef("pk"))))
             .filter(asset_exists=True, is_tracked=True)
         )
 
@@ -569,9 +569,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         child_portfolios = set()
         if pms_instruments := list(self.pms_instruments):
             for parent_portfolio in Portfolio.objects.filter(
-                id__in=AssetPosition.objects.filter(date=val_date, underlying_quote__in=pms_instruments).values(
-                    "portfolio"
-                )
+                id__in=AssetPosition.unannotated_objects.filter(
+                    date=val_date, underlying_quote__in=pms_instruments
+                ).values("portfolio")
             ):
                 child_portfolios.add(parent_portfolio)
         return child_portfolios
@@ -589,6 +589,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         recompute_weighting: bool = False,
         force_recompute_weighting: bool = False,
         compute_metrics: bool = False,
+        evaluate_rebalancer: bool = True,
     ):
         logger.info(f"change at date for {self} at {val_date}")
         qs = self.assets.filter(date=val_date).filter(
@@ -612,7 +613,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
         # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
         self.estimate_net_asset_values(val_date)
-        self.evaluate_rebalancing(val_date)
+        if evaluate_rebalancer:
+            self.evaluate_rebalancing(val_date)
 
         self.updated_at = timezone.now()
         self.save()
@@ -716,17 +718,19 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         Returns: The trade proposal generated by the rebalancing, if any (otherwise None)
         """
         analytic_portfolio = self.get_analytic_portfolio(start_date)
+        rebalancer = getattr(self, "automatic_rebalancer", None)
         initial_assets = analytic_portfolio.assets
         positions = []
         next_trade_proposal = None
         rebalancing_date = None
+        logger.info(f"compute next weights in batch for {self} from {start_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
         returns, prices = self.get_returns(initial_assets, (start_date - BDay(3)).date(), end_date, ffill_returns=True)
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
-            if rebalancer := getattr(self, "automatic_rebalancer", None):
-                if rebalancer.is_valid(to_date):
-                    rebalancing_date = to_date
-                    break
+            logger.info(f"Processing {to_date:%Y-%m-%d}")
+            if rebalancer and rebalancer.is_valid(to_date):
+                rebalancing_date = to_date
+                break
             # with suppress(IndexError):
             last_returns = returns.loc[[to_date_ts], :]
             next_weights = analytic_portfolio.get_next_weights(last_returns.iloc[-1, :].T)
@@ -737,7 +741,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
             analytic_portfolio = AnalyticPortfolio(X=last_returns, weights=next_weights)
 
-        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False)
+        self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False, evaluate_rebalancer=False)
         if rebalancing_date:
             next_trade_proposal = rebalancer.evaluate_rebalancing(rebalancing_date)
 
@@ -759,7 +763,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             # function to handle the position modification after instantiation
             if from_is_active and not to_is_active:
                 asset.weighting = Decimal(0.0)
-            asset.initial_shares = AssetPosition.objects.filter(
+            asset.initial_shares = AssetPosition.unannotated_objects.filter(
                 date=from_date, underlying_quote=asset.underlying_quote, portfolio=self
             ).aggregate(sum_shares=Sum("initial_shares"))["sum_shares"]
             return asset
@@ -769,6 +773,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if (
             self.is_tracked and not self.is_lookthrough and not is_target_portfolio_imported and from_is_active
         ):  # we cannot propagate a new portfolio for untracked, or look-through or already imported or inactive portfolios
+            logger.info(f"computing next weight for {self} from {from_date:%Y-%m-%d} to {to_date:%Y-%m-%d}")
             analytic_portfolio = self.get_analytic_portfolio(from_date)
             returns, prices = self.get_returns(analytic_portfolio.assets, (from_date - BDay(3)).date(), to_date)
             if not returns.empty:
@@ -929,7 +934,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 update_dates.add(position.date)
             self.assets.filter(date__in=update_dates, is_estimated=True).delete()
             leftover_positions = self.assets.filter(date__in=update_dates).all()
-            objs = AssetPosition.objects.bulk_create(
+            objs = AssetPosition.unannotated_objects.bulk_create(
                 positions,
                 update_fields=[
                     "weighting",
@@ -1186,16 +1191,9 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
         previous_date := portfolio.get_latest_asset_position_date(val_date - BDay(1), with_estimated=True)
     ) and portfolio.assets.filter(date=val_date).exists():
         analytic_portfolio = portfolio.get_analytic_portfolio(val_date, with_previous_weights=True)
-        with suppress(InstrumentPrice.DoesNotExist, IndexError):
-            if not instrument.prices.filter(date__lte=previous_date).exists():
-                previous_net_asset_value = instrument.issue_price
-            else:
-                previous_net_asset_value = (
-                    InstrumentPrice.objects.filter_only_valid_prices()
-                    .get(instrument=instrument, date=previous_date)
-                    .net_value
-                )
-            return analytic_portfolio.get_estimate_net_value(float(previous_net_asset_value))
+        with suppress(IndexError):
+            if last_price := instrument.get_latest_price(previous_date):
+                return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
 @receiver(post_save, sender="wbportfolio.Product")
@@ -1240,10 +1238,10 @@ def batch_recompute_lookthrough_as_task(portfolio_id: int, start: date, end: dat
 @receiver(investable_universe_updated, sender="wbfdm.Instrument")
 def update_portfolio_after_investable_universe(*args, end_date: date | None = None, **kwargs):
     if not end_date:
-        end_date = (date.today() - BDay(1)).date()
+        end_date = date.today()
+    end_date = (end_date + timedelta(days=1) - BDay(1)).date()  # shift in case of business day
     from_date = (end_date - BDay(1)).date()
     for portfolio in Portfolio.tracked_objects.filter(is_lookthrough=False).to_dependency_iterator(from_date):
-        logger.info(f"computing next weight for {portfolio} from {from_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
         try:
             portfolio.propagate_or_update_assets(from_date, end_date)
         except Exception as e:

wbportfolio/models/transactions/rebalancing.py

@@ -1,3 +1,4 @@
+import logging
 from datetime import date
 
 from dateutil import rrule
@@ -18,6 +19,8 @@ from wbportfolio.models.transactions.trade_proposals import TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 
+logger = logging.getLogger("pms")
+
 
 class RebalancingModel(models.Model):
     name = models.CharField(max_length=64, verbose_name="Name")
@@ -44,7 +47,7 @@ class RebalancingModel(models.Model):
     ) -> PortfolioDTO:
         model = self.model_class(portfolio, trade_date, last_effective_date, **kwargs)
         if not model.is_valid():
-            raise ValidationError("Rebalacing cannot applied for these parameters")
+            raise ValidationError(model.validation_errors)
         return model.get_target_portfolio()
 
     @classmethod
@@ -74,7 +77,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     activation_date = models.DateField(verbose_name="Activation Date")
     frequency = models.CharField(
         default="RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=1",
-        max_length=56,
+        max_length=256,
         verbose_name=_("Evaluation Frequency"),
         help_text=_("The Evaluation Frequency in RRULE format"),
     )
@@ -113,6 +116,9 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 "rebalancing_model": self.rebalancing_model,
             },
         )
+        logger.info(
+            f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
+        )
         if trade_proposal.rebalancing_model == self.rebalancing_model:
             trade_proposal.status = TradeProposal.Status.DRAFT
             try:

wbportfolio/models/transactions/trade_proposals.py

@@ -195,8 +195,12 @@ class TradeProposal(RiskCheckMixin, WBModel):
 
     def _get_target_portfolio(self, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
+            params = {}
+            if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
+                params.update(rebalancer.parameters)
+            params.update(kwargs)
             return self.rebalancing_model.get_target_portfolio(
-                self.portfolio, self.trade_date, self.last_effective_date, **kwargs
+                self.portfolio, self.trade_date, self.last_effective_date, **params
             )
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
@@ -245,28 +249,31 @@ class TradeProposal(RiskCheckMixin, WBModel):
             trade.save()
 
     def replay(self):
-        trade_proposal = self
-        while trade_proposal and trade_proposal.status == TradeProposal.Status.APPROVED:
-            logger.info(f"Replaying trade proposal {self}")
-            trade_proposal.portfolio.assets.filter(
-                date=trade_proposal.trade_date
+        last_trade_proposal = self
+        while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
+            logger.info(f"Replaying trade proposal {last_trade_proposal}")
+            last_trade_proposal.portfolio.assets.filter(
+                date=last_trade_proposal.trade_date
             ).delete()  # we delete the existing position and we reapply the trade proposal
-            if not trade_proposal.portfolio.assets.filter(date=trade_proposal.trade_date).exists():
-                if trade_proposal.status == TradeProposal.Status.APPROVED:
-                    trade_proposal.revert()
-                if trade_proposal.status == TradeProposal.Status.DRAFT:
-                    trade_proposal.submit()
-                if trade_proposal.status == TradeProposal.Status.SUBMIT:
-                    trade_proposal.approve()
-                trade_proposal.save()
-            next_trade_proposal = trade_proposal.next_trade_proposal
+            if not last_trade_proposal.portfolio.assets.filter(date=last_trade_proposal.trade_date).exists():
+                if last_trade_proposal.status == TradeProposal.Status.APPROVED:
+                    logger.info("Reverting trade proposal ...")
+                    last_trade_proposal.revert()
+                if last_trade_proposal.status == TradeProposal.Status.DRAFT:
+                    logger.info("Submitting trade proposal ...")
+                    last_trade_proposal.submit()
+                if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
+                    logger.info("Approving trade proposal ...")
+                    last_trade_proposal.approve()
+                last_trade_proposal.save()
+            next_trade_proposal = last_trade_proposal.next_trade_proposal
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()
             )
-            overriding_trade_proposal = trade_proposal.portfolio.batch_portfolio(
-                trade_proposal.trade_date, next_trade_date
+            overriding_trade_proposal = last_trade_proposal.portfolio.batch_portfolio(
+                last_trade_proposal.trade_date, next_trade_date
             )
-            trade_proposal = overriding_trade_proposal or next_trade_proposal
+            last_trade_proposal = overriding_trade_proposal or next_trade_proposal
 
     def estimate_shares(self, trade: Trade) -> Decimal | None:
         if not self.portfolio.only_weighting and (quote := trade.underlying_quote_price):

wbportfolio/models/transactions/trades.py

@@ -42,7 +42,7 @@ class TradeQueryset(OrderedModelQuerySet):
     def annotate_base_info(self):
         return self.annotate(
             last_effective_date=Subquery(
-                AssetPosition.objects.filter(
+                AssetPosition.unannotated_objects.filter(
                     date__lte=OuterRef("value_date"),
                     portfolio=OuterRef("portfolio"),
                 )
@@ -51,7 +51,7 @@ class TradeQueryset(OrderedModelQuerySet):
             ),
             effective_weight=Coalesce(
                 Subquery(
-                    AssetPosition.objects.filter(
+                    AssetPosition.unannotated_objects.filter(
                         underlying_quote=OuterRef("underlying_instrument"),
                         date=OuterRef("last_effective_date"),
                         portfolio=OuterRef("portfolio"),
@@ -389,7 +389,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     )
     def revert(self, to_date=None, **kwargs):
         with suppress(AssetPosition.DoesNotExist):
-            asset = AssetPosition.objects.get(
+            asset = AssetPosition.unannotated_objects.get(
                 underlying_quote=self.underlying_instrument,
                 portfolio=self.portfolio,
                 date=self.transaction_date,
@@ -412,7 +412,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         if hasattr(self, "last_effective_date"):
             return self.last_effective_date
         elif (
-            assets := AssetPosition.objects.filter(
+            assets := AssetPosition.unannotated_objects.filter(
                 underlying_quote=self.underlying_instrument,
                 date__lt=self.transaction_date,
                 portfolio=self.portfolio,
@@ -426,7 +426,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         return getattr(
             self,
             "effective_weight",
-            AssetPosition.objects.filter(
+            AssetPosition.unannotated_objects.filter(
                 underlying_quote=self.underlying_instrument,
                 date=self._last_effective_date,
                 portfolio=self.portfolio,

wbportfolio/rebalancing/base.py

@@ -4,6 +4,10 @@ from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
 
 class AbstractRebalancingModel:
+    @property
+    def validation_errors(self) -> str:
+        return getattr(self, "_validation_errors", "Rebalacing cannot applied for these parameters")
+
     def __init__(self, portfolio, trade_date: date, last_effective_date: date, **kwargs):
         self.portfolio = portfolio
         self.trade_date = trade_date

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -3,7 +3,13 @@ from decimal import Decimal
 import pandas as pd
 from django.db.models import Q, QuerySet
 from wbfdm.enums import MarketData
-from wbfdm.models import Classification, Instrument, InstrumentClassificationThroughModel
+from wbfdm.models import (
+    Classification,
+    Exchange,
+    Instrument,
+    InstrumentClassificationThroughModel,
+    InstrumentListThroughModel,
+)
 
 from wbportfolio.pms.typing import Portfolio, Position
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
@@ -17,8 +23,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         instruments = self._get_instruments(**kwargs)
-        self.market_cap_df = pd.Series()
-        df = pd.DataFrame(
+        self.market_cap_df = pd.DataFrame(
             instruments.dl.market_data(
                 values=[MarketData.MARKET_CAPITALIZATION],
                 from_date=self.last_effective_date,
@@ -26,17 +31,22 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
                 target_currency=self.TARGET_CURRENCY,
             )
         )
+        self.exchange_df = pd.DataFrame(
+            instruments.values_list("id", "exchange"), columns=["id", "exchange"]
+        ).set_index("id")
         try:
-            df = df[["valuation_date", "market_capitalization", "instrument_id"]].pivot_table(
-                index="valuation_date", columns="instrument_id", values="market_capitalization"
-            )
-            df = df.ffill()
-            self.market_cap_df = df.iloc[-1, :].transpose()
+            self.market_cap_df = self.market_cap_df[
+                ["valuation_date", "market_capitalization", "instrument_id"]
+            ].pivot_table(index="valuation_date", columns="instrument_id", values="market_capitalization")
+            # self.market_cap_df = df.iloc[-1, :].transpose()
         except (IndexError, KeyError):
-            self.market_cap_df = pd.Series()
+            self.market_cap_df = pd.DataFrame()
 
     def _get_instruments(
-        self, classification_ids: list[int] | None = None, instrument_ids: list[int] | None = None, **kwargs
+        self,
+        classification_ids: list[int] | None = None,
+        instrument_ids: list[int] | None = None,
+        instrument_list_id: int | None = None,
     ) -> QuerySet[Instrument]:
         """
         Use the provided kwargs to return a list of instruments as universe.
@@ -44,34 +54,62 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
         - Or directly from a static list of instrument ids
         - fallback to the last effective portfolio underlying instruments list
         """
+        if not instrument_ids:
+            instrument_ids = []
         if classification_ids:
             classifications = set()
             for classification in Classification.objects.filter(id__in=classification_ids):
                 for children in classification.get_descendants(include_self=True):
                     classifications.add(children)
-            instrument_ids = list(
-                InstrumentClassificationThroughModel.objects.filter(classification__in=classifications).values_list(
-                    "id", flat=True
+            instrument_ids.extend(
+                list(
+                    InstrumentClassificationThroughModel.objects.filter(
+                        classification__in=classifications
+                    ).values_list("id", flat=True)
+                )
+            )
+        if instrument_list_id:
+            instrument_ids.extend(
+                list(
+                    InstrumentListThroughModel.objects.filter(instrument_list_id=instrument_list_id).values_list(
+                        "instrument", flat=True
+                    )
                 )
             )
-        elif not instrument_ids:
+
+        if not instrument_ids:
             instrument_ids = list(
                 self.portfolio.assets.filter(date=self.last_effective_date).values_list(
                     "underlying_instrument", flat=True
                 )
             )
+
         return Instrument.objects.filter(id__in=instrument_ids).filter(
-            Q(delisted_date__isnull=True) | Q(delisted_date__gt=self.trade_date)
+            (Q(delisted_date__isnull=True) | Q(delisted_date__gt=self.trade_date))
         )
 
     def is_valid(self) -> bool:
-        return (
-            not self.market_cap_df.empty and not self.market_cap_df.isnull().any()
-        )  # if we are missing any market cap for not-delisted instrument, we consider the rebalancing not valid
+        if not self.market_cap_df.empty:
+            trade_date_mktp_cap = (
+                self.market_cap_df.loc[self.trade_date, :].transpose().rename("market_capitalization")
+            )
+            df = pd.concat(
+                [trade_date_mktp_cap, self.exchange_df], axis=1
+            )  # if we are missing any market cap for not-delisted instrument, we consider the rebalancing not valid
+            df = df.groupby("exchange", dropna=False)["market_capitalization"].any()
+            missing_exchanges = Exchange.objects.filter(id__in=df[~df].index.to_list())
+            if missing_exchanges.exists():
+                setattr(
+                    self,
+                    "_validation_errors",
+                    f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}",
+                )
+            return df.all()
+        return False
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        market_cap_df = self.market_cap_df
+        market_cap_df = self.market_cap_df.ffill().loc[self.trade_date, :].transpose()
         total_market_cap = market_cap_df.sum()
 
         for underlying_instrument, market_cap in market_cap_df.to_dict().items():

wbportfolio/serializers/transactions/trade_proposals.py

@@ -1,5 +1,4 @@
-from contextlib import suppress
-
+from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
@@ -43,10 +42,11 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
             )
         ):
             target_portfolio_dto = target_portfolio._build_dto(last_effective_date)
-        with suppress(
-            ValidationError
-        ):  # we ignore validation error at this point as the trade are automatically create for convenience
+        try:
             obj.reset_trades(target_portfolio=target_portfolio_dto)
+        except ValidationError as e:
+            if request := self.context.get("request"):
+                warning(request, str(e))
         return obj
 
     @wb_serializers.register_only_instance_resource()

wbportfolio/tests/rebalancing/test_models.py

@@ -1,6 +1,5 @@
 from decimal import Decimal
 
-import numpy as np
 import pytest
 from pandas._libs.tslibs.offsets import BDay
 from wbfdm.models import InstrumentPrice
@@ -145,13 +144,14 @@ class TestMarketCapitalizationRebalancing:
         return MarketCapitalizationRebalancing(portfolio, weekday, last_effective_date, instrument_ids=[i1.id, i2.id])
 
     def test_is_valid(self, portfolio, weekday, model, instrument_factory, instrument_price_factory):
-        assert model.is_valid()
-        model.market_cap_df.iloc[0] = np.nan
         assert not model.is_valid()
+        i2 = model.market_cap_df.columns[1]
+        model.market_cap_df.loc[weekday, i2] = 1000  # some value
+        assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
-        i1 = model.market_cap_df.index[0]
-        i2 = model.market_cap_df.index[1]
+        i1 = model.market_cap_df.columns[0]
+        i2 = model.market_cap_df.columns[1]
         mkt12 = InstrumentPrice.objects.get(instrument_id=i1, date=model.trade_date).market_capitalization
         mkt21 = InstrumentPrice.objects.get(instrument_id=i2, date=model.last_effective_date).market_capitalization
 

wbportfolio/viewsets/transactions/trades.py

@@ -362,6 +362,7 @@ class CustomerDistributionInstrumentChartViewSet(UserPortfolioRequestPermissionM
 class TradeTradeProposalModelViewSet(
     UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, OrderableMixin, viewsets.ModelViewSet
 ):
+    IMPORT_ALLOWED = True
     ordering = (
         "trade_proposal",
         "order",
@@ -381,6 +382,14 @@ class TradeTradeProposalModelViewSet(
     def trade_proposal(self):
         return get_object_or_404(TradeProposal, pk=self.kwargs["trade_proposal_id"])
 
+    def has_import_permission(self, request) -> bool:  # allow import only on draft trade proposal
+        return super().has_import_permission(request) and self.trade_proposal.status == TradeProposal.Status.DRAFT
+
+    def get_import_resource_kwargs(self):
+        resource_kwargs = super().get_import_resource_kwargs()
+        resource_kwargs["columns_mapping"] = {"underlying_instrument": "underlying_instrument__isin"}
+        return resource_kwargs
+
     def get_resource_class(self):
         return TradeProposalTradeResource
 

{wbportfolio-1.46.1.dist-info → wbportfolio-1.46.3.dist-info}/METADATA

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

{wbportfolio-1.46.1.dist-info → wbportfolio-1.46.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 wbportfolio/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
-wbportfolio/apps.py,sha256=Oa_0SF-vaNEii5e27xw6kZ-UsqlE8XHqzuhFP_KG8SQ,97
+wbportfolio/apps.py,sha256=tybcoLFiw5tLdGHYV68X96n6jNZqx4BYx7Ao8mPflH8,749
 wbportfolio/dynamic_preferences_registry.py,sha256=iPGAiCScrIADX2NA8oChpQquAmTxVLO6O6ty_1n5dFg,2030
 wbportfolio/permissions.py,sha256=F147DXfitbw6IdMQGEFfymCJkiG5YGkWKsLdVVliPyw,320
 wbportfolio/preferences.py,sha256=yS3a7wmFdFTLJwus2dmg2oHbSSUL2lXNzHCVKGgUKGY,246
@@ -110,12 +110,12 @@ 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=z74ew0XBEemNLELsuwKeLXOMDXeeWyTWium6LEIw7CA,8645
+wbportfolio/import_export/handlers/asset_position.py,sha256=5wFnHcbq_zGp9rBUec_JEpzjCA0_v17VrV9F8Ps1ETs,8645
 wbportfolio/import_export/handlers/dividend.py,sha256=tftdVdAzNpKSSvouOtvJfzWL362HUPIC94F6Noha8CE,3998
 wbportfolio/import_export/handlers/fees.py,sha256=XYH752IkNGYhhhwatp8nYa1zG1-YZFDkYW15dyQgOIg,2824
 wbportfolio/import_export/handlers/portfolio_cash_flow.py,sha256=2ODaquuC83RfmNwmQ-8TdhiASObfIems_B1g0yqaYTs,2733
 wbportfolio/import_export/handlers/register.py,sha256=sYyXkE8b1DPZ5monxylZn0kjxLVdNYYZR-p61dwEoDM,2271
-wbportfolio/import_export/handlers/trade.py,sha256=LydAyFtqHPNfCF6j1yY9Md0xWf6NMGOE22-xr2UGq40,9975
+wbportfolio/import_export/handlers/trade.py,sha256=LIzXNEN7-tRWCUBvisgy8eTDL85JWO5c7iN06yJA-TI,10395
 wbportfolio/import_export/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/import_export/parsers/default_mapping.py,sha256=KrO-X5CvQCeQoBYzFDxavoQGriyUSeI2QDx5ar_zo7A,1405
 wbportfolio/import_export/parsers/jpmorgan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -190,7 +190,7 @@ wbportfolio/import_export/parsers/vontobel/valuation.py,sha256=iav8_xYpTJchmTa7K
 wbportfolio/import_export/parsers/vontobel/valuation_api.py,sha256=WLkZ5z-WqhFraNorWlOhIpSx1pQ2fnjdsLHwSTA7O2o,882
 wbportfolio/import_export/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/import_export/resources/assets.py,sha256=zjgHlQWpud41jHrKdRyqGUt1KUJQm9Z7pt0uVh4qBWQ,2234
-wbportfolio/import_export/resources/trades.py,sha256=5HC0YrE1fnc_dOMfkOEj7vsICv1JN_OEZiGryg2GboY,1125
+wbportfolio/import_export/resources/trades.py,sha256=LC1SBFmoxT160s0__cYDV2i99uECVrR7OHN0vAJ2LPQ,2232
 wbportfolio/jinja2/wbportfolio/sql/aum_nnm.sql,sha256=BvMnLsVlXIqU5hhwLDbwZ6nBqWULIBDVcgLJ2B4sdS4,4440
 wbportfolio/kpi_handlers/nnm.py,sha256=hCn0oG0C-6dQ0G-6S4r31nAS633NZdlOT-ntZrzvXZI,7180
 wbportfolio/metric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -239,13 +239,14 @@ wbportfolio/migrations/0070_remove_assetposition_unique_asset_position_and_more.
 wbportfolio/migrations/0071_alter_trade_options_alter_trade_order.py,sha256=QjAyQr1eSs2X73zL03uG_MjfcGZhSJV9YQ0UJ39FpVk,695
 wbportfolio/migrations/0072_trade_diff_shares.py,sha256=aTKa1SbIiwmlXaFtBg-ENrSxfM_cf3RPNQBQlk2VEZ0,635
 wbportfolio/migrations/0073_remove_product_price_computation_and_more.py,sha256=J4puisDFwnbnfv2VLWaiCQ7ost6PCOkin9qKVQoLIWM,18725
+wbportfolio/migrations/0074_alter_rebalancer_frequency_and_more.py,sha256=o01rBj-ADgwCRtAai3e5z27alPGEzaiNxUqCwWm6peY,918
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=PDLJry5w1zE4N4arQh20_uFi2v7gy9QyavJ_rfGE21Q,882
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
 wbportfolio/models/asset.py,sha256=V-fSAF1bsfj_Td3VfdKyhCgcwB_xPS6vTI90Dh5iDx8,37502
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/indexes.py,sha256=iLYF2gzNzX4GLj_Nh3fybUcAQ1TslnT0wgQ6mN164QI,728
-wbportfolio/models/portfolio.py,sha256=-B--vg_vGsZjHtUsW1hrkmg8LoGeyBO_ilcE6BEE3e0,55459
+wbportfolio/models/portfolio.py,sha256=r_qTDNTeUu9QiJ6g_g1rIp5yOuUOwinqadJtykb9KE8,55501
 wbportfolio/models/portfolio_cash_flow.py,sha256=2blPiXSw7dbhUVd-7LcxDBb4v0SheNOdvRK3MFYiChA,7273
 wbportfolio/models/portfolio_cash_targets.py,sha256=WmgG-etPisZsh2yaFQpz7EkpvAudKBEzqPsO715w52U,1498
 wbportfolio/models/portfolio_relationship.py,sha256=mMb18UMRWg9kx_9uIPkMktwORuXXLjKdgRPQQvB6fVE,5486
@@ -260,7 +261,7 @@ wbportfolio/models/graphs/portfolio.py,sha256=NwkehWvTcyTYrKO5ku3eNNaYLuBwuLdSbT
 wbportfolio/models/graphs/utils.py,sha256=1AMpEE9mDuUZ82XgN2irxjCW1-LmziROhKevEBo0mJE,2347
 wbportfolio/models/llm/wbcrm/analyze_relationship.py,sha256=_y2Myc-M2hXQDkRGXvzsM0ZNC31dmxSHHz5BKMtymww,2106
 wbportfolio/models/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/models/mixins/instruments.py,sha256=qxIXir762zgDzf5U21GyrlmbVH5I2IaIIgulpaZOHNo,6197
+wbportfolio/models/mixins/instruments.py,sha256=IucFwxbSxyqLwDbaMYg_vKh1BPwGqo1VERpj0U-nS0Q,6728
 wbportfolio/models/mixins/liquidity_stress_test.py,sha256=whkzjtbOyl_ncNyaQBORb_Z_rDgcvfdTYPgqPolu7dA,58865
 wbportfolio/models/reconciliations/__init__.py,sha256=MXH5fZIPGDRBgJkO6wVu_NLRs8fkP1im7G6d-h36lQY,127
 wbportfolio/models/reconciliations/account_reconciliation_lines.py,sha256=QP6M7hMcyFbuXBa55Y-azui6Dl_WgbzMntEqWzQkbfM,7394
@@ -271,9 +272,9 @@ wbportfolio/models/transactions/claim.py,sha256=agdpGqxpO0FSzYDWV-Gv1tQY46k0LN9C
 wbportfolio/models/transactions/dividends.py,sha256=naL5xeDQfUBf5KyGt7y-tTcHL22nzZumT8DV6AaG8Bg,1064
 wbportfolio/models/transactions/expiry.py,sha256=vnNHdcC1hf2HP4rAbmoGgOfagBYKNFytqOwzOI0MlVI,144
 wbportfolio/models/transactions/fees.py,sha256=ffvqo8I4A0l5rLi00jJ6sGot0jmnkoxaNsbDzdPLwCg,5712
-wbportfolio/models/transactions/rebalancing.py,sha256=9EdElkaqPoH14FBSK9QOCLFzVpr4YFa3YrgCJV9XvaI,6396
-wbportfolio/models/transactions/trade_proposals.py,sha256=ZpMWOKXfWo85AW2cqp0X5aUGabGECB4W1bK4RaD5-QM,20311
-wbportfolio/models/transactions/trades.py,sha256=3HthfL0wgzPmwwXRVzA5yvm-UPiQco7HhN30ztsOjvI,27529
+wbportfolio/models/transactions/rebalancing.py,sha256=vEYdYhog9jiPw_xQd_XQunNzcpHZ8Zk18kQhsN4HuhA,6596
+wbportfolio/models/transactions/trade_proposals.py,sha256=tpxg6EJ8Z6sB7VJ39GVLH-sBVJ9_ypUOqaUE0T5Rvhk,20804
+wbportfolio/models/transactions/trades.py,sha256=7IAC9eDx-ouKGn1RPR_Ggd5XjLgr3rE4xBn_ub0o1TE,27589
 wbportfolio/models/transactions/transactions.py,sha256=4THsE4xqdigZAwWKYfTNRLPJlkmAmsgE70Ribp9Lnrk,7127
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/typing.py,sha256=lRWh9alcstZzwA04hFSPZfOFbCjaVPWtUpWnurnsh8c,6014
@@ -283,12 +284,12 @@ wbportfolio/pms/statistics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 wbportfolio/pms/trading/__init__.py,sha256=R_yLKc54sCak8A1cW0O1Aszrcv5KV8mC_3h17Hr20e4,36
 wbportfolio/pms/trading/handler.py,sha256=Xpgo719S0jE1wUTTyGFpYccPEIg9GXghWEAdYawJbrk,7165
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/rebalancing/base.py,sha256=Z5IAG8zu6_RLkQE1AgIoROBUDXWza0myzKhKx_4ONwA,481
+wbportfolio/rebalancing/base.py,sha256=NwTGZtBm1f35gj5Jp6iTyyFvDT1GSIztN990cKBvYzQ,637
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
 wbportfolio/rebalancing/models/__init__.py,sha256=AQjG7Tu5vlmhqncVoYOjpBKU2UIvgo9FuP2_jD2w-UI,232
 wbportfolio/rebalancing/models/composite.py,sha256=XAjJqLRNsV-MuBKrat3THEfAWs6PXQNSO0g8k8MtBXo,1157
 wbportfolio/rebalancing/models/equally_weighted.py,sha256=U29MOHJMQMIg7Y7W_8t5K3nXjaznzt4ArIxQSiv0Xok,863
-wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=AYVoLg_bf7s7DSXVjBuIOltFpkySVmv2lrDD-pKBH9I,3643
+wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=RskXZ41iSK9g4SSYJRNv0hX6z9Ol73nJY2N7A3IxCLw,5051
 wbportfolio/rebalancing/models/model_portfolio.py,sha256=XQdvs03-0M9YUnL4DidwZC4E6k-ANCNcZ--T_aaOXTQ,1233
 wbportfolio/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/reports/monthly_position_report.py,sha256=e7BzjDd6eseUOwLwQJXKvWErQ58YnCsznHU2VtR6izM,2981
@@ -338,7 +339,7 @@ wbportfolio/serializers/transactions/claim.py,sha256=kC4E2RZRrpd9i8tGfoiV-gpWDk3
 wbportfolio/serializers/transactions/dividends.py,sha256=EULwKDumHBv4r2HsdEGZMZGFaye4dRUNNyXg6-wZXzc,520
 wbportfolio/serializers/transactions/expiry.py,sha256=K3XOSbCyef-xRzOjCr4Qg_YFJ_JuuiJ9u6tDS86l0hg,477
 wbportfolio/serializers/transactions/fees.py,sha256=uPmSWuCeoV2bwVS6RmEz3a0VRBWJHIQr0WhklYc1UAI,1068
-wbportfolio/serializers/transactions/trade_proposals.py,sha256=W1fEkis3A-KcCrlBrjVB7F6xJ8xnvSDmAxb7y7Sw7JA,3417
+wbportfolio/serializers/transactions/trade_proposals.py,sha256=h8Ub69YPEhds1fC0dcbvXmSmpszor0WWxsodUeJmPVY,3414
 wbportfolio/serializers/transactions/trades.py,sha256=pONV5NSqrXUnoTEoAxovnnQqu37cZGuB33TYvIOK3rE,10009
 wbportfolio/serializers/transactions/transactions.py,sha256=O137zeCndK-nxIWSRLEj7bXbBZDGa4d6qK6pJIIYK3g,4170
 wbportfolio/static/wbportfolio/css/macro_review.css,sha256=FAVVO8nModxwPXcTKpcfzVxBGPZGJVK1Xn-0dkSfGyc,233
@@ -384,7 +385,7 @@ wbportfolio/tests/models/transactions/test_trades.py,sha256=z0CCZjB648ECDSEdwmzq
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=FrvVsV_uUiTgmRUfsaB-_sGzY30CqknbOY2DvmwR_70,1141
 wbportfolio/tests/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/rebalancing/test_models.py,sha256=Zph5NFWeIJVFxv06F6CBrJC0xPr3TB5ns0EdgzKdh8U,7610
+wbportfolio/tests/rebalancing/test_models.py,sha256=00VGrz_UZtYSqpTg2J0XCt-zInOAvYSNezad8KKxNnw,7660
 wbportfolio/tests/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/serializers/test_claims.py,sha256=vQrg73xQXRFEgvx3KI9ivFre_wpBFzdO0p0J13PkvdY,582
 wbportfolio/tests/viewsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -514,9 +515,9 @@ wbportfolio/viewsets/transactions/fees.py,sha256=7VUXIogmRrXCz_D9tvDiiTae0t5j09W
 wbportfolio/viewsets/transactions/mixins.py,sha256=WipvJoi5hylkpD0y9VATe30WAcwIHUIroVkK10FYw7k,636
 wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQVTN2MH1kG_yCeVkmyK8k,1263
 wbportfolio/viewsets/transactions/trade_proposals.py,sha256=fYTvvRk7k5xsBzbIgJvU4I4OrllF0VkhlrekD4GVgDk,4296
-wbportfolio/viewsets/transactions/trades.py,sha256=6iTIM5g7TUlRtiCjIG4EdYvyfaoB6K3UC2WRX9BD9Jg,15850
+wbportfolio/viewsets/transactions/trades.py,sha256=wdtEWN1V5wsmesR3mRxPmTJUIAmDmqaNsfIhOB57kqY,16330
 wbportfolio/viewsets/transactions/transactions.py,sha256=ixDp-nsNA8t_A06rBCT19hOMJHy0iRmdz1XKdV1OwAs,4450
-wbportfolio-1.46.1.dist-info/METADATA,sha256=MBqT0rgbHIWQspGtldYVWSruQOouRdQDxcV4U9dunWk,734
-wbportfolio-1.46.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.46.1.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.46.1.dist-info/RECORD,,
+wbportfolio-1.46.3.dist-info/METADATA,sha256=oDO6H1uvqNe5ZlHMqFbR4LPQ2x7KfULE_ePXVkPF4pg,734
+wbportfolio-1.46.3.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.46.3.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.46.3.dist-info/RECORD,,