wbportfolio 1.54.23__py2.py3-none-any.whl → 1.55.4__py2.py3-none-any.whl

wbportfolio/pms/trading/handler.py

@@ -145,12 +145,15 @@ class TradingService:
             previous_weight = target_weight = 0
             effective_shares = target_shares = 0
             daily_return = 0
+            is_cash = False
             if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
                 previous_weight = effective_pos.weighting
                 effective_shares = effective_pos.shares
                 daily_return = effective_pos.daily_return
+                is_cash = effective_pos.is_cash
             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
             trade = Trade(
@@ -166,6 +169,7 @@ class TradingService:
                 currency_fx_rate=Decimal(pos.currency_fx_rate),
                 daily_return=Decimal(daily_return),
                 portfolio_contribution=effective_portfolio.portfolio_contribution,
+                is_cash=is_cash,
             )
             trades.append(trade)
         return TradeBatch(trades)

wbportfolio/pms/typing.py

@@ -1,4 +1,6 @@
+import enum
 from dataclasses import asdict, dataclass, field, fields
+from datetime import date
 from datetime import date as date_lib
 from decimal import Decimal
 
@@ -13,7 +15,7 @@ class Valuation:
     outstanding_shares: Decimal = Decimal(0)
 
 
-@dataclass(frozen=True)
+@dataclass()
 class Position:
     underlying_instrument: int
     weighting: Decimal
@@ -38,6 +40,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,
@@ -58,6 +64,7 @@ class Portfolio:
 
     def __post_init__(self):
         positions_map = {}
+
         for pos in self.positions:
             if pos.underlying_instrument in positions_map:
                 positions_map[pos.underlying_instrument] += pos
@@ -67,7 +74,7 @@ class Portfolio:
 
     @property
     def total_weight(self):
-        return round(sum([pos.weighting for pos in self.positions]), 8)
+        return sum([pos.weighting for pos in self.positions])
 
     @property
     def total_shares(self):
@@ -75,7 +82,7 @@ class Portfolio:
 
     @property
     def portfolio_contribution(self) -> Decimal:
-        return sum(map(lambda pos: pos.weighting * (Decimal("1") + pos.daily_return), self.positions))
+        return round(sum(map(lambda pos: pos.weighting * (Decimal("1") + pos.daily_return), self.positions)), 16)
 
     def to_df(self):
         return pd.DataFrame([asdict(pos) for pos in self.positions])
@@ -91,6 +98,28 @@ class Portfolio:
 
 
 @dataclass(frozen=True)
+class Order:
+    class AssetType(enum.Enum):
+        EQUITY = "EQUITY"
+
+    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_instruction: str | None = None
+    comment: str = ""
+
+
+@dataclass()
 class Trade:
     underlying_instrument: int
     instrument_type: int
@@ -104,9 +133,19 @@ class Trade:
     target_shares: Decimal = Decimal("0")
     daily_return: Decimal = Decimal("0")
     portfolio_contribution: Decimal = Decimal("1")
+    quantization_error: Decimal = Decimal("0")
+
     id: int | None = None
     is_cash: bool = False
 
+    def __post_init__(self):
+        self.previous_weight = round(self.previous_weight, 8)
+        # ensure a trade target weight cannot be lower than 0
+        self.target_weight = round(self.target_weight, 8)
+        if self.target_weight < Decimal("1e-7"):
+            self.target_weight = Decimal("0")
+        self.daily_return = round(self.daily_return, 16)
+
     def __add__(self, other):
         return Trade(
             underlying_instrument=self.underlying_instrument,
@@ -137,12 +176,20 @@ class Trade:
         attrs.update(kwargs)
         return Trade(**attrs)
 
+    def set_quantization_error(self, quantization_error: Decimal):
+        self.quantization_error = quantization_error
+        self.target_weight += quantization_error
+
     @property
     def effective_weight(self) -> Decimal:
         return (
-            self.previous_weight * (round(self.daily_return, 16) + 1) / self.portfolio_contribution
-            if self.portfolio_contribution
-            else self.previous_weight
+            round(
+                self.previous_weight * (self.daily_return + 1) / self.portfolio_contribution
+                if self.portfolio_contribution
+                else self.previous_weight,
+                8,
+            )
+            + self.quantization_error
         )
 
     @property
@@ -184,6 +231,9 @@ class TradeBatch:
 
     def __post_init__(self):
         trade_map = {}
+        total_effective_weight = self.total_effective_weight
+        if total_effective_weight and (quant_error := Decimal("1") - self.total_effective_weight):
+            self.largest_effective_order.set_quantization_error(quant_error)
         for trade in self.trades:
             if trade.underlying_instrument in trade_map:
                 trade_map[trade.underlying_instrument] += trade
@@ -191,13 +241,17 @@ 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.previous_weight)
+
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades], Decimal("0")), 8)
+        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], Decimal("0")), 8)
+        return sum([trade.effective_weight for trade in self.trades], Decimal("0"))
 
     @property
     def total_abs_delta_weight(self) -> Decimal:

wbportfolio/rebalancing/models/composite.py

@@ -20,7 +20,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
         """
         try:
             latest_order_proposal = self.portfolio.order_proposals.filter(
-                status="APPROVED", trade_date__lt=self.trade_date
+                status="APPLIED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]

wbportfolio/rebalancing/models/equally_weighted.py

@@ -24,11 +24,11 @@ class EquallyWeightedRebalancing(AbstractRebalancingModel):
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        nb_assets = len(self.effective_portfolio.positions)
-        for position in self.effective_portfolio.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 / nb_assets), date=self.trade_date, asset_valuation_date=self.trade_date
+                    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

@@ -22,7 +22,7 @@ from wbportfolio.rebalancing.decorators import register
 @register("Market Capitalization Rebalancing")
 class MarketCapitalizationRebalancing(AbstractRebalancingModel):
     TARGET_CURRENCY: str = "USD"
-    MIN_WEIGHT: float = 10e-5  # we allow only weight of minimum 0.01%
+    MIN_WEIGHT: float = 1e-5  # we allow only weight of minimum 0.01%
 
     def __init__(
         self,

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):
@@ -20,19 +23,15 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
 
     @property
     def assets(self):
-        return self.model_portfolio.get_positions(self.last_effective_date) if self.model_portfolio else []
+        return self.model_portfolio.get_positions(self.value_date) if self.model_portfolio else []
 
     def is_valid(self) -> bool:
-        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()
-        )
+        return len(self.assets) > 0
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
         for asset in self.assets:
-            asset.date = self.trade_date
-            asset.asset_valuation_date = self.trade_date
+            asset.date = self.value_date
+            asset.asset_valuation_date = self.value_date
             positions.append(asset._build_dto())
         return Portfolio(positions=tuple(positions))

wbportfolio/serializers/orders/order_proposals.py

@@ -2,7 +2,8 @@ from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
-from wbcore.serializers import DefaultFromView
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.serializers import CharField, DefaultFromView
 
 from wbportfolio.models import OrderProposal, Portfolio, RebalancingModel
 
@@ -18,6 +19,7 @@ class OrderProposalRepresentationSerializer(wb_serializers.RepresentationSeriali
 
 
 class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
     rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
     _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
     target_portfolio = wb_serializers.PrimaryKeyRelatedField(
@@ -27,6 +29,15 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     trade_date = wb_serializers.DateField(
         read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
     )
+    _creator = PersonRepresentationSerializer(source="creator")
+    _approver = PersonRepresentationSerializer(source="approver")
+    execution_status_repr = wb_serializers.SerializerMethodField(label="Status", field_class=CharField, read_only=True)
+
+    def get_execution_status_repr(self, obj):
+        repr = obj.execution_status
+        if obj.execution_status_detail:
+            repr += f" (Custodian: {obj.execution_status_detail})"
+        return repr
 
     def create(self, validated_data):
         target_portfolio = validated_data.pop("target_portfolio", None)
@@ -53,7 +64,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     @wb_serializers.register_only_instance_resource()
     def additional_resources(self, instance, request, user, **kwargs):
         res = {}
-        if instance.status == OrderProposal.Status.APPROVED:
+        if instance.status == OrderProposal.Status.APPLIED:
             res["replay"] = reverse("wbportfolio:orderproposal-replay", args=[instance.id], request=request)
         if instance.status == OrderProposal.Status.DRAFT:
             res["reset"] = reverse("wbportfolio:orderproposal-reset", args=[instance.id], request=request)
@@ -73,15 +84,24 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
         fields = (
             "id",
             "trade_date",
+            "portfolio",
+            "_portfolio",
             "total_cash_weight",
             "comment",
             "status",
             "min_order_value",
-            "portfolio",
             "_rebalancing_model",
             "rebalancing_model",
             "target_portfolio",
             "_target_portfolio",
+            "creator",
+            "approver",
+            "_creator",
+            "_approver",
+            "execution_status",
+            "execution_status_detail",
+            "execution_comment",
+            "execution_status_repr",
             "_additional_resources",
         )
 

wbportfolio/serializers/orders/orders.py

@@ -42,6 +42,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
     underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
     underlying_instrument_refinitiv_identifier_code = wb_serializers.CharField(read_only=True)
     underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
+    underlying_instrument_exchange = wb_serializers.CharField(read_only=True)
 
     target_weight = wb_serializers.DecimalField(
         max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
@@ -83,8 +84,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
         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
+            data["desired_target_weight"] = target_weight
         if weighting >= 0:
             data["order_type"] = "BUY"
         else:
@@ -124,6 +124,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "underlying_instrument_ticker",
             "underlying_instrument_refinitiv_identifier_code",
             "underlying_instrument_instrument_type",
+            "underlying_instrument_exchange",
             "order_type",
             "comment",
             "effective_weight",
@@ -138,6 +139,8 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "target_total_value_fx_portfolio",
             "portfolio_currency",
             "has_warnings",
+            "execution_confirmed",
+            "execution_comment",
         )
 
 

wbportfolio/serializers/positions.py

@@ -11,8 +11,8 @@ class AggregatedAssetPositionModelSerializer(wb_serializers.ModelSerializer):
     sum_total_value = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=4)
     weighting = wb_serializers.DecimalField(
         read_only=True,
-        max_digits=6,
-        decimal_places=4,
+        max_digits=9,
+        decimal_places=8,
         percent=True,
         decorators=[{"position": "right", "value": "%"}],
     )

wbportfolio/serializers/rebalancing.py

@@ -49,7 +49,7 @@ class RebalancerModelSerializer(wb_serializers.ModelSerializer):
             "computed_str",
             "_rebalancing_model",
             "rebalancing_model",
-            "approve_order_proposal_automatically",
+            "apply_order_proposal_automatically",
             "activation_date",
             "frequency",
             "frequency_repr",

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -118,13 +118,13 @@ class TestOrderProposal:
         """
         tp = order_proposal_factory.create()
         tp_previous_submit = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date - BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_previous_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(2)).date()
         )
         tp_next_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(1)).date()
         )
 
         # The previous valid order proposal should be the approved one strictly before the current proposal
@@ -139,13 +139,13 @@ class TestOrderProposal:
         """
         tp = order_proposal_factory.create()
         tp_previous_approve = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date - BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date - BDay(1)).date()
         )
         tp_next_submit = order_proposal_factory.create(  # noqa
-            portfolio=tp.portfolio, status=OrderProposal.Status.SUBMIT, trade_date=(tp.trade_date + BDay(1)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.PENDING, trade_date=(tp.trade_date + BDay(1)).date()
         )
         tp_next_approve = order_proposal_factory.create(
-            portfolio=tp.portfolio, status=OrderProposal.Status.APPROVED, trade_date=(tp.trade_date + BDay(2)).date()
+            portfolio=tp.portfolio, status=OrderProposal.Status.APPLIED, trade_date=(tp.trade_date + BDay(2)).date()
         )
 
         # The next valid order proposal should be the approved one strictly after the current proposal
@@ -255,11 +255,12 @@ class TestOrderProposal:
 
     # Test resetting orders
     def test_reset_orders(
-        self, order_proposal, instrument_factory, cash, instrument_price_factory, asset_position_factory
+        self, order_proposal, instrument_factory, cash_factory, instrument_price_factory, asset_position_factory
     ):
         """
         Verify orders are correctly reset based on effective and target portfolios.
         """
+        cash = cash_factory.create()
         effective_date = order_proposal.last_effective_date
 
         # Create instruments for testing
@@ -389,15 +390,15 @@ class TestOrderProposal:
         mock_fct.return_value = iter([])
 
         # Create approved order proposals for testing
-        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPROVED)
+        tp0 = order_proposal_factory.create(status=OrderProposal.Status.APPLIED)
         tp1 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPLIED,
             trade_date=(tp0.trade_date + BusinessMonthEnd(1)).date(),
         )
         tp2 = order_proposal_factory.create(
             portfolio=tp0.portfolio,
-            status=OrderProposal.Status.APPROVED,
+            status=OrderProposal.Status.APPLIED,
             trade_date=(tp1.trade_date + BusinessMonthEnd(1)).date(),
         )
 
@@ -499,9 +500,10 @@ class TestOrderProposal:
         instrument.exchange.save()
         assert order_proposal.get_round_lot_size(Decimal("66"), instrument) == Decimal("66")
 
-    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument):
+    def test_submit_round_lot_size(self, order_proposal, order_factory, instrument_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
+        instrument = instrument_factory.create()
         instrument.round_lot_size = 100
         instrument.save()
         trade = order_factory.create(
@@ -518,11 +520,10 @@ class TestOrderProposal:
         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, order_proposal, order_factory, instrument):
+    def test_submit_round_fractional_shares(self, order_proposal, order_factory):
         order_proposal.portfolio.only_weighting = False
         order_proposal.portfolio.save()
         trade = order_factory.create(
-            underlying_instrument=instrument,
             shares=5.6,
             order_proposal=order_proposal,
             weighting=Decimal("1.0"),
@@ -640,6 +641,7 @@ class TestOrderProposal:
         order_proposal.submit()
         order_proposal.save()
         order_proposal.approve()
+        order_proposal.apply()
         order_proposal.save()
 
         # Final check that weights have been updated to 50%
@@ -651,8 +653,9 @@ class TestOrderProposal:
         )
 
     def test_replay_reset_draft_order_proposal(
-        self, instrument, instrument_price_factory, order_factory, order_proposal_factory
+        self, instrument_factory, instrument_price_factory, order_factory, order_proposal_factory
     ):
+        instrument = instrument_factory.create()
         order_proposal = order_proposal_factory.create(trade_date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(2))
         instrument_price_factory.create(instrument=instrument, date=date.today() - BDay(1))
@@ -663,7 +666,8 @@ class TestOrderProposal:
             weighting=1,
         )
         order_proposal.submit()
-        order_proposal.approve(replay=False)
+        order_proposal.approve()
+        order_proposal.apply(replay=False)
         order_proposal.save()
 
         draft_tp = order_proposal_factory.create(portfolio=order_proposal.portfolio, trade_date=date.today() - BDay(1))
@@ -700,6 +704,7 @@ class TestOrderProposal:
         )
         order_proposal.submit()
         order_proposal.approve()
+        order_proposal.apply()
         order_proposal.save()
 
         order1.refresh_from_db()
@@ -733,3 +738,12 @@ class TestOrderProposal:
         assert order_proposal.get_orders().aggregate(s=Sum("target_weight"))["s"] == Decimal(
             "0.98"
         ), "The total target weight leftover does not equal the stored total cash weight"
+
+    def test_convert_to_portfolio_always_100percent(self, order_proposal, order_factory):
+        o1 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.5"))
+        o2 = order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.3"))
+
+        portfolio = order_proposal.convert_to_portfolio()
+        assert portfolio.positions_map[o1.underlying_instrument.id].weighting == Decimal("0.5")
+        assert portfolio.positions_map[o2.underlying_instrument.id].weighting == Decimal("0.3")
+        assert portfolio.positions_map[order_proposal.cash_component.id].weighting == Decimal("0.2")

wbportfolio/tests/models/test_imports.py

@@ -31,16 +31,15 @@ class TestImportMixinModel:
 
         trade = trade_factory.build()
         data = {"data": [serialize(trade)]}
-        handler = TradeImportHandler(import_source)
 
         # Import non existing data
-        handler.process(data)
+        TradeImportHandler(import_source).process(data)
         assert Trade.objects.count() == 1
 
         # Import already existing data
         # import_source.data['data'][0]['shares'] *= 2
 
-        handler.process(data)
+        TradeImportHandler(import_source).process(data)
         assert Trade.objects.count() == 1
 
     def test_import_price(self, import_source, product, instrument_price_factory, instrument):
@@ -137,7 +136,9 @@ class TestImportMixinModel:
         data = {
             "data": [
                 self._serialize_position(
-                    asset_position_factory.build(date=val_date, underlying_instrument=instrument),
+                    asset_position_factory.build(
+                        date=val_date, underlying_instrument=instrument, weighting=Decimal("0.25")
+                    ),
                     product_portfolio,
                     instrument,
                 )
@@ -171,7 +172,7 @@ class TestImportMixinModel:
     def test_import_assetposition_product_group(
         self, import_source, product_group, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         data = {"data": [self._serialize_position(positions, product_group, equity)]}
 
         # Import non existing data
@@ -183,7 +184,7 @@ class TestImportMixinModel:
     def test_import_assetposition_index(
         self, import_source, index, portfolio, currency, equity, asset_position_factory
     ):
-        positions = asset_position_factory.build(underlying_instrument=equity)
+        positions = asset_position_factory.build(underlying_instrument=equity, weighting=Decimal("1"))
         index.portfolios.add(portfolio)
         data = {"data": [self._serialize_position(positions, index, equity)]}