732 lines
25 KiB
Python
732 lines
25 KiB
Python
"""
|
||
데이트레이딩 API 엔드포인트
|
||
|
||
라우터 prefix: /api/daytrading
|
||
|
||
엔드포인트:
|
||
GET /watchlist — 감시 종목 목록 조회
|
||
POST /watchlist — 감시 종목 추가/교체
|
||
GET /signals — 현재 진입 신호 조회
|
||
POST /execute — 신호 기반 데이트레이딩 실행
|
||
GET /positions — 활성 데이트레이딩 포지션 조회
|
||
POST /close-all — 전체 포지션 강제 청산 (EOD 수동)
|
||
POST /cycle — 1분 주기 사이클 수동 실행 (디버그용)
|
||
|
||
상태 (인메모리, 일일 초기화):
|
||
_watchlist — 감시 종목 코드+이름 딕셔너리
|
||
_positions — 활성 포지션 {stock_code: {...}}
|
||
_orb_cache — 종목별 ORB 데이터
|
||
_daily_pnl — 오늘 실현 손익
|
||
_last_date — 마지막 초기화 날짜 (날짜 바뀌면 자동 리셋)
|
||
"""
|
||
from fastapi import APIRouter, HTTPException, Depends, Query
|
||
from pydantic import BaseModel
|
||
from typing import List, Optional, Dict, Any
|
||
from datetime import datetime, date, time as dtime
|
||
import asyncio
|
||
import logging
|
||
import pytz
|
||
|
||
from app.services.korea_investment_api import korea_investment_api
|
||
from app.services.day_trading_strategy import (
|
||
MinuteCandle, OpeningRange, DayTradeSignal,
|
||
parse_minute_candles, aggregate_to_5min,
|
||
calculate_vwap, calculate_opening_range,
|
||
check_orb_signal, check_vwap_bounce_signal, check_rsi_bb_signal,
|
||
check_day_trade_exit,
|
||
calculate_day_trade_position_size, is_daily_loss_exceeded,
|
||
ORB_END, ENTRY_CUTOFF, EOD_FLAT, MAX_POSITIONS,
|
||
)
|
||
from app.core.market_schedule import (
|
||
is_market_open, is_opening_range_period,
|
||
is_day_trade_entry_window, is_eod_flat_time,
|
||
)
|
||
from app.core.config import settings
|
||
from app.core.json_helpers import _dumps
|
||
from app.services.websocket_manager import websocket_manager
|
||
from app.core.database import get_db, AsyncSessionLocal
|
||
from app.models.models import TradeHistory
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
router = APIRouter()
|
||
logger = logging.getLogger(__name__)
|
||
KST = pytz.timezone("Asia/Seoul")
|
||
|
||
|
||
# ── 인메모리 상태 ──────────────────────────────────────────────────────────────
|
||
|
||
def _kst_now() -> datetime:
|
||
return datetime.now(KST).replace(tzinfo=None)
|
||
|
||
|
||
def _kst_time() -> dtime:
|
||
return datetime.now(KST).time()
|
||
|
||
|
||
def _today_kst() -> date:
|
||
return datetime.now(KST).date()
|
||
|
||
|
||
# 감시 종목 (code → name)
|
||
_watchlist: Dict[str, str] = {}
|
||
|
||
# 활성 포지션
|
||
# {stock_code: {
|
||
# "stock_name", "strategy", "entry_price", "stop_loss", "target_price",
|
||
# "quantity", "highest_price", "entry_time", "reason"
|
||
# }}
|
||
_positions: Dict[str, Dict[str, Any]] = {}
|
||
|
||
# ORB 캐시 (당일, stock_code → OpeningRange)
|
||
_orb_cache: Dict[str, OpeningRange] = {}
|
||
|
||
# 일일 실현 손익 (원)
|
||
_daily_pnl: float = 0.0
|
||
|
||
# 마지막 초기화 날짜
|
||
_last_reset_date: Optional[date] = None
|
||
|
||
# 매매 실행 lock
|
||
_trade_lock = asyncio.Lock()
|
||
|
||
|
||
def _reset_if_new_day() -> None:
|
||
"""날짜가 바뀌면 일일 상태 초기화"""
|
||
global _daily_pnl, _orb_cache, _last_reset_date
|
||
today = _today_kst()
|
||
if _last_reset_date != today:
|
||
_daily_pnl = 0.0
|
||
_orb_cache = {}
|
||
_last_reset_date = today
|
||
logger.info(f"📅 데이트레이딩 상태 일일 초기화: {today}")
|
||
|
||
|
||
# ── Pydantic 모델 ─────────────────────────────────────────────────────────────
|
||
|
||
class WatchlistRequest(BaseModel):
|
||
stocks: List[Dict[str, str]] # [{"code": "005930", "name": "삼성전자"}, ...]
|
||
|
||
|
||
class ExecuteRequest(BaseModel):
|
||
stock_code: str
|
||
dry_run: bool = False # True면 주문 없이 신호만 반환
|
||
|
||
|
||
# ── 내부 헬퍼 ─────────────────────────────────────────────────────────────────
|
||
|
||
async def _fetch_candles(stock_code: str) -> List[MinuteCandle]:
|
||
"""당일 전체 분봉 데이터 조회 및 파싱"""
|
||
raw = await korea_investment_api.get_minute_chart_full_day(stock_code)
|
||
return parse_minute_candles(raw)
|
||
|
||
|
||
async def _get_current_price(stock_code: str) -> float:
|
||
"""현재가 조회"""
|
||
try:
|
||
result = await korea_investment_api.get_current_price(stock_code)
|
||
return float(result.get("output", {}).get("stck_prpr", 0) or 0)
|
||
except Exception:
|
||
return 0.0
|
||
|
||
|
||
async def _get_portfolio_summary() -> Dict[str, float]:
|
||
"""포트폴리오 요약 (총자산, 가용 현금)"""
|
||
try:
|
||
balance = await korea_investment_api.get_balance()
|
||
output2 = balance.get("output2", [{}])
|
||
summary = output2[0] if output2 else {}
|
||
total_assets = float(summary.get("tot_evlu_amt", 0) or 0)
|
||
available_cash = float(summary.get("prvs_rcdl_excc_amt", 0) or 0)
|
||
return {"total_assets": total_assets, "available_cash": available_cash}
|
||
except Exception as e:
|
||
logger.error(f"포트폴리오 조회 실패: {e}")
|
||
return {"total_assets": 0.0, "available_cash": 0.0}
|
||
|
||
|
||
async def _place_buy_order(
|
||
stock_code: str,
|
||
quantity: int,
|
||
price: int,
|
||
) -> Optional[str]:
|
||
"""매수 주문 실행, 주문번호 반환 (실패 시 None)"""
|
||
try:
|
||
result = await korea_investment_api.place_order(
|
||
stock_code=stock_code,
|
||
order_type="BUY",
|
||
quantity=quantity,
|
||
price=price,
|
||
)
|
||
if result.get("rt_cd") == "0":
|
||
return result.get("output", {}).get("ODNO", "")
|
||
logger.warning(f"매수 주문 실패 [{stock_code}]: {result.get('msg1')}")
|
||
return None
|
||
except Exception as e:
|
||
logger.error(f"매수 주문 오류 [{stock_code}]: {e}")
|
||
return None
|
||
|
||
|
||
async def _place_sell_order(
|
||
stock_code: str,
|
||
quantity: int,
|
||
price: int = 0, # 0 = 시장가
|
||
) -> bool:
|
||
"""매도 주문 실행"""
|
||
try:
|
||
result = await korea_investment_api.place_order(
|
||
stock_code=stock_code,
|
||
order_type="SELL",
|
||
quantity=quantity,
|
||
price=price,
|
||
)
|
||
return result.get("rt_cd") == "0"
|
||
except Exception as e:
|
||
logger.error(f"매도 주문 오류 [{stock_code}]: {e}")
|
||
return False
|
||
|
||
|
||
async def _record_trade(
|
||
db: AsyncSession,
|
||
stock_code: str,
|
||
stock_name: str,
|
||
order_type: str,
|
||
price: float,
|
||
quantity: int,
|
||
reason: str,
|
||
profit_loss: float = 0.0,
|
||
) -> None:
|
||
"""TradeHistory DB 기록"""
|
||
try:
|
||
trade = TradeHistory(
|
||
stock_code=stock_code,
|
||
stock_name=stock_name,
|
||
order_type=order_type,
|
||
executed_price=price,
|
||
executed_quantity=quantity,
|
||
total_amount=price * quantity,
|
||
profit_loss=profit_loss,
|
||
profit_loss_rate=(profit_loss / (price * quantity) * 100) if price * quantity > 0 else 0,
|
||
status="COMPLETED",
|
||
entry_reason=reason if order_type == "BUY" else None,
|
||
exit_reason=reason if order_type == "SELL" else None,
|
||
executed_at=_kst_now(),
|
||
)
|
||
db.add(trade)
|
||
await db.commit()
|
||
except Exception as e:
|
||
logger.error(f"TradeHistory 기록 실패: {e}")
|
||
|
||
|
||
# ── 핵심 사이클 로직 ──────────────────────────────────────────────────────────
|
||
|
||
async def run_day_trading_cycle() -> Dict[str, Any]:
|
||
"""1분 주기 데이트레이딩 사이클
|
||
|
||
흐름:
|
||
1. 장 미개장 → 스킵
|
||
2. 일일 상태 초기화 체크
|
||
3. Opening Range 수집 (09:00~09:30)
|
||
4. 활성 포지션 청산 체크
|
||
5. 신규 진입 신호 체크 (09:30~15:00)
|
||
6. 결과 반환
|
||
"""
|
||
_reset_if_new_day()
|
||
now_time = _kst_time()
|
||
result: Dict[str, Any] = {
|
||
"time": _kst_now().strftime("%H:%M:%S"),
|
||
"phase": "",
|
||
"exits": [],
|
||
"entries": [],
|
||
"signals": [],
|
||
}
|
||
|
||
if not is_market_open():
|
||
result["phase"] = "market_closed"
|
||
return result
|
||
|
||
# ── 1. EOD 강제 청산 ──
|
||
if is_eod_flat_time():
|
||
result["phase"] = "eod_flat"
|
||
await _execute_eod_flat()
|
||
return result
|
||
|
||
# ── 2. ORB 수집 단계 (09:00~09:30) ──
|
||
if is_opening_range_period():
|
||
result["phase"] = "opening_range"
|
||
await _collect_opening_range()
|
||
result["orb_count"] = len(_orb_cache)
|
||
return result
|
||
|
||
# ── 3. 매매 가능 구간 (09:30~15:00) ──
|
||
if not is_day_trade_entry_window():
|
||
result["phase"] = "outside_window"
|
||
return result
|
||
|
||
result["phase"] = "active"
|
||
|
||
# ── 4. 활성 포지션 청산 체크 ──
|
||
exits = await _check_exits()
|
||
result["exits"] = exits
|
||
|
||
# ── 5. 신규 진입 신호 체크 ──
|
||
if len(_positions) < MAX_POSITIONS and settings.AUTO_TRADE_ENABLED:
|
||
portfolio = await _get_portfolio_summary()
|
||
total_assets = portfolio["total_assets"]
|
||
available_cash = portfolio["available_cash"]
|
||
|
||
if not is_daily_loss_exceeded(total_assets, _daily_pnl):
|
||
current_day_trade_amount = sum(
|
||
p["entry_price"] * p["quantity"] for p in _positions.values()
|
||
)
|
||
signals = await _scan_signals(
|
||
total_assets=total_assets,
|
||
available_cash=available_cash,
|
||
current_day_trade_amount=current_day_trade_amount,
|
||
)
|
||
result["signals"] = [
|
||
{
|
||
"stock_code": s["signal"].stock_code,
|
||
"strategy": s["signal"].strategy,
|
||
"entry_price": s["signal"].entry_price,
|
||
"stop_loss": s["signal"].stop_loss,
|
||
"target_price": s["signal"].target_price,
|
||
"reason": s["signal"].reason,
|
||
"quantity": s["quantity"],
|
||
}
|
||
for s in signals
|
||
]
|
||
|
||
for s in signals:
|
||
if len(_positions) >= MAX_POSITIONS:
|
||
break
|
||
entry_result = await _execute_entry(s["signal"], s["quantity"])
|
||
if entry_result:
|
||
result["entries"].append(entry_result)
|
||
else:
|
||
logger.warning(
|
||
f"⚠️ 일일 손실 한도 도달 ({_daily_pnl:,.0f}원) → 신규 진입 중단"
|
||
)
|
||
|
||
return result
|
||
|
||
|
||
async def _collect_opening_range() -> None:
|
||
"""Opening Range 집계 (09:00~09:30)"""
|
||
for code in list(_watchlist.keys()):
|
||
if code in _orb_cache:
|
||
continue
|
||
try:
|
||
candles = await _fetch_candles(code)
|
||
orb = calculate_opening_range(candles)
|
||
if orb:
|
||
_orb_cache[code] = orb
|
||
logger.info(
|
||
f"📊 ORB 수집 [{code}]: "
|
||
f"H={orb.high:.0f}, L={orb.low:.0f}, "
|
||
f"분당거래량={orb.avg_vol_per_min:.0f}"
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"ORB 수집 실패 [{code}]: {e}")
|
||
await asyncio.sleep(0.6)
|
||
|
||
|
||
async def _check_exits() -> List[Dict[str, Any]]:
|
||
"""활성 포지션 청산 조건 체크 및 실행"""
|
||
global _daily_pnl
|
||
exits = []
|
||
now_time = _kst_time()
|
||
|
||
for code, pos in list(_positions.items()):
|
||
try:
|
||
current_price = await _get_current_price(code)
|
||
if current_price <= 0:
|
||
continue
|
||
|
||
# 최고가 갱신
|
||
if current_price > pos["highest_price"]:
|
||
_positions[code]["highest_price"] = current_price
|
||
|
||
candles = await _fetch_candles(code)
|
||
candles_5m = aggregate_to_5min(candles)
|
||
|
||
exit_signal = check_day_trade_exit(
|
||
entry_price=pos["entry_price"],
|
||
current_price=current_price,
|
||
stop_loss=pos["stop_loss"],
|
||
target_price=pos["target_price"],
|
||
highest_since_entry=pos["highest_price"],
|
||
candles_5min=candles_5m,
|
||
current_time=now_time,
|
||
)
|
||
|
||
if exit_signal:
|
||
quantity = pos["quantity"]
|
||
ok = await _place_sell_order(code, quantity, price=0) # 시장가
|
||
if ok:
|
||
pnl = (current_price - pos["entry_price"]) * quantity
|
||
_daily_pnl += pnl
|
||
del _positions[code]
|
||
|
||
async with AsyncSessionLocal() as db:
|
||
await _record_trade(
|
||
db, code, pos["stock_name"], "SELL",
|
||
current_price, quantity, exit_signal.reason, pnl,
|
||
)
|
||
|
||
exits.append({
|
||
"stock_code": code,
|
||
"reason": exit_signal.reason,
|
||
"pnl": round(pnl, 0),
|
||
"price": current_price,
|
||
})
|
||
logger.info(
|
||
f"✅ 데이트레이딩 청산 [{code}]: "
|
||
f"{exit_signal.reason}, PNL={pnl:+,.0f}원"
|
||
)
|
||
await websocket_manager.broadcast(_dumps({
|
||
"type": "day_trade_exit",
|
||
"stock_code": code,
|
||
"reason": exit_signal.reason,
|
||
"pnl": pnl,
|
||
}))
|
||
except Exception as e:
|
||
logger.error(f"청산 체크 오류 [{code}]: {e}")
|
||
await asyncio.sleep(0.6)
|
||
|
||
return exits
|
||
|
||
|
||
async def _scan_signals(
|
||
total_assets: float,
|
||
available_cash: float,
|
||
current_day_trade_amount: float,
|
||
) -> List[Dict[str, Any]]:
|
||
"""감시 종목에서 진입 신호 스캔"""
|
||
results = []
|
||
for code, name in list(_watchlist.items()):
|
||
if code in _positions:
|
||
continue
|
||
try:
|
||
candles_1m = await _fetch_candles(code)
|
||
if not candles_1m:
|
||
continue
|
||
candles_5m = aggregate_to_5min(candles_1m)
|
||
current_price = candles_1m[-1].close if candles_1m else 0
|
||
if current_price < settings.MIN_PRICE_KRW:
|
||
continue
|
||
|
||
vwap = calculate_vwap(candles_1m)
|
||
orb = _orb_cache.get(code)
|
||
|
||
signal: Optional[DayTradeSignal] = None
|
||
|
||
# ORB 우선
|
||
if orb:
|
||
signal = check_orb_signal(code, name, candles_1m, orb, current_price)
|
||
|
||
# VWAP 반등
|
||
if signal is None and vwap:
|
||
signal = check_vwap_bounce_signal(code, name, candles_5m, vwap, current_price)
|
||
|
||
# RSI+BB
|
||
if signal is None:
|
||
signal = check_rsi_bb_signal(code, name, candles_5m, current_price)
|
||
|
||
if signal:
|
||
position_size = calculate_day_trade_position_size(
|
||
total_assets, available_cash, current_day_trade_amount
|
||
)
|
||
if position_size < signal.entry_price:
|
||
continue # 최소 1주도 살 수 없으면 스킵
|
||
|
||
quantity = max(1, int(position_size // signal.entry_price))
|
||
results.append({"signal": signal, "quantity": quantity})
|
||
logger.info(
|
||
f"🎯 데이트레이딩 신호 [{code}] {signal.strategy}: "
|
||
f"{signal.reason}, 수량={quantity}"
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.warning(f"신호 스캔 오류 [{code}]: {e}")
|
||
await asyncio.sleep(0.6)
|
||
|
||
# confidence 내림차순 정렬
|
||
results.sort(key=lambda x: x["signal"].confidence, reverse=True)
|
||
return results[:MAX_POSITIONS - len(_positions)]
|
||
|
||
|
||
async def _execute_entry(signal: DayTradeSignal, quantity: int) -> Optional[Dict]:
|
||
"""진입 주문 실행 및 포지션 등록"""
|
||
global _trade_lock
|
||
async with _trade_lock:
|
||
if len(_positions) >= MAX_POSITIONS:
|
||
return None
|
||
if signal.stock_code in _positions:
|
||
return None
|
||
|
||
order_no = await _place_buy_order(
|
||
signal.stock_code, quantity, int(signal.entry_price)
|
||
)
|
||
if not order_no:
|
||
return None
|
||
|
||
_positions[signal.stock_code] = {
|
||
"stock_name": signal.stock_name,
|
||
"strategy": signal.strategy,
|
||
"entry_price": signal.entry_price,
|
||
"stop_loss": signal.stop_loss,
|
||
"target_price": signal.target_price,
|
||
"quantity": quantity,
|
||
"highest_price": signal.entry_price,
|
||
"entry_time": _kst_now().strftime("%H:%M:%S"),
|
||
"reason": signal.reason,
|
||
}
|
||
|
||
async with AsyncSessionLocal() as db:
|
||
await _record_trade(
|
||
db, signal.stock_code, signal.stock_name, "BUY",
|
||
signal.entry_price, quantity, signal.reason,
|
||
)
|
||
|
||
logger.info(
|
||
f"🛒 데이트레이딩 진입 [{signal.stock_code}] "
|
||
f"{signal.strategy}: {signal.entry_price:.0f}원 × {quantity}주"
|
||
)
|
||
await websocket_manager.broadcast(_dumps({
|
||
"type": "day_trade_entry",
|
||
"stock_code": signal.stock_code,
|
||
"strategy": signal.strategy,
|
||
"entry_price": signal.entry_price,
|
||
"quantity": quantity,
|
||
}))
|
||
return {
|
||
"stock_code": signal.stock_code,
|
||
"strategy": signal.strategy,
|
||
"entry_price": signal.entry_price,
|
||
"quantity": quantity,
|
||
"reason": signal.reason,
|
||
}
|
||
|
||
|
||
async def _execute_eod_flat() -> None:
|
||
"""EOD 전체 포지션 강제 청산"""
|
||
global _daily_pnl
|
||
for code, pos in list(_positions.items()):
|
||
try:
|
||
current_price = await _get_current_price(code)
|
||
ok = await _place_sell_order(code, pos["quantity"], price=0)
|
||
if ok:
|
||
pnl = (current_price - pos["entry_price"]) * pos["quantity"]
|
||
_daily_pnl += pnl
|
||
del _positions[code]
|
||
logger.info(f"🔔 EOD 강제 청산 [{code}]: PNL={pnl:+,.0f}원")
|
||
except Exception as e:
|
||
logger.error(f"EOD 청산 오류 [{code}]: {e}")
|
||
await asyncio.sleep(0.6)
|
||
|
||
|
||
# ── API 엔드포인트 ────────────────────────────────────────────────────────────
|
||
|
||
@router.get("/watchlist")
|
||
async def get_watchlist():
|
||
"""감시 종목 목록 조회"""
|
||
_reset_if_new_day()
|
||
return {
|
||
"watchlist": [
|
||
{"code": k, "name": v, "has_orb": k in _orb_cache}
|
||
for k, v in _watchlist.items()
|
||
],
|
||
"count": len(_watchlist),
|
||
}
|
||
|
||
|
||
@router.post("/watchlist")
|
||
async def set_watchlist(req: WatchlistRequest):
|
||
"""감시 종목 설정 (최대 20종목)
|
||
|
||
body: {"stocks": [{"code": "005930", "name": "삼성전자"}, ...]}
|
||
"""
|
||
global _watchlist
|
||
if len(req.stocks) > 20:
|
||
raise HTTPException(400, "감시 종목은 최대 20종목까지만 설정 가능합니다.")
|
||
|
||
_watchlist = {s["code"]: s.get("name", s["code"]) for s in req.stocks}
|
||
logger.info(f"📋 감시 종목 설정: {list(_watchlist.keys())}")
|
||
return {"status": "ok", "watchlist": list(_watchlist.keys())}
|
||
|
||
|
||
@router.get("/signals")
|
||
async def get_current_signals():
|
||
"""현재 진입 가능 신호 조회 (주문 미실행)"""
|
||
_reset_if_new_day()
|
||
if not is_day_trade_entry_window():
|
||
return {
|
||
"phase": "outside_window",
|
||
"message": "데이트레이딩 진입 시간이 아닙니다 (09:30~15:00).",
|
||
"signals": [],
|
||
}
|
||
|
||
portfolio = await _get_portfolio_summary()
|
||
total_assets = portfolio["total_assets"]
|
||
available_cash = portfolio["available_cash"]
|
||
current_day_trade_amount = sum(
|
||
p["entry_price"] * p["quantity"] for p in _positions.values()
|
||
)
|
||
|
||
signals = await _scan_signals(total_assets, available_cash, current_day_trade_amount)
|
||
return {
|
||
"phase": "active",
|
||
"signals": [
|
||
{
|
||
"stock_code": s["signal"].stock_code,
|
||
"stock_name": s["signal"].stock_name,
|
||
"strategy": s["signal"].strategy,
|
||
"entry_price": s["signal"].entry_price,
|
||
"stop_loss": s["signal"].stop_loss,
|
||
"target_price": s["signal"].target_price,
|
||
"reason": s["signal"].reason,
|
||
"confidence": s["signal"].confidence,
|
||
"quantity": s["quantity"],
|
||
}
|
||
for s in signals
|
||
],
|
||
"count": len(signals),
|
||
}
|
||
|
||
|
||
@router.post("/execute")
|
||
async def execute_day_trade(req: ExecuteRequest):
|
||
"""특정 종목 데이트레이딩 신호 스캔 후 진입"""
|
||
_reset_if_new_day()
|
||
code = req.stock_code
|
||
name = _watchlist.get(code, code)
|
||
|
||
if code in _positions:
|
||
raise HTTPException(400, f"{code}는 이미 포지션이 있습니다.")
|
||
if len(_positions) >= MAX_POSITIONS:
|
||
raise HTTPException(400, f"최대 포지션 수({MAX_POSITIONS}종목)에 도달했습니다.")
|
||
if not is_day_trade_entry_window():
|
||
raise HTTPException(400, "데이트레이딩 진입 시간이 아닙니다 (09:30~15:00).")
|
||
|
||
portfolio = await _get_portfolio_summary()
|
||
total_assets = portfolio["total_assets"]
|
||
available_cash = portfolio["available_cash"]
|
||
|
||
if is_daily_loss_exceeded(total_assets, _daily_pnl):
|
||
raise HTTPException(400, "일일 손실 한도(-3%)에 도달하여 신규 진입이 차단됩니다.")
|
||
|
||
candles_1m = await _fetch_candles(code)
|
||
candles_5m = aggregate_to_5min(candles_1m)
|
||
current_price = candles_1m[-1].close if candles_1m else 0
|
||
vwap = calculate_vwap(candles_1m)
|
||
orb = _orb_cache.get(code)
|
||
|
||
signal = None
|
||
if orb:
|
||
signal = check_orb_signal(code, name, candles_1m, orb, current_price)
|
||
if signal is None and vwap:
|
||
signal = check_vwap_bounce_signal(code, name, candles_5m, vwap, current_price)
|
||
if signal is None:
|
||
signal = check_rsi_bb_signal(code, name, candles_5m, current_price)
|
||
|
||
if not signal:
|
||
return {"status": "no_signal", "message": "현재 진입 조건을 충족하는 신호가 없습니다."}
|
||
|
||
current_day_trade_amount = sum(
|
||
p["entry_price"] * p["quantity"] for p in _positions.values()
|
||
)
|
||
position_size = calculate_day_trade_position_size(
|
||
total_assets, available_cash, current_day_trade_amount
|
||
)
|
||
quantity = max(1, int(position_size // signal.entry_price))
|
||
|
||
if req.dry_run:
|
||
return {
|
||
"status": "dry_run",
|
||
"signal": {
|
||
"strategy": signal.strategy,
|
||
"entry_price": signal.entry_price,
|
||
"stop_loss": signal.stop_loss,
|
||
"target_price": signal.target_price,
|
||
"reason": signal.reason,
|
||
"quantity": quantity,
|
||
},
|
||
}
|
||
|
||
entry = await _execute_entry(signal, quantity)
|
||
if not entry:
|
||
raise HTTPException(500, "주문 실행에 실패했습니다.")
|
||
return {"status": "ok", "entry": entry}
|
||
|
||
|
||
@router.get("/positions")
|
||
async def get_positions():
|
||
"""활성 데이트레이딩 포지션 조회"""
|
||
_reset_if_new_day()
|
||
result = []
|
||
for code, pos in _positions.items():
|
||
try:
|
||
current_price = await _get_current_price(code)
|
||
except Exception:
|
||
current_price = pos["entry_price"]
|
||
pnl = (current_price - pos["entry_price"]) * pos["quantity"]
|
||
pnl_pct = (current_price - pos["entry_price"]) / pos["entry_price"] * 100
|
||
result.append({
|
||
"stock_code": code,
|
||
"stock_name": pos["stock_name"],
|
||
"strategy": pos["strategy"],
|
||
"entry_price": pos["entry_price"],
|
||
"current_price": current_price,
|
||
"stop_loss": pos["stop_loss"],
|
||
"target_price": pos["target_price"],
|
||
"quantity": pos["quantity"],
|
||
"pnl": round(pnl, 0),
|
||
"pnl_pct": round(pnl_pct, 2),
|
||
"entry_time": pos["entry_time"],
|
||
})
|
||
return {
|
||
"positions": result,
|
||
"count": len(result),
|
||
"daily_pnl": round(_daily_pnl, 0),
|
||
"is_daily_loss_exceeded": is_daily_loss_exceeded(
|
||
sum(p["entry_price"] * p["quantity"] for p in _positions.values()),
|
||
_daily_pnl,
|
||
),
|
||
}
|
||
|
||
|
||
@router.post("/close-all")
|
||
async def close_all_positions():
|
||
"""전체 포지션 수동 강제 청산 (EOD 대비 수동 실행)"""
|
||
_reset_if_new_day()
|
||
await _execute_eod_flat()
|
||
return {
|
||
"status": "ok",
|
||
"message": "전체 데이트레이딩 포지션 청산 완료",
|
||
"daily_pnl": round(_daily_pnl, 0),
|
||
}
|
||
|
||
|
||
@router.post("/cycle")
|
||
async def manual_cycle():
|
||
"""1분 사이클 수동 실행 (테스트/디버그용)"""
|
||
_reset_if_new_day()
|
||
result = await run_day_trading_cycle()
|
||
return result
|
||
|
||
|
||
@router.get("/status")
|
||
async def get_status():
|
||
"""데이트레이딩 시스템 상태 요약"""
|
||
_reset_if_new_day()
|
||
return {
|
||
"watchlist_count": len(_watchlist),
|
||
"active_positions": len(_positions),
|
||
"orb_collected": len(_orb_cache),
|
||
"daily_pnl": round(_daily_pnl, 0),
|
||
"is_market_open": is_market_open(),
|
||
"is_opening_range": is_opening_range_period(),
|
||
"is_entry_window": is_day_trade_entry_window(),
|
||
"is_eod_flat": is_eod_flat_time(),
|
||
"today": _today_kst().isoformat(),
|
||
}
|