wbportfolio 1.52.6__tar.gz → 1.53.0__tar.gz

{wbportfolio-1.52.6 → wbportfolio-1.53.0}/PKG-INFO

@@ -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 → wbportfolio-1.53.0}/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-1.53.0/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.0}/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-1.52.6 → wbportfolio-1.53.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