wbcommission 2.2.1__tar.gz

wbcommission-2.2.1/.gitignore

@@ -0,0 +1,181 @@
+~
+
+# Docker volumes
+volumes/
+# Poetry auth file
+auth.toml
+
+media/*
+media/
+mediafiles/
+mediafiles/*
+test/*
+staticfiles/*
+staticfiles/
+#
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+info/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+.dccache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+report.xml
+*/report.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+*.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+.idea/
+.idea.bkp/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+crm/
+# Cython debug symbols
+cython_debug/
+
+# Gitlab Runner
+builds
+builds/
+
+# Integrator Office 365 : reverse proxy tunnel for outlook365
+ngrok
+*/ngrok
+/modules/**/system/
+
+/modules/wbmailing/files/*
+/modules/wbmailing/mailing/*
+
+/projects/*/requirements.txt
+public
+
+# Ignore archive localization generated folder
+backend/modules/**/archive/*
+**/**/requirements.txt
+CHANGELOG-*

wbcommission-2.2.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: wbcommission
+Version: 2.2.1
+Summary: A workbench module for managing human resources.
+Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
+Requires-Dist: reportlab==3.*
+Requires-Dist: wbcompliance
+Requires-Dist: wbcore
+Requires-Dist: wbcrm
+Requires-Dist: wbfdm
+Requires-Dist: wbnews

wbcommission-2.2.1/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "wbcommission"
+description = "A workbench module for managing human resources."
+authors = [{ name = "Christopher Wittlinger", email = "c.wittlinger@stainly.com"}]
+dynamic = ["version"]
+
+dependencies = [
+  "wbcore",
+  "wbcrm",
+  "wbnews",
+  "wbfdm",
+  "wbcompliance",
+  "reportlab == 3.*",
+]
+
+[tool.uv.sources]
+wbcore = { workspace = true }
+wbcrm = { workspace = true }
+wbnews = { workspace = true }
+wbfdm = { workspace = true }
+wbcompliance = { workspace = true }
+
+[tool.uv]
+package = true
+
+[tool.hatch.version]
+path = "../../pyproject.toml"
+
+[tool.hatch.build.targets.sdist]
+include = ["wbcommission/*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["wbcommission"]
+only-packages = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

wbcommission-2.2.1/wbcommission/__init__.py

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

wbcommission-2.2.1/wbcommission/admin/__init__.py

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

wbcommission-2.2.1/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-2.2.1/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-2.2.1/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-2.2.1/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-2.2.1/wbcommission/apps.py

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

wbcommission-2.2.1/wbcommission/factories/__init__.py

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

wbcommission-2.2.1/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-2.2.1/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-2.2.1/wbcommission/filters/__init__.py

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