neurostats-API 0.0.23b2__py3-none-any.whl → 0.0.24.post1__py3-none-any.whl

neurostats_API/__init__.py

@@ -1,4 +1,4 @@
-__version__='0.0.23b2'
+__version__='0.0.24.post1'
 
 from .fetchers import (
     BalanceSheetFetcher,

neurostats_API/fetchers/balance_sheet.py

@@ -19,32 +19,43 @@ class BalanceSheetFetcher(StatsFetcher):
             "us_stats": self.process_data_us
         }
 
+        self.return_keys = [
+            'balance_sheet', 'total_asset', 'current_asset', 'non_current_asset', 
+            'current_debt', 'non_current_debt', 'equity', 'balance_sheet_all', 'balance_sheet_YoY'
+        ]
+
     def prepare_query(self):
         pipeline = super().prepare_query()
 
-        pipeline = pipeline + [
-            {
-                "$unwind": "$seasonal_data"    # 展開 seasonal_data 陣列
-            },
-            {
-                "$project": {
-                    "_id": 0,
-                    "ticker": 1,
-                    "company_name": 1,
-                    "year": "$seasonal_data.year",
-                    "season": "$seasonal_data.season",
-                    "balance_sheet": {
-                        "$ifNull": ["$seasonal_data.balance_sheet", []]
-                    }    # 避免 null
-                }
-            },
-            {
-                "$sort": {
-                    "year": -1,
-                    "season": -1
+        name_map = {
+            "twse_stats": "balance_sheet",
+            "us_stats": "balance_sheet"
+        }
+
+
+        chart_name = name_map.get(self.collection_name, "balance_sheet")
+
+        append_pipeline = [
+        {
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "seasonal_data": {
+                    "$map": {
+                        "input": {"$ifNull": ["$seasonal_data", []]},
+                        "as": "season",
+                        "in": {
+                            "year": "$$season.year",
+                            "season": "$$season.season",
+                            "data": {"$ifNull": [f"$$season.{chart_name}", []]}
+                        }
+                    }
                 }
             }
-        ]
+        }
+    ]
+        pipeline = pipeline + append_pipeline
 
         return pipeline
 
@@ -53,6 +64,7 @@ class BalanceSheetFetcher(StatsFetcher):
 
     def query_data(self):
         fetched_data = self.collect_data()
+        fetched_data = fetched_data[0]
 
         process_fn = self.process_function_map[self.collection_name]
         processed_data = process_fn(fetched_data)
@@ -72,14 +84,19 @@ class BalanceSheetFetcher(StatsFetcher):
 
         return_dict = {
             "ticker": self.ticker,
-            "company_name": fetched_data[-1]['company_name']
+            "company_name": fetched_data['company_name']
         }
         table_dict = {}
 
+        seasonal_data = fetched_data.get('seasonal_data')
+        if not seasonal_data:
+            return_dict.update(self._get_empty_structure())
+            return return_dict
+
         # 將value與percentage跟著年分季度一筆筆取出
-        for data in fetched_data:
+        for data in seasonal_data:
             year, season, balance_sheet = data['year'], data['season'], data[
-                'balance_sheet']
+                'data']
             time_index = f"{year}Q{season}"
 
             new_balance_sheet = dict()
@@ -96,35 +113,37 @@ class BalanceSheetFetcher(StatsFetcher):
         old_balance_sheet = old_balance_sheet.loc[:, target_season_col]
         old_balance_sheet = StatsProcessor.expand_value_percentage(old_balance_sheet)
 
+        # 處理QoQ版BalanceSheet
         for time_index, data_dict in table_dict.items():
             new_balance_sheet = self.flatten_dict(
-                balance_sheet, 
+                data_dict, 
                 indexes = index_names,
                 target_keys=["value", "percentage"]
             )
 
             table_dict[time_index] = new_balance_sheet
 
-        total_table = pd.DataFrame.from_dict(table_dict)
-        value_index = total_table.index.str.endswith("_value")
-        total_table.loc[value_index, :] = (
-            total_table.loc[value_index, :].apply(
-                lambda x: StatsProcessor.cal_non_percentage(x, postfix="元"),
-                axis=0
+        total_table = pd.DataFrame.from_dict(table_dict).T
+        value_index = total_table.columns.str.endswith("_value")
+        value_cols = total_table.loc[:, value_index].columns
+        total_table[value_cols] = (
+            total_table[value_cols].map(
+                lambda x: StatsProcessor.cal_non_percentage(x, postfix="千元"),
             )
         )
 
-        percenrage_index = total_table.index.str.endswith(
+        percentage_index = total_table.columns.str.endswith(
             "_percentage"
         )
-        total_table.loc[percenrage_index, :] = (
-            total_table.loc[percenrage_index, :].apply(
+        percentage_cols = total_table.loc[:, percentage_index].columns
+        total_table[percentage_cols] = (
+            total_table[percentage_cols].map(
                 lambda x: StatsProcessor.
                 cal_non_percentage(x, to_str=True, postfix="%"),
-                axis=0
             )
         )
 
+        total_table = total_table.T
         target_season_columns = total_table.columns.str.endswith(
             f"Q{target_season}"
         )
@@ -140,7 +159,6 @@ class BalanceSheetFetcher(StatsFetcher):
                     )
                     break
                 except Exception as e:
-                    print(f"error : {str(e)}")
                     continue
         
         return_dict.update(
@@ -155,24 +173,30 @@ class BalanceSheetFetcher(StatsFetcher):
     def process_data_us(self, fetched_data):
         return_dict = {
             "ticker": self.ticker,
-            "company_name": fetched_data[-1]['company_name']
+            "company_name": fetched_data['company_name']
         }
+        table_dict = {}
 
         table_dict = dict()
 
-        for data in fetched_data:
+        for data in fetched_data['seasonal_data']:
             year, season, balance_sheet = data['year'], data['season'], data[
-                'balance_sheet']
+                'data']
             table_dict[f"{year}Q{season}"] = balance_sheet
 
         table_dict = pd.DataFrame.from_dict(table_dict)
 
         return_dict["balance_sheet"] = table_dict
 
-        latest_season = fetched_data[0]['season']
+        latest_season = fetched_data['seasonal_data'][0]['season']
         target_season_columns = table_dict.columns.str.endswith(
             f"Q{latest_season}"
         )
         table_dict_YoY = table_dict.loc[:, target_season_columns]
         return_dict["balance_sheet_YoY"] = table_dict_YoY
         return return_dict
+
+    def _get_empty_structure(self):
+        return {
+            key: pd.DataFrame(columns= pd.Index([], name = 'date')) for key in self.return_keys
+        }

neurostats_API/fetchers/base.py

@@ -97,8 +97,12 @@ class BaseTEJFetcher(abc.ABC):
             }
         )
 
-        # return 得到最新日期或None
-        return latest_data.get('last_update', {}).get("latest_data_date", None)
+        if (latest_data):
+            # return 得到最新日期或None
+            return latest_data.get('last_update', {}).get("latest_data_date", None)
+        
+        else:
+            return None
 
     def process_value(self, value):
         if isinstance(value, str) and "%" in value:

neurostats_API/fetchers/cash_flow.py

@@ -18,6 +18,8 @@ class CashFlowFetcher(StatsFetcher):
             "twse_stats": self.process_data_twse,
             "us_stats": self.process_data_us
         }
+
+        self.return_keys = ['cash_flow', 'CASHO', 'CASHI', 'CASHF', 'cash_flow_all', 'cash_flow_YoY']
     
     def prepare_query(self):
         pipeline = super().prepare_query()
@@ -31,28 +33,25 @@ class CashFlowFetcher(StatsFetcher):
         chart_name = name_map.get(self.collection_name, "cash_flow")
 
         append_pipeline = [
-            {
-                "$unwind": "$seasonal_data"    # 展開 seasonal_data 陣列
-            },
-            {
-                "$project": {
-                    "_id": 0,
-                    "ticker": 1,
-                    "company_name": 1,
-                    "year": "$seasonal_data.year",
-                    "season": "$seasonal_data.season",
-                    "cash_flow": {
-                        "$ifNull": [f"$seasonal_data.{chart_name}", []]
-                    }    # 避免 null
-                }
-            },
-            {
-                "$sort": {
-                    "year": -1,
-                    "season": -1
+        {
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "seasonal_data": {
+                    "$map": {
+                        "input": {"$ifNull": ["$seasonal_data", []]},
+                        "as": "season",
+                        "in": {
+                            "year": "$$season.year",
+                            "season": "$$season.season",
+                            "data": {"$ifNull": [f"$$season.{chart_name}", []]}
+                        }
+                    }
                 }
             }
-        ]
+        }
+    ]
 
         pipeline = pipeline + append_pipeline
 
@@ -63,6 +62,7 @@ class CashFlowFetcher(StatsFetcher):
     
     def query_data(self):
         fetched_data = self.collect_data()
+        fetched_data = fetched_data[0]
 
         process_fn = self.process_function_map.get(self.collection_name, self.process_data_us)
         return process_fn(fetched_data)
@@ -78,27 +78,36 @@ class CashFlowFetcher(StatsFetcher):
         index_names = []
         column_names = []
 
-        table_dict = dict()
-        CASHO_dict = dict()
-        CASHI_dict = dict()
-        CASHF_dict = dict()
+        table_dict = {}
+        CASHO_dict = {}
+        CASHI_dict = {}
+        CASHF_dict = {}
 
         # 處理cash_flow 比例
         checkpoints = ["營業活動之現金流量－間接法", "投資活動之現金流量", "籌資活動之現金流量", "匯率變動對現金及約當現金之影響"]
         main_cash_flows = [
-            "營業活動之淨現金流入（流出）", "投資活動之淨現金流入（流出）", "籌資活動之淨現金流入（流出）", None
+            "營業活動之淨現金流入（流出）", "投資活動之淨現金流入（流出）", "籌資活動之淨現金流入（流出）", "其他"
         ] # 主要的比例對象
         partial_cash_flows = [CASHO_dict, CASHI_dict, CASHF_dict, dict()] 
 
         # 作法: dictionary中也有checkpoints，如果出現了就換下一個index去計算
 
-        for data in fetched_data:
-            year, season, cash_flow = data['year'], data['season'], data['cash_flow']
+        return_dict = {
+            "ticker": self.ticker,
+            "company_name": fetched_data['company_name']
+        }
+        seasonal_data = fetched_data.get('seasonal_data')
+        if not seasonal_data:
+            return_dict.update(self._get_empty_structure())
+            return return_dict
+
+        for data in seasonal_data:
+            year, season, cash_flow = data['year'], data['season'], data['data']
 
             time_index = f"{year}Q{season}"
 
-            main_cash_flow_name = None
-            partial_cash_flow = None
+            main_cash_flow_name = ""
+            partial_cash_flow = {}
             next_checkpoint = 0
 
             temp_dict = {}
@@ -110,34 +119,34 @@ class CashFlowFetcher(StatsFetcher):
                     partial_cash_flow = partial_cash_flows[next_checkpoint]
                     partial_cash_flow[time_index] = {}
                     next_checkpoint += 1
+
+                if main_cash_flow_name: # 有取得cash flow name再進行接下來的計算percentage
+                    if (isinstance(cash_flow_value, dict)):
+                        value = cash_flow_value.get('value', None) 
+                    else:
+                        value = cash_flow_value
                     
-                if (isinstance(cash_flow_value, dict)):
-                    value = cash_flow_value.get('value', None) 
-                else:
-                    value = cash_flow_value
-                
-
-                main_value = cash_flow.get(main_cash_flow_name, None)
-                if (isinstance(main_value, dict)):
-                    main_value = main_value.get('value', None)
-                else:
-                    pass
-
-                try:
-                    ratio = np.round(
-                        (value / main_value) * 100, 2
-                    )
-                    ratio = f"{ratio}%"
-                except:
-                    ratio = None
-                
-                value = StatsProcessor.cal_non_percentage(value, postfix="千元")
-                temp_dict[index_name] = {
-                    "value" : value,
-                    "percentage": ratio
-                }
-                
-                partial_cash_flow[time_index][index_name] = temp_dict[index_name]
+                    # 處理cashflow percentage部分(取2位 + 接%)
+                    main_value = cash_flow.get(main_cash_flow_name, None)
+                    if (isinstance(main_value, dict)):
+                        main_value = main_value.get('value', None)
+                    else:
+                        pass
+
+                    try:
+                        ratio = np.round(
+                            (value / main_value) * 100, 2
+                        )
+                        ratio = f"{ratio}%"
+                    except:
+                        ratio = None
+                    
+                    value = StatsProcessor.cal_non_percentage(value, postfix="千元")
+                    temp_dict[index_name] = {
+                        "value" : value,
+                        "percentage": ratio
+                    }
+                    partial_cash_flow[time_index][index_name] = temp_dict[index_name]
 
             table_dict[time_index] = temp_dict
             index_names += list(cash_flow.keys())
@@ -157,35 +166,42 @@ class CashFlowFetcher(StatsFetcher):
         CASHF_table = pd.DataFrame(CASHF_dict)
         CASHF_table = StatsProcessor.expand_value_percentage(CASHF_table)
 
-        for time_index in table_dict.keys():
-            table_dict[time_index] = self.flatten_dict(table_dict[time_index], index_names, target_keys=['value', 'percentage'])
-        cash_flow_flatten = pd.DataFrame.from_dict(table_dict)
+        # 回傳歷來格式
+        target_season = seasonal_data[0]['season']
 
-        target_season = fetched_data[0]['season']
-        target_season_column = cash_flow_flatten.columns.str.endswith(f"Q{target_season}")
+        cash_flow_flatten, cash_flow_flatten_YoY = self.flatten_twse(
+            table_dict, target_season, index_names
+        )
 
-        return_dict = {
-            "ticker": self.ticker,
-            "company_name": fetched_data[-1]['company_name'],
+        return_dict.update({
             "cash_flow": cash_flow_table_stats,
             "CASHO": CASHO_table,
             "CASHI": CASHI_table,
             "CASHF": CASHF_table,
             "cash_flow_all": cash_flow_flatten,
-            "cash_flow_YoY": cash_flow_flatten.loc[:, target_season_column]
-        }
+            "cash_flow_YoY": cash_flow_flatten_YoY
+        })
         return return_dict
+    
+    def flatten_twse(self, data_dict: dict, target_season: int, index_names: list):
+        for time_index in data_dict.keys():
+            data_dict[time_index] = self.flatten_dict(data_dict[time_index], index_names, target_keys=['value', 'percentage'])
+        cash_flow_flatten = pd.DataFrame.from_dict(data_dict)
+
+        target_season_column = cash_flow_flatten.columns.str.endswith(f"Q{target_season}")
+
+        return cash_flow_flatten, cash_flow_flatten.loc[:, target_season_column]
 
     def process_data_us(self, fetched_data):
 
         table_dict = {
-            f"{data['year']}Q{data['season']}": data['cash_flow'] 
-            for data in fetched_data
+            f"{data['year']}Q{data['season']}": data['data'] 
+            for data in fetched_data['seasonal_data']
         }
 
         cash_flow_df = pd.DataFrame.from_dict(table_dict)
 
-        latest_season = fetched_data[0]['season']
+        latest_season = fetched_data['seasonal_data'][0]['season']
         target_season_columns = cash_flow_df.columns.str.endswith(
             f"Q{latest_season}"
         )
@@ -193,8 +209,13 @@ class CashFlowFetcher(StatsFetcher):
 
         return_dict = {
             "ticker": self.ticker,
-            "company_name": fetched_data[-1]['company_name'],
+            "company_name": fetched_data['company_name'],
             "cash_flow": cash_flow_df,
             "cash_flow_YoY": cash_flow_df_YoY
         }
         return return_dict
+
+    def _get_empty_structure(self):
+        return {
+            key: pd.DataFrame(columns= pd.Index([], name = 'date')) for key in self.return_keys
+        }

neurostats_API/fetchers/finance_overview.py

@@ -196,7 +196,7 @@ class FinanceOverviewProcessor(StatsProcessor):
             finance_dict['EBIT'] = StatsProcessor.cal_non_percentage(EBIT)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['EBIT'] = None
-            print(f"Error calculating EBIT: {e}")
+            # print(f"Error calculating EBIT: {e}")
 
     @classmethod
     def cal_fcf(cls, finance_dict):
@@ -210,7 +210,7 @@ class FinanceOverviewProcessor(StatsProcessor):
             finance_dict["fcf"] = StatsProcessor.cal_non_percentage(fcf)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['fcf'] = None
-            print(f"Error calculating FCF: {e}")
+            # print(f"Error calculating FCF: {e}")
 
     @classmethod
     def cal_interest_bearing_debt(cls, finance_dict):
@@ -242,7 +242,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                                                  finance_dict['eps'])
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['share_outstanding'] = None
-            print(f"share_outstanding failed because of {str(e)}")
+            # print(f"share_outstanding failed because of {str(e)}")
 
     @classmethod
     def cal_revenue_per_share(cls, finance_dict):
@@ -258,7 +258,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     revenue_per_share, False)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['revenue_per_share'] = None
-            print(f"revenue_per_share failed because of {str(e)}")
+            # print(f"revenue_per_share failed because of {str(e)}")
 
     @classmethod
     def cal_gross_per_share(cls, finance_dict):
@@ -283,7 +283,7 @@ class FinanceOverviewProcessor(StatsProcessor):
 
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['gross_per_share'] = None
-            print(f"gross_per_share failed because of {str(e)}")
+            # print(f"gross_per_share failed because of {str(e)}")
 
     @classmethod
     def cal_operating_income_per_share(cls, finance_dict):
@@ -299,7 +299,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     operating_income_per_share)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['operating_income_per_share'] = None
-            print(f"operating_income_per_share failed because of {str(e)}")
+            # print(f"operating_income_per_share failed because of {str(e)}")
 
     @classmethod
     def cal_operating_cash_flow_per_share(cls, finance_dict):
@@ -331,7 +331,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 fcf_per_share)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['fcf_per_share'] = None
-            print(f"fcf_per_share failed because of {str(e)}")
+            # print(f"fcf_per_share failed because of {str(e)}")
 
 # 盈利能力
 
@@ -375,7 +375,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 gross_over_asset)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['gross_over_asset'] = None
-            print(f"營業毛利/總資產 failed because of {str(e)}")
+            # print(f"營業毛利/總資產 failed because of {str(e)}")
 
     @classmethod
     def cal_roce(cls, finance_dict):
@@ -392,7 +392,7 @@ class FinanceOverviewProcessor(StatsProcessor):
 
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['roce'] = None
-            print(f"ROCE failed because of {str(e)}")
+            # print(f"ROCE failed because of {str(e)}")
 
     @classmethod
     def cal_gross_profit_marginal(cls, finance_dict):
@@ -408,7 +408,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     gross_profit_margin)
         except Exception as e:
             finance_dict['gross_profit_margin'] = None
-            print(f"gross_profit_margin failed because of {str(e)}")
+            # print(f"gross_profit_margin failed because of {str(e)}")
 
     @classmethod
     def cal_operation_profit_rate(cls, finance_dict):
@@ -425,7 +425,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     operation_profit_rate)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["operation_profit_rate"] = None
-            print(f"operation_profit failed because of {str(e)}")
+            # print(f"operation_profit failed because of {str(e)}")
 
     @classmethod
     def cal_operating_cash_flow_profit_rate(cls, finance_dict):
@@ -441,8 +441,8 @@ class FinanceOverviewProcessor(StatsProcessor):
                     operating_cash_flow_profit_rate)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["operating_cash_flow_profit_rate"] = None
-            print(
-                f"operating_cash_flow_profit_rate failed because of {str(e)}")
+            # print(
+            #     f"operating_cash_flow_profit_rate failed because of {str(e)}")
 
 
 # 成長動能
@@ -466,7 +466,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 dso, to_str=True, postfix="日")
         except Exception as e:
             finance_dict['dso'] = None
-            print(f"Error calculating 應收帳款收現天數 because of {str(e)}")
+            # print(f"Error calculating 應收帳款收現天數 because of {str(e)}")
 
     @classmethod
     def cal_account_receive_over_revenue(cls, finance_dict):
@@ -498,7 +498,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 dpo, to_str=True, postfix="日")
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["dpo"] = None
-            print(f"應付帳款週轉天數 failed because of {str(e)}")
+            # print(f"應付帳款週轉天數 failed because of {str(e)}")
 
     @classmethod
     def cal_inventories_cycle_ratio(cls, finance_dict):
@@ -515,7 +515,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     inventories_cycle_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["inventories_cycle_ratio"] = None
-            print(f"Error calculating 存貨周轉率 because of {str(e)}")
+            # print(f"Error calculating 存貨周轉率 because of {str(e)}")
 
     @classmethod
     def cal_dio(cls, finance_dict):
@@ -531,7 +531,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 dio, to_str=True, postfix="日")
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["dio"] = None
-            print(f"Error calculating 存貨週轉天數 because of {str(e)}")
+            # print(f"Error calculating 存貨週轉天數 because of {str(e)}")
 
     @classmethod
     def cal_inventories_revenue_ratio(cls, finance_dict):
@@ -548,7 +548,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     inventories_revenue_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["inventories_revenue_ratio"] = None
-            print(f"Error calculating 存貨佔營收比率 because of {str(e)}")
+            # print(f"Error calculating 存貨佔營收比率 because of {str(e)}")
 
     @classmethod
     def cal_cash_of_conversion_cycle(cls, finance_dict):
@@ -609,7 +609,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 current_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['current_ratio'] = None
-            print(f"Error calculating current ratio: {e}")
+            # print(f"Error calculating current ratio: {e}")
 
     @classmethod
     def cal_quick_ratio(cls, finance_dict):
@@ -625,7 +625,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                 quick_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['quick_ratio'] = None
-            print(f"Error calculating quick ratio: {e}")
+            # print(f"Error calculating quick ratio: {e}")
 
     @classmethod
     def cal_debt_to_equity_ratio(cls, finance_dict):
@@ -640,7 +640,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     debt_to_equity_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['debt_to_equity_ratio'] = None
-            print(f"Error calculating debt to equity ratio: {e}")
+            # print(f"Error calculating debt to equity ratio: {e}")
 
     @classmethod
     def cal_net_debt_to_equity_ratio(cls, finance_dict):
@@ -657,7 +657,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     net_debt_to_equity_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['net_debt_to_equity_ratio'] = None
-            print(f"Error calculating net debt to equity ratio: {e}")
+            # print(f"Error calculating net debt to equity ratio: {e}")
 
     @classmethod
     def cal_interest_coverage_ratio(cls, finance_dict):
@@ -672,7 +672,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     interest_coverage_ratio, to_str=True, postfix="倍")
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['interest_coverage_ratio'] = None
-            print(f"Error calculating interest coverage ratio: {e}")
+            # print(f"Error calculating interest coverage ratio: {e}")
 
     @classmethod
     def cal_debt_to_operating_cash_flow(cls, finance_dict):
@@ -687,7 +687,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     debt_to_operating_cash_flow)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['debt_to_operating_cash_flow'] = None
-            print(f"Error calculating debt to operating cash flow: {e}")
+            # print(f"Error calculating debt to operating cash flow: {e}")
 
     @classmethod
     def cal_debt_to_free_cash_flow(cls, finance_dict):
@@ -702,7 +702,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     debt_to_free_cash_flow)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['debt_to_free_cash_flow'] = None
-            print(f"Error calculating debt to free cash flow: {e}")
+            # print(f"Error calculating debt to free cash flow: {e}")
 
     @classmethod
     def cal_cash_flow_ratio(cls, finance_dict):
@@ -716,4 +716,4 @@ class FinanceOverviewProcessor(StatsProcessor):
                 cash_flow_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['cash_flow_ratio'] = None
-            print(f"Error calculating cash flow ratio: {e}")
+            # print(f"Error calculating cash flow ratio: {e}")