neurostats-API 0.0.25rc1__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

neurostats_API/transformers/finance_overview/stats_overview.py

@@ -0,0 +1,64 @@
+from .base import BaseFinanceOverviewTransformer, FinanceOverviewProcessor
+from neurostats_API.utils import StatsProcessor
+
+
+class FinanceOverviewTransformer(BaseFinanceOverviewTransformer):
+
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+
+        self.target_fields = StatsProcessor.load_yaml(
+            "twse/finance_overview_dict.yaml"
+        )
+        self.inverse_dict = StatsProcessor.load_txt(
+            "twse/seasonal_data_field_dict.txt", json_load=True
+        )
+
+    def process_transform(self, balance_sheet, profit_lose, cash_flow):
+
+        processed_data_dict = self._filter_target_data(
+            balance_sheet, profit_lose, cash_flow
+        )
+        FinanceOverviewProcessor.process_rate(processed_data_dict) # 處理百分比
+        FinanceOverviewProcessor.process_all(processed_data_dict) # 計算所有指標公式
+        self._fill_nan_index(processed_data_dict) # 處理空值
+        FinanceOverviewProcessor.process_thousand_dollar(processed_data_dict) # 處理千元單位
+
+        return processed_data_dict
+
+    def _filter_target_data(self, balance_sheet, profit_lose, cash_flow):
+        data_dict = {
+            'balance_sheet': balance_sheet[-1]['balance_sheet'],
+            'profit_lose': profit_lose[-1]['profit_lose'],
+            "cash_flow": cash_flow[-1]['cash_flow']
+        }
+        filtered_dict = {}
+
+        for key, target_sets in self.target_fields.items():
+            try:
+                small_targets = target_sets['field']
+                value_index = target_sets['value']
+
+                for small_target in small_targets:
+                    big_target = self.inverse_dict[small_target]
+                    # 透過inverse_dict取得項目在balance_sheet/profit_lose/cash_flow
+
+                if (small_target == "利息費用_bank"):
+                    small_target = small_target[:small_target.find("_bank")]
+
+                seasonal_data = data_dict.get(big_target, {})    # 對應的列表
+
+                filtered_dict[key] = seasonal_data.get(small_target, {}).get(
+                    value_index, None
+                )    # 取對應的值
+
+            except Exception as e:
+                print(f"filter failed :{e}")
+                continue
+
+        return filtered_dict
+
+    def _fill_nan_index(self, finance_dict):
+        for key in self.target_fields.keys():
+            if (key not in finance_dict.keys()):
+                finance_dict[key] = None

neurostats_API/transformers/month_revenue/__init__.py

@@ -0,0 +1 @@
+from .twse import TWSEMonthlyRevenueTransformer

neurostats_API/transformers/month_revenue/base.py

@@ -0,0 +1,60 @@
+import abc
+from  ..base import BaseTransformer
+from neurostats_API.utils import StatsProcessor
+import pandas as pd
+
+class BaseMonthRevenueTransformer(BaseTransformer):
+    def __init__(self, ticker, company_name, zone):
+        self.ticker = ticker
+        self.company_name = company_name,
+        self.zone = zone
+
+        self.return_keys = []
+    
+    @abc.abstractmethod
+    def process_transform(self):
+        pass
+
+    @staticmethod
+    def _process_unit(data_df, postfix):
+
+        lambda_map = {
+            "revenue":  lambda x: StatsProcessor.cal_non_percentage(x, postfix="千元"),
+            "increment": lambda x : StatsProcessor.cal_non_percentage(x, postfix="千元"),
+            "ratio": lambda x : StatsProcessor.cal_non_percentage(x, to_str=True, postfix="%"),
+            'percentage': lambda x : StatsProcessor.cal_non_percentage(x, to_str=True, postfix="%"),
+            "YoY_1": StatsProcessor.cal_percentage,
+            "YoY_3": StatsProcessor.cal_percentage,
+            "YoY_5": StatsProcessor.cal_percentage,
+            "YoY_10": StatsProcessor.cal_percentage
+        }
+
+        process_fn = lambda_map.get(postfix)
+        postfix_cols = data_df.columns.str.endswith(postfix)
+        postfix_cols = data_df.loc[:, postfix_cols].columns
+
+        data_df[postfix_cols] = (
+            data_df[postfix_cols].map(
+               process_fn
+            )
+        )
+
+        return data_df
+    
+    def _apply_process_unit_pipeline(
+        self,
+        data_df,
+        postfix_list = ['revenue', 'increment']
+    ):
+        return super()._apply_process_unit_pipeline(
+            data_df,
+            postfix_list
+        )
+
+    def _process_data(self, fetched_data):
+        for data in fetched_data:
+            data.pop("ticker")
+            data.pop("company_name")
+            data.pop("memo")
+        
+        return pd.DataFrame(fetched_data)

neurostats_API/transformers/month_revenue/twse.py

@@ -0,0 +1,129 @@
+from .base import BaseMonthRevenueTransformer
+from neurostats_API.utils import StatsProcessor, YoY_Calculator
+import pandas as pd
+
+class TWSEMonthlyRevenueTransformer(BaseMonthRevenueTransformer):
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+
+        self.data_df = None
+    def process_transform(self, fetched_data):
+        self.data_df = self._process_data(fetched_data)
+        target_month = fetched_data[0]['month']
+
+        self._apply_process_unit_pipeline(
+            self.data_df,
+            postfix_list = [
+                'YoY_1',
+                'YoY_3',
+                "YoY_5",
+                "YoY_10",
+                "ratio",
+                "percentage",
+                "increment",
+                "revenue"
+            ]
+        )
+
+        target_month_df = self.data_df[self.data_df['month'] == target_month]
+        annual_month_df = self.data_df[self.data_df['month'] == 12]
+
+        month_revenue_df = self.data_df.pivot(
+            index='month', columns='year', values='revenue'
+        )
+        month_revenue_df = month_revenue_df.sort_index(ascending=False)
+
+        grand_total_df = target_month_df.pivot(
+            index='month', columns='year', values='grand_total'
+        )
+        grand_total_df.rename(
+            index={target_month: f"grand_total"}, inplace=True
+        )
+        month_revenue_df = pd.concat([grand_total_df, month_revenue_df], axis=0)
+
+        annual_total_df = annual_month_df.pivot(
+            index='month', columns='year', values='grand_total'
+        )
+
+        target_month_df = target_month_df.set_index("year").T
+
+        return_dict = {
+            "month_revenue": month_revenue_df[sorted(month_revenue_df.columns, reverse=True)],
+            "this_month_revenue_over_years": target_month_df.loc[[
+                "revenue", "revenue_increment_ratio", "YoY_1", "YoY_3", "YoY_5", "YoY_10"
+            ]],
+            "grand_total_over_years": target_month_df.loc[[
+                "grand_total", "grand_total_increment_ratio", "grand_total_YoY_1", "grand_total_YoY_3", "grand_total_YoY_5", "grand_total_YoY_10"
+            ]],
+            "recent_month_revenue": self._get_recent_growth(
+                fetched_data, 
+                grand_total_dict=annual_total_df.to_dict(), 
+                interval=12
+            )
+        }
+
+        return return_dict
+
+    def _get_recent_growth(self, monthly_data, grand_total_dict, interval=12):
+        last_month_data = monthly_data[1:interval + 1] + [{}] * max(0, interval - len(monthly_data) + 1)
+
+        MoMs = [
+            YoY_Calculator.cal_growth(this.get('revenue'), last.get('revenue'), delta = 1)
+            for this, last in zip(monthly_data[:interval], last_month_data[:interval])
+        ]
+
+        def safe_accum_yoy(data):
+            try:
+                year = data['year'] - 1
+                total = grand_total_dict[year][12]
+                grand_total = data.get('grand_total')
+                return f"{round(((grand_total - total) / total) * 100, 2)}%"
+            except Exception:
+                return None
+
+        recent_month_data = {
+            "date": [f"{d.get('year', 0)}/{d.get('month', 0)}" for d in monthly_data[:interval]],
+            "revenue": [d.get('revenue') for d in monthly_data[:interval]],
+            "MoM": [f"{(m * 100):.2f}%" if isinstance(m, float) else None for m in MoMs],
+            "YoY": [d.get('revenue_increment_ratio') for d in monthly_data[:interval]],
+            "total_YoY": [d.get('grand_total_increment_ratio') for d in monthly_data[:interval]],
+            # accum_YoY
+            # accum_YoY 為 Davis提出的定義
+            # 2024/6的累計YoY(accum_YoY) 為 2024累計到6月為止的總營收/2023年度總營收
+            "accum_YoY": [safe_accum_yoy(d) for d in monthly_data[:interval]]
+        }
+
+        df = pd.DataFrame(recent_month_data)
+        return df[df['date'] != "0/0"].set_index('date').T
+
+
+    def _get_empty_structure(self, target_year, target_month):
+        """
+        Exception 發生時回傳
+        """
+        recent_date = [f"{target_year}/{target_month}"]
+        for _ in range(11):
+            target_year, target_month = (target_year - 1, 12) if target_month == 1 else (target_year, target_month - 1)
+            recent_date.append(f"{target_year}/{target_month}")
+
+        def empty_df(index, columns):
+            return pd.DataFrame(index=index, columns=columns)
+
+        return {
+            "month_revenue": empty_df(
+                index=pd.Index(['grand_total', 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1], dtype='object', name='month'),
+                columns=pd.Index([f"{target_year - i}" for i in range(10)], dtype=object, name='year')
+            ),
+            "this_month_revenue_over_years": empty_df(
+                index=pd.Index(['revenue', 'revenue_increment_ratio', 'YoY_1', 'YoY_3', 'YoY_5', 'YoY_10'], dtype='object'),
+                columns=pd.Index([f"{target_year - i}" for i in range(10)], dtype='int64', name='year')
+            ),
+            "grand_total_over_years": empty_df(
+                index=pd.Index(['grand_total', 'grand_total_increment_ratio', 'grand_total_YoY_1', 'grand_total_YoY_3', 'grand_total_YoY_5', 'grand_total_YoY_10'], dtype='object'),
+                columns=pd.Index([f"{target_year - i}" for i in range(10)], dtype='int64', name='year')
+            ),
+            "recent_month_revenue": empty_df(
+                index=pd.Index(['revenue', 'MoM', 'YoY', 'total_YoY', 'accum_YoY'], dtype='object'),
+                columns=pd.Index([], dtype = 'object', name = 'date')
+            )
+        }

neurostats_API/transformers/profit_lose/__init__.py

@@ -0,0 +1,2 @@
+from .twse import TWSEProfitLoseTransformer
+from .us import USProfitLoseTransformer

neurostats_API/transformers/profit_lose/base.py

@@ -0,0 +1,82 @@
+from  ..base import BaseTransformer
+import pandas as pd
+
+class BaseProfitLoseTransformer(BaseTransformer):
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+
+    def _process_twse_to_stats_format(self, fetched_data):
+        table_dict = {}
+        for data in fetched_data:
+            year, season, profit_lose = data['year'], data['season'], data['profit_lose']
+
+            time_index = f"{year}Q{season}"
+            table_dict[time_index] = profit_lose
+
+        stats_df = pd.DataFrame(table_dict)
+
+        return stats_df
+    
+    def _process_twse_to_tej_format(self, fetched_data):
+        """
+        new_df 迎合 TEJ格式, 用於 report_generator
+        """
+        if (isinstance(fetched_data, list)):
+            table_dict = {}
+            for data in fetched_data:
+                year, season, profit_lose = data['year'], data['season'], data['profit_lose']
+                time_index = f"{year}Q{season}"
+
+                new_profit_lose = self.flatten_dict(
+                    profit_lose,
+                    target_keys=[
+                        "value", "growth", 
+                        "percentage", "grand_total_percentage"
+                    ] + [f"YoY_{i}" for i in [1, 3, 5, 10]]
+                    + [f"grand_total_YoY_{i}" for i in [1, 3, 5, 10]]
+                )
+
+                table_dict[time_index] = new_profit_lose
+            
+            stats_df = pd.DataFrame.from_dict(table_dict)
+            return stats_df.T
+        
+        elif (isinstance(fetched_data, dict)):
+            for time_index, profit_lose in fetched_data.items():
+                fetched_data[time_index] = self.flatten_dict(
+                    value_dict=profit_lose,
+                    target_keys=[
+                        "value", "growth", "percentage", "grand_total",
+                        "grand_total_percentage"
+                    ] + [f"YoY_{i}" for i in [1, 3, 5, 10]] +
+                    [f"grand_total_YoY_{i}" for i in [1, 3, 5, 10]]
+                )
+
+            stats_df = pd.DataFrame.from_dict(fetched_data)
+            return stats_df.T
+        
+    def _process_us_format(self, fetched_data):
+        """
+        主要用於report generator
+        """
+        if (isinstance(fetched_data, list)):
+            table_dict = {}
+            for data in fetched_data:
+                year, season, income_statement = data['year'], data['season'], data['income_statement']
+                time_index = f"{year}Q{season}"
+
+                table_dict[time_index] = income_statement
+            
+            stats_df = pd.DataFrame.from_dict(table_dict)
+            return stats_df.T
+
+        elif (isinstance(fetched_data, dict)):
+            for time_index, income_statement in fetched_data.items():
+                fetched_data[time_index] = self.flatten_dict(
+                    value_dict=income_statement,
+                    target_keys=["value", "growth"] +
+                    [f"YoY_{i}" for i in [1, 3, 5, 10]]
+                )
+            stats_df = pd.DataFrame.from_dict(fetched_data)
+            return stats_df.T
+

neurostats_API/transformers/profit_lose/twse.py

@@ -0,0 +1,133 @@
+from .base import BaseProfitLoseTransformer
+from neurostats_API.utils import StatsProcessor, YoY_Calculator
+import pandas as pd
+
+
+class TWSEProfitLoseTransformer(BaseProfitLoseTransformer):
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+
+        # 載入欄位切片設定檔（定義哪些欄位要顯示在報表上）
+        self.table_settings = StatsProcessor.load_yaml("twse/profit_lose.yaml")
+
+        # 設定最後回傳的所有欄位 key，包含主頁面、總覽、成長率、比率等
+        self.return_keys = [
+            'profit_lose', 'grand_total_profit_lose', 'revenue', 'grand_total_revenue', 
+            'gross_profit', 'grand_total_gross_profit', 'gross_profit_percentage', 
+            'grand_total_gross_profit_percentage', 'operating_income', 'grand_total_operating_income', 'operating_income_percentage', 
+            'grand_total_operating_income_percentage', 'net_income_before_tax', 'grand_total_net_income_before_tax', 'net_income_before_tax_percentage', 
+            'grand_total_net_income_before_tax_percentage', 'net_income', 'grand_total_net_income', 'net_income_percentage', 
+            'grand_total_income_percentage', 'EPS', 'EPS_growth', 'grand_total_EPS', 
+            'grand_total_EPS_growth', 'profit_lose_all', 'profit_lose_YoY'
+        ]
+
+        self.stats_df = None  # 主頁面統計用 DataFrame
+        self.new_df = None    # 完整表格用 DataFrame（包含 TEJ 格式）
+    
+    def process_transform(self, fetched_data):
+        if (not fetched_data):
+            return self._get_empty_structure()  # 若查無資料，回傳空表結構
+
+        processed_data = self._process_fn(fetched_data)
+
+        return processed_data
+
+
+    def _process_fn(self, fetched_data):
+        return_dict = {
+            "ticker": self.ticker,
+            "company_name": self.company_name,
+        }
+
+        target_season = fetched_data[-1]['season']  # 用來選擇同一季的欄位當作 YoY 主體
+
+        # 轉換原始 JSON -> dict 格式（key: Q1 ~ Q4）
+        stats_dict = self._process_twse_to_stats_format(fetched_data).to_dict()
+
+        # 計算 QoQ 與 YoY 成長率欄位
+        stats_dict = YoY_Calculator.cal_QoQ(stats_dict)
+
+        # 建立主頁面 DataFrame 並擴充 _value / _percentage 欄位
+        self.stats_df = pd.DataFrame.from_dict(stats_dict)
+        self.stats_df = self._slice_target_season(self.stats_df, target_season)
+        self.stats_df = StatsProcessor.expand_value_percentage(self.stats_df)
+
+        # 處理各種單位轉換欄位
+        self.stats_df = self._apply_process_unit_pipeline(
+            self.stats_df,
+            postfix_list=[
+                '_value',
+                '_percentage',
+                '_growth',
+                "_YoY_1",
+                "_YoY_3",
+                "_YoY_5",
+                "_YoY_10",
+            ]
+        )
+
+        # 篩選主頁面欄位（排除 grand_total 欄）
+        grand_total_value_col = self.stats_df.columns.str.endswith("grand_total_value")
+        grand_total_percentage_col = self.stats_df.columns.str.endswith("grand_total_percentage")
+        self.stats_df = self.stats_df.loc[
+            :,
+            (~grand_total_value_col) & (~grand_total_percentage_col) 
+        ]
+
+        
+        stats_main_page_df = StatsProcessor.slice_table(
+            self.stats_df,
+            mode = 'value_and_percentage',
+        )
+        stats_grand_total_df = StatsProcessor.slice_table(
+            self.stats_df,
+            mode = 'grand_total_values'
+        )
+
+        # 建立完整表格 new_df，轉為 TEJ 標準格式並做單位處理
+        self.new_df = self._process_twse_to_tej_format(stats_dict)
+        self.new_df = self._apply_process_unit_pipeline(
+            self.new_df,
+            postfix_list=[
+                '_value',
+                '_percentage',
+                '_growth',
+                "_YoY_1",
+                "_YoY_3",
+                "_YoY_5",
+                "_YoY_10",
+            ]
+        )
+        # 建立 YoY 子表格（以 transposed 的方式）
+        new_df_YoY = self._slice_target_season(self.new_df.T, target_season)
+
+        # 回填主欄位資訊至結果 dict
+        return_dict.update({
+            "profit_lose": stats_main_page_df,
+            "grand_total_profit_lose": stats_grand_total_df,
+            "profit_lose_all": self.new_df.T,
+            "profit_lose_YoY": new_df_YoY
+        })
+
+        # 根據設定檔切出其他欄位（如營收、毛利率等）
+        self._process_target_columns(
+            return_dict,
+            new_df_YoY.T,
+        )
+
+        return return_dict
+
+    def _process_target_columns(self, return_dict ,data_df):
+        for name, setting in self.table_settings.items():
+            target_indexes = setting.get('target_index', [None])
+            for target_index in target_indexes:
+                try:
+                    # 使用設定檔定義的 mode + index，切出對應欄位表格
+                    return_dict[name] = StatsProcessor.slice_table(
+                        total_table=data_df,
+                        mode=setting['mode'],
+                        target_index=target_index
+                    )
+                    break  # 第一個成功就跳出（允許 fallback 多個 index）
+                except Exception as e:
+                    continue

neurostats_API/transformers/profit_lose/us.py

@@ -0,0 +1,25 @@
+from .base import BaseProfitLoseTransformer
+from neurostats_API.utils import StatsProcessor, YoY_Calculator
+import pandas as pd
+
+class USProfitLoseTransformer(BaseProfitLoseTransformer):
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+        self.data_df = None
+    
+    def process_transform(self, fetched_data):
+        
+        data_dict = self._process_us_format(fetched_data).T.to_dict()
+
+        data_dict = YoY_Calculator.cal_QoQ(data_dict)
+        data_dict = YoY_Calculator.cal_YoY(data_dict)
+
+        self.data_df = self._process_us_format(data_dict)
+
+        return_dict = {
+            "ticker": self.ticker,
+            "company_name": self.company_name,
+            "profit_lose": self.data_df
+        }
+
+        return return_dict

neurostats_API/transformers/tej/__init__.py

@@ -0,0 +1 @@
+from .finance_statement import TEJFinanceStatementTransformer

neurostats_API/transformers/tej/base.py

@@ -0,0 +1,149 @@
+from ..base import BaseTransformer
+from neurostats_API.utils import StatsProcessor, YoY_Calculator
+import pandas as pd
+
+
+class BaseTEJTransformer(BaseTransformer):
+
+    def __init__(self, ticker, company_name, zone):
+        super().__init__(ticker, company_name, zone)
+        self.thousand_index_list = [] # 在子類別定義
+        self.percent_index_list = [] # 在子類別定義
+        self.skip_index = [] # 在子類別定義
+
+    def _process_data_to_tej_format(self, fetched_data, target_key):
+        table_dict = {}
+        for data in fetched_data:
+            year, season, target_dict = data['year'], data['season'], data[
+                target_key]
+            time_index = f"{year}Q{season}"
+            table_dict[time_index] = target_dict
+
+        return table_dict
+
+    def _transform_value(self, data_dict):
+        """
+        處理千元, %等單位
+        """
+
+        data_df = pd.DataFrame.from_dict(data_dict)
+        for category, postfix in [(self.thousand_index_list, "千元"),
+                                  (self.percent_index_list, "%")]:
+            process_list = list(set(data_df.index) & set(category))
+
+            if postfix == "%":
+                data_df = data_df.T
+                data_df[process_list] = data_df[process_list].map(
+                    lambda x: f"{x}%"
+                )    # if (not np.isnan(x)) else None)
+                data_df = data_df.T
+            else:
+                data_df.loc[process_list] = data_df.loc[process_list].map(
+                    lambda x: StatsProcessor.
+                    cal_non_percentage(x, postfix=postfix)
+                )
+        return data_df.to_dict()
+
+    def _calculate_growth(self, this_value, last_value, delta):
+        try:
+            return YoY_Calculator.cal_growth(
+                this_value, last_value, delta
+            ) * 100
+        except Exception:
+            return None
+
+    def _get_QoQ_data(self, data, use_cal=False):
+
+        if (use_cal):
+            new_dict = {}
+            for time_index, data_dict in data.items():
+                year, season = time_index.split('Q')
+                year, season = int(year), int(season)
+                last_year, last_season = (year - 1, 4) if season == 1 else (
+                    year, season - 1
+                )
+
+                pre_data_dict = data.get(f"{last_year}Q{last_season}", {})
+
+                new_dict[time_index] = self._calculate_QoQ_dict(
+                    data_dict, pre_data_dict, delta=1
+                )
+            data = pd.DataFrame.from_dict(new_dict)
+            return data
+
+        else:
+            data = pd.DataFrame.from_dict(data)
+            return data
+
+    def _get_YoY_data(self, data, target_season, use_cal=False):
+        if (use_cal):
+            new_dict = {}
+            year_shifts = [1, 3, 5, 10]
+
+            for time_index, data_dict in data.items():
+                year, season = time_index.split('Q')
+                year, season = int(year), int(season)
+
+                target_items = []
+                for shift in year_shifts:
+                    last_year, last_season = (year - shift, season)
+
+                    pre_data_dict = data.get(f"{last_year}Q{last_season}", {})
+
+                    target_items.append(pre_data_dict)
+
+                new_dict[time_index] = self._calculate_YoY_dict(
+                    data_dict, target_items, year_shifts = year_shifts
+                )
+
+            data = pd.DataFrame.from_dict(new_dict)
+            target_season_col = data.columns.str.endswith(f"{target_season}")
+            data = data.loc[:, target_season_col]
+        
+        else:
+            data = pd.DataFrame.from_dict(data)
+            target_season_col = data.columns.str.endswith(f"{target_season}")
+            data = data.loc[:, target_season_col]
+
+        return data
+
+    def _calculate_QoQ_dict(self, this_dict, last_dict, delta):
+        temp_dict = {}
+        for key in list(this_dict.keys()):
+            if key in self.skip_index:
+                temp_dict[f"{key}_value"] = this_dict[key]
+                continue
+            this_value = self._process_value(this_dict[key])
+
+            last_value = last_dict.get(key, None)
+            last_value = self._process_value(last_value)
+
+            growth = self._calculate_growth(
+                this_value, last_value, delta=delta
+            ) if last_value is not None else None
+
+            temp_dict[f"{key}_value"] = this_dict[key]
+            temp_dict[f"{key}_growth"] = (f"{growth:.2f}%" if growth else None)
+
+        return temp_dict
+    
+    def _calculate_YoY_dict(self, this_dict, last_dicts, year_shifts):
+        temp_dict = {}
+        for last_dict, delta in zip(last_dicts, year_shifts):
+            for key in list(this_dict.keys()):
+                if key in self.skip_index:
+                    temp_dict[f"{key}_value"] = this_dict[key]
+                    continue
+                this_value = self._process_value(this_dict[key])
+
+                last_value = last_dict.get(key, None)
+                last_value = self._process_value(last_value)
+                
+                growth = self._calculate_growth(
+                    this_value, last_value, delta=delta
+                ) if last_value is not None else None
+
+                temp_dict[f"{key}_value"] = this_dict[key]
+                temp_dict[f"{key}_YoY_{delta}"] = (f"{growth:.2f}%" if growth else None)
+
+        return temp_dict