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

wbportfolio/permissions.py

@@ -1,3 +1,5 @@
+from rest_framework.permissions import IsAuthenticated
+
 from wbportfolio.models import PortfolioRole
 
 
@@ -11,3 +13,8 @@ def is_portfolio_manager(request):
 
 def is_analyst(request):
     return PortfolioRole.is_analyst(request.user.profile)
+
+
+class IsPortfolioManager(IsAuthenticated):
+    def has_permission(self, request, view):
+        return is_portfolio_manager(request)

wbportfolio/pms/trading/__init__.py

@@ -1 +0,0 @@
-from .handler import TradingService

wbportfolio/pms/trading/optimizer.py

@@ -0,0 +1,61 @@
+import math
+
+import cvxpy as cp
+import numpy as np
+
+from wbportfolio.pms.typing import TradeBatch
+
+
+class TradeShareOptimizer:
+    def __init__(self, batch: TradeBatch, portfolio_total_value: float):
+        self.batch = batch
+        self.portfolio_total_value = portfolio_total_value
+
+    def optimize(self, target_cash: float = 0.99):
+        try:
+            return self.optimize_trade_share(target_cash)
+        except ValueError:
+            return self.floor_trade_share()
+
+    def optimize_trade_share(self, target_cash: float = 0.01):
+        prices_fx_portfolio = np.array([trade.price_fx_portfolio for trade in self.batch.trades])
+        target_allocs = np.array([trade.target_weight for trade in self.batch.trades])
+
+        # Decision variable: number of shares (integers)
+        shares = cp.Variable(len(prices_fx_portfolio), integer=True)
+
+        # Calculate portfolio values
+        portfolio_values = cp.multiply(shares, prices_fx_portfolio)
+
+        # Target values based on allocations
+        target_values = self.portfolio_total_value * target_allocs
+
+        # Objective: minimize absolute deviation from target values
+        objective = cp.Minimize(cp.sum(cp.abs(portfolio_values - target_values)))
+
+        # Constraints
+        constraints = [
+            shares >= 0,  # No short selling
+            cp.sum(portfolio_values) <= self.portfolio_total_value,  # Don't exceed budget
+            cp.sum(portfolio_values) >= (1.0 - target_cash) * self.portfolio_total_value,  # Use at least 99% of budget
+        ]
+
+        # Solve
+        problem = cp.Problem(objective, constraints)
+        problem.solve(solver=cp.CBC)
+
+        if problem != "optimal":
+            raise ValueError(f"Optimization failed: {problem.status}")
+
+        shares_result = shares.value.astype(int)
+        return TradeBatch(
+            [
+                trade.normalize_target(target_shares=shares_result[index])
+                for index, trade in enumerate(self.batch.trades)
+            ]
+        )
+
+    def floor_trade_share(self):
+        return TradeBatch(
+            [trade.normalize_target(target_shares=math.floor(trade.target_shares)) for trade in self.batch.trades]
+        )

wbportfolio/pms/typing.py

@@ -3,10 +3,13 @@ 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:
@@ -57,50 +60,11 @@ class Position:
         return Position(**attrs)
 
 
-@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])
-
-    @property
-    def portfolio_contribution(self) -> Decimal:
-        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])
-
-    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 __bool__(self):
-        return len(self.positions) > 0
-
-
 @dataclass(frozen=True)
 class Order:
     class AssetType(enum.Enum):
         EQUITY = "EQUITY"
+        AMERICAN_DEPOSITORY_RECEIPT = "AMERICAN_DEPOSITORY_RECEIPT"
 
     id: int | str
     trade_date: date
@@ -115,7 +79,9 @@ class Order:
     weighting: float | None = None
     target_shares: float | None = None
     shares: float | None = None
-    execution_instruction: str | None = None
+    execution_price: float | None = None
+    execution_instruction: ExecutionInstruction = ExecutionInstruction.MARKET_ON_CLOSE.value
+    execution_instruction_parameters: dict | None = None
     comment: str = ""
 
 
@@ -126,47 +92,43 @@ class Trade:
     currency: int
     date: date_lib
     price: Decimal
-    previous_weight: 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")
-    portfolio_contribution: Decimal = Decimal("1")
-    quantization_error: Decimal = Decimal("0")
+    effective_quantization_error: Decimal = Decimal("0")
+    target_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)
+        self.effective_weight = round(self.effective_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.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,
-            previous_weight=self.previous_weight,
+            effective_weight=self.effective_weight,
             target_weight=self.target_weight + other.target_weight,
             effective_shares=self.effective_shares,
             target_shares=self.target_shares + other.target_shares,
             daily_return=self.daily_return,
-            portfolio_contribution=self.portfolio_contribution,
             **{
                 f.name: getattr(self, f.name)
                 for f in fields(Trade)
                 if f.name
                 not in [
-                    "previous_weight",
+                    "effective_weight",
                     "target_weight",
                     "effective_shares",
                     "target_shares",
                     "underlying_instrument",
                     "daily_return",
-                    "portfolio_contribution",
                 ]
             },
         )
@@ -176,25 +138,9 @@ 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 (
-            round(
-                self.previous_weight * (self.daily_return + 1) / self.portfolio_contribution
-                if self.portfolio_contribution
-                else self.previous_weight,
-                8,
-            )
-            + self.quantization_error
-        )
-
     @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:
@@ -231,9 +177,10 @@ 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)
+        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
@@ -243,7 +190,7 @@ class TradeBatch:
 
     @property
     def largest_effective_order(self) -> Trade:
-        return max(self.trades, key=lambda obj: obj.previous_weight)
+        return max(self.trades, key=lambda obj: obj.effective_weight)
 
     @property
     def total_target_weight(self) -> Decimal:
@@ -263,41 +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, use_effective: bool = False, *extra_positions):
-        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 if not use_effective else trade.previous_weight,
-                    daily_return=trade.daily_return if use_effective else Decimal("0"),
-                    shares=trade.target_shares,
-                    currency=trade.currency,
-                    date=trade.date,
-                    is_cash=trade.is_cash,
-                    price=trade.price,
-                    currency_fx_rate=trade.currency_fx_rate,
-                )
+
+@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,
             )
-        for position in extra_positions:
-            if position.weighting:
-                positions.append(position)
-        return Portfolio(tuple(positions))
+            trades.append(trade)
+        return TradeBatch(trades)
 
-    def normalize(self, total_target_weight: Decimal = Decimal("1.0")):
+    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 trades batch so that the target weight is 100%
+        Normalize the instantiate portfolio so that the sum of the cash position equals to the new target cash position
         """
-        normalization_factor = (
-            total_target_weight / self.total_target_weight if self.total_target_weight else Decimal("0.0")
-        )
-        normalized_trades = []
-        for trade in self.trades:
-            normalized_trades.append(trade.normalize_target(normalization_factor))
-        tb = TradeBatch(normalized_trades)
-        return tb
+        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/models/composite.py

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

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -108,11 +108,7 @@ 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
 

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(

wbportfolio/risk_management/backends/esg_aggregation_portfolio.py

@@ -0,0 +1,64 @@
+from typing import Generator
+
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbcore import serializers as wb_serializers
+from wbfdm.analysis.esg.enums import ESGAggregation
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+from wbfdm.models import Instrument
+
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("ESG Aggregation Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActivePortfolioRelationshipMixin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.esg_aggregation = ESGAggregation[self.esg_aggregation]
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            esg_aggregation = wb_serializers.ChoiceField(
+                choices=ESGAggregation.choices(),
+                default=ESGAggregation.GHG_EMISSIONS_SCOPE_1.name,
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "esg_aggregation",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        esg_data = self.esg_aggregation.get_esg_data(Instrument.objects.filter(id__in=portfolio.positions_map.keys()))
+        df = portfolio.to_df(exclude_cash=True)
+        df["total_value"] = (df["price"] * df["shares"] * df["currency_fx_rate"]).astype(float)
+        df = df[["total_value", "weighting", "underlying_instrument"]].set_index("underlying_instrument")
+        df["weighting"] = df["weighting"] / df["weighting"].sum()
+        dataloader = DataLoader(
+            df["weighting"].astype(float), esg_data, self.evaluation_date, total_value_fx_usd=df["total_value"]
+        )
+        metrics = dataloader.compute(self.esg_aggregation)
+        for threshold in self.thresholds:
+            numerical_range = threshold.numerical_range
+            incident_df = metrics[(metrics >= numerical_range[0]) & (metrics < numerical_range[1])]
+            for instrument_id, metric in incident_df.to_dict().items():
+                instrument = Instrument.objects.get(id=instrument_id)
+                breached_value = metric
+
+                if metric < 0:
+                    breached_value = f'<span style="color:red">{breached_value}</span>'
+                else:
+                    breached_value = f'<span style="color:green">{breached_value}</span>'
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=breached_value,
+                    report_details={"Aggregation": self.esg_aggregation.value},
+                    severity=threshold.severity,
+                )

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -3,7 +3,7 @@ from typing import Generator
 from django.db import models
 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 wbcore.contrib.currency.models import Currency
 from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
@@ -160,7 +160,7 @@ class RuleBackend(
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
         if not (df := self._filter_df(portfolio.to_df())).empty:
-            df = df[[self.group_by.value, self.field.value]].groupby(self.group_by.value).sum().astype(float)
+            df = df[[self.group_by.value, self.field.value]].dropna().groupby(self.group_by.value).sum().astype(float)
             for threshold in self.thresholds:
                 numerical_range = threshold.numerical_range
                 incident_df = df[
@@ -180,7 +180,7 @@ class RuleBackend(
                             breached_value = f'<span style="color:green">{breached_value}</span>'
                         yield backend.IncidentResult(
                             breached_object=obj,
-                            breached_object_repr=obj_repr,
+                            breached_object_repr=str(obj_repr),
                             breached_value=breached_value,
                             report_details=self.report_details,
                             severity=severity,
@@ -218,7 +218,7 @@ class RuleBackend(
                 obj = Instrument.objects.get(id=pivot_object_id)
                 return obj, str(obj)
             case self.GroupbyChoices.ASSET_TYPE:
-                return None, InstrumentType.objects.get(id=pivot_object_id)
+                return None, InstrumentType.objects.get(id=pivot_object_id).name
             case self.GroupbyChoices.CASH:
                 return None, "Cash"
             case self.GroupbyChoices.COUNTRY:

wbportfolio/risk_management/backends/instrument_list_portfolio.py

@@ -64,10 +64,10 @@ 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)
-            relationships = self.instruments_relationship.filter(instrument=instrument, validated=True)
-
+            ancestors = instrument.get_ancestors(include_self=True)
+            relationships = self.instruments_relationship.filter(instrument__in=ancestors, validated=True)
             if self.exclude and relationships.exists():
                 report_details = {
                     "Instrument Lists": ", ".join(relationships.values_list("instrument_list__name", flat=True)),

wbportfolio/risk_management/tests/test_esg_aggregation_portfolio.py

@@ -0,0 +1,49 @@
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+from faker import Faker
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+
+from wbportfolio.risk_management.backends.esg_aggregation_portfolio import (
+    RuleBackend as ESGAggregationPortfolioBackend,
+)
+from wbportfolio.tests.models.utils import PortfolioTestMixin
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestEsgAggregationPortfolioRuleModel(PortfolioTestMixin):
+    @patch.object(DataLoader, "compute")
+    def test_eval(
+        self,
+        mock_fct,
+        weekday,
+        asset_position_factory,
+        portfolio,
+    ):
+        parameters = {"esg_aggregation": "GHG_EMISSIONS_SCOPE_1"}
+        backend = ESGAggregationPortfolioBackend(
+            weekday,
+            portfolio,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=0.02, upper=0.03))],  # type: ignore
+        )
+
+        a1 = asset_position_factory.create(
+            date=weekday,
+            portfolio=portfolio,
+        )  # Breached position
+
+        a2 = asset_position_factory.create(
+            date=weekday,
+            portfolio=portfolio,
+        )
+        mock_fct.return_value = pd.Series(index=[a1.underlying_quote.id, a2.underlying_quote.id], data=[0.01, 0.025])
+        incidents = list(backend.check_rule())
+        assert len(incidents) == 1
+        incident = incidents[0]
+        assert incident.breached_object == a2.underlying_quote

wbportfolio/risk_management/tests/test_exposure_portfolio.py

@@ -138,5 +138,5 @@ class TestExposurePortfolioRuleModel(PortfolioTestMixin):
         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_object_repr == i1.instrument_type.name
         assert incident.breached_value == '<span style="color:green">+5.00%</span>'

wbportfolio/risk_management/tests/test_stop_loss_instrument.py

@@ -92,7 +92,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
             date=weekday, net_value=500, calculated=False, instrument=benchmark
         )
         RelatedInstrumentThroughModel.objects.create(instrument=product, related_instrument=benchmark, is_primary=True)
-        setattr(stop_loss_instrument_backend, "dynamic_benchmark_type", "PRIMARY_BENCHMARK")
+        stop_loss_instrument_backend.dynamic_benchmark_type = "PRIMARY_BENCHMARK"
 
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 0
@@ -105,7 +105,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
         assert len(res) == 1
         assert res[0].breached_object.id == product.id
 
-        setattr(stop_loss_instrument_backend, "static_benchmark", benchmark)
+        stop_loss_instrument_backend.static_benchmark = benchmark
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 1
         assert res[0].breached_object.id == product.id

wbportfolio/risk_management/tests/test_stop_loss_portfolio.py

@@ -119,7 +119,7 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 0
 
-        setattr(stop_loss_portfolio_backend, "static_benchmark", benchmark)
+        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 == instrument.id