neurostats-API 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

neurostats_API/__init__.py

@@ -1 +1 @@
-__version__='0.0.7'
+__version__='0.0.8'

neurostats_API/fetchers/balance_sheet.py

@@ -1,10 +1,12 @@
 from .base import StatsFetcher, StatsDateTime
 import json
+import numpy as np
 import pandas as pd
 from ..utils import StatsDateTime, StatsProcessor
 import importlib.resources as pkg_resources
 import yaml
 
+
 class BalanceSheetFetcher(StatsFetcher):
     """
     對應iFa.ai -> 財務分析 ->  資產負債表
@@ -13,7 +15,7 @@ class BalanceSheetFetcher(StatsFetcher):
     def __init__(self, ticker, db_client):
         super().__init__(ticker, db_client)
         self.table_settings = StatsProcessor.load_yaml("balance_sheet.yaml")
- 
+
     def prepare_query(self, target_year, target_season):
         pipeline = super().prepare_query()
 
@@ -24,36 +26,42 @@ class BalanceSheetFetcher(StatsFetcher):
         }
 
         pipeline.append({
-        "$project": {
-            "_id": 0,
-            "ticker": 1,
-            "company_name": 1,
-            "balance_sheets": {
-                "$sortArray": {
-                    "input": {
-                        "$map": {
-                            "input": {
-                                "$filter": {
-                                    "input": "$seasonal_data",
-                                    "as": "season",
-                                    "cond": {
-                                        "$eq": ["$$season.season", target_season]
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "balance_sheets": {
+                    "$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",
+                                    "balance_sheet":
+                                    "$$target_season_data.balance_sheet"
                                 }
-                            },
-                            "as": "target_season_data",
-                            "in": {
-                                "year": "$$target_season_data.year",
-                                "season": "$$target_season_data.season",
-                                "balance_sheet": "$$target_season_data.balance_sheet"
                             }
-                        }
-                    },
-                    "sortBy": { "year": -1 }  # 按 year 降序排序
+                        },
+                        "sortBy": {
+                            "year": -1
+                        }  # 按 year 降序排序
+                    }
                 }
             }
-        }
-    })
+        })
 
         return pipeline
 
@@ -93,20 +101,26 @@ class BalanceSheetFetcher(StatsFetcher):
 
             time_index = f"{year}Q{target_season}"
 
-             # 蒐集整體的keys
+            # 蒐集整體的keys
             index_names += list(data['balance_sheet'].keys())
             balance_sheet = data['balance_sheet']
 
             for index_name, value_dict in balance_sheet.items():
                 for item_name, item in value_dict.items():
-                    try: # table_dict[項目][(2020Q1, '%')]
-                        table_dict[index_name][(time_index,item_name)] = item
+                    try:  # table_dict[項目][(2020Q1, '%')]
+                        if (item_name == 'percentage'):
+                            if (isinstance(item, (float, int))):
+                                item = np.round(item, 2)
+                        if ("YoY" in item_name):
+                            if (isinstance(item, (float, int))):
+                                item = np.round(item * 100, 2)
+                        table_dict[index_name][(time_index, item_name)] = item
 
                     except KeyError:
                         if (index_name not in table_dict.keys()):
                             table_dict[index_name] = dict()
 
-                        table_dict[index_name][(time_index,item_name)] = item
+                        table_dict[index_name][(time_index, item_name)] = item
 
         total_table = pd.DataFrame.from_dict(table_dict, orient='index')
         total_table.columns = pd.MultiIndex.from_tuples(total_table.columns)
@@ -118,5 +132,4 @@ class BalanceSheetFetcher(StatsFetcher):
                 target_index=setting['target_index']
                 if "target_index" in setting.keys() else None)
 
-            print(f"{name}: {return_dict[name].columns}")
         return return_dict

neurostats_API/fetchers/cash_flow.py

@@ -1,5 +1,6 @@
 from .base import StatsFetcher, StatsDateTime
 import json
+import numpy as np
 import pandas as pd
 from ..utils import StatsDateTime, StatsProcessor
 import importlib.resources as pkg_resources
@@ -127,8 +128,9 @@ class CashFlowFetcher(StatsFetcher):
                         'value']
                     if (value['value']):
                         table_dict[time_index][index_name][
-                            'percentage'] = value['value'] / cash_flow[
-                                main_cash_flow_name]['value']
+                            'percentage'] = np.round(
+                                (value['value'] / cash_flow[
+                                main_cash_flow_name]['value']) * 100, 2)
                     else:
                         table_dict[time_index][index_name][
                             'percentage'] = None
@@ -141,8 +143,9 @@ class CashFlowFetcher(StatsFetcher):
                         'value']
                     if (value['value']):
                         table_dict[time_index][index_name][
-                            'percentage'] = value['value'] / cash_flow[
-                                main_cash_flow_name]['value']
+                            'percentage'] = np.round(
+                                (value['value'] / cash_flow[
+                                main_cash_flow_name]['value']) * 100, 2) 
                     else:
                         table_dict[time_index][index_name][
                             'percentage'] = None

neurostats_API/fetchers/finance_overview.py

@@ -1,5 +1,6 @@
 from .base import StatsFetcher, StatsDateTime
 import json
+import numpy as np
 import pandas as pd
 from ..utils import StatsDateTime, StatsProcessor
 import importlib.resources as pkg_resources
@@ -14,8 +15,10 @@ class FinanceOverviewFetcher(StatsFetcher):
     def __init__(self, ticker, db_client):
         super().__init__(ticker, db_client)
 
-        self.target_fields = StatsProcessor.load_yaml("finance_overview_dict.yaml")
-        self.inverse_dict = StatsProcessor.load_txt("seasonal_data_field_dict.txt", json_load=True)
+        self.target_fields = StatsProcessor.load_yaml(
+            "finance_overview_dict.yaml")
+        self.inverse_dict = StatsProcessor.load_txt(
+            "seasonal_data_field_dict.txt", json_load=True)
 
     def prepare_query(self, target_year, target_season):
 
@@ -83,9 +86,10 @@ class FinanceOverviewFetcher(StatsFetcher):
         today = StatsDateTime.get_today()
 
         year = today.year - 1 if (today.season == 1) else today.year
-        season = 4 if (today.season == 1) else today.season - 2
+        season = 4 if (today.season == 1) else today.season - 1
         fetched_data = self.collect_data(year, season)
         finance_dict = fetched_data['seasonal_data'][0]
+        FinanceOverviewProcessor.process_rate(finance_dict)
         FinanceOverviewProcessor.process_all(finance_dict)
         fetched_data['seasonal_data'] = finance_dict
         return fetched_data
@@ -93,41 +97,38 @@ class FinanceOverviewFetcher(StatsFetcher):
 
 class FinanceOverviewProcessor(StatsProcessor):
 
+    @classmethod
+    def process_rate(cls, finance_dict):
+        for key in finance_dict:
+            if ('YoY' in key):
+                finance_dict[key] = StatsProcessor.cal_percentage(
+                    finance_dict[key])
+            elif ("rate" in key or 'ratio' in key):
+                finance_dict[key] = StatsProcessor.cal_non_percentage(
+                    finance_dict[key], to_str=True, postfix='%')
+            else:
+                finance_dict[key] = StatsProcessor.cal_non_percentage(
+                    finance_dict[key])
+
     @classmethod
     def process_all(cls, finance_dict):
         methods = [
-            cls.cal_EBIT,
-            cls.cal_share_outstanding,
-            cls.cal_fcf,
-            cls.cal_revenue_per_share,
-            cls.cal_gross_per_share,
-            cls.cal_operating_income_per_share,
-            cls.cal_operating_cash_flow_per_share,
-            cls.fcf_per_share,
-            cls.cal_roa, 
-            cls.cal_roe,
-            cls.cal_gross_over_asset,
-            cls.cal_roce,
-            cls.cal_gross_profit_marginal,
-            cls.cal_operation_profit_rate,
-            cls.cal_operating_cash_flow_profit_rate,
-            cls.cal_dso,
-            cls.cal_account_receive_over_revenue,
-            cls.cal_dpo,
-            cls.cal_inventories_cycle_ratio,
-            cls.cal_dio,
+            cls.cal_EBIT, cls.cal_share_outstanding, cls.cal_fcf,
+            cls.cal_interest_bearing_debt, cls.cal_revenue_per_share,
+            cls.cal_gross_per_share, cls.cal_operating_income_per_share,
+            cls.cal_operating_cash_flow_per_share, cls.fcf_per_share,
+            cls.cal_roa, cls.cal_roe, cls.cal_gross_over_asset, cls.cal_roce,
+            cls.cal_gross_profit_marginal, cls.cal_operation_profit_rate,
+            cls.cal_operating_cash_flow_profit_rate, cls.cal_dso,
+            cls.cal_account_receive_over_revenue, cls.cal_dpo,
+            cls.cal_inventories_cycle_ratio, cls.cal_dio,
             cls.cal_inventories_revenue_ratio,
-            cls.cal_cash_of_conversion_cycle,
-            cls.cal_asset_turnover,
-            cls.cal_application_turnover,
-            cls.cal_current_ratio,
-            cls.cal_quick_ratio,
-            cls.cal_debt_to_equity_ratio,
-            cls.cal_net_debt_to_equity_ratio,
-            cls.cal_interest_coverage_ratio,
+            cls.cal_cash_of_conversion_cycle, cls.cal_asset_turnover,
+            cls.cal_application_turnover, cls.cal_current_ratio,
+            cls.cal_quick_ratio, cls.cal_debt_to_equity_ratio,
+            cls.cal_net_debt_to_equity_ratio, cls.cal_interest_coverage_ratio,
             cls.cal_debt_to_operating_cash_flow,
-            cls.cal_debt_to_free_cash_flow,
-            cls.cal_cash_flow_ratio
+            cls.cal_debt_to_free_cash_flow, cls.cal_cash_flow_ratio
         ]
 
         for method in methods:
@@ -137,13 +138,13 @@ class FinanceOverviewProcessor(StatsProcessor):
     def cal_EBIT(cls, finance_dict):
         """
         計算EBIT
-        EBIT = 營業收入 - 營業成本 - 營業費用
+        EBIT = 營業收入 - 營業成本 - 營業費用 - 所得稅費用
         """
         try:
-            finance_dict['EBIT'] = (finance_dict['revenue'] -
-                                    finance_dict['operating_cost'] -
-                                    finance_dict['operating_expenses'])
-        except (KeyError, TypeError) as e:
+            EBIT = (finance_dict['revenue'] - finance_dict['operating_cost'] -
+                    finance_dict['operating_expenses'] - finance_dict['tax_fee'])
+            finance_dict['EBIT'] = StatsProcessor.cal_non_percentage(EBIT)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['EBIT'] = None
             print(f"Error calculating EBIT: {e}")
 
@@ -154,12 +155,32 @@ class FinanceOverviewProcessor(StatsProcessor):
         自由現金流 =  營業現金流 + 投資現金流
         """
         try:
-            finance_dict["fcf"] = (finance_dict["operating_cash_flow"] +
-                                   finance_dict["financing_cash_flow"])
-        except Exception as e:
+            fcf = (finance_dict["operating_cash_flow"] +
+                   finance_dict["financing_cash_flow"])
+            finance_dict["fcf"] = StatsProcessor.cal_non_percentage(fcf)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['fcf'] = None
             print(f"Error calculating FCF: {e}")
 
+    @classmethod
+    def cal_interest_bearing_debt(cls, finance_dict):
+        """
+        計算有息負債
+        短期借款+長期借款
+        """
+        finance_dict['interest_bearing_debt'] = 0.0
+
+        try:
+            finance_dict['interest_bearing_debt'] += finance_dict[
+                'short_term_liabilities']
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict['interest_bearing_debt'] += 0.0
+        try:
+            finance_dict['interest_bearing_debt'] += finance_dict[
+                'long_term_liabilities']
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict['interest_bearing_debt'] += 0.0
+
     @classmethod
     def cal_share_outstanding(cls, finance_dict):
         """
@@ -169,7 +190,7 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             finance_dict["share_outstanding"] = (finance_dict['net_income'] /
                                                  finance_dict['eps'])
-        except KeyError as e:
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['share_outstanding'] = None
             print(f"share_outstanding failed because of {str(e)}")
 
@@ -180,9 +201,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股營收 = 營業收入 / 在外流通股數
         """
         try:
-            finance_dict['revenue_per_share'] = (
-                finance_dict['revenue'] / finance_dict['share_outstanding'])
-        except KeyError as e:
+            revenue_per_share = (finance_dict['revenue'] /
+                                 finance_dict['share_outstanding'])
+            finance_dict[
+                'revenue_per_share'] = StatsProcessor.cal_non_percentage(
+                    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)}")
 
@@ -194,10 +218,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         """
 
         try:
-            finance_dict['gross_per_share'] = (
-                finance_dict['gross_profit'] /
-                finance_dict['share_outstanding'])
-        except KeyError as e:
+            gross_per_share = (finance_dict['gross_profit'] /
+                               finance_dict['share_outstanding'])
+            finance_dict[
+                'gross_per_share'] = StatsProcessor.cal_non_percentage(
+                    gross_per_share, False)
+
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['gross_per_share'] = None
             print(f"gross_per_share failed because of {str(e)}")
 
@@ -208,10 +235,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股營業利益= （當期營業利益）÷（當期在外流通股數）
         """
         try:
-            finance_dict['operating_income_per_share'] = (
-                finance_dict['operating_income'] /
-                finance_dict['share_outstanding'])
-        except KeyError as e:
+            operating_income_per_share = (finance_dict['operating_income'] /
+                                          finance_dict['share_outstanding'])
+            finance_dict[
+                'operating_income_per_share'] = StatsProcessor.cal_non_percentage(
+                    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)}")
 
@@ -222,10 +251,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         = (當期營業現金流) ÷（當期在外流通股數）
         """
         try:
-            finance_dict["operating_cash_flow_per_share"] = (
+            operating_cash_flow_per_share = (
                 finance_dict["operating_cash_flow"] /
                 finance_dict['share_outstanding'])
-        except KeyError as e:
+            finance_dict[
+                "operating_cash_flow_per_share"] = StatsProcessor.cal_non_percentage(
+                    operating_cash_flow_per_share)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['operating_cash_flow_per_share'] = None
             print(f'operating_cash_flow_per_share because of {str(e)}')
 
@@ -236,9 +268,11 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股自由現金流 = (當期自由現金流) ÷（當期在外流通股數）
         """
         try:
-            finance_dict['fcf_per_share'] = (finance_dict['fcf'] /
-                                             finance_dict['share_outstanding'])
-        except KeyError as e:
+            fcf_per_share = (finance_dict['fcf'] /
+                             finance_dict['share_outstanding'])
+            finance_dict['fcf_per_share'] = StatsProcessor.cal_non_percentage(
+                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)}")
 
@@ -250,27 +284,35 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算資產報酬率(ROA)
         ROA = [ 本期淨利 + 利息費用 × (1-有效稅率) ] ÷（資產總額）
         """
-        finance_dict["roa"] = (
+        roa = (
             finance_dict['net_income'] + finance_dict['interest'] +
             (1 * 0.1)  # 有效稅率需要改，這裡先設0.1
         ) / finance_dict['inventories']
 
+        finance_dict["roa"] = StatsProcessor.cal_percentage(roa)
+
     @classmethod
     def cal_roe(cls, finance_dict):
         """
         計算股東權益報酬率(ROE)
         ROE = (本期淨利) ÷（權益總額）
         """
-        finance_dict['roe'] = (finance_dict['net_income'] /
-                               finance_dict['equity'])
+        roe = (finance_dict['net_income'] / finance_dict['equity'])
+        finance_dict['roe'] = StatsProcessor.cal_percentage(roe)
 
     @classmethod
     def cal_gross_over_asset(cls, finance_dict):
         """
         計算營業毛利/總資產
         """
-        finance_dict['gross_over_asset'] = (finance_dict['gross_profit'] /
-                                            finance_dict['total_asset'])
+        try:
+            gross_over_asset = (finance_dict['gross_profit'] /
+                                finance_dict['total_asset'])
+            finance_dict['gross_over_asset'] = StatsProcessor.cal_percentage(
+                gross_over_asset)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict['gross_over_asset'] = None
+            print(f"營業毛利/總資產 failed because of {str(e)}")
 
     @classmethod
     def cal_roce(cls, finance_dict):
@@ -279,11 +321,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         ROCE = (稅前淨利＋利息費用) / (資產總額－流動負債)
         """
         try:
-            finance_dict['roce'] = (
-                (finance_dict['net_income_before_tax'] +
-                 finance_dict['interest']) /
-                (finance_dict['asset'] - finance_dict['current_liabilities']))
-        except KeyError as e:
+            roce = ((finance_dict['net_income_before_tax'] +
+                     finance_dict['interest']) /
+                    (finance_dict['total_asset'] -
+                     finance_dict['current_liabilities']))
+            finance_dict['roce'] = StatsProcessor.cal_percentage(roce)
+
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['roce'] = None
             print(f"ROCE failed because of {str(e)}")
 
@@ -294,8 +338,11 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業毛利率 = 營業毛利 ÷ 營業收入
         """
         try:
-            finance_dict['gross_profit_margin'] = (
-                finance_dict['gross_profit'] / finance_dict['revenue'])
+            gross_profit_margin = (finance_dict['gross_profit'] /
+                                   finance_dict['revenue'])
+            finance_dict[
+                'gross_profit_margin'] = StatsProcessor.cal_percentage(
+                    gross_profit_margin)
         except:
             finance_dict['gross_profit_margin'] = None
             print(f"gross_profit_margin failed because of {str(e)}")
@@ -307,10 +354,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業利益率 = ( 營業收入－營業成本－營業費用）÷ 營業收入
         """
         try:
-            finance_dict["operation_profit_rate"] = (
+            operation_profit_rate = (
                 finance_dict['revenue'] - finance_dict['operating_cost'] -
-                finance_dict['operating_price']) / finance_dict['revenue']
-        except KeyError as e:
+                finance_dict['operating_expenses']) / finance_dict['revenue']
+            finance_dict[
+                "operation_profit_rate"] = StatsProcessor.cal_percentage(
+                    operation_profit_rate)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["operation_profit_rate"] = None
             print(f"operation_profit failed because of {str(e)}")
 
@@ -321,11 +371,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業現金流利潤率 = 營業活動現金流 ÷ 營業收入
         """
         try:
-            finance_dict["operating_cash_flow_profit_rate"] = (
+            operating_cash_flow_profit_rate = (
                 finance_dict["operating_cash_flow"] / finance_dict["revenue"])
-        except KeyError:
+            finance_dict[
+                "operating_cash_flow_profit_rate"] = StatsProcessor.cal_percentage(
+                    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)}")
 
@@ -342,10 +394,16 @@ class FinanceOverviewProcessor(StatsProcessor):
     def cal_dso(cls, finance_dict):
         """
         計算應收帳款收現天數(DSO)
-        DSO = 365 × (營業收入 ÷ 應收帳款平均餘額)
+        DSO = 365 × (應收帳款平均餘額 ÷ 營業收入)
         """
-        finance_dict['dso'] = (
-            365 * (finance_dict['revenue'] / finance_dict['account_pay']))
+        try:
+            dso = (365 *
+                   (finance_dict['account_pay'] / finance_dict['revenue']))
+            finance_dict['dso'] = StatsProcessor.cal_non_percentage(
+                dso, to_str=True, postfix="日")
+        except:
+            finance_dict['dso'] = None
+            print(f"Error calculating 應收帳款收現天數 because of {str(e)}")
 
     @classmethod
     def cal_account_receive_over_revenue(cls, finance_dict):
@@ -353,8 +411,11 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算應收帳款佔營收比率
         = 應收帳款平均餘額 ÷ 營業收入
         """
-        finance_dict["account_receive_over_revenue"] = (
-            finance_dict['account_receive'] / finance_dict['revenue'])
+        account_receive_over_revenue = (finance_dict['account_receive'] /
+                                        finance_dict['revenue'])
+        finance_dict[
+            "account_receive_over_revenue"] = StatsProcessor.cal_percentage(
+                account_receive_over_revenue)
 
     @classmethod
     def cal_dpo(cls, finance_dict):
@@ -362,9 +423,15 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算應付帳款週轉天數
         DPO = 365天 ÷ (銷貨成本÷平均應付帳款)
         """
-        finance_dict["dpo"] = (
-            365 *
-            (finance_dict['operating_cost'] / finance_dict['account_pay']))
+        try:
+            dpo = (
+                365 *
+                (finance_dict['account_pay'] / finance_dict['operating_cost']))
+            finance_dict["dpo"] = StatsProcessor.cal_non_percentage(
+                dpo, to_str=True, postfix="日")
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict["dpo"] = None
+            print(f"應付帳款週轉天數 failed because of {str(e)}")
 
     @classmethod
     def cal_inventories_cycle_ratio(cls, finance_dict):
@@ -372,19 +439,32 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算存貨周轉率
         = 銷貨成本 ÷ 存貨
         """
+        try:
+            inventories_cycle_ratio = (finance_dict['operating_cost'] /
+                                       finance_dict['inventories'])
 
-        finance_dict["inventories_cycle_ratio"] = (
-            finance_dict['operating_cost'] / finance_dict['inventories'])
+            finance_dict[
+                "inventories_cycle_ratio"] = StatsProcessor.cal_percentage(
+                    inventories_cycle_ratio)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict["inventories_cycle_ratio"] = None
+            print(f"Error calculating 存貨周轉率 because of {str(e)}")
 
     @classmethod
     def cal_dio(cls, finance_dict):
         """
-        計算 存貨週轉天數
-        DIO = 365天 ÷ (銷貨成本 ÷ 存貨)
-        MUDA MUDA MUDA MUDA !!!
+        計算 存貨週轉天數 or 平均售貨天數
+        DIO = 365天 * (存貨 ÷ 銷貨成本)
+        MUDA MUDA MUDA !!!
         """
-        finance_dict["dio"] = (finance_dict["operating_cost"] /
-                               finance_dict["inventories"])
+        try:
+            dio = 365 * (finance_dict["inventories"] /
+                         finance_dict["operating_cost"])
+            finance_dict["dio"] = StatsProcessor.cal_non_percentage(
+                dio, to_str=True, postfix="日")
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict["dio"] = None
+            print(f"Error calculating 存貨週轉天數 because of {str(e)}")
 
     @classmethod
     def cal_inventories_revenue_ratio(cls, finance_dict):
@@ -392,8 +472,16 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算存貨佔營收比率
         存貨佔營收比= 存貨 ÷ 營業收入
         """
-        finance_dict["inventories_revenue_ratio"] = (
-            finance_dict['inventories'] / finance_dict['revenue'])
+        try:
+            inventories_revenue_ratio = (finance_dict['inventories'] /
+                                         finance_dict['revenue'])
+
+            finance_dict[
+                "inventories_revenue_ratio"] = StatsProcessor.cal_percentage(
+                    inventories_revenue_ratio)
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict["inventories_revenue_ratio"] = None
+            print(f"Error calculating 存貨佔營收比率 because of {str(e)}")
 
     @classmethod
     def cal_cash_of_conversion_cycle(cls, finance_dict):
@@ -401,19 +489,42 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算現金循環週期
         存貨週轉天數 + 應收帳款週轉天數 - 應付帳款週轉天數
         """
-        finance_dict["cash_of_conversion_cycle"] = (finance_dict["dio"] +
-                                                    finance_dict["dso"] -
-                                                    finance_dict['dpo'])
+        try:
+            cash_of_conversion_cycle = (finance_dict["dio"] +
+                                        finance_dict["dso"] -
+                                        finance_dict['dpo'])
+            finance_dict[
+                "cash_of_conversion_cycle"] = StatsProcessor.cal_non_percentage(
+                    cash_of_conversion_cycle, to_str=True, postfix="日")
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict["cash_of_conversion_cycle"] = None
 
     @classmethod
     def cal_asset_turnover(cls, finance_dict):
-        finance_dict["asset_turnover"] = (finance_dict["revenue"] /
-                                          finance_dict["inventories"])
+        """
+        計算資產周轉率
+        營業收入 ÷ 資產總額
+        """
+        asset_turnover = (finance_dict["revenue"] /
+                          finance_dict["inventories"])
+        finance_dict["asset_turnover"] = StatsProcessor.cal_percentage(
+            asset_turnover)
 
     @classmethod
     def cal_application_turnover(cls, finance_dict):
-        finance_dict['applcation_turnover'] = (finance_dict['revenue'] /
-                                               finance_dict["application"])
+        """
+        不動產、廠房及設備週轉率
+        營業收入 ÷ 不動產、廠房與設備平均餘額
+        """
+        try:
+            applcation_turnover = (finance_dict['revenue'] /
+                                   finance_dict["application"])
+            finance_dict[
+                'applcation_turnover'] = StatsProcessor.cal_percentage(
+                    applcation_turnover)
+
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            finance_dict['application_turnover'] = None
 
     @classmethod
     def cal_current_ratio(cls, finance_dict):
@@ -421,81 +532,117 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算流動比率 = 流動資產 / 流動負債
         """
         try:
-            finance_dict['current_ratio'] = finance_dict[
-                'current_assets'] / finance_dict['current_liabilities']
+            current_ratio = (finance_dict['current_assets'] /
+                             finance_dict['current_liabilities'])
+            finance_dict['current_ratio'] = StatsProcessor.cal_percentage(
+                current_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['current_ratio'] = None
             print(f"Error calculating current ratio: {e}")
 
     @classmethod
     def cal_quick_ratio(cls, finance_dict):
+        """
+        速動比率
+        (流動資產 - 存貨) / 流動負債
+        """
         try:
-            # 速動比率 = (流動資產 - 存貨) / 流動負債
-            finance_dict['quick_ratio'] = (
-                finance_dict['current_assets'] - finance_dict['inventories']
-            ) / finance_dict['current_liabilities']
+            quick_ratio = (finance_dict['current_assets'] -
+                           finance_dict['inventories']
+                           ) / finance_dict['current_liabilities']
+            finance_dict['quick_ratio'] = StatsProcessor.cal_percentage(
+                quick_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['quick_ratio'] = None
             print(f"Error calculating quick ratio: {e}")
 
     @classmethod
     def cal_debt_to_equity_ratio(cls, finance_dict):
+        """
+        # 負債權益比率 = 總負債 / 股東權益
+        """
         try:
-            # 負債權益比率 = 總負債 / 股東權益
-            finance_dict['debt_to_equity_ratio'] = finance_dict[
+            debt_to_equity_ratio = finance_dict[
                 'total_liabilities'] / finance_dict['equity']
+            finance_dict[
+                'debt_to_equity_ratio'] = StatsProcessor.cal_percentage(
+                    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}")
 
     @classmethod
     def cal_net_debt_to_equity_ratio(cls, finance_dict):
+        """
+        # 淨負債權益比率 = (總負債 - 現金及約當現金) / 股東權益
+        """
         try:
-            # 淨負債權益比率 = (總負債 - 現金及約當現金) / 股東權益
-            finance_dict['net_debt_to_equity_ratio'] = (
+            net_debt_to_equity_ratio = (
                 finance_dict['total_liabilities'] -
                 finance_dict['cash_and_cash_equivalents']
             ) / finance_dict['equity']
+            finance_dict[
+                'net_debt_to_equity_ratio'] = StatsProcessor.cal_percentage(
+                    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}")
 
     @classmethod
     def cal_interest_coverage_ratio(cls, finance_dict):
+        """
+        # 利息保障倍數 = EBIT / 利息費用
+        """
         try:
-            # 利息保障倍數 = EBIT / 利息費用
-            finance_dict['interest_coverage_ratio'] = finance_dict[
-                'EBIT'] / finance_dict['interest_expense']
+            interest_coverage_ratio = finance_dict['EBIT'] / finance_dict[
+                'interest_expense']
+            finance_dict[
+                'interest_coverage_ratio'] = StatsProcessor.cal_non_percentage(
+                    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}")
 
     @classmethod
     def cal_debt_to_operating_cash_flow(cls, finance_dict):
+        """
+        有息負債 / 營業活動現金流
+        """
         try:
-            # 有息負債 / 營業活動現金流
-            finance_dict['debt_to_operating_cash_flow'] = finance_dict[
+            debt_to_operating_cash_flow = finance_dict[
                 'interest_bearing_debt'] / finance_dict['operating_cash_flow']
+            finance_dict[
+                'debt_to_operating_cash_flow'] = StatsProcessor.cal_percentage(
+                    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}")
 
     @classmethod
     def cal_debt_to_free_cash_flow(cls, finance_dict):
+        """
+        # 有息負債 / 自由現金流
+        """
         try:
-            # 有息負債 / 自由現金流
-            finance_dict['debt_to_free_cash_flow'] = finance_dict[
+            debt_to_free_cash_flow = finance_dict[
                 'interest_bearing_debt'] / finance_dict['fcf']
+            finance_dict[
+                'debt_to_free_cash_flow'] = StatsProcessor.cal_percentage(
+                    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}")
 
     @classmethod
     def cal_cash_flow_ratio(cls, finance_dict):
+        """
+        # 現金流量比率 = 營業活動現金流 / 流動負債
+        """
         try:
-            # 現金流量比率 = 營業活動現金流 / 流動負債
-            finance_dict['cash_flow_ratio'] = finance_dict[
+            cash_flow_ratio = finance_dict[
                 'operating_cash_flow'] / finance_dict['current_liabilities']
+            finance_dict['cash_flow_ratio'] = StatsProcessor.cal_percentage(
+                cash_flow_ratio)
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['cash_flow_ratio'] = None
             print(f"Error calculating cash flow ratio: {e}")

neurostats_API/fetchers/profit_lose.py

@@ -1,11 +1,13 @@
 from .base import StatsFetcher, StatsDateTime
+import importlib.resources as pkg_resources
 import json
+import numpy as np
 import pandas as pd
 from ..utils import StatsDateTime, StatsProcessor
-import importlib.resources as pkg_resources
 import yaml
 
 
+
 class ProfitLoseFetcher(StatsFetcher):
     """
     iFa.ai: 財務分析 -> 損益表
@@ -108,6 +110,12 @@ class ProfitLoseFetcher(StatsFetcher):
             for index_name, value_dict in profit_lose.items():
                 # (2020Q1, 項目, 金額或%)
                 for item_name, item in value_dict.items():
+                    if (item_name == 'percentage'):
+                        if (isinstance(item, (float, int))):
+                            item = np.round(item, 2)
+                    if ('YoY' in item_name):
+                        if (isinstance(item, (float, int))):
+                            item = np.round(item * 100, 2)
                     try:
                         table_dict[index_name][(time_index, item_name)] = item
 
@@ -121,6 +129,8 @@ class ProfitLoseFetcher(StatsFetcher):
         total_table = pd.DataFrame.from_dict(table_dict, orient='index')
         total_table.columns = pd.MultiIndex.from_tuples(total_table.columns)
 
+        total_table = total_table.replace("N/A", None)
+
         for name, setting in self.table_settings.items():
             return_dict[name] = StatsProcessor.slice_multi_col_table(
                 total_table=total_table,

neurostats_API/tools/finance_overview_dict.yaml

@@ -15,22 +15,22 @@ net_income:
   field: 本期淨利（淨損）
   value: value
 
+tax_fee:
+  field: 所得稅費用（利益）合計
+  value: value
+
 # TODO: 以下所爬到的資料都是累計的，Ifa有額外計算當季的變化量
 operating_cash_flow:
   field: 營業活動之淨現金流入（流出）
-  value: value
+  value: single_season_value
 
 invest_cash_flow:
   field: 投資活動之淨現金流入（流出）
-  value: value
+  value: single_season_value
 
 financing_cash_flow:
   field: 籌資活動之淨現金流入（流出）
-  value: value
-
-fcf:
-  field: 本期現金及約當現金增加（減少）數
-  value: value
+  value: single_season_value
 # ^^^ 以上皆需要額外在DataBase處理
 
 # 每股財務狀況
@@ -84,7 +84,7 @@ net_income_YoY:
 
 operating_cash_flow_YoY:
   field: 營業活動之淨現金流入（流出）
-  value: YoY_1
+  value: single_season_YoY
 
 # operating_cash_flow_per_share_YoY:
 #   field: 每股營業現金流年成長率
@@ -123,6 +123,13 @@ total_liabilities:
   field: 負債總額
   value: value
 
+short_term_liabilities:
+  field: 短期借款
+  value: value
+
+long_term_liabilities:
+  field: 長期借款
+  value: value
 # 
 cash_and_cash_equivalents:
   field: 現金及約當現金

neurostats_API/tools/seasonal_data_field_dict.txt

@@ -23,6 +23,7 @@
   "非流動資產合計": "balance_sheet",
   "資產總額": "balance_sheet",
   "短期借款": "balance_sheet",
+  "長期借款": "balance_sheet",
   "透過損益按公允價值衡量之金融負債－流動": "balance_sheet",
   "應付票據": "balance_sheet",
   "應付帳款": "balance_sheet",

neurostats_API/utils/data_process.py

@@ -1,5 +1,6 @@
 from importlib.resources import files
 import json
+import numpy as np
 import pandas as pd
 import yaml
 
@@ -117,8 +118,9 @@ class StatsProcessor:
             sliced_table = sliced_table.pivot(index='level_1',
                                               columns='level_0',
                                               values=target_index).sort_index(
-                                                axis=1, level = 1,ascending = False
-                                              )
+                                                  axis=1,
+                                                  level=1,
+                                                  ascending=False)
 
             sliced_table.columns = sliced_table.columns.get_level_values(1)
             sliced_table.columns.name = None
@@ -136,3 +138,27 @@ class StatsProcessor:
             ]
             return return_table
 
+    @classmethod
+    def cal_percentage(cls, value, postfix="%"):
+        if (isinstance(value, (float, int))):
+            value = np.round(value * 100 , 2).item()
+            value = f"{value:.2f}{postfix}"
+
+            return value
+
+        else:
+            return value
+
+    @classmethod
+    def cal_non_percentage(cls, value, to_str=False, postfix="元"):
+        if (isinstance(value, (float, int))):
+            value = np.round(value, 2).item()
+            if (to_str):
+                value = f"{value:.2f}{postfix}"
+                return value
+
+            else:
+                return value
+
+        else:
+            return value

{neurostats_API-0.0.7.dist-info → neurostats_API-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neurostats-API
-Version: 0.0.7
+Version: 0.0.8
 Summary: The service of NeuroStats website
 Home-page: https://github.com/NeurowattStats/NeuroStats_API.git
 Author: JasonWang@Neurowatt
@@ -78,7 +78,7 @@ pip install neurostats-API
 ```Python 
 >>> import neurostats_API
 >>> print(neurostats_API.__version__)
-0.0.6
+0.0.8
 ```
 
 ### 得到最新一期的評價資料與歷年評價
@@ -379,11 +379,12 @@ stats_fetcher.query_data()
 
 ### 現金流量表
 ``` Python
-from neurostats_API.utils import StatsFetcher, DBClient
+from neurostats_API.fetchers import CashFlowFetcher
 db_client = DBClient("<連接的DB位置>").get_client()
-fetcher = StatsFetcher(db_client)
 ticker = 2330 # 換成tw50內任意ticker
-stats_fetcher.get_cash_flow(ticker)
+fetcher = StatsFetcher(ticker, db_client)
+
+stats_fetcher.query()
 ```
 #### 回傳
 ```Python

{neurostats_API-0.0.7.dist-info → neurostats_API-0.0.8.dist-info}/RECORD

@@ -1,26 +1,26 @@
-neurostats_API/__init__.py,sha256=3Kn8sHWnxjlagph2LmftcF8JLlcMlmQIbU5t_jzgK3w,19
+neurostats_API/__init__.py,sha256=9_jSwg7P5SlFv0Ci2ZSYBcAbygp9XV2C8sryRO8tvko,19
 neurostats_API/cli.py,sha256=UJSWLIw03P24p-gkBb6JSEI5dW5U12UvLf1L8HjQD-o,873
 neurostats_API/main.py,sha256=QcsfmWivg2Dnqw3MTJWiI0QvEiRs0VuH-BjwQHFCv00,677
 neurostats_API/fetchers/__init__.py,sha256=U_OMG-mLpsVKYnCBrW2OjFuCzvPeVQ__7A676vGzztY,313
-neurostats_API/fetchers/balance_sheet.py,sha256=FPsVobaNzFOxpXCo1Ui_rPmlG1crTRj9ukqQ4J8aiJg,4268
+neurostats_API/fetchers/balance_sheet.py,sha256=kOpk_83qeNgfhjF44UEmma8k6V6qTsIaFYiEcSVV20A,4910
 neurostats_API/fetchers/base.py,sha256=NW2SFzrimyAIrdJx1LVmTazelyZOAtcj54kJKHc4Vaw,1662
-neurostats_API/fetchers/cash_flow.py,sha256=muVnteEEyeFPapGqgBOoHa8PAieEI796rHPNi5otOMY,7009
-neurostats_API/fetchers/finance_overview.py,sha256=t5QlTM0bL3fkrqlyMn8-8GB6YgMLsofH9NRI8PfPRxE,18447
+neurostats_API/fetchers/cash_flow.py,sha256=5xN5YPGb7i4slDYe_KI2ucL4kh733iC5LLOEmm4J8mM,7137
+neurostats_API/fetchers/finance_overview.py,sha256=-cUb4wWr02xKhNCAXLuduhpvXsO0b14hJLqJqhagooY,25307
 neurostats_API/fetchers/month_revenue.py,sha256=RNA7ROl2vm8Xbib3k50p_1shsHDVSKIbHkyNiRa8yMw,3182
-neurostats_API/fetchers/profit_lose.py,sha256=ffEVNo7-fvtnAq2_gj-Ga55TGW7pPd6WhruOZH8NGYM,4463
+neurostats_API/fetchers/profit_lose.py,sha256=aCvcTbe1FjR3oi8QIDZg0c6G7-r0B-cCdfj6Rtlw0Jw,4870
 neurostats_API/fetchers/tech.py,sha256=wH1kkqiETQhF0HAhk-UIiucnZ3EiL85Q-yMWCcVOiFM,11395
 neurostats_API/fetchers/value_invest.py,sha256=tg8yELbVnTFTEclrwgXnCRW377KkcoLiP-Gk2pyM-9Y,2886
 neurostats_API/tools/balance_sheet.yaml,sha256=dKTMbsYR9EFp48WAzmm_ISHMiJQLyE0V-XWS_gkxmr0,541
 neurostats_API/tools/cash_flow_percentage.yaml,sha256=fk2Z4eb1JjGFvP134eJatHacB7BgTkBenhDJr83w8RE,1345
-neurostats_API/tools/finance_overview_dict.yaml,sha256=Vvf8bv23NwJP8Yyw8DPS8c0_jjT_Wctnnz51SHS4AeI,2335
+neurostats_API/tools/finance_overview_dict.yaml,sha256=URL1IFqO0j5uOwN3xETHriy_u9lYbLvdwghuznenP2Q,2500
 neurostats_API/tools/profit_lose.yaml,sha256=qHBnqG7fR4Pxc_c3n4raL-3l7o5RnABLz9YGOXoaGiA,2086
-neurostats_API/tools/seasonal_data_field_dict.txt,sha256=KlIIdTTdbvUd9TSDE9-gpzk2jt2ck_LdisX8cnrWMD4,7869
+neurostats_API/tools/seasonal_data_field_dict.txt,sha256=Za1fJR1yERbqrX8TgsS2kmMYMbaye43Gu_5ukUNBCNM,7904
 neurostats_API/utils/__init__.py,sha256=FTYKRFzW2XVXdnSHXnS3mQQaHlKF9xGqrMsgZZ2kroc,142
-neurostats_API/utils/data_process.py,sha256=rRKf2H0X2J-tDXDreErcz3Y3TGb8_0Q6GKe0izRjnmA,4942
+neurostats_API/utils/data_process.py,sha256=m1B4EhCNSzOMfTBDtYCjkQSjbDTAEFC6TNf3NNxV36k,5657
 neurostats_API/utils/datetime.py,sha256=I9CIgZdE5OMzUciOS5wvapOVEIrXG_0Qb6iDKfIod6c,574
 neurostats_API/utils/db_client.py,sha256=OYe6yazcR4Aa6jYmy47JrryUeh2NnKGqY2K_lSZe6i8,455
 neurostats_API/utils/fetcher.py,sha256=VbrUhjA-GG5AyjPX2SHtFIbZM4dm3jo0RgZzuCbb_Io,40927
-neurostats_API-0.0.7.dist-info/METADATA,sha256=Ajugxp0vnHoxdzriFfmLhTt32ckq2VnIiIO_eRU2QDo,18241
-neurostats_API-0.0.7.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-neurostats_API-0.0.7.dist-info/top_level.txt,sha256=nSlQPMG0VtXivJyedp4Bkf86EOy2TpW10VGxolXrqnU,15
-neurostats_API-0.0.7.dist-info/RECORD,,
+neurostats_API-0.0.8.dist-info/METADATA,sha256=SCspApNeq7b9pflJC30SaOVCdZtQjBIbh6QOps9HnGw,18232
+neurostats_API-0.0.8.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+neurostats_API-0.0.8.dist-info/top_level.txt,sha256=nSlQPMG0VtXivJyedp4Bkf86EOy2TpW10VGxolXrqnU,15
+neurostats_API-0.0.8.dist-info/RECORD,,