neurostats-API 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

neurostats_API/__init__.py

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

neurostats_API/fetchers/__init__.py

@@ -2,6 +2,7 @@ from .base import StatsDateTime, StatsFetcher
 from .balance_sheet import BalanceSheetFetcher
 from .cash_flow import CashFlowFetcher
 from .finance_overview import FinanceOverviewFetcher
+from .institution import InstitutionFetcher
 from .month_revenue import MonthRevenueFetcher
 from .profit_lose import ProfitLoseFetcher
 from .value_invest import ValueFetcher

neurostats_API/fetchers/balance_sheet.py

@@ -116,10 +116,13 @@ class BalanceSheetFetcher(StatsFetcher):
                     try:  # table_dict[項目][(2020Q1, '%')]
                         if (item_name == 'percentage'):
                             if (isinstance(item, (float, int))):
-                                item = np.round(item, 2)
-                        if ("YoY" in item_name):
+                                item = StatsProcessor.cal_non_percentage(item, to_str=True, postfix="%")
+                        elif ("YoY" in item_name):
                             if (isinstance(item, (float, int))):
-                                item = np.round(item * 100, 2)
+                                item = StatsProcessor.cal_percentage(item)
+                        else:
+                            if (isinstance(item, (float, int))):
+                                item = StatsProcessor.cal_non_percentage(item,  postfix="千元")
                         table_dict[index_name][(time_index, item_name)] = item
 
                     except KeyError:
@@ -132,10 +135,17 @@ class BalanceSheetFetcher(StatsFetcher):
         total_table.columns = pd.MultiIndex.from_tuples(total_table.columns)
 
         for name, setting in self.table_settings.items():
-            return_dict[name] = StatsProcessor.slice_multi_col_table(
-                total_table=total_table,
-                mode=setting['mode'],
-                target_index=setting['target_index']
-                if "target_index" in setting.keys() else None)
-
+            if ('target_index' in setting.keys()):
+                target_indexes = [target_index.strip() for target_index in setting['target_index']]
+            else:
+                target_indexes = [None]
+            for target_index in target_indexes:
+                try:
+                    return_dict[name] = StatsProcessor.slice_multi_col_table(
+                        total_table=total_table,
+                        mode=setting['mode'],
+                        target_index=target_index)
+                    break
+                except Exception as e:
+                    continue
         return return_dict

neurostats_API/fetchers/cash_flow.py

@@ -132,14 +132,15 @@ class CashFlowFetcher(StatsFetcher):
                     table_dict[time_index][index_name]['value'] = value[
                         'value']
                     if (value['value']):
-                        table_dict[time_index][index_name][
-                            'percentage'] = np.round(
+                        ratio = np.round(
                                 (value['value'] / cash_flow[
                                 main_cash_flow_name]['value']) * 100, 2)
+                        table_dict[time_index][index_name][
+                            'percentage'] = f"{ratio}%"
                     else:
                         table_dict[time_index][index_name][
                             'percentage'] = None
-                except:
+                except: # 新增index再做一次
                     if (time_index not in table_dict.keys()):
                         table_dict[time_index] = dict()
                     table_dict[time_index][index_name] = dict()
@@ -147,14 +148,15 @@ class CashFlowFetcher(StatsFetcher):
                     table_dict[time_index][index_name]['value'] = value[
                         'value']
                     if (value['value']):
-                        table_dict[time_index][index_name][
-                            'percentage'] = np.round(
+                        ratio = np.round(
                                 (value['value'] / cash_flow[
                                 main_cash_flow_name]['value']) * 100, 2) 
+                        table_dict[time_index][index_name][
+                            'percentage'] = f"{ratio}%"
                     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]

neurostats_API/fetchers/finance_overview.py

@@ -31,15 +31,19 @@ class FinanceOverviewFetcher(StatsFetcher):
 
         for key, target_sets in self.target_fields.items():
             try:
-                small_target = target_sets['field']
-                big_target = self.inverse_dict[
-                    small_target]  # balance_sheet/profit_lose/cash_flow
+                small_targets = target_sets['field']
+
                 value_index = target_sets['value']  # "金額" or "%"
 
-                target_query.update({
-                    f"{key}":
-                    f"$$target_season_data.{big_target}.{small_target}.{value_index}"
-                })
+                for small_target in small_targets:
+                    big_target = self.inverse_dict[
+                    small_target]  # balance_sheet/profit_lose/cash_flow
+                    if (small_target == "利息費用_bank"):
+                        small_target = small_target[:small_target.find("_bank")]
+                    target_query.update({
+                        f"{key}":
+                        f"$$target_season_data.{big_target}.{small_target}.{value_index}"
+                    })
             except Exception:
                 continue
 
@@ -98,8 +102,16 @@ class FinanceOverviewFetcher(StatsFetcher):
         finance_dict = fetched_data['seasonal_data'][0]
         FinanceOverviewProcessor.process_rate(finance_dict)
         FinanceOverviewProcessor.process_all(finance_dict)
+        self.fill_nan_index(finance_dict)
+        FinanceOverviewProcessor.process_thousand_dollar(finance_dict)
         fetched_data['seasonal_data'] = finance_dict
+
         return fetched_data
+    
+    def fill_nan_index(self, finance_dict):
+        for key in self.target_fields.keys():
+            if (key not in finance_dict.keys()):
+                finance_dict[key] = None
 
 
 class FinanceOverviewProcessor(StatsProcessor):
@@ -116,6 +128,35 @@ class FinanceOverviewProcessor(StatsProcessor):
             else:
                 finance_dict[key] = StatsProcessor.cal_non_percentage(
                     finance_dict[key])
+    
+    
+    @classmethod
+    def process_thousand_dollar(cls, finance_dict):
+        process_index = [
+            "revenue",
+            "gross_profit",
+            "operating_income",
+            "net_income",
+            "operating_cash_flow",
+            "invest_cash_flow",
+            "financing_cash_flow",
+            "fcf",
+
+            'current_assets',
+            'current_liabilities',
+            'non_current_assets',
+            'non_current_liabilities',
+            'total_assets',
+            "total_liabilities",
+            "equity"
+        ]
+        
+        for index in process_index:
+            try:
+                finance_dict[index] = StatsProcessor.cal_non_percentage(finance_dict[index], postfix="千元")
+            except Exception as e:
+                finance_dict[index] = None
+            
 
     @classmethod
     def process_all(cls, finance_dict):
@@ -135,12 +176,13 @@ class FinanceOverviewProcessor(StatsProcessor):
             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:
             method(finance_dict)
 
+
     @classmethod
     def cal_EBIT(cls, finance_dict):
         """
@@ -224,7 +266,14 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算每股毛利
         = （當期營業毛利）÷（當期在外流通股數）
         """
-
+        if ('gross_profit' not in finance_dict.keys()):
+            try:
+                finance_dict['gross_profit'] = (
+                    finance_dict['revenue'] - 
+                    finance_dict['operating_cost']
+                )
+            except:
+                finance_dict['gross_profit'] = None
         try:
             gross_per_share = (finance_dict['gross_profit'] /
                                finance_dict['share_outstanding'])
@@ -267,7 +316,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                     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)}')
+            # print(f'operating_cash_flow_per_share because of {str(e)}')
 
     @classmethod
     def fcf_per_share(cls, finance_dict):
@@ -292,12 +341,15 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算資產報酬率(ROA)
         ROA = [ 本期淨利 + 利息費用 × (1-有效稅率) ] ÷（資產總額）
         """
-        roa = (
-            finance_dict['net_income'] + finance_dict['interest'] +
-            (1 * 0.1)  # 有效稅率需要改，這裡先設0.1
-        ) / finance_dict['inventories']
+        try:
+            roa = (
+                finance_dict['net_income'] + finance_dict['interest'] +
+                (1 * 0.1)  # 有效稅率需要改，這裡先設0.1
+            ) / finance_dict['inventories']
 
-        finance_dict["roa"] = StatsProcessor.cal_percentage(roa)
+            finance_dict["roa"] = StatsProcessor.cal_percentage(roa)
+        except Exception as e:
+            finance_dict["roa"] = None
 
     @classmethod
     def cal_roe(cls, finance_dict):
@@ -305,8 +357,11 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算股東權益報酬率(ROE)
         ROE = (本期淨利) ÷（權益總額）
         """
-        roe = (finance_dict['net_income'] / finance_dict['equity'])
-        finance_dict['roe'] = StatsProcessor.cal_percentage(roe)
+        try:
+            roe = (finance_dict['net_income'] / finance_dict['equity'])
+            finance_dict['roe'] = StatsProcessor.cal_percentage(roe)
+        except Exception as e:
+            finance_dict['roe'] = None
 
     @classmethod
     def cal_gross_over_asset(cls, finance_dict):
@@ -315,7 +370,7 @@ class FinanceOverviewProcessor(StatsProcessor):
         """
         try:
             gross_over_asset = (finance_dict['gross_profit'] /
-                                finance_dict['total_asset'])
+                                finance_dict['total_assets'])
             finance_dict['gross_over_asset'] = StatsProcessor.cal_percentage(
                 gross_over_asset)
         except (KeyError, ZeroDivisionError, TypeError) as e:
@@ -331,7 +386,7 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             roce = ((finance_dict['net_income_before_tax'] +
                      finance_dict['interest']) /
-                    (finance_dict['total_asset'] -
+                    (finance_dict['total_assets'] -
                      finance_dict['current_liabilities']))
             finance_dict['roce'] = StatsProcessor.cal_percentage(roce)
 
@@ -351,7 +406,7 @@ class FinanceOverviewProcessor(StatsProcessor):
             finance_dict[
                 'gross_profit_margin'] = StatsProcessor.cal_percentage(
                     gross_profit_margin)
-        except:
+        except Exception as e:
             finance_dict['gross_profit_margin'] = None
             print(f"gross_profit_margin failed because of {str(e)}")
 
@@ -409,7 +464,7 @@ class FinanceOverviewProcessor(StatsProcessor):
                    (finance_dict['account_pay'] / finance_dict['revenue']))
             finance_dict['dso'] = StatsProcessor.cal_non_percentage(
                 dso, to_str=True, postfix="日")
-        except:
+        except Exception as e:
             finance_dict['dso'] = None
             print(f"Error calculating 應收帳款收現天數 because of {str(e)}")
 
@@ -419,11 +474,15 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算應收帳款佔營收比率
         = 應收帳款平均餘額 ÷ 營業收入
         """
-        account_receive_over_revenue = (finance_dict['account_receive'] /
-                                        finance_dict['revenue'])
-        finance_dict[
-            "account_receive_over_revenue"] = StatsProcessor.cal_percentage(
-                account_receive_over_revenue)
+        try:
+            account_receive_over_revenue = (finance_dict['account_receive'] /
+                                            finance_dict['revenue'])
+            finance_dict[
+                "account_receive_over_revenue"] = StatsProcessor.cal_percentage(
+                    account_receive_over_revenue)
+        except Exception as e:
+            finance_dict[
+                "account_receive_over_revenue"] = None
 
     @classmethod
     def cal_dpo(cls, finance_dict):
@@ -513,10 +572,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算資產周轉率
         營業收入 ÷ 資產總額
         """
-        asset_turnover = (finance_dict["revenue"] /
-                          finance_dict["inventories"])
-        finance_dict["asset_turnover"] = StatsProcessor.cal_percentage(
-            asset_turnover)
+        try:
+            asset_turnover = (finance_dict["revenue"] /
+                            finance_dict["inventories"])
+            finance_dict["asset_turnover"] = StatsProcessor.cal_percentage(
+                asset_turnover)
+        except Exception as e:
+            finance_dict["asset_turnover"] = None
 
     @classmethod
     def cal_application_turnover(cls, finance_dict):
@@ -528,11 +590,12 @@ class FinanceOverviewProcessor(StatsProcessor):
             applcation_turnover = (finance_dict['revenue'] /
                                    finance_dict["application"])
             finance_dict[
-                'applcation_turnover'] = StatsProcessor.cal_percentage(
+                'application_turnover'] = StatsProcessor.cal_percentage(
                     applcation_turnover)
 
-        except (KeyError, ZeroDivisionError, TypeError) as e:
+        except Exception as e:
             finance_dict['application_turnover'] = None
+        
 
     @classmethod
     def cal_current_ratio(cls, finance_dict):

neurostats_API/fetchers/institution.py

@@ -0,0 +1,214 @@
+from .base import StatsFetcher
+from datetime import datetime, timedelta
+import json
+import numpy as np
+import pandas as pd
+from ..utils import StatsDateTime, StatsProcessor
+import importlib.resources as pkg_resources
+import yaml
+
+
+class InstitutionFetcher(StatsFetcher):
+    """
+    iFa -> 交易資訊 -> 法人買賣
+
+    包括: 
+    1. 當日交易
+    2. 一年內交易
+    """
+
+    def __init__(self, ticker, db_client):
+        super().__init__(ticker, db_client)
+
+    def prepare_query(self, start_date, end_date):
+        pipeline = super().prepare_query()
+
+        # target_query = {
+        #     "date": date,
+        #     "institution_trading": "$$target_season_data.institution_trading"
+        # }
+
+        pipeline.append({
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "daily_data": {
+                    "$map": {
+                        "input": {
+                            "$filter": {
+                                "input": "$daily_data",
+                                "as": "daily",
+                                "cond": {
+                                    "$and": [{
+                                        "$gte": ["$$daily.date", start_date]
+                                    }, {
+                                        "$lte": ["$$daily.date", end_date]
+                                    }]
+                                }
+                            }
+                        },
+                        "as": "target_daily_data",
+                        "in": "$$target_daily_data"
+                    }
+                }
+            }
+        })
+
+        return pipeline
+
+    def collect_data(self, start_date, end_date):
+        pipeline = self.prepare_query(start_date, end_date)
+
+        fetched_data = self.collection.aggregate(pipeline).to_list()
+
+        return fetched_data[-1]
+
+    def query_data(self):
+        try:
+            latest_time = StatsDateTime.get_latest_time(
+                self.ticker, self.collection)['last_update_time']
+            latest_date = latest_time['institution_trading'][
+                'latest_date']
+            date = latest_date.replace(hour=0,
+                                       minute=0,
+                                       second=0,
+                                       microsecond=0)
+        except Exception as e:
+            print(
+                f"No updated time for institution_trading in {self.ticker}, use current time instead"
+            )
+            date = datetime.now(self.timezone)
+            date = date.replace(hour=0, minute=0, second=0, microsecond=0)
+
+            if (date.hour < 17):  # 拿不到今天的資料
+                date = date - timedelta(days=1)
+
+        start_date = date - timedelta(days=365)
+
+        daily_data = self.collect_data(start_date, end_date=date)
+
+        daily_data = sorted(daily_data['daily_data'],
+                            key=lambda x: x['date'],
+                            reverse=True)
+
+        table_dict = self.process_data(daily_data)
+
+        return table_dict
+
+    def process_data(self, daily_data):
+        table_dict = dict()
+
+        latest_data = daily_data[0]
+        yesterday_data = daily_data[1]
+
+        # 交易價格與昨天交易
+        price_dict = {
+            "open": latest_data['open'],
+            'close': latest_data['close'],
+            'range': f"{latest_data['low']}-{latest_data['high']}",
+            'volumn': latest_data['volume'] / 1000,
+            'last_open': yesterday_data['open'],
+            'last_close': yesterday_data['close'],
+            'last_range': f"{yesterday_data['low']}-{yesterday_data['high']}",
+            'last_volumn': yesterday_data['volume'] / 1000
+        }
+        # 一年範圍
+        annual_lows = [data['low'] for data in daily_data]
+        annual_highs = [data['high'] for data in daily_data]
+        lowest = np.min(annual_lows).item()
+        highest = np.max(annual_highs).item()
+
+        price_dict['52weeks_range'] = f"{lowest}-{highest}"
+        table_dict['price'] = price_dict
+
+        # 發行股數 & 市值
+
+        # 今日法人買賣
+        table_dict['latest_trading'] = {
+            "date":
+            daily_data[0]['date'],
+            "table":
+            self.process_latest_trading(daily_data[0]['institution_trading'], daily_data[0]['volume'])
+        }
+        # 一年內法人
+        annual_trading = [
+            {
+                **data['institution_trading'],
+                "收盤價": int(data['close'])
+            }
+            for data in daily_data
+        ]  # 將close也併入這個表格
+        annual_dates = [data['date'] for data in daily_data]
+        table_dict['annual_trading'] = self.process_annual_trading(
+            annual_dates, annual_trading)
+        
+        return table_dict
+
+    def process_latest_trading(self, latest_trading, volume):
+        latest_table = {
+            "foreign": self.default_institution_chart(),
+            "mutual": self.default_institution_chart(),
+            "prop": self.default_institution_chart(),
+            "institutional_investor":self.default_institution_chart(),
+        }
+
+        for key in latest_trading.keys():
+            if (key.find("外陸資") >= 0 or key.find("外資") >= 0):
+                self.target_institution(latest_trading, latest_table['foreign'], key, volume)
+            elif (key.find("自營商") >= 0):
+                self.target_institution(latest_trading,latest_table['prop'], key, volume)
+            elif (key.find("投信") >= 0):
+                self.target_institution(latest_trading,latest_table['mutual'], key, volume)
+            elif (key.find("三大法人") >= 0):
+                self.target_institution(latest_trading,latest_table['institutional_investor'], key, volume)
+
+        frames = []
+        for category, trades in latest_table.items():
+            temp_df = pd.DataFrame(trades).T
+            temp_df['category'] = category
+            frames.append(temp_df)
+        
+        latest_df = pd.concat(frames)
+        latest_df = latest_df.reset_index().rename(columns={'index': 'type'})
+        latest_df = latest_df[['type', 'category', 'stock', 'price', 'average_price', 'percentage']]
+
+        return latest_df
+
+    def process_annual_trading(self, dates, annual_tradings):
+        dates = [date.strftime("%m/%d") for date in dates]
+        return pd.DataFrame(annual_tradings, index=dates)
+
+    def target_institution(self, old_table, new_table, key, volume):
+        if (key.find("買進") >= 0):
+            self.cal_institution(old_table, new_table['buy'], key, volume)
+        elif (key.find("賣出") >= 0):
+            self.cal_institution(old_table, new_table['sell'], key, volume)
+        elif (key.find("買賣超") >= 0):
+            self.cal_institution(old_table, new_table['over_buy_sell'], key, volume)
+        
+    def cal_institution(self, old_table, new_table, key, volume):
+        new_table['stock'] = np.round(old_table[key] / 1000, 2).item()
+        new_table['percentage'] = np.round((old_table[key] / volume) * 100, 2).item()
+    
+    def default_institution_chart(self):
+        return {
+            "buy": {
+                "stock": 0,
+                "price": 0,
+                "average_price": 0,
+                "percentage": 0
+            },
+            "sell": {
+                "stock": 0,
+                "price": 0,
+                "average_price": 0,
+                "percentage": 0
+            },
+            "over_buy_sell": {
+                "stock": 0,
+                "price": 0,
+                "average_price": 0,
+                "percentage": 0
+            },
+        }

neurostats_API/fetchers/month_revenue.py

@@ -64,6 +64,17 @@ class MonthRevenueFetcher(StatsFetcher):
     def process_data(self, fetched_data):
 
         monthly_data = fetched_data['monthly_data']
+        for data in monthly_data:
+            for key, value in data.items():
+                if ("YoY" in key):
+                    data[key] = StatsProcessor.cal_percentage(value)
+                elif ("ratio" in key or 'percentage' in key):
+                    data[key] = StatsProcessor.cal_non_percentage(value,
+                                                                  to_str=True,
+                                                                  postfix="%")
+                elif (key not in ('year', 'month')):
+                    data[key] = StatsProcessor.cal_non_percentage(value,
+                                                                  postfix="千元")
         target_month = monthly_data[0]['month']
         monthly_df = pd.DataFrame(monthly_data)
         target_month_df = monthly_df[monthly_df['month'] == target_month]
@@ -77,21 +88,26 @@ class MonthRevenueFetcher(StatsFetcher):
 
         grand_total_df.rename(index={target_month: f"grand_total"},
                               inplace=True)
-        month_revenue_df = month_revenue_df.sort_index(ascending = False)
+        month_revenue_df = month_revenue_df.sort_index(ascending=False)
         month_revenue_df = pd.concat([grand_total_df, month_revenue_df],
                                      axis=0)
 
-        fetched_data['month_revenue'] = month_revenue_df[sorted(month_revenue_df.columns, reverse = True)]
+        fetched_data['month_revenue'] = month_revenue_df[sorted(
+            month_revenue_df.columns, reverse=True)]
         # 歷年月營收
         fetched_data[
             'this_month_revenue_over_years'] = target_month_df.set_index(
-                "year")[["revenue", "revenue_increment_ratio", "YoY_1",
-                        "YoY_3", "YoY_5", "YoY_10"]].T
+                "year")[[
+                    "revenue", "revenue_increment_ratio", "YoY_1", "YoY_3",
+                    "YoY_5", "YoY_10"
+                ]].T
         # 歷年營收成長量
         fetched_data['grand_total_over_years'] = target_month_df.set_index(
-            "year")[["grand_total", "grand_total_increment_ratio",
-                    "grand_total_YoY_1", "grand_total_YoY_3",
-                    "grand_total_YoY_5", "grand_total_YoY_10"]].T
+            "year")[[
+                "grand_total", "grand_total_increment_ratio",
+                "grand_total_YoY_1", "grand_total_YoY_3", "grand_total_YoY_5",
+                "grand_total_YoY_10"
+            ]].T
 
         fetched_data.pop("monthly_data")
 

neurostats_API/fetchers/profit_lose.py

@@ -115,12 +115,15 @@ 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 ('percentage' in item_name):
                         if (isinstance(item, (float, int))):
-                            item = np.round(item, 2)
-                    if ('YoY' in item_name):
+                            item = StatsProcessor.cal_non_percentage(item, to_str=True, postfix="%")
+                    elif ('YoY' in item_name):
                         if (isinstance(item, (float, int))):
-                            item = np.round(item * 100, 2)
+                            item = StatsProcessor.cal_percentage(item)
+                    else:
+                        if (isinstance(item, (float, int))):
+                            item = StatsProcessor.cal_non_percentage(item,  postfix="千元")
                     try:
                         table_dict[index_name][(time_index, item_name)] = item
 
@@ -137,10 +140,19 @@ class ProfitLoseFetcher(StatsFetcher):
         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,
-                mode=setting['mode'],
-                target_index=setting['target_index']
-                if "target_index" in setting.keys() else None)
+            if ('target_index' in setting.keys()):
+                target_indexes = [target.strip() for target in setting['target_index']]
+            else:
+                target_indexes = [None]
+            
+            for target_index in target_indexes:
+                try:
+                    return_dict[name] = StatsProcessor.slice_multi_col_table(
+                        total_table=total_table,
+                        mode=setting['mode'],
+                        target_index=target_index)
+                    break
+                except Exception as e:
+                    continue
 
         return return_dict

neurostats_API/tools/balance_sheet.yaml

@@ -3,24 +3,32 @@ balance_sheet:
 
 total_asset:
   mode: value_and_percentage
-  target_index: 資產總額 負債總額 權益總額
-
+  target_index: 
+    - 資產總額 負債總額 權益總額
+    - 資產總計 負債總計 權益總計
+ 
 current_asset:
   mode: value_and_percentage
-  target_index: 流動資產合計
+  target_index: 
+    - 流動資產合計
 
 non_current_asset:
   mode: value_and_percentage
-  target_index: 非流動資產合計
+  target_index: 
+    - 非流動資產合計
 
 current_debt:
   mode: value_and_percentage
-  target_index: 流動負債合計
+  target_index: 
+    - 流動負債合計
 
 non_current_debt:
   mode: value_and_percentage
-  target_index: 非流動負債合計
+  target_index: 
+    - 非流動負債合計
 
 equity:
   mode: value_and_percentage
-  target_index: 權益總額
+  target_index: 
+    - 權益總額
+    - 權益總計

neurostats_API/tools/finance_overview_dict.yaml

@@ -1,89 +1,111 @@
 # 財務概況
 revenue:
-  field: 營業收入合計
+  field: 
+    - 營業收入合計
   value: value
 
 gross_profit:
-  field: 營業毛利（毛損）淨額
+  field: 
+    - 營業毛利（毛損）淨額
   value: value
 
 operating_income:
-  field: 營業利益（損失）
+  field: 
+    - 營業利益（損失）
   value: value
 
 net_income:
-  field: 本期淨利（淨損）
+  field: 
+    - 本期淨利（淨損）
   value: value
 
 tax_fee:
-  field: 所得稅費用（利益）合計
+  field: 
+    - 所得稅費用（利益）合計
   value: value
 
 # TODO: 以下所爬到的資料都是累計的，Ifa有額外計算當季的變化量
 operating_cash_flow:
-  field: 營業活動之淨現金流入（流出）
+  field: 
+    - 營業活動之淨現金流入（流出）
   value: single_season_value
 
 invest_cash_flow:
-  field: 投資活動之淨現金流入（流出）
+  field: 
+    - 投資活動之淨現金流入（流出）
   value: single_season_value
 
 financing_cash_flow:
-  field: 籌資活動之淨現金流入（流出）
+  field: 
+    - 籌資活動之淨現金流入（流出）
   value: single_season_value
 # ^^^ 以上皆需要額外在DataBase處理
 
 # 每股財務狀況
 capital:
-  field: 普通股股本
+  field: 
+    - 普通股股本
   value: value
+
 eps:
-  field: 基本每股盈餘
+  field: 
+    - 基本每股盈餘
   value: value
 
 # 獲利能力
-total_asset:
-  field: 資產總額
+total_assets:
+  field: 
+    - 資產總額
   value: value
 
 equity:
-  field: 權益總額
+  field: 
+    - 權益總額
   value: value
 
 net_income_before_tax:
-  field: 稅前淨利（淨損）
+  field: 
+    - 稅前淨利（淨損）
   value: value
 
 interest:
-  field: 利息收入
+  field: 
+    - 利息收入
   value: value
 
 operating_expenses:
-  field: 營業費用合計
+  field: 
+    - 營業費用合計
   value: value
 
 net_income_rate:
-  field: 本期淨利（淨損）
+  field: 
+    - 本期淨利（淨損）
   value: percentage
 # 成長動能
 revenue_YoY:
-  field: 營業收入合計
+  field: 
+    - 營業收入合計
   value: YoY_1
 
 gross_prof_YoY:
-  field: 營業毛利（毛損）淨額
+  field: 
+    - 營業毛利（毛損）淨額
   value: YoY_1
 
 operating_income_YoY:
-  field: 營業利益（損失）
+  field: 
+    - 營業利益（損失）
   value: YoY_1
 
 net_income_YoY:
-  field: 本期淨利（淨損）
+  field: 
+    - 本期淨利（淨損）
   value: YoY_1
 
 operating_cash_flow_YoY:
-  field: 營業活動之淨現金流入（流出）
+  field: 
+    - 營業活動之淨現金流入（流出）
   value: single_season_YoY
 
 # operating_cash_flow_per_share_YoY:
@@ -91,53 +113,73 @@ operating_cash_flow_YoY:
 #   value: YoY_1
 # 營運指標
 account_receive:
-  field: 應收帳款淨額
+  field: 
+    - 應收帳款淨額
   value: value
 
 account_pay:
-  field: 應付帳款
+  field: 
+    - 應付帳款
   value: value
 
 inventories:
-  field: 存貨
+  field: 
+    - 存貨
   value: value
 
 operating_cost:
-  field: 營業成本合計
+  field: 
+    - 營業成本合計
   value: value
 
 application:
-  field: 不動產、廠房及設備
+  field: 
+    - 不動產、廠房及設備
   value: value
 
 # 財務韌性
 current_assets:
-  field: 流動資產合計
+  field: 
+    - 流動資產合計
   value: value
 
 current_liabilities:
-  field: 流動負債合計
+  field: 
+    - 流動負債合計
   value: value
 
 total_liabilities:
-  field: 負債總額
+  field: 
+    - 負債總額
   value: value
 
 short_term_liabilities:
-  field: 短期借款
+  field: 
+    - 短期借款
   value: value
 
 long_term_liabilities:
-  field: 長期借款
+  field: 
+    - 長期借款
   value: value
 # 
 cash_and_cash_equivalents:
-  field: 現金及約當現金
+  field: 
+    - 現金及約當現金
   value: value
 
 interest_expense: 
-  field: 利息費用
+  field: 
+    - 利息費用
   value: value
 
+non_current_assets:
+  field: 
+    - 非流動資產合計
+  value: value
 
+non_current_liabilities:
+  field: 
+    - 非流動負債合計
+  value: value
 

neurostats_API/tools/profit_lose.yaml

@@ -6,88 +6,116 @@ grand_total_profit_lose:
 
 revenue:
   mode: growth
-  target_index: 營業收入合計
+  target_index: 
+    - 營業收入合計
+    - 利息收入
 
 grand_total_revenue:
   mode: grand_total_growth
-  target_index: 營業收入合計 
+  target_index: 
+    - 營業收入合計
+    - 利息收入
 
 gross_profit:
   mode: growth
-  target_index: 營業毛利（毛損）淨額
+  target_index: 
+    -  營業毛利（毛損）淨額
 
 grand_total_gross_profit:
   mode: grand_total_growth
-  target_index: 營業毛利（毛損）淨額
+  target_index: 
+    - 營業毛利（毛損）淨額
 
 gross_profit_percentage:
   mode: percentage
-  target_index: 營業毛利（毛損）淨額
+  target_index: 
+    - 營業毛利（毛損）淨額
 
 grand_total_gross_profit_percentage:
   mode: grand_total_percentage
-  target_index: 營業毛利（毛損）淨額
+  target_index: 
+    - 營業毛利（毛損）淨額
 # 營利
 operating_income:
   mode: growth
-  target_index: 營業利益（損失）
+  target_index: 
+    - 營業利益（損失）
 
 grand_total_operating_income:
   mode: grand_total_growth
-  target_index: 營業利益（損失）
+  target_index: 
+    - 營業利益（損失）
 
 operating_income_percentage:
   mode: percentage
-  target_index: 營業利益（損失）
+  target_index: 
+    - 營業利益（損失）
 
 grand_total_operating_income_percentage:
   mode: grand_total_percentage
-  target_index: 營業利益（損失）
+  target_index: 
+    - 營業利益（損失）
 # 稅前淨利
 net_income_before_tax:
   mode: growth
-  target_index: 稅前淨利（淨損）
+  target_index: 
+    - 稅前淨利（淨損）
 
 grand_total_net_income_before_tax:
   mode: grand_total_growth
-  target_index: 稅前淨利（淨損）
+  target_index: 
+    - 稅前淨利（淨損）
 
 net_income_before_tax_percentage:
   mode: percentage
-  target_index: 稅前淨利（淨損）
+  target_index: 
+    - 稅前淨利（淨損）
 
 grand_total_net_income_before_tax_percentage:
   mode: grand_total_percentage
-  target_index: 稅前淨利（淨損）
+  target_index: 
+    - 稅前淨利（淨損）
 # 本期淨利
 net_income:
   mode: growth
-  target_index: 本期淨利（淨損）
+  target_index: 
+    - 本期淨利（淨損）
 
 grand_total_net_income:
   mode: grand_total_growth
-  target_index: 本期淨利（淨損）
+  target_index: 
+    - 本期淨利（淨損）
 
 net_income_percentage:
   mode: percentage
-  target_index: 本期淨利（淨損）
+  target_index: 
+    - 本期淨利（淨損）
 
 grand_total_income_percentage:
   mode: grand_total_percentage
-  target_index: 本期淨利（淨損）
+  target_index: 
+    - 本期淨利（淨損）
 # EPS
 EPS:
   mode: value
-  target_index: 稀釋每股盈餘
+  target_index: 
+    - 基本每股盈餘
+    - 基本每股盈餘合計
 
 EPS_growth:
   mode: growth
-  target_index: 稀釋每股盈餘
+  target_index: 
+    - 基本每股盈餘
+    - 基本每股盈餘合計
 
 grand_total_EPS:
   mode: grand_total
-  target_index: 稀釋每股盈餘
+  target_index: 
+    - 基本每股盈餘
+    - 基本每股盈餘合計
 
 grand_total_EPS_growth:
   mode: grand_total_growth
-  target_index: 稀釋每股盈餘
+  target_index: 
+    - 基本每股盈餘
+    - 基本每股盈餘合計

neurostats_API/tools/seasonal_data_field_dict.txt

@@ -22,11 +22,14 @@
   "其他非流動資產": "balance_sheet",
   "非流動資產合計": "balance_sheet",
   "資產總額": "balance_sheet",
+  "資產總計": "balance_sheet",
   "短期借款": "balance_sheet",
   "長期借款": "balance_sheet",
   "透過損益按公允價值衡量之金融負債－流動": "balance_sheet",
   "應付票據": "balance_sheet",
   "應付帳款": "balance_sheet",
+  "應收款項－淨額": "balance_sheet",
+  "應付款項": "balance_sheet",
   "應付帳款－關係人": "balance_sheet",
   "其他應付款": "balance_sheet",
   "其他應付款項－關係人": "balance_sheet",
@@ -38,6 +41,7 @@
   "其他非流動負債": "balance_sheet",
   "非流動負債合計": "balance_sheet",
   "負債總額": "balance_sheet",
+  "負債總計": "balance_sheet",
   "普通股股本": "balance_sheet",
   "股本合計": "balance_sheet",
   "資本公積－發行溢價": "balance_sheet",
@@ -52,10 +56,12 @@
   "歸屬於母公司業主之權益合計": "balance_sheet",
   "非控制權益": "balance_sheet",
   "權益總額": "balance_sheet",
+  "權益總計": "balance_sheet",
   "負債及權益總計": "balance_sheet",
   "待註銷股本股數（單位：股）": "balance_sheet",
   "預收股款（權益項下）之約當發行股數（單位：股）": "balance_sheet",
   "母公司暨子公司所持有之母公司庫藏股股數（單位：股）": "balance_sheet",
+  "應收款項－淨額": "balance_sheet",
   "繼續營業單位稅前淨利（淨損）": "cash_flow",
   "停業單位稅前淨利（淨損）": "cash_flow",
   "本期稅前淨利（淨損）": "cash_flow",
@@ -135,6 +141,7 @@
   "管理費用": "profit_lose",
   "研究發展費用": "profit_lose",
   "營業費用合計": "profit_lose",
+  "營業費用": "profit_lose",
   "營業利益（損失）": "profit_lose",
   "其他收入": "profit_lose",
   "其他利益及損失淨額": "profit_lose",
@@ -142,6 +149,7 @@
   "營業外收入及支出合計": "profit_lose",
   "稅前淨利（淨損）": "profit_lose",
   "所得稅費用（利益）合計": "profit_lose",
+  "所得稅費用（利益）": "profit_lose",
   "繼續營業單位本期淨利（淨損）": "profit_lose",
   "本期淨利（淨損）": "profit_lose",
   "確定福利計畫之再衡量數": "profit_lose",
@@ -155,5 +163,12 @@
   "母公司業主（綜合損益）": "profit_lose",
   "非控制權益（綜合損益）": "profit_lose",
   "基本每股盈餘": "profit_lose",
-  "稀釋每股盈餘": "profit_lose"
+  "稀釋每股盈餘": "profit_lose",
+  "淨收益": "profit_lose",
+  "利息收入": "profit_lose",
+  "利息費用_bank": "profit_lose",
+  "利息淨收益": "profit_lose",
+  "繼續營業單位稅前損益": "profit_lose",
+  "本期稅後淨利（淨損）": "profit_lose",
+  "減：利息費用": "profit_lose"
 }

neurostats_API/utils/data_process.py

@@ -152,10 +152,21 @@ class StatsProcessor:
     @classmethod
     def cal_non_percentage(cls, value, to_str=False, postfix="元"):
         if (isinstance(value, (float, int))):
+            
             value = np.round(value, 2).item()
+            if (postfix == "千元"):
+                value *= 1000
+                value = int(value)
+
+                postfix = "元"
+
             if (to_str):
-                value = f"{value:.2f}{postfix}"
-                return value
+                if (isinstance(value, float)):
+                    value = f"{value:.2f}{postfix}"
+                    return value
+                elif (isinstance(value, int)):
+                    value = f"{value}{postfix}"
+                    return value
 
             else:
                 return value

{neurostats_API-0.0.9.dist-info → neurostats_API-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neurostats-API
-Version: 0.0.9
+Version: 0.0.11
 Summary: The service of NeuroStats website
 Home-page: https://github.com/NeurowattStats/NeuroStats_API.git
 Author: JasonWang@Neurowatt
@@ -19,6 +19,8 @@ Description-Content-Type: text/markdown
     - [損益表](#損益表)
     - [資產負債表](#資產負債表)
     - [現金流量表](#現金流量表)
+    - [版本紀錄](#版本紀錄)
+
 
 ## 檔案架構
 
@@ -78,7 +80,7 @@ pip install neurostats-API
 ```Python 
 >>> import neurostats_API
 >>> print(neurostats_API.__version__)
-0.0.9
+0.0.10
 ```
 
 ### 得到最新一期的評價資料與歷年評價
@@ -434,6 +436,11 @@ stats_fetcher.query()
 > 大部分資料缺失是因為尚未計算，僅先填上已經有的資料
 
 
-## TODO
-- 將utils/fetcher.py中的功能切分到fetchers資料夾中
+## 版本紀錄
+### 0.0.10
+- 更新指標的資料型態: 單位為千元乘以1000之後回傳整數
+
+- 處理銀行公司在finanace_overview會報錯誤的問題(未完全解決，因銀行公司財報有許多名稱不同，目前都會顯示為None)
 
+### 0.0.9
+- 更新指標的資料型態: 單位為日, %, 倍轉為字串

neurostats_API-0.0.11.dist-info/RECORD

@@ -0,0 +1,27 @@
+neurostats_API/__init__.py,sha256=oR5iCRZvbIRoODxS1VocreTo19N5L8Omvx_AgflzOO0,20
+neurostats_API/cli.py,sha256=UJSWLIw03P24p-gkBb6JSEI5dW5U12UvLf1L8HjQD-o,873
+neurostats_API/main.py,sha256=QcsfmWivg2Dnqw3MTJWiI0QvEiRs0VuH-BjwQHFCv00,677
+neurostats_API/fetchers/__init__.py,sha256=27kdeBuM7dNBRcIyQ1u863CYw0P_DQz-I1G6iSFDq-c,357
+neurostats_API/fetchers/balance_sheet.py,sha256=sQv4Gk5uoKURLEdh57YknOQWiyVwaXJ2Mw75jxNqUS0,5804
+neurostats_API/fetchers/base.py,sha256=NW2SFzrimyAIrdJx1LVmTazelyZOAtcj54kJKHc4Vaw,1662
+neurostats_API/fetchers/cash_flow.py,sha256=TY7VAWVXkj5-mzH5Iu0sIE-oV8MvGmmDy0URNotNV1E,7614
+neurostats_API/fetchers/finance_overview.py,sha256=PxUdWY0x030olYMLcCHDBn068JLmCE2RTOce1dxs5vM,27753
+neurostats_API/fetchers/institution.py,sha256=aODtsFyQcnD9PnMeaehMAN9wZdZ2a0EqSSZO57dY9RE,7691
+neurostats_API/fetchers/month_revenue.py,sha256=nixX2llzjCFr2m2YVjxrSfkBusnZPrPb2dRDq1XLGhw,4251
+neurostats_API/fetchers/profit_lose.py,sha256=xlLNsGSy4Azf4HyZyYaX3dFad-ACO-vuQToBooZi1_w,5698
+neurostats_API/fetchers/tech.py,sha256=wH1kkqiETQhF0HAhk-UIiucnZ3EiL85Q-yMWCcVOiFM,11395
+neurostats_API/fetchers/value_invest.py,sha256=O5IKC8Nl7p5-E-1zoyAyWtiDznaxNemeabanmaHDdJs,3327
+neurostats_API/tools/balance_sheet.yaml,sha256=yTxrWh7m4K3LnaNunETidfNzl6S4Bf58VIg9U38XShQ,648
+neurostats_API/tools/cash_flow_percentage.yaml,sha256=fk2Z4eb1JjGFvP134eJatHacB7BgTkBenhDJr83w8RE,1345
+neurostats_API/tools/finance_overview_dict.yaml,sha256=B9nV75StXkrF3yv2-eezzitlJ38eEK86RD_VY6588gQ,2884
+neurostats_API/tools/profit_lose.yaml,sha256=dcO-0J0BC4p06XBNuowu8ux0NTbyZiOkGfy6szHF6fw,2402
+neurostats_API/tools/seasonal_data_field_dict.txt,sha256=X8yc_el6p8BH_3FikTqBVFGsvWdXT6MHXLfKfi44334,8491
+neurostats_API/utils/__init__.py,sha256=FTYKRFzW2XVXdnSHXnS3mQQaHlKF9xGqrMsgZZ2kroc,142
+neurostats_API/utils/data_process.py,sha256=mDznLqAAZ7gFX3LlJkJvtrMPt38Lh5-NONqgnqT5tSY,5990
+neurostats_API/utils/datetime.py,sha256=XJya4G8b_-ZOaBbMXgQjWh2MC4wc-o6goQ7EQJQMWrQ,773
+neurostats_API/utils/db_client.py,sha256=OYe6yazcR4Aa6jYmy47JrryUeh2NnKGqY2K_lSZe6i8,455
+neurostats_API/utils/fetcher.py,sha256=VbrUhjA-GG5AyjPX2SHtFIbZM4dm3jo0RgZzuCbb_Io,40927
+neurostats_API-0.0.11.dist-info/METADATA,sha256=Tddw5SxRekTkTtemDXgYPoiJf9sxICyRkdlFAbvniSM,18529
+neurostats_API-0.0.11.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+neurostats_API-0.0.11.dist-info/top_level.txt,sha256=nSlQPMG0VtXivJyedp4Bkf86EOy2TpW10VGxolXrqnU,15
+neurostats_API-0.0.11.dist-info/RECORD,,

neurostats_API-0.0.9.dist-info/RECORD

@@ -1,26 +0,0 @@
-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=VeWhd8Z2XZnL5RzxmenLzAd4eyK2sWTuiRGkqWsEmzk,5219
-neurostats_API/fetchers/base.py,sha256=NW2SFzrimyAIrdJx1LVmTazelyZOAtcj54kJKHc4Vaw,1662
-neurostats_API/fetchers/cash_flow.py,sha256=4G4SIUoBSwT-BePmz-SprQ0IJRL2QNWqWdQtlgaRKd4,7371
-neurostats_API/fetchers/finance_overview.py,sha256=EVP7k0JkQq3ydXy0f3t2kzy12iIQEwDniTLn98qZ460,25637
-neurostats_API/fetchers/month_revenue.py,sha256=QmhMAO8jbkjg2R1LR0TAPE3bmDnyuLNjnD24ZsFkTBU,3501
-neurostats_API/fetchers/profit_lose.py,sha256=C0y42RBA-s20XcG6CJ10Rt6Gm_rB6lcvBmIzbTpn64o,5123
-neurostats_API/fetchers/tech.py,sha256=wH1kkqiETQhF0HAhk-UIiucnZ3EiL85Q-yMWCcVOiFM,11395
-neurostats_API/fetchers/value_invest.py,sha256=O5IKC8Nl7p5-E-1zoyAyWtiDznaxNemeabanmaHDdJs,3327
-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=URL1IFqO0j5uOwN3xETHriy_u9lYbLvdwghuznenP2Q,2500
-neurostats_API/tools/profit_lose.yaml,sha256=qHBnqG7fR4Pxc_c3n4raL-3l7o5RnABLz9YGOXoaGiA,2086
-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=m1B4EhCNSzOMfTBDtYCjkQSjbDTAEFC6TNf3NNxV36k,5657
-neurostats_API/utils/datetime.py,sha256=XJya4G8b_-ZOaBbMXgQjWh2MC4wc-o6goQ7EQJQMWrQ,773
-neurostats_API/utils/db_client.py,sha256=OYe6yazcR4Aa6jYmy47JrryUeh2NnKGqY2K_lSZe6i8,455
-neurostats_API/utils/fetcher.py,sha256=VbrUhjA-GG5AyjPX2SHtFIbZM4dm3jo0RgZzuCbb_Io,40927
-neurostats_API-0.0.9.dist-info/METADATA,sha256=z--BAc0e6HHBuXSQgc5ikwjPFzTfe-2o02gFLmgY_do,18232
-neurostats_API-0.0.9.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
-neurostats_API-0.0.9.dist-info/top_level.txt,sha256=nSlQPMG0VtXivJyedp4Bkf86EOy2TpW10VGxolXrqnU,15
-neurostats_API-0.0.9.dist-info/RECORD,,