shuim
85cb5cbc09
- portfolio_cache_bridge: 잔량 산출을 Portfolio(DB) 기준으로. 캐시는 sync 실패 시 최대 5분 낡아 실제와 다른 잔량이 기록될 수 있었음(감사 #14). 조회 실패 시 캐시 폴백. - ORB 캐시 Redis 영속화(save/load_orb_cache) — 재배포 시 인메모리가 날아가 당일 ORB 전략이 통째로 불가능했음. 수집 후 저장, 스케줄러 기동·수집 시 복원. - us_market_scheduler: 부분청산이 Portfolio.quantity 를 갱신하지 않던 문제 → reflect_sell 연동. - 듀얼 전략(MOMENTUM_BREAKOUT/PULLBACK_BUY)이 ActiveTrade.strategy_name 에 저장되지 않아 CLAUDE.md §8.4 모멘텀 전용 청산(+10%/+20% 분할)이 한 번도 실행된 적 없었음 → 태깅 전달. 매도 시에는 실제 행의 strategy_name 으로 close (swing 으로 닫으면 유령 행 잔존). - 수동매도: current_price NULL 시 TypeError 로 주문 후 상태 갱신이 통째로 누락되던 엣지 수정. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
350 lines
14 KiB
Python
350 lines
14 KiB
Python
"""스윙 트레이딩 진입 서비스
|
|
|
|
trade_executor.py의 execute_auto_trade_background() 로직을 기반으로
|
|
strategy_type='swing' 진입만 처리하는 독립 서비스.
|
|
|
|
진입 기준 (CLAUDE.md 섹션 6.2):
|
|
- BULL: RSI(14) < 46, 가격이 BB 하단 부근, 거래량 > 20MA
|
|
- BEAR: RSI(14) < 35, 가격 < BB 하단, 거래량 > 1.5x20MA, 반전 캔들
|
|
- SIDEWAYS: 진입 없음 (CLAUDE.md 6.1)
|
|
- 포지션 사이징: 종목당 총자본 6% (MAX_POSITION_SIZE), 최대 25종목
|
|
|
|
듀얼 전략 (CLAUDE.md 섹션 8.4):
|
|
- 모멘텀 돌파: 20일 신고가 + 거래량 2x + RSI 50~70 (BULL만)
|
|
- 눌림목 매수: MA20>MA60 + MA20 근처 조정 + RSI 반등 (BULL만)
|
|
|
|
진입 전 체크:
|
|
1. 장 오픈 여부 (정규장 09:00~15:30만 허용)
|
|
2. 스윙 포지션 한도 (25종목)
|
|
3. MDD 신규 진입 가능 여부
|
|
4. 적응형 전략 Crisis 모드 차단
|
|
5. 플레이북 이벤트 차단 (FOMC, 옵션만기 등)
|
|
6. 시장 국면 SIDEWAYS 차단
|
|
"""
|
|
import asyncio
|
|
import logging
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select, desc
|
|
from datetime import date
|
|
|
|
from app.core.config import settings
|
|
from app.models.models import Portfolio, StockAnalysis
|
|
from app.services.trade_executor import execute_auto_trade, execute_auto_trade_background
|
|
from app.services.market_analyzer import check_market_regime
|
|
from app.services.mdd_manager import mdd_manager
|
|
from app.services.swing.position_manager import count_swing_positions
|
|
from app.services.market_playbook import is_entry_allowed_by_playbook, get_position_multiplier_from_playbook
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# 스윙 동시 보유 최대 종목 수 (CLAUDE.md 5.1: MAX_HOLDINGS_COUNT = 20)
|
|
MAX_SWING_POSITIONS = 20
|
|
|
|
# RSI 반등 방향 확인용 과거 구간 (kosdaq_scanner.py RSI_DIRECTION_LOOKBACK과 동일)
|
|
RSI_DIRECTION_LOOKBACK = 3
|
|
|
|
|
|
async def execute_swing_entries(recommendations_response: dict, db: AsyncSession) -> list[dict]:
|
|
"""배치 분석 추천 결과를 기반으로 스윙 매수 실행.
|
|
|
|
기존 execute_auto_trade_background()를 재활용하되
|
|
strategy_type='swing' 레이블을 주입하여 데이트레이딩과 분리.
|
|
|
|
처리 흐름:
|
|
1. 장 오픈 여부 체크 (정규장만 허용)
|
|
2. 포지션 한도 체크 (MAX_SWING_POSITIONS)
|
|
3. MDD 체크 (can_open_new_position)
|
|
4. 적응형 전략 Crisis 모드 차단
|
|
5. 플레이북 이벤트 차단
|
|
6. SIDEWAYS 국면 차단
|
|
7. 추천 목록에 strategy_type='swing' 주입
|
|
8. execute_auto_trade_background() 호출
|
|
|
|
Args:
|
|
recommendations_response: Redis 또는 DB에서 가져온 추천 딕셔너리
|
|
- recommendations_by_rule: 규칙별 추천 종목 리스트
|
|
db: AsyncSession 인스턴스
|
|
|
|
Returns:
|
|
list[dict]: 실행된 매수 결과 목록
|
|
"""
|
|
# 장 마감 후 매수 차단 (15:30 이후, KIS 모의투자 24시간 허용 방지)
|
|
from app.core.market_schedule import is_market_open
|
|
if not is_market_open():
|
|
logger.info("[SwingEntry] 장 마감 — 스윙 매수 차단 (정규장만 매매)")
|
|
return []
|
|
|
|
# 포지션 한도 체크
|
|
current_count = await count_swing_positions(db)
|
|
if current_count >= MAX_SWING_POSITIONS:
|
|
logger.info(
|
|
f"[SwingEntry] 최대 포지션 수 도달 ({current_count}/{MAX_SWING_POSITIONS}) — 신규 진입 스킵"
|
|
)
|
|
return []
|
|
|
|
# MDD 체크
|
|
can_open = await mdd_manager.can_open_new_position()
|
|
if not can_open:
|
|
logger.warning("[SwingEntry] MDD 초과 — 신규 진입 차단")
|
|
return []
|
|
|
|
# 적응형 전략 체크 — Crisis 모드에서 스윙 진입 전면 차단
|
|
try:
|
|
from app.services.adaptive_strategy import get_current_adaptive_params
|
|
_adp_swing = get_current_adaptive_params()
|
|
if not _adp_swing.fallback_used and _adp_swing.trading_mode == "crisis":
|
|
logger.warning("[SwingEntry] 적응형 전략 CRISIS 모드 — 스윙 진입 전면 차단")
|
|
return []
|
|
except Exception:
|
|
pass # adaptive 모듈 실패 시 기존 로직 유지
|
|
|
|
# 플레이북 체크 — FOMC/옵션만기/서킷브레이커 등 이벤트 당일 차단
|
|
if not is_entry_allowed_by_playbook():
|
|
logger.info("[SwingEntry] 플레이북 차단 — 신규 진입 비활성화 (이벤트 대응)")
|
|
return []
|
|
|
|
# SIDEWAYS 국면 체크 + [안전형 개선②] 지수 서킷브레이커
|
|
try:
|
|
regime = await check_market_regime()
|
|
regime_str = regime.get("regime_200d", "bull") if isinstance(regime, dict) else "bull"
|
|
if regime_str == "sideways":
|
|
logger.info("[SwingEntry] SIDEWAYS 국면 — 진입 신호 무시 (CLAUDE.md 6.1)")
|
|
return []
|
|
|
|
# [안전형 개선②] 지수 서킷브레이커 (검증 완료: 2024H2 CAGR -9.9%→+1.0%, MDD -7→-1.9)
|
|
# KODEX200(069500) 일봉 종가 < MA20 → 신규 스윙 진입 전면 중단 (기존 보유 청산/관리는 정상 동작).
|
|
# check_market_regime()이 이미 계산한 drop_from_ma20(=(현재가-MA20)/MA20*100)을 재사용하여
|
|
# 지수 데이터 중복 조회를 피한다.
|
|
# 2026-09-17: 사용자 결정으로 기본 OFF (SWING_INDEX_BREAKER_ENABLED=true 로 재활성화 가능).
|
|
if settings.SWING_INDEX_BREAKER_ENABLED and isinstance(regime, dict):
|
|
_drop_from_ma20 = regime.get("drop_from_ma20")
|
|
if _drop_from_ma20 is not None and float(_drop_from_ma20) < 0:
|
|
logger.info(
|
|
"[SwingEntry] 지수 서킷브레이커 — KODEX200 종가<MA20 (drop=%.2f%%) — 신규 진입 전면 중단",
|
|
float(_drop_from_ma20),
|
|
)
|
|
return []
|
|
except Exception as e:
|
|
logger.warning(f"[SwingEntry] 시장 국면 조회 실패: {e}")
|
|
|
|
# strategy_type='swing' 레이블 주입
|
|
rec = dict(recommendations_response)
|
|
_inject_strategy_type(rec, "swing")
|
|
|
|
# 기존 execute_auto_trade_background 재활용 (시그니처 변경 없음)
|
|
try:
|
|
result = await execute_auto_trade_background(rec, db)
|
|
if isinstance(result, list):
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"[SwingEntry] 진입 실행 오류: {e}", exc_info=True)
|
|
|
|
return []
|
|
|
|
|
|
def _inject_strategy_type(rec: dict, strategy_type: str) -> None:
|
|
"""추천 목록의 각 종목에 strategy_type 필드를 주입.
|
|
|
|
recommendations_by_rule 구조가 리스트 또는 딕셔너리일 수 있어
|
|
두 가지 형태를 모두 지원.
|
|
|
|
Args:
|
|
rec: 추천 딕셔너리 (원본을 직접 수정)
|
|
strategy_type: 주입할 전략 타입 (예: "swing")
|
|
"""
|
|
groups = rec.get("recommendations_by_rule", [])
|
|
if isinstance(groups, list):
|
|
for group in groups:
|
|
if isinstance(group, dict):
|
|
for stock in group.get("stocks", []):
|
|
if isinstance(stock, dict):
|
|
stock["strategy_type"] = strategy_type
|
|
elif isinstance(groups, dict):
|
|
for group in groups.values():
|
|
if isinstance(group, list):
|
|
for stock in group:
|
|
if isinstance(stock, dict):
|
|
stock["strategy_type"] = strategy_type
|
|
|
|
|
|
async def scan_dual_strategy_signals(db: AsyncSession) -> list[dict]:
|
|
"""듀얼 전략 시그널 스캔 및 진입 실행 (CLAUDE.md 섹션 8.4).
|
|
|
|
배치 분석으로 저장된 stock_analysis 종목들의 일봉 차트를 조회하여
|
|
모멘텀 돌파 / 눌림목 매수 시그널을 탐색하고, 기존 매매 파이프라인으로 진입.
|
|
|
|
BULL 시장에서만 실행. SIDEWAYS/BEAR에서는 스킵.
|
|
|
|
Returns:
|
|
list[dict]: 실행된 매수 결과 목록
|
|
"""
|
|
from app.core.market_schedule import is_market_open
|
|
from app.services.korea_investment_api import korea_investment_api
|
|
from app.services.mean_reversion_strategy import (
|
|
check_momentum_breakout_signal,
|
|
check_pullback_buy_signal,
|
|
calculate_rsi,
|
|
)
|
|
|
|
if not is_market_open():
|
|
return []
|
|
|
|
# BULL 시장에서만 듀얼 전략 실행
|
|
try:
|
|
regime = await check_market_regime()
|
|
regime_str = regime.get("regime_200d", "bull") if isinstance(regime, dict) else "bull"
|
|
if regime_str != "bull":
|
|
logger.debug("[DualStrategy] BULL이 아님 (%s) — 듀얼 전략 스킵", regime_str)
|
|
return []
|
|
except Exception as e:
|
|
logger.warning(f"[DualStrategy] 시장 국면 조회 실패: {e}")
|
|
return []
|
|
|
|
# 포지션 한도 체크
|
|
current_count = await count_swing_positions(db)
|
|
remaining_slots = MAX_SWING_POSITIONS - current_count
|
|
if remaining_slots <= 0:
|
|
return []
|
|
|
|
# MDD 체크
|
|
if not await mdd_manager.can_open_new_position():
|
|
return []
|
|
|
|
# Crisis 모드 체크
|
|
try:
|
|
from app.services.adaptive_strategy import get_current_adaptive_params
|
|
_adp = get_current_adaptive_params()
|
|
if not _adp.fallback_used and _adp.trading_mode == "crisis":
|
|
return []
|
|
except Exception:
|
|
pass
|
|
|
|
# 현재 보유 종목 (중복 진입 방지)
|
|
result = await db.execute(select(Portfolio.stock_code).where(Portfolio.quantity > 0))
|
|
held_codes = {row[0] for row in result.fetchall()}
|
|
|
|
# 최근 분석된 종목 중 상위 30개 조회 (score 기준)
|
|
analysis_query = (
|
|
select(StockAnalysis)
|
|
.where(StockAnalysis.analysis_date >= date.today())
|
|
.order_by(desc(StockAnalysis.score))
|
|
.limit(30)
|
|
)
|
|
analysis_result = await db.execute(analysis_query)
|
|
candidates = analysis_result.scalars().all()
|
|
|
|
if not candidates:
|
|
logger.debug("[DualStrategy] 분석 데이터 없음 — 스킵")
|
|
return []
|
|
|
|
dual_stocks = []
|
|
scan_count = 0
|
|
|
|
for stock in candidates:
|
|
if scan_count >= 10:
|
|
break
|
|
if stock.stock_code in held_codes:
|
|
continue
|
|
if float(stock.current_price or 0) < settings.MIN_PRICE_KRW:
|
|
continue
|
|
|
|
try:
|
|
chart = await korea_investment_api.get_daily_chart(stock.stock_code, limit=60)
|
|
output2 = chart.get("output2", [])
|
|
if not output2 or len(output2) < 20:
|
|
continue
|
|
|
|
# 최신이 앞에 오므로 reverse
|
|
bars = list(reversed(output2))
|
|
closes = [float(b.get("stck_clpr", 0)) for b in bars]
|
|
highs = [float(b.get("stck_hgpr", 0)) for b in bars]
|
|
volumes = [int(b.get("acml_vol", 0)) for b in bars]
|
|
|
|
if not closes or closes[-1] <= 0:
|
|
continue
|
|
|
|
current_close = closes[-1]
|
|
current_volume = volumes[-1] if volumes else 0
|
|
|
|
rsi = calculate_rsi(closes, period=14)
|
|
if rsi is None:
|
|
continue
|
|
rsi_prev = calculate_rsi(closes[:-RSI_DIRECTION_LOOKBACK], period=14)
|
|
|
|
scan_count += 1
|
|
|
|
# 모멘텀 돌파 체크
|
|
momentum_signal = check_momentum_breakout_signal(
|
|
closes=closes, highs=highs, volumes=volumes,
|
|
current_close=current_close, current_volume=current_volume, rsi=rsi,
|
|
)
|
|
if momentum_signal:
|
|
dual_stocks.append({
|
|
"stock_code": stock.stock_code,
|
|
"stock_name": stock.stock_name,
|
|
"current_price": int(current_close),
|
|
"score": 0.8,
|
|
"signal": momentum_signal["description"],
|
|
"strategy_type": "swing",
|
|
# ActiveTrade.strategy_name 으로 저장돼 swing/exit_service 의 모멘텀 전용
|
|
# 청산(+10% 30% → +20% 30% → 트레일링, CLAUDE.md §8.4)을 타게 한다.
|
|
"strategy_name": "MOMENTUM_BREAKOUT",
|
|
"entry_reason": f"[MOMENTUM_BREAKOUT] {momentum_signal['description']}",
|
|
})
|
|
logger.info(
|
|
f"[DualStrategy] 모멘텀 돌파 시그널: {stock.stock_code} {stock.stock_name}"
|
|
)
|
|
continue
|
|
|
|
# 눌림목 매수 체크
|
|
pullback_signal = check_pullback_buy_signal(
|
|
closes=closes, current_close=current_close,
|
|
current_volume=current_volume, rsi=rsi, rsi_prev=rsi_prev,
|
|
volumes=volumes,
|
|
)
|
|
if pullback_signal:
|
|
dual_stocks.append({
|
|
"stock_code": stock.stock_code,
|
|
"stock_name": stock.stock_name,
|
|
"current_price": int(current_close),
|
|
"score": 0.6,
|
|
"signal": pullback_signal["description"],
|
|
"strategy_type": "swing",
|
|
"strategy_name": "PULLBACK_BUY",
|
|
"entry_reason": f"[PULLBACK_BUY] {pullback_signal['description']}",
|
|
})
|
|
logger.info(
|
|
f"[DualStrategy] 눌림목 매수 시그널: {stock.stock_code} {stock.stock_name}"
|
|
)
|
|
|
|
await asyncio.sleep(0.3) # KIS API 레이트 리밋
|
|
|
|
except Exception as e:
|
|
logger.debug(f"[DualStrategy] {stock.stock_code} 스캔 실패: {e}")
|
|
continue
|
|
|
|
if not dual_stocks:
|
|
logger.debug("[DualStrategy] 시그널 없음")
|
|
return []
|
|
|
|
# 남은 슬롯 이내로 제한
|
|
dual_stocks = dual_stocks[:remaining_slots]
|
|
|
|
# execute_auto_trade_background 형식으로 변환하여 실행
|
|
rec = {
|
|
"recommendations_by_rule": [{
|
|
"rule_name": "dual_strategy",
|
|
"stocks": dual_stocks,
|
|
}]
|
|
}
|
|
|
|
try:
|
|
result = await execute_auto_trade_background(rec, db)
|
|
if isinstance(result, list):
|
|
logger.info(f"[DualStrategy] {len(result)}건 진입 실행 완료")
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"[DualStrategy] 진입 실행 오류: {e}", exc_info=True)
|
|
|
|
return []
|