neurostats-API 0.0.21b0__py3-none-any.whl → 0.0.23__py3-none-any.whl

neurostats_API/fetchers/cash_flow.py

@@ -11,168 +11,151 @@ class CashFlowFetcher(StatsFetcher):
         super().__init__(ticker, db_client)
 
         self.cash_flow_dict = StatsProcessor.load_yaml(
-            "cash_flow_percentage.yaml"
+            "twse/cash_flow_percentage.yaml"
         )  # 計算子表格用
+
+        self.process_function_map = {
+            "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, target_season):
+    def prepare_query(self):
         pipeline = super().prepare_query()
 
-        pipeline.append({
+        name_map = {
+            "twse_stats": "cash_flow",
+            "us_stats": "cash_flow"
+        }
+
+
+        chart_name = name_map.get(self.collection_name, "cash_flow")
+
+        append_pipeline = [
+        {
             "$project": {
                 "_id": 0,
                 "ticker": 1,
                 "company_name": 1,
-                "cash_flows": {
-                    "$sortArray": {
-                        "input": {
-                            "$map": {
-                                "input": {
-                                    "$filter": {
-                                        "input": "$seasonal_data",
-                                        "as": "season",
-                                        "cond": {
-                                            "$eq":
-                                            ["$$season.season", target_season]
-                                        }
-                                    }
-                                },
-                                "as": "target_season_data",
-                                "in": {
-                                    "year":
-                                    "$$target_season_data.year",
-                                    "season":
-                                    "$$target_season_data.season",
-                                    "cash_flow":
-                                    "$$target_season_data.cash_flow"
-                                }
-                            }
-                        },
-                        "sortBy": {
-                            "year": -1
-                        }  # 按 year 降序排序
+                "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
     
-    def collect_data(self, target_season):
-        pipeline = self.prepare_query(target_season)
-
-        fetched_data = self.collection.aggregate(pipeline)
-
-        return list(fetched_data)[0]
+    def collect_data(self):
+        return super().collect_data()
     
     def query_data(self):
-        
-        try:
-            latest_time = StatsDateTime.get_latest_time(self.ticker, self.collection)['last_update_time']
-            target_season = latest_time['seasonal_data']['latest_season']
-        
-        except:
-            today = StatsDateTime.get_today()
-            target_season = today.season - 1 if (today.season > 1) else 4
-
-        fetched_data = self.collect_data(target_season)
-
-        return self.process_data(fetched_data, target_season)
+        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)
     
-    def process_data(self, fetched_data, target_season):
+    def process_data_twse(self, fetched_data):
         """
         處理現金流量表頁面的所有表格
         金流表本身沒有比例 但是Ifa有算，
         項目所屬的情況也不一(分別所屬營業,投資,籌資三個活動)
         所以這裡選擇不用slicing處理
         """
-        cash_flows = fetched_data['cash_flows']
 
         index_names = []
         column_names = []
 
-        table_dict = dict()
-        CASHO_dict = dict()
-        CASHI_dict = dict()
-        CASHF_dict = dict()
-
-        return_dict = {
-            "ticker": fetched_data['ticker'],
-            "company_name": fetched_data['company_name'],
-            "cash_flow": dict(),
-            "CASHO": dict(),
-            "CASHI": dict(),
-            "CASHF": 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 cash_flows:
-            year = data['year']
+        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{target_season}"
+            time_index = f"{year}Q{season}"
 
-            cash_flow = data['cash_flow']
-            main_cash_flow_name = None
-            partial_cash_flow = None
+            main_cash_flow_name = ""
+            partial_cash_flow = {}
             next_checkpoint = 0
 
-            for index_name, value in cash_flow.items():
+            temp_dict = {}
+
+            for index_name, cash_flow_value in cash_flow.items():
                 if (next_checkpoint < 3
                         and index_name == checkpoints[next_checkpoint]): # 找到了主要的變動點
                     main_cash_flow_name = main_cash_flows[next_checkpoint]
                     partial_cash_flow = partial_cash_flows[next_checkpoint]
+                    partial_cash_flow[time_index] = {}
                     next_checkpoint += 1
-                try:
-                    table_dict[time_index][index_name]['value'] = value[
-                        'value']
-                    if (value['value']):
-                        ratio = np.round(
-                                (value['value'] / cash_flow[
-                                main_cash_flow_name]['value']) * 100, 2)
-                        table_dict[time_index][index_name][
-                            'percentage'] = f"{ratio}%"
+
+                if main_cash_flow_name: # 有取得cash flow name再進行接下來的計算percentage
+                    if (isinstance(cash_flow_value, dict)):
+                        value = cash_flow_value.get('value', None) 
                     else:
-                        table_dict[time_index][index_name][
-                            'percentage'] = None
-                except: # 新增index再做一次
-                    if (time_index not in table_dict.keys()):
-                        table_dict[time_index] = dict()
-                    table_dict[time_index][index_name] = dict()
-
-                    table_dict[time_index][index_name]['value'] = value[
-                        'value']
-                    if (value['value']):
-                        ratio = np.round(
-                                (value['value'] / cash_flow[
-                                main_cash_flow_name]['value']) * 100, 2) 
-                        table_dict[time_index][index_name][
-                            'percentage'] = f"{ratio}%"
+                        value = cash_flow_value
+                    
+                    # 處理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:
-                        table_dict[time_index][index_name][
-                            'percentage'] = None
-                table_dict[time_index][index_name]['value'] = StatsProcessor.cal_non_percentage(value['value'], postfix="千元")
-                try:
-                    partial_cash_flow[time_index][index_name] = table_dict[
-                        time_index][index_name]
-                except:
-                    if (time_index not in partial_cash_flow.keys()):
-                        partial_cash_flow[time_index] = dict()
-                    partial_cash_flow[time_index][index_name] = table_dict[
-                        time_index][index_name]
+                        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())
 
         # 轉成dictionary keys
         index_names = list(dict.fromkeys(index_names))
 
         cash_flow_table = pd.DataFrame(table_dict)
-        cash_flow_table = StatsProcessor.expand_value_percentage(cash_flow_table)
+        cash_flow_table_stats = StatsProcessor.expand_value_percentage(cash_flow_table)
 
         CASHO_table = pd.DataFrame(CASHO_dict)
         CASHO_table = StatsProcessor.expand_value_percentage(CASHO_table)
@@ -183,9 +166,56 @@ class CashFlowFetcher(StatsFetcher):
         CASHF_table = pd.DataFrame(CASHF_dict)
         CASHF_table = StatsProcessor.expand_value_percentage(CASHF_table)
 
-        return_dict['cash_flow'] = cash_flow_table
-        return_dict['CASHO'] = CASHO_table
-        return_dict['CASHI'] = CASHI_table
-        return_dict['CASHF'] = CASHF_table
+        # 回傳歷來格式
+        target_season = seasonal_data[0]['season']
+
+        cash_flow_flatten, cash_flow_flatten_YoY = self.flatten_twse(
+            table_dict, target_season, index_names
+        )
+
+        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_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
+        }
+
+        cash_flow_df = pd.DataFrame.from_dict(table_dict)
+
+        latest_season = fetched_data[0]['season']
+        target_season_columns = cash_flow_df.columns.str.endswith(
+            f"Q{latest_season}"
+        )
+        cash_flow_df_YoY = cash_flow_df.loc[:, target_season_columns]
 
+        return_dict = {
+            "ticker": self.ticker,
+            "company_name": fetched_data[-1]['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

@@ -16,9 +16,9 @@ class FinanceOverviewFetcher(StatsFetcher):
         super().__init__(ticker, db_client)
 
         self.target_fields = StatsProcessor.load_yaml(
-            "finance_overview_dict.yaml")
+            "twse/finance_overview_dict.yaml")
         self.inverse_dict = StatsProcessor.load_txt(
-            "seasonal_data_field_dict.txt", json_load=True)
+            "twse/seasonal_data_field_dict.txt", json_load=True)
 
     def prepare_query(self, target_year, target_season):
 
@@ -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}")