wbcommission 1.49.8__tar.gz → 1.49.10__tar.gz

{wbcommission-1.49.8 → wbcommission-1.49.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbcommission
-Version: 1.49.8
+Version: 1.49.10
 Summary: A workbench module for managing human resources.
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: reportlab==3.*

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/analytics/marginality.py

@@ -1,10 +1,11 @@
-from datetime import date
+from datetime import date, timedelta
 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 pandas._libs.tslibs.offsets import BDay
 from wbcore.contrib.currency.models import CurrencyFXRates
 from wbfdm.models import InstrumentPrice
 from wbportfolio.models import Fees
@@ -20,6 +21,9 @@ class MarginalityCalculator:
     }
 
     def __init__(self, products, from_date: date, to_date: date):
+        bday_from_date = (from_date + timedelta(days=1) - BDay(1)).date()
+        bday_to_date = (to_date - timedelta(days=1) + BDay(1)).date()
+
         products = products.annotate(
             fx_rate=Coalesce(
                 Subquery(
@@ -40,7 +44,7 @@ class MarginalityCalculator:
         # 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)
+            .filter(instrument__in=products, date__gte=bday_from_date, date__lte=bday_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"})
@@ -66,10 +70,9 @@ class MarginalityCalculator:
         ).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_date__lte=bday_to_date,
+            transaction_date__gte=bday_from_date,
             transaction_subtype__in=self.FEE_MAP.keys(),
             linked_product__in=products,
         ).annotate(
@@ -93,10 +96,14 @@ class MarginalityCalculator:
         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)
+        self.df_fees = self.df_fees[
+            (self.df_fees.index.get_level_values(1) >= pd.Timestamp(from_date))
+            & (self.df_fees.index.get_level_values(1) <= pd.Timestamp(to_date))
+        ]
 
         # 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(
+            Rebate.objects.filter(date__gte=bday_from_date, date__lte=bday_to_date, product__in=products).values_list(
                 "product", "value", "date", "commission_type__key"
             ),
             columns=["product", "value", "date", "commission_type__key"],
@@ -118,9 +125,16 @@ class MarginalityCalculator:
         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.df_rebates = self.df_rebates[
+            (self.df_rebates.index.get_level_values(1) >= pd.Timestamp(from_date))
+            & (self.df_rebates.index.get_level_values(1) <= pd.Timestamp(to_date))
+        ]
+        # Initialize basic column
+        self.df_aum = self.df_aum[
+            (self.df_aum.index.get_level_values(1) >= pd.Timestamp(from_date))
+            & (self.df_aum.index.get_level_values(1) <= pd.Timestamp(to_date))
+        ]
+        self.empty_column = pd.Series(0.0, dtype="float64", index=self.df_aum.index)
         self._set_basics_statistics()
 
     def _set_basics_statistics(self):

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/models/account_service.py

@@ -91,7 +91,7 @@ class AccountRebateManager:
         only_content_object_ids: list[int] | None = None,
         start_date: date | None = None,
         terminal_account_filter_dict: dict[str, Any] | None = None,
-        **kwargs
+        **kwargs,
     ) -> Generator[tuple[Account, Product, date], None, None]:
         """
         Given the parameters and the instance root account and commission type, yield all valid terminal account, product and date

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/models/commission.py

@@ -201,13 +201,21 @@ class CommissionType(WBModel):
                         )  # If fees are negative, then we need to return the negative of the recipient fees
 
                         # Yield rebate information
-                        yield terminal_account, compute_date, commission, content_object, recipient, rebate_gain, {
-                            "terminal_account_holding_ratio": terminal_account_holding_ratio,
-                            "root_account_total_holding": root_account_total_holding,
-                            "commission_percent": actual_percent,
-                            "commission_pool": commission_pool,
-                            "recipient_percent": recipient_percent,
-                        }
+                        yield (
+                            terminal_account,
+                            compute_date,
+                            commission,
+                            content_object,
+                            recipient,
+                            rebate_gain,
+                            {
+                                "terminal_account_holding_ratio": terminal_account_holding_ratio,
+                                "root_account_total_holding": root_account_total_holding,
+                                "commission_percent": actual_percent,
+                                "commission_pool": commission_pool,
+                                "recipient_percent": recipient_percent,
+                            },
+                        )
 
     def __str__(self) -> str:
         return self.name
@@ -433,11 +441,14 @@ class Commission(OrderedModel, WBModel):
             )
             total_weighting = Decimal(account_roles.aggregate(s=Sum("weighting"))["s"] or 0)
             for account_role in account_roles:
-                yield account_role.entry, Decimal(
-                    account_role.weighting
-                ) / total_weighting if total_weighting else Decimal(0)
+                yield (
+                    account_role.entry,
+                    Decimal(account_role.weighting) / total_weighting if total_weighting else Decimal(0),
+                )
         else:
-            role_recipients = PortfolioRole.objects.exclude(weighting=0).filter(
+            role_recipients = PortfolioRole.objects.exclude(
+                weighting=0
+            ).filter(
                 (Q(role_type=self.portfolio_role_recipient) & (Q(instrument=product) | Q(instrument__isnull=True)))
                 & (Q(start__lte=val_date) | Q(start__isnull=True))
                 & (
@@ -446,9 +457,10 @@ class Commission(OrderedModel, WBModel):
             )
             total_weighting = Decimal(role_recipients.aggregate(s=Sum("weighting"))["s"] or 0)
             for portfolio_role in role_recipients:
-                yield portfolio_role.person.entry_ptr, Decimal(
-                    Decimal(portfolio_role.weighting) / total_weighting
-                ) if total_weighting else Decimal(0)
+                yield (
+                    portfolio_role.person.entry_ptr,
+                    Decimal(Decimal(portfolio_role.weighting) / total_weighting) if total_weighting else Decimal(0),
+                )
 
     @classmethod
     def get_endpoint_basename(cls) -> str:

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/serializers/signals.py

@@ -21,7 +21,7 @@ def commission_adding_additional_resource(sender, serializer, instance, request,
         "generate_customer_commission_report": f'{reverse("wbcommission:rebate-customerreport", request=request)}?recipient_id={instance.id}',
     }
     if user.has_perm("wbcommission.administrate_commission"):
-        res[
-            "generate_audit_commission_report"
-        ] = f'{reverse("wbcommission:rebate-auditreport", request=request)}?recipient_id={instance.id}'
+        res["generate_audit_commission_report"] = (
+            f'{reverse("wbcommission:rebate-auditreport", request=request)}?recipient_id={instance.id}'
+        )
     return res

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/tests/analytics/test_marginality.py

@@ -3,7 +3,8 @@ from faker import Faker
 from pandas.tseries.offsets import BDay
 from rest_framework.reverse import reverse
 from rest_framework.test import APIClient, APIRequestFactory
-from wbportfolio.factories import FeesFactory, InstrumentPriceFactory, ProductFactory
+from wbfdm.factories import InstrumentPriceFactory
+from wbportfolio.factories import FeesFactory, ProductFactory
 from wbportfolio.models import Product
 
 from wbcommission.analytics.marginality import MarginalityCalculator

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/tests/conftest.py

@@ -23,12 +23,11 @@ from wbcore.contrib.geography.factories import (
 )
 from wbcore.contrib.geography.tests.signals import app_pre_migration
 from wbcrm.factories import AccountFactory, AccountRoleFactory, AccountRoleTypeFactory
-from wbfdm.factories import ExchangeFactory, InstrumentFactory, InstrumentTypeFactory
+from wbfdm.factories import ExchangeFactory, InstrumentFactory, InstrumentTypeFactory, InstrumentPriceFactory
 from wbportfolio.factories import (
     ClaimFactory,
     CustomerTradeFactory,
     FeesFactory,
-    InstrumentPriceFactory,
     PortfolioFactory,
     ProductFactory,
     ProductPortfolioRoleFactory,

{wbcommission-1.49.8 → wbcommission-1.49.10}/wbcommission/viewsets/rebate.py

@@ -4,11 +4,13 @@ from decimal import Decimal
 
 import numpy as np
 import pandas as pd
+from django.contrib.messages import warning
 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 django.utils.translation import gettext_lazy as _
 from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.response import Response
@@ -406,11 +408,11 @@ class RebateProductMarginalityViewSet(ExportPandasAPIViewSet):
 
     @cached_property
     def start(self) -> date | None:
-        return get_date_interval_from_request(self.request, exclude_weekend=True)[0]
+        return get_date_interval_from_request(self.request, exclude_weekend=False)[0]
 
     @cached_property
     def end(self) -> date | None:
-        return get_date_interval_from_request(self.request, exclude_weekend=True)[1]
+        return get_date_interval_from_request(self.request, exclude_weekend=False)[1]
 
     def get_queryset(self):
         if self.request.user.has_perm("wbcommission.administrate_commission"):
@@ -420,12 +422,19 @@ class RebateProductMarginalityViewSet(ExportPandasAPIViewSet):
                     date__gte=self.start,
                     date__lte=self.end,
                 )
-            return super().get_queryset().annotate(has_aum=Exists(has_aum_subquery)).filter(has_aum=True)
+            return super().get_queryset().annotate(has_aum=Exists(has_aum_subquery))
         return Product.objects.none()
 
     def get_dataframe(self, request, queryset, **kwargs):
         df = pd.DataFrame()
         if queryset.exists() and self.start and self.end:
+            if self.start.weekday() in (5, 6) or self.end.weekday() in (5, 6):
+                warning(
+                    request,
+                    _(
+                        "The selected date range includes a Saturday or Sunday. Please note that fees and rebates are normalized over the weekend, as fees continue to accumulate during this period."
+                    ),
+                )
             marginality_calculator = MarginalityCalculator(queryset, self.start, self.end)
             df_products = (
                 pd.DataFrame(