wbportfolio 1.49.11__tar.gz → 1.50.1__tar.gz

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.49.11
+Version: 1.50.1
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/models/asset.py

@@ -185,8 +185,8 @@ class AssetPositionIterator:
         return dict(self._weights)
 
     def __iter__(self):
-        # return an iterable excluding the position without a valid weighting
-        yield from filter(lambda a: a.weighting, self.positions.values())
+        # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
+        yield from filter(lambda a: not a.portfolio.is_manageable or a.weighting, self.positions.values())
 
     def __getitem__(self, item: tuple[date, Instrument]) -> float:
         return self._weights[item[0]][item[1].id]

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/models/transactions/trade_proposals.py

@@ -524,7 +524,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         for trade in self.trades.all():
             with suppress(ValueError):
-                asset = trade.to_asset()
+                asset = trade.get_asset()
                 # we add the corresponding asset only if it is not the cache position (already included in estimated_cash_position)
                 if asset.underlying_quote != estimated_cash_position.underlying_quote:
                     assets.append(asset)

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/models/transactions/trades.py

@@ -299,31 +299,9 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             )
         },
     )
-    def to_asset(self) -> AssetPosition:
-        last_underlying_quote_price = self.last_underlying_quote_price
-        if not last_underlying_quote_price:
-            raise ValueError("No price found")
-        asset = AssetPosition(
-            underlying_quote=self.underlying_instrument,
-            portfolio_created=None,
-            portfolio=self.portfolio,
-            date=self.transaction_date,
-            initial_currency_fx_rate=self.currency_fx_rate,
-            weighting=self._target_weight,
-            initial_price=self.last_underlying_quote_price.net_value,
-            initial_shares=None,
-            underlying_quote_price=self.last_underlying_quote_price,
-            asset_valuation_date=self.transaction_date,
-            currency=self.currency,
-            is_estimated=False,
-        )
-        asset.set_weighting(self._target_weight)
-        asset.pre_save()
-        return asset
-
     def execute(self, **kwargs):
         with suppress(ValueError):
-            asset = self.to_asset()
+            asset = self.get_asset()
             AssetPosition.unannotated_objects.update_or_create(
                 underlying_quote=asset.underlying_quote,
                 portfolio_created=asset.portfolio_created,
@@ -570,6 +548,28 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
 
         """
 
+    def get_asset(self) -> AssetPosition:
+        last_underlying_quote_price = self.last_underlying_quote_price
+        if not last_underlying_quote_price:
+            raise ValueError("No price found")
+        asset = AssetPosition(
+            underlying_quote=self.underlying_instrument,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.transaction_date,
+            initial_currency_fx_rate=self.currency_fx_rate,
+            weighting=self._target_weight,
+            initial_price=self.last_underlying_quote_price.net_value,
+            initial_shares=None,
+            underlying_quote_price=self.last_underlying_quote_price,
+            asset_valuation_date=self.transaction_date,
+            currency=self.currency,
+            is_estimated=False,
+        )
+        asset.set_weighting(self._target_weight)
+        asset.pre_save()
+        return asset
+
     def delete(self, **kwargs):
         pre_collection.send(sender=self.__class__, instance=self)
         super().delete(**kwargs)

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/risk_management/backends/liquidity_risk.py

@@ -60,7 +60,7 @@ class RuleBackend(backend.AbstractRuleBackend):
             @classmethod
             def get_parameter_fields(cls):
                 return [
-                    "below_x_days",
+                    "liquidation_factor",
                     "redemption_pct",
                 ]
 

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/risk_management/backends/mixins.py

@@ -1,9 +1,11 @@
+from contextlib import suppress
 from datetime import date, timedelta
 from typing import Generator
 
 import pandas as pd
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.db.models import Sum
 from pandas.tseries.offsets import BDay
 from wbcompliance.models.risk_management import backend
 from wbcore import serializers as wb_serializers
@@ -14,7 +16,7 @@ from wbfdm.serializers import (
     SecurityRepresentationSerializer,
 )
 
-from wbportfolio.models import InstrumentPortfolioThroughModel, Portfolio
+from wbportfolio.models import AssetPosition, InstrumentPortfolioThroughModel, Portfolio
 
 
 class ActivePortfolioRelationshipMixin(backend.AbstractRuleBackend):
@@ -173,10 +175,16 @@ class StopLossMixin(backend.AbstractRuleBackend):
         for threshold in self.thresholds:
             if threshold.is_inrange(total_perf):
                 instrument = Instrument.objects.get(id=tested_instrument_id)
-                report_details = {
-                    "Absolute Percentage": f"{perf_instrument:,.3%}",
-                    "Field": field_label,
-                }
+                report_details = {}
+                with suppress(AssetPosition.DoesNotExist):
+                    previous_portfolio_date = (
+                        self.product.portfolio.assets.filter(date__lt=self.evaluation_date).latest("date").date
+                    )
+                    weighting = self.product.portfolio.assets.filter(
+                        underlying_quote=instrument, date=previous_portfolio_date
+                    ).aggregate(s=Sum("weighting"))["s"]
+                    report_details["Portfolio Impact"] = f"{float(weighting) * total_perf:+,.2%}"
+                report_details["Field"] = field_label
                 if self.benchmark:
                     report_details[f"Relative Percentage VS {str(self.benchmark)}"] = f"{total_perf:,.3%}"
                 if total_perf < 0:

{wbportfolio-1.49.11 → wbportfolio-1.50.1}/wbportfolio/risk_management/tests/test_stop_loss_portfolio.py

@@ -3,11 +3,12 @@ from decimal import Decimal
 
 import pytest
 from faker import Faker
+from pandas._libs.tslibs.offsets import BDay
 from psycopg.types.range import NumericRange
 from wbcompliance.factories.risk_management import RuleThresholdFactory
 
-from wbportfolio.risk_management.backends.stop_loss_instrument import (
-    RuleBackend as StopLossInstrumentRuleBackend,
+from wbportfolio.risk_management.backends.stop_loss_portfolio import (
+    RuleBackend as StopLossPortfolioRuleBackend,
 )
 from wbportfolio.tests.models.utils import PortfolioTestMixin
 
@@ -21,7 +22,7 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         parameters = {"freq": freq, "date_interval_option": date_interval_option}
         lower = random.random()
         upper = random.uniform(lower, 1)
-        return StopLossInstrumentRuleBackend(
+        return StopLossPortfolioRuleBackend(
             weekday,
             product,
             parameters,
@@ -31,8 +32,8 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
     @pytest.mark.parametrize(
         "date_interval_option, freq",
         [
-            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.BUSINESS_DAY),
-            *[("FREQUENCY", option) for option in StopLossInstrumentRuleBackend.FreqChoices.values],
+            ("ROLLING_WINDOWS", StopLossPortfolioRuleBackend.FreqChoices.BUSINESS_DAY),
+            *[("FREQUENCY", option) for option in StopLossPortfolioRuleBackend.FreqChoices.values],
         ],
     )
     def test_check_rule_frequency(
@@ -41,40 +42,49 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         date_interval_option,
         freq,
         product,
-        portfolio,
+        instrument,
         instrument_price_factory,
         asset_position_factory,
         stop_loss_portfolio_backend,
-        instrument_portfolio_through_model_factory,
     ):
-        instrument_portfolio_through_model_factory.create(
-            instrument=product,
-            portfolio=portfolio,
-            primary_portfolio=True,
-        )
+        previous_date = (weekday - BDay(1)).date()
 
         d1 = stop_loss_portfolio_backend._get_start_interval()
 
         threshold = stop_loss_portfolio_backend.thresholds[0]
         breach_perf = random.uniform(threshold.range.lower, threshold.range.upper)
 
-        i1 = instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
-        instrument_price_factory.create(
-            date=weekday, net_value=Decimal(breach_perf + 1) * i1.net_value, calculated=False, instrument=product
+        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(date=previous_date, net_value=100, calculated=False, instrument=product)
+        instrument_price_factory.create(date=weekday, net_value=100, calculated=False, instrument=product)
+
+        i1 = instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=instrument)
+        instrument_price_factory.create(date=previous_date, calculated=False, instrument=instrument)
+        i2 = instrument_price_factory.create(
+            date=weekday, net_value=Decimal(breach_perf + 1) * i1.net_value, calculated=False, instrument=instrument
         )
 
-        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
-        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+        previous_position = asset_position_factory.create(
+            date=previous_date, underlying_instrument=instrument, portfolio=product.portfolio
+        )
+        asset_position_factory.create(date=weekday, underlying_instrument=instrument, portfolio=product.portfolio)
 
+        expected_performance = i2.net_value / i1.net_value - Decimal(1.0)
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 1
-        assert res[0].breached_object.id == product.id
+        incident = res[0]
+        assert incident.breached_object.id == instrument.id
+        assert incident.breached_value == f'<span style="color:green">{expected_performance:+,.2%}</span>'
+        assert incident.report_details == {
+            "Field": "Net Value",
+            "Portfolio Impact": f"{previous_position.weighting * expected_performance:+,.2%}",
+        }
 
     @pytest.mark.parametrize(
         "date_interval_option, freq",
         [
-            ("ROLLING_WINDOWS", StopLossInstrumentRuleBackend.FreqChoices.BUSINESS_DAY),
-            *[("FREQUENCY", option) for option in StopLossInstrumentRuleBackend.FreqChoices.values],
+            ("ROLLING_WINDOWS", StopLossPortfolioRuleBackend.FreqChoices.BUSINESS_DAY),
+            *[("FREQUENCY", option) for option in StopLossPortfolioRuleBackend.FreqChoices.values],
         ],
     )
     def test_check_rule_frequency_2(
@@ -83,33 +93,28 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         date_interval_option,
         freq,
         product,
-        portfolio,
         instrument_price_factory,
         asset_position_factory,
         instrument_factory,
         stop_loss_portfolio_backend,
-        instrument_portfolio_through_model_factory,
     ):
-        instrument_portfolio_through_model_factory.create(
-            instrument=product,
-            portfolio=portfolio,
-            primary_portfolio=True,
-        )
         d1 = stop_loss_portfolio_backend._get_start_interval()
         benchmark = instrument_factory.create()
+        instrument = instrument_factory.create()
 
         threshold = stop_loss_portfolio_backend.thresholds[0]
         threshold.range = NumericRange(upper=-0.5, lower=None)  # type: ignore
         threshold.save()
 
-        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=product)
         instrument_price_factory.create(date=weekday, net_value=100, calculated=False, instrument=product)
 
+        instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=instrument)
+        instrument_price_factory.create(date=weekday, net_value=100, calculated=False, instrument=instrument)
+
         instrument_price_factory.create(date=d1, net_value=100, calculated=False, instrument=benchmark)
         instrument_price_factory.create(date=weekday, net_value=300, calculated=False, instrument=benchmark)
 
-        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
-        asset_position_factory.create(date=weekday, underlying_instrument=product, portfolio=portfolio)
+        asset_position_factory.create(date=weekday, underlying_instrument=instrument, portfolio=product.portfolio)
 
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 0
@@ -117,4 +122,4 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         setattr(stop_loss_portfolio_backend, "static_benchmark", benchmark)
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 1
-        assert res[0].breached_object.id == product.id
+        assert res[0].breached_object.id == instrument.id