kiwoomRest 0.0.1__py3-none-any.whl

kiwoomRest/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.0.1"
+
+from .rest_api import (
+    KwRestApi as KwRestApi,
+    ResponseData as ResponseData,
+)

kiwoomRest/rest_api.py

@@ -0,0 +1,445 @@
+############################################################################
+# 키움증권 REST API 비동기 클라이언트
+# 키움증권 가이드 참고: https://openapi.kiwoom.com/guide/apiguide
+############################################################################
+
+import asyncio
+import aiohttp
+import json
+import time
+
+BASE_URL_REAL = "https://api.kiwoom.com"
+BASE_URL_SIMUL = "https://mockapi.kiwoom.com"
+WSS_URL_REAL = "wss://api.kiwoom.com:10000/api/dostk/websocket"
+WSS_URL_SIMULATION = "wss://mockapi.kiwoom.com:10000/api/dostk/websocket"
+
+from .tr_code_to_path import tr_code_to_path
+
+
+class ResponseData:
+    def __init__(self,
+        api_id: str
+    ) -> None:
+        self.api_id = api_id
+        self.path = str()
+        self.return_code = int(-1)
+        self.return_msg = str()
+        self.cont_yn = str()
+        self.next_key = str()
+        self.body = {}
+        # additional variables
+        self.inputs = dict()
+        self.in_cont_yn = str()
+        self.in_next_key = str()
+        self.request_time = 0.0
+        self.elapsed_ms = 0.0
+
+    def __str__(self) -> str:
+        return f"ResponseData(api_id={self.api_id}, path={self.path}, return_code={self.return_code}, return_msg={self.return_msg}, cont_yn={self.cont_yn}, next_key={self.next_key}, body={self.body})"
+
+class KwRestApi(object):
+
+    class _event_signal:
+        class _slot:
+            def __init__(self, func):
+                self.func = func
+                self.is_coroutine = asyncio.iscoroutinefunction(func)
+            def __eq__(self, other):
+                return self.func == other
+        def __init__(self):
+            self.__slots: list[KwRestApi._event_signal._slot] = []
+        def connect(self, func):
+            # check callable
+            if not hasattr(func, "__call__") :
+                raise ValueError("slot must be callable")
+            # check exist
+            exist_slot = next((s for s in self.__slots if s.func == func), None)
+            if exist_slot:
+                return
+            # add slot
+            self.__slots.append(self._slot(func))
+        def disconnect(self, func):
+            exist_slot = next((s for s in self.__slots if s.func == func), None)
+            if exist_slot:
+                self.__slots.remove(exist_slot)
+        def disconnect_all(self):
+            self.__slots.clear()
+        async def emit_signal(self, *args):
+            for slot in self.__slots:
+                if slot.is_coroutine:
+                    await slot.func(*args)
+                else:
+                    slot.func(*args)
+
+    class _asyncNode:
+        def __init__(self, hashid):
+            self.__event = asyncio.Event()
+            self.hashid = hashid
+            self.jsondata = {}
+
+        def set(self):
+            self.__event.set()
+
+        async def wait(self, timeout=None):
+            if timeout is None:
+                await self.__event.wait()
+                return True
+            try:
+                await asyncio.wait_for(self.__event.wait(), timeout)
+                return True
+            except asyncio.TimeoutError:
+                return False
+
+    def __init__(self):
+        super().__init__()
+        
+        self._access_token = ""
+        self._http = None
+        self._websocket = None
+        self._base_url:str = ""
+        self._connected:bool = False
+        self._is_simulation:bool = False
+        self._last_message:str = ""
+        self._timeout = 5
+        self._last_response_value = None
+    
+        # 이벤트 핸들러
+        self._on_message = self._event_signal()
+        self._on_realtime = self._event_signal()
+
+        # 웹소켓 비동기 요청 노드
+        self._ws_asyncnode:KwRestApi._asyncNode | None = None
+
+    @property
+    def connected(self) -> bool:
+        """로그인 연결상태.
+        True: 연결됨, False: 연결안됨
+
+        A readonly property.
+        """
+        return self._connected
+    
+    @property
+    def is_simulation(self) -> bool:
+        """서버모드
+        True: 모의투자, False: 실투자
+
+        A readonly property.
+        """
+        return self._is_simulation
+
+    @property
+    def last_message(self) -> str:
+        """last error message.
+
+        A readonly property.
+        """
+        return self._last_message
+
+    @property
+    def on_message(self) :
+        """메시지 수신 이벤트 핸들러, 웹소켓 오류/끊김 시 발생
+        on_message(msg:str)
+        """
+        return self._on_message
+
+    @property
+    def on_realtime(self) :
+        """실시간 데이터 수신 이벤트 핸들러
+        on_realtime(realdata:dict)
+        """
+        return self._on_realtime
+
+    @property
+    def last_response(self) -> ResponseData | None:
+        """마지막 요청 응답값
+        ResponseValue: 응답값
+        """
+        return self._last_response_value
+
+    @property
+    def access_token(self) -> str:
+        """access token
+        access_token: access token
+        """
+        return self._access_token
+
+    @property
+    def timeout(self) -> int:
+        """timeout
+        timeout: timeout
+        """
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value: int) -> None:
+        """timeout setter
+        value: timeout
+        """
+        if value <= 0:
+            raise ValueError("timeout must be greater than 0")
+        self._timeout = value
+    
+    async def close(self) -> None:
+        """연결 종료"""
+        self._connected = False
+        if self._websocket and not self._websocket.closed:
+            await self._websocket.close()
+        if self._http and not self._http.closed:
+            await self._http.close()
+
+    async def login(self, appkey:str, secretkey:str, is_simulation:bool = False) -> bool:
+        '''
+        로그인 요청
+        appkey: 앱키
+        secretkey: 앱시크릿키
+        is_simulation: 모의투자 로그인 시 True, 실투자 로그인 시 False (default)
+        return: True: 성공, False: 실패, 실패시 last_message에 실패사유가 저장됨
+        '''
+        if self._connected :
+            self._last_message = "aleady connected"
+            return True
+        
+        if appkey == "" or secretkey == "":
+            self._last_message = "appkey or secretkey is empty"
+            return False
+    
+        self._is_simulation = is_simulation
+        self._base_url = BASE_URL_SIMUL if self._is_simulation else BASE_URL_REAL
+
+        timeout = aiohttp.ClientTimeout(total=10) # 10초 타임아웃
+        self._http = aiohttp.ClientSession(timeout=timeout)
+
+        # 토큰 가져오기
+        self._connected = True
+        inputs = {'grant_type': 'client_credentials', 'appkey': appkey, 'secretkey': secretkey}
+        response = await self.request("oauth2", inputs, path="/oauth2/token")
+        if response.return_code == 0:
+            # 토큰발급 성공
+            token = response.body["token"]
+            self._http.headers["Authorization"] = f"Bearer {token}"
+            self._access_token = token
+            # 웹소켓 연결/인증요청
+            try:
+                websocket = await  self._http.ws_connect(WSS_URL_SIMULATION if self._is_simulation else WSS_URL_REAL)
+                if not websocket.closed:
+                    self._websocket = websocket
+                    asyncio.create_task(self._websocket_listen())
+                    response = await self.realtime({"trnm":"LOGIN", "token" : self._access_token})
+                    if response.return_code == 0:
+                        # 인증성공
+                        self._last_message = "Login success"
+                        return True
+                    else:
+                        self._last_message = response.return_msg
+                else:
+                    self._last_message = "websocket connection failed."
+            except Exception as e:
+                self._last_message = str(e)
+        else:
+            self._last_message = response.return_msg
+        await self.close()
+        return False
+
+    async def request(self
+            , api_id:str
+            , indatas:dict
+            ,*
+            , cont_yn:str="N"
+            , next_key:str=""
+            , path:str=None
+            ) -> ResponseData:
+        '''
+        TR/실시간 요청
+        api_id: TR코드(api-id)
+        indatas: 입력데이터(dictionary)
+        cont_yn: TR연속요청여부
+        next_key: TR연속요청키
+        path: 요청경로(생략시 자동으로 결정)
+        return: ResponseValue, 성공시 return_code = 0, 그외 실패, 실패시 return_msg에 실패사유가 저장됨
+
+        example:
+        # 삼성전자 종목정보 조회
+        inputs = {
+            "stk_cd" : "005930"
+        }
+        response = await api.request("ka10001", inputs)
+        print(response)
+
+        # 조건검색식 목록 조회
+        inputs = {
+            "trnm" : "CNSRLST"
+        }
+        response = await api.request("ka10171", inputs)
+        print(response)
+        '''
+        result = ResponseData(api_id)
+        result.in_cont_yn = cont_yn
+        result.in_next_key = next_key
+        result.inputs = indatas
+
+        if not path:
+            path = tr_code_to_path.get(api_id, None)
+            if not path:
+                self._last_message = "Not supported tr_code-path"
+                result.return_msg = self._last_message
+                return result
+
+        result.path = path
+
+        self._last_response_value = result
+        if not self._connected:
+            self._last_message = "Not connected"
+            result.return_msg = self._last_message
+            return result
+
+        # check if websocket request
+        if path.endswith("/websocket"):
+            result.request_time = time.time()
+            start_time = time.perf_counter_ns()
+            ws_result = await self._ws_request(indatas)
+            result.elapsed_ms = (time.perf_counter_ns() - start_time) / 1000000
+            if ws_result != None:
+                result.return_code = ws_result.get("return_code", -1)
+                result.return_msg = ws_result.get("return_msg", "")
+                result.body = ws_result
+                return result
+            else:
+                result.return_code = -1
+                result.return_msg = self._last_message
+                return result
+
+        headers = dict()
+        headers["api-id"] = api_id
+        headers["cont-yn"] = cont_yn
+        headers["next-key"] = next_key
+        
+        try:
+            result.request_time = time.time()
+            start_time = time.perf_counter_ns()
+            response = await self._http.post(self._base_url + path, headers=headers, json=indatas)
+            response_data:dict = await response.json()
+            result.elapsed_ms = (time.perf_counter_ns() - start_time) / 1000000
+            if response.status != 200:
+                self._last_message = f"Request failed. {response.status}"
+                result.return_msg = self._last_message
+                return result
+            result.cont_yn = response.headers.get("cont-yn", "N")
+            result.next_key = response.headers.get("next-key", "")
+            result.body = response_data
+            result.return_code = result.body.get("return_code", -1)
+            self._last_message = result.body.get("return_msg", "")
+            result.return_msg = self._last_message
+        except Exception as e:
+            self._last_message = str(e)
+            result.return_msg = self._last_message
+
+        return result
+
+    def realtime(self, indatas:dict):
+        '''
+        # ex: 삼성전자, SK하이닉스 실시간 체결 시세 등록
+        inputs = {
+            "trnm" : "REG",
+            "grp_no" : "1",
+            "refresh" : "1",
+            "data" : [{
+                " item" : [ "005930", "000660" ],
+                " type" : [ "0B" ] # 우선호가시세 까지 함께 등록할 경우 ["0B", "0C" ]로 설정
+            }]
+        }
+        response = await api.realtime(inputs)
+        print(response)
+
+        # 실시간 시세 해제 시 "REG" -> "REMOVE" 로 변경
+        inputs["trnm"] = "REMOVE"
+        response = await api.realtime(inputs)
+        '''
+        return self.request("realtime", indatas, path="/api/dostk/websocket", cont_yn="")
+
+    async def ws_sendmessage(self, text:str) -> bool:
+        '''
+        웹소켓 메시지 전송
+        text: 전송할 메시지
+        return: True: 성공, False: 실패, 실패시 last_message에 실패사유가 저장됨
+        '''
+        if not self._connected or self._websocket.closed:
+            self._last_message = "Not connected"
+            return False
+        await self._websocket.send_str(text)
+        return True
+
+    async def _ws_request(self, indatas:dict) -> dict | None:
+        # check connection
+        if not self._connected:
+            self._last_message = "Not connected"
+            return None
+
+        # check async node
+        if self._ws_asyncnode != None:
+            # already requested
+            self._last_message = "Already requested"
+            return None
+
+        trnm = indatas.get("trnm", None)
+        if trnm == None:
+            self._last_message = "trnm is not define."
+            return None
+
+        # create async node
+        node = KwRestApi._asyncNode(trnm)
+        self._ws_asyncnode = node
+
+        # send message
+        try:
+            await self._websocket.send_json(indatas)
+            # wait for response
+            if not await self._ws_asyncnode.wait(self.timeout):
+                # timeout
+                self._last_message = "Timeout"
+                self._ws_asyncnode = None
+                return None
+        except Exception as e:
+            self._last_message = f"websocket request error. {e}"
+            self._ws_asyncnode = None
+            return None
+
+        # set response and return
+        self._ws_asyncnode = None
+        return node.jsondata
+
+    async def _websocket_listen(self):
+        async for msg in self._websocket:
+            if msg.type == aiohttp.WSMsgType.TEXT:
+                json_text = msg.data
+                try:
+                    jsondata = json.loads(json_text)
+                    trnm = jsondata.get("trnm", None)
+                    if trnm != None:
+                        # proc PING
+                        if trnm == "PING":
+                            await self._websocket.send_str(json_text)
+                            continue
+                        # check async node
+                        if self._ws_asyncnode != None and self._ws_asyncnode.hashid == trnm:
+                            # setting jsondata, set event
+                            self._ws_asyncnode.jsondata = jsondata
+                            self._ws_asyncnode.set()
+                            continue
+                    # raise event
+                    await self._on_realtime.emit_signal(jsondata)
+                except Exception as e:
+                    self._last_message = f"websocket exception. {e}"
+                    await self._on_message.emit_signal(self._last_message)
+                    continue
+
+            elif msg.type == aiohttp.WSMsgType.CLOSED:
+                break
+
+            elif msg.type == aiohttp.WSMsgType.ERROR:
+                self._last_message = f"websocket error. {msg}"
+                await self._on_message.emit_signal(self._last_message)
+
+        if self._connected:
+            self._last_message = f"websocket closed."
+            await self._on_message.emit_signal(self._last_message)

kiwoomRest/tr_code_to_path.py

@@ -0,0 +1,205 @@
+tr_code_to_path:dict = {
+    
+    ## 국내주식
+
+    # 종목정보
+    "ka10001" : "/api/dostk/stkinfo",
+    "ka10002" : "/api/dostk/stkinfo",
+    "ka10003" : "/api/dostk/stkinfo",
+    "ka10013" : "/api/dostk/stkinfo",
+    "ka10015" : "/api/dostk/stkinfo",
+    "ka10016" : "/api/dostk/stkinfo",
+    "ka10017" : "/api/dostk/stkinfo",
+    "ka10018" : "/api/dostk/stkinfo",
+    "ka10019" : "/api/dostk/stkinfo",
+    "ka10024" : "/api/dostk/stkinfo",
+    "ka10025" : "/api/dostk/stkinfo",
+    "ka10026" : "/api/dostk/stkinfo",
+    "ka10028" : "/api/dostk/stkinfo",
+    "ka10043" : "/api/dostk/stkinfo",
+    "ka10052" : "/api/dostk/stkinfo",
+    "ka10054" : "/api/dostk/stkinfo",
+    "ka10055" : "/api/dostk/stkinfo",
+    "ka10058" : "/api/dostk/stkinfo",
+    "ka10059" : "/api/dostk/stkinfo",
+    "ka10061" : "/api/dostk/stkinfo",
+    "ka10084" : "/api/dostk/stkinfo",
+    "ka10095" : "/api/dostk/stkinfo",
+    "ka10099" : "/api/dostk/stkinfo",
+    "ka10100" : "/api/dostk/stkinfo",
+    "ka10101" : "/api/dostk/stkinfo",
+    "ka10102" : "/api/dostk/stkinfo",
+    "ka90003" : "/api/dostk/stkinfo",
+    "ka90004" : "/api/dostk/stkinfo",
+    "ka90012" : "/api/dostk/stkinfo",
+
+    # 시세
+    "ka10004" : "/api/dostk/mrkcond",
+    "ka10005" : "/api/dostk/mrkcond",
+    "ka10006" : "/api/dostk/mrkcond",
+    "ka10007" : "/api/dostk/mrkcond",
+    "ka10011" : "/api/dostk/mrkcond",
+    "ka10044" : "/api/dostk/mrkcond",
+    "ka10045" : "/api/dostk/mrkcond",
+    "ka10046" : "/api/dostk/mrkcond",
+    "ka10047" : "/api/dostk/mrkcond",
+    "ka10063" : "/api/dostk/mrkcond",
+    "ka10066" : "/api/dostk/mrkcond",
+    "ka10078" : "/api/dostk/mrkcond",
+    "ka10086" : "/api/dostk/mrkcond",
+    "ka10087" : "/api/dostk/mrkcond",
+    "ka90005" : "/api/dostk/mrkcond",
+    "ka90006" : "/api/dostk/mrkcond",
+    "ka90007" : "/api/dostk/mrkcond",
+    "ka90008" : "/api/dostk/mrkcond",
+    "ka90010" : "/api/dostk/mrkcond",
+    "ka90013" : "/api/dostk/mrkcond",
+
+    # 기관/외국인
+    "ka10008" : "/api/dostk/frgnistt",
+    "ka10009" : "/api/dostk/frgnistt",
+    "ka10131" : "/api/dostk/frgnistt",
+
+    # 업종
+    "ka10010" : "/api/dostk/sect",
+    "ka10051" : "/api/dostk/sect",
+    "ka20001" : "/api/dostk/sect",
+    "ka20002" : "/api/dostk/sect",
+    "ka20003" : "/api/dostk/sect",
+    "ka20009" : "/api/dostk/sect",
+
+    # 순위정보
+    "ka10020" : "/api/dostk/rkinfo",
+    "ka10021" : "/api/dostk/rkinfo",
+    "ka10022" : "/api/dostk/rkinfo",
+    "ka10023" : "/api/dostk/rkinfo",
+    "ka10027" : "/api/dostk/rkinfo",
+    "ka10029" : "/api/dostk/rkinfo",
+    "ka10030" : "/api/dostk/rkinfo",
+    "ka10031" : "/api/dostk/rkinfo",
+    "ka10032" : "/api/dostk/rkinfo",
+    "ka10033" : "/api/dostk/rkinfo",
+    "ka10034" : "/api/dostk/rkinfo",
+    "ka10035" : "/api/dostk/rkinfo",
+    "ka10036" : "/api/dostk/rkinfo",
+    "ka10037" : "/api/dostk/rkinfo",
+    "ka10038" : "/api/dostk/rkinfo",
+    "ka10039" : "/api/dostk/rkinfo",
+    "ka10040" : "/api/dostk/rkinfo",
+    "ka10042" : "/api/dostk/rkinfo",
+    "ka10053" : "/api/dostk/rkinfo",
+    "ka10062" : "/api/dostk/rkinfo",
+    "ka10065" : "/api/dostk/rkinfo",
+    "ka10069" : "/api/dostk/rkinfo",
+    "ka10098" : "/api/dostk/rkinfo",
+    "ka90009" : "/api/dostk/rkinfo",
+
+    # ELW
+    "ka10048" : "/api/dostk/elw",
+    "ka10050" : "/api/dostk/elw",
+    "ka30001" : "/api/dostk/elw",
+    "ka30002" : "/api/dostk/elw",
+    "ka30003" : "/api/dostk/elw",
+    "ka30004" : "/api/dostk/elw",
+    "ka30005" : "/api/dostk/elw",
+    "ka30009" : "/api/dostk/elw",
+    "ka30010" : "/api/dostk/elw",
+    "ka30011" : "/api/dostk/elw",
+    "ka30012" : "/api/dostk/elw",
+
+    # 차트
+    "ka10060" : "/api/dostk/chart",
+    "ka10064" : "/api/dostk/chart",
+    "ka10079" : "/api/dostk/chart",
+    "ka10080" : "/api/dostk/chart",
+    "ka10081" : "/api/dostk/chart",
+    "ka10082" : "/api/dostk/chart",
+    "ka10083" : "/api/dostk/chart",
+    "ka10094" : "/api/dostk/chart",
+    "ka20004" : "/api/dostk/chart",
+    "ka20005" : "/api/dostk/chart",
+    "ka20006" : "/api/dostk/chart",
+    "ka20007" : "/api/dostk/chart",
+    "ka20008" : "/api/dostk/chart",
+    "ka20019" : "/api/dostk/chart",
+
+    # 계좌
+    "ka10072" : "/api/dostk/acnt",
+    "ka10073" : "/api/dostk/acnt",
+    "ka10074" : "/api/dostk/acnt",
+    "ka10075" : "/api/dostk/acnt",
+    "ka10076" : "/api/dostk/acnt",
+    "ka10077" : "/api/dostk/acnt",
+    "ka10085" : "/api/dostk/acnt",
+    "ka10088" : "/api/dostk/acnt",
+    "ka10170" : "/api/dostk/acnt",
+    "kt00001" : "/api/dostk/acnt",
+    "kt00002" : "/api/dostk/acnt",
+    "kt00003" : "/api/dostk/acnt",
+    "kt00004" : "/api/dostk/acnt",
+    "kt00005" : "/api/dostk/acnt",
+    "kt00007" : "/api/dostk/acnt",
+    "kt00008" : "/api/dostk/acnt",
+    "kt00009" : "/api/dostk/acnt",
+    "kt00010" : "/api/dostk/acnt",
+    "kt00011" : "/api/dostk/acnt",
+    "kt00012" : "/api/dostk/acnt",
+    "kt00013" : "/api/dostk/acnt",
+    "kt00015" : "/api/dostk/acnt",
+    "kt00016" : "/api/dostk/acnt",
+    "kt00017" : "/api/dostk/acnt",
+    "kt00018" : "/api/dostk/acnt",
+
+    # ETF
+    "ka40001" : "/api/dostk/etf",
+    "ka40002" : "/api/dostk/etf",
+    "ka40003" : "/api/dostk/etf",
+    "ka40004" : "/api/dostk/etf",
+    "ka40006" : "/api/dostk/etf",
+    "ka40007" : "/api/dostk/etf",
+    "ka40008" : "/api/dostk/etf",
+    "ka40009" : "/api/dostk/etf",
+    "ka40010" : "/api/dostk/etf",
+
+    # 테마
+    "ka90001" : "/api/dostk/thme",
+    "ka90002" : "/api/dostk/thme",
+
+    # 주문
+    "kt10000" : "/api/dostk/ordr",
+    "kt10001" : "/api/dostk/ordr",
+    "kt10002" : "/api/dostk/ordr",
+    "kt10003" : "/api/dostk/ordr",
+
+    # 실시간시세
+    "00" : "/api/dostk/websocket",
+    "04" : "/api/dostk/websocket",
+    "0A" : "/api/dostk/websocket",
+    "0B" : "/api/dostk/websocket",
+    "0C" : "/api/dostk/websocket",
+    "0D" : "/api/dostk/websocket",
+    "0E" : "/api/dostk/websocket",
+    "0F" : "/api/dostk/websocket",
+    "0G" : "/api/dostk/websocket",
+    "0H" : "/api/dostk/websocket",
+    "0J" : "/api/dostk/websocket",
+    "0U" : "/api/dostk/websocket",
+    "0g" : "/api/dostk/websocket",
+    "0m" : "/api/dostk/websocket",
+    "0s" : "/api/dostk/websocket",
+    "0u" : "/api/dostk/websocket",
+    "0w" : "/api/dostk/websocket",
+    "1h" : "/api/dostk/websocket",
+
+    # 조건검색
+    "ka10171" : "/api/dostk/websocket",
+    "ka10172" : "/api/dostk/websocket",
+    "ka10173" : "/api/dostk/websocket",
+    "ka10174" : "/api/dostk/websocket",
+
+    # 신용주문
+    "kt10006" : "/api/dostk/crdordr",
+    "kt10007" : "/api/dostk/crdordr",
+    "kt10008" : "/api/dostk/crdordr",
+    "kt10009" : "/api/dostk/crdordr",
+}

kiwoomrest-0.0.1.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.3
+Name: kiwoomRest
+Version: 0.0.1
+Summary: package for Kiwoom RestAPI
+Project-URL: Homepage, https://github.com/teranum/python-packages/tree/master/kiwoomRest
+Author-email: teranum <teranum@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: aiohttp
+Description-Content-Type: text/markdown
+
+# kiwoomRest Package
+
+키움증권 REST API 간편이용 패키지.
+
+## Installation
+
+```bash
+pip install kiwoomRest
+```
+
+## Usage
+모든 요청은 비동기로 처리되며, 요청에 대한 응답은 await 키워드를 사용하여 받을 수 있습니다.
+<BR/>
+Samples: https://github.com/teranum/kiwoom-restapi-samples
+
+### 로그인 요청은 반드시 먼저 수행되어야 하며, 로그인이 성공하면 다른 요청을 수행할 수 있습니다.
+```python
+import asyncio
+from kiwoomRest import KwRestApi
+from app_keys import appkey, secretkey # app_keys.py 파일에 appkey, secretkey 변수를 정의하고 사용하세요
+
+async def main():
+    # Kiwoom API 객체 생성
+    api = KwRestApi()
+
+    # 실시간 이벤트 핸들러 등록
+    api.on_realtime.connect(lambda realdatas: print(f"on_realtime: {realdatas}"))
+
+    # 로그인
+    ret = await api.login(appkey, secretkey, is_simulation=False) # 실거래서버 사용, 모의투자서버 사용시 is_simulation=True
+    if not ret:
+        print(api.last_message)
+        return
+    print("Login success")
+
+    # 다른 작업...
+    await asyncio.sleep(5)
+
+    # 연결 종료
+    await api.close()
+
+
+asyncio.run(main())
+```
+
+### 조회/연속 요청
+```python
+    # 종목정보 리스트 조회
+    inputs = {
+        "mrkt_tp": "0" # 시장구분: 0:코스피, 10:코스닥, 3:ELW, 8:ETF, 30:K-OTC, 50:코넥스, 5:신주인수권, 4:뮤추얼펀드, 6:리츠, 9:하이일드
+    }
+    response = await api.request("ka10099", inputs)
+    
+    # 주식 종목정보 조회
+    inputs = {
+        "stk_cd" : "005930" # 종목코드: 삼성전자
+    }
+    response = await api.request("ka10001", inputs)
+
+    # 주식 차트 조회
+    inputs = {
+        "stk_cd": "005930",     # 종목코드: 삼성전자
+        "base_dt": "00000000",  # 기준일자: 00000000(현재일자)
+        "upd_stkpc_tp": "1"     # 수정주가구분: 0(미적용), 1(적용)
+    }
+    response = await api.request("ka10081", inputs)
+
+    # 연속조회
+    if response.cont_yn == "Y":
+        response = await api.request("t8410", request, cont_yn=response.cont_yn, next_key=response.next_key)
+
+    # response 출력
+    if response.return_code == 0:
+        print("조회 성공")
+        print(response.body)
+    else:
+        print(f"조회 실패: {response.return_msg}")
+
+```
+
+### 조건검색 조회/실시간
+```python
+    # 서버저장조건 리스트조회
+    inputs = {
+        "trnm" : "CNSRLST"      # CNSRLST 고정값
+    }
+    response = await api.request("ka10171", inputs)
+
+    # 조건검색 요청 일반
+    inputs = {
+        "trnm" : "CNSRREQ",     # CNSRREQ 고정값
+        "seq" : "4",            # 조건검색식 일련번호
+        "search_type" : "0",    # 0:조건검색 
+        "stex_tp" : "K",        # K:KRX
+        "cont_yn" : "N",        # 연속조회여부 (Y:연속조회, N:단순조회)
+        "next_key" : ""         # 연속조회키 (연속조회여부가 'Y'인 경우 필수 세팅)
+    }
+    response = await api.request("ka10172", inputs)
+
+    # 조건검색 실시간 검색 등록
+    api.on_realtime.connect(print) # 실시간 이벤트 핸들러 등록
+    inputs = {
+        "trnm" : "CNSRREQ",     # CNSRREQ 고정값
+        "seq" : "4",            # 조건검색식 일련번호
+        "search_type" : "1",    # 1: 조건검색+실시간조건검색
+        "stex_tp" : "K"         # K:KRX
+    }
+    response = await api.realtime(inputs)
+    
+    if response.return_code != 0:
+        print(f"실시간검색 등록실패: {response.return_msg}")
+        return
+
+    print("실시간검색 등록성공")
+    print(response.body)
+
+    await asyncio.sleep(60) # 60초동안 유효, 후에 중지
+
+    # 조건검색 실시간 해제
+    inputs = {
+        "trnm" : "CNSRCLR",     # CNSRCLR 고정값
+        "seq" : "4",            # 조건검색식 일련번호
+    }
+    response = await api.realtime(inputs)
+    print("실시간검색 해제")
+
+```
+
+### 웹소켓 실시간 시세 등록/해제
+```python
+    api.on_realtime.connect(on_realtime) # 실시간 이벤트 핸들러 연결
+
+    # 삼성전자 실시간 체결 시세 등록
+    inputs = {
+        "trnm" : "REG",
+        "grp_no" : "1",
+        "refresh" : "1",
+        "data" : [{
+            " item" : ["005930"],   # 삼성전자. or SK하이닉스 함께 등록할 경우 ["005930", "000660"] 로 설정
+            " type" : ["0B"]        # 체결시세. or 우선호가시세 함께 등록할 경우 ["0B", "0C"]로 설정
+        }]
+    }
+    response = await api.realtime(inputs)
+    
+    # 60초후 실시간 시세 중지
+    await asyncio.sleep(60)
+
+    # 실시간 시세 해제 시 "REG" -> "REMOVE" 로 변경
+    inputs["trnm"] = "REMOVE"
+    response = await api.realtime(inputs)
+
+def on_realtime(realdatas):
+    print(f"실시간이벤트: {realdatas}")
+
+```
+
+## 프로퍼티, 메소드, 이벤트
+```python
+# 프로퍼티
+    connected -> bool: 연결여부 (연결: True, 미연결: False)
+    is_simulation -> bool: 모의투자 여부 (모의투자: True, 실거래: False))
+    access_token -> str: 발급된 엑세스토큰
+    last_message -> str: 마지막 메시지, 로그인 또는 요청 실패시 사유 저장
+
+# 메소드
+    login(appkey:str, secretkey:str, is_simulation:bool = False) -> bool: 로그인
+        appkey:str - 앱키
+        secretkey:str - 앱시크릿키
+        is_simulation:bool - 모의서버 사용여부 (모의서버: True, 실거래서버: False), 기본값: False
+        reutrn: bool - 로그인 성공여부 (성공: True, 실패: False), 실패시 last_message에 실패 사유 저장
+        
+    request(api_id:str, indatas:dict, *, cont_yn:str='N', next_key:str='0', path:str=None) -> ResponseData: TR요청
+        api_id:str - api-id (TR코드)
+        indatas:dict - 요청 데이터
+        * - cont_yn, next_key, path는 옵션(기본값으로 설정됨)
+        cont_yn:str - 연속조회여부 (연속조회: 'Y', 단순조회: 'N'), 기본값: 'N'
+        next_key:str - 연속조회키 (연속조회여부가 'Y'인 경우 필수 세팅), 기본값: '0'
+        path:str - PATH경로, 기본값: None(자동으로 설정 됨), 설정 필요시 URL값으로 세팅 ex) '/api/dostk/stkinfo'
+        return: ResponseData - 응답 데이터, 요청 성공 여부는 return_code로 확인 가능 (0: 성공, 그 외: 실패)
+    
+    realtime(indatas:dict) -> ResponseData: 실시간 등록/해제
+        indatas:dict - 실시간 요청 데이터
+        return: ResponseData - 응답 데이터, 요청 성공 여부는 return_code로 확인 가능 (0: 성공, 그 외: 실패)
+        
+    close() -> None: 연결 종료
+
+
+# 이벤트:
+    on_message(msg:str): 메시지 수신 이벤트 (웹소켓 오류시 발생)
+        msg - 메시지
+        - ex.1 ) 'websocket exception. {e}'
+        - ex.2 ) 'websocket closed. {msg}'
+        - ex.3 ) 'websocket error. {msg}'
+        
+    on_realtime(realdatas:dict): 실시간 수신 이벤트 (실시간 데이터 수신시 발생)
+        realdatas - 실시간 데이터
+
+    이벤트 핸들러 연결 : api 객체 생성시 연결
+        api = KwRestApi()
+        api.on_message.connect(print)
+        api.on_realtime.connect(print)
+
+# 응답데이터 : ResponseData
+    return_code -> int: 응답코드 (0: 성공, 그 외: 실패)
+    return_msg -> str: 응답메시지 (성공/실패 메시지)
+    body -> dict: 응답데이터 (조회결과 데이터)
+    cont_yn -> str: 연속조회여부 (연속조회 있을 경우: 'Y'로 세팅됨)
+    next_key -> str: 연속조회키
+
+    api_id -> str: 요청 api-id (TR코드)
+    path -> str: 요청 PATH경로(URL)
+```

kiwoomrest-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+kiwoomRest/__init__.py,sha256=QGusLIiQqiPWAlKruu-G6T6G0STyyhG2jJyOaXCspJU,120
+kiwoomRest/rest_api.py,sha256=W-cCUFTg1p5TIJR1d6bn391A_M9hgZYmLkkiTf6tZ0A,15975
+kiwoomRest/tr_code_to_path.py,sha256=dpy5YqXyOiYGQgaW4tSo50_8ApKUSkpbYqCGOpZACGs,6781
+kiwoomrest-0.0.1.dist-info/METADATA,sha256=gFxhsYYDg-03SmW-BPXz9-Att2Gx0VnXJPzLv6UGn2w,8136
+kiwoomrest-0.0.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+kiwoomrest-0.0.1.dist-info/licenses/LICENSE,sha256=RGh27_uzSrWGoN1S0od88T_hkD8HqGDOBJCbBOccXKg,1087
+kiwoomrest-0.0.1.dist-info/RECORD,,

kiwoomrest-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

kiwoomrest-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 teranum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+