whdwo
1399 lines
54 KiB
Python
1399 lines
54 KiB
Python
"""
|
||
main.py
|
||
단타 자동매매 시스템 메인 진입점
|
||
기획서 v2.1 기준
|
||
|
||
실행:
|
||
python -m app.main (Docker 컨테이너)
|
||
python app/main.py (로컬 테스트)
|
||
|
||
환경변수:
|
||
KIS_MOCK=true → 모의투자 모드
|
||
DRY_RUN=true → 신호만 확인, 주문 전송 안 함
|
||
"""
|
||
|
||
import io
|
||
import json
|
||
import os
|
||
import sys
|
||
import asyncio
|
||
import logging
|
||
from datetime import datetime, time, timedelta
|
||
from pathlib import Path
|
||
|
||
# 한글 로그 깨짐 방지 — stdout을 UTF-8로 강제
|
||
if hasattr(sys.stdout, "reconfigure"):
|
||
sys.stdout.reconfigure(encoding="utf-8")
|
||
elif hasattr(sys.stdout, "buffer"):
|
||
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", line_buffering=True)
|
||
|
||
# .env 로드
|
||
def load_env():
|
||
env_path = Path(".env")
|
||
if not env_path.exists():
|
||
return
|
||
with open(env_path, encoding="utf-8") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if not line or line.startswith("#") or "=" not in line:
|
||
continue
|
||
k, _, v = line.partition("=")
|
||
k = k.strip()
|
||
v = v.strip()
|
||
# 인라인 주석 제거 (예: true # 모의투자 → true)
|
||
if " #" in v:
|
||
v = v[:v.index(" #")]
|
||
v = v.strip().strip('"').strip("'")
|
||
if k and v and k not in os.environ:
|
||
os.environ[k] = v
|
||
|
||
load_env()
|
||
|
||
# 프로젝트 루트를 sys.path에 추가 (로컬 실행 시 필요)
|
||
ROOT = Path(__file__).parent.parent
|
||
if str(ROOT) not in sys.path:
|
||
sys.path.insert(0, str(ROOT))
|
||
|
||
# 로깅 설정
|
||
logging.basicConfig(
|
||
level=getattr(logging, os.getenv("LOG_LEVEL", "INFO")),
|
||
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
||
handlers=[
|
||
logging.StreamHandler(sys.stdout),
|
||
logging.FileHandler("logs/stockbot.log", encoding="utf-8"),
|
||
]
|
||
)
|
||
logger = logging.getLogger(__name__)
|
||
|
||
from app.execution.kis_client import KISClient
|
||
from app.execution.order_executor import OrderExecutor
|
||
from app.strategy.volatility_breakout import VolatilityBreakout
|
||
from app.risk.manager import RiskManager
|
||
from app.monitor.notifier import (
|
||
notify_buy, notify_tp1, notify_tp2, notify_sl,
|
||
notify_force_exit, notify_risk, notify_daily_summary,
|
||
notify_error, notify_ai_result, notify_ai_blocked,
|
||
notify_ai_fallback, send
|
||
)
|
||
from app.db.models import init_db, get_conn
|
||
from app.ml.predictor import ScalpingModel
|
||
from app.config import (
|
||
MAX_UNIVERSE, FORCE_EXIT, MAX_POSITIONS,
|
||
MAX_HOLD_MIN, KOSPI_MIN_CHG, MAX_DAILY_ENTRIES,
|
||
MAX_HOURLY_STOP_LOSS, ENTRY_PAUSE_WINDOWS,
|
||
ENTRY_LIMIT_ENFORCE, SL_CASCADE_WINDOW_MIN,
|
||
SL_CASCADE_HALT_THRESHOLD
|
||
)
|
||
|
||
|
||
class SingleInstanceLock:
|
||
"""Process-wide lock so only one StockBot can run per workspace."""
|
||
|
||
def __init__(self, path: str | Path):
|
||
self.path = Path(path)
|
||
self._fh = None
|
||
self._mode = None
|
||
|
||
def acquire(self) -> bool:
|
||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||
self._fh = open(self.path, "a+", encoding="utf-8")
|
||
if os.name == "nt":
|
||
import msvcrt
|
||
|
||
self._fh.seek(0, os.SEEK_END)
|
||
if self._fh.tell() == 0:
|
||
self._fh.write("0")
|
||
self._fh.flush()
|
||
self._fh.seek(0)
|
||
try:
|
||
msvcrt.locking(self._fh.fileno(), msvcrt.LK_NBLCK, 1)
|
||
except OSError:
|
||
self._fh.close()
|
||
self._fh = None
|
||
return False
|
||
self._mode = "msvcrt"
|
||
else:
|
||
import fcntl
|
||
|
||
try:
|
||
fcntl.flock(self._fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||
except OSError:
|
||
self._fh.close()
|
||
self._fh = None
|
||
return False
|
||
self._mode = "fcntl"
|
||
|
||
self._fh.seek(0)
|
||
self._fh.truncate()
|
||
self._fh.write(str(os.getpid()))
|
||
self._fh.flush()
|
||
return True
|
||
|
||
def release(self):
|
||
if self._fh is None:
|
||
return
|
||
try:
|
||
if self._mode == "msvcrt":
|
||
import msvcrt
|
||
|
||
self._fh.seek(0)
|
||
msvcrt.locking(self._fh.fileno(), msvcrt.LK_UNLCK, 1)
|
||
elif self._mode == "fcntl":
|
||
import fcntl
|
||
|
||
fcntl.flock(self._fh.fileno(), fcntl.LOCK_UN)
|
||
finally:
|
||
self._fh.close()
|
||
self._fh = None
|
||
|
||
|
||
class StockBot:
|
||
def __init__(self):
|
||
self.kis = KISClient()
|
||
self.executor = OrderExecutor(self.kis)
|
||
self.strategy = VolatilityBreakout()
|
||
self.positions = {} # ticker → {name, entry, qty, tp1_done, entry_time}
|
||
self.universe = [] # 감시 종목 리스트
|
||
self.ticker_names = {} # ticker → 종목명 캐시
|
||
self.ticker_sectors = {} # ticker -> sector name cache
|
||
self.sl_tickers = set() # 당일 SL 당한 종목 — 재진입 차단
|
||
self.risk = None # RiskManager (잔고 확인 후 초기화)
|
||
self.running = False
|
||
self.scalping_model = ScalpingModel()
|
||
|
||
# 장중 컨텍스트 (midday_context.json 갱신 감지용)
|
||
self._midday_ctx_mtime : float = 0.0
|
||
self._midday_pos_mult : float = 1.0 # midday position_size_multiplier
|
||
self._midday_loaded : bool = False
|
||
self._last_diag : float = 0.0 # 신호 진단 로그 마지막 시각
|
||
self._daily_summary_dates = set()
|
||
|
||
mode = "모의투자" if self.kis.is_mock else "실거래"
|
||
dry = " [DRY_RUN]" if os.getenv("DRY_RUN","true")=="true" else ""
|
||
logger.info(f"StockBot 시작 [{mode}]{dry}")
|
||
|
||
# ─────────────────────────────────────────
|
||
# 장중 컨텍스트 감시
|
||
# ─────────────────────────────────────────
|
||
|
||
def _check_midday_context(self):
|
||
"""midday_context.json 갱신 감지 → 즉시 점심 세션 파라미터 반영"""
|
||
path = Path("data/midday_context.json")
|
||
if not path.exists():
|
||
return
|
||
try:
|
||
mtime = path.stat().st_mtime
|
||
except OSError:
|
||
return
|
||
if mtime <= self._midday_ctx_mtime:
|
||
return
|
||
try:
|
||
ctx = json.loads(path.read_text(encoding="utf-8"))
|
||
if ctx.get("date") != datetime.now().strftime("%Y-%m-%d"):
|
||
return
|
||
if not ctx.get("lunch_trade_allowed", True):
|
||
logger.warning("midday_context: 점심 세션 진입 중단 설정")
|
||
self._midday_pos_mult = float(ctx.get("position_size_multiplier", 1.0))
|
||
# 섹터·블랙리스트 업데이트
|
||
if "hot_sectors" in ctx:
|
||
self.strategy.context["hot_sectors"] = ctx["hot_sectors"]
|
||
if "avoid_sectors" in ctx:
|
||
self.strategy.context["avoid_sectors"] = ctx["avoid_sectors"]
|
||
for t in ctx.get("blacklist_tickers", []):
|
||
bl = self.strategy.context.setdefault("blacklist_tickers", [])
|
||
if t not in bl:
|
||
bl.append(t)
|
||
# lunch_trade_allowed=false이면 진입 자체를 막는 플래그 저장
|
||
self.strategy.context["lunch_trade_allowed"] = ctx.get("lunch_trade_allowed", True)
|
||
self._midday_ctx_mtime = mtime
|
||
self._midday_loaded = True
|
||
logger.info(
|
||
f"midday_context 로드 완료 — 점심 세션 시작 "
|
||
f"(포지션 배율: ×{self._midday_pos_mult}, "
|
||
f"진입허용: {ctx.get('lunch_trade_allowed', True)})"
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"midday_context 로드 실패: {e}")
|
||
|
||
def _today_entry_count(self) -> int:
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
with get_conn() as conn:
|
||
row = conn.execute(
|
||
"SELECT COUNT(DISTINCT ticker || '|' || entry_time) FROM trades WHERE date=? AND side='BUY'",
|
||
(today,),
|
||
).fetchone()
|
||
return int(row[0] or 0)
|
||
|
||
def _recent_stop_loss_count(self, minutes: int = 60) -> int:
|
||
cutoff = (datetime.now() - timedelta(minutes=minutes)).strftime("%H:%M:%S")
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
with get_conn() as conn:
|
||
row = conn.execute("""
|
||
SELECT COUNT(*) FROM trades
|
||
WHERE date=? AND exit_reason='SL' AND exit_time >= ?
|
||
""", (today, cutoff)).fetchone()
|
||
return int(row[0] or 0)
|
||
|
||
def _entry_gate_reason(self, now_str: str) -> str:
|
||
for start, end in ENTRY_PAUSE_WINDOWS:
|
||
if start <= now_str < end:
|
||
return f"entry pause window {start}-{end}"
|
||
|
||
entries = self._today_entry_count()
|
||
if ENTRY_LIMIT_ENFORCE and entries >= MAX_DAILY_ENTRIES:
|
||
return f"daily entry limit reached {entries}/{MAX_DAILY_ENTRIES}"
|
||
|
||
cascade_stop_losses = self._recent_stop_loss_count(SL_CASCADE_WINDOW_MIN)
|
||
if cascade_stop_losses >= SL_CASCADE_HALT_THRESHOLD:
|
||
return (
|
||
f"cascade halt: {cascade_stop_losses} stop losses in last "
|
||
f"{SL_CASCADE_WINDOW_MIN} minutes"
|
||
)
|
||
|
||
stop_losses = self._recent_stop_loss_count(60)
|
||
if ENTRY_LIMIT_ENFORCE and stop_losses >= MAX_HOURLY_STOP_LOSS:
|
||
return f"{stop_losses} stop losses in last 60 minutes"
|
||
|
||
return ""
|
||
|
||
def _entry_warning_reason(self) -> str:
|
||
warnings = []
|
||
entries = self._today_entry_count()
|
||
if entries >= MAX_DAILY_ENTRIES:
|
||
warnings.append(f"daily entries high {entries}/{MAX_DAILY_ENTRIES}")
|
||
|
||
stop_losses = self._recent_stop_loss_count(60)
|
||
if stop_losses >= MAX_HOURLY_STOP_LOSS:
|
||
warnings.append(f"{stop_losses} stop losses in last 60 minutes")
|
||
|
||
return "; ".join(warnings)
|
||
|
||
def _log_entry_acceptance(
|
||
self,
|
||
ticker: str,
|
||
name: str,
|
||
current: float,
|
||
target: float,
|
||
qty: int,
|
||
multiplier: float,
|
||
reason: str,
|
||
):
|
||
logger.info(
|
||
"ENTRY accepted %s(%s) current=%s target=%.0f qty=%s mult=%.2f reason=%s",
|
||
name,
|
||
ticker,
|
||
current,
|
||
target,
|
||
qty,
|
||
multiplier,
|
||
reason,
|
||
)
|
||
|
||
def _save_entry_snapshot(
|
||
self,
|
||
trade_id: int | None,
|
||
ticker: str,
|
||
name: str,
|
||
price_info: dict,
|
||
target: float,
|
||
entry_price: float,
|
||
stop_price: float,
|
||
qty: int,
|
||
signal: dict,
|
||
combined_mult: float,
|
||
model_scores: dict | None = None,
|
||
):
|
||
ctx = self.strategy.context
|
||
prev = self.strategy.prev_data.get(ticker, {})
|
||
now = datetime.now()
|
||
model_scores = model_scores or {}
|
||
with get_conn() as conn:
|
||
conn.execute("""
|
||
INSERT INTO entry_snapshots
|
||
(trade_id, date, ticker, name, entry_time, current_price,
|
||
entry_price, target_price, stop_price, today_open, prev_high,
|
||
prev_low, prev_amount, volume, change_pct, market_sentiment,
|
||
sentiment_score, risk_level, trade_allowed, hot_sectors,
|
||
avoid_sectors, boosted_tickers, blacklist_tickers, ai_boosted,
|
||
ai_win_score, ai_stop_loss_score, ai_model_version,
|
||
position_size_multiplier, combined_multiplier, entry_reason,
|
||
strategy, created_at)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
|
||
""", (
|
||
trade_id,
|
||
now.strftime("%Y-%m-%d"),
|
||
ticker,
|
||
name,
|
||
now.strftime("%H:%M:%S"),
|
||
price_info.get("current"),
|
||
entry_price,
|
||
target,
|
||
stop_price,
|
||
self.strategy.today_open.get(ticker),
|
||
prev.get("high"),
|
||
prev.get("low"),
|
||
prev.get("amount"),
|
||
price_info.get("volume"),
|
||
price_info.get("change_pct"),
|
||
ctx.get("market_sentiment"),
|
||
ctx.get("sentiment_score"),
|
||
ctx.get("risk_level"),
|
||
1 if ctx.get("trade_allowed", True) else 0,
|
||
json.dumps(ctx.get("hot_sectors", []), ensure_ascii=False),
|
||
json.dumps(ctx.get("avoid_sectors", []), ensure_ascii=False),
|
||
json.dumps(ctx.get("boosted_tickers", []), ensure_ascii=False),
|
||
json.dumps(ctx.get("blacklist_tickers", []), ensure_ascii=False),
|
||
1 if signal.get("boosted") else 0,
|
||
model_scores.get("label_win"),
|
||
model_scores.get("label_stop_loss"),
|
||
model_scores.get("model_version"),
|
||
signal.get("multiplier", 1.0),
|
||
combined_mult,
|
||
signal.get("reason", ""),
|
||
"VB",
|
||
now.isoformat(timespec="seconds"),
|
||
))
|
||
|
||
def _build_entry_feature_row(
|
||
self,
|
||
ticker: str,
|
||
price_info: dict,
|
||
target: float,
|
||
entry_price: float,
|
||
stop_price: float,
|
||
signal: dict,
|
||
combined_mult: float,
|
||
) -> dict:
|
||
ctx = self.strategy.context
|
||
prev = self.strategy.prev_data.get(ticker, {})
|
||
return {
|
||
"current_price": price_info.get("current"),
|
||
"entry_price": entry_price,
|
||
"target_price": target,
|
||
"stop_price": stop_price,
|
||
"today_open": self.strategy.today_open.get(ticker),
|
||
"prev_high": prev.get("high"),
|
||
"prev_low": prev.get("low"),
|
||
"prev_amount": prev.get("amount"),
|
||
"volume": price_info.get("volume"),
|
||
"change_pct": price_info.get("change_pct"),
|
||
"sentiment_score": ctx.get("sentiment_score"),
|
||
"trade_allowed": 1 if ctx.get("trade_allowed", True) else 0,
|
||
"ai_boosted": 1 if signal.get("boosted") else 0,
|
||
"position_size_multiplier": signal.get("multiplier", 1.0),
|
||
"combined_multiplier": combined_mult,
|
||
}
|
||
|
||
def _score_entry_candidate(
|
||
self,
|
||
ticker: str,
|
||
name: str,
|
||
price_info: dict,
|
||
target: float,
|
||
entry_price: float,
|
||
stop_price: float,
|
||
signal: dict,
|
||
combined_mult: float,
|
||
) -> dict:
|
||
if not self.scalping_model.available:
|
||
return {}
|
||
try:
|
||
row = self._build_entry_feature_row(
|
||
ticker=ticker,
|
||
price_info=price_info,
|
||
target=target,
|
||
entry_price=entry_price,
|
||
stop_price=stop_price,
|
||
signal=signal,
|
||
combined_mult=combined_mult,
|
||
)
|
||
scores = self.scalping_model.score(row)
|
||
if scores:
|
||
scores["model_version"] = self.scalping_model.version
|
||
logger.info(
|
||
"AI_SCORE %s(%s) win=%.3f stop_loss=%.3f",
|
||
name,
|
||
ticker,
|
||
scores.get("label_win", -1),
|
||
scores.get("label_stop_loss", -1),
|
||
)
|
||
return scores
|
||
except Exception as e:
|
||
logger.warning("AI score failed %s(%s): %s", name, ticker, e)
|
||
return {}
|
||
|
||
def _save_post_entry_snapshot(
|
||
self,
|
||
trade_id: int | None,
|
||
ticker: str,
|
||
elapsed_sec: int,
|
||
entry_price: float,
|
||
price_info: dict,
|
||
mfe_pct: float,
|
||
mae_pct: float,
|
||
position_open: bool,
|
||
):
|
||
if trade_id is None:
|
||
return
|
||
current = price_info.get("current")
|
||
if not entry_price or current is None:
|
||
return
|
||
now = datetime.now()
|
||
return_pct = (current - entry_price) / entry_price * 100
|
||
with get_conn() as conn:
|
||
conn.execute("""
|
||
INSERT OR REPLACE INTO post_entry_snapshots
|
||
(trade_id, date, ticker, sample_time, elapsed_sec, entry_price,
|
||
current_price, return_pct, mfe_pct, mae_pct, volume,
|
||
change_pct, position_open, created_at)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
|
||
""", (
|
||
trade_id,
|
||
now.strftime("%Y-%m-%d"),
|
||
ticker,
|
||
now.strftime("%H:%M:%S"),
|
||
elapsed_sec,
|
||
entry_price,
|
||
current,
|
||
return_pct,
|
||
mfe_pct,
|
||
mae_pct,
|
||
price_info.get("volume"),
|
||
price_info.get("change_pct"),
|
||
1 if position_open else 0,
|
||
now.isoformat(timespec="seconds"),
|
||
))
|
||
|
||
async def _track_post_entry(
|
||
self,
|
||
trade_id: int | None,
|
||
ticker: str,
|
||
name: str,
|
||
entry_price: float,
|
||
):
|
||
if trade_id is None:
|
||
return
|
||
|
||
checkpoints = (60, 180, 300, 600)
|
||
start_ts = datetime.now().timestamp()
|
||
high = entry_price
|
||
low = entry_price
|
||
|
||
for elapsed_sec in checkpoints:
|
||
delay = max(0, start_ts + elapsed_sec - datetime.now().timestamp())
|
||
await asyncio.sleep(delay)
|
||
try:
|
||
price_info = await self.kis.get_price(ticker)
|
||
current = price_info["current"]
|
||
high = max(high, current)
|
||
low = min(low, current)
|
||
mfe_pct = (high - entry_price) / entry_price * 100
|
||
mae_pct = (low - entry_price) / entry_price * 100
|
||
self._save_post_entry_snapshot(
|
||
trade_id=trade_id,
|
||
ticker=ticker,
|
||
elapsed_sec=elapsed_sec,
|
||
entry_price=entry_price,
|
||
price_info=price_info,
|
||
mfe_pct=mfe_pct,
|
||
mae_pct=mae_pct,
|
||
position_open=ticker in self.positions,
|
||
)
|
||
logger.info(
|
||
"POST_ENTRY %s(%s) t=%ss current=%s mfe=%.2f%% mae=%.2f%% open=%s",
|
||
name,
|
||
ticker,
|
||
elapsed_sec,
|
||
current,
|
||
mfe_pct,
|
||
mae_pct,
|
||
ticker in self.positions,
|
||
)
|
||
except Exception as e:
|
||
logger.warning("post-entry snapshot failed %s t=%ss: %s", ticker, elapsed_sec, e)
|
||
|
||
# ─────────────────────────────────────────
|
||
# 초기화
|
||
# ─────────────────────────────────────────
|
||
|
||
async def initialize(self):
|
||
"""시스템 초기화"""
|
||
init_db()
|
||
await self.kis.get_access_token()
|
||
|
||
# 잔고 조회 → RiskManager 초기화
|
||
balance = await self.kis.get_balance()
|
||
cash = balance["cash"]
|
||
self.risk = RiskManager(init_cash=cash)
|
||
logger.info(f"초기 예수금: {cash:,}원")
|
||
|
||
# DB에서 열린 포지션 복원 (재시작 시)
|
||
self._restore_positions_from_db()
|
||
# 당일 SL 종목 복원 (재시작 후에도 재진입 차단 유지)
|
||
self._restore_sl_tickers_from_db()
|
||
self._restore_reentry_controls_from_db()
|
||
await send(f"[시작] 단타봇 가동 | 예수금: {cash:,}원 | "
|
||
f"{'모의투자' if self.kis.is_mock else '실거래'}")
|
||
|
||
def _restore_positions_from_db(self):
|
||
"""재시작 시 DB positions 테이블에서 인메모리 복원"""
|
||
with get_conn() as conn:
|
||
rows = conn.execute("SELECT * FROM positions").fetchall()
|
||
for r in rows:
|
||
ticker, name, entry_time, entry_price, qty, tp1_done, target_price, stop_price, ai_boosted = r
|
||
self.positions[ticker] = {
|
||
"name" : name,
|
||
"entry" : entry_price,
|
||
"qty" : qty,
|
||
"tp1_done" : bool(tp1_done),
|
||
"entry_time": datetime.strptime(entry_time, "%H:%M:%S").replace(
|
||
year=datetime.now().year,
|
||
month=datetime.now().month,
|
||
day=datetime.now().day),
|
||
"sl_price" : stop_price,
|
||
"boosted" : bool(ai_boosted),
|
||
}
|
||
if self.positions:
|
||
logger.info(f"DB 포지션 복원: {list(self.positions.keys())}")
|
||
|
||
def _restore_sl_tickers_from_db(self):
|
||
"""재시작 시 당일 SL 종목 복원 — 재진입 차단 유지"""
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
with get_conn() as conn:
|
||
rows = conn.execute(
|
||
"SELECT DISTINCT ticker FROM trades WHERE date=? AND exit_reason='SL'",
|
||
(today,)
|
||
).fetchall()
|
||
for (ticker,) in rows:
|
||
self.sl_tickers.add(ticker)
|
||
if self.sl_tickers:
|
||
logger.info(f"당일 SL 종목 복원(재진입 차단): {self.sl_tickers}")
|
||
|
||
def _restore_reentry_controls_from_db(self):
|
||
"""재시작 시 오늘 청산 이력 기반 재진입 제한 상태를 복원한다."""
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
with get_conn() as conn:
|
||
rows = conn.execute("""
|
||
SELECT ticker, exit_time, exit_reason
|
||
FROM trades
|
||
WHERE date=?
|
||
AND exit_time IS NOT NULL
|
||
AND exit_reason IN ('TIME', 'FORCE', 'TP1', 'TP2')
|
||
ORDER BY exit_time
|
||
""", (today,)).fetchall()
|
||
|
||
restored = []
|
||
for ticker, exit_time, reason in rows:
|
||
if ticker in self.positions:
|
||
continue
|
||
try:
|
||
exit_dt = datetime.strptime(exit_time, "%H:%M:%S").replace(
|
||
year=datetime.now().year,
|
||
month=datetime.now().month,
|
||
day=datetime.now().day,
|
||
)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
self.strategy.mark_final_exit(ticker, reason, exit_dt)
|
||
restored.append(f"{ticker}:{reason}")
|
||
|
||
if restored:
|
||
logger.info("재진입 제한 상태 복원: %s", ", ".join(restored))
|
||
|
||
def _db_save_position(self, ticker: str, pos: dict, target_price: float):
|
||
with get_conn() as conn:
|
||
conn.execute("""
|
||
INSERT OR REPLACE INTO positions
|
||
(ticker, name, entry_time, entry_price, quantity,
|
||
tp1_done, target_price, stop_price, ai_boosted)
|
||
VALUES (?,?,?,?,?,?,?,?,?)
|
||
""", (
|
||
ticker, pos["name"],
|
||
pos["entry_time"].strftime("%H:%M:%S"),
|
||
pos["entry"], pos["qty"],
|
||
1 if pos.get("tp1_done") else 0,
|
||
target_price, pos["sl_price"],
|
||
1 if pos.get("boosted") else 0,
|
||
))
|
||
|
||
def _db_delete_position(self, ticker: str):
|
||
with get_conn() as conn:
|
||
conn.execute("DELETE FROM positions WHERE ticker=?", (ticker,))
|
||
|
||
def _db_has_open_position(self, ticker: str) -> bool:
|
||
with get_conn() as conn:
|
||
row = conn.execute(
|
||
"SELECT 1 FROM positions WHERE ticker=?",
|
||
(ticker,),
|
||
).fetchone()
|
||
return row is not None
|
||
|
||
def _db_reserve_position(
|
||
self,
|
||
ticker: str,
|
||
name: str,
|
||
entry_price: float,
|
||
qty: int,
|
||
target_price: float,
|
||
stop_price: float,
|
||
ai_boosted: bool,
|
||
) -> bool:
|
||
"""Atomically reserve a ticker before sending a buy order."""
|
||
with get_conn() as conn:
|
||
cur = conn.execute("""
|
||
INSERT OR IGNORE INTO positions
|
||
(ticker, name, entry_time, entry_price, quantity,
|
||
tp1_done, target_price, stop_price, ai_boosted)
|
||
VALUES (?,?,?,?,?,?,?,?,?)
|
||
""", (
|
||
ticker,
|
||
name,
|
||
datetime.now().strftime("%H:%M:%S"),
|
||
entry_price,
|
||
qty,
|
||
0,
|
||
target_price,
|
||
stop_price,
|
||
1 if ai_boosted else 0,
|
||
))
|
||
return cur.rowcount == 1
|
||
|
||
@staticmethod
|
||
def _is_rate_limit_error(err) -> bool:
|
||
msg = str(err)
|
||
return (
|
||
"초당" in msg
|
||
or "거래건수" in msg
|
||
or "rate limit" in msg.lower()
|
||
or "too many" in msg.lower()
|
||
)
|
||
|
||
@staticmethod
|
||
def _is_retryable_price_error(err) -> bool:
|
||
msg = str(err).lower()
|
||
return StockBot._is_rate_limit_error(err) or "타임아웃" in msg or "timeout" in msg
|
||
|
||
async def _get_price_with_retry(self, ticker: str, purpose: str, attempts: int = 4):
|
||
delays = (1.3, 2.8, 5.0, 8.0)
|
||
for attempt in range(1, attempts + 1):
|
||
try:
|
||
return await self.kis.get_price(ticker)
|
||
except Exception as e:
|
||
if attempt >= attempts or not self._is_retryable_price_error(e):
|
||
raise
|
||
wait = delays[min(attempt - 1, len(delays) - 1)]
|
||
logger.warning(
|
||
"%s price retry %s/%s for %s after transient KIS error: %s",
|
||
purpose,
|
||
attempt,
|
||
attempts,
|
||
ticker,
|
||
e,
|
||
)
|
||
await asyncio.sleep(wait)
|
||
|
||
async def _sell_with_retry(
|
||
self,
|
||
ticker: str,
|
||
name: str,
|
||
qty: int,
|
||
reason: str,
|
||
fill_price: float | None = None,
|
||
attempts: int = 3,
|
||
) -> dict:
|
||
delays = (1.2, 2.5, 5.0)
|
||
for attempt in range(1, attempts + 1):
|
||
result = await self.executor.sell(ticker, name, qty, reason, fill_price=fill_price)
|
||
if result.get("success"):
|
||
return result
|
||
error = result.get("error", "")
|
||
if attempt >= attempts or not self._is_rate_limit_error(error):
|
||
return result
|
||
wait = delays[min(attempt - 1, len(delays) - 1)]
|
||
logger.warning(
|
||
"SELL retry %s/%s for %s after rate limit: %s",
|
||
attempt,
|
||
attempts,
|
||
ticker,
|
||
error,
|
||
)
|
||
await asyncio.sleep(wait)
|
||
|
||
# ─────────────────────────────────────────
|
||
# 유니버스 갱신 (08:30)
|
||
# ─────────────────────────────────────────
|
||
|
||
# ETF/ETN/인버스/레버리지 종목 필터
|
||
_ETF_KEYWORDS = ('인버스', '레버리지', '선물', 'KODEX', 'TIGER', 'KBSTAR',
|
||
'HANARO', 'ARIRANG', 'KOSEF', 'SOL', 'ACE', 'RISE', 'PLUS')
|
||
_SECTOR_FIELDS = (
|
||
"sector",
|
||
"sector_name",
|
||
"bstp_kor_isnm",
|
||
"bstp_cls_name",
|
||
"bstp_name",
|
||
)
|
||
_AVOID_SECTOR_NAME_HINTS = (
|
||
("\uac74\uc124", ("\uac74\uc124", "\ub300\uc6b0\uac74\uc124", "\ud604\ub300\uac74\uc124", "GS\uac74\uc124", "DL\uc774\uc564\uc528", "HDC\ud604\ub300\uc0b0\uc5c5\uac1c\ubc1c")),
|
||
("\uc804\uae30\uac00\uc2a4", ("\ud55c\uad6d\uc804\ub825", "\ud55c\uc804", "\ud55c\uad6d\uac00\uc2a4", "\uc9c0\uc5ed\ub09c\ubc29", "\uc804\uae30", "\uac00\uc2a4")),
|
||
("\uc8fc\ub958", ("\ud558\uc774\ud2b8\uc9c4\ub85c", "\ub86f\ub370\uce60\uc131", "\ubb34\ud559", "\ubcf4\ud574\uc591\uc870", "\uad6d\uc21c\ub2f9", "\uc8fc\ub958")),
|
||
)
|
||
|
||
@staticmethod
|
||
def _is_etf(ticker: str, name: str) -> bool:
|
||
if ticker.startswith('Q') or len(ticker) != 6: # ETN or 비정상 코드
|
||
return True
|
||
return any(kw in name for kw in StockBot._ETF_KEYWORDS)
|
||
|
||
@classmethod
|
||
def _sector_from_rank_row(cls, row: dict) -> str:
|
||
for field in cls._SECTOR_FIELDS:
|
||
value = row.get(field)
|
||
if value:
|
||
return str(value).strip()
|
||
return ""
|
||
|
||
def _infer_avoid_sector_from_name(self, name: str) -> str:
|
||
compact_name = (name or "").replace(" ", "")
|
||
if not compact_name:
|
||
return ""
|
||
|
||
for sector in self.strategy.context.get("avoid_sectors", []):
|
||
sector_name = str(sector or "").strip()
|
||
if not sector_name:
|
||
continue
|
||
compact_sector = sector_name.replace(" ", "")
|
||
|
||
for key, hints in self._AVOID_SECTOR_NAME_HINTS:
|
||
if key in compact_sector and any(hint in compact_name for hint in hints):
|
||
return sector_name
|
||
|
||
generic_token = compact_sector.replace("\uc5c5", "")
|
||
if len(generic_token) >= 2 and generic_token in compact_name:
|
||
return sector_name
|
||
|
||
return ""
|
||
|
||
async def update_universe(self):
|
||
"""종목 풀 갱신 + 전일 데이터 수집"""
|
||
logger.info("유니버스 갱신 시작")
|
||
try:
|
||
# ETF 필터 후 MAX_UNIVERSE 확보 위해 여유분 요청
|
||
rank = await self.kis.get_volume_rank(top_n=MAX_UNIVERSE + 20)
|
||
|
||
# 종목명 캐시 갱신 + ETF 필터
|
||
for r in rank:
|
||
self.ticker_names[r["ticker"]] = r["name"]
|
||
sector = self._sector_from_rank_row(r)
|
||
if sector:
|
||
self.ticker_sectors[r["ticker"]] = sector
|
||
tickers = [r["ticker"] for r in rank
|
||
if not self._is_etf(r["ticker"], r["name"])]
|
||
|
||
ctx = self.strategy.context
|
||
blacklist = ctx.get("blacklist_tickers", [])
|
||
tickers = [t for t in tickers if t not in blacklist]
|
||
|
||
boosted = ctx.get("boosted_tickers", [])
|
||
tickers = (
|
||
[t for t in boosted if t in tickers] +
|
||
[t for t in tickers if t not in boosted]
|
||
)[:MAX_UNIVERSE]
|
||
|
||
self.universe = tickers
|
||
logger.info(f"유니버스: {len(tickers)}종목 (ETF 제외)")
|
||
|
||
# 최근 7일 범위 조회 → 공휴일·대체공휴일 자동 처리
|
||
from datetime import timedelta
|
||
today = datetime.now()
|
||
start_dt = (today - timedelta(days=7)).strftime("%Y%m%d")
|
||
end_dt = (today - timedelta(days=1)).strftime("%Y%m%d")
|
||
|
||
for ticker in self.universe:
|
||
# 이미 전일 데이터 있으면 skip
|
||
if self.strategy.has_prev_data(ticker):
|
||
continue
|
||
try:
|
||
ohlcv = await self.kis.get_ohlcv_daily(
|
||
ticker,
|
||
start=start_dt,
|
||
end=end_dt,
|
||
)
|
||
if ohlcv:
|
||
prev = ohlcv[-1] # 가장 최근 거래일
|
||
self.strategy.set_prev_data(
|
||
ticker,
|
||
high = prev["high"],
|
||
low = prev["low"],
|
||
amount= prev.get("amount",
|
||
prev.get("volume", 0) * prev.get("close", 0))
|
||
)
|
||
else:
|
||
logger.warning(f"전일 OHLCV 없음 {ticker} ({start_dt}~{end_dt})")
|
||
except Exception as e:
|
||
logger.warning(f"전일 데이터 실패 {ticker}: {e}")
|
||
await asyncio.sleep(1.1) # 초당 2.5건으로 제한
|
||
|
||
except Exception as e:
|
||
logger.error(f"유니버스 갱신 실패: {e}")
|
||
|
||
# ─────────────────────────────────────────
|
||
# 시가 수집 + 목표가 계산 (08:50)
|
||
# ─────────────────────────────────────────
|
||
|
||
async def calc_targets(self):
|
||
"""당일 시가 기반 목표가 계산"""
|
||
logger.info("목표가 계산 시작")
|
||
self.strategy.targets.clear()
|
||
self.strategy.today_open.clear()
|
||
now_str = datetime.now().strftime("%H:%M")
|
||
valid_count = 0
|
||
for ticker in self.universe:
|
||
try:
|
||
price_info = await self._get_price_with_retry(ticker, "TARGET")
|
||
open_price = price_info.get("open") or 0
|
||
name = self.ticker_names.get(ticker, ticker)
|
||
if open_price <= 0:
|
||
current = price_info.get("current") or 0
|
||
if now_str >= "09:00" and current > 0:
|
||
open_price = current
|
||
logger.warning(f"시가 0 감지({name}/{ticker}) → 현재가 {current:,}를 임시 시가로 사용")
|
||
else:
|
||
logger.info(f"목표가 제외({name}/{ticker}): 시가 미확정(open=0)")
|
||
await asyncio.sleep(1.1)
|
||
continue
|
||
self.strategy.set_today_open(ticker, open_price)
|
||
target = self.strategy.get_target(ticker)
|
||
if target > 0:
|
||
logger.info(f"목표가: {name}({ticker}) {target:,.0f}원 [시가 {open_price:,}]")
|
||
valid_count += 1
|
||
await asyncio.sleep(1.1)
|
||
except Exception as e:
|
||
logger.warning(f"시가 수집 실패 {ticker}: {e}")
|
||
logger.info(f"목표가 계산 완료: {valid_count}/{len(self.universe)}종목 유효")
|
||
|
||
# ─────────────────────────────────────────
|
||
# 메인 매매 루프 (09:00~14:50)
|
||
# ─────────────────────────────────────────
|
||
|
||
async def trading_loop(self):
|
||
"""1초 단위 메인 루프"""
|
||
logger.info("매매 루프 시작")
|
||
self.running = True
|
||
_consecutive_errors = 0
|
||
|
||
while self.running:
|
||
try:
|
||
now = datetime.now()
|
||
now_str = now.strftime("%H:%M")
|
||
|
||
# 14:50 강제 청산
|
||
if now_str >= FORCE_EXIT:
|
||
await self.force_exit_all()
|
||
self.running = False
|
||
break
|
||
|
||
# 14:00 이후 신규 진입 중단 (청산은 계속)
|
||
if now_str > "14:00":
|
||
await self.check_exits()
|
||
await asyncio.sleep(1)
|
||
continue
|
||
|
||
# 09:00 이전 대기
|
||
if now_str < "09:00":
|
||
await asyncio.sleep(1)
|
||
continue
|
||
|
||
# midday_context.json 갱신 감지 (점심 세션 이벤트 기반 시작)
|
||
self._check_midday_context()
|
||
|
||
# 리스크 체크 (L2/L4/L5 하드 중단)
|
||
if not self.risk.can_trade():
|
||
await asyncio.sleep(5)
|
||
continue
|
||
|
||
# 보유 포지션 청산 체크
|
||
await self.check_exits()
|
||
|
||
# 신규 진입 체크
|
||
if self.risk.can_add_position(len(self.positions)):
|
||
await self.check_entries()
|
||
|
||
_consecutive_errors = 0
|
||
await asyncio.sleep(1)
|
||
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception as e:
|
||
_consecutive_errors += 1
|
||
logger.error(
|
||
f"매매 루프 오류 (연속 {_consecutive_errors}회): "
|
||
f"{type(e).__name__}: {e}",
|
||
exc_info=True,
|
||
)
|
||
await notify_error(f"매매 루프 오류 {_consecutive_errors}회: {type(e).__name__}: {e}")
|
||
# 연속 10회 오류 시 루프 종료 (무한 오류 방지)
|
||
if _consecutive_errors >= 10:
|
||
logger.critical("연속 오류 10회 — 매매 루프 강제 종료")
|
||
await notify_error("연속 오류 10회 — 매매 루프 강제 종료")
|
||
self.running = False
|
||
break
|
||
await asyncio.sleep(5)
|
||
|
||
# ─────────────────────────────────────────
|
||
# 진입 체크
|
||
# ─────────────────────────────────────────
|
||
|
||
async def check_entries(self):
|
||
"""유니버스 전체 진입 신호 확인"""
|
||
now_str = datetime.now().strftime("%H:%M")
|
||
# 14:00 이후 진입 차단
|
||
if now_str > "14:00":
|
||
return
|
||
# midday_context 로드 전(11:20~) 11:00 이후 신규 진입 일시 중단
|
||
# — midday_context.json이 생성되면 _check_midday_context()가 자동 해제
|
||
if now_str >= "11:00" and not self._midday_loaded:
|
||
return
|
||
# lunch_trade_allowed=false이면 점심 세션 진입 차단
|
||
if self._midday_loaded and not self.strategy.context.get("lunch_trade_allowed", True):
|
||
return
|
||
gate_reason = self._entry_gate_reason(now_str)
|
||
if gate_reason:
|
||
logger.info("ENTRY blocked: %s", gate_reason)
|
||
return
|
||
warning_reason = self._entry_warning_reason()
|
||
if warning_reason:
|
||
logger.warning("ENTRY warning: %s", warning_reason)
|
||
|
||
_now_ts = datetime.now().timestamp()
|
||
_do_diag = (_now_ts - self._last_diag) >= 300 # 5분마다 진단 로그
|
||
_diag = []
|
||
|
||
for ticker in self.universe:
|
||
if ticker in self.positions:
|
||
if _do_diag:
|
||
_diag.append(f"{ticker}:보유중")
|
||
continue
|
||
if self._db_has_open_position(ticker):
|
||
if _do_diag:
|
||
_diag.append(f"{ticker}:DB보유중")
|
||
continue
|
||
if ticker in self.sl_tickers:
|
||
if _do_diag:
|
||
_diag.append(f"{ticker}:SL차단")
|
||
continue # 당일 SL 종목 재진입 차단
|
||
if len(self.positions) >= MAX_POSITIONS:
|
||
break
|
||
# 목표가 미계산 종목 스킵 (불필요한 API 호출 방지)
|
||
target = self.strategy.get_target(ticker)
|
||
if target <= 0:
|
||
if _do_diag:
|
||
_diag.append(f"{ticker}:목표가없음")
|
||
continue
|
||
|
||
try:
|
||
reserved = False
|
||
price_info = await self._get_price_with_retry(ticker, "ENTRY")
|
||
current = price_info["current"]
|
||
name = self.ticker_names.get(ticker, ticker)
|
||
sector = (
|
||
self.ticker_sectors.get(ticker, "")
|
||
or self._infer_avoid_sector_from_name(name)
|
||
)
|
||
|
||
signal = self.strategy.check_entry(
|
||
ticker=ticker,
|
||
name=name,
|
||
current_price=current,
|
||
sector=sector,
|
||
)
|
||
|
||
if not signal["signal"]:
|
||
if _do_diag:
|
||
_diag.append(
|
||
f"{name}({ticker}):{signal['reason']}"
|
||
f"[현재가{current:,}/목표가{target:,.0f}]"
|
||
)
|
||
continue
|
||
|
||
balance = await self.kis.get_balance()
|
||
cash = balance["cash"]
|
||
# AI 신호 배율 × B안(연속 손절) 배율 × midday 배율
|
||
combined_mult = (
|
||
signal.get("multiplier", 1.0)
|
||
* self.risk.get_consec_multiplier()
|
||
* self._midday_pos_mult
|
||
)
|
||
invest = self.risk.get_pos_size(cash, combined_mult)
|
||
qty = max(1, int(invest // current))
|
||
reserve_stop = current * (1 - self.risk.get_sl_pct())
|
||
if not self._db_reserve_position(
|
||
ticker=ticker,
|
||
name=name,
|
||
entry_price=current,
|
||
qty=qty,
|
||
target_price=target,
|
||
stop_price=reserve_stop,
|
||
ai_boosted=signal.get("boosted", False),
|
||
):
|
||
logger.info("ENTRY blocked: DB active position exists for %s", ticker)
|
||
continue
|
||
reserved = True
|
||
self._log_entry_acceptance(
|
||
ticker=ticker,
|
||
name=name,
|
||
current=current,
|
||
target=target,
|
||
qty=qty,
|
||
multiplier=combined_mult,
|
||
reason=signal["reason"],
|
||
)
|
||
|
||
result = await self.executor.buy(
|
||
ticker=ticker, name=name,
|
||
qty=qty, reason=signal["reason"],
|
||
ai_boosted=signal.get("boosted", False),
|
||
fill_price=current,
|
||
)
|
||
|
||
if result["success"]:
|
||
reserved = False
|
||
entry_price = result["price"] or current
|
||
sl_price = entry_price * (1 - self.risk.get_sl_pct())
|
||
model_scores = self._score_entry_candidate(
|
||
ticker=ticker,
|
||
name=name,
|
||
price_info=price_info,
|
||
target=target,
|
||
entry_price=entry_price,
|
||
stop_price=sl_price,
|
||
signal=signal,
|
||
combined_mult=combined_mult,
|
||
)
|
||
self._save_entry_snapshot(
|
||
trade_id=result.get("trade_id"),
|
||
ticker=ticker,
|
||
name=name,
|
||
price_info=price_info,
|
||
target=target,
|
||
entry_price=entry_price,
|
||
stop_price=sl_price,
|
||
qty=qty,
|
||
signal=signal,
|
||
combined_mult=combined_mult,
|
||
model_scores=model_scores,
|
||
)
|
||
asyncio.create_task(
|
||
self._track_post_entry(
|
||
trade_id=result.get("trade_id"),
|
||
ticker=ticker,
|
||
name=name,
|
||
entry_price=entry_price,
|
||
)
|
||
)
|
||
|
||
pos = {
|
||
"name" : name,
|
||
"entry" : entry_price,
|
||
"qty" : qty,
|
||
"tp1_done" : False,
|
||
"entry_time": datetime.now(),
|
||
"sl_price" : sl_price,
|
||
"boosted" : signal.get("boosted", False),
|
||
}
|
||
self.positions[ticker] = pos
|
||
self._db_save_position(
|
||
ticker, pos,
|
||
target_price=self.strategy.get_target(ticker),
|
||
)
|
||
|
||
await notify_buy(
|
||
ticker=ticker, name=name,
|
||
price=entry_price,
|
||
target=int(entry_price * 1.03),
|
||
stop=int(sl_price),
|
||
boosted=signal.get("boosted", False),
|
||
)
|
||
|
||
else:
|
||
if reserved:
|
||
self._db_delete_position(ticker)
|
||
reserved = False
|
||
|
||
except Exception as e:
|
||
if "reserved" in locals() and reserved:
|
||
self._db_delete_position(ticker)
|
||
logger.error(f"진입 체크 오류 {ticker}: {type(e).__name__}: {e}")
|
||
|
||
if _do_diag:
|
||
self._last_diag = _now_ts
|
||
if _diag:
|
||
logger.info(f"[신호진단] {' | '.join(_diag)}")
|
||
else:
|
||
logger.info("[신호진단] 전 종목 신호 없음 (유니버스 비어있거나 모두 필터됨)")
|
||
|
||
# ─────────────────────────────────────────
|
||
# 청산 체크
|
||
# ─────────────────────────────────────────
|
||
|
||
async def check_exits(self):
|
||
"""보유 포지션 청산 신호 확인"""
|
||
for ticker, pos in list(self.positions.items()):
|
||
try:
|
||
price_info = await self._get_price_with_retry(ticker, "EXIT")
|
||
current = price_info["current"]
|
||
name = pos["name"]
|
||
|
||
# 시간 청산: MAX_HOLD_MIN 초과
|
||
hold_min = (datetime.now() - pos["entry_time"]).seconds / 60
|
||
if hold_min >= MAX_HOLD_MIN:
|
||
await self._do_exit(ticker, pos, current, qty=pos["qty"], reason="TIME")
|
||
continue
|
||
|
||
# 전략 청산 신호
|
||
signal = self.strategy.check_exit(
|
||
ticker=ticker,
|
||
entry_price=pos["entry"],
|
||
current_price=current,
|
||
qty=pos["qty"],
|
||
tp1_done=pos["tp1_done"],
|
||
sl_pct=self.risk.get_sl_pct(),
|
||
)
|
||
|
||
if signal["signal"]:
|
||
await self._do_exit(
|
||
ticker, pos, current,
|
||
qty=signal["qty"],
|
||
reason=signal["reason"],
|
||
)
|
||
|
||
await asyncio.sleep(1.1)
|
||
|
||
except Exception as e:
|
||
logger.error(f"청산 체크 오류 {ticker}: {type(e).__name__}: {e}")
|
||
await asyncio.sleep(5)
|
||
|
||
async def _do_exit(self, ticker: str, pos: dict,
|
||
current: float, qty: int, reason: str):
|
||
"""실제 청산 실행"""
|
||
name = pos["name"]
|
||
result = await self._sell_with_retry(ticker, name, qty, reason, fill_price=current)
|
||
|
||
if not result["success"]:
|
||
return
|
||
|
||
exit_price = result["price"] or current
|
||
pnl = (exit_price - pos["entry"]) * qty
|
||
pnl_pct = (exit_price - pos["entry"]) / pos["entry"] * 100
|
||
|
||
self.risk.record_trade(pnl)
|
||
|
||
# B안: 연속 손절 2회·3회 도달 시 Discord 알림
|
||
if reason == "SL":
|
||
consec = self.risk.consec_loss
|
||
if consec in (2, 3):
|
||
mult = self.risk.get_consec_multiplier()
|
||
await notify_risk(
|
||
"L3-B",
|
||
f"{consec}연속 손절 — 포지션 크기 {int(mult * 100)}%로 축소"
|
||
)
|
||
|
||
if reason == "TP1":
|
||
pos["tp1_done"] = True
|
||
pos["qty"] -= qty
|
||
if pos["qty"] <= 0:
|
||
del self.positions[ticker]
|
||
self._db_delete_position(ticker)
|
||
self.strategy.mark_final_exit(ticker, reason)
|
||
else:
|
||
self._db_save_position(ticker, pos, self.strategy.get_target(ticker))
|
||
await notify_tp1(ticker, name, pnl_pct)
|
||
|
||
elif reason in ("TP2", "SL", "TIME", "FORCE"):
|
||
del self.positions[ticker]
|
||
self._db_delete_position(ticker)
|
||
self.strategy.mark_final_exit(ticker, reason)
|
||
if reason == "TP2":
|
||
await notify_tp2(ticker, name, pnl_pct)
|
||
elif reason == "SL":
|
||
self.sl_tickers.add(ticker) # 당일 재진입 차단
|
||
await notify_sl(ticker, name, pnl_pct)
|
||
|
||
# L2/L3 체크 후 디스코드 경고
|
||
if not self.risk.can_trade():
|
||
await notify_risk(
|
||
self.risk.stop_reason.split(":")[0],
|
||
self.risk.stop_reason
|
||
)
|
||
|
||
# ─────────────────────────────────────────
|
||
# 강제 청산 (14:50)
|
||
# ─────────────────────────────────────────
|
||
|
||
async def force_exit_all(self):
|
||
"""14:50 전량 강제 청산"""
|
||
logger.info("14:50 강제 청산 시작")
|
||
for ticker, pos in list(self.positions.items()):
|
||
try:
|
||
price_info = await self._get_price_with_retry(ticker, "FORCE_EXIT")
|
||
current = price_info["current"]
|
||
await self._do_exit(
|
||
ticker, pos, current,
|
||
qty=pos["qty"], reason="FORCE"
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"강제 청산 실패 {ticker}: {e}")
|
||
await notify_force_exit()
|
||
logger.info("강제 청산 완료")
|
||
|
||
# ─────────────────────────────────────────
|
||
# 일일 결산 (15:10)
|
||
# ─────────────────────────────────────────
|
||
|
||
async def daily_summary(self):
|
||
"""당일 결산 로그 및 디스코드 알림 + DB 저장"""
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
if today in self._daily_summary_dates:
|
||
logger.info("결산 이미 처리됨: %s", today)
|
||
return
|
||
|
||
with get_conn() as conn:
|
||
rows = conn.execute("""
|
||
SELECT pnl, fee, exit_reason FROM trades
|
||
WHERE date=? AND exit_time IS NOT NULL
|
||
""", (today,)).fetchall()
|
||
|
||
pnls = [r[0] for r in rows if r[0] is not None]
|
||
fees = [r[1] for r in rows if r[1] is not None]
|
||
total = len(pnls)
|
||
wins = sum(1 for p in pnls if p > 0)
|
||
losses = total - wins
|
||
gross_pnl = sum(p for p in pnls if p > 0) - abs(sum(p for p in pnls if p < 0))
|
||
total_fee = sum(fees)
|
||
net = sum(pnls)
|
||
mdd = min(self.risk.daily_pnl / self.risk.init_cash * 100, 0.0)
|
||
stopped = 0 if self.risk.can_trade() else 1
|
||
exit_counts = {}
|
||
for _, _, reason in rows:
|
||
key = reason or "UNKNOWN"
|
||
exit_counts[key] = exit_counts.get(key, 0) + 1
|
||
|
||
# daily_summary 테이블 저장
|
||
with get_conn() as conn:
|
||
conn.execute("""
|
||
INSERT OR REPLACE INTO daily_summary
|
||
(date, total_trades, win_trades, lose_trades,
|
||
gross_pnl, total_fee, net_pnl, max_drawdown, trading_stopped)
|
||
VALUES (?,?,?,?,?,?,?,?,?)
|
||
""", (today, total, wins, losses, gross_pnl, total_fee, net, mdd, stopped))
|
||
|
||
self._daily_summary_dates.add(today)
|
||
try:
|
||
await notify_daily_summary(total, wins, losses, net)
|
||
except Exception as e:
|
||
logger.error("결산 Discord 요약 전송 실패: %s", e)
|
||
if exit_counts:
|
||
dist = " / ".join(f"{k}:{v}" for k, v in sorted(exit_counts.items()))
|
||
logger.info("Exit distribution: %s", dist)
|
||
try:
|
||
await send(f"[청산분포] {dist}")
|
||
except Exception as e:
|
||
logger.error("청산분포 Discord 전송 실패: %s", e)
|
||
self.risk.reset_daily()
|
||
logger.info(f"결산: {total}회 / 승{wins} 패{losses} / {net:+,.0f}원 (fee {total_fee:,.0f}원)")
|
||
|
||
|
||
# ─────────────────────────────────────────
|
||
# 스케줄러
|
||
# ─────────────────────────────────────────
|
||
|
||
async def run():
|
||
bot = StockBot()
|
||
await bot.initialize()
|
||
|
||
now = datetime.now().strftime("%H:%M")
|
||
if "09:00" <= now < "15:00":
|
||
logger.info("장 중 재시작 감지 → AI 컨텍스트 로드 + 유니버스/목표가 즉시 계산")
|
||
ctx = bot.strategy.load_ai_context()
|
||
await notify_ai_result(
|
||
ctx["market_sentiment"],
|
||
ctx["sentiment_score"],
|
||
ctx.get("hot_sectors", []),
|
||
ctx.get("avoid_sectors", []),
|
||
ctx.get("reason", ""),
|
||
)
|
||
bot.risk.set_risk_level(ctx.get("risk_level", "보통"))
|
||
await bot.update_universe()
|
||
await bot.calc_targets()
|
||
await bot.trading_loop() # 바로 매매루프 진입
|
||
# 매매루프 종료 후 15:10 결산까지 대기
|
||
while True:
|
||
now = datetime.now().strftime("%H:%M")
|
||
if now == "15:10":
|
||
await bot.daily_summary()
|
||
return
|
||
if now > "15:10":
|
||
return
|
||
await asyncio.sleep(30)
|
||
|
||
# 08:30 이후~09:00 이전 시작 시 컨텍스트·유니버스 즉시 로드
|
||
if "08:30" <= now < "09:00":
|
||
logger.info("장 전 재시작 감지(08:30~09:00) → AI 컨텍스트 로드 + 유니버스 즉시 갱신")
|
||
ctx = bot.strategy.load_ai_context()
|
||
bot.risk.set_risk_level(ctx.get("risk_level", "보통"))
|
||
await bot.update_universe()
|
||
if now >= "08:50":
|
||
logger.info("08:50 이후 장 전 재시작 감지 → 목표가 즉시 계산")
|
||
await bot.calc_targets()
|
||
|
||
while True:
|
||
now = datetime.now().strftime("%H:%M")
|
||
|
||
try:
|
||
# 08:30 AI 컨텍스트 로드 + 유니버스 갱신
|
||
# (claude_morning이 08:15에 시작해 08:30 전에 daily_context.json 생성)
|
||
if now == "08:30":
|
||
ctx = bot.strategy.load_ai_context()
|
||
await notify_ai_result(
|
||
ctx["market_sentiment"],
|
||
ctx["sentiment_score"],
|
||
ctx.get("hot_sectors", []),
|
||
ctx.get("avoid_sectors", []),
|
||
ctx.get("reason", ""),
|
||
)
|
||
bot.risk.set_risk_level(ctx.get("risk_level", "보통"))
|
||
await bot.update_universe()
|
||
|
||
# 08:50 목표가 계산
|
||
elif now == "08:50":
|
||
await bot.calc_targets()
|
||
|
||
# 09:00 매매 루프 시작
|
||
elif now == "09:00":
|
||
await bot.calc_targets()
|
||
await bot.trading_loop()
|
||
|
||
# 15:10 결산
|
||
elif now == "15:10":
|
||
await bot.daily_summary()
|
||
|
||
except Exception as e:
|
||
logger.error(f"스케줄러 루프 오류 ({now}): {e}", exc_info=True)
|
||
|
||
await asyncio.sleep(30)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
os.makedirs("logs", exist_ok=True)
|
||
os.makedirs("data", exist_ok=True)
|
||
instance_lock = SingleInstanceLock("logs/stockbot.lock")
|
||
if not instance_lock.acquire():
|
||
logger.error("StockBot already running; duplicate process exiting")
|
||
sys.exit(2)
|
||
logger.info("=" * 50)
|
||
logger.info("단타 자동매매 시스템 시작")
|
||
logger.info(f"모드: {'모의투자' if os.getenv('KIS_MOCK','true')=='true' else '실거래'}")
|
||
logger.info(f"DRY_RUN: {os.getenv('DRY_RUN','true')}")
|
||
logger.info("=" * 50)
|
||
asyncio.run(run())
|