wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/viewsets/mixins.py

@@ -0,0 +1,39 @@
+from datetime import date, datetime
+
+from django.http import HttpRequest
+from django.utils.functional import cached_property
+from wbcommission.models import Commission, Rebate
+
+
+class CommissionPermissionMixin:
+    queryset = Commission.objects.all()
+    request: HttpRequest
+
+    @cached_property
+    def validity_date(self) -> date:
+        if validity_date_repr := self.request.GET.get("validity_date"):
+            return datetime.strptime(validity_date_repr, "%Y-%m-%d")
+        return date.today()
+
+    def get_queryset(self):
+        # allow the user to see claim only on accounts it can see
+        return (
+            super().get_queryset().filter_for_user(self.request.user, validity_date=self.validity_date)  # type: ignore
+        )
+
+
+class RebatePermissionMixin:
+    queryset = Rebate.objects.all()
+    request: HttpRequest
+
+    @cached_property
+    def validity_date(self) -> date:
+        if validity_date_repr := self.request.GET.get("validity_date"):
+            return datetime.strptime(validity_date_repr, "%Y-%m-%d")
+        return date.today()
+
+    def get_queryset(self):
+        # allow the user to see claim only on accounts it can see
+        return (
+            super().get_queryset().filter_for_user(self.request.user, validity_date=self.validity_date)  # type: ignore
+        )

wbcommission/viewsets/rebate.py

@@ -0,0 +1,481 @@
+from collections import defaultdict
+from datetime import date
+from decimal import Decimal
+
+import numpy as np
+import pandas as pd
+from django.db.models import Exists, ExpressionWrapper, F, FloatField, OuterRef, Sum
+from django.db.models.functions import Coalesce
+from django.shortcuts import get_object_or_404
+from django.utils.dateparse import parse_date
+from django.utils.functional import cached_property
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcommission.filters import (
+    CustomerRebateGroupByFilter,
+    RebateDateFilter,
+    RebateGroupByFilter,
+    RebateMarginalityFilter,
+)
+from wbcommission.models import CommissionType, Rebate
+from wbcommission.models.rebate import RebateGroupbyChoice, manage_rebate_as_task
+from wbcommission.reports.audit_report import create_audit_report_and_send_as_task
+from wbcommission.reports.customer_report import create_customer_report_and_send_as_task
+from wbcommission.serializers import RebateModelSerializer
+from wbcommission.viewsets.buttons.rebate import RebateTableButtonConfig
+from wbcommission.viewsets.display.rebate import (
+    RebatePandasViewDisplayConfig,
+    RebateProductMarginalityDisplayConfig,
+)
+from wbcommission.viewsets.endpoints.rebate import (
+    RebatePandasViewEndpointConfig,
+    RebateProductMarginalityEndpointConfig,
+)
+from wbcommission.viewsets.titles.rebate import (
+    RebatePandasViewTitleConfig,
+    RebateProductMarginalityTitleConfig,
+)
+from wbcore import serializers as wb_serializers
+from wbcore import viewsets
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.permissions.permissions import IsInternalUser
+from wbcore.serializers import decorator
+from wbcore.utils.date import get_date_interval_from_request
+from wbcore.utils.strings import format_number
+from wbcrm.models.accounts import Account
+from wbfdm.models import Classification, ClassificationGroup, InstrumentPrice
+from wbfdm.preferences import get_default_classification_group
+from wbportfolio.models import Product
+
+from ..analytics.marginality import MarginalityCalculator
+from ..permissions import IsCommissionAdmin
+from .mixins import RebatePermissionMixin
+
+
+class RebateModelViewSet(RebatePermissionMixin, viewsets.ModelViewSet):
+    serializer_class = RebateModelSerializer
+    queryset = Rebate.objects.all()
+    filterset_class = RebateDateFilter
+
+    endpoint_config_class = RebatePandasViewEndpointConfig
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        return {"value_usd": {"Σ": format_number(queryset.aggregate(s=Sum(F("value_usd")))["s"] or 0)}}
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                fx_rate=Coalesce(CurrencyFXRates.get_fx_rates_subquery("date"), Decimal(1)),
+                value_usd=ExpressionWrapper(F("value") * F("fx_rate"), output_field=FloatField()),
+            )
+        )
+
+    @action(detail=False, methods=["PATCH"], permission_classes=[IsCommissionAdmin])
+    def recompute(self, request, pk=None):
+        if "start_date" in request.POST:
+            prune_existing = request.POST.get("prune_existing", "false") == "true"
+            start_date = parse_date(request.POST["start_date"])
+            if only_account_ids_repr := request.POST.get("only_accounts", None):
+                only_account_ids = only_account_ids_repr.split(",")
+                accounts = Account.objects.filter(id__in=only_account_ids, level=0)
+            else:
+                accounts = Account.objects.filter(level=0)
+            for account in accounts:
+                manage_rebate_as_task.delay(
+                    account.id, start_date=start_date, prune_existing=prune_existing, user=request.user
+                )
+            return Response({"status": f"{accounts.count()} are being recomputed"}, status=status.HTTP_200_OK)
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=False, methods=["GET", "PATCH"], permission_classes=[IsInternalUser])
+    def customerreport(self, request, pk=None):
+        start, end = get_date_interval_from_request(request, request_type="POST")
+        user = request.user
+        recipient = get_object_or_404(Entry, pk=request.GET.get("recipient_id", None))
+        create_customer_report_and_send_as_task.delay(user.id, recipient.id, start, end)
+        return Response({"__notification": {"title": "Report send."}}, status=status.HTTP_200_OK)
+
+    @action(detail=False, methods=["GET", "PATCH"], permission_classes=[IsCommissionAdmin])
+    def auditreport(self, request, pk=None):
+        start, end = get_date_interval_from_request(request, request_type="POST")
+        user = request.user
+        recipient = get_object_or_404(Entry, pk=request.GET.get("recipient_id", None))
+        create_audit_report_and_send_as_task.delay(user.id, recipient.id, start, end)
+        return Response({"__notification": {"title": "Report send."}}, status=status.HTTP_200_OK)
+
+
+class RebatePandasView(RebatePermissionMixin, ExportPandasAPIViewSet):
+    queryset = Rebate.objects.all()
+
+    filterset_class = RebateGroupByFilter
+
+    search_fields = ["title"]
+
+    display_config_class = RebatePandasViewDisplayConfig
+    title_config_class = RebatePandasViewTitleConfig
+    endpoint_config_class = RebatePandasViewEndpointConfig
+    button_config_class = RebateTableButtonConfig
+
+    def get_ordering_fields(self):
+        return ["rebate_total", *map(lambda x: f"rebate_{x}", self.rebate_types.keys())]
+
+    def get_pandas_fields(self, request):
+        fields = [pf.PKField(key="id", label="ID"), pf.CharField(key="title", label="Title")]
+        for key, label in self.rebate_types.items():
+            fields.append(
+                pf.FloatField(
+                    key="rebate_" + key,
+                    label=label,
+                    precision=2,
+                    decorators=[decorator(decorator_type="text", position="left", value="$")],
+                )
+            )
+        fields.append(
+            pf.FloatField(
+                key="rebate_total",
+                label="Total Rebate",
+                precision=2,
+                decorators=[decorator(decorator_type="text", position="left", value="$")],
+            )
+        )
+        return pf.PandasFields(fields=fields)
+
+    @cached_property
+    def groupby_classification_group(self) -> ClassificationGroup:
+        try:
+            return ClassificationGroup.objects.get(id=self.request.GET["groupby_classification_group"])
+        except (ValueError, KeyError):
+            return get_default_classification_group()
+
+    @cached_property
+    def rebate_types(self):
+        return dict(CommissionType.objects.values_list("key", "name"))
+
+    def get_queryset(self):
+        qs = (
+            super()
+            .get_queryset()
+            .annotate(
+                fx_rate=CurrencyFXRates.get_fx_rates_subquery("date", lookup_expr="exact"),
+                value_usd=F("value") * F("fx_rate"),
+            )
+        )
+        qs = Account.annotate_root_account_info(qs)
+        qs = self.groupby_classification_group.annotate_queryset(qs, 0, "product")
+        return (
+            qs.select_related("product")
+            .prefetch_related("product__currency")
+            .prefetch_related("product__parent")
+            .select_related("recipient")
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        groupby = self.request.GET.get("group_by", "PRODUCT")
+        groupby_map = RebateGroupbyChoice.map[groupby]
+        pivot = groupby_map["pk"]
+        pivot_label = groupby_map["title_key"]
+        if pivot == "classification_id":
+            df = pd.DataFrame(
+                queryset.values_list(
+                    "value_usd",
+                    "commission_type__key",
+                    "classifications",
+                ),
+                columns=["value_usd", "commission_type__key", "classifications"],
+            )
+            df = (
+                df.explode("classifications")
+                .rename(columns={"classifications": "classification_id"})
+                .replace([np.inf, -np.inf, np.nan], None)
+            )
+            df["classification_title"] = df.classification_id.map(
+                dict(Classification.objects.filter(id__in=df.classification_id.unique()).values_list("id", "name")),
+                na_action="ignore",
+            )
+        else:
+            df = pd.DataFrame(
+                queryset.values_list(
+                    "value_usd",
+                    "commission_type__key",
+                    pivot,
+                    pivot_label,
+                ),
+                columns=["value_usd", "commission_type__key", pivot, pivot_label],
+            )
+        df = df.rename(columns={pivot: "id", pivot_label: "title"})
+        df = pd.pivot_table(
+            df,
+            index=["id", "title"],
+            columns="commission_type__key",
+            values="value_usd",
+            aggfunc="sum",
+            fill_value=0,
+        )
+        df["total"] = df.sum(axis=1)
+        # Ensure all type are always present as a columns
+        for commission_type in self.rebate_types.keys():
+            if commission_type not in df.columns:
+                df[commission_type] = 0
+        df = df.add_prefix("rebate_").reset_index()
+        df.id = df.id.fillna(0)
+        df.title = df.title.fillna("None")
+        df[df.columns.difference(["id", "title"])] = df[df.columns.difference(["id", "title"])].astype("float")
+        return df
+
+    def get_aggregates(self, request, df):
+        if df.empty:
+            return {}
+        return {
+            **{
+                "rebate_"
+                + commission_type.key: {
+                    "Σ": format_number(df["rebate_" + commission_type.key].sum()),
+                }
+                for commission_type in CommissionType.objects.all()
+            },
+            "rebate_total": {
+                "Σ": format_number(df["rebate_total"].sum()),
+            },
+        }
+
+    def get_filterset_class(self, request):
+        profile = request.user.profile
+        if profile.is_internal or request.user.is_superuser:
+            return RebateGroupByFilter
+        return CustomerRebateGroupByFilter
+
+
+class RebateProductMarginalityViewSet(ExportPandasAPIViewSet):
+    IDENTIFIER = "wbcommission:product-marginality"
+
+    filterset_class = RebateMarginalityFilter
+
+    pandas_fields = pf.PandasFields(
+        fields=[
+            pf.PKField(key="id", label="ID"),
+            pf.CharField(key="title", label="title"),
+            pf.CharField(key="currency_symbol", label="Currency"),
+            pf.FloatField(key="base_management_fees_percent", label="Base Management Fees", percent=True),
+            pf.FloatField(
+                key="management_fees",
+                label="management_fees",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="management_rebates",
+                label="management_rebates",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="management_marginality",
+                label="management_marginality",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(key="base_performance_fees_percent", label="Base Performance Fees", percent=True),
+            pf.FloatField(
+                key="performance_fees",
+                label="performance_fees",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="performance_rebates",
+                label="performance_rebates",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="performance_marginality",
+                label="performance_marginality",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="total_fees",
+                label="total_fees",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}")
+                ],
+            ),
+            pf.FloatField(
+                key="total_rebates",
+                label="total_rebates",
+                decorators=[
+                    wb_serializers.decorator(decorator_type="text", position="left", value="{{currency_symbol}}"),
+                ],
+            ),
+            pf.FloatField(key="total_marginality_percent", label="total_marginality_percent", percent=True),
+            pf.FloatField(
+                key="total_fees_usd",
+                label="total_fees_usd",
+                decorators=[wb_serializers.decorator(decorator_type="text", position="left", value="$")],
+            ),
+            pf.FloatField(
+                key="total_rebates_usd",
+                label="total_rebates_usd",
+                decorators=[wb_serializers.decorator(decorator_type="text", position="left", value="$")],
+            ),
+            pf.FloatField(
+                key="total_marginality_usd",
+                label="total_marginality_usd",
+                decorators=[wb_serializers.decorator(decorator_type="text", position="left", value="$")],
+            ),
+            pf.FloatField(key="net_management_marginality", label="net_management_marginality", percent=True),
+            pf.FloatField(key="net_performance_marginality", label="net_performance_marginality", percent=True),
+        ]
+    )
+    queryset = Product.objects.all()
+    ordering_fields = [
+        "title",
+        "base_management_fees_percent",
+        "base_performance_fees_percent",
+        "management_fees",
+        "management_rebates",
+        "management_marginality",
+        "performance_fees",
+        "performance_rebates",
+        "performance_marginality",
+        "total_fees",
+        "total_rebates",
+        "total_marginality_percent",
+        "total_fees_usd",
+        "total_rebates_usd",
+        "total_marginality_usd",
+        "net_management_marginality",
+    ]
+    search_fields = ["title", "bank_title"]
+    ordering = ["title"]
+
+    display_config_class = RebateProductMarginalityDisplayConfig
+    title_config_class = RebateProductMarginalityTitleConfig
+    endpoint_config_class = RebateProductMarginalityEndpointConfig
+
+    def get_aggregates(self, request, df):
+        aggregates = {}
+        if not df.empty:
+            total_fees = df.total_fees.sum()
+            total_rebates = df.total_rebates.sum()
+            total_marginality_percent = 1 - total_rebates / total_fees if total_fees != 0 else 0
+
+            aggregates = {
+                "total_marginality_percent": {"Σ": format_number(total_marginality_percent)},
+                "total_fees_usd": {"Σ": format_number(df.total_fees_usd.sum())},
+                "total_rebates_usd": {"Σ": format_number(df.total_rebates_usd.sum())},
+                "total_marginality_usd": {"Σ": format_number(df.total_marginality_usd.sum())},
+            }
+            if aggregated_net_management_marginality := getattr(self, "aggregated_net_management_marginality", None):
+                aggregates["net_management_marginality"] = {
+                    "Σ": format_number(aggregated_net_management_marginality, decimal=4)
+                }
+            if aggregated_net_performance_marginality := getattr(self, "aggregated_net_performance_marginality", None):
+                aggregates["net_performance_marginality"] = {
+                    "Σ": format_number(aggregated_net_performance_marginality, decimal=4)
+                }
+            currency_aggregates = defaultdict(dict)
+            for currency_symbol in df["currency_symbol"].unique():
+                for field in [
+                    "management_fees",
+                    "management_rebates",
+                    "performance_fees",
+                    "performance_rebates",
+                    "total_fees",
+                    "total_rebates",
+                    "management_marginality",
+                    "performance_marginality",
+                ]:
+                    currency_aggregates[field][currency_symbol] = format_number(
+                        df.loc[df["currency_symbol"] == currency_symbol, field].sum()
+                    )
+            aggregates.update(currency_aggregates)
+        return aggregates
+
+    @cached_property
+    def start(self) -> date | None:
+        return get_date_interval_from_request(self.request, exclude_weekend=True)[0]
+
+    @cached_property
+    def end(self) -> date | None:
+        return get_date_interval_from_request(self.request, exclude_weekend=True)[1]
+
+    def get_queryset(self):
+        if self.request.user.has_perm("wbcommission.administrate_commission"):
+            has_aum_subquery = InstrumentPrice.objects.filter(instrument=OuterRef("pk"), outstanding_shares__gt=0)
+            if self.start and self.end:
+                has_aum_subquery = has_aum_subquery.filter(
+                    date__gte=self.start,
+                    date__lte=self.end,
+                )
+            return super().get_queryset().annotate(has_aum=Exists(has_aum_subquery)).filter(has_aum=True)
+        return Product.objects.none()
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        df = pd.DataFrame()
+        if queryset.exists() and self.start and self.end:
+            marginality_calculator = MarginalityCalculator(queryset, self.start, self.end)
+            df_products = (
+                pd.DataFrame(
+                    queryset.values(
+                        "id", "computed_str", "current_management_fees", "current_performance_fees", "currency__symbol"
+                    )
+                )
+                .set_index("id")
+                .rename(
+                    columns={
+                        "currency__symbol": "currency_symbol",
+                        "computed_str": "title",
+                        "current_management_fees": "base_management_fees_percent",
+                        "current_performance_fees": "base_performance_fees_percent",
+                    }
+                )
+            )
+            # Concat dataframe and add extra statistic columns
+            df = pd.concat(
+                [
+                    df_products["title"],
+                    df_products["base_management_fees_percent"],
+                    df_products["base_performance_fees_percent"],
+                    df_products["currency_symbol"],
+                    marginality_calculator.management_fees,
+                    marginality_calculator.performance_fees,
+                    marginality_calculator.total_fees,
+                    marginality_calculator.total_rebates,
+                    marginality_calculator.total_marginality_percent,
+                    marginality_calculator.management_rebates,
+                    marginality_calculator.performance_rebates,
+                    marginality_calculator.management_marginality,
+                    marginality_calculator.performance_marginality,
+                    marginality_calculator.management_marginality_percent,
+                    marginality_calculator.total_fees_usd,
+                    marginality_calculator.total_rebates_usd,
+                    marginality_calculator.total_marginality_usd,
+                ],
+                axis=1,
+            )
+            df["net_management_marginality"] = marginality_calculator.get_net_marginality("management")
+            df["net_performance_marginality"] = marginality_calculator.get_net_marginality("performance")
+            self.aggregated_net_management_marginality = marginality_calculator.get_aggregated_net_marginality(
+                "management"
+            )
+            self.aggregated_net_performance_marginality = marginality_calculator.get_aggregated_net_marginality(
+                "performance"
+            )
+            # Sanitize
+            df = df.replace([np.inf, -np.inf, np.nan], 0).reset_index()
+            df = df[(df["total_fees"] != 0) | (df["total_rebates"] != 0)]
+            return df
+        return df

wbcommission/viewsets/titles/__init__.py

@@ -0,0 +1 @@
+from .rebate import RebatePandasViewTitleConfig, RebateProductMarginalityTitleConfig

wbcommission/viewsets/titles/rebate.py

@@ -0,0 +1,11 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class RebatePandasViewTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Rebates"
+
+
+class RebateProductMarginalityTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Marginality per Product"

wbcommission-2.2.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,76 @@
+wbcommission/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+wbcommission/apps.py,sha256=3q9lAeEBfv83rCzud3P0-VZgbWUfG0S61G5h3zFk1Ds,97
+wbcommission/dynamic_preferences_registry.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/permissions.py,sha256=Qjmterwqsm1st8YZNfj_7-Gl6WnvVvkE6SCgYynMhSU,219
+wbcommission/urls.py,sha256=6IgkFTSk7u7eD2CO3DXZP0oLFQtEQvUOg1EKqFLdeF4,1101
+wbcommission/admin/__init__.py,sha256=xEYZYO9IUSNExPsY7jsxFS-Jjkl92tXnb7eSfwGpkZg,151
+wbcommission/admin/accounts.py,sha256=8QtAEK5iCjbXlpOoxWC9-aO-ekvCRgKczOUb2oPqGRo,815
+wbcommission/admin/commission.py,sha256=lye6PicAUKCGBVMmYxuIiz9g0DRbbTrv9eSryH0Uulg,2077
+wbcommission/admin/rebate.py,sha256=XoDyGl1MoUAiUrm-GL5wlHvCzASgZqmGWvfMVOm2rJA,230
+wbcommission/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/analytics/marginality.py,sha256=bSIpjglq7_yYK2z1sfJ7ymUXUMS_FR_b_gwthVEVs2U,8116
+wbcommission/factories/__init__.py,sha256=3EdqwSHMqJIa5C_yH15M75u_frkLEno151aFoxrOLN0,249
+wbcommission/factories/commission.py,sha256=Hf99FIEwQaj42YivziqEWcIFu4aB_8uUiug1dh3RNDU,3020
+wbcommission/factories/rebate.py,sha256=GnKE2LOb4ynNUxF1-A8sDpnxAO4HHdcrRWrFSTKDdTA,682
+wbcommission/filters/__init__.py,sha256=9XoFMsmHcdTqy7ujQFlxvAJFvZoc4hjZ1SR6pyY8-9k,156
+wbcommission/filters/rebate.py,sha256=42wDFwSsfPZHstawAnSnENx6fkLeel3St5w3_58IA2o,8300
+wbcommission/filters/signals.py,sha256=J-a9F3IwWhgl7HZE9I2Z6PA6H7fKDnMrhtSQZ4wqhGU,1583
+wbcommission/generators/__init__.py,sha256=Pt8TjtYCmqhROvWNmf_dxuONKVcrj7SH14nJAcv7_1Q,47
+wbcommission/generators/rebate_generator.py,sha256=Cp_JvdI64N0tlTYDiOkk67ZwB8HTzCzTEHn2gdTVxEo,4154
+wbcommission/migrations/0001_initial.py,sha256=mE-vL8OsbdVvpnAqOQm38ZHQj6MVlpsu78b5WvJaxl0,11816
+wbcommission/migrations/0002_commissionrule_remove_accountcustomer_account_and_more.py,sha256=gAqysHE_jwEbNWkMTAbocBS6B5R9IDfV3fAn9wrPWyE,16384
+wbcommission/migrations/0003_alter_commission_account.py,sha256=P0EciB1Rne8LsbJqgtBnzfSD6O6pVSmmfeB2Ue5zeUk,727
+wbcommission/migrations/0004_rebate_audit_log.py,sha256=861gZjI0XwIjKgM60v663I4fj-IzGVYx91p2ydQmOkM,543
+wbcommission/migrations/0005_alter_rebate_audit_log.py,sha256=u_1c9dGGG3zoppPNgnGT2eoSVOdPbksNC3ifUHrgUH0,538
+wbcommission/migrations/0006_commissionrule_consider_zero_percent_for_exclusion.py,sha256=6km7vAPs49c7mAjxgVQDwKYOPs4exbfo2Hd0RFbtAvc,679
+wbcommission/migrations/0007_remove_commission_unique_crm_recipient_account_and_more.py,sha256=Olo_Acmg-aGOq4ZwQA5HjvxcHEZlnIMqbJObBBUQz5k,1947
+wbcommission/migrations/0008_alter_commission_options_alter_commission_order.py,sha256=iNwNF1QcmVoj5Eu2yPJEHfI7bIA3e4WZMILjCfBVEx0,830
+wbcommission/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/models/__init__.py,sha256=BJyah0_zKssfU2ohvu4qcQSHAT1ovcZ_go2-sLEagyw,183
+wbcommission/models/account_service.py,sha256=WUzcuWoZEr5twkZFEd-ejofkg6ZPCL3o-0vYXvIVAkI,10652
+wbcommission/models/commission.py,sha256=tkWb7ej2wjIGc_GIj-m02AGEwSEoElQ12LO6nyE1xUg,29574
+wbcommission/models/rebate.py,sha256=TWrnTEjJkbr_KQb_pWnvdPWbFzRxJZyxoyZT5cfI1c4,12699
+wbcommission/models/signals.py,sha256=d-123hxTlbp2A9AwUOE_E90jrDN1e3_r7d8aGq7SmiY,2270
+wbcommission/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/reports/audit_report.py,sha256=FAcZbXrzRfchYcAgC9B6XyQFY_o4vYnCVbkdoB5jfTg,2177
+wbcommission/reports/customer_report.py,sha256=_vciCoE2D43W7r2tCaTK-n_jm01dfFGM_wYD82-yGhc,14245
+wbcommission/reports/utils.py,sha256=Twc1SOwRIkB-_RJHFO1-tJaQ3ocCjFz0GsUXZPMZ3i8,1078
+wbcommission/serializers/__init__.py,sha256=t38bchJeNgOcogmedHLfLBQBtRXuR-_hj0US_55Fug4,196
+wbcommission/serializers/commissions.py,sha256=mWSxVuKAZdSHFfBuqB0c7Nf_cYBXL8kb7SQCgVNXuRw,677
+wbcommission/serializers/rebate.py,sha256=q69cDY8YO7-m9QkNg5gatgY7QnXZq9AnR42lS7EuBQY,4037
+wbcommission/serializers/signals.py,sha256=lX-oBPhWoIrDTSvP3UbKRh6VA16T9-NtisMFPwXP8-c,1427
+wbcommission/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/tests/conftest.py,sha256=WEuFy8wOiCvUxKHObOBU0xsCZ_AZubXS0jtfIakTrGY,2605
+wbcommission/tests/signals.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/tests/test_permissions.py,sha256=My-dDaBfkBcVD7aakhYkHFtNVS_6ag8C0c7kRP--wIU,2537
+wbcommission/tests/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/tests/analytics/test_marginality.py,sha256=AtAVSD_DRG2YiwQCkeicrssjYtWK1HDegM9HBRqlBZg,11719
+wbcommission/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/tests/models/mixins.py,sha256=s0Z_zMZLee6KCdUOrOTAutdgTz2nZhzJJsi8cO8xDjc,817
+wbcommission/tests/models/test_account_service.py,sha256=ABHIyW82404d3RIlTPqmUt7kGUPdH8bUtSyUtJZ_AHc,13490
+wbcommission/tests/models/test_commission.py,sha256=dBtvh3SorcAVzTFE5jUHd3gsmqa8QaTBJQ-ooxreySo,28064
+wbcommission/tests/models/test_rebate.py,sha256=pbgao6plo5TCGpkiRIQtl6Y0sSP4D0UCtBmqjswFVd0,5745
+wbcommission/tests/viewsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/tests/viewsets/test_rebate.py,sha256=q-naStrCA-uqQVzOYPE7EmG9c7dbgSLgUJ-_rMbNMgM,3261
+wbcommission/viewsets/__init__.py,sha256=iuWo3Y9t8XxPgRG5DIURBk0J8hDoK2oTmMhv9hiAUcU,232
+wbcommission/viewsets/commissions.py,sha256=pL8GOaGlHbEgX86OXKa1HHZSLnQl8uNtpukuhotB-WM,759
+wbcommission/viewsets/mixins.py,sha256=g5hopDDpDlimlOoH55x-C4HIZxsn_RJnpLztjNY_vDY,1308
+wbcommission/viewsets/rebate.py,sha256=mnkifgroC7qKzbUHJKoy5zaEhpmgqHBRnV6NjLoQgfM,20947
+wbcommission/viewsets/buttons/__init__.py,sha256=hebcLFrOBe36pjHpYLxkY4ucT75WtQiQxIsjaO0rD14,67
+wbcommission/viewsets/buttons/rebate.py,sha256=UXwwtlz24Dyko-6HF4ad3GKvc3YNfFNzVjWOLztI1Vs,2376
+wbcommission/viewsets/buttons/signals.py,sha256=7c-TI_SxGuCi-Y4e8yHFUva6TLIdXI5NHOKGowrARNI,2220
+wbcommission/viewsets/display/__init__.py,sha256=_aqbPI2tZZJNgzIB05MH_eFbWmraTb8tB0R6llAPXFw,160
+wbcommission/viewsets/display/commissions.py,sha256=4ifC3j3-wE1t57Yy9x02RnT1VAYbeXUtIMxq4ljdt-c,671
+wbcommission/viewsets/display/rebate.py,sha256=T45d_FP3W6934BwWVBAiT58tb4Dr7BmIA9nPnAdoOEA,5287
+wbcommission/viewsets/endpoints/__init__.py,sha256=ghffTV9z9LxVzxNS4divoQ54sVosYZiJCEuqeUJ5gmo,135
+wbcommission/viewsets/endpoints/commissions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/viewsets/endpoints/rebate.py,sha256=4QOR3MHD7JZVr2LhPi51d1xKg_ttbfD4YbJ4mGq9QjU,728
+wbcommission/viewsets/menu/__init__.py,sha256=i2Sn3h8e-KZefQHg72QS4ba5P34pTGFe3s-dobYW5WU,65
+wbcommission/viewsets/menu/commissions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/viewsets/menu/rebate.py,sha256=Qzhwr2xG3_j7frxs3eWLZuMoUzT2nCBrWmEYbZ8fKfU,484
+wbcommission/viewsets/titles/__init__.py,sha256=Sg64aMWm_OD4-P57YoaN6Mqv6NRVU5m7ii_WvaWuTsY,85
+wbcommission/viewsets/titles/commissions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wbcommission/viewsets/titles/rebate.py,sha256=VTSHJW3voqCMVhDZ_zVeVmZid_WY3P4X9k11VdJM_GQ,301
+wbcommission-2.2.1.dist-info/METADATA,sha256=0uHLSJaMN3PDweadP-mBkB3zUztq5wabMuxCGuTotuM,322
+wbcommission-2.2.1.dist-info/WHEEL,sha256=aO3RJuuiFXItVSnAUEmQ0yRBvv9e1sbJh68PtuQkyAE,105
+wbcommission-2.2.1.dist-info/RECORD,,

wbcommission-2.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any