wbportfolio 1.48.0__py2.py3-none-any.whl → 1.49.0__py2.py3-none-any.whl

wbportfolio/models/transactions/trades.py

@@ -136,6 +136,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         REDEMPTION = "REDEMPTION", "Redemption"
         BUY = "BUY", "Buy"
         SELL = "SELL", "Sell"
+        NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
 
     external_identifier2 = models.CharField(
         max_length=255,
@@ -224,7 +225,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         source=Status.DRAFT,
         target=GET_STATE(
             lambda self, **kwargs: (
-                self.Status.SUBMIT if self.underlying_quote_price is not None else self.Status.FAILED
+                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
             ),
             states=[Status.SUBMIT, Status.FAILED],
         ),
@@ -245,7 +246,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        if not self.underlying_quote_price:
+        if not self.last_underlying_quote_price:
             self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     def can_submit(self):
@@ -263,13 +264,15 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     @cached_property
-    def underlying_quote_price(self) -> InstrumentPrice | None:
+    def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
+            # we try t0 first
             return InstrumentPrice.objects.filter_only_valid_prices().get(
-                instrument=self.underlying_instrument, date=self.value_date
+                instrument=self.underlying_instrument, date=self.transaction_date
             )
         except InstrumentPrice.DoesNotExist:
             with suppress(InstrumentPrice.DoesNotExist):
+                # we fall back to the latest price before t0
                 return (
                     InstrumentPrice.objects.filter_only_valid_prices()
                     .filter(instrument=self.underlying_instrument, date__lte=self.value_date)
@@ -296,7 +299,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         },
     )
     def execute(self, **kwargs):
-        if self.underlying_quote_price:
+        if self.last_underlying_quote_price:
             asset, created = AssetPosition.unannotated_objects.update_or_create(
                 underlying_quote=self.underlying_instrument,
                 portfolio_created=None,
@@ -305,9 +308,9 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 defaults={
                     "initial_currency_fx_rate": self.currency_fx_rate,
                     "weighting": self._target_weight,
-                    "initial_price": self.underlying_quote_price.net_value,
+                    "initial_price": self.last_underlying_quote_price.net_value,
                     "initial_shares": None,
-                    "underlying_quote_price": self.underlying_quote_price,
+                    "underlying_quote_price": self.last_underlying_quote_price,
                     "asset_valuation_date": self.transaction_date,
                     "currency": self.currency,
                     "is_estimated": False,
@@ -316,7 +319,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             asset.set_weighting(self._target_weight)
 
     def can_execute(self):
-        if not self.underlying_quote_price:
+        if not self.last_underlying_quote_price:
             return {"underlying_instrument": "Cannot execute a trade without a valid quote price"}
         if not self.portfolio.is_manageable:
             return {"portfolio": "The portfolio needs to be a model portfolio in order to execute this trade manually"}
@@ -494,8 +497,8 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-            if self._effective_shares:
-                self.shares = self._effective_shares * self.weighting
+            if not self.portfolio.only_weighting:
+                self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
@@ -513,7 +516,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.total_value_gross = self.price_gross * self.shares
         self.transaction_type = Transaction.Type.TRADE
 
-        if self.transaction_subtype is None:
+        if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
             self._set_transaction_subtype()
         if self.id and hasattr(self, "claims"):
@@ -525,6 +528,8 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         super().save(*args, **kwargs)
 
     def _set_transaction_subtype(self):
+        if self.weighting == 0:
+            self.transaction_subtype = Trade.Type.NO_CHANGE
         if self.underlying_instrument.instrument_type.key == "product":
             if self.shares is not None:
                 if self.shares > 0:

wbportfolio/pms/trading/handler.py

@@ -62,7 +62,7 @@ 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()
+        # TradeBatch(validated_trades).validate()
         if self.effective_portfolio:
             for trade in validated_trades:
                 if (

wbportfolio/pms/typing.py

@@ -70,6 +70,9 @@ class Portfolio:
     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)
 

wbportfolio/rebalancing/models/composite.py

@@ -2,6 +2,7 @@ from decimal import Decimal
 
 from django.core.exceptions import ObjectDoesNotExist
 
+from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -11,11 +12,23 @@ from wbportfolio.rebalancing.decorators import register
 class CompositeRebalancing(AbstractRebalancingModel):
     @property
     def base_assets(self) -> dict[int, Decimal]:
+        """
+        Return a dictionary representation (instrument_id: target weight) of this trade proposal
+        Returns:
+            A dictionary representation
+
+        """
         try:
             latest_trade_proposal = self.portfolio.trade_proposals.filter(
                 status="APPROVED", trade_date__lte=self.trade_date
             ).latest("trade_date")
-            return latest_trade_proposal.base_assets
+            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")
+            }
         except ObjectDoesNotExist:
             return dict()
 

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -101,6 +101,24 @@ class RuleBackend(
             )
             _classifications = ClassificationRepresentationSerializer(many=True, source="parameters__classifications")
 
+            extra_filter_field = wb_serializers.ChoiceField(
+                choices=cls.Field.choices,
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field",
+                help_text="Specify if we need to narrow done the position applying a filter on that field and the corresponding range",
+            )
+            extra_filter_field_lower_bound = wb_serializers.FloatField(
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field Lower bound",
+            )
+            extra_filter_field_upper_bound = wb_serializers.FloatField(
+                default=None,
+                allow_null=True,
+                label="Extra Filter Field Lower bound",
+            )
+
             @classmethod
             def get_parameter_fields(cls):
                 return [
@@ -111,6 +129,9 @@ class RuleBackend(
                     "currencies",
                     "countries",
                     "classifications",
+                    "extra_filter_field",
+                    "extra_filter_field_lower_bound",
+                    "extra_filter_field_upper_bound",
                 ]
 
         return RuleBackendSerializer
@@ -131,6 +152,10 @@ class RuleBackend(
             repr["Only Countries"] = ", ".join(map(lambda o: o.code_2, self.countries))
         if self.classifications:
             repr["Only Classifications"] = ", ".join(map(lambda o: o.name, self.classifications))
+        if self.extra_filter_field:
+            repr["Extra Filter Field"] = (
+                f"{self.extra_filter_field}=[{self.extra_filter_field_lower_bound},{self.extra_filter_field_upper_bound}["
+            )
         return repr
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
@@ -180,7 +205,11 @@ class RuleBackend(
                     & df["primary_classification"].isin(list(map(lambda o: o.id, self.classifications)))
                 )
             ]
-
+        if self.extra_filter_field:
+            if (lower_bound := self.extra_filter_field_lower_bound) is not None:
+                df = df[df[self.extra_filter_field] >= lower_bound]
+            if (upper_bound := self.extra_filter_field_upper_bound) is not None:
+                df = df[df[self.extra_filter_field] < upper_bound]
         return df
 
     def _get_obj_repr(self, pivot_object_id) -> tuple[models.Model | None, str]:

wbportfolio/risk_management/tests/test_exposure_portfolio.py

@@ -93,3 +93,50 @@ class TestExposurePortfolioRuleModel(PortfolioTestMixin):
             ExposurePortfolioRuleBackend.GroupbyChoices.FAVORITE_CLASSIFICATION,
         ]:
             assert incidents[0].breached_object == classification
+
+    def test_exposure_rule_with_extra_filter_field(
+        self, weekday, portfolio, asset_position_factory, instrument_price_factory, instrument_factory
+    ):
+        parameters = {
+            "group_by": "instrument_type",
+            "field": ExposurePortfolioRuleBackend.Field.WEIGHTING.value,
+            "extra_filter_field": "market_capitalization_usd",
+            "extra_filter_field_lower_bound": 1000.0,
+            "extra_filter_field_upper_bound": 10000.0,
+        }
+        exposure_portfolio_backend = ExposurePortfolioRuleBackend(
+            weekday,
+            portfolio,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=0.05, upper=None))],  # type: ignore
+        )
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create(instrument_type=i1.instrument_type)
+        i3 = instrument_factory.create(instrument_type=i1.instrument_type)
+        instrument_price_factory.create(instrument=i1, date=weekday, market_capitalization=1000)
+        instrument_price_factory.create(instrument=i2, date=weekday, market_capitalization=9999)
+        instrument_price_factory.create(instrument=i3, date=weekday, market_capitalization=10001)
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.025,
+            underlying_instrument=i1,
+            portfolio=portfolio,
+        )
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.025,
+            underlying_instrument=i2,
+            portfolio=portfolio,
+        )
+
+        asset_position_factory.create(
+            date=weekday,
+            weighting=0.95,
+            underlying_instrument=i3,
+            portfolio=portfolio,
+        )
+        incidents = list(exposure_portfolio_backend.check_rule())
+        assert len(incidents) == 1
+        incident = incidents[0]
+        assert incident.breached_object_repr == i1.instrument_type
+        assert incident.breached_value == '<span style="color:green">+5.00%</span>'

wbportfolio/serializers/portfolios.py

@@ -1,7 +1,10 @@
+from datetime import date
+
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
 from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
 from wbcore.contrib.directory.models import BankingContact
+from wbfdm.serializers import InstrumentRepresentationSerializer
 
 from wbportfolio.models import Portfolio, PortfolioPortfolioThroughModel
 from wbportfolio.serializers.rebalancing import RebalancerRepresentationSerializer
@@ -21,12 +24,25 @@ class PortfolioRepresentationSerializer(wb_serializers.RepresentationSerializer)
 
 class PortfolioModelSerializer(wb_serializers.ModelSerializer):
     _currency = CurrencyRepresentationSerializer(source="currency")
+    _hedged_currency = CurrencyRepresentationSerializer(source="hedged_currency")
     _depends_on = PortfolioRepresentationSerializer(source="depends_on", many=True)
     automatic_rebalancer = wb_serializers.PrimaryKeyRelatedField(read_only=True)
     _automatic_rebalancer = RebalancerRepresentationSerializer(source="automatic_rebalancer")
+    _instruments = InstrumentRepresentationSerializer(source="instruments", many=True)
 
     create_index = wb_serializers.BooleanField(write_only=True, default=False)
 
+    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)
+
+    def get_next_expected_trade_proposal_date(self, obj):
+        if (automatic_rebalancer := getattr(obj, "automatic_rebalancer", None)) and (
+            _d := automatic_rebalancer.get_next_rebalancing_date(date.today())
+        ):
+            return _d.strftime("%Y-%m-%d")
+
     def create(self, validated_data):
         create_index = validated_data.pop("create_index", False)
         obj = super().create(validated_data)
@@ -133,8 +149,12 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "updated_at",
             "_depends_on",
             "depends_on",
+            "_instruments",
+            "instruments",
             "_currency",
             "currency",
+            "_hedged_currency",
+            "hedged_currency",
             "automatic_rebalancer",
             "_automatic_rebalancer",
             "invested_timespan",
@@ -145,6 +165,12 @@ class PortfolioModelSerializer(wb_serializers.ModelSerializer):
             "is_composition",
             "_additional_resources",
             "create_index",
+            "initial_position_date",
+            "last_position_date",
+            "last_asset_under_management_usd",
+            "last_positions",
+            "last_trade_proposal_date",
+            "next_expected_trade_proposal_date",
         )
 
 

wbportfolio/serializers/transactions/trades.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 from rest_framework import serializers
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
+from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
 
 from wbportfolio.models import PortfolioRole, Trade, TradeProposal
 from wbportfolio.models.transactions.claim import Claim
@@ -212,6 +213,14 @@ class TradeModelSerializer(TransactionModelSerializer):
 
 
 class TradeTradeProposalModelSerializer(TradeModelSerializer):
+    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)
+    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
+        source="underlying_instrument", label_key="name"
+    )
+
     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)
@@ -249,6 +258,10 @@ class TradeTradeProposalModelSerializer(TradeModelSerializer):
         fields = (
             "id",
             "shares",
+            "underlying_instrument_isin",
+            "underlying_instrument_ticker",
+            "underlying_instrument_refinitiv_identifier_code",
+            "underlying_instrument_instrument_type",
             "underlying_instrument",
             "_underlying_instrument",
             "transaction_subtype",

wbportfolio/tests/models/test_portfolios.py

@@ -1062,7 +1062,7 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         # we approve the rebalancing trade proposal
         assert rebalancing_trade_proposal.status == "SUBMIT"
-        rebalancing_trade_proposal.approve()
+        rebalancing_trade_proposal.approve(no_replay=True)
         rebalancing_trade_proposal.save()
 
         # check that the rebalancing was applied and position reflect that