shuim
9fab4018d4
하네스 규칙 검사 전역 위반 117→0, 회차별 검증(code-verifier opus 4도메인)으로 Critical/High 해소. 주문·리스크 - MDD 강제축소 반복 매도(종목별 완료 집합·재시도 상한·날짜 롤오버·잔고 오류 보류·epoch·장외 미주문) - KIS 거부 FAILED 기록, 결과 불명(전송 후) 재전송 금지·PENDING, 미전송 실패만 재시도(msg_cd 분류) - 국내 전량·손실 매도 시장가, 부분 익절 직전 현재가, 지정가만 미체결 취소(cancel_order_v2: TR 0013U·조직번호) + 0체결 롤백 - 누적 4%·현금·레버리지(신규분 포함)·사이클 내 매수 누적, 수동매수 공용 가드(buy_guards), 수동매도 DT 차감·락 - 가드 우회 엔드포인트 차단(/recommendations/auto-trade 위임, US /execute 매수 410·매도 가드) - 매수 슬롯=성공 매수, 평가 상한·회전, 업무거부/계좌 쿨다운, 프로세스 내 in-flight 주문 중복 차단 데이트레이딩 - 진입·청산 shield, 청산 진행 중 표식(소유 토큰), 2단계 청산 체크, 결과 불명 → 보유 감소 판정·비DT 차감 상한 - 전일 포지션 재시도(일시 실패 미산정), 분할매도 영속, ORB 구간 손절, /cycle 락, 사이클 내 현금 차감, 체결 수량 보정 스윙 - 손절 공백(판정 예외 시 하드 바닥), 단일 손절 소스·범위 검증, 매도 직전 KIS 잔고 상한(min(주문가능,보유)−DT) - 결과 불명 체결 대조·장부 반영, 대체가(나이·진입 이후·ATR 캐시), 분할 단계 기록, 국면 실패 fail-closed - 듀얼 플레이북·서킷브레이커 게이트, 평균회귀 우선·듀얼 독립, 시간손절 거래일 - 거래 확대(사용자 결정, 백테스트 미검증): RSI 46/35 정본 경로, 모멘텀 v2 ON, SIDEWAYS ADX AND, 트레일링 1차 익절 후, 20일 시간손절 ON 인프라·보안 - 계좌·손익 GET 인증, 세션 is_active·관리자 경로, 서명키 파생, realip, WS 토큰 마스킹 - KIS 토큰 즉시 실패(sleep 제거)·무효 시 캐시 삭제, 주문 5xx+JSON 본문 반환 - db_worker 종료 drain(멱등 재실행·커밋 불명 격리·예산·밴 커밋), stop_grace 40s, Redis 타임아웃·volatile-lru, /health DLQ·캐시 - KRX 휴장일, py3.11 비호환 f-string 수정 + Jenkins 이미지 내 compileall·헬스 실패 시 빌드 실패 하네스: rules_check 에 PEP 701 f-string 검사, 마커(allow-*), deploy 스모크 401 기준 CLAUDE.md: 실제 동작·플래그·백로그(§8.5-27~38) 갱신 backend 1451 passed / hooks 112 passed / tsc ok / py3.9 compile 0 errors Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
843 lines
40 KiB
Python
843 lines
40 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)
|
||
- 포지션 사이징: 종목당 총자본 MAX_POSITION_SIZE(기본 4%, 절대 상한),
|
||
최대 MAX_HOLDINGS_COUNT 종목(기본 20) — 값은 config.py/§0 우선순위를 따른다
|
||
|
||
듀얼 전략 (CLAUDE.md 섹션 8.4):
|
||
- 모멘텀 돌파: 20일 신고가 + 거래량 2x + RSI 50~70 (BULL만)
|
||
- 눌림목 매수: MA20>MA60 + MA20 근처 조정 + RSI 반등 (BULL만)
|
||
|
||
진입 전 체크:
|
||
1. 장 오픈 여부 (정규장 09:00~15:30만 허용)
|
||
2. 스윙 포지션 한도 (MAX_SWING_POSITIONS)
|
||
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
|
||
|
||
from app.core.log_throttle import warn_throttled # noqa: E402
|
||
|
||
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 모드에서 스윙 진입 전면 차단
|
||
# [§4 2026-10-02] 판정은 try 밖. 조회 실패 = Crisis 여부 불명 → 진입 차단(fail-closed).
|
||
_crisis_block = _adaptive_entry_block_reason_v2()
|
||
if _crisis_block:
|
||
logger.warning(f"[SwingEntry] {_crisis_block} — 스윙 진입 전면 차단")
|
||
return []
|
||
|
||
# 플레이북 체크 — FOMC/옵션만기/서킷브레이커 등 이벤트 당일 차단
|
||
if not is_entry_allowed_by_playbook():
|
||
logger.info("[SwingEntry] 플레이북 차단 — 신규 진입 비활성화 (이벤트 대응)")
|
||
return []
|
||
|
||
# SIDEWAYS 국면 체크 + [안전형 개선②] 지수 서킷브레이커
|
||
# [H3 2026-10-02] 국면 조회 실패·국면 키 누락은 신규 진입 차단(fail-closed).
|
||
# 기존엔 조회 예외를 warning 후 통과시키고 키 누락을 "bull" 로 간주했다.
|
||
try:
|
||
regime = await check_market_regime()
|
||
except Exception as e:
|
||
logger.error(f"[SwingEntry] 시장 국면 조회 실패 — 신규 진입 차단(fail-closed): {e}")
|
||
return []
|
||
regime_str = _regime_200d_or_none_v2(regime)
|
||
if regime_str is None:
|
||
logger.error(
|
||
"[SwingEntry] 시장 국면 판정값(regime_200d) 없음 — 신규 진입 차단(fail-closed)"
|
||
)
|
||
return []
|
||
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 로 재활성화 가능).
|
||
# [§4 2026-10-02] 값 파싱만 try 안, 판정은 밖. 켜져 있는데 값을 해석할 수 없으면 차단.
|
||
_breaker_block = _index_breaker_block_reason_v2(regime)
|
||
if _breaker_block:
|
||
logger.info(f"[SwingEntry] {_breaker_block} — 신규 진입 전면 중단")
|
||
return []
|
||
|
||
# strategy_type='swing' 레이블 주입
|
||
rec = dict(recommendations_response)
|
||
_inject_strategy_type(rec, "swing")
|
||
|
||
# 기존 execute_auto_trade_background 재활용 (시그니처 변경 없음)
|
||
# [2026-09-27] execute_auto_trade_background() 는 항상 list 를 반환한다(과거엔
|
||
# 암묵적 None). 이 list 에는 성공한 BUY 뿐 아니라 주문 실패(success=False)한
|
||
# BUY/SELL, 청산 우선 로직으로 섞인 SELL 도 함께 담기므로 len(result) 를 그대로
|
||
# "진입 n건"으로 로깅하지 않고 action/success 기준으로 분리 집계한다.
|
||
try:
|
||
result = await execute_auto_trade_background(rec, db)
|
||
if isinstance(result, list):
|
||
buy_success = sum(
|
||
1 for r in result
|
||
if isinstance(r, dict) and r.get("action") == "BUY" and r.get("success")
|
||
)
|
||
sell_count = sum(
|
||
1 for r in result if isinstance(r, dict) and r.get("action") == "SELL"
|
||
)
|
||
fail_count = sum(
|
||
1 for r in result if isinstance(r, dict) and not r.get("success")
|
||
)
|
||
if buy_success or sell_count or fail_count:
|
||
logger.info(
|
||
"[SwingEntry] 진입 %d건 / 청산 %d건 / 주문실패 %d건",
|
||
buy_success, sell_count, fail_count,
|
||
)
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"[SwingEntry] 진입 실행 오류: {e}", exc_info=True)
|
||
|
||
return []
|
||
|
||
|
||
def _adaptive_entry_block_reason_v2() -> str:
|
||
"""적응형 Crisis 진입 차단 사유. 빈 문자열이면 진입 허용.
|
||
|
||
조회만 try 안에 두고, 판정은 밖에서 한다(CLAUDE.md §4: 가드를 try 안에 두지 말 것).
|
||
조회가 실패하면 Crisis 여부를 알 수 없으므로 신규 진입을 차단한다(fail-closed).
|
||
fallback 파라미터(적응형 미산출)는 정상 상태로 간주한다 — 기존 동작 유지.
|
||
"""
|
||
_adp = None
|
||
try:
|
||
from app.services.adaptive_strategy import get_current_adaptive_params
|
||
_adp = get_current_adaptive_params()
|
||
except Exception as e:
|
||
logger.warning(f"[SwingEntry] 적응형 파라미터 조회 실패 — Crisis 여부 불명: {e}")
|
||
return "적응형 파라미터 조회 실패(fail-closed)"
|
||
if _adp is None:
|
||
logger.warning("[SwingEntry] 적응형 파라미터 None — Crisis 여부 불명")
|
||
return "적응형 파라미터 없음(fail-closed)"
|
||
if not getattr(_adp, "fallback_used", False) and getattr(_adp, "trading_mode", None) == "crisis":
|
||
return "적응형 전략 CRISIS 모드"
|
||
return ""
|
||
|
||
|
||
def _index_breaker_block_reason_v2(regime) -> str:
|
||
"""지수 서킷브레이커 차단 사유. 빈 문자열이면 진입 허용.
|
||
|
||
KODEX200 종가 < MA20 (check_market_regime() 의 drop_from_ma20 < 0) 이면 차단.
|
||
settings.SWING_INDEX_BREAKER_ENABLED=False 면 항상 허용(2026-09-17 사용자 결정 기본 OFF).
|
||
값 파싱만 try 안 — 켜져 있는데 값을 해석할 수 없으면 차단(fail-closed, §4).
|
||
값이 아예 없으면(None) 기존 동작대로 통과한다.
|
||
평균회귀(execute_swing_entries)·듀얼(scan_dual_strategy_signals) 공용 —
|
||
[H-1 2026-10-02 3회차] 듀얼에는 이 판정이 없었다.
|
||
"""
|
||
if not settings.SWING_INDEX_BREAKER_ENABLED:
|
||
return ""
|
||
_raw_drop = regime.get("drop_from_ma20") if isinstance(regime, dict) else None
|
||
if _raw_drop is None:
|
||
return ""
|
||
try:
|
||
_drop_from_ma20 = float(_raw_drop)
|
||
except (TypeError, ValueError) as e:
|
||
logger.warning(f"[SwingEntry] 지수 서킷브레이커 값 해석 실패({_raw_drop!r}) — 신규 진입 차단: {e}")
|
||
return f"지수 서킷브레이커 값 해석 실패({_raw_drop!r}, fail-closed)"
|
||
if _drop_from_ma20 < 0:
|
||
return f"지수 서킷브레이커 — KODEX200 종가<MA20 (drop={_drop_from_ma20:.2f}%)"
|
||
return ""
|
||
|
||
|
||
def _regime_200d_or_none_v2(regime) -> "str | None":
|
||
"""check_market_regime() 결과에서 regime_200d 를 꺼낸다. 없거나 형식이 틀리면 None.
|
||
|
||
기존 `.get("regime_200d", "bull")` 은 판정 실패(키 누락)를 BULL 로 해석해
|
||
진입을 계속시켰다. 호출부는 None 을 진입 차단으로 처리한다.
|
||
"""
|
||
if not isinstance(regime, dict):
|
||
return None
|
||
val = regime.get("regime_200d")
|
||
if not isinstance(val, str) or not val:
|
||
return None
|
||
return val
|
||
|
||
|
||
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_momentum_breakout_signal_v2,
|
||
check_pullback_buy_signal_v2,
|
||
calculate_rsi,
|
||
)
|
||
from app.services.signal_types import BuySignal
|
||
|
||
if not is_market_open():
|
||
return []
|
||
|
||
# BULL 시장에서만 듀얼 전략 실행
|
||
try:
|
||
regime = await check_market_regime()
|
||
except Exception as e:
|
||
logger.warning(f"[DualStrategy] 시장 국면 조회 실패 — 스킵(fail-closed): {e}")
|
||
return []
|
||
# [H3 2026-10-02] 국면 키 누락을 "bull" 로 간주하지 않는다(fail-closed).
|
||
regime_str = _regime_200d_or_none_v2(regime)
|
||
if regime_str != "bull":
|
||
if regime_str is None:
|
||
logger.warning("[DualStrategy] 국면 판정값(regime_200d) 없음 — 스킵(fail-closed)")
|
||
else:
|
||
logger.debug("[DualStrategy] BULL이 아님 (%s) — 듀얼 전략 스킵", regime_str)
|
||
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 모드 체크 — [§4 2026-10-02] 판정 try 밖, 조회 실패 시 차단(fail-closed)
|
||
_crisis_block_dual = _adaptive_entry_block_reason_v2()
|
||
if _crisis_block_dual:
|
||
logger.info(f"[DualStrategy] {_crisis_block_dual} — 듀얼 전략 스킵")
|
||
return []
|
||
|
||
# [H-1 2026-10-02 3회차] 플레이북(FOMC·옵션만기 등 이벤트 당일)·지수 서킷브레이커 —
|
||
# execute_swing_entries 와 같은 의미로 적용한다(이전엔 듀얼에 없어 이벤트 당일에도 진입).
|
||
# 판정은 try 밖. 플레이북 position_multiplier 는 평균회귀 경로에서도 실제 사이징에
|
||
# 적용되는 곳이 없어(import 만 존재) 듀얼에도 적용하지 않는다 — 동일 의미 유지.
|
||
if not is_entry_allowed_by_playbook():
|
||
logger.info("[DualStrategy] 플레이북 차단 — 신규 진입 비활성화 (이벤트 대응)")
|
||
return []
|
||
_breaker_block_dual = _index_breaker_block_reason_v2(regime)
|
||
if _breaker_block_dual:
|
||
logger.info(f"[DualStrategy] {_breaker_block_dual} — 듀얼 전략 스킵")
|
||
return []
|
||
|
||
# [H-2 2026-10-02 3회차] 듀얼은 MCP 리스크 평가(RISK_ASSESSMENT) 대상이 아니다
|
||
# (2026-10-02 사용자 결정 — 거래 확대, AI 필터 미적용). 하드 리스크 한도(4%·20종목·
|
||
# MDD·밴·현금 95%)는 execute_auto_trade_background → _execute_buy 경로에서 그대로 적용된다.
|
||
|
||
# [M-1 2026-10-02 3회차] 일일 매수 한도 선확인 — 이미 소진됐으면 종목별 일봉 조회
|
||
# (최대 10회 KIS 호출)를 하지 않는다. 한도 판정의 정본은 execute_auto_trade_background
|
||
# 이고 여기는 같은 기준(스윙 소유 BUY distinct 종목 수, 국면 max_trades 반영)의 조기 생략일 뿐.
|
||
# 조회 실패(None)는 그쪽과 같이 fail-closed.
|
||
from app.services.trade_executor import _count_swing_buys_today_v2, _regime_limits_v2
|
||
_limit_regime = regime if settings.BEAR_MARKET_FILTER_ENABLED else None
|
||
_regime_max, _ = _regime_limits_v2(_limit_regime)
|
||
_daily_limit = min(int(settings.MAX_DAILY_TRADES), _regime_max)
|
||
_bought_today = await _count_swing_buys_today_v2(db)
|
||
if _bought_today is None:
|
||
logger.warning("[DualStrategy] 당일 스윙 매수 건수 조회 실패 — 스킵(fail-closed)")
|
||
return []
|
||
if _bought_today >= _daily_limit:
|
||
logger.info(
|
||
f"[DualStrategy] 일일 매수 한도 도달 (오늘 스윙 {_bought_today}종목 / 한도 "
|
||
f"{_daily_limit}) — 듀얼 스캔 생략"
|
||
)
|
||
return []
|
||
|
||
# 현재 보유 종목 (중복 진입 방지)
|
||
result = await db.execute(select(Portfolio.stock_code).where(Portfolio.quantity > 0))
|
||
held_codes = {row[0] for row in result.fetchall()}
|
||
|
||
# 최근 분석된 종목 중 상위 30개 조회 (score 기준)
|
||
# [H5 주석 2026-10-02, 동작 무변경] 듀얼 전략은 독립 유니버스가 없다. 후보는 일일 배치가
|
||
# 저장한 StockAnalysis(당일분) 상위 30개(룰 점수순, 0~15 스케일)이고 그중 미보유·
|
||
# 가격필터 통과 10개만 차트를 본다. 신고가 돌파·눌림목 종목이라도 배치 룰 점수 상위
|
||
# 30 에 들지 못하면 스캔되지 않는다. 배치 실패 시 0건(§6.4).
|
||
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
|
||
|
||
# 모멘텀 돌파 체크
|
||
# [C2 2026-10-02] v1 은 오늘 봉이 20일 고점 구간에 포함돼 구조적으로 미발동.
|
||
# MOMENTUM_BREAKOUT_ENABLED(기본 True)면 오늘 봉 제외 v2, False 면 기존 v1.
|
||
if settings.MOMENTUM_BREAKOUT_ENABLED:
|
||
momentum_signal = check_momentum_breakout_signal_v2(
|
||
closes=closes, highs=highs, volumes=volumes,
|
||
current_close=current_close, current_volume=current_volume, rsi=rsi,
|
||
)
|
||
else:
|
||
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,
|
||
# [2026-09-27 FIX] signals(복수) 누락으로 trade_executor 의
|
||
# should_buy 판정(:1906)이 항상 False 였다 → ML 앙상블이 독립적으로
|
||
# BUY 를 낼 때만 진입되던 버그. 진입 근거와 **의미가 일치하는**
|
||
# 키워드만 채운다(거짓 신호는 저널·ML 학습 데이터를 오염시킴).
|
||
# · 신고가돌파 ← current_close > 20일 고점(v2: 직전 20봉) (StrongBuySignal)
|
||
# · 거래량증가상승 ← vol_ratio >= 2.0 & 상승 돌파
|
||
"signals": [
|
||
BuySignal.신고가돌파.value,
|
||
BuySignal.거래량증가상승.value,
|
||
],
|
||
"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
|
||
|
||
# 눌림목 매수 체크
|
||
# [C2 2026-10-02] 20일 평균거래량에서 오늘(장중) 봉 제외 — 모멘텀과 같은 원칙.
|
||
pullback_signal = check_pullback_buy_signal_v2(
|
||
closes=closes, current_close=current_close,
|
||
current_volume=current_volume, rsi=rsi, rsi_prev=rsi_prev,
|
||
volumes=volumes,
|
||
exclude_today_volume=True,
|
||
)
|
||
if pullback_signal:
|
||
dual_stocks.append({
|
||
"stock_code": stock.stock_code,
|
||
"stock_name": stock.stock_name,
|
||
"current_price": int(current_close),
|
||
"score": 0.6,
|
||
# [2026-09-27 FIX] 모멘텀 돌파와 동일 사유. check_pullback_buy_signal 의
|
||
# 진입 근거와 1:1 대응하는 키워드만 채운다.
|
||
# · 정배열눌림목 ← MA20>MA60(정배열) & MA20 ±3% 조정 (StrongBuySignal)
|
||
# · 눌림목진입 ← RSI 40~55 반등 + 거래량 ≥1.2×20MA (StrongBuySignal)
|
||
# · MA20상향 ← ma20 > ma60 ("20일선 > 60일선")
|
||
"signals": [
|
||
BuySignal.정배열눌림목.value,
|
||
BuySignal.눌림목진입.value,
|
||
BuySignal.MA20상향.value,
|
||
],
|
||
"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:
|
||
# 키는 정적(메모리 증가 방지), 종목 구분은 메시지의 종목 코드로 한다.
|
||
warn_throttled(
|
||
logger, "entry_service:dual_scan",
|
||
f"[DualStrategy] {stock.stock_code} 스캔 실패: {type(e).__name__}: {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,
|
||
}]
|
||
}
|
||
|
||
# [관측성] execute_auto_trade_background() 는 [2026-09-27 수정]으로 내부
|
||
# trade_results 를 항상 list 로 반환한다(과거엔 암묵적 None 을 돌려줘 아래
|
||
# isinstance(result, list) 가 항상 False 였다 — 지금은 정상 동작).
|
||
# 다만 이 list 에는 성공한 BUY 뿐 아니라 **주문 실패(success=False)한
|
||
# BUY/SELL 과, 청산 우선 로직으로 섞여 들어온 SELL 도 함께 담긴다.**
|
||
# 따라서 단순 len(result) 는 "진입 n건"으로 오인시킬 수 있어, 아래에서
|
||
# action/success 기준으로 분리 집계한다. 위임 직전 후보 로그는 관측성
|
||
# 확보를 위해 계속 남긴다.
|
||
logger.info(
|
||
"[DualStrategy] %d건 시그널 → 매매 파이프라인 위임: %s",
|
||
len(dual_stocks),
|
||
", ".join(
|
||
f"{s['stock_code']}({s.get('strategy_name')})" for s in dual_stocks
|
||
),
|
||
)
|
||
|
||
try:
|
||
result = await execute_auto_trade_background(rec, db)
|
||
if isinstance(result, list):
|
||
buy_success = sum(
|
||
1 for r in result
|
||
if isinstance(r, dict) and r.get("action") == "BUY" and r.get("success")
|
||
)
|
||
sell_count = sum(
|
||
1 for r in result if isinstance(r, dict) and r.get("action") == "SELL"
|
||
)
|
||
fail_count = sum(
|
||
1 for r in result if isinstance(r, dict) and not r.get("success")
|
||
)
|
||
logger.info(
|
||
"[DualStrategy] 진입 %d건 / 청산 %d건 / 주문실패 %d건",
|
||
buy_success, sell_count, fail_count,
|
||
)
|
||
return result
|
||
# [2026-09-27] execute_auto_trade_background() 는 이제 항상 list 를 반환하므로
|
||
# 이 분기는 정상 경로에서 도달하지 않는다. 다만 향후 시그니처 회귀(반환 타입
|
||
# 변경) 시 조용히 무시되지 않도록 isinstance 방어는 유지하고 경고로 남긴다.
|
||
logger.warning(
|
||
"[DualStrategy] 예상치 못한 반환 타입(list 아님, %r) — 방어 로직 발동",
|
||
type(result),
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"[DualStrategy] 진입 실행 오류: {e}", exc_info=True)
|
||
|
||
return []
|
||
|
||
|
||
async def scan_range_trading_signals(db: AsyncSession) -> list[dict]:
|
||
"""박스권(SIDEWAYS) 레인지 매매 시그널 스캔 및 진입 실행.
|
||
|
||
CLAUDE.md §8.5 항목 9 — SIDEWAYS 국면 담당 전략이 없어 코스피가 BULL 이 아닌
|
||
구간에서 거래가 전무한 문제를 메우기 위한 **신규 신호원**.
|
||
|
||
⚠️ **백테스트 미검증.** `settings.RANGE_TRADE_ENABLED` 가 False(기본값)이면
|
||
함수 진입 즉시 [] 를 반환한다 — 어떤 조회·판정·주문도 수행하지 않으므로
|
||
플래그가 꺼져 있는 동안 기존 동작은 완전히 불변이다.
|
||
|
||
┌─ SIDEWAYS 차단 우회에 관한 명시적 설계 결정 ────────────────────────────┐
|
||
│ 이 전략은 **SIDEWAYS 국면 전용**이므로, CLAUDE.md §6.1 의 "SIDEWAYS = │
|
||
│ 모든 진입 무시" 전면 차단을 의도적으로 우회한다. │
|
||
│ · market_analyzer.check_market_regime() 은 sideways 에서 │
|
||
│ position_multiplier=0, max_trades=0 을 반환한다. │
|
||
│ → execute_auto_trade_background() 는 max_trades==0 에서 즉시 []을 │
|
||
│ 반환하므로(2026-09-27 수정 이후에도 동일 — 반환 타입만 list로 정정 │
|
||
│ 됐을 뿐 조기 종료 자체는 그대로) 사용할 수 없다. 종목별로 │
|
||
│ execute_auto_trade() 를 직접 호출하고 │
|
||
│ _position_multiplier 를 RANGE_TRADE_POSITION_MULTIPLIER 로 주입한다. │
|
||
│ · trade_executor._execute_buy 는 _regime_str=="sideways" 를 하드 차단 │
|
||
│ 한다(방어코드). 따라서 자본 한도가 가장 보수적인 "bear" 라벨을 주입해 │
|
||
│ BEAR 전략 자본 상한(30%) 아래에서 동작시킨다. │
|
||
│ · 우회는 **RANGE_TRADE_ENABLED 뒤에서만** 일어난다. market_analyzer 와 │
|
||
│ mean_reversion_strategy 는 수정하지 않았으므로 다른 전략(평균회귀· │
|
||
│ 모멘텀·눌림목)의 SIDEWAYS 차단은 그대로 유지된다. │
|
||
└──────────────────────────────────────────────────────────────────────────┘
|
||
|
||
리스크 게이트 (scan_dual_strategy_signals 와 동일 + 레인지 전용 추가):
|
||
1. RANGE_TRADE_ENABLED 플래그
|
||
2. 장 오픈 여부 (정규장만)
|
||
3. 시장 국면 == SIDEWAYS (조회 실패 시 진입 중단 — fail-closed)
|
||
4. 스윙 포지션 한도 (MAX_SWING_POSITIONS)
|
||
5. 레인지 전용 포지션 한도 (RANGE_TRADE_MAX_POSITIONS ∩ 자본 비율 유도 상한)
|
||
6. MDD (await mdd_manager.can_open_new_position())
|
||
7. 적응형 Crisis 모드 (조회 실패 시 fail-closed)
|
||
8. 플레이북 이벤트 차단
|
||
9. 보유 종목 중복 진입 방지
|
||
10. 연속손실 밴 (loss_tracker.is_banned_safe)
|
||
11. 가격 필터 (MIN_PRICE_KRW)
|
||
12. 이후 execute_auto_trade() 내부에서 가격필터·MDD·밴·보유수·당일매도쿨다운,
|
||
_execute_buy 내부에서 correlation_filter·레버리지ETF한도·뉴스필터·
|
||
MIN_BUY_AMOUNT_KRW 가 다시 적용된다.
|
||
|
||
Returns:
|
||
list[dict]: 실행된 매수 결과 목록
|
||
"""
|
||
# ── 게이트 1: 기능 플래그 (백테스트 미검증 — 기본 False) ──────────────
|
||
if not settings.RANGE_TRADE_ENABLED:
|
||
return []
|
||
|
||
from app.core.market_schedule import is_market_open
|
||
from app.models.models import ActiveTrade
|
||
from app.services.korea_investment_api import korea_investment_api
|
||
from app.services.loss_tracker import loss_tracker
|
||
from app.services.mean_reversion_strategy import (
|
||
calculate_adx,
|
||
calculate_atr,
|
||
calculate_bollinger,
|
||
calculate_rsi,
|
||
)
|
||
from app.services.range_trading_strategy import (
|
||
RANGE_TRADE_STRATEGY_NAME,
|
||
calculate_range_stop_loss,
|
||
check_range_buy_signal,
|
||
)
|
||
from app.services.signal_types import BuySignal
|
||
|
||
# ── 게이트 2: 정규장만 ────────────────────────────────────────────────
|
||
if not is_market_open():
|
||
return []
|
||
|
||
# ── 게이트 3: SIDEWAYS 국면에서만 동작 (fail-closed) ──────────────────
|
||
try:
|
||
regime = await check_market_regime()
|
||
except Exception as e:
|
||
logger.warning(f"[RangeTrade] 시장 국면 조회 실패 — 진입 중단(fail-closed): {e}")
|
||
return []
|
||
regime_str = regime.get("regime_200d", "") if isinstance(regime, dict) else ""
|
||
if regime_str != "sideways":
|
||
logger.debug("[RangeTrade] SIDEWAYS 아님 (%s) — 레인지 전략 스킵", regime_str or "unknown")
|
||
return []
|
||
|
||
# ── 게이트 4: 스윙 전체 포지션 한도 ───────────────────────────────────
|
||
current_count = await count_swing_positions(db)
|
||
remaining_slots = MAX_SWING_POSITIONS - current_count
|
||
if remaining_slots <= 0:
|
||
logger.info("[RangeTrade] 스윙 포지션 한도 도달 (%d) — 스킵", current_count)
|
||
return []
|
||
|
||
# ── 게이트 5: 레인지 전용 포지션/자본 한도 ────────────────────────────
|
||
# 자본 배분: 새 자본 몫을 만들지 않고 스윙 예산(SWING_MAX_CAPITAL_RATIO=0.70)을
|
||
# 공유한다. 레인지 몫은 스윙 몫 **내부** 비율(RANGE_TRADE_MAX_CAPITAL_RATIO).
|
||
# 실효 상한 = 총자본 × 0.70 × 0.10 = 7%
|
||
# 종목당 = MAX_POSITION_SIZE(4%) × RANGE_TRADE_POSITION_MULTIPLIER(0.5) = 2%
|
||
# → 허용 종목 수 = floor(7% / 2%) = 3
|
||
_per_position_ratio = settings.MAX_POSITION_SIZE * settings.RANGE_TRADE_POSITION_MULTIPLIER
|
||
_range_capital_ratio = settings.SWING_MAX_CAPITAL_RATIO * settings.RANGE_TRADE_MAX_CAPITAL_RATIO
|
||
_ratio_cap = int(_range_capital_ratio / _per_position_ratio) if _per_position_ratio > 0 else 0
|
||
max_range_positions = max(0, min(settings.RANGE_TRADE_MAX_POSITIONS, _ratio_cap))
|
||
if max_range_positions <= 0:
|
||
logger.info("[RangeTrade] 자본 배분 상한이 0 — 스킵")
|
||
return []
|
||
|
||
_range_count_result = await db.execute(
|
||
select(ActiveTrade.stock_code).where(
|
||
ActiveTrade.status == "active",
|
||
ActiveTrade.strategy_name == RANGE_TRADE_STRATEGY_NAME,
|
||
)
|
||
)
|
||
_range_held = {row[0] for row in _range_count_result.fetchall()}
|
||
range_slots = max_range_positions - len(_range_held)
|
||
if range_slots <= 0:
|
||
logger.info(
|
||
"[RangeTrade] 레인지 포지션 한도 도달 (%d/%d) — 스킵",
|
||
len(_range_held), max_range_positions,
|
||
)
|
||
return []
|
||
remaining_slots = min(remaining_slots, range_slots)
|
||
|
||
# ── 게이트 6: MDD ────────────────────────────────────────────────────
|
||
if not await mdd_manager.can_open_new_position():
|
||
logger.warning("[RangeTrade] MDD 초과 — 신규 진입 차단")
|
||
return []
|
||
|
||
# ── 게이트 7: 적응형 Crisis 모드 (fail-closed) ────────────────────────
|
||
try:
|
||
from app.services.adaptive_strategy import get_current_adaptive_params
|
||
_adp = get_current_adaptive_params()
|
||
_adp_crisis = (not _adp.fallback_used) and _adp.trading_mode == "crisis"
|
||
except Exception as e:
|
||
logger.warning(f"[RangeTrade] 적응형 파라미터 조회 실패 — 진입 중단(fail-closed): {e}")
|
||
return []
|
||
if _adp_crisis:
|
||
logger.warning("[RangeTrade] 적응형 CRISIS 모드 — 레인지 진입 차단")
|
||
return []
|
||
|
||
# ── 게이트 8: 플레이북 ───────────────────────────────────────────────
|
||
if not is_entry_allowed_by_playbook():
|
||
logger.info("[RangeTrade] 플레이북 차단 — 신규 진입 비활성화")
|
||
return []
|
||
|
||
# ── 후보 조회 ────────────────────────────────────────────────────────
|
||
held_result = await db.execute(select(Portfolio.stock_code).where(Portfolio.quantity > 0))
|
||
held_codes = {row[0] for row in held_result.fetchall()}
|
||
|
||
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("[RangeTrade] 분석 데이터 없음 — 스킵")
|
||
return []
|
||
|
||
range_stocks: list[dict] = []
|
||
scan_count = 0
|
||
|
||
for stock in candidates:
|
||
if scan_count >= settings.RANGE_TRADE_SCAN_LIMIT:
|
||
break
|
||
if len(range_stocks) >= remaining_slots:
|
||
break
|
||
# 게이트 9: 중복 진입 방지
|
||
if stock.stock_code in held_codes:
|
||
continue
|
||
# 게이트 11: 가격 필터
|
||
if float(stock.current_price or 0) <= settings.MIN_PRICE_KRW:
|
||
continue
|
||
# 게이트 10: 연속손실 밴 (try 밖 — 실패를 삼키지 않는다)
|
||
if await loss_tracker.is_banned_safe(stock.stock_code):
|
||
logger.debug("[RangeTrade] %s 연속손실 밴 — 스킵", stock.stock_code)
|
||
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) < 40:
|
||
continue
|
||
|
||
bars = list(reversed(output2)) # 최신이 앞 → 오래된 순으로
|
||
opens = [float(b.get("stck_oprc", 0)) for b in bars]
|
||
closes = [float(b.get("stck_clpr", 0)) for b in bars]
|
||
highs = [float(b.get("stck_hgpr", 0)) for b in bars]
|
||
lows = [float(b.get("stck_lwpr", 0)) for b in bars]
|
||
volumes = [int(b.get("acml_vol", 0)) for b in bars]
|
||
|
||
if not closes or closes[-1] <= 0:
|
||
continue
|
||
scan_count += 1
|
||
|
||
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)
|
||
bb = calculate_bollinger(closes, period=20)
|
||
if bb is None:
|
||
continue
|
||
bb_upper, bb_middle, bb_lower = bb
|
||
adx = calculate_adx(highs, lows, closes, period=14)
|
||
atr = calculate_atr(highs, lows, closes, period=14) or 0.0
|
||
|
||
signal = check_range_buy_signal(
|
||
highs=highs, lows=lows, closes=closes, volumes=volumes,
|
||
current_close=current_close, current_volume=current_volume,
|
||
rsi=rsi, bb_upper=bb_upper, bb_middle=bb_middle, bb_lower=bb_lower,
|
||
adx=adx, rsi_prev=rsi_prev, opens=opens,
|
||
)
|
||
if not signal:
|
||
await asyncio.sleep(0.3) # KIS API 레이트 리밋
|
||
continue
|
||
|
||
stops = calculate_range_stop_loss(
|
||
entry_price=current_close, atr=atr, box_low=signal["box_low"],
|
||
)
|
||
range_stocks.append({
|
||
"stock_code": stock.stock_code,
|
||
"stock_name": stock.stock_name,
|
||
"current_price": int(current_close),
|
||
"score": 5.0,
|
||
# signals: trade_executor 의 BUY_KEYWORDS/STRONG_BUY_KEYWORDS 매칭용.
|
||
# 레인지 진입은 'BB 하단 터치 + RSI 바닥 탈출 반등' 과 동일 성격이다.
|
||
"signals": [
|
||
BuySignal.볼린저하한선.value,
|
||
BuySignal.RSI바닥탈출.value,
|
||
BuySignal.횡보장평균회귀.value,
|
||
],
|
||
"signal": signal["description"],
|
||
"strategy_type": "swing", # 스윙 예산/청산 파이프라인 공유
|
||
"strategy_name": RANGE_TRADE_STRATEGY_NAME, # ActiveTrade.strategy_name
|
||
"entry_reason": f"[{RANGE_TRADE_STRATEGY_NAME}] {signal['description']}",
|
||
"stop_loss": stops["stop_loss_pct"], # 음수 보장 (-abs)
|
||
"take_profit": max(
|
||
0.0,
|
||
(signal["target_price"] - current_close) / current_close * 100.0,
|
||
),
|
||
"atr": atr,
|
||
"closes": closes,
|
||
"rsi": rsi,
|
||
"bb": (bb_upper, bb_middle, bb_lower),
|
||
})
|
||
logger.info(
|
||
"[RangeTrade] 박스권 진입 시그널: %s %s — %s",
|
||
stock.stock_code, stock.stock_name, signal["description"],
|
||
)
|
||
await asyncio.sleep(0.3)
|
||
|
||
except Exception as e:
|
||
warn_throttled(logger, "entry_service:682", f"[RangeTrade] {stock.stock_code} 스캔 실패: {e}")
|
||
continue
|
||
|
||
if not range_stocks:
|
||
logger.debug("[RangeTrade] 시그널 없음")
|
||
return []
|
||
|
||
range_stocks = range_stocks[:remaining_slots]
|
||
|
||
# ── 진입 실행 ────────────────────────────────────────────────────────
|
||
# execute_auto_trade_background() 는 SIDEWAYS 의 max_trades=0 에서 즉시 종료하므로
|
||
# 종목별 execute_auto_trade() 를 직접 호출한다(상단 설계 결정 주석 참조).
|
||
# _regime_str="bear": _execute_buy 의 sideways 하드 차단을 피하면서 가장 보수적인
|
||
# 자본 한도(BEAR 30%)를 적용받는다. _position_multiplier 로 종목당 비중을 2%로 축소.
|
||
results: list[dict] = []
|
||
for stock_dict in range_stocks:
|
||
stock_dict["_regime_str"] = "bear"
|
||
stock_dict["_position_multiplier"] = float(settings.RANGE_TRADE_POSITION_MULTIPLIER)
|
||
try:
|
||
result = await execute_auto_trade(stock_dict, db)
|
||
except Exception as e:
|
||
logger.error(
|
||
f"[RangeTrade] {stock_dict.get('stock_code')} 진입 실행 오류: {e}",
|
||
exc_info=True,
|
||
)
|
||
continue
|
||
if isinstance(result, dict) and result.get("action") == "BUY":
|
||
results.append(result)
|
||
else:
|
||
logger.info(
|
||
"[RangeTrade] %s 진입 보류: action=%s reason=%s",
|
||
stock_dict.get("stock_code"),
|
||
(result or {}).get("action") if isinstance(result, dict) else "?",
|
||
(result or {}).get("reason", "미상") if isinstance(result, dict) else "?",
|
||
)
|
||
await asyncio.sleep(0.5) # KIS API 레이트 리밋
|
||
|
||
if results:
|
||
logger.info(f"[RangeTrade] {len(results)}건 진입 실행 완료")
|
||
return results
|