wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/viewsets/custodians.py

@@ -0,0 +1,66 @@
+from django.shortcuts import get_object_or_404
+from rest_framework import filters
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbportfolio.filters import CustodianFilterSet
+from wbportfolio.models import Custodian
+from wbportfolio.serializers import (
+    CustodianModelSerializer,
+    CustodianRepresentationSerializer,
+)
+
+from .configs import (
+    CustodianButtonConfig,
+    CustodianDisplayConfig,
+    CustodianEndpointConfig,
+    CustodianTitleConfig,
+)
+
+
+class CustodianRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbportfolio:custodian"
+
+    filter_backends = (
+        filters.SearchFilter,
+        filters.OrderingFilter,
+    )
+
+    queryset = Custodian.objects.all()
+    serializer_class = CustodianRepresentationSerializer
+
+    search_fields = ("name",)
+    ordering_fields = search_fields
+    ordering = ["name"]
+
+
+class CustodianModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    queryset = Custodian.objects.all()
+    filterset_class = CustodianFilterSet
+    serializer_class = CustodianModelSerializer
+
+    search_fields = ("name", "mapping")
+    ordering_fields = search_fields
+    ordering = ["name"]
+
+    display_config_class = CustodianDisplayConfig
+    button_config_class = CustodianButtonConfig
+    title_config_class = CustodianTitleConfig
+    endpoint_config_class = CustodianEndpointConfig
+
+    @action(detail=True, methods=["PATCH"])
+    def merge(self, request, pk=None):
+        if (merged_custodian_id := request.POST.get("merged_custodian", None)) and merged_custodian_id != pk:
+            merged_custodian = get_object_or_404(Custodian, pk=merged_custodian_id)
+            base_custodian = get_object_or_404(Custodian, pk=pk)
+            base_custodian.merge(merged_custodian)
+            return Response({"send": True})
+        return Response({"send": True})
+
+    @action(detail=True, methods=["PATCH"])
+    def split(self, request, pk=None):
+        if mapping_choice := request.POST.get("mapping_choice", None):
+            custodian = get_object_or_404(Custodian, pk=pk)
+            custodian.split_off(mapping_choice)
+        return Response({"send": True})

wbportfolio/viewsets/esg.py

@@ -0,0 +1,165 @@
+from contextlib import suppress
+from datetime import date, datetime
+
+import pandas as pd
+from django.contrib.messages import warning
+from django.db.models import Q
+from django.utils.functional import cached_property
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.utils.strings import format_number
+from wbfdm.analysis.esg.enums import AggregationMethod, ESGAggregation
+from wbfdm.analysis.esg.esg_analysis import DataLoader
+from wbfdm.models import Instrument
+from wbportfolio.filters import ESGMetricAggregationPortfolioPandasFilterSet
+from wbportfolio.models import AssetPosition
+from wbportfolio.viewsets.configs import (
+    ESGMetricAggregationPortfolioPandasDisplayConfig,
+    ESGMetricAggregationPortfolioPandasEndpointConfig,
+    ESGMetricAggregationPortfolioPandasTitleConfig,
+)
+
+from .mixins import UserPortfolioRequestPermissionMixin
+
+
+class ESGMetricAggregationPortfolioPandasViewSet(UserPortfolioRequestPermissionMixin, ExportPandasAPIViewSet):
+    IDENTIFIER = "wbportfolio:esgmetricportfolio"
+    filterset_class = ESGMetricAggregationPortfolioPandasFilterSet
+    queryset = AssetPosition.objects.all()
+
+    display_config_class = ESGMetricAggregationPortfolioPandasDisplayConfig
+    title_config_class = ESGMetricAggregationPortfolioPandasTitleConfig
+    endpoint_config_class = ESGMetricAggregationPortfolioPandasEndpointConfig
+
+    search_fields = ["underlying_instrument_repr"]
+
+    @cached_property
+    def val_date(self) -> date:
+        if validity_date_repr := self.request.GET.get("date"):
+            val_date = datetime.strptime(validity_date_repr, "%Y-%m-%d")
+        else:
+            val_date = date.today()
+
+        qs = AssetPosition.objects.filter(portfolio=self.portfolio, date__lte=val_date)
+        if qs.exists():
+            return qs.latest("date").date
+        else:
+            warning(
+                self.request,
+                f"No position were found before the {val_date:%Y-%m-%d}. Please select another date",
+            )
+            return val_date
+
+    @cached_property
+    def base_df(self) -> pd.DataFrame:
+        if self.action != "metadata":
+            with suppress(KeyError):
+                df = (
+                    pd.DataFrame(
+                        AssetPosition.objects.filter(portfolio=self.portfolio, date=self.val_date)
+                        .exclude(
+                            Q(underlying_instrument__is_cash=True) | Q(underlying_instrument__is_cash_equivalent=True)
+                        )
+                        .values("underlying_instrument", "weighting", "total_value_fx_usd")
+                    )
+                    .groupby("underlying_instrument")
+                    .sum()
+                    .astype(float)
+                )
+                df["weighting"] = df["weighting"] / df["weighting"].sum()
+                return df
+        return pd.DataFrame(columns=["weighting", "total_value_fx_usd"])
+
+    @cached_property
+    def esg_aggregation(self) -> ESGAggregation | None:
+        return ESGAggregation[self.request.GET.get("esg_aggregation", ESGAggregation.GHG_EMISSIONS_SCOPE_1.name)]
+
+    @cached_property
+    def esg_data(self) -> pd.Series:
+        if self.action != "metadata":
+            return self.esg_aggregation.get_esg_data(Instrument.objects.filter(id__in=self.base_df.index))
+        return pd.Series(dtype="float64")
+
+    @cached_property
+    def dataloader(self) -> DataLoader:
+        dataloader = DataLoader(
+            self.base_df["weighting"],
+            self.esg_data,
+            self.val_date,
+            total_value_fx_usd=self.base_df["total_value_fx_usd"],
+        )
+        self.metric = dataloader.compute(self.esg_aggregation).rename("metric")
+        return dataloader
+
+    @cached_property
+    def metric_columns(self) -> list[str]:
+        return (
+            ["weighting", "total_value_fx_usd", "esg_data", "weights_in_coverage", "metric"]
+            + list(map(lambda x: x.series.name, self.dataloader.extra_esg_data_logs))
+            + list(map(lambda x: x.series.name, self.dataloader.intermediary_logs))
+        )
+
+    def get_pandas_fields(self, request):
+        fields = [
+            pf.PKField(key="underlying_instrument", label="ID"),
+            pf.CharField(key="underlying_instrument_repr", label="Instrument"),
+            pf.FloatField(key="weighting", label="Weight", percent=True),
+            pf.FloatField(key="total_value_fx_usd", label="Total Asset (USD)"),
+            pf.FloatField(key="esg_data", label="ESG Data", precision=4),
+            pf.FloatField(key="weights_in_coverage", label="Weights in Coverage", percent=True),
+        ]
+        for extra_esg_data_log in self.dataloader.extra_esg_data_logs:
+            fields.append(
+                pf.FloatField(
+                    key=extra_esg_data_log.series.name,
+                    label=extra_esg_data_log.label,
+                    percent=extra_esg_data_log.is_percent,
+                    precision=extra_esg_data_log.precision,
+                )
+            )
+        for intermediary_log in self.dataloader.intermediary_logs:
+            fields.append(
+                pf.FloatField(
+                    key=intermediary_log.series.name,
+                    label=intermediary_log.label,
+                    percent=intermediary_log.is_percent,
+                    precision=intermediary_log.precision,
+                )
+            )
+        if self.esg_aggregation.get_aggregation() == AggregationMethod.PERCENTAGE_SUM:
+            fields.append(pf.FloatField(key="metric", label="Metric", percent=True))
+        else:
+            fields.append(pf.FloatField(key="metric", label="Metric", precision=4))
+        return pf.PandasFields(fields=fields)
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        dataloader = self.dataloader
+        df = pd.concat(
+            [
+                self.base_df["weighting"],
+                self.base_df["total_value_fx_usd"],
+                self.esg_data.rename("esg_data"),
+                *map(lambda x: x.series, dataloader.extra_esg_data_logs),
+                dataloader.weights_in_coverage.rename("weights_in_coverage"),
+                *map(lambda x: x.series, dataloader.intermediary_logs),
+                self.metric,
+            ],
+            axis=1,
+        )
+        return df
+
+    def manipulate_dataframe(self, df):
+        df["underlying_instrument_repr"] = df.index.map(
+            dict(self.dataloader.instruments.values_list("id", "computed_str"))
+        )
+        return df.reset_index()
+
+    def get_aggregates(self, request, df):
+        aggregates = {}
+        for column in self.metric_columns:
+            with suppress(TypeError, KeyError):  # silent aggregation on str type
+                aggregates[column] = {"Σ": format_number(df[column].sum(), decimal=4)}
+        return aggregates
+
+    def get_ordering_fields(self) -> list[str]:
+        return ["underlying_instrument_repr"] + self.metric_columns

wbportfolio/viewsets/mixins.py

@@ -0,0 +1,48 @@
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from wbfdm.models import Instrument
+from wbportfolio.models import Portfolio, PortfolioRole
+
+
+class UserPortfolioRequestPermissionMixin:
+    @cached_property
+    def instrument(self) -> Instrument:
+        return get_object_or_404(Instrument, pk=self.kwargs["instrument_id"])
+
+    @cached_property
+    def portfolio(self) -> Portfolio:
+        return get_object_or_404(Portfolio, id=self.kwargs["portfolio_id"])
+
+    @cached_property
+    def instrument_or_none(self) -> Instrument | None:
+        try:
+            return get_object_or_404(Instrument, pk=self.kwargs["instrument_id"])
+        except Exception:
+            return None
+
+    @cached_property
+    def portfolio_or_none(self) -> Portfolio | None:
+        try:
+            return get_object_or_404(Portfolio, id=self.kwargs["portfolio_id"])
+        except Exception:
+            return None
+
+    @cached_property
+    def is_manager(self) -> bool:
+        return PortfolioRole.is_manager(self.request.user.profile)
+
+    @cached_property
+    def is_portfolio_manager(self) -> bool:
+        return PortfolioRole.is_portfolio_manager(
+            self.request.user.profile, portfolio=self.portfolio_or_none, instrument=self.instrument_or_none
+        )
+
+    @cached_property
+    def is_analyst(self) -> bool:
+        return PortfolioRole.is_analyst(
+            self.request.user.profile, portfolio=self.portfolio_or_none, instrument=self.instrument_or_none
+        )
+
+    @cached_property
+    def has_portfolio_access(self) -> bool:
+        return self.is_portfolio_manager or self.is_analyst

wbportfolio/viewsets/portfolio_cash_flow.py

@@ -0,0 +1,31 @@
+from django.db.models import Case, F, Value, When
+from wbcore import viewsets
+from wbportfolio.models import DailyPortfolioCashFlow
+from wbportfolio.serializers import DailyPortfolioCashFlowModelSerializer
+from wbportfolio.viewsets.configs.display import DailyPortfolioCashFlowDisplayConfig
+from wbportfolio.viewsets.configs.titles import DailyPortfolioCashFlowTitleConfig
+
+
+class DailyPortfolioCashFlowModelViewSet(viewsets.ModelViewSet):
+    queryset = DailyPortfolioCashFlow.objects.all()
+    serializer_class = DailyPortfolioCashFlowModelSerializer
+
+    display_config_class = DailyPortfolioCashFlowDisplayConfig
+    title_config_class = DailyPortfolioCashFlowTitleConfig
+
+    ordering_fields = ("value_date",)
+    ordering = ("-value_date",)
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        if portfolio_id := self.kwargs.get("portfolio_id", None):
+            queryset = queryset.filter(portfolio_id=portfolio_id)
+
+        return queryset.annotate(
+            swing_pricing_indicator=Case(
+                When(cash_flow_asset_ratio__lt=F("swing_pricing__negative_threshold"), then=Value("neg")),
+                When(cash_flow_asset_ratio__gt=F("swing_pricing__positive_threshold"), then=Value("pos")),
+                default=None,
+            )
+        )

wbportfolio/viewsets/portfolio_cash_targets.py

@@ -0,0 +1,8 @@
+from wbcore import viewsets
+from wbportfolio.models import PortfolioCashTarget
+from wbportfolio.serializers import PortfolioCashTargetModelSerializer
+
+
+class PortfolioCashTargetModelViewSet(viewsets.ModelViewSet):
+    queryset = PortfolioCashTarget.objects.all()
+    serializer_class = PortfolioCashTargetModelSerializer

wbportfolio/viewsets/portfolio_relationship.py

@@ -0,0 +1,46 @@
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbportfolio.models import (
+    InstrumentPortfolioThroughModel,
+    PortfolioInstrumentPreferredClassificationThroughModel,
+)
+from wbportfolio.serializers import (
+    InstrumentPortfolioThroughModelSerializer,
+    InstrumentPreferedClassificationThroughProductModelSerializer,
+)
+
+from .configs import (
+    InstrumentPortfolioThroughPortfolioModelDisplayConfig,
+    InstrumentPortfolioThroughPortfolioModelEndpointConfig,
+    PortfolioInstrumentPreferredClassificationThroughDisplayConfig,
+    PortfolioInstrumentPreferredClassificationThroughEndpointConfig,
+)
+
+
+class InstrumentPreferedClassificationThroughProductModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    serializer_class = InstrumentPreferedClassificationThroughProductModelSerializer
+    queryset = PortfolioInstrumentPreferredClassificationThroughModel.objects.all()
+
+    search_fields = ("instrument__computed_str", "classification__computed_str")
+    ordering_fields = ordering = ["instrument__computed_str"]
+    filterset_fields = {"instrument": ["exact"], "classification": ["exact"]}
+    display_config_class = PortfolioInstrumentPreferredClassificationThroughDisplayConfig
+    endpoint_config_class = PortfolioInstrumentPreferredClassificationThroughEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(portfolio=self.kwargs["portfolio_id"])
+
+
+class InstrumentPortfolioThroughPortfolioModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    serializer_class = InstrumentPortfolioThroughModelSerializer
+    queryset = InstrumentPortfolioThroughModel.objects.all()
+
+    search_fields = ("instrument__name",)
+    ordering_fields = ["instrument__name"]
+    ordering = ["instrument__name"]
+
+    display_config_class = InstrumentPortfolioThroughPortfolioModelDisplayConfig
+    endpoint_config_class = InstrumentPortfolioThroughPortfolioModelEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(portfolio=self.kwargs["portfolio_id"])

wbportfolio/viewsets/portfolio_swing_pricing.py

@@ -0,0 +1,8 @@
+from wbcore import viewsets
+from wbportfolio.models.portfolio_swing_pricings import PortfolioSwingPricing
+from wbportfolio.serializers import PortfolioSwingPricingModelSerializer
+
+
+class PortfolioSwingPricingModelViewSet(viewsets.ModelViewSet):
+    queryset = PortfolioSwingPricing.objects.all()
+    serializer_class = PortfolioSwingPricingModelSerializer

wbportfolio/viewsets/portfolios.py

@@ -0,0 +1,154 @@
+from datetime import datetime
+
+from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.currency.models import Currency
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.date import get_date_interval_from_request
+from wbportfolio.filters import PortfolioFilterSet
+from wbportfolio.models import (
+    Portfolio,
+    PortfolioPortfolioThroughModel,
+    PortfolioSynchronization,
+    PriceComputation,
+    TradeProposal,
+)
+from wbportfolio.models.portfolio import resynchronize_history_as_task
+from wbportfolio.serializers import (
+    ModelPortfolioModelSerializer,
+    PortfolioModelSerializer,
+    PortfolioPortfolioThroughModelSerializer,
+    PortfolioRepresentationSerializer,
+)
+
+from .configs import (
+    ModelPortfolioButtonConfig,
+    ModelPortfolioDisplayConfig,
+    ModelPortfolioEndpointConfig,
+    ModelPortfolioTitleConfig,
+    PortfolioButtonConfig,
+    PortfolioDisplayConfig,
+    PortfolioEndpointConfig,
+    PortfolioPortfolioThroughModelDisplayConfig,
+    PortfolioPortfolioThroughModelEndpointConfig,
+    PortfolioPreviewConfig,
+    PortfolioTitleConfig,
+)
+from .mixins import UserPortfolioRequestPermissionMixin
+
+
+class PortfolioRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbportfolio:portfolio"
+
+    ordering_fields = ordering = search_fields = ("name",)
+    queryset = Portfolio.objects.all()
+    serializer_class = PortfolioRepresentationSerializer
+    filterset_class = PortfolioFilterSet
+
+
+class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, viewsets.ModelViewSet):
+    filterset_class = PortfolioFilterSet
+    serializer_class = PortfolioModelSerializer
+    queryset = Portfolio.objects.all()
+
+    search_fields = ("currency__key", "name")
+    ordering_fields = search_fields
+    ordering = ["name"]
+
+    display_config_class = PortfolioDisplayConfig
+    button_config_class = PortfolioButtonConfig
+    title_config_class = PortfolioTitleConfig
+    endpoint_config_class = PortfolioEndpointConfig
+    preview_config_class = PortfolioPreviewConfig
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .select_related(
+                "currency",
+                "portfolio_synchronization",
+            )
+            .prefetch_related(
+                "depends_on",
+                "dependent_portfolios",
+            )
+        )
+
+    @action(detail=True, methods=["PATCH"])
+    def rebalance(self, request, pk=None):
+        if (date_str := request.POST.get("trade_date", None)) and (
+            model_portfolio_id := request.POST.get("model_portfolio", None)
+        ):
+            TradeProposal.objects.create(
+                portfolio=Portfolio.objects.get(id=pk),
+                model_portfolio=Portfolio.objects.get(id=model_portfolio_id),
+                trade_date=datetime.strptime(date_str, "%Y-%m-%d"),
+            )
+            return Response({"send": True})
+        raise HttpResponse("Bad Request", status=400)
+
+    @action(detail=True, methods=["PATCH"])
+    def resynchronize(self, request, pk=None):
+        if request.user.has_perm("wbportfolio.administrate_instrument"):
+            portfolio = get_object_or_404(Portfolio, pk=pk)
+            instrument = request.GET.get("instrument", None)
+            start, end = get_date_interval_from_request(request, request_type="POST")
+            resynchronize_history_as_task.delay(portfolio.id, start, end, instrument_id=instrument)
+            return Response({"send": True})
+        return HttpResponse("Unauthorized", status=401)
+
+
+class ModelPortfolioModelViewSet(PortfolioModelViewSet):
+    serializer_class = ModelPortfolioModelSerializer
+    endpoint_config_class = ModelPortfolioEndpointConfig
+    display_config_class = ModelPortfolioDisplayConfig
+    title_config_class = ModelPortfolioTitleConfig
+    button_config_class = ModelPortfolioButtonConfig
+
+    @action(detail=False, methods=["POST"])
+    def createmodelportfolio(self, request, pk=None):
+        if self.is_portfolio_manager:
+            name = request.POST["name"]
+            currency_id = request.POST["currency"]
+            currency = Currency.objects.get(id=currency_id)
+            portfolio_synchronization_id = request.POST.get("portfolio_synchronization", None)
+            price_computation_id = request.POST.get("price_computation", None)
+            portfolio_synchronization = (
+                PortfolioSynchronization.objects.get(id=portfolio_synchronization_id)
+                if portfolio_synchronization_id
+                else None
+            )
+            create_index = request.POST.get("create_index", "false") == "true"
+            index_parameters = {}
+            if create_index:
+                index_parameters["price_computation"] = (
+                    PriceComputation.objects.get(id=price_computation_id) if price_computation_id else None
+                )
+            Portfolio.create_model_portfolio(
+                name, currency, portfolio_synchronization=portfolio_synchronization, index_parameters=index_parameters
+            )
+            return Response({"send": True})
+        raise HttpResponse("Unauthorized", status=403)
+
+    def get_queryset(self):
+        model_portfolios = PortfolioPortfolioThroughModel.objects.filter(
+            type=PortfolioPortfolioThroughModel.Type.MODEL
+        ).values("dependency_portfolio")
+        return super().get_queryset().filter(id__in=model_portfolios)
+
+
+class PortfolioPortfolioThroughModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    serializer_class = PortfolioPortfolioThroughModelSerializer
+    queryset = PortfolioPortfolioThroughModel.objects.all()
+
+    search_fields = ["dependency_portfolio__name"]
+
+    display_config_class = PortfolioPortfolioThroughModelDisplayConfig
+    endpoint_config_class = PortfolioPortfolioThroughModelEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(portfolio=self.kwargs["portfolio_id"])