shuim
5f0f839039
## CRITICAL/HIGH (S1-S8) - S1: Aggressive 모드 %B 스케일링 캡 1.3 (BB 중앙선 위 매수 방지) - S2: ML scaler train-only fit (데이터 누수 제거) - S3: SIDEWAYS = ADX<20 AND slope≈0 (트렌드 초기 차단 해소) - S4: EOD 청산 실패 시 재시도 + CRITICAL 로그 - S5: 일일 손실 한도에 미실현 P&L 포함 - S6: trailing stop 고점 매 사이클 갱신 - S7: 섹터 필터 미매핑 종목 "기타" 분류 (max 3 적용) - S8: 스캐너 RSI 기준 25→46, BB 점수 -3%~+1.5% 구간 ## MEDIUM (M1-M7) - M1: 스캐너 최소 거래량 100만→10만주 - M2: ADX 히스테리시스 18/22 (국면 플리핑 방지) - M3: 분할매도 최소 수익 1.0%→0.5% - M4: ORB 갭 필터 4% + 레인지 폭 0.3% 최소 - M5: 쿨다운 스트릭 부분매도 시 미변경 - M6: MDD 강제매도 loss_tracker 기록 제거 (허위 ban 방지) - M7: RSI Wilder 스무딩으로 통일 ## 인프라/보안 - 인증 누락 엔드포인트 수정 (analysis, journals) - nginx 보안 헤더 location 블록 누락 수정 - Alembic 마이그레이션 IF NOT EXISTS 가드 추가 - SellRequest/UsOrderRequest 입력 검증 강화 - 차트 네이버 폴백 추가 (DB 데이터 없을 때) - 서버 이전 시 자동 DB 마이그레이션 + KRX 초기 수집 - CLAUDE.md 섹션 5.1 백테스트 값 동기화 (4%→6%, -6%→-7%) - MAX_SWING_POSITIONS 25→20 (CLAUDE.md 준수) - mdd_manager failed_count에서 skip 종목 제외 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
326 lines
15 KiB
Python
326 lines
15 KiB
Python
"""
|
|
MDD(Maximum Drawdown) 관리 - CLAUDE.md 섹션 6.3
|
|
|
|
- 포트폴리오 최고점 대비 하락률 추적
|
|
- -10% 돌파 시: 신규 진입 중단 + 기존 포지션 30% 축소
|
|
- -20% 돌파 시: 전체 포지션 50% 강제 축소 (레버리지/인버스 우선)
|
|
"""
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
from typing import Dict, Optional
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_MDD_REDIS_KEY = "mdd:state"
|
|
|
|
|
|
class MDDManager:
|
|
"""포트폴리오 MDD 관리자 (싱글톤으로 사용)"""
|
|
|
|
def __init__(self):
|
|
self.peak_balance: float = 0.0
|
|
self.is_paused: bool = False
|
|
self.is_short_term_strategy_paused: bool = False # MDD -10% 시 단기 전략 중단
|
|
self.reduction_applied: Optional[str] = None # None, "10pct", "20pct"
|
|
self._reduction_executed_10pct: bool = False # 중복 축소 실행 방지
|
|
self._reduction_executed_20pct: bool = False
|
|
self._lock = asyncio.Lock() # 스케줄러-sync 동시 접근 방지
|
|
|
|
async def save_to_redis(self) -> None:
|
|
"""MDD 상태를 Redis에 영속화 — 앱 재시작 시 복원용."""
|
|
try:
|
|
from app.core.redis import get_redis
|
|
r = get_redis()
|
|
if r:
|
|
state = {
|
|
"peak_balance": self.peak_balance,
|
|
"is_paused": self.is_paused,
|
|
"is_short_term_strategy_paused": self.is_short_term_strategy_paused,
|
|
"reduction_applied": self.reduction_applied,
|
|
"_reduction_executed_10pct": self._reduction_executed_10pct,
|
|
"_reduction_executed_20pct": self._reduction_executed_20pct,
|
|
}
|
|
await r.set(_MDD_REDIS_KEY, json.dumps(state))
|
|
except Exception as e:
|
|
logger.warning(f"[MDD] Redis 저장 실패: {e}")
|
|
|
|
async def load_from_redis(self) -> bool:
|
|
"""Redis에서 MDD 상태 복원. 복원 성공 시 True 반환."""
|
|
try:
|
|
from app.core.redis import get_redis
|
|
r = get_redis()
|
|
if r:
|
|
raw = await r.get(_MDD_REDIS_KEY)
|
|
if raw:
|
|
state = json.loads(raw)
|
|
self.peak_balance = float(state.get("peak_balance", 0.0))
|
|
self.is_paused = bool(state.get("is_paused", False))
|
|
self.is_short_term_strategy_paused = bool(state.get("is_short_term_strategy_paused", False))
|
|
self.reduction_applied = state.get("reduction_applied")
|
|
self._reduction_executed_10pct = bool(state.get("_reduction_executed_10pct", False))
|
|
self._reduction_executed_20pct = bool(state.get("_reduction_executed_20pct", False))
|
|
logger.info(
|
|
f"[MDD] Redis에서 복원: peak={self.peak_balance:,.0f}, "
|
|
f"paused={self.is_paused}, reduction={self.reduction_applied}"
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
logger.warning(f"[MDD] Redis 복원 실패: {e}")
|
|
return False
|
|
|
|
async def update(self, current_balance: float) -> Dict:
|
|
"""MDD 업데이트 및 필요한 조치 반환 (thread-safe)
|
|
|
|
Returns:
|
|
{"action": "NONE"/"REDUCE_AND_PAUSE"/"FORCE_REDUCE",
|
|
"drawdown": float, ...}
|
|
"""
|
|
async with self._lock:
|
|
if current_balance > self.peak_balance:
|
|
self.peak_balance = current_balance
|
|
self.is_paused = False
|
|
self.is_short_term_strategy_paused = False
|
|
self.reduction_applied = None
|
|
self._reduction_executed_10pct = False
|
|
self._reduction_executed_20pct = False
|
|
|
|
if self.peak_balance <= 0:
|
|
return {"action": "NONE", "drawdown": 0.0}
|
|
|
|
drawdown_pct = ((current_balance - self.peak_balance) / self.peak_balance) * 100
|
|
|
|
# -20% 돌파: 50% 강제 축소
|
|
if drawdown_pct <= -20 and self.reduction_applied != "20pct":
|
|
self.is_paused = True
|
|
self.is_short_term_strategy_paused = True # 단번에 -20% 도달 시에도 단기전략 차단
|
|
self.reduction_applied = "20pct"
|
|
logger.warning(f"MDD {drawdown_pct:.1f}% - 50% 강제 축소 + 신규진입 중단")
|
|
await self.save_to_redis()
|
|
# Telegram MDD 경고
|
|
try:
|
|
from app.services.telegram_notifier import telegram_notifier
|
|
asyncio.ensure_future(telegram_notifier.notify_mdd_warning(
|
|
action="FORCE_REDUCE", drawdown=drawdown_pct, reduce_pct=0.50,
|
|
))
|
|
except Exception:
|
|
pass
|
|
return {
|
|
"action": "FORCE_REDUCE",
|
|
"drawdown": drawdown_pct,
|
|
"reduce_pct": 0.50,
|
|
"prioritize_leverage": True,
|
|
}
|
|
|
|
# -10% 돌파: 30% 축소 + 신규진입 중단 + 단기전략 중단
|
|
if drawdown_pct <= -10 and self.reduction_applied is None:
|
|
self.is_paused = True
|
|
self.is_short_term_strategy_paused = True # CLAUDE.md 5.3: 단기 매매 전략 중단
|
|
self.reduction_applied = "10pct"
|
|
logger.warning(f"MDD {drawdown_pct:.1f}% - 30% 축소 + 신규진입 중단 + 단기전략 중단")
|
|
await self.save_to_redis()
|
|
# Telegram MDD 경고
|
|
try:
|
|
from app.services.telegram_notifier import telegram_notifier
|
|
asyncio.ensure_future(telegram_notifier.notify_mdd_warning(
|
|
action="REDUCE_AND_PAUSE", drawdown=drawdown_pct, reduce_pct=0.30,
|
|
))
|
|
except Exception:
|
|
pass
|
|
return {
|
|
"action": "REDUCE_AND_PAUSE",
|
|
"drawdown": drawdown_pct,
|
|
"reduce_pct": 0.30,
|
|
"short_term_strategy_paused": True,
|
|
}
|
|
|
|
# Redis 영속화 (상태 변경 시)
|
|
await self.save_to_redis()
|
|
return {"action": "NONE", "drawdown": drawdown_pct}
|
|
|
|
async def can_open_new_position(self) -> bool:
|
|
"""신규 포지션 진입 가능 여부 (thread-safe)"""
|
|
async with self._lock:
|
|
return not self.is_paused
|
|
|
|
async def is_short_term_strategy_enabled(self) -> bool:
|
|
"""단기 전략 활성화 여부 (thread-safe) — MDD -10% 이상일 때만 활성화"""
|
|
async with self._lock:
|
|
return not self.is_short_term_strategy_paused
|
|
|
|
async def reset(self):
|
|
"""MDD 상태 리셋 (수동 복구 시) — async + Lock으로 동시성 안전 보장"""
|
|
async with self._lock:
|
|
self.is_paused = False
|
|
self.is_short_term_strategy_paused = False
|
|
self.reduction_applied = None
|
|
self._reduction_executed_10pct = False
|
|
self._reduction_executed_20pct = False
|
|
logger.info("MDD 관리자 리셋")
|
|
await self.save_to_redis()
|
|
|
|
|
|
async def execute_reduction(self, mdd_action: dict) -> list[dict]:
|
|
"""MDD 액션에 따라 포지션 축소 매도 실행.
|
|
|
|
CLAUDE.md 5.3:
|
|
- REDUCE_AND_PAUSE (-10%): 기존 포지션 30% 축소
|
|
- FORCE_REDUCE (-20%): 50% 강제 축소, 레버리지/인버스 ETF 우선
|
|
|
|
중복 실행 방지: 동일 reduction_applied 레벨에서 1회만 실행.
|
|
"""
|
|
action = mdd_action.get("action", "NONE")
|
|
if action == "NONE":
|
|
return []
|
|
|
|
reduce_pct = mdd_action.get("reduce_pct", 0.0)
|
|
prioritize_leverage = mdd_action.get("prioritize_leverage", False)
|
|
|
|
if reduce_pct <= 0:
|
|
return []
|
|
|
|
# [BUG FIX] executed_key를 Lock 밖(finally)에서도 참조하므로
|
|
# Lock 진입 전에 None으로 초기화
|
|
executed_key: Optional[str] = None
|
|
|
|
# 중복 실행 방지: 이미 해당 레벨의 축소가 실행된 경우 스킵
|
|
async with self._lock:
|
|
# [이슈2 수정] reduction_applied가 None이면 executed_key가
|
|
# "_reduction_executed_None" 속성을 생성해 중복 실행 방지가 무력화됨.
|
|
# None 상태는 MDD 미달(정상)이므로 early return.
|
|
if self.reduction_applied is None:
|
|
logger.debug(f"[MDD] reduction_applied=None — 축소 불필요, 스킵")
|
|
return []
|
|
executed_key = f"_reduction_executed_{self.reduction_applied}"
|
|
if getattr(self, executed_key, False):
|
|
logger.debug(f"[MDD] {action} 축소 이미 실행됨 — 스킵")
|
|
return []
|
|
setattr(self, executed_key, True)
|
|
|
|
try:
|
|
from app.services.korea_investment_api import korea_investment_api
|
|
from app.services.db_worker import enqueue_trade_history
|
|
|
|
# 현재 보유 종목 조회
|
|
balance = await korea_investment_api.get_balance()
|
|
holdings = balance.get("output1", [])
|
|
if not holdings:
|
|
logger.info(f"[MDD] {action} — 보유 종목 없음, 축소 불필요")
|
|
return []
|
|
|
|
# 레버리지/인버스 ETF 우선 정렬 (FORCE_REDUCE 시)
|
|
LEVERAGE_KEYWORDS = {"레버리지", "2X", "3X", "인버스", "TIGER 200선물", "KODEX 인버스", "곱버스"}
|
|
if prioritize_leverage:
|
|
def _is_leverage(h):
|
|
name = h.get("prdt_name", "")
|
|
return any(kw in name for kw in LEVERAGE_KEYWORDS)
|
|
holdings = sorted(holdings, key=lambda h: (not _is_leverage(h),))
|
|
|
|
results = []
|
|
skipped = 0
|
|
for h in holdings:
|
|
stock_code = h.get("pdno", "")
|
|
stock_name = h.get("prdt_name", stock_code)
|
|
quantity = int(h.get("hldg_qty", 0) or 0)
|
|
current_price = float(h.get("prpr", 0) or 0)
|
|
|
|
if quantity <= 0 or current_price <= 0:
|
|
skipped += 1
|
|
continue
|
|
|
|
sell_qty = max(int(quantity * reduce_pct), 1)
|
|
sell_qty = min(sell_qty, quantity)
|
|
|
|
try:
|
|
from app.services.trade_executor import safe_place_order
|
|
order_resp = await safe_place_order(
|
|
stock_code=stock_code,
|
|
order_type="SELL",
|
|
quantity=sell_qty,
|
|
price=None, # 시장가
|
|
)
|
|
if order_resp and order_resp.get("rt_cd") == "0":
|
|
order_id = order_resp.get("output", {}).get("ODNO", "")
|
|
avg_price = float(h.get("pchs_avg_pric", current_price))
|
|
profit_loss = (current_price - avg_price) * sell_qty
|
|
profit_loss_rate = ((current_price - avg_price) / avg_price * 100) if avg_price > 0 else 0.0
|
|
|
|
# MDD 강제매도는 시스템적(systemic) 리스크 축소이며,
|
|
# 개별 종목의 전략 실패가 아니므로 loss_tracker에 기록하지 않음.
|
|
# 기록 시 양호한 종목이 MDD 축소로 인해 false ban될 수 있음.
|
|
|
|
await enqueue_trade_history({
|
|
"stock_code": stock_code,
|
|
"stock_name": stock_name,
|
|
"order_type": "SELL",
|
|
"order_price": current_price,
|
|
"order_quantity": sell_qty,
|
|
"executed_price": current_price,
|
|
"executed_quantity": sell_qty,
|
|
"total_amount": current_price * sell_qty,
|
|
"status": "COMPLETED",
|
|
"order_id": order_id,
|
|
"exit_reason": f"MDD {action} ({reduce_pct*100:.0f}% 축소)",
|
|
"net_profit_loss": profit_loss,
|
|
"strategy_type": "mdd_reduction",
|
|
})
|
|
|
|
# [FIX] 전량 매도 시 ActiveTrade 닫기
|
|
remaining_qty = quantity - sell_qty
|
|
if remaining_qty <= 0:
|
|
from app.services.db_worker import enqueue_close_active_trade
|
|
await enqueue_close_active_trade(stock_code)
|
|
else:
|
|
# 부분 매도: remaining_pct 갱신
|
|
# 기존 ActiveTrade의 remaining_pct에 매도 비율을 곱해야 함
|
|
# (예: 기존 0.5 * 남은비율 0.7 = 0.35)
|
|
# db_worker가 직접 setattr하므로, reduce_ratio를 전달하여
|
|
# 워커가 기존 값에 곱하도록 처리
|
|
from app.services.db_worker import enqueue_active_trade_upsert
|
|
sell_ratio = remaining_qty / quantity # 남은 비율 (0.7 or 0.5)
|
|
await enqueue_active_trade_upsert({
|
|
"stock_code": stock_code,
|
|
"remaining_pct_multiply": sell_ratio,
|
|
})
|
|
|
|
results.append({
|
|
"stock_code": stock_code,
|
|
"stock_name": stock_name,
|
|
"sell_quantity": sell_qty,
|
|
"reason": action,
|
|
})
|
|
logger.warning(
|
|
f"[MDD] {action} 매도: {stock_code} {stock_name} "
|
|
f"{sell_qty}주 (총 {quantity}주 중 {reduce_pct*100:.0f}%)"
|
|
)
|
|
|
|
await asyncio.sleep(0.3) # KIS API 레이트 리밋
|
|
|
|
except Exception as e:
|
|
logger.error(f"[MDD] 축소 매도 실패 ({stock_code}): {e}")
|
|
|
|
failed_count = len(holdings) - len(results) - skipped
|
|
if failed_count > 0 and executed_key is not None:
|
|
# 매도 실패 종목이 있으면 플래그 리셋 → 다음 주기에 재시도
|
|
async with self._lock:
|
|
setattr(self, executed_key, False)
|
|
logger.warning(
|
|
f"[MDD] {action} 부분 완료: {len(results)}종목 성공, "
|
|
f"{failed_count}종목 실패 → 다음 주기 재시도 예정"
|
|
)
|
|
else:
|
|
logger.warning(f"[MDD] {action} 완료: {len(results)}종목 축소 매도")
|
|
return results
|
|
|
|
except Exception as e:
|
|
logger.error(f"[MDD] execute_reduction 실패: {e}", exc_info=True)
|
|
# 전체 실패 시 플래그 리셋 → 재시도 가능
|
|
if executed_key is not None:
|
|
async with self._lock:
|
|
setattr(self, executed_key, False)
|
|
return []
|
|
|
|
|
|
# 싱글톤 인스턴스
|
|
mdd_manager = MDDManager()
|