joungmin/upbit-trader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: MVC 구조 분리 + 미사용 파일 archive 정리

Browse Source 
- tick_trader.py를 Controller로 축소, 로직을 3개 모듈로 분리:
  - core/signal.py: 시그널 감지, 지표 계산 (calc_vr, calc_atr, detect_signal)
  - core/order.py: Upbit 주문 실행 (매수/매도/취소/조회)
  - core/position_manager.py: 포지션 관리, DB sync, 복구, 청산 조건
- type hints, Google docstring, 구체적 예외 타입 적용
- 50줄 초과 함수 분리 (process_signal, restore_positions)
- 미사용 파일 58개 archive/ 폴더로 이동
- README.md 추가

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
joungmin
2026-03-06 20:46:47 +09:00
parent 976c53ed66
commit 6e0c4508fa
69 changed files with 5018 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
core/fng.py
View File

@@ -1,71 +0,0 @@
"""공포탐욕지수(F&G) 조회 모듈.
alternative.me API로 일일 F&G 값을 가져와 메모리에 캐시한다.
캐시 TTL은 24시간 (F&G는 하루 1회 KST 09:00 업데이트).
환경변수:
FNG_MIN_ENTRY (기본값 41): 이 값 미만이면 진입 차단
"""
from __future__ import annotations
import json
import logging
import os
import time
import urllib.request
from datetime import datetime
logger = logging.getLogger(__name__)
FNG_MIN_ENTRY = int(os.getenv("FNG_MIN_ENTRY", "41")) # 진입 허용 최소 F&G 값
_FNG_API_URL = "https://api.alternative.me/fng/?limit=1&format=json"
_CACHE_TTL = 86400 # 24시간 (API는 하루 1회 KST 09:00 업데이트)
_fng_value: int | None = None
_fng_cached_at: float = 0.0
_fng_date_str: str = ""
def get_fng() -> int:
"""오늘의 F&G 지수 반환 (0~100). API 실패 시 50(중립) 반환."""
global _fng_value, _fng_cached_at, _fng_date_str
now = time.time()
if _fng_value is not None and (now - _fng_cached_at) < _CACHE_TTL:
return _fng_value
try:
with urllib.request.urlopen(_FNG_API_URL, timeout=5) as r:
data = json.loads(r.read())
entry = data["data"][0]
_fng_value = int(entry["value"])
_fng_cached_at = now
_fng_date_str = entry.get("timestamp", "")
logger.info(
f"[F&G] 지수={_fng_value} ({entry.get('value_classification','')}) "
f"날짜={datetime.fromtimestamp(int(_fng_date_str)).strftime('%Y-%m-%d') if _fng_date_str else '?'}"
)
except Exception as e:
logger.warning(f"[F&G] API 조회 실패: {e} → 캐시/중립값 사용")
if _fng_value is None:
_fng_value = 50 # 폴백: 중립
return _fng_value # type: ignore[return-value]
def is_entry_allowed() -> bool:
"""현재 F&G 기준으로 진입 허용 여부 반환.
F&G ≥ FNG_MIN_ENTRY(41) 이면 True.
극공포/공포 구간(< 41)이면 False → 진입 차단.
"""
fv = get_fng()
allowed = fv >= FNG_MIN_ENTRY
if not allowed:
label = (
"극공포" if fv <= 25 else
"공포" if fv <= 40 else
"약공포"
)
logger.debug(f"[F&G] 진입 차단 — F&G={fv} ({label}) < {FNG_MIN_ENTRY}")
return allowed

17
core/llm_advisor.py
View File

@@ -1,14 +1,13 @@
"""OpenRouter LLM 기반 매매 어드바이저.
"""OpenRouter LLM 기반 매수 어드바이저.
매수: 시그널 감지 후 LLM이 매수 여부 + 지정가 결정
매도: 1분 주기로 LLM이 매도 목표가 결정 (cascade fallback)
시그널 감지 후 LLM이 매수 여부를 판단한다.
매도는 트레일링 스탑으로 대체되어 LLM을 사용하지 않는다.
LLM에게 제공하는 DB Tool (OpenAI function calling):
- get_price_ticks(ticker, minutes): Oracle price_tick 테이블 (최근 N분 가격 틱)
- get_ohlcv(ticker, limit): Oracle backtest_ohlcv 1분봉 (지지/저항 파악용)
- get_ticker_context(ticker): 종목 평판 정보 (가격 변동, 뉴스)
- get_trade_history(ticker): 최근 거래 이력 (승패, 손익)
- get_btc_trend(): BTC 최근 동향 (알트 매수 판단용)
DB Tool (OpenAI function calling):
- get_price_ticks: Oracle price_tick (최근 N분 가격 틱)
- get_ohlcv: Oracle backtest_ohlcv 1분봉
- get_ticker_context: 종목 평판 (가격 변동, 뉴스)
- get_btc_trend: BTC 최근 동향
"""
from __future__ import annotations

85
core/market.py
View File

@@ -1,85 +0,0 @@
"""Market data utilities."""
from __future__ import annotations
import logging
import time
import pyupbit
import requests
logger = logging.getLogger(__name__)
TOP_N = 20 # 거래량 상위 N개 종목만 스캔
_TICKER_URL = "https://api.upbit.com/v1/ticker"
# 티커 목록 캐시 (5분 TTL — API rate limit 방지)
_ticker_cache: list[str] = []
_ticker_cache_time: float = 0.0
_TICKER_CACHE_TTL = 300 # 5분
def get_top_tickers() -> list[str]:
"""24시간 거래대금 상위 KRW 마켓 티커 반환 (5분 캐시)."""
global _ticker_cache, _ticker_cache_time
if _ticker_cache and (time.time() - _ticker_cache_time) < _TICKER_CACHE_TTL:
return _ticker_cache
try:
all_tickers = pyupbit.get_tickers(fiat="KRW")
if not all_tickers:
return []
# 100개씩 나눠서 조회 (URL 길이 제한, 429 재시도 포함)
chunk_size = 100
ticker_data = []
for i in range(0, len(all_tickers), chunk_size):
chunk = all_tickers[i:i + chunk_size]
params = {"markets": ",".join(chunk)}
for attempt in range(3):
try:
resp = requests.get(_TICKER_URL, params=params, timeout=5)
if resp.status_code == 429:
wait = 2 ** attempt # 1s → 2s → 4s
logger.warning(f"429 Rate Limit, {wait}s 대기 후 재시도 ({attempt+1}/3)")
time.sleep(wait)
continue
resp.raise_for_status()
ticker_data.extend(resp.json())
break
except Exception as e:
if attempt == 2:
raise
time.sleep(1)
# 스테이블코인 제외
EXCLUDE = {"KRW-USDT", "KRW-USDC", "KRW-DAI", "KRW-BUSD"}
ticker_data = [t for t in ticker_data if t["market"] not in EXCLUDE]
# 24h 거래대금 기준 정렬
ticker_data.sort(key=lambda x: x.get("acc_trade_price_24h", 0), reverse=True)
top = [t["market"] for t in ticker_data[:TOP_N]]
_ticker_cache = top
_ticker_cache_time = time.time()
logger.debug(f"상위 {TOP_N}개: {top[:5]}...")
return top
except Exception as e:
logger.error(f"get_top_tickers 실패: {e}")
return _ticker_cache # 실패 시 이전 캐시 반환
def get_ohlcv(ticker: str, count: int = 21):
"""일봉 OHLCV 데이터 반환."""
try:
return pyupbit.get_ohlcv(ticker, interval="day", count=count)
except Exception as e:
logger.error(f"get_ohlcv({ticker}) 실패: {e}")
return None
def get_current_price(ticker: str) -> float | None:
"""현재가 반환."""
try:
return pyupbit.get_current_price(ticker)
except Exception as e:
logger.error(f"get_current_price({ticker}) 실패: {e}")
return None

110
core/market_regime.py
View File

@@ -1,110 +0,0 @@
"""시장 레짐(Bull/Neutral/Bear) 판단.
BTC·ETH·SOL·XRP 가중 평균 2h 추세로 레짐을 결정하고
매수 조건 파라미터(trend_pct, vol_mult)를 동적으로 반환한다.
계산된 현재가는 price_history DB에 저장해 재활용한다.
"""
from __future__ import annotations
import logging
import time
import pyupbit
from .price_db import get_price_n_hours_ago, insert_prices
logger = logging.getLogger(__name__)
# 대장 코인 가중치
LEADERS: dict[str, float] = {
"KRW-BTC": 0.40,
"KRW-ETH": 0.30,
"KRW-SOL": 0.15,
"KRW-XRP": 0.15,
}
TREND_HOURS = 2 # 2h 추세 기준
BULL_THRESHOLD = 1.5 # score ≥ 1.5% → Bull
BEAR_THRESHOLD = -0.5 # score < -0.5% → Bear
# 레짐별 매수 조건 파라미터
REGIME_PARAMS: dict[str, dict] = {
"bull": {"trend_pct": 3.0, "vol_mult": 1.5, "emoji": "🟢"},
"neutral": {"trend_pct": 5.0, "vol_mult": 2.0, "emoji": "🟡"},
"bear": {"trend_pct": 8.0, "vol_mult": 3.5, "emoji": "🔴"},
}
# 10분 캐시 (스캔 루프마다 API 호출 방지)
_cache: dict = {}
_cache_ts: float = 0.0
_CACHE_TTL = 600
def get_regime() -> dict:
"""현재 시장 레짐 반환.
Returns:
{
'name': 'bull' | 'neutral' | 'bear',
'score': float, # 가중 평균 2h 추세(%)
'trend_pct': float, # 매수 추세 임계값
'vol_mult': float, # 거래량 배수 임계값
'emoji': str,
}
"""
global _cache, _cache_ts
if _cache and (time.time() - _cache_ts) < _CACHE_TTL:
return _cache
score = 0.0
current_prices: dict[str, float] = {}
for ticker, weight in LEADERS.items():
try:
current = pyupbit.get_current_price(ticker)
if not current:
continue
current_prices[ticker] = current
# DB에서 2h 전 가격 조회 → 없으면 API 캔들로 대체
past = get_price_n_hours_ago(ticker, TREND_HOURS)
if past is None:
df = pyupbit.get_ohlcv(ticker, interval="minute60", count=4)
if df is not None and len(df) >= 3:
past = float(df["close"].iloc[-3])
if past:
trend = (current - past) / past * 100
score += trend * weight
logger.debug(f"[레짐] {ticker} {trend:+.2f}% (기여 {trend*weight:+.3f})")
except Exception as e:
logger.warning(f"[레짐] {ticker} 오류: {e}")
# 현재가 DB 저장 (다음 레짐 계산 및 추세 판단에 재활용)
if current_prices:
try:
insert_prices(current_prices)
except Exception as e:
logger.warning(f"[레짐] 가격 저장 오류: {e}")
# 레짐 결정
if score >= BULL_THRESHOLD:
name = "bull"
elif score < BEAR_THRESHOLD:
name = "bear"
else:
name = "neutral"
params = REGIME_PARAMS[name]
result = {"name": name, "score": round(score, 3), **params}
logger.info(
f"[레짐] score={score:+.3f}% → {params['emoji']} {name.upper()} "
f"(TREND≥{params['trend_pct']}% / VOL≥{params['vol_mult']}x)"
)
_cache = result
_cache_ts = time.time()
return result

222
core/monitor.py
View File

@@ -1,222 +0,0 @@
"""트레일링 스탑 + 타임 스탑 감시 - 백그라운드 스레드에서 실행."""
import logging
import os
import time
from datetime import datetime
import pyupbit
from .market import get_current_price
from . import trader
logger = logging.getLogger(__name__)
CHECK_INTERVAL = 10 # 10초마다 체크
# 타임 스탑: N시간 경과 후 수익률이 M% 미만이면 청산
TIME_STOP_HOURS = float(os.getenv("TIME_STOP_HOURS", "24"))
TIME_STOP_MIN_GAIN_PCT = float(os.getenv("TIME_STOP_MIN_GAIN_PCT", "3"))
# ATR 기반 적응형 트레일링 스탑 파라미터
ATR_CANDLES = 7 # 최근 N개 40분봉으로 자연 진폭 계산 (≈5h, int(5*60/40)=7)
ATR_MULT = 1.5 # 평균 진폭 × 배수 = 스탑 임계값
ATR_MIN_STOP = 0.010 # 최소 스탑 1.0% (너무 좁아지는 거 방지)
ATR_MAX_STOP = 0.020 # 최대 스탑 2.0% (너무 넓어지는 거 방지)
# ATR 캐시: 종목별 (스탑비율, 계산시각) — 40분마다 갱신
_atr_cache: dict[str, tuple[float, float]] = {}
_ATR_CACHE_TTL = 2400 # 40분
def _resample_40m(df):
"""minute10 DataFrame → 40분봉으로 리샘플링."""
return (
df.resample("40min")
.agg({"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"})
.dropna(subset=["close"])
)
def _get_adaptive_stop(ticker: str) -> float:
"""최근 ATR_CANDLES개 40분봉 평균 진폭 × ATR_MULT 로 적응형 스탑 비율 반환.
캐시(40분)를 활용해 API 호출 최소화.
계산 실패 시 ATR_MIN_STOP 반환.
"""
now = time.time()
cached = _atr_cache.get(ticker)
if cached and (now - cached[1]) < _ATR_CACHE_TTL:
return cached[0]
try:
fetch_n = (ATR_CANDLES + 2) * 4 # 40분봉 N개 = 10분봉 N*4개
df10 = pyupbit.get_ohlcv(ticker, interval="minute10", count=fetch_n)
if df10 is None or df10.empty:
return ATR_MIN_STOP
df = _resample_40m(df10)
if len(df) < ATR_CANDLES:
return ATR_MIN_STOP
ranges = (df["high"] - df["low"]) / df["low"]
avg_range = ranges.iloc[-ATR_CANDLES:].mean()
stop = float(max(ATR_MIN_STOP, min(ATR_MAX_STOP, avg_range * ATR_MULT)))
except Exception as e:
logger.debug(f"[ATR] {ticker} 계산 실패: {e}")
stop = ATR_MIN_STOP
_atr_cache[ticker] = (stop, now)
return stop
def _check_trailing_stop(ticker: str, pos: dict, current: float) -> bool:
"""적응형 트레일링 스탑(최고가 기준) + 고정 스탑(매수가 기준) 체크."""
trader.update_peak(ticker, current)
pos = trader.get_positions().get(ticker)
if pos is None:
return False
peak = pos["peak_price"]
buy_price = pos["buy_price"]
stop_pct = _get_adaptive_stop(ticker)
drop_from_peak = (peak - current) / peak
drop_from_buy = (buy_price - current) / buy_price
if drop_from_peak >= stop_pct:
reason = (
f"트레일링스탑 | 최고가={peak:,.2f}원 → "
f"현재={current:,.2f}원 ({drop_from_peak:.2%} 하락 | 스탑={stop_pct:.2%})"
)
return trader.sell(ticker, reason=reason)
if drop_from_buy >= stop_pct:
reason = (
f"스탑로스 | 매수가={buy_price:,.2f}원 → "
f"현재={current:,.2f}원 ({drop_from_buy:.2%} 하락 | 스탑={stop_pct:.2%})"
)
return trader.sell(ticker, reason=reason)
return False
def _check_time_stop(ticker: str, pos: dict, current: float) -> bool:
"""타임 스탑 체크. 매도 시 True 반환.
조건: 보유 후 TIME_STOP_HOURS 경과 AND 수익률 < TIME_STOP_MIN_GAIN_PCT%
"""
entry_time = pos.get("entry_time")
if entry_time is None:
return False
elapsed_hours = (datetime.now() - entry_time).total_seconds() / 3600
if elapsed_hours < TIME_STOP_HOURS:
return False
pnl_pct = (current - pos["buy_price"]) / pos["buy_price"] * 100
if pnl_pct >= TIME_STOP_MIN_GAIN_PCT:
return False
reason = (
f"타임스탑 | {elapsed_hours:.2f}시간 경과 후 "
f"수익률={pnl_pct:+.2f}% (기준={TIME_STOP_MIN_GAIN_PCT:+.2f}% 미달)"
)
trader.sell(ticker, reason=reason)
return True
def _check_shadow_position(ticker: str, spos: dict) -> None:
"""Shadow 포지션 청산 조건 체크 (트레일링 + 타임 스탑).
실제 포지션과 동일한 로직을 적용하되 주문 없이 결과만 기록.
"""
current = get_current_price(ticker)
if current is None:
return
trader.update_shadow_peak(ticker, current)
# 갱신 후 최신 값 재조회
spos = trader.get_shadow_positions().get(ticker)
if spos is None:
return
buy_price = spos["buy_price"]
peak = spos["peak_price"]
entry_time = spos["entry_time"]
stop_pct = _get_adaptive_stop(ticker)
drop_from_peak = (peak - current) / peak
elapsed_hours = (datetime.now() - entry_time).total_seconds() / 3600
pnl_pct = (current - buy_price) / buy_price * 100
reason = None
if drop_from_peak >= stop_pct:
reason = (
f"트레일링스탑 | 최고={peak:,.2f}→현재={current:,.2f}"
f" ({drop_from_peak:.2%} | 스탑={stop_pct:.2%})"
)
elif elapsed_hours >= TIME_STOP_HOURS and pnl_pct < TIME_STOP_MIN_GAIN_PCT:
reason = (
f"타임스탑 | {elapsed_hours:.1f}h 경과 "
f"수익률={pnl_pct:+.2f}% (기준={TIME_STOP_MIN_GAIN_PCT:+.2f}%)"
)
if reason:
trader.close_shadow(ticker, current, pnl_pct, reason)
def _check_position(ticker: str, pos: dict) -> None:
"""단일 포지션 전체 체크 (트레일링 스탑 → 타임 스탑 순서)."""
current = get_current_price(ticker)
if current is None:
return
buy_price = pos["buy_price"]
pnl = (current - buy_price) / buy_price * 100
peak = pos["peak_price"]
drop_from_peak = (peak - current) / peak
drop_from_buy = (buy_price - current) / buy_price
stop_pct = _get_adaptive_stop(ticker)
entry_time = pos.get("entry_time", datetime.now())
elapsed_hours = (datetime.now() - entry_time).total_seconds() / 3600
logger.info(
f"[감시] {ticker} 현재={current:,.2f} | 매수가={buy_price:,.2f} | 최고={peak:,.2f} | "
f"수익률={pnl:+.2f}% | peak하락={drop_from_peak:.2%} | buy하락={drop_from_buy:.2%} | "
f"스탑={stop_pct:.2%} | 보유={elapsed_hours:.2f}h"
)
# 1순위: 적응형 트레일링 스탑
if _check_trailing_stop(ticker, pos, current):
return
# 2순위: 타임 스탑
_check_time_stop(ticker, pos, current)
def run_monitor(interval: int = CHECK_INTERVAL) -> None:
"""전체 포지션 감시 루프."""
logger.info(
f"모니터 시작 | 체크={interval}초 | ATR×{ATR_MULT} "
f"(최소={ATR_MIN_STOP:.2%} / 최대={ATR_MAX_STOP:.2%}) | "
f"타임스탑={TIME_STOP_HOURS:.0f}h/{TIME_STOP_MIN_GAIN_PCT:+.2f}%"
)
while True:
# 실제 포지션 감시
positions_snapshot = dict(trader.get_positions())
for ticker, pos in positions_snapshot.items():
try:
_check_position(ticker, pos)
except Exception as e:
logger.error(f"모니터 오류 {ticker}: {e}")
# Shadow 포지션 감시 (WF차단 종목 재활 추적)
shadow_snapshot = trader.get_shadow_positions()
for ticker, spos in shadow_snapshot.items():
try:
_check_shadow_position(ticker, spos)
except Exception as e:
logger.error(f"Shadow 모니터 오류 {ticker}: {e}")
time.sleep(interval)

178
core/order.py Normal file
View File

@@ -0,0 +1,178 @@
"""Upbit 주문 실행 모듈.
주문 제출, 취소, 체결 조회, 시장가 매도 등
Upbit REST API와 직접 통신하는 로직을 담당한다.
"""
from __future__ import annotations
import logging
import math
import time
from typing import Optional, Tuple
import pyupbit
log = logging.getLogger(__name__)
def round_price(price: float) -> float:
"""Upbit 호가 단위로 내림 처리.
Args:
price: 원본 가격.
Returns:
호가 단위에 맞춰 내림된 가격.
"""
if price >= 2_000_000: unit = 1000
elif price >= 1_000_000: unit = 500
elif price >= 100_000: unit = 100
elif price >= 10_000: unit = 10
elif price >= 1_000: unit = 5
elif price >= 100: unit = 1
elif price >= 10: unit = 0.1
else: unit = 0.01
return math.floor(price / unit) * unit
def submit_limit_buy(
client: pyupbit.Upbit,
ticker: str,
price: float,
qty: float,
sim_mode: bool = False,
) -> Optional[str]:
"""지정가 매수 주문 제출.
Returns:
주문 UUID. 실패 시 None.
"""
price = round_price(price)
if sim_mode:
return f"sim-buy-{ticker}"
try:
order = client.buy_limit_order(ticker, price, qty)
if not order or 'error' in str(order):
log.error(f"지정가 매수 실패 {ticker}: {order}")
return None
return order.get('uuid')
except (ConnectionError, TimeoutError, ValueError) as e:
log.error(f"지정가 매수 오류 {ticker}: {e}")
return None
def submit_limit_sell(
client: pyupbit.Upbit,
ticker: str,
qty: float,
price: float,
sim_mode: bool = False,
) -> Optional[str]:
"""지정가 매도 주문 제출.
Returns:
주문 UUID. 실패 시 None.
"""
price = round_price(price)
if sim_mode:
return f"sim-{ticker}"
try:
order = client.sell_limit_order(ticker, price, qty)
if not order or 'error' in str(order):
log.error(f"지정가 매도 실패 {ticker}: price={price} qty={qty} -> {order}")
return None
return order.get('uuid')
except (ConnectionError, TimeoutError, ValueError) as e:
log.error(f"지정가 매도 오류 {ticker}: {e}")
return None
def cancel_order(
client: pyupbit.Upbit,
uuid: Optional[str],
sim_mode: bool = False,
) -> None:
"""주문 취소. sim_mode이거나 uuid가 없으면 무시."""
if sim_mode or not uuid or uuid.startswith('sim-'):
return
try:
client.cancel_order(uuid)
except (ConnectionError, TimeoutError, ValueError) as e:
log.warning(f"주문 취소 실패 {uuid}: {e}")
def check_order_state(
client: pyupbit.Upbit,
uuid: str,
) -> Tuple[Optional[str], Optional[float]]:
"""주문 상태 조회.
Returns:
(state, avg_price) 튜플. state: 'done'|'wait'|'cancel'|None.
"""
try:
detail = client.get_order(uuid)
if not detail:
return None, None
state = detail.get('state')
avg_price = float(detail.get('avg_price') or 0) or None
return state, avg_price
except (ConnectionError, TimeoutError, ValueError) as e:
log.warning(f"주문 조회 실패 {uuid}: {e}")
return None, None
def _avg_price_from_order(
client: pyupbit.Upbit,
uuid: str,
) -> Optional[float]:
"""체결 내역에서 가중평균 체결가를 계산."""
try:
detail = client.get_order(uuid)
if not detail:
return None
trades = detail.get('trades', [])
if trades:
total_funds = sum(float(t['funds']) for t in trades)
total_vol = sum(float(t['volume']) for t in trades)
return total_funds / total_vol if total_vol > 0 else None
avg = detail.get('avg_price')
return float(avg) if avg else None
except (ConnectionError, TimeoutError, ValueError) as e:
log.warning(f"체결가 조회 실패 {uuid}: {e}")
return None
def sell_market(
client: pyupbit.Upbit,
ticker: str,
qty: float,
sim_mode: bool = False,
) -> Optional[float]:
"""시장가 매도. 체결가를 반환.
Args:
client: Upbit 클라이언트.
ticker: 종목 코드.
qty: 매도 수량.
sim_mode: 시뮬레이션 모드.
Returns:
체결 평균가. 실패 시 None.
"""
if sim_mode:
price = pyupbit.get_current_price(ticker)
log.info(f"[SIM 시장가매도] {ticker} {qty:.6f}개 @ {price:,.0f}")
return price
try:
order = client.sell_market_order(ticker, qty)
if not order or 'error' in str(order):
log.error(f"시장가 매도 실패: {order}")
return None
uuid = order.get('uuid')
time.sleep(1.5)
avg_price = _avg_price_from_order(client, uuid) if uuid else None
return avg_price or pyupbit.get_current_price(ticker)
except (ConnectionError, TimeoutError, ValueError) as e:
log.error(f"시장가 매도 오류 {ticker}: {e}")
return None

264
core/position_manager.py Normal file
View File

@@ -0,0 +1,264 @@
"""포지션 + 미체결 매수 관리 모듈.
포지션 활성화, 트레일링 스탑/손절/타임아웃 체크,
미체결 매수 체결 확인, 예산 계산 등을 담당한다.
"""
from __future__ import annotations
import logging
import time
from datetime import datetime
from typing import Optional
import oracledb
import os
log = logging.getLogger(__name__)
# ── DB 연결 (position_sync) ──────────────────────────────────────────────────
_db_conn: Optional[oracledb.Connection] = None
def _get_db() -> oracledb.Connection:
"""Oracle ADB 연결을 반환. 끊어졌으면 재연결."""
global _db_conn
if _db_conn is None:
kwargs = dict(
user=os.environ["ORACLE_USER"],
password=os.environ["ORACLE_PASSWORD"],
dsn=os.environ["ORACLE_DSN"],
)
if w := os.environ.get("ORACLE_WALLET"):
kwargs["config_dir"] = w
_db_conn = oracledb.connect(**kwargs)
return _db_conn
def sync_position(
ticker: str,
state: str,
*,
buy_price: Optional[float] = None,
sell_price: Optional[float] = None,
qty: Optional[float] = None,
order_uuid: Optional[str] = None,
invested_krw: Optional[int] = None,
) -> None:
"""position_sync 테이블에 포지션 상태를 기록/삭제.
Args:
ticker: 종목 코드.
state: 'PENDING_BUY' | 'PENDING_SELL' | 'IDLE'.
"""
try:
conn = _get_db()
cur = conn.cursor()
if state == 'IDLE':
cur.execute("DELETE FROM position_sync WHERE ticker = :1", [ticker])
else:
now = datetime.now()
cur.execute(
"""MERGE INTO position_sync ps
USING (SELECT :1 AS ticker FROM dual) src
ON (ps.ticker = src.ticker)
WHEN MATCHED THEN UPDATE SET
state = :2, buy_price = :3, sell_price = :4,
qty = :5, order_uuid = :6, invested_krw = :7, updated_at = :8
WHEN NOT MATCHED THEN INSERT
(ticker, state, buy_price, sell_price, qty, order_uuid, invested_krw, updated_at)
VALUES (:9, :10, :11, :12, :13, :14, :15, :16)""",
[ticker, state, buy_price, sell_price, qty, order_uuid, invested_krw, now,
ticker, state, buy_price, sell_price, qty, order_uuid, invested_krw, now],
)
conn.commit()
except oracledb.Error as e:
log.warning(f"[sync_position] {ticker} {state} 실패: {e}")
global _db_conn
_db_conn = None
def calc_remaining_budget(
positions: dict,
pending_buys: dict,
max_budget: int,
) -> float:
"""남은 투자 가능 금액을 계산.
Args:
positions: 현재 포지션 dict.
pending_buys: 미체결 매수 dict.
max_budget: 총 예산.
Returns:
남은 투자 가능 금액 (원).
"""
invested = sum(p['entry_price'] * p['qty'] for p in positions.values())
invested += sum(p['price'] * p['qty'] for p in pending_buys.values())
return max_budget - invested
def check_exit_conditions(
pos: dict,
current_price: float,
*,
trail_pct: float = 0.015,
min_profit_pct: float = 0.005,
stop_loss_pct: float = 0.02,
timeout_secs: float = 14400,
) -> Optional[str]:
"""포지션 청산 조건을 체크.
Args:
pos: 포지션 dict (entry_price, entry_ts, running_peak).
current_price: 현재 가격.
Returns:
청산 사유 ('stoploss' | 'trail' | 'timeout') 또는 None.
"""
entry = pos['entry_price']
profit_pct = (current_price - entry) / entry
elapsed = (datetime.now() - pos['entry_ts']).total_seconds()
# 1. 손절
if profit_pct <= -stop_loss_pct:
return 'stoploss'
# 2. 트레일링 스탑
peak = pos['running_peak']
if peak > 0:
drop = (peak - current_price) / peak
if profit_pct >= min_profit_pct and drop >= trail_pct:
return 'trail'
# 3. 타임아웃
if elapsed >= timeout_secs:
return 'timeout'
return None
def restore_from_upbit(
client,
tickers: list[str],
positions: dict,
pending_buys: dict,
*,
cancel_fn,
fp_fn,
tg_fn,
) -> None:
"""Upbit 잔고에서 포지션과 미체결 매수를 복구.
Args:
client: pyupbit.Upbit 인스턴스.
tickers: 감시 종목 리스트.
positions: 포지션 dict (in-place 수정).
pending_buys: 미체결 매수 dict (in-place 수정).
cancel_fn: 주문 취소 함수.
fp_fn: 가격 포맷 함수.
tg_fn: 텔레그램 알림 함수.
"""
_restore_positions(client, tickers, positions, cancel_fn, fp_fn, tg_fn)
_restore_pending_buys(client, tickers, positions, pending_buys, fp_fn)
_sync_restored(positions, pending_buys)
def _restore_positions(
client, tickers: list[str], positions: dict,
cancel_fn, fp_fn, tg_fn,
) -> None:
"""잔고에서 보유 포지션을 복구."""
balances = client.get_balances()
log.info(f"[복구] 잔고 조회: {len(balances)}건")
for b in balances:
currency = b.get('currency', '')
bal = float(b.get('balance', 0))
locked = float(b.get('locked', 0))
avg = float(b.get('avg_buy_price', 0))
total = bal + locked
if currency == 'KRW' or total <= 0 or avg <= 0:
continue
ticker = f'KRW-{currency}'
if ticker not in tickers or ticker in positions:
if ticker not in tickers:
log.info(f"[복구] {ticker} TICKERS 외 -> 스킵")
continue
log.info(f"[복구] {ticker} bal={bal:.6f} locked={locked:.6f} avg={fp_fn(avg)}원")
# 기존 미체결 매도 주문 취소
try:
old_orders = client.get_order(ticker, state='wait') or []
for o in (old_orders if isinstance(old_orders, list) else []):
if o.get('side') == 'ask':
cancel_fn(o.get('uuid'))
log.info(f"[복구] {ticker} 기존 매도 주문 취소: {o.get('uuid')}")
except (ConnectionError, TimeoutError, ValueError) as e:
log.warning(f"[복구] {ticker} 주문 조회/취소 실패: {e}")
time.sleep(0.5)
actual_bal = client.get_balance(currency)
if not actual_bal or actual_bal <= 0:
actual_bal = total
log.warning(f"[복구] {ticker} get_balance 실패, total={total:.6f} 사용")
positions[ticker] = {
'entry_price': avg,
'entry_ts': datetime.now(),
'running_peak': avg,
'qty': actual_bal,
}
log.info(f"[복구] {ticker} 수량:{actual_bal:.6f} 매수평균:{fp_fn(avg)}원 트레일링")
tg_fn(f"♻️ <b>포지션 복구</b> {ticker}\n매수평균: {fp_fn(avg)}원 수량: {actual_bal:.6f}")
def _restore_pending_buys(
client, tickers: list[str], positions: dict,
pending_buys: dict, fp_fn,
) -> None:
"""미체결 매수 주문을 복구."""
for ticker in tickers:
if ticker in positions or ticker in pending_buys:
continue
try:
orders = client.get_order(ticker, state='wait') or []
for o in (orders if isinstance(orders, list) else []):
if o.get('side') == 'bid':
price = float(o.get('price', 0))
rem = float(o.get('remaining_volume', 0))
if price > 0 and rem > 0:
pending_buys[ticker] = {
'uuid': o.get('uuid'),
'price': price,
'qty': rem,
'ts': datetime.now(),
'vol_ratio': 0,
}
log.info(f"[복구] {ticker} 미체결 매수 복구: {fp_fn(price)}원 수량:{rem:.6f}")
break
except (ConnectionError, TimeoutError, ValueError):
log.warning(f"[복구] {ticker} 미체결 매수 조회 실패")
def _sync_restored(positions: dict, pending_buys: dict) -> None:
"""복구된 포지션을 position_sync DB에 반영."""
restored = len(positions) + len(pending_buys)
if restored:
log.info(f"[복구] 총 {len(positions)}개 포지션 + {len(pending_buys)}개 미체결 매수 복구됨")
for ticker, pos in positions.items():
sync_position(
ticker, 'PENDING_SELL',
buy_price=pos['entry_price'],
qty=pos['qty'],
invested_krw=int(pos['qty'] * pos['entry_price']),
)
for ticker, pb in pending_buys.items():
sync_position(
ticker, 'PENDING_BUY',
buy_price=pb['price'],
qty=pb['qty'],
order_uuid=pb.get('uuid'),
invested_krw=int(pb['qty'] * pb['price']),
)

94
core/price_collector.py
View File

@@ -1,94 +0,0 @@
"""10분마다 상위 종목 현재가를 Oracle DB에 저장하는 수집기."""
from __future__ import annotations
import logging
import time
import pyupbit
import requests
from .market import get_top_tickers
from .market_regime import LEADERS
from .price_db import cleanup_old_prices, insert_prices, insert_prices_with_time
logger = logging.getLogger(__name__)
COLLECT_INTERVAL = 600 # 10분 (초)
CLEANUP_EVERY = 6 # 1시간(10분 × 6)마다 오래된 데이터 정리
def backfill_prices(hours: int = 48) -> None:
"""시작 시 과거 N시간치 1시간봉 종가를 DB에 백필.
price_history에 데이터가 없으면 추세 판단이 불가능하므로
봇 시작 직후 한 번 호출해 과거 데이터를 채운다.
"""
tickers = get_top_tickers()
if not tickers:
logger.warning("[백필] 종목 목록 없음, 스킵")
return
# 대장 코인 항상 포함
for leader in LEADERS:
if leader not in tickers:
tickers = tickers + [leader]
count = hours + 2 # 여유 있게 요청
total_rows = 0
for ticker in tickers:
try:
df = pyupbit.get_ohlcv(ticker, interval="minute60", count=count)
if df is None or df.empty:
continue
rows = [
(ticker, float(row["close"]), ts.to_pydatetime())
for ts, row in df.iterrows()
]
insert_prices_with_time(rows)
total_rows += len(rows)
time.sleep(0.1)
except Exception as e:
logger.error(f"[백필] {ticker} 오류: {e}")
logger.info(f"[백필] 완료 — {len(tickers)}개 종목 / {total_rows}개 레코드 저장")
def run_collector(interval: int = COLLECT_INTERVAL) -> None:
"""가격 수집 루프."""
logger.info(f"가격 수집기 시작 (주기={interval//60}분)")
time.sleep(30) # 스캐너와 동시 API 호출 방지
cycle = 0
while True:
try:
tickers = get_top_tickers()
if not tickers:
continue
# 대장 코인은 top20 밖이어도 항상 포함
for leader in LEADERS:
if leader not in tickers:
tickers = tickers + [leader]
resp = requests.get(
"https://api.upbit.com/v1/ticker",
params={"markets": ",".join(tickers)},
timeout=5,
)
resp.raise_for_status()
data = resp.json()
valid = {
item["market"]: item["trade_price"]
for item in data
if item.get("trade_price")
}
insert_prices(valid)
logger.info(f"[수집] {len(valid)}개 종목 가격 저장")
cycle += 1
if cycle % CLEANUP_EVERY == 0:
cleanup_old_prices(keep_hours=48)
logger.info("오래된 가격 데이터 정리 완료")
except Exception as e:
logger.error(f"가격 수집 오류: {e}")
time.sleep(interval)

380
core/price_db.py
View File

@@ -1,380 +0,0 @@
"""Oracle ADB price_history CRUD."""
from __future__ import annotations
import os
from contextlib import contextmanager
from typing import Generator, Optional
import oracledb
_pool: Optional[oracledb.ConnectionPool] = None
def _get_pool() -> oracledb.ConnectionPool:
global _pool
if _pool is None:
kwargs: dict = dict(
user=os.environ["ORACLE_USER"],
password=os.environ["ORACLE_PASSWORD"],
dsn=os.environ["ORACLE_DSN"],
min=1,
max=3,
increment=1,
)
wallet = os.environ.get("ORACLE_WALLET")
if wallet:
kwargs["config_dir"] = wallet
_pool = oracledb.create_pool(**kwargs)
return _pool
@contextmanager
def _conn() -> Generator[oracledb.Connection, None, None]:
pool = _get_pool()
conn = pool.acquire()
try:
yield conn
conn.commit()
except Exception:
conn.rollback()
raise
finally:
pool.release(conn)
def insert_prices(ticker_prices: dict[str, float]) -> None:
"""여러 종목의 현재가를 한 번에 저장 (recorded_at = 현재 시각)."""
if not ticker_prices:
return
rows = [(ticker, price) for ticker, price in ticker_prices.items()]
sql = "INSERT INTO price_history (ticker, price) VALUES (:1, :2)"
with _conn() as conn:
conn.cursor().executemany(sql, rows)
def insert_prices_with_time(rows: list[tuple]) -> None:
"""(ticker, price, recorded_at) 튜플 리스트를 한 번에 저장 (백필용)."""
if not rows:
return
sql = """
INSERT INTO price_history (ticker, price, recorded_at)
VALUES (:1, :2, :3)
"""
with _conn() as conn:
conn.cursor().executemany(sql, rows)
def get_price_n_hours_ago(ticker: str, hours: float) -> Optional[float]:
"""N시간 전 가장 가까운 가격 반환. 데이터 없으면 None."""
sql = """
SELECT price FROM price_history
WHERE ticker = :ticker
AND recorded_at BETWEEN
SYSTIMESTAMP - INTERVAL ':h' HOUR - INTERVAL '10' MINUTE
AND SYSTIMESTAMP - INTERVAL ':h' HOUR + INTERVAL '10' MINUTE
ORDER BY ABS(CAST(recorded_at AS DATE) -
CAST(SYSTIMESTAMP - INTERVAL ':h' HOUR AS DATE))
FETCH FIRST 1 ROWS ONLY
"""
# Oracle INTERVAL bind param 미지원으로 직접 포맷
h = int(hours)
sql = f"""
SELECT price FROM price_history
WHERE ticker = :ticker
AND recorded_at BETWEEN
SYSTIMESTAMP - ({h}/24) - (10/1440)
AND SYSTIMESTAMP - ({h}/24) + (10/1440)
ORDER BY ABS(CAST(recorded_at AS DATE) -
CAST(SYSTIMESTAMP - ({h}/24) AS DATE))
FETCH FIRST 1 ROWS ONLY
"""
with _conn() as conn:
cursor = conn.cursor()
cursor.execute(sql, {"ticker": ticker})
row = cursor.fetchone()
return float(row[0]) if row else None
def cleanup_old_prices(keep_hours: int = 48) -> None:
"""N시간 이상 오래된 데이터 삭제 (DB 용량 관리)."""
sql = f"DELETE FROM price_history WHERE recorded_at < SYSTIMESTAMP - ({keep_hours}/24)"
with _conn() as conn:
conn.cursor().execute(sql)
# ── 포지션 영구 저장 (재시작 후 실제 매수가 복원용) ──────────────────────────
def upsert_position(
ticker: str,
buy_price: float,
peak_price: float,
amount: float,
invested_krw: int,
entry_time: str, # ISO 포맷 문자열
trade_id: str = "",
) -> None:
"""포지션 저장 또는 갱신 (MERGE)."""
sql = """
MERGE INTO positions p
USING (SELECT :ticker AS ticker FROM dual) s
ON (p.ticker = s.ticker)
WHEN MATCHED THEN
UPDATE SET peak_price = :peak_price,
amount = :amount,
invested_krw = :invested_krw,
updated_at = SYSTIMESTAMP
WHEN NOT MATCHED THEN
INSERT (ticker, buy_price, peak_price, amount, invested_krw, entry_time, trade_id)
VALUES (:ticker, :buy_price, :peak_price, :amount, :invested_krw,
TO_TIMESTAMP(:entry_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF6'), :trade_id)
"""
with _conn() as conn:
conn.cursor().execute(sql, {
"ticker": ticker,
"buy_price": buy_price,
"peak_price": peak_price,
"amount": amount,
"invested_krw": invested_krw,
"entry_time": entry_time,
"trade_id": trade_id,
})
def delete_position(ticker: str) -> None:
"""포지션 삭제 (매도 완료 시)."""
with _conn() as conn:
conn.cursor().execute(
"DELETE FROM positions WHERE ticker = :ticker", {"ticker": ticker}
)
# ── Walk-forward 거래 이력 ────────────────────────────────────────────────────
def ensure_trade_results_table() -> None:
"""trade_results 테이블이 없으면 생성."""
ddl = """
CREATE TABLE trade_results (
id NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
ticker VARCHAR2(20) NOT NULL,
is_win NUMBER(1) NOT NULL,
pnl_pct NUMBER(10,4),
traded_at TIMESTAMP DEFAULT SYSTIMESTAMP NOT NULL
)
"""
idx = "CREATE INDEX idx_tr_ticker ON trade_results (ticker, traded_at DESC)"
with _conn() as conn:
for sql in (ddl, idx):
try:
conn.cursor().execute(sql)
except oracledb.DatabaseError as e:
if e.args[0].code not in (955, 1408):
raise
# sell_reason 컬럼이 100 BYTE 이하이면 500으로 확장
try:
conn.cursor().execute(
"ALTER TABLE trade_results MODIFY sell_reason VARCHAR2(500)"
)
except oracledb.DatabaseError:
pass # 이미 500 이상이거나 컬럼 없으면 무시
def record_trade(
ticker: str,
is_win: bool,
pnl_pct: float,
fee_krw: float = 0.0,
krw_profit: float = 0.0,
trade_id: str = "",
buy_price: float = 0.0,
sell_price: float = 0.0,
invested_krw: int = 0,
sell_reason: str = "",
) -> None:
"""거래 결과 저장 (수수료·KRW 손익·trade_id 포함)."""
with _conn() as conn:
conn.cursor().execute(
"INSERT INTO trade_results "
"(ticker, is_win, pnl_pct, fee_krw, krw_profit, "
" trade_id, buy_price, sell_price, invested_krw, sell_reason) "
"VALUES (:t, :w, :p, :f, :k, :tid, :bp, :sp, :ikrw, :sr)",
{
"t": ticker,
"w": 1 if is_win else 0,
"p": round(pnl_pct, 4),
"f": round(fee_krw, 2),
"k": round(krw_profit, 2),
"tid": trade_id,
"bp": buy_price,
"sp": sell_price,
"ikrw": invested_krw,
"sr": sell_reason,
},
)
def get_cumulative_krw_profit() -> float:
"""전체 거래 누적 KRW 손익 반환 (수수료 차감 후). 데이터 없으면 0."""
with _conn() as conn:
cur = conn.cursor()
cur.execute("SELECT SUM(krw_profit) FROM trade_results WHERE krw_profit IS NOT NULL")
row = cur.fetchone()
return float(row[0]) if row and row[0] is not None else 0.0
def load_recent_wins(ticker: str, n: int = 5) -> list[bool]:
"""직전 N건 거래의 승/패 리스트 반환 (오래된 순). 없으면 빈 리스트."""
sql = """
SELECT is_win FROM (
SELECT is_win FROM trade_results
WHERE ticker = :t
ORDER BY traded_at DESC
FETCH FIRST :n ROWS ONLY
) ORDER BY ROWNUM DESC
"""
with _conn() as conn:
cur = conn.cursor()
cur.execute(sql, {"t": ticker, "n": n})
rows = cur.fetchall()
return [bool(r[0]) for r in rows]
# ── 직전 매도가 영구 저장 (재시작 후 재매수 차단 유지용) ──────────────────────
def ensure_sell_prices_table() -> None:
"""sell_prices 테이블이 없으면 생성."""
ddl = """
CREATE TABLE sell_prices (
ticker VARCHAR2(20) NOT NULL PRIMARY KEY,
price NUMBER(20,8) NOT NULL,
updated_at TIMESTAMP DEFAULT SYSTIMESTAMP NOT NULL
)
"""
with _conn() as conn:
try:
conn.cursor().execute(ddl)
except oracledb.DatabaseError as e:
if e.args[0].code != 955: # ORA-00955: 이미 존재
raise
def upsert_sell_price(ticker: str, price: float) -> None:
"""직전 매도가 저장 또는 갱신."""
sql = """
MERGE INTO sell_prices s
USING (SELECT :ticker AS ticker FROM dual) d
ON (s.ticker = d.ticker)
WHEN MATCHED THEN
UPDATE SET price = :price, updated_at = SYSTIMESTAMP
WHEN NOT MATCHED THEN
INSERT (ticker, price) VALUES (:ticker, :price)
"""
with _conn() as conn:
conn.cursor().execute(sql, {"ticker": ticker, "price": price})
def load_sell_prices() -> dict[str, float]:
"""저장된 직전 매도가 전체 로드."""
with _conn() as conn:
cur = conn.cursor()
cur.execute("SELECT ticker, price FROM sell_prices")
return {r[0]: float(r[1]) for r in cur.fetchall()}
def delete_sell_price(ticker: str) -> None:
"""매도가 기록 삭제 (더 이상 필요 없을 때)."""
with _conn() as conn:
conn.cursor().execute(
"DELETE FROM sell_prices WHERE ticker = :ticker", {"ticker": ticker}
)
# ── WF 상태 영구 저장 (재시작 후 shadow 재활 상태 유지) ──────────────────────
def ensure_wf_state_table() -> None:
"""wf_state 테이블이 없으면 생성."""
ddl = """
CREATE TABLE wf_state (
ticker VARCHAR2(20) NOT NULL PRIMARY KEY,
is_blocked NUMBER(1) DEFAULT 0 NOT NULL,
shadow_cons_wins NUMBER DEFAULT 0 NOT NULL,
updated_at TIMESTAMP DEFAULT SYSTIMESTAMP NOT NULL
)
"""
with _conn() as conn:
try:
conn.cursor().execute(ddl)
except oracledb.DatabaseError as e:
if e.args[0].code != 955: # ORA-00955: 이미 존재
raise
def upsert_wf_state(ticker: str, is_blocked: bool, shadow_cons_wins: int) -> None:
"""WF 차단 상태 저장 또는 갱신."""
sql = """
MERGE INTO wf_state w
USING (SELECT :ticker AS ticker FROM dual) d
ON (w.ticker = d.ticker)
WHEN MATCHED THEN
UPDATE SET is_blocked = :is_blocked,
shadow_cons_wins = :shadow_cons_wins,
updated_at = SYSTIMESTAMP
WHEN NOT MATCHED THEN
INSERT (ticker, is_blocked, shadow_cons_wins)
VALUES (:ticker, :is_blocked, :shadow_cons_wins)
"""
with _conn() as conn:
conn.cursor().execute(sql, {
"ticker": ticker,
"is_blocked": 1 if is_blocked else 0,
"shadow_cons_wins": shadow_cons_wins,
})
def load_wf_states() -> dict[str, dict]:
"""저장된 WF 상태 전체 로드.
Returns:
{ticker: {"is_blocked": bool, "shadow_cons_wins": int}}
"""
with _conn() as conn:
cur = conn.cursor()
cur.execute("SELECT ticker, is_blocked, shadow_cons_wins FROM wf_state")
return {
r[0]: {"is_blocked": bool(r[1]), "shadow_cons_wins": int(r[2])}
for r in cur.fetchall()
}
def delete_wf_state(ticker: str) -> None:
"""WF 상태 삭제 (WF 해제 시)."""
with _conn() as conn:
conn.cursor().execute(
"DELETE FROM wf_state WHERE ticker = :ticker", {"ticker": ticker}
)
def load_positions() -> list[dict]:
"""저장된 전체 포지션 로드."""
sql = """
SELECT ticker, buy_price, peak_price, amount, invested_krw,
TO_CHAR(entry_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF6') AS entry_time,
trade_id
FROM positions
"""
with _conn() as conn:
cursor = conn.cursor()
cursor.execute(sql)
rows = cursor.fetchall()
return [
{
"ticker": r[0],
"buy_price": float(r[1]),
"peak_price": float(r[2]),
"amount": float(r[3]),
"invested_krw": int(r[4]),
"entry_time": r[5],
"trade_id": r[6] or "",
}
for r in rows
]

139
core/signal.py Normal file
View File

@@ -0,0 +1,139 @@
"""시그널 감지 + 지표 계산 모듈.
20초봉 데이터에서 양봉 + 거래량 + 사전 필터를 적용하여
매수 시그널 후보를 반환한다.
"""
from __future__ import annotations
import logging
from typing import Optional
log = logging.getLogger(__name__)
def calc_vr(bar_list: list[dict], idx: int, lookback: int = 61) -> float:
"""거래량비(Volume Ratio) 계산. 상위 10% 트리밍.
Args:
bar_list: 봉 리스트.
idx: 현재 봉 인덱스.
lookback: 기준 봉 수.
Returns:
현재 봉 거래량 / trimmed mean 비율.
"""
start = max(0, idx - lookback)
end = max(0, idx - 2)
baseline = sorted(bar_list[i]['volume'] for i in range(start, end))
if not baseline:
return 0.0
trim = max(1, len(baseline) // 10)
trimmed = baseline[:len(baseline) - trim]
if not trimmed:
return 0.0
avg = sum(trimmed) / len(trimmed)
return bar_list[idx]['volume'] / avg if avg > 0 else 0.0
def calc_atr(bar_list: list[dict], lookback: int = 28) -> float:
"""ATR(Average True Range) 비율 계산.
Args:
bar_list: 봉 리스트.
lookback: ATR 계산 봉 수.
Returns:
ATR / 직전 종가 비율 (0~1 범위).
"""
if len(bar_list) < lookback + 2:
return 0.0
trs = []
for i in range(-lookback - 1, -1):
b = bar_list[i]
bp = bar_list[i - 1]
tr = max(
b['high'] - b['low'],
abs(b['high'] - bp['close']),
abs(b['low'] - bp['close']),
)
trs.append(tr)
prev_close = bar_list[-2]['close']
return (sum(trs) / len(trs)) / prev_close if prev_close > 0 else 0.0
def detect_signal(
ticker: str,
bar_list: list[dict],
*,
vol_min: float = 5.0,
vol_lookback: int = 61,
vol_krw_min: float = 5_000_000,
spread_min: float = 0.3,
) -> Optional[dict]:
"""양봉 + 거래량 + 사전 필터 3종을 적용하여 시그널 후보를 반환.
Args:
ticker: 종목 코드.
bar_list: 봉 리스트 (list로 변환된 deque).
vol_min: 최소 거래량 배수.
vol_lookback: 거래량 평균 기준 봉 수.
vol_krw_min: 최소 거래대금 (원).
spread_min: 횡보 필터 최소 변동폭 (%).
Returns:
시그널 dict 또는 None.
"""
n = len(bar_list)
if n < vol_lookback + 5:
return None
b = bar_list[-1]
if b['close'] <= b['open']:
return None
vr = calc_vr(bar_list, n - 1, lookback=vol_lookback)
if vr < vol_min:
return None
bar_krw = b['close'] * b['volume']
if bar_krw < vol_krw_min:
return None
# 1) 횡보 필터: 최근 15봉 변동폭 < 0.3%
recent = bar_list[-15:]
period_high = max(x['high'] for x in recent)
period_low = min(x['low'] for x in recent)
if period_low > 0:
spread_pct = (period_high - period_low) / period_low * 100
if spread_pct < spread_min:
log.debug(f"[필터/횡보] {ticker} 15봉 변동 {spread_pct:.2f}% -> 스킵")
return None
# 2) 고점 필터: 30분 구간 90%+ 위치 & 변동 1%+
long_bars = bar_list[-90:]
long_high = max(x['high'] for x in long_bars)
long_low = min(x['low'] for x in long_bars)
if long_high > long_low:
pos_in_range = (b['close'] - long_low) / (long_high - long_low)
move_pct = (long_high - long_low) / long_low * 100
if pos_in_range > 0.9 and move_pct > 1.0:
log.debug(f"[필터/고점] {ticker} 구간 {pos_in_range:.0%} 위치, 변동 {move_pct:.1f}% -> 스킵")
return None
# 3) 연속 양봉 필터: 직전 2봉 이상 연속 양봉
prev_greens = 0
for k in range(len(bar_list) - 2, max(len(bar_list) - 12, 0), -1):
if bar_list[k]['close'] > bar_list[k]['open']:
prev_greens += 1
else:
break
if prev_greens < 2:
log.debug(f"[필터/양봉] {ticker} 직전 연속양봉 {prev_greens}개 < 2 -> 스킵")
return None
return {
'ticker': ticker,
'price': b['close'],
'vol_ratio': vr,
'bar_list': bar_list,
}

171
core/strategy.py
View File

@@ -1,171 +0,0 @@
"""Volume Lead 전략: 10분봉 거래량 급증 + 횡보 감지 후 +THRESH% 상승 시 진입.
흐름:
1. 직전 완성 10분봉 거래량 > 로컬 LV봉(280분) 평균 × VOL_THRESH AND
QN봉(120분) 이전 종가 대비 가격 변동 < PRICE_QUIET_PCT% (횡보 중 축적)
→ 신호가(signal_price) + 거래량비율(vol_ratio) 기록
* 더 강한 vol(> 기존 sig vol_ratio)이 오면 sig_p 갱신
2. signal_price 대비 +TREND_AFTER_VOL%(4.8%) 이상 상승 시 진입
3. 신호불사: 가격이 신호가 아래로 내려가도 신호 유지 (sig_p 고정, 만료까지 대기)
4. SIGNAL_TIMEOUT_MIN(480분=8h) 초과 시 신호 초기화
거래량 임계값 + 진입 차단 (F&G 기반 3구간):
- F&G ≤ FNG_FEAR_THRESHOLD(40): VOL_THRESH_FEAR(6.0x) ← 공포/극공포
- F&G 41 ~ FNG_MAX_ENTRY(50): VOL_THRESH_NORMAL(5.0x) ← 중립
- F&G > FNG_MAX_ENTRY(50): 진입 차단 ← 탐욕/극탐욕
캔들: minute10 데이터 직접 사용 (40분봉 리샘플링 없음)
"""
from __future__ import annotations
import logging
import os
import time
import pyupbit
from .fng import get_fng
from .market import get_current_price
from .notify import notify_signal, notify_watch
logger = logging.getLogger(__name__)
# 10분봉 직접 사용 파라미터
LOCAL_VOL_CANDLES = int(os.getenv("LOCAL_VOL_CANDLES", "28")) # 로컬 vol 평균 구간 (280분)
QUIET_CANDLES = int(os.getenv("QUIET_CANDLES", "12")) # 횡보 체크 구간 (120분)
PRICE_QUIET_PCT = float(os.getenv("PRICE_QUIET_PCT", "2.0")) # 횡보 기준 (%)
TREND_AFTER_VOL = float(os.getenv("TREND_AFTER_VOL", "4.8")) # 진입 임계값 (신호가 대비 %)
SIGNAL_TIMEOUT_MIN = int(os.getenv("SIGNAL_TIMEOUT_MIN", "480")) # 신호 유효 시간 (분=8h)
# F&G 기반 거래량 임계값 + 진입 차단
VOL_THRESH_NORMAL = float(os.getenv("VOL_THRESH_NORMAL", "5.0")) # 중립 구간 (F&G 41~FNG_MAX_ENTRY)
VOL_THRESH_FEAR = float(os.getenv("VOL_THRESH_FEAR", "6.0")) # 공포/극공포 (F&G ≤ FNG_FEAR_THRESHOLD)
FNG_FEAR_THRESHOLD = int(os.getenv("FNG_FEAR_THRESHOLD", "40")) # 공포 기준 (이하 → FEAR 임계값)
FNG_MAX_ENTRY = int(os.getenv("FNG_MAX_ENTRY", "50")) # 진입 허용 최대 F&G (초과 → 차단)
# 관찰 알림 (신호 임계값에 근접했지만 미달인 종목)
WATCH_VOL_THRESH = float(os.getenv("WATCH_VOL_THRESH", "4.0")) # 관찰 시작 임계값
WATCH_COOLDOWN_MIN = int(os.getenv("WATCH_COOLDOWN_MIN", "30")) # 같은 종목 재알림 최소 간격 (분)
WATCH_VOL_JUMP = float(os.getenv("WATCH_VOL_JUMP", "0.5")) # 쿨다운 무시 vol 상승폭
# 10분봉 조회 수
_FETCH_10M = LOCAL_VOL_CANDLES + QUIET_CANDLES + 5 # 45봉
# 축적 신호 상태: ticker → {"price": float, "time": float(unix), "vol_ratio": float}
_accum_signals: dict[str, dict] = {}
# 관찰 알림 상태: ticker → {"time": float, "vol_ratio": float}
_watch_notified: dict[str, dict] = {}
def get_active_signals() -> dict[str, dict]:
"""현재 활성화된 신호 딕셔너리 반환 (fast-poll 루프용).
Returns:
{ticker: {"price": float, "time": float, "vol_ratio": float}}
"""
return dict(_accum_signals)
def should_buy(ticker: str) -> bool:
"""Volume Lead 전략 (10분봉 직접 감지).
1단계: F&G 값으로 vol 임계값 동적 설정 (≤40→6x, >40→5x)
2단계: 10분봉 거래량 급증 + QN봉 횡보 → 신호가 기록 (더 강한 vol이면 갱신)
3단계: 신호가 대비 +TREND_AFTER_VOL% 상승 확인 시 진입
신호불사: 가격이 신호가 아래로 내려가도 신호 유지 (sig_p 고정)
"""
fng = get_fng()
# F&G 탐욕/극탐욕 구간 진입 차단
if fng > FNG_MAX_ENTRY:
logger.debug(f"[F&G차단] {ticker} F&G={fng} > {FNG_MAX_ENTRY} (탐욕) → 진입 금지")
return False
# F&G 구간별 vol 임계값
vth = VOL_THRESH_FEAR if fng <= FNG_FEAR_THRESHOLD else VOL_THRESH_NORMAL
current = get_current_price(ticker)
if not current:
return False
now = time.time()
# ── 신호 만료 체크 ────────────────────────────────────
sig = _accum_signals.get(ticker)
if sig is not None:
age_min = (now - sig["time"]) / 60
if age_min > SIGNAL_TIMEOUT_MIN:
del _accum_signals[ticker]
sig = None
logger.debug(f"[축적타임아웃] {ticker} {age_min:.0f}분 경과 → 신호 초기화")
# ── 10분봉 데이터 조회 ────────────────────────────────
try:
df10 = pyupbit.get_ohlcv(ticker, interval="minute10", count=_FETCH_10M)
except Exception:
return False
if df10 is None or len(df10) < LOCAL_VOL_CANDLES + QUIET_CANDLES:
return False
# ── 거래량 비율 계산 (직전 완성봉 기준) ───────────────
vol_prev = float(df10["volume"].iloc[-2])
vol_avg = float(df10["volume"].iloc[-(LOCAL_VOL_CANDLES + 2):-2].mean())
vol_r = vol_prev / vol_avg if vol_avg > 0 else 0.0
# ── 횡보 체크 (QN봉 이전 종가 기준) ──────────────────
close_qn = float(df10["close"].iloc[-(QUIET_CANDLES + 1)])
chg = abs(current - close_qn) / close_qn * 100 if close_qn > 0 else 999.0
# ── 관찰 알림: WATCH_VOL_THRESH ≤ vol_r < vth + 횡보 ──
if WATCH_VOL_THRESH <= vol_r < vth and chg < PRICE_QUIET_PCT:
prev = _watch_notified.get(ticker)
age_min = (now - prev["time"]) / 60 if prev else 999.0
vol_jump = vol_r - prev["vol_ratio"] if prev else vol_r
if prev is None or age_min >= WATCH_COOLDOWN_MIN or vol_jump >= WATCH_VOL_JUMP:
_watch_notified[ticker] = {"time": now, "vol_ratio": vol_r}
logger.info(
f"[관찰] {ticker} vol={vol_r:.2f}x (신호기준={vth:.1f}x) + 횡보({chg:.1f}%) | F&G={fng}"
)
notify_watch(ticker, current, vol_r, vth, chg, fng=fng)
elif vol_r < WATCH_VOL_THRESH:
_watch_notified.pop(ticker, None)
# ── vol 스파이크 + 횡보 → 신호 설정/갱신 ────────────
if vol_r >= vth and chg < PRICE_QUIET_PCT:
if sig is None or vol_r > sig.get("vol_ratio", 0.0):
_accum_signals[ticker] = {"price": current, "time": now, "vol_ratio": vol_r}
sig = _accum_signals[ticker]
logger.info(
f"[축적감지] {ticker} 10m vol={vol_r:.2f}x ≥ {vth:.1f}x + 횡보({chg:.1f}%) "
f"→ 신호가={current:,.2f}원 (F&G={fng})"
)
notify_signal(ticker, current, vol_r, fng=fng)
if sig is None:
logger.debug(
f"[축적✗] {ticker} vol={vol_r:.2f}x (기준={vth:.1f}x) / 횡보={chg:.1f}%"
)
return False
# ── 진입 확인: 신호가 대비 +TREND_AFTER_VOL% 이상 ──
signal_price = sig["price"]
vol_ratio = sig["vol_ratio"]
move_pct = (current - signal_price) / signal_price * 100
age_min = (now - sig["time"]) / 60
if move_pct >= TREND_AFTER_VOL:
del _accum_signals[ticker]
logger.info(
f"[축적진입] {ticker} 신호가={signal_price:,.2f}원 → 현재={current:,.2f}원 "
f"(+{move_pct:.1f}% ≥ {TREND_AFTER_VOL}% | 거래량={vol_ratio:.2f}x | F&G={fng})"
)
return True
# 신호불사: 가격 하락해도 신호 유지 (sig_p 고정, 만료까지 대기)
logger.debug(
f"[축적대기] {ticker} 신호가={signal_price:,.2f} 현재={current:,.2f} "
f"({move_pct:+.1f}% / 목표={TREND_AFTER_VOL}% | "
f"거래량={vol_ratio:.2f}x | 경과={age_min:.0f}분)"
)
return False

666
core/trader.py
View File

@@ -1,666 +0,0 @@
"""매수/매도 실행 및 포지션 관리."""
from __future__ import annotations
import logging
import os
import threading
import time
import uuid
from datetime import datetime
from typing import Optional
import pyupbit
from dotenv import load_dotenv
from .notify import notify_buy, notify_sell, notify_error
from .price_db import (
delete_position, load_positions, upsert_position,
ensure_trade_results_table, record_trade, load_recent_wins,
ensure_sell_prices_table, upsert_sell_price, load_sell_prices,
get_cumulative_krw_profit,
ensure_wf_state_table, upsert_wf_state, load_wf_states, delete_wf_state,
)
load_dotenv()
logger = logging.getLogger(__name__)
SIMULATION_MODE = os.getenv("SIMULATION_MODE", "").lower() in ("true", "1", "yes")
if SIMULATION_MODE:
logging.getLogger(__name__).warning(
"*** SIMULATION MODE ACTIVE — 실제 주문이 실행되지 않습니다 ***"
)
INITIAL_BUDGET = int(os.getenv("MAX_BUDGET", "10000000")) # 초기 원금 (고정)
MAX_POSITIONS = int(os.getenv("MAX_POSITIONS", "3")) # 최대 동시 보유 종목 수
# 복리 적용 예산 (매도 후 재계산) — 수익 시 복리 증가, 손실 시 차감 (하한 30%)
MIN_BUDGET = INITIAL_BUDGET * 3 // 10 # 최소 예산: 초기값의 30%
MAX_BUDGET = INITIAL_BUDGET
PER_POSITION = INITIAL_BUDGET // MAX_POSITIONS
def _recalc_compound_budget() -> None:
"""누적 수익/손실을 반영해 MAX_BUDGET / PER_POSITION 재계산.
수익 시 복리로 증가, 손실 시 차감 (최소 초기 예산의 30% 보장).
매도 완료 후 호출.
"""
global MAX_BUDGET, PER_POSITION
try:
cum_profit = get_cumulative_krw_profit()
effective = max(INITIAL_BUDGET + int(cum_profit), MIN_BUDGET)
MAX_BUDGET = effective
PER_POSITION = effective // MAX_POSITIONS
logger.info(
f"[복리] 누적수익={cum_profit:+,.0f}원 | "
f"운용예산={MAX_BUDGET:,}원 | 포지션당={PER_POSITION:,}원"
)
except Exception as e:
logger.warning(f"[복리] 예산 재계산 실패 (이전 값 유지): {e}")
# Walk-forward 필터 설정
WF_WINDOW = int(float(os.getenv("WF_WINDOW", "5"))) # 이력 윈도우 크기
WF_MIN_WIN_RATE = float(os.getenv("WF_MIN_WIN_RATE", "0.40")) # 최소 승률 임계값
WF_SHADOW_WINS = int(os.getenv("WF_SHADOW_WINS", "2")) # shadow N연승 → WF 해제
WF_VOL_BYPASS_THRESH = float(os.getenv("WF_VOL_BYPASS_THRESH", "10.0")) # 이 이상 vol이면 WF 무시
_lock = threading.Lock()
_positions: dict = {}
# 구조: { ticker: { buy_price, peak_price, amount, invested_krw, entry_time } }
_last_sell_prices: dict[str, float] = {}
# 직전 매도가 기록 — 재매수 시 이 가격 이상일 때만 진입 허용
_trade_history: dict[str, list[bool]] = {}
# walk-forward 이력: { ticker: [True/False, ...] } (True=수익)
_shadow_lock = threading.Lock()
_shadow_positions: dict[str, dict] = {}
# WF차단 종목 가상 포지션: { ticker: { buy_price, peak_price, entry_time } }
_shadow_cons_wins: dict[str, int] = {}
# shadow 연속 승 횟수: { ticker: int }
_upbit: Optional[pyupbit.Upbit] = None
def _get_upbit() -> pyupbit.Upbit:
global _upbit
if _upbit is None:
_upbit = pyupbit.Upbit(os.getenv("ACCESS_KEY"), os.getenv("SECRET_KEY"))
return _upbit
def _get_history(ticker: str) -> list[bool]:
"""in-memory 이력 반환. 없으면 DB에서 초기 로드."""
if ticker not in _trade_history:
try:
_trade_history[ticker] = load_recent_wins(ticker, WF_WINDOW)
except Exception:
_trade_history[ticker] = []
return _trade_history[ticker]
def _update_history(
ticker: str, is_win: bool, pnl_pct: float,
fee_krw: float = 0.0, krw_profit: float = 0.0,
trade_id: str = "", buy_price: float = 0.0,
sell_price: float = 0.0, invested_krw: int = 0,
sell_reason: str = "",
) -> None:
"""매도 후 in-memory 이력 갱신 + DB 기록."""
hist = _trade_history.setdefault(ticker, [])
hist.append(is_win)
# 윈도우 초과분 제거 (메모리 절약)
if len(hist) > WF_WINDOW * 2:
_trade_history[ticker] = hist[-WF_WINDOW:]
try:
record_trade(
ticker, is_win, pnl_pct, fee_krw, krw_profit,
trade_id, buy_price, sell_price, invested_krw, sell_reason,
)
except Exception as e:
logger.error(f"거래 이력 저장 실패 {ticker}: {e}")
# ── Shadow 재활 ────────────────────────────────────────────────────────────────
def _shadow_enter(ticker: str) -> None:
"""WF 차단 종목에 shadow(가상) 포지션 진입.
buy() 내부(_lock 보유 중)에서 호출됨.
API 호출 후 _shadow_lock으로만 shadow 상태 보호 (deadlock 방지).
"""
# 이미 shadow 중이면 스킵
if ticker in _shadow_positions:
return
price = pyupbit.get_current_price(ticker)
if not price:
return
with _shadow_lock:
if ticker in _shadow_positions: # double-check
return
_shadow_positions[ticker] = {
"buy_price": price,
"peak_price": price,
"entry_time": datetime.now(),
}
cons = _shadow_cons_wins.get(ticker, 0)
try:
upsert_wf_state(ticker, is_blocked=True, shadow_cons_wins=cons)
except Exception as e:
logger.error(f"WF 상태 DB 저장 실패 {ticker}: {e}")
logger.info(
f"[Shadow진입] {ticker} @ {price:,.0f}원 "
f"(가상 — WF 재활 {cons}/{WF_SHADOW_WINS}연승 필요)"
)
def get_shadow_positions() -> dict:
"""Shadow 포지션 스냅샷 반환 (monitor 에서 조회용)."""
with _shadow_lock:
return {k: dict(v) for k, v in _shadow_positions.items()}
def update_shadow_peak(ticker: str, price: float) -> None:
"""Shadow 포지션 최고가 갱신."""
with _shadow_lock:
if ticker in _shadow_positions:
if price > _shadow_positions[ticker]["peak_price"]:
_shadow_positions[ticker]["peak_price"] = price
def close_shadow(ticker: str, sell_price: float, pnl_pct: float, reason: str) -> None:
"""Shadow 포지션 청산 및 WF 재활 진행.
연속승 갱신 → WF_SHADOW_WINS 달성 시 WF 이력 초기화 + Telegram 알림.
"""
with _shadow_lock:
spos = _shadow_positions.pop(ticker, None)
if spos is None:
return
is_win = pnl_pct > 0
cons = _shadow_cons_wins.get(ticker, 0)
cons = cons + 1 if is_win else 0
_shadow_cons_wins[ticker] = cons
do_wf_reset = cons >= WF_SHADOW_WINS
if do_wf_reset:
_shadow_cons_wins.pop(ticker, None)
# shadow 상태 DB 갱신 (_shadow_lock 해제 후)
try:
if do_wf_reset:
delete_wf_state(ticker)
else:
upsert_wf_state(ticker, is_blocked=True, shadow_cons_wins=cons)
except Exception as e:
logger.error(f"WF 상태 DB 갱신 실패 {ticker}: {e}")
mark = "✅" if is_win else "❌"
logger.info(
f"[Shadow청산] {ticker} {spos['buy_price']:,.0f}→{sell_price:,.0f}원 "
f"| {mark} {pnl_pct:+.1f}% | {reason} | 연속승={cons}/{WF_SHADOW_WINS}"
)
if do_wf_reset:
with _lock: # _shadow_lock은 이미 해제된 상태 (deadlock 없음)
_trade_history.pop(ticker, None)
logger.warning(
f"[WF해제] {ticker} Shadow {WF_SHADOW_WINS}연승 달성 → "
f"WF 이력 초기화, 실거래 재개"
)
notify_error(
f"🎉 [{ticker}] WF 재활 완료!\n"
f"Shadow {WF_SHADOW_WINS}연승 달성 → 실거래 재개"
)
def _db_upsert(ticker: str, pos: dict) -> None:
"""포지션을 Oracle DB에 저장 (실패해도 거래는 계속)."""
try:
upsert_position(
ticker=ticker,
buy_price=pos["buy_price"],
peak_price=pos["peak_price"],
amount=pos["amount"],
invested_krw=pos["invested_krw"],
entry_time=pos["entry_time"].isoformat(),
trade_id=pos.get("trade_id", ""),
)
except Exception as e:
logger.error(f"포지션 DB 저장 실패 {ticker}: {e}")
def get_positions() -> dict:
return _positions
def get_budget_info() -> dict:
"""현재 복리 예산 정보 반환 (main.py 등 외부에서 동적 조회용)."""
return {
"max_budget": MAX_BUDGET,
"per_position": PER_POSITION,
"initial": INITIAL_BUDGET,
}
def restore_positions() -> None:
"""시작 시 Oracle DB + Upbit 잔고를 교차 확인하여 포지션 복원.
trade_results 테이블도 이 시점에 생성 (없으면).
DB에 저장된 실제 매수가를 복원하고, Upbit 잔고에 없으면 DB에서도 삭제한다.
"""
# trade_results / sell_prices / wf_state 테이블 초기화
try:
ensure_trade_results_table()
except Exception as e:
logger.warning(f"trade_results 테이블 생성 실패 (무시): {e}")
# 시작 시 복리 예산 복원 (이전 세션 수익 반영)
_recalc_compound_budget()
# WF 상태 복원 (shadow 연속승 횟수 유지)
try:
ensure_wf_state_table()
wf_states = load_wf_states()
for ticker, state in wf_states.items():
if state["is_blocked"]:
_shadow_cons_wins[ticker] = state["shadow_cons_wins"]
if wf_states:
logger.info(
f"[복원] WF 차단 상태 {len(wf_states)}건 복원: "
+ ", ".join(f"{t}(shadow={s['shadow_cons_wins']})" for t, s in wf_states.items())
)
except Exception as e:
logger.warning(f"WF 상태 복원 실패 (무시): {e}")
try:
ensure_sell_prices_table()
except Exception as e:
logger.warning(f"sell_prices 테이블 생성 실패 (무시): {e}")
# 직전 매도가 복원 (재매수 차단 기준 유지)
try:
loaded = load_sell_prices()
_last_sell_prices.update(loaded)
if loaded:
logger.info(f"[복원] 직전 매도가 {len(loaded)}건 복원: {list(loaded.keys())}")
except Exception as e:
logger.warning(f"직전 매도가 복원 실패 (무시): {e}")
# DB에서 저장된 포지션 로드
try:
saved = {row["ticker"]: row for row in load_positions()}
except Exception as e:
logger.error(f"DB 포지션 로드 실패: {e}")
saved = {}
if SIMULATION_MODE:
# --- 시뮬레이션: Upbit 잔고 조회 없이 DB 포지션만 복원 ---
logger.info("[SIMULATION] 시뮬레이션 모드 — Upbit 잔고 조회 생략, DB 포지션만 복원")
for ticker, s in saved.items():
current = pyupbit.get_current_price(ticker)
if not current:
continue
peak = max(s["peak_price"], current)
entry_time = datetime.fromisoformat(s["entry_time"]) if isinstance(s["entry_time"], str) else s["entry_time"]
with _lock:
_positions[ticker] = {
"buy_price": s["buy_price"],
"peak_price": peak,
"amount": s.get("amount", 0),
"invested_krw": s["invested_krw"],
"entry_time": entry_time,
"trade_id": s.get("trade_id", ""),
}
logger.info(
f"[SIMULATION][복원] {ticker} 매수가={s['buy_price']:,.0f}원 | "
f"현재가={current:,.0f}원 (DB 복원)"
)
return
upbit = _get_upbit()
balances = upbit.get_balances()
upbit_tickers = set()
for b in balances:
currency = b["currency"]
if currency == "KRW":
continue
amount = float(b["balance"]) + float(b["locked"])
if amount <= 0:
continue
ticker = f"KRW-{currency}"
current = pyupbit.get_current_price(ticker)
if not current:
continue
invested_krw = int(amount * current)
if invested_krw < 1_000: # 소액 잔고 무시
continue
upbit_tickers.add(ticker)
if ticker in saved:
# DB에 저장된 실제 매수가 복원
s = saved[ticker]
peak = max(s["peak_price"], current) # 재시작 중 올랐을 수 있으므로 높은 쪽
entry_time = datetime.fromisoformat(s["entry_time"]) if isinstance(s["entry_time"], str) else s["entry_time"]
with _lock:
_positions[ticker] = {
"buy_price": s["buy_price"],
"peak_price": peak,
"amount": amount,
"invested_krw": s["invested_krw"],
"entry_time": entry_time,
"trade_id": s.get("trade_id", ""),
}
logger.info(
f"[복원] {ticker} 매수가={s['buy_price']:,.0f}원 | 현재가={current:,.0f}원 "
f"| 수량={amount} (DB 복원)"
)
else:
# DB에 없음 → 현재가로 초기화 후 DB에 저장
entry_time = datetime.now()
with _lock:
_positions[ticker] = {
"buy_price": current,
"peak_price": current,
"amount": amount,
"invested_krw": min(invested_krw, PER_POSITION),
"entry_time": entry_time,
}
_db_upsert(ticker, _positions[ticker])
logger.warning(
f"[복원] {ticker} 현재가={current:,.0f}원 | 수량={amount} "
f"(DB 기록 없음 → 현재가로 초기화)"
)
# Upbit 잔고에 없는데 DB에 남아있는 항목 정리
for ticker in saved:
if ticker not in upbit_tickers:
try:
delete_position(ticker)
logger.info(f"[정리] {ticker} Upbit 잔고 없음 → DB 포지션 삭제")
except Exception as e:
logger.error(f"DB 포지션 삭제 실패 {ticker}: {e}")
def buy(ticker: str, vol_ratio: float = 0.0) -> bool:
"""시장가 매수. 예산·포지션 수 확인 후 진입.
Args:
vol_ratio: 진입 시점의 거래량 배율. WF_VOL_BYPASS_THRESH 이상이면 WF 필터 무시.
"""
with _lock:
if ticker in _positions:
logger.debug(f"{ticker} 이미 보유 중")
return False
# WF 이력 항상 DB에서 직접 로드 (재시작과 무관하게 최신 이력 반영)
try:
hist = load_recent_wins(ticker, WF_WINDOW)
_trade_history[ticker] = hist # 메모리 캐시 동기화
except Exception as e:
logger.warning(f"WF 이력 DB 로드 실패 {ticker}: {e}")
hist = _trade_history.get(ticker, [])
# 직전 매도가 +1% 이상일 때만 재진입 (손절 직후 역방향 재매수 방지)
# 단, 직전 거래가 수익(승)이었으면 이 필터 스킵 — 다시 상승 시 재진입 허용
if ticker in _last_sell_prices:
last_was_win = bool(hist[-1]) if hist else False
if not last_was_win:
current_check = pyupbit.get_current_price(ticker)
last_sell = _last_sell_prices[ticker]
threshold = last_sell * 1.01
if current_check and current_check < threshold:
logger.info(
f"[재매수 차단] {ticker} 현재={current_check:,.2f} < "
f"직전매도+1%={threshold:,.2f} → 상승 흐름 미확인"
)
return False
# Walk-forward 필터: 직전 WF_WINDOW건 승률이 낮으면 진입 차단 + shadow 진입
# vol이 WF_VOL_BYPASS_THRESH 이상이면 WF 무시 (강한 신호 우선)
if WF_MIN_WIN_RATE > 0:
if WF_VOL_BYPASS_THRESH > 0 and vol_ratio >= WF_VOL_BYPASS_THRESH:
logger.info(
f"[WF바이패스] {ticker} vol={vol_ratio:.1f}x ≥ {WF_VOL_BYPASS_THRESH}x"
f" → WF 필터 무시 (강한 vol 신호)"
)
elif len(hist) >= WF_WINDOW:
recent_wr = sum(hist[-WF_WINDOW:]) / WF_WINDOW
if recent_wr < WF_MIN_WIN_RATE:
logger.info(
f"[WF차단] {ticker} 직전{WF_WINDOW}건 승률={recent_wr*100:.0f}%"
f" < {WF_MIN_WIN_RATE*100:.0f}% → 진입 차단 (shadow 재활 시작)"
)
_shadow_enter(ticker) # 가상 포지션으로 WF 재활 추적
return False
if len(_positions) >= MAX_POSITIONS:
logger.info(f"최대 포지션 도달({MAX_POSITIONS}), {ticker} 패스")
return False
invested = sum(p["invested_krw"] for p in _positions.values())
available = MAX_BUDGET - invested
order_krw = min(available, PER_POSITION)
if order_krw < 10_000:
logger.info(f"잔여 예산 부족({order_krw:,}원), {ticker} 패스")
return False
try:
if SIMULATION_MODE:
# --- 시뮬레이션 매수 ---
sim_price = pyupbit.get_current_price(ticker)
if not sim_price:
logger.error(f"[SIMULATION] 현재가 조회 실패: {ticker}")
return False
amount = order_krw / sim_price
actual_price = sim_price
logger.info(
f"[SIMULATION][매수] {ticker} @ {actual_price:,.0f}원 | "
f"수량={amount:.8f} | 투자금={order_krw:,}원 (모의 주문)"
)
else:
# --- 실제 매수 ---
upbit = _get_upbit()
result = upbit.buy_market_order(ticker, order_krw)
if not result or "error" in str(result):
logger.error(f"매수 실패: {result}")
return False
time.sleep(0.5) # 체결 대기
currency = ticker.split("-")[1]
amount = float(upbit.get_balance(currency) or 0)
# 실제 체결가 = 투자금 / 수량 (시장가 주문 슬리피지 반영)
actual_price = order_krw / amount if amount > 0 else pyupbit.get_current_price(ticker)
entry_time = datetime.now()
trade_id = str(uuid.uuid4())
_positions[ticker] = {
"buy_price": actual_price,
"peak_price": actual_price,
"amount": amount,
"invested_krw": order_krw,
"entry_time": entry_time,
"trade_id": trade_id,
}
_db_upsert(ticker, _positions[ticker])
prefix = "[SIMULATION]" if SIMULATION_MODE else ""
logger.info(
f"{prefix}[매수] {ticker} @ {actual_price:,.0f}원 (실체결가) | "
f"수량={amount} | 투자금={order_krw:,}원 | trade_id={trade_id[:8]}"
)
from .fng import get_fng
notify_buy(ticker, actual_price, amount, order_krw,
max_budget=MAX_BUDGET, per_position=PER_POSITION,
fng=get_fng())
return True
except Exception as e:
logger.error(f"매수 예외 {ticker}: {e}")
notify_error(f"매수 실패 {ticker}: {e}")
return False
def _get_avg_fill_price(
upbit: pyupbit.Upbit,
order_uuid: str,
ticker: str,
fallback: float,
) -> tuple[float, float | None]:
"""주문 UUID로 실제 체결 내역을 조회해 가중평균 체결가와 실수수료를 반환.
분할 체결(여러 fills)이면 합산 평균가 계산.
조회 실패 시 (fallback_price, None) 반환.
"""
if not order_uuid:
return fallback, None
try:
import hashlib
import jwt as _jwt
import requests as _req
query_str = f"uuid={order_uuid}"
payload = {
"access_key": upbit.access_key,
"nonce": str(uuid.uuid4()),
"query_hash": hashlib.sha512(query_str.encode()).hexdigest(),
"query_hash_alg": "SHA512",
}
token = _jwt.encode(payload, upbit.secret_key, algorithm="HS256")
resp = _req.get(
"https://api.upbit.com/v1/order",
params={"uuid": order_uuid},
headers={"Authorization": f"Bearer {token}"},
timeout=5,
)
data = resp.json()
trades = data.get("trades", [])
if not trades:
return fallback, None
total_vol = sum(float(t["volume"]) for t in trades)
total_krw = sum(float(t["price"]) * float(t["volume"]) for t in trades)
avg_price = total_krw / total_vol if total_vol > 0 else fallback
paid_fee = float(data.get("paid_fee", 0))
if len(trades) > 1:
logger.info(
f"[분할체결] {ticker} {len(trades)}건 → "
f"평균={avg_price:,.4f}원 (수수료={paid_fee:,.0f}원)"
)
return avg_price, paid_fee
except Exception as e:
logger.debug(f"[체결조회 실패] {ticker} uuid={order_uuid[:8]}: {e}")
return fallback, None
def sell(ticker: str, reason: str = "") -> bool:
"""시장가 전량 매도."""
with _lock:
if ticker not in _positions:
return False
pos = _positions[ticker]
try:
if SIMULATION_MODE:
# --- 시뮬레이션 매도 ---
actual_amount = pos["amount"]
actual_sell_price = pyupbit.get_current_price(ticker) or pos["buy_price"]
sell_value = actual_sell_price * actual_amount
fee = pos["invested_krw"] * 0.0005 + sell_value * 0.0005
krw_profit = sell_value - pos["invested_krw"] - fee
pnl = (actual_sell_price - pos["buy_price"]) / pos["buy_price"] * 100
logger.info(
f"[SIMULATION][매도] {ticker} @ {actual_sell_price:,.4f}원 | "
f"수익률={pnl:+.1f}% | 순익={krw_profit:+,.0f}원 (모의 주문) | 사유={reason}"
)
else:
# --- 실제 매도 ---
upbit = _get_upbit()
currency = ticker.split("-")[1]
# 실제 잔고 확인 (재시작 후 이미 매도된 경우 대비)
actual_amount = float(upbit.get_balance(currency) or 0)
if actual_amount < 0.00001:
logger.warning(f"[매도] {ticker} 실제 잔고 없음 → 포지션 정리 (이미 매도됨)")
del _positions[ticker]
return True
result = upbit.sell_market_order(ticker, actual_amount)
if not result or "error" in str(result):
logger.error(f"매도 실패: {result}")
# 실패 후에도 잔고 재확인 → 0이면 실제로는 매도됨
actual_amount2 = float(upbit.get_balance(currency) or 0)
if actual_amount2 < 0.00001:
logger.warning(f"[매도] {ticker} 잔고 소진 확인 → 포지션 정리")
del _positions[ticker]
return True
return False
time.sleep(0.5) # 체결 완료 대기
# 실제 체결 내역으로 가중평균 매도가 계산 (분할 체결 대응)
order_uuid = result.get("uuid", "") if isinstance(result, dict) else ""
fallback_price = pyupbit.get_current_price(ticker) or pos["buy_price"]
actual_sell_price, actual_fee_from_order = _get_avg_fill_price(
upbit, order_uuid, ticker, fallback_price
)
pnl = (actual_sell_price - pos["buy_price"]) / pos["buy_price"] * 100
sell_value = actual_sell_price * actual_amount
# 수수료: 주문 조회 성공 시 실제값, 아니면 추정값 (0.05% 양방향)
fee = actual_fee_from_order if actual_fee_from_order is not None \
else (pos["invested_krw"] * 0.0005 + sell_value * 0.0005)
krw_profit = sell_value - pos["invested_krw"] - fee
prefix = "[SIMULATION]" if SIMULATION_MODE else ""
logger.info(
f"{prefix}[매도] {ticker} @ {actual_sell_price:,.4f}원 | "
f"수익률={pnl:+.1f}% | 순익={krw_profit:+,.0f}원 (수수료 {fee:,.0f}원) | 사유={reason}"
)
try:
cum = get_cumulative_krw_profit() + krw_profit
except Exception:
cum = 0.0
notify_sell(ticker, actual_sell_price, pnl, reason,
krw_profit=krw_profit, fee_krw=fee, cum_profit=cum)
_last_sell_prices[ticker] = actual_sell_price
try:
upsert_sell_price(ticker, actual_sell_price)
except Exception as e:
logger.error(f"직전 매도가 DB 저장 실패 {ticker}: {e}")
_update_history(
ticker, pnl > 0, pnl, fee, krw_profit,
trade_id=pos.get("trade_id", ""),
buy_price=pos["buy_price"],
sell_price=actual_sell_price,
invested_krw=pos["invested_krw"],
sell_reason=reason,
)
del _positions[ticker]
try:
delete_position(ticker)
except Exception as e:
logger.error(f"포지션 DB 삭제 실패 {ticker}: {e}")
# 복리 예산 재계산: 수익 발생분만 다음 투자에 반영
_recalc_compound_budget()
return True
except Exception as e:
logger.error(f"매도 예외 {ticker}: {e}")
notify_error(f"매도 실패 {ticker}: {e}")
return False
def update_peak(ticker: str, current_price: float) -> None:
"""최고가 갱신 (트레일링 스탑 기준선 상향)."""
with _lock:
if ticker in _positions:
if current_price > _positions[ticker]["peak_price"]:
_positions[ticker]["peak_price"] = current_price
_db_upsert(ticker, _positions[ticker])