commit 83bd51117f8b6a672242ac673ea96a70c9c6f402 Author: joungmin Date: Sat Feb 28 10:20:02 2026 +0900 feat: initial upbit auto-trader implementation Strategy C: volatility breakout (Larry Williams K=0.5) AND momentum (MA20 + 2x volume surge) must both trigger for a buy signal. Hard rules: - Trailing stop: sell when price drops -10% from peak - Max budget: 1,000,000 KRW total, up to 3 positions (333,333 KRW each) - Scan top 20 KRW tickers by 24h trading volume every 60s - Monitor positions every 10s Co-Authored-By: Claude Sonnet 4.6 diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..3703940 --- /dev/null +++ b/.env.example @@ -0,0 +1,2 @@ +ACCESS_KEY= +SECRET_KEY= diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..32196d0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.env +__pycache__/ +*.pyc +.venv/ +*.log diff --git a/core/__init__.py b/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/core/market.py b/core/market.py new file mode 100644 index 0000000..334d7c9 --- /dev/null +++ b/core/market.py @@ -0,0 +1,62 @@ +"""Market data utilities.""" + +from __future__ import annotations + +import logging + +import pyupbit +import requests + +logger = logging.getLogger(__name__) + +TOP_N = 20 # 거래량 상위 N개 종목만 스캔 +_TICKER_URL = "https://api.upbit.com/v1/ticker" + + +def get_top_tickers() -> list[str]: + """24시간 거래대금 상위 KRW 마켓 티커 반환.""" + try: + all_tickers = pyupbit.get_tickers(fiat="KRW") + if not all_tickers: + return [] + + # 100개씩 나눠서 조회 (URL 길이 제한) + 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)} + resp = requests.get(_TICKER_URL, params=params, timeout=5) + resp.raise_for_status() + ticker_data.extend(resp.json()) + + # 스테이블코인 제외 + 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]] + logger.debug(f"상위 {TOP_N}개: {top[:5]}...") + return top + except Exception as e: + logger.error(f"get_top_tickers 실패: {e}") + return [] + + +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 diff --git a/core/monitor.py b/core/monitor.py new file mode 100644 index 0000000..92fb608 --- /dev/null +++ b/core/monitor.py @@ -0,0 +1,58 @@ +"""트레일링 스탑 감시 - 백그라운드 스레드에서 실행.""" + +import logging +import time + +from .market import get_current_price +from . import trader + +logger = logging.getLogger(__name__) + +STOP_LOSS_PCT = 0.10 # 최고가 대비 -10% +CHECK_INTERVAL = 10 # 10초마다 체크 + + +def _check_stop(ticker: str, pos: dict) -> None: + """단일 포지션 스탑 체크.""" + current = get_current_price(ticker) + if current is None: + return + + # 최고가 갱신 + trader.update_peak(ticker, current) + + # 최신 peak_price 읽기 (update 후) + pos = trader.get_positions().get(ticker) + if pos is None: + return + + peak = pos["peak_price"] + buy_price = pos["buy_price"] + drop_from_peak = (peak - current) / peak + + # 로그 (보유 중 상태 확인) + pnl = (current - buy_price) / buy_price * 100 + logger.info( + f"[감시] {ticker} 현재={current:,.0f} | " + f"최고={peak:,.0f} | 하락={drop_from_peak:.1%} | 수익률={pnl:+.1f}%" + ) + + if drop_from_peak >= STOP_LOSS_PCT: + reason = ( + f"트레일링스탑 | 최고가={peak:,.0f}원 → " + f"현재={current:,.0f}원 ({drop_from_peak:.1%} 하락)" + ) + trader.sell(ticker, reason=reason) + + +def run_monitor(interval: int = CHECK_INTERVAL) -> None: + """전체 포지션 감시 루프.""" + logger.info(f"모니터 시작 (체크 주기={interval}초, 스탑={STOP_LOSS_PCT:.0%})") + while True: + positions_snapshot = dict(trader.get_positions()) + for ticker, pos in positions_snapshot.items(): + try: + _check_stop(ticker, pos) + except Exception as e: + logger.error(f"모니터 오류 {ticker}: {e}") + time.sleep(interval) diff --git a/core/strategy.py b/core/strategy.py new file mode 100644 index 0000000..a005430 --- /dev/null +++ b/core/strategy.py @@ -0,0 +1,69 @@ +"""Strategy C: 변동성 돌파 AND 모멘텀 동시 충족 시 매수 신호.""" + +import logging + +from .market import get_current_price, get_ohlcv + +logger = logging.getLogger(__name__) + +# 변동성 돌파 계수 (래리 윌리엄스 기본값) +BREAKOUT_K = 0.5 +# 모멘텀 이동평균 기간 +MA_PERIOD = 20 +# 거래량 급증 배수 +VOLUME_MULTIPLIER = 2.0 + + +def check_volatility_breakout(ticker: str) -> bool: + """변동성 돌파 조건: 현재가 > 오늘 시가 + 전일 변동폭 × K.""" + df = get_ohlcv(ticker, count=2) + if df is None or len(df) < 2: + return False + + prev = df.iloc[-2] + today = df.iloc[-1] + target = today["open"] + (prev["high"] - prev["low"]) * BREAKOUT_K + current = get_current_price(ticker) + + if current is None: + return False + + result = current > target + if result: + logger.debug(f"[변동성돌파] {ticker} 현재가={current:,.0f} 목표가={target:,.0f}") + return result + + +def check_momentum(ticker: str) -> bool: + """모멘텀 조건: 현재가 > MA20 AND 오늘 거래량 > 20일 평균 × 2.""" + df = get_ohlcv(ticker, count=MA_PERIOD + 1) + if df is None or len(df) < MA_PERIOD + 1: + return False + + ma = df["close"].iloc[-MA_PERIOD:].mean() + avg_vol = df["volume"].iloc[:-1].mean() # 오늘 제외한 20일 평균 + today_vol = df["volume"].iloc[-1] + current = get_current_price(ticker) + + if current is None: + return False + + price_ok = current > ma + vol_ok = today_vol > avg_vol * VOLUME_MULTIPLIER + result = price_ok and vol_ok + + if result: + logger.debug( + f"[모멘텀] {ticker} 현재가={current:,.0f} MA20={ma:,.0f} " + f"오늘거래량={today_vol:.1f} 평균={avg_vol:.1f}" + ) + return result + + +def should_buy(ticker: str) -> bool: + """Strategy C: 변동성 돌파 AND 모멘텀 모두 충족 시 True.""" + vb = check_volatility_breakout(ticker) + if not vb: + return False + mo = check_momentum(ticker) + return vb and mo diff --git a/core/trader.py b/core/trader.py new file mode 100644 index 0000000..4c640c2 --- /dev/null +++ b/core/trader.py @@ -0,0 +1,119 @@ +"""매수/매도 실행 및 포지션 관리.""" + +from __future__ import annotations + +import logging +import os +import threading +import time +from typing import Optional + +import pyupbit +from dotenv import load_dotenv + +load_dotenv() + +logger = logging.getLogger(__name__) + +MAX_BUDGET = 1_000_000 # 총 운용 한도: 100만원 +MAX_POSITIONS = 3 # 최대 동시 보유 종목 수 +PER_POSITION = MAX_BUDGET // MAX_POSITIONS # 종목당 33만3천원 + +_lock = threading.Lock() +_positions: dict = {} +# 구조: { ticker: { buy_price, peak_price, amount, invested_krw } } + +_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_positions() -> dict: + return _positions + + +def buy(ticker: str) -> bool: + """시장가 매수. 예산·포지션 수 확인 후 진입.""" + with _lock: + if ticker in _positions: + logger.debug(f"{ticker} 이미 보유 중") + 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 + + upbit = _get_upbit() + try: + current = pyupbit.get_current_price(ticker) + 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) + + _positions[ticker] = { + "buy_price": current, + "peak_price": current, + "amount": amount, + "invested_krw": order_krw, + } + logger.info( + f"[매수] {ticker} @ {current:,.0f}원 | " + f"수량={amount} | 투자금={order_krw:,}원" + ) + return True + except Exception as e: + logger.error(f"매수 예외 {ticker}: {e}") + return False + + +def sell(ticker: str, reason: str = "") -> bool: + """시장가 전량 매도.""" + with _lock: + if ticker not in _positions: + return False + + pos = _positions[ticker] + upbit = _get_upbit() + try: + result = upbit.sell_market_order(ticker, pos["amount"]) + if not result or "error" in str(result): + logger.error(f"매도 실패: {result}") + return False + + current = pyupbit.get_current_price(ticker) + pnl = (current - pos["buy_price"]) / pos["buy_price"] * 100 + logger.info( + f"[매도] {ticker} @ {current:,.0f}원 | " + f"수익률={pnl:+.1f}% | 사유={reason}" + ) + del _positions[ticker] + return True + except Exception as e: + logger.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 diff --git a/daemon/__init__.py b/daemon/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/daemon/runner.py b/daemon/runner.py new file mode 100644 index 0000000..e213d78 --- /dev/null +++ b/daemon/runner.py @@ -0,0 +1,46 @@ +"""매수 기회 스캔 루프 - 60초마다 전체 시장 스캔.""" + +import logging +import time + +from core import trader +from core.market import get_top_tickers +from core.strategy import should_buy + +logger = logging.getLogger(__name__) + +SCAN_INTERVAL = 60 # 초 + + +def run_scanner() -> None: + """메인 스캔 루프.""" + logger.info(f"스캐너 시작 (주기={SCAN_INTERVAL}초)") + while True: + try: + # 포지션 꽉 찼으면 스캔 스킵 + if len(trader.get_positions()) >= trader.MAX_POSITIONS: + logger.info("포지션 최대치 도달, 스캔 스킵") + time.sleep(SCAN_INTERVAL) + continue + + tickers = get_top_tickers() + logger.info(f"스캔 시작: {len(tickers)}개 종목") + + for ticker in tickers: + # 이미 보유 중인 종목 제외 + if ticker in trader.get_positions(): + continue + + try: + if should_buy(ticker): + logger.info(f"매수 신호: {ticker}") + trader.buy(ticker) + time.sleep(0.15) # API rate limit 방지 + except Exception as e: + logger.error(f"스캔 오류 {ticker}: {e}") + time.sleep(0.3) + + except Exception as e: + logger.error(f"스캐너 루프 오류: {e}") + + time.sleep(SCAN_INTERVAL) diff --git a/main.py b/main.py new file mode 100644 index 0000000..e9933de --- /dev/null +++ b/main.py @@ -0,0 +1,35 @@ +"""Upbit 자동 트레이딩 봇 진입점.""" + +import logging +import threading + +from dotenv import load_dotenv + +load_dotenv() + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", + handlers=[ + logging.StreamHandler(), + logging.FileHandler("trading.log", encoding="utf-8"), + ], +) + +from core.monitor import run_monitor +from daemon.runner import run_scanner + + +def main() -> None: + # 트레일링 스탑 감시 스레드 (10초 주기) + monitor_thread = threading.Thread( + target=run_monitor, args=(10,), daemon=True, name="monitor" + ) + monitor_thread.start() + + # 매수 스캔 루프 (60초 주기, 메인 스레드) + run_scanner() + + +if __name__ == "__main__": + main() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..20af01c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,8 @@ +[project] +name = "upbit-trader" +version = "0.1.0" +requires-python = ">=3.9" +dependencies = [ + "pyupbit>=0.3.0", + "python-dotenv>=1.0", +]