wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/analysis/esg/esg_analysis.py

@@ -0,0 +1,217 @@
+from dataclasses import dataclass
+from datetime import date
+
+import numpy as np
+import pandas as pd
+from django.utils.functional import cached_property
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbfdm.enums import ESG
+from wbfdm.models import Instrument
+
+from .enums import AggregationMethod, ESGAggregation
+from .utils import get_esg_df
+
+
+@dataclass
+class Log:
+    series: pd.Series
+    label: str
+    is_percent: bool = False
+    precision: int = 4
+    group: str | None = None
+
+
+class DataLoader:
+    def __init__(
+        self, weights: pd.Series, esg_data: pd.Series, val_date: date, total_value_fx_usd: pd.Series | None = None
+    ):
+        self.weights = weights
+        self.val_date = val_date
+        try:
+            self.fx_rate_usd_to_eur = float(
+                CurrencyFXRates.objects.get(currency=Currency.objects.get(key="EUR"), date=val_date).value
+            )
+        except (CurrencyFXRates.DoesNotExist, Currency.DoesNotExist):
+            self.fx_rate_usd_to_eur = 1.0
+        self.total_value_fx_usd = total_value_fx_usd
+        self.instruments = Instrument.objects.filter(id__in=self.weights.index)
+        self.empty_series = pd.Series(1.0, index=weights.index, dtype="float64")
+        self.esg_data = esg_data
+        self.weights_in_coverage = (
+            self.weights.loc[~esg_data.reindex(self.weights.index, fill_value=None).isnull()]
+        ).rename("weights_in_coverage")
+        self.intermediary_logs: list[Log] = []
+        self.extra_esg_data_logs: list[Log] = []
+
+    @cached_property
+    def enterprise_value_included_cash(self) -> pd.Series:
+        data = get_esg_df(self.instruments, ESG.EVIC_EUR) * 1000000
+        self.extra_esg_data_logs.append(Log(series=data.rename("enterprise_value_included_cash"), label="EVIC (EUR)"))
+        return data
+
+    @cached_property
+    def current_value_investment_factor(self) -> pd.Series:
+        data = get_esg_df(self.instruments, ESG.CVI_FACTOR)
+        data = data.reindex(self.weights.index, fill_value=1.0)
+        self.extra_esg_data_logs.append(Log(series=data.rename("current_value_investment_factor"), label="CVI Factor"))
+        return data
+
+    @cached_property
+    def nace_section_code(self) -> pd.Series:
+        data = get_esg_df(self.instruments, ESG.NACE_SECTION_CODE)
+        self.extra_esg_data_logs.append(Log(series=data.rename("nace_section_code"), label="NACE_SECTION_CODE"))
+        return data
+
+    def _get_percentage_sum(self, mask_value: str) -> pd.Series:
+        df = self.weights_in_coverage.copy()
+        df.loc[self.esg_data != mask_value] = 0.0
+        return df.dropna()
+
+    def _get_weighted_avg_normalized(self) -> pd.Series:
+        weights_normalized = self.weights_in_coverage / self.weights_in_coverage.sum()
+        self.intermediary_logs.append(
+            Log(
+                series=weights_normalized.rename("weights_normalized"),
+                label="Rebased Weights",
+                is_percent=True,
+                precision=2,
+            )
+        )
+        return (weights_normalized * self.esg_data).dropna()
+
+    def _get_weighted_avg_normalized_per_category(self) -> pd.Series:
+        df = pd.concat([self.weights, self.nace_section_code], keys=["weighting", "nace_section_code"], axis=1)
+        sector_codes = ["C", "D", "F", "G", "J", "K", "M", "N", "Q", "S"]
+        res = pd.Series(np.nan, index=df.index)
+        rebased_weights_logs_per_sector = []
+        weighted_average_logs_per_sector = []
+        for sector_code in sector_codes:
+            try:
+                dff = df[df["nace_section_code"] == sector_code]
+                weights_normalized_per_sector = dff["weighting"] / dff["weighting"].sum()
+            except (TypeError, KeyError):
+                weights_normalized_per_sector = pd.Series(np.nan, index=self.weights.index)
+
+            rebased_weights_logs_per_sector.append(
+                Log(
+                    series=weights_normalized_per_sector.rename(f"weights_normalized_sector_{sector_code.lower()}"),
+                    label=sector_code,
+                    group="Weight rebased per NACE sector",
+                    is_percent=True,
+                    precision=2,
+                )
+            )
+            weighted_average_per_sector = weights_normalized_per_sector * self.esg_data
+            weighted_average_logs_per_sector.append(
+                Log(
+                    series=weighted_average_per_sector.rename(f"weighted_average_sector_{sector_code.lower()}"),
+                    label=sector_code,
+                    group="Weight Average per NACE sector",
+                    precision=4,
+                )
+            )
+
+            res[weighted_average_per_sector.dropna().index] = weighted_average_per_sector.dropna()
+        self.intermediary_logs.extend(rebased_weights_logs_per_sector)
+        self.intermediary_logs.extend(weighted_average_logs_per_sector)
+        return res.dropna()
+
+    def _get_investor_allocation(self, exposure: pd.Series) -> pd.Series:
+        exposure_eur = exposure * self.fx_rate_usd_to_eur
+        self.intermediary_logs.append(Log(series=exposure.rename("exposure"), label="Exposure"))
+        self.intermediary_logs.append(Log(series=exposure_eur.rename("exposure_eur"), label="Exposure (EUR)"))
+
+        evic_eur = self.enterprise_value_included_cash
+        cvi_factor = self.current_value_investment_factor
+
+        exposure_with_cvi = exposure_eur * cvi_factor
+        self.intermediary_logs.append(
+            Log(series=exposure_with_cvi.rename("exposure_with_cvi"), label="Exposure With CVI")
+        )
+        try:
+            rebase_factor = exposure_with_cvi.loc[self.weights_in_coverage.index].sum() / exposure_with_cvi.sum()
+            exposure_with_cvi_normalized = exposure_with_cvi.loc[self.weights_in_coverage.index] / rebase_factor
+        except ZeroDivisionError:
+            exposure_with_cvi_normalized = exposure_with_cvi
+
+        self.intermediary_logs.append(
+            Log(
+                series=exposure_with_cvi_normalized.rename("exposure_with_cvi_normalized"),
+                label="Exposure With CVI (Normalized)",
+            )
+        )
+
+        attribution_factor = exposure_with_cvi_normalized / evic_eur
+        self.intermediary_logs.append(
+            Log(series=attribution_factor.rename("attribution_factor"), label="Attribution Factor", is_percent=True)
+        )
+
+        return (self.esg_data * attribution_factor).dropna()
+
+    def _get_investor_allocation_per_million(self, exposure: pd.Series) -> pd.Series:
+        self.intermediary_logs.append(Log(series=exposure.rename("exposure"), label="Exposure"))
+
+        evic_eur = self.enterprise_value_included_cash
+        cvi_factor = self.current_value_investment_factor
+
+        exposure_with_cvi = exposure * cvi_factor
+        self.intermediary_logs.append(
+            Log(series=exposure_with_cvi.rename("exposure_with_cvi"), label="Exposure With CVI")
+        )
+        try:
+            rebase_factor = exposure_with_cvi.loc[self.weights_in_coverage.index].sum() / exposure_with_cvi.sum()
+            exposure_with_cvi_normalized = exposure_with_cvi.loc[self.weights_in_coverage.index] / rebase_factor
+        except ZeroDivisionError:
+            exposure_with_cvi_normalized = exposure_with_cvi
+
+        self.intermediary_logs.append(
+            Log(
+                series=exposure_with_cvi_normalized.rename("exposure_with_cvi_normalized"),
+                label="Exposure With CVI (Normalized)",
+            )
+        )
+
+        weights_normalized = exposure_with_cvi_normalized / exposure_with_cvi_normalized.sum()
+        self.intermediary_logs.append(
+            Log(
+                series=weights_normalized.rename("weights_normalized"),
+                label="Weight based on CVI",
+                is_percent=True,
+                precision=2,
+            )
+        )
+        cvi_based_exposure_per_million = weights_normalized * 1e6
+        self.intermediary_logs.append(
+            Log(
+                series=cvi_based_exposure_per_million.rename("cvi_based_exposure_per_million"),
+                label="CVI-based exposure for EUR 1mn",
+            )
+        )
+
+        attribution_factor = cvi_based_exposure_per_million / evic_eur
+        self.intermediary_logs.append(
+            Log(series=attribution_factor.rename("attribution_factor"), label="Attribution Factor", is_percent=True)
+        )
+
+        return (self.esg_data * attribution_factor).dropna()
+
+    def compute(self, esg_aggregation: ESGAggregation):
+        aggregation_method = esg_aggregation.get_aggregation()
+        if aggregation_method == AggregationMethod.PERCENTAGE_SUM:
+            # we need to apply a mask
+            if esg_aggregation in [ESGAggregation.LACK_OF_PROCESS_AND_COMPLIANCE_OF_UN_PRINCIPLES]:
+                mask = "No Evidence"
+            else:
+                mask = "Yes"
+
+            return self._get_percentage_sum(mask)
+        if aggregation_method == AggregationMethod.WEIGHTED_AVG_NORMALIZED:
+            return self._get_weighted_avg_normalized()
+        if aggregation_method == AggregationMethod.WEIGHTED_AVG_CATEGORY_NORMALIZED:
+            return self._get_weighted_avg_normalized_per_category()
+        if aggregation_method == AggregationMethod.INVESTOR_ALLOCATION:
+            return self._get_investor_allocation(self.total_value_fx_usd)
+        if aggregation_method == AggregationMethod.INVESTOR_ALLOCATION_PER_MILLION:
+            return self._get_investor_allocation_per_million(self.weights * 1000000)
+        else:
+            raise ValueError("Aggregation Method not supported")

wbfdm/analysis/esg/utils.py

@@ -0,0 +1,13 @@
+import pandas as pd
+from wbfdm.enums import ESG
+from wbfdm.models.instruments.instruments import InstrumentQuerySet
+
+
+def get_esg_df(instruments: InstrumentQuerySet, esg: ESG, **kwargs) -> pd.Series:
+    df = pd.DataFrame(instruments.dl.esg(values=[esg]))
+    if not df.empty:
+        return df.pivot_table(
+            index="instrument_id", values="value", columns="factor_code", aggfunc="first", dropna=False
+        )[esg.value]
+    else:
+        return pd.Series(dtype="float64")

wbfdm/analysis/financial_analysis/__init__.py

@@ -0,0 +1 @@
+from .financial_statistics_analysis import FinancialStatistics

wbfdm/analysis/financial_analysis/financial_metric_analysis.py

@@ -0,0 +1,88 @@
+from datetime import date
+
+import pandas as pd
+from wbfdm.enums import Financial, PeriodType, SeriesType
+from wbfdm.models import Instrument
+from wbfdm.utils import rename_period_index_level_to_repr
+
+
+def financial_metric_estimate_analysis(instrument_id: int, financial: Financial) -> tuple[pd.DataFrame, dict, list]:
+    estimate_mapping = {}
+    columns = []
+    if not (
+        df := pd.DataFrame(
+            Instrument.objects.filter(id=instrument_id).dl.financials(
+                values=[financial],
+                series_type=SeriesType.FULL_ESTIMATE,
+                period_type=PeriodType.ALL,
+                from_year=date.today().year - 5,
+            ),
+        )
+    ).empty:
+        df = df.pivot_table(
+            index=["year", "interim", "period_type", "estimate"],
+            columns=["financial"],
+            values=["value", "difference_pct", "value_high", "value_low", "value_amount", "value_stdev"],
+            dropna=False,
+        )
+        df["difference_pct"] = df["difference_pct"] * 100
+        df = rename_period_index_level_to_repr(df)
+        df = df.set_index([[f"{index[0]}-{index[1]}" for index in df.index]])
+
+        columns = list(df.index)
+
+        df = df[["value", "difference_pct", "value_high", "value_low", "value_stdev", "value_amount"]]
+        df = df.rename(
+            columns={
+                "difference_pct": "Diff (%)",
+                "value": "Estimate",
+                "value_amount": "#",
+                "value_high": "High Est.",
+                "value_low": "Low Est.",
+                "value_stdev": "St.Dev. Est.",
+            }
+        )
+        df = df.T
+
+        df["financial"] = [index[0] for index in df.index]
+        df = df.set_index([[f"{index[0]}-{index[1]}" for index in df.index]])
+        df = df.reset_index()
+
+    return df, estimate_mapping, columns
+
+
+def financial_metric_growths(instrument_id: int, financial: Financial):
+    # Get the base dataframe from a dataloader with the given financial
+    if not (
+        df := pd.DataFrame(
+            Instrument.objects.filter(id=instrument_id).dl.financials(
+                values=[financial],
+                series_type=SeriesType.COMPLETE,
+                period_type=PeriodType.ALL,
+                from_year=date.today().year - 5,
+            )
+        )
+    ).empty:
+        # Pivot the dataframe to get the financial in the correct format
+        df = df.pivot_table(index=["year", "interim", "period_type"], columns="financial", values="value")
+
+        # Compute the growth factors
+        df[f"{financial.value}_qq"] = df.loc[df.index.get_level_values("interim") != 0].pct_change() * 100
+        df[f"{financial.value}_yy_y"] = (
+            df.loc[df.index.get_level_values("interim") == 0, financial.value].pct_change() * 100
+        )
+        df[f"{financial.value}_yy_q"] = (
+            df.loc[df.index.get_level_values("interim") != 0, financial.value].pct_change(4) * 100
+        )
+        df[f"{financial.value}_yy"] = df[f"{financial.value}_yy_y"].combine_first(df[f"{financial.value}_yy_q"])
+
+        # Select on the two growth columns
+        df = df[[f"{financial.value}_yy", f"{financial.value}_qq"]]
+
+        df = rename_period_index_level_to_repr(df)
+        df = df.set_index([[f"{index[0]}-{index[1]}" for index in df.index]])
+        df = df.rename(columns={f"{financial.value}_yy": "YoY Growth (%)", f"{financial.value}_qq": "QoQ Growth (%)"})
+        df = df.T
+        df = df.reset_index().reset_index()
+
+    return df

wbfdm/analysis/financial_analysis/financial_ratio_analysis.py

@@ -0,0 +1,125 @@
+from contextlib import suppress
+from datetime import date
+
+import pandas as pd
+from django.db.models import TextChoices
+from wbfdm.enums import Financial, MarketData, PeriodType
+from wbfdm.models import Instrument
+
+
+class FinancialRatio(TextChoices):
+    PE = "pe", "P/E"
+    PS = "ps", "P/S"
+    PB = "pb", "P/B"
+    PFCF = "pfcf", "P/FCF"
+
+    @classmethod
+    def get_financials_for_ratio(cls, ratio: "FinancialRatio") -> list[Financial]:
+        financials = {
+            cls.PE: [Financial.EPS],
+            cls.PS: [Financial.REVENUE, Financial.SHARES_OUTSTANDING],
+            cls.PB: [Financial.TANGIBLE_BOOK_VALUE_PER_SHARE],
+            cls.PFCF: [Financial.CASH_FLOW_FROM_OPERATIONS, Financial.CAPEX],
+        }
+
+        return financials[ratio]
+
+    @classmethod
+    def get_financials(cls, ratios: list["FinancialRatio"]) -> list[Financial]:
+        financials = list()
+        for ratio in ratios:
+            financials.extend(cls.get_financials_for_ratio(ratio))
+        return list(set(financials))
+
+    def compute_pe(self, df: pd.DataFrame) -> pd.DataFrame:
+        if Financial.EPS.value in df:
+            df[self.value] = df["close"] / df[Financial.EPS.value]
+        return df
+
+    def compute_ps(self, df: pd.DataFrame) -> pd.DataFrame:
+        if "revenue_per_share" in df:
+            df[self.value] = df["close"] / df["revenue_per_share"]
+        return df
+
+    def compute_pb(self, df: pd.DataFrame) -> pd.DataFrame:
+        if Financial.TANGIBLE_BOOK_VALUE_PER_SHARE.value in df:
+            df[self.value] = df["close"] / df[Financial.TANGIBLE_BOOK_VALUE_PER_SHARE.value]
+        return df
+
+    def compute_pfcf(self, df: pd.DataFrame) -> pd.DataFrame:
+        if Financial.FREE_CASH_FLOW_PER_SHARE.value in df:
+            df[self.value] = df["close"] / df[Financial.FREE_CASH_FLOW_PER_SHARE.value]
+        return df
+
+    def compute(self, df: pd.DataFrame) -> pd.DataFrame:
+        compute_methods = {
+            self.PE: self.compute_pe,
+            self.PS: self.compute_ps,
+            self.PB: self.compute_pb,
+            self.PFCF: self.compute_pfcf,
+        }
+        return compute_methods[self](df)
+
+
+def get_financial_ratios(
+    instrument_id: int, ratios: list[FinancialRatio], from_date: date, to_date: date, ttm: bool = True
+):
+    """Computes financial ratios and adds them to the dataframe"""
+    if ttm:
+        financials_df = pd.DataFrame(
+            Instrument.objects.filter(id=instrument_id).dl.statements(
+                financials=FinancialRatio.get_financials(ratios),
+                period_type=PeriodType.INTERIM,
+            )
+        )
+    else:
+        financials_df = pd.DataFrame(
+            Instrument.objects.filter(id=instrument_id).dl.financials(
+                values=FinancialRatio.get_financials(ratios),
+                period_type=PeriodType.INTERIM,
+            )
+        )
+    if financials_df.empty:
+        return pd.DataFrame()
+    financials_df = financials_df.pivot_table(
+        index="period_end_date",
+        columns="financial",
+        values="value",
+    ).sort_index()
+    financials_df.index = pd.to_datetime(financials_df.index)
+    if (
+        FinancialRatio.PS in ratios
+        and Financial.REVENUE.value in financials_df
+        and Financial.SHARES_OUTSTANDING.value in financials_df
+    ):
+        financials_df["revenue_per_share"] = (
+            financials_df[Financial.REVENUE.value] / financials_df[Financial.SHARES_OUTSTANDING.value]
+        )
+    if (
+        FinancialRatio.PFCF in ratios
+        and Financial.FREE_CASH_FLOW_PER_SHARE.value not in financials_df.columns
+        and Financial.CASH_FLOW_FROM_OPERATIONS.value in financials_df
+        and Financial.CAPEX.value in financials_df
+    ):
+        financials_df[Financial.FREE_CASH_FLOW_PER_SHARE.value] = (
+            financials_df[Financial.CASH_FLOW_FROM_OPERATIONS.value] - financials_df[Financial.CAPEX.value]
+        )
+    financials_df = financials_df.rolling("365d").sum()
+    prices_df = pd.DataFrame(
+        Instrument.objects.filter(id=instrument_id).dl.market_data(
+            values=[MarketData.CLOSE], from_date=from_date, to_date=to_date
+        )
+    )
+    if not prices_df.empty:
+        prices_df = prices_df.set_index("valuation_date").sort_index()[["close"]]
+        prices_df.index = pd.to_datetime(prices_df.index)
+
+        financials_df = pd.merge_asof(
+            prices_df, financials_df, left_index=True, right_index=True, direction="backward" if ttm else "forward"
+        )
+
+    for ratio in ratios:
+        with suppress(KeyError):
+            financials_df = ratio.compute(financials_df)
+
+    return financials_df