ksxt 1.0.0__tar.gz → 1.0.1__tar.gz

{ksxt-1.0.0/src/ksxt.egg-info → ksxt-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ksxt
-Version: 1.0.0
+Version: 1.0.1
 License: MIT License
         
         Copyright © 2023 AMOSA

{ksxt-1.0.0 → ksxt-1.0.1}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ksxt"
-version = "1.0.0"
+version = "1.0.1"
 readme = "README.md"
 license = { file="LICENSE.txt" }
 

{ksxt-1.0.0 → ksxt-1.0.1}/src/ksxt/async_/base/async_exchange.py

@@ -1,19 +1,14 @@
 import asyncio
+import time
 import aiohttp
-import json
-import os
-import platform
-import tomllib
 from datetime import datetime
-from pathlib import Path
 from typing import Any, Dict, Literal, Optional
 
-import yarl
 
-from ksxt.async_.base.throttler import Throttler
 from ksxt.base.errors import NotSupportedError
+from ksxt.base.rate_limiter import RateLimiterContext
 from ksxt.base.rest_exchange import RestExchange
-from ksxt.config import CONFIG_DIR
+from ksxt.config import VALID_METHODS
 import ksxt.models
 
 
@@ -23,22 +18,26 @@ class AsyncExchange(RestExchange):
     def __init__(self, config: Dict = None, filename: str = None):
         super().__init__(config, filename)
 
-        self.asyncio_loop = asyncio.get_event_loop()
-        self.session = aiohttp.ClientSession()
-        self.throttle = Throttler({}, self.asyncio_loop)
+        self.asyncio_loop = None
+        self.session: aiohttp.ClientSession = None
 
     async def initialize(self):
         if self.asyncio_loop is None:
             self.asyncio_loop = asyncio.get_event_loop()
-        if self.session is None:
+
+        if self.session is None or (
+            self.session_last_used and (time.time() - self.session_last_used > self.session_lifetime)
+        ):
+            if self.session:
+                await self.session.close()
             self.session = aiohttp.ClientSession()
-        if self.throttle is None:
-            self.throttle = Throttler({}, self.asyncio_loop)
+            self.session_last_used = time.time()
 
     async def close(self):
         if self.session:
             await self.session.close()
             self.session = None
+            self.session_last_used = None
 
     async def __aenter__(self):
         await self.initialize()
@@ -47,49 +46,43 @@ class AsyncExchange(RestExchange):
     async def __aexit__(self, *args):
         await self.close()
 
-    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)
+    async def fetch(self, url, method="GET", headers=None, body=None, params=None):
+        # Ensure that resources are initialized before the request
+        await self.initialize()
 
-        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]}
+        method_lower = method.lower()
+        if method_lower not in VALID_METHODS:
+            raise ValueError(f"Invalid HTTP method: {method}")
 
-        elif Path(tr_config_filename).suffix == ".toml":
-            with open(config_path, mode="rb") as f:
-                c = tomllib.load(f)
-                return c
+        session_method = getattr(self.session, method.lower())
 
-    async def fetch(self, url, method="GET", headers=None, body=None, params=None):
-        request_headers = headers
-        request_body = str(body).encode() if body else None
-        request_params = params
+        # TODO : Set rate limiters value when config load
+        api_name = ""
 
-        session_method = getattr(self.session, method.lower())
+        if api_name and api_name in self.rate_limiters:
+            await self.rate_limiters[api_name].async_acquire()
 
         try:
             async with session_method(
                 url,
-                # yarl.URL(url, encoded=True),
-                headers=request_headers,
-                data=request_body,
-                params=request_params,
+                headers=headers,
+                data=str(body).encode() if body else None,
+                params=params,
                 timeout=aiohttp.ClientTimeout(total=int(self.timeout / 1000)),
             ) as response:
                 http_response = await response.text(errors="replace")
                 json_response = self.parse_json(http_response)
                 return json_response
-        except asyncio.TimeoutError as e:
+        except (asyncio.TimeoutError, aiohttp.ClientError) as e:
             details = f"{self.id} {method} {url}"
             raise TimeoutError(details) from e
+        finally:
+            if (
+                api_name
+                and api_name in self.rate_limiters
+                and isinstance(self.rate_limiters[api_name], RateLimiterContext)
+            ):
+                self.rate_limiters[api_name].release()
 
     async def fetch2(
         self, path, security_type, params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}

ksxt-1.0.1/src/ksxt/async_/koreainvest.py

@@ -0,0 +1,481 @@
+from datetime import datetime, timedelta
+import json
+import os
+import time
+from typing import Any, Dict, Literal, Optional
+
+import pytz
+
+from ksxt.api.koreainvest import ImplicitAPI
+from ksxt.async_.base.async_exchange import AsyncExchange
+from ksxt.market.manager import MarketManager
+from ksxt.parser.koreainvest import KoreaInvestParser
+
+import ksxt.models
+
+
+class KoreaInvest(AsyncExchange, ImplicitAPI):
+    def __init__(self, config: Dict = None) -> None:
+        super().__init__(config, "koreainvest.toml")
+        self.parser = KoreaInvestParser()
+        self.timezone = pytz.timezone("Asia/Seoul")
+
+    def is_activate(self, path, security_type) -> bool:
+        mode = "dev" if self.is_dev == True else "app"
+
+        tr_id = self.apis[self.type][security_type][path][mode]["tr_id"]
+
+        if security_type != "token" and not bool(tr_id):
+            return False
+
+        return super().is_activate(path=path, security_type=security_type)
+
+    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={},
+    ):
+        mode = "dev" if self.is_dev == True else "app"
+
+        host_url = self.apis[self.type][mode]["hostname"]
+        destination = self.apis[self.type][security_type][path]["url"]
+        version = self.apis[self.type]["version"]
+        params["version"] = version
+        destination = self.implode_params(destination, params)
+
+        url = f"{host_url}/{destination}"
+
+        tr_id = self.apis[self.type][security_type][path][mode]["tr_id"]
+        authorization_token = f"Bearer {self.token}"
+
+        if api_type == "private":
+            if headers is None:
+                headers = {}
+                headers.update(
+                    {
+                        "content-type": "application/json",
+                        "authorization": authorization_token,
+                        "appkey": self.open_key,
+                        "appsecret": self.secret_key,
+                        "tr_id": tr_id,
+                        "custtype": "P",
+                    }
+                )
+
+        if method_type.upper() == "POST":
+            body = json.dumps(params)
+            params = {}
+
+        return {"url": url, "method": method_type, "headers": headers, "body": body, "params": params}
+
+    async def create_token(self) -> ksxt.models.KsxtTokenResponse:
+        params = {"grant_type": "client_credentials", "appkey": self.open_key, "appsecret": self.secret_key}
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.public_post_generate_token(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtTokenResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_token(response=response)
+
+        self.save_token(self.open_key, parsed_info.access_token, expired=parsed_info.expired_datetime)
+
+        return ksxt.models.KsxtTokenResponse(header=common_header, response=common_response, info=parsed_info)
+
+    def get_common_response(self, response):
+        if "error_code" in response:
+            return self.create_common_response(
+                success="1",
+                msg_code=self.safe_string(response, "error_code"),
+                msg=self.safe_string(response, "error_description"),
+                info=response,
+            )
+
+        if "rt_cd" in response and response["rt_cd"] != "0":
+            return self.create_common_response(
+                success="1",
+                msg_code=self.safe_string(response, "msg_cd"),
+                msg=self.safe_string(response, "msg1"),
+                info=response,
+            )
+
+        if "response" in response and response["response"]["success"] != "0":
+            return self.create_common_response(
+                success="1",
+                msg_code=self.safe_string(response["response"], "code"),
+                msg=self.safe_string(response["response"], "message"),
+                info=response,
+            )
+
+        return self.create_common_response(
+            success="0",
+            msg_code=self.safe_string(response, "msg_cd"),
+            msg=self.safe_string(response, "msg1"),
+            info=response,
+        )
+
+    @AsyncExchange.check_token
+    async def fetch_balance(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtBalanceResponse:
+        if base_market == "KRW":
+            params = {
+                "CANO": acc_num[:8],
+                "ACNT_PRDT_CD": acc_num[-2:],
+                "AFHR_FLPR_YN": "N",
+                "OFL_YN": "",
+                "INQR_DVSN": "01",
+                "UNPR_DVSN": "01",
+                "FUND_STTL_ICLD_YN": "N",
+                "FNCG_AMT_AUTO_RDPT_YN": "N",
+                "PRCS_DVSN": "01",
+                "CTX_AREA_FK100": "",
+                "CTX_AREA_NK100": "",
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_balance(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtBalanceResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_balance(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtBalanceResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_cash(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtCashResponse:
+        if base_market == "KRW":
+            params = {
+                "CANO": acc_num[:8],
+                "ACNT_PRDT_CD": acc_num[-2:],
+                "AFHR_FLPR_YN": "N",
+                "OFL_YN": "",
+                "INQR_DVSN": "01",
+                "UNPR_DVSN": "01",
+                "FUND_STTL_ICLD_YN": "N",
+                "FNCG_AMT_AUTO_RDPT_YN": "N",
+                "PRCS_DVSN": "01",
+                "CTX_AREA_FK100": "",
+                "CTX_AREA_NK100": "",
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_cash(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtCashResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_cash(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtCashResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_orderbook(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtSingleOrderBookResponse:
+        if base_market == "KRW":
+            params = {"FID_COND_MRKT_DIV_CODE": "J", "FID_INPUT_ISCD": symbol}
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_orderbook(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtSingleOrderBookResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_orderbook(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtSingleOrderBookResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_security(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtSecurityResponse:
+        if base_market == "KRW":
+            params = {"PRDT_TYPE_CD": "300", "PDNO": symbol}
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_security_info(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtSecurityResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_security(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtSecurityResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_ticker(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtTickerResponse:
+        if base_market == "KRW":
+            params = {"FID_COND_MRKT_DIV_CODE": "J", "FID_INPUT_ISCD": symbol}
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_ticker_price(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtTickerResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_ticker(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtTickerResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_historical_data_index(
+        self, symbol: str, time_frame: str, start: str | None = None, end: str | None = None, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtHistoricalDataResponse:
+        if time_frame.endswith("D"):
+            param_code = "D"
+        elif time_frame.endswith("W") or time_frame.endswith("w"):
+            param_code = "W"
+        elif time_frame.endswith("M"):
+            param_code = "M"
+        elif time_frame.endswith("Y"):
+            param_code = "Y"
+        else:
+            assert ValueError(f"{time_frame} is not valid value")
+
+        if start is None:
+            start = self.now(base_market) - timedelta(days=50)
+        if end is None:
+            end = self.now(base_market)
+
+        if base_market == "KRW":
+            params = {
+                "FID_COND_MRKT_DIV_CODE": "U",
+                "FID_INPUT_ISCD": symbol,
+                "FID_INPUT_DATE_1": start.strftime("%Y%m%d"),
+                "FID_INPUT_DATE_2": end.strftime("%Y%m%d"),
+                "FID_PERIOD_DIV_CODE": param_code,
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+
+        response = await self.private_get_fetch_index_ohlcv(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_historical_index_data(response=response, symbol=symbol, base_market=base_market)
+
+        return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def fetch_historical_data(
+        self, symbol: str, time_frame: str, start: str | None = None, end: str | None = None, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtHistoricalDataResponse:
+        if time_frame.endswith("D"):
+            param_code = "D"
+        elif time_frame.endswith("W") or time_frame.endswith("w"):
+            param_code = "W"
+        elif time_frame.endswith("M"):
+            param_code = "M"
+        elif time_frame.endswith("Y"):
+            param_code = "Y"
+        else:
+            assert ValueError(f"{time_frame} is not valid value")
+
+        if start is None:
+            start = self.now(base_market) - timedelta(days=100)
+        if end is None:
+            end = self.now(base_market)
+
+        if base_market == "KRW":
+            params = {
+                "FID_COND_MRKT_DIV_CODE": "J",
+                "FID_INPUT_ISCD": symbol,
+                "FID_INPUT_DATE_1": start.strftime("%Y%m%d"),
+                "FID_INPUT_DATE_2": end.strftime("%Y%m%d"),
+                "FID_PERIOD_DIV_CODE": param_code,
+                "FID_ORG_ADJ_PRC": "0",
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        if time_frame.endswith("m"):
+            common_header = self.create_common_header(request_params=params)
+            response = await self.private_get_fetch_security_ohlcv_minute(self.extend(params))
+        elif time_frame.endswith("D"):
+            common_header = self.create_common_header(request_params=params)
+            response = await self.private_get_fetch_security_ohlcv_day(self.extend(params))
+        elif time_frame.endswith("W"):
+            common_header = self.create_common_header(request_params=params)
+            response = await self.private_get_fetch_security_ohlcv_week(self.extend(params))
+        elif time_frame.endswith("M"):
+            common_header = self.create_common_header(request_params=params)
+            response = await self.private_get_fetch_security_ohlcv_month(self.extend(params))
+        elif time_frame.endswith("Y"):
+            common_header = self.create_common_header(request_params=params)
+            response = await self.private_get_fetch_security_ohlcv_year(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_historical_data(response=response, symbol=symbol, base_market=base_market)
+
+        return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def modify_order(
+        self,
+        acc_num: str,
+        order_id: str,
+        price: float,
+        qty: float,
+        *args,
+        symbol: str | None = "",
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtModifyOrderResponse:
+        if base_market == "KRW":
+            params = {
+                "CANO": acc_num[:8],
+                "ACNT_PRDT_CD": acc_num[-2:],
+                "KRX_FWDG_ORD_ORGNO": "",
+                "ORGN_ODNO": str(order_id),
+                "RVSE_CNCL_DVSN_CD": "01",
+                "ORD_DVSN": "00",
+                "ORD_QTY": str(qty),
+                "ORD_UNPR": str(price),
+                "QTY_ALL_ORD_YN": "N",
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+        response = await self.private_post_send_modify_order(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtModifyOrderResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_modify_order(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtModifyOrderResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def cancel_order(
+        self, acc_num: str, order_id: str, symbol: str | None = "", qty: float = 0, *args, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtCancelOrderResponse:
+        if base_market == "KRW":
+            params = {
+                "CANO": acc_num[:8],
+                "ACNT_PRDT_CD": acc_num[-2:],
+                "KRX_FWDG_ORD_ORGNO": "",
+                "ORGN_ODNO": str(order_id),
+                "RVSE_CNCL_DVSN_CD": "02",
+                "ORD_DVSN": "00",
+                "ORD_QTY": str(qty),
+                "ORD_UNPR": str(0),
+                "QTY_ALL_ORD_YN": "N",
+            }
+        else:
+            assert ValueError(f"{base_market} is not valid value")
+
+        common_header = self.create_common_header(request_params=params)
+        response = await self.private_post_send_cancel_order(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtCancelOrderResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_cancel_order(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtCancelOrderResponse(header=common_header, response=common_response, info=parsed_info)
+
+    @AsyncExchange.check_token
+    async def create_order(
+        self,
+        acc_num: str,
+        symbol: str,
+        ticket_type: Literal["EntryLong"] | Literal["EntryShort"] | Literal["ExitLong"] | Literal["ExitShort"],
+        otype: Literal["limit"] | Literal["market"],
+        price: float | None = 0,
+        qty: float | None = 0,
+        amount: float | None = 0,
+        base_market: str = "KRW",
+    ) -> ksxt.models.KsxtCreateOrderResponse:
+        if otype.lower() == "limit":
+            order_dvsn = "00"
+        elif otype.lower() == "market":
+            order_dvsn = "01"
+        params = {
+            "CANO": acc_num[:8],
+            "ACNT_PRDT_CD": acc_num[-2:],
+            "PDNO": symbol,
+            "ORD_DVSN": order_dvsn,
+            "ORD_QTY": str(qty),  # string type 으로 설정
+            "ORD_UNPR": str(price),  # string type 으로 설정
+        }
+
+        common_header = self.create_common_header(request_params=params)
+
+        if ticket_type == "EntryLong":
+            response = await self.private_post_send_order_entry(self.extend(params))
+        elif ticket_type == "ExitLong":
+            response = await self.private_post_send_order_exit(self.extend(params))
+
+        common_response = self.get_common_response(response=response)
+        if common_response.success != "0":
+            return ksxt.models.KsxtCreateOrderResponse(header=common_header, response=common_response, info=None)
+
+        parsed_info = self.parser.parse_create_order(response=response, base_market=base_market)
+
+        return ksxt.models.KsxtCreateOrderResponse(header=common_header, response=common_response, info=parsed_info)
+
+    def get_market_code_in_feeder(self, symbol: str, base_market: str = "KRW"):
+        if base_market == "KRW":
+            return ""
+        elif base_market == "USD":
+            if symbol.upper() == "ALL":
+                return "NASD"
+
+            response = self.fetch_security(symbol=symbol, base_market=base_market)
+            return response["exchange"]
+        else:
+            return ""
+
+    def get_market_code_in_broker(self, symbol: str, base_market: str = "KRW"):
+        if base_market == "KRW":
+            return ""
+        elif base_market == "USD":
+            if symbol.upper() == "ALL":
+                return "NASD"
+
+            response = self.fetch_security(symbol=symbol, base_market=base_market)
+            exname = response["exchange"]
+            if exname == "NYS":
+                return "NYSE"
+            elif exname == "NAS":
+                return "NASD"
+            elif exname == "AMS":
+                return "AMEX"
+            else:
+                return ""
+        else:
+            return ""

{ksxt-1.0.0 → ksxt-1.0.1}/src/ksxt/base/exchange.py

@@ -20,6 +20,11 @@ class Exchange:
     is_dev = False
 
     session = None
+    # 세션 유효 시간 (초)
+    session_lifetime = 10
+    # 세션의 마지막 사용 시간
+    session_last_used: time = None
+    
     timeout = 10000  # milliseconds = seconds * 1000
     synchronous = True