wbportfolio 1.43.1__py2.py3-none-any.whl

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

wbportfolio/metric/backends/portfolio_esg.py

@@ -0,0 +1,66 @@
+from typing import Generator
+
+import pandas as pd
+from wbfdm.analysis.esg.enums import ESGAggregation
+from wbfdm.analysis.esg.esg_analysis import DataLoader, get_esg_df
+from wbfdm.contrib.metric.decorators import register
+from wbfdm.contrib.metric.dto import Metric, MetricField, MetricKey
+from wbportfolio.models import Portfolio
+
+from .base import PortfolioMetricBaseBackend
+from .portfolio_base import DataLoader as PortfolioDataLoader
+
+
+def _generate_metric_key_from_enum():
+    metric_keys = []
+    for key, label in ESGAggregation.choices():
+        metric_keys.append(
+            MetricKey(
+                key=f"portfolio_esg_{key.lower()}",
+                label=label,
+                subfields=[
+                    MetricField(key="score", label="Score"),
+                ],
+            )
+        )
+    return metric_keys
+
+
+PORTFOLIO_ESG_KEYS = _generate_metric_key_from_enum()
+
+
+@register()
+class PortfolioESGMetricBackend(PortfolioMetricBaseBackend):
+    keys = PORTFOLIO_ESG_KEYS
+
+    def _get_metrics_for_esg_aggregation(
+        self, instruments, weights: pd.Series, total_value_fx_usd: pd.Series, esg_aggregation: ESGAggregation
+    ) -> pd.Series:
+        dl = DataLoader(
+            weights, get_esg_df(instruments, esg_aggregation.get_esg_code()), self.val_date, total_value_fx_usd
+        )
+        df = dl.compute(esg_aggregation)
+
+        return df.rename("score").to_frame()
+
+    def compute_metrics(self, basket: Portfolio) -> Generator[Metric, None, None]:
+        val_date = self._get_valid_date(basket)
+        portfolio_dataloader = PortfolioDataLoader(basket, val_date)
+        base_df = portfolio_dataloader.base_df
+
+        if not base_df.empty:
+            for esg in ESGAggregation:
+                df = self._get_metrics_for_esg_aggregation(
+                    portfolio_dataloader.instruments, base_df["weighting"], base_df["total_value_fx_usd"], esg
+                )
+                df_aggregated = df.sum(axis=0)
+                metrics = self.convert_df_into_metrics(df, f"portfolio_esg_{esg.name.lower()}", basket.id, val_date)
+                aggregated_metrics = self.convert_df_into_metrics(
+                    df_aggregated,
+                    f"portfolio_esg_{esg.name.lower()}",
+                    basket.id,
+                    val_date,
+                    dependency_metrics=metrics,
+                )
+                yield from metrics
+                yield from aggregated_metrics

wbportfolio/metric/tests/conftest.py

@@ -0,0 +1,4 @@
+from wbfdm.contrib.metric.factories import InstrumentMetricFactory
+from wbportfolio.tests.conftest import *  # noqa
+
+register(InstrumentMetricFactory)

wbportfolio/metric/tests/test_portfolio_base.py

@@ -0,0 +1,135 @@
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+import pytest
+from django.db.models import Sum
+from faker import Faker
+from wbfdm.dataloaders.proxies import InstrumentDataloaderProxy
+from wbfdm.enums import Financial
+from wbportfolio.factories import AssetPositionFactory, PortfolioFactory
+from wbportfolio.models import AssetPosition
+
+from ..backends.portfolio_base import DataLoader
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPortfolioBaseDataloader:
+    @pytest.fixture
+    def dataloader(self, weekday):
+        portfolio = PortfolioFactory.create()
+        AssetPositionFactory.create_batch(5, portfolio=portfolio, date=weekday, is_estimated=False)
+        dataloader = DataLoader(portfolio, weekday)
+        base_df = dataloader.base_df
+        columns = dataloader.columns_map.keys()
+        dataloader.__dict__["market_capitalization_df"] = pd.DataFrame(
+            np.random.randint(1e6, 1e9, size=(base_df.shape[0], len(columns))), index=base_df.index, columns=columns
+        )
+        dataloader.__dict__["ebit_usd_df"] = pd.DataFrame(
+            np.random.randint(100, 100000, size=(base_df.shape[0], len(columns))), index=base_df.index, columns=columns
+        )
+        dataloader.__dict__["total_assets_usd_df"] = pd.DataFrame(
+            np.random.randint(1e6, 1e9, size=(base_df.shape[0], len(columns))), index=base_df.index, columns=columns
+        )
+        dataloader.__dict__["liabilities_usd_df"] = pd.DataFrame(
+            np.random.randint(1e6, 1e9, size=(base_df.shape[0], len(columns))), index=base_df.index, columns=columns
+        )
+        return dataloader
+
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test__get_financial_df(self, mock_fct, dataloader: DataLoader):
+        return_value = []
+        base_df = dataloader.base_df
+        for pivot_date in dataloader.pivot_dates:
+            for instrument_id in base_df.index:
+                return_value.append({"instrument_id": instrument_id, "year": pivot_date.year, "value": fake.pyfloat()})
+        mock_fct.return_value = return_value
+        res = dataloader._get_financial_df(Financial.EBIT)
+        pd.testing.assert_index_equal(res.index, base_df.index)
+        assert set(res.columns.tolist()) == set(dataloader.columns_map.keys())
+
+    @patch.object(InstrumentDataloaderProxy, "financials")
+    def test__get_financial_df_empty(self, mock_fct, dataloader: DataLoader):
+        mock_fct.return_value = []
+        with pytest.raises(ValueError):
+            dataloader._get_financial_df(Financial.EBIT)
+
+    def test_base_df(self, dataloader):
+        base_df = dataloader.base_df
+        total_portfolio_weight = AssetPosition.objects.filter(
+            portfolio=dataloader.portfolio, date=dataloader.val_date
+        ).aggregate(c=Sum("weighting"))["c"]
+        for instrument_id, df in base_df.to_dict("index").items():
+            for key, value in df.items():
+                pos = AssetPosition.objects.get(
+                    portfolio=dataloader.portfolio, date=dataloader.val_date, underlying_instrument=instrument_id
+                )
+                if key == "weighting":
+                    assert float(getattr(pos, key) / total_portfolio_weight) == pytest.approx(value, abs=1e-6)
+                else:
+                    assert float(getattr(pos, key)) == value
+
+    # Test portfolio metric computation
+    def test_portfolio_ownership_df(self, dataloader):
+        assert dataloader.portfolio_ownership_df.dropna().empty is False
+        pd.testing.assert_frame_equal(
+            dataloader.portfolio_ownership_df,
+            (1.0 / dataloader.market_capitalization_df).multiply(dataloader.base_df.total_value_fx_usd, axis=0),
+            check_exact=True,
+        )
+
+    def test_portfolio_ebit_usd_df(self, dataloader):
+        assert dataloader.portfolio_ebit_usd_df.dropna().empty is False
+        pd.testing.assert_frame_equal(
+            dataloader.portfolio_ebit_usd_df,
+            dataloader.portfolio_ownership_df * dataloader.ebit_usd_df,
+            check_exact=True,
+        )
+        pd.testing.assert_series_equal(
+            dataloader.portfolio_ebit_usd_df.aggregate, dataloader.portfolio_ebit_usd_df.sum(axis=0), check_exact=True
+        )
+
+    def test_portfolio_total_assets_usd_df(self, dataloader):
+        assert dataloader.portfolio_total_assets_usd_df.dropna().empty is False
+        pd.testing.assert_frame_equal(
+            dataloader.portfolio_total_assets_usd_df,
+            dataloader.portfolio_ownership_df * dataloader.total_assets_usd_df,
+            check_exact=True,
+        )
+        pd.testing.assert_series_equal(
+            dataloader.portfolio_total_assets_usd_df.aggregate,
+            dataloader.portfolio_total_assets_usd_df.sum(axis=0),
+            check_exact=True,
+        )
+
+    def test_portfolio_liabilities_usd_df(self, dataloader):
+        assert dataloader.portfolio_liabilities_usd_df.dropna().empty is False
+        pd.testing.assert_frame_equal(
+            dataloader.portfolio_liabilities_usd_df,
+            dataloader.portfolio_ownership_df * dataloader.liabilities_usd_df,
+            check_exact=True,
+        )
+        pd.testing.assert_series_equal(
+            dataloader.portfolio_liabilities_usd_df.aggregate,
+            dataloader.portfolio_liabilities_usd_df.sum(axis=0),
+            check_exact=True,
+        )
+
+    def test_portfolio_aggregation_capital_employed(self, dataloader):
+        assert dataloader.portfolio_aggregation_capital_employed.dropna().empty is False
+        pd.testing.assert_series_equal(
+            dataloader.portfolio_aggregation_capital_employed,
+            dataloader.portfolio_total_assets_usd_df.aggregate - dataloader.portfolio_liabilities_usd_df.aggregate,
+            check_exact=True,
+        )
+
+    def test_portfolio_aggregation_roce(self, dataloader):
+        assert dataloader.portfolio_aggregation_roce.dropna().empty is False
+        pd.testing.assert_series_equal(
+            dataloader.portfolio_aggregation_roce,
+            dataloader.portfolio_ebit_usd_df.aggregate
+            / dataloader.portfolio_aggregation_capital_employed.rolling(2).mean(),
+            check_exact=True,
+        )

wbportfolio/metric/tests/test_portfolio_esg.py

@@ -0,0 +1,69 @@
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from faker import Faker
+from wbfdm.analysis.esg.enums import ESGAggregation
+from wbfdm.contrib.metric.models import InstrumentMetric
+
+from ..backends.portfolio_esg import PortfolioESGMetricBackend
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPortfolioESGDataloader:
+    @pytest.fixture
+    def backend(self, weekday):
+        return PortfolioESGMetricBackend(weekday)
+
+    @patch.object(PortfolioESGMetricBackend, "_get_metrics_for_esg_aggregation")
+    def test_compute_metrics(self, mock_fct, backend, portfolio, instrument_factory, asset_position_factory):
+        instruments = instrument_factory.create_batch(2)
+        asset_position_factory.create(portfolio=portfolio, is_estimated=False, date=backend.val_date)
+        esg_aggregation = pd.DataFrame(
+            np.random.randint(1, 100, size=[2, 1]), index=[i.id for i in instruments], columns=["score"]
+        )
+        mock_fct.return_value = esg_aggregation
+        for metric in backend.compute_metrics(portfolio):
+            InstrumentMetric.update_or_create_from_metric(metric)
+
+        p_ct = ContentType.objects.get_for_model(portfolio)
+
+        # check that we indeed created and stored a metrics for each esg aggregation and for each instrument
+        for esg in ESGAggregation:
+            for instrument in instruments:
+                assert (
+                    InstrumentMetric.objects.get(
+                        basket_content_type=p_ct.pk,
+                        basket_id=portfolio.id,
+                        instrument=instrument,
+                        date=backend.val_date,
+                        key=f"portfolio_esg_{esg.name.lower()}",
+                    ).metrics["score"]
+                    == esg_aggregation.loc[instrument.id, "score"]
+                )
+
+            # check if the egg aggregated accross the whole portfolio is properly stored
+            assert (
+                InstrumentMetric.objects.get(
+                    basket_content_type=p_ct.pk,
+                    basket_id=portfolio.id,
+                    instrument__isnull=True,
+                    date=backend.val_date,
+                    key=f"portfolio_esg_{esg.name.lower()}",
+                ).metrics["score"]
+                == esg_aggregation.sum(axis=0)["score"]
+            )
+
+        #
+        # # basic checks
+        # assert res[0].basket_id == portfolio.id
+        # assert res[0].basket_content_type_id ==
+        # assert res[0].key ==
+        # assert res[0].metrics ==
+        # assert res[0].date ==
+        # assert res[0].instrument_id ==
+        # assert res[0].dependency_metrics ==