fc27e726f9
변경 사항 (Changes): 구문 오류(Syntax error) 및 토큰 낭비를 방지하기 위해 에이전트 쉘(Agent shell)과 파이썬 코드 스니펫에 다수의 신규 안전 규칙(Safety rules)을 추가함. 스키마 검증 및 적절한 SQL 포맷팅을 보장하기 위해 임시(Ad-hoc) 데이터베이스 쿼리 작성 가이드라인을 도입함. 코드 수정 후 UI 기능이 정상 작동하는지 확인하기 위해, 백테스트 웹 서비스 재시작 및 브라우저 검증에 대한 새로운 규칙을 구현함. 시스템 전반의 무결성(Integrity)을 유지하기 위해 실전 매매(Live trading), 웹 백테스팅, 파라미터 탐색(Parameter searches) 간의 일관성 검사(Consistency checks) 체계를 확립함. 기대 효과 (Impact): 이러한 개선 사항들은 트레이딩 시스템의 견고성(Robustness)과 신뢰성을 향상시키며, 에러 발생을 최소화하고 다양한 시스템 컴포넌트 간의 원활한 상호작용을 보장함.
899 lines
40 KiB
Python
899 lines
40 KiB
Python
"""
|
|
kis_trader/strategies/base.py — 전략 공통 기반 클래스
|
|
======================================================
|
|
각 전략은 **독립 쓰레드**로 돌아간다. 구조:
|
|
start() → 백그라운드 thread 기동 → self._run_loop() (while self._running)
|
|
stop() → self._running = False + join
|
|
|
|
루프 안에서 하는 일:
|
|
1. 장 세션 체크 (check_market_status — 매도·EOD 포함, 정규장 마감까지)
|
|
2. 보유 종목(active_trades where strategy=self.strategy_id) 로드 → 매도 시그널 체크
|
|
3. check_buy_allowed() 통과 시 후보 순회 → 매수 시그널 체크 ({SID}_TIME_END = 매수 종료만)
|
|
4. 시그널 발생 시 OrderManager.place() 로 집중 (실제 주문은 OrderManager 내부에서 종목Lock+ODNO+실잔고검증)
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import random
|
|
import threading
|
|
import time
|
|
from abc import ABC, abstractmethod
|
|
from datetime import datetime as dt
|
|
from typing import Dict, List, Optional, Any, Tuple
|
|
|
|
from ..database.db_manager import TradeDBExt
|
|
from ..execution.kis_client import KISClient
|
|
from ..execution.order_manager import OrderManager
|
|
from ..network.ws_manager import WSManager
|
|
from ..utils.env import get_env_bool, get_env_from_db, get_env_int
|
|
from ..utils.logger import get_logger
|
|
|
|
|
|
# 비본주 판별 — kis_trader.utils.non_stock 공용 (KISClient 랭킹 필터와 동일)
|
|
from ..utils.non_stock import is_non_stock as _is_non_stock
|
|
from ..utils.non_stock import is_unmanageable_holding as _is_unmanageable_holding
|
|
|
|
|
|
from ..engine.strategy_eod import (
|
|
is_backtest_eod_bar,
|
|
is_live_eod_now,
|
|
is_strategy_eod_bar,
|
|
parse_eod_hm,
|
|
resolve_strategy_eod_params,
|
|
)
|
|
|
|
|
|
class BaseStrategy(ABC, threading.Thread):
|
|
"""
|
|
모든 전략의 공통 부모 클래스. threading.Thread 상속 → start() 시 독립 쓰레드.
|
|
|
|
서브클래스 구현 필수:
|
|
- strategy_id (class attribute 또는 property, 고유 문자열)
|
|
- check_buy(code, name) -> Optional[dict] (매수 시그널 dict)
|
|
- check_sell_signals() -> List[dict] (매도 시그널 리스트)
|
|
- _candidate_filter(c) -> bool (본인이 관심 있는 후보인지)
|
|
"""
|
|
|
|
strategy_id: str = "BASE"
|
|
loop_min_sleep: float = 0.1
|
|
loop_max_sleep: float = 0.1
|
|
|
|
# 전략별 유니버스 소스 기본값 (env 미설정 시) — HTS 조건검색 단일 정책
|
|
DEFAULT_UNIVERSE_SOURCES: Dict[str, str] = {
|
|
"SCALP": "kiwoom_condition",
|
|
"SHORT": "kiwoom_condition", # 키움 tail(A 시가대비+F 저가회복) WS 실시간
|
|
"BREAKOUT": "kiwoom_condition",
|
|
"MOMENTUM": "kiwoom_condition", # 키움 WS 실시간 조건 (KIS REST 폴링 대비 유니버스 품질↑)
|
|
"UPDOW": "condition",
|
|
}
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
db: TradeDBExt,
|
|
client: KISClient,
|
|
ws: WSManager,
|
|
order_mgr: OrderManager,
|
|
condition_mgr=None,
|
|
ranking_mgr=None,
|
|
kiwoom_condition_mgr=None,
|
|
market_guard=None,
|
|
):
|
|
super().__init__(daemon=True, name=f"Strat-{self.strategy_id}")
|
|
self.db = db
|
|
self.client = client
|
|
self.ws = ws
|
|
self.order_mgr = order_mgr
|
|
self.condition_mgr = condition_mgr # ConditionSearchManager (KIS REST, 선택)
|
|
self.ranking_mgr = ranking_mgr # VolumeRankManager (선택)
|
|
# KiwoomConditionSearchManager (키움 WS 실시간 조건검색, 선택). KIS 와 별개 소스.
|
|
self.kiwoom_condition_mgr = kiwoom_condition_mgr
|
|
self.market_guard = market_guard # MarketGuard (선택, None 이면 가드 없음)
|
|
self.logger = get_logger(f"kis_trader.strategy.{self.strategy_id}")
|
|
# MarketGuard PANIC 차단 로그 스팸 방지용 (분당 1회)
|
|
self._panic_log_ts: float = 0.0
|
|
|
|
# 유니버스 소스: "ranking" | "condition"(KIS) | "kiwoom_condition"(키움 WS)
|
|
# env: {STRATEGY_ID}_UNIVERSE_SOURCE — 런타임에 스위치 가능.
|
|
key = f"{self.strategy_id}_UNIVERSE_SOURCE"
|
|
default = self.DEFAULT_UNIVERSE_SOURCES.get(self.strategy_id, "ranking")
|
|
self.universe_source = (
|
|
(get_env_from_db(key, default) or default).strip().lower()
|
|
)
|
|
if self.universe_source not in ("ranking", "condition", "kiwoom_condition"):
|
|
self.logger.warning(
|
|
"알 수 없는 UNIVERSE_SOURCE=%s → 기본값 %s 사용",
|
|
self.universe_source, default,
|
|
)
|
|
self.universe_source = default
|
|
|
|
self._running = False
|
|
# 보유 종목 — 매 루프 DB active_trades 와 동기화 (진실의 원천 = DB)
|
|
self.holdings: Dict[str, dict] = {}
|
|
# 장중 고점·세션저점·전략별 부가키 — DB sync 로 덮어쓰지 않음 (래칫/어깨 퇴행 방지)
|
|
self._runtime: Dict[str, dict] = {}
|
|
# 최근 매도 쿨다운 (종목별 마지막 매도 타임스탬프)
|
|
self.recently_sold: Dict[str, float] = {}
|
|
# 당일 매매불가 종목 (다음 후보로 넘어감)
|
|
self.untradable_skip: set = set()
|
|
|
|
# 일일 익절 목표 가드 (Orchestrator 주입, 없으면 OFF)
|
|
self.daily_profit_halt: Any = None
|
|
|
|
self._sync_holdings_from_db(log_restore=True)
|
|
|
|
# ------------------------------------------------------------------
|
|
# 외부 인터페이스
|
|
# ------------------------------------------------------------------
|
|
def stop_loop(self) -> None:
|
|
"""쓰레드 정지 요청 (daemon 이지만 정상 종료 시 호출)."""
|
|
self._running = False
|
|
|
|
# ------------------------------------------------------------------
|
|
# 스캔 루프 sleep (env 핫리로드 — 재시작 없이 반영)
|
|
# ------------------------------------------------------------------
|
|
# REST 유량과는 별개의 "스캔 회전율" 조절. WS 따라가기 속도를 결정한다.
|
|
# 전략별 클래스 기본값(loop_min_sleep 등)을 폴백으로 두고, env 가 있으면 우선.
|
|
def _scan_sleep(self, kind: str) -> float:
|
|
"""kind: 'loop'(루프끝) | 'reject'(탈락) | 'buy_ok'(매수성공) | 'buy_fail'(주문실패)."""
|
|
from ..utils.env import get_env_float
|
|
if kind == "loop":
|
|
lo = get_env_float("STRATEGY_LOOP_SLEEP_MIN", self.loop_min_sleep)
|
|
hi = get_env_float("STRATEGY_LOOP_SLEEP_MAX", self.loop_max_sleep)
|
|
elif kind == "reject":
|
|
lo = get_env_float("SCAN_REJECT_SLEEP_MIN", 0.2)
|
|
hi = get_env_float("SCAN_REJECT_SLEEP_MAX", 0.5)
|
|
elif kind == "buy_ok":
|
|
lo = get_env_float("SCAN_BUY_OK_SLEEP_MIN", 1.0)
|
|
hi = get_env_float("SCAN_BUY_OK_SLEEP_MAX", 2.0)
|
|
else: # buy_fail
|
|
lo = get_env_float("SCAN_BUY_FAIL_SLEEP_MIN", 0.3)
|
|
hi = get_env_float("SCAN_BUY_FAIL_SLEEP_MAX", 0.8)
|
|
lo = max(0.0, lo)
|
|
hi = max(lo, hi)
|
|
return random.uniform(lo, hi)
|
|
|
|
# ------------------------------------------------------------------
|
|
# 하락매수(dip) 종목 제외 — 대형주에 떨어지는 칼날 잡기 방지
|
|
# ------------------------------------------------------------------
|
|
def is_dip_buy_excluded(self, code: str) -> bool:
|
|
"""
|
|
하락매수 계열(UPDOW·SHORT) 이 매수하면 안 되는 종목인지 판정.
|
|
- ``DIP_BUY_EXCLUDE_CODES`` : 콤마구분 종목코드 화이트리스트 제외 (기본 빈 값 → 무효)
|
|
예) 삼성전자·하이닉스 등 대형 주도주는 하락매수가 아니라 추세추종 대상.
|
|
기본값이 비어 있으면 기존 동작과 100% 동일 (필터 OFF).
|
|
"""
|
|
raw = str(get_env_from_db("DIP_BUY_EXCLUDE_CODES", "") or "").strip()
|
|
if not raw:
|
|
return False
|
|
code = str(code or "").strip()
|
|
excluded = {c.strip() for c in raw.split(",") if c.strip()}
|
|
return code in excluded
|
|
|
|
def run(self) -> None:
|
|
"""threading.Thread.run() 오버라이드 — 전략 메인 루프."""
|
|
self._running = True
|
|
self.logger.info("🚀 전략 쓰레드 시작 [%s]", self.strategy_id)
|
|
try:
|
|
self._run_loop()
|
|
except Exception as e:
|
|
self.logger.exception("전략 루프 예외: %s", e)
|
|
finally:
|
|
self.logger.info("⏹ 전략 쓰레드 종료 [%s]", self.strategy_id)
|
|
|
|
# ------------------------------------------------------------------
|
|
# 메인 루프
|
|
# ------------------------------------------------------------------
|
|
def _run_loop(self) -> None:
|
|
last_date = dt.now().strftime("%Y-%m-%d")
|
|
last_closed_log = 0.0
|
|
while self._running:
|
|
try:
|
|
now = dt.now()
|
|
today = now.strftime("%Y-%m-%d")
|
|
|
|
# 날짜 변경 처리 (당일 매매불가 리셋 등)
|
|
if today != last_date:
|
|
last_date = today
|
|
self.untradable_skip.clear()
|
|
self.on_new_day()
|
|
|
|
# 장 시간 체크 (서브클래스 오버라이드 가능)
|
|
if not self.check_market_status():
|
|
# 장외 heartbeat: 봇 기동 직후 1회 + 이후 1시간마다 1회.
|
|
# (봇 살아있음·보유·유니버스 상태만 확인용 — 잦은 로그 노이즈 제거)
|
|
interval = get_env_int("OFF_HOURS_LOG_INTERVAL_SEC", 3600)
|
|
if time.time() - last_closed_log >= interval:
|
|
try:
|
|
universe = self._load_candidates()
|
|
except Exception:
|
|
universe = []
|
|
self.logger.info(
|
|
"🌙 [장외] holdings=%d universe=%d recently_sold=%d",
|
|
len(self.holdings), len(universe), len(self.recently_sold),
|
|
)
|
|
last_closed_log = time.time()
|
|
time.sleep(30)
|
|
continue
|
|
|
|
# 설정 리로드 (DB env_config 실시간 반영)
|
|
self.reload_config()
|
|
|
|
# 보유 목록 = DB 진실 + _runtime 오버레이 (poll 체결·재시작 정합)
|
|
self._sync_holdings_from_db()
|
|
|
|
# ── [1] 매도 먼저 ────────────────────────────────
|
|
sell_signals = self.check_sell_signals()
|
|
if sell_signals and get_env_bool("REAL_BALANCE_VERIFY_BEFORE_SELL", True):
|
|
self.order_mgr.prefetch_broker_holdings()
|
|
for sig in sell_signals:
|
|
self._submit_sell(sig)
|
|
|
|
# ── [2] 후보 구독 동기화 (공유 WS) ────────────────
|
|
candidates = self._load_candidates()
|
|
cand_codes = [c.get("code") for c in candidates if c.get("code")]
|
|
hold_codes = list(self.holdings.keys())
|
|
# KIS 최소 구독 모드: 후보=키움 WS, KIS=영구+보유 (WSManager.sync_targets_split)
|
|
self.ws.sync_targets_split(self.strategy_id, cand_codes, hold_codes)
|
|
|
|
# ── [2b] 미체결 지정가 만료 취소 ───────────────────
|
|
self.manage_pending_orders()
|
|
|
|
# ── [3] 매수 체크 (매수 종료 TIME_END 와 매도 세션 분리) ──
|
|
max_stocks = self._max_stocks()
|
|
active_cnt = len(self.holdings)
|
|
if candidates and active_cnt < max_stocks and self.check_buy_allowed():
|
|
self._scan_and_buy(candidates, max_stocks, active_cnt)
|
|
|
|
# 고점·세션저점 등 런타임 오버레이 저장 (다음 루프 DB sync 시 max merge)
|
|
self._capture_runtime_overlay()
|
|
|
|
time.sleep(self._scan_sleep("loop"))
|
|
|
|
except KeyboardInterrupt:
|
|
self._running = False
|
|
break
|
|
except Exception as e:
|
|
self.logger.error("루프 예외: %s", e)
|
|
time.sleep(5)
|
|
|
|
def manage_pending_orders(self) -> None:
|
|
"""미체결 ATR 지정가 만료 시 취소 — 서브클래스에서 구현."""
|
|
return None
|
|
|
|
def on_limit_buy_submitted(self, signal: Dict, result) -> None:
|
|
"""지정가 접수 성공 — 체결 전까지 holdings 미반영 (서브클래스)."""
|
|
return None
|
|
|
|
def _resolve_buy_qty_live(
|
|
self,
|
|
curr_price: float,
|
|
*,
|
|
invest_cap: Optional[float] = None,
|
|
hard_cap: int = 0,
|
|
max_stocks: Optional[int] = None,
|
|
) -> Tuple[int, Optional[str]]:
|
|
"""포트폴리오 정합 ON → ``resolve_live_buy_qty``, OFF → ``invest_qty_for_price``."""
|
|
from ..utils.position_sizing import invest_qty_for_price
|
|
|
|
cap = float(
|
|
invest_cap if invest_cap is not None
|
|
else getattr(self, "slot_money", 0) or get_env_int("SLOT_MONEY_DEFAULT", 3_000_000)
|
|
)
|
|
if hard_cap > 0 and cap > hard_cap:
|
|
cap = float(hard_cap)
|
|
if self._live_portfolio_budget_enabled():
|
|
qty, _, rej = self._resolve_live_buy_qty(
|
|
curr_price, invest_cap=cap, max_stocks=max_stocks,
|
|
)
|
|
return qty, rej
|
|
qty = invest_qty_for_price(curr_price, cap)
|
|
if qty < 1:
|
|
return 0, "수량0"
|
|
return qty, None
|
|
|
|
def _live_portfolio_budget_enabled(self) -> bool:
|
|
from ..utils.live_portfolio_common import live_portfolio_budget_align_enabled
|
|
return live_portfolio_budget_align_enabled(self.strategy_id)
|
|
|
|
def _portfolio_exposure_krw(self) -> float:
|
|
from ..backtest.backtest_portfolio_common import portfolio_exposure_krw
|
|
return portfolio_exposure_krw(self.holdings)
|
|
|
|
def _live_total_budget_krw(self, max_stocks: Optional[int] = None) -> float:
|
|
from ..utils.live_portfolio_common import resolve_live_total_budget_krw
|
|
ms = max_stocks if max_stocks is not None else self._max_stocks()
|
|
slot = float(getattr(self, "slot_money", 0) or get_env_int("SLOT_MONEY_DEFAULT", 3_000_000))
|
|
return resolve_live_total_budget_krw(self.strategy_id, ms, slot)
|
|
|
|
def _live_portfolio_budget_full(self, max_stocks: Optional[int] = None) -> bool:
|
|
from ..utils.live_portfolio_common import live_portfolio_budget_full
|
|
if not self._live_portfolio_budget_enabled():
|
|
return False
|
|
ms = max_stocks if max_stocks is not None else self._max_stocks()
|
|
slot = float(getattr(self, "slot_money", 0) or get_env_int("SLOT_MONEY_DEFAULT", 3_000_000))
|
|
return live_portfolio_budget_full(self.holdings, self.strategy_id, slot, ms)
|
|
|
|
def _live_portfolio_entry_guard(self, code: str, max_stocks: Optional[int] = None) -> Optional[str]:
|
|
from ..utils.live_portfolio_common import live_portfolio_entry_reject
|
|
if not self._live_portfolio_budget_enabled():
|
|
return None
|
|
ms = max_stocks if max_stocks is not None else self._max_stocks()
|
|
slot = float(getattr(self, "slot_money", 0) or get_env_int("SLOT_MONEY_DEFAULT", 3_000_000))
|
|
return live_portfolio_entry_reject(
|
|
self.db, self.holdings, self.strategy_id, code, slot, ms,
|
|
)
|
|
|
|
def _resolve_live_buy_qty(
|
|
self,
|
|
curr_price: float,
|
|
*,
|
|
invest_cap: Optional[float] = None,
|
|
max_stocks: Optional[int] = None,
|
|
) -> Tuple[int, float, Optional[str]]:
|
|
from ..utils.live_portfolio_common import resolve_live_buy_qty
|
|
ms = max_stocks if max_stocks is not None else self._max_stocks()
|
|
slot = float(getattr(self, "slot_money", 0) or get_env_int("SLOT_MONEY_DEFAULT", 3_000_000))
|
|
return resolve_live_buy_qty(
|
|
curr_price,
|
|
self.holdings,
|
|
self.strategy_id,
|
|
slot,
|
|
max_stocks=ms,
|
|
invest_cap=invest_cap,
|
|
)
|
|
|
|
def _scan_and_buy(self, candidates: List[Dict], max_stocks: int, active_cnt: int) -> None:
|
|
if self._live_portfolio_budget_full(max_stocks):
|
|
now_ts = time.time()
|
|
last = getattr(self, "_live_budget_full_log_ts", 0.0)
|
|
if now_ts - last >= 300:
|
|
self._live_budget_full_log_ts = now_ts
|
|
self.logger.info(
|
|
"🔍 [탈락-총한도] %s exposure=%.0f >= budget=%.0f (보유 %d/%d)",
|
|
self.strategy_id,
|
|
self._portfolio_exposure_krw(),
|
|
self._live_total_budget_krw(max_stocks),
|
|
active_cnt, max_stocks,
|
|
)
|
|
return
|
|
|
|
# ── 시장 급락 서킷브레이커 가드 ────────────────────────────────
|
|
# MarketGuard 가 PANIC 모드면 신규 매수 전면 차단.
|
|
# 매도는 평소처럼 동작 (포지션 정리·손실 확대 방지).
|
|
if self.market_guard is not None and self.market_guard.is_panic():
|
|
now_ts = time.time()
|
|
if now_ts - self._panic_log_ts >= 60: # 분당 1회만 로그
|
|
self._panic_log_ts = now_ts
|
|
self.logger.warning(
|
|
"⛔ [매수차단] MarketGuard PANIC: %s (보유 %d, 후보 %d)",
|
|
self.market_guard.panic_reason(), active_cnt, len(candidates),
|
|
)
|
|
return
|
|
|
|
guard = getattr(self, "daily_profit_halt", None)
|
|
if guard is not None:
|
|
try:
|
|
allowed, halt_msg = guard.buy_allowed(self.strategy_id)
|
|
if not allowed:
|
|
now_ts = time.time()
|
|
log_key = f"profit_halt_{self.strategy_id}"
|
|
if now_ts - getattr(self, "_profit_halt_log_ts", 0.0) >= 60.0:
|
|
self._profit_halt_log_ts = now_ts
|
|
self.logger.info(
|
|
"⛔ [매수차단] %s (보유 %d, 후보 %d)",
|
|
halt_msg or "일일익절", active_cnt, len(candidates),
|
|
)
|
|
return
|
|
except Exception as ex:
|
|
self.logger.debug("일일익절 가드 예외(매수 계속): %s", ex)
|
|
|
|
self.logger.info(
|
|
"🔍 [매수체크] 후보 %d (보유 %d/%d)",
|
|
len(candidates), active_cnt, max_stocks,
|
|
)
|
|
for c in candidates:
|
|
if not self._running:
|
|
return
|
|
code = c.get("code") or c.get("stk_cd", "")
|
|
name = c.get("name") or c.get("stk_nm", code)
|
|
if name == code or not str(name or "").strip():
|
|
try:
|
|
from ..utils.stock_name import resolve_stock_display_name
|
|
|
|
name = resolve_stock_display_name(self.db, code, name)
|
|
except Exception:
|
|
name = code
|
|
if not code or code in self.holdings:
|
|
continue
|
|
if code in self.untradable_skip:
|
|
continue
|
|
if not self._candidate_filter(c):
|
|
continue
|
|
guard = self._live_portfolio_entry_guard(code, max_stocks)
|
|
if guard:
|
|
self.logger.info("🔍 [%s] %s(%s)", guard, name, code)
|
|
continue
|
|
# 재진입 쿨다운
|
|
cooldown_sec = self._reentry_cooldown_sec()
|
|
elapsed = time.time() - self.recently_sold.get(code, 0)
|
|
if elapsed < cooldown_sec:
|
|
continue
|
|
|
|
signal = self.check_buy(code, name)
|
|
if not signal:
|
|
time.sleep(self._scan_sleep("reject"))
|
|
continue
|
|
|
|
result = self._submit_buy(signal)
|
|
if result and result.success:
|
|
time.sleep(self._scan_sleep("buy_ok"))
|
|
return # 1루프당 1매수 (포지션 과집중 방지)
|
|
time.sleep(self._scan_sleep("buy_fail"))
|
|
|
|
# ------------------------------------------------------------------
|
|
# OrderManager 호출 래퍼
|
|
# ------------------------------------------------------------------
|
|
def _submit_buy(self, signal: Dict):
|
|
from ..execution.order_manager import OrderRequest
|
|
|
|
req = OrderRequest(
|
|
strategy_id=self.strategy_id,
|
|
code=signal["code"],
|
|
name=signal.get("name", signal["code"]),
|
|
side="BUY",
|
|
qty=int(signal.get("qty", 0)),
|
|
price_ref=float(signal.get("price", 0)),
|
|
stop_price=float(signal.get("stop_price", 0)),
|
|
target_price=float(signal.get("target_price", 0)),
|
|
atr_entry=float(signal.get("atr_entry", 0)),
|
|
size_class=signal.get("size_class"),
|
|
entry_features=signal.get("entry_features"),
|
|
use_limit_buy=bool(signal.get("use_limit_buy")),
|
|
)
|
|
result = self.order_mgr.place(req)
|
|
if result.success and not signal.get("use_limit_buy"):
|
|
# 로컬 holdings 갱신 (DB 는 OrderManager 가 이미 upsert 함)
|
|
fp = float(result.filled_avg_price)
|
|
self.holdings[req.code] = {
|
|
"buy_price": fp,
|
|
"qty": result.filled_qty,
|
|
"stop_price": req.stop_price,
|
|
"target_price": req.target_price,
|
|
"max_price": float(signal.get("max_price", fp) or fp),
|
|
"session_low": float(signal.get("session_low", fp) or fp),
|
|
"atr_entry": req.atr_entry,
|
|
"buy_time": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
|
|
"name": req.name,
|
|
"size_class": req.size_class or "",
|
|
}
|
|
self._capture_runtime_overlay()
|
|
elif result.success and signal.get("use_limit_buy"):
|
|
self.on_limit_buy_submitted(signal, result)
|
|
else:
|
|
# 매매불가 종목은 당일 제외
|
|
if result.reason and "order_reject" in result.reason:
|
|
if any(k in (result.reason or "") for k in ("매매불가", "40070000")):
|
|
self.untradable_skip.add(req.code)
|
|
return result
|
|
|
|
def _submit_sell(self, signal: Dict):
|
|
from ..execution.order_manager import OrderRequest
|
|
|
|
req = OrderRequest(
|
|
strategy_id=self.strategy_id,
|
|
code=signal["code"],
|
|
name=signal.get("name", signal["code"]),
|
|
side="SELL",
|
|
qty=int(signal.get("qty", 0)),
|
|
price_ref=float(signal.get("current_price", signal.get("price", 0))),
|
|
reason=signal.get("reason", ""),
|
|
buy_price=float(signal.get("buy_price", 0)),
|
|
profit_pct=float(signal.get("profit_pct", 0)),
|
|
)
|
|
result = self.order_mgr.place(req)
|
|
if result.success:
|
|
self.recently_sold[req.code] = time.time()
|
|
self._drop_local_position(req.code)
|
|
elif result.reason == "broker_no_position":
|
|
if req.code in self.holdings:
|
|
self.logger.info(
|
|
"🧹 [유령정리] %s %s — 로컬 holdings 제거 (%s)",
|
|
req.name, req.code, result.reason,
|
|
)
|
|
self._drop_local_position(req.code)
|
|
return result
|
|
|
|
# ------------------------------------------------------------------
|
|
# 서브클래스 공통 헬퍼
|
|
# ------------------------------------------------------------------
|
|
def _session_time_bounds(self) -> Tuple[int, int]:
|
|
"""실매 **매도·EOD** 세션 (HHMM). ``{SID}_TIME_END``(매수 종료)와 별도.
|
|
|
|
종료 우선순위:
|
|
- SHORT: ``TAIL_TIME_START`` / ``TAIL_TIME_END``
|
|
- 그 외: ``{SID}_SELL_TIME_END`` → ``MARKET_SESSION_END_HM`` → 기본 **1530**
|
|
"""
|
|
sid = self.strategy_id.upper()
|
|
if sid == "SHORT":
|
|
from ..engine.tail_env_keys import tail_market_time_hm
|
|
return tail_market_time_hm()
|
|
start = get_env_int(f"{sid}_TIME_START", 0) or get_env_int("TIME_START", 0) or 900
|
|
sell_end = (
|
|
get_env_int(f"{sid}_SELL_TIME_END", 0)
|
|
or get_env_int("MARKET_SESSION_END_HM", 0)
|
|
or 1530
|
|
)
|
|
return start, sell_end
|
|
|
|
def _buy_time_bounds(self) -> Tuple[int, int]:
|
|
"""신규 **매수** 허용 구간 (HHMM). ``{SID}_TIME_END`` / ``TIME_END`` = 매수 종료만."""
|
|
sid = self.strategy_id.upper()
|
|
if sid == "SHORT":
|
|
return self._session_time_bounds()
|
|
start = get_env_int(f"{sid}_TIME_START", 0) or get_env_int("TIME_START", 0) or 900
|
|
buy_end = get_env_int(f"{sid}_TIME_END", 0) or get_env_int("TIME_END", 0)
|
|
if buy_end <= 0:
|
|
_, sell_end = self._session_time_bounds()
|
|
buy_end = sell_end
|
|
return start, buy_end
|
|
|
|
def check_market_status(self) -> bool:
|
|
"""매도·EOD 포함 실매 세션이 열려 있는지 (정규장 마감까지).
|
|
|
|
``{STRATEGY_ID}_TIME_END`` 는 **매수 종료** 전용 — 여기서는 사용하지 않는다.
|
|
``FORCE_MARKET_OPEN=true`` 면 모든 시간 통과 (백테스트/디버그용).
|
|
"""
|
|
if get_env_bool("FORCE_MARKET_OPEN", False):
|
|
return True
|
|
now = dt.now()
|
|
if now.weekday() >= 5: # 토/일
|
|
return False
|
|
hhmm_now = now.hour * 100 + now.minute
|
|
start, end = self._session_time_bounds()
|
|
return start <= hhmm_now <= end
|
|
|
|
def check_buy_allowed(self) -> bool:
|
|
"""신규 매수 허용 시간 — ``{SID}_TIME_END`` / ``TIME_END`` 기준 (매수 종료)."""
|
|
if get_env_bool("FORCE_MARKET_OPEN", False):
|
|
return True
|
|
if not self.check_market_status():
|
|
return False
|
|
now = dt.now()
|
|
hhmm_now = now.hour * 100 + now.minute
|
|
start, buy_end = self._buy_time_bounds()
|
|
return start <= hhmm_now <= buy_end
|
|
|
|
def _max_stocks(self) -> int:
|
|
"""전략별 동시 보유 한도.
|
|
|
|
우선순위:
|
|
1. ``{STRATEGY_ID}_MAX_STOCKS`` (예: ``SCALP_MAX_STOCKS``)
|
|
2. ``MAX_STOCKS`` (글로벌, 미설정/구버전 호환)
|
|
3. 3 (최후 fallback)
|
|
"""
|
|
sid = self.strategy_id.upper()
|
|
if sid == "SHORT":
|
|
per_strategy = (
|
|
get_env_int("TAIL_MAX_STOCKS", 0)
|
|
or get_env_int("SHORT_MAX_STOCKS", 0)
|
|
)
|
|
else:
|
|
per_strategy = get_env_int(f"{sid}_MAX_STOCKS", 0)
|
|
if per_strategy > 0:
|
|
return per_strategy
|
|
return get_env_int("MAX_STOCKS", 3)
|
|
|
|
def _reentry_cooldown_sec(self) -> int:
|
|
sid = self.strategy_id.upper()
|
|
cd = get_env_int(f"{sid}_COOLDOWN_SEC", 0)
|
|
if cd > 0:
|
|
return cd
|
|
if sid == "SHORT":
|
|
tail_cd = get_env_int("TAIL_COOLDOWN_SEC", 0)
|
|
if tail_cd > 0:
|
|
return tail_cd
|
|
return get_env_int("REENTRY_COOLDOWN_SEC", 300)
|
|
|
|
# DB sync 시 holdings 에 합치지 않고 _runtime 만 유지하는 장중 오버레이 키
|
|
_RUNTIME_OVERLAY_KEYS: Tuple[str, ...] = (
|
|
"max_price", "session_low",
|
|
"updow_entry_bar_key", "box_low", "box_high",
|
|
)
|
|
|
|
def _load_holdings_from_db(self, *, log_restore: bool = False) -> None:
|
|
"""DB → holdings 동기화 (지정가 체결 등 이벤트 시 호출)."""
|
|
self._sync_holdings_from_db(log_restore=log_restore)
|
|
|
|
def _drop_local_position(self, code: str) -> None:
|
|
"""매도·유령정리 후 메모리 보유·런타임 오버레이 제거."""
|
|
self.holdings.pop(code, None)
|
|
self._runtime.pop(code, None)
|
|
|
|
def _merge_runtime_overlay(
|
|
self, code: str, avg_bp: float, db_max: float, db_sess_low: float,
|
|
) -> Tuple[float, float]:
|
|
"""DB 행 + _runtime → max_price/session_low (퇴행 방지)."""
|
|
rt = self._runtime.get(code) or {}
|
|
max_p = max(
|
|
avg_bp,
|
|
float(db_max or 0),
|
|
float(rt.get("max_price") or 0),
|
|
)
|
|
sess_candidates = [
|
|
v for v in (
|
|
avg_bp,
|
|
float(db_sess_low or 0),
|
|
float(rt.get("session_low") or 0),
|
|
) if v > 0
|
|
]
|
|
sess_low = min(sess_candidates) if sess_candidates else avg_bp
|
|
return max_p, sess_low
|
|
|
|
def _apply_runtime_extra_fields(self, code: str, holding: Dict[str, Any]) -> None:
|
|
"""UPDOW 등 전략 부가 필드를 _runtime → holdings 로 복원."""
|
|
rt = self._runtime.get(code) or {}
|
|
for k in self._RUNTIME_OVERLAY_KEYS:
|
|
if k in ("max_price", "session_low"):
|
|
continue
|
|
if k in rt and rt[k] is not None:
|
|
holding[k] = rt[k]
|
|
|
|
def _capture_runtime_overlay(self) -> None:
|
|
"""매도 판단 루프가 갱신한 고점·저점을 _runtime 에 저장."""
|
|
for code, h in self.holdings.items():
|
|
rt = self._runtime.setdefault(code, {})
|
|
mp = float(h.get("max_price") or 0)
|
|
if mp > float(rt.get("max_price") or 0):
|
|
rt["max_price"] = mp
|
|
sl = float(h.get("session_low") or 0)
|
|
if sl > 0:
|
|
prev = float(rt.get("session_low") or 0)
|
|
rt["session_low"] = sl if prev <= 0 else min(prev, sl)
|
|
for k in self._RUNTIME_OVERLAY_KEYS:
|
|
if k in ("max_price", "session_low"):
|
|
continue
|
|
if k in h and h[k] is not None:
|
|
rt[k] = h[k]
|
|
|
|
def _after_holdings_sync(self) -> None:
|
|
"""서브클래스 훅 — DB sync 직후 (UPDOW entry_bar_key 등)."""
|
|
return None
|
|
|
|
def _sync_holdings_from_db(self, *, log_restore: bool = False) -> None:
|
|
"""DB active_trades → holdings (진실의 원천). 장중 고점은 _runtime 과 merge.
|
|
|
|
- DB에 없는 종목은 holdings·_runtime 에서 제거 (양방향 정합)
|
|
- poll_pending 매수 체결·재시작 후에도 다음 루프에 자동 반영
|
|
- ETF/ETN/스팩 등 시세 불가 종목만 보유 루프에서 제외.
|
|
우선주는 매수 차단 대상이지만, 이미 산 경우 매도 가능하도록 유지.
|
|
"""
|
|
try:
|
|
prefix = self.strategy_id.split("_")[0] if "_" in self.strategy_id else self.strategy_id
|
|
rows = self.db.get_active_trades(strategy_prefix=prefix)
|
|
skipped_non_stock: list[str] = []
|
|
new_holdings: Dict[str, dict] = {}
|
|
for code, t in rows.items():
|
|
if t.get("strategy") and t["strategy"] != self.strategy_id:
|
|
continue
|
|
if get_env_bool("EXCLUDE_NON_STOCK", True):
|
|
name = (t.get("name") or "").strip()
|
|
# 우선주(is_non_stock)는 매도 정리 위해 holdings 유지.
|
|
# ETF/ETN/스팩만 자동 제외.
|
|
if _is_unmanageable_holding(name, code):
|
|
skipped_non_stock.append(f"{code}({name})")
|
|
continue
|
|
avg_bp = float(t.get("avg_buy_price", 0) or t.get("buy_price", 0) or 0)
|
|
qty = int(t.get("current_qty", 0) or t.get("qty", 0) or 0)
|
|
if qty <= 0 or avg_bp <= 0:
|
|
continue
|
|
db_max = float(t.get("max_price") or 0)
|
|
db_sess = float(t.get("session_low") or 0)
|
|
max_p, sess_low = self._merge_runtime_overlay(code, avg_bp, db_max, db_sess)
|
|
holding = {
|
|
"buy_price": avg_bp,
|
|
"qty": qty,
|
|
"stop_price": t.get("stop_price", 0),
|
|
"target_price": t.get("target_price", 0),
|
|
"max_price": max_p,
|
|
"session_low": sess_low,
|
|
"atr_entry": t.get("atr_at_entry", t.get("atr_entry", 0)),
|
|
"buy_time": t.get("buy_date", dt.now().strftime("%Y-%m-%d %H:%M:%S")),
|
|
"name": t.get("name", code),
|
|
"size_class": t.get("size_class", ""),
|
|
}
|
|
self._apply_runtime_extra_fields(code, holding)
|
|
new_holdings[code] = holding
|
|
|
|
db_codes = set(new_holdings.keys())
|
|
for code in list(self._runtime.keys()):
|
|
if code not in db_codes:
|
|
del self._runtime[code]
|
|
|
|
prev_codes = set(self.holdings.keys())
|
|
self.holdings.clear()
|
|
self.holdings.update(new_holdings)
|
|
self._after_holdings_sync()
|
|
|
|
if log_restore and self.holdings:
|
|
self.logger.info(
|
|
"📂 [DB 복원] 보유 %d종목 (%s)",
|
|
len(self.holdings), self.strategy_id,
|
|
)
|
|
elif not log_restore:
|
|
added = db_codes - prev_codes
|
|
if added:
|
|
self.logger.info(
|
|
"📂 [DB동기화] +%d종목 (%s) poll/체결 반영: %s",
|
|
len(added), self.strategy_id, ",".join(sorted(added)[:5]),
|
|
)
|
|
removed = prev_codes - db_codes
|
|
if removed:
|
|
self.logger.debug(
|
|
"📂 [DB동기화] -%d종목 (%s) 청산 반영: %s",
|
|
len(removed), self.strategy_id, ",".join(sorted(removed)[:5]),
|
|
)
|
|
|
|
if skipped_non_stock:
|
|
self.logger.warning(
|
|
"⚠️ ETF/ETN/스팩 보유 자동 제외(시세불가 — 한투 HTS에서 직접 처분 권장): %s",
|
|
", ".join(skipped_non_stock),
|
|
)
|
|
except Exception as e:
|
|
self.logger.warning("DB holdings 동기화 실패: %s", e)
|
|
|
|
def _load_candidates(self) -> List[Dict]:
|
|
"""
|
|
후보 로드 우선순위:
|
|
1) universe_source == "ranking" → VolumeRankManager
|
|
2) universe_source == "condition" → ConditionSearchManager (KIS REST)
|
|
3) universe_source == "kiwoom_condition" → KiwoomConditionSearchManager (키움 WS)
|
|
|
|
⚡ 운영 스위치는 **{SID}_UNIVERSE_SOURCE 하나** 만 바꾸면 됨.
|
|
- condition + CONDITION_{SID}_NAME/SEQ → KIS 조건 (REST 폴링)
|
|
- kiwoom_condition + CONDITION_{SID}_NAME → 키움 조건 (WS 실시간, seq 자동)
|
|
- ranking → 거래량/거래대금 순위
|
|
(키움 seq 를 고정하려면 CONDITION_{SID}_KIWOOM_SEQ 선택 설정)
|
|
"""
|
|
key = f"{self.strategy_id}_UNIVERSE_SOURCE"
|
|
default = self.DEFAULT_UNIVERSE_SOURCES.get(self.strategy_id, "ranking")
|
|
current_src = (get_env_from_db(key, default) or default).strip().lower()
|
|
if current_src not in ("ranking", "condition", "kiwoom_condition"):
|
|
current_src = default
|
|
if current_src != self.universe_source:
|
|
self.logger.info(
|
|
"🔄 [유니버스 소스 전환] %s: %s → %s (재시작 없이 즉시 반영)",
|
|
self.strategy_id, self.universe_source, current_src,
|
|
)
|
|
self.universe_source = current_src
|
|
|
|
# 소스명 → 매니저 매핑. primary(선택 소스) 먼저, 나머지는 폴백 순.
|
|
mgr_by_src = {
|
|
"ranking": self.ranking_mgr,
|
|
"condition": self.condition_mgr,
|
|
"kiwoom_condition": self.kiwoom_condition_mgr,
|
|
}
|
|
order = [self.universe_source] + [
|
|
s for s in ("condition", "kiwoom_condition", "ranking")
|
|
if s != self.universe_source
|
|
]
|
|
|
|
candidates: List[Dict] = []
|
|
for tag in order:
|
|
mgr = mgr_by_src.get(tag)
|
|
if mgr is None:
|
|
continue
|
|
if not self._is_strategy_registered(mgr):
|
|
continue
|
|
try:
|
|
universe = mgr.get_universe_for(self.strategy_id)
|
|
# 매니저에 등록은 돼 있으나 아직 비어있음 → [] 이 정답 (폴백 금지).
|
|
# (설정된 유니버스가 비어있을 수 있는 상태: 장 마감 후 등)
|
|
if universe:
|
|
candidates = mgr.get_candidates_for(self.strategy_id) or []
|
|
else:
|
|
candidates = []
|
|
return self._post_filter_candidates(candidates)
|
|
except Exception as e:
|
|
self.logger.debug("%s 유니버스 로드 실패: %s", tag, e)
|
|
|
|
# 두 매니저 모두 본 전략 설정 없음 → 레거시 DB 경로
|
|
try:
|
|
candidates = self.db.get_target_candidates() or []
|
|
except Exception as e:
|
|
self.logger.debug("target_candidates 조회 실패: %s", e)
|
|
candidates = []
|
|
return self._post_filter_candidates(candidates)
|
|
|
|
def _post_filter_candidates(self, candidates: List[Dict]) -> List[Dict]:
|
|
"""매니저 결과 → ETN/비본주 자동 제외 + 전략별 후보 하드캡.
|
|
|
|
- ``EXCLUDE_NON_STOCK=true`` (기본 true): ETN/ETF/스팩/우선주 등 비본주 자동 제외.
|
|
``kis_trader.utils.non_stock.is_non_stock`` (코드 끝 5/7/9·알파벳 + 이름).
|
|
- ``{STRATEGY_ID}_CAND_LIMIT`` (기본 0=무제한): 매니저 원본 순서 보존하며 상위 N개만 사용.
|
|
WS 구독 41 한도 안전 + cond/ranking 폭주 시 매수 체크 분당 회전율 보장.
|
|
"""
|
|
if not candidates:
|
|
return []
|
|
|
|
# 1) 비본주 필터
|
|
if get_env_bool("EXCLUDE_NON_STOCK", True):
|
|
filtered: List[Dict] = []
|
|
dropped = 0
|
|
for c in candidates:
|
|
code = (c.get("code") or c.get("stk_cd") or "").strip()
|
|
name = (c.get("name") or c.get("stk_nm") or "").strip()
|
|
if _is_non_stock(name, code):
|
|
dropped += 1
|
|
continue
|
|
filtered.append(c)
|
|
if dropped:
|
|
self.logger.debug("🛡 비본주 자동 제외 %d종목 (ETN/ETF/스팩/우선주)", dropped)
|
|
candidates = filtered
|
|
|
|
# 2) 전략별 후보 하드캡
|
|
sid = self.strategy_id.upper()
|
|
cap = get_env_int(f"{sid}_CAND_LIMIT", 0)
|
|
if cap > 0 and len(candidates) > cap:
|
|
self.logger.debug(
|
|
"✂ 후보 하드캡 적용: %d → %d (%s_CAND_LIMIT=%d)",
|
|
len(candidates), cap, sid, cap,
|
|
)
|
|
candidates = candidates[:cap]
|
|
|
|
# 3) 백테 유니버스 슬롯 정합 — target_candidates_history 스냅샷 ∩ 실시간 후보
|
|
from ..utils.live_portfolio_common import (
|
|
filter_candidates_by_history_universe,
|
|
live_universe_slot_align_enabled,
|
|
)
|
|
if live_universe_slot_align_enabled(sid):
|
|
before = len(candidates)
|
|
candidates, dropped = filter_candidates_by_history_universe(
|
|
candidates, self.db, sid,
|
|
)
|
|
if dropped > 0:
|
|
now_ts = time.time()
|
|
last = getattr(self, "_universe_slot_log_ts", 0.0)
|
|
if now_ts - last >= 120:
|
|
self._universe_slot_log_ts = now_ts
|
|
self.logger.info(
|
|
"🔍 [유니버스슬롯] %s 후보 %d→%d (history 교집합, 제외 %d)",
|
|
sid, before, len(candidates), dropped,
|
|
)
|
|
|
|
return candidates
|
|
|
|
def _is_strategy_registered(self, mgr) -> bool:
|
|
"""매니저의 _configs 에 본 전략이 들어있는지."""
|
|
if mgr is None:
|
|
return False
|
|
try:
|
|
cfgs = getattr(mgr, "_configs", [])
|
|
return any(c.get("strategy_id") == self.strategy_id for c in cfgs)
|
|
except Exception:
|
|
return False
|
|
|
|
def on_new_day(self) -> None:
|
|
"""날짜 변경 훅 (서브클래스 오버라이드 가능)."""
|
|
pass
|
|
|
|
def reload_config(self) -> None:
|
|
"""설정 리로드 훅 (서브클래스 오버라이드)."""
|
|
pass
|
|
|
|
# ------------------------------------------------------------------
|
|
# 서브클래스 구현 필수 메서드
|
|
# ------------------------------------------------------------------
|
|
@abstractmethod
|
|
def check_buy(self, code: str, name: str) -> Optional[Dict]:
|
|
"""매수 시그널. 성공 시 dict(code/name/price/qty/stop_price/...)."""
|
|
raise NotImplementedError
|
|
|
|
@abstractmethod
|
|
def check_sell_signals(self) -> List[Dict]:
|
|
"""보유 종목 순회 → 매도 시그널 리스트."""
|
|
raise NotImplementedError
|
|
|
|
def _candidate_filter(self, candidate: Dict) -> bool:
|
|
"""후보 중 본 전략이 관심 있는 것만 True. 기본 True."""
|
|
return True
|