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

neurostats_API/fetchers/month_revenue.py

@@ -0,0 +1,92 @@
+from .base import StatsFetcher, StatsDateTime
+import json
+import pandas as pd
+from ..utils import StatsDateTime, StatsProcessor
+import importlib.resources as pkg_resources
+import yaml
+
+
+class MonthRevenueFetcher(StatsFetcher):
+    """
+        iFa.ai: 財務分析 -> 每月營收
+    """
+
+    def __init__(self, ticker, db_client):
+        super().__init__(ticker, db_client)
+
+    def prepare_query(self, target_year, target_month):
+        pipeline = super().prepare_query()
+
+        pipeline.append({
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "monthly_data": {
+                    "$sortArray": {
+                        "input": "$monthly_data",
+                        "sortBy": {
+                            "year": -1,
+                            "month": -1
+                        }
+                    }
+                },
+            }
+        })
+
+        return pipeline
+
+    def collect_data(self, target_year, target_month):
+        pipeline = self.prepare_query(target_year, target_month)
+
+        fetched_data = self.collection.aggregate(pipeline)
+
+        fetched_data = list(fetched_data)
+
+        return fetched_data[-1]
+
+    def query_data(self):
+        today = StatsDateTime.get_today()
+        target_month = today.month
+        target_year = today.year
+
+        # Query data
+        fetched_data = self.collect_data(target_year, target_month)
+
+        return self.process_data(fetched_data)
+
+    def process_data(self, fetched_data):
+
+        monthly_data = fetched_data['monthly_data']
+        target_month = monthly_data[0]['month']
+        monthly_df = pd.DataFrame(monthly_data)
+        target_month_df = monthly_df[monthly_df['month'] == target_month]
+        month_revenue_df = monthly_df.pivot(index='month',
+                                            columns='year',
+                                            values='revenue')
+
+        grand_total_df = target_month_df.pivot(index='month',
+                                               columns='year',
+                                               values='grand_total')
+
+        grand_total_df.rename(index={target_month: f"grand_total"},
+                              inplace=True)
+        month_revenue_df = 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[
+            'this_month_revenue_over_years'] = target_month_df.set_index(
+                "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
+
+        fetched_data.pop("monthly_data")
+
+        return fetched_data

neurostats_API/fetchers/profit_lose.py

@@ -0,0 +1,141 @@
+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 yaml
+
+
+
+class ProfitLoseFetcher(StatsFetcher):
+    """
+    iFa.ai: 財務分析 -> 損益表
+    """
+
+    def __init__(self, ticker, db_client):
+        super().__init__(ticker, db_client)
+
+        self.table_settings = StatsProcessor.load_yaml("profit_lose.yaml")
+
+    def prepare_query(self, target_season):
+        pipeline = super().prepare_query()
+
+        target_query = {
+            "year": "$$target_season_data.year",
+            "season": "$$target_season_data.season",
+            "balance_sheet": "$$$$target_season_data.balance_sheet"
+        }
+
+        pipeline.append({
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "profit_loses": {
+                    "$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",
+                                    "profit_lose":
+                                    "$$target_season_data.profit_lose"
+                                }
+                            }
+                        },
+                        "sortBy": {
+                            "year": -1
+                        }  # 按 year 降序排序
+                    }
+                }
+            }
+        })
+
+        return pipeline
+
+    def collect_data(self, target_season):
+        pipeline = self.prepare_query(target_season)
+
+        fetched_data = self.collection.aggregate(pipeline)
+
+        return list(fetched_data)[-1]
+
+    def query_data(self):
+        today = StatsDateTime.get_today()
+
+        target_season = today.season
+        target_season = target_season - 1 if target_season > 1 else 4
+
+        fetched_data = self.collect_data(target_season)
+
+        return self.process_data(fetched_data, target_season)
+
+    def process_data(self, fetched_data, target_season):
+
+        profit_loses = fetched_data['profit_loses']
+
+        index_names = []
+
+        table_dict = dict()
+        grand_total_dict = dict()
+
+        return_dict = {
+            "ticker": fetched_data['ticker'],
+            "company_name": fetched_data['company_name'],
+        }
+
+        for data in profit_loses:
+            year = data['year']
+
+            time_index = f"{year}Q{target_season}"
+
+            # 蒐集整體的keys
+            index_names += list(data['profit_lose'].keys())
+            profit_lose = data['profit_lose']
+
+            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
+
+                    except KeyError:
+                        if (index_name not in table_dict.keys()):
+                            table_dict[index_name] = dict()
+                            grand_total_dict[index_name] = dict()
+
+                        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)
+
+        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)
+
+        return return_dict

neurostats_API/tools/balance_sheet.yaml

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

neurostats_API/tools/cash_flow_percentage.yaml

@@ -0,0 +1,39 @@
+# 注意此並非用於slicing
+CASHO:
+  main_index: 營業活動之淨現金流入（流出）
+  index: 
+    - 繼續營業單位稅前淨利（淨損）
+    - 收益費損項目合計
+    - 折舊費用
+    - 攤銷費用
+    - 與營業活動相關之資產及負債之淨變動合計
+    - 營業活動之淨現金流入（流出）
+
+CASHI:
+  main_index: 投資活動之淨現金流入（流出）
+  index: 
+    - 投資活動之淨現金流入（流出）
+    - 取得不動產、廠房及設備
+    - 處分不動產、廠房及設備
+    - 取得無形資產
+    - 處分無形資產
+    - 取得透過損益按公允價值衡量之金融資產
+    - 處分透過損益按公允價值衡量之金融資產
+    - 取得透過其他綜合損益按公允價值衡量之金融資產
+    - 處分透過其他綜合損益按公允價值衡量之金融資產
+    - 取得按攤銷後成本衡量之金融資產
+    - 處分按攤銷後成本衡量之金融資產
+    - 按攤銷後成本衡量之金融資產到期還本
+  
+CASHO:
+  main_index: 籌資活動之淨現金流入（流出）
+  index: 
+    - 籌資活動之淨現金流入（流出）
+    - 短期借款增加
+    - 短期借款減少
+    - 發行公司債
+    - 償還公司債
+    - 舉借長期借款
+    - 償還長期借款
+    - 發放現金股利
+    - 庫藏股票買回成本

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/profit_lose.yaml

@@ -9,7 +9,7 @@ revenue:
   target_index: 營業收入合計
 
 grand_total_revenue:
-  mode: grand_total_values
+  mode: grand_total_growth
   target_index: 營業收入合計 
 
 gross_profit:

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,18 +1,164 @@
 from importlib.resources import files
 import json
+import numpy as np
+import pandas as pd
 import yaml
 
+target_metric_dict = {
+    'value': ['value'],
+    'value_and_percentage': ['value', 'percentage'],
+    'percentage': ['percentage'],
+    'grand_total': ['grand_total'],
+    'grand_total_values': ['grand_total', 'grand_total_percentage'],
+    'grand_total_percentage': ['grand_total_percentage'],
+    'growth': [f'YoY_{i}' for i in [1, 3, 5, 10]],
+    'grand_total_growth': [f"grand_total_YoY_{i}" for i in [1, 3, 5, 10]]
+}
+
+
 class StatsProcessor:
+
     @classmethod
-    def load_txt(cls, filename, json_load = True):
+    def load_txt(cls, filename, json_load=True):
         txt_path = files('neurostats_API.tools').joinpath(filename)
         with open(txt_path, 'r', encoding='utf-8') as f:
-            data = json.load(f) if (json_load) else f.read() 
+            data = json.load(f) if (json_load) else f.read()
         return data
+
     @classmethod
     def load_yaml(cls, filename):
         yaml_path = files('neurostats_API.tools').joinpath(filename)
         with open(yaml_path, 'r', encoding='utf-8') as f:
             data = yaml.safe_load(f)
 
-        return data
+        return data
+
+    @classmethod
+    def expand_value_percentage(cls, dataframe):
+
+        expanded_columns = {}
+        for col in dataframe.columns:
+            # Use json_normalize to split 'value' and 'percentage'
+            expanded_df = pd.json_normalize(
+                dataframe[col]).add_prefix(f"{col}_")
+            expanded_df.index = dataframe.index
+            # Append the expanded columns to the new DataFrame
+            expanded_columns[col] = expanded_df
+
+        expanded_df = pd.concat(expanded_columns.values(), axis=1)
+
+        return expanded_df
+
+    @classmethod
+    def slice_table(
+            cls,
+            total_table,
+            mode='value',
+            target_index=None,  # None or Str， 要特別抓哪個index
+    ):
+        """
+        total_table: column應為 <時間>_<單位>
+        對只有單層column的table，切出想要的index
+        """
+        times = [
+            column.split("_")[0] for column in total_table.columns.unique()
+        ]  #取出timeIndex
+        try:
+            target_metrics = target_metric_dict[mode]
+        except KeyError as e:
+            return f"mode Error: Get mode should be {list(target_metric_dict.keys())} but get {mode}"
+
+        desired_order = [
+            f"{time}_{value_name}" for time in times
+            for value_name in target_metrics
+        ]
+
+        if (target_index):
+            target_index = target_index.split()
+            sliced_table = total_table.loc[target_index, desired_order].T
+
+            return sliced_table.T
+
+        else:
+            return total_table.loc[:, desired_order]
+
+    @classmethod
+    def slice_multi_col_table(
+            cls,
+            total_table,
+            mode='value',
+            target_index=None,  # None or Str， 要特別抓哪個index
+    ):
+        """
+        對Multicolumn的dataframe切出目標的index
+        """
+        times = total_table.columns.get_level_values(0).unique()
+        try:
+            target_metrics = target_metric_dict[mode]
+        except KeyError as e:
+            return f"mode Error: Get mode should be {list(target_metric_dict.keys())} but get {mode}"
+
+        desired_order = [(time, value_name) for time in times
+                         for value_name in target_metrics]
+
+        if (target_index):
+            target_index = target_index.split()
+            sliced_table = total_table.loc[
+                target_index, pd.IndexSlice[:,
+                                            target_metrics]][desired_order].T
+            if (mode == 'value_and_percentage'):  # 因應balance_sheet 頁面的格式
+                return_table = sliced_table.T
+                return_table.columns = [
+                    "_".join(flatten_indexs)
+                    for flatten_indexs in return_table.columns.to_flat_index()
+                ]
+                return return_table
+
+            sliced_table = sliced_table.reset_index()
+            sliced_table = sliced_table.pivot(index='level_1',
+                                              columns='level_0',
+                                              values=target_index).sort_index(
+                                                  axis=1,
+                                                  level=1,
+                                                  ascending=False)
+
+            sliced_table.columns = sliced_table.columns.get_level_values(1)
+            sliced_table.columns.name = None
+            sliced_table.index.name = None
+
+            return sliced_table.reindex(target_metrics)
+
+        else:
+            return_table = total_table.loc[:, pd.IndexSlice[:,
+                                                            target_metrics]][
+                                                                desired_order]
+            return_table.columns = [
+                "_".join(flatten_indexs)
+                for flatten_indexs in return_table.columns.to_flat_index()
+            ]
+            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