wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbcommission/admin/__init__.py

@@ -0,0 +1,4 @@
+from .accounts import AccountModelAdmin
+from .commission import CommissionModelAdmin, CommissionTypeModelAdmin
+
+# from .rebate import RebateModelAdmin

wbcommission/admin/accounts.py

@@ -0,0 +1,22 @@
+from django.contrib import admin
+from wbcommission.models.rebate import manage_rebate_as_task
+from wbcrm.admin.accounts import AccountModelAdmin as BaseAccountModelAdmin
+from wbcrm.models.accounts import Account
+
+from .commission import CommissionTabularInline
+
+admin.site.unregister(Account)
+
+
+@admin.register(Account)
+class AccountModelAdmin(BaseAccountModelAdmin):
+    def make_rebates(self, request, queryset):
+        for account in queryset:
+            manage_rebate_as_task.delay(account.id)
+
+    def get_assets_under_management(self, request, queryset):
+        for account in queryset:
+            account.get_assets_under_management()
+
+    actions = list(BaseAccountModelAdmin.actions) + [make_rebates, get_assets_under_management]
+    inlines = BaseAccountModelAdmin.inlines + [CommissionTabularInline]

wbcommission/admin/commission.py

@@ -0,0 +1,85 @@
+from django.contrib import admin
+from wbcommission.models import (
+    Commission,
+    CommissionExclusionRule,
+    CommissionRole,
+    CommissionRule,
+    CommissionType,
+)
+
+
+@admin.register(CommissionType)
+class CommissionTypeModelAdmin(admin.ModelAdmin):
+    pass
+
+
+class CommissionRuleTabularInline(admin.TabularInline):
+    ordering = ("timespan__startswith", "assets_under_management_range__startswith")
+    fields = (
+        "timespan",
+        "assets_under_management_range",
+        "percent",
+    )
+    model = CommissionRule
+    extra = 0
+
+
+class CommissionRoleTabularInline(admin.TabularInline):
+    model = CommissionRole
+    autocomplete_fields = ["person"]
+    fields = (
+        "person",
+        "commission",
+    )
+    extra = 0
+
+
+class CommissionTabularInline(admin.TabularInline):
+    extra = 0
+    model = Commission
+    fields = [
+        "order",
+        "crm_recipient",
+        "account_role_type_recipient",
+        "portfolio_role_recipient",
+        "commission_type",
+        "net_commission",
+        "is_hidden",
+        "exclusion_rule_account_role_type",
+    ]
+    readonly_fields = ["order"]
+    ordering = ["order"]
+    autocomplete_fields = ["account", "crm_recipient"]
+    show_change_link = True
+
+
+@admin.register(Commission)
+class CommissionModelAdmin(admin.ModelAdmin):
+    list_display = [
+        "account",
+        "crm_recipient",
+        "portfolio_role_recipient",
+        "account_role_type_recipient",
+        "order",
+        "net_commission",
+        "commission_type",
+        "is_hidden",
+        "exclusion_rule_account_role_type",
+    ]
+
+    autocomplete_fields = ["account", "crm_recipient"]
+
+    inlines = [CommissionRoleTabularInline, CommissionRuleTabularInline]
+
+
+@admin.register(CommissionExclusionRule)
+class CommissionExclusionRuleAdmin(admin.ModelAdmin):
+    list_display = [
+        "product",
+        "commission_type",
+        "account_role_type",
+        "timespan",
+        "overriding_percent",
+        "overriding_net_or_gross_commission",
+    ]
+    autocomplete_fields = ["product", "account_role_type"]

wbcommission/admin/rebate.py

@@ -0,0 +1,7 @@
+# @admin.register(Rebate)
+# class RebateModelAdmin(admin.ModelAdmin):
+#     def has_add_permission(self, request, obj=None):
+#         return False
+
+#     def has_delete_permission(self, request, obj=None):
+#         return False

wbcommission/analytics/marginality.py

@@ -0,0 +1,181 @@
+from datetime import date
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from django.db.models import Case, OuterRef, Subquery, Value, When
+from django.db.models.functions import Coalesce
+from wbcommission.models import CommissionType, Rebate
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import Fees
+
+
+class MarginalityCalculator:
+    FEE_MAP = {
+        "MANAGEMENT": "management",
+        "PERFORMANCE": "performance",
+        "PERFORMANCE_CRYSTALIZED": "performance",
+    }
+
+    def __init__(self, products, from_date: date, to_date: date):
+        products = products.annotate(
+            fx_rate=Coalesce(
+                Subquery(
+                    CurrencyFXRates.objects.filter(
+                        currency=OuterRef("currency"), date=OuterRef("last_valuation_date")
+                    ).values("value")[:1]
+                ),
+                Decimal(1.0),
+            )
+        )
+
+        self.fx_rates = (
+            pd.DataFrame(products.values_list("id", "fx_rate"), columns=["id", "fx_rate"])
+            .set_index("id")["fx_rate"]
+            .astype(float)
+        )
+
+        # compute net marginality
+        self.df_aum = pd.DataFrame(
+            InstrumentPrice.objects.annotate_base_data()
+            .filter(instrument__in=products, date__gte=from_date, date__lte=to_date)
+            .values_list("calculated", "net_value_usd", "date", "outstanding_shares", "instrument"),
+            columns=["calculated", "net_value_usd", "date", "outstanding_shares", "instrument"],
+        ).rename(columns={"instrument": "id"})
+        self.df_aum["date"] = pd.to_datetime(self.df_aum["date"])
+        self.df_aum = (
+            self.df_aum.sort_values(by="calculated")
+            .groupby(["id", "date"])
+            .agg({"net_value_usd": "last", "outstanding_shares": "first"})
+        )
+        self.df_aum = (self.df_aum.net_value_usd * self.df_aum.outstanding_shares).astype(float)
+        self.df_aum = self.df_aum.reindex(
+            pd.MultiIndex.from_product(
+                [
+                    self.df_aum.index.levels[0],
+                    pd.date_range(
+                        self.df_aum.index.get_level_values("date").min(),
+                        self.df_aum.index.get_level_values("date").max(),
+                    ),
+                ],
+                names=["id", "date"],
+            ),
+            method="ffill",
+        ).dropna()
+
+        # Build the fees dataframe where product id is the index and colum are the every fees type available and value are the amount.
+
+        fees = Fees.valid_objects.filter(
+            transaction_date__lte=to_date,
+            transaction_date__gte=from_date,
+            transaction_subtype__in=self.FEE_MAP.keys(),
+            linked_product__in=products,
+        ).annotate(
+            fee_type=Case(
+                *[When(transaction_subtype=k, then=Value(v)) for k, v in self.FEE_MAP.items()],
+                default=Value("management"),
+            )
+        )
+        self.df_fees = pd.DataFrame(
+            fees.values_list("linked_product", "fee_type", "total_value", "transaction_date", "calculated"),
+            columns=["linked_product", "fee_type", "total_value", "transaction_date", "calculated"],
+        ).rename(columns={"linked_product": "id", "transaction_date": "date"})
+        self.df_fees["date"] = pd.to_datetime(self.df_fees["date"])
+
+        self.df_fees = (
+            self.df_fees[["fee_type", "total_value", "id", "date"]]
+            .pivot_table(index=["id", "date"], columns="fee_type", values="total_value", aggfunc="sum")
+            .astype("float")
+            .round(4)
+        )
+        self.df_fees["total"] = self.df_fees.sum(axis=1)
+        self.df_fees = self.df_fees.reindex(self.df_aum.index, fill_value=0)
+        self.df_fees = self._rolling_average_monday(self.df_fees)
+
+        # Build the fees dataframe where product id is the index and colum are the every fees type available and value are the amount.
+        self.df_rebates = pd.DataFrame(
+            Rebate.objects.filter(date__gte=from_date, date__lte=to_date, product__in=products).values_list(
+                "product", "value", "date", "commission_type__key"
+            ),
+            columns=["product", "value", "date", "commission_type__key"],
+        ).rename(columns={"product": "id"})
+        self.df_rebates["date"] = pd.to_datetime(self.df_rebates["date"])
+
+        self.df_rebates = (
+            pd.pivot_table(
+                self.df_rebates,
+                index=["id", "date"],
+                columns="commission_type__key",
+                values="value",
+                aggfunc="sum",
+                fill_value=0,
+            )
+            .astype("float")
+            .round(4)
+        )
+        self.df_rebates = self.df_rebates.reindex(self.df_aum.index, fill_value=0)
+        self.df_rebates["total"] = self.df_rebates.sum(axis=1)
+        self.df_rebates = self._rolling_average_monday(self.df_rebates)
+        # Iniliaze basic column
+
+        self.empty_column = pd.Series(0.0, dtype="float64", index=self.df_fees.index)
+        self._set_basics_statistics()
+
+    def _set_basics_statistics(self):
+        groupby_fees = self.df_fees.groupby(level=0).sum(numeric_only=True)
+        groupby_rebates = self.df_rebates.groupby(level=0).sum(numeric_only=True)
+        for key in [*CommissionType.objects.values_list("key", flat=True), "total"]:
+            fees = groupby_fees.get(key, self.empty_column)
+            rebates = groupby_rebates.get(key, self.empty_column)
+            fees_usd = fees * self.fx_rates
+            rebates_usd = rebates * self.fx_rates
+            marginality = fees - rebates
+            marginality_usd = fees_usd - rebates_usd
+            marginality_percent = (fees - rebates) / fees.replace(0, np.nan)
+            marginality_percent_usd = (fees_usd - rebates_usd) / fees_usd.replace(0, np.nan)
+
+            setattr(self, f"{key}_fees", fees.rename(f"{key}_fees"))
+            setattr(self, f"{key}_rebates", rebates.rename(f"{key}_rebates"))
+            setattr(self, f"{key}_fees_usd", fees_usd.rename(f"{key}_fees_usd"))
+            setattr(self, f"{key}_rebates_usd", rebates_usd.rename(f"{key}_rebates_usd"))
+            setattr(self, f"{key}_marginality", marginality.rename(f"{key}_marginality"))
+            setattr(self, f"{key}_marginality_usd", marginality_usd.rename(f"{key}_marginality_usd"))
+            setattr(self, f"{key}_marginality_percent", marginality_percent.rename(f"{key}_marginality_percent"))
+            setattr(
+                self,
+                f"{key}_marginality_percent_usd",
+                marginality_percent_usd.rename(f"{key}_marginality_percent_usd"),
+            )
+
+    def _rolling_average_monday(self, df):
+        """
+        This utility method take a dataframe and assum the values on Mondays are accumulated over the weekend. So we need to average every Saturday, Sunday and Monday together.
+        """
+
+        monday = df[df.index.get_level_values("date").weekday == 0] / 3
+        monday = monday.reindex(df.index, method="bfill")
+        df[df.index.get_level_values("date").weekday.isin([5, 6, 0])] = monday[
+            df.index.get_level_values("date").weekday.isin([5, 6, 0])
+        ]
+        return df
+
+    def get_net_marginality(self, type: str) -> pd.Series:
+        return (
+            ((self.df_fees.get(type, self.empty_column) - self.df_rebates.get(type, self.empty_column)) / self.df_aum)
+            .groupby("id")
+            .mean()
+        ) * 360
+
+    def get_aggregated_net_marginality(self, type: str) -> pd.Series:
+        # we compute the total net marginality for management for the aggregate function
+        total_aum = self.df_aum.groupby(level=1).sum()
+        return (
+            (
+                (
+                    self.df_fees.get(type, self.empty_column).groupby(level=1).sum()
+                    - self.df_rebates.get(type, self.empty_column).groupby(level=1).sum()
+                )
+                / total_aum
+            ).mean(axis=0)
+        ) * 360

wbcommission/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class CommissionConfig(AppConfig):
+    name = "wbcommission"

wbcommission/factories/__init__.py

@@ -0,0 +1,9 @@
+from .commission import (
+    AccountTypeRoleCommissionFactory,
+    CommissionFactory,
+    CommissionRoleFactory,
+    PortfolioRoleCommissionFactory,
+    CommissionExclusionRuleFactory,
+    CommissionTypeFactory,
+)
+from .rebate import RebateFactory

wbcommission/factories/commission.py

@@ -0,0 +1,100 @@
+from datetime import date
+
+import factory
+from psycopg.types.range import DateRange
+from wbcommission.models.commission import (
+    Commission,
+    CommissionExclusionRule,
+    CommissionRole,
+    CommissionType,
+)
+from wbportfolio.models.roles import PortfolioRole
+
+
+class CommissionTypeFactory(factory.django.DjangoModelFactory):
+    name = "MANAGEMENT"
+    key = factory.LazyAttribute(lambda x: x.name.lower())
+
+    class Meta:
+        model = CommissionType
+        django_get_or_create = ["key"]
+
+
+class CommissionFactory(factory.django.DjangoModelFactory):
+    account = factory.SubFactory("wbcrm.factories.AccountFactory")
+    crm_recipient = factory.SubFactory("wbcore.contrib.directory.factories.entries.EntryFactory")
+
+    portfolio_role_recipient = None
+    account_role_type_recipient = None
+    order = 0
+    commission_type = factory.SubFactory(CommissionTypeFactory)
+    net_commission = True
+    is_hidden = False
+
+    class Meta:
+        model = Commission
+
+    @factory.post_generation
+    def rule_timespan(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            v = self.rules.first()
+            v.timespan = extracted
+            v.save()
+
+    @factory.post_generation
+    def rule_aum(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            v = self.rules.first()
+            v.assets_under_management_range = extracted
+            v.save()
+
+    @factory.post_generation
+    def rule_percent(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            v = self.rules.first()
+            v.percent = extracted
+            v.save()
+
+
+class PortfolioRoleCommissionFactory(CommissionFactory):
+    crm_recipient = None
+    account_role_type_recipient = None
+    portfolio_role_recipient = factory.Iterator([role_choice[0] for role_choice in PortfolioRole.RoleType.choices])
+
+    class Meta:
+        model = Commission
+
+
+class AccountTypeRoleCommissionFactory(CommissionFactory):
+    crm_recipient = None
+    portfolio_role_recipient = None
+    account_role_type_recipient = factory.SubFactory("wbcrm.factories.AccountRoleTypeFactory")
+
+    class Meta:
+        model = Commission
+
+
+class CommissionRoleFactory(factory.django.DjangoModelFactory):
+    commission = factory.SubFactory(CommissionFactory)
+    person = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+
+    class Meta:
+        model = CommissionRole
+
+
+class CommissionExclusionRuleFactory(factory.django.DjangoModelFactory):
+    product = factory.SubFactory("wbportfolio.factories.products.ProductFactory")
+    commission_type = factory.SubFactory(CommissionTypeFactory)
+    overriding_percent = factory.Faker("pydecimal", min_value=0, max_value=1, right_digits=2)
+    overriding_net_or_gross_commission = "DEFAULT"
+    account_role_type = None
+    timespan = DateRange(date.min, date.max)
+
+    class Meta:
+        model = CommissionExclusionRule

wbcommission/factories/rebate.py

@@ -0,0 +1,16 @@
+import factory
+from wbcommission.models import Rebate
+
+
+class RebateFactory(factory.django.DjangoModelFactory):
+    date = factory.Faker("date_object")
+
+    commission = factory.SubFactory("wbcommission.factories.CommissionFactory")
+    account = factory.LazyAttribute(lambda o: o.commission.account)
+    commission_type = factory.LazyAttribute(lambda o: o.commission.commission_type)
+    product = factory.SubFactory("wbportfolio.factories.ProductFactory")
+    recipient = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+    value = factory.Faker("pydecimal", positive=True, max_value=1000000, right_digits=4)
+
+    class Meta:
+        model = Rebate

wbcommission/filters/__init__.py

@@ -0,0 +1,7 @@
+from .rebate import (
+    CustomerRebateGroupByFilter,
+    RebateDateFilter,
+    RebateGroupByFilter,
+    RebateMarginalityFilter,
+)
+from .signals import *

wbcommission/filters/rebate.py

@@ -0,0 +1,187 @@
+from wbcommission.models import Rebate
+from wbcommission.models.rebate import RebateGroupbyChoice
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import Company
+from wbcore.filters.defaults import current_quarter_date_range
+from wbcore.pandas.filterset import PandasFilterSetMixin
+from wbfdm.models import ClassificationGroup
+from wbfdm.preferences import get_default_classification_group
+from wbportfolio.filters.transactions.claim import CommissionBaseFilterSet
+from wbportfolio.models import Product
+
+
+class RebateDateFilter(CommissionBaseFilterSet):
+    date = wb_filters.DateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=current_quarter_date_range,
+    )
+
+    class Meta:
+        model = Rebate
+        fields = {
+            "date": ["exact"],
+            "account": ["exact"],
+            "product": ["exact"],
+            "recipient": ["exact"],
+            "commission_type": ["exact"],
+        }
+
+
+class RebateGroupByFilter(PandasFilterSetMixin, RebateDateFilter):
+    group_by = wb_filters.ChoiceFilter(
+        label="Group By",
+        choices=RebateGroupbyChoice.choices(),
+        default=RebateGroupbyChoice.ACCOUNT.name,  # typing: ignore
+        method=lambda queryset, label, value: queryset,
+        clearable=False,
+        required=True,
+    )
+    groupby_classification_group = wb_filters.ModelChoiceFilter(
+        default=lambda k, v, f: get_default_classification_group().id,
+        method=lambda queryset, label, value: queryset,
+        label="Group by Classification Group",
+        queryset=ClassificationGroup.objects.all(),
+        endpoint=ClassificationGroup.get_representation_endpoint(),
+        value_key=ClassificationGroup.get_representation_value_key(),
+        label_key=ClassificationGroup.get_representation_label_key(),
+    )
+
+    class Meta:
+        model = Rebate
+        fields = {"recipient": ["exact"]}
+        df_fields = {
+            "management__gte": wb_filters.NumberFilter(
+                label="Management Fees (USD)", lookup_expr="gte", field_name="management"
+            ),
+            "management__lte": wb_filters.NumberFilter(
+                label="Management Fees (USD)", lookup_expr="lte", field_name="management"
+            ),
+            "performance__gte": wb_filters.NumberFilter(
+                label="Performance Fees (USD)", lookup_expr="gte", field_name="performance"
+            ),
+            "performance__lte": wb_filters.NumberFilter(
+                label="Performance Fees (USD)", lookup_expr="lte", field_name="performance"
+            ),
+            "total_rebate__gte": wb_filters.NumberFilter(
+                label="Total Fees (USD)", lookup_expr="gte", field_name="total_rebate"
+            ),
+            "total_rebate__lte": wb_filters.NumberFilter(
+                label="Total Fees (USD)", lookup_expr="lte", field_name="total_rebate"
+            ),
+        }
+
+
+class CustomerRebateGroupByFilter(RebateGroupByFilter):
+    product = wb_filters.ModelChoiceFilter(
+        label="Product",
+        queryset=Product.objects.all(),
+        endpoint=Product.get_representation_endpoint(),
+        value_key=Product.get_representation_value_key(),
+        label_key="{{title}} {{currency_repr}} - {{isin}}",
+    )
+
+    class Meta:
+        model = Rebate
+        fields = {
+            # "price_start" : ["gte", "exact", "lte"],
+            # "price_end" : ["gte", "exact", "lte"],
+            "account": ["exact"],
+            "product": ["exact"],
+            "recipient": ["exact"],
+        }
+
+
+class RebateMarginalityFilter(PandasFilterSetMixin, wb_filters.FilterSet):
+    date = wb_filters.DateRangeFilter(
+        label="Date Range",
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        required=True,
+        clearable=False,
+        default=current_quarter_date_range,
+    )
+
+    bank = wb_filters.ModelMultipleChoiceFilter(
+        label="Bank",
+        queryset=Company.bank_objects.all(),
+        endpoint=Company.get_representation_endpoint(),
+        filter_params={"bank_product": True},
+        value_key=Company.get_representation_value_key(),
+        label_key=Company.get_representation_label_key(),
+        method="filter_bank",
+    )
+
+    def filter_bank(self, queryset, name, value):
+        if value:
+            return queryset.filter(bank__in=value)
+        return queryset
+
+    class Meta:
+        model = Product
+        fields = {}
+        df_fields = {
+            "management_fees__gte": wb_filters.NumberFilter(
+                field_name="management_fees", lookup_expr="gte", label="Sum Management Fees"
+            ),
+            "management_rebates__gte": wb_filters.NumberFilter(
+                field_name="management_rebates", lookup_expr="gte", label="Sum Management Rebates"
+            ),
+            "management_marginality__gte": wb_filters.NumberFilter(
+                field_name="management_marginality", lookup_expr="gte", label="Marginality Management"
+            ),
+            "performance_fees__gte": wb_filters.NumberFilter(
+                field_name="performance_fees", lookup_expr="gte", label="Sum Performance Fees"
+            ),
+            "performance_rebates__gte": wb_filters.NumberFilter(
+                field_name="performance_rebates", lookup_expr="gte", label="Sum Performance Rebates"
+            ),
+            "performance_marginality__gte": wb_filters.NumberFilter(
+                field_name="performance_marginality", lookup_expr="gte", label="Marginality Performance"
+            ),
+            "total_fees__gte": wb_filters.NumberFilter(field_name="total_fees", lookup_expr="gte", label="Total Fees"),
+            "total_rebates__gte": wb_filters.NumberFilter(
+                field_name="total_rebates", lookup_expr="gte", label="Total Rebates"
+            ),
+            "total_marginality_percent__gte": wb_filters.NumberFilter(
+                field_name="total_marginality_percent", lookup_expr="gte", label="Total Marginality"
+            ),
+            "total_fees_usd__gte": wb_filters.NumberFilter(
+                field_name="total_fees_usd", lookup_expr="gte", label="Total Fees"
+            ),
+            "total_rebates_usd__gte": wb_filters.NumberFilter(
+                field_name="total_rebates_usd", lookup_expr="gte", label="Total Rebates"
+            ),
+            "management_fees__lte": wb_filters.NumberFilter(
+                field_name="management_fees", lookup_expr="lte", label="Sum Management Fees"
+            ),
+            "management_rebates__lte": wb_filters.NumberFilter(
+                field_name="management_rebates", lookup_expr="lte", label="Sum Management Rebates"
+            ),
+            "management_marginality__lte": wb_filters.NumberFilter(
+                field_name="management_marginality", lookup_expr="lte", label="Marginality Management"
+            ),
+            "performance_fees__lte": wb_filters.NumberFilter(
+                field_name="performance_fees", lookup_expr="lte", label="Sum Performance Fees"
+            ),
+            "performance_rebates__lte": wb_filters.NumberFilter(
+                field_name="performance_rebates", lookup_expr="lte", label="Sum Performance Rebates"
+            ),
+            "performance_marginality__lte": wb_filters.NumberFilter(
+                field_name="performance_marginality", lookup_expr="lte", label="Marginality Performance"
+            ),
+            "total_fees__lte": wb_filters.NumberFilter(field_name="total_fees", lookup_expr="lte", label="Total Fees"),
+            "total_rebates__lte": wb_filters.NumberFilter(
+                field_name="total_rebates", lookup_expr="lte", label="Total Rebates"
+            ),
+            "total_marginality_percent__lte": wb_filters.NumberFilter(
+                field_name="total_marginality_percent", lookup_expr="lte", label="Total Marginality"
+            ),
+            "total_fees_usd__lte": wb_filters.NumberFilter(
+                field_name="total_fees_usd", lookup_expr="lte", label="Total Fees"
+            ),
+            "total_rebates_usd__lte": wb_filters.NumberFilter(
+                field_name="total_rebates_usd", lookup_expr="lte", label="Total Rebates"
+            ),
+        }