neurostats-API 0.0.24__py3-none-any.whl → 0.0.25__py3-none-any.whl

neurostats_API/fetchers/finance_overview.py

@@ -1,8 +1,17 @@
 from .base import StatsFetcher, StatsDateTime
+from datetime import datetime
 import json
 import numpy as np
 import pandas as pd
-from ..utils import StatsDateTime, StatsProcessor
+from pymongo import ASCENDING, DESCENDING
+import pytz
+import holidays
+import warnings
+warnings.filterwarnings(
+    "ignore",
+    category=holidays.deprecations.v1_incompatibility.FutureIncompatibilityWarning
+)
+from ..utils import StatsDateTime, StatsProcessor, NoCompanyError
 import importlib.resources as pkg_resources
 import yaml
 
@@ -16,9 +25,11 @@ class FinanceOverviewFetcher(StatsFetcher):
         super().__init__(ticker, db_client)
 
         self.target_fields = StatsProcessor.load_yaml(
-            "twse/finance_overview_dict.yaml")
+            "twse/finance_overview_dict.yaml"
+        )
         self.inverse_dict = StatsProcessor.load_txt(
-            "twse/seasonal_data_field_dict.txt", json_load=True)
+            "twse/seasonal_data_field_dict.txt", json_load=True
+        )
 
     def prepare_query(self, target_year, target_season):
 
@@ -33,47 +44,56 @@ class FinanceOverviewFetcher(StatsFetcher):
             try:
                 small_targets = target_sets['field']
 
-                value_index = target_sets['value']  # "金額" or "%"
+                value_index = target_sets['value']    # "金額" or "%"
 
                 for small_target in small_targets:
                     big_target = self.inverse_dict[
-                    small_target]  # balance_sheet/profit_lose/cash_flow
+                        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}"
-                    })
+                    target_query.update(
+                        {
+                            f"{key}":
+                            f"$$target_season_data.{big_target}.{small_target}.{value_index}"
+                        }
+                    )
             except Exception:
                 continue
 
-        pipeline.append({
-            "$project": {
-                "_id": 0,
-                "ticker": 1,
-                "company_name": 1,
-                "seasonal_data": {
-                    "$map": {
-                        "input": {
-                            "$filter": {
-                                "input": "$seasonal_data",
-                                "as": "season",
-                                "cond": {
-                                    "$and": [{
-                                        "$eq": ["$$season.year", target_year]
-                                    }, {
-                                        "$eq":
-                                        ["$$season.season", target_season]
-                                    }]
+        pipeline.append(
+            {
+                "$project": {
+                    "_id": 0,
+                    "ticker": 1,
+                    "company_name": 1,
+                    "seasonal_data": {
+                        "$map": {
+                            "input": {
+                                "$filter": {
+                                    "input": "$seasonal_data",
+                                    "as": "season",
+                                    "cond": {
+                                        "$and": [
+                                            {
+                                                "$eq":
+                                                ["$$season.year", target_year]
+                                            }, {
+                                                "$eq": [
+                                                    "$$season.season",
+                                                    target_season
+                                                ]
+                                            }
+                                        ]
+                                    }
                                 }
-                            }
-                        },
-                        "as": "target_season_data",
-                        "in": target_query
+                            },
+                            "as": "target_season_data",
+                            "in": target_query
+                        }
                     }
                 }
             }
-        })
+        )
 
         return pipeline
 
@@ -90,7 +110,8 @@ class FinanceOverviewFetcher(StatsFetcher):
 
         try:
             latest_time = StatsDateTime.get_latest_time(
-                self.ticker, self.collection)['last_update_time']
+                self.ticker, self.collection
+            )['last_update_time']
             year = latest_time['seasonal_data']['latest_year']
             season = latest_time['seasonal_data']['latest_season']
         except Exception as e:
@@ -107,7 +128,7 @@ class FinanceOverviewFetcher(StatsFetcher):
         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()):
@@ -121,68 +142,76 @@ class FinanceOverviewProcessor(StatsProcessor):
         for key in finance_dict:
             if ('YoY' in key):
                 finance_dict[key] = StatsProcessor.cal_percentage(
-                    finance_dict[key])
+                    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='%')
+                    finance_dict[key], to_str=True, postfix='%'
+                )
             else:
                 finance_dict[key] = StatsProcessor.cal_non_percentage(
-                    finance_dict[key])
-    
-    
+                    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"
+            "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="千元")
+                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):
         methods = [
-            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_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:
             method(finance_dict)
 
-
     @classmethod
     def cal_EBIT(cls, finance_dict):
         """
@@ -190,9 +219,10 @@ class FinanceOverviewProcessor(StatsProcessor):
         EBIT = 營業收入 - 營業成本 - 營業費用 - 所得稅費用
         """
         try:
-            EBIT = (finance_dict['revenue'] - finance_dict['operating_cost'] -
-                    finance_dict['operating_expenses'] -
-                    finance_dict['tax_fee'])
+            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
@@ -205,8 +235,10 @@ class FinanceOverviewProcessor(StatsProcessor):
         自由現金流 =  營業現金流 + 投資現金流
         """
         try:
-            fcf = (finance_dict["operating_cash_flow"] +
-                   finance_dict["financing_cash_flow"])
+            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
@@ -238,8 +270,9 @@ class FinanceOverviewProcessor(StatsProcessor):
         流通股數 = 本期淨利 ÷ 基本每股盈餘
         """
         try:
-            finance_dict["share_outstanding"] = (finance_dict['net_income'] /
-                                                 finance_dict['eps'])
+            finance_dict["share_outstanding"] = (
+                finance_dict['net_income'] / finance_dict['eps']
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['share_outstanding'] = None
             # print(f"share_outstanding failed because of {str(e)}")
@@ -251,11 +284,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股營收 = 營業收入 / 在外流通股數
         """
         try:
-            revenue_per_share = (finance_dict['revenue'] /
-                                 finance_dict['share_outstanding'])
-            finance_dict[
-                'revenue_per_share'] = StatsProcessor.cal_non_percentage(
-                    revenue_per_share, False)
+            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)}")
@@ -269,17 +304,17 @@ class FinanceOverviewProcessor(StatsProcessor):
         if ('gross_profit' not in finance_dict.keys()):
             try:
                 finance_dict['gross_profit'] = (
-                    finance_dict['revenue'] - 
-                    finance_dict['operating_cost']
+                    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'])
-            finance_dict[
-                'gross_per_share'] = StatsProcessor.cal_non_percentage(
-                    gross_per_share, False)
+            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
@@ -292,11 +327,14 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股營業利益= （當期營業利益）÷（當期在外流通股數）
         """
         try:
-            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)
+            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)}")
@@ -310,10 +348,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             operating_cash_flow_per_share = (
                 finance_dict["operating_cash_flow"] /
-                finance_dict['share_outstanding'])
-            finance_dict[
-                "operating_cash_flow_per_share"] = StatsProcessor.cal_non_percentage(
-                    operating_cash_flow_per_share)
+                finance_dict['share_outstanding']
+            )
+            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)}')
@@ -325,10 +365,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         每股自由現金流 = (當期自由現金流) ÷（當期在外流通股數）
         """
         try:
-            fcf_per_share = (finance_dict['fcf'] /
-                             finance_dict['share_outstanding'])
+            fcf_per_share = (
+                finance_dict['fcf'] / finance_dict['share_outstanding']
+            )
             finance_dict['fcf_per_share'] = StatsProcessor.cal_non_percentage(
-                fcf_per_share)
+                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)}")
@@ -344,7 +386,7 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             roa = (
                 finance_dict['net_income'] + finance_dict['interest'] +
-                (1 * 0.1)  # 有效稅率需要改，這裡先設0.1
+                (1 * 0.1)    # 有效稅率需要改，這裡先設0.1
             ) / finance_dict['inventories']
 
             finance_dict["roa"] = StatsProcessor.cal_percentage(roa)
@@ -369,10 +411,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算營業毛利/總資產
         """
         try:
-            gross_over_asset = (finance_dict['gross_profit'] /
-                                finance_dict['total_assets'])
+            gross_over_asset = (
+                finance_dict['gross_profit'] / finance_dict['total_assets']
+            )
             finance_dict['gross_over_asset'] = StatsProcessor.cal_percentage(
-                gross_over_asset)
+                gross_over_asset
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['gross_over_asset'] = None
             # print(f"營業毛利/總資產 failed because of {str(e)}")
@@ -384,10 +428,15 @@ class FinanceOverviewProcessor(StatsProcessor):
         ROCE = (稅前淨利＋利息費用) / (資產總額－流動負債)
         """
         try:
-            roce = ((finance_dict['net_income_before_tax'] +
-                     finance_dict['interest']) /
-                    (finance_dict['total_assets'] -
-                     finance_dict['current_liabilities']))
+            roce = (
+                (
+                    finance_dict['net_income_before_tax'] +
+                    finance_dict['interest']
+                ) / (
+                    finance_dict['total_assets'] -
+                    finance_dict['current_liabilities']
+                )
+            )
             finance_dict['roce'] = StatsProcessor.cal_percentage(roce)
 
         except (KeyError, ZeroDivisionError, TypeError) as e:
@@ -401,11 +450,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業毛利率 = 營業毛利 ÷ 營業收入
         """
         try:
-            gross_profit_margin = (finance_dict['gross_profit'] /
-                                   finance_dict['revenue'])
-            finance_dict[
-                'gross_profit_margin'] = StatsProcessor.cal_percentage(
-                    gross_profit_margin)
+            gross_profit_margin = (
+                finance_dict['gross_profit'] / finance_dict['revenue']
+            )
+            finance_dict['gross_profit_margin'] = StatsProcessor.cal_percentage(
+                gross_profit_margin
+            )
         except Exception as e:
             finance_dict['gross_profit_margin'] = None
             # print(f"gross_profit_margin failed because of {str(e)}")
@@ -419,10 +469,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             operation_profit_rate = (
                 finance_dict['revenue'] - finance_dict['operating_cost'] -
-                finance_dict['operating_expenses']) / finance_dict['revenue']
-            finance_dict[
-                "operation_profit_rate"] = StatsProcessor.cal_percentage(
-                    operation_profit_rate)
+                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)}")
@@ -435,10 +487,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         """
         try:
             operating_cash_flow_profit_rate = (
-                finance_dict["operating_cash_flow"] / finance_dict["revenue"])
-            finance_dict[
-                "operating_cash_flow_profit_rate"] = StatsProcessor.cal_percentage(
-                    operating_cash_flow_profit_rate)
+                finance_dict["operating_cash_flow"] / finance_dict["revenue"]
+            )
+            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(
@@ -460,10 +514,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         DSO = 365 × (應收帳款平均餘額 ÷ 營業收入)
         """
         try:
-            dso = (365 *
-                   (finance_dict['account_pay'] / finance_dict['revenue']))
+            dso = (
+                365 * (finance_dict['account_pay'] / finance_dict['revenue'])
+            )
             finance_dict['dso'] = StatsProcessor.cal_non_percentage(
-                dso, to_str=True, postfix="日")
+                dso, to_str=True, postfix="日"
+            )
         except Exception as e:
             finance_dict['dso'] = None
             # print(f"Error calculating 應收帳款收現天數 because of {str(e)}")
@@ -475,14 +531,15 @@ class FinanceOverviewProcessor(StatsProcessor):
         = 應收帳款平均餘額 ÷ 營業收入
         """
         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)
+            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
+            finance_dict["account_receive_over_revenue"] = None
 
     @classmethod
     def cal_dpo(cls, finance_dict):
@@ -493,9 +550,11 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             dpo = (
                 365 *
-                (finance_dict['account_pay'] / finance_dict['operating_cost']))
+                (finance_dict['account_pay'] / finance_dict['operating_cost'])
+            )
             finance_dict["dpo"] = StatsProcessor.cal_non_percentage(
-                dpo, to_str=True, postfix="日")
+                dpo, to_str=True, postfix="日"
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["dpo"] = None
             # print(f"應付帳款週轉天數 failed because of {str(e)}")
@@ -507,12 +566,14 @@ class FinanceOverviewProcessor(StatsProcessor):
         = 銷貨成本 ÷ 存貨
         """
         try:
-            inventories_cycle_ratio = (finance_dict['operating_cost'] /
-                                       finance_dict['inventories'])
-
-            finance_dict[
-                "inventories_cycle_ratio"] = StatsProcessor.cal_percentage(
-                    inventories_cycle_ratio)
+            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)}")
@@ -525,10 +586,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         MUDA MUDA MUDA !!!
         """
         try:
-            dio = 365 * (finance_dict["inventories"] /
-                         finance_dict["operating_cost"])
+            dio = 365 * (
+                finance_dict["inventories"] / finance_dict["operating_cost"]
+            )
             finance_dict["dio"] = StatsProcessor.cal_non_percentage(
-                dio, to_str=True, postfix="日")
+                dio, to_str=True, postfix="日"
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict["dio"] = None
             # print(f"Error calculating 存貨週轉天數 because of {str(e)}")
@@ -540,12 +603,14 @@ class FinanceOverviewProcessor(StatsProcessor):
         存貨佔營收比= 存貨 ÷ 營業收入
         """
         try:
-            inventories_revenue_ratio = (finance_dict['inventories'] /
-                                         finance_dict['revenue'])
-
-            finance_dict[
-                "inventories_revenue_ratio"] = StatsProcessor.cal_percentage(
-                    inventories_revenue_ratio)
+            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)}")
@@ -557,12 +622,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         存貨週轉天數 + 應收帳款週轉天數 - 應付帳款週轉天數
         """
         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="日")
+            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
 
@@ -573,10 +639,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業收入 ÷ 資產總額
         """
         try:
-            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)
+                asset_turnover
+            )
         except Exception as e:
             finance_dict["asset_turnover"] = None
 
@@ -587,15 +655,14 @@ class FinanceOverviewProcessor(StatsProcessor):
         營業收入 ÷ 不動產、廠房與設備平均餘額
         """
         try:
-            applcation_turnover = (finance_dict['revenue'] /
-                                   finance_dict["application"])
-            finance_dict[
-                'application_turnover'] = StatsProcessor.cal_percentage(
-                    applcation_turnover)
+            applcation_turnover = (
+                finance_dict['revenue'] / finance_dict["application"]
+            )
+            finance_dict['application_turnover'
+                         ] = StatsProcessor.cal_percentage(applcation_turnover)
 
         except Exception as e:
             finance_dict['application_turnover'] = None
-        
 
     @classmethod
     def cal_current_ratio(cls, finance_dict):
@@ -603,10 +670,13 @@ class FinanceOverviewProcessor(StatsProcessor):
         計算流動比率 = 流動資產 / 流動負債
         """
         try:
-            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)
+                current_ratio
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['current_ratio'] = None
             # print(f"Error calculating current ratio: {e}")
@@ -618,11 +688,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         (流動資產 - 存貨) / 流動負債
         """
         try:
-            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)
+                quick_ratio
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['quick_ratio'] = None
             # print(f"Error calculating quick ratio: {e}")
@@ -633,11 +704,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         # 負債權益比率 = 總負債 / 股東權益
         """
         try:
-            debt_to_equity_ratio = finance_dict[
-                'total_liabilities'] / finance_dict['equity']
-            finance_dict[
-                'debt_to_equity_ratio'] = StatsProcessor.cal_percentage(
-                    debt_to_equity_ratio)
+            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}")
@@ -652,9 +724,10 @@ class FinanceOverviewProcessor(StatsProcessor):
                 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)
+            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}")
@@ -667,9 +740,10 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             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="倍")
+            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}")
@@ -682,9 +756,10 @@ class FinanceOverviewProcessor(StatsProcessor):
         try:
             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)
+            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}")
@@ -695,11 +770,12 @@ class FinanceOverviewProcessor(StatsProcessor):
         # 有息負債 / 自由現金流
         """
         try:
-            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)
+            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}")
@@ -713,7 +789,250 @@ class FinanceOverviewProcessor(StatsProcessor):
             cash_flow_ratio = finance_dict[
                 'operating_cash_flow'] / finance_dict['current_liabilities']
             finance_dict['cash_flow_ratio'] = StatsProcessor.cal_percentage(
-                cash_flow_ratio)
+                cash_flow_ratio
+            )
         except (KeyError, ZeroDivisionError, TypeError) as e:
             finance_dict['cash_flow_ratio'] = None
             # print(f"Error calculating cash flow ratio: {e}")
+
+
+class AgentFinanceOverviewFetcher(FinanceOverviewFetcher):
+    """
+    目前僅適用美股
+    """
+
+    def __init__(self, ticker, db_client):
+        self.ticker = ticker
+        self.timezone = pytz.timezone("Asia/Taipei")
+        self.tw_company_list = StatsProcessor.load_json("company_list/tw.json")
+        self.us_company_list = StatsProcessor.load_json("company_list/us_TradingView_list.json")
+
+        if (ticker not in self.us_company_list.keys()):
+            raise NoCompanyError("class \"AgentFinanceOverviewFetcher\" only supports US company now")
+
+        db_name = "company" if self.ticker in self.tw_company_list else "company_us"
+        self.db = db_client[db_name]
+
+        daily_collection_name_map = {
+            "company": "twse_daily_share_price",
+            'company_us': "us_technical"
+        }
+
+        seasonal_collection_name_map = {
+            'company': "twse_seasonal_report",
+            "company_us": "us_fundamentals"
+        }
+
+        self.daily_collection_name = daily_collection_name_map.get(db_name)
+        self.seasonal_collection_name = seasonal_collection_name_map.get(
+            db_name
+        )
+
+        assert self.daily_collection_name != "unknown", f"請確認 {ticker} 是否是 {','.join(list(daily_collection_name_map.values()))}"
+        assert self.seasonal_collection_name != "unknown", f"請確認 {ticker} 是否是 {','.join(list(seasonal_collection_name_map.values()))}"
+        self.daily_collection = db_client[db_name][self.daily_collection_name]
+        self.seasonal_collection = db_client[db_name][
+            self.seasonal_collection_name]
+
+    def query_data(self, date=None):
+
+        query_set = self._prepare_query(date)
+        if (date is None):
+            str_date = datetime.today().strftime("%Y-%m-%d")
+        if (isinstance(date, datetime)):
+            str_date = date.strftime("%Y-%m-%d")
+        elif (isinstance(date, str)):
+            str_date = date
+
+        daily_query, daily_projection, daily_sorting = query_set['daily']
+        seasonal_query, seasonal_projection, seasonal_sorting = query_set[
+            'seasonal']
+
+        daily_datas = self.daily_collection.find(daily_query, daily_projection
+                                                 ).sort(daily_sorting)
+        seasonal_datas = self.seasonal_collection.find(
+            seasonal_query, seasonal_projection
+        ).sort(seasonal_sorting)
+
+        daily_data = [data for data in daily_datas]
+        seasonal_data = [
+            {
+                **data['balance_sheet'],
+                **data['income_statement'],
+                **data['cash_flow']
+            } for data in seasonal_datas
+        ]
+
+        seasonal_df = pd.DataFrame(seasonal_data)
+        TTM_data = seasonal_df.mean()
+
+        return_dict = {
+            "date": str_date,
+            "ticker": self.ticker,
+            "company_name": self._get_company_name(),
+            "category": self._get_category(),
+            "market_open": self._is_us_market_open(),
+            "latest_close":
+            self._get_latest_close(daily_data),
+            "close_offset":
+            self._get_latest_offset(daily_data).get("value", "0.0"),
+            "close_offset_percentage":
+            self._get_latest_offset(daily_data).get("percentage", "0.0%"),
+            "latest_volume":
+            self._get_latest_volume(daily_data),
+            "average_volume":
+            self._get_latest_average_volume(daily_data, 30),
+            "market_capitalzation":
+            self._get_market_capitalization(daily_data, seasonal_data),
+            "P_E":
+            self._get_PE(daily_data, TTM_data),
+            "P_S":
+            self._get_PS(daily_data, TTM_data, seasonal_data),
+        }
+
+        return return_dict
+
+    def _prepare_query(self, date=None):
+        if (date is None):
+            date = datetime.today()
+        elif (isinstance(date, str)):
+            date = datetime.strptime(date, "%Y-%m-%d")
+
+        daily_query = {"ticker": self.ticker, "date": {"$lte": date}}
+
+        seasons = []
+        year = date.year
+        season = (date.month - 1) // 3 + 1
+
+        for _ in range(4):
+            seasons.append({"year": year, "season": season})
+            year = year if season != 1 else year - 1
+            season = season - 1 if season != 1 else 4
+
+        seasonal_query = {"ticker": self.ticker, "$or": seasons}
+
+        daily_projection = {"_id": 0}
+        seasonal_projection = {"_id": 0}
+
+        daily_sorting = {"date": ASCENDING}
+        seasonal_sorting = {"year": ASCENDING, "season": ASCENDING}
+
+        query_set = {
+            "daily": [daily_query, daily_projection, daily_sorting],
+            "seasonal": [seasonal_query, seasonal_projection, seasonal_sorting]
+        }
+
+        return query_set
+
+    def _get_latest_close(self, daily_data):
+        latest_close = daily_data[-1]['close']
+        latest_close = str(round(latest_close, 2))
+        return latest_close
+
+    def _get_latest_offset(self, daily_data):
+        latest_close = daily_data[-1]['close']
+        previous = daily_data[-2]['close']
+
+        offset = latest_close - previous
+        percentage = offset / previous
+
+        offset = str(np.round(offset, 2))
+
+        return {'value': offset, "percentage": f"{percentage:.2f}%"}
+
+    def _get_latest_volume(self, daily_data):
+        try:
+            volume = round(daily_data[-1]['volume'], 2)
+            return str(volume)
+        except Exception as e:
+            return "Error"
+
+    def _get_latest_average_volume(self, daily_data, length=30):
+        try:
+            daily_data = pd.DataFrame(daily_data).tail(length)
+
+            value = daily_data['volume'].mean().item()
+            value = round(value, 2)
+
+            return str(value)
+
+        except Exception as e:
+            return "Error"
+
+    def _get_market_capitalization(self, daily_data, seasonal_data):
+        try:
+            latest_close = float(self._get_latest_close(daily_data))
+            latest_common_share = seasonal_data[-1][
+                'Common Stock']
+
+            percentage = round((latest_close * latest_common_share), 2)
+
+            return str(percentage)
+
+        except Exception as e:
+            return "Error"
+
+    def _get_PE(self, daily_data, TTM_data):
+        try:
+            latest_close = float(self._get_latest_close(daily_data))
+            TTM_EPS = TTM_data['Diluted EPS']
+
+            value = round((latest_close / TTM_EPS), 2)
+
+            return str(value)
+
+        except Exception as e:
+            return "Error"
+
+    def _get_PS(self, daily_data, TTM_data, seasonal_data):
+        try:
+            market_capitalzation = self._get_market_capitalization(daily_data, seasonal_data)
+            market_capitalzation = float(market_capitalzation)
+            TTM_revenue = TTM_data['Total Revenue']
+
+            value = round((market_capitalzation / TTM_revenue), 2)
+
+            return str(value)
+        except Exception as e:
+            return "Error"
+
+    def _is_us_market_open(self):
+        
+        taiwan_dt = datetime.now(pytz.timezone('Asia/Taipei'))
+
+        # 轉成美東時間（會自動處理夏令時間）
+        eastern = pytz.timezone('US/Eastern')
+        us_dt = taiwan_dt.astimezone(eastern)
+
+        # 假日判斷
+        us_holidays = holidays.NYSE(years=us_dt.year)
+        if us_dt.date() in us_holidays:
+            return False
+
+        # 週末
+        if us_dt.weekday() >= 5:  # 5 = Saturday, 6 = Sunday
+            return False
+
+        # 判斷是否在開盤時間
+        market_open = us_dt.replace(hour=9, minute=30, second=0, microsecond=0)
+        market_close = us_dt.replace(hour=16, minute=0, second=0, microsecond=0)
+        
+        return market_open <= us_dt <= market_close
+    
+    def _get_category(self):
+        category = self.us_company_list.get(self.ticker,{}).get('en_industry')
+
+        if (category):
+            return category
+
+        else:
+            raise ValueError("No company")
+    
+    def _get_company_name(self):
+        company_name = self.us_company_list.get(self.ticker,{}).get('name')
+
+        if (company_name):
+            return company_name
+
+        else:
+            raise ValueError("No company")