wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/import_export/resources/trades.py

@@ -0,0 +1,41 @@
+import rstr
+from faker import Faker
+from import_export import fields
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.io.resources import FilterModelResource
+from wbfdm.models import Instrument
+from wbportfolio.models import Trade
+
+fake = Faker()
+
+
+class TradeProposalTradeResource(FilterModelResource):
+    """
+    Trade Resource class to use to import trade from the trade proposal
+    """
+
+    DUMMY_FIELD_MAP = {
+        "underlying_instrument": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "weighting": 1.0,
+        "shares": 1000.2536,
+        "comment": lambda: fake.sentence(),
+        "order": 1,
+    }
+    underlying_instrument = fields.Field(
+        column_name="underlying_instrument",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="isin"),
+    )
+
+    class Meta:
+        import_id_fields = ("id",)
+        fields = (
+            "id",
+            "underlying_instrument",
+            "weighting",
+            "shares",
+            "comment",
+            "order",
+        )
+        export_order = fields
+        model = Trade

wbportfolio/import_export/utils.py

@@ -0,0 +1,42 @@
+import os
+
+import dateparser
+from xlrd.xldate import xldate_as_datetime
+
+
+def get_fields_name(model):
+    return [field.name for field in model._meta.get_fields()]
+
+
+def get_file_extension(file):
+    name, extension = os.path.splitext(file.name)
+    return extension.lower()
+
+
+def convert_string_to_number(string):
+    if string == "nan" or not string:
+        return 0.0
+    if type(string) in (int, float):
+        return float(string)
+    try:
+        return float(string.replace(" ", "").replace(",", ""))
+    except ValueError:
+        return 0.0
+
+
+def parse_date(date, formats=[]):
+    if isinstance(date, int) or isinstance(date, float):
+        return xldate_as_datetime(int(date), 0).date()
+    if isinstance(date, str):
+        if format:
+            return dateparser.parse(date, date_formats=formats).date()
+        else:
+            return dateparser.parse(date).date()
+
+
+def extract_exchange_ticker(bbg_ticker):
+    try:
+        ticker, exchange = bbg_ticker.split(" ")[0:2]
+    except Exception:
+        ticker, exchange = bbg_ticker, None
+    return ticker, exchange

wbportfolio/metric/backends/__init__.py

@@ -0,0 +1,2 @@
+from .portfolio_base import PortfolioBaseMetricBackend
+from .portfolio_esg import PortfolioESGMetricBackend

wbportfolio/metric/backends/base.py

@@ -0,0 +1,86 @@
+from datetime import date
+
+import numpy as np
+import pandas as pd
+from django.db.models import Exists, OuterRef, QuerySet
+from wbfdm.contrib.metric.backends.base import AbstractBackend, Metric
+from wbfdm.contrib.metric.exceptions import MetricInvalidParameterException
+from wbfdm.models import InstrumentType
+from wbportfolio.models import AssetPosition, InstrumentPortfolioThroughModel, Portfolio
+
+
+class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
+    BASKET_MODEL_CLASS = Portfolio
+
+    def convert_df_into_metrics(
+        self,
+        df: pd.DataFrame | pd.Series,
+        key: str,
+        portfolio_id: int,
+        metric_date: date,
+        columns_map: dict[int | str, str] | None = None,
+        dependency_metrics: list["Metric"] | None = None,
+    ) -> list[Metric]:
+        if not dependency_metrics:
+            dependency_metrics = []
+        metrics = []
+        df = df.replace([np.inf, -np.inf, np.nan], None)
+        if isinstance(df, pd.DataFrame):
+            if columns_map:
+                df = df.rename(columns=columns_map)
+            for instrument_id, metric in df.to_dict("index").items():
+                metrics.append(
+                    Metric(
+                        basket_id=portfolio_id,
+                        basket_content_type_id=self.content_type.id,
+                        key=key,
+                        metrics=metric,
+                        date=metric_date,
+                        instrument_id=instrument_id,
+                        dependency_metrics=dependency_metrics,
+                    )
+                )
+        else:
+            if columns_map:
+                df = df.rename(index=columns_map)
+            metrics.append(
+                Metric(
+                    basket_id=portfolio_id,
+                    basket_content_type_id=self.content_type.id,
+                    key=key,
+                    metrics=df.to_dict(),
+                    date=metric_date,
+                    dependency_metrics=dependency_metrics,
+                )
+            )
+        return metrics
+
+    def _get_valid_date(self, portfolio):
+        qs = portfolio.assets.filter(is_estimated=False)
+        if self.val_date is not None:
+            qs = qs.filter(date__lte=self.val_date)
+        try:
+            return qs.latest("date").date
+        except AssetPosition.DoesNotExist:
+            raise MetricInvalidParameterException()
+
+    def get_queryset(self) -> QuerySet[Portfolio]:
+        product_portfolios = (
+            super()
+            .get_queryset()
+            .annotate(
+                has_product=Exists(
+                    InstrumentPortfolioThroughModel.objects.filter(
+                        instrument__instrument_type=InstrumentType.PRODUCT, portfolio=OuterRef("pk")
+                    )
+                )
+            )
+            .filter(has_product=True, is_active=True)
+        )
+        try:
+            last_position_date = (
+                AssetPosition.objects.filter(portfolio__in=product_portfolios, is_estimated=False).latest("date").date
+            )
+        except AssetPosition.DoesNotExist:
+            last_position_date = date.today()
+        return product_portfolios.filter_invested_at_date(last_position_date)

wbportfolio/metric/backends/constants.py

@@ -0,0 +1,222 @@
+from wbfdm.contrib.metric.dto import MetricField, MetricKey
+
+PORTFOLIO_EBIT = MetricKey(
+    key="portfolio_ebit",
+    label="EBIT",
+    subfields=[
+        MetricField(
+            key="fy_3",
+            label="FY-3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_2",
+            label="FY-2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_1",
+            label="FY-1",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy0",
+            label="FY0",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(key="fy1", label="FY1", decorators=[{"position": "left", "value": "$"}]),
+        MetricField(
+            key="fy2",
+            label="FY2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy3",
+            label="FY3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy4",
+            label="FY4",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+    ],
+)
+
+PORTFOLIO_TOTAL_ASSETS = MetricKey(
+    key="portfolio_total_assets",
+    label="Total Assets",
+    subfields=[
+        MetricField(
+            key="fy_3",
+            label="FY-3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_2",
+            label="FY-2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_1",
+            label="FY-1",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy0",
+            label="FY0",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(key="fy1", label="FY1", decorators=[{"position": "left", "value": "$"}]),
+        MetricField(
+            key="fy2",
+            label="FY2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy3",
+            label="FY3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy4",
+            label="FY4",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+    ],
+)
+
+PORTFOLIO_LIABILITIES = MetricKey(
+    key="portfolio_liabilities",
+    label="Liabilities",
+    subfields=[
+        MetricField(
+            key="fy_3",
+            label="FY-3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_2",
+            label="FY-2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_1",
+            label="FY-1",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy0",
+            label="FY0",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(key="fy1", label="FY1", decorators=[{"position": "left", "value": "$"}]),
+        MetricField(
+            key="fy2",
+            label="FY2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy3",
+            label="FY3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy4",
+            label="FY4",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+    ],
+)
+
+PORTFOLIO_CAPITAL_EMPLOYED = MetricKey(
+    key="portfolio_capital_employed",
+    label="Capital Employed",
+    subfields=[
+        MetricField(
+            key="fy_3",
+            label="FY-3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_2",
+            label="FY-2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy_1",
+            label="FY-1",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy0",
+            label="FY0",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(key="fy1", label="FY1", decorators=[{"position": "left", "value": "$"}]),
+        MetricField(
+            key="fy2",
+            label="FY2",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy3",
+            label="FY3",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+        MetricField(
+            key="fy4",
+            label="FY4",
+            list_display_kwargs={"show": "open"},
+            decorators=[{"position": "left", "value": "$"}],
+        ),
+    ],
+)
+
+PORTFOLIO_ROCE = MetricKey(
+    key="portfolio_roce",
+    label="ROCE",
+    subfields=[
+        MetricField(
+            key="fy_3", label="FY-3", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}
+        ),
+        MetricField(
+            key="fy_2", label="FY-2", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}
+        ),
+        MetricField(
+            key="fy_1", label="FY-1", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}
+        ),
+        MetricField(key="fy0", label="FY0", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}),
+        MetricField(key="fy1", label="FY1", serializer_kwargs={"percent": True}),
+        MetricField(key="fy2", label="FY2", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}),
+        MetricField(key="fy3", label="FY3", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}),
+        MetricField(key="fy4", label="FY4", list_display_kwargs={"show": "open"}, serializer_kwargs={"percent": True}),
+    ],
+)

wbportfolio/metric/backends/portfolio_base.py

@@ -0,0 +1,255 @@
+from contextlib import suppress
+from datetime import date
+from typing import Generator
+
+import pandas as pd
+from django.db.models import Q
+from django.utils.functional import cached_property
+from wbfdm.contrib.metric.backends.base import Metric
+from wbfdm.contrib.metric.decorators import register
+from wbfdm.enums import Financial, MarketData
+from wbfdm.models import Instrument
+from wbportfolio.models import Portfolio
+
+from .base import PortfolioMetricBaseBackend
+from .constants import (
+    PORTFOLIO_CAPITAL_EMPLOYED,
+    PORTFOLIO_EBIT,
+    PORTFOLIO_LIABILITIES,
+    PORTFOLIO_ROCE,
+    PORTFOLIO_TOTAL_ASSETS,
+)
+
+
+class DataLoader:
+    def __init__(
+        self, portfolio: Portfolio, val_date: date, past_offset: int = 4, forecast_offset: int = 4, freq: str = "YE"
+    ):
+        self.portfolio = portfolio
+        self.val_date = val_date
+        self.instruments = Instrument.objects.filter(id__in=self.base_df.index)
+        self.past_offset = past_offset
+        self.forecast_offset = forecast_offset
+        self.pivot_dates = list(
+            pd.date_range(end=self.val_date, periods=self.past_offset, freq=freq, inclusive="left")
+        ) + list(pd.date_range(start=self.val_date, periods=self.past_offset, freq=freq, inclusive="right"))
+        self.columns_map = {
+            self.val_date.year + offset: f"fy{offset + 1}".replace("-", "_")
+            for offset in range(-1 * self.past_offset, self.forecast_offset)
+        }
+        self.from_year = self.val_date.year - self.past_offset
+        self.to_year = self.val_date.year + self.forecast_offset - 1
+
+        self.empty_series = pd.Series(dtype="float64")
+
+    def _get_financial_df(self, financial: Financial, target_currency: str = "USD", **kwargs) -> pd.DataFrame:
+        """
+        Private helper method to gather necessary financial data from the finanical dataloader and pivot it into Instrument*Years format
+
+        Args:
+            financial: Financial Metric
+            target_currency: Target currency
+            **kwargs: fdm datalaoder keyword argument
+
+        Returns:
+            A dataframe whose index is the instrument ids and columns are the years offsets
+        """
+
+        df = pd.DataFrame(
+            self.instruments.dl.financials(
+                values=[financial],
+                from_year=self.from_year,
+                to_year=self.to_year,
+                target_currency=target_currency,
+                **kwargs,
+            )
+        )
+        if df.empty:
+            raise ValueError(f"No financial data for {financial.value}")
+        return df.pivot_table(index="instrument_id", values="value", columns="year", aggfunc="first")
+
+    # Data Input
+    @cached_property
+    def market_capitalization_df(self) -> pd.DataFrame:
+        df_list = []
+        for pivot_date in self.pivot_dates:
+            try:
+                mkt_caps = pd.DataFrame(
+                    self.instruments.dl.market_data(
+                        values=[MarketData.MARKET_CAPITALIZATION],
+                        from_date=(pivot_date - pd.tseries.offsets.BDay(3)).date(),
+                        to_date=pivot_date,
+                        target_currency="USD",
+                    )
+                )
+                res = (
+                    mkt_caps[["instrument_id", "market_capitalization"]]
+                    .groupby("instrument_id")
+                    .last()["market_capitalization"]
+                ).astype(float)
+            except KeyError:
+                res = self.empty_series
+            res = res.rename(pivot_date.year)
+            df_list.append(res)
+        return pd.concat(df_list, axis=1).ffill(axis=1)
+
+    @cached_property
+    def ebit_usd_df(self) -> pd.DataFrame:
+        return self._get_financial_df(Financial.EBIT)
+
+    @cached_property
+    def total_assets_usd_df(self) -> pd.DataFrame:
+        return self._get_financial_df(Financial.TOTAL_ASSETS)
+
+    @cached_property
+    def liabilities_usd_df(self) -> pd.DataFrame:
+        return self._get_financial_df(Financial.CURRENT_LIABILITIES)
+
+    # Generate basic portfolio data as a dataframe
+    @cached_property
+    def base_df(self) -> pd.DataFrame:
+        df = pd.DataFrame(
+            self.portfolio.assets.filter(date=self.val_date)
+            .exclude(Q(underlying_instrument__is_cash=True) | Q(underlying_instrument__is_cash_equivalent=True))
+            .values("underlying_instrument", "shares", "price_fx_usd", "total_value_fx_usd", "weighting"),
+            columns=["underlying_instrument", "shares", "price_fx_usd", "total_value_fx_usd", "weighting"],
+        )
+        df = (
+            df.groupby("underlying_instrument")
+            .agg(
+                {
+                    "shares": "sum",
+                    "price_fx_usd": "first",
+                    "total_value_fx_usd": "sum",
+                    "weighting": "sum",
+                }
+            )
+            .astype(float)
+        )
+        df["weighting"] = df["weighting"] / df["weighting"].sum()
+        df.index = df.index.rename("instrument_id")
+        return df
+
+    # Portfolio Metrics
+
+    @cached_property
+    def portfolio_ownership_df(self) -> pd.DataFrame:
+        return (1.0 / self.market_capitalization_df).multiply(self.base_df.total_value_fx_usd, axis=0)
+
+    @cached_property
+    def portfolio_ebit_usd_df(self) -> pd.DataFrame:
+        df = self.portfolio_ownership_df * self.ebit_usd_df
+        df.aggregate = df.sum(axis=0)
+        return df
+
+    @cached_property
+    def portfolio_total_assets_usd_df(self) -> pd.DataFrame:
+        df = self.portfolio_ownership_df * self.total_assets_usd_df
+        df.aggregate = df.sum(axis=0)
+        return df
+
+    @cached_property
+    def portfolio_liabilities_usd_df(self) -> pd.DataFrame:
+        df = self.portfolio_ownership_df * self.liabilities_usd_df
+        df.aggregate = df.sum(axis=0)
+        return df
+
+    @cached_property
+    def portfolio_aggregation_capital_employed(self) -> pd.Series:
+        return self.portfolio_total_assets_usd_df.aggregate - self.portfolio_liabilities_usd_df.aggregate
+
+    @cached_property
+    def portfolio_aggregation_roce(self) -> pd.Series:
+        return self.portfolio_ebit_usd_df.aggregate / self.portfolio_aggregation_capital_employed.rolling(2).mean()
+
+
+@register()
+class PortfolioBaseMetricBackend(PortfolioMetricBaseBackend):
+    portfolio_ebit = PORTFOLIO_EBIT
+    portfolio_total_assets = PORTFOLIO_TOTAL_ASSETS
+    portfolio_liabilities = PORTFOLIO_LIABILITIES
+    portfolio_capital_employed = PORTFOLIO_CAPITAL_EMPLOYED
+    portfolio_roce = PORTFOLIO_ROCE
+
+    keys = [
+        PORTFOLIO_EBIT,
+        PORTFOLIO_TOTAL_ASSETS,
+        PORTFOLIO_LIABILITIES,
+        PORTFOLIO_CAPITAL_EMPLOYED,
+        PORTFOLIO_ROCE,
+    ]
+
+    def compute_metrics(self, basket: Portfolio) -> Generator[Metric, None, None]:
+        val_date = self._get_valid_date(basket)
+        dataloader = DataLoader(basket, val_date)
+
+        # Load all necessary metrics into a Metric DTO from the dataloader
+        with suppress(ValueError):
+            portfolio_ebit_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_ebit_usd_df,
+                "portfolio_ebit",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+            )
+            portfolio_aggregation_ebit_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_ebit_usd_df.aggregate,
+                "portfolio_ebit",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+                dependency_metrics=portfolio_ebit_metrics,
+            )
+
+            portfolio_total_assets_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_total_assets_usd_df,
+                "portfolio_total_assets",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+            )
+            portfolio_aggregation_total_assets_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_total_assets_usd_df.aggregate,
+                "portfolio_total_assets",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+                dependency_metrics=portfolio_total_assets_metrics,
+            )
+
+            portfolio_liabilities_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_liabilities_usd_df,
+                "portfolio_liabilities",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+            )
+            portfolio_aggregation_liabilities_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_liabilities_usd_df.aggregate,
+                "portfolio_liabilities",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+                dependency_metrics=portfolio_liabilities_metrics,
+            )
+
+            portfolio_aggregation_capital_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_aggregation_capital_employed,
+                "portfolio_capital_employed",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+                dependency_metrics=portfolio_aggregation_total_assets_metrics
+                + portfolio_aggregation_liabilities_metrics,
+            )
+
+            portfolio_aggregation_roce_metrics = self.convert_df_into_metrics(
+                dataloader.portfolio_aggregation_roce,
+                "portfolio_roce",
+                dataloader.portfolio.id,
+                val_date,
+                columns_map=dataloader.columns_map,
+                dependency_metrics=portfolio_aggregation_ebit_metrics + portfolio_aggregation_capital_metrics,
+            )
+
+            yield from portfolio_aggregation_roce_metrics