neurostats-API 0.0.23b1__tar.gz → 0.0.23b2__tar.gz

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neurostats_API
-Version: 0.0.23b1
+Version: 0.0.23b2
 Summary: The service of NeuroStats website
 Home-page: https://github.com/NeurowattStats/NeuroStats_API.git
 Author: JasonWang@Neurowatt
@@ -89,7 +89,7 @@ pip install neurostats-API
 ```Python 
 >>> import neurostats_API
 >>> print(neurostats_API.__version__)
-0.0.23b
+0.0.23b2
 ```
 
 ### 得到最新一期的評價資料與歷年評價

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/README.md

@@ -73,7 +73,7 @@ pip install neurostats-API
 ```Python 
 >>> import neurostats_API
 >>> print(neurostats_API.__version__)
-0.0.23b
+0.0.23b2
 ```
 
 ### 得到最新一期的評價資料與歷年評價

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/__init__.py

@@ -1,4 +1,4 @@
-__version__='0.0.23b'
+__version__='0.0.23b2'
 
 from .fetchers import (
     BalanceSheetFetcher,

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/fetchers/institution.py

@@ -1,5 +1,5 @@
 from .base import StatsFetcher
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, date
 import json
 import numpy as np
 import pandas as pd
@@ -28,53 +28,65 @@ class InstitutionFetcher(StatsFetcher):
         #     "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]
-                                    }]
+        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"
-                    }
-                },
-                "institution_trading": {
-                    "$map": {
-                        "input": {
-                            "$filter": {
-                                "input": "$institution_trading",
-                                "as": "institution",
-                                "cond": {
-                                    "$and": [{
-                                        "$gte":
-                                        ["$$institution.date", start_date]
-                                    }, {
-                                        "$lte":
-                                        ["$$institution.date", end_date]
-                                    }]
+                            },
+                            "as": "target_daily_data",
+                            "in": "$$target_daily_data"
+                        }
+                    },
+                    "institution_trading": {
+                        "$map": {
+                            "input": {
+                                "$filter": {
+                                    "input": "$institution_trading",
+                                    "as": "institution",
+                                    "cond": {
+                                        "$and": [
+                                            {
+                                                "$gte": [
+                                                    "$$institution.date",
+                                                    start_date
+                                                ]
+                                            }, {
+                                                "$lte": [
+                                                    "$$institution.date",
+                                                    end_date
+                                                ]
+                                            }
+                                        ]
+                                    }
                                 }
-                            }
+                            },
+                            "as": "target_institution_data",
+                            "in": "$$target_institution_data"
                         },
-                        "as": "target_institution_data",
-                        "in": "$$target_institution_data"
-                    },
+                    }
                 }
             }
-        })
+        )
 
         return pipeline
 
@@ -88,33 +100,37 @@ class InstitutionFetcher(StatsFetcher):
     def query_data(self):
         try:
             latest_time = StatsDateTime.get_latest_time(
-                self.ticker, self.collection)['last_update_time']
+                self.ticker, self.collection
+            )['last_update_time']
             latest_date = latest_time['institution_trading']['latest_date']
-            end_date = latest_date.replace(hour=0,
-                                           minute=0,
-                                           second=0,
-                                           microsecond=0)
+            end_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"
             )
             end_date = datetime.now(self.timezone)
-            end_date = date.replace(hour=0, minute=0, second=0, microsecond=0)
+            end_date = end_date.replace(
+                hour=0, minute=0, second=0, microsecond=0
+            )
 
-            if (date.hour < 17):  # 拿不到今天的資料
+            if (end_date.hour < 17):    # 拿不到今天的資料
                 end_date = end_date - timedelta(days=1)
 
         start_date = end_date - timedelta(days=365)
 
         fetched_data = self.collect_data(start_date, end_date)
 
-        fetched_data['daily_data'] = sorted(fetched_data['daily_data'],
-                                            key=lambda x: x['date'],
-                                            reverse=True)
+        fetched_data['daily_data'] = sorted(
+            fetched_data['daily_data'], key=lambda x: x['date'], reverse=True
+        )
+
         fetched_data['institution_trading'] = sorted(
             fetched_data['institution_trading'],
             key=lambda x: x['date'],
-            reverse=True)
+            reverse=True
+        ) if (fetched_data['institution_trading']) else []
 
         table_dict = self.process_data(fetched_data)
 
@@ -131,16 +147,16 @@ class InstitutionFetcher(StatsFetcher):
 
         # 交易價格與昨天交易
         price_dict = {
-            "open": latest_daily_data['open'],
-            'close': latest_daily_data['close'],
+            "open": round(latest_daily_data['open'], 2),
+            'close': round(latest_daily_data['close'], 2),
             'range':
-            f"{latest_daily_data['low']} - {latest_daily_data['high']}",
-            'volume': latest_daily_data['volume'] / 1000,
-            'last_open': yesterday_daily_data['open'],
-            'last_close': yesterday_daily_data['close'],
+            f"{latest_daily_data['low']:.2f} - {latest_daily_data['high']:.2f}",
+            'volume': round(latest_daily_data['volume'] / 1000, 2),
+            'last_open': round(yesterday_daily_data['open'], 2),
+            'last_close': round(yesterday_daily_data['close'], 2),
             'last_range':
-            f"{yesterday_daily_data['low']} - {yesterday_daily_data['high']}",
-            'last_volume': yesterday_daily_data['volume'] / 1000
+            f"{yesterday_daily_data['low']:.2f} - {yesterday_daily_data['high']:.2f}",
+            'last_volume': round(yesterday_daily_data['volume'] / 1000, 2)
         }
         # 一年範圍
         annual_lows = [data['low'] for data in daily_datas]
@@ -148,20 +164,36 @@ class InstitutionFetcher(StatsFetcher):
         lowest = np.min(annual_lows).item()
         highest = np.max(annual_highs).item()
 
-        price_dict['52weeks_range'] = f"{lowest} - {highest}"
+        price_dict['52weeks_range'] = f"{lowest:.2f} - {highest:.2f}"
         table_dict['price'] = price_dict
 
         # 發行股數 & 市值
         # 沒有實作
 
+        table_dict['latest_trading'] = {
+            'date': date.today(),
+            'table': pd.DataFrame(
+                columns = ['category', 'variable', 'close', 'volume']
+            )
+        }
+        table_dict['annual_trading'] = pd.DataFrame(
+            columns = ['date', 'close', 'volume']
+        )
+
+        if (not institution_tradings):
+            return table_dict
+
         # 今日法人買賣
-        latest_trading = institution_tradings[0]
+        latest_trading = institution_tradings[0] if (institution_tradings) else {
+            'date': date.today()
+        }
         table_dict['latest_trading'] = {
             "date":
             latest_trading['date'],
             "table":
-            self.process_latest_trading(latest_trading,
-                                        latest_daily_data['volume'])
+            self.process_latest_trading(
+                latest_trading, latest_daily_data['volume']
+            )
         }
         # 一年內法人
         annual_dates = [
@@ -182,17 +214,20 @@ class InstitutionFetcher(StatsFetcher):
             for data in institution_tradings
         }
 
-        annual_trading = {
+        annual_trading_dates = sorted(list(annual_trading.keys()))
+        annual_trading_skip = {
             date: {
-                "close": annual_closes[date],
-                "volume": annual_volumes[date],
+                "close": annual_closes.get(date, 0.0),
+                "volume": annual_volumes.get(date, 0.0),
                 **annual_trading[date]
             }
-            for date in annual_dates
+            for date in annual_trading_dates
         }
 
         table_dict['annual_trading'] = self.process_annual_trading(
-            annual_dates, annual_trading)
+            annual_dates, annual_trading_skip
+        )
+            
 
         return table_dict
 
@@ -206,30 +241,36 @@ class InstitutionFetcher(StatsFetcher):
 
         for key in latest_trading.keys():
             if (key.find("外陸資") >= 0 or key.find("外資") >= 0):
-                self.target_institution(latest_trading,
-                                        latest_table['foreign'], key, volume)
+                self.target_institution(
+                    latest_trading, latest_table['foreign'], key, volume
+                )
             elif (key.find("自營商") >= 0):
-                self.target_institution(latest_trading, latest_table['prop'],
-                                        key, volume)
+                self.target_institution(
+                    latest_trading, latest_table['prop'], key, volume
+                )
             elif (key.find("投信") >= 0):
-                self.target_institution(latest_trading, latest_table['mutual'],
-                                        key, volume)
+                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)
+                self.target_institution(
+                    latest_trading, latest_table['institutional_investor'], key,
+                    volume
+                )
         # 計算合計
         for unit in ['stock', 'percentage']:
             # 買進總和
             latest_table['institutional_investor']['buy'][unit] = (
                 latest_table['foreign']['buy'][unit] +
                 latest_table['prop']['buy'][unit] +
-                latest_table['mutual']['buy'][unit])
+                latest_table['mutual']['buy'][unit]
+            )
             # 賣出總和
             latest_table['institutional_investor']['sell'][unit] = (
                 latest_table['foreign']['sell'][unit] +
                 latest_table['prop']['sell'][unit] +
-                latest_table['mutual']['sell'][unit])
+                latest_table['mutual']['sell'][unit]
+            )
 
         frames = []
         for category, trades in latest_table.items():
@@ -243,18 +284,22 @@ class InstitutionFetcher(StatsFetcher):
             'type', 'category', 'stock', 'price', 'average_price', 'percentage'
         ]]
 
-        latest_df = pd.melt(latest_df,
-                            id_vars=['type', 'category'],
-                            var_name='variable',
-                            value_name='value')
+        latest_df = pd.melt(
+            latest_df,
+            id_vars=['type', 'category'],
+            var_name='variable',
+            value_name='value'
+        )
 
-        latest_df = latest_df.pivot_table(index=['category', 'variable'],
-                                          columns='type',
-                                          values='value',
-                                          aggfunc='first')
+        latest_df = latest_df.pivot_table(
+            index=['category', 'variable'],
+            columns='type',
+            values='value',
+            aggfunc='first'
+        )
 
         # 重設列名，去除多層索引
-        latest_df.columns.name = None  # 去除列名稱
+        latest_df.columns.name = None    # 去除列名稱
         latest_df = latest_df.reset_index()
 
         return latest_df
@@ -268,8 +313,9 @@ class InstitutionFetcher(StatsFetcher):
         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)
+            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()

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/fetchers/margin_trading.py

@@ -1,5 +1,5 @@
 from .base import StatsFetcher
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, date
 import json
 import numpy as np
 import pandas as pd
@@ -23,70 +23,84 @@ class MarginTradingFetcher(StatsFetcher):
     def prepare_query(self, start_date, end_date):
         pipeline = super().prepare_query()
 
-        pipeline.append({
-            "$project": {
-                "_id": 0,
-                "ticker": 1,
-                "company_name": 1,
-                "daily_data": {
-                    "$map": {
-                        "input": {
-                            "$filter": {
-                                "input": "$daily_data",
-                                "as": "daliy",
-                                "cond": {
-                                    "$and": [{
-                                        "$gte": ["$$daliy.date", start_date]
-                                    }, {
-                                        "$lte": ["$$daliy.date", end_date]
-                                    }]
+        pipeline.append(
+            {
+                "$project": {
+                    "_id": 0,
+                    "ticker": 1,
+                    "company_name": 1,
+                    "daily_data": {
+                        "$map": {
+                            "input": {
+                                "$filter": {
+                                    "input": "$daily_data",
+                                    "as": "daliy",
+                                    "cond": {
+                                        "$and": [
+                                            {
+                                                "$gte":
+                                                ["$$daliy.date", start_date]
+                                            }, {
+                                                "$lte":
+                                                ["$$daliy.date", end_date]
+                                            }
+                                        ]
+                                    }
                                 }
-                            }
-                        },
-                        "as": "target_daliy_data",
-                        "in": "$$target_daliy_data"
-                    }
-                },
-                "margin_trading": {
-                    "$map": {
-                        "input": {
-                            "$filter": {
-                                "input": "$margin_trading",
-                                "as": "margin",
-                                "cond": {
-                                    "$and": [{
-                                        "$gte": ["$$margin.date", start_date]
-                                    }, {
-                                        "$lte": ["$$margin.date", end_date]
-                                    }]
+                            },
+                            "as": "target_daliy_data",
+                            "in": "$$target_daliy_data"
+                        }
+                    },
+                    "margin_trading": {
+                        "$map": {
+                            "input": {
+                                "$filter": {
+                                    "input": "$margin_trading",
+                                    "as": "margin",
+                                    "cond": {
+                                        "$and": [
+                                            {
+                                                "$gte":
+                                                ["$$margin.date", start_date]
+                                            }, {
+                                                "$lte":
+                                                ["$$margin.date", end_date]
+                                            }
+                                        ]
+                                    }
                                 }
-                            }
-                        },
-                        "as": "target_margin_data",
-                        "in": "$$target_margin_data"
-                    }
-                },
-                "security_lending": {
-                    "$map": {
-                        "input": {
-                            "$filter": {
-                                "input": "$security_lending",
-                                "as": "lending",
-                                "cond": {
-                                    "$and": [{
-                                        "$gte": ["$$lending.date", start_date]
-                                    }, {
-                                        "$lte": ["$$lending.date", end_date]
-                                    }]
+                            },
+                            "as": "target_margin_data",
+                            "in": "$$target_margin_data"
+                        }
+                    },
+                    "security_lending": {
+                        "$map": {
+                            "input": {
+                                "$filter": {
+                                    "input": "$security_lending",
+                                    "as": "lending",
+                                    "cond": {
+                                        "$and": [
+                                            {
+                                                "$gte":
+                                                ["$$lending.date", start_date]
+                                            }, {
+                                                "$lte":
+                                                ["$$lending.date", end_date]
+                                            }
+                                        ]
+                                    }
                                 }
-                            }
-                        },
-                        "as": "target_lending_data",
-                        "in": "$$target_lending_data"
+                            },
+                            "as": "target_lending_data",
+                            "in": "$$target_lending_data"
+                        }
                     }
                 }
             }
-        })
+        )
 
         return pipeline
 
@@ -100,39 +114,42 @@ class MarginTradingFetcher(StatsFetcher):
     def query_data(self):
         try:
             latest_time = StatsDateTime.get_latest_time(
-                self.ticker, self.collection)['last_update_time']
+                self.ticker, self.collection
+            )['last_update_time']
             latest_date = latest_time['margin_trading']['latest_date']
-            end_date = latest_date.replace(hour=0,
-                                           minute=0,
-                                           second=0,
-                                           microsecond=0)
+            end_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"
             )
             end_date = datetime.now(self.timezone)
-            end_date = end_date.replace(hour=0,
-                                        minute=0,
-                                        second=0,
-                                        microsecond=0)
+            end_date = end_date.replace(
+                hour=0, minute=0, second=0, microsecond=0
+            )
 
-            if (end_date.hour < 22):  # 拿不到今天的資料
+            if (end_date.hour < 22):    # 拿不到今天的資料
                 end_date = end_date - timedelta(days=1)
 
         start_date = end_date - timedelta(days=365)
 
         fetched_data = self.collect_data(start_date, end_date)
 
-        fetched_data['daily_data'] = sorted(fetched_data['daily_data'],
-                                            key=lambda x: x['date'],
-                                            reverse=True)
-        fetched_data['margin_trading'] = sorted(fetched_data['margin_trading'],
-                                                key=lambda x: x['date'],
-                                                reverse=True)
+        fetched_data['daily_data'] = sorted(
+            fetched_data['daily_data'], key=lambda x: x['date'], reverse=True
+        )
+        fetched_data['margin_trading'] = sorted(
+            fetched_data['margin_trading'],
+            key=lambda x: x['date'],
+            reverse=True
+        ) if (fetched_data['margin_trading']) else []
+
         fetched_data['security_lending'] = sorted(
             fetched_data['security_lending'],
             key=lambda x: x['date'],
-            reverse=True)
+            reverse=True
+        )if (fetched_data['security_lending']) else []
 
         table_dict = self.process_data(fetched_data)
 
@@ -149,19 +166,18 @@ class MarginTradingFetcher(StatsFetcher):
         price_dict = {
             "open": latest_data['open'],
             'close': latest_data['close'],
-            'range': f"{latest_data['low']} - {latest_data['high']}",
-            'volume': latest_data['volume'] / 1000,
+            'range': f"{latest_data['low']:.2f} - {latest_data['high']:.2f}",
+            'volume': round(float(latest_data['volume']) / 1000, 2),
             'last_open': yesterday_data['open'],
             'last_close': yesterday_data['close'],
-            'last_range':
-            f"{yesterday_data['low']} - {yesterday_data['high']}",
-            'last_volume': yesterday_data['volume'] / 1000
+            'last_range': f"{yesterday_data['low']:.2f} - {yesterday_data['high']:.2f}",
+            'last_volume': round(float(yesterday_data['volume']) / 1000, 2)
         }
         annual_lows = [data['low'] for data in daily_datas]
         annual_highs = [data['high'] for data in daily_datas]
         lowest = np.min(annual_lows).item()
         highest = np.max(annual_highs).item()
-        price_dict['52weeks_range'] = f"{lowest} - {highest}"
+        price_dict['52weeks_range'] = f"{lowest:.2f} - {highest:.2f}"
 
         return_dict['price'] = price_dict
 
@@ -169,6 +185,18 @@ class MarginTradingFetcher(StatsFetcher):
         margin_trading = fetched_data['margin_trading']
         security_lending = fetched_data['security_lending']
 
+        return_dict['margin_trading'] = pd.DataFrame()
+        return_dict['stock_lending'] = pd.DataFrame()
+        return_dict['latest_trading'] = {
+            'date': date.today(),
+            "margin_trading": pd.DataFrame(),
+            "stock_lending": pd.DataFrame()
+        }
+        return_dict['annual_margin'] = pd.DataFrame()
+        return_dict['security_offset'] = 0.0
+        if (not margin_trading):
+            return return_dict
+
         latest_margin_date = margin_trading[0]['date']
         latest_lending_date = security_lending[0]['date']
         ## 融資融券
@@ -176,7 +204,8 @@ class MarginTradingFetcher(StatsFetcher):
         for trading in margin_trading:
             trading['financing']['現償'] = trading['financing'].pop('現金償還')
             trading['short_selling']['現償'] = trading['short_selling'].pop(
-                '現券償還')
+                '現券償還'
+            )
         ### 轉換
         latest_margin_trading = margin_trading[0]
         latest_margin_trading_df = {
@@ -185,7 +214,8 @@ class MarginTradingFetcher(StatsFetcher):
             if (isinstance(sub_dict, dict))
         }
         latest_margin_trading_df = pd.DataFrame.from_dict(
-            latest_margin_trading_df)
+            latest_margin_trading_df
+        )
 
         ## 借券表格
         latest_stock_lending = security_lending[0]['stock_lending']
@@ -195,9 +225,9 @@ class MarginTradingFetcher(StatsFetcher):
             for type_name, value in latest_stock_lending.items()
         }
         latest_stock_lending.pop("前日餘額")
-        latest_stock_lending_df = pd.DataFrame.from_dict(latest_stock_lending,
-                                                         orient="index",
-                                                         columns=['stock_lending'])
+        latest_stock_lending_df = pd.DataFrame.from_dict(
+            latest_stock_lending, orient="index", columns=['stock_lending']
+        )
 
         latest_dict = {
             "date": latest_margin_date,
@@ -262,14 +292,14 @@ class MarginTradingFetcher(StatsFetcher):
 
         annual_dict = {
             date: {
-                "close": close_prices[date],
-                "volume": volumes[date],
+                "close": close_prices.get(date, 0.0),
+                "volume": volumes.get(date, 0.0),
                 **financings[date],
                 **short_sellings[date],
                 **stock_lendings[date], 
-                "資券互抵":security_offsets[date]
+                "資券互抵": security_offsets[date]
             }
-            for date in annual_dates
+            for date in financings.keys()
         }
 
         annual_table = pd.DataFrame.from_dict(annual_dict)

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/fetchers/tech.py

@@ -138,6 +138,62 @@ class TechFetcher(StatsFetcher):
         )
 
         return df
+    
+    def conduct_db_search_tej(self):
+        # 再對TEJ search
+        tej_required_cols = [
+            "mdate", "open_d", 'high_d', 'low_d', 'close_d', 'vol'
+        ]
+
+        required_cols = ['date', 'open', 'high', 'low', 'close', 'volume']
+        tej_name_proj = {
+            tej_name: org_name
+            for tej_name, org_name in zip(tej_required_cols, required_cols)
+        }
+
+        query = {'ticker': self.ticker}
+        ticker_full = self.collection.find_one(query)
+
+        if not ticker_full:
+            raise ValueError("No ticker found in database")
+
+        daily_data = ticker_full.get("data", [])
+        if not isinstance(daily_data, list):
+            raise TypeError("Expected 'daily_data' to be a list.")
+
+        df = pd.DataFrame(daily_data)
+
+        if not self.has_required_columns(df, tej_required_cols):
+            raise KeyError(f"Missing required columns")
+        df = df.rename(columns=tej_name_proj)
+
+        return df[required_cols]
+    
+    def conduct_db_search_us(self):
+        required_cols = ['date', 'open', 'high', 'low', 'close', 'volume']
+
+        query = {'ticker': self.ticker}
+        filter_query = {"daily_data" : 1, "_id": 0}
+        ticker_full = self.collection.find_one(query, filter_query)
+
+        if not ticker_full:
+            raise ValueError("No ticker found in database")
+
+        daily_data = ticker_full.get("daily_data", [])
+        if not isinstance(daily_data, list):
+            raise TypeError("Expected 'daily_data' to be a list.")
+
+        df = pd.DataFrame(daily_data)
+
+        if not self.has_required_columns(df, required_cols):
+            missing_cols = [col for col in required_cols if col not in df.columns]
+            missing_cols = ",".join(missing_cols)
+            print(Warning(f"{missing_cols} not in columns"))
+            for col in missing_cols:
+                df[col] = pd.NA
+            # raise KeyError(f"Missing required columns")
+
+        return df[required_cols]
 
     
     def conduct_db_search_twse(self):

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/fetchers/value_invest.py

@@ -54,7 +54,8 @@ class ValueFetcher(StatsFetcher):
                                                 "EV_OPI": "$$daily_item.EV_OPI",
                                                 "EV_EBIT": "$$daily_item.EV_EBIT",
                                                 "EV_EBITDA": "$$daily_item.EV_EBITDA",
-                                                "EV_S": "$$daily_item.EV_S"
+                                                "EV_S": "$$daily_item.EV_S",
+                                                "Yield": "$$daily_item.Yield"
                                             }
                                     }
                             },
@@ -110,7 +111,8 @@ class ValueFetcher(StatsFetcher):
                 EV_OPI,
                 EV_EBIT,
                 EV_EBITDA,
-                EV_S
+                EV_S,
+                Yield
             }
         """
 
@@ -142,7 +144,8 @@ class ValueFetcher(StatsFetcher):
                                                 "EV_OPI": "$$daily.EV_OPI",
                                                 "EV_EBIT": "$$daily.EV_EBIT",
                                                 "EV_EBITDA": "$$daily.EV_EBITDA",
-                                                "EV_S": "$$daily.EV_S"
+                                                "EV_S": "$$daily.EV_S",
+                                                "Yield": "$$daily.Yield"
                                             }
                                     }
                             }
@@ -153,7 +156,7 @@ class ValueFetcher(StatsFetcher):
         fetched_data = self.collection.aggregate(pipeline).to_list()
         fetched_data = fetched_data[0]
 
-        value_keys = ["P_E", "P_FCF", "P_B", "P_S", "EV_OPI", "EV_EBIT", "EV_EVITDA", "EV_S"]
+        value_keys = ["P_E", "P_FCF", "P_B", "P_S", "EV_OPI", "EV_EBIT", "EV_EBITDA", "EV_S", "Yield"]
         return_dict = {value_key: dict() for value_key in value_keys}
 
         for value_key in value_keys:

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API/tools/tej_db/tej_db_percent_index.yaml

@@ -29,9 +29,6 @@ TWN/AINVFQ1:
 - r607
 - r613
 - r612
-- r609
-- r614
-- r611
 TWN/AFESTM1:
 - r105
 - r106

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/neurostats_API.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neurostats_API
-Version: 0.0.23b1
+Version: 0.0.23b2
 Summary: The service of NeuroStats website
 Home-page: https://github.com/NeurowattStats/NeuroStats_API.git
 Author: JasonWang@Neurowatt
@@ -89,7 +89,7 @@ pip install neurostats-API
 ```Python 
 >>> import neurostats_API
 >>> print(neurostats_API.__version__)
-0.0.23b
+0.0.23b2
 ```
 
 ### 得到最新一期的評價資料與歷年評價

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='neurostats_API',
-    version='0.0.23b1',
+    version='0.0.23b2',
     long_description=open('README.md', 'r', encoding='utf-8').read(),
     long_description_content_type='text/markdown',
     install_requires=[

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/test/test_fetchers.py

@@ -12,8 +12,11 @@ pp = PrettyPrinter(
     indent=2
 )
 
-with open(f"./tw50_company_list.json") as f:
-    company_list = json.load(f)
+
+company_list = {
+    "1260": "富味香",
+    "2330": "台積電"
+}
 db_client = DBClient("mongodb://neurowatt:neurodb123@db.neurowatt.ai:27017/neurowatt").get_client()
 
 def test_value_serie():
@@ -222,7 +225,7 @@ def test_institution_trading():
 
 def test_margin_trading():
     from neurostats_API.fetchers import MarginTradingFetcher
-    fetcher = MarginTradingFetcher(ticker='2330', db_client=db_client)
+    fetcher = MarginTradingFetcher(ticker='1260', db_client=db_client)
 
     fetched_data = fetcher.query_data()
 

{neurostats_api-0.0.23b1 → neurostats_api-0.0.23b2}/test/test_tej.py

@@ -23,7 +23,7 @@ def test_QoQ():
             fetch_mode = mode,
             start_date="2024-01-01",
             end_date="2024-12-31",
-            indexes = []
+            indexes = ["eps"]
         )
         print(data)
         if (isinstance(data, dict)):
@@ -40,7 +40,7 @@ def test_YoY():
     ]
 
     for mode in modes:
-        data = fetcher.get(ticker, mode, indexes = ['r405'])
+        data = fetcher.get(ticker, mode, indexes = ["r405"])
         print (data)
 
 def test_stock_price():