wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/risk_management/backends/__init__.py

@@ -0,0 +1,11 @@
+from .accounts import *
+from .controversy_portfolio import *
+from .exposure_portfolio import *
+from .instrument_list_portfolio import *
+from .liquidity_stress_instrument import *
+from .stop_loss_instrument import *
+from .stop_loss_portfolio import *
+from .ucits_portfolio import *
+from .accounts import *
+from .product_integrity import *
+from .liquidity_risk import *

wbportfolio/risk_management/backends/accounts.py

@@ -0,0 +1,166 @@
+from datetime import timedelta
+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 wbcore.contrib.directory.models import Entry
+from wbcrm.models import Account
+from wbfdm.models import Classification
+from wbfdm.preferences import get_default_classification_group
+from wbportfolio.analysis.claims import ConsolidatedTradeSummary
+from wbportfolio.models import Product, ProductGroup
+from wbportfolio.models.transactions.claim import Claim, ClaimGroupbyChoice
+from wbportfolio.serializers import ProductRepresentationSerializer
+
+
+@register("Account Shares Rule Backend", rule_group_key="sales")
+class RuleBackend(backend.AbstractRuleBackend):
+    OBJECT_FIELD_NAME: str = "customer"
+
+    customer: Entry
+
+    class FieldChoices(models.TextChoices):
+        SHARES = "SHARES", "Shares"
+        AUM = "AUM", "AUM"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.end_date = self.evaluation_date
+        self.start_date = (self.evaluation_date - pd.tseries.offsets.BDay(self.business_days_interval)).date()
+
+        self.group_by = ClaimGroupbyChoice[self.group_by]
+        self.field = self.FieldChoices[self.field]
+
+    def is_passive_evaluation_valid(self) -> bool:
+        return Claim.objects.filter_for_customer(self.customer).filter(date__lte=self.evaluation_date).exists()
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Entry)
+
+    def _build_dto_args(self):
+        qs = Claim.objects.filter_for_customer(self.customer).filter(
+            status=Claim.Status.APPROVED, date__lte=self.evaluation_date
+        )
+        if self.only_products:
+            qs = qs.filter(product__in=self.only_products)
+        groupby_map = ClaimGroupbyChoice.get_map(self.group_by.name)
+        pivot = groupby_map["pk"]
+        pivot_label = groupby_map["title_key"]
+        cts_generator = ConsolidatedTradeSummary(
+            qs,
+            self.start_date,
+            self.end_date + timedelta(days=1),  # we shift by one because end date is excluded
+            pivot,
+            pivot_label,
+            classification_group=get_default_classification_group(),
+        )
+        return (cts_generator,)
+
+    @classmethod
+    def get_all_active_relationships(cls) -> models.QuerySet:
+        return Entry.objects.annotate(
+            has_open_account=models.Exists(Account.open_objects.filter(owner=models.OuterRef("pk")))
+        ).filter(has_open_account=True)
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            business_days_interval = wb_serializers.IntegerField(default=7)
+            moving_average_window = wb_serializers.IntegerField(default=1)  # 1 means the initial time series
+
+            only_products = wb_serializers.PrimaryKeyRelatedField(
+                queryset=Product.objects.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Only Products",
+            )
+            _only_products = ProductRepresentationSerializer(many=True, source="parameters__only_products")
+
+            group_by = wb_serializers.ChoiceField(
+                choices=ClaimGroupbyChoice.choices(),
+                default=ClaimGroupbyChoice.ACCOUNT,
+                allow_null=True,
+                help_text="Choose how to group by shares",
+                label="Group By",
+            )
+            field = wb_serializers.ChoiceField(
+                choices=cls.FieldChoices.choices,
+                default=cls.FieldChoices.SHARES,
+                allow_null=True,
+                help_text="Choose which metric to choose",
+                label="Field",
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "field",
+                    "group_by",
+                    "business_days_interval",
+                    "moving_average_window",
+                    "only_products",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(
+        self, cts_generator: ConsolidatedTradeSummary, **kwargs
+    ) -> Generator[backend.IncidentResult, None, None]:
+        df = cts_generator.get_aum_df()
+        if df.empty:
+            return
+        if self.field == self.FieldChoices.SHARES:
+            perf = df["sum_shares_perf"]
+            start_df = df["sum_shares_start"]
+            end_df = df["sum_shares_end"]
+        else:
+            perf = df["sum_aum_perf"]
+            start_df = df["sum_aum_start"]
+            end_df = df["sum_aum_end"]
+        perf = perf.dropna()
+        if not perf.empty:
+            for threshold in self.thresholds:
+                numerical_range = threshold.numerical_range
+                breached_perf = perf[(perf > numerical_range[0]) & (perf < numerical_range[1])].dropna()
+                if not breached_perf.empty:
+                    for breached_obj_id, percentage in breached_perf.to_dict().items():
+                        breached_obj = None
+                        if self.group_by == ClaimGroupbyChoice.PRODUCT:
+                            breached_obj = Product.objects.get(id=breached_obj_id)
+                        elif self.group_by == ClaimGroupbyChoice.PRODUCT_GROUP:
+                            breached_obj = ProductGroup.objects.get(id=breached_obj_id)
+                        elif self.group_by == ClaimGroupbyChoice.CLASSIFICATION:
+                            breached_obj = Classification.objects.get(id=breached_obj_id)
+                        elif self.group_by in [ClaimGroupbyChoice.ACCOUNT, ClaimGroupbyChoice.ROOT_ACCOUNT]:
+                            breached_obj = Account.objects.get(id=breached_obj_id)
+                        elif self.group_by in [
+                            ClaimGroupbyChoice.ACCOUNT_OWNER,
+                            ClaimGroupbyChoice.ROOT_ACCOUNT_OWNER,
+                        ]:
+                            breached_obj = Entry.objects.get(id=breached_obj_id)
+                        report_details = {
+                            "Period": f"{cts_generator.start_date:%d.%m.%Y} - {cts_generator.end_date:%d.%m.%Y}",
+                        }
+                        color = "red" if percentage < 0 else "green"
+                        if self.field == "AUM":
+                            report_details[
+                                "AUM Change"
+                            ] = f'<span style="color:{color}">{start_df.loc[breached_obj_id]:.0f} $ → {end_df.loc[breached_obj_id]:.0f} $</span>'
+                        else:
+                            report_details[
+                                "Shares Change"
+                            ] = f"<span style='color:{color}'>{start_df.loc[breached_obj_id]:.0f} → {end_df.loc[breached_obj_id]:.0f}</span>"
+                        report_details["Group By"] = self.group_by.value
+                        yield backend.IncidentResult(
+                            breached_object=breached_obj,
+                            breached_object_repr=str(breached_obj),
+                            breached_value=f'<span style="color:{color}">{percentage:+,.2%}</span>',
+                            report_details=report_details,
+                            severity=threshold.severity,
+                        )

wbportfolio/risk_management/backends/controversy_portfolio.py

@@ -0,0 +1,63 @@
+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 wbcore import serializers as wb_serializers
+from wbfdm.enums import ESGControveryFlag
+from wbfdm.models import Instrument
+from wbfdm.models.esg.controversies import Controversy
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("Controversy Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActivePortfolioRelationshipMixin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # if thresholds are attached to this rule, we take the first as severity. Otherwise, we get the risk incident with the highest severity (e.g. Critical)
+        if self.thresholds:
+            self.severity = self.thresholds[0].severity
+        else:
+            self.severity = RiskIncidentType.objects.order_by("-severity_order").first()
+        self.flags_repr = [ESGControveryFlag[f].label for f in self.flags]
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            flags = wb_serializers.MultipleChoiceField(
+                choices=ESGControveryFlag.choices,
+                default=[ESGControveryFlag.ORANGE.value, ESGControveryFlag.RED.value],
+                label="Flags",
+                help_text="Set the flags that will trigger the rule",
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "flags",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        for instrument_id, weight in portfolio.positions_map.items():
+            instrument = Instrument.objects.get(id=instrument_id)
+            if (
+                controversies := Controversy.objects.filter(
+                    instrument__in=instrument.get_ancestors(include_self=True), flag__in=self.flags
+                )
+            ).exists():
+                controversies_headlines = "".join([f"<li>{c.headline}</li>" for c in controversies])
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=f"# {controversies.count()}",
+                    report_details={
+                        "Controversies Flags": ", ".join(self.flags_repr),
+                        "Controversies Headlines": controversies_headlines,
+                    },
+                    severity=self.severity,
+                )

wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -0,0 +1,203 @@
+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 wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.geography.serializers import CountryRepresentationSerializer
+from wbfdm.models import Classification, Instrument, InstrumentType
+from wbfdm.serializers import (
+    ClassificationRepresentationSerializer,
+    InstrumentTypeRepresentationSerializer,
+)
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("Exposure Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(
+    ActivePortfolioRelationshipMixin,
+):
+    class GroupbyChoices(models.TextChoices):
+        UNDERLYING_INSTRUMENT = "underlying_instrument", "Underlying Instrument"
+        ASSET_TYPE = "instrument_type", "Asset Type"
+        CASH = "is_cash", "Cash"
+        CURRENCY = "currency", "Currency"
+        COUNTRY = "country", "Country"
+        PRIMARY_CLASSIFICATION = "primary_classification", "Primary Classification"
+        FAVORITE_CLASSIFICATION = "favorite_classification", "Favorite Classification"
+
+    class Field(models.TextChoices):
+        WEIGHTING = "weighting", "Weighting"
+        MARKET_CAPITALIZATION_USD = "market_capitalization_usd", "Market Capitalization (USD)"
+        MARKET_SHARE = "market_share", "Market Shares"
+        DAILY_LIQUIDITY = "daily_liquidity", "Daily Liquidity"
+        VOLUME_USD = "volume_usd", "Dollar Volume"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.group_by = self.GroupbyChoices(self.group_by)
+        self.field = self.Field(self.field)
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            group_by = wb_serializers.ChoiceField(
+                choices=cls.GroupbyChoices.choices,
+                default=cls.GroupbyChoices.ASSET_TYPE,
+                allow_null=True,
+                help_text="Choose how the position will be aggregated before evaluating the rule",
+                label="Group By",
+            )
+            field = wb_serializers.ChoiceField(
+                choices=cls.Field.choices,
+                default=cls.Field.WEIGHTING,
+                allow_null=True,
+                label="Field",
+                help_text="Choose which field will be evaluated after aggregatation",
+            )
+            is_cash = wb_serializers.BooleanField(
+                default=None, allow_null=True, label="Cash", help_text="Exclude cash position"
+            )
+            asset_classes = wb_serializers.PrimaryKeyRelatedField(
+                queryset=InstrumentType.objects.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Only Asset Classes",
+            )
+            _asset_classes = InstrumentTypeRepresentationSerializer(source="asset_classes", many=True)
+
+            currencies = wb_serializers.PrimaryKeyRelatedField(
+                queryset=Currency.objects.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Only Currencies",
+            )
+            _currencies = CurrencyRepresentationSerializer(many=True, source="parameters__currencies")
+            countries = wb_serializers.PrimaryKeyRelatedField(
+                queryset=Geography.countries.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Only Countries",
+            )
+            _countries = CountryRepresentationSerializer(
+                many=True, source="parameters__countries", filter_params={"level": 1}
+            )
+            classifications = wb_serializers.PrimaryKeyRelatedField(
+                queryset=Classification.objects.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Classifications",
+            )
+            _classifications = ClassificationRepresentationSerializer(many=True, source="parameters__classifications")
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "group_by",
+                    "field",
+                    "is_cash",
+                    "asset_classes",
+                    "currencies",
+                    "countries",
+                    "classifications",
+                ]
+
+        return RuleBackendSerializer
+
+    @property
+    def report_details(self) -> dict[str, str]:
+        repr = {
+            "Field": self.field.label,
+            "Group By": self.group_by.label,
+        }
+        if self.is_cash:
+            repr["Only Cash"] = "True"
+        if self.asset_classes:
+            repr["Only Types"] = ", ".join(map(lambda o: o.name, self.asset_classes))
+        if self.currencies:
+            repr["Only Currencies"] = ", ".join(map(lambda o: o.key, self.currencies))
+        if self.countries:
+            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))
+        return repr
+
+    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)
+            for threshold in self.thresholds:
+                dff = df.copy()
+                numerical_range = threshold.numerical_range
+                dff = dff[(dff[self.field.value] > numerical_range[0]) & (dff[self.field.value] < numerical_range[1])]
+                if not dff.empty:
+                    for id, row in dff.to_dict("index").items():
+                        obj, obj_repr = self._get_obj_repr(id)
+                        severity: RiskIncidentType = threshold.severity
+                        if self.field == self.Field.WEIGHTING:
+                            breached_value = f"{row[self.field.value]:+,.2%}"
+                        else:
+                            breached_value = f"{row[self.field.value]:,.3f}"
+                        if row[self.field.value] < 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=obj,
+                            breached_object_repr=obj_repr,
+                            breached_value=breached_value,
+                            report_details=self.report_details,
+                            severity=severity,
+                        )
+
+    def _filter_df(self, df):
+        if df.empty:
+            return df
+        if self.is_cash is True or self.is_cash is False:
+            df = df[df["is_cash"] == self.is_cash]
+
+        if self.asset_classes:
+            df = df[df["instrument_type"].isin(list(map(lambda o: o.id, self.asset_classes)))]
+        if self.countries:
+            df = df[(~df["country"].isnull() & df["country"].isin(list(map(lambda o: o.id, self.countries))))]
+        if self.currencies:
+            df = df[(~df["currency"].isnull() & df["currency"].isin(list(map(lambda o: o.id, self.currencies))))]
+        if self.classifications:
+            df = df[
+                (
+                    ~df["primary_classification"].isnull()
+                    & df["primary_classification"].isin(list(map(lambda o: o.id, self.classifications)))
+                )
+            ]
+        return df
+
+    def _get_obj_repr(self, pivot_object_id) -> tuple[models.Model | None, str]:
+        match self.group_by:
+            case self.GroupbyChoices.UNDERLYING_INSTRUMENT:
+                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)
+            case self.GroupbyChoices.CASH:
+                return None, "Cash"
+            case self.GroupbyChoices.COUNTRY:
+                obj = Geography.countries.get(id=pivot_object_id)
+                return obj, str(obj)
+            case self.GroupbyChoices.CURRENCY:
+                obj = Currency.objects.get(id=pivot_object_id)
+                return obj, str(obj)
+            case self.GroupbyChoices.PRIMARY_CLASSIFICATION:
+                obj = Classification.objects.get(id=pivot_object_id)
+                return obj, str(obj)
+            case self.GroupbyChoices.FAVORITE_CLASSIFICATION:
+                obj = Classification.objects.get(id=pivot_object_id)
+                return obj, str(obj)

wbportfolio/risk_management/backends/instrument_list_portfolio.py

@@ -0,0 +1,89 @@
+from typing import Generator
+
+from django.db.models import Q
+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 Instrument, InstrumentList, InstrumentListThroughModel
+from wbfdm.serializers.instruments.instrument_lists import (
+    InstrumentListRepresentationSerializer,
+)
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+
+from .mixins import ActivePortfolioRelationshipMixin
+
+
+@register("Instrument List Portfolio Rule Backend", rule_group_key="portfolio")
+class RuleBackend(ActivePortfolioRelationshipMixin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instrument_list_type:
+            self.instrument_lists = InstrumentList.objects.filter(instrument_list_type=self.instrument_list_type)
+        self.instruments_relationship = InstrumentListThroughModel.objects.filter(
+            Q(instrument_list__in=self.instrument_lists)
+            & (Q(from_date__isnull=True) | Q(from_date__lte=self.evaluation_date))
+            & (Q(to_date__isnull=True) | Q(to_date__gt=self.evaluation_date))
+        )
+        self.instrument_lists_repr = " ,".join(map(lambda x: x.name, self.instrument_lists))
+        self.severity = self.thresholds[0].severity
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            exclude = wb_serializers.BooleanField(
+                default=True,
+                label="Exclude",
+                help_text="If true, the rule will check that the portfolio composition DOES NOT intersect the given instrument list",
+            )
+            instrument_list_type = wb_serializers.ChoiceField(
+                choices=InstrumentList.InstrumentListType.choices,
+                required=False,
+                default=None,
+                allow_null=True,
+                help_text="If specified, will dynamically load the list of instrument list to check of the same specified type",
+                label="Instrument List Type",
+            )
+            instrument_lists = wb_serializers.PrimaryKeyRelatedField(
+                queryset=InstrumentList.objects.all(),
+                many=True,
+                default=None,
+                allow_null=True,
+                label="Instrument Lists",
+            )
+            _instrument_lists = InstrumentListRepresentationSerializer(many=True)
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "exclude",
+                    "instrument_list_type",
+                    "instrument_lists",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        for instrument_id, weight in portfolio.positions_map.items():
+            instrument = Instrument.objects.get(id=instrument_id)
+            relationships = self.instruments_relationship.filter(instrument=instrument, validated=True)
+
+            if self.exclude and relationships.exists():
+                report_details = {
+                    "Instrument Lists": ", ".join(relationships.values_list("instrument_list__name", flat=True)),
+                }
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=f"# {relationships.count()}",
+                    report_details=report_details,
+                    severity=self.severity,
+                )
+            elif not self.exclude and not relationships.exists():
+                report_details = {"Instrument Lists": self.instrument_lists_repr}
+                yield backend.IncidentResult(
+                    breached_object=instrument,
+                    breached_object_repr=str(instrument),
+                    breached_value=f"# {relationships.count()}",
+                    report_details=report_details,
+                    severity=self.severity,
+                )

wbportfolio/risk_management/backends/liquidity_risk.py

@@ -0,0 +1,86 @@
+from contextlib import suppress
+from math import ceil
+from typing import Generator
+
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.db.models import Exists, OuterRef, Sum
+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 Instrument, InstrumentPrice
+from wbportfolio.models import AssetPosition
+
+
+@register("Liquidity Risk", rule_group_key="portfolio")
+class RuleBackend(backend.AbstractRuleBackend):
+    OBJECT_FIELD_NAME: str = "instrument"
+
+    instrument: Instrument
+
+    def get_queryset(self):
+        return self.instrument.assets.filter(
+            date=self.evaluation_date, shares__isnull=False, is_invested=True
+        ).exclude(shares=0)
+
+    def is_passive_evaluation_valid(self) -> bool:
+        return self.get_queryset().exists()
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return ContentType.objects.get_for_model(Instrument)
+
+    def _build_dto_args(self):
+        with suppress(InstrumentPrice.DoesNotExist):
+            last_price = self.instrument.valuations.get(date=self.evaluation_date)
+            total_shares = self.get_queryset().aggregate(c=Sum("shares"))["c"]
+            if last_price.volume_50d and total_shares:
+                return float(total_shares), last_price.volume_50d
+        return tuple()
+
+    @classmethod
+    def get_all_active_relationships(cls) -> models.QuerySet:
+        try:
+            base_qs = AssetPosition.objects.filter(shares__isnull=False, is_invested=True).exclude(shares=0)
+            last_asset_position = base_qs.latest("date").date
+
+            return Instrument.objects.annotate(
+                has_assets=Exists(base_qs.filter(underlying_instrument=OuterRef("pk"), date=last_asset_position))
+            ).filter(has_assets=True, children__isnull=True)
+        except AssetPosition.DoesNotExist:
+            return Instrument.objects.none()
+
+    @classmethod
+    def get_serializer_class(cls) -> wb_serializers.Serializer:
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            liquidation_factor = wb_serializers.FloatField(default=3.0, label="Liquidation Factor")
+            redemption_pct = wb_serializers.FloatField(default=0.80, label="Redemption Percentage", percent=True)
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return [
+                    "below_x_days",
+                    "redemption_pct",
+                ]
+
+        return RuleBackendSerializer
+
+    def _process_dto(
+        self, total_shares: float, volume_50d: float, **kwargs
+    ) -> Generator[backend.IncidentResult, None, None]:
+        days_to_liquidate = (total_shares * self.redemption_pct * self.liquidation_factor) / volume_50d
+        for threshold in self.thresholds:
+            numerical_range = threshold.numerical_range
+            if days_to_liquidate >= numerical_range[0] and days_to_liquidate < numerical_range[1]:
+                yield backend.IncidentResult(
+                    breached_object=self.instrument,
+                    breached_object_repr=str(self.instrument),
+                    breached_value=f"{ceil(days_to_liquidate)} Days",
+                    report_details={
+                        "Volume 50D": volume_50d,
+                        "Total Shares": total_shares,
+                        "Redemption Percentage": f"{self.redemption_pct:.1%}",
+                        "Liquidation Factor": self.liquidation_factor,
+                    },
+                    severity=threshold.severity,
+                )