wbportfolio 2.2.1__py2.py3-none-any.whl

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 ==