shuim/auto-stock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

매매전략 수정중

Browse Source
This commit is contained in:
shuim
2026-03-06 20:46:08 +09:00
parent 2b9a90a03f
commit 12460b7c9e
15 changed files with 752 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
backend/app/services/trade_executor.py
View File

@@ -1,3 +1,12 @@
"""자동매매 실행 엔진 (trade_executor.py)
흐름 요약:
execute_auto_trade_background() ← 추천 목록 수신
└─ execute_auto_trade() ← 종목별 공통 필터 (가격·MDD·신호 등)
├─ _execute_buy() ← 매수 로직 (급등체크→트렌드→포지션사이징→주문)
└─ _execute_sell() ← 매도 로직 (중복체크→주문→DB기록)
└─ _verify_and_sync_execution() ← 체결 확인·슬리피지 기록·부분체결 재주문
"""
import asyncio
import logging
import time
@@ -23,11 +32,35 @@ logger = logging.getLogger(__name__)
# ── 종목별 세마포어 — 동일 종목 동시 주문 방지 ────────────────────────────────
_order_semaphores: dict = {}
_SEMAPHORE_MAX_SIZE = 200
def _cleanup_semaphores() -> None:
"""세마포어 딕셔너리 크기가 임계값 초과 시 미사용 항목 제거.
[동작] sem._value == 1 이면 현재 아무도 잡고 있지 않은 상태(unlock).
장기 운영 시 거래된 적 있는 모든 종목 코드가 누적되는 것을 방지.
"""
if len(_order_semaphores) <= _SEMAPHORE_MAX_SIZE:
return # 임계값 이하 → 정리 불필요
to_delete = [
code for code, sem in _order_semaphores.items()
if sem._value == 1 # unlocked = 현재 사용 중 아님
]
for code in to_delete:
_order_semaphores.pop(code, None)
if to_delete:
logger.debug(f"[SEMAPHORE_CLEANUP] {len(to_delete)}개 세마포어 정리 (잔여: {len(_order_semaphores)})")
def _get_order_semaphore(stock_code: str) -> asyncio.Semaphore:
"""종목별 세마포어 반환. 없으면 생성."""
"""종목별 세마포어 반환. 없으면 생성. 크기 초과 시 미사용 항목 정리.
[동작] 동일 종목에 대해 동시에 2개 이상의 주문이 발생하지 않도록
asyncio.Semaphore(1) 으로 상호 배제. 코드 진입 시 lock → 완료 시 release.
"""
if stock_code not in _order_semaphores:
_cleanup_semaphores() # 200개 초과 시 미사용 세마포어 정리
_order_semaphores[stock_code] = asyncio.Semaphore(1)
return _order_semaphores[stock_code]
@@ -37,27 +70,35 @@ _ORDER_LOCK_TTL = 60 # seconds
async def _acquire_order_lock(stock_code: str, order_type: str) -> bool:
"""Redis SETNX 기반 분산락 획득. 성공 시 True."""
"""Redis SETNX 기반 분산락 획득. 성공 시 True.
[동작] Redis SET NX(NOT EXISTS) + EX(TTL 60초)로 원자적 락 설정.
- 동일 종목·방향의 주문이 이미 처리 중이면 False → 호출측에서 SKIP.
- Redis 미연결 시 True(락 없이 진행) — 이 경우 세마포어가 2차 방어.
"""
try:
from app.core.redis import get_redis
client = get_redis()
if not client:
return True # Redis 미연결 → 락 없이 진행
return True # Redis 미연결 → 락 없이 진행 (세마포어가 대신 보호)
key = f"order_lock:{stock_code}:{order_type}"
result = await client.set(key, "1", nx=True, ex=_ORDER_LOCK_TTL)
return result is True
return result is True # None이면 이미 키 존재 → 락 실패
except Exception as e:
logger.debug(f"[order_lock] 획득 오류 (패스): {e}")
return True
async def _release_order_lock(stock_code: str, order_type: str) -> None:
"""Redis 분산락 해제."""
"""Redis 분산락 해제.
[동작] finally 블록에서 반드시 호출 — 주문 성공/실패 관계없이 락 해제.
"""
try:
from app.core.redis import delete_key
await delete_key(f"order_lock:{stock_code}:{order_type}")
except Exception:
pass
pass # 해제 실패 시 TTL(60초) 만료 후 자동 해제됨
# ── 주문 재시도 — Exponential backoff (1→2→4초, 최대 3회) ───────────────────
@@ -70,28 +111,39 @@ async def _place_order_with_retry(
exchange_code: str = "NASD",
max_retries: int = 3,
) -> dict:
"""주문 실행 with exponential backoff. 시스템 오류에만 재시도."""
"""주문 실행 with exponential backoff. 시스템 오류에만 재시도.
[동작]
1. 국내/해외 분기 후 KIS REST API 호출
2. rt_cd "0"(성공) 또는 "1"(PENDING) → 즉시 반환 (재시도 불필요)
3. 그 외 오류: 1초→2초→4초 대기 후 최대 max_retries회 재시도
4. 최대 재시도 소진 시 last_result(마지막 응답) 반환
"""
last_result: dict = {}
for attempt in range(max_retries):
try:
if is_domestic:
# 국내 주식 주문 (KIS TTTC0012U / VTTC0012U)
result = await korea_investment_api.place_order(stock_code, order_type, quantity, price)
else:
# 해외 주식 주문 (KIS TTTT1002U 등)
result = await korea_investment_api.place_overseas_order(
stock_code, order_type, quantity, float(price), exchange_code
)
# rt_cd "0"=성공, "1"=PENDING → 재시도 불필요
if result.get("rt_cd") in ("0", "1"):
return result
# rt_cd 오류 → 재시도 대상
last_result = result
if attempt < max_retries - 1:
wait = 1 * (2 ** attempt) # 1s → 2s → 4s
wait = 1 * (2 ** attempt) # 1s → 2s → 4s (exponential backoff)
logger.warning(
f"[ORDER_RETRY] {stock_code} {order_type} rt_cd={result.get('rt_cd')} "
f"→ {wait}초 후 재시도 ({attempt + 1}/{max_retries})"
)
await asyncio.sleep(wait)
except Exception as e:
# 네트워크 타임아웃 등 예외 → 재시도 대상
last_result = {"rt_cd": "-1", "msg1": str(e), "odno": None}
if attempt < max_retries - 1:
wait = 1 * (2 ** attempt)
@@ -104,13 +156,19 @@ async def _place_order_with_retry(
# ── 미체결 주문 1분 후 자동 취소 ─────────────────────────────────────────────
async def _auto_cancel_if_pending(order_id: str, stock_code: str, quantity: int, delay: int = 60) -> None:
"""delay초 후에도 PENDING 상태면 자동 취소."""
await asyncio.sleep(delay)
"""delay초 후에도 PENDING 상태면 자동 취소.
[동작] 주문 후 delay(기본 60초)를 기다린 뒤 KIS 취소 API 호출.
이미 체결됐다면 취소 실패(msg1에 오류 메시지) → DEBUG 로그만 남기고 무시.
호출 측에서 asyncio.create_task() 로 백그라운드 실행.
"""
await asyncio.sleep(delay) # 60초 대기 후 취소 시도
try:
result = await korea_investment_api.cancel_order(order_id, quantity)
if result.get("rt_cd") == "0":
logger.info(f"[AUTO_CANCEL] 미체결 자동 취소 완료: {stock_code} order_id={order_id}")
else:
# 이미 체결됐거나 취소 불가 상태 → 무시
logger.debug(f"[AUTO_CANCEL] {stock_code} — {result.get('msg1')} (이미 체결됐을 수 있음)")
except Exception as e:
logger.debug(f"[AUTO_CANCEL] {stock_code} — {type(e).__name__}: {e}")
@@ -122,13 +180,18 @@ _ACCOUNT_CACHE_TTL = 30 # seconds
def _get_cached_account() -> tuple | None:
"""(available_cash, total_assets) 30초 캐시. 만료 시 None 반환."""
"""(available_cash, total_assets) 30초 캐시. 만료 시 None 반환.
[동작] monotonic clock으로 TTL 검사. 만료되지 않았으면 캐시 반환,
만료됐거나 데이터가 없으면 None → 호출측에서 portfolio_cache 재조회.
"""
if _account_cache["data"] and time.monotonic() - _account_cache["ts"] < _ACCOUNT_CACHE_TTL:
return _account_cache["data"]
return None
def _set_account_cache(available_cash: float, total_assets: float) -> None:
"""계좌 캐시 갱신. 현재 시각(monotonic)을 타임스탬프로 저장."""
_account_cache["data"] = (available_cash, total_assets)
_account_cache["ts"] = time.monotonic()
@@ -162,9 +225,14 @@ async def _calculate_kelly_position(
"""Kelly Criterion 기반 최적 포지션 사이징 (Half-Kelly 적용).
f* = (p*b - (1-p)) / b
- p: 최근 N거래 승률
- b: 평균이익률 / 평균손실률
데이터 부족(< 5개)이면 0.0 반환 → 호출측에서 v2 fallback.
- p: 최근 N거래 승률 (이긴 거래 수 / 전체 거래 수)
- b: 평균이익률 / 평균손실률 (Payoff Ratio)
- Half-Kelly: f* / 2 → 변동성 감소 목적
[동작]
1. DB에서 최근 lookback회 매도 체결 기록 조회
2. 5거래 미만이면 통계 신뢰 부족 → 0.0 반환 (호출측에서 v2 fallback)
3. 반환값 = min(total_assets×clamped, available_cash, max_per_position 한도)
"""
try:
recent = await db.execute(
@@ -180,19 +248,19 @@ async def _calculate_kelly_position(
)
trades = recent.scalars().all()
if len(trades) < 5:
return 0.0
return 0.0 # 데이터 부족 → v2 fallback
rates = [float(t.profit_loss_rate) for t in trades]
wins = [r for r in rates if r > 0]
losses = [abs(r) for r in rates if r < 0]
wins = [r for r in rates if r > 0] # 수익 거래 목록
losses = [abs(r) for r in rates if r < 0] # 손실 거래 절대값 목록
if not wins or not losses:
return 0.0
return 0.0 # 전승 또는 전패 → Kelly 계산 불가
p = len(wins) / len(rates)
b = (sum(wins) / len(wins)) / (sum(losses) / len(losses))
kelly_f = (p * b - (1 - p)) / b
half_kelly = max(0.0, kelly_f / 2)
clamped = min(half_kelly, max_per_position)
p = len(wins) / len(rates) # 승률
b = (sum(wins) / len(wins)) / (sum(losses) / len(losses)) # Payoff Ratio
kelly_f = (p * b - (1 - p)) / b # Kelly 공식
half_kelly = max(0.0, kelly_f / 2) # Half-Kelly (보수적)
clamped = min(half_kelly, max_per_position) # 종목당 최대 4% 상한 적용
return min(total_assets * clamped, available_cash, total_assets * max_per_position)
except Exception as e:
logger.debug(f"[kelly] {stock_code} 계산 오류: {type(e).__name__}: {e}")
@@ -212,19 +280,33 @@ async def _verify_and_sync_execution(
db_trade_id: int,
delay: int = 3,
) -> None:
"""주문 후 KIS 체결 내역 조회 → DB 업데이트 + 슬리피지 기록 + 부분 체결 재주문."""
await asyncio.sleep(delay)
"""주문 후 KIS 체결 내역 조회 → DB 업데이트 + 슬리피지 기록 + 부분 체결 재주문.
[동작 흐름]
1. delay초 대기 (체결 확인 전 KIS 서버 처리 시간 확보)
2. KIS 체결 조회 API 호출 → filled_qty, filled_price 추출
3. 슬리피지 계산: (체결가 - 주문가) / 주문가 × 100
4. 별도 AsyncSessionLocal 세션으로 TradeHistory 업데이트
- 완전 체결(filled_qty == ordered_quantity) → status = "COMPLETED"
- 부분 체결(filled_qty < ordered_quantity) → status = "PARTIAL" + 잔여 재주문
5. 포트폴리오 동기화 트리거
주의: 호출측 db 세션과 분리된 별도 세션을 사용 (cross-session 충돌 방지).
"""
await asyncio.sleep(delay) # KIS 서버 체결 처리 대기
if not order_id:
# order_id 없으면 체결 조회 불가 → 포트폴리오 동기화만 수행
await _delayed_sync_portfolio(0)
return
try:
# KIS 체결 내역 조회 (TR: TTTC8001R / VTTC8001R)
exec_result = await korea_investment_api.get_order_execution(order_id, is_domestic)
filled_qty = int(exec_result.get("filled_qty", 0))
filled_price = float(exec_result.get("filled_price", order_price) or order_price)
# ── 슬리피지 계산 및 로깅 ─────────────────────────────────────────────
# ── 슬리피지 계산: (체결가 - 주문가) / 주문가 × 100 ─────────────────
slippage_pct = 0.0
if order_price > 0 and filled_price > 0:
slippage_pct = ((filled_price - order_price) / order_price) * 100
@@ -234,7 +316,7 @@ async def _verify_and_sync_execution(
f"슬리피지={slippage_pct:+.3f}%"
)
# ── DB 업데이트 (별도 세션) ───────────────────────────────────────────
# ── DB 업데이트 (별도 세션으로 호출측 세션과 격리) ───────────────────
if filled_qty > 0:
async with AsyncSessionLocal() as session:
row = await session.execute(
@@ -242,7 +324,7 @@ async def _verify_and_sync_execution(
)
trade = row.scalar_one_or_none()
if trade:
partial = filled_qty < ordered_quantity
partial = filled_qty < ordered_quantity # 부분 체결 여부
trade.executed_quantity = filled_qty
trade.executed_price = Decimal(str(filled_price))
trade.status = "PARTIAL" if partial else "COMPLETED"
@@ -257,6 +339,7 @@ async def _verify_and_sync_execution(
f"[PARTIAL_FILL] {stock_code} {order_type} "
f"{filled_qty}/{ordered_quantity}주 체결 → 잔여 {remain}주 재주문"
)
# 재주문은 백그라운드 태스크로 분리 (현재 흐름 블록 방지)
asyncio.create_task(
_reorder_unfilled(
stock_code=stock_code,
@@ -269,14 +352,14 @@ async def _verify_and_sync_execution(
)
)
await _delayed_sync_portfolio(0)
await _delayed_sync_portfolio(0) # KIS 잔고 기준으로 포트폴리오 재동기화
except Exception as e:
logger.warning(
f"[VERIFY_EXEC] {stock_code} {order_type} 체결 확인 실패 — "
f"{type(e).__name__}: {e} (포트폴리오 동기화만 실행)"
)
await _delayed_sync_portfolio(0)
await _delayed_sync_portfolio(0) # 체결 확인 실패해도 포트폴리오는 동기화
# ── 부분 체결 후 미체결 수량 재주문 ──────────────────────────────────────────
@@ -410,6 +493,7 @@ async def _execute_buy(
return {"action": "HOLD", "stock": stock_name, "reason": "trend_filter_error"}
# ── 3. 현금·자산 조회 (30초 캐시 활용) ──────────────────────────────────
# KIS API 호출을 줄이기 위해 인메모리 캐시(TTL 30초) 우선 사용
cached = _get_cached_account()
if cached:
available_cash, total_assets = cached
@@ -422,9 +506,10 @@ async def _execute_buy(
except Exception:
available_cash, total_assets = 0.0, 0.0
daily_cutoff = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0)
daily_cutoff = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0) # 오늘 00:00:00 KST
# ── 4. PENDING 포함 오늘 중복 주문 차단 ──────────────────────────────────
# 오늘 이미 BUY 주문이 있으면(COMPLETED 또는 PENDING 상태) 재진입 방지
pending_check = await db.execute(
select(TradeHistory).where(
TradeHistory.stock_code == stock_code,
@@ -436,7 +521,8 @@ async def _execute_buy(
if pending_check.scalars().first():
return {"action": "SKIP", "stock": stock_name, "reason": "already_ordered_today"}
# ── 5. 일 매수 횟수 제한 (settings 기반) ─────────────────────────────────
# ── 5. 일 매수 횟수 제한 (settings.MAX_DAILY_BUYS_PER_STOCK) ─────────────
# 종목당 당일 최대 매수 횟수를 초과하면 추가 매수 차단
daily_buy_check = await db.execute(
select(TradeHistory).where(
TradeHistory.stock_code == stock_code,
@@ -449,10 +535,12 @@ async def _execute_buy(
return {"action": "HOLD", "stock": stock_name, "reason": "daily_trade_limit"}
# ── 6. 쿨다운 체크 (ATR 기반 동적) ──────────────────────────────────────
# ATR%가 높을수록(고변동) 쿨다운 단축 → max(15, 30 - atr_pct×3)분
# 예: ATR% = 5% → 쿨다운 = max(15, 30-15) = 15분
# ATR% = 1% → 쿨다운 = max(15, 30-3) = 27분
atr_val = float(stock.get("atr", 0) or 0)
if atr_val > 0 and current_price > 0:
atr_pct = atr_val / current_price * 100
# 고변동(ATR% > 3%) → 쿨다운 단축, 저변동 → 기본 30분
cooldown_min = max(15, int(30 - atr_pct * 3))
else:
cooldown_min = int(stock.get("add_buy_cooldown_min", 30) or 30)
@@ -465,13 +553,15 @@ async def _execute_buy(
TradeHistory.status.in_(["EXECUTED", "COMPLETED"]),
TradeHistory.created_at >= daily_cutoff,
)
.order_by(desc(TradeHistory.created_at))
.order_by(desc(TradeHistory.created_at)) # 가장 최근 매수부터
)
recent_buys = cooldown_check.scalars().all()
# 마지막 매수 이후 쿨다운 시간이 지나지 않았으면 HOLD
if recent_buys and (_get_kst_now() - recent_buys[0].created_at).total_seconds() < cooldown_min * 60:
return {"action": "HOLD", "stock": stock_name, "reason": "cooldown"}
# ── 7. 포지션 사이징 (Kelly 우선, v2 fallback) ────────────────────────────
# 우선순위: Half-Kelly → calculate_position_size_v2 → available_cash×4%
current_value = float(holding.quantity * current_price) if holding else 0.0
regime_str = stock.get("_regime_str", "bear")
regime = MarketRegime.BULL if regime_str == "bull" else MarketRegime.BEAR
@@ -480,7 +570,7 @@ async def _execute_buy(
db, stock_code, total_assets, available_cash
)
if invest_amount <= 0:
# Kelly 데이터 부족 → v2 fallback
# Kelly 데이터 부족(5거래 미만) → 전략 v2 fallback
invest_amount = calculate_position_size_v2(
total_assets=total_assets,
available_cash=available_cash,
@@ -489,20 +579,25 @@ async def _execute_buy(
rsi=stock.get("rsi"),
adx=stock.get("adx_14"),
)
if invest_amount <= 0 and total_assets <= 0:
if invest_amount <= 0:
# v2도 0 반환 시(현금 부족 등) → 가용현금의 4% 최소 배분
invest_amount = available_cash * 0.04
# 투자금액 → 주수 환산 (Decimal 사용으로 부동소수점 오차 방지)
quantity = int(Decimal(str(invest_amount)) / Decimal(str(current_price)))
if quantity <= 0:
return {"action": "SKIP", "reason": "quantity_zero", "stock": stock_name}
# ── 8. Redis 분산락 획득 ──────────────────────────────────────────────────
# 여러 워커/프로세스가 동시에 같은 종목을 매수하는 것을 방지
if not await _acquire_order_lock(stock_code, "BUY"):
return {"action": "SKIP", "stock": stock_name, "reason": "order_lock_busy"}
# ── 9. 주문 실행 (종목별 세마포어 + 재시도) ───────────────────────────────
# 세마포어: 단일 프로세스 내 동일 종목 동시 주문 방지
# 재시도: exponential backoff (1→2→4초, 최대 3회)
try:
order_price = _adjust_order_price(current_price, "BUY", is_domestic)
order_price = _adjust_order_price(current_price, "BUY", is_domestic) # +0.5% 체결률 향상
async with _get_order_semaphore(stock_code):
order_result = await _place_order_with_retry(
is_domestic=is_domestic,
@@ -515,10 +610,11 @@ async def _execute_buy(
total_amount = Decimal(str(current_price)) * quantity
entry_reason = f"매수 신호: {', '.join(signals[:3])}. 점수: {score_val}점"
success = order_result.get("rt_cd") == "0"
is_pending = order_result.get("rt_cd") == "1"
success = order_result.get("rt_cd") == "0" # KIS 성공 코드
is_pending = order_result.get("rt_cd") == "1" # 주문접수(체결 미확인)
status = "COMPLETED" if success else ("PENDING" if is_pending else "FAILED")
# TradeHistory DB 기록 (flush로 id 확보 후 commit)
trade = TradeHistory(
rule_id=stock.get("rule_id"),
stock_code=stock_code,
@@ -538,16 +634,18 @@ async def _execute_buy(
executed_at=_get_kst_now() if success else None,
)
db.add(trade)
await db.flush() # id 확보
await db.flush() # auto-increment id 확보 (commit 전에 id 필요)
trade_id = trade.id
await db.commit()
if success:
# 인메모리 포트폴리오 캐시 즉시 반영 (UI 실시간 업데이트)
try:
from app.api.endpoints.portfolio import portfolio_cache
portfolio_cache.apply_buy(stock_code, stock_name, quantity, current_price)
except Exception:
pass
# 3초 후 KIS 체결 확인 → 슬리피지 기록 + 부분체결 재주문 (백그라운드)
asyncio.create_task(
_verify_and_sync_execution(
order_id=order_result.get("odno", ""),
@@ -563,6 +661,7 @@ async def _execute_buy(
)
)
elif is_pending:
# PENDING(주문접수) 상태이면 60초 후 미체결 자동 취소 시도
order_id_val = order_result.get("odno")
if order_id_val:
asyncio.create_task(_auto_cancel_if_pending(order_id_val, stock_code, quantity))
@@ -596,10 +695,21 @@ async def _execute_sell(
stock_code: str,
stock_name: str,
) -> dict:
"""SELL 주문 실행 로직 — 중복체크 → semaphore → 주문 → TradeHistory → 체결 확인."""
"""SELL 주문 실행 로직 — 중복체크 → semaphore → 주문 → TradeHistory → 체결 확인.
quantity = holding.quantity
[동작 흐름]
1. 현재 손익률 계산 (현재가 vs 평균매입가)
2. ATR 기반 동적 손절선·트레일링스탑 재계산
3. Redis 분산락 획득 → 중복 매도 방지
4. 30초 이내 동일 종목 SELL 기록 확인 (FAILED 제외)
5. 지정가 -0.5% 조정 후 KIS SELL 주문
6. TradeHistory DB 기록 (flush → id 확보 → commit)
7. 성공 시: 포트폴리오 캐시 즉시 제거 + 체결 확인 백그라운드 태스크
"""
quantity = holding.quantity # 보유 전량 매도
_avg = float(holding.average_price or 0)
# 손익률: (현재가 - 평균매입가) / 평균매입가 × 100
profit_loss_rate = (
((current_price - _avg) / _avg) * 100 if _avg > 0
else float(holding.profit_loss_rate or 0)
@@ -607,31 +717,35 @@ async def _execute_sell(
take_profit = stock.get("take_profit", 3.0)
stop_loss = stock.get("stop_loss", -1.5)
# ATR 기반 동적 손절/트레일링 스탑 조정
# ── ATR 기반 동적 손절/트레일링 스탑 조정 ────────────────────────────────
# ATR 손절선 = 평균매입가 - 2.5×ATR (기본 손절보다 유리한 쪽 사용)
# 트레일링스탑 = 고점 - 1.5×ATR (수익 실현 구간에서만 적용)
atr = float(stock.get("atr", 0) or 0)
_avg_price = float(holding.average_price or 0)
exit_reason_detail = f"손익률 {profit_loss_rate:.2f}%"
if atr > 0 and _avg_price > 0:
atr_stop_price = _avg_price - 2.5 * atr
atr_stop_price = _avg_price - 2.5 * atr # ATR 기반 손절가
atr_stop_pct = ((atr_stop_price / _avg_price) - 1) * 100
stop_loss = max(stop_loss, atr_stop_pct)
stop_loss = max(stop_loss, atr_stop_pct) # 기본 손절 vs ATR 손절 중 유리한 쪽
high_price = float(stock.get("high_price") or current_price)
trailing_stop_price = high_price - 1.5 * atr
trailing_stop_price = high_price - 1.5 * atr # 고점 기준 트레일링스탑
if current_price <= trailing_stop_price and profit_loss_rate > 0:
exit_reason_detail = f"ATR 트레일링 스탑: {current_price:.0f} ≤ {trailing_stop_price:.0f} | {exit_reason_detail}"
# Redis 분산락 획득
# Redis 분산락 획득 — 여러 워커가 동시에 같은 종목을 매도하는 것을 방지
if not await _acquire_order_lock(stock_code, "SELL"):
return {"action": "SKIP", "stock": stock_name, "reason": "order_lock_busy"}
try:
# ── 1. 중복 주문 체크 (10초 이내) ────────────────────────────────────
recent_cutoff = _get_kst_now() - timedelta(seconds=10)
# ── 1. 중복 주문 체크 (30초 이내, FAILED 제외) ───────────────────────
# FAILED 주문은 제외하여 오류 이후 재매도 허용
recent_cutoff = _get_kst_now() - timedelta(seconds=30)
duplicate_check = await db.execute(
select(TradeHistory).where(
TradeHistory.stock_code == stock_code,
TradeHistory.order_type == "SELL",
TradeHistory.status.in_(["COMPLETED", "PARTIAL", "PENDING"]),
TradeHistory.created_at >= recent_cutoff,
)
)
@@ -639,7 +753,7 @@ async def _execute_sell(
return {"action": "SKIP", "reason": "duplicate_order", "stock": stock_name}
# ── 2. 주문 실행 (종목별 세마포어 + 재시도) ──────────────────────────
order_price = _adjust_order_price(current_price, "SELL", is_domestic)
order_price = _adjust_order_price(current_price, "SELL", is_domestic) # -0.5% 체결률 향상
async with _get_order_semaphore(stock_code):
order_result = await _place_order_with_retry(
is_domestic=is_domestic,
@@ -651,11 +765,12 @@ async def _execute_sell(
)
total_amount = Decimal(str(current_price)) * quantity
profit_loss = (current_price - float(holding.average_price or current_price)) * quantity
profit_loss = (current_price - float(holding.average_price or current_price)) * quantity # 절대 손익금액
success = order_result.get("rt_cd") == "0"
is_pending = order_result.get("rt_cd") == "1"
status = "COMPLETED" if success else ("PENDING" if is_pending else "FAILED")
# TradeHistory DB 기록
trade = TradeHistory(
rule_id=stock.get("rule_id"),
stock_code=stock_code,
@@ -677,11 +792,12 @@ async def _execute_sell(
executed_at=_get_kst_now() if success else None,
)
db.add(trade)
await db.flush() # id 확보
await db.flush() # auto-increment id 확보
trade_id = trade.id
await db.commit()
if success:
# 인메모리 포트폴리오 캐시에서 해당 종목 즉시 제거 (UI 실시간 반영)
try:
from app.api.endpoints.portfolio import portfolio_cache
avg = float(holding.average_price or current_price)
@@ -691,6 +807,7 @@ async def _execute_sell(
]
except Exception:
pass
# 3초 후 KIS 체결 확인 (슬리피지 기록 포함)
asyncio.create_task(
_verify_and_sync_execution(
order_id=order_result.get("odno", ""),
@@ -706,6 +823,7 @@ async def _execute_sell(
)
)
elif is_pending:
# PENDING 상태 → 60초 후 미체결 자동 취소 시도
order_id_val = order_result.get("odno")
if order_id_val:
asyncio.create_task(_auto_cancel_if_pending(order_id_val, stock_code, quantity))
@@ -730,7 +848,15 @@ async def _execute_sell(
async def execute_auto_trade_background(recommendations_response: dict, db: AsyncSession):
"""recommendations_response dict 에서 추천 종목을 꺼내 자동매매 실행."""
"""recommendations_response dict 에서 추천 종목을 꺼내 자동매매 실행.
[동작 흐름]
1. 시장 국면(BEAR_MARKET_FILTER) 조회 → 최대 거래 수·포지션 배율 결정
2. recommendations_by_rule 그룹을 단일 unique_stocks dict로 정규화
- 동일 종목이 여러 룰에 걸리면 우선순위(rule_priority) 낮은 쪽 유지
3. (rule_priority ASC, score DESC)로 정렬 → 상위 max_trades개 처리
4. 종목별 execute_auto_trade() 호출 (0.5초 간격 → KIS API 레이트 리밋 준수)
"""
if not isinstance(recommendations_response, dict):
logger.error("[AUTO_TRADE_BG] recommendations_response is not a dict: %r", recommendations_response)
return
@@ -739,6 +865,7 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
total_processed = 0
trade_results = []
# 시장 국면 조회 (BEAR 시 max_trades 축소, position_multiplier 감소)
market_regime = None
if settings.BEAR_MARKET_FILTER_ENABLED:
market_regime = await check_market_regime()
@@ -748,8 +875,9 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
max_trades = min(20, regime_max_trades)
result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
held_stocks = {p.stock_code for p in result.scalars().all()}
held_stocks = {p.stock_code for p in result.scalars().all()} # 현재 보유 종목 집합
# recommendations_by_rule 정규화 (list 또는 dict 모두 처리)
rec_groups = recommendations_response.get("recommendations_by_rule", [])
if isinstance(rec_groups, dict):
normalized_list = []
@@ -760,6 +888,7 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
normalized_list.append({"rule_name": name, "stocks": group})
rec_groups = normalized_list
# 종목 코드 기준으로 중복 제거 (rule_priority 낮은 쪽 = 더 중요한 규칙 우선)
unique_stocks: dict = {}
for rule_group in rec_groups:
if not isinstance(rule_group, dict):
@@ -777,8 +906,9 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
if stock_code not in unique_stocks:
unique_stocks[stock_code] = stock
elif stock.get("rule_priority", 999) < unique_stocks[stock_code].get("rule_priority", 999):
unique_stocks[stock_code] = stock
unique_stocks[stock_code] = stock # 더 높은 우선순위 룰로 교체
# 우선순위↑(숫자↓), 점수↓ 순으로 정렬 후 max_trades개만 처리
sorted_stocks = sorted(
unique_stocks.values(),
key=lambda s: (s.get("rule_priority", 999), -s.get("score", 0)),
@@ -789,7 +919,7 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
logger.warning("[AUTO_TRADE_BG] Skipping invalid stock entry: %r", stock)
continue
try:
stock["_position_multiplier"] = position_multiplier
stock["_position_multiplier"] = position_multiplier # 국면별 배율 주입
stock["_regime_str"] = (
market_regime.get("regime_200d", "bear") if market_regime else "bear"
)
@@ -799,7 +929,7 @@ async def execute_auto_trade_background(recommendations_response: dict, db: Asyn
if result["action"] in ["BUY", "SELL"]:
trade_results.append(result)
await asyncio.sleep(0.5)
await asyncio.sleep(0.5) # KIS API 레이트 리밋: 초당 2회 이하 권장
except Exception as e:
logger.error(f"[AUTO_TRADE_BG] {stock.get('stock_code')} 처리 오류: {type(e).__name__}: {e}")
@@ -839,6 +969,19 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
공통 필터(가격·MDD·손실추적·보유수·당일매도쿨다운·신호분석)를 통과한 후
_execute_buy / _execute_sell 에 위임한다.
[필터 체크 순서]
1. 유효성 검사 (stock_code, current_price)
2. 국내/해외 구분 (stock_code 6자리 숫자 → 국내)
3. 가격 필터 (국내 5,000원↑ / 미국 $4↑)
4. MDD 일시정지 여부 (MDD < -10% 시 신규진입 중단)
5. 연속손실 밴 여부 (3회 연속 손실 → 30일 진입 금지)
6. 최대 보유 종목 수 초과 여부 (settings.MAX_HOLDINGS_COUNT)
7. 당일 매도 후 재매수 쿨다운 (당일 SELL COMPLETED 기록 존재 시 재매수 금지)
8. 신호 분석: BUY_KEYWORDS / SELL_KEYWORDS / BLOCK_KEYWORDS 매칭
9. ML 가중치 통합 (ML_ENSEMBLE_ENABLED 시 rule 40% + ML 60% 합산)
10. ATR 강제 손절 (신호 없어도 현재가 ≤ avg - 2.5×ATR 이면 강제 매도)
11. _execute_buy 또는 _execute_sell 위임
"""
try:
stock_code = stock.get("stock_code")
@@ -849,6 +992,7 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
if not stock_code or current_price <= 0:
return {"action": "SKIP", "reason": "invalid_data"}
# 국내(6자리 숫자) vs 해외 판별
is_domestic = stock_code.isdigit() and len(stock_code) == 6
exchange_code = stock.get("exchange_code", "NASD")
@@ -862,22 +1006,26 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
# ── MDD / 손실추적 / 보유수 ──────────────────────────────────────────
if not await mdd_manager.can_open_new_position():
# MDD -10% 이상 낙폭 → 신규 진입 중단
return {"action": "SKIP", "reason": "mdd_pause", "stock": stock_name}
if loss_tracker.is_banned(stock_code):
# 3회 연속 손실 종목 → 30거래일 진입 금지
return {"action": "SKIP", "reason": "consecutive_loss_ban", "stock": stock_name}
held_result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
if len(held_result.scalars().all()) >= settings.MAX_HOLDINGS_COUNT:
# 동시 보유 20종목 한도 초과
return {"action": "SKIP", "reason": "max_holdings_reached", "stock": stock_name}
# ── 당일 매도 후 재매수 쿨다운 ───────────────────────────────────────
# 당일 이미 SELL 체결된 종목은 당일 재매수 금지 (섹션 4.3)
cutoff_time = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0)
recent_sell = await db.execute(
select(TradeHistory).where(
TradeHistory.stock_code == stock_code,
TradeHistory.order_type == "SELL",
TradeHistory.status == "EXECUTED",
TradeHistory.status.in_(["COMPLETED", "PARTIAL"]),
TradeHistory.executed_at >= cutoff_time,
)
)
@@ -891,7 +1039,7 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
Portfolio.quantity > 0,
)
)
holding = result.scalar_one_or_none()
holding = result.scalar_one_or_none() # None이면 신규매수, 있으면 추가매수/매도 판단
# ── 신호 분석 (Enum 기반) ─────────────────────────────────────────────
text_signals = " ".join(signals)
@@ -900,16 +1048,21 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
except Exception:
score_val = 0.0
# "거래량부족" 신호 제거 후 매수 판단 (거래량 부족 단독으로는 매수 차단)
signals_without_volume_weak = [s for s in signals if "거래량부족" not in s]
text_signals_filtered = " ".join(signals_without_volume_weak)
should_buy = any(k in text_signals_filtered for k in BUY_KEYWORDS)
if not signals_without_volume_weak and signals:
should_buy = False
should_buy = False # 거래량부족 신호만 있으면 매수 금지
should_sell = any(k in text_signals for k in SELL_KEYWORDS)
# ── ML 가중치 통합 (60% ML + 40% 규칙) ──────────────────────────────
# ── ML 가중치 통합 (기본: 규칙 30% + ML 70%) ─────────────────────────
# weighted_score = score × RULE_WEIGHT + ml_score × ML_WEIGHT
# ML BUY: weighted_score ≥ threshold AND confidence ≥ min → should_buy = True
# ML SELL: confidence ≥ 0.5 → should_sell = True
# ML HOLD: weighted_score 낮으면 should_buy = False 강제
ml_score_trade = stock.get("ml_score")
ml_confidence_trade = stock.get("ml_confidence")
ml_signal_trade = stock.get("ml_signal")
@@ -932,12 +1085,13 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
ml_signal_trade == "HOLD"
and weighted_score < settings.ML_ENSEMBLE_BUY_THRESHOLD * 0.7
):
should_buy = False
should_buy = False # ML이 HOLD 강하게 권고 시 매수 억제
except Exception as e:
logger.debug(f"[ML_WEIGHT] {stock_code} 가중치 계산 오류: {e}")
has_rule = stock.get("rule_id") is not None
if has_rule:
# 규칙 기반 종목: BLOCK 신호만 없으면 should_buy = True (규칙 자체가 매수 신호)
if any(b in text_signals for b in BLOCK_KEYWORDS):
return {"action": "HOLD", "stock": stock_name, "reason": "disparity_overheated"}
@@ -945,16 +1099,19 @@ async def execute_auto_trade(stock: dict, db: AsyncSession):
if not ml_hold_active:
should_buy = True
else:
# 비규칙 종목: BLOCK 신호 있으면 과열 HOLD
if any(b in text_signals for b in BLOCK_KEYWORDS):
return {"action": "HOLD", "stock": stock_name, "reason": "overheat_no_rule"}
if should_buy and not has_rule:
# 비규칙 종목: 강한 신호 OR (신호 2개 이상 AND 점수 2점 이상) 필수
has_strong_signal = any(k in text_signals_filtered for k in STRONG_BUY_KEYWORDS)
matched_count = sum(1 for k in BUY_KEYWORDS if k in text_signals_filtered)
if not has_strong_signal and (matched_count < 2 or score_val < 2):
should_buy = False
# ── ATR 기반 강제 손절 (신호 없어도 발동) ────────────────────────────
# 현재가가 평균매입가 - 2.5×ATR 이하이면 매도 신호 없어도 강제 손절
if holding and not should_sell:
atr = float(stock.get("atr", 0) or 0)
avg_price = float(holding.average_price or 0)