wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/risk_management/backends/liquidity_stress_instrument.py

@@ -0,0 +1,86 @@
+from typing import Generator
+
+from django.contrib.contenttypes.models import ContentType
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbcore import serializers as wb_serializers
+from wbcore.serializers.fields.number import percent_decorator
+from wbfdm.models import Instrument
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActiveProductRelationshipMixin
+
+
+@register("Liquidity Stress Instrument Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActiveProductRelationshipMixin, backend.AbstractRuleBackend):
+    @classmethod
+    def get_parameter_fields(cls):
+        return [
+            "group_by",
+            "field",
+            "is_cash",
+            "asset_classes",
+            "currencies",
+            "countries",
+            "classification_height",
+            "classifications",
+        ]
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            below_x_days = wb_serializers.IntegerField(default=5, label="Below X days")
+            liquidity_factor = wb_serializers.FloatField(default=0.33, label="Liquidity factory")
+            pct_worst_volume = wb_serializers.FloatField(
+                default=100.0, label="Worst volume (%)", percent=True, decorators=[percent_decorator]
+            )
+            pct_redemption = wb_serializers.FloatField(
+                default=100.0, label="Redemption (%)", percent=True, decorators=[percent_decorator]
+            )
+            last_x_trading_dates = wb_serializers.IntegerField(default=60, label="Number of trading days")
+            is_slicing = wb_serializers.BooleanField(default=True, label="Slicing")
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "below_x_days",
+                    "liquidity_factor",
+                    "pct_worst_volume",
+                    "pct_redemption",
+                    "last_x_trading_dates",
+                    "is_slicing",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        # TODO adapt to DTO framework
+        factor = self.instrument.pct_liquidated_below_n_days(
+            self.evaluation_date,
+            below_n_days=self.below_x_days,
+            liq_factor=self.liquidity_factor,
+            pct_worst_volume=self.pct_worst_volume,
+            pct_redemption=self.pct_redemption,
+            last_x_trading_dates=self.last_x_trading_dates,
+            is_slicing=self.is_slicing,
+        )
+        for threshold in self.thresholds:
+            if factor is not None and threshold.is_inrange(factor):
+                yield backend.IncidentResult(
+                    breached_object=self.instrument,
+                    breached_object_repr=str(self.instrument),
+                    breached_value=str(factor),
+                    report_details=dict(),
+                    severity=threshold.severity,
+                )
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Instrument)
+
+    def is_passive_evaluation_valid(self) -> bool:
+        if not self.instrument.portfolio:
+            return False
+        return (self.instrument.portfolio.imported_assets.filter(date=self.evaluation_date).exists()) and (
+            self.instrument.valuations.filter(date=self.evaluation_date).exists()
+        )

wbportfolio/risk_management/backends/mixins.py

@@ -0,0 +1,220 @@
+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 pandas.tseries.offsets import BDay
+from wbcompliance.models.risk_management import backend
+from wbcore import serializers as wb_serializers
+from wbfdm.backends.dto import PriceDTO
+from wbfdm.models import Instrument, InstrumentPrice, InstrumentType
+from wbfdm.serializers import (
+    InstrumentTypeRepresentationSerializer,
+    SecurityRepresentationSerializer,
+)
+from wbportfolio.models import InstrumentPortfolioThroughModel, Portfolio
+
+
+class ActivePortfolioRelationshipMixin(backend.AbstractRuleBackend):
+    OBJECT_FIELD_NAME: str = "portfolio"
+
+    portfolio: Portfolio
+
+    def is_passive_evaluation_valid(self) -> bool:
+        return self.portfolio.imported_assets.filter(date=self.evaluation_date).exists()
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Portfolio)
+
+    def _build_dto_args(self):
+        return (self.portfolio._build_dto(self.evaluation_date, is_estimated=False),)
+
+    @classmethod
+    def get_all_active_relationships(cls) -> models.QuerySet:
+        valid_relationships = InstrumentPortfolioThroughModel.objects.filter(
+            instrument__instrument_type__key="product"
+        ).values("portfolio")
+        return Portfolio.objects.filter(id__in=valid_relationships, is_tracked=True)
+
+
+class ActiveProductRelationshipMixin(backend.AbstractRuleBackend):
+    OBJECT_FIELD_NAME: str = "product"
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Instrument)
+
+    @classmethod
+    def get_all_active_relationships(cls) -> models.QuerySet:
+        return Instrument.active_objects.filter(instrument_type__key="product")
+
+
+class StopLossMixin(backend.AbstractRuleBackend):
+    class FreqChoices(models.TextChoices):
+        BUSINESS_DAY = "B", "Business Day"
+        WEEKLY_FRIDAY = "W-FRI", "Friday to Friday"
+        BUSINESS_MONTHLY = "BME", "Business Monthly"
+        BUSINESS_YEARLY = "BYE", "Business Yearly"
+
+    class DateIntervalOption(models.TextChoices):
+        ROLLING_WINDOWS = "ROLLING_WINDOWS", "Rolling Window"
+        FREQUENCY = "FREQUENCY", "Frequency"
+
+    class DynamicBenchmarkType(models.TextChoices):
+        PORTFOLIO = "PORTFOLIO", "Primary Portfolio"
+        PRIMARY_BENCHMARK = "PRIMARY_BENCHMARK", "Primary Benchmark"
+
+    class FieldType(models.TextChoices):
+        OUTSTANDING_SHARES = "outstanding_shares", "Outstanding shares"
+        NET_VALUE = "net_value", "Net Value"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.portfolio = self.product.portfolio
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            freq = wb_serializers.ChoiceField(
+                choices=cls.FreqChoices,
+                default=cls.FreqChoices.WEEKLY_FRIDAY,
+                label="Frequency",
+                help_text="Valid only if the interval Option is Frequency. Specify the frequency use for aggregation",
+            )
+            date_interval_option = wb_serializers.ChoiceField(
+                choices=cls.DateIntervalOption,
+                default=cls.DateIntervalOption.ROLLING_WINDOWS,
+                label="Interval Option",
+            )
+            dynamic_benchmark_type = wb_serializers.ChoiceField(
+                choices=cls.DynamicBenchmarkType,
+                default=None,
+                allow_null=True,
+                label="Benchmark Type",
+                help_text="If specified, will compare the stop loss against the instrument related potential benchmark performance",
+            )
+            rolling_window_interval = wb_serializers.IntegerField(
+                default=7,
+                label="Rolling Window Interval",
+                help_text="Valid only if interval option is Rolling Window. Specify the number of day for sampling",
+            )
+            static_benchmark = wb_serializers.PrimaryKeyRelatedField(
+                queryset=Instrument.objects.all(),
+                default=None,
+                allow_null=True,
+                label="Static Benchmark (If any)",
+                help_text="If specified, will compare the stop loss against this benchmark",
+            )
+            asset_class = wb_serializers.PrimaryKeyRelatedField(
+                queryset=InstrumentType.objects.all(),
+                default=None,
+                allow_null=True,
+                label="Only Asset Class",
+            )
+            _asset_class = InstrumentTypeRepresentationSerializer(source="asset_class")
+
+            _static_benchmark = SecurityRepresentationSerializer(
+                source="static_benchmark", default=None, allow_null=True
+            )
+            field = wb_serializers.ChoiceField(
+                choices=cls.FieldType.choices,
+                default=cls.FieldType.NET_VALUE,
+                label="Field",
+            )
+            penny_stock_max_abs_net_value = wb_serializers.FloatField(
+                default=0.001, label="Penny Stock Max Absolute Net value"
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "freq",
+                    "date_interval_option",
+                    "dynamic_benchmark_type",
+                    "rolling_window_interval",
+                    "static_benchmark",
+                    "asset_class",
+                    "field",
+                    "penny_stock_max_abs_net_value",
+                ]
+
+        return RuleBackendSerializer
+
+    @property
+    def benchmark(self):
+        if self.dynamic_benchmark_type == self.DynamicBenchmarkType.PRIMARY_BENCHMARK.name:
+            return self.product.primary_benchmark
+        elif self.dynamic_benchmark_type == self.DynamicBenchmarkType.PORTFOLIO.name:
+            return self.product
+        elif self.static_benchmark:
+            return self.static_benchmark
+
+    def is_passive_evaluation_valid(self) -> bool:
+        try:
+            last_price = self.product.get_price(self.evaluation_date)
+            base_condition = last_price != 0
+            if (benchmark := self.benchmark) and (last_benchmark_price := benchmark.get_price(self.evaluation_date)):
+                return (last_benchmark_price != 0) and base_condition
+            return base_condition
+        except ValueError:
+            return False
+
+    def _generate_incidents(
+        self,
+        tested_instrument_id: int,
+        perf_instrument: float,
+        perf_benchmark: float,
+    ) -> Generator[backend.IncidentResult, None, None]:
+        total_perf = perf_instrument if perf_benchmark is None else perf_instrument - perf_benchmark
+        field_label = self.FieldType(self.field).label
+        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,
+                }
+                if self.benchmark:
+                    report_details[f"Relative Percentage VS {str(self.benchmark)}"] = f"{total_perf:,.3%}"
+                if total_perf < 0:
+                    breached_value = f'<span style="color:red">{total_perf:+,.2%}</span>'
+                else:
+                    breached_value = f'<span style="color:green">{total_perf:+,.2%}</span>'
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=breached_value,
+                    report_details=report_details,
+                    severity=threshold.severity,
+                )
+
+    def _get_start_interval(self) -> date:
+        if self.date_interval_option == self.DateIntervalOption.FREQUENCY.name:
+            return pd.date_range(end=self.evaluation_date, periods=2, freq=self.FreqChoices(self.freq).value)[0].date()
+        else:
+            return (self.evaluation_date - timedelta(days=self.rolling_window_interval - 1) - BDay(1)).date()
+
+    def _get_performance(self, valuation_dto: PriceDTO) -> float:
+        if not valuation_dto:
+            return 0.0
+        start_date = self._get_start_interval()
+        if (
+            qs := InstrumentPrice.objects.filter(
+                calculated=False,
+                instrument_id=valuation_dto.instrument,
+                date__lte=start_date,
+                date__gte=start_date - BDay(2),  # we allow 2 business day interval in case of market holiday
+            ).exclude(
+                net_value__lte=self.penny_stock_max_abs_net_value, net_value__gte=-self.penny_stock_max_abs_net_value
+            )
+        ).exists():
+            last_value = float(getattr(qs.latest("date"), self.field))
+            return float(getattr(valuation_dto, self.field)) / last_value - 1
+        return 0.0
+
+    def _build_dto_args(self) -> tuple[PriceDTO, PriceDTO | None]:
+        if benchmark := self.benchmark:
+            return self.product._build_dto(self.evaluation_date), benchmark._build_dto(self.evaluation_date)
+        return self.product._build_dto(self.evaluation_date), None

wbportfolio/risk_management/backends/product_integrity.py

@@ -0,0 +1,111 @@
+from typing import Generator
+
+import pandas as pd
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbcore import serializers as wb_serializers
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import AssetPosition, Product
+
+
+@register("Product Data Integrity", rule_group_key="portfolio")
+class RuleBackend(backend.AbstractRuleBackend):
+    OBJECT_FIELD_NAME: str = "product"
+
+    class DataTypeChoices(models.TextChoices):
+        INSTRUMENT_PRICE = "INSTRUMENT_PRICE", "Valuation"
+        ASSET_POSITION = "ASSET_POSITION", "Asset Position"
+
+    product: Product
+
+    def is_passive_evaluation_valid(self) -> bool:
+        return self.product.is_active_at_date(self.evaluation_date)
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Product)
+
+    def _build_dto_args(self):
+        return (self.product,)
+
+    @classmethod
+    def get_all_active_relationships(cls) -> models.QuerySet:
+        return Product.active_objects.all()
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            data_type = wb_serializers.MultipleChoiceField(
+                choices=cls.DataTypeChoices.choices,
+                default=[cls.DataTypeChoices.ASSET_POSITION.value, cls.DataTypeChoices.INSTRUMENT_PRICE.value],
+                label="Flags",
+                help_text="Set the flags that will trigger the rule",
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return ["data_type"]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, product: Product, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        for lag_threshold in self.thresholds:
+            numerical_range = lag_threshold.numerical_range
+
+            last_asset_position_date = (
+                AssetPosition.objects.filter(is_estimated=False, portfolio=product.portfolio).latest("date").date
+            )
+            last_instrument_price_date = (
+                InstrumentPrice.objects.filter(calculated=False, instrument=product).latest("date").date
+            )
+
+            asset_position_lag = (
+                len(
+                    pd.date_range(
+                        min([self.evaluation_date, last_asset_position_date]), self.evaluation_date, freq="B"
+                    )
+                )
+                - 1
+            )
+            instrument_price_lag = (
+                len(
+                    pd.date_range(
+                        min([self.evaluation_date, last_instrument_price_date]), self.evaluation_date, freq="B"
+                    )
+                )
+                - 1
+            )
+
+            if (
+                self.DataTypeChoices.ASSET_POSITION.value in self.data_type
+                and asset_position_lag >= numerical_range[0]
+                and asset_position_lag < numerical_range[1]
+            ):
+                yield backend.IncidentResult(
+                    breached_object=product,
+                    breached_object_repr=str(product),
+                    breached_value=str(asset_position_lag),
+                    report_details={
+                        "Last Datapoint": f"{last_asset_position_date:%d.%m.%Y}",
+                        "Data Type": "Asset Position",
+                    },
+                    severity=lag_threshold.severity,
+                )
+            if (
+                self.DataTypeChoices.INSTRUMENT_PRICE.value in self.data_type
+                and instrument_price_lag >= numerical_range[0]
+                and instrument_price_lag < numerical_range[1]
+            ):
+                yield backend.IncidentResult(
+                    breached_object=product,
+                    breached_object_repr=str(product),
+                    breached_value=str(instrument_price_lag),
+                    report_details={
+                        "Lag": instrument_price_lag,
+                        "Last Datapoint": f"{last_instrument_price_date:%d.%m.%Y}",
+                        "Data Type": "Valuation",
+                    },
+                    severity=lag_threshold.severity,
+                )

wbportfolio/risk_management/backends/stop_loss_instrument.py

@@ -0,0 +1,24 @@
+from typing import Generator
+
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbportfolio.pms.typing import Valuation as ValuationDTO
+
+from .mixins import ActiveProductRelationshipMixin, StopLossMixin
+
+
+@register("Stop Loss Instrument Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActiveProductRelationshipMixin, StopLossMixin, backend.AbstractRuleBackend):
+    def is_passive_evaluation_valid(self) -> bool:
+        return (
+            super().is_passive_evaluation_valid()
+            and self.product
+            and self.product.valuations.filter(date=self.evaluation_date).exists()
+        )
+
+    def _process_dto(
+        self, instrument_valuation_dto: ValuationDTO, benchmark_valuation_dto: ValuationDTO = None, *args, **kwargs
+    ) -> Generator[backend.IncidentResult, None, None]:
+        perf_instrument = self._get_performance(instrument_valuation_dto)
+        perf_benchmark = self._get_performance(benchmark_valuation_dto)
+        yield from self._generate_incidents(self.product.id, perf_instrument, perf_benchmark)

wbportfolio/risk_management/backends/stop_loss_portfolio.py

@@ -0,0 +1,36 @@
+from typing import Generator
+
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+from wbportfolio.pms.typing import Valuation as ValuationDTO
+
+from .mixins import ActiveProductRelationshipMixin, StopLossMixin
+
+
+@register("Stop Loss Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActiveProductRelationshipMixin, StopLossMixin, backend.AbstractRuleBackend):
+    def _build_dto_args(self) -> tuple[PortfolioDTO, ValuationDTO | None]:
+        return (
+            self.portfolio._build_dto(self.evaluation_date),
+            super()._build_dto_args()[1],
+        )
+
+    def is_passive_evaluation_valid(self) -> bool:
+        return (
+            super().is_passive_evaluation_valid()
+            and self.portfolio
+            and self.portfolio.assets.filter(date=self.evaluation_date).exists()
+        )
+
+    def _process_dto(
+        self, portfolio: PortfolioDTO, benchmark_valuation_dto: ValuationDTO = None, **kwargs
+    ) -> Generator[backend.IncidentResult, None, None]:
+        if self.asset_class:
+            portfolio = PortfolioDTO(filter(lambda x: x.instrument_type == self.asset_class.id, portfolio.positions))
+        perf_benchmark = self._get_performance(benchmark_valuation_dto)
+        for instrument_id, pos in portfolio.positions_map.items():
+            if pos.price is not None:
+                perf_instrument = self._get_performance(ValuationDTO(instrument=instrument_id, net_value=pos.price))
+
+                yield from self._generate_incidents(instrument_id, perf_instrument, perf_benchmark)

wbportfolio/risk_management/backends/ucits_portfolio.py

@@ -0,0 +1,63 @@
+from typing import Generator
+
+import pandas as pd
+from wbcompliance.models import RiskIncidentType
+from wbcompliance.models.risk_management import backend
+from wbcompliance.models.risk_management.dispatch import register
+from wbcore import serializers as wb_serializers
+from wbcore.serializers.fields.number import percent_decorator
+from wbfdm.models import Instrument
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("UCITS 5|10|40 Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActivePortfolioRelationshipMixin, backend.AbstractRuleBackend):
+    DEFAULT_THRESHOLD_1: float = 0.05
+    DEFAULT_THRESHOLD_2: float = 0.10
+    DEFAULT_THRESHOLD_3: float = 0.40
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            threshold_1 = wb_serializers.FloatField(
+                default=cls.DEFAULT_THRESHOLD_1, label="Threshold 1", percent=True, decorators=[percent_decorator]
+            )
+            threshold_2 = wb_serializers.FloatField(
+                default=cls.DEFAULT_THRESHOLD_2, label="Threshold 2", percent=True, decorators=[percent_decorator]
+            )
+            threshold_3 = wb_serializers.FloatField(
+                default=cls.DEFAULT_THRESHOLD_3, label="Threshold 3", percent=True, decorators=[percent_decorator]
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return ["threshold_1", "threshold_2", "threshold_3"]
+
+        return RuleBackendSerializer
+
+    def _filter_df(self, df):
+        if df.empty:
+            return df
+        return df[(df["weighting"] >= self.threshold_1) & (~df["is_cash"])]
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        if not (df := self._filter_df(pd.DataFrame(portfolio.to_df()).astype({"weighting": float}))).empty:
+            df = df[["underlying_instrument", "weighting"]].groupby("underlying_instrument").sum()
+            total_weight_threshold_1_2 = df.loc[df["weighting"] < self.threshold_2, "weighting"].sum()
+            highest_incident_type = RiskIncidentType.objects.order_by("-severity_order").first()
+            for id, row in df.to_dict("index").items():
+                if (row["weighting"] > self.threshold_2) or (total_weight_threshold_1_2 > self.threshold_3):
+                    instrument = Instrument.objects.get(id=id)
+                    yield backend.IncidentResult(
+                        breached_object=instrument,
+                        breached_object_repr=str(instrument),
+                        breached_value=f'∑[0%, {self.threshold_2:.2%}]:  {row["weighting"]:+.2%} | ∑[{self.threshold_1:.2%}, {self.threshold_2:.2%}]: {total_weight_threshold_1_2:+.2%}',
+                        report_details={
+                            "Breach Thresholds": f"{self.threshold_1}|{self.threshold_2}|{self.threshold_3}",
+                            "Weighting": f"{row['weighting']:.3f}",
+                            f"Sum of positions whose weight are between {self.threshold_1:.2%} and {self.threshold_2:.2%}": f"{total_weight_threshold_1_2:.3f}",
+                        },
+                        severity=highest_incident_type,
+                    )

wbportfolio/risk_management/tests/conftest.py

@@ -0,0 +1,15 @@
+from pytest_factoryboy import register
+from wbcompliance.factories.risk_management import (
+    RiskIncidentTypeFactory,
+    RiskRuleFactory,
+    RuleBackendFactory,
+    RuleThresholdFactory,
+)
+from wbfdm.factories import ControversyFactory
+from wbportfolio.tests.conftest import *  # noqa
+
+register(RiskIncidentTypeFactory)
+register(RiskRuleFactory)
+register(RuleBackendFactory)
+register(RuleThresholdFactory)
+register(ControversyFactory)

wbportfolio/risk_management/tests/test_accounts.py

@@ -0,0 +1,98 @@
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from psycopg.types.range import NumericRange
+from wbcompliance.factories.risk_management import RuleThresholdFactory
+from wbportfolio.models.transactions.claim import ClaimGroupbyChoice
+from wbportfolio.risk_management.backends.accounts import (
+    RuleBackend as AccountRuleBackend,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestAccountRuleModel:
+    @pytest.fixture
+    def account_backend(
+        self,
+        entry,
+        weekday,
+        business_days_interval,
+        group_by=ClaimGroupbyChoice.ACCOUNT.name,
+        extra_parameters=None,
+    ):
+        parameters = {"group_by": group_by, "business_days_interval": business_days_interval, "field": "SHARES"}
+        if extra_parameters:
+            parameters.update(extra_parameters)
+        return AccountRuleBackend(
+            weekday,
+            entry,
+            parameters,
+            [RuleThresholdFactory.create(range=NumericRange(lower=None, upper=-0.2))],  # detect any -20% perf
+        )
+
+    @pytest.mark.parametrize(
+        "business_days_interval",
+        [7],
+    )
+    def test_check_rule_groupby_account(
+        self,
+        weekday,
+        entry,
+        business_days_interval,
+        product,
+        claim_factory,
+        customer_trade_factory,
+        account_factory,
+        account_backend,
+    ):
+        # Simple test to test if a valid drop in performance outside the rule window will not be detected but a one within will.
+        account = account_factory.create(owner=entry)
+        other_account = account_factory.create()
+        claim_factory.create(
+            date=(weekday - BDay(business_days_interval + 2)).date(),
+            account=account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=100,
+        )
+        claim_factory.create(
+            date=(weekday - BDay(business_days_interval + 1)).date(),
+            account=account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=-50,
+        )  # this drop should not be detected
+
+        claim_factory.create(
+            date=(weekday - BDay(business_days_interval)).date(),
+            account=account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=150,
+        )
+        claim_factory.create(
+            date=weekday,
+            account=account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=-50,
+        )  # this drop should be detected
+
+        claim_factory.create(
+            date=(weekday - BDay(business_days_interval)).date(),
+            account=other_account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=150,
+        )
+        claim_factory.create(
+            date=weekday,
+            account=other_account,
+            trade=customer_trade_factory.create(underlying_instrument=product),
+            status="APPROVED",
+            shares=-50,
+        )  # this drop is valid but an another account so won't be detected
+        res = list(account_backend.check_rule())
+        assert len(res) == 1