"""스윙 트레이딩 독립 스케줄러 main.py의 lifespan에서 asyncio.create_task()로 시작되는 백그라운드 태스크. 기존 auto_trade_scheduler()를 대체. 60초 주기 실행 흐름: 1. 장 오픈 체크 (장외 시 30분 대기) 2. 스윙 포지션 손절/익절 체크 (check_and_execute_exit_v2) 3. MDD 체크 + 강제 축소 실행 (10% → 30% 축소, 20% → 50% 축소) 4. AUTO_TRADE_ENABLED 체크 5. Redis 캐시 또는 DB에서 추천 조회 6. MCP RISK_ASSESSMENT → 승인 시 스윙 매수 실행 MDD 축소 (CLAUDE.md 5.3): - reduction_applied == "10pct": 30% 축소 (REDUCE_AND_PAUSE) - reduction_applied == "20pct": 50% 축소 (FORCE_REDUCE, 레버리지 ETF 우선) 추천 데이터 소스 (우선순위): 1. Redis: "recommendations:latest" 키 (배치 분석 결과 캐시) 2. DB: get_rule_based_recommendations_from_db() (Redis 미스 시 폴백) """ import asyncio import logging import pytz from datetime import timedelta as _td from app.core.config import settings from app.core.database import AsyncSessionLocal from app.core.market_schedule import is_market_open from app.services.mdd_manager import mdd_manager from app.services.swing.exit_service import check_and_execute_exit_v2 from app.services.swing.entry_service import execute_swing_entries, scan_dual_strategy_signals logger = logging.getLogger(__name__) _KST = pytz.timezone("Asia/Seoul") # [M2] MDD 갱신 실패 감시 — 연속 실패가 이 횟수를 넘으면 error 로 승격 MDD_UPDATE_FAILURE_ALERT = 5 # MDD 갱신 상태 (모니터링/디버깅용 인메모리 상태) _mdd_health: dict = {"consecutive_failures": 0, "last_error": None, "empty_account": False} def get_mdd_update_health() -> dict: """MDD 갱신 상태 스냅샷 반환 (연속 실패 횟수/마지막 오류/진입 차단 여부). swing_scheduler 의 MDD 갱신이 조용히 실패 중인지 외부에서 확인하기 위한 읽기 전용 헬퍼. [항목7 2026-09-27] 헬스의 원본(source of truth)은 mdd_manager 로 이동했다 (can_open_new_position() 이 순환 import 없이 참조하려면 mdd_manager 가 소유해야 함). 이 함수는 시그니처를 유지한 읽기 전용 파사드이며, mdd_manager 스냅샷을 병합해 blind_block_active/threshold 까지 함께 노출한다. """ snapshot = dict(_mdd_health) snapshot.update(mdd_manager.get_update_health()) return snapshot def _normalize_recommendations(rec: dict) -> dict: """recommendations_by_rule 키 정규화. Redis 캐시에 "recommendations" 키로 저장된 경우 "recommendations_by_rule"로 변환하여 execute_swing_entries()와 호환. Args: rec: 추천 딕셔너리 Returns: dict: 정규화된 추천 딕셔너리 """ if not isinstance(rec, dict): return rec if "recommendations_by_rule" in rec: return rec if "recommendations" in rec: rec["recommendations_by_rule"] = rec["recommendations"] return rec def _filter_unsuitable_stocks(rec: dict, unsuitable_codes: set) -> None: """장 전 AI 분석에서 부적합 판정된 종목을 추천 목록에서 제거.""" groups = rec.get("recommendations_by_rule", []) if isinstance(groups, list): for group in groups: if isinstance(group, dict) and "stocks" in group: group["stocks"] = [ s for s in group["stocks"] if isinstance(s, dict) and s.get("stock_code") not in unsuitable_codes ] elif isinstance(groups, dict): for key, stocks in groups.items(): if isinstance(stocks, list): groups[key] = [ s for s in stocks if isinstance(s, dict) and s.get("stock_code") not in unsuitable_codes ] async def swing_scheduler() -> None: """60초 주기 스윙 트레이딩 스케줄러. 무한 루프로 실행되며 asyncio.CancelledError로만 종료. 각 사이클에서 예외 발생 시 로그 기록 후 다음 사이클 계속. DB 세션은 사이클마다 AsyncSessionLocal()로 새로 생성하여 장시간 세션 유지로 인한 커넥션 풀 고갈 방지. """ await asyncio.sleep(2) from app.api.endpoints.recommendations import ( get_rule_based_recommendations_from_db, ) from app.api.endpoints.mcp import request_mcp_risk_assessment from app.core.redis import get_json logger.info("📈 [Swing] Scheduler started (every 60s)") _mdd_update_failures = 0 _mdd_last_error: str | None = None # [M3] '정상 응답이지만 총평가금액 0'(빈/미입금 계좌) 누적 횟수 — 장애 카운터와 분리 _mdd_empty_account_seen = 0 try: while True: try: logger.info("[Swing] ── 사이클 시작 ──") if not is_market_open(): logger.info("[Swing] 장 미오픈 — 개장까지 대기") # 개장을 넘겨 자지 않도록 상한 (2026-09-23) from app.core.market_schedule import seconds_until_market_open _until_open = seconds_until_market_open() await asyncio.sleep(1800.0 if _until_open is None else max(15.0, min(1800.0, _until_open))) continue # ── Phase 1: 청산 체크 (별도 세션) ── async with AsyncSessionLocal() as exit_session: try: exits = await check_and_execute_exit_v2(exit_session) if exits: logger.info(f"[Swing] 청산 실행: {len(exits)}건") except Exception as e: logger.error(f"[Swing] 청산 체크 오류: {e}", exc_info=True) # ── Phase 2: MDD 업데이트 + 체크 + 강제 축소 ── # [FIX] mdd_manager.update()를 매 사이클 호출하여 MDD 감지 활성화 # [M2 2026-09-27] 여기가 mdd_manager.update() 의 유일한 실효 호출부다. # 실패를 debug 로 삼키면 KIS 장애 시 peak/drawdown 이 갱신되지 않아 # -10%/-20% 게이트가 무증상으로 영구 미발동한다 → 경고 + 연속 실패 카운트. # [M3 2026-09-27] "응답 없음/파싱 실패"(진짜 장애)와 "정상 응답 + 총평가금액 # 0"(빈/미입금 계좌)을 구분한다. 후자는 정상 응답이므로 실패로 계수하지 않고 # MDD 갱신만 스킵한다 — 그러지 않으면 신규 모의계좌에서 매 사이클 실패가 # 누적돼 🚨 error 로그가 계속 찍혀 실제 KIS 장애와 구분되지 않는다. _empty_account = False try: from app.services.korea_investment_api import korea_investment_api balance_resp = await korea_investment_api.get_balance() if not balance_resp: raise ValueError("잔고 조회 응답 없음 (resp=없음)") _out2 = balance_resp.get("output2") if not isinstance(_out2, list) or not _out2: raise ValueError("잔고 응답 파싱 실패 (output2 누락/형식 이상)") _raw_total = (_out2[0] or {}).get("tot_evlu_amt") if _raw_total is None or str(_raw_total).strip() == "": raise ValueError("잔고 응답 파싱 실패 (tot_evlu_amt 누락)") try: _total = float(_raw_total) except (TypeError, ValueError): raise ValueError(f"잔고 응답 파싱 실패 (tot_evlu_amt={_raw_total!r})") if _total <= 0: # 정상 응답이지만 자산 0 — 빈 계좌/미입금. 장애 아님. _empty_account = True _mdd_empty_account_seen += 1 if _mdd_empty_account_seen == 1 or _mdd_empty_account_seen % 60 == 0: logger.info( f"[Swing] 잔고 총평가금액 0 (빈/미입금 계좌) — MDD 갱신 스킵 " f"({_mdd_empty_account_seen}회 누적)" ) else: _mdd_empty_account_seen = 0 if _empty_account: # 정상 응답(장애 아님) — 실패 카운터 리셋 + 빈 계좌 표시. # 빈 계좌는 진입 차단 사유가 아니다(항목7). await mdd_manager.record_update_success(empty_account=True) if _total > 0: mdd_result = await mdd_manager.update(_total) # [항목7] 갱신 성공 → fail-safe 차단 해제 await mdd_manager.record_update_success(empty_account=False) if _mdd_update_failures: logger.warning( f"[Swing] MDD 갱신 복구 (연속 실패 {_mdd_update_failures}회 후 정상화)" ) _mdd_update_failures = 0 _mdd_last_error = None if mdd_result.get("action") != "NONE": logger.warning(f"[Swing] MDD 상태 변경: {mdd_result}") except Exception as e: _mdd_update_failures += 1 _mdd_last_error = str(e) # [항목7] 실패를 mdd_manager 에 보고 → 임계 도달 시 # can_open_new_position() 이 모든 진입 경로를 차단한다(청산은 무영향). await mdd_manager.record_update_failure(_mdd_last_error) if _mdd_update_failures >= MDD_UPDATE_FAILURE_ALERT: logger.error( f"[Swing] 🚨 MDD 갱신 연속 실패 {_mdd_update_failures}회 — " f"peak/drawdown 미갱신 상태, -10%/-20% 게이트가 작동하지 않을 수 있음: {e}", exc_info=True, ) else: logger.warning( f"[Swing] MDD 갱신 실패 ({_mdd_update_failures}회 연속): {e}" ) # 상태 노출용 (모니터링/헬스체크에서 참조 가능) _mdd_health["consecutive_failures"] = _mdd_update_failures _mdd_health["last_error"] = _mdd_last_error else: _mdd_health["consecutive_failures"] = _mdd_update_failures _mdd_health["last_error"] = _mdd_last_error _mdd_health["empty_account"] = _empty_account can_open_new = await mdd_manager.can_open_new_position() logger.info(f"[Swing] MDD 체크: can_open={can_open_new}") if not can_open_new: if mdd_manager.get_update_health().get("blind_block_active"): logger.error( f"[Swing] 🚨 MDD 갱신 장애로 신규 진입 차단(fail-safe, 연속 실패 " f"{_mdd_update_failures}회, 마지막 오류: {_mdd_last_error}) — " f"청산/축소는 계속 수행" ) else: logger.warning("[Swing] MDD 초과 — 신규 진입 차단") if mdd_manager.reduction_applied: try: reduce_pct = 0.50 if mdd_manager.reduction_applied == "20pct" else 0.30 mdd_action = { "action": "FORCE_REDUCE" if mdd_manager.reduction_applied == "20pct" else "REDUCE_AND_PAUSE", "reduce_pct": reduce_pct, "prioritize_leverage": mdd_manager.reduction_applied == "20pct", } results = await mdd_manager.execute_reduction(mdd_action) if results: logger.warning(f"[Swing] MDD 강제 축소 완료: {len(results)}종목") except Exception as e: logger.error(f"[Swing] MDD 강제 축소 실패: {e}", exc_info=True) await asyncio.sleep(60) continue # 3. 자동매매 활성화 여부 if not settings.AUTO_TRADE_ENABLED: logger.info("[Swing] AUTO_TRADE_ENABLED=False — 스킵") await asyncio.sleep(60) continue # ── Phase 3: 추천 조회 + 진입 실행 (별도 세션) ── # 4. Redis 캐시 확인 → cache miss 시 DB 조회 rec = await get_json("recommendations:latest") # [FIX] Redis 캐시가 존재해도 recommendations_by_rule이 비어있으면(배치가 빈 # 추천을 캐싱한 경우) 기존엔 '히트'로 처리해 DB 폴백을 건너뛰고 스킵했다. # 빈 캐시가 30분 TTL 동안 DB의 유효 후보를 가려 매매를 막으므로, 비어있으면 # 캐시 미스와 동일하게 DB 조회로 폴백한다. if rec and rec.get("recommendations_by_rule"): rec = _normalize_recommendations(rec) logger.info(f"[Swing] Redis 캐시 히트 (추천 {len(rec.get('recommendations_by_rule', []))}그룹)") else: logger.info("[Swing] Redis 캐시 미스/빈값 → DB 조회") async with AsyncSessionLocal() as rec_session: rec = await get_rule_based_recommendations_from_db(rec_session) if not rec or not rec.get("recommendations_by_rule"): logger.info("[Swing] 추천 데이터 없음 — 스킵") await asyncio.sleep(60) continue # 5. 장 전 AI 분석 결과 활용 + MCP 리스크 평가 (최적화) # 장 전 Sonnet 배치 분석 결과가 Redis에 있으면 부적합 종목을 사전 필터링 # MCP RISK_ASSESSMENT는 실제 매수 직전에만 호출 (비용 절감) _ai_filtered_codes = set() try: _ai_pre = await get_json("ai:pre_market:latest") if _ai_pre and isinstance(_ai_pre, dict): for s in _ai_pre.get("suitable_stocks", []): if isinstance(s, dict) and not s.get("suitable", True): _ai_filtered_codes.add(s.get("stock_code", "")) if _ai_filtered_codes: logger.info(f"[Swing] AI 장 전 분석 필터: {len(_ai_filtered_codes)}종목 제외") except Exception: pass # 추천 목록에서 AI 부적합 종목 제거 if _ai_filtered_codes: _filter_unsuitable_stocks(rec, _ai_filtered_codes) recommendations = rec.get("recommendations_by_rule", []) if isinstance(recommendations, dict): rec_count = sum(len(v) for v in recommendations.values()) top_stocks = [ item.get("stock_code", "") for items in recommendations.values() for item in (items[:3] if isinstance(items, list) else []) ][:10] else: rec_count = sum( len(g.get("stocks", [])) for g in recommendations if isinstance(g, dict) ) top_stocks = [ s.get("stock_code", "") for g in recommendations if isinstance(g, dict) for s in g.get("stocks", [])[:3] ][:10] if not top_stocks: logger.info("[Swing] 필터링 후 추천 종목 없음 — 스킵") await asyncio.sleep(60) continue # MCP 리스크 평가 (Haiku — 실제 진입 직전 1회) trade_plan = { "action": "BUY", "strategy": "swing", "total_recommendations": rec_count, "top_stocks": top_stocks, } logger.info(f"[Swing] MCP 리스크 평가 요청: {len(top_stocks)}종목") mcp_approved, mcp_reason = await request_mcp_risk_assessment( trade_plan, {"strategy": "swing"}, {"top_stocks": top_stocks} ) logger.info(f"[Swing] MCP 결과: approved={mcp_approved}, reason={mcp_reason}") if not mcp_approved: logger.warning(f"[Swing] MCP 거부: {mcp_reason}") from app.services.db_worker import enqueue_db_write await enqueue_db_write({ "type": "log_mcp_deny", "reason": mcp_reason, "trade_plan": trade_plan, }) await asyncio.sleep(60) continue # 6. 스윙 진입 실행 (별도 세션) async with AsyncSessionLocal() as entry_session: logger.info(f"[Swing] 진입 실행 시작: {top_stocks[:5]}") # execute_swing_entries() 내부에서 진입/청산/실패 건수를 이미 # 분리 집계해 로깅하므로(entry_service.py 참조), 여기서는 결과를 # 그대로 소비하지 않고 반환값(list, 2026-09-27 이후 항상 list)만 # 확인한다. await execute_swing_entries(rec, entry_session) # 7. 듀얼 전략 시그널 스캔 (모멘텀 돌파 + 눌림목 매수, CLAUDE.md 8.4) try: async with AsyncSessionLocal() as dual_session: dual_results = await scan_dual_strategy_signals(dual_session) if dual_results: # [2026-09-27] scan_dual_strategy_signals() 가 위임하는 # execute_auto_trade_background() 는 항상 list 를 반환하며, # 그 list 에는 성공 BUY 뿐 아니라 주문 실패(success=False)한 # BUY/SELL, 청산 우선 로직으로 섞인 SELL 도 포함된다. # 따라서 len(dual_results) 를 그대로 "진입 n건"으로 쓰지 않고 # action/success 기준으로 분리 집계한다(상세 집계는 # entry_service.scan_dual_strategy_signals() 내부 로그 참조). buy_success = sum( 1 for r in dual_results if isinstance(r, dict) and r.get("action") == "BUY" and r.get("success") ) sell_count = sum( 1 for r in dual_results if isinstance(r, dict) and r.get("action") == "SELL" ) fail_count = sum( 1 for r in dual_results if isinstance(r, dict) and not r.get("success") ) logger.info( f"[Swing] 듀얼 전략 — 진입 {buy_success}건 / " f"청산 {sell_count}건 / 주문실패 {fail_count}건" ) except Exception as e: logger.debug(f"[Swing] 듀얼 전략 스캔 오류: {e}") logger.info("[Swing] ── 사이클 완료 ──") except Exception as e: logger.error(f"[Swing] 스케줄러 사이클 오류: {e}", exc_info=True) await asyncio.sleep(60) except asyncio.CancelledError: logger.info("[Swing] Scheduler stopped") raise