ksxt 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

ksxt/base/rest_exchange.py

@@ -1,28 +1,41 @@
 import json
+import logging
+import toml
 import os
-from datetime import datetime
-from typing import Any, Dict, Optional
+from pathlib import Path
 
+from typing import Any, Dict, List, Literal, Optional
+
+from datetime import datetime, UTC
+import pytz
+import time
+
+from ksxt.base.errors import NotSupportedError
 from ksxt.base.exchange import Exchange
 from ksxt.config import CONFIG_DIR
+import ksxt.models
 
 
 class RestExchange(Exchange):
     required_credentials = {
-        'open_key': True,
-        'secret_key': True,
-        'uid': False,
-        'login': False,
-        'password': False,
-        'token': False
+        "open_key": True,
+        "secret_key": True,
+        "uid": False,
+        "login": False,
+        "password": False,
+        "token": False,
     }
 
     headers = None
     token = None
     token_expired = None
-    type = 'rest'
+    type = "rest"
 
-    def __init__(self, config: Dict=None) -> None:
+    rate_limit = 2000  # milliseconds = seconds * 1000
+    lastRestRequestTimestamp = 0
+    timezone = pytz.timezone("UTC")
+
+    def __init__(self, config: Dict = None, filename: str = None) -> None:
         super().__init__()
 
         self.headers = dict() if self.headers is None else self.headers
@@ -30,33 +43,100 @@ class RestExchange(Exchange):
         if config is None:
             config = {}
 
-        settings = self.deep_extend(self.describe(), config)
+        # settings = self.deep_extend(self.describe(), config)
+        # Exchange.set_attr(self, settings)
+
+        settings = self.deep_extend(config)
         Exchange.set_attr(self, settings)
 
-        apis = self._get_api_from_file()
+        apis = self._get_api_from_file(filename)
         Exchange.set_attr(self, apis)
-        
-        self.set_token()
+
+    def __del__(self):
+        if self.session:
+            try:
+                self.session.close()
+            except Exception as e:
+                pass
+
+    def _get_api_from_file(self, filename: str):
+        if filename is None:
+            tr_config_filename = "tr_dev.json" if self.is_dev else "tr_app.json"
+        else:
+            tr_config_filename = filename
+
+        config_path = os.path.join(CONFIG_DIR, tr_config_filename)
+
+        if Path(tr_config_filename).suffix == ".json":
+            with open(
+                config_path,
+                encoding="utf-8",
+            ) as f:
+                c = json.load(f)
+                return {"apis": c[self.name]}
+
+        elif Path(tr_config_filename).suffix == ".toml":
+            with open(config_path, mode="r") as f:
+                c = toml.load(f)
+                return c
 
     def check_token(func):
         def wrapper(self, *args, **kwargs):
-            import time
-            if self.token_expired is None or time.strftime('%Y-%m-%d %H:%M:%S') >= self.token_expired:
-                self.set_token()
+            if not self.is_valid_token():
+                self.create_token()
 
             return func(self, *args, **kwargs)
+
         return wrapper
 
-    def _get_api_from_file(self):
-        tr_config_filename = 'tr_dev.json' if self.is_dev else 'tr_app.json'
+    def is_valid_token(self) -> bool:
+        self.load_token()
+        if self.token_expired is None:
+            return False
 
-        config_path = os.path.join(CONFIG_DIR, tr_config_filename)
+        return datetime.now(self.timezone) <= self.timezone.localize(self.token_expired)
+
+    def read_token(self):
+        try:
+            token_path = os.path.join(CONFIG_DIR, "token.toml")
+            with open(token_path, mode="r") as f:
+                c = toml.load(f)
+            return c
+        except Exception as e:
+            return {}
+
+    def load_token(self):
+        try:
+            data = self.read_token()
 
-        with open(config_path, encoding='utf-8',) as f:
-            c = json.load(f)
-            return { 'apis': c[self.name] }
+            if self.open_key in data.keys():
+                self.token = data[self.open_key]["token"]
+                self.token_expired = data[self.open_key]["expired"]
+        except Exception as e:
+            pass
 
-    def set_token(self):
+    def save_token(self, open_key, token, expired):
+        try:
+            logging.info("save token")
+            logging.info(open_key)
+            logging.info(token)
+            logging.info(expired)
+
+            data = self.read_token()
+            if open_key not in data:
+                data[open_key] = {}
+            data[open_key]["token"] = token
+            data[open_key]["expired"] = expired
+
+            token_path = os.path.join(CONFIG_DIR, "token.toml")
+            with open(token_path, "w") as file:
+                toml.dump(data, file)
+
+            self.load_token()
+        except Exception as e:
+            pass
+
+    def create_token(self):
         pass
 
     def prepare_request_headers(self, headers=None):
@@ -67,18 +147,23 @@ class RestExchange(Exchange):
 
         self.headers.update(headers)
 
-        headers.update({"content-type":"application/json"})
-        #headers.update({'appKey':self.open_key})
-        #headers.update({'appsecret':self.secret_key})
+        headers.update({"content-type": "application/json"})
+        # headers.update({'appKey':self.open_key})
+        # headers.update({'appsecret':self.secret_key})
 
         return headers
 
-
-    def describe(self) -> Dict:
-        return {}
-
-    def fetch(self, url, method='GET', headers=None, body=None, params=None):
-        request_headers = headers #self.prepare_request_headers(headers=headers)
+    def throttle(self, cost=None):
+        now = float(self.milliseconds())
+        elapsed = now - self.lastRestRequestTimestamp
+        cost = 1 if cost is None else cost
+        sleep_time = self.rate_limit * cost
+        if elapsed < sleep_time:
+            delay = sleep_time - elapsed
+            time.sleep(delay / 1000.0)
+
+    def fetch(self, url, method="GET", headers=None, body=None, params=None):
+        request_headers = headers
         request_body = body
         request_params = params
 
@@ -96,10 +181,10 @@ class RestExchange(Exchange):
                 headers=request_headers,
                 data=request_body,
                 params=request_params,
-                timeout=int(self.timeout / 1000)
+                timeout=int(self.timeout / 1000),
             )
 
-            response.encoding = 'utf-8'
+            response.encoding = "utf-8"
 
             headers = response.headers
             http_status_code = response.status_code
@@ -108,111 +193,210 @@ class RestExchange(Exchange):
             json_response = self.parse_json(http_response)
 
         except TimeoutError as e:
-            details = ' '.join([self.id, method, url])
+            details = " ".join([self.id, method, url])
             raise TimeoutError(details) from e
-        
-        if json_response:
-            return json_response
 
-    def sign(self, path, market, module, api: Any = 'public', method='GET', headers: Optional[Any] = None, body: Optional[Any] = None, params: Optional[Any] = None, config={}):
+        return json_response
+
+    def is_activate(self, path, security_type) -> bool:
+        return self.apis[self.type][security_type][path]["activate"]
+
+    def sign(
+        self,
+        path,
+        security_type,
+        method_type,
+        api_type: Any = "public",
+        headers: Optional[Any] = None,
+        body: Optional[Any] = None,
+        params: Optional[Any] = None,
+        config={},
+    ):
         pass
 
-    def fetch2(self, path, market, module, api: Any = 'public', method='GET', params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}):
-        # Rate Limit 체크 후 throttle 처리
-
-        is_activate = self.apis[self.type][market][module][path]['activate']
+    def fetch2(
+        self, path, security_type, params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}
+    ):
+        is_activate = self.is_activate(path=path, security_type=security_type)
         if not is_activate:
             return {
-                'response': {
-                # 성공 실패 여부
-                'success' : '-1',
-                # 응답코드
-                'code': 'fail',
-                # 응답메세지
-                'message': f'지원하지 않는 함수({path}) 입니다.'
-            }}
+                "response": {
+                    # 성공 실패 여부
+                    "success": "-1",
+                    # 응답코드
+                    "code": "fail",
+                    # 응답메세지
+                    "message": f"지원하지 않는 함수({path}) 입니다.",
+                }
+            }
+
+        # if self.enableRateLimit:
+        #     cost = self.calculate_rate_limiter_cost(api, method, path, params, config)
+        #     self.throttle(cost)
+
+        # self.lastRestRequestTimestamp = self.milliseconds()
+
+        method_type = self.apis[self.type][security_type][path]["method"]
+        api_type = self.apis[self.type][security_type][path]["api"]
+        request = self.sign(path, security_type, method_type, api_type, headers, body, params, config)
+        return self.fetch(request["url"], request["method"], request["headers"], request["body"], request["params"])
+
+    def request(
+        self, path, security_type, params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}
+    ):
+        return self.fetch2(path, security_type, params, headers, body, config)
+
+    # region base method
+    def create_token(self) -> ksxt.models.KsxtTokenResponse:
+        raise NotSupportedError(f"{self.id} {self.create_token.__qualname__}() is not supported yet.")
 
-        request = self.sign(path, market, module, api, method, headers, body, params, config)
-        return self.fetch(request['url'], request['method'], request['headers'], request['body'], request['params'])
+    @check_token
+    def fetch_markets(self, market_name: str) -> ksxt.models.KsxtMarketResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_markets.__qualname__}() is not supported yet.")
 
-    def request(self, path, market, module, api: Any='public', method='GET', params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}):
-        return self.fetch2(path, market, module, api, method, params, headers, body, config)
+    @check_token
+    def fetch_security(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtSecurityResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_security.__qualname__}() is not supported yet.")
 
+    @check_token
+    def fetch_ticker(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtTickerResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_ticker.__qualname__}() is not supported yet.")
 
-    # region public feeder
     @check_token
-    def fetch_markets(self, market_name: str):
-        pass
-    
+    def fetch_orderbook(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtSingleOrderBookResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_orderbook.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_security(self, symbol: str, base_market: str = 'KRW'):
-        pass
-    
+    def fetch_historical_data_index(
+        self,
+        symbol: str,
+        time_frame: str,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtHistoricalDataResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_historical_data_index.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_ticker(self, symbol: str, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_historical_data(
+        self,
+        symbol: str,
+        time_frame: str,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtHistoricalDataResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_historical_data.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_historical_data(self, symbol: str, time_frame: str, start: Optional[str] = None, end: Optional[str] = None, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_is_holiday(self, dt: datetime, base_market: str = "KRW") -> ksxt.models.KsxtHolidayResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_is_holiday.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_is_holiday(self, dt: datetime, base_market: str= 'KRW'):
-        pass    
-    # endregion public feeder
+    def fetch_user_info(self, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_user_info.__qualname__}() is not supported yet.")
 
-    # region private feeder
     @check_token
-    def fetch_user_info(self, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_balance(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtBalanceResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_balance.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_balance(self, acc_num: str, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_cash(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtCashResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_cash.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_cash(self, acc_num: str, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_trade_fee(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtTradeFeeResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_trade_fee.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_screener_list(self, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_screener_list(self, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_screener_list.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_screener(self, screen_id: str, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_screener(self, screen_id: str, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_screener.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_deposit_history(self, acc_num: str, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_deposit_history(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtDepositHistoryResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_deposit_history.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_withdrawal_history(self, acc_num: str, base_market: str= 'KRW'):
-        pass
-    # endregion private feeder
+    def fetch_withdrawal_history(
+        self, acc_num: str, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtWithdrawalHistoryResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_withdrawal_history.__qualname__}() is not supported yet.")
 
-    # region broker
     @check_token
-    def create_order(self, acc_num: str, symbol: str, ticket_type: str, price: float, qty: float, otype: str, base_market: str= 'KRW'):
-        pass
-    
+    def create_order(
+        self,
+        acc_num: str,
+        symbol: str,
+        ticket_type: Literal["EntryLong", "EntryShort", "ExitLong", "ExitShort"],
+        otype: Literal["limit", "market"],
+        price: Optional[float] = 0,
+        qty: Optional[float] = 0,
+        amount: Optional[float] = 0,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtCreateOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.create_order.__qualname__}() is not supported yet.")
+
     @check_token
-    def cancel_order(self, acc_num: str, order_id: str, symbol: Optional[str] = '', qty: float = 0, *args, base_market: str= 'KRW'):
-        pass
-    
+    def cancel_order(
+        self, acc_num: str, order_id: str, symbol: Optional[str] = "", qty: float = 0, *args, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtCancelOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.cancel_order.__qualname__}() is not supported yet.")
+
     @check_token
-    def modify_order(self, acc_num: str, order_id: str, price: float, qty: float, *args, symbol: Optional[str] = '',  base_market: str= 'KRW'):
-        pass
-    
+    def modify_order(
+        self,
+        acc_num: str,
+        order_id: str,
+        price: float,
+        qty: float,
+        *args,
+        symbol: Optional[str] = "",
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtModifyOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.modify_order.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_open_order(self, acc_num: str, symbol: Optional[str] = '', start: Optional[str] = None, end: Optional[str] = None, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_open_order(
+        self,
+        acc_num: str,
+        symbol: Optional[str] = "",
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtOpenOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_open_order.__qualname__}() is not supported yet.")
+
     @check_token
-    def fetch_closed_order(self, acc_num: str, symbol: Optional[str] = '', start: Optional[str] = None, end: Optional[str] = None, base_market: str= 'KRW'):
-        pass
-    
+    def fetch_closed_order(
+        self,
+        acc_num: str,
+        symbol: Optional[str] = "",
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtClosedOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_closed_order.__qualname__}() is not supported yet.")
+
     @check_token
-    def reserve_order(self, acc_num:str, symbol: str, price: float, qty: float, target_date: str, base_market: str= 'KRW'):
-        pass
-    # endregion broker
+    def fetch_open_order_detail(
+        self, acc_num: str, order_ids: List[str], base_market: str = "KRW"
+    ) -> ksxt.models.KsxtOpenOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_open_order_detail.__qualname__}() is not supported yet.")
+
+    @check_token
+    def fetch_closed_order_detail(
+        self, acc_num: str, order_ids: List[str], base_market: str = "KRW"
+    ) -> ksxt.models.KsxtOpenOrderResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_closed_order_detail.__qualname__}() is not supported yet.")
+
+    @check_token
+    def reserve_order(
+        self, acc_num: str, symbol: str, price: float, qty: float, target_date: str, base_market: str = "KRW"
+    ):
+        raise NotSupportedError(f"{self.id} {self.reserve_order.__qualname__}() is not supported yet.")
+
+    # endregion base method

ksxt/base/types.py

@@ -1,39 +1,4 @@
-import types
 from typing import Union
 
 
-class Entry:
-    def __init__(self, path, market, module, api, method, config):
-        # function key
-        self.path = path
-
-        # market type : stock, derivative, oversea_stock, oversea_derivative
-        self.market = market
-
-        # Feeder / Broker
-        self.module = module
-
-        # Token / Hash / Private / Public
-        self.api = api
-
-        # GET / POST
-        self.method = method
-
-        self.config = config
-
-        def unbound_method(_self, params={}):
-            return _self.request(self.path, self.market, self.module, self.api, self.method, params, config=self.config)
-
-        self.unbound_method = unbound_method
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self.unbound_method
-        else:
-            return types.MethodType(self.unbound_method, instance)
-
-    def __set_name__(self, owner, name):
-        self.name = name
-
-
-IndexType = Union[str, int]
+IndexType = Union[str, int]