wbportfolio 1.54.21__py2.py3-none-any.whl → 1.54.23__py2.py3-none-any.whl

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 from unittest.mock import call, patch
 
 import pytest
+from django.db.models import Sum
 from faker import Faker
 from pandas._libs.tslibs.offsets import BDay, BusinessMonthEnd
 
@@ -50,31 +51,36 @@ class TestOrderProposal:
         )
 
         # Create orders for testing
-        t1 = order_factory.create(
+        o1 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("0.05"),
             portfolio=order_proposal.portfolio,
             underlying_instrument=a1.underlying_quote,
         )
-        t2 = order_factory.create(
+        o2 = order_factory.create(
             order_proposal=order_proposal,
             weighting=Decimal("-0.05"),
             portfolio=order_proposal.portfolio,
             underlying_instrument=a2.underlying_quote,
         )
 
+        r1 = o1.price / a1.initial_price - Decimal("1")
+        r2 = o2.price / a2.initial_price - Decimal("1")
+        p_return = a1.weighting * (Decimal("1") + r1) + a2.weighting * (Decimal("1") + r2)
         # Get the validated trading service
-        validated_trading_service = order_proposal.validated_trading_service
+        trades = order_proposal.validated_trading_service.trades_batch.trades_map
+        t1 = trades[a1.underlying_quote.id]
+        t2 = trades[a2.underlying_quote.id]
 
         # Assert effective and target portfolios are as expected
-        assert validated_trading_service._effective_portfolio.to_dict() == {
-            a1.underlying_quote.id: a1.weighting,
-            a2.underlying_quote.id: a2.weighting,
-        }
-        assert validated_trading_service._target_portfolio.to_dict() == {
-            a1.underlying_quote.id: a1.weighting + t1.weighting,
-            a2.underlying_quote.id: a2.weighting + t2.weighting,
-        }
+        assert t1.previous_weight == a1.weighting
+        assert t2.previous_weight == a2.weighting
+        assert t1.target_weight == pytest.approx(
+            a1.weighting * ((r1 + Decimal("1")) / p_return) + o1.weighting, abs=Decimal("1e-8")
+        )
+        assert t2.target_weight == pytest.approx(
+            a2.weighting * ((r2 + Decimal("1")) / p_return) + o2.weighting, abs=Decimal("1e-8")
+        )
 
     # Test the calculation of the last effective date
     def test_last_effective_date(self, order_proposal, asset_position_factory):
@@ -361,15 +367,12 @@ class TestOrderProposal:
         assert order_proposal.orders.get(underlying_instrument=i2).weighting == Decimal("-0.3")
         assert order_proposal.orders.get(underlying_instrument=cash).weighting == Decimal("0.5")
 
-    def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory, instrument_price_factory):
+    def test_reset_orders_remove_invalid_orders(self, order_proposal, order_factory):
         # create a invalid trade and its price
         invalid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(0))
-        instrument_price_factory.create(date=invalid_trade.value_date, instrument=invalid_trade.underlying_instrument)
 
         # create a valid trade and its price
         valid_trade = order_factory.create(order_proposal=order_proposal, weighting=Decimal(1))
-        instrument_price_factory.create(date=valid_trade.value_date, instrument=valid_trade.underlying_instrument)
-
         order_proposal.reset_orders()
         assert order_proposal.orders.get(underlying_instrument=valid_trade.underlying_instrument).weighting == Decimal(
             "1"
@@ -687,3 +690,46 @@ class TestOrderProposal:
         order.save()
         assert order.shares == Decimal(0)
         assert order.weighting == Decimal(0)
+
+    def test_reset_order_use_desired_target_weight(self, order_proposal, order_factory):
+        order1 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.7")
+        )
+        order2 = order_factory.create(
+            order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.3")
+        )
+        order_proposal.submit()
+        order_proposal.approve()
+        order_proposal.save()
+
+        order1.refresh_from_db()
+        order2.refresh_from_db()
+        assert order1.desired_target_weight == Decimal("0.5")
+        assert order2.desired_target_weight == Decimal("0.5")
+        assert order1.weighting == Decimal("0.5")
+        assert order2.weighting == Decimal("0.5")
+
+        order1.desired_target_weight = Decimal("0.7")
+        order2.desired_target_weight = Decimal("0.3")
+        order1.save()
+        order2.save()
+
+        order_proposal.reset_orders(use_desired_target_weight=True)
+        order1.refresh_from_db()
+        order2.refresh_from_db()
+        assert order1.weighting == Decimal("0.7")
+        assert order2.weighting == Decimal("0.3")
+
+    def test_reset_order_proposal_keeps_target_cash_weight(self, order_factory, order_proposal_factory):
+        order_proposal = order_proposal_factory.create(
+            total_cash_weight=Decimal("0.02")
+        )  # create a OP with total cash weight of 2%
+
+        # create orders that total weight account for only 50%
+        order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.3"))
+        order_factory.create(order_proposal=order_proposal, weighting=Decimal("0.2"))
+
+        order_proposal.reset_orders()
+        assert order_proposal.get_orders().aggregate(s=Sum("target_weight"))["s"] == Decimal(
+            "0.98"
+        ), "The total target weight leftover does not equal the stored total cash weight"

wbportfolio/tests/models/test_products.py

@@ -215,3 +215,14 @@ class TestProductModel(PortfolioTestMixin):
             body=f"The product {product} will be terminated on the {product.delisted_date:%Y-%m-%d}",
             user=internal_user,
         )
+
+    def test_delist_product_disable_report(self, product, report_factory):
+        report = report_factory.create(content_object=product, is_active=True)
+        assert product.delisted_date is None
+        assert report.is_active
+
+        product.delisted_date = datetime.date.today()
+        product.save()
+
+        report.refresh_from_db()
+        assert report.is_active is False

wbportfolio/tests/signals.py

@@ -17,8 +17,6 @@ from wbportfolio.viewsets import (
     ClaimEntryModelViewSet,
     CustodianDistributionInstrumentChartViewSet,
     CustomerDistributionInstrumentChartViewSet,
-    DistributionChartViewSet,
-    DistributionTableViewSet,
     NominalProductChartView,
     OrderOrderProposalModelViewSet,
     OrderProposalPortfolioModelViewSet,
@@ -96,14 +94,6 @@ def receive_kwargs_portfolio_role_instrument(sender, *args, **kwargs):
     return {}
 
 
-@receiver(custom_update_kwargs, sender=DistributionChartViewSet)
-@receiver(custom_update_kwargs, sender=DistributionTableViewSet)
-def receive_kwargs_distribution_chart_instrument_id(sender, *args, **kwargs):
-    if instrument_id := kwargs.get("underlying_instrument_id"):
-        return {"instrument_id": instrument_id}
-    return {}
-
-
 @receiver(custom_update_kwargs, sender=ProductPerformanceFeesModelViewSet)
 def receive_kwargs_product_performance_fees(sender, *args, **kwargs):
     CurrencyFXRatesFactory()

wbportfolio/tests/tests.py

@@ -19,6 +19,8 @@ for key, value in default_config.items():
                 "AccountReconciliationLine",
                 "TopDownPortfolioCompositionPandasAPIView",
                 "CompositionModelPortfolioPandasView",
+                "DistributionChartViewSet",
+                "DistributionTableViewSet",
                 # "ClaimModelViewSet",
                 # "ClaimModelSerializer",
             ],

wbportfolio/viewsets/__init__.py

@@ -2,12 +2,16 @@ from .assets import (
     AssetPositionInstrumentModelViewSet,
     AssetPositionModelViewSet,
     AssetPositionPortfolioModelViewSet,
-    AssetPositionUnderlyingInstrumentChartViewSet,
     CashPositionPortfolioPandasAPIView,
     CompositionModelPortfolioPandasView,
-    ContributorPortfolioChartView,
 )
-from .charts import *
+from .charts import (
+    DistributionChartViewSet,
+    DistributionTableViewSet,
+    AssetPositionUnderlyingInstrumentChartViewSet,
+    ContributorPortfolioChartView
+
+)
 from .custodians import CustodianModelViewSet, CustodianRepresentationViewSet
 from .portfolio_relationship import InstrumentPreferedClassificationThroughProductModelViewSet
 from .portfolios import (
@@ -23,7 +27,6 @@ from .positions import (
 )
 from .registers import RegisterModelViewSet, RegisterRepresentationViewSet
 from .roles import PortfolioRoleInstrumentModelViewSet, PortfolioRoleModelViewSet
-from .signals import *
 from .rebalancing import RebalancingModelRepresentationViewSet, RebalancerRepresentationViewSet, RebalancerModelViewSet
 from .transactions import *
 from .orders import *

wbportfolio/viewsets/assets.py

@@ -2,23 +2,15 @@ from contextlib import suppress
 from datetime import date, datetime
 
 import pandas as pd
-import plotly.graph_objects as go
 from django.db.models import Exists, F, OuterRef, Q, Sum
 from django.utils.dateparse import parse_date
 from django.utils.functional import cached_property
-from plotly.subplots import make_subplots
 from wbcore import viewsets
-from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
-from wbcore.filters import DjangoFilterBackend
 from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.serializers import decorator
-from wbcore.utils.date import get_date_interval_from_request
-from wbcore.utils.figures import (
-    get_default_timeserie_figure,
-    get_hovertemplate_timeserie,
-)
 from wbcore.utils.strings import format_number
 from wbfdm.contrib.metric.viewsets.mixins import InstrumentMetricMixin
 from wbfdm.models import Instrument
@@ -27,11 +19,8 @@ from wbportfolio.filters import (
     AssetPositionFilter,
     AssetPositionInstrumentFilter,
     AssetPositionPortfolioFilter,
-    AssetPositionUnderlyingInstrumentChartFilter,
     CashPositionPortfolioFilterSet,
-    CompositionContributionChartFilter,
     CompositionModelPortfolioPandasFilter,
-    ContributionChartFilter,
 )
 from wbportfolio.import_export.resources.assets import AssetPositionResource
 from wbportfolio.metric.backends.portfolio_base import (
@@ -69,16 +58,12 @@ from .configs import (
     AssetPositionPortfolioEndpointConfig,
     AssetPositionPortfolioTitleConfig,
     AssetPositionTitleConfig,
-    AssetPositionUnderlyingInstrumentChartEndpointConfig,
-    AssetPositionUnderlyingInstrumentChartTitleConfig,
     CashPositionPortfolioDisplayConfig,
     CashPositionPortfolioEndpointConfig,
     CashPositionPortfolioTitleConfig,
     CompositionModelPortfolioPandasDisplayConfig,
     CompositionModelPortfolioPandasEndpointConfig,
     CompositionModelPortfolioPandasTitleConfig,
-    ContributorPortfolioChartEndpointConfig,
-    ContributorPortfolioChartTitleConfig,
 )
 from .mixins import UserPortfolioRequestPermissionMixin
 
@@ -344,205 +329,6 @@ class CashPositionPortfolioPandasAPIView(
         return AssetPosition.objects.none()
 
 
-# ##### CHART VIEWS #####
-
-
-class ContributorPortfolioChartView(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
-    filterset_class = ContributionChartFilter
-    filter_backends = (DjangoFilterBackend,)
-    IDENTIFIER = "wbportfolio:portfolio-contributor"
-    queryset = AssetPosition.objects.all()
-
-    title_config_class = ContributorPortfolioChartTitleConfig
-    endpoint_config_class = ContributorPortfolioChartEndpointConfig
-
-    ROW_HEIGHT: int = 20
-
-    @property
-    def min_height(self):
-        if hasattr(self, "nb_rows"):
-            return self.nb_rows * self.ROW_HEIGHT
-        return "300px"
-
-    @cached_property
-    def hedged_currency(self) -> Currency | None:
-        if "hedged_currency" in self.request.GET:
-            with suppress(Currency.DoesNotExist):
-                return Currency.objects.get(pk=self.request.GET["hedged_currency"])
-
-    @cached_property
-    def show_lookthrough(self) -> bool:
-        return self.portfolio.is_composition and self.request.GET.get("show_lookthrough", "false").lower() == "true"
-
-    def get_filterset_class(self, request):
-        if self.portfolio.is_composition:
-            return CompositionContributionChartFilter
-        return ContributionChartFilter
-
-    def get_plotly(self, queryset):
-        fig = go.Figure()
-        data = []
-        if self.show_lookthrough:
-            d1, d2 = get_date_interval_from_request(self.request)
-            for _d in pd.date_range(d1, d2):
-                for pos in self.portfolio.get_lookthrough_positions(_d.date()):
-                    data.append(
-                        [
-                            pos.date,
-                            pos.initial_price,
-                            pos.initial_currency_fx_rate,
-                            pos.underlying_instrument_id,
-                            pos.weighting,
-                        ]
-                    )
-        else:
-            data = queryset.annotate_hedged_currency_fx_rate(self.hedged_currency).values_list(
-                "date", "price", "hedged_currency_fx_rate", "underlying_instrument", "weighting"
-            )
-        df = Portfolio.get_contribution_df(data).rename(columns={"group_key": "underlying_instrument"})
-        if not df.empty:
-            df = df[["contribution_total", "contribution_forex", "underlying_instrument"]].sort_values(
-                by="contribution_total", ascending=True
-            )
-
-            df["instrument_id"] = df.underlying_instrument.map(
-                dict(Instrument.objects.filter(id__in=df["underlying_instrument"]).values_list("id", "name_repr"))
-            )
-            df_forex = df[["instrument_id", "contribution_forex"]]
-            df_forex = df_forex[df_forex.contribution_forex != 0]
-
-            contribution_equity = df.contribution_total - df.contribution_forex
-
-            text_forex = df_forex.contribution_forex.apply(lambda x: f"{x:,.2%}")
-            text_equity = contribution_equity.apply(lambda x: f"{x:,.2%}")
-            setattr(self, "nb_rows", df.shape[0])
-            fig.add_trace(
-                go.Bar(
-                    y=df.instrument_id,
-                    x=contribution_equity,
-                    name="Contribution Equity",
-                    orientation="h",
-                    marker=dict(
-                        color="rgba(247,110,91,0.6)",
-                        line=dict(color="rgb(247,110,91,1.0)", width=2),
-                    ),
-                    text=text_equity.values,
-                    textposition="auto",
-                )
-            )
-            fig.add_trace(
-                go.Bar(
-                    y=df_forex.instrument_id,
-                    x=df_forex.contribution_forex,
-                    name="Contribution Forex",
-                    orientation="h",
-                    marker=dict(
-                        color="rgba(58, 71, 80, 0.6)",
-                        line=dict(color="rgba(58, 71, 80, 1.0)", width=2),
-                    ),
-                    text=text_forex.values,
-                    textposition="outside",
-                )
-            )
-            fig.update_layout(
-                barmode="relative",
-                xaxis=dict(showgrid=False, showline=False, zeroline=False, tickformat=".2%"),
-                yaxis=dict(showgrid=False, showline=False, zeroline=False, tickmode="linear"),
-                margin=dict(b=0, r=20, l=20, t=0, pad=20),
-                paper_bgcolor="rgba(0,0,0,0)",
-                plot_bgcolor="rgba(0,0,0,0)",
-                font=dict(family="roboto", size=12, color="black"),
-                bargap=0.3,
-            )
-            # fig = get_horizontal_barplot(df, x_label="contribution_total", y_label="name")
-        return fig
-
-    def parse_figure_dict(self, figure_dict: dict[str, any]) -> dict[str, any]:
-        figure_dict = super().parse_figure_dict(figure_dict)
-        figure_dict["style"]["minHeight"] = self.min_height
-        return figure_dict
-
-    def get_queryset(self):
-        if self.has_portfolio_access:
-            return super().get_queryset().filter(portfolio=self.portfolio)
-        return AssetPosition.objects.none()
-
-
-class AssetPositionUnderlyingInstrumentChartViewSet(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
-    IDENTIFIER = "wbportfolio:assetpositionchart"
-
-    queryset = AssetPosition.objects.all()
-
-    title_config_class = AssetPositionUnderlyingInstrumentChartTitleConfig
-    endpoint_config_class = AssetPositionUnderlyingInstrumentChartEndpointConfig
-    filterset_class = AssetPositionUnderlyingInstrumentChartFilter
-
-    def get_queryset(self):
-        return AssetPosition.objects.filter(underlying_quote__in=self.instrument.get_descendants(include_self=True))
-
-    def get_plotly(self, queryset):
-        fig = make_subplots(specs=[[{"secondary_y": True}]])
-        fig = get_default_timeserie_figure(fig)
-        if queryset.exists():
-            df_weight = pd.DataFrame(queryset.values("date", "weighting", "portfolio__name"))
-            df_weight = df_weight.where(pd.notnull(df_weight), 0)
-            df_weight = df_weight.groupby(["date", "portfolio__name"]).sum().reset_index()
-            min_date = df_weight["date"].min()
-            max_date = df_weight["date"].max()
-
-            df_price = (
-                pd.DataFrame(
-                    self.instrument.prices.filter_only_valid_prices()
-                    .annotate_base_data()
-                    .filter(date__gte=min_date, date__lte=max_date)
-                    .values_list("date", "net_value_usd"),
-                    columns=["date", "price_fx_usd"],
-                )
-                .set_index("date")
-                .sort_index()
-            )
-
-            fig.add_trace(
-                go.Scatter(
-                    x=df_price.index, y=df_price.price_fx_usd, mode="lines", marker_color="green", name="Price"
-                ),
-                secondary_y=False,
-            )
-
-            df_weight = pd.DataFrame(queryset.values("date", "weighting", "portfolio__name"))
-            df_weight = df_weight.where(pd.notnull(df_weight), 0)
-            df_weight = df_weight.groupby(["date", "portfolio__name"]).sum().reset_index()
-            for portfolio_name, df_tmp in df_weight.groupby("portfolio__name"):
-                fig.add_trace(
-                    go.Scatter(
-                        x=df_tmp.date,
-                        y=df_tmp.weighting,
-                        hovertemplate=get_hovertemplate_timeserie(is_percent=True),
-                        mode="lines",
-                        name=f"Allocation: {portfolio_name}",
-                    ),
-                    secondary_y=True,
-                )
-
-            # Set x-axis title
-            fig.update_xaxes(title_text="Date")
-            # Set y-axes titles
-            fig.update_yaxes(
-                title_text="<b>Price</b>",
-                secondary_y=False,
-                titlefont=dict(color="green"),
-                tickfont=dict(color="green"),
-            )
-            fig.update_yaxes(
-                title_text="<b>Portfolio Allocation (%)</b>",
-                secondary_y=True,
-                titlefont=dict(color="blue"),
-                tickfont=dict(color="blue"),
-            )
-
-        return fig
-
-
 class CompositionModelPortfolioPandasView(
     UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, ExportPandasAPIViewSet
 ):

wbportfolio/viewsets/charts/__init__.py

@@ -1 +1,6 @@
-from .assets import DistributionChartViewSet, DistributionTableViewSet
+from .assets import (
+    DistributionChartViewSet,
+    DistributionTableViewSet,
+    AssetPositionUnderlyingInstrumentChartViewSet,
+    ContributorPortfolioChartView
+)