wbportfolio 1.52.6__py2.py3-none-any.whl → 1.53.0__py2.py3-none-any.whl

wbportfolio/factories/portfolios.py

@@ -19,6 +19,7 @@ class PortfolioFactory(factory.django.DjangoModelFactory):
     is_manageable = True
     is_tracked = True
     is_lookthrough = False
+    only_weighting = True
     invested_timespan = DateRange(date.min, date.max)
 
     @factory.post_generation

wbportfolio/migrations/0078_trade_drift_factor.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.0.14 on 2025-07-02 13:10
+
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0077_remove_transaction_currency_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='trade',
+            name='drift_factor',
+            field=models.DecimalField(decimal_places=6, default=Decimal('1'), help_text='Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return', max_digits=16, verbose_name='Drift Factor'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'),
+                                      help_text='The weight to be multiplied against the target', max_digits=9,
+                                      verbose_name='Weight'),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -693,7 +693,7 @@ class AssetPosition(ImportMixin, models.Model):
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)
 
-    def _build_dto(self, new_weight: Decimal = None) -> PositionDTO:
+    def _build_dto(self, new_weight: Decimal = None, **kwargs) -> PositionDTO:
         """
         Data Transfer Object
         Returns:
@@ -726,6 +726,7 @@ class AssetPosition(ImportMixin, models.Model):
             price=self._price,
             currency_fx_rate=self._currency_fx_rate,
             portfolio_created=self.portfolio_created.id if self.portfolio_created else None,
+            **kwargs,
         )
 
     @cached_property

wbportfolio/models/portfolio.py

@@ -355,8 +355,23 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def _build_dto(self, val_date: date, **extra_kwargs) -> PortfolioDTO:
         "returns the dto representation of this portfolio at the specified date"
+        assets = self.assets.filter(date=val_date, **extra_kwargs)
+        try:
+            drifted_weights = self.get_analytic_portfolio(val_date).get_next_weights()
+        except InvalidAnalyticPortfolio:
+            drifted_weights = {}
         return PortfolioDTO(
-            tuple([pos._build_dto() for pos in self.assets.filter(date=val_date, **extra_kwargs)]),
+            tuple(
+                [
+                    pos._build_dto(
+                        drift_factor=drifted_weights.get(pos.underlying_quote.id, float(pos.weighting))
+                        / float(pos.weighting)
+                        if pos.weighting
+                        else Decimal(1.0)
+                    )
+                    for pos in assets
+                ]
+            ),
         )
 
     def get_weights(self, val_date: date) -> dict[int, float]:

wbportfolio/models/transactions/trade_proposals.py

@@ -1,4 +1,5 @@
 import logging
+import math
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
@@ -112,7 +113,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return TradingService(
             self.trade_date,
-            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            effective_portfolio=self._get_default_effective_portfolio(),
             target_portfolio=target_portfolio,
             total_target_weight=target_portfolio.total_weight,
         )
@@ -206,7 +207,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         service = TradingService(
             self.trade_date,
-            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            effective_portfolio=self._get_default_effective_portfolio(),
             target_portfolio=self._build_dto().convert_to_portfolio(),
             total_target_weight=total_target_weight,
         )
@@ -239,6 +240,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if self.trades.exists():
             return self._build_dto().convert_to_portfolio()
         # Return the current portfolio by default
+        return self._get_default_effective_portfolio()
+
+    def _get_default_effective_portfolio(self):
         return self.portfolio._build_dto(self.last_effective_date)
 
     def reset_trades(
@@ -253,13 +257,12 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # delete all existing trades
         last_effective_date = self.last_effective_date
         # Get effective and target portfolio
-        effective_portfolio = self.portfolio._build_dto(last_effective_date)
         if not target_portfolio:
             target_portfolio = self._get_default_target_portfolio()
         if target_portfolio:
             service = TradingService(
                 self.trade_date,
-                effective_portfolio=effective_portfolio,
+                effective_portfolio=self._get_default_effective_portfolio(),
                 target_portfolio=target_portfolio,
                 total_target_weight=total_target_weight,
             )
@@ -275,11 +278,13 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 )
                 # we cannot do a bulk-create because Trade is a multi table inheritance
                 weighting = round(trade_dto.delta_weight, 6)
+                drift_factor = trade_dto.drift_factor
                 try:
                     trade = self.trades.get(underlying_instrument=instrument)
                     trade.weighting = weighting
                     trade.currency_fx_rate = currency_fx_rate
                     trade.status = Trade.Status.DRAFT
+                    trade.drift_factor = drift_factor
                 except Trade.DoesNotExist:
                     trade = Trade(
                         underlying_instrument=instrument,
@@ -289,6 +294,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                         trade_proposal=self,
                         portfolio=self.portfolio,
                         weighting=weighting,
+                        drift_factor=drift_factor,
                         status=Trade.Status.DRAFT,
                         currency_fx_rate=currency_fx_rate,
                     )
@@ -374,6 +380,16 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if price_fx_portfolio:
             return trade_total_value_fx_portfolio / price_fx_portfolio
 
+    def get_round_lot_size(self, shares: Decimal, underlying_quote: Instrument) -> Decimal:
+        if (round_lot_size := underlying_quote.round_lot_size) != 1 and (
+            not underlying_quote.exchange or underlying_quote.exchange.apply_round_lot_size
+        ):
+            if shares > 0:
+                shares = math.ceil(shares / round_lot_size) * round_lot_size
+            elif abs(shares) > round_lot_size:
+                shares = math.floor(shares / round_lot_size) * round_lot_size
+        return shares
+
     def get_estimated_target_cash(self, currency: Currency) -> AssetPosition:
         """
         Estimates the target cash weight and shares for a trade proposal.
@@ -464,7 +480,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         trades = []
         trades_validation_warnings = []
         for trade in self.trades.all():
-            trade_warnings = trade.submit(by=by, description=description, **kwargs)
+            trade_warnings = trade.submit(
+                by=by, description=description, portfolio_total_asset_value=self.portfolio_total_asset_value, **kwargs
+            )
             if trade_warnings:
                 trades_validation_warnings.extend(trade_warnings)
             trades.append(trade)

wbportfolio/models/transactions/trades.py

@@ -53,7 +53,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 .order_by("-date")
                 .values("date")[:1]
             ),
-            effective_weight=Coalesce(
+            _previous_weight=Coalesce(
                 Subquery(
                     AssetPosition.unannotated_objects.filter(
                         underlying_quote=OuterRef("underlying_instrument"),
@@ -66,6 +66,7 @@ class TradeQueryset(OrderedModelQuerySet):
                 ),
                 Decimal(0),
             ),
+            effective_weight=F("_previous_weight") * F("drift_factor"),
             target_weight=F("effective_weight") + F("weighting"),
             effective_shares=Coalesce(
                 Subquery(
@@ -163,8 +164,8 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     )
 
     weighting = models.DecimalField(
-        max_digits=16,
-        decimal_places=6,
+        max_digits=9,
+        decimal_places=8,
         default=Decimal(0),
         help_text="The weight to be multiplied against the target",
         verbose_name="Weight",
@@ -223,7 +224,13 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         on_delete=models.CASCADE,
         help_text="The Trade Proposal this trade is coming from",
     )
-
+    drift_factor = models.DecimalField(
+        max_digits=16,
+        decimal_places=6,
+        default=Decimal(1.0),
+        verbose_name="Drift Factor",
+        help_text="Drift factor to be applied to the previous portfolio weight to get the actual effective weight including daily return",
+    )
     external_id = models.CharField(
         max_length=255,
         null=True,
@@ -268,13 +275,27 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         },
         on_error="FAILED",
     )
-    def submit(self, by=None, description=None, **kwargs):
-        errors = []
+    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.trade_proposal and not self.portfolio.only_weighting:
+            shares = self.trade_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.shares = shares
+                if portfolio_total_asset_value:
+                    self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
+
         if not self.price:
-            errors.append(
+            warnings.append(
                 f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
             )
-        return errors
+        return warnings
 
     def can_submit(self):
         pass
@@ -457,16 +478,14 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     @property
     @admin.display(description="Effective Weight")
     def _effective_weight(self) -> Decimal:
-        return getattr(
-            self,
-            "effective_weight",
-            AssetPosition.unannotated_objects.filter(
-                underlying_quote=self.underlying_instrument,
-                date=self._last_effective_date,
-                portfolio=self.portfolio,
-            ).aggregate(s=Sum("weighting"))["s"]
-            or Decimal(0),
-        )
+        if hasattr(self, "effective_weight"):
+            return self.effective_weight
+        previous_weight = AssetPosition.unannotated_objects.filter(
+            underlying_quote=self.underlying_instrument,
+            date=self._last_effective_date,
+            portfolio=self.portfolio,
+        ).aggregate(s=Sum("weighting"))["s"] or Decimal(0)
+        return previous_weight * self.drift_factor
 
     @property
     @admin.display(description="Effective Shares")
@@ -545,9 +564,11 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             # we try to get the price if not provided directly from the underlying instrument
             self.price = self.get_price()
         if self.trade_proposal and not self.portfolio.only_weighting:
-            self.shares = self.trade_proposal.get_estimated_shares(
+            estimated_shares = self.trade_proposal.get_estimated_shares(
                 self.weighting, self.underlying_instrument, self.price
             )
+            if estimated_shares:
+                self.shares = estimated_shares
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
@@ -636,6 +657,10 @@ class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
             underlying_instrument=self.underlying_instrument.id,
             effective_weight=self._effective_weight,
             target_weight=self._target_weight,
+            effective_shares=self._effective_shares,
+            target_shares=self._target_shares,
+            currency_fx_rate=self.currency_fx_rate,
+            price=self.price,
             instrument_type=self.underlying_instrument.security_instrument_type.id,
             currency=self.underlying_instrument.currency,
             date=self.transaction_date,

wbportfolio/pms/trading/handler.py

@@ -1,11 +1,69 @@
+import math
 from datetime import date
 from decimal import Decimal
 
+import cvxpy as cp
+import numpy as np
 from django.core.exceptions import ValidationError
 
 from wbportfolio.pms.typing import Portfolio, Trade, TradeBatch
 
 
+class TradeShareOptimizer:
+    def __init__(self, batch: TradeBatch, portfolio_total_value: float):
+        self.batch = batch
+        self.portfolio_total_value = portfolio_total_value
+
+    def optimize(self, target_cash: float = 0.99):
+        try:
+            return self.optimize_trade_share(target_cash)
+        except ValueError:
+            return self.floor_trade_share()
+
+    def optimize_trade_share(self, target_cash: float = 0.01):
+        prices_fx_portfolio = np.array([trade.price_fx_portfolio for trade in self.batch.trades])
+        target_allocs = np.array([trade.target_weight for trade in self.batch.trades])
+
+        # Decision variable: number of shares (integers)
+        shares = cp.Variable(len(prices_fx_portfolio), integer=True)
+
+        # Calculate portfolio values
+        portfolio_values = cp.multiply(shares, prices_fx_portfolio)
+
+        # Target values based on allocations
+        target_values = self.portfolio_total_value * target_allocs
+
+        # Objective: minimize absolute deviation from target values
+        objective = cp.Minimize(cp.sum(cp.abs(portfolio_values - target_values)))
+
+        # Constraints
+        constraints = [
+            shares >= 0,  # No short selling
+            cp.sum(portfolio_values) <= self.portfolio_total_value,  # Don't exceed budget
+            cp.sum(portfolio_values) >= (1.0 - target_cash) * self.portfolio_total_value,  # Use at least 99% of budget
+        ]
+
+        # Solve
+        problem = cp.Problem(objective, constraints)
+        problem.solve(solver=cp.CBC)
+
+        if problem != "optimal":
+            raise ValueError(f"Optimization failed: {problem.status}")
+
+        shares_result = shares.value.astype(int)
+        return TradeBatch(
+            [
+                trade.normalize_target(target_shares=shares_result[index])
+                for index, trade in enumerate(self.batch.trades)
+            ]
+        )
+
+    def floor_trade_share(self):
+        return TradeBatch(
+            [trade.normalize_target(target_shares=math.floor(trade.target_shares)) for trade in self.batch.trades]
+        )
+
+
 class TradingService:
     """
     This class represents the trading service. It can be instantiated either with the target portfolio and the effective portfolio or given a direct list of trade
@@ -87,15 +145,16 @@ class TradingService:
         for instrument_id, pos in instruments.items():
             if not pos.is_cash:
                 effective_weight = target_weight = 0
-                effective_shares = 0
-                instrument_type = currency = None
+                effective_shares = target_shares = 0
+                drift_factor = 1.0
                 if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
                     effective_weight = effective_pos.weighting
                     effective_shares = effective_pos.shares
-                    instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
+                    drift_factor = effective_pos.drift_factor
                 if target_pos := target_portfolio.positions_map.get(instrument_id, None):
                     target_weight = target_pos.weighting
-                    instrument_type, currency = target_pos.instrument_type, target_pos.currency
+                    if target_pos.shares is not None:
+                        target_shares = target_pos.shares
 
                 trades.append(
                     Trade(
@@ -103,9 +162,13 @@ class TradingService:
                         effective_weight=effective_weight,
                         target_weight=target_weight,
                         effective_shares=effective_shares,
+                        target_shares=target_shares,
                         date=self.trade_date,
-                        instrument_type=instrument_type,
-                        currency=currency,
+                        instrument_type=pos.instrument_type,
+                        currency=pos.currency,
+                        price=Decimal(pos.price),
+                        currency_fx_rate=Decimal(pos.currency_fx_rate),
+                        drift_factor=Decimal(drift_factor),
                     )
                 )
         return TradeBatch(tuple(trades))
@@ -140,3 +203,8 @@ class TradingService:
                 raise ValidationError(self.errors)
 
         return not bool(self._errors)
+
+    def get_optimized_trade_batch(self, portfolio_total_value: float, target_cash: float):
+        return TradeShareOptimizer(
+            self.trades_batch, portfolio_total_value
+        ).floor_trade_share()  # TODO switch to the other optimization when ready

wbportfolio/pms/typing.py

@@ -19,6 +19,7 @@ class Position:
     weighting: Decimal
     date: date_lib
 
+    drift_factor: float = 1.0
     currency: int | None = None
     instrument_type: int | None = None
     asset_valuation_date: date_lib | None = None
@@ -83,21 +84,23 @@ class Trade:
     instrument_type: int
     currency: int
     date: date_lib
-
+    price: Decimal
     effective_weight: Decimal
     target_weight: Decimal
+    currency_fx_rate: Decimal = Decimal("1")
+    effective_shares: Decimal = Decimal("0")
+    target_shares: Decimal = Decimal("0")
+    drift_factor: Decimal = Decimal("1")
     id: int | None = None
-    effective_shares: Decimal = None
     is_cash: bool = False
 
     def __add__(self, other):
         return Trade(
             underlying_instrument=self.underlying_instrument,
-            effective_weight=self.effective_weight + other.effective_weight,
+            effective_weight=self.effective_weight,
             target_weight=self.target_weight + other.target_weight,
-            effective_shares=self.effective_shares + other.effective_shares
-            if (self.effective_shares is not None and other.effective_shares is not None)
-            else None,
+            effective_shares=self.effective_shares,
+            target_shares=self.target_shares + other.target_shares,
             **{
                 f.name: getattr(self, f.name)
                 for f in fields(Trade)
@@ -106,15 +109,29 @@ class Trade:
                     "effective_weight",
                     "target_weight",
                     "effective_shares",
+                    "target_shares",
                     "underlying_instrument",
                 ]
             },
         )
 
+    def copy(self, **kwargs):
+        attrs = {f.name: getattr(self, f.name) for f in fields(Trade)}
+        attrs.update(kwargs)
+        return Trade(**attrs)
+
     @property
     def delta_weight(self) -> Decimal:
         return self.target_weight - self.effective_weight
 
+    @property
+    def delta_shares(self) -> Decimal:
+        return self.target_shares - self.effective_shares
+
+    @property
+    def price_fx_portfolio(self) -> Decimal:
+        return self.price * self.currency_fx_rate
+
     def validate(self):
         return True
         # if self.effective_weight < 0 or self.effective_weight > 1.0:
@@ -122,17 +139,22 @@ class Trade:
         # if self.target_weight < 0 or self.target_weight > 1.0:
         #     raise ValidationError("Target Weight needs to be in range [0, 1]")
 
-    def normalize_target(self, factor: Decimal):
-        t = Trade(
-            target_weight=self.target_weight * factor,
-            **{f.name: getattr(self, f.name) for f in fields(Trade) if f.name not in ["target_weight"]},
-        )
-        return t
+    def normalize_target(
+        self, factor: Decimal | None = None, target_shares: Decimal | int | None = None, target_weight: Decimal = None
+    ):
+        if factor is None:
+            if target_shares is not None:
+                factor = target_shares / self.target_shares if self.target_shares else Decimal("1")
+            elif target_weight is not None:
+                factor = target_weight / self.target_weight if self.target_weight else Decimal("1")
+            else:
+                raise ValueError("Target weight and shares cannot be both None")
+        return self.copy(target_weight=self.target_weight * factor, target_shares=self.target_shares * factor)
 
 
 @dataclass(frozen=True)
 class TradeBatch:
-    trades: tuple[Trade]
+    trades: list[Trade]
     trades_map: dict[Trade] = field(init=False, repr=False)
 
     def __post_init__(self):
@@ -174,9 +196,12 @@ class TradeBatch:
                     underlying_instrument=trade.underlying_instrument,
                     instrument_type=trade.instrument_type,
                     weighting=trade.target_weight,
+                    shares=trade.target_shares,
                     currency=trade.currency,
                     date=trade.date,
                     is_cash=trade.is_cash,
+                    price=trade.price,
+                    currency_fx_rate=trade.currency_fx_rate,
                 )
             )
         for position in extra_positions:

wbportfolio/serializers/transactions/trades.py

@@ -315,8 +315,9 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
     )
 
     status = wb_serializers.ChoiceField(default=Trade.Status.DRAFT, choices=Trade.Status.choices)
-    target_weight = wb_serializers.DecimalField(max_digits=16, decimal_places=6, required=False, default=0)
-    effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
+    weighting = wb_serializers.DecimalField(max_digits=7, decimal_places=6)
+    target_weight = wb_serializers.DecimalField(max_digits=7, decimal_places=6, required=False, default=0)
+    effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=7, decimal_places=6, default=0)
     effective_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
     target_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
 

wbportfolio/tests/models/test_portfolios.py

@@ -1033,18 +1033,19 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         i1 = instrument_factory.create(currency=portfolio.currency)
         i2 = instrument_factory.create(currency=portfolio.currency)
+
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=weekday)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=middle_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i1, date=rebalancing_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=(weekday - BDay(1)).date())
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=weekday)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=middle_date)
+        instrument_price_factory.create(net_value=Decimal("100"), instrument=i2, date=rebalancing_date)
+
         asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i1, weighting=0.7)
         asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i2, weighting=0.3)
 
-        instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=i1, date=weekday)
-        instrument_price_factory.create(instrument=i1, date=middle_date)
-        instrument_price_factory.create(instrument=i1, date=rebalancing_date)
-        instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())
-        instrument_price_factory.create(instrument=i2, date=weekday)
-        instrument_price_factory.create(instrument=i2, date=middle_date)
-        instrument_price_factory.create(instrument=i2, date=rebalancing_date)
-
         rebalancer_factory.create(portfolio=portfolio, frequency="RRULE:FREQ=DAILY;", activation_date=rebalancing_date)
         positions, rebalancing_trade_proposal = portfolio.drift_weights(weekday, (rebalancing_date + BDay(1)).date())
         assert rebalancing_trade_proposal.trade_date == rebalancing_date

wbportfolio/tests/models/transactions/test_trade_proposals.py

@@ -267,15 +267,25 @@ class TestTradeProposal:
         asset_position_factory.create(
             portfolio=trade_proposal.portfolio, date=effective_date, underlying_instrument=i2, weighting=Decimal("0.3")
         )
-        instrument_price_factory.create(instrument=i1, date=effective_date)
-        instrument_price_factory.create(instrument=i2, date=effective_date)
-        instrument_price_factory.create(instrument=i3, date=effective_date)
+        p1 = instrument_price_factory.create(instrument=i1, date=effective_date)
+        p2 = instrument_price_factory.create(instrument=i2, date=effective_date)
+        p3 = instrument_price_factory.create(instrument=i3, date=effective_date)
 
         # build the target portfolio
         target_portfolio = PortfolioDTO(
             positions=(
-                Position(underlying_instrument=i2.id, date=trade_proposal.trade_date, weighting=Decimal("0.4")),
-                Position(underlying_instrument=i3.id, date=trade_proposal.trade_date, weighting=Decimal("0.6")),
+                Position(
+                    underlying_instrument=i2.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.4"),
+                    price=float(p2.net_value),
+                ),
+                Position(
+                    underlying_instrument=i3.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.6"),
+                    price=float(p3.net_value),
+                ),
             )
         )
 
@@ -295,9 +305,24 @@ class TestTradeProposal:
         # build the target portfolio
         new_target_portfolio = PortfolioDTO(
             positions=(
-                Position(underlying_instrument=i1.id, date=trade_proposal.trade_date, weighting=Decimal("0.2")),
-                Position(underlying_instrument=i2.id, date=trade_proposal.trade_date, weighting=Decimal("0.3")),
-                Position(underlying_instrument=i3.id, date=trade_proposal.trade_date, weighting=Decimal("0.5")),
+                Position(
+                    underlying_instrument=i1.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.2"),
+                    price=float(p1.net_value),
+                ),
+                Position(
+                    underlying_instrument=i2.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.3"),
+                    price=float(p2.net_value),
+                ),
+                Position(
+                    underlying_instrument=i3.id,
+                    date=trade_proposal.trade_date,
+                    weighting=Decimal("0.5"),
+                    price=float(p3.net_value),
+                ),
             )
         )
 
@@ -381,6 +406,8 @@ class TestTradeProposal:
 
     @patch.object(Portfolio, "get_total_asset_value")
     def test_get_estimated_target_cash(self, mock_fct, trade_proposal, trade_factory, cash_factory):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
         mock_fct.return_value = Decimal(1_000_000)  # 1 million cash
         cash = cash_factory.create(currency=trade_proposal.portfolio.currency)
         trade_factory.create(  # equity trade
@@ -412,3 +439,191 @@ class TestTradeProposal:
         tp2 = trade_proposal_factory.create(portfolio=portfolio, trade_date=tp.trade_date - BDay(1))
         instrument.refresh_from_db()
         assert instrument.inception_date == (tp2.trade_date + BDay(1)).date()
+
+    def test_get_round_lot_size(self, trade_proposal, instrument):
+        # without a round lot size, we expect no normalization of shares
+        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+        instrument.round_lot_size = 100
+        instrument.save()
+
+        # if instrument has a round lot size different than 1, we expect different behavior based on whether shares is positive or negative
+        assert trade_proposal.get_round_lot_size(Decimal(66.0), instrument) == Decimal("100")
+        assert trade_proposal.get_round_lot_size(Decimal(-66.0), instrument) == Decimal(-66.0)
+        assert trade_proposal.get_round_lot_size(Decimal(-120), instrument) == Decimal(-200)
+
+        # exchange can disable rounding based on the lot size
+        instrument.exchange.apply_round_lot_size = False
+        instrument.exchange.save()
+        assert trade_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
+
+    def test_submit_round_lot_size(self, trade_proposal, trade_factory, instrument):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
+        instrument.round_lot_size = 100
+        instrument.save()
+        trade = trade_factory.create(
+            status="DRAFT",
+            underlying_instrument=instrument,
+            shares=70,
+            trade_proposal=trade_proposal,
+            weighting=Decimal("1.0"),
+        )
+        warnings = trade_proposal.submit()
+        trade_proposal.save()
+        assert (
+            len(warnings) == 1
+        )  # ensure that submit returns a warning concerning the rounded trade based on the lot size
+        trade.refresh_from_db()
+        assert trade.shares == 100  # we expect the share to be transformed from 70 to 100 (lot size of 100)
+
+    def test_submit_round_fractional_shares(self, trade_proposal, trade_factory, instrument):
+        trade_proposal.portfolio.only_weighting = False
+        trade_proposal.portfolio.save()
+        trade = trade_factory.create(
+            status="DRAFT",
+            underlying_instrument=instrument,
+            shares=5.6,
+            trade_proposal=trade_proposal,
+            weighting=Decimal("1.0"),
+        )
+        trade_proposal.submit()
+        trade_proposal.save()
+        trade.refresh_from_db()
+        assert trade.shares == 6  # we expect the fractional share to be rounded
+
+    def test_ex_post(
+        self, instrument_factory, asset_position_factory, instrument_price_factory, trade_proposal_factory, portfolio
+    ):
+        """
+        Tests the ex-post rebalancing mechanism of a portfolio with two instruments.
+        Verifies that weights are correctly recalculated after submitting and approving a trade proposal.
+        """
+
+        # --- Create instruments ---
+        msft = instrument_factory.create(currency=portfolio.currency)
+        apple = instrument_factory.create(currency=portfolio.currency)
+
+        # --- Key dates ---
+        d1 = date(2025, 6, 24)
+        d2 = date(2025, 6, 25)
+        d3 = date(2025, 6, 26)
+        d4 = date(2025, 6, 27)
+
+        # --- Create MSFT prices ---
+        msft_p1 = instrument_price_factory.create(instrument=msft, date=d1, net_value=Decimal("10"))
+        msft_p2 = instrument_price_factory.create(instrument=msft, date=d2, net_value=Decimal("8"))
+        msft_p3 = instrument_price_factory.create(instrument=msft, date=d3, net_value=Decimal("12"))
+        msft_p4 = instrument_price_factory.create(instrument=msft, date=d4, net_value=Decimal("15"))  # noqa
+
+        # Calculate MSFT returns between dates
+        msft_r2 = msft_p2.net_value / msft_p1.net_value - Decimal("1")  # noqa
+        msft_r3 = msft_p3.net_value / msft_p2.net_value - Decimal("1")
+
+        # --- Create Apple prices (stable) ---
+        apple_p1 = instrument_price_factory.create(instrument=apple, date=d1, net_value=Decimal("100"))
+        apple_p2 = instrument_price_factory.create(instrument=apple, date=d2, net_value=Decimal("100"))
+        apple_p3 = instrument_price_factory.create(instrument=apple, date=d3, net_value=Decimal("100"))
+        apple_p4 = instrument_price_factory.create(instrument=apple, date=d4, net_value=Decimal("100"))  # noqa
+
+        # Apple returns (always 0 since price is stable)
+        apple_r2 = apple_p2.net_value / apple_p1.net_value - Decimal("1")  # noqa
+        apple_r3 = apple_p3.net_value / apple_p2.net_value - Decimal("1")
+
+        # --- Create positions on d2 ---
+        msft_a2 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=msft,
+            date=d2,
+            initial_shares=10,
+            weighting=Decimal("0.44"),
+        )
+        apple_a2 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=apple,
+            date=d2,
+            initial_shares=1,
+            weighting=Decimal("0.56"),
+        )
+
+        # Check that initial weights sum to 1
+        total_weight_d2 = msft_a2.weighting + apple_a2.weighting
+        assert total_weight_d2 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
+
+        # --- Calculate total portfolio return between d2 and d3 ---
+        portfolio_r3 = msft_a2.weighting * (Decimal("1.0") + msft_r3) + apple_a2.weighting * (
+            Decimal("1.0") + apple_r3
+        )
+
+        # --- Create positions on d3 with weights adjusted for returns ---
+        msft_a3 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=msft,
+            date=d3,
+            initial_shares=10,
+            weighting=msft_a2.weighting * (Decimal("1.0") + msft_r3) / portfolio_r3,
+        )
+        apple_a3 = asset_position_factory.create(
+            portfolio=portfolio,
+            underlying_quote=apple,
+            date=d3,
+            initial_shares=1,
+            weighting=apple_a2.weighting * (Decimal("1.0") + apple_r3) / portfolio_r3,
+        )
+
+        # Check that weights on d3 sum to 1
+        total_weight_d3 = msft_a3.weighting + apple_a3.weighting
+        assert total_weight_d3 == pytest.approx(Decimal("1.0"), abs=Decimal("1e-6"))
+
+        # --- Create a trade proposal on d3 ---
+        trade_proposal = trade_proposal_factory.create(portfolio=portfolio, trade_date=d3)
+        trade_proposal.reset_trades()
+
+        # Retrieve trades for each instrument
+        trade_msft = trade_proposal.trades.get(underlying_instrument=msft)
+        trade_apple = trade_proposal.trades.get(underlying_instrument=apple)
+
+        # Check that trade weights are initially zero
+        assert trade_msft.weighting == Decimal("0")
+        assert trade_apple.weighting == Decimal("0")
+
+        # --- Adjust trade weights to target 50% each ---
+        target_weight = Decimal("0.5")
+        trade_msft.weighting = target_weight - msft_a3.weighting
+        trade_msft.save()
+
+        trade_apple.weighting = target_weight - apple_a3.weighting
+        trade_apple.save()
+
+        # --- Check drift factors and effective weights ---
+        assert trade_msft.drift_factor == pytest.approx(msft_a3.weighting / msft_a2.weighting, abs=Decimal("1e-6"))
+        assert trade_apple.drift_factor == pytest.approx(apple_a3.weighting / apple_a2.weighting, abs=Decimal("1e-6"))
+
+        assert trade_msft._effective_weight == pytest.approx(msft_a3.weighting, abs=Decimal("1e-6"))
+        assert trade_apple._effective_weight == pytest.approx(apple_a3.weighting, abs=Decimal("1e-6"))
+
+        # Check that the target weight is the sum of drifted weight and adjustment
+        assert trade_msft._target_weight == pytest.approx(
+            msft_a2.weighting * trade_msft.drift_factor + trade_msft.weighting,
+            abs=Decimal("1e-6"),
+        )
+        assert trade_msft._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
+
+        assert trade_apple._target_weight == pytest.approx(
+            apple_a2.weighting * trade_apple.drift_factor + trade_apple.weighting,
+            abs=Decimal("1e-6"),
+        )
+        assert trade_apple._target_weight == pytest.approx(target_weight, abs=Decimal("1e-6"))
+
+        # --- Submit and approve the trade proposal ---
+        trade_proposal.submit()
+        trade_proposal.save()
+        trade_proposal.approve()
+        trade_proposal.save()
+
+        # --- Refresh positions after ex-post rebalancing ---
+        msft_a3.refresh_from_db()
+        apple_a3.refresh_from_db()
+
+        # Final check that weights have been updated to 50%
+        assert msft_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))
+        assert apple_a3.weighting == pytest.approx(target_weight, abs=Decimal("1e-6"))

wbportfolio/viewsets/transactions/trades.py

@@ -526,4 +526,6 @@ class TradeTradeProposalModelViewSet(
             effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
             target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
             portfolio_currency=F("portfolio__currency__symbol"),
+            security=F("underlying_instrument__parent"),
+            company=F("underlying_instrument__parent__parent"),
         )

{wbportfolio-1.52.6.dist-info → wbportfolio-1.53.0.dist-info}/METADATA

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

{wbportfolio-1.52.6.dist-info → wbportfolio-1.53.0.dist-info}/RECORD

@@ -63,7 +63,7 @@ wbportfolio/factories/indexes.py,sha256=sInyNARyfUNbScxr_ng1HhxtJXIsK3awFf9BF1gr
 wbportfolio/factories/portfolio_cash_flow.py,sha256=e8LWkk5Gy0FU4HoCL9xPseCtLlVIkMrvAmey5swqcfc,727
 wbportfolio/factories/portfolio_cash_targets.py,sha256=6bYaKjV56yRbjRaQzime218Dho652pcpkAqwhq63D3g,678
 wbportfolio/factories/portfolio_swing_pricings.py,sha256=CLT9AgZKPwChfPDATl-r2r8IVsM5U6S5gDJ8BzsweyI,828
-wbportfolio/factories/portfolios.py,sha256=3_wzz-q7Tc3CtVOQNM8eA4UZljds2IizTzGWE9ue1AQ,1524
+wbportfolio/factories/portfolios.py,sha256=zjjbb81ZokA7vJ7SXFDOmiNqP3Aq6-ZEh2gPiaYKfkY,1550
 wbportfolio/factories/product_groups.py,sha256=JMtG301j5XehB3qmNSbXt6af56Y9uvG3fgbCMf9FCSc,1987
 wbportfolio/factories/products.py,sha256=N0V6sM_98sC6l8qN78wgfmtpYq7O2c5rW5hT5ZM5gsA,2880
 wbportfolio/factories/rebalancing.py,sha256=5wlB5cT65oBFcMQDLyMn50JOJMD7GQvzpr9Pe0cqJLE,721
@@ -247,14 +247,15 @@ wbportfolio/migrations/0074_alter_rebalancer_frequency_and_more.py,sha256=o01rBj
 wbportfolio/migrations/0075_portfolio_initial_position_date_and_more.py,sha256=rXRpsraVlmueAlO2UpBZV4qMf7dtPuptrhfLblZcJDo,1099
 wbportfolio/migrations/0076_alter_dividendtransaction_price_and_more.py,sha256=4g3ok79nw8mTAxHFAqBAdpGKetaPAjv06YSywywt4aU,6106
 wbportfolio/migrations/0077_remove_transaction_currency_and_more.py,sha256=Yf4a3zn2siDtWdIEPEIsj_W87jxOIBwiFVATneU8FxU,29597
+wbportfolio/migrations/0078_trade_drift_factor.py,sha256=26Z3yoiBhMueB-k2R9HaIzg5Qr7BYpdtzlU-65T_cH0,999
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=HSpa5xwh_MHQaBpNrq9E0CbdEE5Iq-pDLIsPzZ-TRTg,904
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=WwbLjpGHzz17yJxrkuTP4MbErqcTJMlKkDrQI92p5II,45490
+wbportfolio/models/asset.py,sha256=9wD7d8rfK8MEogj0WgaZud9wQs5JGPR61gDQRU3W5as,45522
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/exceptions.py,sha256=3ix0tWUO-O6jpz8f07XIwycw2x3JFRoWzjwil8FVA2Q,52
 wbportfolio/models/indexes.py,sha256=gvW4K9U9Bj8BmVCqFYdWiXvDWhjHINRON8XhNsZUiQY,639
-wbportfolio/models/portfolio.py,sha256=yQ8cqAZLOMwsiejC9RzOLoqLDV5q5ZWYWMOc2BlcHdw,56281
+wbportfolio/models/portfolio.py,sha256=evF-_6lhVdo-fs0Y9-J6EQYO8HlOEHoayrALVbT6UgY,56822
 wbportfolio/models/portfolio_cash_flow.py,sha256=uElG7IJUBY8qvtrXftOoskX6EA-dKgEG1JJdvHeWV7g,7336
 wbportfolio/models/portfolio_cash_targets.py,sha256=WmgG-etPisZsh2yaFQpz7EkpvAudKBEzqPsO715w52U,1498
 wbportfolio/models/portfolio_relationship.py,sha256=ZGECiPZiLdlk4uSamOrEfuzO0hduK6OMKJLUSnh5_kc,5190
@@ -281,16 +282,16 @@ wbportfolio/models/transactions/claim.py,sha256=SF2FlwG6SRVmA_hT0NbXah5-fYejccWK
 wbportfolio/models/transactions/dividends.py,sha256=mmOdGWR35yndUMoCuG24Y6BdtxDhSk2gMQ-8LVguqzg,1890
 wbportfolio/models/transactions/fees.py,sha256=wJtlzbBCAq1UHvv0wqWTE2BEjCF5RMtoaSDS3kODFRo,7112
 wbportfolio/models/transactions/rebalancing.py,sha256=obzgewWKOD4kJbCoF5fhtfDk502QkbrjPKh8T9KDGew,7355
-wbportfolio/models/transactions/trade_proposals.py,sha256=Jd7rfiE42Qtqp9VXQ448OF9m_DKoFR8ISjSh-1TDi8o,31592
-wbportfolio/models/transactions/trades.py,sha256=og8R4Sg7LCRQsuX09uYjZXq9q4VsUb0j8W8iCTyx0pQ,31571
+wbportfolio/models/transactions/trade_proposals.py,sha256=ikc3QMSBBWcBwCdl67_G-OomHuC-Tb9I-KttKkbgWwc,32399
+wbportfolio/models/transactions/trades.py,sha256=gJdJ4fcqBR73XzNPYg6mPGMgk4z8DAtcgkUSPGcj5LM,33323
 wbportfolio/models/transactions/transactions.py,sha256=XTcUeMUfkf5XTSZaR2UAyGqCVkOhQYk03_vzHLIgf8Q,3807
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/pms/typing.py,sha256=qcqEs94HA7qNB631LErV7FVQ4ytYBLetuPDcilrnlW0,6798
+wbportfolio/pms/typing.py,sha256=izDCw5g6AUpqXriDDWa9KHpx7D7PSGLddBqhzXgryNQ,7875
 wbportfolio/pms/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/analytics/portfolio.py,sha256=vE0KA6Z037bUdmBTkYuBqXElt80nuYObNzY_kWvxEZY,1360
 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=ORvtwAG2VX1GvNvNE2HnDvS-4UNrgBwCMPydnfphtY0,5992
+wbportfolio/pms/trading/handler.py,sha256=kKUPuZ7bVmvzVteVQWPsmcPxBHpUAjRgO66P5Lfi7NY,8619
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/rebalancing/base.py,sha256=NwTGZtBm1f35gj5Jp6iTyyFvDT1GSIztN990cKBvYzQ,637
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
@@ -347,7 +348,7 @@ wbportfolio/serializers/transactions/claim.py,sha256=kC4E2RZRrpd9i8tGfoiV-gpWDk3
 wbportfolio/serializers/transactions/dividends.py,sha256=ADXf9cXe8rq55lC_a8vIzViGLmQ-yDXkgR54k2m-N0w,1814
 wbportfolio/serializers/transactions/fees.py,sha256=3mBzs6vdfST9roeQB-bmLJhipY7i5jBtAXjoTTE-GOg,2388
 wbportfolio/serializers/transactions/trade_proposals.py,sha256=ufYBYiSttz5KAlAaaXbnf98oUFT_qNfxF_VUM4ClXE8,4072
-wbportfolio/serializers/transactions/trades.py,sha256=JtL2jrvIjBVsmB2N5ngw_1UyzK7BbxGK5yuNTCRSfkU,16815
+wbportfolio/serializers/transactions/trades.py,sha256=YVccQpP480P4-0uVaRfnmpPFoIdW2U0c92kJBR_fPLo,16889
 wbportfolio/static/wbportfolio/css/macro_review.css,sha256=FAVVO8nModxwPXcTKpcfzVxBGPZGJVK1Xn-0dkSfGyc,233
 wbportfolio/static/wbportfolio/markdown/documentation/account_holding_reconciliation.md,sha256=MabxOvOne8s5gl6osDoow6-3ghaXLAYg9THWpvy6G5I,921
 wbportfolio/static/wbportfolio/markdown/documentation/aggregate_asset_position_liquidity.md,sha256=HEgXB7uqmqfty-GBCCXYxrAN-teqmxWuqDLK_liKWVc,1090
@@ -377,7 +378,7 @@ wbportfolio/tests/models/test_merge.py,sha256=sdsjiZsmR6vsUKwTa5kkvL6QTeAZqtd_EP
 wbportfolio/tests/models/test_portfolio_cash_flow.py,sha256=X8dsXexsb1b0lBiuGzu40ps_Az_1UmmKT0eo1vbXH94,5792
 wbportfolio/tests/models/test_portfolio_cash_targets.py,sha256=q8QWAwt-kKRkLC0E05GyRhF_TTQXIi8bdHjXVU0fCV0,965
 wbportfolio/tests/models/test_portfolio_swing_pricings.py,sha256=kr2AOcQkyg2pX3ULjU-o9ye-NVpjMrrfoe-DVbYCbjs,1656
-wbportfolio/tests/models/test_portfolios.py,sha256=ECUAxE07KwmlHN1udMHVCmNDQrRcCbMfRQe8L3cHOX0,53111
+wbportfolio/tests/models/test_portfolios.py,sha256=L_NTLYdLgKkllXlnjX8aBOFl95zBJq8gjQySuhQG1T0,53320
 wbportfolio/tests/models/test_product_groups.py,sha256=AcdxhurV-n_bBuUsfD1GqVtwLFcs7VI2CRrwzsIUWbU,3337
 wbportfolio/tests/models/test_products.py,sha256=IcBzw9hrGiWFMRwPBTMukCMWrhqnjOVA2hhb90xYOW8,9580
 wbportfolio/tests/models/test_roles.py,sha256=4Cn7WyrA2ztJNeWLk5cy9kYo5XLWMbFSvo1O-9JYxeA,3323
@@ -387,7 +388,7 @@ wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCe
 wbportfolio/tests/models/transactions/test_claim.py,sha256=NG3BKB-FVcIDgHSJHCjImxgMM3ISVUMl24xUPmEcPec,5570
 wbportfolio/tests/models/transactions/test_fees.py,sha256=tAp18x2wCNQr11LUnLtHNbBDbbX0v1DZnmW7i-cEi5Q,2423
 wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=fZ5tx6kByEGXD6nhapYdvk9HOjYlmjhU2w6KlQJ6QE4,4061
-wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=ERGDbniHctEnIG5yFLkrZX2Jw1jEew5rWceVKuKskto,18997
+wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=eXSs_xjmfdmmkKy6_MMWpyzir6j2FIhKsBQUpzrHNMo,28370
 wbportfolio/tests/models/transactions/test_trades.py,sha256=vqvOqUY_uXvBp8YOKR0Wq9ycA2oeeEBhO3dzV7sbXEU,9863
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=fAuY1zcXibttFpBh2GhKVyzdYfi1kz_b7SPa9xZQXY0,1086
@@ -518,8 +519,8 @@ wbportfolio/viewsets/transactions/fees.py,sha256=WT2bWWfgozz4_rpyTKX7dgBBTXD-gu0
 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=zdb9yqyAE1-hcMmxxN3CYePWoPVWIW3WP3v8agErDeY,6210
-wbportfolio/viewsets/transactions/trades.py,sha256=DcfiJReBnnR6oBgNKZyBYWhXurtxJG_DCzxq5WCionA,22025
-wbportfolio-1.52.6.dist-info/METADATA,sha256=9YI1D7f4Omg3dI2yJs8v_cUOHJ4cdzujpm3l7QfGh38,702
-wbportfolio-1.52.6.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.52.6.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.52.6.dist-info/RECORD,,
+wbportfolio/viewsets/transactions/trades.py,sha256=GHOw5jtcqoaHiRrxxxL29c9405QiPisEn4coGELKDrE,22146
+wbportfolio-1.53.0.dist-info/METADATA,sha256=OWTBERfDBEZ3lznF4KBNs4pV6Y9hyoKlrLTHZjawV_E,702
+wbportfolio-1.53.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.53.0.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.53.0.dist-info/RECORD,,