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

ksxt/__init__.py

@@ -1,3 +1,5 @@
-__version__ = '0.0.2'
+__version__ = "0.0.2"
 
 from ksxt.koreainvest import KoreaInvest
+from ksxt.upbit import Upbit
+from ksxt.bithumb import Bithumb

ksxt/api/__init__.py

@@ -0,0 +1,26 @@
+import types
+
+
+class Entry:
+    def __init__(self, security_type, path, config):
+        # equity, derivative, oversea_equity, oversea_derivative
+        self.security_type = security_type
+
+        # function key
+        self.path = path
+
+        self.config = config
+
+        def unbound_method(_self, params={}):
+            return _self.request(self.path, self.security_type, 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

ksxt/api/auto/api_generator.py

@@ -0,0 +1,54 @@
+import importlib
+
+
+def generate_class_code(exchange_name: str):
+    try:
+        # Dynamically import the module based on the exchange name
+        module = importlib.import_module(f"{exchange_name}")
+        exchange_methods = module.entries[exchange_name]
+    except ImportError:
+        raise ValueError(f"Module for exchange '{exchange_name}' could not be found.")
+    except AttributeError:
+        raise ValueError(f"Entries for exchange '{exchange_name}' not found in the module.")
+
+    class_code = "class ImplicitAPI:\n"
+
+    # Calculate maximum length for method names for alignment
+    max_length = 0
+    for category, methods in exchange_methods.items():
+        for access, http_methods in methods.items():
+            if isinstance(http_methods, dict):
+                for method, paths in http_methods.items():
+                    max_length = max(max_length, *(len(f"{access}_{method}_{path}") for path in paths))
+            elif isinstance(http_methods, list):
+                max_length = max(max_length, *(len(f"{access}_{path}") for path in http_methods))
+
+    for category, methods in exchange_methods.items():
+        class_code += f"\n    # {category} API methods\n"
+        for access, http_methods in methods.items():
+            class_code += f"\n    # {access} methods\n"
+            if isinstance(http_methods, dict):
+                for method, paths in http_methods.items():
+                    class_code += f"\n    # {method} requests\n"
+                    for path in paths:
+                        entry_name = f"{access}_{method}_{path}"
+                        # Right-align entry names for better readability
+                        class_code += f"    {entry_name.ljust(max_length)} = Entry('{category}', '{path}', {{}})\n"
+            elif isinstance(http_methods, list):
+                for path in http_methods:
+                    entry_name = f"{access}_{path}"
+                    class_code += f"    {entry_name.ljust(max_length)} = Entry('{category}', '{path}', {{}})\n"
+
+    return class_code
+
+
+if __name__ == "__main__":
+    exchange_names = ["bithumb", "koreainvest", "upbit"]  # List of exchanges to generate files for
+
+    for exchange_name in exchange_names:
+        class_code = generate_class_code(exchange_name)
+        filename = f"./src/ksxt/api/{exchange_name}.py"
+        with open(filename, "w") as file:
+            file.write("from ksxt.api import Entry\n")
+            file.write("\n")
+            file.write(class_code)

ksxt/api/auto/bithumb.py

@@ -0,0 +1,35 @@
+entries = {
+    "bithumb": {
+        "stock": {
+            "public": {
+                "get": [
+                    "fetch_markets",
+                    "fetch_security_ohlcv_minute",
+                    "fetch_security_ohlcv_day",
+                    "fetch_security_ohlcv_week",
+                    "fetch_security_ohlcv_month",
+                    "fetch_ticker_price",
+                    "fetch_tickers_price",
+                    "fetch_orderbook",
+                    "fetch_orderbooks",
+                    "fetch_security_info",
+                ]
+            },
+            "private": {
+                "get": [
+                    "fetch_balance",
+                    "fetch_cash",
+                    "fetch_trade_fee",
+                    "fetch_opened_order",
+                    "fetch_opened_order_detail",
+                    "fetch_closed_order",
+                    "fetch_closed_order_detail",
+                    "fetch_withdrawal_history",
+                    "fetch_deposit_history",
+                ],
+                "post": ["send_order_entry", "send_order_entry_market", "send_order_exit", "send_order_exit_market"],
+                "delete": ["send_cancel_order"],
+            },
+        }
+    }
+}

ksxt/api/auto/koreainvest.py

@@ -0,0 +1,49 @@
+entries = {
+    "koreainvest": {
+        "stock": {
+            "private": {
+                "get": [
+                    "fetch_balance",
+                    "fetch_cash",
+                    "fetch_orderbook",
+                    "fetch_security_info",
+                    "fetch_ticker_price",
+                    "fetch_index_ohlcv",
+                    "fetch_security_ohlcv_day",
+                    "fetch_security_ohlcv_minute",
+                    "fetch_security_ohlcv_month",
+                    "fetch_security_ohlcv_week",
+                    "fetch_security_ohlcv_year",
+                    "fetch_closed_order",
+                    "fetch_opened_order",
+                    "fetch_pnl",
+                    "fetch_screener",
+                    "fetch_screener_list",
+                ],
+                "post": [
+                    "send_modify_order",
+                    "send_cancel_order",
+                    "send_order_entry",
+                    "send_order_exit",
+                    "send_order_loan_entry",
+                    "send_order_loan_exit",
+                ],
+            },
+            "public": {
+                "post": [
+                    "generate_token",
+                    "revoke_token",
+                ]
+            },
+        },
+    },
+    "websocket": {
+        "stock": {
+            "subscribe": {
+                "ticker": ["subscribe_ticker"],
+                "trade": ["subscribe_trade"],
+                "orderbook": ["subscribe_orderbook"],
+            }
+        }
+    },
+}

ksxt/api/auto/upbit.py

@@ -0,0 +1,39 @@
+entries = {
+    "upbit": {
+        "stock": {
+            "public": {
+                "get": [
+                    "fetch_markets",
+                    "fetch_security_ohlcv_minute",
+                    "fetch_security_ohlcv_day",
+                    "fetch_security_ohlcv_week",
+                    "fetch_security_ohlcv_month",
+                    "fetch_ticker_price",
+                    "fetch_tickers_price",
+                    "fetch_orderbook",
+                    "fetch_orderbooks",
+                ]
+            },
+            "private": {
+                "get": [
+                    "fetch_balance",
+                    "fetch_cash",
+                    "fetch_security_info",
+                    "fetch_trade_fee",
+                    "fetch_closed_order_detail",
+                    "fetch_opened_order_detail",
+                    "fetch_opened_order",
+                    "fetch_closed_order",
+                    "fetch_withdrawal_history",
+                    "fetch_deposit_history",
+                ],
+                "post": ["send_order_entry", "send_order_entry_market", "send_order_exit", "send_order_exit_market"],
+                "delete": ["send_cancel_order"],
+            },
+        },
+        "websocket": {
+            "public": ["subscribe_ticker", "subscribe_trade", "subscribe_orderbook", "subscribe_order"],
+            "private": ["subscribe_ticker", "subscribe_trade"],
+        },
+    }
+}

ksxt/api/bithumb.py

@@ -0,0 +1,42 @@
+from ksxt.api import Entry
+
+
+class ImplicitAPI:
+
+    # stock API methods
+
+    # public methods
+
+    # get requests
+    public_get_fetch_markets = Entry("stock", "fetch_markets", {})
+    public_get_fetch_security_ohlcv_minute = Entry("stock", "fetch_security_ohlcv_minute", {})
+    public_get_fetch_security_ohlcv_day = Entry("stock", "fetch_security_ohlcv_day", {})
+    public_get_fetch_security_ohlcv_week = Entry("stock", "fetch_security_ohlcv_week", {})
+    public_get_fetch_security_ohlcv_month = Entry("stock", "fetch_security_ohlcv_month", {})
+    public_get_fetch_ticker_price = Entry("stock", "fetch_ticker_price", {})
+    public_get_fetch_tickers_price = Entry("stock", "fetch_tickers_price", {})
+    public_get_fetch_orderbook = Entry("stock", "fetch_orderbook", {})
+    public_get_fetch_orderbooks = Entry("stock", "fetch_orderbooks", {})
+    public_get_fetch_security_info = Entry("stock", "fetch_security_info", {})
+
+    # private methods
+
+    # get requests
+    private_get_fetch_balance = Entry("stock", "fetch_balance", {})
+    private_get_fetch_cash = Entry("stock", "fetch_cash", {})
+    private_get_fetch_trade_fee = Entry("stock", "fetch_trade_fee", {})
+    private_get_fetch_opened_order = Entry("stock", "fetch_opened_order", {})
+    private_get_fetch_opened_order_detail = Entry("stock", "fetch_opened_order_detail", {})
+    private_get_fetch_closed_order = Entry("stock", "fetch_closed_order", {})
+    private_get_fetch_closed_order_detail = Entry("stock", "fetch_closed_order_detail", {})
+    private_get_fetch_withdrawal_history = Entry("stock", "fetch_withdrawal_history", {})
+    private_get_fetch_deposit_history = Entry("stock", "fetch_deposit_history", {})
+
+    # post requests
+    private_post_send_order_entry = Entry("stock", "send_order_entry", {})
+    private_post_send_order_entry_market = Entry("stock", "send_order_entry_market", {})
+    private_post_send_order_exit = Entry("stock", "send_order_exit", {})
+    private_post_send_order_exit_market = Entry("stock", "send_order_exit_market", {})
+
+    # delete requests
+    private_delete_send_cancel_order = Entry("stock", "send_cancel_order", {})

ksxt/api/koreainvest.py

@@ -0,0 +1,40 @@
+from ksxt.api import Entry
+
+
+class ImplicitAPI:
+
+    # stock API methods
+
+    # private methods
+
+    # get requests
+    private_get_fetch_balance = Entry("stock", "fetch_balance", {})
+    private_get_fetch_cash = Entry("stock", "fetch_cash", {})
+    private_get_fetch_orderbook = Entry("stock", "fetch_orderbook", {})
+    private_get_fetch_security_info = Entry("stock", "fetch_security_info", {})
+    private_get_fetch_ticker_price = Entry("stock", "fetch_ticker_price", {})
+    private_get_fetch_index_ohlcv = Entry("stock", "fetch_index_ohlcv", {})
+    private_get_fetch_security_ohlcv_day = Entry("stock", "fetch_security_ohlcv_day", {})
+    private_get_fetch_security_ohlcv_minute = Entry("stock", "fetch_security_ohlcv_minute", {})
+    private_get_fetch_security_ohlcv_month = Entry("stock", "fetch_security_ohlcv_month", {})
+    private_get_fetch_security_ohlcv_week = Entry("stock", "fetch_security_ohlcv_week", {})
+    private_get_fetch_security_ohlcv_year = Entry("stock", "fetch_security_ohlcv_year", {})
+    # private_get_fetch_closed_order          = Entry('stock', 'fetch_closed_order', {})
+    # private_get_fetch_opened_order          = Entry('stock', 'fetch_opened_order', {})
+    # private_get_fetch_pnl                   = Entry('stock', 'fetch_pnl', {})
+    # private_get_fetch_screener              = Entry('stock', 'fetch_screener', {})
+    # private_get_fetch_screener_list         = Entry('stock', 'fetch_screener_list', {})
+
+    # post requests
+    private_post_send_modify_order = Entry("stock", "send_modify_order", {})
+    private_post_send_cancel_order = Entry("stock", "send_cancel_order", {})
+    private_post_send_order_entry = Entry("stock", "send_order_entry", {})
+    private_post_send_order_exit = Entry("stock", "send_order_exit", {})
+    private_post_send_order_loan_entry = Entry("stock", "send_order_loan_entry", {})
+    private_post_send_order_loan_exit = Entry("stock", "send_order_loan_exit", {})
+
+    # public methods
+
+    # post requests
+    public_post_generate_token = Entry("token", "generate_token", {})
+    public_post_revoke_token = Entry("token", "revoke_token", {})

ksxt/api/upbit.py

@@ -0,0 +1,54 @@
+from ksxt.api import Entry
+
+
+class ImplicitAPI:
+
+    # stock API methods
+
+    # public methods
+
+    # get requests
+    public_get_fetch_markets = Entry("stock", "fetch_markets", {})
+    public_get_fetch_security_ohlcv_minute = Entry("stock", "fetch_security_ohlcv_minute", {})
+    public_get_fetch_security_ohlcv_day = Entry("stock", "fetch_security_ohlcv_day", {})
+    public_get_fetch_security_ohlcv_week = Entry("stock", "fetch_security_ohlcv_week", {})
+    public_get_fetch_security_ohlcv_month = Entry("stock", "fetch_security_ohlcv_month", {})
+    public_get_fetch_ticker_price = Entry("stock", "fetch_ticker_price", {})
+    public_get_fetch_tickers_price = Entry("stock", "fetch_tickers_price", {})
+    public_get_fetch_orderbook = Entry("stock", "fetch_orderbook", {})
+    public_get_fetch_orderbooks = Entry("stock", "fetch_orderbooks", {})
+
+    # private methods
+
+    # get requests
+    private_get_fetch_balance = Entry("stock", "fetch_balance", {})
+    private_get_fetch_cash = Entry("stock", "fetch_cash", {})
+    private_get_fetch_security_info = Entry("stock", "fetch_security_info", {})
+    private_get_fetch_trade_fee = Entry("stock", "fetch_trade_fee", {})
+    private_get_fetch_closed_order_detail = Entry("stock", "fetch_closed_order_detail", {})
+    private_get_fetch_opened_order_detail = Entry("stock", "fetch_opened_order_detail", {})
+    private_get_fetch_opened_order = Entry("stock", "fetch_opened_order", {})
+    private_get_fetch_closed_order = Entry("stock", "fetch_closed_order", {})
+    private_get_fetch_withdrawal_history = Entry("stock", "fetch_withdrawal_history", {})
+    private_get_fetch_deposit_history = Entry("stock", "fetch_deposit_history", {})
+
+    # post requests
+    private_post_send_order_entry = Entry("stock", "send_order_entry", {})
+    private_post_send_order_entry_market = Entry("stock", "send_order_entry_market", {})
+    private_post_send_order_exit = Entry("stock", "send_order_exit", {})
+    private_post_send_order_exit_market = Entry("stock", "send_order_exit_market", {})
+
+    # delete requests
+    private_delete_send_cancel_order = Entry("stock", "send_cancel_order", {})
+
+    # websocket API methods
+
+    # public methods
+    public_subscribe_ticker = Entry("websocket", "subscribe_ticker", {})
+    public_subscribe_trade = Entry("websocket", "subscribe_trade", {})
+    public_subscribe_orderbook = Entry("websocket", "subscribe_orderbook", {})
+    public_subscribe_order = Entry("websocket", "subscribe_order", {})
+
+    # private methods
+    private_subscribe_ticker = Entry("websocket", "subscribe_ticker", {})
+    private_subscribe_trade = Entry("websocket", "subscribe_trade", {})

ksxt/async_/__init__.py

@@ -0,0 +1,4 @@
+from ksxt.async_.base.async_exchange import AsyncExchange
+from ksxt.async_.upbit import Upbit
+from ksxt.async_.bithumb import Bithumb
+from ksxt.async_.koreainvest import KoreaInvest

ksxt/async_/base/async_exchange.py

@@ -0,0 +1,232 @@
+import asyncio
+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.rest_exchange import RestExchange
+from ksxt.config import CONFIG_DIR
+import ksxt.models
+
+
+class AsyncExchange(RestExchange):
+    synchronous = False
+
+    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)
+
+    async def initialize(self):
+        if self.asyncio_loop is None:
+            self.asyncio_loop = asyncio.get_event_loop()
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+        if self.throttle is None:
+            self.throttle = Throttler({}, self.asyncio_loop)
+
+    async def close(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    async def __aenter__(self):
+        await self.initialize()
+        return self
+
+    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)
+
+        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="rb") as f:
+                c = tomllib.load(f)
+                return c
+
+    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
+
+        session_method = getattr(self.session, method.lower())
+
+        try:
+            async with session_method(
+                url,
+                # yarl.URL(url, encoded=True),
+                headers=request_headers,
+                data=request_body,
+                params=request_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:
+            details = f"{self.id} {method} {url}"
+            raise TimeoutError(details) from e
+
+    async def fetch2(
+        self, path, security_type, params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}
+    ):
+        is_activate = self.apis[self.type][security_type][path]["activate"]
+        if not is_activate:
+            return {
+                "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 await self.fetch(
+            request["url"], request["method"], request["headers"], request["body"], request["params"]
+        )
+
+    # region base method
+    async def fetch_markets(self, market_name: str) -> ksxt.models.KsxtMarketResponse:
+        raise NotSupportedError(f"{self.id} {self.fetch_markets.__qualname__}() is not supported yet.")
+
+    async 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.")
+
+    async 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.")
+
+    async 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.")
+
+    async 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.")
+
+    async def fetch_is_holiday(self, dt: datetime, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_is_holiday.__qualname__}() is not supported yet.")
+
+    async def fetch_user_info(self, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_user_info.__qualname__}() is not supported yet.")
+
+    async 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.")
+
+    async 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.")
+
+    async def fetch_screener_list(self, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_screener_list.__qualname__}() is not supported yet.")
+
+    async def fetch_screener(self, screen_id: str, base_market: str = "KRW"):
+        raise NotSupportedError(f"{self.id} {self.fetch_screener.__qualname__}() is not supported yet.")
+
+    async 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.")
+
+    async 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.")
+
+    async 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.")
+
+    async 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.")
+
+    async def modify_order(
+        self,
+        acc_num: str,
+        order_id: str,
+        price: float,
+        qty: float,
+        *args,
+        symbol: Optional[str] = "",
+        base_market: str = "KRW",
+    ):
+        raise NotSupportedError(f"{self.id} {self.modify_order.__qualname__}() is not supported yet.")
+
+    async 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.")
+
+    async 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.")
+
+    async 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
+
+    async def sleep(self, milliseconds):
+        return await asyncio.sleep(milliseconds / 1000)