shuim
a264561576
- 스윙 체결가 확인 전 executed_price NULL + fill_sweep, 진입가 resolve(ActiveTrade↔Portfolio), 0체결/부분체결 매수 장부 원복 - DT 고아 감지(근거 한정)·0체결 매도 복원·stale 점검 확대, 시간손절 -0.3% 원복 - 폴백 손절 ATR 캐시, 거래량부족-차단 신호 매수 차단, 현금 5% 유보 재적용, MDD peak/reset 수정 - KIS 서킷브레이커 청산 우회·경보, db_worker 재큐잉 순서, heartbeat·health-watch 사이드카 - 실시간 WS 재구독·41건 우선순위·다건 프레임 분할, 차트 샘플 제거·당일봉 합성, WS 서브프로토콜 인증 - 프론트: 미관리 그룹·확인 모달·차트 실시간 반영·예수금 표시 정정 - 전문가 에이전트 6종 추가(.claude/agents) - 유닛 스위트 2667 passed (소켓 차단 하), tsc OK Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Y83Za98XsNw9zuA4FTUytN
4577 lines
248 KiB
Python
4577 lines
248 KiB
Python
"""자동매매 실행 엔진 (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 re
|
||
import time
|
||
from decimal import Decimal
|
||
from datetime import datetime, timedelta
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from sqlalchemy import select, desc, and_, or_, func
|
||
|
||
from app.core.config import settings
|
||
from app.core.database import AsyncSessionLocal
|
||
from app.models.models import TradeHistory, Portfolio
|
||
from app.services.korea_investment_api import korea_investment_api
|
||
from app.services.mdd_manager import mdd_manager
|
||
from app.services.loss_tracker import loss_tracker
|
||
from app.services.market_analyzer import check_market_regime, _get_kst_now
|
||
from app.services.mean_reversion_strategy import (
|
||
MarketRegime, calculate_position_size_v2,
|
||
check_exit_signal, calculate_rsi, calculate_bollinger, calculate_atr,
|
||
)
|
||
from app.services.technical_indicators import (
|
||
TREND_FILTER_ENABLED, TREND_MA_SHORT, TREND_MA_LONG, TREND_TOLERANCE_PCT, _ma, _ema,
|
||
)
|
||
# §8.5-2 포지션 사이징 단일 출처 (순수 계산 모듈 — settings/DB/네트워크 없음)
|
||
from app.services.sizing_core import (
|
||
amount_to_quantity, clamp_by_ratios, effective_min_buy_amount, half_kelly_fraction,
|
||
remaining_position_room,
|
||
)
|
||
from app.services.signal_types import BUY_KEYWORDS, SELL_KEYWORDS, STRONG_BUY_KEYWORDS, BLOCK_KEYWORDS
|
||
from app.services.correlation_filter import validate_correlation_filter
|
||
from app.services.exchange_detector import is_us_stock, detect_exchange, get_market_info
|
||
from app.core.timeutil import now_kst
|
||
from app.services.trade_helpers import (
|
||
check_opening_range_volatility, check_surge_prevention, check_trend_filter,
|
||
calculate_cooldown_minutes, get_daily_cutoff_utc, get_leverage_check_keywords,
|
||
is_leverage_etf, calculate_profit_loss_rate, calculate_atr_based_stops,
|
||
build_kis_order_id, calculate_trade_costs,
|
||
)
|
||
|
||
from app.core.log_throttle import warn_throttled # noqa: E402
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
# ── 잔량 추적 해석 (CLAUDE.md §8.5 항목4) ─────────────────────────────────────
|
||
def _resolve_remaining_pct_v2(stock: dict, holding=None) -> tuple[float, bool]:
|
||
"""remaining_pct 와 '잔량 추적 가능 여부' 를 함께 반환.
|
||
|
||
기존 `stock.get("remaining_pct", 1.0) or 1.0` 은 '추적 소스 없음(None)' 과
|
||
'실제로 잔량 100%' 를 구분하지 못했다. ActiveTrade 행이 없는 보유분
|
||
(브로커 잔고 sync 로 생긴 Portfolio 행 / legacy 행)은 매 사이클 잔량 100%로
|
||
간주되어 SELL_PARTIAL(50%)이 무한 반복됐다.
|
||
|
||
Args:
|
||
stock: 종목 dict (remaining_pct 주입 대상)
|
||
holding: Portfolio ORM (현재 판정에 미사용 — 향후 확장용, 시그니처 고정)
|
||
|
||
Returns:
|
||
(remaining_pct, is_tracked)
|
||
- is_tracked=False → 잔량을 신뢰할 수 없음. 호출측은 부분매도를 스킵하고
|
||
전량 청산 신호만 채택해야 한다. 값은 기존 동작과 동일한 1.0 을 준다.
|
||
- remaining_pct 는 항상 0 < x <= 1.0 범위로 클램프.
|
||
"""
|
||
raw = stock.get("remaining_pct") if isinstance(stock, dict) else None
|
||
if raw is None:
|
||
return 1.0, False
|
||
try:
|
||
val = float(raw)
|
||
except (TypeError, ValueError):
|
||
return 1.0, False
|
||
if not (0.0 < val <= 1.0):
|
||
# 0 이하(전량 소진) 또는 1 초과(오염) → 추적 불가로 간주
|
||
return 1.0, False
|
||
return val, True
|
||
|
||
|
||
# ── 종목별 세마포어 — 동일 종목 동시 주문 방지 ────────────────────────────────
|
||
_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]
|
||
|
||
|
||
# ── Redis 분산락 — 중복 주문 완전 방지 (TTL 60초) ────────────────────────────
|
||
_ORDER_LOCK_TTL = 60 # seconds
|
||
|
||
|
||
# [M-2 5회차 2026-10-02] 프로세스 내 (종목, 방향) in-flight 표 — Redis 락의 1차 방어.
|
||
# 기존 주석은 "Redis 장애 시 세마포어가 2차 방어"라고 했지만 종목별 Semaphore(1) 은 **직렬화**만
|
||
# 한다 — 스윙 청산·DT·_execute_sell·수동 매도가 같은 종목 SELL 을 순서대로 **둘 다** 전송했다.
|
||
# 여기에 이미 있으면(같은 프로세스에서 진행 중) Redis 결과와 무관하게 거부한다.
|
||
# 값 = 획득 시각(monotonic). release 누락에 대비해 Redis 와 같은 TTL 이 지나면 무효.
|
||
_inflight_order_locks: dict = {}
|
||
|
||
|
||
def _local_order_lock_held_v2(key: tuple) -> bool:
|
||
ts = _inflight_order_locks.get(key)
|
||
if ts is None:
|
||
return False
|
||
if time.monotonic() - ts > _ORDER_LOCK_TTL:
|
||
logger.warning(f"[order_lock] 로컬 in-flight {key} TTL 초과 — release 누락으로 보고 해제")
|
||
_inflight_order_locks.pop(key, None)
|
||
return False
|
||
return True
|
||
|
||
|
||
async def _acquire_order_lock(stock_code: str, order_type: str) -> bool:
|
||
"""주문 락 획득 (프로세스 내 in-flight 표 + Redis SETNX). 성공 시 True.
|
||
|
||
[동작]
|
||
1. 같은 프로세스에서 같은 (종목, 방향) 주문이 진행 중이면 False — Redis 상태와 무관.
|
||
확인과 등록 사이에 await 가 없어 원자적이다(단일 이벤트 루프).
|
||
2. Redis SET NX + EX(TTL 60초) — 다른 프로세스/워커와의 중복 방지.
|
||
- 키가 이미 있으면 False(로컬 등록도 취소) → 호출측 SKIP.
|
||
- Redis 미연결·예외면 True(로컬 표만으로 진행). 여기서 False 로 막으면 Redis 장애 동안
|
||
손절 매도까지 전부 멈춘다(§8.1-11). 단일 프로세스 운영이므로 로컬 표로 중복이 막힌다.
|
||
"""
|
||
_local_key = (stock_code, str(order_type).upper())
|
||
if _local_order_lock_held_v2(_local_key):
|
||
logger.warning(f"[order_lock] {stock_code} {order_type} — 같은 프로세스에서 주문 진행 중, 중복 차단")
|
||
return False
|
||
_inflight_order_locks[_local_key] = time.monotonic()
|
||
try:
|
||
from app.core.redis import get_redis
|
||
client = get_redis()
|
||
if not client:
|
||
return True # Redis 미연결 → 로컬 in-flight 표로 보호
|
||
key = f"order_lock:{stock_code}:{order_type}"
|
||
result = await client.set(key, "1", nx=True, ex=_ORDER_LOCK_TTL)
|
||
if result is True:
|
||
return True
|
||
_inflight_order_locks.pop(_local_key, None) # 다른 프로세스가 보유 — 로컬 등록 취소
|
||
return False
|
||
except Exception as e:
|
||
logger.warning(f"[order_lock] Redis 획득 오류 (로컬 in-flight 표로 진행): {e}")
|
||
return True
|
||
|
||
|
||
async def _release_order_lock(stock_code: str, order_type: str) -> None:
|
||
"""주문 락 해제 — 로컬 in-flight 표 먼저(항상), 그다음 Redis 키.
|
||
|
||
[동작] finally 블록에서 반드시 호출 — 주문 성공/실패 관계없이 락 해제.
|
||
Redis DELETE 가 실패하면 키가 TTL(60초)까지 남아 다른 경로의 다음 주문이 최대 1사이클
|
||
밀릴 수 있다(알려진 한계 — 로컬 표는 이미 해제됨).
|
||
"""
|
||
_inflight_order_locks.pop((stock_code, str(order_type).upper()), None)
|
||
try:
|
||
from app.core.redis import delete_key
|
||
await delete_key(f"order_lock:{stock_code}:{order_type}")
|
||
except Exception:
|
||
pass # 해제 실패 시 TTL(60초) 만료 후 자동 해제됨
|
||
|
||
|
||
# ── 주문 재시도 — Exponential backoff (1→2→4초, 최대 3회) ───────────────────
|
||
# 재시도 대상 KIS msg_cd (레이트리밋). 업무 거부(잔고 부족·호가 오류·계좌 오류 등)는
|
||
# 재시도해도 같은 결과이고, 반복 주문이 일일 한도·쿨다운 판정을 오염시키므로 제외한다.
|
||
# [M-2 3회차 2026-10-02] KIS 게이트웨이 토큰 무효(EGW00121/EGW00123)도 재시도 대상.
|
||
# 게이트웨이 단계 거부라 주문이 접수되지 않은 것이 확실하고, korea_investment_api 가 이 코드에서
|
||
# 토큰을 재발급하므로 재시도하면 같은 사이클에 주문이 나간다(손절 매도가 1사이클 지연되던 문제).
|
||
from app.services.korea_investment_api import KIS_TOKEN_INVALID_MSG_CODES as _KIS_TOKEN_INVALID
|
||
_RETRYABLE_ORDER_MSG_CDS = frozenset({
|
||
"EGW00201", # 초당 거래건수 초과
|
||
*_KIS_TOKEN_INVALID,
|
||
})
|
||
|
||
|
||
# [2026-10-02 r4] safe_place_order(_v2) 의 rt_cd "-1" 응답에 붙는 msg_cd. DT 가 이 값으로
|
||
# "주문이 KIS 에 전송됐는지"를 구분한다(전송 전 실패는 재시도 안전, 전송 후 불명은 체결 조회 필요).
|
||
# korea_investment_api.place_order 가 자체 예외 처리에서 붙이는 KIS_PRESEND_CONNECT·
|
||
# KIS_PRESEND_CIRCUIT_OPEN·TOKEN_UNAVAILABLE·KIS_TRANSPORT_UNKNOWN 과 같은 체계다.
|
||
SAFE_ORDER_MSG_LOCK_BUSY = "ORDER_LOCK_BUSY"
|
||
SAFE_ORDER_MSG_PRESEND_EXCEPTION = "KIS_PRESEND_EXCEPTION"
|
||
SAFE_ORDER_MSG_TRANSPORT_UNKNOWN = "KIS_TRANSPORT_UNKNOWN"
|
||
|
||
|
||
# [H-3 5회차 2026-10-02] '전송 전' 실패 = KIS 에 주문이 가지 않은 것이 확실 → 재전송 안전.
|
||
from app.services.korea_investment_api import KIS_PRESEND_TOKEN_UNAVAILABLE as _KIS_PRESEND_TOKEN
|
||
_PRESEND_ORDER_MSG_CDS = frozenset({
|
||
"KIS_PRESEND_CONNECT",
|
||
"KIS_PRESEND_CIRCUIT_OPEN",
|
||
_KIS_PRESEND_TOKEN, # TOKEN_UNAVAILABLE
|
||
"KIS_PRESEND_EXCEPTION", # SAFE_ORDER_MSG_PRESEND_EXCEPTION
|
||
"ORDER_LOCK_BUSY", # SAFE_ORDER_MSG_LOCK_BUSY
|
||
})
|
||
|
||
|
||
def _is_retryable_order_failure(result: dict) -> bool:
|
||
"""주문 응답이 **재전송해도 안전한** 실패인지. rt_cd "0"(성공)은 호출부에서 먼저 걸러진다.
|
||
|
||
[H-3 5회차] 재전송은 KIS 에 주문이 가지 않았거나 게이트웨이에서 거부된 것이 확실한 경우만:
|
||
- 레이트리밋(EGW00201)·토큰 무효(EGW00121/123) — 게이트웨이 거부
|
||
- 전송 전 실패(KIS_PRESEND_*·TOKEN_UNAVAILABLE·ORDER_LOCK_BUSY)
|
||
rt_cd "-1" 이라도 `KIS_TRANSPORT_UNKNOWN`·msg_cd 없음·응답 없음은 **전송 후 결과 불명**이라
|
||
재전송하면 이중 체결(4% 초과 매수·과다 매도)이 난다 → 재시도 대상이 아니다
|
||
(`_is_order_outcome_unknown_v2` 로 따로 판정). rt_cd "1" 등 업무 거부도 재시도하지 않는다.
|
||
"""
|
||
if not isinstance(result, dict) or not result:
|
||
return False
|
||
cd = str(result.get("msg_cd") or "")
|
||
return cd in _RETRYABLE_ORDER_MSG_CDS or cd in _PRESEND_ORDER_MSG_CDS
|
||
|
||
|
||
def _is_order_outcome_unknown_v2(result) -> bool:
|
||
"""주문이 KIS 에 접수됐는지 알 수 없는 응답인지(전송 후 불명).
|
||
|
||
응답 없음/빈 dict, 또는 rt_cd "-1" 인데 재전송 안전 코드가 아닌 경우
|
||
(KIS_TRANSPORT_UNKNOWN·msg_cd 없음).
|
||
"""
|
||
if not isinstance(result, dict) or not result:
|
||
return True
|
||
if str(result.get("rt_cd")) != "-1":
|
||
return False
|
||
return not _is_retryable_order_failure(result)
|
||
|
||
|
||
async def _place_order_with_retry(
|
||
is_domestic: bool,
|
||
stock_code: str,
|
||
order_type: str,
|
||
quantity: int,
|
||
price: float,
|
||
exchange_code: str = "NASD",
|
||
max_retries: int = 3,
|
||
) -> dict:
|
||
"""주문 실행 with exponential backoff. 시스템 오류에만 재시도.
|
||
|
||
[동작]
|
||
1. 국내/해외 분기 후 KIS REST API 호출
|
||
2. rt_cd "0"(성공) → 즉시 반환
|
||
3. 업무 거부(rt_cd "1" 등, 레이트리밋 msg_cd 제외) → 재시도 없이 즉시 반환
|
||
4. 네트워크/시스템 오류(rt_cd "-1")·레이트리밋: 1초→2초→4초 대기 후 최대 max_retries회 재시도
|
||
5. 최대 재시도 소진 시 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
|
||
)
|
||
# [H-1 2026-10-02] KIS 는 rt_cd "0" 만 접수 성공이다. 기존엔 "1" 을
|
||
# PENDING(접수)으로 보고 즉시 반환, 그 밖의 코드는 업무 거부(잔고 부족·
|
||
# 호가 오류 등)까지 3회 재시도했다. 이제 재시도는 네트워크/시스템 오류
|
||
# (래퍼가 만든 rt_cd "-1")와 레이트리밋(msg_cd)만 — 업무 거부는 즉시 반환.
|
||
if result.get("rt_cd") == "0":
|
||
return result
|
||
last_result = result
|
||
if _is_order_outcome_unknown_v2(result):
|
||
# [H-3 5회차] 전송 후 결과 불명 — 재전송 금지. 당일 주문내역에 보이면 그 결과를,
|
||
# 아니면 불명 응답을 그대로 돌려준다(호출부가 PENDING 으로 기록하고 잔고 동기화로
|
||
# 확인). 주문내역 조회 실패도 []/None 이라 '없음'과 구분할 수 없으므로,
|
||
# 못 찾았다고 재전송하지 않는다.
|
||
if is_domestic:
|
||
_dup = await _find_recent_order(stock_code, order_type, quantity)
|
||
if _dup:
|
||
logger.warning(
|
||
f"[ORDER_DUP] {stock_code} {order_type} 결과 불명이나 주문 접수 확인됨 "
|
||
f"(odno={_dup.get('odno')}) → 재전송 안 함"
|
||
)
|
||
return _dup
|
||
logger.error(
|
||
f"[ORDER_UNKNOWN] {stock_code} {order_type} {quantity}주 — 전송 후 결과 불명 "
|
||
f"(msg_cd={result.get('msg_cd')} msg1={result.get('msg1')}). 이중 체결 방지로 "
|
||
f"재전송하지 않음 — 잔고 동기화로 확인"
|
||
)
|
||
return result
|
||
if not _is_retryable_order_failure(result):
|
||
logger.warning(
|
||
f"[ORDER_REJECT] {stock_code} {order_type} KIS 거부 — 재시도 안 함 "
|
||
f"(rt_cd={result.get('rt_cd')} msg_cd={result.get('msg_cd')} msg1={result.get('msg1')})"
|
||
)
|
||
return result
|
||
if attempt < max_retries - 1:
|
||
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:
|
||
# 네트워크 타임아웃 등 예외 → 재시도 대상
|
||
# [2026-09-23] 단, KIS가 주문을 접수한 뒤 응답만 못 받은 경우가 있으므로
|
||
# 재시도 전에 당일 체결 내역으로 중복 여부를 확인한다(멱등성 보강).
|
||
# [H-3 5회차] place_order 호출 중 예외 = 전송 여부 불명 → 재전송 금지(위와 동일 정책).
|
||
last_result = {"rt_cd": "-1", "msg_cd": SAFE_ORDER_MSG_TRANSPORT_UNKNOWN,
|
||
"msg1": str(e), "odno": None}
|
||
if is_domestic:
|
||
_dup = await _find_recent_order(stock_code, order_type, quantity)
|
||
if _dup:
|
||
logger.warning(
|
||
f"[ORDER_DUP] {stock_code} {order_type} 예외 발생했으나 주문 접수 확인됨 "
|
||
f"(odno={_dup.get('odno')}) → 재전송 안 함"
|
||
)
|
||
return _dup
|
||
logger.error(
|
||
f"[ORDER_UNKNOWN] {stock_code} {order_type} {quantity}주 — 주문 중 예외로 결과 불명 "
|
||
f"({type(e).__name__}: {e}). 이중 체결 방지로 재전송하지 않음 — 잔고 동기화로 확인"
|
||
)
|
||
return last_result
|
||
return last_result or {"rt_cd": "-1", "msg1": "max_retries_exceeded", "odno": None}
|
||
|
||
|
||
async def _find_recent_order(stock_code: str, order_type: str, quantity: int) -> dict | None:
|
||
"""직전 주문이 실제로 KIS에 접수됐는지 당일 주문체결 내역으로 확인.
|
||
|
||
타임아웃/연결 끊김으로 응답을 못 받았지만 주문은 접수된 경우, 그대로 재시도하면
|
||
중복 체결이 된다. 최근 2분 내 같은 종목·매매구분·수량 주문이 있으면 그 주문을 반환한다.
|
||
조회 실패 시 None (판단 불가 → 호출측의 기존 재시도 로직을 따른다).
|
||
"""
|
||
try:
|
||
rows = await korea_investment_api.get_todays_orders(stock_code)
|
||
except Exception as e:
|
||
logger.warning(f"[ORDER_DUP] 주문내역 조회 실패 ({stock_code}): {e}")
|
||
return None
|
||
if not rows:
|
||
return None
|
||
|
||
_now = datetime.now()
|
||
_side = "02" if order_type.upper() == "BUY" else "01" # KIS: 01=매도, 02=매수
|
||
for row in rows:
|
||
try:
|
||
if row.get("pdno") != stock_code:
|
||
continue
|
||
if row.get("sll_buy_dvsn_cd") not in (_side, None, ""):
|
||
continue
|
||
if int(row.get("ord_qty", 0) or 0) != int(quantity):
|
||
continue
|
||
_t = str(row.get("ord_tmd") or "") # HHMMSS
|
||
if len(_t) == 6:
|
||
_ordered = _now.replace(
|
||
hour=int(_t[:2]), minute=int(_t[2:4]), second=int(_t[4:]), microsecond=0
|
||
)
|
||
if (_now - _ordered).total_seconds() > 120:
|
||
continue
|
||
return {
|
||
"rt_cd": "0",
|
||
"msg1": "기존 주문 확인(중복 방지)",
|
||
# [L-5 5회차] 같은 종목·방향·수량의 '아무' 주문일 수 있다 — 자기 주문이라는
|
||
# 보장이 없으므로 이 ODNO 로 취소하지 않는다(_execute_sell 이 이 표식을 본다).
|
||
"_matched_by_lookup": True,
|
||
"odno": row.get("odno"),
|
||
"output": {"ODNO": row.get("odno"), "ord_prc": row.get("ord_unpr")},
|
||
}
|
||
except Exception:
|
||
continue
|
||
return None
|
||
|
||
|
||
# ── [C1] 공통 주문 래퍼 — 분산락+세마포어 보호 (daytrading/swing에서 import) ──
|
||
async def safe_place_order(
|
||
stock_code: str,
|
||
order_type: str,
|
||
quantity: int,
|
||
price: float | None = None,
|
||
is_domestic: bool = True,
|
||
exchange_code: str = "NASD",
|
||
) -> dict:
|
||
"""Redis 분산락 + 세마포어로 보호된 주문 실행.
|
||
|
||
daytrading/exit_service, swing/exit_service에서 korea_investment_api.place_order()
|
||
대신 이 함수를 사용하여 이중 주문을 방지합니다.
|
||
"""
|
||
if not await _acquire_order_lock(stock_code, order_type):
|
||
logger.warning(f"[SAFE_ORDER] {stock_code} {order_type} — 분산락 획득 실패 (이미 처리 중)")
|
||
return {"rt_cd": "-1", "msg_cd": SAFE_ORDER_MSG_LOCK_BUSY, "msg1": "order_lock_busy"}
|
||
|
||
_sent = False # place_order 호출 진입 여부 — 예외 시 전송 전/후 구분
|
||
try:
|
||
async with _get_order_semaphore(stock_code):
|
||
_sent = True
|
||
if is_domestic:
|
||
result = await korea_investment_api.place_order(
|
||
stock_code=stock_code,
|
||
order_type=order_type,
|
||
quantity=quantity,
|
||
price=price,
|
||
)
|
||
else:
|
||
result = await korea_investment_api.place_overseas_order(
|
||
symbol=stock_code,
|
||
order_type=order_type,
|
||
quantity=quantity,
|
||
price=price or 0,
|
||
exchange_code=exchange_code,
|
||
)
|
||
return result or {"rt_cd": "-1", "msg_cd": SAFE_ORDER_MSG_TRANSPORT_UNKNOWN, "msg1": "no_response"}
|
||
except Exception as e:
|
||
_cd = SAFE_ORDER_MSG_TRANSPORT_UNKNOWN if _sent else SAFE_ORDER_MSG_PRESEND_EXCEPTION
|
||
logger.error(f"[SAFE_ORDER] {stock_code} {order_type} 실패({_cd}): {e}")
|
||
return {"rt_cd": "-1", "msg_cd": _cd, "msg1": str(e)}
|
||
finally:
|
||
await _release_order_lock(stock_code, order_type)
|
||
|
||
|
||
# ── [멀티테넌트 1단계 §5.8] 사용자 스코프 주문 락/래퍼 ────────────────────────
|
||
# 기존 safe_place_order/_acquire_order_lock/_auto_cancel_if_pending는 시그니처
|
||
# 불변 유지. 사용자별 계좌(ctx.kis)로 주문하는 경로는 아래 _v2 함수를 사용한다.
|
||
async def _acquire_order_lock_v2(user_id, stock_code: str, order_type: str) -> bool:
|
||
"""Redis 분산락 획득 — 사용자 네임스페이스 키(`order_lock:{user_id}:{code}:{type}`).
|
||
|
||
구조는 `_acquire_order_lock`과 동일(SETNX+TTL 60초). legacy 컨텍스트(user_id가
|
||
None 또는 legacy owner id)도 이 함수를 쓰면 키에 user_id가 섞이므로, legacy
|
||
경로는 기존 `_acquire_order_lock`(user_id 없는 키)을 그대로 사용해야 한다.
|
||
"""
|
||
try:
|
||
from app.core.redis import get_redis
|
||
client = get_redis()
|
||
if not client:
|
||
return True
|
||
key = f"order_lock:{user_id}:{stock_code}:{order_type}"
|
||
result = await client.set(key, "1", nx=True, ex=_ORDER_LOCK_TTL)
|
||
return result is True
|
||
except Exception as e:
|
||
# 통과 근거는 _acquire_order_lock 과 동일(단일 프로세스 + 종목별 세마포어 2차 방어,
|
||
# 차단 시 청산까지 정지).
|
||
logger.warning(f"[order_lock_v2] user_id={user_id} 획득 오류 (패스 — 세마포어가 2차 방어): {e}")
|
||
return True
|
||
|
||
|
||
async def _release_order_lock_v2(user_id, stock_code: str, order_type: str) -> None:
|
||
"""Redis 분산락 해제 — `_acquire_order_lock_v2`와 짝을 이루는 사용자 네임스페이스 키."""
|
||
try:
|
||
from app.core.redis import delete_key
|
||
await delete_key(f"order_lock:{user_id}:{stock_code}:{order_type}")
|
||
except Exception as _swallowed:
|
||
logger.warning("[order_lock_v2] 락 해제 실패(TTL 만료까지 유지): %s", _swallowed)
|
||
|
||
|
||
async def safe_place_order_v2(
|
||
ctx, # UserContext (순환 임포트 회피 — 타입은 app.services.tenant.context.UserContext)
|
||
stock_code: str,
|
||
order_type: str,
|
||
quantity: int,
|
||
price: float | None = None,
|
||
is_domestic: bool = True,
|
||
exchange_code: str = "NASD",
|
||
) -> dict:
|
||
"""`safe_place_order`의 사용자 스코프 버전 (설계 문서 §5.8).
|
||
|
||
- `ctx.is_legacy`면 기존 전역 경로(`_acquire_order_lock`/`_release_order_lock`,
|
||
`_get_order_semaphore(stock_code)`)를 그대로 사용 — swing/daytrading exit_service
|
||
등 기존 스케줄러가 잡는 락과 같은 키여야 같은 계좌·종목 동시 매도가 직렬화된다.
|
||
사용자 컨텍스트(`is_legacy=False`)만 사용자 네임스페이스 키(`{user_id}:{code}`)를 쓴다.
|
||
- 세마포어: `_get_order_semaphore(f"{ctx.user_id}:{stock_code}")` — 기존 함수 재사용,
|
||
키 문자열만 사용자 네임스페이스로 바꿈(시그니처 불변).
|
||
- Redis 락: `_acquire_order_lock_v2`/`_release_order_lock_v2` (legacy는 v1 그대로).
|
||
- 주문 실행: `ctx.kis.place_order(...)`/`ctx.kis.place_overseas_order(...)`.
|
||
- 반환 형식은 `safe_place_order`와 동일.
|
||
"""
|
||
if ctx.is_legacy:
|
||
semaphore_key = stock_code
|
||
lock_acquired = await _acquire_order_lock(stock_code, order_type)
|
||
else:
|
||
semaphore_key = f"{ctx.user_id}:{stock_code}"
|
||
lock_acquired = await _acquire_order_lock_v2(ctx.user_id, stock_code, order_type)
|
||
|
||
if not lock_acquired:
|
||
logger.warning(f"[SAFE_ORDER_V2] user_id={ctx.user_id} {stock_code} {order_type} — 분산락 획득 실패 (이미 처리 중)")
|
||
return {"rt_cd": "-1", "msg_cd": SAFE_ORDER_MSG_LOCK_BUSY, "msg1": "order_lock_busy"}
|
||
|
||
_sent = False
|
||
try:
|
||
async with _get_order_semaphore(semaphore_key):
|
||
_sent = True
|
||
if is_domestic:
|
||
result = await ctx.kis.place_order(
|
||
stock_code=stock_code,
|
||
order_type=order_type,
|
||
quantity=quantity,
|
||
price=price,
|
||
)
|
||
else:
|
||
result = await ctx.kis.place_overseas_order(
|
||
symbol=stock_code,
|
||
order_type=order_type,
|
||
quantity=quantity,
|
||
price=price or 0,
|
||
exchange_code=exchange_code,
|
||
)
|
||
return result or {"rt_cd": "-1", "msg_cd": SAFE_ORDER_MSG_TRANSPORT_UNKNOWN, "msg1": "no_response"}
|
||
except Exception as e:
|
||
_cd = SAFE_ORDER_MSG_TRANSPORT_UNKNOWN if _sent else SAFE_ORDER_MSG_PRESEND_EXCEPTION
|
||
logger.error(f"[SAFE_ORDER_V2] user_id={ctx.user_id} {stock_code} {order_type} 실패({_cd}): {e}")
|
||
return {"rt_cd": "-1", "msg_cd": _cd, "msg1": str(e)}
|
||
finally:
|
||
if ctx.is_legacy:
|
||
await _release_order_lock(stock_code, order_type)
|
||
else:
|
||
await _release_order_lock_v2(ctx.user_id, stock_code, order_type)
|
||
|
||
|
||
async def _auto_cancel_if_pending_v2(ctx, order_id: str, stock_code: str, quantity: int, delay: int = 60) -> None:
|
||
"""`_auto_cancel_if_pending`의 사용자 스코프 버전 — `ctx.kis.cancel_order`를 사용."""
|
||
await asyncio.sleep(delay)
|
||
try:
|
||
result = await ctx.kis.cancel_order(order_id, quantity)
|
||
if result.get("rt_cd") == "0":
|
||
logger.info(f"[AUTO_CANCEL_V2] user_id={ctx.user_id} 미체결 자동 취소 완료: {stock_code} order_id={order_id}")
|
||
else:
|
||
logger.debug(f"[AUTO_CANCEL_V2] user_id={ctx.user_id} {stock_code} — {result.get('msg1')} (이미 체결됐을 수 있음)")
|
||
except Exception as e:
|
||
logger.warning(f"[AUTO_CANCEL_V2] user_id={ctx.user_id} {stock_code} — {type(e).__name__}: {e}")
|
||
|
||
|
||
# ── 미체결 주문 1분 후 자동 취소 ─────────────────────────────────────────────
|
||
async def _auto_cancel_if_pending(order_id: str, stock_code: str, quantity: int, delay: int = 60) -> None:
|
||
"""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.warning(f"[AUTO_CANCEL] {stock_code} — {type(e).__name__}: {e}")
|
||
|
||
|
||
# ── 계좌 정보 30초 인메모리 캐시 ──────────────────────────────────────────────
|
||
_account_cache: dict = {"data": None, "ts": 0.0}
|
||
_ACCOUNT_CACHE_TTL = 30 # seconds
|
||
|
||
|
||
def _get_cached_account() -> tuple | 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()
|
||
_account_cache["deducted"] = False
|
||
|
||
|
||
def _get_cached_account_v2() -> tuple | None:
|
||
"""`_get_cached_account` + '매수 차감으로 현금이 0 이 된 캐시' 도 신뢰.
|
||
|
||
기존 호출부는 현금 0 캐시를 불신(무한 0주 루프 방지)하고 portfolio_cache/KIS 로
|
||
재조회한다. 그러나 매수 접수로 차감된 0 은 진짜 0 이고, 재조회 소스(portfolio_cache·
|
||
KIS 예수금)는 아직 그 매수를 반영하지 않았을 수 있다 → 차감된 캐시는 TTL 동안 그대로 쓴다.
|
||
"""
|
||
cached = _get_cached_account()
|
||
if cached is None:
|
||
return None
|
||
if cached[0] > 0 or _account_cache.get("deducted"):
|
||
return cached
|
||
return None
|
||
|
||
|
||
def _deduct_account_cache_v2(amount: float, available_cash: float, total_assets: float) -> None:
|
||
"""[H-2 2026-10-02] 매수 접수 성공 시 30초 계좌 캐시의 현금을 즉시 차감.
|
||
|
||
기존엔 캐시가 TTL 동안 매수 전 현금을 그대로 돌려줘, 같은 사이클의 다음 종목이
|
||
현금 95%(MAX_TOTAL_CAPITAL_USAGE)·스윙 70%(SWING_MAX_CAPITAL_RATIO) 가드를 매수
|
||
전 기준으로 통과했다. 총자산은 현금→주식 이동이라 그대로 둔다.
|
||
캐시가 없거나 만료됐으면 이번 판정에 쓴 값(available_cash/total_assets)에서 차감해 심는다.
|
||
"""
|
||
try:
|
||
amt = max(0.0, float(amount))
|
||
except (TypeError, ValueError):
|
||
amt = 0.0
|
||
cached = _get_cached_account()
|
||
base_cash, base_assets = cached if cached is not None else (available_cash, total_assets)
|
||
_account_cache["data"] = (max(0.0, float(base_cash) - amt), float(base_assets))
|
||
_account_cache["ts"] = time.monotonic()
|
||
_account_cache["deducted"] = True
|
||
|
||
|
||
# ── [M-3 2026-10-02] 사이클 내 매수 성공 종목 인메모리 누적 ───────────────────
|
||
# Portfolio 행은 db_worker 큐 경유로 비동기 반영되므로 같은 사이클(및 직후 사이클)의
|
||
# 보유수·섹터·레버리지·전략배분 판정이 방금 산 종목을 보지 못했다.
|
||
# 매수 접수 성공 종목을 TTL 동안 기억해 판정에 합산한다(이미 Portfolio 에 보이면 중복 제외).
|
||
_recent_cycle_buys: dict = {} # stock_code -> {"ts", "stock_name", "quantity", "price"}
|
||
_RECENT_CYCLE_BUY_TTL_SEC = 300 # db_worker 반영 지연 흡수용(전략 파라미터 아님)
|
||
|
||
|
||
def _note_cycle_buy_v2(stock_code: str, stock_name: str, quantity: int, price: float) -> None:
|
||
_recent_cycle_buys[stock_code] = {
|
||
"ts": time.monotonic(),
|
||
"stock_name": stock_name or "",
|
||
"quantity": int(quantity or 0),
|
||
"price": float(price or 0),
|
||
}
|
||
|
||
|
||
def _recent_cycle_buys_v2() -> dict:
|
||
"""TTL 이내 매수 성공 종목 (만료분 정리 후 사본 반환)."""
|
||
now = time.monotonic()
|
||
for code in [c for c, v in _recent_cycle_buys.items()
|
||
if now - v.get("ts", 0) > _RECENT_CYCLE_BUY_TTL_SEC]:
|
||
_recent_cycle_buys.pop(code, None)
|
||
return dict(_recent_cycle_buys)
|
||
|
||
|
||
def _forget_cycle_buy_v2(stock_code: str, reason: str) -> None:
|
||
"""[M-4 3회차] 미체결·취소 확정 매수는 사이클 매수 누적에서 뺀다(보유수 과대 집계 방지)."""
|
||
if _recent_cycle_buys.pop(stock_code, None) is not None:
|
||
logger.warning(f"[CYCLE_BUY] {stock_code}: 사이클 매수 누적에서 제외 — {reason}")
|
||
|
||
|
||
def _domestic_recent_cycle_buy_codes_v2() -> set:
|
||
"""국내 보유수 집계용 — 해외(USD) 매수는 MAX_HOLDINGS_COUNT 대상이 아니다."""
|
||
return {c for c in _recent_cycle_buys_v2().keys() if c and not is_us_stock(c)}
|
||
|
||
|
||
def _domestic_recent_swing_buy_codes_v2() -> set:
|
||
"""[M-3 4회차] 사이클 매수 누적 중 국내 '스윙 소유' 매수 (일일 스윙 한도 집계용)."""
|
||
return {
|
||
c for c, v in _recent_cycle_buys_v2().items()
|
||
if c and not is_us_stock(c)
|
||
and (v.get("strategy_type") in (None, *_SWING_OWNER_STRATEGY_TYPES))
|
||
}
|
||
|
||
|
||
# ── [M-1 3회차 2026-10-02] 업무 거부 매수 종목 단기 쿨다운 (인메모리) ──────────
|
||
_order_reject_cooldown: dict = {} # stock_code -> monotonic ts
|
||
|
||
|
||
_eval_rotation_offset: int = 0 # [L-3 4회차] 신규 후보 평가 시작 오프셋(사이클마다 회전)
|
||
_account_reject_at: float | None = None # [L-2 4회차] 계좌 단위 거부 시각(monotonic)
|
||
|
||
|
||
def _account_reject_cooldown_remaining_v2() -> float:
|
||
"""계좌 단위 거부 쿨다운 남은 초. 없으면 0."""
|
||
global _account_reject_at
|
||
if _account_reject_at is None:
|
||
return 0.0
|
||
left = settings.AUTO_TRADE_ORDER_REJECT_COOLDOWN_MIN * 60 - (time.monotonic() - _account_reject_at)
|
||
if left <= 0:
|
||
_account_reject_at = None
|
||
return 0.0
|
||
return left
|
||
|
||
|
||
def _note_order_reject_v2(stock_code: str, order_result: dict) -> None:
|
||
global _account_reject_at
|
||
if str(order_result.get("msg_cd") or "") in set(settings.KIS_ACCOUNT_REJECT_MSG_CODES or ()):
|
||
_account_reject_at = time.monotonic()
|
||
logger.error(
|
||
f"[ORDER_REJECT_COOLDOWN] 🚨 계좌 단위 거부 msg_cd={order_result.get('msg_cd')} "
|
||
f"({order_result.get('msg1')}) — {settings.AUTO_TRADE_ORDER_REJECT_COOLDOWN_MIN:g}분간 "
|
||
f"전 종목 신규 매수 보류(청산은 계속). 계좌·앱키 상태 확인 필요"
|
||
)
|
||
_order_reject_cooldown[stock_code] = time.monotonic()
|
||
logger.warning(
|
||
f"[ORDER_REJECT_COOLDOWN] {stock_code}: KIS 업무 거부 "
|
||
f"(rt_cd={order_result.get('rt_cd')} msg_cd={order_result.get('msg_cd')} "
|
||
f"msg1={order_result.get('msg1')}) — {settings.AUTO_TRADE_ORDER_REJECT_COOLDOWN_MIN:g}분간 재주문 안 함"
|
||
)
|
||
|
||
|
||
def _order_reject_cooldown_remaining_v2(stock_code: str) -> float:
|
||
"""남은 쿨다운(초). 없으면 0."""
|
||
ts = _order_reject_cooldown.get(stock_code)
|
||
if ts is None:
|
||
return 0.0
|
||
left = settings.AUTO_TRADE_ORDER_REJECT_COOLDOWN_MIN * 60 - (time.monotonic() - ts)
|
||
if left <= 0:
|
||
_order_reject_cooldown.pop(stock_code, None)
|
||
return 0.0
|
||
return left
|
||
|
||
|
||
def _merge_recent_buys_into_holdings_v2(holdings: list) -> list:
|
||
"""보유 리스트에 '아직 Portfolio 에 안 보이는' 최근 매수 종목을 의사 행으로 덧붙인다."""
|
||
from types import SimpleNamespace
|
||
held = {getattr(h, "stock_code", None) for h in holdings}
|
||
merged = list(holdings)
|
||
for code, v in _recent_cycle_buys_v2().items():
|
||
if code in held:
|
||
continue
|
||
merged.append(SimpleNamespace(
|
||
stock_code=code,
|
||
stock_name=v["stock_name"],
|
||
quantity=v["quantity"],
|
||
current_price=v["price"],
|
||
average_price=v["price"],
|
||
strategy_type="swing",
|
||
))
|
||
return merged
|
||
|
||
|
||
def _leverage_exposure_v2(holdings: list, keywords) -> float | None:
|
||
"""보유 레버리지/인버스 ETF 평가액 합. 행 해석 실패 시 None(판정 불가)."""
|
||
total = 0.0
|
||
for h in holdings:
|
||
try:
|
||
h_name = getattr(h, "stock_name", "") or ""
|
||
if is_leverage_etf(h_name, keywords):
|
||
total += float(getattr(h, "quantity", 0) or 0) * float(
|
||
getattr(h, "current_price", 0) or getattr(h, "average_price", 0) or 0
|
||
)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[LEVERAGE_LIMIT] 보유 행 평가 실패({getattr(h, 'stock_code', '?')}): {e}"
|
||
)
|
||
return None
|
||
return total
|
||
|
||
|
||
def _parse_scale_v2(raw, name: str, stock_code: str) -> float:
|
||
"""배율 해석. None → 1.0(미주입), 0.0 은 0.0 그대로(진입 차단 의미 보존).
|
||
|
||
[M-4 2026-10-02] 기존 `float(x or 1.0)` 은 0.0 을 1.0 으로 바꿔 국면/플레이북의
|
||
'진입 차단(0배)'을 무력화했다. 해석 불가 값은 안전한 쪽(0.0 = 매수 안 함) + warning.
|
||
"""
|
||
if raw is None:
|
||
return 1.0
|
||
try:
|
||
val = float(raw)
|
||
except (TypeError, ValueError):
|
||
logger.warning(f"[POSITION_SCALE] {stock_code}: {name}={raw!r} 해석 불가 — 0 으로 간주(매수 차단)")
|
||
return 0.0
|
||
if val != val: # NaN
|
||
logger.warning(f"[POSITION_SCALE] {stock_code}: {name}=NaN — 0 으로 간주(매수 차단)")
|
||
return 0.0
|
||
return max(0.0, min(1.0, val))
|
||
|
||
|
||
def _dt_invested_amount_v2(stock_code: str) -> float:
|
||
"""데이트레이딩 인메모리 포지션 투자액 합계(진입가×수량).
|
||
|
||
[R6-2 2026-10-10] 예외를 로그 없이 0.0 으로 삼키면 스윙 투자액이 DT 포지션까지
|
||
포함해 부풀려지고(보수 방향), 원인 추적 불가능한 swing_capital_cap 차단이 났다.
|
||
값은 이전과 같이 0.0 폴백(보수 방향 유지)이되 warning 을 남긴다(§4).
|
||
"""
|
||
try:
|
||
from app.services.daytrading.position_manager import day_trading_state as _dts
|
||
return sum(
|
||
float(p.get("entry_price", 0) or 0) * int(p.get("quantity", 0) or 0)
|
||
for p in _dts.positions.values()
|
||
)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[TRADE] {stock_code}: DT 투자액 집계 실패 — 0 으로 간주"
|
||
f"(스윙 투자액 과대 → 스윙 잔여 한도 보수 산정): {e}"
|
||
)
|
||
return 0.0
|
||
|
||
|
||
def _reapply_capital_guards_v2(
|
||
invest_amount: float,
|
||
available_cash: float,
|
||
min_cash_reserve: float,
|
||
swing_room: float | None,
|
||
) -> float:
|
||
"""패턴메모리 조정 이후 현금 유보(§5.1 95%)·스윙 자본 상한(70%) 재적용.
|
||
|
||
[R6-1 2026-10-10] 두 가드가 패턴메모리(최대 1.5배) **이전**에만 적용돼, 조정이
|
||
한도 끝까지 줄인 금액을 되돌리면 4% 재클램프만으로는 두 상한을 넘을 수 있었다.
|
||
리스크 가드이므로 호출부는 try 밖에서 무조건 호출한다(§4). swing_room=None 은
|
||
스윙 상한 미적용(비율 ≥1 또는 총자산 0) 경로다.
|
||
"""
|
||
bounded = min(float(invest_amount), max(0.0, float(available_cash) - float(min_cash_reserve)))
|
||
if swing_room is not None:
|
||
bounded = min(bounded, max(0.0, float(swing_room)))
|
||
return max(0.0, bounded)
|
||
|
||
|
||
# ── 지정가 조정 — 체결률 향상 ──────────────────────────────────────────────────
|
||
def _resolve_sell_order_price_v2(
|
||
stock_code: str, current_price: float, is_domestic: bool, full_exit: bool, profit_loss_rate: float,
|
||
) -> tuple:
|
||
"""[H-1 4회차] (기준가, 주문가 또는 None=시장가, 방식) — 순수 판정.
|
||
|
||
- 해외: 기존 지정가(현재가 −0.5%) 유지
|
||
- 국내 전량 청산 또는 손실 청산: 시장가 (미체결로 수량을 잠그면 후속 손절이 거부된다)
|
||
- 국내 부분 익절: 'limit_refresh' — 호출부가 주문 직전 현재가로 지정가를 재산정
|
||
"""
|
||
if not is_domestic:
|
||
return current_price, _adjust_order_price(current_price, "SELL", is_domestic), "limit_overseas"
|
||
if full_exit or profit_loss_rate < 0:
|
||
return current_price, None, "market"
|
||
return current_price, None, "limit_refresh"
|
||
|
||
|
||
async def _fresh_domestic_price_v2(stock_code: str) -> float:
|
||
"""주문 직전 국내 현재가. 실패/0 이면 0.0(호출부가 시장가로 폴백)."""
|
||
try:
|
||
data = await korea_investment_api.get_current_price(stock_code)
|
||
return float(((data or {}).get("output") or {}).get("stck_prpr") or 0)
|
||
except Exception as e:
|
||
logger.warning(f"[SELL] {stock_code}: 주문 직전 현재가 조회 실패 — 시장가로 폴백: {e}")
|
||
return 0.0
|
||
|
||
|
||
def _adjust_order_price(price: float, order_type: str, is_domestic: bool = True) -> float:
|
||
"""BUY +0.5% / SELL -0.5% 지정가 조정.
|
||
|
||
국내: 원화 정수 반환 (KIS는 원화 단위 정수만 허용).
|
||
해외: 소수점 2자리 반환 (USD 단위).
|
||
"""
|
||
if order_type == "BUY":
|
||
adjusted = price * 1.005
|
||
else:
|
||
adjusted = price * 0.995
|
||
|
||
if is_domestic:
|
||
return float(int(adjusted)) # 원화 정수
|
||
return round(adjusted, 2) # USD 소수점 2자리
|
||
|
||
|
||
# ── Kelly Criterion 포지션 사이징 ─────────────────────────────────────────────
|
||
async def _calculate_kelly_position(
|
||
db: AsyncSession,
|
||
stock_code: str,
|
||
total_assets: float,
|
||
available_cash: float,
|
||
max_per_position: float = 0.04,
|
||
lookback: int = 20,
|
||
) -> float:
|
||
"""Kelly Criterion 기반 최적 포지션 사이징 (Half-Kelly 적용).
|
||
|
||
f* = (p*b - (1-p)) / b
|
||
- 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(
|
||
select(TradeHistory)
|
||
.where(
|
||
TradeHistory.stock_code == stock_code,
|
||
TradeHistory.order_type == "SELL",
|
||
TradeHistory.status == "COMPLETED",
|
||
TradeHistory.profit_loss_rate.isnot(None),
|
||
)
|
||
# [하드닝 R1 2026-10-09] executed_at 단독 DESC 는 NULL(스윙 청산·DT·MDD SELL)을
|
||
# PostgreSQL 에서 맨 앞에 둬 '최근 N거래'가 시간순이 아니었다 → coalesce 로 정렬.
|
||
.order_by(desc(_fill_or_created_at_v2()), desc(TradeHistory.id))
|
||
.limit(lookback)
|
||
)
|
||
trades = recent.scalars().all()
|
||
if len(trades) < 5:
|
||
return 0.0 # 데이터 부족 → v2 fallback
|
||
|
||
rates = [float(t.profit_loss_rate) for t in trades]
|
||
# [§8.5-2 통합 2026-09-27] Kelly 통계 수식은 sizing_core.half_kelly_fraction 로 이동
|
||
# (순수 계산). DB 조회·예외 처리·fallback 판단은 이 함수에 남는다.
|
||
# min_trades=5 미만 / 전승 / 전패 → None → 기존과 동일하게 0.0 반환(v2 fallback).
|
||
half_kelly = half_kelly_fraction(rates, min_trades=5)
|
||
if half_kelly is None:
|
||
return 0.0
|
||
|
||
clamped = min(half_kelly, max_per_position) # 종목당 최대 4% 상한 적용
|
||
# = min(총자산×clamped, 가용현금, 총자산×max_per_position) — 통합 전과 동일
|
||
return clamp_by_ratios(
|
||
total_assets * clamped, total_assets, [max_per_position], available_cash,
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"[kelly] {stock_code} 계산 오류: {type(e).__name__}: {e}")
|
||
return 0.0
|
||
|
||
|
||
# ── 체결 확인 + 부분 체결 처리 + 슬리피지 로깅 ───────────────────────────────
|
||
async def _cancel_unfilled_order_v2(
|
||
order_id: str, stock_code: str, remaining_qty: int, org_no: str | None = None,
|
||
) -> bool:
|
||
"""[H-1 4회차] 미체결 잔량 취소(자기 ODNO 만). 성공 True, 실패는 error 로그 후 False.
|
||
|
||
[5회차] 인프라 `cancel_order_v2`(공식 order-rvsecncl 대조: KRX_FWDG_ORD_ORGNO 필수) 사용.
|
||
org_no 는 원주문 응답에서 추출해 전달하고, None 이면 v2 가 당일 주문내역에서 찾는다.
|
||
못 찾으면 미전송 `ORGNO_NOT_FOUND` → 취소 미확정이므로 호출부는 롤백하지 않는다.
|
||
"""
|
||
try:
|
||
result = await korea_investment_api.cancel_order_v2(
|
||
order_id, org_no=org_no, quantity=remaining_qty, stock_code=stock_code,
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"[VERIFY_EXEC] {stock_code} 미체결 매도 취소 실패(예외) order_id={order_id}: {e} — 수동 취소 필요")
|
||
return False
|
||
if (result or {}).get("rt_cd") == "0":
|
||
logger.warning(f"[VERIFY_EXEC] {stock_code} 미체결 매도 {remaining_qty}주 취소 완료 (order_id={order_id})")
|
||
return True
|
||
logger.error(
|
||
f"[VERIFY_EXEC] {stock_code} 미체결 매도 취소 거부 order_id={order_id} "
|
||
f"rt_cd={(result or {}).get('rt_cd')} msg={(result or {}).get('msg1')} — 수동 취소 필요"
|
||
)
|
||
return False
|
||
|
||
|
||
def _extract_org_no_v2(order_result) -> str | None:
|
||
"""원주문 응답의 KRX_FWDG_ORD_ORGNO (취소에 필요). 추출 실패는 None — cancel_order_v2 가 조회."""
|
||
try:
|
||
from app.services.korea_investment_api import extract_order_org_no
|
||
return extract_order_org_no(order_result)
|
||
except Exception as e:
|
||
logger.warning(f"[SELL] 주문조직번호 추출 실패 — 취소 시 주문내역 조회로 대체: {e}")
|
||
return None
|
||
|
||
|
||
async def _rollback_active_trade_v2(stock_code: str, snapshot: dict | None, filled_qty: int) -> None:
|
||
"""[H-1 5회차] 취소된 지정가 부분 익절의 ActiveTrade 원복 (db_worker 큐).
|
||
|
||
- 0체결: 주문 전 스냅샷(remaining_pct·quantity·highest_since_entry·전략 필터) 그대로 upsert
|
||
→ 같은 익절 단계가 다음 사이클에 다시 판정된다. created_at·strategy_name 은 upsert 가
|
||
건드리지 않는다(행을 닫지 않았으므로 보존).
|
||
- 부분 체결: 잔량만 실제 체결 기준(스냅샷 수량 − 체결)으로 정정. remaining_pct 는 이미
|
||
진행한 단계값을 유지한다(같은 단계 재발동 방지).
|
||
"""
|
||
if not snapshot:
|
||
return
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
payload = {k: v for k, v in snapshot.items() if v is not None}
|
||
if filled_qty > 0:
|
||
payload = {k: v for k, v in payload.items() if k not in ("remaining_pct", "highest_since_entry")}
|
||
payload["quantity"] = max(0, int(snapshot.get("quantity") or 0) - int(filled_qty))
|
||
await enqueue_active_trade_upsert(payload)
|
||
logger.warning(
|
||
f"[VERIFY_EXEC] {stock_code} 취소된 지정가 익절 ActiveTrade 원복 "
|
||
f"(체결 {filled_qty}주, payload={payload})"
|
||
)
|
||
|
||
|
||
async def _mark_trade_cancelled_v2(order_id: str, db_trade_id: int, filled_qty: int = 0) -> None:
|
||
"""TradeHistory 를 CANCELLED 로 (db_worker 큐 경유)."""
|
||
fields = {"status": "CANCELLED", "executed_quantity": int(filled_qty)}
|
||
if db_trade_id:
|
||
from app.services.db_worker import enqueue_update_trade_history
|
||
await enqueue_update_trade_history(db_trade_id, fields)
|
||
else:
|
||
from app.services.db_worker import enqueue_update_trade_history_by_order_id
|
||
await enqueue_update_trade_history_by_order_id(order_id, fields)
|
||
|
||
|
||
# ── [하드닝 R7 2026-10-10] 불성립 BUY 의 ActiveTrade 원복 ─────────────────────────
|
||
# 운영 9/28: 스윙 BUY #324(352820)·#325(006360)가 TradeHistory 에 COMPLETED·전량으로 남았으나
|
||
# ActiveTrade 는 17~32초 만에 닫혔고(동기화의 유령 행 정리로 추정) synced 재시딩·SELL·보유가 모두
|
||
# 없다. 같은 날 체결된 매수(005490·015760·033780)는 전부 synced 로 재시딩됐으므로 두 건은
|
||
# 0체결 소멸로 추정된다(KIS 체결조회로 운영자 확정 필요). 당시엔 체결조회 경로 자체가 없어
|
||
# (§8.5-27, 10/01 수정) CANCELLED 강등도 불가했다.
|
||
# 현재 코드는 0체결·잔량 소멸이면 TradeHistory 를 CANCELLED 로 강등하지만, 주문 시점에 만든
|
||
# 스윙 ActiveTrade 는 그대로 active 로 남겨 sync 의 유령 정리에 맡겼다(장부 불일치 창 + 그 사이
|
||
# 청산 판정이 존재하지 않는 포지션을 본다). 부분체결·잔량 소멸도 ActiveTrade 수량이 주문 수량이었다.
|
||
#
|
||
# 원복 정보는 v3 시그니처를 바꾸지 않도록 주문번호 키 레지스트리로 넘긴다(§4 시그니처 보존).
|
||
# 등록하지 않은 호출부(수동 매수·매도·결과 불명 resolver)는 동작 불변.
|
||
_buy_entry_rollbacks: dict[str, dict] = {}
|
||
|
||
|
||
def register_buy_entry_rollback_v2(
|
||
order_id, stock_code: str, strategy_name: str, quantity: int, accumulate: bool,
|
||
) -> None:
|
||
"""BUY 주문이 만든 ActiveTrade 의 원복 정보를 등록한다(당일, 프로세스 메모리)."""
|
||
key = _entry_fill_key_v2(order_id)
|
||
if not key or not strategy_name:
|
||
return
|
||
today = _get_kst_now().date().isoformat()
|
||
# 체결 확인이 목킹·예외로 소비하지 못한 지난 날짜 항목 정리(무한 증가 방지)
|
||
for k in [k for k, v in _buy_entry_rollbacks.items() if v.get("day") != today]:
|
||
_buy_entry_rollbacks.pop(k, None)
|
||
_buy_entry_rollbacks[key] = {
|
||
"day": today,
|
||
"stock_code": stock_code,
|
||
"strategy_name": strategy_name,
|
||
"quantity": int(quantity),
|
||
"accumulate": bool(accumulate),
|
||
}
|
||
|
||
|
||
def _pop_buy_entry_rollback_v2(order_id, stock_code: str) -> dict | None:
|
||
rb = _buy_entry_rollbacks.pop(_entry_fill_key_v2(order_id), None)
|
||
if not rb or rb.get("stock_code") != stock_code:
|
||
return None # 다른 종목 키 충돌(주문번호는 일별 순번) — 원복하지 않는다
|
||
if rb.get("day") != _get_kst_now().date().isoformat():
|
||
return None
|
||
return rb
|
||
|
||
|
||
def _notify_buy_ledger_v2(message: str) -> None:
|
||
try:
|
||
from app.services.telegram_notifier import telegram_notifier
|
||
spawn_tracked_task_v2(telegram_notifier.notify_system_warning("BUY_LEDGER", message))
|
||
except Exception as _tg_err:
|
||
logger.warning(f"[BUY_LEDGER] 텔레그램 통지 실패: {_tg_err}")
|
||
|
||
|
||
async def _rollback_buy_active_trade_v2(
|
||
order_id: str, rollback: dict | None, filled_qty: int,
|
||
) -> str:
|
||
"""불성립(0체결)·부분체결 확정 BUY 의 ActiveTrade 를 실제 체결 기준으로 원복(db_worker 큐).
|
||
|
||
반환: 'none'(등록 없음) | 'closed' | 'resized' | 'manual'(추가매수 — 수동 확인) | 'noop'.
|
||
|
||
- 신규 진입 + 0체결 → 그 전략명(동등) active 행 close. 이미 sync 가 닫았으면 워커가 no-op.
|
||
- 신규 진입 + 부분체결 확정 → quantity 를 체결수량으로(entry_price 키 없음 → 행이 없으면
|
||
워커가 생성하지 않고 skip). 체결가 보정(entry_fill_adjust)보다 **먼저** 큐잉해야 평단이 체결가가 된다.
|
||
- 추가매수(accumulate) → 가중평균·remaining_pct 재계산을 역산할 근거가 없어 원복하지 않는다.
|
||
error + 텔레그램으로 수동 확인을 요청한다(과다 수량이 남으면 분할매도가 과다매도 시도 →
|
||
매도 직전 KIS 잔고 상한이 막지만 장부는 틀린 상태).
|
||
"""
|
||
if not rollback:
|
||
return "none"
|
||
code = rollback["stock_code"]
|
||
strategy_name = rollback["strategy_name"]
|
||
ordered = int(rollback.get("quantity") or 0)
|
||
filled = max(0, int(filled_qty or 0))
|
||
if ordered > 0 and filled >= ordered:
|
||
return "noop"
|
||
if rollback.get("accumulate"):
|
||
logger.error(
|
||
f"[BUY_LEDGER] {code} 추가매수 {ordered}주 중 {filled}주만 체결 확정(order_id={order_id}) — "
|
||
f"ActiveTrade({strategy_name}) 누적 수량·평단 자동 원복 불가, 수동 확인 필요"
|
||
)
|
||
_notify_buy_ledger_v2(
|
||
f"{code} 추가매수 {filled}/{ordered}주 체결 확정 — ActiveTrade({strategy_name}) 수동 정정 필요"
|
||
)
|
||
return "manual"
|
||
if filled <= 0:
|
||
from app.services.db_worker import enqueue_close_active_trade
|
||
await enqueue_close_active_trade(code, strategy_name)
|
||
logger.warning(
|
||
f"[BUY_LEDGER] {code} 매수 0체결 소멸(order_id={order_id}) — "
|
||
f"ActiveTrade({strategy_name}) close 큐잉"
|
||
)
|
||
return "closed"
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
await enqueue_active_trade_upsert({
|
||
"stock_code": code, "strategy_name": strategy_name, "quantity": filled,
|
||
})
|
||
logger.warning(
|
||
f"[BUY_LEDGER] {code} 매수 부분체결 확정 {filled}/{ordered}주(order_id={order_id}) — "
|
||
f"ActiveTrade({strategy_name}) 수량 {ordered}→{filled}"
|
||
)
|
||
return "resized"
|
||
|
||
|
||
async def _verify_and_sync_execution(
|
||
order_id: str,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
ordered_quantity: int,
|
||
order_price: float,
|
||
order_type: str,
|
||
is_domestic: bool,
|
||
exchange_code: str,
|
||
db_trade_id: int,
|
||
delay: int = 3,
|
||
) -> None:
|
||
"""기존 시그니처 유지 래퍼 — 미체결 자동 취소 없음(시장가·주문종류 불명 경로).
|
||
|
||
[H-1 5회차] 미체결 취소는 `_verify_and_sync_execution_v2(cancel_unfilled_limit=True)` 로
|
||
**자기 ODNO 의 국내 지정가 부분 익절**에만 켠다. 시장가는 종가 단일가·VI·하한가에서 15초 넘게
|
||
미체결일 수 있고, 그 손절을 취소하면 청산이 사라진다.
|
||
"""
|
||
await _verify_and_sync_execution_v2(
|
||
order_id, stock_code, stock_name, ordered_quantity, order_price, order_type,
|
||
is_domestic, exchange_code, db_trade_id, delay=delay,
|
||
)
|
||
|
||
|
||
async def _verify_and_sync_execution_v2(
|
||
order_id: str,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
ordered_quantity: int,
|
||
order_price: float,
|
||
order_type: str,
|
||
is_domestic: bool,
|
||
exchange_code: str,
|
||
db_trade_id: int,
|
||
delay: int = 3,
|
||
cancel_unfilled_limit: bool = False,
|
||
rollback_active_trade: dict | None = None,
|
||
order_org_no: str | None = None,
|
||
) -> None:
|
||
"""기존 시그니처 유지 래퍼 — 본체는 `_verify_and_sync_execution_v3`."""
|
||
await _verify_and_sync_execution_v3(
|
||
order_id, stock_code, stock_name, ordered_quantity, order_price, order_type,
|
||
is_domestic, exchange_code, db_trade_id, delay=delay,
|
||
cancel_unfilled_limit=cancel_unfilled_limit,
|
||
rollback_active_trade=rollback_active_trade,
|
||
order_org_no=order_org_no,
|
||
)
|
||
|
||
|
||
# [2026-10-08] ActiveTrade 진입가 체결가 보정을 이미 큐잉한 BUY 주문번호(당일, 프로세스 메모리).
|
||
# swing/fill_sweep 이 같은 주문을 이중 보정하지 않게 한다(TradeHistory 갱신만 유실된 경우 등).
|
||
_entry_fill_adjusted_orders: dict[str, str] = {}
|
||
|
||
|
||
def _entry_fill_key_v2(order_id) -> str:
|
||
return str(order_id or "").strip().lstrip("0")
|
||
|
||
|
||
def note_entry_fill_adjusted_v2(order_id) -> None:
|
||
key = _entry_fill_key_v2(order_id)
|
||
if not key:
|
||
return
|
||
today = _get_kst_now().date().isoformat()
|
||
for k in [k for k, d in _entry_fill_adjusted_orders.items() if d != today]:
|
||
_entry_fill_adjusted_orders.pop(k, None)
|
||
_entry_fill_adjusted_orders[key] = today
|
||
|
||
|
||
def entry_fill_already_adjusted_v2(order_id) -> bool:
|
||
key = _entry_fill_key_v2(order_id)
|
||
return bool(key) and _entry_fill_adjusted_orders.get(key) == _get_kst_now().date().isoformat()
|
||
|
||
|
||
# ── [하드닝 R3 2026-10-09] 기존 스윙 ActiveTrade 진입가 1회성 백필 ─────────────────
|
||
# 진입 upsert 는 주문 지정가(현재가×~1.005)를 entry_price 로 기록한다. 체결 확인 시 보정
|
||
# (entry_fill_adjust / swing.fill_sweep)은 **앞으로의 체결**과 **당일·미확인 행**에만 적용돼,
|
||
# 이미 체결가가 확정된 과거 BUY 의 ActiveTrade 는 주문가로 남는다(운영 active 5행 +0.3~0.8%).
|
||
# 그 결과 손절이 실제 평단 기준 -7% 가 아니라 약 -6.3% 에서, 1차 익절 최소수익 가드가 실제로는
|
||
# 약 1.3% 에서 걸리고 SELL net_profit_loss 가 과소 기록된다.
|
||
# 아래 함수들이 "확정 가능한 행만" 골라 db_worker 의 entry_fill_adjust 경로로 보정한다.
|
||
# 확정할 수 없으면 보정하지 않고 사유를 돌려준다(엉뚱한 행의 진입가를 움직이지 않는다).
|
||
|
||
# ActiveTrade 생성 시각보다 이 초 이전까지의 BUY 를 '그 행을 만든 매수'로 본다
|
||
# (executor 는 TradeHistory INSERT 직후 ActiveTrade upsert 를 큐잉한다 — 운영 실측 차이 <0.1초).
|
||
_ENTRY_BACKFILL_MATCH_WINDOW_SEC = 120
|
||
# Numeric(15,2) 반올림·가중평균 누적 반올림 허용 오차(원)
|
||
_ENTRY_BACKFILL_PRICE_TOL = 0.05
|
||
_ENTRY_BACKFILL_SWING_BUY_TYPES = (None, "", "swing")
|
||
_ENTRY_BACKFILL_SEEDED_NAMES = ("synced",)
|
||
_ENTRY_BACKFILL_SEEDED_REASON_PREFIXES = ("동기화 유입", "외부 유입 포지션")
|
||
|
||
|
||
def _entry_backfill_is_seeded_v2(row) -> bool:
|
||
name = (getattr(row, "strategy_name", None) or "").strip()
|
||
reason = (getattr(row, "entry_reason", None) or "").strip()
|
||
return name in _ENTRY_BACKFILL_SEEDED_NAMES or reason.startswith(_ENTRY_BACKFILL_SEEDED_REASON_PREFIXES)
|
||
|
||
|
||
def _entry_backfill_fill_confirmed_v2(th) -> bool:
|
||
"""swing.fill_sweep.unconfirmed_fill_clause_v2 의 부정(파이썬 판정, 같은 정의).
|
||
|
||
미확인 = 체결가 NULL, 또는 레거시 규약(체결가=주문가 대체 + slippage NULL).
|
||
"""
|
||
ep = getattr(th, "executed_price", None)
|
||
if ep is None:
|
||
return False
|
||
op = getattr(th, "order_price", None)
|
||
if getattr(th, "slippage", None) is None and op is not None and float(ep) == float(op):
|
||
return False
|
||
return True
|
||
|
||
|
||
def plan_swing_entry_backfill_v2(active_row, same_stock_active_rows, buy_rows) -> tuple[dict | None, str]:
|
||
"""기존 스윙 ActiveTrade 1행의 진입가 백필 payload 를 계산한다 (순수 함수, I/O 없음).
|
||
|
||
Args:
|
||
active_row: 대상 ActiveTrade(status=active).
|
||
same_stock_active_rows: 같은 종목의 active ActiveTrade 전체(대상 포함) — db_worker 가
|
||
전략명으로 고를 행(같은 전략명 중 id 최대)이 대상과 같은지 확인용.
|
||
buy_rows: 같은 종목 TradeHistory BUY 후보(필터 전이어도 된다 — 여기서 거른다).
|
||
|
||
Returns:
|
||
(payload | None, 사유). payload 는 `enqueue_active_trade_upsert` 에 그대로 넘긴다.
|
||
보정 방식은 entry_fill_adjust 델타(order_price=현재 entry_price 스냅샷, filled_price=목표,
|
||
filled_qty=행 수량)라서, 큐 처리 시점의 행이 스냅샷과 같으면 정확히 목표가가 되고
|
||
두 번 실행해도 두 번째는 델타 0 이다(재계산 시 이미 보정됨으로 skip).
|
||
"""
|
||
from app.services.db_worker import DT_STRATEGY_NAMES
|
||
|
||
name = (getattr(active_row, "strategy_name", None) or "").strip()
|
||
code = getattr(active_row, "stock_code", None)
|
||
if getattr(active_row, "status", "active") != "active":
|
||
return None, "active 아님"
|
||
if not name:
|
||
return None, "strategy_name 없음(대상 행 확정 불가)"
|
||
if name in DT_STRATEGY_NAMES:
|
||
return None, "데이트레이딩 행"
|
||
if _entry_backfill_is_seeded_v2(active_row):
|
||
return None, "시딩(동기화 유입) 행 — entry_price 가 KIS 평단"
|
||
if (getattr(active_row, "currency_code", None) or "KRW") != "KRW":
|
||
return None, "해외 행"
|
||
|
||
eligible = [
|
||
r for r in (same_stock_active_rows or [])
|
||
if getattr(r, "status", "active") == "active"
|
||
and (getattr(r, "strategy_name", None) or "").strip() == name
|
||
]
|
||
if eligible:
|
||
newest = max(eligible, key=lambda r: int(getattr(r, "id", 0) or 0))
|
||
if getattr(newest, "id", None) != getattr(active_row, "id", None):
|
||
return None, f"전략명 {name} 의 최신 active 행(id={getattr(newest, 'id', None)})이 대상이 아님"
|
||
|
||
try:
|
||
cur = float(getattr(active_row, "entry_price", 0) or 0)
|
||
rec_q = int(getattr(active_row, "quantity", 0) or 0)
|
||
rp = float(getattr(active_row, "remaining_pct", 1.0) if getattr(active_row, "remaining_pct", None) is not None else 1.0)
|
||
except (TypeError, ValueError):
|
||
return None, "행 수치 파싱 실패"
|
||
if cur <= 0 or rec_q <= 0:
|
||
return None, "entry_price/quantity 비정상"
|
||
if rec_q * min(1.0, max(0.0, rp)) < 1:
|
||
return None, "실보유(quantity×remaining_pct) < 1주"
|
||
|
||
created = getattr(active_row, "created_at", None)
|
||
if created is None:
|
||
return None, "ActiveTrade.created_at 없음"
|
||
lo = created - timedelta(seconds=_ENTRY_BACKFILL_MATCH_WINDOW_SEC)
|
||
buys = sorted(
|
||
[
|
||
t for t in (buy_rows or [])
|
||
if getattr(t, "stock_code", code) == code
|
||
and getattr(t, "order_type", None) == "BUY"
|
||
and getattr(t, "status", None) == "COMPLETED"
|
||
and getattr(t, "strategy_type", None) in _ENTRY_BACKFILL_SWING_BUY_TYPES
|
||
and (getattr(t, "currency_code", None) or "KRW") == "KRW"
|
||
and getattr(t, "created_at", None) is not None
|
||
and t.created_at >= lo
|
||
],
|
||
key=lambda t: (t.created_at, int(getattr(t, "id", 0) or 0)),
|
||
)
|
||
if not buys:
|
||
return None, "대응 스윙 BUY 없음"
|
||
unconfirmed = [getattr(t, "id", None) for t in buys if not _entry_backfill_fill_confirmed_v2(t)]
|
||
if unconfirmed:
|
||
return None, f"체결가 미확정 BUY {unconfirmed} (레거시 규약 — 수동 확인)"
|
||
try:
|
||
qs = [int(getattr(t, "executed_quantity", 0) or 0) for t in buys]
|
||
ops = [float(getattr(t, "order_price", 0) or 0) for t in buys]
|
||
fps = [float(getattr(t, "executed_price", 0) or 0) for t in buys]
|
||
except (TypeError, ValueError):
|
||
return None, "BUY 수치 파싱 실패"
|
||
if any(q <= 0 for q in qs) or any(p <= 0 for p in ops) or any(p <= 0 for p in fps):
|
||
return None, "BUY 수량/가격 비정상(부분·0체결 포함)"
|
||
if sum(qs) != rec_q:
|
||
return None, f"BUY 체결수량 합 {sum(qs)} ≠ 행 수량 {rec_q} (부분체결·수동 개입 — 수동 확인)"
|
||
if len(buys) > 1 and rp < 1.0:
|
||
return None, "분할 익절 후 추가매수 행 — 가중치 재구성 불가(수동 확인)"
|
||
last_reason = (getattr(buys[-1], "entry_reason", None) or "").strip()
|
||
row_reason = (getattr(active_row, "entry_reason", None) or "").strip()
|
||
if last_reason and row_reason and last_reason != row_reason:
|
||
return None, "최신 BUY 의 entry_reason 이 행과 다름(다른 매수의 행)"
|
||
|
||
total_q = float(sum(qs))
|
||
target = round(sum(f * q for f, q in zip(fps, qs)) / total_q, 2)
|
||
expected_unadjusted = sum(o * q for o, q in zip(ops, qs)) / total_q
|
||
if abs(cur - target) <= _ENTRY_BACKFILL_PRICE_TOL:
|
||
return None, "이미 체결가 기준"
|
||
if abs(cur - expected_unadjusted) > _ENTRY_BACKFILL_PRICE_TOL:
|
||
return None, (
|
||
f"현재 진입가 {cur:,.2f} 가 주문가 기준({expected_unadjusted:,.2f})도 체결가 기준({target:,.2f})도 "
|
||
f"아님 — 수동 확인"
|
||
)
|
||
|
||
payload = {
|
||
"stock_code": code,
|
||
"strategy_name": name,
|
||
"entry_fill_adjust": {
|
||
"order_price": cur,
|
||
"filled_price": target,
|
||
"filled_qty": rec_q,
|
||
},
|
||
}
|
||
high = getattr(active_row, "highest_since_entry", None)
|
||
# 고점이 진입 주문가 그대로(진입 후 갱신된 적 없음)면 함께 내린다. 갱신됐으면 실제 관측 고점이라 유지.
|
||
if high is None or abs(float(high) - cur) <= _ENTRY_BACKFILL_PRICE_TOL:
|
||
payload["highest_since_entry"] = target
|
||
return payload, f"{cur:,.2f} → {target:,.2f}"
|
||
|
||
|
||
|
||
async def collect_swing_entry_backfill_v2(db) -> list[dict]:
|
||
"""운영 active 스윙 ActiveTrade 전체의 백필 계획을 만든다 (SELECT 전용, commit 없음).
|
||
|
||
Returns:
|
||
[{"active_id", "stock_code", "strategy_name", "entry_price", "payload"|None, "reason"}]
|
||
"""
|
||
from app.models.models import ActiveTrade
|
||
from app.services.db_worker import DT_STRATEGY_NAMES
|
||
|
||
rows = (await db.execute(
|
||
select(ActiveTrade).where(ActiveTrade.status == "active").order_by(ActiveTrade.id)
|
||
)).scalars().all()
|
||
by_code: dict[str, list] = {}
|
||
for r in rows:
|
||
by_code.setdefault(r.stock_code, []).append(r)
|
||
plans: list[dict] = []
|
||
for r in rows:
|
||
name = (r.strategy_name or "").strip()
|
||
if name in DT_STRATEGY_NAMES or _entry_backfill_is_seeded_v2(r):
|
||
continue
|
||
buys = []
|
||
if r.created_at is not None:
|
||
buys = (await db.execute(
|
||
select(TradeHistory).where(
|
||
TradeHistory.stock_code == r.stock_code,
|
||
TradeHistory.order_type == "BUY",
|
||
TradeHistory.created_at >= r.created_at - timedelta(seconds=_ENTRY_BACKFILL_MATCH_WINDOW_SEC),
|
||
)
|
||
)).scalars().all()
|
||
payload, reason = plan_swing_entry_backfill_v2(r, by_code.get(r.stock_code, []), buys)
|
||
plans.append({
|
||
"active_id": r.id,
|
||
"stock_code": r.stock_code,
|
||
"strategy_name": r.strategy_name,
|
||
"entry_price": float(r.entry_price) if r.entry_price is not None else None,
|
||
"payload": payload,
|
||
"reason": reason,
|
||
})
|
||
return plans
|
||
|
||
|
||
async def apply_swing_entry_backfill_v2(plans: list[dict], submit=None) -> int:
|
||
"""계획 중 payload 가 있는 것만 db_worker upsert_active_trade 로 제출한다. 반환 = 제출 건수.
|
||
|
||
submit 기본값은 `enqueue_active_trade_upsert`(앱 프로세스 안 — 워커가 처리).
|
||
앱 밖 1회성 스크립트는 워커가 없으므로 `db_worker._execute_db_task_impl` 로 같은 핸들러를
|
||
직접 실행하는 submit 을 넘긴다(backend/backfill_swing_entry_fill.py).
|
||
"""
|
||
if submit is None:
|
||
from app.services.db_worker import enqueue_active_trade_upsert as submit
|
||
n = 0
|
||
for p in plans:
|
||
payload = p.get("payload")
|
||
if not payload:
|
||
continue
|
||
await submit(dict(payload))
|
||
n += 1
|
||
return n
|
||
|
||
|
||
def _fill_update_fields_v2(
|
||
order_type: str,
|
||
filled_qty: int,
|
||
filled_price: float,
|
||
slippage_pct: float,
|
||
sell_pnl_basis: dict | None,
|
||
) -> dict:
|
||
"""[2026-10-08] 체결 확인 결과 → TradeHistory 갱신 필드 (순수 함수).
|
||
|
||
- executed_price·executed_quantity·total_amount(=체결가×체결수량) 를 **함께** 갱신한다.
|
||
이전엔 total_amount 가 주문가×주문수량으로 남아(#448 한화엔진 41,506×9) 매수 합계가
|
||
주문가 기준이었다.
|
||
- 체결가를 모르면(filled_price ≤ 0) 가격·금액 필드를 넣지 않는다 — 주문가로 대체 금지.
|
||
- SELL + sell_pnl_basis(entry_price>0) 이면 순손익·비용·수익률을 체결가 기준으로 재계산한다.
|
||
net_rate=False 면 profit_loss_rate 는 기존 executor 규약대로 비용 전(gross) 수익률.
|
||
"""
|
||
fields: dict = {
|
||
"executed_quantity": int(filled_qty),
|
||
"status": "COMPLETED",
|
||
"executed_at": _get_kst_now(),
|
||
}
|
||
if filled_price and filled_price > 0:
|
||
fields["executed_price"] = Decimal(str(round(float(filled_price), 2)))
|
||
fields["total_amount"] = Decimal(str(round(float(filled_price) * int(filled_qty), 2)))
|
||
fields["slippage"] = Decimal(str(round(slippage_pct, 4)))
|
||
basis = sell_pnl_basis or {}
|
||
entry = float(basis.get("entry_price") or 0)
|
||
if order_type == "SELL" and entry > 0 and filled_qty > 0:
|
||
costs = calculate_trade_costs(
|
||
entry_price=entry, exit_price=float(filled_price), quantity=int(filled_qty),
|
||
is_domestic=bool(basis.get("is_domestic", True)),
|
||
market=basis.get("market") or "KOSPI",
|
||
)
|
||
gross = (float(filled_price) - entry) * int(filled_qty)
|
||
net = gross - float(costs["total_cost"])
|
||
if basis.get("net_rate"):
|
||
rate = net / (entry * int(filled_qty)) * 100
|
||
else:
|
||
rate = (float(filled_price) / entry - 1.0) * 100
|
||
fields["commission"] = Decimal(str(costs["total_cost"]))
|
||
fields["net_profit_loss"] = Decimal(str(round(net, 2)))
|
||
fields["profit_loss_rate"] = Decimal(str(round(rate, 4)))
|
||
return fields
|
||
|
||
|
||
# ── [하드닝 R1 2026-10-09] 슬리피지 부호 규약 ─────────────────────────────────
|
||
# TradeHistory.slippage 저장 규약(변경하지 않음 — DT entry_service 와 같은 컬럼을 공유하므로
|
||
# 한쪽만 바꾸면 컬럼 안에 두 규약이 섞인다):
|
||
# slippage = (체결가 − 주문가) / 주문가 × 100 [단위 %, side 무관 원시값]
|
||
# → BUY 에서 + 는 불리(비싸게 삼), SELL 에서 + 는 유리(비싸게 팜).
|
||
# 따라서 BUY/SELL 을 섞어 평균하면 상쇄되어 실행 비용이 과소 보고된다. 분석·로그는 반드시
|
||
# slippage_cost_bp_v2 로 side 보정(불리 = +)한 bp 를 쓸 것.
|
||
def slippage_cost_bp_v2(order_type: str, slippage_pct) -> float | None:
|
||
"""원시 슬리피지(%) → side 보정 비용(bp, 불리 = +). 해석 불가면 None."""
|
||
try:
|
||
val = float(slippage_pct)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
if val != val or val in (float("inf"), float("-inf")):
|
||
return None
|
||
side = str(order_type or "").upper()
|
||
if side == "BUY":
|
||
sign = 1.0
|
||
elif side == "SELL":
|
||
sign = -1.0
|
||
else:
|
||
return None
|
||
return sign * val * 100.0
|
||
|
||
|
||
# ── [하드닝 R1 2026-10-09] ActiveTrade 손절·익절 컬럼 = 절대가 ──────────────────
|
||
def _swing_active_trade_levels_v2(entry_price, atr, take_profit_pct) -> tuple[float | None, float | None]:
|
||
"""스윙 ActiveTrade.stop_loss / take_profit 에 저장할 **절대가**를 계산한다.
|
||
|
||
이전엔 추천 actions 의 퍼센트(-1.50 / 3.00)를 그대로 넣어 같은 컬럼에 퍼센트와 절대가
|
||
(sync 시딩·DT)가 섞였고, 저장된 -1.5% 는 실제 손절선(적응형 → strategy_cfg → config)과
|
||
무관했다. 스윙 청산 판정은 이 컬럼을 읽지 않으므로(매매 동작 무변경) 표시·감사·
|
||
재시딩 승계(portfolio.py: `> 0` 일 때만 승계 = 가격 규약)용이다.
|
||
|
||
- stop_loss: swing/exit_service 와 같은 식 — resolve_swing_stop_params_v2 의 손절률(항상 음수)
|
||
로 만든 가격과 ATR 손절가(진입가 − 배수×ATR) 중 **높은 쪽**(가격 기준 타이트, §5.2).
|
||
해석기 예외 시 config STOP_LOSS_PERCENT 로 폴백(-abs 부호 가드는 try 밖).
|
||
- take_profit: 호출부가 준 퍼센트를 절대가로 환산만 한다(값 무변경). 없거나 0 이하면 None.
|
||
"""
|
||
try:
|
||
entry = float(entry_price)
|
||
except (TypeError, ValueError):
|
||
return None, None
|
||
if not (entry > 0):
|
||
return None, None
|
||
try:
|
||
atr_f = float(atr or 0)
|
||
except (TypeError, ValueError):
|
||
atr_f = 0.0
|
||
if atr_f != atr_f or atr_f < 0:
|
||
atr_f = 0.0
|
||
|
||
stop_pct = None
|
||
atr_mult = float(settings.ATR_STOP_MULTIPLIER)
|
||
try:
|
||
from app.services.mean_reversion_strategy import resolve_swing_stop_params_v2
|
||
stop_pct, atr_mult = resolve_swing_stop_params_v2(atr_f if atr_f > 0 else None, entry)
|
||
except Exception as _res_err:
|
||
logger.warning(
|
||
"[BUY] 스윙 손절 파라미터 해석 실패 — config STOP_LOSS_PERCENT 로 ActiveTrade 손절가 기록: %s",
|
||
_res_err,
|
||
)
|
||
stop_pct = None
|
||
if stop_pct is None:
|
||
stop_pct = float(settings.STOP_LOSS_PERCENT)
|
||
stop_pct = -abs(float(stop_pct)) # 부호 가드 — try 밖 (양수 손절률 → 진입가 위 손절가 방지)
|
||
stop_price = entry * (1 + stop_pct / 100)
|
||
if atr_f > 0 and atr_mult and atr_mult > 0:
|
||
atr_stop = entry - float(atr_mult) * atr_f
|
||
if 0 < atr_stop < entry:
|
||
stop_price = max(stop_price, atr_stop)
|
||
stop_price = round(stop_price, 2) if 0 < stop_price < entry else None
|
||
|
||
tp_price = None
|
||
try:
|
||
tp = abs(float(take_profit_pct)) if take_profit_pct is not None else 0.0
|
||
except (TypeError, ValueError):
|
||
tp = 0.0
|
||
if tp > 0 and tp == tp and tp != float("inf"):
|
||
tp_price = round(entry * (1 + tp / 100), 2)
|
||
return stop_price, tp_price
|
||
|
||
|
||
# ── [하드닝 R1 2026-10-09] 백그라운드 태스크 강참조 ─────────────────────────────
|
||
# asyncio 이벤트 루프는 태스크를 약참조로만 들고 있어, 반환값을 버린 create_task 는 실행 중
|
||
# GC 로 사라질 수 있다(체결 확인·미체결 지정가 취소·진입가 보정 유실). 이 모듈의 백그라운드
|
||
# 태스크는 전부 spawn_tracked_task_v2 로 만들고, 종료 시 drain_tracked_tasks_v2 로 기다린다.
|
||
_tracked_bg_tasks: "set[asyncio.Task]" = set()
|
||
|
||
|
||
def _on_tracked_task_done_v2(task: "asyncio.Task") -> None:
|
||
_tracked_bg_tasks.discard(task)
|
||
if task.cancelled():
|
||
return
|
||
exc = task.exception()
|
||
if exc is not None:
|
||
logger.warning(
|
||
"[BG_TASK] 백그라운드 태스크 예외 종료 (%s): %r", task.get_name(), exc,
|
||
)
|
||
|
||
|
||
def spawn_tracked_task_v2(coro, *, name: str | None = None) -> "asyncio.Task":
|
||
"""강참조를 보관하는 create_task. 완료 시 자동 제거 + 예외는 warning 으로 남긴다."""
|
||
task = asyncio.get_running_loop().create_task(coro, name=name)
|
||
_tracked_bg_tasks.add(task)
|
||
task.add_done_callback(_on_tracked_task_done_v2)
|
||
return task
|
||
|
||
|
||
def pending_tracked_tasks_count_v2() -> int:
|
||
return sum(1 for t in _tracked_bg_tasks if not t.done())
|
||
|
||
|
||
async def drain_tracked_tasks_v2(timeout: float) -> int:
|
||
"""종료 시 추적 태스크를 최대 timeout 초 기다리고 남은 것은 cancel. 취소한 개수를 반환."""
|
||
loop = asyncio.get_running_loop()
|
||
# 다른(이미 닫힌) 루프의 태스크는 기다릴 수 없다 — 집합에서 정리만 한다.
|
||
for t in [t for t in list(_tracked_bg_tasks) if t.get_loop() is not loop]:
|
||
_tracked_bg_tasks.discard(t)
|
||
pending = [t for t in list(_tracked_bg_tasks) if not t.done()]
|
||
if not pending:
|
||
return 0
|
||
_done, still = await asyncio.wait(pending, timeout=max(0.0, float(timeout)))
|
||
for t in still:
|
||
t.cancel()
|
||
if still:
|
||
logger.warning(
|
||
"[BG_TASK] 종료 drain %.1fs 초과 — 미완료 백그라운드 태스크 %d건 취소 "
|
||
"(체결 확인·미체결 취소 누락 가능, 수동 확인 필요)", float(timeout), len(still),
|
||
)
|
||
await asyncio.gather(*still, return_exceptions=True)
|
||
return len(still)
|
||
|
||
|
||
# ── [하드닝 R1 2026-10-09] 결과 불명 BUY 정정 (§8.5-34) ─────────────────────────
|
||
# 전송 후 응답 유실(KIS_TRANSPORT_UNKNOWN 등)인 BUY 는 PENDING 으로 기록되고, 체결 확인·
|
||
# ActiveTrade 생성이 `if success:` 안에만 있어 실행되지 않았다. 실제 체결이면 ActiveTrade 없는
|
||
# 보유 → sync 가 'synced'(-7% 고정·TP 없음)로 편입했고, 미접수면 PENDING 이 당일 재매수 차단·
|
||
# 일일 슬롯을 영구히 소진했다. 아래 resolver 가 당일 주문내역(엄격 조회: 실패를 '없음'과 구분)
|
||
# 으로 접수 여부를 확정한다. 이 상수들은 조회 타이밍이며 전략 파라미터가 아니다.
|
||
_UNKNOWN_BUY_ORDER_ID_PREFIX = "UNK-"
|
||
_UNKNOWN_BUY_RESOLVE_DELAYS_SEC = (3, 10, 30) # 누적 ≈43초 — KIS 주문내역 반영 지연 흡수
|
||
_UNKNOWN_BUY_ORDER_TIME_SLACK_SEC = 10 # 주문 전송 시각 이전 ord_tmd 허용 오차(시계 차)
|
||
|
||
|
||
def _unknown_order_placeholder_id_v2(stock_code: str, order_type: str = "BUY") -> str:
|
||
"""결과 불명 주문의 TradeHistory.order_id 자리표시자 — ODNO 가 없어 행을 다시 찾을 수 없었다.
|
||
|
||
db_worker 의 order_id 갱신은 당일+최신 1행 규약이라 이 값으로 같은 행을 정정할 수 있다.
|
||
KIS ODNO(숫자)와 겹치지 않도록 접두사를 둔다.
|
||
"""
|
||
side = (order_type or "X")[:1].upper()
|
||
return f"{_UNKNOWN_BUY_ORDER_ID_PREFIX}{side}{stock_code}-{_get_kst_now():%H%M%S%f}"
|
||
|
||
|
||
async def _lookup_todays_orders_strict_v2(stock_code: str) -> list | None:
|
||
"""당일 주문내역 — 조회 실패면 None (get_todays_orders 는 실패도 [] 라 '없음'과 구분 불가)."""
|
||
try:
|
||
result, _ = await korea_investment_api._daily_ccld_fetch_v2(stock_code=stock_code)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[ORDER_UNKNOWN] {stock_code} 당일 주문내역 조회 예외: {type(e).__name__}: {e}"
|
||
)
|
||
return None
|
||
if not isinstance(result, dict) or str(result.get("rt_cd")) != "0":
|
||
logger.warning(
|
||
f"[ORDER_UNKNOWN] {stock_code} 당일 주문내역 조회 실패 "
|
||
f"(rt_cd={(result or {}).get('rt_cd') if isinstance(result, dict) else None})"
|
||
)
|
||
return None
|
||
out = result.get("output1") or []
|
||
return out if isinstance(out, list) else [out]
|
||
|
||
|
||
def _match_unknown_buy_order_v2(rows: list, stock_code: str, quantity: int, sent_at) -> dict | None:
|
||
"""주문내역에서 '이 BUY' 로 볼 수 있는 행 — 같은 종목·매수·수량, 전송 시각(−오차) 이후.
|
||
|
||
여러 건이면 전송 시각에 가장 가까운 행. 시각을 못 읽는 행은 후보에서 뺀다(오귀속 방지).
|
||
"""
|
||
try:
|
||
sent_sec = sent_at.hour * 3600 + sent_at.minute * 60 + sent_at.second
|
||
except AttributeError:
|
||
return None
|
||
best, best_gap = None, None
|
||
for row in rows or []:
|
||
try:
|
||
if not isinstance(row, dict) or row.get("pdno") != stock_code:
|
||
continue
|
||
if row.get("sll_buy_dvsn_cd") not in ("02", None, ""):
|
||
continue
|
||
if int(row.get("ord_qty", 0) or 0) != int(quantity):
|
||
continue
|
||
if not row.get("odno"):
|
||
continue
|
||
_t = str(row.get("ord_tmd") or "")
|
||
if len(_t) != 6 or not _t.isdigit():
|
||
continue
|
||
ord_sec = int(_t[:2]) * 3600 + int(_t[2:4]) * 60 + int(_t[4:])
|
||
gap = ord_sec - sent_sec
|
||
if gap < -_UNKNOWN_BUY_ORDER_TIME_SLACK_SEC:
|
||
continue
|
||
if best_gap is None or abs(gap) < best_gap:
|
||
best, best_gap = row, abs(gap)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return best
|
||
|
||
|
||
def _notify_order_unknown_v2(message: str) -> None:
|
||
try:
|
||
from app.services.telegram_notifier import telegram_notifier
|
||
spawn_tracked_task_v2(telegram_notifier.notify_system_warning("ORDER_UNKNOWN", message))
|
||
except Exception as _tg_err:
|
||
logger.warning(f"[ORDER_UNKNOWN] 텔레그램 통지 실패: {_tg_err}")
|
||
|
||
|
||
async def _resolve_unknown_buy_v2(ctx: dict) -> str:
|
||
"""결과 불명 BUY 를 당일 주문내역으로 확정한다. 반환: 'failed'|'cancelled'|'accepted'|'unresolved'.
|
||
|
||
ctx 키: placeholder_id, stock_code, stock_name, quantity, order_price, sent_at(KST naive),
|
||
is_domestic, holding(bool), strategy_type, strategy_name, entry_reason, atr, take_profit
|
||
|
||
- 미접수(마지막 조회 성공 + 일치 주문 없음) → FAILED + 사이클 매수 누적 제외
|
||
- 접수 + 0체결·잔량 소멸 → CANCELLED
|
||
- 접수(체결 또는 미체결 대기) → COMPLETED + ActiveTrade 생성(정상 매수 경로와 같은 규약),
|
||
체결가를 알면 체결 기준 금액으로 갱신
|
||
- 조회 실패(마지막 시도) 또는 해외 → PENDING 유지 + error + 텔레그램(수동 확인)
|
||
TradeHistory 는 자리표시자 order_id 로 db_worker 큐 경유 갱신한다(§3.2).
|
||
"""
|
||
code = ctx["stock_code"]
|
||
qty = int(ctx["quantity"])
|
||
pid = ctx["placeholder_id"]
|
||
strategy_type = ctx.get("strategy_type") or "swing"
|
||
tag = f"[ORDER_UNKNOWN] {code}/{ctx.get('stock_name', '')} BUY {qty}주"
|
||
from app.services.db_worker import enqueue_update_trade_history_by_order_id
|
||
|
||
if not ctx.get("is_domestic", True):
|
||
await asyncio.sleep(_UNKNOWN_BUY_RESOLVE_DELAYS_SEC[0])
|
||
logger.error(f"{tag} 해외 주문은 주문내역 대조 미지원 — PENDING 유지, 수동 확인 필요 (order_id={pid})")
|
||
_notify_order_unknown_v2(f"{code} 해외 BUY {qty}주 결과 불명 — 수동 확인 필요")
|
||
await _delayed_sync_portfolio(0)
|
||
return "unresolved"
|
||
|
||
rows, match = None, None
|
||
for _delay in _UNKNOWN_BUY_RESOLVE_DELAYS_SEC:
|
||
await asyncio.sleep(_delay)
|
||
rows = await _lookup_todays_orders_strict_v2(code)
|
||
if rows is None:
|
||
continue
|
||
match = _match_unknown_buy_order_v2(rows, code, qty, ctx.get("sent_at"))
|
||
if match is not None:
|
||
break
|
||
|
||
if match is None:
|
||
if rows is None:
|
||
# 마지막 조회가 실패 — 접수 여부를 모른다. FAILED 로 단정하면 체결분이 관리 밖에 놓인다.
|
||
logger.error(
|
||
f"{tag} 주문내역 조회 {len(_UNKNOWN_BUY_RESOLVE_DELAYS_SEC)}회 실패/미확정 — "
|
||
f"PENDING 유지, 수동 확인 필요 (order_id={pid})"
|
||
)
|
||
_notify_order_unknown_v2(f"{code} BUY {qty}주 결과 불명·주문내역 조회 실패 — 수동 확인 필요")
|
||
await _delayed_sync_portfolio(0)
|
||
return "unresolved"
|
||
await enqueue_update_trade_history_by_order_id(pid, {
|
||
"status": "FAILED", "executed_quantity": 0,
|
||
"order_type": "BUY", "strategy_type": strategy_type,
|
||
})
|
||
_forget_cycle_buy_v2(code, f"결과 불명 BUY 미접수 확정 (order_id={pid})")
|
||
logger.warning(f"{tag} 결과 불명 → 당일 주문내역에 없음, FAILED 로 정정 (order_id={pid})")
|
||
_notify_order_unknown_v2(f"{code} BUY {qty}주 결과 불명 → 미접수 확인(FAILED)")
|
||
await _delayed_sync_portfolio(0)
|
||
return "failed"
|
||
|
||
odno = str(match.get("odno"))
|
||
try:
|
||
info = await korea_investment_api.get_order_execution(odno, True) or {}
|
||
except Exception as e:
|
||
logger.warning(f"{tag} 체결 조회 예외(odno={odno}): {type(e).__name__}: {e} — 접수로 처리")
|
||
info = {}
|
||
filled_qty = min(int(info.get("filled_qty", 0) or 0), qty)
|
||
filled_price = float(info.get("filled_price") or 0)
|
||
remaining = info.get("remaining_qty")
|
||
|
||
if info.get("found") and filled_qty == 0 and (remaining == 0 or info.get("cancelled")):
|
||
await enqueue_update_trade_history_by_order_id(pid, {
|
||
"status": "CANCELLED", "executed_quantity": 0,
|
||
"order_type": "BUY", "strategy_type": strategy_type,
|
||
})
|
||
_forget_cycle_buy_v2(code, f"결과 불명 BUY 0체결·잔량 소멸 (odno={odno})")
|
||
logger.warning(f"{tag} 접수됐으나 0체결·잔량 소멸 → CANCELLED (odno={odno})")
|
||
_notify_order_unknown_v2(f"{code} BUY {qty}주 결과 불명 → 접수·미체결 소멸(CANCELLED, odno={odno})")
|
||
await _delayed_sync_portfolio(0)
|
||
return "cancelled"
|
||
|
||
# 접수 확정 — 정상 매수 경로(success)와 같은 규약: 주문 수량으로 COMPLETED + ActiveTrade.
|
||
# 부분체결·잔량 소멸만 체결분으로 줄인다. 잔량이 살아 있으면 정상 경로처럼 sync 가 진실.
|
||
order_price = float(ctx.get("order_price") or 0)
|
||
rec_qty = filled_qty if (0 < filled_qty < qty and remaining == 0) else qty
|
||
if filled_qty > 0 and filled_price > 0 and (filled_qty >= qty or remaining == 0):
|
||
slip = ((filled_price - order_price) / order_price * 100) if order_price > 0 else 0.0
|
||
fields = _fill_update_fields_v2("BUY", rec_qty, filled_price, slip, None)
|
||
else:
|
||
fields = {"status": "COMPLETED", "executed_quantity": qty, "executed_at": _get_kst_now()}
|
||
fields["message"] = f"자동매수(결과 불명→접수 확인 odno={odno})"
|
||
fields["order_type"] = "BUY"
|
||
fields["strategy_type"] = strategy_type
|
||
await enqueue_update_trade_history_by_order_id(pid, fields)
|
||
|
||
entry_price = filled_price if (filled_price > 0 and filled_qty > 0) else order_price
|
||
_at_stop_price, _at_tp_price = _swing_active_trade_levels_v2(
|
||
entry_price, ctx.get("atr"), ctx.get("take_profit", 5.0),
|
||
)
|
||
try:
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
await enqueue_active_trade_upsert({
|
||
"stock_code": code,
|
||
"stock_name": ctx.get("stock_name"),
|
||
"accumulate_entry": bool(ctx.get("holding")),
|
||
"quantity": rec_qty,
|
||
"entry_price": entry_price,
|
||
"strategy_name": ctx.get("strategy_name") or strategy_type,
|
||
"stop_loss": _at_stop_price,
|
||
"take_profit": _at_tp_price,
|
||
"entry_reason": ctx.get("entry_reason"),
|
||
"highest_since_entry": entry_price,
|
||
})
|
||
except Exception as _at_err:
|
||
logger.warning(f"{tag} ActiveTrade 생성 실패: {_at_err}")
|
||
logger.warning(
|
||
f"{tag} 결과 불명 → 접수 확인(odno={odno}, 체결 {filled_qty}/{qty}주, 잔량={remaining}) "
|
||
f"— COMPLETED·ActiveTrade 등록"
|
||
)
|
||
_notify_order_unknown_v2(
|
||
f"{code} BUY {qty}주 결과 불명 → 접수 확인(odno={odno}, 체결 {filled_qty}주) — 포지션 관리 등록"
|
||
)
|
||
await _delayed_sync_portfolio(0)
|
||
return "accepted"
|
||
|
||
|
||
async def _verify_and_sync_execution_v3(
|
||
order_id: str,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
ordered_quantity: int,
|
||
order_price: float,
|
||
order_type: str,
|
||
is_domestic: bool,
|
||
exchange_code: str,
|
||
db_trade_id: int,
|
||
delay: int = 3,
|
||
cancel_unfilled_limit: bool = False,
|
||
rollback_active_trade: dict | None = None,
|
||
order_org_no: str | None = None,
|
||
sell_pnl_basis: dict | None = None,
|
||
fill_entry_strategy_name: str | None = None,
|
||
) -> None:
|
||
"""[2026-10-08] v2 + 체결 기준 금액·손익 갱신.
|
||
|
||
sell_pnl_basis: {"entry_price", "market", "is_domestic", "strategy_type", "net_rate"} —
|
||
SELL 체결 확인 시 순손익·비용·수익률을 체결가로 재계산(_fill_update_fields_v2).
|
||
strategy_type 은 order_id 중복 행 좁히기용 식별 키로도 쓴다.
|
||
fill_entry_strategy_name: BUY 체결 확인 시 이 전략명의 ActiveTrade.entry_price 를
|
||
체결가 기준으로 보정(db_worker entry_fill_adjust). None 이면 보정하지 않는다.
|
||
|
||
[H-1 5회차] cancel_unfilled_limit=True: 폴링 종료 시 국내 SELL 잔량이 살아 있으면 취소.
|
||
rollback_active_trade: 주문 전 ActiveTrade 스냅샷(전략 필터 포함). 0체결 취소 확정 시 그대로
|
||
upsert 해 remaining_pct·quantity·highest_since_entry 를 원복한다(행을 닫지 않는 부분 익절 전용).
|
||
|
||
주문 후 KIS 체결 내역 조회 → DB 업데이트 + 슬리피지 기록 (부분 체결 자동 재주문 없음).
|
||
|
||
[동작 흐름]
|
||
1. delay초 대기 (체결 확인 전 KIS 서버 처리 시간 확보)
|
||
2. KIS 체결 조회 API 호출 → filled_qty, filled_price 추출
|
||
3. 슬리피지 계산: (체결가 - 주문가) / 주문가 × 100
|
||
4. db_worker 큐를 통해 TradeHistory UPDATE (CLAUDE.md 3.2 준수)
|
||
- 완전 체결(filled_qty >= ordered_quantity) → status = "COMPLETED"
|
||
- 부분 체결 + KIS 잔량 소멸(rmn_qty == 0: 취소·거부·만료) → 체결분만 기록(COMPLETED)
|
||
+ warning("수동 확인"). **자동 재주문하지 않는다** (아래 ③)
|
||
- 부분 체결 + 잔량이 KIS 에 살아 있음/모름 → DB 미갱신 + warning (재주문 금지)
|
||
5. 포트폴리오 동기화 트리거
|
||
|
||
[2026-10-01] `get_order_execution` 이 존재하지 않는 경로를 호출해 이 함수의 체결 반영
|
||
분기는 **한 번도 실행된 적이 없다**. 경로를 고치면서 처음 살아나는 분기의 결함을 함께 고쳤다:
|
||
① 첫 부분체결 관측에서 곧바로 break → 잔량이 아직 KIS 에 지정가 주문으로 살아 있는데
|
||
같은 수량을 재주문 = **중복 주문(과다 매수 / 과다 매도 시도)**. 이제 전량 체결 또는
|
||
잔량 소멸까지 폴링을 계속한다.
|
||
② status "PARTIAL" 은 매수 재진입 가드(당일 중복매수·일일횟수·쿨다운: EXECUTED/COMPLETED
|
||
(/PENDING) 만 셈)와 손익 집계(COMPLETED/FILLED 만 셈)에서 빠진다 → 부분체결 BUY 가
|
||
당일 재매수를 허용하고 부분체결 SELL 이 성과에서 사라진다. 체결분만 수량에 반영하고
|
||
status 는 COMPLETED 를 유지한다.
|
||
③ 잔량 소멸 시 재주문도 제거했다. 잔량이 사라지는 경우는 사실상 사용자 HTS 취소·KIS 거부·
|
||
만료뿐이고(취소는 별도 행(orgn_odno)으로 기록돼 원주문 cncl_yn 이 N 일 수 있다),
|
||
`_reorder_unfilled` 는 MDD fail-safe·밴·종목당 4%·현금·주문 세마포어/Redis 락·
|
||
TradeHistory·체결 검증을 전부 우회한다. 취소 의도를 덮어쓰거나 가드 없는 주문을 내느니
|
||
warning 으로 수동 확인을 요청한다. `_reorder_unfilled` 는 시그니처 보존용으로만 남긴다.
|
||
"""
|
||
await asyncio.sleep(delay) # KIS 서버 체결 처리 대기
|
||
|
||
if not order_id:
|
||
# order_id 없으면 체결 조회 불가 → 포트폴리오 동기화만 수행
|
||
await _delayed_sync_portfolio(0)
|
||
return
|
||
|
||
# [하드닝 R7] 자동매수가 등록한 ActiveTrade 원복 정보(불성립·부분체결 확정 시 사용)
|
||
_buy_rb = _pop_buy_entry_rollback_v2(order_id, stock_code) if order_type == "BUY" else None
|
||
|
||
try:
|
||
# KIS 체결 내역 조회 (inquire-daily-ccld, TR: TTTC0081R→폴백 TTTC8001R / 모의 V*)
|
||
# [실전 안정화] 최대 5회 폴링 (3초 간격, 최대 15초) — 체결 지연 대응
|
||
filled_qty = 0
|
||
filled_price = 0.0
|
||
remaining_qty = None
|
||
exec_result = {}
|
||
max_polls = 5
|
||
poll_interval = 3
|
||
|
||
for poll in range(max_polls):
|
||
exec_result = await korea_investment_api.get_order_execution(order_id, is_domestic)
|
||
filled_qty = int(exec_result.get("filled_qty", 0) or 0)
|
||
# [2026-10-08] 평균체결가가 없으면 0 — 주문가로 대체하지 않는다(아래 경고 분기)
|
||
filled_price = float(exec_result.get("filled_price") or 0)
|
||
remaining_qty = exec_result.get("remaining_qty")
|
||
|
||
if filled_qty >= ordered_quantity:
|
||
break # 전량 체결
|
||
if filled_qty > 0 and remaining_qty == 0:
|
||
break # 부분 체결 후 잔량 소멸(취소·거부) — 더 기다려도 변하지 않음
|
||
|
||
if poll < max_polls - 1:
|
||
logger.debug(
|
||
f"[VERIFY_EXEC] {stock_code} {order_type} 체결 {filled_qty}/{ordered_quantity} "
|
||
f"({poll + 1}/{max_polls}), {poll_interval}초 후 재시도"
|
||
)
|
||
await asyncio.sleep(poll_interval)
|
||
|
||
if filled_qty == 0:
|
||
logger.warning(
|
||
f"[VERIFY_EXEC] {stock_code} {order_type} "
|
||
f"{max_polls}회 폴링 후에도 체결 미확인 — order_id={order_id} "
|
||
f"(조회성공={exec_result.get('ok')}, 주문행발견={exec_result.get('found')})"
|
||
)
|
||
# [M-4 3회차] 주문행이 확인됐고 잔량 0(취소·거부·만료)이면 매수는 죽었다 →
|
||
# 사이클 매수 누적에서 제외. 잔량이 살아 있거나 모르면 유지(보수적).
|
||
if order_type == "BUY" and exec_result.get("found") and (
|
||
remaining_qty == 0 or exec_result.get("cancelled")
|
||
):
|
||
_forget_cycle_buy_v2(stock_code, f"미체결·취소 확정 (order_id={order_id})")
|
||
# [L-4 4회차] 체결 0 + 잔량 소멸 = 매수 불성립 → CANCELLED. COMPLETED 로 남으면
|
||
# 일일 스윙 슬롯·already_ordered_today·Kelly 통계가 허수 매수로 오염된다.
|
||
await _mark_trade_cancelled_v2(order_id, db_trade_id, filled_qty=0)
|
||
# [하드닝 R7] 주문 시점에 만든 스윙 ActiveTrade 도 닫는다 — sync 의 유령 정리에
|
||
# 맡기면 그 사이 청산 판정이 없는 포지션을 보고, 장부(BUY만 있는 고아)가 남는다.
|
||
await _rollback_buy_active_trade_v2(order_id, _buy_rb, 0)
|
||
elif order_type == "BUY":
|
||
# 잔량이 살아 있거나(지정가 대기) 확인 불가 — 매수 미체결 주문은 취소하지 않는다
|
||
# (4회차 정책). TradeHistory 의 COMPLETED·전량은 **잠정치**이고 확정은
|
||
# swing/fill_sweep 의 후속 조회에 맡긴다. 끝내 체결되지 않으면 장부가 거짓이 되므로
|
||
# 식별 가능한 warning 을 남긴다.
|
||
logger.warning(
|
||
f"[BUY_LEDGER] {stock_code} BUY {ordered_quantity}주 체결 0 · 잔량 "
|
||
f"{remaining_qty if remaining_qty is not None else '미상'} — TradeHistory COMPLETED 는 "
|
||
f"잠정(미체결 소멸 시 CANCELLED 강등 필요, order_id={order_id})"
|
||
)
|
||
|
||
# [2026-10-08] 체결수량>0 인데 평균체결가를 못 받으면 주문가로 대체하지 않는다
|
||
# (#432/#433 처럼 호가단위상 불가능한 주문가가 체결가로 저장되던 경로).
|
||
if filled_qty > 0 and float(exec_result.get("filled_price") or 0) <= 0:
|
||
logger.warning(
|
||
f"[VERIFY_EXEC] {stock_code} {order_type} 체결 {filled_qty}주 확인됐으나 평균체결가 없음 "
|
||
f"— 체결가·금액 갱신 생략(주문가 대체 안 함, order_id={order_id})"
|
||
)
|
||
filled_price = 0.0
|
||
|
||
# [H-1 4회차] 국내 SELL 이 폴링 종료 시 잔량이 KIS 에 살아 있으면(지정가 미체결) 취소한다.
|
||
# 남겨 두면 수량이 잠겨 swing/exit_service 의 시장가 손절이 종일 '주문가능수량 부족'으로
|
||
# 거부된다. 취소 성공 시 체결분만 기록(0 이면 CANCELLED), 실패 시 error.
|
||
if (
|
||
cancel_unfilled_limit and order_type == "SELL" and is_domestic
|
||
and filled_qty < ordered_quantity
|
||
and isinstance(remaining_qty, (int, float)) and remaining_qty > 0
|
||
):
|
||
_cancelled = await _cancel_unfilled_order_v2(
|
||
order_id, stock_code, int(remaining_qty), org_no=order_org_no,
|
||
)
|
||
if _cancelled:
|
||
if filled_qty <= 0:
|
||
await _mark_trade_cancelled_v2(order_id, db_trade_id, filled_qty=0)
|
||
await _rollback_active_trade_v2(stock_code, rollback_active_trade, filled_qty=0)
|
||
await _delayed_sync_portfolio(0)
|
||
return
|
||
await _rollback_active_trade_v2(stock_code, rollback_active_trade, filled_qty=filled_qty)
|
||
remaining_qty = 0 # 아래 '부분 체결 + 잔량 소멸' 경로로 체결분만 기록
|
||
|
||
if filled_qty > ordered_quantity:
|
||
# 다른 주문 행과 혼동된 경우 등 — 주문 수량을 넘겨 기록하지 않는다
|
||
logger.warning(
|
||
f"[VERIFY_EXEC] {stock_code} {order_type} 체결수량 {filled_qty} > 주문수량 "
|
||
f"{ordered_quantity} — 주문수량으로 클램프 (order_id={order_id})"
|
||
)
|
||
filled_qty = ordered_quantity
|
||
|
||
# ── 슬리피지 계산: (체결가 - 주문가) / 주문가 × 100 ─────────────────
|
||
slippage_pct = 0.0
|
||
if filled_qty > 0 and order_price > 0 and filled_price > 0:
|
||
# 저장값은 side 무관 원시값(규약: slippage_cost_bp_v2 주석). 로그에는 side 보정 비용도 남긴다.
|
||
slippage_pct = ((filled_price - order_price) / order_price) * 100
|
||
_slip_cost_bp = slippage_cost_bp_v2(order_type, slippage_pct)
|
||
logger.info(
|
||
f"[SLIPPAGE] {stock_code} {order_type} "
|
||
f"주문가={order_price:.2f} 체결가={filled_price:.2f} "
|
||
f"슬리피지={slippage_pct:+.3f}%(원시) "
|
||
f"비용={'n/a' if _slip_cost_bp is None else f'{_slip_cost_bp:+.1f}bp'}(불리=+)"
|
||
)
|
||
|
||
partial = 0 < filled_qty < ordered_quantity
|
||
remainder_dead = partial and remaining_qty == 0
|
||
if partial and not remainder_dead:
|
||
# 잔량이 KIS 에 미체결 지정가로 살아 있다(또는 모른다) → 재주문하면 중복 주문.
|
||
# 최종 체결 수량이 아직 정해지지 않았으므로 원장도 건드리지 않는다(포트폴리오 sync 가 진실).
|
||
logger.warning(
|
||
f"[PARTIAL_FILL] {stock_code} {order_type} {filled_qty}/{ordered_quantity}주 체결, "
|
||
f"잔량 {remaining_qty if remaining_qty is not None else '미상'}주 KIS 미체결 주문 유지 "
|
||
f"— 재주문·원장 갱신 안 함 (order_id={order_id})"
|
||
)
|
||
|
||
# ── DB 업데이트 (CLAUDE.md 3.2: db_worker 큐 경유, 직접 세션 금지) ───
|
||
if filled_qty > 0 and (not partial or remainder_dead):
|
||
# PARTIAL 금지 — 위 docstring ② (가드·집계 누락). 금액·손익은 체결 기준(_fill_update_fields_v2)
|
||
update_fields = _fill_update_fields_v2(
|
||
order_type, filled_qty, filled_price, slippage_pct, sell_pnl_basis,
|
||
)
|
||
# order_id 중복 행 좁히기용 식별 키(db_worker 가 setattr 하지 않음)
|
||
update_fields["order_type"] = order_type
|
||
if (sell_pnl_basis or {}).get("strategy_type"):
|
||
update_fields["strategy_type"] = sell_pnl_basis["strategy_type"]
|
||
if db_trade_id:
|
||
# 기존 경로: trade_id로 조회 (레거시 호출 호환) — id 경로는 모든 키를 setattr 하므로
|
||
# order_id 경로 전용 식별 키는 뺀다(행의 전략 구분을 덮어쓰지 않도록).
|
||
from app.services.db_worker import enqueue_update_trade_history
|
||
await enqueue_update_trade_history(db_trade_id, {
|
||
k: v for k, v in update_fields.items() if k not in ("order_type", "strategy_type")
|
||
})
|
||
else:
|
||
# 신규 경로: order_id로 조회 (db_worker 큐 경유 INSERT 시 trade_id 미확보)
|
||
from app.services.db_worker import enqueue_update_trade_history_by_order_id
|
||
await enqueue_update_trade_history_by_order_id(order_id, update_fields)
|
||
|
||
# [하드닝 R7] 부분체결·잔량 소멸 BUY → ActiveTrade 수량을 체결수량으로.
|
||
# 아래 체결가 보정보다 먼저 큐잉해야 보정 분모(행 수량)가 체결수량이 된다.
|
||
if order_type == "BUY" and remainder_dead:
|
||
await _rollback_buy_active_trade_v2(order_id, _buy_rb, filled_qty)
|
||
|
||
# ── BUY 체결가로 스윙 ActiveTrade 진입가 보정 (db_worker 큐) ──────────
|
||
# 진입 시 upsert 는 주문가(+0.5% 조정가)로 기록된다. 스윙 손익·손절이 이 값을
|
||
# 진입가로 쓰므로(swing/position_manager.resolve_swing_entry_price_v2) 체결가로 맞춘다.
|
||
if order_type == "BUY" and fill_entry_strategy_name and filled_price > 0:
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
# swing/fill_sweep 가 같은 주문을 다시 보정하지 않도록 표시(비멱등 — 이중 보정 방지)
|
||
note_entry_fill_adjusted_v2(order_id)
|
||
await enqueue_active_trade_upsert({
|
||
"stock_code": stock_code,
|
||
"strategy_name": fill_entry_strategy_name,
|
||
"entry_fill_adjust": {
|
||
"order_price": float(order_price),
|
||
"filled_price": float(filled_price),
|
||
"filled_qty": int(filled_qty),
|
||
},
|
||
})
|
||
|
||
# ── 부분 체결 + 잔량 소멸 → 자동 재주문 금지, 수동 확인 요청 (docstring ③) ──
|
||
if remainder_dead:
|
||
remain = ordered_quantity - filled_qty
|
||
logger.warning(
|
||
f"[PARTIAL_FILL] {stock_code}/{stock_name} {order_type} order_id={order_id} "
|
||
f"체결 {filled_qty}/{ordered_quantity}주, 잔량 {remaining_qty}주(미체결 {remain}주 소멸) "
|
||
f"취소확인={exec_result.get('cancel_confirmed_qty')} 거부={exec_result.get('rejected_qty')} "
|
||
f"cncl_yn={'Y' if exec_result.get('cancelled') else 'N'} — 자동 재주문 안 함, 수동 확인 필요"
|
||
)
|
||
|
||
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) # 체결 확인 실패해도 포트폴리오는 동기화
|
||
|
||
|
||
# ── 부분 체결 후 미체결 수량 재주문 ──────────────────────────────────────────
|
||
async def _reorder_unfilled(
|
||
stock_code: str,
|
||
stock_name: str,
|
||
order_type: str,
|
||
quantity: int,
|
||
price: float,
|
||
is_domestic: bool,
|
||
exchange_code: str = "NASD",
|
||
) -> None:
|
||
"""부분 체결 잔여 수량 재주문 (1회 한정)."""
|
||
try:
|
||
result = await _place_order_with_retry(
|
||
is_domestic=is_domestic,
|
||
stock_code=stock_code,
|
||
order_type=order_type,
|
||
quantity=quantity,
|
||
price=price,
|
||
exchange_code=exchange_code,
|
||
max_retries=2,
|
||
)
|
||
if result.get("rt_cd") == "0":
|
||
logger.info(f"[REORDER] {stock_code} {order_type} 미체결 {quantity}주 재주문 성공")
|
||
else:
|
||
logger.warning(f"[REORDER] {stock_code} {order_type} 미체결 재주문 실패: {result.get('msg1')}")
|
||
except Exception as e:
|
||
logger.error(f"[REORDER_ERROR] {stock_code} {order_type}: {type(e).__name__}: {e}")
|
||
|
||
|
||
def _recommendation_trailing_high_v2(stock: dict, current_price: float) -> float:
|
||
"""[하드닝 R2 2026-10-09] 추천 경로 check_exit_signal 의 트레일링 고점.
|
||
|
||
진입 이후 고점(ActiveTrade.highest_since_entry → stock["highest_since_entry"])과 현재가 중
|
||
큰 값. 진입 이후 고점을 모르면 현재가만 쓴다(트레일링 = 현재가 − k×ATR 이라 발동하지 않음).
|
||
당일 고가(stock["high_price"])는 진입 전 체결이 섞이므로 절대 쓰지 않는다 —
|
||
swing/exit_service 의 trailing_high 정의(highest_since_entry, 현재가로 상향)와 같다.
|
||
"""
|
||
try:
|
||
cur = float(current_price or 0)
|
||
except (TypeError, ValueError):
|
||
cur = 0.0
|
||
hse_raw = stock.get("highest_since_entry")
|
||
try:
|
||
hse = float(hse_raw) if hse_raw is not None else 0.0
|
||
except (TypeError, ValueError):
|
||
logger.warning(f"[EXIT_SIGNAL] highest_since_entry 파싱 실패({hse_raw!r}) — 현재가로 대체")
|
||
hse = 0.0
|
||
if hse != hse or hse == float("inf"): # NaN/inf 방어
|
||
hse = 0.0
|
||
return max(hse, cur)
|
||
|
||
|
||
def _swing_entry_price_for_stock_v2(stock: dict, holding, stock_code: str) -> float:
|
||
"""[2026-10-08] 스윙 손익·손절 판정 진입가.
|
||
|
||
Portfolio.average_price 는 같은 종목 스윙+DT 혼합 평단일 수 있다(§3.5). 스윙 소유
|
||
ActiveTrade.entry_price(execute_auto_trade 가 stock["_swing_entry_price"] 로 주입)를
|
||
우선하고, 없으면 Portfolio 평단으로 폴백한다(swing/position_manager 의 단일 규칙).
|
||
DT 태그 종목은 기존대로 Portfolio 평단.
|
||
"""
|
||
_pa = float(getattr(holding, "average_price", 0) or 0) if holding is not None else 0.0
|
||
from app.services.db_worker import DT_STRATEGY_NAMES
|
||
if (stock.get("strategy_type") or "swing") in DT_STRATEGY_NAMES:
|
||
return _pa
|
||
from app.services.swing.position_manager import resolve_swing_entry_price_v2
|
||
price, _basis = resolve_swing_entry_price_v2(stock.get("_swing_entry_price"), _pa, stock_code)
|
||
return price
|
||
|
||
|
||
def _existing_position_qty_v2(holding, stock_code: str) -> int:
|
||
"""해당 종목의 기존 보유 수량 (종목당 누적 상한 산정용).
|
||
|
||
Portfolio 행은 stock_code UNIQUE 라 스윙+DT 수량이 합산돼 있다(CLAUDE.md §3.5).
|
||
§5.1 의 종목당 상한은 '계좌 내 그 종목 비중'이므로 **전략 구분 없이 전체**를 센다
|
||
(보수적). 단 DT 가 sync 이전에 산 수량은 행에 아직 없을 수 있으므로
|
||
`max(행 수량, DT 인메모리 수량)` 으로 잡는다 — 더하면 sync 이후 이중 계상된다.
|
||
"""
|
||
_row_qty = int(getattr(holding, "quantity", 0) or 0) if holding is not None else 0
|
||
try:
|
||
from app.services.daytrading.position_manager import day_trading_state as _dts
|
||
_dt_qty = int((_dts.positions.get(stock_code) or {}).get("quantity", 0) or 0)
|
||
except Exception as _e:
|
||
logger.warning(
|
||
f"[POSITION_CAP] {stock_code}: DT 인메모리 수량 조회 실패 — Portfolio 행 수량만 반영: {_e}"
|
||
)
|
||
_dt_qty = 0
|
||
return max(_row_qty, _dt_qty)
|
||
|
||
|
||
def _apply_position_cap_room_v2(
|
||
invest_amount: float,
|
||
holding,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
current_price: float,
|
||
total_assets: float,
|
||
position_cap_ratio: float,
|
||
) -> tuple[float, str | None]:
|
||
"""종목당 누적 상한 적용. 반환 = (클램프된 금액, SKIP 사유 또는 None).
|
||
|
||
매수 예산 = min(기존 예산, 총자산 × position_cap_ratio − 기존 보유 평가액).
|
||
잔여 한도가 실효 최소주문금액(effective_min_buy_amount) 미만이면
|
||
'position_cap_reached' 로 건너뛴다. 보유가 있는데 총자산을 모르면(잔고 조회 실패)
|
||
한도를 검증할 수 없으므로 'position_cap_unverifiable' 로 추가매수를 막는다.
|
||
|
||
리스크 가드이므로 이 함수 자체에 try 로 감싼 판정이 없다(§4, §8.1-10).
|
||
신규 진입(보유 0)은 잔여 한도 = 총자산 × cap 이라 기존 1건 클램프와 동일하게 동작한다.
|
||
"""
|
||
_existing_qty = _existing_position_qty_v2(holding, stock_code)
|
||
if _existing_qty <= 0:
|
||
return invest_amount, None
|
||
|
||
_existing_value = _existing_qty * float(current_price)
|
||
if total_assets <= 0:
|
||
logger.warning(
|
||
f"[POSITION_CAP] {stock_code}/{stock_name}: 기존 보유 {_existing_qty}주 "
|
||
f"(평가 {_existing_value:,.0f}원)인데 총자산 미확인 — 종목당 상한 "
|
||
f"{position_cap_ratio:.1%} 검증 불가로 추가매수 차단"
|
||
)
|
||
return 0.0, "position_cap_unverifiable"
|
||
|
||
_room = remaining_position_room(total_assets, position_cap_ratio, _existing_value)
|
||
_min_buy = effective_min_buy_amount(
|
||
config_min_amount=settings.MIN_BUY_AMOUNT_KRW,
|
||
total_assets=total_assets,
|
||
position_cap_ratio=position_cap_ratio,
|
||
factor=0.9,
|
||
)
|
||
if _room < _min_buy:
|
||
logger.info(
|
||
f"[POSITION_CAP] {stock_code}/{stock_name}: 종목당 상한 도달 — 기존 "
|
||
f"{_existing_qty}주 평가 {_existing_value:,.0f}원 = 총자산의 "
|
||
f"{_existing_value / total_assets:.2%} (상한 {position_cap_ratio:.1%}), "
|
||
f"잔여 {_room:,.0f}원 < 최소주문 {_min_buy:,.0f}원 — 추가매수 건너뜀"
|
||
)
|
||
return 0.0, "position_cap_reached"
|
||
|
||
if invest_amount > _room:
|
||
logger.info(
|
||
f"[POSITION_CAP] {stock_code}/{stock_name}: 기존 보유 {_existing_value:,.0f}원 반영 — "
|
||
f"매수 예산 {invest_amount:,.0f} → {_room:,.0f}원 (종목당 상한 {position_cap_ratio:.1%})"
|
||
)
|
||
return _room, None
|
||
return invest_amount, None
|
||
|
||
|
||
async def _execute_buy(
|
||
stock: dict,
|
||
db: AsyncSession,
|
||
holding,
|
||
current_price: float,
|
||
signals: list,
|
||
score_val: float,
|
||
is_domestic: bool,
|
||
exchange_code: str,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
) -> dict:
|
||
"""BUY 주문 실행 로직 — 선체크 → semaphore → 주문 → TradeHistory 기록 → 체결 확인."""
|
||
|
||
# ── 0. 장 시작 30분 변동성 회피 (09:00~09:30 진입 차단) ──────────────────
|
||
if await check_opening_range_volatility():
|
||
logger.debug(f"[BUY_SKIP] {stock_code} — 장 시작 30분 변동성 회피 (09:00~09:30)")
|
||
return {"action": "SKIP", "stock": stock_name, "reason": "opening_range_volatility"}
|
||
|
||
# ── 0.5. 실적 필터 (Phase 2 — 기본 OFF) ──────────────────────────────────
|
||
# FUNDAMENTAL_FILTER_ENABLED=True일 때만 동작. 적자(EPS<0)·하락전망(컨센서스
|
||
# 목표가 여력 부족) 종목 진입 차단. 데이터원=네이버. **point-in-time 백테스트
|
||
# 검증(OpenDART) 전엔 켜지 말 것.** 실패 시 차단 안 함(안전).
|
||
if settings.FUNDAMENTAL_FILTER_ENABLED and is_domestic:
|
||
try:
|
||
from app.services.naver_finance import get_stock_fundamentals
|
||
_ff = await get_stock_fundamentals(stock_code)
|
||
if _ff:
|
||
if settings.FUNDAMENTAL_BLOCK_NEGATIVE_EPS and _ff.get("eps"):
|
||
try:
|
||
_eps_v = float(str(_ff["eps"]).replace(",", "").replace("원", ""))
|
||
if _eps_v < 0:
|
||
return {"action": "HOLD", "stock": stock_name,
|
||
"reason": "fundamental_negative_eps(적자)"}
|
||
except Exception as _swallowed:
|
||
warn_throttled(logger, "trade_executor:813", "[FUND_FILTER] EPS 파싱 실패: %s", _swallowed)
|
||
_tp = _ff.get("target_price")
|
||
if _tp and current_price:
|
||
try:
|
||
_upside = (float(str(_tp).replace(",", "")) / current_price - 1) * 100
|
||
if _upside < settings.FUNDAMENTAL_MIN_UPSIDE_PCT:
|
||
return {"action": "HOLD", "stock": stock_name,
|
||
"reason": f"fundamental_low_upside(목표가 여력 {_upside:+.0f}%)"}
|
||
except Exception as _swallowed:
|
||
warn_throttled(logger, "trade_executor:822", "[FUND_FILTER] 목표가 파싱 실패: %s", _swallowed)
|
||
except Exception as _ff_err:
|
||
warn_throttled(logger, "trade_executor:825", f"[FUND_FILTER] {stock_code} 실적필터 스킵: {_ff_err}")
|
||
|
||
# ── 1. 3일 급등 체크 (ATR 기반 동적 임계값) ───────────────────────────────
|
||
surge_check = await check_surge_prevention(stock_code, is_domestic, exchange_code, current_price)
|
||
if surge_check.get("skip"):
|
||
return {"action": "HOLD", "stock": stock_name, "reason": surge_check.get("reason", "chase_buy_prevention")}
|
||
|
||
# ── 2. 트렌드 필터 (MA + EMA 병행) ───────────────────────────────────────
|
||
trend_check = await check_trend_filter(stock_code, stock_name, is_domestic, exchange_code, current_price, stock)
|
||
if trend_check.get("skip"):
|
||
return {"action": "HOLD", "stock": stock_name, "reason": trend_check.get("reason", "trend_filter")}
|
||
|
||
# ── 3. 현금·자산 조회 (30초 캐시 → portfolio_cache → KIS API 직접) ─────
|
||
# [H-2 2026-10-02] _v2: 매수 차감으로 0 이 된 캐시는 신뢰(재조회 소스가 매수 전 값).
|
||
cached = _get_cached_account_v2()
|
||
# [FIX] 현금이 0인 캐시는 신뢰하지 않는다. 기존엔 available_cash=0이 캐시되면
|
||
# 그대로 재사용해 수량이 0으로 계산되어 매수 주문이 영영 안 나갔다(무한루프).
|
||
if cached:
|
||
available_cash, total_assets = cached
|
||
else:
|
||
available_cash, total_assets = 0.0, 0.0
|
||
# 1차: portfolio_cache 확인
|
||
try:
|
||
from app.api.endpoints.portfolio import portfolio_cache
|
||
summary_copy = portfolio_cache.get_summary_copy()
|
||
if summary_copy:
|
||
available_cash = float(summary_copy.get("available_cash", 0))
|
||
total_assets = float(summary_copy.get("total_assets", 0))
|
||
except Exception as _swallowed:
|
||
warn_throttled(logger, "trade_executor:852", "[BUY] 포트폴리오 캐시 현금/자산 조회 실패(KIS 직접 조회로 진행): %s", _swallowed)
|
||
# 2차: 현금이 0이면 KIS API로 직접 조회.
|
||
# [FIX] 기존 조건은 (cash<=0 AND assets<=0) 이라, 평가자산은 있는데 캐시 현금만
|
||
# 0인 경우(portfolio_cache 요약이 available_cash=0을 준 케이스) KIS 재조회를
|
||
# 건너뛰어 현금 0이 고착됐다. 현금이 0이면 자산과 무관하게 실제 예수금을 읽는다.
|
||
if available_cash <= 0:
|
||
try:
|
||
balance = await korea_investment_api.get_balance()
|
||
# NOTE: output2가 빈 리스트([])일 때 balance.get()의 default([{}])는 적용되지 않으므로
|
||
# 아래 `if output2:` 가드가 빈 리스트 케이스를 걸러낸다 (IndexError 방지 + 기존
|
||
# available_cash/total_assets 캐시값을 의도적으로 덮어쓰지 않고 보존).
|
||
output2 = balance.get("output2", [{}])
|
||
if output2:
|
||
b = output2[0] if isinstance(output2, list) else output2
|
||
# [M-3 3회차] 현금 정의 단일화 — buy_guards 와 같은 우선순위
|
||
# (ord_psbl_cash → prvs_rcdl_excc_amt → … → dnca_tot_amt).
|
||
# dnca_tot_amt(D+2 예수금)는 당일 매수가 많으면 음수/과소라 최후순위.
|
||
from app.services.buy_guards import resolve_available_cash_v2
|
||
available_cash = await resolve_available_cash_v2(
|
||
korea_investment_api, b, stock_code
|
||
)
|
||
total_assets = float(b.get("tot_evlu_amt", 0))
|
||
logger.info(f"[CASH_INIT] KIS API 직접 조회: cash={available_cash:,.0f} assets={total_assets:,.0f}")
|
||
except Exception as e:
|
||
logger.warning(f"[CASH_INIT] KIS 잔고 조회 실패: {e}")
|
||
# [FIX] 실제 현금(>0)일 때만 캐시한다. 0 현금을 캐시하면 위 무한루프가 재발한다.
|
||
if available_cash > 0:
|
||
_set_account_cache(available_cash, total_assets)
|
||
|
||
# [2026-09-23] TradeHistory.created_at 은 KST 저장(now_kst)이므로
|
||
# daily_cutoff도 UTC 기준으로 계산해야 9시간 오차가 없음.
|
||
daily_cutoff = get_daily_cutoff_utc() # 오늘 00:00:00 UTC
|
||
|
||
# ── 4. PENDING 포함 오늘 중복 주문 차단 ──────────────────────────────────
|
||
# 오늘 이미 BUY 주문이 있으면(COMPLETED 또는 PENDING 상태) 재진입 방지
|
||
pending_check = await db.execute(
|
||
select(TradeHistory).where(
|
||
TradeHistory.stock_code == stock_code,
|
||
TradeHistory.order_type == "BUY",
|
||
TradeHistory.status.in_(["EXECUTED", "COMPLETED", "PENDING"]),
|
||
TradeHistory.created_at >= daily_cutoff,
|
||
)
|
||
)
|
||
if pending_check.scalars().first():
|
||
return {"action": "SKIP", "stock": stock_name, "reason": "already_ordered_today"}
|
||
|
||
# ── 5. 일 매수 횟수 제한 (settings.MAX_DAILY_BUYS_PER_STOCK) ─────────────
|
||
# 종목당 당일 최대 매수 횟수를 초과하면 추가 매수 차단
|
||
daily_buy_check = await db.execute(
|
||
select(TradeHistory).where(
|
||
TradeHistory.stock_code == stock_code,
|
||
TradeHistory.order_type == "BUY",
|
||
TradeHistory.status.in_(["EXECUTED", "COMPLETED"]),
|
||
TradeHistory.created_at >= daily_cutoff,
|
||
)
|
||
)
|
||
if len(daily_buy_check.scalars().all()) >= settings.MAX_DAILY_BUYS_PER_STOCK:
|
||
return {"action": "HOLD", "stock": stock_name, "reason": "daily_trade_limit"}
|
||
|
||
# ── 6. 쿨다운 체크 (ATR 기반 동적) ──────────────────────────────────────
|
||
cooldown_min = calculate_cooldown_minutes(stock, current_price)
|
||
|
||
cooldown_check = await db.execute(
|
||
select(TradeHistory)
|
||
.where(
|
||
TradeHistory.stock_code == stock_code,
|
||
TradeHistory.order_type == "BUY",
|
||
TradeHistory.status.in_(["EXECUTED", "COMPLETED"]),
|
||
TradeHistory.created_at >= daily_cutoff,
|
||
)
|
||
.order_by(desc(TradeHistory.created_at)) # 가장 최근 매수부터
|
||
)
|
||
recent_buys = cooldown_check.scalars().all()
|
||
# 마지막 매수 이후 쿨다운 시간이 지나지 않았으면 HOLD
|
||
# created_at·현재시각 모두 KST naive 기준 (예전에는 UTC now 와 KST created_at 을
|
||
# 비교해 차이가 음수가 되어 쿨다운이 항상 발동했다)
|
||
if recent_buys and (now_kst() - recent_buys[0].created_at).total_seconds() < cooldown_min * 60:
|
||
return {"action": "HOLD", "stock": stock_name, "reason": "cooldown"}
|
||
|
||
# ── 6.5. 상관관계 필터 (CLAUDE.md 섹션 5.4) ──────────────────────────────────
|
||
# 섹터 집중도 + 포트폴리오 상관계수 필터
|
||
# [M-1 2026-10-02] 조회·필터 실행만 try 안, 판정은 밖(§4). 기존엔 예외 시
|
||
# current_holdings=[] 로 통과해 섹터·상관 필터뿐 아니라 아래 레버리지 20% 집계와
|
||
# 전략 배분(_strategy_total_alloc)까지 0 으로 계산됐다 → 실패 시 신규 진입 차단.
|
||
# [M-3] 같은 사이클에 방금 산(아직 Portfolio 미반영) 종목을 의사 행으로 합산한다.
|
||
current_holdings = []
|
||
_corr_error: str | None = None
|
||
is_valid, filter_reason = False, None
|
||
try:
|
||
# 현재 포트폴리오 보유 종목 조회
|
||
portfolio_result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
|
||
current_holdings = _merge_recent_buys_into_holdings_v2(
|
||
list(portfolio_result.scalars().all())
|
||
)
|
||
|
||
# 상관관계 필터 검증
|
||
is_valid, filter_reason = await validate_correlation_filter(
|
||
stock_code=stock_code,
|
||
portfolio_holdings=current_holdings,
|
||
max_per_sector=settings.MAX_STOCKS_PER_SECTOR if hasattr(settings, 'MAX_STOCKS_PER_SECTOR') else 3,
|
||
correlation_threshold=settings.CORRELATION_THRESHOLD if hasattr(settings, 'CORRELATION_THRESHOLD') else 0.7,
|
||
lookback_days=60
|
||
)
|
||
except Exception as e:
|
||
_corr_error = f"{type(e).__name__}: {e}"
|
||
|
||
if _corr_error is not None:
|
||
logger.warning(
|
||
f"[CORRELATION_FILTER_ERROR] {stock_code}: 보유/섹터/상관 판정 불가 — "
|
||
f"신규 진입 차단(fail-closed): {_corr_error}"
|
||
)
|
||
return {"action": "SKIP", "stock": stock_name, "reason": "correlation_filter_unavailable"}
|
||
if not is_valid:
|
||
logger.info(f"[CORRELATION_FILTER] {stock_code}/{stock_name}: {filter_reason}")
|
||
return {"action": "HOLD", "stock": stock_name, "reason": filter_reason}
|
||
logger.debug(f"[CORRELATION_FILTER] {stock_code}/{stock_name}: {filter_reason}")
|
||
|
||
# ── 6.6. 레버리지/인버스 ETF 20% 한도 — [M-2] 사이징 이후(7.7)로 이동 ─────────
|
||
# 신규 주문 금액을 포함해 판정해야 하므로 invest_amount 확정 뒤에 검사한다.
|
||
_leverage_keywords = get_leverage_check_keywords()
|
||
|
||
# ── 7. 포지션 사이징 (Kelly 우선, v2 fallback) ────────────────────────────
|
||
# 우선순위: Half-Kelly → calculate_position_size_v2 → available_cash×4%
|
||
regime_str = stock.get("_regime_str", "bear")
|
||
# CLAUDE.md 6.1: SIDEWAYS에서는 진입 불가 — 방어코드
|
||
if regime_str == "sideways":
|
||
return {"action": "SKIP", "reason": "sideways_regime", "stock": stock_name}
|
||
regime = MarketRegime.BULL if regime_str == "bull" else MarketRegime.BEAR
|
||
|
||
# [이슈7 수정] current_strategy_allocation은 단일 종목 보유액이 아니라
|
||
# 해당 전략(mean_reversion) 전체 보유액을 전달해야 포지션 한도가 정확히 계산됨.
|
||
# current_holdings는 섹션 6.5에서 이미 조회된 Portfolio 리스트를 재활용.
|
||
strategy_tag = stock.get("strategy_type", "swing")
|
||
_strategy_total_alloc = 0.0
|
||
for _h in current_holdings:
|
||
_h_strategy = getattr(_h, "strategy_type", None) or "swing"
|
||
_h_qty = float(getattr(_h, "quantity", 0) or 0)
|
||
_h_price = float(getattr(_h, "current_price", 0) or getattr(_h, "average_price", 0) or 0)
|
||
if _h_strategy == strategy_tag:
|
||
_strategy_total_alloc += _h_qty * _h_price
|
||
|
||
# ── 7.0. 적응형 전략 파라미터 적용 ─────────────────────────────────────
|
||
# position_size 상한을 적응형 모드에 따라 조정 (Crisis=1.5%, Defensive=4% 등)
|
||
#
|
||
# [HIGH-2 수정] settings.MAX_POSITION_SIZE(4%)는 CLAUDE.md §5.1/§8.2가 규정한
|
||
# "종목당 절대 상한(hard ceiling)"이다. adaptive_strategy._MODE_PARAMS 는 문서·백테스트
|
||
# 기준값이므로 그 숫자 자체는 건드리지 않고(Normal 6% / Aggressive 7% 유지),
|
||
# 소비 지점인 여기서 min()으로 클램프해 절대 상한을 넘지 못하게 한다.
|
||
# → 결과적으로 Normal/Aggressive의 실효 종목당 비중은 4%로 묶이고,
|
||
# Defensive(4%)/Crisis(1.5%)처럼 4% 이하인 모드만 적응형 값이 실제로 작동한다.
|
||
# [§4 2026-10-02] 조회만 try 안. 기존엔 클램프·Crisis 차단이 try 안에 있어
|
||
# 예외 시 둘 다 조용히 건너뛰었다. 조회 실패 = Crisis 여부 불명 → 진입 차단.
|
||
_adaptive_position_cap = settings.MAX_POSITION_SIZE # 기본 4% = 절대 상한
|
||
_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"[ADAPTIVE] {stock_code}: 적응형 파라미터 조회 실패 — Crisis 여부 불명으로 "
|
||
f"신규 진입 차단(fail-closed): {type(e).__name__}: {e}"
|
||
)
|
||
return {"action": "SKIP", "reason": "adaptive_params_unavailable", "stock": stock_name}
|
||
if _adp is None:
|
||
logger.warning(f"[ADAPTIVE] {stock_code}: 적응형 파라미터 None — 신규 진입 차단(fail-closed)")
|
||
return {"action": "SKIP", "reason": "adaptive_params_unavailable", "stock": stock_name}
|
||
if not getattr(_adp, "fallback_used", False):
|
||
# Crisis 모드: max_daily_trades=0이면 신규 진입 차단 (CLAUDE.md 섹션 8.4)
|
||
if getattr(_adp, "trading_mode", None) == "crisis" and (getattr(_adp, "max_daily_trades", 0) or 0) <= 0:
|
||
return {"action": "SKIP", "reason": "adaptive_crisis_mode", "stock": stock_name}
|
||
try:
|
||
_adaptive_position_cap = float(_adp.position_size)
|
||
except (TypeError, ValueError, AttributeError) as e:
|
||
logger.warning(
|
||
f"[ADAPTIVE] {stock_code}: position_size 해석 실패 — MAX_POSITION_SIZE 사용: {e}"
|
||
)
|
||
_adaptive_position_cap = settings.MAX_POSITION_SIZE
|
||
# 절대 상한 클램프 — 무조건 적용 (CLAUDE.md §5.1 hard ceiling)
|
||
_adaptive_position_cap = max(0.0, min(_adaptive_position_cap, settings.MAX_POSITION_SIZE))
|
||
|
||
invest_amount = await _calculate_kelly_position(
|
||
db, stock_code, total_assets, available_cash,
|
||
max_per_position=_adaptive_position_cap,
|
||
)
|
||
if invest_amount <= 0:
|
||
# Kelly 데이터 부족(5거래 미만) → 전략 v2 fallback
|
||
invest_amount = calculate_position_size_v2(
|
||
total_assets=total_assets,
|
||
available_cash=available_cash,
|
||
current_strategy_allocation=_strategy_total_alloc,
|
||
regime=regime,
|
||
rsi=stock.get("rsi"),
|
||
adx=stock.get("adx_14"),
|
||
max_per_position=_adaptive_position_cap,
|
||
)
|
||
if invest_amount <= 0:
|
||
# v2도 0 반환 시(현금 부족 등) → 적응형 position_size 이내
|
||
invest_amount = min(available_cash, total_assets * _adaptive_position_cap)
|
||
|
||
# [#9] 글로벌 자본 가드 — 현금이 전체 자본의 (1-MAX_TOTAL_CAPITAL_USAGE)% 미만이면 진입 차단
|
||
min_cash_reserve = total_assets * (1 - settings.MAX_TOTAL_CAPITAL_USAGE)
|
||
if available_cash - invest_amount < min_cash_reserve:
|
||
invest_amount = max(0, available_cash - min_cash_reserve)
|
||
if invest_amount <= 0:
|
||
return {"action": "SKIP", "reason": "global_capital_guard", "stock": stock_name}
|
||
|
||
# [스윙:DT 자본 배분 2026-09-22] 스윙 합산 투자액이 총자산 × SWING_MAX_CAPITAL_RATIO 를
|
||
# 넘지 않도록 상한. 스윙 투자액 = 주식 평가액 − 데이트레이딩 포지션 투자액.
|
||
# (스윙이 자본 91%를 점유해 DT 예산이 남지 않던 문제 → 50:50)
|
||
_swing_cap_ratio = float(getattr(settings, "SWING_MAX_CAPITAL_RATIO", 1.0) or 1.0)
|
||
_swing_room: float | None = None
|
||
if 0 < _swing_cap_ratio < 1 and total_assets > 0:
|
||
_dt_amount = _dt_invested_amount_v2(stock_code)
|
||
_swing_invested = max(0.0, total_assets - available_cash - _dt_amount)
|
||
_swing_room = total_assets * _swing_cap_ratio - _swing_invested
|
||
if invest_amount > _swing_room:
|
||
invest_amount = max(0.0, _swing_room)
|
||
if invest_amount <= 0:
|
||
logger.info(
|
||
f"[TRADE] {stock_name}: 스윙 자본 상한 도달 "
|
||
f"({_swing_invested/total_assets:.1%} ≥ {_swing_cap_ratio:.0%}) — 신규 매수 차단"
|
||
)
|
||
return {"action": "SKIP", "reason": "swing_capital_cap", "stock": stock_name}
|
||
|
||
# ── 7.5. 패턴 메모리 기반 포지션 조정 ──────────────────────────────────
|
||
# 종목별 과거 행동 패턴(지지/저항선, RSI 반등, 승률 등)을 기반으로
|
||
# 투자금액을 -30% ~ +30% 범위에서 동적 조정.
|
||
# CLAUDE.md 5.1 절대 상한(4%)은 조정 후 재적용.
|
||
try:
|
||
from app.services.stock_pattern_memory import get_pattern_adjusted_invest_amount
|
||
invest_amount = await get_pattern_adjusted_invest_amount(
|
||
stock_code=stock_code,
|
||
base_invest_amount=invest_amount,
|
||
rsi=stock.get("rsi"),
|
||
current_price=current_price,
|
||
current_volume=float(stock.get("volume", 0) or 0),
|
||
)
|
||
except Exception as _pm_err:
|
||
# [HIGH-1 수정] 조용한 실패 방지 — debug → warning.
|
||
logger.warning(f"[PATTERN_MEMORY] {stock_code} 포지션 조정 실패 (기본 투자금액 유지): {_pm_err}")
|
||
|
||
# [HIGH-1 수정] CLAUDE.md §5.1 종목당 4% 절대 상한 재적용.
|
||
# 과거에는 이 클램프가 위 try 블록 안에 있어, get_pattern_adjusted_invest_amount()가
|
||
# 예외를 던지면 클램프를 건너뛰고 Kelly/v2가 _adaptive_position_cap(적응형 6~7%)로
|
||
# 산출한 금액이 그대로 통과했다. 예외 발생 여부와 무관하게 항상 적용되도록 try 밖으로 이동.
|
||
# total_assets=0(잔고 조회 실패 등)이면 비율 상한을 계산할 수 없으므로 현금 상한만 적용
|
||
# — 0으로 클램프해 전 종목이 quantity_zero로 조용히 탈락하는 것을 방지.
|
||
# [§8.5-2 통합 2026-09-27] 클램프 수식만 sizing_core 로 위임 — 클램프 **순서**
|
||
# (글로벌 자본 가드 → 스윙 자본 캡 → 패턴 메모리 → 절대 상한)와 total_assets>0
|
||
# 분기는 최근 확정된 동작이므로 그대로 유지한다.
|
||
if total_assets > 0:
|
||
invest_amount = clamp_by_ratios(
|
||
invest_amount, total_assets, [settings.MAX_POSITION_SIZE], available_cash,
|
||
)
|
||
else:
|
||
invest_amount = min(invest_amount, available_cash)
|
||
# [R6-1 2026-10-10] 패턴메모리 증액(최대 1.5배) 뒤 현금 유보·스윙 70% 상한 재적용.
|
||
# 리스크 가드 — try 밖에서 무조건(§4, §8.1-10).
|
||
invest_amount = _reapply_capital_guards_v2(
|
||
invest_amount, available_cash, min_cash_reserve, _swing_room,
|
||
)
|
||
|
||
# ── 7.6. 종목당 **누적** 상한 (CLAUDE.md §5.1) ─────────────────────────
|
||
# [2026-10-01] 위 클램프는 '주문 1건' 기준이라, 같은 종목이 매일 추천되면
|
||
# 추가매수가 쌓여 종목 비중이 MAX_POSITION_SIZE 를 넘었다. 기존 보유 평가액을
|
||
# 차감한 잔여 한도로 다시 묶는다. 리스크 가드이므로 try 밖에 둔다(§4, §8.1-10).
|
||
_pos_cap_result = _apply_position_cap_room_v2(
|
||
invest_amount=invest_amount,
|
||
holding=holding,
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
current_price=current_price,
|
||
total_assets=total_assets,
|
||
position_cap_ratio=_adaptive_position_cap,
|
||
)
|
||
if _pos_cap_result[1] is not None:
|
||
return {"action": "SKIP", "reason": _pos_cap_result[1], "stock": stock_name}
|
||
invest_amount = _pos_cap_result[0]
|
||
|
||
# [BUG FIX] 국면별 배율(_position_multiplier)과 뉴스 배율(_news_position_scale)을
|
||
# invest_amount에 반영 — 기존에는 stock dict에 주입만 되고 실제로 사용되지 않았음.
|
||
# [M-4 2026-10-02] `float(x or 1.0)` 는 0.0(진입 차단)을 1.0 으로 바꿨다.
|
||
_position_multiplier = _parse_scale_v2(
|
||
stock.get("_position_multiplier"), "_position_multiplier", stock_code
|
||
)
|
||
_news_position_scale = _parse_scale_v2(
|
||
stock.get("_news_position_scale"), "_news_position_scale", stock_code
|
||
)
|
||
|
||
if _position_multiplier != 1.0 or _news_position_scale != 1.0:
|
||
invest_amount = invest_amount * _position_multiplier * _news_position_scale
|
||
logger.debug(
|
||
f"[POSITION_SCALE] {stock_code}: position_multiplier={_position_multiplier:.2f} "
|
||
f"news_scale={_news_position_scale:.2f} → invest_amount={invest_amount:,.0f}"
|
||
)
|
||
|
||
# ── 7.7. 레버리지/인버스 ETF 20% 한도 (CLAUDE.md §5.1) ─────────────────
|
||
# [M-2 2026-10-02] 신규 주문분 포함: (보유 레버리지 평가액 + invest_amount) / 총자산.
|
||
# 기존엔 보유분만 봐서 19% 보유 상태에서 4% 를 더 사 23% 가 될 수 있었다.
|
||
# [M-1] 판정은 try 밖. 총자산·보유 평가를 알 수 없으면 한도 검증 불가 → 차단.
|
||
if is_leverage_etf(stock_name, _leverage_keywords) and invest_amount > 0:
|
||
_lev_total = _leverage_exposure_v2(current_holdings, _leverage_keywords)
|
||
if _lev_total is None or total_assets <= 0:
|
||
logger.warning(
|
||
f"[LEVERAGE_LIMIT] {stock_code}/{stock_name}: 레버리지 한도 "
|
||
f"{settings.LEVERAGE_ETF_MAX_RATIO*100:.0f}% 검증 불가 "
|
||
f"(total_assets={total_assets:,.0f}) — 신규 진입 차단(fail-closed)"
|
||
)
|
||
return {"action": "SKIP", "stock": stock_name, "reason": "leverage_limit_unverifiable"}
|
||
_lev_ratio_after = (_lev_total + invest_amount) / total_assets
|
||
if _lev_ratio_after > settings.LEVERAGE_ETF_MAX_RATIO:
|
||
logger.warning(
|
||
f"[LEVERAGE_LIMIT] {stock_code}/{stock_name}: 매수 후 레버리지 ETF 비중 "
|
||
f"{_lev_ratio_after*100:.1f}% (보유 {_lev_total:,.0f} + 신규 {invest_amount:,.0f}) "
|
||
f"> {settings.LEVERAGE_ETF_MAX_RATIO*100:.0f}% 한도"
|
||
)
|
||
return {"action": "HOLD", "stock": stock_name, "reason": "leverage_etf_limit_exceeded"}
|
||
|
||
# 투자금액 → 주수 환산 (Decimal 사용으로 부동소수점 오차 방지)
|
||
# [§8.5-2 통합 2026-09-27] sizing_core.amount_to_quantity 위임 — 동일한
|
||
# int(Decimal(str(amount))/Decimal(str(price))) 경로. max(1, ...) 없음(예산 0 → 0주).
|
||
quantity = amount_to_quantity(invest_amount, current_price)
|
||
logger.info(
|
||
f"[BUY_CALC] {stock_code}/{stock_name}: cash={available_cash:,.0f} assets={total_assets:,.0f} "
|
||
f"invest={invest_amount:,.0f} qty={quantity} price={current_price:,.0f}"
|
||
)
|
||
if quantity <= 0:
|
||
# [관측성] 수량 0 원인을 구분: 배율(플레이북 FOMC·국면·뉴스)로 투자금이
|
||
# 0이 됐는지, 아니면 현금 부족인지. "매수 실행 후 조용히 스킵"의 정체를 로그로.
|
||
if _position_multiplier <= 0 or _news_position_scale <= 0:
|
||
_qz_reason = "entry_blocked_multiplier_0(플레이북/국면/뉴스로 진입차단)"
|
||
else:
|
||
_qz_reason = "quantity_zero(현금/가격 대비 1주 미만)"
|
||
logger.info(f"[BUY_SKIP] {stock_code}/{stock_name}: {_qz_reason} (invest={invest_amount:,.0f})")
|
||
return {"action": "SKIP", "reason": _qz_reason, "stock": stock_name}
|
||
|
||
# 최소 매수 금액 가드: 수수료 대비 비효율 방지 (기본 config.MIN_BUY_AMOUNT_KRW, 15만원)
|
||
#
|
||
# [MEDIUM-5 문서 불일치 — 의도된 설계]
|
||
# CLAUDE.md §5.1/§8.2는 최소주문금액을 "15만원 고정"으로 서술하지만,
|
||
# 실제 구현은 아래와 같이 소액 계좌에서만 자동 하향된다:
|
||
# 실효하한 = min(MIN_BUY_AMOUNT_KRW, 총자산 × 적응형포지션상한 × 0.9)
|
||
# 이유: 총자산이 작으면 종목당 예산(총자산×4%) 자체가 15만원 미만이 되어
|
||
# 모든 종목이 min_amount_guard로 영구 차단된다(2026-09-23 하루 141건 차단 사례).
|
||
# 큰 계좌에서는 항상 config값(15만원)이 더 작게 선택되므로 문서와 동일하게 동작한다.
|
||
# → 동작을 문서에 맞추는 대신 문서(§5.1)를 이 동작에 맞춰 보정할 예정. 코드 변경 금지.
|
||
# 예) 총자산 300만원 × 4% × 0.9 = 108,000원이 실효 하한(15만원 아님).
|
||
# [§8.5-2 통합 2026-09-27] 계산식만 sizing_core.effective_min_buy_amount 로 위임.
|
||
# = min(MIN_BUY_AMOUNT_KRW, 총자산 × 적응형cap × 0.9). 로직·계수 변경 없음.
|
||
try:
|
||
_MIN_BUY_AMOUNT = effective_min_buy_amount(
|
||
config_min_amount=settings.MIN_BUY_AMOUNT_KRW,
|
||
total_assets=total_assets,
|
||
position_cap_ratio=_adaptive_position_cap,
|
||
factor=0.9,
|
||
)
|
||
except Exception:
|
||
_MIN_BUY_AMOUNT = settings.MIN_BUY_AMOUNT_KRW
|
||
_actual_amount = quantity * current_price
|
||
if _actual_amount < _MIN_BUY_AMOUNT:
|
||
logger.info(f"[SKIP] {stock_code}: 매수금액 {_actual_amount:,.0f}원 < 최소 {_MIN_BUY_AMOUNT:,.0f}원")
|
||
return {"action": "SKIP", "reason": "min_amount_guard", "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) # +0.5% 체결률 향상
|
||
_unknown_sent_at = _get_kst_now() # 결과 불명 시 주문내역 대조 기준 시각
|
||
async with _get_order_semaphore(stock_code):
|
||
order_result = await _place_order_with_retry(
|
||
is_domestic=is_domestic,
|
||
stock_code=stock_code,
|
||
order_type="BUY",
|
||
quantity=quantity,
|
||
price=order_price,
|
||
exchange_code=exchange_code,
|
||
)
|
||
|
||
total_amount = Decimal(str(order_price)) * quantity
|
||
|
||
# ── 매수 스토리 구성: 기술 + 뉴스 + 실적 + 전망 (Phase 1: 기록 전용) ──────
|
||
# 주문은 이미 위에서 접수됐으므로 여기서의 펀더멘털 조회는 주문을 지연·차단하지
|
||
# 않는다(실패/타임아웃 시 기술 스토리로 폴백). 매매 판단엔 미사용.
|
||
_story = [f"기술: {', '.join(signals[:3])} (점수 {score_val})"]
|
||
try:
|
||
_ns = stock.get("_news_position_scale")
|
||
if _ns is not None and float(_ns) < 1.0:
|
||
_story.append(f"뉴스: 악재 감지 → 비중 {float(_ns):.0%}")
|
||
except Exception as _swallowed:
|
||
warn_throttled(logger, "trade_executor:1210", "[STORY] 뉴스 배율 스토리 생성 실패: %s", _swallowed)
|
||
if is_domestic:
|
||
try:
|
||
from app.services.naver_finance import get_stock_fundamentals
|
||
_fd = await get_stock_fundamentals(stock_code)
|
||
if _fd:
|
||
_val = []
|
||
if _fd.get("per"):
|
||
_val.append(f"PER {_fd['per']}")
|
||
if _fd.get("eps"):
|
||
_val.append(f"EPS {_fd['eps']}")
|
||
if _val:
|
||
_story.append("실적: " + ", ".join(_val))
|
||
_tp = _fd.get("target_price")
|
||
if _tp:
|
||
try:
|
||
_tpv = float(str(_tp).replace(",", ""))
|
||
_up = (_tpv / current_price - 1) * 100 if current_price else 0.0
|
||
_outlook = f"전망: 목표가 {_tp}({_up:+.0f}%)"
|
||
if _fd.get("recomm_mean"):
|
||
_outlook += f", 투자의견 {_fd['recomm_mean']}/5"
|
||
_story.append(_outlook)
|
||
except Exception as _swallowed:
|
||
warn_throttled(logger, "trade_executor:1233", "[STORY] 목표가 스토리 생성 실패: %s", _swallowed)
|
||
except Exception as _story_err:
|
||
warn_throttled(logger, "trade_executor:1236", f"[STORY] {stock_code} 펀더멘털 스킵: {_story_err}")
|
||
entry_reason = " | ".join(_story)
|
||
success = order_result.get("rt_cd") == "0" # KIS 성공 코드
|
||
# [H-3 5회차] 전송 후 결과 불명 — 체결됐을 수 있다. 거부 쿨다운 대상 아님.
|
||
_outcome_unknown = (not success) and _is_order_outcome_unknown_v2(order_result)
|
||
if not success and not _outcome_unknown and not _is_retryable_order_failure(order_result):
|
||
# [M-1 3회차] 업무 거부(rt_cd "1" 등) — 같은 종목 반복 주문 방지용 단기 쿨다운
|
||
_note_order_reject_v2(stock_code, order_result)
|
||
# [H-1 2026-10-02] rt_cd≠"0" 은 KIS 거부/실패다. 기존엔 "1" 을 PENDING 으로
|
||
# 기록해 일일 스윙 한도·already_ordered_today·note_system_buy 가 거부 주문에
|
||
# 소진됐다. 체결 확인 전 상태는 _verify_and_sync_execution 이 갱신한다.
|
||
# [H-3 5회차] 단, 결과 불명은 PENDING('접수·체결 미확인') — 일일 스윙 한도·
|
||
# already_ordered_today·당일 매도 판정·유입잔고 강등 근거가 모두 PENDING 을
|
||
# 접수된 주문으로 센다. FAILED 로 두면 같은 사이클/다음 사이클이 재매수해 이중 체결.
|
||
status = "COMPLETED" if success else ("PENDING" if _outcome_unknown else "FAILED")
|
||
|
||
# [2026-09-30] 유입 잔고 강등 레이스 방어 — '시스템 매수' 를 **DB 반영 전에**
|
||
# 인메모리로 즉시 등록한다. 아래 enqueue 들은 db_worker 큐를 거쳐 비동기로
|
||
# INSERT 되는데, `_verify_and_sync_execution()` 이 곧바로 `sync_portfolio()`
|
||
# 를 돌리므로 그 사이에 sync 가 "근거 없음 → external 강등" 판정을 내리면
|
||
# 방금 산 포지션의 손절·익절이 통째로 멈춘다.
|
||
# 주문 거부(FAILED)는 주식이 생기지 않으므로 등록하지 않는다 — 등록하면
|
||
# 기존 유입 잔고가 '매수 실패' 만으로 격리를 면한다.
|
||
if success:
|
||
from app.services.system_buy_registry import note_system_buy
|
||
note_system_buy(stock_code, quantity)
|
||
# [H-2] 같은 사이클의 현금 95%·스윙 70% 가드가 이 매수를 반영하도록 즉시 차감.
|
||
# [Low 3회차] 계좌 캐시는 KRW(국내 예수금)다 — 해외(USD) 매수 금액을 빼면
|
||
# 단위가 섞여 국내 가용현금이 과소평가된다 → 국내 매수만 차감.
|
||
if is_domestic:
|
||
_deduct_account_cache_v2(
|
||
float(order_price) * quantity, available_cash, total_assets
|
||
)
|
||
# [M-3] 같은 사이클의 보유수·섹터·레버리지 판정에 합산.
|
||
_note_cycle_buy_v2(stock_code, stock_name, quantity, float(order_price))
|
||
# [M-3 4회차] 일일 스윙 한도 집계용 전략 태그 (TradeHistory.strategy_type 과 같은 값)
|
||
if stock_code in _recent_cycle_buys:
|
||
_recent_cycle_buys[stock_code]["strategy_type"] = stock.get("strategy_type", "swing")
|
||
elif _outcome_unknown:
|
||
# [H-3 5회차] 체결됐을 수 있으므로 '산 것'으로 보수 집계(보유수·일일 한도·강등 근거).
|
||
# 실제 여부는 잔고 동기화가 확정한다. 현금 캐시는 차감하지 않는다(과소 추정 회피 불필요).
|
||
from app.services.system_buy_registry import note_system_buy
|
||
note_system_buy(stock_code, quantity)
|
||
_note_cycle_buy_v2(stock_code, stock_name, quantity, float(order_price))
|
||
if stock_code in _recent_cycle_buys:
|
||
_recent_cycle_buys[stock_code]["strategy_type"] = stock.get("strategy_type", "swing")
|
||
# [하드닝 R1 2026-10-09] 잔고 동기화는 resolver 가 확정 후 실행한다 — 먼저 돌리면
|
||
# 체결분이 ActiveTrade 등록 전에 'synced' 로 시딩돼 이중 행이 생길 수 있다.
|
||
|
||
# TradeHistory DB 기록 (db_worker 큐 경유 — CLAUDE.md 3.2 준수)
|
||
kis_order_id = build_kis_order_id(order_result)
|
||
# [하드닝 R1 2026-10-09] 결과 불명은 ODNO 가 없어 행을 다시 찾을 수 없다 → 자리표시자
|
||
_unknown_placeholder_id = None
|
||
if _outcome_unknown and not kis_order_id:
|
||
_unknown_placeholder_id = _unknown_order_placeholder_id_v2(stock_code, "BUY")
|
||
kis_order_id = _unknown_placeholder_id
|
||
from app.services.db_worker import enqueue_trade_history
|
||
await enqueue_trade_history({
|
||
"rule_id": None, # JSON config rule은 trading_rules 테이블에 없으므로 FK 위반 방지
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
"order_type": "BUY",
|
||
"order_price": Decimal(str(order_price)),
|
||
"order_quantity": quantity,
|
||
# [2026-10-08] 체결가는 체결 확인(_verify_and_sync_execution_v3)이 채운다 — 그 전엔 NULL.
|
||
# 주문가(+0.5% 조정가)를 체결가로 넣으면 확인 실패 시 호가단위상 불가능한 값
|
||
# (#433 현대차 337,177 / #432 풍산 68,139)이 체결가로 영구히 남았다.
|
||
# total_amount 는 확인 전까지 주문가 기준 추정치, 확인 시 체결가×체결수량으로 덮어쓴다.
|
||
"executed_price": None,
|
||
"executed_quantity": quantity if success else 0,
|
||
"total_amount": total_amount,
|
||
"status": status,
|
||
"order_id": kis_order_id,
|
||
"message": f"자동매수: {'추가매수' if holding else '신규'} | {' | '.join(signals[:2])}",
|
||
"entry_reason": entry_reason,
|
||
"signals": signals,
|
||
"strategy_type": stock.get("strategy_type", "swing"),
|
||
"currency_code": get_market_info(stock_code)["currency"],
|
||
"exchange_code": exchange_code,
|
||
"created_at": _get_kst_now(),
|
||
"executed_at": _get_kst_now() if success else None,
|
||
})
|
||
|
||
if _outcome_unknown:
|
||
# [하드닝 R1 2026-10-09 §8.5-34] 결과 불명 BUY 확정 태스크 (FAILED/CANCELLED/접수 등록)
|
||
if _unknown_placeholder_id:
|
||
spawn_tracked_task_v2(_resolve_unknown_buy_v2({
|
||
"placeholder_id": _unknown_placeholder_id,
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
"quantity": quantity,
|
||
"order_price": float(order_price),
|
||
"sent_at": _unknown_sent_at,
|
||
"is_domestic": is_domestic,
|
||
"holding": bool(holding),
|
||
"strategy_type": stock.get("strategy_type", "swing"),
|
||
"strategy_name": stock.get("strategy_name") or stock.get("strategy_type", "swing"),
|
||
"entry_reason": entry_reason,
|
||
"atr": stock.get("atr"),
|
||
"take_profit": stock.get("take_profit", 5.0),
|
||
}))
|
||
else:
|
||
# 불명 응답에 ODNO 가 있다(드묾) — 접수된 것이므로 정상 경로처럼 체결 확인에 맡긴다.
|
||
spawn_tracked_task_v2(_delayed_sync_portfolio(3))
|
||
|
||
if success:
|
||
# [하드닝 R1 2026-10-09] ActiveTrade.stop_loss/take_profit 은 절대가 규약
|
||
# (sync 시딩·DT restore 와 동일). 손절가는 swing/exit_service 와 같은 실효값.
|
||
_at_stop_price, _at_tp_price = _swing_active_trade_levels_v2(
|
||
order_price, stock.get("atr"), stock.get("take_profit", 5.0),
|
||
)
|
||
# [C2] ActiveTrade 생성 — 분할매도/트레일링 스탑 추적용
|
||
try:
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
await enqueue_active_trade_upsert({
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
# [2026-10-08] 추가매수면 기존 행에 수량 가산·진입가 가중평균(덮어쓰기 금지).
|
||
# 같은 전략명 active 행이 없으면 db_worker 가 신규 생성한다(키는 무시).
|
||
"accumulate_entry": bool(holding),
|
||
"quantity": quantity,
|
||
"entry_price": order_price,
|
||
# 듀얼 전략(MOMENTUM_BREAKOUT/PULLBACK_BUY)은 strategy_name 으로 전달돼
|
||
# 청산 분기를 결정한다. 없으면 strategy_type 폴백.
|
||
"strategy_name": stock.get("strategy_name") or stock.get("strategy_type", "swing"),
|
||
# [하드닝 R1] 퍼센트(-1.50/3.00) 저장 금지 — 절대가(실효 손절가)로 통일
|
||
"stop_loss": _at_stop_price,
|
||
"take_profit": _at_tp_price,
|
||
"entry_reason": entry_reason,
|
||
"highest_since_entry": order_price,
|
||
})
|
||
except Exception as _at_err:
|
||
logger.warning(f"[BUY] ActiveTrade 생성 실패 {stock_code}: {_at_err}")
|
||
|
||
# 인메모리 포트폴리오 캐시 즉시 반영 (UI 실시간 업데이트)
|
||
try:
|
||
from app.api.endpoints.portfolio import portfolio_cache
|
||
await portfolio_cache.apply_buy(stock_code, stock_name, quantity, order_price)
|
||
except Exception as _swallowed:
|
||
logger.warning("[BUY] portfolio_cache.apply_buy 실패: %s", _swallowed)
|
||
# WebSocket → 프론트엔드 즉시 갱신 트리거
|
||
try:
|
||
from app.services.websocket_manager import websocket_manager
|
||
await websocket_manager.broadcast_json({
|
||
"type": "trade_executed",
|
||
"data": {
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
"trade_type": "BUY",
|
||
"quantity": quantity,
|
||
"price": current_price,
|
||
},
|
||
})
|
||
except Exception as _swallowed:
|
||
logger.warning("[BUY] WebSocket 갱신 트리거 실패: %s", _swallowed)
|
||
# Telegram 매수 체결 알림
|
||
try:
|
||
from app.services.telegram_notifier import telegram_notifier
|
||
spawn_tracked_task_v2(telegram_notifier.notify_trade_executed(
|
||
order_type="BUY",
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
quantity=quantity,
|
||
price=current_price,
|
||
))
|
||
except Exception as _swallowed:
|
||
logger.warning("[BUY] 텔레그램 체결 알림 실패: %s", _swallowed)
|
||
# [하드닝 R7] 0체결 소멸·부분체결 확정 시 위 ActiveTrade 를 실제 체결 기준으로 원복
|
||
register_buy_entry_rollback_v2(
|
||
kis_order_id, stock_code,
|
||
stock.get("strategy_name") or stock.get("strategy_type", "swing"),
|
||
quantity, bool(holding),
|
||
)
|
||
# 3초 후 KIS 체결 확인 → 슬리피지 기록 + 부분체결 재주문 (백그라운드)
|
||
spawn_tracked_task_v2(
|
||
_verify_and_sync_execution_v3(
|
||
order_id=kis_order_id,
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
ordered_quantity=quantity,
|
||
order_price=order_price,
|
||
order_type="BUY",
|
||
is_domestic=is_domestic,
|
||
exchange_code=exchange_code,
|
||
db_trade_id=0, # db_worker 큐 경유로 trade_id 미확보, order_id로 조회
|
||
delay=3,
|
||
# [2026-10-08] 체결가로 ActiveTrade 진입가 보정 (위 upsert 와 같은 전략명)
|
||
fill_entry_strategy_name=(
|
||
stock.get("strategy_name") or stock.get("strategy_type", "swing")
|
||
),
|
||
sell_pnl_basis={"strategy_type": stock.get("strategy_type", "swing")},
|
||
)
|
||
)
|
||
# [H-1] 기존 `elif is_pending:` 자동취소 분기 제거 — rt_cd≠"0" 은 거부라
|
||
# 취소할 주문이 없다(주문번호도 없음). 접수 성공 건의 미체결 정리는
|
||
# _verify_and_sync_execution 경로가 담당한다.
|
||
|
||
return {
|
||
"action": "BUY",
|
||
"stock": stock_name,
|
||
"quantity": quantity,
|
||
"price": current_price,
|
||
"success": success,
|
||
}
|
||
|
||
except ValueError as e:
|
||
logger.error(f"[BUY_VALIDATION] {stock_code}: {e}")
|
||
return {"action": "BUY_FAILED", "stock": stock_name, "error": str(e)}
|
||
except Exception as e:
|
||
logger.error(f"[BUY_ERROR] {stock_code}: {type(e).__name__}: {e}", exc_info=True)
|
||
return {"action": "BUY_FAILED", "stock": stock_name, "error": str(e)}
|
||
finally:
|
||
await _release_order_lock(stock_code, "BUY")
|
||
|
||
|
||
def _dt_inmemory_qty_v2(stock_code: str) -> int | None:
|
||
"""DT 인메모리 포지션 수량. 조회 실패 시 None(호출부가 '확인 불가'로 취급)."""
|
||
try:
|
||
from app.services.daytrading.position_manager import day_trading_state as _dts
|
||
return int((_dts.positions.get(stock_code) or {}).get("quantity", 0) or 0)
|
||
except Exception as e:
|
||
logger.warning(f"[SELL] {stock_code}: DT 인메모리 수량 조회 실패: {type(e).__name__}: {e}")
|
||
return None
|
||
|
||
|
||
# 자동 매도 대상이 아닌 Portfolio.strategy_type — 사용자 수동 판단 원칙.
|
||
# external : sync 가 시스템 매수 근거 없이 발견한 유입 잔고(portfolio.EXTERNAL_STRATEGY_TYPE)
|
||
# manual : manual_buy / portfolio_v2 수동 매수
|
||
_MANUAL_JUDGMENT_STRATEGY_TYPES = ("external", "manual")
|
||
|
||
# 스윙 엔진이 '자기 것'으로 간주하는 strategy_type (NULL 레거시 행은 별도로 포함).
|
||
# 매도 소유권(_sell_ownership_block_reason_v2)과 일일 매수 한도 집계
|
||
# (_count_swing_buys_today_v2)가 같은 기준을 쓴다 — 한쪽만 바꾸지 말 것.
|
||
# swing/position_manager.STRATEGY_TYPE("swing") 과 동일.
|
||
_SWING_OWNER_STRATEGY_TYPES = ("swing",)
|
||
|
||
|
||
def _swing_owned_clause_v2(column):
|
||
"""스윙 소유 행 SQL 필터 = `column IS NULL OR column IN (_SWING_OWNER_STRATEGY_TYPES)`.
|
||
|
||
NULL 을 명시 포함한다(SQL 3값 논리 — `IN` 만 쓰면 legacy NULL 행이 빠진다).
|
||
"""
|
||
return or_(column.is_(None), column.in_(_SWING_OWNER_STRATEGY_TYPES))
|
||
|
||
|
||
def _sell_ownership_block_reason_v2(holding, stock: dict) -> str | None:
|
||
"""추천 경로 매도(_execute_sell)가 이 보유 행을 팔아도 되는지 판정.
|
||
|
||
swing/exit_service 가 `get_swing_holdings()`(strategy_type=='swing') 만 청산하는 것과
|
||
같은 기준이다. 반환이 None 이면 허용, 문자열이면 SKIP 사유.
|
||
|
||
- external / manual → 'manual_judgment_holding' (warning)
|
||
- DT 계열(DT_STRATEGY_NAMES) → 'owned_by_daytrading' — DT 엔진 소유
|
||
(단 호출자 태그도 DT 계열이면 자기 보유분이므로 허용)
|
||
- 그 외 비-swing(us_swing 등) → 'owned_by_other_strategy' — 호출자 태그와 같을 때만 허용
|
||
|
||
strategy_type 이 비어 있으면 모델 기본값과 같이 'swing' 으로 본다.
|
||
MDD 강제축소(mdd_manager)·DT 청산·swing/exit_service 는 이 함수를 거치지 않는다
|
||
(각자 주문 경로를 가진다) — 리스크 청산은 영향받지 않는다(§8.1-11).
|
||
"""
|
||
from app.services.db_worker import DT_STRATEGY_NAMES
|
||
|
||
_holding_type = (getattr(holding, "strategy_type", None) or "swing")
|
||
_caller_tag = stock.get("strategy_type") or "swing"
|
||
if _holding_type in _SWING_OWNER_STRATEGY_TYPES:
|
||
return None
|
||
if _holding_type in _MANUAL_JUDGMENT_STRATEGY_TYPES:
|
||
return "manual_judgment_holding"
|
||
if _holding_type in DT_STRATEGY_NAMES:
|
||
return None if _caller_tag in DT_STRATEGY_NAMES else "owned_by_daytrading"
|
||
return None if _caller_tag == _holding_type else "owned_by_other_strategy"
|
||
|
||
|
||
# ── [하드닝 R1 2026-10-09] 추천 경로 매도 ↔ swing/exit_service 공용 가드 ──────────────
|
||
# 스윙 보유분을 매도하는 엔진이 둘이다(swing/exit_service 60초 주기, 추천 경로 _execute_sell).
|
||
# exit_service 는 종목별 최근 청산 시각(_recent_exits, EXIT_COOLDOWN_SEC)과 매도 직전 KIS
|
||
# 실보유 상한(_presell_kis_holding_v2)으로 큐 지연 중 이중 분할매도·과다매도를 막는데,
|
||
# _execute_sell 은 둘 다 쓰지 않아 큐 적체 시 같은 단계를 한 번 더 낼 수 있었다.
|
||
# → 두 경로가 같은 _recent_exits 딕셔너리와 같은 KIS 상한 함수를 쓴다(정본은 exit_service).
|
||
|
||
# ── [하드닝 R1] 가격 필터 ETF/리츠 예외 판정 ─────────────────────────────────────
|
||
# 기존: 종목명에 키워드가 '어디든' 들어 있으면 예외 → '인프라'로 시작하는 일반주, 영문명에
|
||
# SOL/ACE/ETF 가 섞인 종목(NETFLIX ⊃ ETF)이 5,000원 이하여도 §5.1 가격 필터를 우회했다.
|
||
# - 운용사 브랜드: 종목명 '접두사' + 뒤가 영문자가 아닐 때만 ("KODEX 200", "SOL 미국배당")
|
||
# - ETF/ETN/REIT: 독립 단어(영문자 경계)일 때만
|
||
# - 리츠/인프라: 종목명 '접미사'일 때만 ("SK리츠", "맥쿼리인프라")
|
||
_PRICE_EXEMPT_ETF_BRANDS = ("KODEX", "TIGER", "KBSTAR", "ARIRANG", "SOL", "HANARO", "ACE")
|
||
_PRICE_EXEMPT_WORD_RE = re.compile(r"(?<![A-Z])(?:ETF|ETN|REIT|REITS)(?![A-Z])")
|
||
_PRICE_EXEMPT_SUFFIXES = ("리츠", "인프라")
|
||
|
||
|
||
def _is_price_filter_exempt_name_v2(stock_name) -> bool:
|
||
"""가격 필터(MIN_PRICE_*) 예외 대상(ETF/ETN/리츠/인프라펀드) 종목명 판정. 이름 없으면 False."""
|
||
name = str(stock_name or "").strip().upper()
|
||
if not name:
|
||
return False
|
||
for brand in _PRICE_EXEMPT_ETF_BRANDS:
|
||
if name.startswith(brand):
|
||
nxt = name[len(brand):len(brand) + 1]
|
||
if not ("A" <= nxt <= "Z"):
|
||
return True
|
||
if _PRICE_EXEMPT_WORD_RE.search(name):
|
||
return True
|
||
return name.endswith(_PRICE_EXEMPT_SUFFIXES)
|
||
|
||
|
||
def _swing_exit_cooldown_block_v2(stock_code: str) -> str | None:
|
||
"""공용 스윙 청산 쿨다운 판정. 차단이면 사유 문자열, 허용이면 None.
|
||
|
||
swing/exit_service._recent_exits 를 그대로 참조한다(한쪽에만 기록하면 다시 이중화된다).
|
||
참조 자체가 실패하면 fail-closed('cooldown_check_failed') — 추천 경로 매도를 보류해도
|
||
exit_service 가 손절·익절을 계속 판정하므로 청산이 사라지지는 않는다(§8.1-11).
|
||
"""
|
||
try:
|
||
from app.services.swing.exit_service import _recent_exits, EXIT_COOLDOWN_SEC
|
||
_last = _recent_exits.get(stock_code)
|
||
_cool = float(EXIT_COOLDOWN_SEC)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: 공용 청산 쿨다운 조회 실패 — 추천 경로 매도 보류 "
|
||
f"({type(e).__name__}: {e})"
|
||
)
|
||
return "cooldown_check_failed"
|
||
if _last is None:
|
||
return None
|
||
_elapsed = time.time() - float(_last)
|
||
if _elapsed < _cool:
|
||
logger.info(
|
||
f"[SELL] {stock_code}: 직전 스윙 청산 {int(_elapsed)}초 전 — 공용 쿨다운"
|
||
f"({int(_cool)}초) 중 추천 경로 매도 스킵"
|
||
)
|
||
return "recent_swing_exit_cooldown"
|
||
return None
|
||
|
||
|
||
def _mark_swing_exit_v2(stock_code: str) -> None:
|
||
"""추천 경로 매도(접수 또는 결과 불명)를 공용 _recent_exits 에 기록 — exit_service 도 쿨다운."""
|
||
try:
|
||
from app.services.swing.exit_service import _recent_exits
|
||
_recent_exits[stock_code] = time.time()
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: 공용 청산 시각 기록 실패 — exit_service 쿨다운 미적용 가능 "
|
||
f"({type(e).__name__}: {e})"
|
||
)
|
||
|
||
|
||
async def _recommendation_sell_kis_cap_v2(stock_code: str, dt_qty: int) -> "tuple[int, int] | None":
|
||
"""추천 경로 국내 매도 직전 KIS 실보유 상한. (매도 상한, 스윙 실보유) 또는 None(조회 실패).
|
||
|
||
매도 상한 = max(0, min(주문가능, 보유) − DT 인메모리) — swing/exit_service 와 같은 식.
|
||
스윙 실보유 = max(0, 보유 − DT) — 전량 청산 판정 기준(대기 중 매도 주문분은 보유에 남는다).
|
||
조회 실패면 None → 호출부는 매도를 보류한다(과다매도보다 청산 지연이 낫다, exit_service 와 동일).
|
||
"""
|
||
try:
|
||
from app.services.swing.exit_service import _presell_kis_holding_v2
|
||
except Exception as e:
|
||
logger.warning(f"[SELL] {stock_code}: KIS 상한 함수 import 실패 — 매도 보류 ({type(e).__name__}: {e})")
|
||
return None
|
||
snap = await _presell_kis_holding_v2(stock_code)
|
||
if snap is None:
|
||
return None
|
||
_hldg, _sellable = int(snap[0]), int(snap[1])
|
||
_dt = max(0, int(dt_qty or 0))
|
||
return max(0, min(_sellable, _hldg) - _dt), max(0, _hldg - _dt)
|
||
|
||
|
||
async def _recommendation_prior_position_net_v2(
|
||
db: AsyncSession, stock_code: str, market,
|
||
) -> "float | None":
|
||
"""[하드닝 R1 2026-10-09] 추천 경로 전량 청산 — 이번 레그 이전에 실현된 포지션 순손익 합(원).
|
||
|
||
swing/exit_service 와 **같은 정의**(_prior_position_realized_net_v2)를 쓰기 위해 비-DT active
|
||
ActiveTrade 행을 SELECT 해 그대로 위임한다. 주문 전에 호출해야 한다(이번 레그 TradeHistory 가
|
||
큐로 먼저 커밋되면 이중 합산). 행이 없거나 조회·import 실패면 None → 이번 레그 순손익만으로 판정.
|
||
SELECT 전용(commit·add 없음).
|
||
"""
|
||
try:
|
||
from app.models.models import ActiveTrade as _AT
|
||
from app.services.db_worker import not_dt_strategy_clause
|
||
from app.services.swing.exit_service import _prior_position_realized_net_v2
|
||
_row = (await db.execute(
|
||
select(_AT)
|
||
.where(
|
||
_AT.stock_code == stock_code,
|
||
_AT.status == "active",
|
||
not_dt_strategy_clause(_AT.strategy_name),
|
||
)
|
||
.order_by(_AT.id.desc())
|
||
.limit(1)
|
||
)).scalars().first()
|
||
if _row is None:
|
||
return None
|
||
return await _prior_position_realized_net_v2(db, stock_code, _row, market)
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: 포지션 누적 실현손익 조회 실패 — 이번 레그 순손익만으로 승패 판정 "
|
||
f"({type(e).__name__}: {e})"
|
||
)
|
||
return None
|
||
|
||
|
||
def _recommendation_position_is_loss_v2(prior_realized_net, leg_net) -> bool:
|
||
"""추천 경로 전량 청산 승패 — swing/exit_service._position_is_loss_v2 와 동일 정의(순손익, §5.1).
|
||
|
||
포지션 누적 순손익(이전 레그 합 + 이번 레그 순손익) < 0 이면 패. 왕복 비용 이내의 소폭 이익도 패.
|
||
"""
|
||
try:
|
||
from app.services.swing.exit_service import _position_is_loss_v2
|
||
except Exception as e:
|
||
logger.warning(f"[SELL] _position_is_loss_v2 import 실패 — 동일 식 인라인 사용 ({type(e).__name__}: {e})")
|
||
total = float(leg_net) + (float(prior_realized_net) if prior_realized_net is not None else 0.0)
|
||
return total < 0
|
||
return _position_is_loss_v2(prior_realized_net, leg_net)
|
||
|
||
|
||
def _non_name_target_for_sell_v2(stock: dict) -> tuple:
|
||
"""전략명으로 매칭할 수 없을 때의 ActiveTrade 대상 — (strategy_name, filter_not_dt).
|
||
|
||
DT 로 태깅된 보유분은 DT 전략명(기존 동작), 그 외는 비-DT 최신 행을 직접 겨냥한다.
|
||
"""
|
||
from app.services.db_worker import DT_STRATEGY_NAMES
|
||
_st = stock.get("strategy_type") or "swing"
|
||
if _st in DT_STRATEGY_NAMES:
|
||
return _st, False
|
||
return None, True
|
||
|
||
|
||
async def _resolve_sell_active_trade_target_v2(db, stock: dict, stock_code: str) -> tuple:
|
||
"""추천 경로 매도의 ActiveTrade 대상 결정 — (strategy_name|None, filter_not_dt).
|
||
|
||
filter_not_dt=True 면 payload 에 strategy_name_not=DT_STRATEGY_NAMES 를 써서 비-DT
|
||
최신 행을 겨냥한다(전략명 NULL·'synced' 등 이름을 모르는 행 포함).
|
||
[하드닝 R8] 역추적 SELECT 예외 시 예전에는 로그 없이 'swing' 이름으로 폴백해,
|
||
실제 행이 'synced' 면 close/upsert 매칭이 0건이 되어 유령 active 행이 남고
|
||
remaining_pct 미갱신으로 분할 단계가 재발동할 수 있었다 → warning + 비-DT 필터.
|
||
"""
|
||
_name = stock.get("strategy_name")
|
||
if _name:
|
||
return _name, False
|
||
try:
|
||
from app.models.models import ActiveTrade as _AT
|
||
from app.services.db_worker import not_dt_strategy_clause
|
||
_row = (await db.execute(
|
||
select(_AT)
|
||
.where(
|
||
_AT.stock_code == stock_code,
|
||
_AT.status == "active",
|
||
not_dt_strategy_clause(_AT.strategy_name),
|
||
)
|
||
.order_by(_AT.id.desc())
|
||
.limit(1)
|
||
)).scalars().first()
|
||
_name = _row.strategy_name if _row else None
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: ActiveTrade 전략명 역추적 실패 → 비-DT 최신 행 필터로 대상 지정 "
|
||
f"({type(e).__name__}: {e})"
|
||
)
|
||
return _non_name_target_for_sell_v2(stock)
|
||
if _name:
|
||
return _name, False
|
||
# 비-DT 행이 없거나(=닫을 대상 없음) 전략명이 NULL 인 경우.
|
||
return _non_name_target_for_sell_v2(stock)
|
||
|
||
|
||
async def _execute_sell(
|
||
stock: dict,
|
||
db: AsyncSession,
|
||
holding,
|
||
current_price: float,
|
||
signals: list,
|
||
is_domestic: bool,
|
||
exchange_code: str,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
sell_pct: float = 1.0, # [CLAUDE.md 5.2] 분할매도 비율 (0.5 = 50%, 1.0 = 전량)
|
||
) -> dict:
|
||
"""SELL 주문 실행 로직 — 중복체크 → semaphore → 주문 → TradeHistory → 체결 확인.
|
||
|
||
[동작 흐름]
|
||
1. 현재 손익률 계산 (현재가 vs 평균매입가)
|
||
2. ATR 기반 동적 손절선·트레일링스탑 재계산
|
||
3. Redis 분산락 획득 → 중복 매도 방지
|
||
4. 30초 이내 동일 종목 SELL 기록 확인 (FAILED 제외)
|
||
5. 지정가 -0.5% 조정 후 KIS SELL 주문
|
||
6. TradeHistory DB 기록 (flush → id 확보 → commit)
|
||
7. 성공 시: 포트폴리오 캐시 즉시 제거 + 체결 확인 백그라운드 태스크
|
||
|
||
[2026-03-15 CLAUDE.md 정합성 수정]
|
||
- sell_pct 파라미터 추가: check_exit_signal의 SELL_PARTIAL(50%) 지원
|
||
- 기본 손절 -6% (CLAUDE.md 5.2), 익절 2R (ATR 기반)
|
||
"""
|
||
|
||
# ── 보유 행 소유권 가드 (2026-10-01) ─────────────────────────────────────
|
||
# 추천 경로는 strategy_type 검사 없이 보유 행을 스윙 이름으로 팔았다
|
||
# (external·manual 유입 잔고, strategy_type='daytrading' 행 포함).
|
||
# 이 함수의 호출자는 execute_auto_trade 하나뿐이며 MDD 강제축소·DT 청산·
|
||
# swing/exit_service 는 별도 주문 경로라 영향이 없다. try 밖 가드(§4).
|
||
_ownership_block = _sell_ownership_block_reason_v2(holding, stock)
|
||
if _ownership_block is not None:
|
||
_h_type = getattr(holding, "strategy_type", None)
|
||
_msg = (
|
||
f"[SELL] {stock_code}/{stock_name}: 보유 {getattr(holding, 'quantity', '?')}주 "
|
||
f"strategy_type='{_h_type}' — 추천 경로 자동매도 스킵({_ownership_block}, "
|
||
f"요청 sell_pct={sell_pct*100:.0f}%, 호출 태그='{stock.get('strategy_type', 'swing')}')"
|
||
)
|
||
if _ownership_block == "owned_by_daytrading":
|
||
# [2026-10-01] DT 인메모리에 포지션이 없는데 daytrading 행이 남아 있으면
|
||
# 고아 행일 수 있다(재시작·stale 청산 실패 등) — 아무 엔진도 팔지 않으므로
|
||
# info 에 묻히지 않게 warning 으로 올린다.
|
||
_dt_mem_qty = _dt_inmemory_qty_v2(stock_code)
|
||
if _dt_mem_qty is None or _dt_mem_qty <= 0:
|
||
logger.warning(
|
||
_msg + f" — DT 인메모리 포지션 "
|
||
f"{'조회 실패' if _dt_mem_qty is None else '0주'}인데 daytrading 행 "
|
||
f"{getattr(holding, 'quantity', '?')}주가 남아 있음: 고아 행 가능성, "
|
||
f"수동 확인 필요 ({stock_name}/{stock_code})"
|
||
)
|
||
else:
|
||
logger.info(_msg + f" — DT 엔진 소유(인메모리 {_dt_mem_qty}주)")
|
||
elif _ownership_block == "manual_judgment_holding":
|
||
logger.warning(_msg + " — 유입/수동 보유분은 수동 판단 대상")
|
||
else:
|
||
logger.warning(_msg + " — 다른 전략 엔진 소유")
|
||
return {"action": "SKIP", "reason": _ownership_block, "stock": stock_name}
|
||
|
||
# ── [하드닝 R1] swing/exit_service 와 공용 청산 쿨다운 (try 밖 가드, §4) ──────────
|
||
# 큐 적체로 remaining_pct·Portfolio 가 아직 옛 값이면 exit_service 가 막 낸 분할매도와
|
||
# 같은 단계를 추천 경로가 다시 낼 수 있다 → 같은 _recent_exits 로 차단.
|
||
_cooldown_block = _swing_exit_cooldown_block_v2(stock_code)
|
||
if _cooldown_block is not None:
|
||
return {"action": "SKIP", "reason": _cooldown_block, "stock": stock_name}
|
||
|
||
# [CLAUDE.md 5.2] 분할매도: sell_pct에 따라 매도 수량 결정
|
||
# [2026-09-23] Portfolio 행은 stock_code UNIQUE 라 같은 종목의 스윙+데이트레이딩
|
||
# 수량이 합산돼 있다. 행 전체를 대상으로 잡으면 다른 전략 보유분까지 매도된다
|
||
# → 데이트레이딩 엔진이 들고 있는 수량은 제외한 '이 전략의 보유분'만 대상으로 한다.
|
||
total_qty = holding.quantity
|
||
# [M-3 2026-09-27] 변수 기준 구분:
|
||
# _row_total_qty = Portfolio 행 수량(스윙+DT 합산) — 포트폴리오 캐시/DB 행 기준
|
||
# total_qty = 이 전략의 보유분(_own_qty, DT 제외) — 주문·잔량 회계 기준
|
||
# 캐시 반영은 반드시 행 합산 기준(_row_total_qty)을 써야 DT 보유분이 사라지지 않는다
|
||
# (swing/exit_service.reflect_sell / portfolio_cache_bridge 와 동일 기준).
|
||
_row_total_qty = int(total_qty or 0)
|
||
_strategy_tag = stock.get("strategy_type", "swing")
|
||
if _strategy_tag != "daytrading":
|
||
try:
|
||
from app.services.daytrading.position_manager import day_trading_state as _dts
|
||
_dt_pos = _dts.positions.get(stock_code)
|
||
_dt_qty = int((_dt_pos or {}).get("quantity", 0) or 0)
|
||
except Exception:
|
||
_dt_qty = 0
|
||
if _dt_qty > 0:
|
||
_own = max(0, total_qty - _dt_qty)
|
||
if _own <= 0:
|
||
logger.info(
|
||
f"[SELL] {stock_name}: 보유 {total_qty}주 전량이 데이트레이딩 포지션 — 스윙 청산 스킵"
|
||
)
|
||
return {"action": "SKIP", "reason": "owned_by_daytrading", "stock": stock_name}
|
||
logger.info(
|
||
f"[SELL] {stock_name}: 보유 {total_qty}주 중 DT {_dt_qty}주 제외 → {_own}주 대상"
|
||
)
|
||
total_qty = _own # = _own_qty (이 전략 보유분)
|
||
|
||
# ── 매도 수량 결정 (원본 수량 기준) ──────────────────────────────────────
|
||
# [M-1 2026-09-27] sell_pct 의 의미 = '진입 시 원본 수량 대비' 비율.
|
||
# check_exit_signal(>0.50) / _check_momentum_exit(>0.75, 0.45~0.75) /
|
||
# range_trading_strategy(>0.50) 의 remaining_pct 게이트가 원본 누적
|
||
# (1.0 → 0.70 → 0.40)을 전제하므로 매도 수량도 원본 기준이어야 한다.
|
||
# 기존 코드는 수량은 '현재 잔량' 기준, new_remaining 은 '원본' 기준 차감이라
|
||
# 분할이 반복될수록 과소매도 + remaining_pct 오염이 누적됐다.
|
||
# → swing/exit_service.py 와 동일하게 원본 수량을 remaining_pct 로 역산한다.
|
||
_rp_for_qty, _rp_tracked_for_qty = _resolve_remaining_pct_v2(stock, holding)
|
||
_original_qty = total_qty
|
||
if _rp_tracked_for_qty and 0.0 < _rp_for_qty < 1.0:
|
||
# 0 나눗셈 가드 = 위 조건(0 < rp), original_qty < total_qty 가드 = max()
|
||
_original_qty = max(total_qty, int(round(total_qty / _rp_for_qty)))
|
||
elif not _rp_tracked_for_qty and sell_pct < 1.0:
|
||
# 추적 불가(ActiveTrade active 행 없음/오염) → 역산 불가.
|
||
# 상위 execute_auto_trade 가 이 경우 부분매도 신호를 폐기하므로(§8.5 항목4①)
|
||
# 정상 경로에서는 도달하지 않는다. 방어적으로 '현재 잔량 = 원본' 으로 두어
|
||
# 기존 동작(현재 잔량 기준 비율 매도)을 유지한다.
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: remaining_pct 추적 불가 상태에서 부분매도 요청 "
|
||
f"(sell_pct={sell_pct*100:.0f}%) — 원본 수량 역산 불가, 현재 잔량 기준 적용"
|
||
)
|
||
|
||
if sell_pct >= 1.0:
|
||
quantity = total_qty # 전량매도 시 잔여분 없도록 (기존 동작 유지)
|
||
else:
|
||
quantity = min(max(int(_original_qty * sell_pct), 1), total_qty)
|
||
|
||
# [M-2 2026-09-27] 계산된 매도 수량이 보유 전량과 같아지면(1~2주 소량 보유 +
|
||
# sell_pct=0.5 → max(1,·) 로 전량 체결) 실질적 전량 청산이다. sell_pct<1.0
|
||
# 분기를 그대로 타면 close_active_trade 가 호출되지 않아 quantity=0 유령 active
|
||
# 행이 남고, loss_tracker.record_trade_result_safe() 도 스킵돼 §5.1 3연패 밴
|
||
# 카운트에서 이 청산이 빠진다 → 실제 체결 기준으로 전량 청산 처리한다.
|
||
# ── [하드닝 R1] 국내 매도 직전 KIS 실보유 상한 (swing/exit_service 와 같은 식, try 밖 §4) ──
|
||
# Portfolio 수량(sync 지연)·remaining_pct(큐 지연)만으로 정하면 exit_service 가 막 판
|
||
# 물량이나 DT 물량까지 다시 팔 수 있다. 상한 = min(주문가능, 보유) − DT 인메모리.
|
||
# 조회 실패·DT 수량 확인 불가면 매도 보류(청산 지연 < 과다매도), 상한 0 이면 주문 안 함.
|
||
if is_domestic:
|
||
if _strategy_tag != "daytrading":
|
||
_dt_for_cap = _dt_inmemory_qty_v2(stock_code)
|
||
if _dt_for_cap is None:
|
||
logger.warning(f"[SELL] {stock_code}: DT 수량 확인 불가 — 추천 경로 매도 보류")
|
||
return {"action": "SKIP", "reason": "dt_qty_unknown", "stock": stock_name}
|
||
else:
|
||
_dt_for_cap = 0
|
||
_kis_cap = await _recommendation_sell_kis_cap_v2(stock_code, _dt_for_cap)
|
||
if _kis_cap is None:
|
||
return {"action": "SKIP", "reason": "kis_holding_check_failed", "stock": stock_name}
|
||
_cap_qty, _kis_own_qty = _kis_cap
|
||
if _cap_qty <= 0:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: KIS 기준 매도 가능 0주 (스윙 실보유 {_kis_own_qty}, "
|
||
f"DT {_dt_for_cap}) — 추천 경로 매도 안 함"
|
||
)
|
||
return {"action": "SKIP", "reason": "kis_sellable_zero", "stock": stock_name}
|
||
if _kis_own_qty < total_qty:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: 장부 보유 {total_qty}주 > KIS 실보유 {_kis_own_qty}주 — KIS 기준 적용"
|
||
)
|
||
total_qty = _kis_own_qty
|
||
if quantity > _cap_qty:
|
||
logger.warning(
|
||
f"[SELL] {stock_code}: 매도 수량 {quantity}주 > KIS 매도 상한 {_cap_qty}주 — 상한 적용"
|
||
)
|
||
quantity = _cap_qty
|
||
if quantity > total_qty:
|
||
quantity = total_qty
|
||
|
||
_full_exit = sell_pct >= 1.0 or (total_qty > 0 and quantity >= total_qty)
|
||
if _full_exit and sell_pct < 1.0:
|
||
logger.info(
|
||
f"[SELL] {stock_code}: 부분매도 요청({sell_pct*100:.0f}%)이 보유 전량"
|
||
f"({total_qty}주)과 동일 → 전량 청산으로 처리 (ActiveTrade 종료 + 손실추적)"
|
||
)
|
||
|
||
_avg = _swing_entry_price_for_stock_v2(stock, holding, stock_code)
|
||
if abs(_avg - float(holding.average_price or 0)) >= 0.01:
|
||
# 혼합 평단 대신 스윙 진입가로 판정할 때는 KIS 손익률(혼합 평단 기준)을 쓰지 않는다
|
||
profit_loss_rate = calculate_profit_loss_rate(current_price, _avg, None)
|
||
else:
|
||
profit_loss_rate = calculate_profit_loss_rate(current_price, _avg, holding.profit_loss_rate)
|
||
|
||
# [CLAUDE.md 5.2] 기본 손절 -6% (안정적 종목), 익절은 ATR 기반 2R
|
||
take_profit = stock.get("take_profit", 5.0)
|
||
base_stop_loss = stock.get("stop_loss", -float(settings.STOP_LOSS_PERCENT))
|
||
|
||
# ── ATR 기반 동적 손절/트레일링 스탑 조정 ────────────────────────────────
|
||
atr = float(stock.get("atr", 0) or 0)
|
||
atr_stops = calculate_atr_based_stops(
|
||
_avg, current_price, atr, stock,
|
||
base_stop_loss=base_stop_loss
|
||
)
|
||
# [2026-09-27] atr_stops["stop_loss"] 는 _execute_sell 내에서 사용되지 않아 제거
|
||
# (실제 스윙 손절 판정은 swing/exit_service 단일 경로 — execute_auto_trade 의
|
||
# check_exit_signal/ATR 강제 손절 블록은 추천 dict 에 atr 이 없어 운영상 휴면이다)
|
||
trailing_stop_price = atr_stops["trailing_stop_price"]
|
||
exit_reason_detail = atr_stops["exit_reason_detail"] or f"손익률 {profit_loss_rate:.2f}%"
|
||
|
||
# Redis 분산락 획득 — 여러 워커가 동시에 같은 종목을 매도하는 것을 방지
|
||
if not await _acquire_order_lock(stock_code, "SELL"):
|
||
return {"action": "SKIP", "stock": stock_name, "reason": "order_lock_busy"}
|
||
|
||
try:
|
||
# ── 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,
|
||
)
|
||
)
|
||
if duplicate_check.scalars().first():
|
||
return {"action": "SKIP", "reason": "duplicate_order", "stock": stock_name}
|
||
|
||
# [하드닝 R1 2026-10-09] 전량 청산 승패용 이전 레그 순손익 합 — 주문 전에 구한다
|
||
# (이번 레그 TradeHistory 가 큐로 먼저 커밋되면 이중 합산). swing/exit_service 와 같은 정의.
|
||
_prior_realized_net = None
|
||
if _full_exit:
|
||
_prior_realized_net = await _recommendation_prior_position_net_v2(
|
||
db, stock_code, stock.get("market", "KOSPI") or "KOSPI",
|
||
)
|
||
|
||
# ── 2. 주문 실행 (종목별 세마포어 + 재시도) ──────────────────────────
|
||
# [H-1 4회차 2026-10-02] current_price 는 추천 경로에서 StockAnalysis 배치 값(최대 30분
|
||
# 낡음)이다. 그 ×0.995 지정가는 하락 중 미체결로 남아 수량을 잠가 swing/exit_service 의
|
||
# 시장가 손절까지 거부됐다. → 국내:
|
||
# - 전량 청산·손실 청산(손절) = 시장가(price=None)
|
||
# - 부분 익절 = 주문 직전 현재가로 재산정한 지정가(조회 실패 시 시장가)
|
||
# 해외는 기존 유지(US_TRADING_ENABLED=False, 시장가 미지원 경로).
|
||
_ref_price, order_price, _order_kind = _resolve_sell_order_price_v2(
|
||
stock_code, current_price, is_domestic, _full_exit, profit_loss_rate
|
||
)
|
||
if _order_kind == "limit_refresh":
|
||
_ref_price = await _fresh_domestic_price_v2(stock_code)
|
||
if _ref_price > 0:
|
||
order_price = _adjust_order_price(_ref_price, "SELL", is_domestic)
|
||
else:
|
||
_ref_price, order_price, _order_kind = current_price, None, "market_fallback"
|
||
logger.info(
|
||
f"[SELL] {stock_code}/{stock_name}: 주문 방식={_order_kind} "
|
||
f"(가격={'시장가' if order_price is None else f'{order_price:,.2f}'}, 기준가={_ref_price:,.2f}, "
|
||
f"배치가={current_price:,.2f}, 전량={_full_exit}, 손익률={profit_loss_rate:.2f}%)"
|
||
)
|
||
async with _get_order_semaphore(stock_code):
|
||
order_result = await _place_order_with_retry(
|
||
is_domestic=is_domestic,
|
||
stock_code=stock_code,
|
||
order_type="SELL",
|
||
quantity=quantity,
|
||
price=order_price,
|
||
exchange_code=exchange_code,
|
||
)
|
||
# 체결 확인·슬리피지 기준가 (시장가면 직전 기준가)
|
||
_verify_ref_price = float(order_price) if order_price is not None else float(_ref_price)
|
||
|
||
# 확인 전 추정치(배치 현재가 기준) — 체결 확인 시 체결가×체결수량·순손익으로 덮어쓴다
|
||
total_amount = Decimal(str(current_price)) * quantity
|
||
gross_profit_loss = (current_price - (_avg or current_price)) * quantity
|
||
# [#4 수수료/세금 반영] net PnL 계산
|
||
_market_type = stock.get("market", "KOSPI") or "KOSPI"
|
||
trade_costs = calculate_trade_costs(
|
||
entry_price=_avg, exit_price=current_price, quantity=quantity,
|
||
is_domestic=is_domestic, market=_market_type,
|
||
)
|
||
profit_loss = gross_profit_loss - trade_costs["total_cost"] # net 손익
|
||
success = order_result.get("rt_cd") == "0"
|
||
# [H-1 2026-10-02] rt_cd≠"0" = 거부/실패 → FAILED (PENDING 으로 남기면 30초
|
||
# 중복매도 차단·당일 부분매도 차단이 거부 주문에 소진된다).
|
||
# [H-3 5회차] 단 전송 후 결과 불명은 PENDING — 팔렸을 수 있으므로 30초 중복매도 차단·
|
||
# 당일 매도 판정이 이 주문을 접수된 것으로 봐야 재매도(과다매도)가 나지 않는다.
|
||
_outcome_unknown = (not success) and _is_order_outcome_unknown_v2(order_result)
|
||
status = "COMPLETED" if success else ("PENDING" if _outcome_unknown else "FAILED")
|
||
if _outcome_unknown:
|
||
spawn_tracked_task_v2(_delayed_sync_portfolio(3))
|
||
# [하드닝 R1] 접수·결과 불명 매도는 공용 청산 시각에 기록 → exit_service 도 쿨다운을 적용해
|
||
# 큐 반영 전 같은 단계 재매도를 막는다(거부=FAILED 는 기록하지 않아 즉시 재시도 허용).
|
||
if success or _outcome_unknown:
|
||
_mark_swing_exit_v2(stock_code)
|
||
# [H-1 5회차] 미체결 자동 취소 = 국내 지정가 부분 익절 + 자기 주문번호일 때만.
|
||
# 시장가(전량·손절)는 절대 취소하지 않는다. 조회로 매칭된 주문(_matched_by_lookup)은
|
||
# 자기 주문이라는 보장이 없어 취소 대상에서 뺀다(L-5).
|
||
_cancel_unfilled_limit = (
|
||
is_domestic and order_price is not None and not _full_exit
|
||
and not order_result.get("_matched_by_lookup")
|
||
)
|
||
_at_rollback: dict | None = None
|
||
|
||
# TradeHistory DB 기록 (db_worker 큐 경유 — CLAUDE.md 3.2 준수)
|
||
kis_order_id = build_kis_order_id(order_result)
|
||
from app.services.db_worker import enqueue_trade_history
|
||
await enqueue_trade_history({
|
||
"rule_id": None,
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
"order_type": "SELL",
|
||
# [2026-10-08] order_price = 실제 지정가(시장가면 주문 직전 기준가). 체결가는 확인 후 기록.
|
||
"order_price": Decimal(str(_verify_ref_price)),
|
||
"order_quantity": quantity,
|
||
"executed_price": None,
|
||
"executed_quantity": quantity if success else 0,
|
||
"total_amount": total_amount,
|
||
"status": status,
|
||
"order_id": kis_order_id,
|
||
"message": f"자동매도: {exit_reason_detail}",
|
||
"exit_reason": f"손익: {profit_loss:,.0f}원 (수수료/세금: {trade_costs['total_cost']:,.0f}원)",
|
||
"signals": signals,
|
||
"commission": Decimal(str(trade_costs["total_cost"])) if success else None,
|
||
"net_profit_loss": Decimal(str(profit_loss)) if success else None,
|
||
"profit_loss_rate": Decimal(str(profit_loss_rate)) if success else None,
|
||
"strategy_type": stock.get("strategy_type", "swing"),
|
||
"currency_code": get_market_info(stock_code)["currency"],
|
||
"exchange_code": exchange_code,
|
||
"created_at": _get_kst_now(),
|
||
"executed_at": _get_kst_now() if success else None,
|
||
})
|
||
|
||
if success:
|
||
# [CLAUDE.md 5.5 / 8.1#6] 연속 손실 추적 — 전량매도 시 loss_tracker 기록
|
||
# [M-2] _full_exit = sell_pct>=1.0 또는 '계산 수량 == 보유 전량'
|
||
if _full_exit:
|
||
try:
|
||
from app.services.loss_tracker import loss_tracker
|
||
# [하드닝 R1 2026-10-09] gross 수익률(profit_loss_rate) 이 아니라 비용 차감 순손익 +
|
||
# 포지션 누적(이전 분할 레그) 기준 — swing/exit_service 와 동일 정의(§5.1).
|
||
is_loss = _recommendation_position_is_loss_v2(_prior_realized_net, profit_loss)
|
||
await loss_tracker.record_trade_result_safe(
|
||
stock_code=stock_code,
|
||
is_loss=is_loss,
|
||
)
|
||
await loss_tracker.save_to_db(stock_code=stock_code)
|
||
except Exception as _lt_err:
|
||
logger.warning(f"[SELL] loss_tracker 업데이트 실패 {stock_code}: {_lt_err}")
|
||
|
||
# [C2] ActiveTrade 종료/갱신
|
||
try:
|
||
# 실제 행의 strategy_name 을 사용한다. strategy_type("swing")으로 닫으면
|
||
# 듀얼 전략 행(MOMENTUM_BREAKOUT/PULLBACK_BUY)과 매칭되지 않아 유령 행이 남는다.
|
||
# [§8.5 항목3 2026-09-27] 역추적은 not_dt_strategy_clause 로 DT 행 제외.
|
||
# 전략명 NULL 비-DT 행·역추적 실패(하드닝 R8)는 strategy_name_not 필터로
|
||
# 비-DT 최신 행을 직접 겨냥한다('swing' 폴백은 매칭 0건 → 유령 active 행).
|
||
_at_name, _at_filter_not_dt = await _resolve_sell_active_trade_target_v2(
|
||
db, stock, stock_code
|
||
)
|
||
_at_name = _at_name or stock.get("strategy_type", "swing")
|
||
|
||
if _full_exit: # [M-2] 실제 체결이 보유 전량이면 active 행을 닫는다
|
||
if _at_filter_not_dt:
|
||
from app.services.db_worker import (
|
||
DT_STRATEGY_NAMES as _DTN,
|
||
enqueue_db_write,
|
||
)
|
||
await enqueue_db_write({
|
||
"type": "close_active_trade",
|
||
"data": {
|
||
"stock_code": stock_code,
|
||
"strategy_name_not": list(_DTN),
|
||
},
|
||
})
|
||
else:
|
||
from app.services.db_worker import enqueue_close_active_trade
|
||
await enqueue_close_active_trade(stock_code, strategy_name=_at_name)
|
||
else:
|
||
from app.services.db_worker import enqueue_active_trade_upsert
|
||
# [§8.5 항목4] 추적 여부 확인용 (미추적 시 기존과 동일하게 1.0).
|
||
# 잔량 비율 자체는 아래에서 '원본 수량 기준 실제 체결' 로 계산한다.
|
||
remaining_pct, _rp_tracked = _resolve_remaining_pct_v2(stock, holding)
|
||
if not _rp_tracked:
|
||
logger.info(
|
||
f"[SELL] {stock_code}: remaining_pct 추적 불가 → 1.0 기준으로 "
|
||
f"ActiveTrade 잔량 재설정 (sell_pct={sell_pct*100:.0f}%)"
|
||
)
|
||
# [M-1] 원본 수량 기준 실제 잔량 비율. 뺄셈(remaining_pct - sell_pct)은
|
||
# 매도 수량이 현재 잔량 기준일 때와 어긋나 잔량이 오염됐다 →
|
||
# 실제 체결 수량으로 계산한다 (예: 원본 100, 잔량 70, 50주 매도 → 0.20).
|
||
# [H1 2026-10-02] 단, 홀수 수량의 내림 매도로 실제 비율이 게이트 위에
|
||
# 남으면 같은 단계가 재발동하므로 단계값(이전 − sell_pct)을 상한으로 둔다.
|
||
# 추적 불가(_rp_tracked=False)면 remaining_pct 는 1.0 으로 해석된다.
|
||
from app.services.sizing_core import remaining_pct_after_partial_sell
|
||
new_remaining = remaining_pct_after_partial_sell(
|
||
remaining_pct, sell_pct, max(0, total_qty - quantity), _original_qty
|
||
) if _original_qty > 0 else 0.0
|
||
_at_payload = {
|
||
"stock_code": stock_code,
|
||
"remaining_pct": new_remaining,
|
||
"quantity": max(0, total_qty - quantity), # 잔량 갱신(과다매도 방지)
|
||
# [Low 3회차] 고점은 내려가면 안 된다 — 트레일링 스탑이 현재가 기준으로
|
||
# 리셋돼 느슨해지던 문제. max(기존 고점, 현재가).
|
||
"highest_since_entry": max(
|
||
float(stock.get("highest_since_entry") or 0.0), float(current_price)
|
||
),
|
||
}
|
||
if _at_filter_not_dt:
|
||
# 전략명 NULL 인 비-DT 행 대상 (이름 동등 매칭 불가).
|
||
# 대상 행이 아예 없으면 db_worker 가 필수 키 누락으로 스킵 —
|
||
# 매도 경로에서 새 active 행을 만들지 않는 것이 의도된 동작이다.
|
||
from app.services.db_worker import DT_STRATEGY_NAMES as _DTN2
|
||
_at_payload["strategy_name_not"] = list(_DTN2)
|
||
else:
|
||
_at_payload["strategy_name"] = _at_name
|
||
# [H-1 5회차] 지정가 익절이 0체결로 취소되면 되돌릴 주문 전 상태
|
||
if _cancel_unfilled_limit:
|
||
_at_rollback = {
|
||
k: v for k, v in _at_payload.items()
|
||
if k not in ("remaining_pct", "quantity", "highest_since_entry")
|
||
}
|
||
_at_rollback.update({
|
||
"remaining_pct": remaining_pct if _rp_tracked else None,
|
||
"quantity": int(total_qty),
|
||
"highest_since_entry": (
|
||
float(stock["highest_since_entry"])
|
||
if stock.get("highest_since_entry") is not None else None
|
||
),
|
||
})
|
||
await enqueue_active_trade_upsert(_at_payload)
|
||
except Exception as _at_err:
|
||
logger.warning(f"[SELL] ActiveTrade 업데이트 실패 {stock_code}: {_at_err}")
|
||
|
||
# 인메모리 포트폴리오 캐시 반영 (UI 실시간 업데이트)
|
||
try:
|
||
from app.api.endpoints.portfolio import portfolio_cache
|
||
avg = float(holding.average_price or current_price)
|
||
await portfolio_cache.apply_sell(stock_code, quantity, current_price, avg)
|
||
# [CLAUDE.md 5.2] 분할매도: 잔여 수량이 있으면 캐시에서 제거하지 않음
|
||
# [M-3 2026-09-27] 캐시/Portfolio 행 기준 잔량은 '행 합산(_row_total_qty)'
|
||
# 에서 매도 수량을 뺀 값이어야 한다. 스윙 보유분(total_qty=_own_qty)으로
|
||
# 계산하면 스윙 전량 청산 시 remaining_qty=0 이 되어 DT 보유분까지 캐시에서
|
||
# 삭제됐다 (Portfolio DB 행은 합산 수량으로 잔존 → 캐시/DB 불일치).
|
||
remaining_qty = max(0, _row_total_qty - quantity)
|
||
if remaining_qty <= 0:
|
||
portfolio_cache.holdings = [
|
||
h for h in portfolio_cache.holdings if h.stock_code != stock_code
|
||
]
|
||
else:
|
||
# 잔여 수량 반영 (분할매도 후 남은 포지션)
|
||
for h in portfolio_cache.holdings:
|
||
if h.stock_code == stock_code:
|
||
h.quantity = remaining_qty
|
||
break
|
||
except Exception as _swallowed:
|
||
logger.warning("[SELL] portfolio_cache 반영 실패: %s", _swallowed)
|
||
# WebSocket → 프론트엔드 즉시 갱신 트리거
|
||
try:
|
||
from app.services.websocket_manager import websocket_manager
|
||
await websocket_manager.broadcast_json({
|
||
"type": "trade_executed",
|
||
"data": {
|
||
"stock_code": stock_code,
|
||
"stock_name": stock_name,
|
||
"trade_type": "SELL",
|
||
"quantity": quantity,
|
||
"price": current_price,
|
||
},
|
||
})
|
||
except Exception as _swallowed:
|
||
logger.warning("[SELL] WebSocket 갱신 트리거 실패: %s", _swallowed)
|
||
# Telegram 매도 체결 알림
|
||
try:
|
||
from app.services.telegram_notifier import telegram_notifier
|
||
spawn_tracked_task_v2(telegram_notifier.notify_trade_executed(
|
||
order_type="SELL",
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
quantity=quantity,
|
||
price=current_price,
|
||
profit_loss=profit_loss,
|
||
profit_loss_rate=profit_loss_rate,
|
||
))
|
||
except Exception as _swallowed:
|
||
logger.warning("[SELL] 텔레그램 체결 알림 실패: %s", _swallowed)
|
||
# 3초 후 KIS 체결 확인 (슬리피지 기록 포함)
|
||
spawn_tracked_task_v2(
|
||
_verify_and_sync_execution_v3(
|
||
order_id=kis_order_id,
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
ordered_quantity=quantity,
|
||
order_price=_verify_ref_price,
|
||
order_type="SELL",
|
||
is_domestic=is_domestic,
|
||
exchange_code=exchange_code,
|
||
db_trade_id=0, # db_worker 큐 경유로 trade_id 미확보, order_id로 조회
|
||
delay=3,
|
||
cancel_unfilled_limit=_cancel_unfilled_limit,
|
||
rollback_active_trade=_at_rollback,
|
||
order_org_no=_extract_org_no_v2(order_result),
|
||
# [2026-10-08] 체결가 기준 순손익 재계산 (기록 시와 같은 진입가·시장 구분)
|
||
sell_pnl_basis={
|
||
"entry_price": _avg,
|
||
"market": _market_type,
|
||
"is_domestic": is_domestic,
|
||
"strategy_type": stock.get("strategy_type", "swing"),
|
||
"net_rate": False,
|
||
},
|
||
)
|
||
)
|
||
# [H-1] 기존 `elif is_pending:` 자동취소 분기 제거 (BUY 와 동일 사유).
|
||
|
||
return {
|
||
"action": "SELL",
|
||
"stock": stock_name,
|
||
"quantity": quantity,
|
||
"price": current_price,
|
||
"profit_loss": profit_loss_rate,
|
||
"success": success,
|
||
}
|
||
|
||
except ValueError as e:
|
||
logger.error(f"[SELL_VALIDATION] {stock_code}: {e}")
|
||
return {"action": "SELL_FAILED", "stock": stock_name, "error": str(e)}
|
||
except Exception as e:
|
||
logger.error(f"[SELL_ERROR] {stock_code}: {type(e).__name__}: {e}", exc_info=True)
|
||
return {"action": "SELL_FAILED", "stock": stock_name, "error": str(e)}
|
||
finally:
|
||
await _release_order_lock(stock_code, "SELL")
|
||
|
||
|
||
# execute_auto_trade_background 동시 실행 방지 — 스윙 스케줄러·API 트리거가 겹치면
|
||
# 일일 거래 한도(MAX_DAILY_TRADES)가 호출 단위로만 적용돼 합산 초과됨 (2026-09-17 11종목 동시 매수 사고).
|
||
_auto_trade_bg_lock = asyncio.Lock()
|
||
|
||
|
||
async def _count_swing_buys_today_v2(db: AsyncSession) -> int | None:
|
||
"""당일 스윙 소유 BUY 종목 수 (distinct stock_code). 조회 실패 시 None.
|
||
|
||
None 은 '모름'이다 — 호출부가 fail-closed(신규 매수 차단)로 처리한다.
|
||
여기서 0 으로 폴백하면 한도가 조용히 풀린다(이전 동작).
|
||
"""
|
||
try:
|
||
_res = await db.execute(
|
||
select(TradeHistory.stock_code)
|
||
.where(
|
||
TradeHistory.order_type == "BUY",
|
||
TradeHistory.status.in_(["COMPLETED", "PENDING"]),
|
||
TradeHistory.created_at >= get_daily_cutoff_utc(),
|
||
_swing_owned_clause_v2(TradeHistory.strategy_type),
|
||
)
|
||
.distinct()
|
||
)
|
||
_codes = {c for c in _res.scalars().all() if c}
|
||
except Exception as e:
|
||
logger.error(f"[AUTO_TRADE_BG] 당일 스윙 매수 건수 조회 예외: {type(e).__name__}: {e}")
|
||
return None
|
||
# [M-3 4회차] db_worker 반영 지연 중인(아직 TradeHistory 에 안 보이는) 이번/직전 사이클
|
||
# 국내 스윙 매수를 합집합으로 더한다 — 지연 동안 MAX_DAILY_TRADES 를 넘겨 사는 것을 방지.
|
||
# swing/entry_service 의 듀얼 선확인도 이 함수를 그대로 쓴다.
|
||
_codes |= _domestic_recent_swing_buy_codes_v2()
|
||
return len(_codes)
|
||
|
||
|
||
def _regime_limits_v2(market_regime) -> tuple[int, float]:
|
||
"""check_market_regime() 결과 → (국면 max_trades, position_multiplier).
|
||
|
||
- None(BEAR_MARKET_FILTER_ENABLED=False 로 조회 안 함): 기존과 동일하게 제한 없음
|
||
(MAX_DAILY_TRADES, 1.0).
|
||
- dict 인데 regime_200d 가 없음 = 판정 실패 → (0, 0.0) fail-closed + error 로그.
|
||
- max_trades 키가 없으면 MAX_DAILY_TRADES(장외 분기 등 기존 동작), 해석 불가면 0.
|
||
- position_multiplier 키가 없으면 1.0(기존), 해석 불가면 0.0.
|
||
"""
|
||
if market_regime is None:
|
||
return int(settings.MAX_DAILY_TRADES), 1.0
|
||
if not isinstance(market_regime, dict) or not market_regime.get("regime_200d"):
|
||
logger.error(
|
||
f"[AUTO_TRADE_BG] 🚨 시장 국면 판정값 없음({market_regime!r:.200}) — "
|
||
f"신규 진입 차단(fail-closed)"
|
||
)
|
||
return 0, 0.0
|
||
_mt = market_regime.get("max_trades")
|
||
try:
|
||
max_trades = int(settings.MAX_DAILY_TRADES) if _mt is None else int(_mt)
|
||
except (TypeError, ValueError):
|
||
logger.error(f"[AUTO_TRADE_BG] max_trades={_mt!r} 해석 불가 — 신규 진입 차단")
|
||
max_trades = 0
|
||
_pm = market_regime.get("position_multiplier")
|
||
try:
|
||
pm = 1.0 if _pm is None else float(_pm)
|
||
except (TypeError, ValueError):
|
||
logger.error(f"[AUTO_TRADE_BG] position_multiplier={_pm!r} 해석 불가 — 0 배 적용")
|
||
pm = 0.0
|
||
return max(0, max_trades), max(0.0, pm)
|
||
|
||
|
||
async def execute_auto_trade_background(recommendations_response: dict, db: AsyncSession):
|
||
"""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 []
|
||
|
||
if _auto_trade_bg_lock.locked():
|
||
logger.info("[AUTO_TRADE_BG] 이전 실행이 진행 중 — 이번 호출 스킵 (중복 실행 방지)")
|
||
return []
|
||
async with _auto_trade_bg_lock:
|
||
return await _execute_auto_trade_background_locked(recommendations_response, db)
|
||
|
||
|
||
async def _execute_auto_trade_background_locked(recommendations_response: dict, db: AsyncSession):
|
||
# trade_results 는 except 절에서도 참조하므로 try 밖에서 바인딩한다(항상 list 반환 보장).
|
||
trade_results: list = []
|
||
try:
|
||
total_processed = 0
|
||
|
||
# 시장 국면 조회 (BEAR 시 max_trades 축소, position_multiplier 감소)
|
||
market_regime = None
|
||
if settings.BEAR_MARKET_FILTER_ENABLED:
|
||
market_regime = await check_market_regime()
|
||
|
||
# [H3 2026-10-02] 필터가 켜져 있는데 국면 판정값이 없거나 형식이 틀리면
|
||
# (판정 실패) fail-closed. 기존 기본값(20건·1.0배)은 실패를 정상장으로 취급했다.
|
||
regime_max_trades, position_multiplier = _regime_limits_v2(market_regime)
|
||
max_trades = min(settings.MAX_DAILY_TRADES, regime_max_trades)
|
||
# [M-2 4회차] 아래 게이트(국면·일일 한도·건수 조회 실패)는 **신규 매수만** 막는다.
|
||
# 조기 return 하면 추천 목록에 있는 보유 종목의 청산 판정까지 사라졌다 → max_trades=0
|
||
# 으로 두고 루프에서 보유 종목만 _exit_only 로 평가한다(§8.1-11).
|
||
_buy_block_reason: str | None = None
|
||
if max_trades <= 0:
|
||
_buy_block_reason = "regime_gate"
|
||
logger.info(
|
||
f"[AUTO_TRADE_BG] 국면 게이트 — max_trades=0 "
|
||
f"(regime={market_regime.get('regime') if isinstance(market_regime, dict) else None}) "
|
||
f"— 신규 진입 스킵, 보유 종목 청산 판정만 수행"
|
||
)
|
||
|
||
# 일일 한도는 "오늘 이미 나간 BUY 종목 수"를 차감한 전역 기준으로 적용
|
||
# (호출 단위 슬라이스만으로는 여러 사이클에 걸쳐 한도 초과됨)
|
||
# [2026-10-01] MAX_DAILY_TRADES 는 스윙 한도다 → 스윙 소유 매수(swing + NULL
|
||
# 레거시)만 센다. DT·manual·external·us_swing 매수는 제외(매도 소유권과 같은 기준).
|
||
# [2026-10-01] 조회 실패 시 fail-closed — 한도를 검증할 수 없으면 신규 매수를
|
||
# 막는다. 판정은 try 밖(§4). 스윙 청산은 swing/scheduler step 2
|
||
# (check_and_execute_exit_v2)가 이 함수와 독립적으로 수행하므로 영향이 없다.
|
||
_bought_today = await _count_swing_buys_today_v2(db) if _buy_block_reason is None else 0
|
||
if _bought_today is None:
|
||
_buy_block_reason = "daily_count_unverifiable"
|
||
max_trades = 0
|
||
logger.error(
|
||
f"[AUTO_TRADE_BG] 🚨 당일 스윙 매수 건수 조회 실패 — 일일 한도 "
|
||
f"{min(settings.MAX_DAILY_TRADES, regime_max_trades)}종목 검증 불가로 "
|
||
f"이번 사이클 신규 진입 차단(fail-closed). 보유 종목 청산 판정은 계속"
|
||
)
|
||
elif _buy_block_reason is None:
|
||
max_trades = max(0, max_trades - _bought_today)
|
||
if max_trades == 0:
|
||
_buy_block_reason = "daily_limit"
|
||
logger.info(
|
||
f"[AUTO_TRADE_BG] 일일 매수 한도 도달 (오늘 스윙 {_bought_today}종목 / 한도 "
|
||
f"{min(settings.MAX_DAILY_TRADES, regime_max_trades)}) — 신규 진입 스킵, "
|
||
f"보유 종목 청산 판정만 수행"
|
||
)
|
||
if _buy_block_reason is not None:
|
||
max_trades = 0
|
||
|
||
# [2026-09-27] held_stocks 집합은 파일 전체에서 미사용이라 전용 SELECT 와 함께 제거.
|
||
# 보유 여부는 execute_auto_trade() 내부에서 종목별로 직접 조회한다.
|
||
|
||
# recommendations_by_rule 정규화 (list 또는 dict 모두 처리)
|
||
rec_groups = recommendations_response.get("recommendations_by_rule", [])
|
||
if isinstance(rec_groups, dict):
|
||
normalized_list = []
|
||
for name, group in rec_groups.items():
|
||
if isinstance(group, dict):
|
||
normalized_list.append(group)
|
||
else:
|
||
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):
|
||
logger.warning("[AUTO_TRADE_BG] Invalid rule_group: %r", rule_group)
|
||
continue
|
||
stocks_list = rule_group.get("stocks")
|
||
if not isinstance(stocks_list, list):
|
||
logger.warning("[AUTO_TRADE_BG] Invalid stocks list: %r", stocks_list)
|
||
continue
|
||
for stock in stocks_list:
|
||
if not isinstance(stock, dict):
|
||
logger.warning("[AUTO_TRADE_BG] Skipping non-dict stock entry: %r", stock)
|
||
continue
|
||
stock_code = stock.get("stock_code")
|
||
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 # 더 높은 우선순위 룰로 교체
|
||
|
||
# 우선순위↑(숫자↓), 점수↓ 순으로 정렬 후 max_trades개만 처리
|
||
sorted_stocks = sorted(
|
||
unique_stocks.values(),
|
||
key=lambda s: (s.get("rule_priority", 999), -s.get("score", 0)),
|
||
)
|
||
|
||
# [M-1 3회차 2026-10-02] 슬롯 = 'BUY & success' 건수. 기존 `sorted_stocks[:max_trades]` 는
|
||
# SKIP/HOLD(보유·당일매수·쿨다운 등)도 슬롯을 소비해, 상위에 이미 산 종목이 남으면 신규
|
||
# 후보를 평가조차 못 했다. 전체 후보를 순회하되 KIS 호출량은 '신규 후보 평가 상한'으로 묶고,
|
||
# 매수 슬롯 소진 뒤에는 보유 종목만 청산 판정용으로 계속 평가한다(_exit_only).
|
||
# DB-READ: 보유 종목 코드 SELECT 전용
|
||
_held_res = await db.execute(select(Portfolio.stock_code).where(Portfolio.quantity > 0))
|
||
_held_set = {c for c in _held_res.scalars().all() if c}
|
||
_eval_cap = max(1, int(settings.AUTO_TRADE_MAX_EVALUATIONS_PER_CYCLE))
|
||
_buys_ok = 0
|
||
_evaluated_new = 0
|
||
_skipped_cooldown = 0
|
||
_skipped_cap = 0
|
||
|
||
# [L-3 4회차] 순회 순서 = 보유 종목(청산 판정 우선, 원래 정렬) → 신규 후보.
|
||
# 신규 후보가 평가 상한보다 많으면 시작 오프셋을 사이클마다 회전해, 상위 HOLD 종목이
|
||
# 매 사이클 상한을 전부 차지해 하위 후보가 영영 평가되지 않는 것을 막는다.
|
||
global _eval_rotation_offset
|
||
_held_list = [x for x in sorted_stocks if isinstance(x, dict) and x.get("stock_code") in _held_set]
|
||
_new_list = [x for x in sorted_stocks if not (isinstance(x, dict) and x.get("stock_code") in _held_set)]
|
||
if len(_new_list) > _eval_cap and max_trades > 0:
|
||
_off = _eval_rotation_offset % len(_new_list)
|
||
_new_list = _new_list[_off:] + _new_list[:_off]
|
||
_eval_rotation_offset = (_off + _eval_cap) % len(_new_list)
|
||
else:
|
||
_eval_rotation_offset = 0
|
||
|
||
for stock in _held_list + _new_list:
|
||
if not isinstance(stock, dict):
|
||
logger.warning("[AUTO_TRADE_BG] Skipping invalid stock entry: %r", stock)
|
||
continue
|
||
_code = stock.get("stock_code")
|
||
_is_held = _code in _held_set
|
||
# [L-2 4회차] 계좌 단위 거부 쿨다운 중이면 신규 매수 전부 보류(청산 판정은 계속)
|
||
_slots_full = _buys_ok >= max_trades or _account_reject_cooldown_remaining_v2() > 0
|
||
if not _is_held:
|
||
if _slots_full:
|
||
continue
|
||
if _order_reject_cooldown_remaining_v2(_code) > 0:
|
||
_skipped_cooldown += 1
|
||
continue
|
||
if _evaluated_new >= _eval_cap:
|
||
_skipped_cap += 1
|
||
continue
|
||
_evaluated_new += 1
|
||
try:
|
||
stock["_position_multiplier"] = position_multiplier # 국면별 배율 주입
|
||
stock["_regime_str"] = (
|
||
(market_regime.get("regime_200d") or "bear")
|
||
if isinstance(market_regime, dict) else "bear"
|
||
)
|
||
if _slots_full:
|
||
stock["_exit_only"] = True # 보유 종목: 청산 판정만, 추가매수 금지
|
||
result = await execute_auto_trade(stock, db)
|
||
total_processed += 1
|
||
|
||
if result["action"] in ["BUY", "SELL"]:
|
||
trade_results.append(result)
|
||
if result["action"] == "BUY" and result.get("success"):
|
||
_buys_ok += 1
|
||
else:
|
||
# [관측성] 매수 후보가 왜 진입 안 됐는지 사유를 남긴다. 기존엔 HOLD/SKIP
|
||
# 사유가 로그에 안 남아 "매수 실행" 후 조용히 스킵되는 이유를 추적하기
|
||
# 어려웠다(예: 플레이북 FOMC 차단, 상관/뉴스/쿨다운, 수량 0 등).
|
||
logger.info(
|
||
f"[AUTO_TRADE_BG] {stock.get('stock_code')} 진입 보류: "
|
||
f"action={result.get('action')} reason={result.get('reason', '미상')}"
|
||
)
|
||
|
||
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}")
|
||
continue
|
||
|
||
logger.info(
|
||
f"[AUTO_TRADE_BG] 사이클 요약: 후보 {len(sorted_stocks)} / 신규 평가 {_evaluated_new} "
|
||
f"(상한 {_eval_cap}, 초과 {_skipped_cap}) / 매수 성공 {_buys_ok}/{max_trades} / "
|
||
f"거부 쿨다운 스킵 {_skipped_cooldown}"
|
||
)
|
||
|
||
# [관측성 2026-09-27] 체결 결과를 호출부로 반환한다. 기존엔 trade_results 를
|
||
# 만들어놓고 return 이 없어 항상 None 이 나갔고, swing/entry_service.py 의
|
||
# isinstance(result, list) 분기가 영구 False → "진입 n건" 로그가 사라졌다.
|
||
# 담기는 값은 action 이 BUY/SELL 인 dict 뿐이다(SKIP/HOLD/*_FAILED 는 제외).
|
||
return trade_results
|
||
|
||
except Exception as e:
|
||
logger.error(
|
||
f"[AUTO_TRADE_BG] 전체 오류: {type(e).__name__}: {e} — "
|
||
f"recommendations_response keys={list(recommendations_response.keys()) if isinstance(recommendations_response, dict) else '?'}"
|
||
)
|
||
# 예외 시점까지 실제로 체결된 건은 유실 없이 보고한다(부분 결과 반환).
|
||
return trade_results
|
||
|
||
|
||
async def _background_sync_portfolio():
|
||
try:
|
||
from app.api.endpoints.portfolio import sync_portfolio
|
||
async with AsyncSessionLocal() as session:
|
||
await sync_portfolio(session, force=True)
|
||
except Exception as e:
|
||
logger.error(f"[PORTFOLIO_SYNC] 백그라운드 동기화 실패: {type(e).__name__}: {e}")
|
||
|
||
|
||
async def _delayed_sync_portfolio(delay_seconds: int = 3):
|
||
try:
|
||
await asyncio.sleep(delay_seconds)
|
||
from app.api.endpoints.portfolio import sync_portfolio
|
||
async with AsyncSessionLocal() as session:
|
||
try:
|
||
await sync_portfolio(session, force=True)
|
||
except Exception as inner_e:
|
||
logger.error(f"[PORTFOLIO_SYNC] 실행 실패: {type(inner_e).__name__}: {inner_e}")
|
||
except Exception as e:
|
||
logger.error(f"[PORTFOLIO_SYNC] 딜레이 동기화 실패: {type(e).__name__}: {e}")
|
||
|
||
|
||
# [하드닝 R5 2026-10-09] market_analyzer 가 RSI 매수 신호에 거래량 배수 < 1.0 이면
|
||
# " (거래량부족-차단)" 을 붙인다(market_analyzer.py 의 analyze_rsi 분기). 이 마커는
|
||
# 종목 단위 사실(당일 거래량 < 20일 평균)이므로 rule 강제매수·ML BUY·비규칙 신호 어느 경로든
|
||
# 신규 매수를 막는다. 백테스트 check_buy_signal 의 공통 선행 필터(current_volume < avg →
|
||
# 거부, CLAUDE.md §6.2)와 화면 buy_allowed(recommendations._block_reasons_v2)와도 일치한다.
|
||
_VOLUME_FLOOR_BLOCK_MARKER = "거래량부족-차단"
|
||
|
||
|
||
def _volume_floor_block_reason_v2(signals) -> "str | None":
|
||
"""신호 목록에 거래량 하한 차단 마커가 있으면 해당 신호 문자열, 없으면 None."""
|
||
for sig in (signals or []):
|
||
text = str(sig)
|
||
if _VOLUME_FLOOR_BLOCK_MARKER in text:
|
||
return text
|
||
return None
|
||
|
||
|
||
def _ml_gate_score_v2(rule_score: float, ml_score: float) -> float:
|
||
"""ML 매수/HOLD 게이트 비교용 점수 산출 (0~100 스케일 기준).
|
||
|
||
[배경 — 2026-09-28 스케일 불일치 수정]
|
||
market_analyzer.py(:603-608) 는 룰 점수를 0~100 으로 정규화한 뒤
|
||
`rule*RULE_WEIGHT + ml*ML_WEIGHT` 로 블렌딩하고, 그 결과를 다시 0~15 로
|
||
축소해 StockAnalysis.score 에 저장한다. 즉 trade_executor 가 받는
|
||
stock["score"] 는 **이미 ML 이 반영된 0~RULE_SCORE_MAX 스케일** 값이다.
|
||
(ml_score 키가 실린 모든 추천 경로 = recommendations.py:45 _stock_analysis_to_dict /
|
||
recommendations.py:589 rec.model_dump() 가 동일하게 이 값을 전달한다.)
|
||
|
||
그런데 기존 게이트는 그 0~15 값을 정규화 없이 0~100 ML 점수와 다시 가중합해
|
||
① 룰 기여 상한이 15×0.3=4.5 (임계 60 의 7.5%) 로 사실상 소멸
|
||
② ml_score 를 이중 계산
|
||
하는 두 결함을 안고 있었다.
|
||
|
||
ML_SCORE_NORMALIZE_ENABLED=False(기본) → 기존 계산식을 비트 단위로 그대로 유지.
|
||
True → 재블렌딩을 제거하고 0~RULE_SCORE_MAX 를 0~100 으로 환산해 임계와 직접 비교.
|
||
(ML 은 이미 score 안에 ML_WEIGHT 비중으로 반영되어 있다.)
|
||
임계값·가중치(ML_ENSEMBLE_BUY_THRESHOLD/RULE_WEIGHT/ML_WEIGHT)는 무변경.
|
||
"""
|
||
if not settings.ML_SCORE_NORMALIZE_ENABLED:
|
||
# 기존 동작 (0~15 룰점수 + 0~100 ML점수 가중합) — 비트 동일
|
||
return (
|
||
rule_score * settings.ML_ENSEMBLE_RULE_WEIGHT
|
||
+ ml_score * settings.ML_ENSEMBLE_ML_WEIGHT
|
||
)
|
||
rule_max = float(settings.RULE_SCORE_MAX or 15)
|
||
if rule_max <= 0:
|
||
rule_max = 15.0
|
||
return (rule_score / rule_max) * 100.0
|
||
|
||
|
||
def _fill_or_created_at_v2():
|
||
"""TradeHistory 의 '체결 시각' 표현 — executed_at, 없으면 created_at.
|
||
|
||
[하드닝 R1 2026-10-09] swing/exit_service(손절 포함)·DT·MDD 의 SELL 행은 COMPLETED 인데
|
||
executed_at 이 NULL 이다(운영 14일: 스윙 SELL 29/29, DT SELL 33/33). executed_at 만 보면
|
||
이 행들이 '당일 매도'·최근 거래 정렬에서 빠진다.
|
||
"""
|
||
return func.coalesce(TradeHistory.executed_at, TradeHistory.created_at)
|
||
|
||
|
||
def _today_sell_conditions_v2(stock_code: str, cutoff_time) -> list:
|
||
"""당일 SELL 판정 조건.
|
||
|
||
COMPLETED/PARTIAL 은 coalesce(executed_at, created_at), PENDING 은 created_at 기준.
|
||
[하드닝 R1 2026-10-09] executed_at 단독 비교는 executed_at 을 기록하지 않는 경로
|
||
(swing/exit_service 손절·DT·MDD)의 SELL 을 놓쳐, 손절 직후 같은 종목 당일 재매수와
|
||
부분매도 반복이 허용됐다(인메모리 _recent_exits 30초만 방어).
|
||
"""
|
||
return [
|
||
TradeHistory.stock_code == stock_code,
|
||
TradeHistory.order_type == "SELL",
|
||
or_(
|
||
and_(
|
||
TradeHistory.status.in_(["COMPLETED", "PARTIAL"]),
|
||
_fill_or_created_at_v2() >= cutoff_time,
|
||
),
|
||
and_(
|
||
TradeHistory.status == "PENDING",
|
||
TradeHistory.created_at >= cutoff_time,
|
||
),
|
||
),
|
||
]
|
||
|
||
|
||
async def _non_dt_sold_today_v2(db: AsyncSession, stock_code: str, cutoff_time) -> bool:
|
||
"""당일 비-DT SELL 존재 여부 — 스윙 보유분 '부분매도 반복 차단' 판정 전용.
|
||
|
||
DT 판정은 db_worker.not_dt_strategy_clause 정본 표현(CLAUDE.md §3.3).
|
||
조회 실패 시 True(보수적: 부분매도만 막고 전량 청산은 허용 — 기존 동작과 동일).
|
||
"""
|
||
from app.services.db_worker import not_dt_strategy_clause
|
||
try:
|
||
_res = await db.execute(
|
||
select(TradeHistory.id).where(
|
||
*_today_sell_conditions_v2(stock_code, cutoff_time),
|
||
not_dt_strategy_clause(TradeHistory.strategy_type),
|
||
).limit(1)
|
||
)
|
||
return _res.first() is not None
|
||
except Exception as e:
|
||
logger.warning(
|
||
f"[TRADE] {stock_code}: 당일 비-DT 매도 조회 실패 — 부분매도 차단으로 간주 "
|
||
f"(전량 청산은 허용): {type(e).__name__}: {e}"
|
||
)
|
||
return True
|
||
|
||
|
||
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")
|
||
stock_name = stock.get("stock_name")
|
||
current_price = float(stock.get("current_price", 0))
|
||
signals = stock.get("signals", [])
|
||
|
||
if not stock_code or current_price <= 0:
|
||
return {"action": "SKIP", "reason": "invalid_data"}
|
||
|
||
# ── 비상 정지 (TRADING_HALTED) 가드 ─────────────────────────────
|
||
if settings.TRADING_HALTED:
|
||
return {"action": "SKIP", "reason": "trading_halted", "stock": stock_name}
|
||
|
||
# 국내(6자리 숫자) vs 해외 판별 — exchange_detector 모듈 사용
|
||
is_domestic = not is_us_stock(stock_code)
|
||
if is_domestic:
|
||
exchange_code = "KRX"
|
||
else:
|
||
exchange_code = stock.get("exchange_code") or detect_exchange(stock_code)
|
||
|
||
# ── 가격 필터 (CLAUDE.md 5.4: ETF/리츠 예외) ─────────────────────────
|
||
# [M-6 2026-10-02] 판정만 여기서 하고, 적용은 보유 조회 뒤 `_guard` 로 한다.
|
||
# 기존엔 즉시 SKIP 반환해 5,000원 이하로 떨어진 보유 종목의 손절·청산 판정이
|
||
# 막혔다(§8.1-11 청산 우선 위반).
|
||
# [하드닝 R1] 부분문자열 판정('인프라웨어'·'NETFLIX'⊃ETF 등 일반주 통과) → 위치 한정 판정
|
||
_is_etf = _is_price_filter_exempt_name_v2(stock_name)
|
||
if is_domestic:
|
||
_is_penny = current_price <= settings.MIN_PRICE_KRW and not _is_etf # CLAUDE.md 5.4: "초과"
|
||
else:
|
||
_is_penny = current_price <= settings.MIN_PRICE_USD and not _is_etf # CLAUDE.md 5.4: "초과"
|
||
|
||
# ── 현재 보유 조회 (리스크 가드보다 먼저) ────────────────────────────
|
||
# [2026-09-27 M3] MDD/밴/보유수/쿨다운 가드는 '신규 매수'에만 적용해야 한다.
|
||
# 기존에는 즉시 SKIP 반환해 보유 종목의 check_exit_signal·ATR 강제 손절에
|
||
# 도달조차 못했다(MDD -10%·보유 20종목 = 가장 청산이 필요한 국면에서 손절 불가).
|
||
# → 보유가 있으면 사유를 _buy_blocked_reason 에 담고 청산 판정까지 진행한다.
|
||
result = await db.execute(
|
||
select(Portfolio).where(
|
||
Portfolio.stock_code == stock_code,
|
||
Portfolio.quantity > 0,
|
||
)
|
||
)
|
||
holding = result.scalar_one_or_none() # None이면 신규매수, 있으면 추가매수/매도 판단
|
||
|
||
_buy_blocked_reason: str | None = None
|
||
# [2026-09-27 H-1] 당일 SELL 체결 여부. 보유 종목의 청산 판정은 계속 진행하되,
|
||
# '부분매도'가 사이클마다 반복되는 것(계단식 청산 + 왕복 수수료)을 막기 위한 플래그.
|
||
_sold_today = False
|
||
|
||
def _guard(reason: str):
|
||
"""보유 없으면 즉시 SKIP dict 반환, 보유 중이면 매수만 차단하고 계속 진행."""
|
||
nonlocal _buy_blocked_reason
|
||
if holding is None:
|
||
return {"action": "SKIP", "reason": reason, "stock": stock_name}
|
||
if _buy_blocked_reason is None:
|
||
_buy_blocked_reason = reason
|
||
return None
|
||
|
||
if _is_penny:
|
||
_r = _guard("penny_stock")
|
||
if _r is not None:
|
||
return _r
|
||
|
||
# ── MDD / 손실추적 / 보유수 ──────────────────────────────────────────
|
||
if not await mdd_manager.can_open_new_position():
|
||
# MDD -10% 이상 낙폭 → 신규 진입 중단
|
||
_r = _guard("mdd_pause")
|
||
if _r is not None:
|
||
return _r
|
||
|
||
if await loss_tracker.is_banned_safe(stock_code):
|
||
# 3회 연속 손실 종목 → 30거래일 진입 금지
|
||
_r = _guard("consecutive_loss_ban")
|
||
if _r is not None:
|
||
return _r
|
||
|
||
# ── 유입 격리분 추가매수 차단 ────────────────────────────────────────
|
||
# [2026-09-30] 유입 잔고(strategy_type='external') 행에 스윙 매수를 얹으면
|
||
# Portfolio 는 stock_code UNIQUE 로 수량이 합산되므로(CLAUDE.md §3.5) 행이
|
||
# swing 으로 승격되고 **유입분까지 스윙 자동 손절 대상이 된다.**
|
||
# 2026-09-30 에 105560(KB금융)에서 실제로 발생했다(external 3주 + 매수 3주
|
||
# → swing 6주). 사용자 결정 "스윙으로 편입하는 건 없어야 해" 의 정면 위반이다.
|
||
#
|
||
# 여기서 막으면 그 혼재가 **발생하지 않는다** — 유입분 격리를 지키면서
|
||
# 시스템 매수분이 관리 밖에 남는 트레이드오프도 함께 사라진다(애초에 안 산다).
|
||
# `_guard` 를 쓰므로 **청산 판정은 그대로 통과**한다(§8.1-11).
|
||
# DT 경로(daytrading/entry_service)는 이 함수를 타지 않고, DT 는 인메모리로
|
||
# 자기 수량을 관리하므로 차단 대상이 아니다.
|
||
if holding is not None and (holding.strategy_type or "swing") == "external":
|
||
logger.warning(
|
||
f"🚧 유입 격리분 추가매수 차단: {stock_name}({stock_code}) "
|
||
f"보유 {holding.quantity}주 strategy_type='external' — "
|
||
f"매수하면 행 전체가 swing 으로 승격돼 유입분이 자동 손절 대상이 된다"
|
||
)
|
||
_r = _guard("external_inflow_holding")
|
||
if _r is not None:
|
||
return _r
|
||
elif holding is not None:
|
||
# [2026-10-01] "팔 수 없는 행에는 사지 않는다" — 매도 소유권과 대칭.
|
||
# manual(수동매수)·daytrading(EOD 미청산 등)·us_swing 행에 스윙이 추가매수하면
|
||
# 그 수량은 swing/exit_service(=='swing' 만)도 _execute_sell 도 팔지 않아
|
||
# SL/TP 없는 보유가 된다. `_guard` 경유라 청산 판정은 그대로 통과(§8.1-11).
|
||
_own_block = _sell_ownership_block_reason_v2(holding, stock)
|
||
if _own_block is not None:
|
||
logger.warning(
|
||
f"🚧 비-스윙 보유 행 추가매수 차단: {stock_name}({stock_code}) "
|
||
f"보유 {holding.quantity}주 strategy_type='{holding.strategy_type}' "
|
||
f"({_own_block}) — 스윙 청산 경로가 이 행을 팔지 않으므로 "
|
||
f"추가매수분이 SL/TP 없이 남는다"
|
||
)
|
||
_r = _guard(f"non_swing_holding:{_own_block}")
|
||
if _r is not None:
|
||
return _r
|
||
|
||
held_result = await db.execute(select(Portfolio).where(Portfolio.quantity > 0))
|
||
# 적응형 전략: max_holdings 오버라이드 (실패 시 settings 기본값 fallback)
|
||
# [§4 2026-10-02] 폴백은 유지하되 조용히 넘기지 않는다(warning, 레이트리밋).
|
||
_adaptive_max_holdings = settings.MAX_HOLDINGS_COUNT
|
||
try:
|
||
from app.services.adaptive_strategy import get_current_adaptive_params
|
||
_adaptive = get_current_adaptive_params()
|
||
if not _adaptive.fallback_used:
|
||
_adaptive_max_holdings = _adaptive.max_holdings
|
||
except Exception as _mh_err:
|
||
warn_throttled(
|
||
logger, "trade_executor:max_holdings_overlay",
|
||
"[TRADE] 적응형 max_holdings 조회 실패 — MAX_HOLDINGS_COUNT 폴백: %s", _mh_err,
|
||
)
|
||
# [M-3 2026-10-02] 같은 사이클에 방금 산(아직 Portfolio 미반영) 종목을 합산.
|
||
_held_codes = {getattr(_h, "stock_code", None) for _h in held_result.scalars().all()}
|
||
_held_count = len(_held_codes | _domestic_recent_cycle_buy_codes_v2())
|
||
if _held_count >= _adaptive_max_holdings:
|
||
# 동시 보유 한도 초과 (적응형: max_holdings)
|
||
_r = _guard("max_holdings_reached")
|
||
if _r is not None:
|
||
return _r
|
||
|
||
# ── 당일 매도 후 재매수 쿨다운 ───────────────────────────────────────
|
||
# 당일 이미 SELL 체결된 종목은 당일 재매수 금지 (섹션 4.3)
|
||
# [2026-09-27 §8.5 항목5] PENDING(접수만 되고 미체결) SELL 주문을 포함한다.
|
||
# 근거: models.py:141 status(String), :157 created_at(DateTime, default=now_kst),
|
||
# :158 executed_at(DateTime, nullable) — 둘 다 KST naive 저장.
|
||
# _execute_sell(trade_executor.py:1303·1329-1330)은 rt_cd=="1" 일 때
|
||
# status="PENDING", executed_at=None 으로 기록하므로 executed_at 날짜
|
||
# 필터만으로는 PENDING 행이 전부 탈락한다 → 지정가 부분매도가 미체결인
|
||
# 동안 _sold_today=False 로 남아 사이클마다 중복 부분매도가 쌓였다.
|
||
# PENDING 은 created_at 으로 '당일'만 인정 → 체결·취소 없이 남은 과거 유령 행이
|
||
# 쿨다운을 영구히 걸지 않는다.
|
||
cutoff_time = _get_kst_now().replace(hour=0, minute=0, second=0, microsecond=0)
|
||
recent_sell = await db.execute(
|
||
select(TradeHistory).where(*_today_sell_conditions_v2(stock_code, cutoff_time))
|
||
)
|
||
if recent_sell.first():
|
||
# 당일 재매수 차단은 DT 매도까지 포함한다(같은 종목 왕복 방지 — 기존 동작).
|
||
_r = _guard("cooldown_sell_today")
|
||
if _r is not None:
|
||
return _r
|
||
# [2026-10-01] 단 '부분매도 반복 차단'(_sold_today) 은 스윙 자신의 매도만 본다.
|
||
# DT 가 같은 종목을 팔았다고 스윙 보유분의 부분익절이 당일 막히면 안 된다.
|
||
_sold_today = await _non_dt_sold_today_v2(db, stock_code, cutoff_time)
|
||
|
||
# [BUG FIX] ActiveTrade.remaining_pct 조회 — 미주입 시 1차 익절 후에도
|
||
# remaining_pct가 항상 1.0으로 간주되어 SELL_PARTIAL이 반복 발생하는 문제 방지.
|
||
# 읽기 전용 SELECT만 수행 (DB 쓰기 없음, swing/exit_service.py의 자체 추적과 무충돌).
|
||
if holding is not None and stock.get("remaining_pct") is None:
|
||
try:
|
||
from app.models.models import ActiveTrade
|
||
# [2026-09-27 M6] swing/position_manager.get_swing_active_trade 및
|
||
# db_worker 와 동일 패턴: day_trade 행 제외 + 최신 행 우선.
|
||
# (같은 종목에 swing/day_trade 행이 동시에 active 일 때 DT 행의
|
||
# remaining_pct 가 스윙 청산 판단에 주입되는 것을 방지)
|
||
# [2026-09-27 §8.5 항목3] `!= "day_trade"` 는 SQL 3값 논리로
|
||
# strategy_name IS NULL 인 legacy 스윙 행까지 탈락시켜, 잔량 추적
|
||
# 소스를 잃고 remaining_pct 가 매 사이클 1.0 으로 뭉개졌다.
|
||
# → db_worker.not_dt_strategy_clause() 로 3곳을 동일 표현으로 통일.
|
||
from app.services.db_worker import not_dt_strategy_clause
|
||
_at_result = await db.execute(
|
||
select(ActiveTrade)
|
||
.where(
|
||
ActiveTrade.stock_code == stock_code,
|
||
ActiveTrade.status == "active",
|
||
not_dt_strategy_clause(ActiveTrade.strategy_name),
|
||
)
|
||
.order_by(ActiveTrade.id.desc())
|
||
.limit(1)
|
||
)
|
||
_active_trade = _at_result.scalars().first()
|
||
if _active_trade is not None and _active_trade.remaining_pct is not None:
|
||
stock["remaining_pct"] = float(_active_trade.remaining_pct)
|
||
# [2026-10-08] 스윙 진입가(혼합 평단 회피) — _swing_entry_price_for_stock_v2 가 쓴다
|
||
if _active_trade is not None and getattr(_active_trade, "entry_price", None):
|
||
stock["_swing_entry_price"] = float(_active_trade.entry_price)
|
||
# [Low 3회차] 부분매도 시 고점을 낮추지 않도록 기존 고점을 함께 전달
|
||
_hse = getattr(_active_trade, "highest_since_entry", None) if _active_trade is not None else None
|
||
if _hse is not None and stock.get("highest_since_entry") is None:
|
||
stock["highest_since_entry"] = float(_hse)
|
||
except Exception as _at_err:
|
||
# 조회 실패 = 잔량 추적 불가 → _resolve_remaining_pct_v2 가 부분매도를
|
||
# 차단한다. 조용히 넘기면 원인 추적이 불가하므로 최소 warning.
|
||
logger.warning(
|
||
f"[TRADE] {stock_code}: ActiveTrade remaining_pct 조회 실패 "
|
||
f"(부분매도 차단, 전량 청산만 허용): {_at_err}"
|
||
)
|
||
|
||
# ── 신호 분석 (Enum 기반) ─────────────────────────────────────────────
|
||
text_signals = " ".join(signals)
|
||
try:
|
||
score_val = float(stock.get("score", 0) or 0)
|
||
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_sell = any(k in text_signals for k in SELL_KEYWORDS)
|
||
|
||
# ── 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")
|
||
|
||
if settings.ML_ENSEMBLE_ENABLED and ml_score_trade is not None:
|
||
try:
|
||
# [2026-09-28] 스케일 불일치(0~15 룰점수 vs 0~100 임계) 및 ML 이중
|
||
# 계산 수정. ML_SCORE_NORMALIZE_ENABLED=False 면 기존 계산과 동일.
|
||
# HOLD 게이트(*0.7)도 같은 weighted_score 를 쓰므로 스케일 일관.
|
||
weighted_score = _ml_gate_score_v2(score_val, float(ml_score_trade))
|
||
if (
|
||
ml_signal_trade == "BUY"
|
||
and weighted_score >= settings.ML_ENSEMBLE_BUY_THRESHOLD
|
||
and (ml_confidence_trade or 0) >= settings.ML_ENSEMBLE_CONFIDENCE_MIN
|
||
):
|
||
should_buy = True
|
||
elif ml_signal_trade == "SELL" and (ml_confidence_trade or 0) >= 0.5:
|
||
# [2026-10-02] ML 단독 SELL 은 보유분 전량매도(_exit_sell_pct=1.0, 룰
|
||
# 청산 판정 생략)를 유발한다. 운영 LSTM 은 재학습 전 사실상 난수
|
||
# (CLAUDE.md §8.5-20)이므로 ML_SELL_SIGNAL_ENABLED(기본 False)로 막는다.
|
||
# 룰 기반 청산(check_exit_signal·ATR 손절·SELL_KEYWORDS)은 그대로.
|
||
if settings.ML_SELL_SIGNAL_ENABLED:
|
||
should_sell = True
|
||
elif holding is not None:
|
||
warn_throttled(
|
||
logger, "trade_executor:ml_sell_disabled",
|
||
"[ML_WEIGHT] %s: ML SELL 무시(재학습 전, ML_SELL_SIGNAL_ENABLED=False) "
|
||
"conf=%s — 룰 기반 청산 판정으로 진행",
|
||
stock_code, ml_confidence_trade,
|
||
)
|
||
elif (
|
||
ml_signal_trade == "HOLD"
|
||
and weighted_score < settings.ML_ENSEMBLE_BUY_THRESHOLD * 0.7
|
||
):
|
||
should_buy = False # ML이 HOLD 강하게 권고 시 매수 억제
|
||
except Exception as e:
|
||
warn_throttled(logger, "trade_executor:2366", f"[ML_WEIGHT] {stock_code} 가중치 계산 오류: {e}")
|
||
|
||
has_rule = stock.get("rule_id") is not None
|
||
|
||
# ── BLOCK 키워드(과열·이격) 판정 ─────────────────────────────────────
|
||
# [2026-09-27 H1-A] 기존에는 BLOCK 감지 시 즉시 HOLD를 return 해
|
||
# 아래 청산 판정(check_exit_signal·ATR 강제 손절)에 도달하지 못했다.
|
||
# 보유 종목이 과열이면 오히려 매도해야 하는 국면인데 손절·전량익절·트레일링이
|
||
# 전부 스킵됐다. → 조기 return 대신 should_buy 만 끄고 청산 판정까지 진행한다.
|
||
# 판정 임계값·BLOCK_KEYWORDS 목록은 무변경(제어 흐름만 수정).
|
||
_block_overheat_reason: str | None = None
|
||
if any(b in text_signals for b in BLOCK_KEYWORDS):
|
||
_block_overheat_reason = (
|
||
"disparity_overheated" if has_rule else "overheat_no_rule"
|
||
)
|
||
should_buy = False
|
||
if holding is None:
|
||
# 보유 없는 종목은 청산 판정이 무의미 → 기존과 동일하게 즉시 HOLD 반환
|
||
return {"action": "HOLD", "stock": stock_name, "reason": _block_overheat_reason}
|
||
|
||
if has_rule and _block_overheat_reason is None:
|
||
# 규칙 기반 종목: BLOCK 신호만 없으면 should_buy = True (규칙 자체가 매수 신호)
|
||
# ML HOLD는 신뢰도 60% 이상일 때만 rule 매수를 차단
|
||
# (신뢰도 40% 미만의 약한 HOLD는 rule 판단을 우선)
|
||
ml_hold_active = (
|
||
settings.ML_ENSEMBLE_ENABLED
|
||
and ml_signal_trade == "HOLD"
|
||
and not should_buy
|
||
and (ml_confidence_trade or 0) >= 0.6
|
||
)
|
||
if not ml_hold_active:
|
||
should_buy = True
|
||
|
||
# ML HOLD이면 매수 억제 — 단, 신뢰도 60% 이상의 '확신 있는' HOLD만 차단.
|
||
# [FIX] 기존에는 신뢰도 무관하게 차단해, 일봉 데이터 부족으로 ML 피처 추출이
|
||
# 실패한 경우(signal=HOLD, confidence=0 = 사실상 "의견 없음")까지 모든 매수를
|
||
# 막아버렸다(수개월간 거래 0의 근본 원인). 위 ml_hold_active(1417~) 로직과 동일하게
|
||
# confidence>=0.6 조건을 적용해, 저신뢰/실패 HOLD는 룰 기반 판단을 막지 않도록 한다.
|
||
if (
|
||
ml_signal_trade == "HOLD"
|
||
and settings.ML_ENSEMBLE_ENABLED
|
||
and (ml_confidence_trade or 0) >= 0.6
|
||
):
|
||
should_buy = False
|
||
logger.info(f"[TRADE] {stock_code}: ML HOLD(conf≥0.6) → 매수 차단")
|
||
|
||
# [하드닝 R5] 거래량 하한 차단 — has_rule 강제매수(위)·ML BUY 가 '(거래량부족-차단)'
|
||
# 을 덮어써 9/28 이후 스윙 BUY 25건 중 8건이 거래량 미달로 체결됐다.
|
||
# 신규 매수만 끈다(조기 return 없음) → 보유 종목 청산 판정은 그대로 진행(§8.1-11).
|
||
# try 밖에 둔다(§4 가드 규칙).
|
||
_vol_block_sig = _volume_floor_block_reason_v2(signals)
|
||
if _vol_block_sig is not None and should_buy:
|
||
should_buy = False
|
||
logger.info(
|
||
f"[TRADE] {stock_code}/{stock_name}: 거래량 하한 미달 → 매수 차단 "
|
||
f"(has_rule={has_rule}, ml_signal={ml_signal_trade}, signal='{_vol_block_sig}')"
|
||
)
|
||
|
||
if should_buy and not has_rule:
|
||
# 비규칙 종목: 강한 신호 OR (신호 2개 이상 AND 점수 4점 이상) 필수
|
||
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 < 4):
|
||
should_buy = False
|
||
|
||
# ── CLAUDE.md 6.3: check_exit_signal 연동 (보유 종목 청산 판단) ─────
|
||
# [2026-03-15] 기존에 텍스트 신호 매칭에만 의존하던 매도 판단을
|
||
# mean_reversion_strategy.check_exit_signal()로 보완.
|
||
# RSI/BB/ATR 기반 부분매도(50%)/전량매도/트레일링스탑 규칙 적용.
|
||
# ⚠️ [하드닝 R2 2026-10-09] 운영 추천 경로에서는 **휴면(dormant)** 이다.
|
||
# recommendations._stock_analysis_to_dict 가 만드는 dict 에는 atr/bb/closes 키가
|
||
# 없어 atr=0 → 아래 두 블록(check_exit_signal·ATR 강제 손절)이 실행되지 않는다.
|
||
# **스윙 청산의 실효 경로는 swing/exit_service 단일 경로**이며, 이 블록을
|
||
# 스윙 손절의 2차 방어로 간주하지 말 것. 호출부가 atr(+rsi/bb 또는 closes)을
|
||
# 실어 보낼 때만 활성화된다(예: 미배선 박스권 dict). 그때 트레일링 고점은
|
||
# 당일 고가(high_price)가 아니라 진입 이후 고점(ActiveTrade.highest_since_entry)
|
||
# 을 쓴다 — _recommendation_trailing_high_v2.
|
||
_exit_signal = None
|
||
_exit_sell_pct = 1.0
|
||
if holding and not should_sell:
|
||
# [2026-10-08] Portfolio 평단은 스윙+DT 혼합일 수 있다 → 스윙 ActiveTrade 진입가 우선
|
||
avg_price = _swing_entry_price_for_stock_v2(stock, holding, stock_code)
|
||
atr = float(stock.get("atr", 0) or 0)
|
||
|
||
if avg_price > 0:
|
||
# 차트 데이터가 있으면 RSI/BB 기반 청산 판단
|
||
closes = stock.get("closes", [])
|
||
rsi_val = stock.get("rsi")
|
||
bb_data = stock.get("bb") # (upper, middle, lower)
|
||
|
||
# RSI/BB가 직접 전달되지 않은 경우 closes에서 계산
|
||
if rsi_val is None and len(closes) >= 15:
|
||
rsi_val = calculate_rsi(closes, 14)
|
||
if bb_data is None and len(closes) >= 20:
|
||
bb_data = calculate_bollinger(closes, 20)
|
||
|
||
if rsi_val is not None and bb_data is not None and atr > 0:
|
||
bb_upper, bb_middle, bb_lower = bb_data if isinstance(bb_data, (tuple, list)) else (0, 0, 0)
|
||
# remaining_pct: 현재 보유 비율 (1차 익절 전 = 1.0, 후 = 0.5 등)
|
||
# [§8.5 항목4] None = '추적 소스 없음' 을 명시 상태로 분리.
|
||
remaining_pct, _remaining_tracked = _resolve_remaining_pct_v2(stock, holding)
|
||
# [하드닝 R2] 당일 고가(high_price) 금지 — 진입 이후 고점만 쓴다.
|
||
trailing_high = _recommendation_trailing_high_v2(stock, current_price)
|
||
lowest_since = float(stock.get("lowest_since_entry") or avg_price)
|
||
|
||
_exit_signal = check_exit_signal(
|
||
regime=MarketRegime.BULL if stock.get("_regime_str", "bear") == "bull" else MarketRegime.BEAR,
|
||
rsi=rsi_val,
|
||
close=current_price,
|
||
bb_upper=bb_upper,
|
||
bb_middle=bb_middle,
|
||
bb_lower=bb_lower,
|
||
entry_price=avg_price,
|
||
atr=atr,
|
||
lowest_since_entry=lowest_since,
|
||
remaining_pct=remaining_pct,
|
||
trailing_high=trailing_high,
|
||
)
|
||
# [§8.5 항목4①] 잔량 추적 불가(ActiveTrade 행 없음/오염) 상태에서는
|
||
# 부분매도를 채택하지 않는다 — 매 사이클 remaining_pct=1.0 으로
|
||
# 재평가되어 계단식 분할매도 + 왕복 수수료가 무한 반복된다.
|
||
# 전량 청산(손절·RSI 전량·트레일링)은 그대로 허용한다.
|
||
if (
|
||
_exit_signal is not None
|
||
and _exit_signal.sell_pct < 1.0
|
||
and not _remaining_tracked
|
||
):
|
||
logger.info(
|
||
f"[EXIT_SIGNAL] {stock_code}/{stock_name} 부분매도 차단: "
|
||
f"remaining_pct 추적 불가(ActiveTrade active 행 없음 — "
|
||
f"브로커 잔고 sync/legacy 보유분) "
|
||
f"sell_pct={_exit_signal.sell_pct*100:.0f}%, "
|
||
f"reason={_exit_signal.reason} — 전량 청산 신호만 허용"
|
||
)
|
||
_exit_signal = None
|
||
|
||
if _exit_signal:
|
||
should_sell = True
|
||
_exit_sell_pct = _exit_signal.sell_pct
|
||
signals = list(signals) + [f"전략청산: {_exit_signal.reason}"]
|
||
logger.info(
|
||
f"[EXIT_SIGNAL] {stock_code}/{stock_name}: "
|
||
f"{_exit_signal.action} {_exit_signal.sell_pct*100:.0f}% — {_exit_signal.reason}"
|
||
)
|
||
|
||
# ATR 기반 강제 손절 (check_exit_signal에서 미처리된 경우 폴백)
|
||
if not should_sell and atr > 0:
|
||
atr_stop_price = avg_price - 2.5 * atr
|
||
if current_price <= atr_stop_price:
|
||
should_sell = True
|
||
_exit_sell_pct = 1.0 # 손절은 전량
|
||
signals = list(signals) + [f"ATR 손절: {current_price:.0f} ≤ {atr_stop_price:.0f}"]
|
||
|
||
# ── 뉴스 감성 필터 (매수 전) ───────────────────────────────────────
|
||
# NEWS_ENABLED 시 종목 뉴스 점수 조회 → 강한 악재 차단 / 약한 악재 포지션 축소
|
||
_news_position_scale = 1.0 # 뉴스에 의한 포지션 배율 (기본 100%)
|
||
# [2026-09-27 H1] 청산 대상(보유+매도신호)은 뉴스 필터를 타지 않는다 —
|
||
# news_negative SKIP 이 손절보다 먼저 반환되면 청산이 또 막힌다.
|
||
if should_buy and not (should_sell and holding) and settings.NEWS_ENABLED:
|
||
try:
|
||
from app.services.news_sentiment import get_stock_news_score
|
||
news_score = await get_stock_news_score(stock_code)
|
||
if news_score <= settings.NEWS_BLOCK_SCORE:
|
||
logger.info(
|
||
f"[NEWS_FILTER] {stock_code}/{stock_name} 진입 차단: "
|
||
f"news_score={news_score:.3f} <= {settings.NEWS_BLOCK_SCORE}"
|
||
)
|
||
return {"action": "SKIP", "reason": "news_negative", "stock": stock_name,
|
||
"news_score": news_score}
|
||
elif news_score <= settings.NEWS_REDUCE_SCORE:
|
||
_news_position_scale = 0.5 # 포지션 50% 축소
|
||
logger.info(
|
||
f"[NEWS_FILTER] {stock_code}/{stock_name} 포지션 50% 축소: "
|
||
f"news_score={news_score:.3f} <= {settings.NEWS_REDUCE_SCORE}"
|
||
)
|
||
except Exception as e:
|
||
warn_throttled(logger, "trade_executor:2520", f"[NEWS_FILTER] {stock_code} 뉴스 스코어 조회 오류 (무시): {e}")
|
||
|
||
# 뉴스 포지션 배율을 stock dict에 전달 (_execute_buy에서 참조)
|
||
if _news_position_scale < 1.0:
|
||
stock["_news_position_scale"] = _news_position_scale
|
||
|
||
# ── 매매 실행 위임 ────────────────────────────────────────────────────
|
||
# [2026-09-27 H1] 청산은 항상 매수보다 우선한다.
|
||
# 기존에는 should_buy 를 먼저 평가해, 보유 종목이 당일 룰 추천에 포함되면
|
||
# (rule 기반은 BLOCK/ML HOLD 만 없으면 should_buy=True 강제)
|
||
# 손절·전량익절·트레일링이 전부 무력화되고 물타기 매수가 나갔다.
|
||
# [2026-09-27 H-1] 당일 이미 SELL 체결된 보유 종목의 '부분매도' 반복 차단.
|
||
# _guard() 가 보유 종목의 cooldown_sell_today 조기 SKIP 을 제거한 뒤부터,
|
||
# ActiveTrade 행이 없는 보유분(브로커 sync·legacy strategy_name IS NULL)은
|
||
# remaining_pct 가 매 사이클 1.0 으로 간주되어 SELL_PARTIAL(0.5)이 무한 반복됐다.
|
||
# → 전량 청산(손절·RSI≥70·트레일링)은 그대로 허용하고, 부분매도만 당일 1회로 제한한다.
|
||
if _sold_today and should_sell and holding and _exit_sell_pct < 1.0:
|
||
logger.info(
|
||
f"[TRADE] {stock_code}/{stock_name} 부분매도 차단: cooldown_sell_today "
|
||
f"(당일 매도 기록 존재, sell_pct={_exit_sell_pct*100:.0f}%, "
|
||
f"reason={(_exit_signal.reason if _exit_signal else ' '.join(signals))}) "
|
||
f"— 전량 청산 신호만 허용"
|
||
)
|
||
return {"action": "SKIP", "reason": "cooldown_sell_today", "stock": stock_name}
|
||
|
||
if should_buy and should_sell and holding:
|
||
logger.warning(
|
||
f"[TRADE_CONFLICT] {stock_code}/{stock_name}: 동일 사이클에 매수·매도 신호 동시 발생 "
|
||
f"→ 청산 우선 실행. has_rule={has_rule} score={score_val} "
|
||
f"ml_signal={ml_signal_trade} ml_conf={ml_confidence_trade} "
|
||
f"exit={(_exit_signal.reason if _exit_signal else None)} "
|
||
f"sell_pct={_exit_sell_pct} signals={signals}"
|
||
)
|
||
|
||
if should_sell and holding:
|
||
logger.info(f"[TRADE] 📉 매도 실행: {stock_code}/{stock_name} @ {current_price:,.0f} ({_exit_sell_pct*100:.0f}%)")
|
||
return await _execute_sell(
|
||
stock, db, holding, current_price, signals,
|
||
is_domestic, exchange_code, stock_code, stock_name,
|
||
sell_pct=_exit_sell_pct, # [CLAUDE.md 5.2] 분할매도 비율 전달
|
||
)
|
||
|
||
if should_buy:
|
||
# [M-1 3회차] 사이클 매수 슬롯 소진 후에는 보유 종목 청산 판정만 수행한다.
|
||
if stock.get("_exit_only"):
|
||
return {"action": "SKIP", "reason": "buy_slots_full", "stock": stock_name}
|
||
_acct_left = _account_reject_cooldown_remaining_v2()
|
||
if _acct_left > 0:
|
||
return {"action": "SKIP", "reason": f"account_reject_cooldown({_acct_left/60:.0f}m)", "stock": stock_name}
|
||
_rc_left = _order_reject_cooldown_remaining_v2(stock_code)
|
||
if _rc_left > 0:
|
||
return {"action": "SKIP", "reason": f"order_reject_cooldown({_rc_left/60:.0f}m)", "stock": stock_name}
|
||
# [M3] 리스크 가드(MDD/밴/보유수/당일매도쿨다운)는 신규 매수만 차단한다
|
||
if _buy_blocked_reason is not None:
|
||
logger.info(
|
||
f"[TRADE] {stock_code}/{stock_name} 매수 차단: {_buy_blocked_reason} (청산 판정은 수행됨)"
|
||
)
|
||
return {"action": "SKIP", "reason": _buy_blocked_reason, "stock": stock_name}
|
||
logger.info(f"[TRADE] 매수 실행: {stock_code}/{stock_name} @ {current_price:,.0f}")
|
||
return await _execute_buy(
|
||
stock, db, holding, current_price, signals, score_val,
|
||
is_domestic, exchange_code, stock_code, stock_name,
|
||
)
|
||
|
||
logger.info(f"[TRADE] ⏸️ HOLD: {stock_code}/{stock_name} (buy={should_buy}, sell={should_sell}, has_rule={has_rule})")
|
||
|
||
# [2026-09-27 H1-A] BLOCK(과열·이격) 사유는 조기 return 제거 후에도 그대로 노출 —
|
||
# 호출측 로깅·집계 호환을 위해 기존 reason 문자열을 유지한다.
|
||
if _block_overheat_reason is not None:
|
||
return {"action": "HOLD", "stock": stock_name, "reason": _block_overheat_reason}
|
||
|
||
return {"action": "HOLD", "stock": stock_name, "reason": "no_buy_signal(진입조건 미충족)"}
|
||
|
||
except ValueError as e:
|
||
logger.error(f"[TRADE_VALIDATION] {stock.get('stock_code')}: {e}")
|
||
return {"action": "ERROR", "error": str(e)}
|
||
except Exception as e:
|
||
logger.error(f"[TRADE_ERROR] {stock.get('stock_code')}: {type(e).__name__}: {e}", exc_info=True)
|
||
return {"action": "ERROR", "error": str(e)}
|