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

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
@@ -17,25 +75,20 @@ class TradingService:
         trade_date: date,
         effective_portfolio: Portfolio | None = None,
         target_portfolio: Portfolio | None = None,
-        trades_batch: TradeBatch | None = None,
-        total_value: Decimal = None,
+        total_target_weight: Decimal = Decimal("1.0"),
     ):
-        self.total_value = total_value
         self.trade_date = trade_date
         if target_portfolio is None:
             target_portfolio = Portfolio(positions=())
         if effective_portfolio is None:
             effective_portfolio = Portfolio(positions=())
-        # If effective portfoolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
-        trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio, trades_batch=trades_batch)
-        # if no trade but a effective portfolio is provided, we get the trade batch only from the effective portofolio (and the target portfolio if provided, but optional. Without it, the trade delta weight will be 0 )
-        # Finally, we compute the target portfolio
-        if trades_batch and not target_portfolio:
-            target_portfolio = trades_batch.convert_to_portfolio()
+        # If effective portfolio and trades batch is provided, we ensure the trade batch contains at least one trade for every position
+        self.trades_batch = self.build_trade_batch(effective_portfolio, target_portfolio).normalize(
+            total_target_weight
+        )
 
-        self.trades_batch = trades_batch
-        self.effective_portfolio = effective_portfolio
-        self.target_portfolio = target_portfolio
+        self._effective_portfolio = effective_portfolio
+        self._target_portfolio = target_portfolio
 
     @property
     def errors(self) -> list[str]:
@@ -62,12 +115,11 @@ class TradingService:
         Test the given value against all the validators on the field,
         and either raise a `ValidationError` or simply return.
         """
-        # TradeBatch(validated_trades).validate()
-        if self.effective_portfolio:
+        if self._effective_portfolio:
             for trade in validated_trades:
                 if (
                     trade.effective_weight
-                    and trade.underlying_instrument not in self.effective_portfolio.positions_map
+                    and trade.underlying_instrument not in self._effective_portfolio.positions_map
                 ):
                     raise ValidationError("All effective position needs to be matched with a validated trade")
 
@@ -75,7 +127,6 @@ class TradingService:
         self,
         effective_portfolio: Portfolio,
         target_portfolio: Portfolio,
-        trades_batch: TradeBatch | None = None,
     ) -> TradeBatch:
         """
         Given combination of effective portfolio and either a trades batch or a target portfolio, ensure all theres variables are set
@@ -87,39 +138,40 @@ class TradingService:
 
         Returns: The normalized trades batch
         """
-        instruments = list(effective_portfolio.positions_map.keys())
-        instruments.extend(list(target_portfolio.positions_map.keys()))
-        if trades_batch:
-            instruments.extend(list(trades_batch.trades_map.keys()))
-        _trades: list[Trade] = []
-        for instrument in set(instruments):
-            effective_weight = target_weight = 0
-            effective_shares = 0
-            instrument_type = currency = None
-            if effective_pos := effective_portfolio.positions_map.get(instrument, None):
-                effective_weight = effective_pos.weighting
-                effective_shares = effective_pos.shares
-                instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
-            if target_pos := target_portfolio.positions_map.get(instrument, None):
-                target_weight = target_pos.weighting
-                instrument_type, currency = target_pos.instrument_type, target_pos.currency
-            if trades_batch and (trade := trades_batch.trades_map.get(instrument, None)):
-                effective_weight, target_weight = trade.effective_weight, trade.target_weight
-                effective_shares = trade.effective_shares
-                instrument_type, currency = trade.instrument_type, trade.currency
-
-            _trades.append(
-                Trade(
-                    underlying_instrument=instrument,
-                    effective_weight=effective_weight,
-                    target_weight=target_weight,
-                    effective_shares=effective_shares,
-                    date=self.trade_date,
-                    instrument_type=instrument_type,
-                    currency=currency,
+        instruments = effective_portfolio.positions_map.copy()
+        instruments.update(target_portfolio.positions_map)
+
+        trades: list[Trade] = []
+        for instrument_id, pos in instruments.items():
+            if not pos.is_cash:
+                effective_weight = target_weight = 0
+                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
+                    drift_factor = effective_pos.drift_factor
+                if target_pos := target_portfolio.positions_map.get(instrument_id, None):
+                    target_weight = target_pos.weighting
+                    if target_pos.shares is not None:
+                        target_shares = target_pos.shares
+
+                trades.append(
+                    Trade(
+                        underlying_instrument=instrument_id,
+                        effective_weight=effective_weight,
+                        target_weight=target_weight,
+                        effective_shares=effective_shares,
+                        target_shares=target_shares,
+                        date=self.trade_date,
+                        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))
+        return TradeBatch(tuple(trades))
 
     def is_valid(self, ignore_error: bool = False) -> bool:
         """
@@ -152,10 +204,7 @@ class TradingService:
 
         return not bool(self._errors)
 
-    def normalize(self):
-        """
-        Normalize the instantiate trades batch so that the target weight is 100%
-        """
-        self.trades_batch = TradeBatch(
-            [trade.normalize_target(self.trades_batch.total_target_weight) for trade in self.trades_batch.trades]
-        )
+    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
@@ -48,7 +49,7 @@ class Position:
 @dataclass(frozen=True)
 class Portfolio:
     positions: tuple[Position] | tuple
-    positions_map: dict[Position] = field(init=False, repr=False)
+    positions_map: dict[int, Position] = field(init=False, repr=False)
 
     def __post_init__(self):
         positions_map = {}
@@ -80,23 +81,26 @@ class Portfolio:
 @dataclass(frozen=True)
 class Trade:
     underlying_instrument: int
-    instrument_type: str
+    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)
@@ -105,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:
@@ -121,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, total_target_weight: Decimal):
-        t = Trade(
-            target_weight=self.target_weight / total_target_weight if total_target_weight else self.target_weight,
-            **{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):
@@ -145,15 +168,15 @@ class TradeBatch:
 
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades]), 6)
+        return round(sum([trade.target_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades]), 6)
+        return round(sum([trade.effective_weight for trade in self.trades], Decimal("0")), 6)
 
     @property
-    def totat_abs_delta_weight(self) -> Decimal:
-        return sum([abs(trade.delta_weight) for trade in self.trades])
+    def total_abs_delta_weight(self) -> Decimal:
+        return sum([abs(trade.delta_weight) for trade in self.trades], Decimal("0"))
 
     def __add__(self, other):
         return TradeBatch(tuple(self.trades + other.trades))
@@ -165,7 +188,7 @@ class TradeBatch:
         if round(float(self.total_target_weight), 4) != 1:  # we do that to remove decimal over precision
             raise ValidationError(f"Total Weight cannot be different than 1 ({float(self.total_target_weight)})")
 
-    def convert_to_portfolio(self):
+    def convert_to_portfolio(self, *extra_positions):
         positions = []
         for instrument, trade in self.trades_map.items():
             positions.append(
@@ -173,8 +196,28 @@ 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:
+            if position.weighting:
+                positions.append(position)
         return Portfolio(tuple(positions))
+
+    def normalize(self, total_target_weight: Decimal = Decimal("1.0")):
+        """
+        Normalize the instantiate trades batch so that the target weight is 100%
+        """
+        normalization_factor = (
+            total_target_weight / self.total_target_weight if self.total_target_weight else Decimal("0.0")
+        )
+        normalized_trades = []
+        for trade in self.trades:
+            normalized_trades.append(trade.normalize_target(normalization_factor))
+        tb = TradeBatch(normalized_trades)
+        return tb

wbportfolio/rebalancing/models/model_portfolio.py

@@ -16,25 +16,22 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
 
     @property
     def model_portfolio(self):
-        if model_portfolio_rel := self.model_portfolio_rel:
-            return model_portfolio_rel.dependency_portfolio
+        return self.model_portfolio_rel.dependency_portfolio if self.model_portfolio_rel else None
+
+    @property
+    def assets(self):
+        return self.model_portfolio.get_positions(self.last_effective_date) if self.model_portfolio else []
 
     def is_valid(self) -> bool:
-        if model_portfolio := self.model_portfolio:
-            assets = model_portfolio.get_positions(self.last_effective_date)
-            return (
-                assets.exists()
-                and InstrumentPrice.objects.filter(
-                    date=self.trade_date, instrument__in=assets.values("underlying_quote")
-                ).exists()
-            )
-        return False
+        instruments = list(map(lambda o: o.underlying_quote, self.assets))
+        return (
+            len(self.assets) > 0
+            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=instruments).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        assets = self.model_portfolio.get_positions(self.last_effective_date)
-
-        for asset in assets:
+        for asset in self.assets:
             asset.date = self.trade_date
             asset.asset_valuation_date = self.trade_date
             positions.append(asset._build_dto())

wbportfolio/serializers/transactions/trade_proposals.py

@@ -1,3 +1,5 @@
+from decimal import Decimal
+
 from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
@@ -16,6 +18,17 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
+    total_cash_weight = wb_serializers.DecimalField(
+        default=0,
+        decimal_places=4,
+        max_digits=5,
+        write_only=True,
+        required=False,
+        precision=4,
+        percent=True,
+        label="Target Cash",
+        help_text="Enter the desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
+    )
 
     trade_date = wb_serializers.DateField(
         read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
@@ -23,6 +36,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
 
     def create(self, validated_data):
         target_portfolio = validated_data.pop("target_portfolio", None)
+        total_cash_weight = validated_data.pop("total_cash_weight", Decimal("0.0"))
         rebalancing_model = validated_data.get("rebalancing_model", None)
         if request := self.context.get("request"):
             validated_data["creator"] = request.user.profile
@@ -32,7 +46,9 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         if target_portfolio and not rebalancing_model and (last_effective_date := obj.last_effective_date):
             target_portfolio_dto = target_portfolio._build_dto(last_effective_date)
         try:
-            obj.reset_trades(target_portfolio=target_portfolio_dto)
+            obj.reset_trades(
+                target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight
+            )
         except ValidationError as e:
             if request := self.context.get("request"):
                 warning(request, str(e), extra_tags="auto_close=0")
@@ -60,6 +76,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         fields = (
             "id",
             "trade_date",
+            "total_cash_weight",
             "comment",
             "status",
             "portfolio",

wbportfolio/serializers/transactions/trades.py

@@ -315,11 +315,22 @@ 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)
 
+    total_value_fx_portfolio = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=2, default=0)
+    effective_total_value_fx_portfolio = wb_serializers.DecimalField(
+        read_only=True, max_digits=16, decimal_places=2, default=0
+    )
+    target_total_value_fx_portfolio = wb_serializers.DecimalField(
+        read_only=True, max_digits=16, decimal_places=2, default=0
+    )
+
+    portfolio_currency = wb_serializers.CharField(read_only=True)
+
     def validate(self, data):
         data.pop("company", None)
         data.pop("security", None)
@@ -331,6 +342,8 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
             )
         effective_weight = self.instance._effective_weight if self.instance else Decimal(0.0)
         weighting = data.get("weighting", self.instance.weighting if self.instance else Decimal(0.0))
+        if (target_weight := data.pop("target_weight", None)) is not None:
+            weighting = target_weight - effective_weight
         if (target_weight := data.pop("target_weight", None)) is not None:
             weighting = target_weight - effective_weight
         if weighting >= 0:
@@ -343,14 +356,25 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
     class Meta:
         model = Trade
         percent_fields = ["effective_weight", "target_weight", "weighting"]
+        decorators = {
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "effective_total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+            "target_total_value_fx_portfolio": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{portfolio_currency}}"
+            ),
+        }
         read_only_fields = (
             "transaction_subtype",
             "shares",
-            # "underlying_instrument",
-            # "_underlying_instrument",
-            "shares",
             "effective_shares",
             "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
         )
         fields = (
             "id",
@@ -375,6 +399,10 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
             "order",
             "effective_shares",
             "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
+            "portfolio_currency",
         )
 
 

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