wbportfolio 1.54.14__py2.py3-none-any.whl → 1.54.16__py2.py3-none-any.whl

wbportfolio/pms/trading/handler.py

@@ -117,7 +117,7 @@ class TradingService:
         if self._effective_portfolio:
             for trade in validated_trades:
                 if (
-                    trade.effective_weight
+                    trade.previous_weight
                     and trade.underlying_instrument not in self._effective_portfolio.positions_map
                 ):
                     raise ValidationError("All effective position needs to be matched with a validated trade")
@@ -137,37 +137,38 @@ class TradingService:
 
         Returns: The normalized trades batch
         """
+
         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:
-                previous_weight = target_weight = 0
-                effective_shares = target_shares = 0
-                drift_factor = 1.0
-                if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
-                    previous_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
-                trade = Trade(
-                    underlying_instrument=instrument_id,
-                    previous_weight=previous_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) if pos.price is not None else Decimal("0"),
-                    currency_fx_rate=Decimal(pos.currency_fx_rate),
-                    drift_factor=Decimal(drift_factor),
-                )
-                trades.append(trade)
+            previous_weight = target_weight = 0
+            effective_shares = target_shares = 0
+            daily_return = 0
+            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
+            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
+            trade = Trade(
+                underlying_instrument=instrument_id,
+                previous_weight=previous_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) if pos.price is not None else Decimal("0"),
+                currency_fx_rate=Decimal(pos.currency_fx_rate),
+                daily_return=Decimal(daily_return),
+                portfolio_contribution=effective_portfolio.portfolio_contribution,
+            )
+            trades.append(trade)
         return TradeBatch(trades)
 
     def is_valid(self, ignore_error: bool = False) -> bool:

wbportfolio/pms/typing.py

@@ -19,7 +19,7 @@ class Position:
     weighting: Decimal
     date: date_lib
 
-    drift_factor: Decimal = Decimal("1")
+    daily_return: Decimal = Decimal("0")
     currency: int | None = None
     instrument_type: int | None = None
     asset_valuation_date: date_lib | None = None
@@ -73,6 +73,10 @@ class Portfolio:
     def total_shares(self):
         return sum([pos.target_shares for pos in self.positions if pos.target_shares is not None])
 
+    @property
+    def portfolio_contribution(self) -> Decimal:
+        return sum(map(lambda pos: pos.weighting * (Decimal("1") + pos.daily_return), self.positions))
+
     def to_df(self):
         return pd.DataFrame([asdict(pos) for pos in self.positions])
 
@@ -98,7 +102,8 @@ class Trade:
     currency_fx_rate: Decimal = Decimal("1")
     effective_shares: Decimal = Decimal("0")
     target_shares: Decimal = Decimal("0")
-    drift_factor: Decimal = Decimal("1")
+    daily_return: Decimal = Decimal("0")
+    portfolio_contribution: Decimal = Decimal("1")
     id: int | None = None
     is_cash: bool = False
 
@@ -109,8 +114,9 @@ class Trade:
             target_weight=self.target_weight + other.target_weight,
             effective_shares=self.effective_shares,
             target_shares=self.target_shares + other.target_shares,
-            drift_factor=self.drift_factor
-            ** {
+            daily_return=self.daily_return,
+            portfolio_contribution=self.portfolio_contribution,
+            **{
                 f.name: getattr(self, f.name)
                 for f in fields(Trade)
                 if f.name
@@ -120,7 +126,8 @@ class Trade:
                     "effective_shares",
                     "target_shares",
                     "underlying_instrument",
-                    "drift_factor",
+                    "daily_return",
+                    "portfolio_contribution",
                 ]
             },
         )
@@ -132,7 +139,11 @@ class Trade:
 
     @property
     def effective_weight(self) -> Decimal:
-        return self.previous_weight * self.drift_factor
+        return (
+            self.previous_weight * (round(self.daily_return, 16) + 1) / self.portfolio_contribution
+            if self.portfolio_contribution
+            else self.previous_weight
+        )
 
     @property
     def delta_weight(self) -> Decimal:
@@ -210,7 +221,7 @@ class TradeBatch:
                     underlying_instrument=trade.underlying_instrument,
                     instrument_type=trade.instrument_type,
                     weighting=trade.target_weight if not use_effective else trade.previous_weight,
-                    drift_factor=trade.drift_factor if use_effective else Decimal("1"),
+                    daily_return=trade.daily_return if use_effective else Decimal("0"),
                     shares=trade.target_shares,
                     currency=trade.currency,
                     date=trade.date,

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(
+            latest_order_proposal = self.portfolio.order_proposals.filter(
                 status="APPROVED", 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/market_capitalization_weighted.py

@@ -12,6 +12,7 @@ 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
@@ -120,11 +121,12 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
         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(weighting)
+                weighting = round(Decimal(weighting), 8)
             positions.append(
                 Position(
                     underlying_instrument=underlying_instrument,

wbportfolio/serializers/__init__.py

@@ -27,6 +27,7 @@ from .registers import RegisterModelSerializer, RegisterRepresentationSerializer
 from .roles import PortfolioRoleModelSerializer, PortfolioRoleProjectModelSerializer
 from .signals import *
 from .transactions import *
+from .orders import *
 from .products import (
     ProductRepresentationSerializer,
     ProductCustomerRepresentationSerializer,

wbportfolio/serializers/orders/__init__.py

@@ -0,0 +1,2 @@
+from .order_proposals import OrderProposalModelSerializer, ReadOnlyOrderProposalModelSerializer, OrderProposalRepresentationSerializer
+from .orders import OrderOrderProposalModelSerializer, ReadOnlyOrderOrderProposalModelSerializer, OrderOrderProposalListModelSerializer

wbportfolio/serializers/{transactions/trade_proposals.py → orders/order_proposals.py}

@@ -6,16 +6,24 @@ from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
 from wbcore.serializers import DefaultFromView
 
-from wbportfolio.models import Portfolio, RebalancingModel, TradeProposal
+from wbportfolio.models import OrderProposal, Portfolio, RebalancingModel
 
 from .. import PortfolioRepresentationSerializer, RebalancingModelRepresentationSerializer
 
 
-class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
+class OrderProposalRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:orderproposal-detail")
+
+    class Meta:
+        model = OrderProposal
+        fields = ("id", "trade_date", "status", "_detail")
+
+
+class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
     _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
     target_portfolio = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
+        queryset=Portfolio.objects.all(), write_only=True, required=False
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
     total_cash_weight = wb_serializers.DecimalField(
@@ -43,10 +51,15 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         obj = super().create(validated_data)
 
         target_portfolio_dto = None
-        if target_portfolio and not rebalancing_model:
+        if target_portfolio:
             target_portfolio_dto = target_portfolio._build_dto(obj.trade_date)
+        elif rebalancing_model:
+            target_portfolio_dto = rebalancing_model.get_target_portfolio(
+                obj.portfolio, obj.trade_date, obj.last_effective_date
+            )
+
         try:
-            obj.reset_trades(
+            obj.reset_orders(
                 target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight
             )
         except ValidationError as e:
@@ -57,21 +70,21 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
     @wb_serializers.register_only_instance_resource()
     def additional_resources(self, instance, request, user, **kwargs):
         res = {}
-        if instance.status == TradeProposal.Status.APPROVED:
-            res["replay"] = reverse("wbportfolio:tradeproposal-replay", args=[instance.id], request=request)
-        if instance.status == TradeProposal.Status.DRAFT:
-            res["reset"] = reverse("wbportfolio:tradeproposal-reset", args=[instance.id], request=request)
-            res["normalize"] = reverse("wbportfolio:tradeproposal-normalize", args=[instance.id], request=request)
-            res["deleteall"] = reverse("wbportfolio:tradeproposal-deleteall", args=[instance.id], request=request)
-        res["trades"] = reverse(
-            "wbportfolio:tradeproposal-trade-list",
+        if instance.status == OrderProposal.Status.APPROVED:
+            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)
+            res["normalize"] = reverse("wbportfolio:orderproposal-normalize", args=[instance.id], request=request)
+            res["deleteall"] = reverse("wbportfolio:orderproposal-deleteall", args=[instance.id], request=request)
+        res["orders"] = reverse(
+            "wbportfolio:orderproposal-order-list",
             args=[instance.id],
             request=request,
         )
         return res
 
     class Meta:
-        model = TradeProposal
+        model = OrderProposal
         only_fsm_transition_on_instance = True
         fields = (
             "id",
@@ -88,6 +101,6 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         )
 
 
-class ReadOnlyTradeProposalModelSerializer(TradeProposalModelSerializer):
-    class Meta(TradeProposalModelSerializer.Meta):
-        read_only_fields = TradeProposalModelSerializer.Meta.fields
+class ReadOnlyOrderProposalModelSerializer(OrderProposalModelSerializer):
+    class Meta(OrderProposalModelSerializer.Meta):
+        read_only_fields = OrderProposalModelSerializer.Meta.fields

wbportfolio/serializers/orders/orders.py

@@ -0,0 +1,187 @@
+from decimal import Decimal
+
+from rest_framework import serializers
+from wbcore import serializers as wb_serializers
+from wbcore.metadata.configs.display.list_display import BaseTreeGroupLevelOption
+from wbfdm.models import Instrument
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
+from wbfdm.serializers.instruments.instruments import (
+    CompanyRepresentationSerializer,
+    SecurityRepresentationSerializer,
+)
+
+from wbportfolio.models import Order
+
+
+class GetSecurityDefault:
+    requires_context = True
+
+    def __call__(self, serializer_instance):
+        try:
+            instance = serializer_instance.view.get_object()
+            return instance.underlying_instrument.parent or instance.underlying_instrument
+        except Exception:
+            return None
+
+
+class GetCompanyDefault:
+    requires_context = True
+
+    def __call__(self, serializer_instance):
+        try:
+            instance = serializer_instance.view.get_object()
+            security = instance.underlying_instrument.parent or instance.underlying_instrument
+            return security.parent or security
+        except Exception:
+            return None
+
+
+class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
+    underlying_instrument = wb_serializers.SlugRelatedField(read_only=True, slug_field="name")
+    underlying_instrument_isin = wb_serializers.CharField(read_only=True)
+    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)
+
+    target_weight = wb_serializers.DecimalField(
+        max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        required=False,
+        default=0,
+    )
+    effective_weight = wb_serializers.DecimalField(
+        read_only=True,
+        max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        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)
+    has_warnings = wb_serializers.BooleanField(read_only=True)
+
+    def validate(self, data):
+        data.pop("company", None)
+        data.pop("security", None)
+        if self.instance and "underlying_instrument" in data:
+            raise serializers.ValidationError(
+                {
+                    "underlying_instrument": "You cannot modify the underlying instrument other than creating a new entry"
+                }
+            )
+        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:
+            data["order_type"] = "BUY"
+        else:
+            data["order_type"] = "SELL"
+        data["weighting"] = weighting
+        return super().validate(data)
+
+    class Meta:
+        model = Order
+        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 = (
+            "order_type",
+            "shares",
+            "effective_shares",
+            "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
+            "has_warnings",
+        )
+        fields = (
+            "id",
+            "shares",
+            "underlying_instrument",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument_refinitiv_identifier_code",
+            "underlying_instrument_instrument_type",
+            "order_type",
+            "comment",
+            "effective_weight",
+            "target_weight",
+            "weighting",
+            "order_proposal",
+            "order",
+            "effective_shares",
+            "target_shares",
+            "total_value_fx_portfolio",
+            "effective_total_value_fx_portfolio",
+            "target_total_value_fx_portfolio",
+            "portfolio_currency",
+            "has_warnings",
+        )
+
+
+class OrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
+    company = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.filter(level=0),
+        required=False,
+        read_only=lambda view: not view.new_mode,
+        default=GetCompanyDefault(),
+    )
+    _company = CompanyRepresentationSerializer(source="company", required=False)
+
+    security = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.filter(is_security=True),
+        required=False,
+        read_only=lambda view: not view.new_mode,
+        default=GetSecurityDefault(),
+    )
+    _security = SecurityRepresentationSerializer(
+        source="security",
+        optional_get_parameters={"company": "parent"},
+        depends_on=[{"field": "company", "options": {}}],
+        required=False,
+    )
+    underlying_instrument = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Instrument.objects.all(), label="Quote", read_only=lambda view: not view.new_mode
+    )
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
+        source="underlying_instrument",
+        optional_get_parameters={"security": "parent"},
+        depends_on=[{"field": "security", "options": {}}],
+        tree_config=BaseTreeGroupLevelOption(clear_filter=True, filter_key="parent"),
+    )
+
+    class Meta(OrderOrderProposalListModelSerializer.Meta):
+        fields = list(OrderOrderProposalListModelSerializer.Meta.fields) + [
+            "company",
+            "_company",
+            "security",
+            "_security",
+            "_underlying_instrument",
+        ]
+
+
+class ReadOnlyOrderOrderProposalModelSerializer(OrderOrderProposalListModelSerializer):
+    class Meta(OrderOrderProposalListModelSerializer.Meta):
+        read_only_fields = OrderOrderProposalListModelSerializer.Meta.fields

wbportfolio/serializers/portfolios.py

@@ -34,10 +34,10 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
 
     last_asset_under_management_usd = wb_serializers.FloatField(read_only=True)
     last_positions = wb_serializers.FloatField(read_only=True)
-    last_trade_proposal_date = wb_serializers.DateField(read_only=True)
-    next_expected_trade_proposal_date = wb_serializers.SerializerMethodField(read_only=True)
+    last_order_proposal_date = wb_serializers.DateField(read_only=True)
+    next_expected_order_proposal_date = wb_serializers.SerializerMethodField(read_only=True)
 
-    def get_next_expected_trade_proposal_date(self, obj):
+    def get_next_expected_order_proposal_date(self, obj):
         if (automatic_rebalancer := getattr(obj, "automatic_rebalancer", None)) and (
             _d := automatic_rebalancer.get_next_rebalancing_date(date.today())
         ):
@@ -107,8 +107,8 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             args=[instance.id],
             request=request,
         )
-        additional_resources["trade_proposals"] = reverse(
-            "wbportfolio:portfolio-tradeproposal-list",
+        additional_resources["order_proposals"] = reverse(
+            "wbportfolio:portfolio-orderproposal-list",
             args=[instance.id],
             request=request,
         )
@@ -169,8 +169,8 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "last_position_date",
             "last_asset_under_management_usd",
             "last_positions",
-            "last_trade_proposal_date",
-            "next_expected_trade_proposal_date",
+            "last_order_proposal_date",
+            "next_expected_order_proposal_date",
         )
 
 

wbportfolio/serializers/rebalancing.py

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

wbportfolio/serializers/transactions/__init__.py

@@ -1,4 +1,3 @@
-from .trade_proposals import TradeProposalModelSerializer, ReadOnlyTradeProposalModelSerializer
 from .claim import (
     ClaimAccountSerializer,
     ClaimAPIModelSerializer,
@@ -12,8 +11,5 @@ from .dividends import DividendModelSerializer, DividendRepresentationSerializer
 from .fees import FeesModelSerializer, FeesRepresentationSerializer
 from .trades import (
     TradeModelSerializer,
-    TradeProposalRepresentationSerializer,
-    TradeRepresentationSerializer,
-    TradeTradeProposalModelSerializer,
-    ReadOnlyTradeTradeProposalModelSerializer,
+    TradeRepresentationSerializer
 )