오렌지파이5에서 **보유 종목(주식/ETF)**을 파일로 관리하고,

• 수익 최고점(peak) 대비 -X% 트레일링
• 매수가 대비 -Y% 손절
• 손절/트레일링 근접 경고
• 1시간 요약 / 15:35 요약 / 16:00 리포트
• 리스크 HIGH일 때만 30분→10분 자동 단축
• 다음날 자동 재감시(active=1 복구)
  를 시놀로지 Chat 웹훅으로 자동 알림해주는 파이썬 봇입니다.

※ 가격은 yfinance 기반이라 “지연 Close”로 동작합니다(실시간 아님).
실시간으로 바꾸려면 추후 키움 API 등 연동이 필요합니다.

1) 동작 개념(핵심 로직)

✅ 트레일링(수익 구간)

• 내 매수금액(평가금액 기준) 대비 최고점(peak)을 계속 갱신
• 기준선 = peak × (1 - trailing%)
• 현재가가 기준선 이하로 내려오면 매도 알림

✅ 가변 트레일링(수익이 커질수록 더 타이트)

예: base trailing이 10%인 종목이라면

• 수익 0~20%: 10%
• 수익 20~50%: 7% (10%×0.7)
• 수익 50% 이상: 5% (10%×0.5)

✅ 손절(매수가 기준)

• 손절선 = 매수금액 × (1 - stop_loss%)
• 현재가가 손절선 이하로 내려오면 손절 알림

✅ 근접 경고

• 트레일링 기준선까지 2% 이내로 접근하면 “근접 경고”
• 손절선까지 2% 이내로 접근하면 “손절 근접 경고”

✅ 리스크 레벨(LOW / MEDIUM / HIGH)

• Trigger(기준선 이하) / Near(근접) 종목 수
• 위험 노출 비중(Trigger+Near 종목 평가금액 합 / 전체 평가금액)
  을 기준으로 LOW/MEDIUM/HIGH 표시
  → 장중 요약, 16:00 리포트에 같이 출력

✅ 실행 주기 자동 변경(장중만)

• 평소 장중: 30분
• 리스크 HIGH: 10분(더 촘촘히 감시)
• 장외: 120분(불필요 호출 절약)

✅ 다음날 자동 재활성화

• 매도/손절 알림 후 active=0으로 자동 비활성화(옵션)
• 다음날 09:01에 자동으로 active=1로 복구(옵션)

2) 폴더 구성(그대로 만들기)

아래 3개 파일만 있으면 됩니다.

jusik_top10/
 ├─ main.py
 ├─ config.json
 ├─ positions.csv
 └─ state.json   (없으면 자동 생성됨, 처음엔 {} 권장)

3) 설치(오렌지파이5)

sudo apt update
sudo apt install -y python3-pip
python3 -m pip install --user requests yfinance

4) config.json (복붙용)

synology_chat_webhook_url만 본인 값으로 바꿔주세요.

{
  "synology_chat_webhook_url": "여기에_시놀로지챗_웹훅_URL_붙여넣기",  "default_trailing_pct": 0.10,
  "default_stop_loss_pct": 0.08,  "market_open": "09:00",
  "market_close": "15:30",  "startup_notify_enabled": true,  "near_alert_enabled": true,
  "near_alert_distance_pct": 2.0,
  "near_alert_cooldown_minutes": 60,  "stoploss_near_enabled": true,
  "stoploss_near_distance_pct": 2.0,
  "stoploss_near_cooldown_minutes": 180,  "auto_disable_on_alert": true,  "hourly_summary_enabled": true,
  "hourly_summary_interval_minutes": 60,  "daily_summary_time": "15:35",  "after_close_summary_enabled": true,
  "after_close_summary_time": "16:00",
  "after_close_include_inactive": false,  "adaptive_trailing_enabled": true,
  "adaptive_trailing_factors": [
    { "min_profit_pct": 0,  "factor": 1.0 },
    { "min_profit_pct": 20, "factor": 0.7 },
    { "min_profit_pct": 50, "factor": 0.5 }
  ],  "risk_high_near_count": 3,
  "risk_high_near_exposure_pct": 30,  "adaptive_interval_enabled": true,
  "interval_minutes_market": 30,
  "interval_minutes_high_risk": 10,
  "interval_minutes_off_market": 120,  "daily_reactivate_enabled": true,
  "daily_reactivate_time": "09:01"
}

5) positions.csv (복붙용)

• market: KS(코스피), KQ(코스닥)
• trailing_pct: 0.10 = 10%
• stop_loss_pct: 0.08 = -8%
• active: 1(감시), 0(감시중지)

code,name,market,qty,buy_price,trailing_pct,stop_loss_pct,active
005930,삼성전자,KS,10,70000,0.10,0.08,1
069500,KODEX 200,KS,20,35000,0.08,0.07,1

6) state.json 초기화(권장)

처음 적용할 때 state가 꼬였으면 초기화가 안전합니다.

echo "{}" > state.json

7) main.py (전체 소스 — 그대로 복붙)

아래 코드를 main.py로 저장하세요.

# (아래 전체 코드 그대로 복붙)
"""
Orange Pi 5 (Ubuntu/ARM) 주식/ETF 트레일링 스탑 알림 시스템 (yfinance 기반, 지연 Close OK)[핵심 기능]
- positions.csv 관리: 종목/수량/매수가/trailing_pct/stop_loss_pct/active
- state.json 유지: peak_value, last_alerted_peak, 근접 경고 시각, 요약 발송 기록 등
- Synology Chat Incoming Webhook으로 알림 전송[장중(09:00~15:30) 기능]
1) 손절(매수가 기준) 알림: entry*(1-stop_loss_pct) 이하
2) 손절 근접 경고: 손절선까지 +X% 남으면(0% 이하면 손절)
3) 트레일링(수익구간) 알림: peak*(1-eff_trailing) 이하
4) 트레일링 근접 경고: 기준선까지 +X% 남으면
5) 1시간 요약(장중): 총 수익률 + 종목별 요약 + 리스크 레벨[장마감 이후]
- 15:35 일일 요약(TOP3/WORST3)
- 16:00 리포트(섹션 분리: TRIGGER/NEAR/SAFE + 손절 정보 + 리스크)[추가 보강]
- 가변 트레일링(Adaptive Trailing): base_trailing_pct × factor(수익구간별)
- 리스크 HIGH일 때 장중 주기 자동 단축(예: 30→10분)
- 매도/손절 알림 후 auto_disable_on_alert=true면 active=0 자동 변경
- 다음날 지정 시간에 active=0 → active=1 자동 재활성화(옵션)
- state.json 깨짐 자동복구 + 원자저장
- positions.csv 원자저장
- 시작 1회 안내 메시지[주의]
- yfinance는 지연 Close 기반(실시간 아님)
"""import os
import json
import time
import csv
import tempfile
from dataclasses import dataclass
from datetime import datetime, time as dtimeimport requests
import yfinance as yfBASE = os.path.dirname(os.path.abspath(__file__))
CONFIG_PATH = os.path.join(BASE, "config.json")
POSITIONS_PATH = os.path.join(BASE, "positions.csv")
STATE_PATH = os.path.join(BASE, "state.json")def log(step: str, msg: str = "", level: str = "INFO"):
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    if msg:
        print(f"[{now}] [{level}] [{step}] {msg}")
    else:
        print(f"[{now}] [{level}] [{step}]")def fmt_money(x) -> str:
    return f"{x:,.0f}"def parse_hhmm(s: str) -> dtime:
    hh, mm = s.split(":")
    return dtime(hour=int(hh), minute=int(mm))def is_market_open(now: datetime, open_t: dtime, close_t: dtime) -> bool:
    t = now.time()
    return open_t <= t <= close_tdef load_json_safe(path, default):
    if not os.path.exists(path):
        return default
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
        bak = f"{path}.broken_{ts}"
        try:
            os.replace(path, bak)
        except:
            try:
                import shutil
                shutil.copy2(path, bak)
            except:
                pass
        print(f"[WARN] JSON이 깨져 자동 복구했습니다. 백업: {bak} / 오류: {e}")
        return defaultdef save_json_atomic(path, data):
    tmp_dir = os.path.dirname(path) or "."
    fd, tmp_path = tempfile.mkstemp(prefix="state_", suffix=".json", dir=tmp_dir)
    os.close(fd)
    try:
        with open(tmp_path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
        os.replace(tmp_path, path)
    finally:
        if os.path.exists(tmp_path):
            try:
                os.remove(tmp_path)
            except:
                passdef parse_float_optional(x):
    if x is None:
        return None
    s = str(x).strip()
    if s == "":
        return None
    return float(s)def parse_int_optional(x, default=1):
    if x is None:
        return default
    s = str(x).strip()
    if s == "":
        return default
    try:
        return int(float(s))
    except:
        return default@dataclass
class Position:
    code: str
    name: str
    market: str
    qty: float
    buy_price: float
    trailing_pct: float
    stop_loss_pct: float
    active: int    @property
    def ticker(self) -> str:
        return f"{self.code}.{self.market.upper()}"def load_positions_csv(path, default_trailing_pct: float, default_stop_loss_pct: float) -> list[Position]:
    if not os.path.exists(path):
        raise RuntimeError(f"positions.csv가 없습니다: {path}")    positions = []
    with open(path, "r", encoding="utf-8-sig") as f:
        reader = csv.DictReader(f)
        required = {"code", "qty", "buy_price"}
        if not required.issubset(set(reader.fieldnames or [])):
            raise RuntimeError(f"positions.csv 컬럼이 필요합니다: {sorted(required)}")        for row in reader:
            code = row["code"].strip()
            name = (row.get("name") or code).strip()
            market = (row.get("market") or "KS").strip().upper()
            if market not in ("KS", "KQ"):
                raise RuntimeError(f"{code} market 값 오류: {market} (KS/KQ만 허용)")            qty = float(row["qty"])
            buy_price = float(row["buy_price"])            trailing_pct = parse_float_optional(row.get("trailing_pct"))
            if trailing_pct is None:
                trailing_pct = default_trailing_pct
            if not (0 < trailing_pct < 1):
                raise RuntimeError(f"{code} trailing_pct 비정상: {trailing_pct}")            stop_loss_pct = parse_float_optional(row.get("stop_loss_pct"))
            if stop_loss_pct is None:
                stop_loss_pct = default_stop_loss_pct
            if not (0 <= stop_loss_pct < 1):
                raise RuntimeError(f"{code} stop_loss_pct 비정상: {stop_loss_pct}")            active = parse_int_optional(row.get("active"), default=1)
            active = 1 if active != 0 else 0            positions.append(Position(code, name, market, qty, buy_price, trailing_pct, stop_loss_pct, active))
    return positionsdef save_positions_csv_atomic(path, positions: list[Position]):
    fieldnames = ["code", "name", "market", "qty", "buy_price", "trailing_pct", "stop_loss_pct", "active"]
    tmp_dir = os.path.dirname(path) or "."
    fd, tmp_path = tempfile.mkstemp(prefix="positions_", suffix=".csv", dir=tmp_dir)
    os.close(fd)
    try:
        with open(tmp_path, "w", encoding="utf-8-sig", newline="") as f:
            w = csv.DictWriter(f, fieldnames=fieldnames)
            w.writeheader()
            for p in positions:
                w.writerow({
                    "code": p.code, "name": p.name, "market": p.market,
                    "qty": p.qty, "buy_price": p.buy_price,
                    "trailing_pct": p.trailing_pct, "stop_loss_pct": p.stop_loss_pct,
                    "active": p.active
                })
        os.replace(tmp_path, path)
    finally:
        if os.path.exists(tmp_path):
            try: os.remove(tmp_path)
            except: passdef send_synology_chat(webhook_url: str, text: str):
    payload_json = json.dumps({"text": text}, ensure_ascii=False)
    r = requests.post(webhook_url, data={"payload": payload_json}, timeout=10)
    r.raise_for_status()def get_last_price_yf(ticker: str) -> float:
    hist = yf.Ticker(ticker).history(period="7d")
    if hist is None or hist.empty:
        raise RuntimeError(f"가격 데이터 비어있음: {ticker}")
    return float(hist["Close"].iloc[-1])def get_adaptive_factor(cfg: dict, peak_profit_pct: float) -> float:
    if not bool(cfg.get("adaptive_trailing_enabled", True)):
        return 1.0
    tiers = cfg.get("adaptive_trailing_factors", [])
    if not isinstance(tiers, list) or len(tiers) == 0:
        return 1.0    valid = []
    for t in tiers:
        try:
            m = float(t.get("min_profit_pct", 0))
            f = float(t.get("factor", 1.0))
            if f > 0:
                valid.append((m, f))
        except:
            pass    if not valid:
        return 1.0    valid.sort(key=lambda x: x[0])
    chosen = valid[0][1]
    for m, f in valid:
        if peak_profit_pct >= m:
            chosen = f
        else:
            break
    return chosendef effective_trailing_pct(cfg: dict, base_trailing_pct: float, entry_value: float, peak_value: float) -> float:
    if entry_value <= 0:
        return base_trailing_pct
    peak_profit_pct = (peak_value - entry_value) / entry_value * 100.0
    factor = get_adaptive_factor(cfg, peak_profit_pct)
    eff = base_trailing_pct * factor
    eff = max(eff, 0.01)
    eff = min(eff, base_trailing_pct)
    return effdef cleanup_state(state: dict, active_codes: set[str]):
    for k in list(state.keys()):
        if k in ("_summary", "_hourly_summary", "_startup", "_after_close_summary", "_reactivate"):
            continue
        if k not in active_codes:
            del state[k]def should_send_daily_summary(state: dict, now: datetime, summary_time: dtime) -> bool:
    if now.time() < summary_time:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_summary", {})
    return s.get("last_date") != todaydef should_send_hourly_summary_market_only(state: dict, now: datetime, interval_minutes: int, market_open: bool) -> bool:
    if not market_open:
        return False
    hourly = state.setdefault("_hourly_summary", {})
    last_str = hourly.get("last_sent")
    if not last_str:
        return True
    last_dt = datetime.strptime(last_str, "%Y-%m-%d %H:%M:%S")
    diff_min = (now - last_dt).total_seconds() / 60.0
    return diff_min >= interval_minutesdef should_send_after_close_summary(state: dict, now: datetime, summary_time: dtime) -> bool:
    if now.time() < summary_time:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_after_close_summary", {})
    return s.get("last_date") != todaydef should_send_startup_notify(state: dict) -> bool:
    st = state.setdefault("_startup", {})
    return not bool(st.get("sent", False))def mark_startup_notify_sent(state: dict):
    st = state.setdefault("_startup", {})
    st["sent"] = True
    st["sent_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")def should_reactivate_today(state: dict, now: datetime, hhmm: str) -> bool:
    t = parse_hhmm(hhmm)
    if now.time() < t:
        return False
    today = now.strftime("%Y-%m-%d")
    s = state.setdefault("_reactivate", {})
    return s.get("last_date") != todaydef reactivate_all_positions(positions_all: list[Position], state: dict) -> bool:
    changed = False
    for p in positions_all:
        if p.active == 0:
            p.active = 1
            changed = True
    if changed:
        state.setdefault("_reactivate", {})["last_date"] = datetime.now().strftime("%Y-%m-%d")
    return changeddef calc_risk_level(detail_list: list[dict], total_current_active: float, cfg: dict, near_dist: float) -> dict:
    trigger = [d for d in detail_list if d.get("active") == 1 and d.get("to_stop", 999) <= 0]
    near = [d for d in detail_list if d.get("active") == 1 and 0 < d.get("to_stop", 999) <= near_dist]    trigger_cnt = len(trigger)
    near_cnt = len(near)    risk_exposure = sum(float(d.get("cur", 0.0)) for d in (trigger + near))
    exposure_pct = (risk_exposure / total_current_active * 100.0) if total_current_active > 0 else 0.0    high_near_cnt = int(cfg.get("risk_high_near_count", 3))
    high_exposure_pct = float(cfg.get("risk_high_near_exposure_pct", 30))    if trigger_cnt > 0 or near_cnt >= high_near_cnt or exposure_pct >= high_exposure_pct:
        level = "HIGH"
    elif near_cnt > 0:
        level = "MEDIUM"
    else:
        level = "LOW"    return {
        "level": level,
        "trigger_cnt": trigger_cnt,
        "near_cnt": near_cnt,
        "risk_exposure": risk_exposure,
        "exposure_pct": exposure_pct
    }def top_worst_lines(rows, n=3):
    rows_desc = sorted(rows, key=lambda r: r["rate_now"], reverse=True)[:n]
    rows_asc = sorted(rows, key=lambda r: r["rate_now"], reverse=False)[:n]    def line(r):
        sign = "+" if r["profit_now"] >= 0 else ""
        return f"- {r['name']}({r['code']}): {r['rate_now']:+.2f}% ({sign}{fmt_money(r['profit_now'])}원)"    return [line(r) for r in rows_desc], [line(r) for r in rows_asc]def run_once(cfg: dict, positions_all: list[Position], state: dict):
    now = datetime.now()
    now_str = now.strftime("%Y-%m-%d %H:%M:%S")    webhook_url = cfg["synology_chat_webhook_url"]    market_open_t = parse_hhmm(cfg.get("market_open", "09:00"))
    market_close_t = parse_hhmm(cfg.get("market_close", "15:30"))
    daily_summary_t = parse_hhmm(cfg.get("daily_summary_time", "15:35"))    hourly_enabled = bool(cfg.get("hourly_summary_enabled", True))
    hourly_interval = int(cfg.get("hourly_summary_interval_minutes", 60))    auto_disable = bool(cfg.get("auto_disable_on_alert", True))    near_enabled = bool(cfg.get("near_alert_enabled", True))
    near_dist = float(cfg.get("near_alert_distance_pct", 2.0))
    near_cooldown = int(cfg.get("near_alert_cooldown_minutes", 60))    sl_near_enabled = bool(cfg.get("stoploss_near_enabled", True))
    sl_near_dist = float(cfg.get("stoploss_near_distance_pct", 2.0))
    sl_near_cooldown = int(cfg.get("stoploss_near_cooldown_minutes", 180))    after_close_enabled = bool(cfg.get("after_close_summary_enabled", True))
    after_close_time = parse_hhmm(cfg.get("after_close_summary_time", "16:00"))
    include_inactive = bool(cfg.get("after_close_include_inactive", False))    positions_active = [p for p in positions_all if p.active == 1]
    active_codes = {p.code for p in positions_active}
    cleanup_state(state, active_codes)    market_open = is_market_open(now, market_open_t, market_close_t)
    log("MARKET", f"장중={market_open}")    price_targets = positions_all if include_inactive else positions_active
    price_cache: dict[str, float] = {}    log("PRICE", f"조회 대상={len(price_targets)}")
    for p in price_targets:
        if p.code in price_cache:
            continue
        try:
            price_cache[p.code] = get_last_price_yf(p.ticker)
        except Exception as e:
            log("PRICE", f"FAIL {p.name}({p.code}) {e}", level="WARN")    positions_ok = [p for p in positions_active if p.code in price_cache]
    if not positions_ok:
        return False, "LOW", market_open    total_entry = total_current = total_peak = 0.0
    rows = []    for p in positions_ok:
        entry_value = p.qty * p.buy_price
        current_value = p.qty * price_cache[p.code]
        s = state.setdefault(p.code, {})        peak_value = float(s.get("peak_value", entry_value))
        if current_value > peak_value:
            peak_value = current_value
        s["peak_value"] = peak_value        profit_now = current_value - entry_value
        rate_now = (profit_now / entry_value * 100.0) if entry_value else 0.0        total_entry += entry_value
        total_current += current_value
        total_peak += peak_value        rows.append({"code": p.code, "name": p.name, "profit_now": profit_now, "rate_now": rate_now})    total_profit_now = total_current - total_entry
    total_rate_now = (total_profit_now / total_entry * 100.0) if total_entry else 0.0    changed_positions = False
    if market_open:
        pos_map = {p.code: p for p in positions_all}        for p in positions_ok:
            entry_value = p.qty * p.buy_price
            current_value = p.qty * price_cache[p.code]
            s = state.setdefault(p.code, {})
            peak_value = float(s.get("peak_value", entry_value))            # 손절 근접 + 손절 트리거
            if p.stop_loss_pct > 0:
                stop_loss_value = entry_value * (1 - p.stop_loss_pct)
                to_stoploss = (current_value - stop_loss_value) / stop_loss_value * 100.0 if stop_loss_value > 0 else None                if sl_near_enabled and to_stoploss is not None and (0 < to_stoploss <= sl_near_dist):
                    ns = state.setdefault(p.code, {})
                    last_sl_near = ns.get("last_stoploss_near_alert_at")
                    can_send = True
                    if last_sl_near:
                        last_dt = datetime.strptime(last_sl_near, "%Y-%m-%d %H:%M:%S")
                        can_send = (now - last_dt).total_seconds() >= sl_near_cooldown * 60
                    if can_send:
                        msg = (
                            f"[손절 근접 경고/매수가 -{int(p.stop_loss_pct*100)}%]\n"
                            f"- {p.name}({p.code})\n"
                            f"- 손절선까지 거리: {to_stoploss:+.2f}% (0% 이하이면 손절)\n"
                            f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                            f"- 손절선: {fmt_money(stop_loss_value)}원\n"
                            f"- 평가금액: {fmt_money(current_value)}원\n"
                            f"- 시각: {now_str}"
                        )
                        send_synology_chat(webhook_url, msg)
                        ns["last_stoploss_near_alert_at"] = now_str                stop_loss_triggered = current_value <= stop_loss_value
                last_sl = s.get("last_stop_loss_alert_at")
                already_today = bool(last_sl and last_sl[:10] == now_str[:10])
                if stop_loss_triggered and not already_today:
                    msg = (
                        f"[손절 알림/매수가 -{int(p.stop_loss_pct*100)}%]\n"
                        f"- {p.name}({p.code})\n"
                        f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                        f"- 평가금액: {fmt_money(current_value)}원\n"
                        f"- 손절선: {fmt_money(stop_loss_value)}원\n"
                        f"- 매수금액: {fmt_money(entry_value)}원\n"
                        f"- 시각: {now_str}"
                    )
                    send_synology_chat(webhook_url, msg)
                    s["last_stop_loss_alert_at"] = now_str
                    if auto_disable and pos_map[p.code].active != 0:
                        pos_map[p.code].active = 0
                        changed_positions = True            # 트레일링 근접 + 트리거
            last_alerted_peak = float(s.get("last_alerted_peak", 0))
            if peak_value > entry_value:
                eff_trailing = effective_trailing_pct(cfg, p.trailing_pct, entry_value, peak_value)
                stop_value = peak_value * (1 - eff_trailing)
                to_stop = (current_value - stop_value) / stop_value * 100.0
                drop_from_peak = (peak_value - current_value) / peak_value * 100.0
                triggered = current_value <= stop_value                if near_enabled and (0 < to_stop <= near_dist):
                    ns = state.setdefault(p.code, {})
                    last_near = ns.get("last_near_alert_at")
                    can_send = True
                    if last_near:
                        last_dt = datetime.strptime(last_near, "%Y-%m-%d %H:%M:%S")
                        can_send = (now - last_dt).total_seconds() >= near_cooldown * 60
                    if can_send:
                        msg = (
                            f"[근접 경고/트레일링 {int(eff_trailing*100)}%]\n"
                            f"- {p.name}({p.code})\n"
                            f"- 기준선까지 거리: {to_stop:+.2f}% (0% 이하이면 트리거)\n"
                            f"- 피크 대비 하락률: {drop_from_peak:.2f}%\n"
                            f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                            f"- 시각: {now_str}"
                        )
                        send_synology_chat(webhook_url, msg)
                        ns["last_near_alert_at"] = now_str                if triggered and last_alerted_peak < peak_value:
                    msg = (
                        f"[매도 알림/트레일링 {int(eff_trailing*100)}%]\n"
                        f"- {p.name}({p.code})\n"
                        f"- 기준선까지 거리: {to_stop:+.2f}% (트리거)\n"
                        f"- 피크 대비 하락률: {drop_from_peak:.2f}%\n"
                        f"- 최근가(지연 Close): {fmt_money(price_cache[p.code])}원\n"
                        f"- 시각: {now_str}"
                    )
                    send_synology_chat(webhook_url, msg)
                    s["last_alerted_peak"] = peak_value
                    if auto_disable and pos_map[p.code].active != 0:
                        pos_map[p.code].active = 0
                        changed_positions = True    # 리스크/리포트용 상세 리스트
    positions_for_report = positions_all if include_inactive else positions_active
    detail_list = []
    for p in positions_for_report:
        if p.code not in price_cache:
            continue
        entry_value = p.qty * p.buy_price
        current_value = p.qty * price_cache[p.code]
        s = state.get(p.code, {})
        peak_value = float(s.get("peak_value", entry_value))
        eff_trailing = effective_trailing_pct(cfg, p.trailing_pct, entry_value, peak_value) if peak_value > entry_value else p.trailing_pct
        stop_value = peak_value * (1 - eff_trailing) if peak_value else 0.0
        to_stop = (current_value - stop_value) / stop_value * 100.0 if stop_value else 0.0        stop_loss_value = entry_value * (1 - p.stop_loss_pct) if p.stop_loss_pct > 0 else 0.0
        to_stoploss = (current_value - stop_loss_value) / stop_loss_value * 100.0 if stop_loss_value > 0 else None        profit_now = current_value - entry_value
        rate_now = (profit_now / entry_value * 100.0) if entry_value else 0.0        detail_list.append({
            "name": p.name, "code": p.code, "active": p.active,
            "cur": current_value, "entry": entry_value,
            "profit": profit_now, "rate": rate_now,
            "peak": peak_value, "eff_trailing": eff_trailing,
            "stop": stop_value, "to_stop": to_stop,
            "stop_loss_pct": p.stop_loss_pct, "stop_loss_value": stop_loss_value, "to_stoploss": to_stoploss
        })    risk = calc_risk_level(detail_list, total_current, cfg, near_dist)    # 장중 1시간 요약
    if bool(cfg.get("hourly_summary_enabled", True)):
        if should_send_hourly_summary_market_only(state, now, int(cfg.get("hourly_summary_interval_minutes", 60)), market_open):
            lines = []
            for r in rows:
                sign = "+" if r["profit_now"] >= 0 else ""
                lines.append(f"- {r['name']}({r['code']}): {r['rate_now']:+.2f}% ({sign}{fmt_money(r['profit_now'])}원)")            risk_box = (
                f"[리스크 레벨: {risk['level']}]\n"
                f"- Trigger: {risk['trigger_cnt']} / Near: {risk['near_cnt']}\n"
                f"- 위험노출: {fmt_money(risk['risk_exposure'])}원 ({risk['exposure_pct']:.1f}%)\n"
            )            msg = (
                f"[1시간 포트폴리오 요약]\n"
                f"- 총 손익: {fmt_money(total_profit_now)}원\n"
                f"- 총 수익률: {total_rate_now:+.2f}%\n\n"
                + risk_box + "\n"
                + "\n".join(lines) +
                f"\n\n- 시각: {now_str}"
            )
            send_synology_chat(webhook_url, msg)
            state.setdefault("_hourly_summary", {})["last_sent"] = now_str    # 15:35 일일 요약
    if should_send_daily_summary(state, now, daily_summary_t):
        total_profit_peak = total_peak - total_entry
        total_rate_peak = (total_profit_peak / total_entry * 100.0) if total_entry else 0.0
        top3, worst3 = top_worst_lines(rows, n=3)        msg = (
            f"[포트폴리오 일일 요약]\n"
            f"- 총 매수금액: {fmt_money(total_entry)}원\n"
            f"- 총 평가금액(현재): {fmt_money(total_current)}원\n"
            f"- 총 손익(현재): {fmt_money(total_profit_now)}원 ({total_rate_now:+.2f}%)\n"
            f"- 총 최고평가(피크): {fmt_money(total_peak)}원\n"
            f"- 총 손익(피크): {fmt_money(total_profit_peak)}원 ({total_rate_peak:+.2f}%)\n"
            f"\n[손익률 TOP3]\n" + "\n".join(top3) +
            f"\n\n[손익률 WORST3]\n" + "\n".join(worst3) +
            f"\n\n- 시각: {now_str}"
        )
        send_synology_chat(webhook_url, msg)
        state.setdefault("_summary", {})["last_date"] = now.strftime("%Y-%m-%d")    # 16:00 리포트(섹션 분리)
    if bool(cfg.get("after_close_summary_enabled", True)) and should_send_after_close_summary(state, now, after_close_time):
        trigger = [d for d in detail_list if d["active"] == 1 and d["to_stop"] <= 0]
        near = [d for d in detail_list if d["active"] == 1 and 0 < d["to_stop"] <= near_dist]
        safe = [d for d in detail_list if d["active"] == 1 and d["to_stop"] > near_dist]        def line(d):
            a = "A1" if d["active"] == 1 else "A0"
            sl_part = ""
            if d["stop_loss_pct"] > 0 and d["to_stoploss"] is not None:
                sl_part = f" / to_SL={d['to_stoploss']:+.2f}%(-{int(d['stop_loss_pct']*100)}%)"
            sign = "+" if d["profit"] >= 0 else ""
            return (
                f"- {d['name']}({d['code']})[{a}] to_stop={d['to_stop']:+.2f}%{sl_part}\n"
                f"  cur={fmt_money(d['cur'])} stop={fmt_money(d['stop'])} eff_trailing={int(d['eff_trailing']*100)}% "
                f"pnl={sign}{fmt_money(d['profit'])}원 ({d['rate']:+.2f}%)"
            )        risk_box = (
            f"[리스크 레벨: {risk['level']}]\n"
            f"- Trigger: {risk['trigger_cnt']} / Near: {risk['near_cnt']}\n"
            f"- 위험노출: {fmt_money(risk['risk_exposure'])}원 ({risk['exposure_pct']:.1f}%)\n"
        )        msg = (
            f"[16:00 리포트/기준선+손절+리스크]\n"
            f"- 총 손익(active=1): {fmt_money(total_profit_now)}원\n"
            f"- 총 수익률(active=1): {total_rate_now:+.2f}%\n"
            f"- 설명: to_stop=+X%는 트레일 기준선까지 남은 비율(0% 이하 트리거)\n"
            f"- 설명: to_SL=+X%는 손절선까지 남은 비율(0% 이하 손절)\n\n"
            + risk_box + "\n"
            + "🚨 TRIGGER\n" + ("\n".join(line(d) for d in trigger) if trigger else "- 없음") + "\n\n"
            + f"⚠️ NEAR (<= {near_dist:.1f}%)\n" + ("\n".join(line(d) for d in near) if near else "- 없음") + "\n\n"
            + "✅ SAFE\n" + ("\n".join(line(d) for d in safe) if safe else "- 없음") +
            f"\n\n- 시각: {now_str}"
        )
        send_synology_chat(webhook_url, msg)
        state.setdefault("_after_close_summary", {})["last_date"] = now.strftime("%Y-%m-%d")    if changed_positions:
        save_positions_csv_atomic(POSITIONS_PATH, positions_all)    return changed_positions, risk["level"], market_opendef main():
    cfg = load_json_safe(CONFIG_PATH, {})
    if not cfg:
        raise RuntimeError("config.json이 없습니다.")    default_trailing_pct = float(cfg.get("default_trailing_pct", 0.10))
    default_stop_loss_pct = float(cfg.get("default_stop_loss_pct", 0.08))    state = load_json_safe(STATE_PATH, {})    if bool(cfg.get("startup_notify_enabled", True)) and should_send_startup_notify(state):
        try:
            positions_all = load_positions_csv(POSITIONS_PATH, default_trailing_pct, default_stop_loss_pct)
            active_positions = [p for p in positions_all if p.active == 1]
            lines = [
                f"- {p.name}({p.code}.{p.market}) qty={p.qty:g} buy={fmt_money(p.buy_price)} "
                f"trail={int(p.trailing_pct*100)}% sl={int(p.stop_loss_pct*100)}%"
                for p in active_positions
            ]
            msg = "[주식 알림봇 시작]\n" + "\n".join(lines) + f"\n- 시각: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            send_synology_chat(cfg["synology_chat_webhook_url"], msg)
            mark_startup_notify_sent(state)
            save_json_atomic(STATE_PATH, state)
        except Exception as e:
            log("STARTUP", f"시작 안내 실패: {e}", level="WARN")    while True:
        now = datetime.now()
        try:
            positions_all = load_positions_csv(POSITIONS_PATH, default_trailing_pct, default_stop_loss_pct)            if bool(cfg.get("daily_reactivate_enabled", True)):
                if should_reactivate_today(state, now, cfg.get("daily_reactivate_time", "09:01")):
                    if reactivate_all_positions(positions_all, state):
                        save_positions_csv_atomic(POSITIONS_PATH, positions_all)
                        save_json_atomic(STATE_PATH, state)            changed, risk_level, market_open = run_once(cfg, positions_all, state)
            save_json_atomic(STATE_PATH, state)            sleep_min = int(cfg.get("interval_minutes_market", 30))
            if bool(cfg.get("adaptive_interval_enabled", True)):
                mkt_min = int(cfg.get("interval_minutes_market", sleep_min))
                high_min = int(cfg.get("interval_minutes_high_risk", 10))
                off_min = int(cfg.get("interval_minutes_off_market", 120))
                sleep_min = (high_min if risk_level == "HIGH" else mkt_min) if market_open else off_min            log("SLEEP", f"{sleep_min}분 후 재실행 (risk={risk_level}, market_open={market_open})")
            time.sleep(sleep_min * 60)        except Exception as e:
            log("ERROR", f"루프 오류: {e}", level="ERROR")
            time.sleep(120)if __name__ == "__main__":
    main()

8) 실행(백그라운드)

cd ~/python/jusik_top10
nohup python3.9 main.py > jusik.log 2>&1 &
tail -f jusik.log

9) 운영 팁

• positions.csv에서 active=0으로 수동 비활성화 가능
• 손절/트레일링 트리거 후 auto_disable_on_alert=true면 자동으로 active=0
• 다음날 09:01에 자동으로 active=1 복구 (옵션)

10) 트러블슈팅

✅ config.json이 없습니다

• main.py와 같은 폴더에 config.json이 있는지 확인

ls -al

✅ state.json JSONDecodeError(Extra data)

• 파일이 깨진 것 → {}로 초기화

cp state.json state.json.bak
echo "{}" > state.json

✅ 알림이 안 오면

• webhook URL 오타/토큰 확인
• 방화벽/SSL 문제 여부 확인
• logs 확인

tail -n 200 jusik.log

게시물 Orange Pi 5로 “주식/ETF 트레일링 스탑 + 손절 + 리스크 레벨” 알림봇 만들기 (Synology Chat 웹훅, 10~30분 자동 주기)_버전 두번째 full 소스이 하우인포-IT·테크에 처음 등장했습니다.

📌 상단 요약 (5줄)

• 네이버에서 주가를 가져와 실시간 손익을 계산하는 자동화 시스템
• 단순 평가손익이 아닌 수수료·세금 포함 순손익 계산
• 분할매수(LOTS) 구조까지 정확히 처리
• 환율 자동 반영으로 해외 ETF까지 KRW 기준 계산
• Synology Chat으로 장중 자동 알림 전송 + 히스토리 저장

1️⃣ 왜 이런 구조가 필요했는가

일반적인 주식 봇은 대부분 다음과 같습니다.

(현재가 - 매입가) × 수량

하지만 실제 투자에서는 이 계산이 정확하지 않습니다.

• 매수 수수료
• 매도 수수료
• 거래세
• 분할 매수 평단
• ETF 거래세 면제 여부
• 해외 ETF 환율 반영

이 요소를 모두 반영하지 않으면
HTS와 실제 계산 값이 달라집니다.

이 시스템은 그 차이를 줄이기 위해 설계되었습니다.

2️⃣ 데이터 수집 구조 (네이버 주가 안정화 처리)

이 코드는 단순 requests.get() 구조가 아닙니다.

포함된 안정화 로직:

• 네이버 응답 형식 변경 대응
• 자동 재시도
• 연결/읽기 타임아웃 분리
• 세션 재사용
• 실패 시 쿨다운
• 일시적 불안정 구간 보호

👉 장기 운영을 고려한 네트워크 방어 구조

3️⃣ 손익 계산 엔진 (핵심 로직)

① 실제 순손익 계산

반영 항목:

• 매수 수수료
• 매도 수수료
• 주식 매도 거래세
• ETF 거래세 0 처리
• 매수 수수료 취득원가 포함 여부 옵션
• 증권사별 수수료율 반영

즉,

HTS에서 보는 계산 방식과 동일 구조

② LOTS 구조 처리

예시:

"lots": [
  {"buy_price": 30000, "qty": 5},
  {"buy_price": 32000, "qty": 3}
]

처리 내용:

• 평단 자동 계산
• 총 투자원금 계산
• LOT별 손익 합산
• 분할매수 대응

👉 물타기/분할 매수 전략에 필수

4️⃣ 환율 자동 반영 시스템

해외 ETF 대응을 위해 다음 구조가 포함되어 있습니다.

• exchangerate.host 기본 호출
• 실패 시 frankfurter.app 폴백
• 필요한 통화만 계산
• 주기적 자동 갱신

즉,

USD 자산을 KRW 기준으로 정확히 환산

5️⃣ 실행 모드 제어

지원 옵션:

--market-hours 09:00~15:30
--every-min 10
--holiday-file holidays.json

가능 기능:

• 장중만 실행
• N분 간격 반복
• 주말 자동 제외
• 휴장일 자동 제외

👉 수동 개입 없이 자동 운용

6️⃣ 임계치 알림 시스템

예시:

--alert-pl-pct 10
--alert-total-pl-abs 1000000

동작:

• 종목 수익률 10% 이상 알림
• 총 손익 100만원 이상 알림
• 쿨다운 기능으로 중복 방지

👉 실전 투자에 중요한 리스크/수익 관리 기능

7️⃣ 히스토리 저장 구조

포함 기능:

append_history_jsonl(...)

의미:

• 실행 시점 스냅샷 저장
• JSONL 형식 로그 축적

확장 가능성:

• 웹 대시보드
• 수익률 그래프
• 월간 리포트 자동 생성
• 투자 패턴 분석

이미 데이터 기반이 준비된 상태

8️⃣ Synology Chat 전송 구조

일반적인 webhook과 차이점:

• payload / json / text 3단계 전송 시도
• 411 에러 retry 처리
• 전송 간격 제한
• 긴 메시지 자동 분할
• 실패 시 에러 웹훅 분리 전송

👉 실사용 환경에서 발생 가능한 예외 대응 포함

9️⃣ 왜 ‘실전용’ 구조인가

이 시스템은 단순 예제가 아니라:

• 네이버 응답 변동 대응
• 실제 증권사 손익 방식 반영
• 분할 매수 처리
• 환율 폴백 구조
• 장중 자동화
• 임계치 알림
• 히스토리 축적

운영 중 발생하는 문제를 반영한 구조입니다.

🔎 확장 가능 영역

이미 계산 엔진과 로그 저장 구조가 완성되어 있으므로:

• SQLite/DB 연동
• 웹 대시보드 구축
• 월간 자동 리포트
• 투자 전략 분석 엔진
• AI 기반 매매 패턴 분석

으로 확장이 가능합니다.

실행 방법

python 파일명.py

결론

이 파일은 단순 “주가 알림 봇”이 아니라

개인 투자자를 위한 계산 중심 자동화 엔진

에 가깝습니다.

코드를 전부 이해하는 것보다
구조와 확장 가능성을 이해하는 것이 더 중요합니다.

그리고 이 코드는
그걸 충분히 해낼 수 있는 구조를 이미 가지고 있습니다.

아래 full 소스 제공해 드립니다.

실행방법 python 파일명.py

# -*- coding: utf-8 -*-
"""
Synology Chat(Webhook)으로 네이버 주가/ETF 전송 봇 (Python 3.9+)
- LOTS(분할매수), 분배금 반영, ETF만 알림, 환율 환산
- 자동 환율(exchangerate.host → frankfurter.app 폴백) + 최초 보장
- 데몬/장중, 휴장일, 재시도 세션, Graceful 종료(CTRL+C/신호)
- 수수료/거래세 반영 순손익(키움증권 등) 계산
- 커미션 기본값: --venue krx(0.015%), nxt(0.0145%) | 직접 지정은 --commission-bps
- 웹훅 성공 판정(200/204/JSON success), 레이트리밋 지터, 상태파일 잠금(옵션)
"""

import argparse, time, json, urllib3, math, os, signal, logging, sys, re, random, atexit
from datetime import datetime, timedelta, time as dtime, date as ddate, timezone
from typing import Optional, Set, Dict, Any, Tuple, List
import requests
from urllib.parse import urlsplit, urlunsplit, parse_qsl, urlencode

# (optional) 파일락: Linux/Synology 권장
try:
    import fcntl  # type: ignore
    _HAS_FCNTL = True
except Exception:
    _HAS_FCNTL = False

# ===== 로깅 유틸 =====
LOG_BODY_MAX = 3000  # 응답 본문은 너무 길면 초과분 생략

def _mask_url(url: str) -> str:
    """웹훅 token, 키 등 쿼리스트링 민감정보 마스킹"""
    try:
        sp = urlsplit(url)
        qs = parse_qsl(sp.query, keep_blank_values=True)
        masked = []
        SENSITIVE = {
            "token","apikey","appkey","secret","secretkey","appsecret",
            "hook","webhook","authorization","sig","signature"
        }
        for k, v in qs:
            if k.lower() in SENSITIVE or re.search(r"(token|secret|sig|hook|auth)", k, re.I):
                masked.append((k, "***"))
            else:
                masked.append((k, v))
        new_q = urlencode(masked, doseq=True)
        return urlunsplit((sp.scheme, sp.netloc, sp.path, new_q, sp.fragment))
    except Exception:
        return url

def _log_http(resp: requests.Response, label: str = ""):
    """요청/응답 핵심을 구조적으로 출력"""
    try:
        req = resp.request
        masked_url = _mask_url(req.url)
        logging.error(
            "%sHTTP %s %s -> %s\n[req headers]=%s\n[req body]=%s\n[resp headers]=%s\n[resp body]=%s",
            (f"[{label}] " if label else ""),
            req.method, masked_url, resp.status_code,
            dict(req.headers),
            (req.body.decode("utf-8", errors="ignore") if isinstance(req.body, bytes) else str(req.body))[:LOG_BODY_MAX],
            dict(resp.headers),
            (resp.text or "")[:LOG_BODY_MAX],
        )
    except Exception as e:
        logging.exception("[_log_http] 로깅 중 예외: %s", e)

# -------------------- 로깅 --------------------
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
log = logging.getLogger("naver-syno-bot")

# =====================[ 환경변수 / 기본설정 ]=====================
CHAT_WEBHOOK_URL = os.getenv("CHAT_WEBHOOK_URL", "").strip()
CHAT_ERROR_WEBHOOK_URL = os.getenv("CHAT_ERROR_WEBHOOK_URL", "").strip()

VERIFY_SSL = True
DEFAULT_INTERVAL = 1200   # 20분
DEFAULT_TZ = "Asia/Seoul"
DEFAULT_REPORT_CCY = "KRW"

# 네이버 시세 요청 타임아웃(연결, 읽기)
NAVER_TIMEOUT = (3.0, 7.0)

# 네이버 조회 실패 쿨다운(초): 같은 종목이 연속 실패할 때 잠시 스킵(네이버 불안정 완화)
FAIL_COOLDOWN_SEC = 30
_failed_cache: Dict[str, float] = {}  # code -> last_fail_ts

# 임계치 알림 쿨다운(초): 임계 충족 상태가 유지될 때 알림 스팸 방지
ALERT_COOLDOWN_SEC = 1800  # 30분

# (옵션) 단일 인스턴스 실행 보장 PID 파일
DEFAULT_PID_FILE = "/tmp/naver_stock_bot.pid"

# 히스토리 저장(월간 리포트용)
DEFAULT_HISTORY_DIR = "./reports"
DEFAULT_HISTORY_PREFIX = "history"


# 기본 종목/포트폴리오 — 파일로 대체 가능 (중복키 주의)
STOCKS: Dict[str, Any] = {
    "SK하이닉스": "000660",
    "TIGER 미국필라델피아AI반도체나스닥": "497570",
}
PORTFOLIO: Dict[str, Any] = {
    "SK하이닉스": {"buy_price": 337_788, "qty": 13},
    "TIGER 미국필라델피아AI반도체나스닥": {"buy_price": 13_069, "qty": 140}
}
DIVIDENDS: Dict[str, Any] = {}  # {"이름":{"currency":"KRW","items":[{"total":..}|{"per_share":..,"qty":..}]}}
FX_RATES: Dict[str, float] = {"KRW": 1.0}

# ==== Fee/Tax (Kiwoom 등) ====
_commission_rate = 0.0             # 예: 0.015% -> 0.00015
_sell_tax_rate_stock = 0.0         # 일반 주식 매도세율(%)
_sell_tax_rate_etf = 0.0           # ETF 매도세율(%). 한국 ETF는 보통 0.0
_include_buy_commission_in_cost = True  # 매수 커미션을 취득원가에 포함할지

# 네이버 비공식 가격 API
BASE = "https://m.stock.naver.com/api/stock/{code}/price"
HEADERS = {"User-Agent": "Mozilla/5.0", "Accept": "application/json, text/plain, */*", "Referer": "https://m.stock.naver.com/"}

# 실행 상태
_stop = False
_sessions: Dict[bool, requests.Session] = {}  # verify별 세션 캐시

# ---- 자동 환율 상태 ----
_auto_fx_enabled = False
_auto_fx_extra: Set[str] = set()
_fx_refresh_minutes = 720
_last_fx_fetch: Optional[datetime] = None

# ---- 전송 최소 간격(폭주 방지) ----
_last_send_ts: Optional[float] = None
_min_send_gap_sec: float = 1.5

# -------------------- 시그널 핸들러 --------------------
def _install_signal_handlers():
    def handler(signum, frame):
        global _stop
        _stop = True
        log.info("신호(%s) 수신 → 종료 준비...", signum)
    signal.signal(signal.SIGINT, handler)
    try:
        signal.signal(signal.SIGTERM, handler)
    except Exception:
        pass
    if hasattr(signal, "SIGBREAK"):
        try:
            signal.signal(signal.SIGBREAK, handler)
        except Exception:
            pass

# -------------------- HTTP 세션(재시도 포함) --------------------
def _build_session(verify_ssl: bool) -> requests.Session:
    from urllib3.util.retry import Retry
    from requests.adapters import HTTPAdapter
    sess = requests.Session()
    retry = Retry(
        total=5, backoff_factor=0.8,
        status_forcelist=(429, 500, 502, 503, 504),
        allowed_methods=frozenset(["GET", "POST"]),
        raise_on_status=False, respect_retry_after_header=True
    )
    adapter = HTTPAdapter(max_retries=retry, pool_connections=10, pool_maxsize=10)
    sess.mount("https://", adapter); sess.mount("http://", adapter)
    sess.verify = verify_ssl
    if not verify_ssl:
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    return sess

def _get_session(verify_ssl: bool) -> requests.Session:
    s = _sessions.get(bool(verify_ssl))
    if s is None:
        s = _build_session(verify_ssl)
        _sessions[bool(verify_ssl)] = s
    return s

# -------------------- 유틸 --------------------
def _tzinfo(tz_name: str):
    try:
        from zoneinfo import ZoneInfo
        return ZoneInfo(tz_name)
    except Exception:
        return timezone(timedelta(hours=9))  # KST fallback

def _to_float(x):
    if x is None: return None
    if isinstance(x, (int, float)): return float(x)
    s = str(x).replace(",", "").strip()
    if s in ("", "-", "null", "None"): return None
    try: return float(s)
    except Exception: return None

def _fmt_money(v: float, ccy: str = "KRW") -> str:
    return f"{v:,.0f}{'원' if ccy=='KRW' else ' ' + ccy}"

def _fmt_signed(v: float, c: str = "KRW") -> str:
    sign = "+" if v > 0 else ("-" if v < 0 else "±")
    return f"{sign}{abs(v):,.0f}{'원' if c=='KRW' else ' ' + c}"

def _fmt_signed_pct(v: float) -> str:
    sign = "+" if v > 0 else ("-" if v < 0 else "±")
    return f"{sign}{abs(v):.2f}%"

def _is_weekday(dt: datetime) -> bool:
    return dt.weekday() < 5

def _within(dt: datetime, start_t: dtime, end_t: dtime) -> bool:
    now_t = dt.time()
    return (now_t >= start_t) and (now_t <= end_t)

def _ceil_to_next_minutes(dt: datetime, every_min: int) -> datetime:
    total_secs = dt.hour * 3600 + dt.minute * 60 + dt.second
    step = every_min * 60
    next_total = math.ceil((total_secs + 1) / step) * step
    next_hour = next_total // 3600
    next_min = (next_total % 3600) // 60
    next_sec = next_total % 60
    next_dt = dt.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(hours=next_hour, minutes=next_min, seconds=next_sec)
    if next_dt.date() != dt.date():
        next_dt = datetime(dt.year, dt.month, dt.day, tzinfo=dt.tzinfo) + timedelta(days=1)
        next_dt = next_dt.replace(hour=0, minute=0, second=0, microsecond=0)
    return next_dt

# -------------------- JSON 관대 파서 --------------------
_COMMENT_RE = re.compile(r"(/\*.*?\*/|//[^\n]*\n)", re.S)
_TRAILING_COMMA_RE = re.compile(r",\s*([}\]])")

def _load_json_lenient(path: str):
    with open(path, "r", encoding="utf-8") as f:
        txt = f.read()
    if txt.startswith("\ufeff"):
        txt = txt.lstrip("\ufeff")
    txt = _COMMENT_RE.sub("\n", txt)
    txt = _TRAILING_COMMA_RE.sub(r"\1", txt)
    return json.loads(txt)

def _load_json(path: str):
    try:
        return _load_json_lenient(path)
    except Exception:
        with open(path, "r", encoding="utf-8") as f:
            raw = f.read()
        return json.loads(raw)

def _parse_hhmm(s: str) -> dtime:
    hh, mm = s.strip().split(":"); return dtime(int(hh), int(mm))

def _parse_holiday_dates(h_strings) -> Set[ddate]:
    res: Set[ddate] = set()
    for s in h_strings or []:
        s = str(s).strip()
        if not s: continue
        try:
            y, m, d = s.split("-"); res.add(ddate(int(y), int(m), int(d)))
        except Exception:
            log.warning("[경고] 휴장일 형식 무시: %s (YYYY-MM-DD)", s)
    return res

def _load_holidays_from_file(path: str) -> Set[ddate]:
    out: Set[ddate] = set()
    if not path or not os.path.exists(path): return out
    try:
        if path.lower().endswith(".json"):
            data = _load_json(path)
            if isinstance(data, list):
                return _parse_holiday_dates([str(x) for x in data])
            if isinstance(data, dict) and "holidays" in data and isinstance(data["holidays"], list):
                return _parse_holiday_dates([str(x) for x in data["holidays"]])
            log.warning("[경고] JSON은 배열 또는 {'holidays':[...]} 지원"); return out
        else:
            with open(path, "r", encoding="utf-8") as f:
                lines = [line.strip().split(",")[0] for line in f if line.strip()]
            return _parse_holiday_dates(lines)
    except Exception as e:
        log.warning("[경고] 휴장일 파일 로드 실패: %s", e); return out

# -------------------- ETF 판별 --------------------
ETF_KEYWORDS = ["ETF", "KODEX", "TIGER", "ACE", "KBSTAR", "HANARO", "KOSEF", "SOL", "ARIRANG", "TREX"]

def _is_etf_name(name: str) -> bool:
    up = name.upper(); return any(k in up for k in ETF_KEYWORDS)

def _is_etf_entry(name: str, stock_entry: Any) -> bool:
    if isinstance(stock_entry, dict) and str(stock_entry.get("type","")).upper() == "ETF":
        return True
    return _is_etf_name(name)

# -------------------- 환율 처리 --------------------
def _parse_fx_pairs(pairs: List[str]) -> Dict[str, float]:
    out = {}
    for p in pairs or []:
        if "=" not in p: continue
        k, v = p.split("=", 1)
        k = k.strip().upper()
        try: out[k] = float(v.strip())
        except Exception: log.warning("[경고] 환율 무시: %s", p)
    return out

def _get_fx(ccy: str, report_ccy: str) -> float:
    ccy = (ccy or "KRW").upper(); report_ccy = (report_ccy or "KRW").upper()
    if ccy == report_ccy: return 1.0
    r_from = FX_RATES.get(ccy); r_to = FX_RATES.get(report_ccy)
    if not r_from or not r_to: return 1.0
    return r_from / r_to

def _collect_needed_currencies(report_ccy: str) -> Set[str]:
    need = {report_ccy.upper(), "KRW"}
    for _, entry in STOCKS.items():
        if isinstance(entry, dict):
            need.add(str(entry.get("currency","KRW")).upper())
        else:
            need.add("KRW")
    for v in DIVIDENDS.values():
        if isinstance(v, dict):
            need.add(str(v.get("currency","KRW")).upper())
    need |= _auto_fx_extra
    need = {c for c in need if c}
    return need

def _fetch_fx_exchangerate_host(symbols: List[str], verify_ssl: bool) -> Dict[str, float]:
    url = "https://api.exchangerate.host/latest"
    sess = _get_session(verify_ssl)
    params = {"base":"KRW", "symbols": ",".join(sorted(set([c for c in symbols if c != "KRW"])))}  # KRW 제외
    r = sess.get(url, params=params, timeout=10)
    r.raise_for_status()
    j = r.json()
    rates = j.get("rates", {}) or {}
    out = {"KRW": 1.0}
    for c, v in rates.items():
        try:
            v = float(v)
            if v > 0:
                out[c.upper()] = 1.0 / v
        except Exception:
            pass
    return out

def _fetch_fx_frankfurter(symbols: List[str], verify_ssl: bool) -> Dict[str, float]:
    url = "https://api.frankfurter.app/latest"
    sess = _get_session(verify_ssl)
    params = {"from":"KRW", "to": ",".join(sorted(set([c for c in symbols if c != "KRW"])))}  # KRW 제외
    r = sess.get(url, params=params, timeout=10)
    r.raise_for_status()
    j = r.json()
    rates = j.get("rates", {}) or {}
    out = {"KRW": 1.0}
    for c, v in rates.items():
        try:
            v = float(v)
            if v > 0:
                out[c.upper()] = 1.0 / v
        except Exception:
            pass
    return out

def _auto_fetch_and_update_fx(report_ccy: str, verify_ssl: bool):
    global _last_fx_fetch
    try:
        need = _collect_needed_currencies(report_ccy)
        if need == {"KRW"}:
            FX_RATES["KRW"] = 1.0
            _last_fx_fetch = datetime.now()
        try:
            log.info("[FX] 갱신 완료 (report=%s)", report_ccy.upper())
            for k in sorted(FX_RATES.keys()):
                log.info("[FX] %s = %.6f", k, float(FX_RATES[k]))
        except Exception:
            pass
            log.info("자동 환율: 필요한 외화 없음(KRW만)")
            return

        got = {}
        try:
            got = _fetch_fx_exchangerate_host(list(need), verify_ssl)
            log.info("자동 환율(메인) 적용: %s", got)
        except Exception as e:
            log.warning("exchangerate.host 실패: %s → frankfurter.app 폴백 시도", e)
            got = _fetch_fx_frankfurter(list(need), verify_ssl)
            log.info("자동 환율(폴백) 적용: %s", got)

        FX_RATES.setdefault("KRW", 1.0)
        for k, v in got.items():
            if v and v > 0:
                FX_RATES[k.upper()] = float(v)
        FX_RATES.setdefault(report_ccy.upper(), FX_RATES.get(report_ccy.upper(), 1.0))
        _last_fx_fetch = datetime.now()
    except Exception as e:
        log.error("자동 환율 갱신 실패: %s", e)

def _maybe_refresh_fx(report_ccy: str, verify_ssl: bool):
    if not _auto_fx_enabled:
        return
    now = datetime.now()
    if (_last_fx_fetch is None) or ((now - _last_fx_fetch).total_seconds() >= _fx_refresh_minutes * 60):
        _auto_fetch_and_update_fx(report_ccy, verify_ssl)

# -------------------- 상태 파일 --------------------
def _lock_file(f):
    if _HAS_FCNTL:
        try:
            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
        except Exception:
            pass

def _unlock_file(f):
    if _HAS_FCNTL:
        try:
            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
        except Exception:
            pass

def _load_state(path: str) -> Dict[str, Any]:
    if not path or not os.path.exists(path):
        return {"stock_alerts": {}, "total_alert": None}
    try:
        with open(path, "r", encoding="utf-8") as f:
            _lock_file(f)
            raw = f.read()
            _unlock_file(f)
        return json.loads(raw or "{}") or {"stock_alerts": {}, "total_alert": None}
    except Exception:
        return {"stock_alerts": {}, "total_alert": None}

def _save_state(path: str, state: Dict[str, Any]):
    if not path: return
    try:
        os.makedirs(os.path.dirname(path), exist_ok=True)
    except Exception:
        pass
    try:
        tmp = path + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f:
            _lock_file(f)
            json.dump(state, f, ensure_ascii=False, indent=2)
            f.flush()
            os.fsync(f.fileno())
            _unlock_file(f)
        os.replace(tmp, path)
    except Exception as e:
        log.warning("상태 파일 저장 실패: %s", e)

# -------------------- 히스토리 저장(JSONL) --------------------
def _history_path_for_month(history_dir: str, prefix: str, tz_name: str) -> str:
    tz = _tzinfo(tz_name)
    now = datetime.now(tz)
    ym = now.strftime("%Y-%m")
    base = f"{prefix}_{ym}.jsonl"
    return os.path.join(history_dir, base)

def append_history_jsonl(rows, tz_name: str, report_ccy: str, history_dir: str, prefix: str = DEFAULT_HISTORY_PREFIX):
    """스냅샷(rows)을 JSONL로 누적 저장한다. (월간 CSV 리포트 생성용 원천데이터)"""
    if not history_dir:
        return
    try:
        os.makedirs(history_dir, exist_ok=True)
    except Exception:
        pass

    tz = _tzinfo(tz_name)
    ts = datetime.now(tz).isoformat(timespec="seconds")

    out = {"ts": ts, "tz": tz_name, "report_ccy": report_ccy, "items": []}

    for name, price, diff, pct, traded_at, ccy, entry in rows:
        pos = PORTFOLIO.get(name)
        invested, qty, avg_buy, lots_view = _pos_invested_qty_avg(pos) if pos else (0.0, 0, 0.0, [])
        out["items"].append({
            "name": name,
            "code": _get_code(entry),
            "currency": ccy,
            "price": price,
            "diff": diff,
            "pct": pct,
            "traded_at": traded_at,
            "qty": qty,
            "avg_buy": avg_buy,
            "invested": invested,
            "lots": [{"buy_price": b, "qty": q} for (b, q) in lots_view] if len(lots_view) > 1 else []
        })

    path = _history_path_for_month(history_dir, prefix, tz_name)
    try:
        with open(path, "a", encoding="utf-8") as f:
            f.write(json.dumps(out, ensure_ascii=False) + "\n")
    except Exception as e:
        log.warning("히스토리 저장 실패(%s): %s", path, e)

# -------------------- 시세 조회 --------------------
def _get_code(entry: Any) -> str:
    if isinstance(entry, dict): return str(entry.get("code","")).strip()
    return str(entry).strip()

def _get_currency(entry: Any) -> str:
    if isinstance(entry, dict):
        c = str(entry.get("currency","KRW")).upper()
        return c if c else "KRW"
    return "KRW"

def fetch_price_from_naver(code: str, verify_ssl: bool, timeout=NAVER_TIMEOUT) -> Tuple[Optional[float], Optional[float], Optional[float], Optional[str]]:
    """네이버 응답 스키마 변동/오프장/빈 응답 견고화"""
    if not code or not isinstance(code, str):
        return None, None, None, None
    sess = _get_session(verify_ssl)
    try:
        r = sess.get(BASE.format(code=code), headers=HEADERS, timeout=timeout)
        r.raise_for_status()
    except Exception:
        # 실패 기록(쿨다운용) 후 상위에서 처리
        try:
            _failed_cache[code] = time.time()
        except Exception:
            pass
        raise
    try:
        data = r.json()
    except Exception:
        try:
            _failed_cache[code] = time.time()
        except Exception:
            pass
        return None, None, None, None

    def _normalize(d: dict) -> Tuple[Optional[float], Optional[float], Optional[float], Optional[str]]:
        last = _to_float(d.get("closePrice")) or _to_float(d.get("close"))
        diff = _to_float(d.get("compareToPreviousClosePrice")) or _to_float(d.get("diff"))
        pct  = _to_float(d.get("fluctuationsRatio")) or _to_float(d.get("rate"))
        date = d.get("localTradedAt") or d.get("localTradedTime") or d.get("time")
        return last, diff, pct, date

    if isinstance(data, list):
        if not data:
            return None, None, None, None
        # 최신이 0번 인덱스로 오는 케이스
        return _normalize(data[0] or {})

    if isinstance(data, dict):
        # 스키마 케이스 1: {closePrice:{price}, prevClosePrice:{price}}
        if "closePrice" in data or "prevClosePrice" in data:
            try:
                last = _to_float(data.get("closePrice", {}).get("price"))
                prev = _to_float(data.get("prevClosePrice", {}).get("price"))
                diff = (last - prev) if (last is not None and prev is not None) else None
                pct  = (diff / prev * 100) if (diff is not None and prev not in (None, 0)) else None
                date = data.get("localTradedAt")
                return last, diff, pct, date
            except Exception:
                pass
        # 스키마 케이스 2: 낙관 파싱
        return _normalize(data)

    return None, None, None, None

def snapshot_all(verify_ssl: bool) -> List[Tuple[str, Optional[float], Optional[float], Optional[float], Optional[str], str, Any]]:
    rows = []
    for name, entry in STOCKS.items():
        code = _get_code(entry).strip()
        ccy = _get_currency(entry)
        if not code:
            log.warning("종목 '%s' 코드가 비어 있어 스킵합니다.", name)
            rows.append((name, None, None, None, None, ccy, entry))
            continue
        try:
            price, diff, pct, date = fetch_price_from_naver(code, verify_ssl)
        except Exception as e:
            log.warning("네이버 조회 실패 %s(%s): %s", name, code, e)
            price = diff = pct = date = None
        rows.append((name, price, diff, pct, date, ccy, entry))

    # 포트폴리오에 있으나 종목 목록에 없는 키 알림(오타/누락 방지)
    missing = set(PORTFOLIO.keys()) - set(STOCKS.keys())
    if missing:
        log.warning("포트폴리오에 있으나 STOCKS에 없는 항목: %s", ", ".join(sorted(missing)))
    return rows

# -------------------- 포트폴리오/배당 계산 --------------------
def _pos_invested_qty_avg(pos) -> Tuple[float, int, float, List[Tuple[float, int]]]:
    if not pos: return 0.0, 0, 0.0, []
    if "lots" in pos and isinstance(pos["lots"], list):
        invested = 0.0; qty = 0; lots_view = []
        for lot in pos["lots"]:
            b = float(lot.get("buy_price", 0) or 0); q = int(lot.get("qty", 0) or 0)
            if q <= 0: continue
            invested += b * q; qty += q; lots_view.append((b, q))
        avg = (invested / qty) if qty else 0.0
        return invested, qty, avg, lots_view
    buy = float(pos.get("buy_price", 0) or 0); qty = int(pos.get("qty", 0) or 0)
    invested = buy * qty
    return invested, qty, buy, [(buy, qty)] if qty > 0 else []

def _div_total_for(name: str) -> Tuple[float, str]:
    d = DIVIDENDS.get(name)
    if not d: return 0.0, "KRW"
    items = d.get("items"); ccy = str(d.get("currency","KRW")).upper()
    if not items or not isinstance(items, list): return 0.0, ccy
    total = 0.0
    for it in items:
        if "total" in it:
            v = _to_float(it.get("total")); total += v if v else 0.0; continue
        per = _to_float(it.get("per_share")); q = _to_float(it.get("qty"))
        if per and q: total += per * q
    return total, ccy

# ==================== 수수료/세금(순손익) 유틸 ====================
def _calc_commission(value: float) -> float:
    if value <= 0: return 0.0
    return float(value) * float(_commission_rate)

def _calc_sell_tax(value: float, is_etf: bool) -> float:
    rate = _sell_tax_rate_etf if is_etf else _sell_tax_rate_stock
    if value <= 0 or rate <= 0: return 0.0
    return float(value) * float(rate)

def _estimate_net_pl(invested_r: float, market_r: float, is_etf: bool) -> Tuple[float, float]:
    buy_commission = _calc_commission(invested_r) if _include_buy_commission_in_cost else 0.0
    basis_r = invested_r + buy_commission
    sell_commission = _calc_commission(market_r)
    sell_tax = _calc_sell_tax(market_r, is_etf)
    net_proceeds = market_r - sell_commission - sell_tax
    net_pl = net_proceeds - basis_r
    net_roi = (net_pl / basis_r * 100) if basis_r > 0 else 0.0
    return net_pl, net_roi

def _safe_roi(pl: float, invested: float) -> float:
    return (pl / invested * 100.0) if invested and invested != 0 else 0.0

# -------------------- 메시지 포맷 --------------------
def format_chat_message(rows, tz_name: str, report_ccy: str, mention: str = "", title_prefix: str = "", compact: bool = False) -> str:
    tz = _tzinfo(tz_name); ts = datetime.now(tz).strftime("%Y-%m-%d %H:%M")
    title = f"[네이버 주가 스냅샷] {ts} (보유손익)"
    if title_prefix: title = f"{title_prefix} {title}"
    head = f"{mention}{title}" if mention else title
    lines = [head]

    total_invested_r = 0.0; total_market_r = 0.0; total_div_r = 0.0

    for name, price, diff, pct, date, ccy, entry in rows:
        if price is None:
            lines.append(f"- {name}: 데이터 없음"); continue

        pos = PORTFOLIO.get(name)
        invested, qty, avg_buy, lots_view = _pos_invested_qty_avg(pos) if pos else (0.0, 0, 0.0, [])

        fx = _get_fx(ccy, report_ccy)
        price_r = (price or 0) * fx
        invested_r = invested * fx
        market_r   = (price or 0) * qty * fx

        div_sum, div_ccy = _div_total_for(name)
        fx_div = _get_fx(div_ccy, report_ccy); div_r = div_sum * fx_div

        pl_r  = market_r - invested_r
        roi   = _safe_roi(pl_r, invested_r)

        # 순손익(수수료/세금 반영)
        is_etf = _is_etf_entry(name, entry)
        net_pl_r, net_roi = _estimate_net_pl(invested_r, market_r, is_etf)

        total_invested_r += invested_r; total_market_r += market_r; total_div_r += div_r

        sign = "▲" if (diff is not None and diff > 0) else ("▼" if (diff is not None and diff < 0) else "-")
        diff_txt = f"{abs(diff):,.0f}" if diff is not None else "N/A"
        pct_txt  = f"{pct:.2f}%" if pct is not None else "N/A"

        lots_note = ""
        if len(lots_view) > 1:
            lots_note = " | lots " + "; ".join([f"{int(b):,}×{q}" for b, q in lots_view])

        date_txt = ""  # 필요 시 표시 확장 가능(localTradedAt 등)

        unit = "원" if report_ccy == "KRW" else f" {report_ccy}"
        if qty > 0:
            if compact:
                lines.append(
                    f"- {name}\n"
                    f"  현재가 {price_r:,.0f}{unit} {sign}{diff_txt} ({pct_txt})\n"
                    f"  매입가(평단) {avg_buy * fx:,.0f}{unit} × {qty}주{(' (분할매수 %d회)' % len(lots_view)) if len(lots_view) > 1 else ''}\n"
                    f"  투자 {_fmt_money(invested_r, report_ccy)} → 평가 {_fmt_money(market_r, report_ccy)}\n"
                    f"  손익 {_fmt_signed(pl_r, report_ccy)} ({_fmt_signed_pct(roi)}) | 순손익 {_fmt_signed(net_pl_r, report_ccy)} ({_fmt_signed_pct(net_roi)})"
                    f"{f' | 분배금 {_fmt_money(div_r, report_ccy)}' if round(div_r) > 0 else ''}"
                    f"{lots_note}{date_txt}"
                )
            else:
                lines.append(
                    f"- {name}: {price_r:,.0f}{unit} "
                    f"{sign}{diff_txt} ({pct_txt})"
                    f" | 매입가(평단) {avg_buy * fx:,.0f}{unit} × {qty}주"
                    f" | 투자원금 {_fmt_money(invested_r, report_ccy)}"
                    f" | 평가금액 {_fmt_money(market_r, report_ccy)}"
                    f" | 평가손익 {_fmt_signed(pl_r, report_ccy)} ({_fmt_signed_pct(roi)})"
                    f" | 순손익(수수료/세금) {_fmt_signed(net_pl_r, report_ccy)} ({_fmt_signed_pct(net_roi)})"
                    f"{f' | 분배금 누계 {_fmt_money(div_r, report_ccy)}' if round(div_r) > 0 else ''}"
                    f"{lots_note}{date_txt}"
                )
        else:
            if compact:
                lines.append(
                    f"- {name}: {price_r:,.0f}{unit} {sign}{diff_txt} ({pct_txt})"
                    f"{f' | (미보유) 분배금 {_fmt_money(div_r, report_ccy)}' if round(div_r) > 0 else ''}{date_txt}"
                )
            else:
                lines.append(
                    f"- {name}: {price_r:,.0f}{unit} "
                    f"{sign}{diff_txt} ({pct_txt})"
                    f"{f' | (미보유) 분배금 누계 {_fmt_money(div_r, report_ccy)}' if round(div_r) > 0 else ''}{date_txt}"
                )

    if total_invested_r > 0:
        total_pl_r  = total_market_r - total_invested_r
        total_roi   = _safe_roi(total_pl_r, total_invested_r)
        lines.append("=" * 110)
        lines.append(f"[합계] 투자원금 {_fmt_money(total_invested_r, report_ccy)} / 평가금액 {_fmt_money(total_market_r, report_ccy)}")
        lines.append(f"[합계] 평가손익 {_fmt_signed(total_pl_r, report_ccy)} ({_fmt_signed_pct(total_roi)})")
        if round(total_div_r) > 0:
            lines.append(f"[합계] 분배금 누계 {_fmt_money(total_div_r, report_ccy)}")

        # 합계 순손익(수수료/세금 반영)
        net_pl_all, net_roi_all, _ = _calc_totals_net(rows, report_ccy)
        lines.append(f"[합계] 순손익(수수료/세금) {_fmt_signed(net_pl_all, report_ccy)} ({_fmt_signed_pct(net_roi_all)})")

    return "\n".join(lines)

# -------------------- 합계 계산(기존/순손익) --------------------
def _calc_totals(rows, report_ccy: str) -> Tuple[float, float, float]:
    total_invested_r = 0.0; total_market_r = 0.0
    for name, price, diff, pct, date, ccy, entry in rows:
        if price is None: continue
        pos = PORTFOLIO.get(name)
        if not pos: continue
        invested, qty, _, _ = _pos_invested_qty_avg(pos)
        fx = _get_fx(ccy, report_ccy)
        total_invested_r += invested * fx
        total_market_r   += (price or 0) * qty * fx
    total_pl_r = total_market_r - total_invested_r
    total_roi = _safe_roi(total_pl_r, total_invested_r)
    return total_pl_r, total_roi, total_invested_r

def _calc_totals_net(rows, report_ccy: str) -> Tuple[float, float, float]:
    total_basis_r = 0.0
    total_net_proceeds = 0.0
    for name, price, diff, pct, date, ccy, entry in rows:
        if price is None:
            continue
        pos = PORTFOLIO.get(name)
        if not pos:
            continue
        invested, qty, _, _ = _pos_invested_qty_avg(pos)
        fx = _get_fx(ccy, report_ccy)
        invested_r = invested * fx
        market_r   = (price or 0) * qty * fx

        is_etf = _is_etf_entry(name, entry)
        buy_commission = _calc_commission(invested_r) if _include_buy_commission_in_cost else 0.0
        basis_r = invested_r + buy_commission
        sell_commission = _calc_commission(market_r)
        sell_tax = _calc_sell_tax(market_r, is_etf)

        total_basis_r += basis_r
        total_net_proceeds += max(0.0, market_r - sell_commission - sell_tax)

    net_pl = total_net_proceeds - total_basis_r
    net_roi = _safe_roi(net_pl, total_basis_r)
    return net_pl, net_roi, total_basis_r

# -------------------- 웹훅 전송 --------------------
def _respect_min_gap():
    global _last_send_ts
    if _min_send_gap_sec <= 0:
        return
    now = time.time()
    if _last_send_ts is not None:
        gap = now - _last_send_ts
        if gap < _min_send_gap_sec:
            _sleep_with_stop(_min_send_gap_sec - gap)
    _last_send_ts = time.time()

def _post_webhook(url: str, payload_text: str, verify_ssl: bool):
    """Synology Chat Webhook 전송 (411은 Retry-After/백오프+지터 후 1회 재시도)"""
    sess = _get_session(verify_ssl)

    def _send(as_what: str) -> requests.Response:
        _respect_min_gap()
        if as_what == "payload":
            data = {"payload": json.dumps({"text": payload_text}, ensure_ascii=False)}
            return sess.post(url, data=data, headers={"Content-Type":"application/x-www-form-urlencoded; charset=utf-8"}, timeout=10)
        elif as_what == "json":
            return sess.post(url, json={"text": payload_text}, timeout=10)
        else:
            data = {"text": payload_text}
            return sess.post(url, data=data, headers={"Content-Type":"application/x-www-form-urlencoded; charset=utf-8"}, timeout=10)

    def ok_resp(r: requests.Response, j: dict) -> bool:
        # 200/204 허용, JSON이면 success=true류도 허용
        if r.status_code in (200, 204):
            if not j:
                return True
            return j.get("success") in (True, "true", "OK", "ok", None)
        return False

    def try_send_once(as_what: str) -> Tuple[bool, str]:
        r = _send(as_what)
        try:
            ct = r.headers.get("Content-Type","")
            j = r.json() if "json" in ct.lower() else {}
        except Exception:
            j = {}
        if ok_resp(r, j):
            return True, "ok"

        if r.status_code == 411:
            try:
                ra = r.headers.get("Retry-After")
                wait = float(ra) if ra is not None else 3.0
            except Exception:
                wait = 3.0
            wait += random.uniform(0, 1.0)  # 지터
            _sleep_with_stop(min(max(wait, 1.0), 10.0))
            r2 = _send(as_what)
            try:
                ct2 = r2.headers.get("Content-Type","")
                j2 = r2.json() if "json" in ct2.lower() else {}
            except Exception:
                j2 = {}
            if ok_resp(r2, j2):
                return True, "ok"
            _log_http(r2, label=f"webhook-retry-{as_what}")
            return False, f"rate-411-retry-fail:{r2.status_code}"

        _log_http(r, label=f"webhook-{as_what}")
        return False, f"http-{r.status_code}"

    for as_what in ("payload", "json", "text"):
        try:
            ok, reason = try_send_once(as_what)
        except Exception as e:
            log.warning("[WARN] webhook %s send exception: %s", as_what, e)
            ok, reason = False, "exception"
        if ok:
            return True

    raise RuntimeError("전송 실패: 레이트 리밋/권한/포맷/인증서 등을 확인하세요.")

# -------------------- 전송 크기 분할 --------------------
def _split_text_chunks(text: str, limit: int = 4000, reserve_suffix: int = 24) -> list:
    """
    텍스트를 limit자 이하로 분할하되, 뒤에 붙일 꼬리표 길이(reserve_suffix)를 미리 뺀다.
    - 가능한 한 줄 단위로 자름(\n 경계 우선, 60% 이상 채웠을 때)
    - 줄이 너무 길면 하드 컷
    """
    if text is None:
        return [""]
    s = str(text)
    eff_limit = max(200, limit - max(0, reserve_suffix))
    if len(s) <= eff_limit:
        return [s]

    parts = []
    start = 0
    while start < len(s):
        end = min(len(s), start + eff_limit)
        if end < len(s):
            nl = s.rfind("\n", start, end)
            if nl != -1 and (nl - start) >= int(eff_limit * 0.6):
                end = nl + 1
        parts.append(s[start:end])
        start = end
    return parts

def send_to_synology_chat(message: str, verify_ssl: bool):
    if not CHAT_WEBHOOK_URL:
        raise RuntimeError("CHAT_WEBHOOK_URL이 비어 있습니다. 환경변수로 설정하세요.")
    parts = _split_text_chunks(message, 4000, reserve_suffix=24)
    total = len(parts)
    for i, part in enumerate(parts, 1):
        suffix = "" if total == 1 else f"\n(part {i}/{total})"
        _post_webhook(CHAT_WEBHOOK_URL, part + suffix, verify_ssl)

def send_error_alert(message: str, verify_ssl: bool):
    _sleep_with_stop(2)
    if CHAT_ERROR_WEBHOOK_URL:
        try:
            _post_webhook(CHAT_ERROR_WEBHOOK_URL, f"[에러 알림]\n{message}", verify_ssl)
        except Exception as e:
            log.error("에러 웹훅 전송 실패: %s", e)

# -------------------- 임계치(알람) --------------------
def _check_stock_alerts(rows, alert_pl_pct, alert_pl_abs, state, report_ccy, only_etf=False) -> List[str]:
    res = []; state.setdefault("stock_alerts", {})
    for name, price, diff, pct, date, ccy, entry in rows:
        if price is None: continue
        if only_etf and not _is_etf_entry(name, entry): continue
        pos = PORTFOLIO.get(name)
        if not pos: continue
        invested, qty, _, _ = _pos_invested_qty_avg(pos)
        fx = _get_fx(ccy, report_ccy)
        market_r = (price or 0) * qty * fx
        invested_r = invested * fx
        pl_r = market_r - invested_r
        roi  = _safe_roi(pl_r, invested_r)
        need_alert = False; reason=[]
        if alert_pl_pct is not None and abs(roi) >= alert_pl_pct:
            need_alert=True; reason.append(f"수익률 {roi:.2f}% (임계 {alert_pl_pct}%)")
        if alert_pl_abs is not None and abs(pl_r) >= alert_pl_abs:
            need_alert=True; reason.append(f"손익 {pl_r:,.0f}{'원' if report_ccy=='KRW' else ' ' + report_ccy} (임계 {alert_pl_abs:,.0f}{'원' if report_ccy=='KRW' else ' ' + report_ccy})")
        if not need_alert: continue
        last = state["stock_alerts"].get(name, {})
        # 쿨다운: 같은 종목이 임계 상태를 유지할 때 알림 스팸 방지
        try:
            if last.get("ts") and (time.time() - float(last.get("ts"))) < ALERT_COOLDOWN_SEC:
                continue
        except Exception:
            pass
        last_pl = last.get("pl")
        if last_pl is None or (pl_r >= 0) != (last_pl >= 0):
            res.append(f"📣 [종목 임계] {name}: {_fmt_signed(pl_r, report_ccy)} ({_fmt_signed_pct(roi)})")
            state["stock_alerts"][name] = {"pl": pl_r, "roi": roi, "ts": time.time()}
        else:
            was_under = True
            if alert_pl_pct is not None and last.get("roi") is not None:
                was_under &= (abs(float(last["roi"])) < alert_pl_pct)
            if alert_pl_abs is not None and last.get("pl") is not None:
                was_under &= (abs(float(last["pl"])) < alert_pl_abs)
            if was_under:
                res.append(f"📣 [종목 임계] {name}: {_fmt_signed(pl_r, report_ccy)} ({_fmt_signed_pct(roi)})")
                state["stock_alerts"][name] = {"pl": pl_r, "roi": roi, "ts": time.time()}
    return res

def _check_total_alert(rows, alert_total_pl_pct, alert_total_pl_abs, state, report_ccy, only_etf=False) -> Optional[str]:
    state.setdefault("total_alert", None)
    fil_rows = rows if not only_etf else [(n,p,d,pc,dt,ccy,e) for (n,p,d,pc,dt,ccy,e) in rows if _is_etf_entry(n,e)]
    total_pl_r, total_roi, total_invested_r = _calc_totals(fil_rows, report_ccy)
    need_alert=False; reasons=[]
    if alert_total_pl_pct is not None and abs(total_roi) >= alert_total_pl_pct:
        need_alert=True; reasons.append(f"합계 수익률 {total_roi:.2f}% (임계 {alert_total_pl_pct}%)")
    if alert_total_pl_abs is not None and abs(total_pl_r) >= alert_total_pl_abs:
        need_alert=True; reasons.append(f"합계 손익 {total_pl_r:,.0f}{'원' if report_ccy=='KRW' else ' ' + report_ccy} (임계 {alert_total_pl_abs:,.0f}{'원' if report_ccy=='KRW' else ' ' + report_ccy})")
    if not need_alert: return None
    last = state.get("total_alert")
    # 쿨다운: 합계 알림 스팸 방지
    try:
        if last and last.get("ts") and (time.time() - float(last.get("ts"))) < ALERT_COOLDOWN_SEC:
            return None
    except Exception:
        pass
    if last is None or (total_pl_r >= 0) != (float(last.get("pl", 0)) >= 0):
        state["total_alert"] = {"pl": total_pl_r, "roi": total_roi, "ts": time.time()}
        return f"🚨 [합계 임계] 평가손익 {_fmt_signed(total_pl_r, report_ccy)} ({_fmt_signed_pct(total_roi)}) | 투자원금 {_fmt_money(total_invested_r, report_ccy)} | 사유: {', '.join(reasons)}"
    was_under=True
    if alert_total_pl_pct is not None and last and last.get("roi") is not None:
        was_under &= (abs(float(last["roi"])) < alert_total_pl_pct)
    if alert_total_pl_abs is not None and last and last.get("pl") is not None:
        was_under &= (abs(float(last["pl"])) < alert_total_pl_abs)
    if was_under:
        state["total_alert"] = {"pl": total_pl_r, "roi": total_roi, "ts": time.time()}
        return f"🚨 [합계 임계] 평가손익 {_fmt_signed(total_pl_r, report_ccy)} ({_fmt_signed_pct(total_roi)}) | 사유: {', '.join(reasons)}"
    return None

# -------------------- 슬립(중단가능) --------------------
def _sleep_with_stop(seconds: float):
    global _stop
    end = time.time() + float(seconds)
    try:
        while not _stop and time.time() < end:
            time.sleep(min(1.0, end - time.time()))
    except KeyboardInterrupt:
        _stop = True

# -------------------- 실행 루틴 --------------------
def run_once(verify_ssl: bool, tz_name: str, report_ccy: str, mention: str = "", title_prefix: str = "", compact: bool = False, save_history: bool = False, history_dir: str = DEFAULT_HISTORY_DIR, history_prefix: str = DEFAULT_HISTORY_PREFIX):
    _maybe_refresh_fx(report_ccy, verify_ssl)
    rows = snapshot_all(verify_ssl)
    if save_history:
        append_history_jsonl(rows, tz_name=tz_name, report_ccy=report_ccy, history_dir=history_dir, prefix=history_prefix)
    msg = format_chat_message(rows, tz_name=tz_name, report_ccy=report_ccy, mention=mention, title_prefix=title_prefix, compact=compact)
    print(msg)
    send_to_synology_chat(msg, verify_ssl)

def run_daemon(interval_sec: int, verify_ssl: bool, tz_name: str, report_ccy: str,
               mention: str = "", title_prefix: str = "",
               compact: bool = False,
               save_history: bool = False,
               history_dir: str = DEFAULT_HISTORY_DIR,
               history_prefix: str = DEFAULT_HISTORY_PREFIX,
               alerts_only: bool = False,
               alert_pl_pct: Optional[float] = None, alert_pl_abs: Optional[float] = None,
               alert_total_pl_pct: Optional[float] = None, alert_total_pl_abs: Optional[float] = None,
               state_file: str = "",
               alerts_etf_only: bool = False, alerts_total_etf_only: bool = False):
    state = _load_state(state_file); next_send = datetime.min.replace(tzinfo=None)
    while not _stop:
        now = datetime.now()
        if now >= next_send:
            try:
                _maybe_refresh_fx(report_ccy, verify_ssl)
                rows = snapshot_all(verify_ssl)
                if save_history:
                    append_history_jsonl(rows, tz_name=tz_name, report_ccy=report_ccy, history_dir=history_dir, prefix=history_prefix)
                if save_history:
                    append_history_jsonl(rows, tz_name=tz_name, report_ccy=report_ccy, history_dir=history_dir, prefix=history_prefix)
                stock_alerts = _check_stock_alerts(rows, alert_pl_pct, alert_pl_abs, state, report_ccy, only_etf=alerts_etf_only)
                total_alert  = _check_total_alert(rows, alert_total_pl_pct, alert_total_pl_abs, state, report_ccy, only_etf=alerts_total_etf_only)
                if stock_alerts or total_alert:
                    alert_text = "\n".join(([total_alert] if total_alert else []) + stock_alerts)
                    try: send_to_synology_chat(alert_text, verify_ssl)
                    except Exception as e: log.error("[에러] 임계 알림 전송 실패: %s", e); send_error_alert(str(e), verify_ssl)
                if not alerts_only:
                    msg = format_chat_message(rows, tz_name=tz_name, report_ccy=report_ccy, mention=mention, title_prefix=title_prefix, compact=compact)
                    print(msg); send_to_synology_chat(msg, verify_ssl)
                _save_state(state_file, state)
            except Exception as e:
                log.error("[에러] 데몬 루프 오류: %s", e); send_error_alert(str(e), verify_ssl)
            next_send = now + timedelta(seconds=interval_sec)
        _sleep_with_stop(5)

def run_market_hours(start_str: str, end_str: str, every_min: int, verify_ssl: bool, tz_name: str, report_ccy: str,
                     weekdays_only: bool = True, holidays: Optional[Set[ddate]] = None,
                     mention: str = "", title_prefix: str = "",
                     compact: bool = False,
                     save_history: bool = False,
                     history_dir: str = DEFAULT_HISTORY_DIR,
                     history_prefix: str = DEFAULT_HISTORY_PREFIX,
                     alerts_only: bool = False,
                     alert_pl_pct: Optional[float] = None, alert_pl_abs: Optional[float] = None,
                     alert_total_pl_pct: Optional[float] = None, alert_total_pl_abs: Optional[float] = None,
                     state_file: str = "",
                     alerts_etf_only: bool = False, alerts_total_etf_only: bool = False):
    start_t = _parse_hhmm(start_str); end_t = _parse_hhmm(end_str)
    holidays = holidays or set(); tz = _tzinfo(tz_name); state = _load_state(state_file)

    while not _stop:
        now = datetime.now(tz); today = now.date()
        is_weekend = not _is_weekday(now); is_holiday = today in holidays

        if (weekdays_only and is_weekend) or is_holiday:
            days = 1; nxt = today + timedelta(days=days)
            while (weekdays_only and nxt.weekday() >= 5) or (nxt in holidays): days += 1; nxt = today + timedelta(days=days)
            next_start = datetime.combine(nxt, start_t, tzinfo=tz)
            sleep_sec = max(5, int((next_start - now).total_seconds()))
            log.info("[대기] %s → %s 까지 %s초 대기", "휴장일" if is_holiday else "주말 제외", next_start, sleep_sec)
            _sleep_with_stop(sleep_sec); continue

        if _within(now, start_t, end_t):
            next_run = _ceil_to_next_minutes(now, every_min)
            if not _within(next_run, start_t, end_t):
                days = 1; nxt = today + timedelta(days=days)
                while (weekdays_only and nxt.weekday() >= 5) or (nxt in holidays): days += 1; nxt = today + timedelta(days=days)
                next_start = datetime.combine(nxt, start_t, tzinfo=tz)
                sleep_sec = max(5, int((next_start - now).total_seconds()))
                log.info("[대기] 창 종료 → 다음 영업일 시작 %s 까지 %s초 대기", next_start, sleep_sec)
                _sleep_with_stop(sleep_sec); continue

            try:
                _maybe_refresh_fx(report_ccy, verify_ssl)
                rows = snapshot_all(verify_ssl)
                stock_alerts = _check_stock_alerts(rows, alert_pl_pct, alert_pl_abs, state, report_ccy, only_etf=alerts_etf_only)
                total_alert  = _check_total_alert(rows, alert_total_pl_pct, alert_total_pl_abs, state, report_ccy, only_etf=alerts_total_etf_only)
                if stock_alerts or total_alert:
                    alert_text = "\n".join(([total_alert] if total_alert else []) + stock_alerts)
                    try: send_to_synology_chat(alert_text, verify_ssl)
                    except Exception as e: log.error("[에러] 임계 알림 전송 실패: %s", e); send_error_alert(str(e), verify_ssl)
                if not alerts_only:
                    msg = format_chat_message(rows, tz_name=tz_name, report_ccy=report_ccy, mention=mention, title_prefix=title_prefix, compact=compact)
                    print(msg); send_to_synology_chat(msg, verify_ssl)
                _save_state(state_file, state)
            except Exception as e:
                log.error("[에러] 전송 중 오류: %s", e); send_error_alert(str(e), verify_ssl)

            now2 = datetime.now(tz)
            sleep_sec = max(5, int((next_run - now2).total_seconds()))
            log.info("[대기] 다음 실행 %s 까지 %s초 대기", next_run, sleep_sec)
            _sleep_with_stop(sleep_sec)
        else:
            target_dt = datetime.combine(today, start_t, tzinfo=tz)
            if now >= target_dt:
                days = 1; nxt = today + timedelta(days=days)
                while (weekdays_only and nxt.weekday() >= 5) or (nxt in holidays): days += 1; nxt = today + timedelta(days=days)
                target_dt = datetime.combine(nxt, start_t, tzinfo=tz)
            sleep_sec = max(5, int((target_dt - now).total_seconds()))
            log.info("[대기] 시간 창 외 → %s 까지 %s초 대기", target_dt, sleep_sec)
            _sleep_with_stop(sleep_sec)


# -------------------- PID 락(단일 인스턴스) --------------------
_pid_file_path: str = ""

def _acquire_pid_lock(pid_file: str):
    """pid_file이 지정되면 단일 인스턴스 실행을 보장한다."""
    global _pid_file_path
    if not pid_file:
        return
    try:
        # 디렉터리 생성(가능하면)
        d = os.path.dirname(pid_file)
        if d:
            os.makedirs(d, exist_ok=True)
    except Exception:
        pass

    # 이미 존재 + PID가 살아있으면 중복 실행으로 판단
    try:
        if os.path.exists(pid_file):
            with open(pid_file, "r", encoding="utf-8") as f:
                old = (f.read() or "").strip()
            if old.isdigit():
                old_pid = int(old)
                try:
                    os.kill(old_pid, 0)  # 프로세스 존재 여부 확인
                    raise RuntimeError(f"이미 실행 중입니다(pid={old_pid}). pid_file={pid_file}")
                except ProcessLookupError:
                    # 죽은 PID → 덮어씀
                    pass
                except PermissionError:
                    # 권한으로 확인 불가 → 보수적으로 중복 실행 방지
                    raise RuntimeError(f"PID 확인 권한이 없어 중복 실행을 막습니다. pid_file={pid_file}")
    except RuntimeError:
        raise
    except Exception:
        # pid 읽기 실패는 덮어쓰기 허용
        pass

    try:
        with open(pid_file, "w", encoding="utf-8") as f:
            f.write(str(os.getpid()))
        _pid_file_path = pid_file
        atexit.register(_release_pid_lock)
        log.info("[PID] lock acquired: %s", pid_file)
    except Exception as e:
        raise RuntimeError(f"PID 파일 생성 실패: {pid_file} ({e})")

def _release_pid_lock():
    global _pid_file_path
    if not _pid_file_path:
        return
    try:
        if os.path.exists(_pid_file_path):
            os.remove(_pid_file_path)
            log.info("[PID] lock released: %s", _pid_file_path)
    except Exception:
        pass
    _pid_file_path = ""


# -------------------- main --------------------
def main():
    global VERIFY_SSL, STOCKS, PORTFOLIO, DIVIDENDS, FX_RATES
    global _auto_fx_enabled, _auto_fx_extra, _fx_refresh_minutes, _last_fx_fetch
    global _commission_rate, _sell_tax_rate_stock, _sell_tax_rate_etf, _include_buy_commission_in_cost

    _install_signal_handlers()

    p = argparse.ArgumentParser(description="Synology Chat으로 네이버 주가/ETF 알림 (배당/환율/ETF필터+자동환율+수수료/세금)")
    p.add_argument("--daemon", action="store_true", help="지정 간격으로 반복 전송")
    p.add_argument("--interval", type=int, default=DEFAULT_INTERVAL, help="반복 전송 간격(초), 기본 1200")
    p.add_argument("--insecure", action="store_true", help="SSL 검증 비활성화(자가서명 인증서일 때)")
    # 장중
    p.add_argument("--market-hours", action="store_true", help="장시간 내 주기 전송")
    p.add_argument("--start", default="09:00", help="--market-hours 시작 시각(HH:MM)")
    p.add_argument("--end", default="15:30", help="--market-hours 종료 시각(HH:MM)")
    p.add_argument("--every-min", type=int, default=10, help="--market-hours 전송 주기(분)")
    p.add_argument("--no-weekdays-only", action="store_true", help="주말에도 전송하려면 지정")
    p.add_argument("--tz", default=DEFAULT_TZ, help="시간대(기본 Asia/Seoul)")
    # 휴장일
    p.add_argument("--holiday", action="append", default=[], help="휴장일 YYYY-MM-DD (여러 번 지정)")
    p.add_argument("--holiday-file", default="", help="휴장일 파일(JSON/CSV/텍스트)")
    # 외부 데이터
    p.add_argument("--stocks-file", default="", help="종목 코드/속성 JSON {'이름':'코드'} or {'이름':{'code','type','currency'}}")
    p.add_argument("--portfolio-file", default="", help="포트폴리오 JSON {'이름': {'buy_price,qty'} or lots}")
    p.add_argument("--dividends-file", default="", help="분배금 JSON {'이름': {'currency','items':[...] } }")
    p.add_argument("--fx-file", default="", help="환율 JSON {'USD':1350,'KRW':1,...}")
    # 환율 수동/자동
    p.add_argument("--fx", action="append", default=[], help="수동 환율(예: USD=1350). 여러번 지정 가능")
    p.add_argument("--report-ccy", default=DEFAULT_REPORT_CCY, help="리포트 통화(기본 KRW)")
    p.add_argument("--auto-fx", action="store_true", help="자동으로 환율 불러오기")
    p.add_argument("--auto-fx-extra", default="", help="자동 환율에 추가할 통화(쉼표구분)")
    p.add_argument("--fx-refresh-min", type=int, default=720, help="자동 환율 갱신 주기(분)")
    # 메시지
    p.add_argument("--mention", default="", help="메시지 상단 멘션/텍스트")
    p.add_argument("--title-prefix", default="", help="제목 접두어")
    p.add_argument("--compact", action="store_true", help="메시지를 2~3줄 요약 형태로 출력(가독성 향상)")
    # 히스토리(월간 CSV 리포트 원천)
    p.add_argument("--save-history", action="store_true", help="스냅샷을 JSONL로 저장(월간 리포트용)")
    p.add_argument("--history-dir", default=DEFAULT_HISTORY_DIR, help="히스토리 저장 폴더")
    p.add_argument("--history-prefix", default=DEFAULT_HISTORY_PREFIX, help="히스토리 파일 접두어")
    # 수수료/세금 옵션 (bps 입력)
    p.add_argument("--commission-bps", type=float, default=None,
                   help="커미션(bp). 예: 1.5bp=0.015%%는 1.5. 지정하지 않으면 --venue에 따라 기본값 적용")
    p.add_argument("--sell-tax-bps-stock", type=float, default=0.0, help="주식 매도 거래세(bp). 예: 20bp=0.20%%는 20")
    p.add_argument("--sell-tax-bps-etf", type=float, default=0.0, help="ETF 매도 거래세(bp). 보통 0")
    p.add_argument("--no-buy-commission-into-cost", action="store_true",
                   help="매수 커미션을 취득원가에 포함하지 않음(기본 포함)")
    p.add_argument("--venue", choices=["krx","nxt"], default="krx",
                   help="기본 커미션 적용 시장: krx=0.015%%, nxt=0.0145%% (commission-bps 미지정 시에만 적용)")
    # 임계치 알람
    p.add_argument("--alert-pl-pct", type=float, default=None, help="종목별 손익률 임계치(절대값, %)")
    p.add_argument("--alert-pl-abs", type=float, default=None, help="종목별 손익액 임계치(절대값, 리포트통화)")
    p.add_argument("--alert-total-pl-pct", type=float, default=None, help="합계 손익률 임계치(절대값, %)")
    p.add_argument("--alert-total-pl-abs", type=float, default=None, help="합계 손익액 임계치(절대값, 리포트통화)")
    p.add_argument("--alerts-only", action="store_true", help="임계치 충족 시 알림만 전송(스냅샷 생략)")
    p.add_argument("--state-file", default=".naver_stock_state.json", help="임계치 중복 억제용 상태파일 경로")
    p.add_argument("--pid-file", default=DEFAULT_PID_FILE, help="단일 인스턴스 실행 보장 PID 파일 경로(빈 문자열이면 비활성)")
    p.add_argument("--no-pid-lock", action="store_true", help="PID 락 비활성화(중복 실행 허용)")

    args = p.parse_args()
    if args.insecure: VERIFY_SSL = False

    # 단일 인스턴스 실행(옵션)
    pid_file = "" if getattr(args, "no_pid_lock", False) else (getattr(args, "pid_file", "") or "")
    try:
        _acquire_pid_lock(pid_file)
    except Exception as e:
        log.error(str(e))
        sys.exit(1)

    # 외부 파일 로드(관대 파서)
    if args.stocks_file:
        try:
            STOCKS = _load_json(args.stocks_file); assert isinstance(STOCKS, dict); log.info("종목 로드: %d개", len(STOCKS))
        except Exception as e:
            log.error("종목 파일 로드 실패: %s", e)
    if args.portfolio_file:
        try:
            PORTFOLIO = _load_json(args.portfolio_file); assert isinstance(PORTFOLIO, dict); log.info("포트폴리오 로드: %d개", len(PORTFOLIO))
        except Exception as e:
            log.error("포트폴리오 파일 로드 실패: %s", e)
    if args.dividends_file:
        try:
            DIVIDENDS = _load_json(args.dividends_file); assert isinstance(DIVIDENDS, dict); log.info("분배금 로드: %d개 종목", len(DIVIDENDS))
        except Exception as e:
            log.error("분배금 파일 로드 실패: %s", e)

    # 환율: 파일 → 수동 CLI → 자동
    if args.fx_file:
        try: FX_RATES.update(_load_json(args.fx_file)); log.info("환율 로드: %s", FX_RATES)
        except Exception as e: log.error("환율 파일 로드 실패: %s", e)
    if args.fx:
        FX_RATES.update(_parse_fx_pairs(args.fx)); log.info("환율 적용(추가): %s", FX_RATES)

    # 자동 환율 설정
    _auto_fx_enabled = bool(args.auto_fx)
    _fx_refresh_minutes = int(args.fx_refresh_min or 720)
    _auto_fx_extra = {t.strip().upper() for t in (args.auto_fx_extra or "").split(",") if t.strip()}

    # 리포트 통화 안전값
    if args.report_ccy.upper() not in FX_RATES: FX_RATES[args.report_ccy.upper()] = 1.0

    # 휴장일 합치기
    holidays: Set[ddate] = set()
    if args.holiday: holidays |= _parse_holiday_dates(args.holiday)
    if args.holiday_file: holidays |= _load_holidays_from_file(args.holiday_file)

    # 수수료/세금 옵션(bps → rate)
    if args.commission_bps is None:
        venue_default_bps = 1.5 if args.venue == "krx" else 1.45
        commission_bps_effective = venue_default_bps
    else:
        commission_bps_effective = float(args.commission_bps)

    _commission_rate = float(commission_bps_effective) / 10000.0
    _sell_tax_rate_stock = float(args.sell_tax_bps_stock or 0.0) / 10000.0
    _sell_tax_rate_etf = float(args.sell_tax_bps_etf or 0.0) / 10000.0
    _include_buy_commission_in_cost = not bool(args.no_buy_commission_into_cost)

    log.info("[FEE] venue=%s, commission=%.5f%%, tax(stock/etf)=%.5f%%/%.5f%%, buy_comm_in_cost=%s",
             args.venue, _commission_rate*100, _sell_tax_rate_stock*100, _sell_tax_rate_etf*100,
             _include_buy_commission_in_cost)

    # 시작 시 1회 환율 자동 갱신(옵션 켠 경우) — 최초 보장
    if _auto_fx_enabled:
        _last_fx_fetch = None
        _auto_fetch_and_update_fx(args.report_ccy.upper(), VERIFY_SSL)

    try:
        if args.market_hours:
            log.info("[INFO] 장시간 모드 시작 (%s~%s, %d분 간격, 주말제외=%s, 휴장일=%d, SSL=%s, TZ=%s, REP=%s, AUTO_FX=%s/%d분)",
                     args.start, args.end, args.every_min, not args.no_weekdays_only, len(holidays),
                     VERIFY_SSL, args.tz, args.report_ccy.upper(), _auto_fx_enabled, _fx_refresh_minutes)
            run_market_hours(args.start, args.end, args.every_min, VERIFY_SSL,
                tz_name=args.tz, report_ccy=args.report_ccy.upper(),
                weekdays_only=not args.no_weekdays_only, holidays=holidays,
                mention=args.mention, title_prefix=args.title_prefix,
                compact=bool(args.compact),
                save_history=bool(args.save_history),
                history_dir=str(args.history_dir),
                history_prefix=str(args.history_prefix),
                alerts_only=args.alerts_only,
                alert_pl_pct=args.alert_pl_pct, alert_pl_abs=args.alert_pl_abs,
                alert_total_pl_pct=args.alert_total_pl_pct, alert_total_pl_abs=args.alert_total_pl_abs,
                state_file=args.state_file)
        elif args.daemon:
            log.info("[INFO] 데몬 모드 시작 (간격: %d초, SSL=%s, TZ=%s, REP=%s, AUTO_FX=%s/%d분)",
                     args.interval, VERIFY_SSL, args.tz, args.report_ccy.upper(), _auto_fx_enabled, _fx_refresh_minutes)
            run_daemon(args.interval, VERIFY_SSL, tz_name=args.tz, report_ccy=args.report_ccy.upper(),
                mention=args.mention, title_prefix=args.title_prefix,
                compact=bool(args.compact),
                alerts_only=args.alerts_only,
                alert_pl_pct=args.alert_pl_pct, alert_pl_abs=args.alert_pl_abs,
                alert_total_pl_pct=args.alert_total_pl_pct, alert_total_pl_abs=args.alert_total_pl_abs,
                state_file=args.state_file)
        else:
            run_once(VERIFY_SSL, tz_name=args.tz, report_ccy=args.report_ccy.upper(),
                     mention=args.mention, title_prefix=args.title_prefix, compact=bool(args.compact),
                     save_history=bool(args.save_history), history_dir=str(args.history_dir), history_prefix=str(args.history_prefix))
    except KeyboardInterrupt:
        log.info("사용자 중단(Ctrl+C) 감지 → 안전 종료합니다.")
    except Exception as e:
        log.error("치명적 오류: %s", e); send_error_alert(str(e), VERIFY_SSL); sys.exit(1)

if __name__ == "__main__":
    main()

게시물 개인 투자용 주식 자동화 시스템 구조 설명이 하우인포-IT·테크에 처음 등장했습니다.

✅ 왜 DB에 저장해야 할까?

많은 분들이 이런 자동화 봇을 만듭니다.

• 네이버/증권 API로 주가 조회
• 보유 종목 수익률 계산
• Synology Chat, Slack, 텔레그램으로 알림 전송

하지만 시간이 지나면 이런 생각이 들죠.

“어제보다 오늘 얼마나 늘었지?”
“한 달 동안 수익률 추이가 어땠지?”
“어떤 종목이 실제로 수익에 가장 기여했지?”

👉 알림 메시지로는 절대 알 수 없습니다.
👉 시계열 데이터(History)가 필요합니다.

🧠 해결 방법 구조

가장 간단하고 강력한 구조는 아래입니다.

[파이썬 주식 봇]
        ↓
   SQLite DB 저장
        ↓
 Streamlit 웹 대시보드

이 방법의 장점은:

• 별도 서버 불필요
• DB는 파일 하나 (백업 쉬움)
• 오렌지파이 / 라즈베리파이에서도 충분히 동작
• 웹에서 그래프로 바로 확인 가능

🗄️ 1단계 — SQLite DB 설계

봇이 실행될 때마다 2가지 정보를 저장합니다.

① 포트폴리오 전체 요약 (1행)

② 종목별 스냅샷 (종목 수 만큼)

💾 SQLite 저장 코드 (봇에 추가)

import sqlite3
from datetime import datetime

DB_PATH = "/home/orangepi/python/data/portfolio.db"

def init_db():
    con = sqlite3.connect(DB_PATH)
    cur = con.cursor()

    cur.execute("""
    CREATE TABLE IF NOT EXISTS portfolio_snapshot (
      ts TEXT PRIMARY KEY,
      total_value_krw REAL,
      total_invested_krw REAL,
      total_pl_krw REAL,
      total_roi_pct REAL
    )
    """)

    cur.execute("""
    CREATE TABLE IF NOT EXISTS holding_snapshot (
      ts TEXT,
      name TEXT,
      qty REAL,
      avg_buy REAL,
      price REAL,
      market_value_krw REAL,
      pl_krw REAL,
      roi_pct REAL,
      PRIMARY KEY (ts, name)
    )
    """)
    con.commit()
    con.close()

봇이 계산을 마친 시점에 다음 함수 호출만 추가하면 됩니다.

def save_snapshot(summary, holdings):
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    con = sqlite3.connect(DB_PATH)
    cur = con.cursor()

    cur.execute("""
    INSERT OR REPLACE INTO portfolio_snapshot VALUES (?,?,?,?,?)
    """, (ts,
          summary["total_value_krw"],
          summary["total_invested_krw"],
          summary["total_pl_krw"],
          summary["total_roi_pct"]))

    for h in holdings:
        cur.execute("""
        INSERT OR REPLACE INTO holding_snapshot VALUES (?,?,?,?,?,?,?,?)
        """, (ts, h["name"], h["qty"], h["avg_buy"],
              h["price"], h["market_value_krw"],
              h["pl_krw"], h["roi_pct"]))

    con.commit()
    con.close()

🌐 2단계 — Streamlit 웹 대시보드 만들기

Streamlit은 파이썬으로 웹을 만드는 가장 쉬운 도구입니다.

설치:

pip install streamlit pandas

dashboard.py 생성:

import sqlite3, pandas as pd
import streamlit as st

DB_PATH = "/home/orangepi/python/data/portfolio.db"

st.title("📈 포트폴리오 대시보드")

con = sqlite3.connect(DB_PATH)
snap = pd.read_sql_query("SELECT * FROM portfolio_snapshot ORDER BY ts", con)
hold = pd.read_sql_query("SELECT * FROM holding_snapshot ORDER BY ts", con)
con.close()

st.subheader("총 평가금액 추이")
st.line_chart(snap.set_index("ts")["total_value_krw"])

st.subheader("총 손익 추이")
st.line_chart(snap.set_index("ts")["total_pl_krw"])

st.subheader("최근 종목별 손익")
latest = hold["ts"].max()
st.dataframe(
    hold[hold["ts"] == latest].sort_values("pl_krw", ascending=False)
)

실행:

streamlit run dashboard.py --server.port 8501

이제 브라우저에서 접속하면 주식 손익 그래프 웹페이지가 열립니다.

📊 이렇게 보입니다

4

• 총 자산 증가 추이
• 손익 변동 그래프
• 종목별 수익 기여도
• 자산 비중 파이차트 (추가 가능)

🚀 이 방식의 진짜 장점

✨ 확장 아이디어

• 주간/월간 리포트를 자동으로 PNG 그래프로 생성 후 Chat 전송
• Grafana/Metabase 연결
• 종목별 ROI 히스토리 그래프
• 자산군(ETF/주식/금) 비중 변화 추이

✅ 마무리

주식 자동화 봇을 만들었다면, 이제는 데이터를 쌓아야 할 단계입니다.

기록되지 않는 수익률은, 결국 기억에만 남습니다.

SQLite + Streamlit 조합은
가볍고, 쉽고, 강력한 개인 투자자용 대시보드를 만드는 최고의 방법입니다.

지금 사용 중인 주식 봇에 단 50줄만 추가해보세요.
당신의 투자가 ‘데이터’로 보이기 시작합니다.

다음시간에 실시간 기록을 남기는 소스를 보겠습니다.

게시물 📈 파이썬 주식 봇 데이터를 DB에 저장하고 웹 대시보드로 보는 방법 (SQLite + Streamlit)이 하우인포-IT·테크에 처음 등장했습니다.