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

neurostats_API/__init__.py

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

neurostats_API/fetchers/__init__.py

@@ -1,3 +1,7 @@
 from .base import StatsDateTime, StatsFetcher
+from .balance_sheet import BalanceSheetFetcher
+from .cash_flow import CashFlowFetcher
 from .finance_overview import FinanceOverviewFetcher
+from .month_revenue import MonthRevenueFetcher
+from .profit_lose import ProfitLoseFetcher
 from .value_invest import ValueFetcher

neurostats_API/fetchers/balance_sheet.py

@@ -0,0 +1,122 @@
+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 BalanceSheetFetcher(StatsFetcher):
+    """
+    對應iFa.ai -> 財務分析 ->  資產負債表
+    """
+
+    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()
+
+        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,
+            "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"
+                            }
+                        }
+                    },
+                    "sortBy": { "year": -1 }  # 按 year 降序排序
+                }
+            }
+        }
+    })
+
+        return pipeline
+
+    def collect_data(self, target_year, target_season):
+        pipeline = self.prepare_query(target_year, target_season)
+
+        fetched_data = self.collection.aggregate(pipeline)
+
+        fetched_data = list(fetched_data)
+
+        return fetched_data[-1]
+
+    def query_data(self):
+        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
+        fetched_data = self.collect_data(year, season)
+
+        return self.process_data(season, fetched_data)
+
+    def process_data(self, target_season, fetched_data):
+        return_dict = {
+            "ticker": self.ticker,
+            "company_name": fetched_data['company_name']
+        }
+
+        index_names = []
+
+        table_dict = dict()
+
+        balance_sheets = fetched_data['balance_sheets']
+
+        # 將value與percentage跟著年分季度一筆筆取出
+        for data in balance_sheets:
+            year = data['year']
+
+            time_index = f"{year}Q{target_season}"
+
+             # 蒐集整體的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
+
+                    except KeyError:
+                        if (index_name not in table_dict.keys()):
+                            table_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)
+
+        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)
+
+            print(f"{name}: {return_dict[name].columns}")
+        return return_dict

neurostats_API/fetchers/cash_flow.py

@@ -0,0 +1,181 @@
+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 CashFlowFetcher(StatsFetcher):
+    def __init__(self, ticker, db_client):
+        super().__init__(ticker, db_client)
+
+        self.cash_flow_dict = StatsProcessor.load_yaml(
+            "cash_flow_percentage.yaml"
+        )  # 計算子表格用
+    
+    def prepare_query(self, target_season):
+        pipeline = super().prepare_query()
+
+        pipeline.append({
+            "$project": {
+                "_id": 0,
+                "ticker": 1,
+                "company_name": 1,
+                "cash_flows": {
+                    "$sortArray": {
+                        "input": {
+                            "$map": {
+                                "input": {
+                                    "$filter": {
+                                        "input": "$seasonal_data",
+                                        "as": "season",
+                                        "cond": {
+                                            "$eq":
+                                            ["$$season.season", target_season]
+                                        }
+                                    }
+                                },
+                                "as": "target_season_data",
+                                "in": {
+                                    "year":
+                                    "$$target_season_data.year",
+                                    "season":
+                                    "$$target_season_data.season",
+                                    "cash_flow":
+                                    "$$target_season_data.cash_flow"
+                                }
+                            }
+                        },
+                        "sortBy": {
+                            "year": -1
+                        }  # 按 year 降序排序
+                    }
+                }
+            }
+        })
+
+        return pipeline
+    
+    def collect_data(self, target_season):
+        pipeline = self.prepare_query(target_season)
+
+        fetched_data = self.collection.aggregate(pipeline)
+
+        return list(fetched_data)[0]
+    
+    def query_data(self):
+        today = StatsDateTime.get_today()
+
+        target_season = today.season - 1 if (today.season > 1) else 4
+
+        fetched_data = self.collect_data(target_season)
+
+        return self.process_data(fetched_data, target_season)
+    
+    def process_data(self, fetched_data, target_season):
+        """
+        處理現金流量表頁面的所有表格
+        金流表本身沒有比例 但是Ifa有算，
+        項目所屬的情況也不一(分別所屬營業,投資,籌資三個活動)
+        所以這裡選擇不用slicing處理
+        """
+        cash_flows = fetched_data['cash_flows']
+
+        index_names = []
+        column_names = []
+
+        table_dict = dict()
+        CASHO_dict = dict()
+        CASHI_dict = dict()
+        CASHF_dict = dict()
+
+        return_dict = {
+            "ticker": fetched_data['ticker'],
+            "company_name": fetched_data['company_name'],
+            "cash_flow": dict(),
+            "CASHO": dict(),
+            "CASHI": dict(),
+            "CASHF": dict()
+        }
+
+        checkpoints = ["營業活動之現金流量－間接法", "投資活動之現金流量", "籌資活動之現金流量", "匯率變動對現金及約當現金之影響"]
+        main_cash_flows = [
+            "營業活動之淨現金流入（流出）", "投資活動之淨現金流入（流出）", "籌資活動之淨現金流入（流出）", None
+        ] # 主要的比例對象
+        partial_cash_flows = [CASHO_dict, CASHI_dict, CASHF_dict, dict()] 
+
+        # 作法: dictionary中也有checkpoints，如果出現了就換下一個index去計算
+
+        for data in cash_flows:
+            year = data['year']
+
+            time_index = f"{year}Q{target_season}"
+
+            cash_flow = data['cash_flow']
+            main_cash_flow_name = None
+            partial_cash_flow = None
+            next_checkpoint = 0
+
+            for index_name, value in cash_flow.items():
+                if (next_checkpoint < 3
+                        and index_name == checkpoints[next_checkpoint]): # 找到了主要的變動點
+                    main_cash_flow_name = main_cash_flows[next_checkpoint]
+                    partial_cash_flow = partial_cash_flows[next_checkpoint]
+                    next_checkpoint += 1
+                try:
+                    table_dict[time_index][index_name]['value'] = value[
+                        'value']
+                    if (value['value']):
+                        table_dict[time_index][index_name][
+                            'percentage'] = value['value'] / cash_flow[
+                                main_cash_flow_name]['value']
+                    else:
+                        table_dict[time_index][index_name][
+                            'percentage'] = None
+                except:
+                    if (time_index not in table_dict.keys()):
+                        table_dict[time_index] = dict()
+                    table_dict[time_index][index_name] = dict()
+
+                    table_dict[time_index][index_name]['value'] = value[
+                        'value']
+                    if (value['value']):
+                        table_dict[time_index][index_name][
+                            'percentage'] = value['value'] / cash_flow[
+                                main_cash_flow_name]['value']
+                    else:
+                        table_dict[time_index][index_name][
+                            'percentage'] = None
+
+                try:
+                    partial_cash_flow[time_index][index_name] = table_dict[
+                        time_index][index_name]
+                except:
+                    if (time_index not in partial_cash_flow.keys()):
+                        partial_cash_flow[time_index] = dict()
+                    partial_cash_flow[time_index][index_name] = table_dict[
+                        time_index][index_name]
+
+            index_names += list(cash_flow.keys())
+
+        # 轉成dictionary keys
+        index_names = list(dict.fromkeys(index_names))
+
+        cash_flow_table = pd.DataFrame(table_dict)
+        cash_flow_table = StatsProcessor.expand_value_percentage(cash_flow_table)
+
+        CASHO_table = pd.DataFrame(CASHO_dict)
+        CASHO_table = StatsProcessor.expand_value_percentage(CASHO_table)
+
+        CASHI_table = pd.DataFrame(CASHI_dict)
+        CASHI_table = StatsProcessor.expand_value_percentage(CASHI_table)
+
+        CASHF_table = pd.DataFrame(CASHF_dict)
+        CASHF_table = StatsProcessor.expand_value_percentage(CASHF_table)
+
+        return_dict['cash_flow'] = cash_flow_table
+        return_dict['CASHO'] = CASHO_table
+        return_dict['CASHI'] = CASHI_table
+        return_dict['CASHF'] = CASHF_table
+
+        return return_dict

neurostats_API/fetchers/finance_overview.py

@@ -82,7 +82,9 @@ class FinanceOverviewFetcher(StatsFetcher):
     def query_data(self):
         today = StatsDateTime.get_today()
 
-        fetched_data = self.collect_data(2024, 2)
+        year = today.year - 1 if (today.season == 1) else today.year
+        season = 4 if (today.season == 1) else today.season - 2
+        fetched_data = self.collect_data(year, season)
         finance_dict = fetched_data['seasonal_data'][0]
         FinanceOverviewProcessor.process_all(finance_dict)
         fetched_data['seasonal_data'] = finance_dict

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,131 @@
+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 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():
+                    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)
+
+        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/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: