wbfdm 1.43.1__py2.py3-none-any.whl

wbfdm/viewsets/configs/titles/financials_analysis.py

@@ -0,0 +1,50 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+from wbfdm.models import Instrument
+
+
+class SummaryTableInstrumentChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Financial Summary Table"
+
+
+class FinancialsGraphInstrumentChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Financials Graph Chart"
+
+
+class ProfitabilityRatiosInstrumentChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Profitability Ratios Chart"
+
+
+class CashFlowAnalysisInstrumentTableChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Cash Flow Analysis Table"
+
+
+class CashFlowAnalysisInstrumentBarChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Cash Flow Analysis Bar Chart"
+
+
+class NetDebtAndEbitdaInstrumentChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Net debt and EBITDA Chart"
+
+
+class EarningsInstrumentChartTitle(TitleViewConfig):
+    def get_list_title(self) -> str:
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{instrument.name_repr} - Earnings Analysis Chart"
+
+
+class FinancialAnalysisGeneratorTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"Ratios for {str(instrument)}"

wbfdm/viewsets/configs/titles/instrument_prices.py

@@ -0,0 +1,50 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+from wbfdm.models import Instrument
+
+
+class InstrumentPriceTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Instrument Prices"
+
+    def get_instance_title(self):
+        return "Price: {{_instrument.name}} {{date}}"
+
+    def get_create_title(self):
+        return "New Price"
+
+
+class InstrumentPriceInstrumentTitleConfig(InstrumentPriceTitleConfig):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Prices"
+
+
+class InstrumentPriceStatisticsInstrumentTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Statistics Chart"
+
+
+class MonthlyPerformancesInstrumentTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Monthly Returns Table"
+
+
+class InstrumentTitleConfigMixin(TitleViewConfig):
+    def get_list_title(self):
+        assert self.message, "No message has been set"
+        instrument = Instrument.objects.get(id=self.view.kwargs["instrument_id"])
+        return f"{self.message} {str(instrument)}"
+
+
+class FinancialStatisticsInstrumentTitleConfig(InstrumentTitleConfigMixin):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Financial Statistics Chart"
+
+
+class InstrumentPriceInstrumentDistributionReturnsChartTitleConfig(InstrumentTitleConfigMixin):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Distribution Returns Chart"
+
+
+class BestAndWorstReturnsInstrumentTitleConfig(InstrumentTitleConfigMixin):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - Best and Worst returns Table "

wbfdm/viewsets/configs/titles/instrument_requests.py

@@ -0,0 +1,16 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class InstrumentRequestTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Instrument Requests"
+
+    def get_instance_title(self):
+        try:
+            obj = self.view.get_object()
+            return f"Instrument Request: {str(obj)}"
+        except AssertionError:
+            return "Instrument Request: {{status}}"
+
+    def get_create_title(self):
+        return "New Instrument Request"

wbfdm/viewsets/configs/titles/instruments.py

@@ -0,0 +1,31 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class InstrumentTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Instruments"
+
+    def get_instance_title(self):
+        try:
+            obj = self.view.get_object()
+            instrument_type = obj.instrument_type.name if obj.instrument_type else "Instrument"
+            return f"{instrument_type}: {str(obj)}"
+        except AssertionError:
+            return "Instrument: {{name}}"
+
+    def get_create_title(self):
+        return "New Instrument"
+
+
+class SubviewInstrumentTitleViewConfig(TitleViewConfig):
+    def get_list_title(self):
+        return f"{str(self.view.instrument)} - {self.view.SUBVIEW_NAME} "
+
+    def get_delete_title(self) -> str:
+        return None
+
+    def get_instance_title(self) -> str:
+        return None
+
+    def get_create_title(self) -> str:
+        return None

wbfdm/viewsets/configs/titles/instruments_relationships.py

@@ -0,0 +1,21 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class InstrumentFavoriteGroupTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return "Instrument Favorite Groups"
+
+    def get_instance_title(self):
+        try:
+            obj = self.view.get_object()
+            return f"Favorite Group: {str(obj)}"
+        except AssertionError:
+            return "Instrument: {{name}}"
+
+    def get_create_title(self):
+        return "New Favorite Group"
+
+
+class ClassifiedInstrumentTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return "Classified Instruments"

wbfdm/viewsets/configs/titles/market_data.py

@@ -0,0 +1,13 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+from wbfdm.enums import MarketDataChartType
+
+
+class PerformanceSummaryChartTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return f"{self.view.instrument} - Performance Summary"
+
+
+class MarketDataChartTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        market_data_chart_type = MarketDataChartType(self.request.GET.get("chart_type", "close"))
+        return f"{self.view.instrument} - {market_data_chart_type.label} Chart"

wbfdm/viewsets/configs/titles/prices.py

@@ -0,0 +1,15 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class InstrumentPriceTitleViewConfig(TitleViewConfig):
+    def get_list_title(self):
+        return f"{self.view.instrument} - Prices"
+
+    def get_delete_title(self) -> str:
+        return None
+
+    # def get_instance_title(self) -> str:
+    #     return None
+
+    def get_create_title(self) -> str:
+        return None

wbfdm/viewsets/configs/titles/statement_with_estimates.py

@@ -0,0 +1,10 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class StatementTitleViewConfig(TitleViewConfig):
+    def get_list_title(self):
+        try:
+            statement_label = self.view.financial_analysis_mapping[self.view.kwargs["statement"]][1]
+            return f"{self.view.instrument} - {statement_label} Table"
+        except KeyError:
+            return f"{self.view.instrument} - Statement"

wbfdm/viewsets/esg.py

@@ -0,0 +1,72 @@
+import pandas as pd
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbfdm.enums import ESG
+from wbfdm.models.instruments import Instrument
+from wbfdm.serializers import InstrumentControversySerializer
+from wbfdm.viewsets.configs import (
+    InstrumentESGControversiesEndpointViewConfig,
+    InstrumentESGControversiesTitleViewConfig,
+    InstrumentESGControversyDisplayViewConfig,
+    InstrumentESGPAIDisplayViewConfig,
+    InstrumentESGPAIEndpointViewConfig,
+    InstrumentESGPAITitleViewConfig,
+)
+
+from .mixins import InstrumentMixin
+
+
+class InstrumentESGControversiesViewSet(InstrumentMixin, viewsets.ViewSet):
+    IDENTIFIER = "wbfdm:instrument-controversy"
+    display_config_class = InstrumentESGControversyDisplayViewConfig
+    title_config_class = InstrumentESGControversiesTitleViewConfig
+    endpoint_config_class = InstrumentESGControversiesEndpointViewConfig
+    serializer_class = InstrumentControversySerializer
+    queryset = Instrument.objects.none()
+    permission_classes = []
+
+    def list(self, request, instrument_id):
+        queryset = self.get_queryset()
+        serializer = self.get_serializer_class()
+        serializer = serializer(queryset, many=True)
+        return Response({"results": serializer.data})
+
+    def get_queryset(self):
+        return sorted(
+            Instrument.objects.filter(id=self.instrument.id).dl.esg_controversies(),
+            key=lambda x: (x["review"] is None, x["review"]),
+            reverse=True,
+        )
+
+
+class InstrumentESGPAIViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    queryset = Instrument.objects.none()
+    display_config_class = InstrumentESGPAIDisplayViewConfig
+    endpoint_config_class = InstrumentESGPAIEndpointViewConfig
+    title_config_class = InstrumentESGPAITitleViewConfig
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_pandas_fields(self, request):
+        return pf.PandasFields(
+            fields=[
+                pf.PKField(key="index", label="ID"),
+                pf.IntegerField(key="section", label="Section"),
+                pf.TextField(key="asi", label="Adverse sustainability indicator"),
+                pf.TextField(key="metric", label="Metric"),
+                pf.TextField(key="factor", label="Factor"),
+                pf.FloatField(key="value", label="Value"),
+            ]
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        df = pd.DataFrame(queryset.dl.esg(values=list(ESG))).reset_index()
+        if not df.empty:
+            ESG_mapping = ESG.mapping()
+            df[["section", "asi", "metric", "factor"]] = pd.DataFrame(
+                df.factor_code.map(ESG_mapping).tolist(), index=df.index
+            )
+        return df

wbfdm/viewsets/exchanges.py

@@ -0,0 +1,63 @@
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbfdm.filters import ExchangeFilterSet
+from wbfdm.models import Exchange
+from wbfdm.serializers import ExchangeModelSerializer, ExchangeRepresentationSerializer
+
+from .configs import (
+    ExchangeButtonConfig,
+    ExchangeDisplayConfig,
+    ExchangeEndpointConfig,
+    ExchangeTitleConfig,
+)
+
+
+class ExchangeRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    queryset = Exchange.objects.all()
+    serializer_class = ExchangeRepresentationSerializer
+
+    search_fields = (
+        "name",
+        "mic_code",
+        "operating_mic_code",
+        "bbg_exchange_codes",
+        "bbg_composite_primary",
+        "bbg_composite",
+        "refinitiv_mnemonic",
+        "refinitiv_identifier_code",
+        "city__name",
+        "website",
+        "comments",
+    )
+    ordering_fields = search_fields
+    ordering = ["name"]
+
+
+class ExchangeModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
+    filterset_class = ExchangeFilterSet
+    serializer_class = ExchangeModelSerializer
+    queryset = Exchange.objects.select_related(
+        "country",
+        "city",
+    )
+
+    search_fields = (
+        "name",
+        "mic_code",
+        "operating_mic_code",
+        "bbg_exchange_codes",
+        "bbg_composite_primary",
+        "refinitiv_mnemonic",
+        "bbg_composite",
+        "refinitiv_identifier_code",
+        "city__name",
+        "website",
+        "comments",
+    )
+    ordering_fields = search_fields
+    ordering = ["name"]
+
+    display_config_class = ExchangeDisplayConfig
+    button_config_class = ExchangeButtonConfig
+    title_config_class = ExchangeTitleConfig
+    endpoint_config_class = ExchangeEndpointConfig

wbfdm/viewsets/financial_analysis/__init__.py

@@ -0,0 +1,3 @@
+from .statement_with_estimates import StatementWithEstimatesPandasViewSet
+from .financial_metric_analysis import FinancialMetricAnalysisPandasViewSet
+from .financial_ratio_analysis import ValuationRatioChartViewSet

wbfdm/viewsets/financial_analysis/financial_metric_analysis.py

@@ -0,0 +1,85 @@
+import pandas as pd
+from django.utils.functional import cached_property
+from rest_framework.exceptions import ParseError
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.pandas.utils import override_number_to_percent
+from wbcore.serializers.fields.types import DisplayMode
+from wbfdm.analysis.financial_analysis.financial_metric_analysis import (
+    financial_metric_estimate_analysis,
+    financial_metric_growths,
+)
+from wbfdm.enums import Financial
+from wbfdm.filters import GroupKeyFinancialsFilterSet
+from wbfdm.models.instruments import Instrument
+from wbfdm.viewsets.configs.display.statement_with_estimates import (
+    StatementWithEstimatesDisplayViewConfig,
+)
+from wbfdm.viewsets.configs.endpoints.statements import StatementsEndpointViewConfig
+from wbfdm.viewsets.configs.titles.statement_with_estimates import (
+    StatementTitleViewConfig,
+)
+
+from ..mixins import InstrumentMixin
+
+
+class FinancialMetricAnalysisPandasViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    queryset = Instrument.objects.none()
+    display_config_class = StatementWithEstimatesDisplayViewConfig
+    endpoint_config_class = StatementsEndpointViewConfig
+    title_config_class = StatementTitleViewConfig
+    filterset_class = GroupKeyFinancialsFilterSet
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_pandas_fields(self, request):
+        return pf.PandasFields(
+            fields=[
+                *[pf.FloatField(key=field, label=field, display_mode=DisplayMode.SHORTENED) for field in self.columns],
+                pf.PKField(key="id", label="ID"),
+                pf.CharField(key="financial", label="Financial"),
+                pf.JsonField(key="_overwrites", label="Overwrites"),
+            ]
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        if group_keys := request.GET.get("group_keys"):
+            try:
+                financial = Financial(group_keys.lower())
+            except ValueError:
+                raise ParseError()
+            df, self._estimate_mapping, self._columns = financial_metric_estimate_analysis(
+                queryset.first().id, financial
+            )
+            empty_row = pd.Series([None], dtype="float64", name="empty_row")
+            df_growth = financial_metric_growths(queryset.first().id, financial)
+
+            df = pd.concat([df_growth, df, empty_row]).dropna(how="all")
+            if "financial" in df.columns:
+                override_number_to_percent(df, df["financial"].str.contains("(%)"))
+
+            df = df.rename(columns={"index": "id"})
+            return df
+
+        return pd.DataFrame()
+
+    @cached_property
+    def columns(self):
+        if not hasattr(self, "_columns"):
+            self.get_dataframe(self.request, self.get_queryset())
+        return self._columns
+
+    @property
+    def year_columns(self):
+        yield from filter(lambda col: "Y" in col, self.columns)
+
+    @property
+    def interim_columns(self):
+        yield from filter(lambda col: "Y" not in col, self.columns)
+
+    @cached_property
+    def estimate_mapping(self):
+        if not hasattr(self, "_estimate_mapping"):
+            self.get_dataframe(self.request, self.get_queryset())
+        return self._estimate_mapping

wbfdm/viewsets/financial_analysis/financial_ratio_analysis.py

@@ -0,0 +1,85 @@
+from contextlib import suppress
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from wbcore import viewsets
+from wbcore.utils.date import get_date_interval_from_request
+from wbfdm.analysis.financial_analysis.financial_ratio_analysis import (
+    FinancialRatio,
+    get_financial_ratios,
+)
+from wbfdm.filters import FinancialRatioFilterSet
+from wbfdm.models.instruments import Instrument
+
+from ..configs import ValuationRatioChartTitleConfig
+from ..mixins import InstrumentMixin
+
+
+class ValuationRatioChartViewSet(InstrumentMixin, viewsets.ChartViewSet):
+    queryset = Instrument.objects.all()
+    filterset_class = FinancialRatioFilterSet
+    title_config_class = ValuationRatioChartTitleConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(id=self.instrument.id)
+
+    def get_plotly(self, queryset):
+        pd.options.plotting.backend = "plotly"
+
+        ratios = [FinancialRatio.PE, FinancialRatio.PS, FinancialRatio.PB, FinancialRatio.PFCF]
+        ttm = False if self.request.GET.get("ttm", "true") == "false" else True
+        start, end = get_date_interval_from_request(self.request, date_range_fieldname="period")
+
+        df = get_financial_ratios(
+            self.instrument.id,
+            ratios,
+            from_date=start,
+            to_date=end,
+            ttm=ttm,
+        )
+        fig = go.Figure()
+        colors = iter(px.colors.qualitative.T10)
+
+        for ratio, color in zip(ratios, colors):
+            with suppress(AttributeError):
+                series = getattr(df, ratio.value)
+
+                fig.add_trace(
+                    go.Scatter(
+                        x=series.index,
+                        y=series,
+                        line=dict(color=color),
+                        name=f"{ratio.label} {'TTM' if ttm else 'FTM'}",
+                        legendgroup=f"{ratio.label} {'TTM' if ttm else 'FTM'}",
+                        visible="legendonly" if ratio != FinancialRatio.PE else True,
+                    ),
+                )
+
+        # fig = df.plot()
+        fig.update_layout(
+            template="plotly_white",
+            legend=dict(x=0.02, y=0.98, bgcolor="rgba(0,0,0,0)"),
+            margin=dict(l=0, r=0, t=0, b=0),
+            showlegend=True,
+        )
+
+        for i, d in enumerate(fig.data):
+            with suppress(AttributeError, IndexError, TypeError, OverflowError):
+                if (v := d.y[-1]) and not np.isnan(v):
+                    fig.add_scatter(
+                        x=[d.x[-1]],
+                        y=[v],
+                        name=d.name,
+                        mode="markers+text",
+                        text=round(v),
+                        textfont=dict(color=d.line.color),
+                        textposition="middle right",
+                        marker=dict(color=d.line.color, size=12, symbol="circle"),
+                        legendgroup=d.name,
+                        showlegend=False,
+                        visible="legendonly" if i != 0 else True,
+                    )
+
+        return fig

wbfdm/viewsets/financial_analysis/statement_with_estimates.py

@@ -0,0 +1,145 @@
+from contextlib import suppress
+
+import numpy as np
+from django.conf import settings
+from django.contrib.messages import warning
+from django.utils.functional import cached_property
+from wbcore.cache.decorators import cache_table
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.pandas import fields as pf
+from wbcore.serializers.fields.types import DisplayMode
+from wbcore.utils.date import get_next_day_timedelta
+from wbfdm.analysis.financial_analysis.statement_with_estimates import (
+    StatementWithEstimates,
+)
+from wbfdm.enums import CalendarType
+from wbfdm.filters import StatementWithEstimateFilter
+from wbfdm.models.instruments import Instrument
+from wbfdm.viewsets.configs.display.statement_with_estimates import (
+    StatementWithEstimatesDisplayViewConfig,
+)
+from wbfdm.viewsets.configs.endpoints.statements import StatementsEndpointViewConfig
+from wbfdm.viewsets.configs.titles.statement_with_estimates import (
+    StatementTitleViewConfig,
+)
+
+from ..mixins import InstrumentMixin
+
+
+@cache_table(
+    timeout=lambda view: get_next_day_timedelta(),
+    key_prefix=lambda view: f"_{view.instrument.id}_{view.financial_analysis_key}_{view.calendar_type}",
+)
+class StatementWithEstimatesPandasViewSet(InstrumentMixin, ExportPandasAPIViewSet):
+    queryset = Instrument.objects.none()
+    display_config_class = StatementWithEstimatesDisplayViewConfig
+    endpoint_config_class = StatementsEndpointViewConfig
+    title_config_class = StatementTitleViewConfig
+    filterset_class = StatementWithEstimateFilter
+
+    financial_analysis_mapping = {
+        "income": ("income_statement_with_estimate", "Income Statement"),
+        "balancesheet": ("balance_sheet_with_estimate", "Balance Sheet"),
+        "cashflow": ("cash_flow_statement_with_estimate", "Cash Flow Statement"),
+        "ratios": ("ratios_with_estimate", "Ratios"),
+        "summary": ("summary_with_estimate", "Summary"),
+        "margins": ("margins_with_estimates", "Margins"),
+        "cashflow-ratios": ("cashflow_ratios_with_estimates", "Cashflow Ratios"),
+        "asset-turnover-ratios": ("asset_turnover_with_estimates", "Asset-Turnover Ratios"),
+        "credit": ("credit_with_estimates", "Credit"),
+        "long-term-solvency": ("long_term_solvency_with_estimates", "Long-term Solvency"),
+        "short-term-liquidity": ("short_term_liquidity_with_estimates", "Short-term Liquidity"),
+    }
+
+    def get_queryset(self):
+        return Instrument.objects.filter(id=self.instrument.id)
+
+    def get_pandas_fields(self, request):
+        return pf.PandasFields(
+            fields=[
+                *[pf.FloatField(key=field, label=field, display_mode=DisplayMode.SHORTENED) for field in self.columns],
+                pf.PKField(key="id", label="ID"),
+                pf.CharField(key="financial", label="Financial"),
+                pf.CharField(key="_group_key", label="Group Key"),
+                pf.JsonField(key="_overwrites", label="Overwrites"),
+                pf.SparklineField(key="progress", label="Yearly Trend"),
+            ]
+        )
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        statement_with_estimate = StatementWithEstimates(self.instrument, calendar_type=self.calendar_type)
+        financial_analysis_result = getattr(
+            statement_with_estimate, self.financial_analysis_mapping[self.financial_analysis_key][0]
+        )
+        df = financial_analysis_result.formatted_df
+
+        year_columns = list(filter(lambda col: "Y" in col, df.columns))
+        if year_columns:
+            df["progress"] = df[year_columns].replace([np.inf, -np.inf, np.nan], None).apply(list, axis=1)
+
+        self.extra_cache_kwargs["_estimate_mapping"] = financial_analysis_result.estimated_mapping
+        self.extra_cache_kwargs["_columns"] = df.columns
+        self.extra_cache_kwargs["_errors"] = financial_analysis_result.errors
+
+        if financial_analysis_result.errors.get("duplicated_interims", []) and not settings.DEBUG:
+            with suppress(ModuleNotFoundError):
+                from sentry_sdk import capture_message
+
+                capture_message(
+                    f"Duplicate index detected for instrument {self.instrument} (id: {self.instrument.id})",
+                    level="error",
+                )
+        return df
+
+    def add_messages(self, request, instance=None, **kwargs):
+        if self.errors:
+            message = """
+            <p>While gathering the financial data, we detected the following issues from the data vendor:</p>
+            <ul>
+            """
+            if duplicated_interim := self.errors.get("duplicated_interim", []):
+                message += f"""
+                <li>Duplicated data for for interim period <strong>{', '.join(duplicated_interim)}</strong>
+                    <ul>
+                    <li>First available data was used and the rest was ignored
+                    </li>
+                    </ul>
+                </li>
+                """
+            if missing_data := self.errors.get("missing_data", []):
+                for error in missing_data:
+                    message += f"<li>{error}</li>"
+            message += "</ul>"
+            warning(request, message, extra_tags="auto_close=0")
+
+    # Cached attributes as properties
+    @cached_property
+    def calendar_type(self):
+        return CalendarType(self.request.GET.get("calendar_type", CalendarType.FISCAL.value))
+
+    @cached_property
+    def financial_analysis_key(self):
+        return self.kwargs.get("statement", "income")
+
+    @cached_property
+    def estimate_mapping(self):
+        return getattr(self, "_estimate_mapping", {})
+
+    @cached_property
+    def errors(self):
+        return getattr(self, "_errors", {})
+
+    @cached_property
+    def columns(self):
+        return self.df.columns
+
+    def get_ordering_fields(self):
+        return self.columns
+
+    @cached_property
+    def year_columns(self):
+        return list(filter(lambda col: "Y" in col, self.columns))
+
+    @cached_property
+    def interim_columns(self):
+        return list(filter(lambda col: "Y" not in col, self.columns))