wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/pms/typing.py

@@ -1,10 +1,15 @@
+import enum
 from dataclasses import asdict, dataclass, field, fields
+from datetime import date
 from datetime import date as date_lib
 from decimal import Decimal
+from typing import Self
 
 import pandas as pd
 from django.core.exceptions import ValidationError
 
+from wbportfolio.order_routing import ExecutionInstruction
+
 
 @dataclass(frozen=True)
 class Valuation:
@@ -13,12 +18,13 @@ class Valuation:
     outstanding_shares: Decimal = Decimal(0)
 
 
-@dataclass(frozen=True)
+@dataclass()
 class Position:
     underlying_instrument: int
     weighting: Decimal
     date: date_lib
 
+    daily_return: Decimal = Decimal("0")
     currency: int | None = None
     instrument_type: int | None = None
     asset_valuation_date: date_lib | None = None
@@ -37,6 +43,10 @@ class Position:
     volume_usd: float = None
     price: float = None
 
+    def __post_init__(self):
+        self.daily_return = round(self.daily_return, 16)
+        self.weighting = round(self.weighting, 8)
+
     def __add__(self, other):
         return Position(
             weighting=self.weighting + other.weighting,
@@ -44,59 +54,70 @@ class Position:
             **{f.name: getattr(self, f.name) for f in fields(Position) if f.name not in ["weighting", "shares"]},
         )
 
-
-@dataclass(frozen=True)
-class Portfolio:
-    positions: tuple[Position] | tuple
-    positions_map: dict[Position] = field(init=False, repr=False)
-
-    def __post_init__(self):
-        positions_map = {}
-        for pos in self.positions:
-            if pos.underlying_instrument in positions_map:
-                positions_map[pos.underlying_instrument] += pos
-            else:
-                positions_map[pos.underlying_instrument] = pos
-        object.__setattr__(self, "positions_map", positions_map)
-
-    @property
-    def total_weight(self):
-        return round(sum([pos.weighting for pos in self.positions]), 6)
-
-    @property
-    def total_shares(self):
-        return sum([pos.target_shares for pos in self.positions if pos.target_shares is not None])
-
-    def to_df(self):
-        return pd.DataFrame([asdict(pos) for pos in self.positions])
-
-    def to_dict(self) -> dict[int, Decimal]:
-        return {underlying_instrument: pos.weighting for underlying_instrument, pos in self.positions_map.items()}
-
-    def __len__(self):
-        return len(self.positions)
+    def copy(self, **kwargs):
+        attrs = {f.name: getattr(self, f.name) for f in fields(Position)}
+        attrs.update(kwargs)
+        return Position(**attrs)
 
 
 @dataclass(frozen=True)
+class Order:
+    class AssetType(enum.Enum):
+        EQUITY = "EQUITY"
+        AMERICAN_DEPOSITORY_RECEIPT = "AMERICAN_DEPOSITORY_RECEIPT"
+
+    id: int | str
+    trade_date: date
+    target_weight: float
+
+    # Instrument identifier
+    asset_class: AssetType
+    refinitiv_identifier_code: str | None = None
+    bloomberg_ticker: str | None = None
+    sedol: str | None = None
+
+    weighting: float | None = None
+    target_shares: float | None = None
+    shares: float | None = None
+    execution_price: float | None = None
+    execution_instruction: ExecutionInstruction = ExecutionInstruction.MARKET_ON_CLOSE.value
+    execution_instruction_parameters: dict | None = None
+    comment: str = ""
+
+
+@dataclass()
 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")
+    daily_return: Decimal = Decimal("0")
+    effective_quantization_error: Decimal = Decimal("0")
+    target_quantization_error: Decimal = Decimal("0")
+
     id: int | None = None
-    effective_shares: Decimal = None
+    is_cash: bool = False
+
+    def __post_init__(self):
+        self.effective_weight = round(self.effective_weight, 8)
+        # ensure a trade target weight cannot be lower than 0
+        self.target_weight = max(round(self.target_weight, 8), Decimal("0"))
+        self.daily_return = round(self.daily_return, 16)
 
     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,
+            daily_return=self.daily_return,
             **{
                 f.name: getattr(self, f.name)
                 for f in fields(Trade)
@@ -105,14 +126,29 @@ class Trade:
                     "effective_weight",
                     "target_weight",
                     "effective_shares",
+                    "target_shares",
                     "underlying_instrument",
+                    "daily_return",
                 ]
             },
         )
 
+    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
+        return (self.target_weight + self.target_quantization_error) - 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
@@ -121,21 +157,30 @@ 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):
         trade_map = {}
+        if self.total_effective_weight and (quant_error := Decimal("1") - self.total_effective_weight):
+            self.largest_effective_order.effective_quantization_error = quant_error
+        if self.total_target_weight and (quant_error := Decimal("1") - self.total_target_weight):
+            self.largest_effective_order.target_quantization_error = quant_error
         for trade in self.trades:
             if trade.underlying_instrument in trade_map:
                 trade_map[trade.underlying_instrument] += trade
@@ -143,17 +188,21 @@ class TradeBatch:
                 trade_map[trade.underlying_instrument] = trade
         object.__setattr__(self, "trades_map", trade_map)
 
+    @property
+    def largest_effective_order(self) -> Trade:
+        return max(self.trades, key=lambda obj: obj.effective_weight)
+
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades]), 6)
+        return sum([trade.target_weight for trade in self.trades], Decimal("0"))
 
     @property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades]), 6)
+        return sum([trade.effective_weight for trade in self.trades], Decimal("0"))
 
     @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))
@@ -161,20 +210,106 @@ class TradeBatch:
     def __len__(self):
         return len(self.trades)
 
+    def __iter__(self):
+        return iter(self.trades_map.values())
+
     def validate(self):
         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):
-        positions = []
-        for instrument, trade in self.trades_map.items():
-            positions.append(
-                Position(
-                    underlying_instrument=trade.underlying_instrument,
-                    instrument_type=trade.instrument_type,
-                    weighting=trade.target_weight,
-                    currency=trade.currency,
-                    date=trade.date,
-                )
+
+@dataclass(frozen=True)
+class Portfolio:
+    positions: list[Position] | list
+    positions_map: dict[int, Position] = field(init=False, repr=False)
+
+    def __post_init__(self):
+        positions_map = {}
+
+        for pos in self.positions:
+            if pos.underlying_instrument in positions_map:
+                positions_map[pos.underlying_instrument] += pos
+            else:
+                positions_map[pos.underlying_instrument] = pos
+        object.__setattr__(self, "positions_map", positions_map)
+
+    @property
+    def total_weight(self):
+        return sum([pos.weighting for pos in self.positions])
+
+    @property
+    def total_shares(self):
+        return sum([pos.target_shares for pos in self.positions if pos.target_shares is not None])
+
+    def to_df(self, exclude_cash: bool = False) -> pd.DataFrame:
+        return pd.DataFrame([asdict(pos) for pos in self.positions if not exclude_cash or not pos.is_cash])
+
+    def to_dict(self) -> dict[int, Decimal]:
+        return {underlying_instrument: pos.weighting for underlying_instrument, pos in self.positions_map.items()}
+
+    def get_orders(self, target_portfolio: Self) -> TradeBatch:
+        instruments = self.positions_map.copy()
+        instruments.update(target_portfolio.positions_map)
+
+        trades: list[Trade] = []
+        for instrument_id, pos in instruments.items():
+            effective_weight = target_weight = 0
+            effective_shares = target_shares = 0
+            daily_return = 0
+            price = Decimal("0")
+            is_cash = False
+            trade_date = None
+            if effective_pos := self.positions_map.get(instrument_id, None):
+                effective_weight = effective_pos.weighting
+                effective_shares = effective_pos.shares
+                daily_return = effective_pos.daily_return
+                is_cash = effective_pos.is_cash
+                price = effective_pos.price
+                trade_date = effective_pos.date
+
+            if target_pos := target_portfolio.positions_map.get(instrument_id, None):
+                target_weight = target_pos.weighting
+                is_cash = target_pos.is_cash
+                if target_pos.shares is not None:
+                    target_shares = target_pos.shares
+                if target_pos.price:
+                    price = target_pos.price
+                trade_date = target_pos.date
+
+            trade = Trade(
+                underlying_instrument=instrument_id,
+                effective_weight=effective_weight,
+                target_weight=target_weight,
+                effective_shares=effective_shares,
+                target_shares=target_shares,
+                date=trade_date,
+                instrument_type=pos.instrument_type,
+                currency=pos.currency,
+                price=Decimal(price) if price else Decimal("0"),
+                currency_fx_rate=Decimal(pos.currency_fx_rate),
+                daily_return=Decimal(daily_return),
+                is_cash=is_cash,
             )
-        return Portfolio(tuple(positions))
+            trades.append(trade)
+        return TradeBatch(trades)
+
+    def __len__(self):
+        return len(self.positions)
+
+    def __bool__(self):
+        return len(self.positions) > 0
+
+    def normalize_cash(self, target_cash_weight: Decimal):
+        """
+        Normalize the instantiate portfolio so that the sum of the cash position equals to the new target cash position
+        """
+        positions = list(filter(lambda pos: not pos.is_cash, self.positions))
+        cash_position = next(filter(lambda pos: pos.is_cash, self.positions), None)
+        total_non_cash_weight = sum(map(lambda pos: pos.weighting, positions))
+        target_weight = Decimal("1") - target_cash_weight
+        for pos in positions:
+            pos.weighting = pos.weighting * target_weight / total_non_cash_weight
+        if cash_position:
+            cash_position.weighting = target_cash_weight
+            positions.append(cash_position)
+        return Portfolio(positions)

wbportfolio/rebalancing/base.py

@@ -8,10 +8,21 @@ class AbstractRebalancingModel:
     def validation_errors(self) -> str:
         return getattr(self, "_validation_errors", "Rebalacing cannot applied for these parameters")
 
-    def __init__(self, portfolio, trade_date: date, last_effective_date: date, **kwargs):
+    def __init__(
+        self,
+        portfolio,
+        trade_date: date,
+        last_effective_date: date,
+        effective_portfolio: PortfolioDTO | None = None,
+        **kwargs,
+    ):
         self.portfolio = portfolio
         self.trade_date = trade_date
         self.last_effective_date = last_effective_date
+        self.effective_portfolio = effective_portfolio
+        # we try to get the portfolio at the trade date
+        if not self.effective_portfolio:
+            self.effective_portfolio = self.portfolio._build_dto(self.last_effective_date)
 
     def is_valid(self) -> bool:
         return True

wbportfolio/rebalancing/decorators.py

@@ -2,7 +2,7 @@ def register(model_name: str):
     """
     Decorator to include when a backend need automatic registration
     """
-    from wbportfolio.models.transactions.rebalancing import RebalancingModel
+    from wbportfolio.models.rebalancing import RebalancingModel
 
     def _decorator(backend_class):
         defaults = {

wbportfolio/rebalancing/models/composite.py

@@ -3,7 +3,6 @@ from decimal import Decimal
 from django.core.exceptions import ObjectDoesNotExist
 from wbfdm.models import InstrumentPrice
 
-from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -14,21 +13,18 @@ class CompositeRebalancing(AbstractRebalancingModel):
     @property
     def base_assets(self) -> dict[int, Decimal]:
         """
-        Return a dictionary representation (instrument_id: target weight) of this trade proposal
+        Return a dictionary representation (instrument_id: target weight) of this order proposal
         Returns:
             A dictionary representation
 
         """
         try:
-            latest_trade_proposal = self.portfolio.trade_proposals.filter(
-                status="APPROVED", trade_date__lt=self.trade_date
+            latest_order_proposal = self.portfolio.order_proposals.filter(
+                status="CONFIRMED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]
-                for v in latest_trade_proposal.trades.all()
-                .annotate_base_info()
-                .filter(status=Trade.Status.EXECUTED)
-                .values("underlying_instrument", "target_weight")
+                for v in latest_order_proposal.get_orders().values("underlying_instrument", "target_weight")
             }
         except ObjectDoesNotExist:
             return dict()

wbportfolio/rebalancing/models/equally_weighted.py

@@ -10,23 +10,25 @@ from wbportfolio.rebalancing.decorators import register
 @register("Equally Weighted Rebalancing")
 class EquallyWeightedRebalancing(AbstractRebalancingModel):
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.assets = self.portfolio.assets.filter(date=self.last_effective_date)
+        super(EquallyWeightedRebalancing, self).__init__(*args, **kwargs)
+        if not self.effective_portfolio:
+            self.effective_portfolio = self.portfolio._build_dto(self.trade_date)
 
     def is_valid(self) -> bool:
         return (
-            self.assets.exists()
+            len(self.effective_portfolio.positions) > 0
             and InstrumentPrice.objects.filter(
-                date=self.trade_date, instrument__in=self.assets.values("underlying_quote")
+                date=self.trade_date, instrument__in=self.effective_portfolio.positions_map.keys()
             ).exists()
         )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        assets = self.portfolio.assets.filter(date=self.last_effective_date)
-        nb_assets = assets.count()
-        for asset in assets:
-            asset.date = self.trade_date
-            asset.asset_valuation_date = self.trade_date
-            positions.append(asset._build_dto(new_weight=Decimal(1 / nb_assets)))
-        return Portfolio(positions=tuple(positions))
+        assets = list(filter(lambda p: not p.is_cash, self.effective_portfolio.positions))
+        for position in assets:
+            positions.append(
+                position.copy(
+                    weighting=Decimal(1 / len(assets)), date=self.trade_date, asset_valuation_date=self.trade_date
+                )
+            )
+        return Portfolio(positions)

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -12,7 +12,9 @@ from wbfdm.models import (
     InstrumentListThroughModel,
 )
 
+from wbportfolio.pms.analytics.utils import fix_quantization_error
 from wbportfolio.pms.typing import Portfolio, Position
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
 
@@ -20,9 +22,17 @@ from wbportfolio.rebalancing.decorators import register
 @register("Market Capitalization Rebalancing")
 class MarketCapitalizationRebalancing(AbstractRebalancingModel):
     TARGET_CURRENCY: str = "USD"
+    MIN_WEIGHT: float = 1e-5  # we allow only weight of minimum 0.01%
 
-    def __init__(self, *args, bypass_exchange_check: bool = False, ffill_market_cap_limit: int = 5, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(
+        self,
+        *args,
+        bypass_exchange_check: bool = False,
+        ffill_market_cap_limit: int = 5,
+        effective_portfolio: PortfolioDTO | None = None,
+        **kwargs,
+    ):
+        super().__init__(*args, effective_portfolio=effective_portfolio, **kwargs)
         self.bypass_exchange_check = bypass_exchange_check
         instruments = self._get_instruments(**kwargs)
         self.market_cap_df = pd.DataFrame(
@@ -78,9 +88,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
             )
 
         if not instrument_ids:
-            instrument_ids = list(
-                self.portfolio.assets.filter(date=self.trade_date).values_list("underlying_instrument", flat=True)
-            )
+            instrument_ids = list(self.effective_portfolio.positions_map.keys())
 
         return (
             Instrument.objects.filter(id__in=instrument_ids)
@@ -100,22 +108,21 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
                 return df.any()
             else:
                 if missing_exchanges.exists():
-                    setattr(
-                        self,
-                        "_validation_errors",
-                        f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}",
-                    )
+                    self._validation_errors = f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}"
                 return df.all()
         return False
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        total_market_cap = self.market_cap_df.dropna().sum()
-        for underlying_instrument, market_cap in self.market_cap_df.to_dict().items():
-            if np.isnan(market_cap):
+        df = self.market_cap_df / self.market_cap_df.dropna().sum()
+        df = df[df > self.MIN_WEIGHT]
+        df = df / df.sum()
+        df = fix_quantization_error(df, 8)
+        for underlying_instrument, weighting in df.to_dict().items():
+            if np.isnan(weighting):
                 weighting = Decimal(0)
             else:
-                weighting = Decimal(market_cap / total_market_cap)
+                weighting = round(Decimal(weighting), 8)
             positions.append(
                 Position(
                     underlying_instrument=underlying_instrument,

wbportfolio/rebalancing/models/model_portfolio.py

@@ -1,5 +1,3 @@
-from wbfdm.models import InstrumentPrice
-
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -9,6 +7,11 @@ from wbportfolio.rebalancing.decorators import register
 class ModelPortfolioRebalancing(AbstractRebalancingModel):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.value_date = (
+            self.trade_date
+            if self.model_portfolio.assets.filter(date=self.trade_date).exists()
+            else self.last_effective_date
+        )
 
     @property
     def model_portfolio_rel(self):
@@ -16,26 +19,19 @@ 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.value_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
+        return len(self.assets) > 0
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        assets = self.model_portfolio.get_positions(self.last_effective_date)
-
-        for asset in assets:
-            asset.date = self.trade_date
-            asset.asset_valuation_date = self.trade_date
+        for asset in self.assets:
+            asset.date = self.value_date
+            asset.asset_valuation_date = self.value_date
             positions.append(asset._build_dto())
         return Portfolio(positions=tuple(positions))

wbportfolio/risk_management/backends/__init__.py

@@ -9,3 +9,4 @@ from .ucits_portfolio import *
 from .accounts import *
 from .product_integrity import *
 from .liquidity_risk import *
+from .esg_aggregation_portfolio import *

wbportfolio/risk_management/backends/controversy_portfolio.py

@@ -2,7 +2,7 @@ from typing import Generator
 
 from wbcompliance.models.risk_management import backend
 from wbcompliance.models.risk_management.dispatch import register
-from wbcompliance.models.risk_management.rules import RiskIncidentType
+from wbcompliance.models.risk_management.incidents import RiskIncidentType
 from wbcore import serializers as wb_serializers
 from wbfdm.enums import ESGControveryFlag
 from wbfdm.models import Instrument
@@ -44,7 +44,7 @@ class RuleBackend(ActivePortfolioRelationshipMixin):
         return RuleBackendSerializer
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
-        for instrument_id, weight in portfolio.positions_map.items():
+        for instrument_id in portfolio.positions_map.keys():
             instrument = Instrument.objects.get(id=instrument_id)
             if (
                 controversies := Controversy.objects.filter(