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

neurostats_API/async_mode/fetchers/twse_margin.py

@@ -0,0 +1,100 @@
+from .base import AsyncBaseFetcher
+from datetime import datetime, timedelta
+from neurostats_API.async_mode.factory import get_extractor
+from ..db_extractors import (
+    AsyncTWSEChipDBExtractor,
+    AsyncYFDailyTechDBExtractor,
+)
+
+from neurostats_API.transformers import TWSEChipTransformer
+from neurostats_API.utils import NotSupportedError
+import pandas as pd
+
+
+class AsyncTWSEMarginFetcher(AsyncBaseFetcher):
+    """
+    stats 網頁用
+    """
+
+    def __init__(self, ticker, client):
+        self.ticker = ticker
+        self.transformer_map = {"tw": TWSEChipTransformer}
+        try:
+            self.margin_extractor = get_extractor(
+                "TWSE_chip", ticker, client, fetch_type='M'
+            )
+            self.security_extractor = get_extractor(
+                "TWSE_chip", ticker, client, fetch_type='S'
+            )
+            self.daily_extractor = get_extractor("YF_tech", ticker, client)
+
+            company_name = self.margin_extractor.get_company_name()
+            zone = self.margin_extractor.get_zone()
+
+
+
+            transformer = self.get_transformer(zone)
+            self.transformer = transformer(ticker, company_name, zone)
+        except NotSupportedError as e:
+            raise NotSupportedError(
+                f"{self.__class__.__name__} only support {list(self.transformer_map.keys())} companies now, {ticker} is not available"
+            ) from e
+
+    async def query_data(self, start_date=None, end_date=None):
+        margin = await self.margin_extractor.query_data(start_date, end_date)
+        security_lending = await self.security_extractor.query_data(
+            start_date, end_date
+        )
+
+        tech_data = await self.daily_extractor.query_data(start_date, end_date)
+
+        fetched_data = {
+            "margin_trading": margin,
+            "security_lending": security_lending
+        }
+        transformed_data = self.transformer.process_transform(
+            tech_data=tech_data, **fetched_data
+        )
+        transformed_data['annual_trading'] = self._concat_data(
+            transformed_data['annual_trading']
+        )
+
+        return transformed_data
+
+    async def query_data_annual(self):
+        """
+        取一年內的資料
+        """
+        end_date = datetime.today()
+        start_date = end_date - timedelta(days=365)
+
+        fetched_data = await self.query_data(start_date, end_date)
+
+        return fetched_data
+
+    def _concat_data(self, annaual_data):
+        """
+        借券, 債券串接
+        annaual_data: 
+        {
+            "margin_trading": pd.DataFrame,
+            'security_lending': pd.DataFrame
+        }
+        """
+
+        margin_annual = annaual_data.get("margin_trading")
+        security_annaul = annaual_data.get("security_lending")
+
+        unique_cols = [
+            name for name in security_annaul.columns
+            if name not in margin_annual.columns
+        ]
+        concat_df = pd.concat(
+            [margin_annual, security_annaul[unique_cols]], axis=1
+        )
+
+        return {
+            'margin_trading': margin_annual,
+            'security_lending': security_annaul,
+            'stats_page_history': concat_df
+        }

neurostats_API/async_mode/fetchers/value.py

@@ -0,0 +1,76 @@
+from .base import AsyncBaseFetcher
+from ..db_extractors import (
+    AsyncDailyValueDBExtractor, AsyncTEJDailyValueDBExtractor
+)
+from neurostats_API.async_mode.factory import get_extractor
+from neurostats_API.transformers import TWSEAnnualValueTransformer, TWSEHistoryValueTransformer
+from neurostats_API.utils import NotSupportedError
+
+
+class AsyncTWSEStatsValueFetcher(AsyncBaseFetcher):
+
+    def __init__(self, ticker, client):
+
+        self.ticker = ticker
+        self.transformer_map = {
+                "tw": (TWSEHistoryValueTransformer, TWSEAnnualValueTransformer)
+            }
+        try:
+            self.daily_data_extractor = get_extractor("TWSE_value", ticker, client, fetch_type = 'D')
+            self.annual_data_extractor = get_extractor("TWSE_value", ticker, client, fetch_type = 'Y')
+
+            self.company_name = self.daily_data_extractor.get_company_name()
+            self.zone = self.daily_data_extractor.get_zone()
+
+            transformer = self.get_transformer(self.zone)
+
+            daily_transformer, annual_transformer = transformer
+            self.daily_transformer = daily_transformer(
+                ticker, self.company_name, self.zone
+            )
+            self.annual_transformer = annual_transformer(
+                ticker, self.company_name, self.zone
+            )
+
+            self.return_dict = {
+                "ticker": self.ticker,
+                "company_name": self.company_name
+            }
+        except NotSupportedError as e:
+            raise NotSupportedError(
+                f"{self.__class__.__name__} only support {list(self.transformer_map.keys())} companies now, {ticker} is not available"
+            ) from e
+
+    async def query_data(self, start_date=None, end_date=None):
+
+        annual_data = await self.annual_data_extractor.query_data(
+            start_date, end_date
+        )
+        daily_data = await self.daily_data_extractor.query_data(
+            start_date=start_date, end_date=end_date
+        )
+
+        self.return_dict['yearly_data'
+                         ] = self.annual_transformer.process_transform(
+                             annual_data
+                         )
+        self.return_dict['daily_data'] = self.daily_transformer.process_latest(
+            daily_data
+        )
+        self.return_dict['value_serie'
+                         ] = self.daily_transformer.process_transform(
+                             daily_data
+                         )
+
+        return self.return_dict
+
+    async def query_value_serie(self, start_date=None, end_date=None):
+        daily_data = await self.daily_data_extractor.query_data(
+            start_date, end_date
+        )
+        self.return_dict['value_serie'
+                         ] = self.daily_transformer.process_transform(
+                             daily_data
+                         )
+
+        return self.return_dict