wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/admin/transactions/trades.py

@@ -0,0 +1,49 @@
+from django.contrib import admin
+from wbportfolio.admin.transactions import TransactionModelAdmin
+from wbportfolio.models import Trade, TradeProposal
+
+
+@admin.register(Trade)
+class TradeAdmin(TransactionModelAdmin):
+    search_fields = [*TransactionModelAdmin.search_fields, "bank"]
+    list_filter = (*TransactionModelAdmin.list_filter, "pending")
+    list_display = (
+        "transaction_subtype",
+        "status",
+        "shares",
+        "price",
+        "pending",
+        "marked_for_deletion",
+        "exclude_from_history",
+        *TransactionModelAdmin.list_display[1:],
+    )
+    readonly_fields = [
+        "_effective_weight",
+        "_target_weight",
+        "_effective_shares",
+        "_target_shares",
+    ]
+    fieldsets = (
+        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
+        (
+            "Trade Information",
+            {
+                "fields": (
+                    ("transaction_subtype", "status", "pending", "marked_for_deletion", "exclude_from_history"),
+                    ("price", "price_gross"),
+                    ("register", "custodian", "bank", "external_identifier2"),
+                    ("_effective_weight", "_target_weight", "weighting"),
+                    ("_effective_shares", "_target_shares", "shares"),
+                )
+            },
+        ),
+    )
+    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "register", "custodian"]
+
+
+@admin.register(TradeProposal)
+class TradeProposalAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "model_portfolio__name", "comment"]
+
+    list_display = ("portfolio", "model_portfolio", "trade_date", "status")
+    autocomplete_fields = ["portfolio", "model_portfolio"]

wbportfolio/admin/transactions/transactions.py

@@ -0,0 +1,37 @@
+from django.contrib import admin
+from wbportfolio.models import Transaction
+
+
+@admin.register(Transaction)
+class TransactionModelAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "underlying_instrument__computed_str"]
+    list_filter = ("transaction_type", "portfolio")
+    list_display = (
+        "transaction_type",
+        "portfolio",
+        "underlying_instrument",
+        "transaction_date",
+        "currency",
+        "currency_fx_rate",
+        "total_value",
+        "total_value_fx_portfolio",
+        "import_source",
+    )
+    fieldsets = (
+        (
+            "Transaction Information",
+            {
+                "fields": (
+                    ("portfolio", "underlying_instrument", "transaction_type", "import_source", "external_id"),
+                    ("transaction_date", "book_date", "value_date"),
+                    ("currency", "currency_fx_rate"),
+                    ("total_value", "total_value_gross"),
+                    ("total_value_fx_portfolio", "total_value_gross_fx_portfolio"),
+                    "comment",
+                )
+            },
+        ),
+    )
+    autocomplete_fields = ["portfolio", "underlying_instrument", "currency"]
+    ordering = ("-transaction_date",)
+    raw_id_fields = ["import_source"]

wbportfolio/analysis/claims.py

@@ -0,0 +1,235 @@
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from django.db import connection
+from django.db.models import DecimalField, ExpressionWrapper, F, OuterRef, Subquery
+from django.template.loader import get_template
+from jinjasql import JinjaSql
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.dataloader.utils import dictfetchall
+from wbcrm.models import Account
+from wbfdm.models import ClassificationGroup
+from wbfdm.models.instruments import Classification, InstrumentPrice
+from wbportfolio.models.products import Product
+
+if TYPE_CHECKING:
+    from datetime import date
+    from typing import Iterable
+
+
+def get_assets_and_net_new_money_progression(
+    from_date: "date", to_date: "date", product_id: int | None = None, account_tree_id: int | None = None
+) -> "Iterable[dict]":
+    template = get_template("wbportfolio/sql/aum_nnm.sql", using="jinja").template
+    query, params = JinjaSql(param_style="format").prepare_query(
+        template,
+        {
+            "from_date": from_date.strftime("%Y-%m-%d"),
+            "to_date": to_date.strftime("%Y-%m-%d"),
+            "product_id": product_id,
+            "account_tree_id": account_tree_id,
+        },
+    )
+
+    with connection.cursor() as cursor:
+        cursor.execute(query, params)
+        yield from dictfetchall(cursor)
+
+
+class ConsolidatedTradeSummary:
+    def __init__(
+        self,
+        queryset,
+        start_date: "date",
+        end_date: "date",
+        pivot: str,
+        pivot_label: str,
+        classification_group: ClassificationGroup | None = None,
+        classification_height: int = 0,
+    ):
+        self.queryset = queryset.filter(trade__isnull=False, status="APPROVED")
+        self.start_date = start_date
+        self.end_date = end_date
+        self.pivot = pivot
+        self.pivot_label = pivot_label
+        self.queryset = self.queryset.annotate(
+            net_value=InstrumentPrice.subquery_closest_value(
+                "net_value", date_name="date", instrument_pk_name="product__pk", date_lookup="exact"
+            ),
+            fx_rate=CurrencyFXRates.get_fx_rates_subquery("date", lookup_expr="exact"),
+            aum=ExpressionWrapper(F("fx_rate") * F("net_value") * F("shares"), output_field=DecimalField()),
+            internal_trade=F("trade__marked_as_internal"),
+        )
+        self.queryset = Account.annotate_root_account_info(self.queryset)
+
+        if classification_group:
+            self.queryset = classification_group.annotate_queryset(self.queryset, classification_height, "product")
+
+        self.queryset = self.queryset.select_related(
+            "product",
+            "account",
+            "product__parent",
+        )
+        self.df = self._prepare_df()
+
+    def _prepare_df(self) -> pd.DataFrame:
+        columns = ["shares", "date", "product__id", "aum", "internal_trade"]
+        if self.pivot == "classification_id":
+            columns.append("classifications")
+        else:
+            columns.append(self.pivot)
+            columns.append(self.pivot_label)
+
+        df = pd.DataFrame(self.queryset.values_list(*columns), columns=columns)
+        if self.pivot == "classification_id":
+            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",
+            )
+        df_product = pd.DataFrame(
+            Product.objects.annotate(
+                net_value_date_start=Subquery(
+                    InstrumentPrice.objects.filter(
+                        instrument=OuterRef("pk"), calculated=False, date__lte=self.start_date
+                    )
+                    .order_by("-date")
+                    .values("date")[:1]
+                ),
+                net_value_date_end=Subquery(
+                    InstrumentPrice.objects.filter(
+                        instrument=OuterRef("pk"), calculated=False, date__lte=self.end_date
+                    )
+                    .order_by("-date")
+                    .values("date")[:1]
+                ),
+                net_value_start=InstrumentPrice.subquery_closest_value(
+                    "net_value",
+                    date_name="net_value_date_start",
+                    instrument_pk_name="pk",
+                    date_lookup="exact"
+                    # we get all net value (even estimated) to avoir showing None price on holiday
+                ),
+                fx_rate_start=CurrencyFXRates.get_fx_rates_subquery(
+                    "net_value_date_start", currency="currency", lookup_expr="exact"
+                ),
+                price_start=ExpressionWrapper(F("net_value_start") * F("fx_rate_start"), output_field=DecimalField()),
+                net_value_end=InstrumentPrice.subquery_closest_value(
+                    "net_value",
+                    date_name="net_value_date_end",
+                    instrument_pk_name="pk",
+                    date_lookup="exact"
+                    # we get all net value (even estimated) to avoir showing None price on holiday
+                ),
+                fx_rate_end=CurrencyFXRates.get_fx_rates_subquery(
+                    "net_value_date_end", currency="currency", lookup_expr="exact"
+                ),
+                price_end=ExpressionWrapper(F("net_value_end") * F("fx_rate_end"), output_field=DecimalField()),
+            ).values("price_start", "price_end", "id"),
+            columns=["price_start", "price_end", "id"],
+        ).rename(columns={"id": "product__id"})
+
+        df = df.merge(df_product, on="product__id")
+
+        df = df.rename(columns={self.pivot: "id", self.pivot_label: "title"})
+        df.loc[df["id"].isnull(), "id"] = -1
+        df.loc[df["id"] == -1, "title"] = "N/A"
+        df = df.dropna(subset=["id"])
+        df[df.columns.difference(["title", "id", "date", "product__id", "internal_trade"])] = df[
+            df.columns.difference(["title", "id", "date", "product__id", "internal_trade"])
+        ].astype("float")
+        return df[df["date"] < self.end_date]
+
+    def get_aum_df(self) -> pd.DataFrame:
+        df = self.df.copy().drop(columns=["internal_trade"])
+        df.loc[df.date <= self.start_date, "sum_shares_start"] = df.shares
+        df.loc[df.date <= self.end_date, "sum_shares_end"] = df.shares
+        df = df.fillna(0)
+        # Prepare dataframe
+        df["sum_aum_start"] = df.sum_shares_start * df.price_start
+        df["sum_aum_end"] = df.sum_shares_end * df.price_end
+
+        # Sanitize dataframe
+        df = df.drop(
+            columns=df.columns.difference(["id", "sum_shares_start", "sum_shares_end", "sum_aum_start", "sum_aum_end"])
+        )
+        df = df.groupby("id").agg(
+            {
+                "sum_shares_start": "sum",
+                "sum_shares_end": "sum",
+                "sum_aum_start": "sum",
+                "sum_aum_end": "sum",
+            }
+        )
+        df = df.round()
+        # Compute statistics
+        df["sum_shares_diff"] = df.sum_shares_end - df.sum_shares_start
+        df["sum_shares_perf"] = df.sum_shares_end / df.sum_shares_start - 1
+        df["sum_aum_diff"] = df.sum_aum_end - df.sum_aum_start
+        df["sum_aum_perf"] = df.sum_aum_end / df.sum_aum_start - 1
+        return df
+
+    def get_nnm_df(
+        self, only_positive: bool = False, only_negative: bool = False, filter_internal_trade: bool = True
+    ) -> pd.DataFrame:
+        df = self.df.copy()
+        if filter_internal_trade:
+            df = df[~df["internal_trade"]].drop(columns=["internal_trade"])
+        if only_positive:
+            df.loc[df["aum"] < 0, "aum"] = 0
+        elif only_negative:
+            df.loc[df["aum"] > 0, "aum"] = 0
+        df = df[(df["date"] < self.end_date) & (df["date"] >= self.start_date)]
+        df["date"] = pd.to_datetime(df["date"])
+        df["period"] = "sum_nnm_" + df.date.dt.year.astype(str) + "-" + df.date.dt.month.map("{:02}".format)
+        df = df[["id", "period", "aum"]].groupby(["id", "period"]).sum().reset_index()
+        df = pd.pivot_table(df, values="aum", index="id", columns=["period"])
+        df["sum_nnm_total"] = df.sum(axis=1)
+        df = df.round().fillna(0).reindex(self.df["id"].unique(), fill_value=0)
+        return df
+
+    def get_aum_sparkline(self) -> pd.DataFrame:
+        df = self.df[self.df["date"] >= self.start_date].copy()
+        df["aum_sparkline"] = None
+        if not df.empty:
+            df["aum_sparkline"] = df["aum"]
+            df = df[["product__id", "id", "date", "aum_sparkline"]].groupby(["product__id", "id", "date"]).sum()
+            df = df.reindex(
+                pd.MultiIndex.from_product(
+                    [
+                        df.index.levels[0],
+                        df.index.levels[1],
+                        pd.date_range(df.index.levels[2].min(), df.index.levels[2].max()),
+                    ],  # we downsample to make the chart easier on the frontend
+                    names=["product__id", "id", "date"],
+                ),
+                fill_value=0,
+            )
+            df["aum_sparkline"] = df.groupby(level=["product__id", "id"])["aum_sparkline"].cumsum()
+            df = df.groupby(level=[1, 2]).sum()
+            df = df.reindex(
+                pd.MultiIndex.from_product(
+                    [
+                        df.index.levels[0],
+                        pd.date_range(df.index.levels[1].min(), df.index.levels[1].max(), freq="W-MON"),
+                    ],  # we downsample to make the chart easier on the frontend
+                    names=["id", "date"],
+                ),
+                fill_value=0,
+            )
+            return df.reset_index().dropna()[["id", "aum_sparkline"]].groupby("id").agg(list)
+        return pd.DataFrame()
+
+    def get_initial_investment_date_df(self) -> pd.DataFrame:
+        return (
+            self.df[["date", "id"]]
+            .sort_values(by="date")
+            .groupby("id")
+            .first()
+            .rename(columns={"date": "initial_investment_date"})
+        )

wbportfolio/apps.py

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

wbportfolio/contrib/company_portfolio/admin.py

@@ -0,0 +1,28 @@
+from django.contrib import admin
+
+from .models import (
+    AssetAllocation,
+    AssetAllocationType,
+    CompanyPortfolioData,
+    GeographicFocus,
+)
+
+
+@admin.register(CompanyPortfolioData)
+class CompanyPortfolioDataModelAdmin(admin.ModelAdmin):
+    pass
+
+
+@admin.register(AssetAllocationType)
+class AssetAllocationTypeModelAdmin(admin.ModelAdmin):
+    pass
+
+
+@admin.register(AssetAllocation)
+class AssetAllocationModelAdmin(admin.ModelAdmin):
+    pass
+
+
+@admin.register(GeographicFocus)
+class GeographicFocusModelAdmin(admin.ModelAdmin):
+    pass

wbportfolio/contrib/company_portfolio/apps.py

@@ -0,0 +1,29 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+from wbcore.contrib.directory.configurations import configuration_registry
+
+
+class WbportfolioDirectoryConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wbportfolio.contrib.company_portfolio"
+
+    def ready(self) -> None:
+        from .management import initialize_task
+
+        post_migrate.connect(
+            initialize_task,
+            dispatch_uid="wbportfolio.contrib.company_portfolio.tasks.initialize_task",
+        )
+
+        configuration_registry.DEFAULT_COMPANY_MODEL_VIEWSET = (
+            "wbportfolio.contrib.company_portfolio.viewsets.CompanyModelViewSet"
+        )
+        configuration_registry.DEFAULT_COMPANY_MODEL_SERIALIZER = (
+            "wbportfolio.contrib.company_portfolio.serializers.CompanyModelSerializer"
+        )
+        configuration_registry.DEFAULT_PERSON_MODEL_VIEWSET = (
+            "wbportfolio.contrib.company_portfolio.viewsets.PersonModelViewSet"
+        )
+        configuration_registry.DEFAULT_PERSON_MODEL_SERIALIZER = (
+            "wbportfolio.contrib.company_portfolio.serializers.PersonModelSerializer"
+        )

wbportfolio/contrib/company_portfolio/configs/__init__.py

@@ -0,0 +1,3 @@
+from .display import *
+from .endpoints import *
+from .previews import *

wbportfolio/contrib/company_portfolio/configs/display.py

@@ -0,0 +1,182 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.directory.viewsets.display.entries import CompanyModelDisplay as CMD
+from wbcore.contrib.directory.viewsets.display.entries import PersonModelDisplay as PMD
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display import (
+    Inline,
+    Layout,
+    Page,
+    Section,
+    Style,
+)
+from wbcore.metadata.configs.display.instance_display.operators import default
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+AUM_TABLE = Section(
+    key="aum_table_section",
+    collapsible=False,
+    title=_("AUM By Product"),
+    display=Display(
+        pages=[
+            Page(
+                title=_("AUM By Product"),
+                layouts={
+                    default(): Layout(
+                        grid_template_areas=[["aum_table"]],
+                        inlines=[Inline(key="aum_table", endpoint="wbportfolio_aum")],
+                    )
+                },
+            ),
+        ]
+    ),
+)
+
+AUM_FIELDS = Section(
+    key="aum_fields_section",
+    collapsible=False,
+    title=_("AUM"),
+    display=Display(
+        pages=[
+            Page(
+                title=_("AUM"),
+                layouts={
+                    default(): Layout(
+                        grid_template_areas=[
+                            ["asset_under_management", "assets_under_management_currency", "investment_discretion"],
+                            ["invested_assets_under_management_usd", "potential", "."],
+                        ],
+                        grid_auto_columns="minmax(min-content, 1fr)",
+                        grid_auto_rows=Style.MIN_CONTENT,
+                    )
+                },
+            ),
+        ]
+    ),
+)
+
+
+class CompanyModelDisplay(CMD):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        list_display = super().get_list_display()
+        list_display.fields = (
+            *list_display.fields[:5],
+            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
+            dp.Field(key="asset_under_management", label="AUM"),
+            dp.Field(key="potential", label="Potential"),
+            *list_display.fields[5:],
+        )
+        return list_display
+
+    AUM_TABLE = AUM_TABLE
+    PORTFOLIO_FIELDS = AUM_FIELDS
+
+    def get_instance_display(self) -> Display:
+        asset_allocation_section = Section(
+            key="asset_allocation_section",
+            collapsible=False,
+            title=_("Asset Allocation"),
+            display=Display(
+                pages=[
+                    Page(
+                        title=_("Asset Allocation"),
+                        layouts={
+                            default(): Layout(
+                                grid_template_areas=[["asset_allocation"]],
+                                inlines=[Inline(key="asset_allocation", endpoint="asset_allocation_table")],
+                            )
+                        },
+                    ),
+                ]
+            ),
+        )
+
+        geographic_focus_section = Section(
+            key="geographic_focus_section",
+            collapsible=False,
+            title=_("Geographic Focus"),
+            display=Display(
+                pages=[
+                    Page(
+                        title=_("Geographic Focus"),
+                        layouts={
+                            default(): Layout(
+                                grid_template_areas=[["geographic_focus"]],
+                                inlines=[Inline(key="geographic_focus", endpoint="geographic_focus_table")],
+                            )
+                        },
+                    ),
+                ]
+            ),
+        )
+
+        instance_display = super().get_instance_display()
+        if "pk" in self.view.kwargs:
+            instance_display.pages.insert(
+                1,
+                Page(
+                    title=_("Customer Information"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[["asset_allocation_section", "geographic_focus_section"]],
+                            sections=[asset_allocation_section, geographic_focus_section],
+                        )
+                    },
+                ),
+            )
+
+        return instance_display
+
+
+class PersonModelDisplay(PMD):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        list_display = super().get_list_display()
+
+        list_display.fields = (
+            *list_display.fields[:7],
+            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
+            dp.Field(key="asset_under_management", label="AUM"),
+            dp.Field(key="potential", label="Potential"),
+            *list_display.fields[7:],
+        )
+        return list_display
+
+    AUM_TABLE = AUM_TABLE
+    PORTFOLIO_FIELDS = AUM_FIELDS
+
+
+class AssetAllocationDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="percent", label="Percent"),
+                dp.Field(key="asset_type", label="Type"),
+                dp.Field(key="max_investment", label="Max Investment"),
+                dp.Field(key="comment", label="Comment"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["company", "percent", "asset_type", "max_investment"], [repeat_field(4, "comment")]]
+        )
+
+
+class GeographicFocusDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="percent", label="Percent"),
+                dp.Field(key="country", label="Location"),
+                dp.Field(key="comment", label="Comment"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["company", "percent", "country"], [repeat_field(3, "comment")]])

wbportfolio/contrib/company_portfolio/configs/endpoints.py

@@ -0,0 +1,34 @@
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class AssetAllocationModelEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        if company_id := self.view.kwargs.get("company_id", None):
+            return reverse(
+                "company_portfolio:companyassetallocation-list",
+                kwargs={"company_id": company_id},
+                request=self.request,
+            )
+        return reverse("company_portfolio:assetallocation-list", request=self.request)
+
+    def get_create_endpoint(self, **kwargs):
+        if company_id := self.view.kwargs.get("company_id", None):
+            return f"{reverse('company_portfolio:companyassetallocation-list', kwargs={'company_id': company_id}, request=self.request)}?company={company_id}"
+        return super().get_create_endpoint(**kwargs)
+
+
+class GeographicFocusModelEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        if company_id := self.view.kwargs.get("company_id", None):
+            return reverse(
+                "company_portfolio:companygeographicfocus-list",
+                kwargs={"company_id": company_id},
+                request=self.request,
+            )
+        return reverse("company_portfolio:geographicfocus-list", request=self.request)
+
+    def get_create_endpoint(self, **kwargs):
+        if company_id := self.view.kwargs.get("company_id", None):
+            return f"{reverse('company_portfolio:companygeographicfocus-list', kwargs={'company_id': company_id}, request=self.request)}?company={company_id}"
+        return super().get_create_endpoint(**kwargs)

wbportfolio/contrib/company_portfolio/configs/previews.py

@@ -0,0 +1,37 @@
+from wbcore.contrib.directory.viewsets.previews import EntryPreviewConfig
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+
+
+class CompanyPreviewConfig(EntryPreviewConfig):
+    def get_display(self) -> Display:
+        fields = [
+            [repeat_field(2, "computed_str")],
+            ["primary_telephone", "primary_email"],
+            [repeat_field(2, "primary_manager")],
+            ["asset_under_management", "invested_assets_under_management_usd"],
+            [repeat_field(2, "potential")],
+        ]
+        try:
+            entry = self.view.get_object()
+            if entry.profile_image:
+                fields.insert(0, [repeat_field(2, "profile_image")])
+        except Exception:
+            pass
+
+        return create_simple_display(fields)
+
+    def get_buttons(self):
+        buttons = super().get_buttons()
+        buttons.append(
+            bt.WidgetButton(key="asset_allocation_table", icon=WBIcon.DATA_LIST.icon, label="Asset Allocation"),
+        )
+        buttons.append(
+            bt.WidgetButton(key="geographic_focus_table", icon=WBIcon.DATA_LIST.icon, label="Geographic Focus"),
+        )
+        return buttons

wbportfolio/contrib/company_portfolio/constants.py

@@ -0,0 +1 @@
+DEFAULT_PORTFOLIO_DATA_UPDATE_TASK_INTERVAL_MINUTES: int = 60