hyowons
402 lines
18 KiB
Python
402 lines
18 KiB
Python
"""트레일링 스톱 예약 상태 관리 (계단식 분할 매도).
|
||
|
||
키움에 REST 트레일링 주문 TR 이 없어서, 스톱지정가(trde_tp=28) 주문을 실제로 걸어두고
|
||
고점이 갱신될 때마다 조건단가를 kt10002 정정으로 올려 트레일링을 구현한다.
|
||
|
||
**예약 1건 = 계단(레그) N개 = 키움 스톱주문 N건.** 고점 대비 하락률이 깊어질수록 더 많이
|
||
파는 계단식 청산이다 (예: −10% 20% / −20% 50% / −30% 전량). 계단별로 수량과 조건단가가
|
||
다른 스톱주문을 동시에 걸어두고, 고점이 오르면 살아있는 레그를 전부 상향 정정한다.
|
||
|
||
주문이 키움 서버에 있으므로 감시 루프가 죽어도 계단별 손절선은 살아있다.
|
||
감시 루프가 하는 일은 "이미 승인된 주문의 조건단가 상향"뿐 — 신규 발주·수량 변경 없음.
|
||
|
||
⚠️ 계단 비중은 관리자님이 **누적**으로 입력하고(20/50/100 = 전량), 내부에는 계단별
|
||
**추가분**(20/30/50)으로 환산해 저장한다. 주문 수량이 곧 추가분이기 때문이다.
|
||
|
||
⚠️ 한 계단이 체결된 뒤 반등해 신고점을 찍어도 **남은 계단만 새 고점 기준으로 따라 올린다**.
|
||
남은 수량을 계단 비율대로 재배치하려면 기존 주문 취소 + 신규 발주가 필요한데, 그러면
|
||
감시 루프에 자동 발주 경로가 생긴다(매매 자동 트리거 금지). 2026-07-31 관리자님 결정.
|
||
|
||
⚠️ kt10002 정정 응답의 ord_no 는 신규 주문번호다. 정정할 때마다 ord_no 를 갱신하지 않으면
|
||
두 번째 정정부터 orig_ord_no 가 틀려서 전부 실패한다. commit_step_modify 가 이걸 담당.
|
||
|
||
상태는 파일(state/trailing_stops.json)에 저장 — 웹·감시 루프가 각각 다른 프로세스라
|
||
같은 예약 목록을 봐야 한다. 동시성은 fcntl flock 으로 직렬화 (pin.py 와 같은 패턴).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import fcntl
|
||
import json
|
||
import os
|
||
import secrets
|
||
from datetime import datetime, timedelta, timezone
|
||
from pathlib import Path
|
||
from typing import Optional
|
||
|
||
from .guards import tick_size
|
||
|
||
WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
|
||
STATE_FILE = WORKSPACE_ROOT / 'state' / 'trailing_stops.json'
|
||
|
||
KST = timezone(timedelta(hours=9))
|
||
|
||
# 트레일 폭 허용 범위 (%). 너무 좁으면 정상 출렁임에 즉시 털리고, 너무 넓으면 스톱 의미가 없다.
|
||
# ⚠️ 상한을 바꾸면 **세 곳**이 같이 움직여야 한다 — 여기(서버 검증) /
|
||
# behive_web 트레일 폭 드롭다운 옵션 / behive_web `trailBlockReason` 의 범위 체크.
|
||
# 하나만 고치면 드롭다운에서 고를 수 있는데 서버가 거부하거나 그 반대가 된다.
|
||
MIN_TRAIL_PCT = 0.5
|
||
MAX_TRAIL_PCT = 30.0
|
||
|
||
# 지정가(ord_uv) = 조건단가(cond_uv) 보다 이 틱수만큼 아래.
|
||
# 조건단가와 같게 두면 발동 후 그 가격 아래로는 안 팔려 미체결로 남는다.
|
||
# 반대로 너무 벌리면 급락 시 헐값 매도가 되니 2틱.
|
||
ORD_UV_GAP_TICKS = 2
|
||
|
||
# 계단 개수 상한. 고점이 오를 때마다 살아있는 레그를 전부 정정하므로 정정 콜이 계단 수에
|
||
# 비례한다 (예약 3건 × 5계단 = 분당 15콜). 키움 rate limit 여유를 보고 5로 둔다.
|
||
MAX_STEPS = 5
|
||
|
||
|
||
def _now_iso() -> str:
|
||
return datetime.now(KST).isoformat(timespec='seconds')
|
||
|
||
|
||
def floor_to_tick(price: int) -> int:
|
||
"""호가단위로 내림. 매도 조건단가·지정가는 내림이 안전(더 빨리 발동/체결)."""
|
||
t = tick_size(price)
|
||
return price - (price % t)
|
||
|
||
|
||
def compute_levels(peak: int, trail_pct: float, min_sell_price: Optional[int] = None) -> dict:
|
||
"""고점·트레일 폭(·최저 매도가) → 조건단가(트리거)·지정가(체결가).
|
||
|
||
cond_uv = max(peak × (1 − pct/100), min_sell_price) 를 호가단위 내림
|
||
ord_uv = cond_uv − ORD_UV_GAP_TICKS 틱
|
||
|
||
min_sell_price(최저 매도가) = 손절선의 하한. 트레일 폭을 넓게 잡아도 이 가격 아래로는
|
||
손절선이 내려가지 않는다 — 초기 구간 손실 제한용. 고점이 올라 트레일 손절선이 이 값을
|
||
추월하면 그 뒤로는 트레일이 지배한다(최저가는 자연히 무의미해짐).
|
||
"""
|
||
if peak <= 0:
|
||
raise ValueError(f'peak must be > 0 (got {peak})')
|
||
if not (MIN_TRAIL_PCT <= trail_pct <= MAX_TRAIL_PCT):
|
||
raise ValueError(f'trail_pct out of range: {trail_pct}')
|
||
# round(_, 6) 은 부동소수점 잡음만 걷어낸다 — 5500×(1−30/100) 이 3849.9999999999995 로
|
||
# 나오는 탓에 int() 가 3849 로 깎고 호가단위 내림이 3845 까지 끌어내리던 버그가 있었다
|
||
# (의도는 3850). 잡음을 없앤 뒤 내림하므로 "정확히 그 폭 아래" 성격은 그대로다.
|
||
cond_uv = floor_to_tick(int(round(peak * (1 - trail_pct / 100), 6)))
|
||
floor_applied = False
|
||
if min_sell_price:
|
||
if min_sell_price <= 0:
|
||
raise ValueError(f'min_sell_price must be > 0 (got {min_sell_price})')
|
||
floor_uv = floor_to_tick(int(min_sell_price))
|
||
if floor_uv > cond_uv:
|
||
cond_uv = floor_uv
|
||
floor_applied = True
|
||
ord_uv = floor_to_tick(cond_uv - ORD_UV_GAP_TICKS * tick_size(cond_uv))
|
||
if cond_uv <= 0 or ord_uv <= 0:
|
||
raise ValueError(f'computed level <= 0 (peak={peak}, pct={trail_pct})')
|
||
return {'cond_uv': cond_uv, 'ord_uv': ord_uv, 'floor_applied': floor_applied}
|
||
|
||
|
||
def normalize_steps(raw: list) -> list:
|
||
"""입력한 계단 정의(누적 비중)를 내부 표현(추가 비중)으로 환산·검증한다.
|
||
|
||
입력 [{'pct': 10, 'cum': 20}, {'pct': 20, 'cum': 50}, {'pct': 30, 'cum': 100}]
|
||
출력 [{'n': 1, 'pct': 10.0, 'cum': 20.0, 'weight': 20.0}, ... weight 30, 50]
|
||
|
||
cum(누적 비중)은 "이 하락률에 닿았을 때 최초 보유의 몇 %가 팔려 있어야 하는가"다.
|
||
주문 수량은 계단마다의 추가분이므로 weight = cum − 직전 cum 으로 환산한다.
|
||
|
||
마지막 cum 이 100 미만이어도 허용한다(일부만 계단 청산하고 나머지는 계속 보유).
|
||
남는 수량은 스톱이 걸리지 않으므로 호출측이 화면에 표시해 준다.
|
||
"""
|
||
if not raw:
|
||
raise ValueError('계단이 비어 있음')
|
||
if len(raw) > MAX_STEPS:
|
||
raise ValueError(f'계단은 최대 {MAX_STEPS}개 (입력 {len(raw)}개)')
|
||
steps = []
|
||
prev_pct = 0.0
|
||
prev_cum = 0.0
|
||
for i, s in enumerate(raw, start=1):
|
||
pct = float(s['pct'])
|
||
cum = float(s['cum'])
|
||
if not (MIN_TRAIL_PCT <= pct <= MAX_TRAIL_PCT):
|
||
raise ValueError(f'{i}단계 하락률 {pct}% 는 {MIN_TRAIL_PCT}~{MAX_TRAIL_PCT}% 범위를 벗어남')
|
||
if pct <= prev_pct:
|
||
raise ValueError(f'{i}단계 하락률 {pct}% 가 앞 계단({prev_pct}%)보다 깊지 않음')
|
||
if cum <= prev_cum:
|
||
raise ValueError(f'{i}단계 누적 비중 {cum}% 가 앞 계단({prev_cum}%)보다 크지 않음')
|
||
if cum > 100:
|
||
raise ValueError(f'{i}단계 누적 비중 {cum}% 가 100% 를 넘음')
|
||
steps.append({'n': i, 'pct': pct, 'cum': cum, 'weight': cum - prev_cum})
|
||
prev_pct, prev_cum = pct, cum
|
||
return steps
|
||
|
||
|
||
def allocate_step_qty(total_qty: int, weights: list) -> list:
|
||
"""계단별 추가 비중(%) → 정수 주수. 최대잔여법(Hare quota).
|
||
|
||
내림으로 나눈 뒤 남는 주를 소수부가 큰 계단부터 1주씩 배분한다.
|
||
"내림 후 마지막 계단에 몰아주기" 보다 얕은 계단이 0주로 죽는 일이 적다
|
||
(2주 · 20/30/50 → 최대잔여 [0,1,1] 2계단 생존 / 몰아주기 [0,0,2] 1계단).
|
||
|
||
수량이 적어 0주가 되는 계단은 그대로 0 을 반환한다 — 발주할 수 없으므로
|
||
호출측이 걸러내고 "몇 계단으로 줄었는지" 를 사용자에게 알린다.
|
||
"""
|
||
if total_qty <= 0 or not weights:
|
||
return [0] * len(weights)
|
||
exact = [total_qty * w / 100.0 for w in weights]
|
||
base = [int(x) for x in exact]
|
||
remain = int(round(sum(exact))) - sum(base)
|
||
order = sorted(range(len(weights)), key=lambda i: exact[i] - base[i], reverse=True)
|
||
for i in order[:max(0, remain)]:
|
||
base[i] += 1
|
||
return base
|
||
|
||
|
||
def compute_step_levels(peak: int, steps: list, min_sell_price: Optional[int] = None) -> list:
|
||
"""고점 + 계단 정의 → 계단별 조건단가·지정가.
|
||
|
||
최저 매도가는 모든 계단에 같은 하한으로 걸린다. 그래서 초기에는 여러 계단이 같은
|
||
가격으로 뭉칠 수 있다(전부 최저 매도가). 그래도 주문을 병합하지 않는 이유는, 고점이
|
||
올라 트레일 손절선이 최저 매도가를 추월하면 각 계단이 제 하락률대로 다시 벌어지기
|
||
때문이다 — 병합해 버리면 정정만으로는 다시 쪼갤 수 없다(신규 발주가 필요해진다).
|
||
"""
|
||
out = []
|
||
for s in steps:
|
||
lv = compute_levels(peak, s['pct'], min_sell_price)
|
||
out.append({**s, 'cond_uv': lv['cond_uv'], 'ord_uv': lv['ord_uv'],
|
||
'floor_applied': lv['floor_applied']})
|
||
return out
|
||
|
||
|
||
def next_step_levels(res: dict, cur_price: int) -> Optional[dict]:
|
||
"""현재가가 고점을 넘었으면 새 고점과 상향 대상 레그를 반환 (순수 함수 — 단위테스트 대상).
|
||
|
||
반환 {'peak': 새 고점, 'steps': [{'n', 'cond_uv', 'ord_uv'}, ...]}.
|
||
고점이 안 올랐으면 None.
|
||
|
||
steps 가 빈 리스트일 수 있다 — 고점은 올랐지만 호가단위 내림이나 최저 매도가 지배로
|
||
조건단가가 하나도 안 올라간 경우다. 이때 호출측은 정정 API 없이 고점만 갱신한다
|
||
(불필요한 콜 0, 화면의 고점 표시는 정확하게 유지).
|
||
"""
|
||
if cur_price <= 0 or cur_price <= res['peak']:
|
||
return None
|
||
ups = []
|
||
for s in res.get('steps') or []:
|
||
lv = compute_levels(cur_price, s['pct'], res.get('min_sell_price'))
|
||
if lv['cond_uv'] > s['cond_uv']:
|
||
ups.append({'n': s['n'], 'cond_uv': lv['cond_uv'], 'ord_uv': lv['ord_uv']})
|
||
return {'peak': cur_price, 'steps': ups}
|
||
|
||
|
||
class _FileLock:
|
||
def __init__(self, path: Path):
|
||
self.path = path
|
||
self._fp = None
|
||
|
||
def __enter__(self):
|
||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||
self._fp = open(self.path, 'w')
|
||
fcntl.flock(self._fp, fcntl.LOCK_EX)
|
||
return self
|
||
|
||
def __exit__(self, *args):
|
||
try:
|
||
fcntl.flock(self._fp, fcntl.LOCK_UN)
|
||
finally:
|
||
self._fp.close()
|
||
|
||
|
||
_LOCK_FILE = STATE_FILE.with_suffix(STATE_FILE.suffix + '.lock')
|
||
|
||
|
||
def _read() -> list:
|
||
if not STATE_FILE.exists():
|
||
return []
|
||
try:
|
||
data = json.loads(STATE_FILE.read_text(encoding='utf-8'))
|
||
except (OSError, ValueError):
|
||
return []
|
||
return data.get('reservations') or []
|
||
|
||
|
||
def _write(reservations: list) -> None:
|
||
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
|
||
tmp = STATE_FILE.with_suffix(STATE_FILE.suffix + '.tmp')
|
||
tmp.write_text(json.dumps({'reservations': reservations}, ensure_ascii=False, indent=2),
|
||
encoding='utf-8')
|
||
os.replace(tmp, STATE_FILE)
|
||
|
||
|
||
def list_active() -> list:
|
||
"""등록된 예약 전체 (락 없이 읽기 — 감시 루프의 스냅샷용)."""
|
||
return _read()
|
||
|
||
|
||
def get(res_id: str) -> Optional[dict]:
|
||
for r in _read():
|
||
if r['id'] == res_id:
|
||
return r
|
||
return None
|
||
|
||
|
||
def find_by_symbol(account: str, symbol: str) -> Optional[dict]:
|
||
"""같은 계좌·종목의 기존 예약. 중복 등록 차단용."""
|
||
for r in _read():
|
||
if r['account'] == account and r['symbol'] == symbol:
|
||
return r
|
||
return None
|
||
|
||
|
||
def register_steps(account: str, symbol: str, symbol_name: str, total_qty: int,
|
||
peak: int, steps: list, routing_suffix: str = '',
|
||
card_id: Optional[str] = None,
|
||
min_sell_price: Optional[int] = None) -> dict:
|
||
"""키움에 계단별 스톱주문이 접수된 직후 호출 — 레그 목록을 예약 1건으로 등록.
|
||
|
||
steps 각 항목은 접수 결과까지 채워져 있어야 한다:
|
||
{'n', 'pct', 'cum', 'weight', 'qty', 'ord_no', 'cond_uv', 'ord_uv'}
|
||
|
||
접수에 실패한 레그는 호출측이 빼고 넘긴다 — 여기 등록된 것은 전부 키움에 살아있는
|
||
주문이어야 감시 루프의 생존 판정이 성립한다.
|
||
|
||
초기 고점(peak)은 등록 시점 현재가다. 과거 고점(52주·매수후) 기준 옵션은 손절선이
|
||
현재가 위로 올라가 즉시 발동하는 구조라 2026-07-30 제거됐다.
|
||
"""
|
||
if not steps:
|
||
raise ValueError('등록할 계단이 없음 — 접수 성공한 레그가 하나도 없다')
|
||
for s in steps:
|
||
if not s.get('ord_no'):
|
||
raise ValueError(f'{s.get("n")}단계 ord_no 없음 — 접수 확인된 주문만 등록')
|
||
res = {
|
||
'id': 'TRL-' + ''.join(secrets.choice('ABCDEFGHJKLMNPQRSTUVWXYZ23456789') for _ in range(4)),
|
||
'account': account,
|
||
'symbol': symbol,
|
||
'symbol_name': symbol_name,
|
||
'qty': total_qty,
|
||
'min_sell_price': min_sell_price,
|
||
'peak': peak,
|
||
'steps': [{'n': s['n'], 'pct': s['pct'], 'cum': s['cum'], 'weight': s['weight'],
|
||
'qty': s['qty'], 'ord_no': s['ord_no'],
|
||
'cond_uv': s['cond_uv'], 'ord_uv': s['ord_uv'],
|
||
'entry_cond_uv': s['cond_uv'], 'modify_count': 0} for s in steps],
|
||
'routing_suffix': routing_suffix,
|
||
'card_id': card_id,
|
||
'created_at': _now_iso(),
|
||
'updated_at': _now_iso(),
|
||
'entry_peak': peak,
|
||
}
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
reservations.append(res)
|
||
_write(reservations)
|
||
return res
|
||
|
||
|
||
def commit_peak(res_id: str, peak: int) -> Optional[dict]:
|
||
"""고점만 갱신 (정정할 레그가 없었던 경우). 화면의 고점 표시를 정확하게 유지한다."""
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
for r in reservations:
|
||
if r['id'] == res_id:
|
||
r['peak'] = peak
|
||
r['updated_at'] = _now_iso()
|
||
_write(reservations)
|
||
return r
|
||
return None
|
||
|
||
|
||
def commit_step_modify(res_id: str, step_n: int, new_ord_no: str, peak: int,
|
||
cond_uv: int, ord_uv: int) -> Optional[dict]:
|
||
"""레그 정정 성공 후 상태 갱신. new_ord_no 는 kt10002 응답의 신규 주문번호.
|
||
|
||
⚠️ ord_no 갱신이 이 함수의 핵심 — 안 하면 그 레그의 다음 정정이 전부 실패한다.
|
||
고점은 예약 단위라 레그마다 같은 값으로 덮어써도 무해하다.
|
||
"""
|
||
if not new_ord_no:
|
||
raise ValueError('new_ord_no required')
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
for r in reservations:
|
||
if r['id'] != res_id:
|
||
continue
|
||
for s in r.get('steps') or []:
|
||
if s['n'] != step_n:
|
||
continue
|
||
s['ord_no'] = new_ord_no
|
||
s['cond_uv'] = cond_uv
|
||
s['ord_uv'] = ord_uv
|
||
s['modify_count'] = s.get('modify_count', 0) + 1
|
||
r['peak'] = peak
|
||
r['updated_at'] = _now_iso()
|
||
_write(reservations)
|
||
return r
|
||
return None
|
||
return None
|
||
|
||
|
||
def remove_step(res_id: str, step_n: int, reason: str = '') -> Optional[dict]:
|
||
"""레그 하나를 예약에서 제거 (체결·취소·소멸). 마지막 레그면 예약 자체를 지운다.
|
||
|
||
반환 {'step': 제거된 레그, 'reservation': 예약 스냅샷, 'remaining': 남은 레그 수,
|
||
'reservation_removed': bool} — 알림 메시지 조립용.
|
||
"""
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
for i, r in enumerate(reservations):
|
||
if r['id'] != res_id:
|
||
continue
|
||
steps = r.get('steps') or []
|
||
hit = next((s for s in steps if s['n'] == step_n), None)
|
||
if hit is None:
|
||
return None
|
||
steps.remove(hit)
|
||
hit['removed_reason'] = reason
|
||
snapshot = json.loads(json.dumps(r))
|
||
if not steps:
|
||
reservations.pop(i)
|
||
_write(reservations)
|
||
return {'step': hit, 'reservation': snapshot, 'remaining': 0,
|
||
'reservation_removed': True}
|
||
r['updated_at'] = _now_iso()
|
||
_write(reservations)
|
||
return {'step': hit, 'reservation': snapshot, 'remaining': len(steps),
|
||
'reservation_removed': False}
|
||
return None
|
||
|
||
|
||
def should_notify_failure(res_id: str, now_ts: float, cooldown_sec: int) -> bool:
|
||
"""정정 실패 알림을 보낼지. 보낸다고 판단하면 그 시점을 기록한다 (락 안에서 원자적).
|
||
|
||
NXT 시간대에 KRX/SOR 원주문 정정이 거부되면 매 사이클 실패가 반복된다 —
|
||
쿨다운 없이 알리면 20:00까지 매분 텔레그램이 쏟아진다.
|
||
"""
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
for r in reservations:
|
||
if r['id'] != res_id:
|
||
continue
|
||
last = r.get('last_fail_notice_ts') or 0
|
||
if now_ts - last < cooldown_sec:
|
||
return False
|
||
r['last_fail_notice_ts'] = now_ts
|
||
_write(reservations)
|
||
return True
|
||
return False
|
||
|
||
|
||
def remove(res_id: str, reason: str = '') -> Optional[dict]:
|
||
"""예약 종료 (체결·취소·소멸). 반환값은 제거된 예약 — 알림 메시지용."""
|
||
with _FileLock(_LOCK_FILE):
|
||
reservations = _read()
|
||
for i, r in enumerate(reservations):
|
||
if r['id'] == res_id:
|
||
gone = reservations.pop(i)
|
||
_write(reservations)
|
||
gone['removed_reason'] = reason
|
||
return gone
|
||
return None
|