""" kis_trader/network/kiwoom_condition_manager.py — 키움 조건검색 기반 동적 유니버스 (WS 실시간) ================================================================================================== 팩트 체크 먼저: * KIS 조건검색(psearch-title/psearch-result)은 **웹소켓 미지원 → REST 폴링만** 가능하다. (기존 ``ConditionSearchManager`` 참고) * 반면 키움 신형 오픈API 는 **웹소켓으로 조건검색 실시간(편입/이탈 push)** 을 지원한다. - CNSRLST : 서버 저장 조건식 목록 (name → seq 해결) - CNSRREQ : 실시간 조건검색 등록 (search_type="1") → 초기 매칭 + 이후 REAL push - REAL : 편입(843="I") / 이탈(843="D"), 종목코드는 9001 - CNSRCLR : 실시간 해제 (이 경로는 ``_test_kiwoom_condition_realtime.py`` 에서 실계정으로 검증 완료) 설계 (최소 침습): * ``ConditionSearchManager`` 를 **서브클래싱** 하여 - 결과 반영 로직(``_apply_result``), 순서 계산(``_build_ordered_universe``), 스냅샷 저장(``_save_snapshot``), 조회 API(``get_universe_for``/``get_candidates_for``), EXIT grace, name_map, _configs 정규화 등을 **그대로 재사용**한다. - 데이터 취득만 REST 폴링 → **키움 WS 실시간** 으로 오버라이드. * 스냅샷은 KIS 와 **동일한** ``target_candidates_history`` 에 저장하므로 백테스트/유니버스 타임라인 코드는 변경 없이 그대로 재현 가능하다. * BaseStrategy 는 ``kiwoom_condition_mgr`` 로 주입받아 ``{SID}_UNIVERSE_SOURCE=kiwoom_condition`` 일 때 이 매니저를 소비한다. (KIS ``condition`` 소스와 완전 독립 — 기존 동작 불변) 사용: km = KiwoomConditionSearchManager( app_key=..., app_secret=..., # 반드시 KIWOOM_APP_KEY_REAL (main 이 is_mock=False 고정) configs=[{"strategy_id": "MOMENTUM", "name": "momentum", "seq": "3"}], db=db, ) km.start() codes = km.get_universe_for("MOMENTUM") """ from __future__ import annotations import json import threading import time from typing import Dict, List, Optional, Set from .condition_manager import ConditionSearchManager from ..utils.env import get_env_from_db, get_env_int from ..utils.logger import get_logger from ..ws.kis_ws import _get_kiwoom_token_cached logger = get_logger("kis_trader.kwcond") def _normalize_code(raw) -> str: """키움 종목코드 정규화: 'A005930' → '005930' (KIS 6자리 코드계와 정합).""" c = str(raw or "").strip() if not c: return "" # 키움은 국내주식 코드 앞에 'A' 접두를 붙이는 경우가 있음. if c[0] in ("A", "a") and len(c) >= 7: c = c[1:] return c class KiwoomConditionSearchManager(ConditionSearchManager): """키움 웹소켓 실시간 조건검색 매니저. ``ConditionSearchManager`` 와 **동일한 public API** 를 제공한다: - start() / stop() - get_universe_for(strategy_id) / get_candidates_for(strategy_id) - _configs (BaseStrategy._is_strategy_registered 판별용) """ def __init__( self, *, app_key: str, app_secret: str, is_mock: bool, configs: Optional[List[Dict]] = None, db=None, on_change=None, ): # 부모 초기화: client 는 REST 미사용이므로 None, user_id 는 로깅용 placeholder. # configs 정규화·EXIT grace·name_map·_lock 등은 부모가 세팅. super().__init__( client=None, user_id="KIWOOM", configs=configs, db=db, on_change=on_change, ) self._app_key = (app_key or "").strip() self._app_secret = (app_secret or "").strip() self._is_mock = bool(is_mock) self._token: Optional[str] = None # WS URL (실전/모의) — env 로 오버라이드 가능. if self._is_mock: self._ws_url = ( get_env_from_db( "KIWOOM_WS_URL_MOCK", "wss://mockapi.kiwoom.com:10000/api/dostk/websocket", ) or "wss://mockapi.kiwoom.com:10000/api/dostk/websocket" ).strip() else: self._ws_url = ( get_env_from_db( "KIWOOM_WS_URL_REAL", "wss://api.kiwoom.com:10000/api/dostk/websocket", ) or "wss://api.kiwoom.com:10000/api/dostk/websocket" ).strip() # 실시간 재등록 대기(초) — 재접속 시 사용. self._reconnect_backoff = float(get_env_int("KIWOOM_COND_RECONNECT_SEC", 5)) # 키움 전용 상태 self._kw_lock = threading.Lock() self._ws = None self._ws_thread: Optional[threading.Thread] = None # seq → {code(정규화): name} (삽입순 유지 = HTS 응답 순서) self._seq_codes: Dict[str, "Dict[str, str]"] = {} # seq → [strategy_id, ...] (같은 seq 를 공유하는 전략) self._sid_by_seq: Dict[str, List[str]] = {} # 이번 접속에서 실시간 등록할 unique seq 목록 (CNSRLST 해결 후 채움) self._active_seqs: List[str] = [] # 최초 CNSRLST 처리 + CNSRREQ 시도 완료 신호 (start() 동기 대기용) self._ready = threading.Event() self._start_ok = False # ------------------------------------------------------------------ # Public API (오버라이드) — 부모 start() 는 REST 폴링이므로 사용 안 함 # ------------------------------------------------------------------ def start(self) -> bool: """토큰 발급 → 키움 WS 접속 → CNSRLST 로 seq 해결 → CNSRREQ 실시간 등록.""" if not self._configs: logger.info("키움 조건검색 configs 비어 있음 → 매니저 비활성") return False if not (self._app_key and self._app_secret): logger.warning("키움 앱키/시크릿 누락 → 조건검색 매니저 비활성") return False try: import websocket # noqa: F401 (websocket-client 존재 확인) except Exception as e: logger.warning("websocket-client 미설치 → 키움 조건검색 비활성: %s", e) return False self._token = _get_kiwoom_token_cached( self._app_key, self._app_secret, self._is_mock ) if not self._token: logger.warning("키움 토큰 발급 실패 → 조건검색 매니저 비활성") return False self._running = True self._ws_thread = threading.Thread( target=self._run_ws_forever, daemon=True, name="KwCondSearch" ) self._ws_thread.start() # 최초 CNSRLST 해결 + CNSRREQ 시도까지 잠깐 동기 대기 (KIS start() 가 # seq 해결을 동기로 하는 것과 UX 정합). 타임아웃돼도 백그라운드는 계속 시도. ready_timeout = float(get_env_int("KIWOOM_COND_START_TIMEOUT_SEC", 10)) self._ready.wait(timeout=ready_timeout) if self._start_ok: logger.info( "✅ 키움 조건검색 실시간 시작 (%d개, mock=%s, exit_grace=%ds, history=%s)", len(self._active_seqs), self._is_mock, int(self._exit_grace_sec), "ON" if (self.history_enabled and self.db is not None) else "OFF", ) else: logger.warning( "⚠️ 키움 조건검색 실시간 초기 등록 미완료(타임아웃) — 백그라운드 재시도 지속" ) # 스레드는 떠 있으므로 True 반환 (등록은 비동기로 계속 시도/재접속). return True def stop(self) -> None: self._running = False try: if self._ws is not None: self._ws.close() except Exception: pass # ------------------------------------------------------------------ # WS 라이프사이클 # ------------------------------------------------------------------ def _run_ws_forever(self) -> None: """접속 → (끊기면) 백오프 후 재접속 루프. 재접속 시 실시간 재등록.""" import websocket # websocket-client while self._running: try: self._ws = websocket.WebSocketApp( self._ws_url, on_open=self._on_open, on_message=self._on_message, on_error=self._on_error, on_close=self._on_close, ) # ping_interval=0 : 키움은 서버가 PING 을 보내면 echo 하는 방식. self._ws.run_forever(ping_interval=0) except Exception as e: logger.debug("키움 조건검색 WS 예외: %s", e) if not self._running: break # 재접속 대기 (중단 감지 해상도 0.5s) deadline = time.time() + self._reconnect_backoff while self._running and time.time() < deadline: time.sleep(0.5) def _on_open(self, ws) -> None: try: ws.send(json.dumps({"trnm": "LOGIN", "token": self._token})) logger.debug("키움 조건검색 LOGIN 발송") except Exception as e: logger.debug("키움 조건검색 LOGIN 발송 실패: %s", e) def _on_error(self, ws, err) -> None: logger.debug("키움 조건검색 WS 오류: %s", err) def _on_close(self, ws, code, msg) -> None: logger.debug("키움 조건검색 WS 종료 (code=%s)", code) def _on_message(self, ws, message) -> None: try: data = json.loads(message) except Exception: return trnm = data.get("trnm") # 키움 WS keep-alive: 받은 PING 을 그대로 돌려보냄 if trnm == "PING": try: ws.send(message) except Exception: pass return if trnm == "LOGIN": if str(data.get("return_code")) in ("0", "0.0"): logger.debug("키움 조건검색 LOGIN OK → CNSRLST") try: ws.send(json.dumps({"trnm": "CNSRLST"})) except Exception: pass else: logger.warning("키움 조건검색 LOGIN 실패: %s", data.get("return_msg")) return if trnm == "CNSRLST": self._handle_condition_list(ws, data.get("data") or []) return if trnm == "CNSRREQ": self._handle_cnsrreq(data) return if trnm == "REAL": self._handle_real(data.get("data") or []) return if trnm == "CNSRCLR": logger.debug("키움 조건검색 CNSRCLR 응답: rc=%s", data.get("return_code")) return # ------------------------------------------------------------------ # 조건식 목록 → seq 해결 → 실시간 등록 # ------------------------------------------------------------------ @staticmethod def _seq_name(item): """CNSRLST data 항목: [seq, name] 배열 또는 {seq,name} dict 모두 허용.""" if isinstance(item, (list, tuple)): seq = str(item[0]) if len(item) > 0 else "" name = str(item[1]) if len(item) > 1 else "" return seq.strip(), name.strip() if isinstance(item, dict): return str(item.get("seq") or "").strip(), str(item.get("name") or "").strip() return "", "" def _handle_condition_list(self, ws, rows: List) -> None: """CNSRLST 응답으로 name→seq 해결 후, 전략별 seq 확정 + CNSRREQ 발송.""" name_to_seq: Dict[str, str] = {} for it in rows: seq, name = self._seq_name(it) if name: name_to_seq[name.strip().lower()] = seq if rows: logger.info( "키움 저장 조건식 %d개: %s", len(rows), ", ".join( f"{self._seq_name(x)[0]}:{self._seq_name(x)[1] or '?'}" for x in rows ), ) # 전략별 seq 확정 (seq 우선, 없으면 name 으로 해결) sid_by_seq: Dict[str, List[str]] = {} for cfg in self._configs: sid = cfg["strategy_id"] seq = (cfg.get("seq") or "").strip() if not seq and cfg.get("name"): seq = name_to_seq.get(cfg["name"].strip().lower(), "") if not seq: logger.warning( "⚠️ 키움 조건식 seq 해결 실패 (strategy=%s name=%s) → 이 전략 폴백", sid, cfg.get("name"), ) continue cfg["seq"] = seq # 해결 결과 반영 sid_by_seq.setdefault(seq, []) if sid not in sid_by_seq[seq]: sid_by_seq[seq].append(sid) logger.info( "🔗 키움 조건식 매핑: strategy=%s seq=%s name=%s", sid, seq, cfg.get("name") or "?", ) with self._kw_lock: self._sid_by_seq = sid_by_seq self._active_seqs = list(sid_by_seq.keys()) # 실시간(search_type=1) 등록 — unique seq 별 1회. stex_tp=K (KRX) sent = 0 for seq in self._active_seqs: try: ws.send(json.dumps({ "trnm": "CNSRREQ", "seq": seq, "search_type": "1", "stex_tp": "K", })) sent += 1 except Exception as e: logger.debug("키움 CNSRREQ 발송 실패 (seq=%s): %s", seq, e) self._start_ok = sent > 0 self._ready.set() def _handle_cnsrreq(self, data: Dict) -> None: """CNSRREQ 초기 응답: 현재 매칭 종목 리스트로 seq universe 초기화.""" rc = str(data.get("return_code")) seq = str(data.get("seq") or "").strip() if rc not in ("0", "0.0"): logger.warning( "키움 CNSRREQ 실패 (seq=%s) rc=%s msg=%s", seq, rc, data.get("return_msg"), ) return # seq 가 응답에 없을 수 있음 → active_seqs 가 1개면 그걸로 간주 if not seq: with self._kw_lock: if len(self._active_seqs) == 1: seq = self._active_seqs[0] if not seq: return codes: "Dict[str, str]" = {} for it in (data.get("data") or []): code = self._extract_code(it) if code: codes[code] = code # 초기 응답엔 종목명 없음 → code 로 대체 with self._kw_lock: self._seq_codes[seq] = codes self._publish_seq(seq) logger.info( "✅ 키움 실시간 등록 (seq=%s) 초기 매칭 %d종목", seq, len(codes) ) def _handle_real(self, rows: List) -> None: """REAL push: 843=I(편입)/D(이탈), 9001=종목코드. seq 별 universe 갱신.""" touched: Set[str] = set() with self._kw_lock: for it in rows: vals = it.get("values") if isinstance(it, dict) else None if not isinstance(vals, dict): continue code = _normalize_code(vals.get("9001")) if not code: continue ins_del = str(vals.get("843") or "").strip().upper() # seq 는 item 또는 상위에서 옴. item 에 없으면 유일 seq 로 폴백. seq = str(it.get("item") or it.get("seq") or "").strip() if isinstance(it, dict) else "" if not seq: if len(self._active_seqs) == 1: seq = self._active_seqs[0] else: # seq 불명 + 다중 조건 → 어느 유니버스인지 특정 불가, skip continue bucket = self._seq_codes.setdefault(seq, {}) if ins_del == "D": bucket.pop(code, None) else: # "I" 또는 기타 → 편입으로 처리 (삽입순 유지) if code not in bucket: bucket[code] = code touched.add(seq) for seq in touched: self._publish_seq(seq) @staticmethod def _extract_code(item) -> str: """조건검색 결과 항목에서 종목코드 추출 (9001 우선, jmcode 폴백).""" if isinstance(item, dict): return _normalize_code(item.get("9001") or item.get("jmcode")) if isinstance(item, (list, tuple)) and item: return _normalize_code(item[0]) return "" # ------------------------------------------------------------------ # seq universe → 전략별 반영 (부모 _apply_result 재사용) # ------------------------------------------------------------------ def _publish_seq(self, seq: str) -> None: """seq 의 현재 종목집합을 그 seq 를 쓰는 모든 전략에 반영. 부모 ``_apply_result(strategy_id, rows)`` 를 그대로 호출 → enters/exits 계산·순서·EXIT grace·스냅샷 저장까지 KIS 와 동일하게 처리. """ with self._kw_lock: bucket = dict(self._seq_codes.get(seq, {})) sids = list(self._sid_by_seq.get(seq, [])) # rows: 삽입순(HTS 응답 순서) 유지 → _build_ordered_universe 가 그대로 사용 rows = [{"code": c, "name": n} for c, n in bucket.items()] from ..utils.universe_source import universe_source_active for sid in sids: if not universe_source_active(sid, "kiwoom_condition"): continue try: self._apply_result(sid, rows) except Exception as e: logger.debug("키움 조건검색 _apply_result 예외 (%s): %s", sid, e)