436 lines
13 KiB
Python
436 lines
13 KiB
Python
"""
|
|
운영 포트폴리오 스냅샷·최근 24시간 수익률 텔레그램 리포트.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
from typing import Any
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from config import (
|
|
COIN_NAME,
|
|
COIN_TELEGRAM_BOT_TOKEN,
|
|
COIN_TELEGRAM_CHAT_ID,
|
|
DAILY_PNL_REPORT_ENABLED,
|
|
DAILY_PNL_REPORT_HOUR,
|
|
DAILY_PNL_REPORT_MINUTE,
|
|
DAILY_PNL_REPORT_TZ,
|
|
DAILY_PNL_SNAPSHOT_ON_LIVE,
|
|
DAILY_PNL_SNAPSHOT_RETENTION_DAYS,
|
|
ENTRY_INTERVAL,
|
|
GT_INITIAL_CASH_KRW,
|
|
SYMBOL,
|
|
)
|
|
from deepcoin.ops.monitor import Monitor
|
|
from deepcoin.paths import LIVE_TRADES_LOG, PORTFOLIO_SNAPSHOTS_LOG, ensure_dirs
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
ROLLING_HOURS = 24
|
|
MAX_ANCHOR_SKEW_HOURS = 6
|
|
|
|
|
|
def _report_tz() -> ZoneInfo:
|
|
"""
|
|
리포트 기준 타임존.
|
|
|
|
Returns:
|
|
ZoneInfo (잘못된 이름이면 UTC).
|
|
"""
|
|
try:
|
|
return ZoneInfo(DAILY_PNL_REPORT_TZ)
|
|
except Exception:
|
|
logger.warning("DAILY_PNL_REPORT_TZ=%s invalid, using UTC", DAILY_PNL_REPORT_TZ)
|
|
return ZoneInfo("UTC")
|
|
|
|
|
|
def _parse_ts(value: str) -> datetime:
|
|
"""ISO 시각 → timezone-aware datetime."""
|
|
dt = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
|
|
if dt.tzinfo is None:
|
|
dt = dt.replace(tzinfo=timezone.utc)
|
|
return dt
|
|
|
|
|
|
def fetch_mark_price(monitor: Monitor, symbol: str = SYMBOL) -> float:
|
|
"""
|
|
최근 종가(3분봉)를 조회합니다.
|
|
|
|
Args:
|
|
monitor: Monitor 인스턴스.
|
|
symbol: 통화 코드.
|
|
|
|
Returns:
|
|
종가. 실패 시 0.
|
|
"""
|
|
try:
|
|
data = monitor.get_coin_data(symbol, interval=ENTRY_INTERVAL)
|
|
if data is None or data.empty:
|
|
return 0.0
|
|
return float(data["Close"].iloc[-1])
|
|
except Exception as exc:
|
|
logger.warning("mark price fetch failed: %s", exc)
|
|
return 0.0
|
|
|
|
|
|
def portfolio_from_balances(
|
|
balances: dict[str, dict[str, float]],
|
|
mark_price: float,
|
|
*,
|
|
ts: datetime | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
잔고·시세로 총자산 스냅샷 dict를 만듭니다.
|
|
|
|
Args:
|
|
balances: load_balances_dict() 결과.
|
|
mark_price: 코인 평가 단가.
|
|
ts: 기록 시각 (None이면 now UTC).
|
|
|
|
Returns:
|
|
스냅샷 필드 dict.
|
|
"""
|
|
when = ts or datetime.now(timezone.utc)
|
|
krw = float((balances.get("KRW") or {}).get("balance") or 0.0)
|
|
qty = float((balances.get(SYMBOL) or {}).get("balance") or 0.0)
|
|
holding_value = qty * mark_price if mark_price > 0 else 0.0
|
|
total = krw + holding_value
|
|
return {
|
|
"ts": when.isoformat(timespec="seconds"),
|
|
"symbol": SYMBOL,
|
|
"krw": round(krw, 0),
|
|
"coin_qty": qty,
|
|
"mark_price": mark_price,
|
|
"holding_value_krw": round(holding_value, 0),
|
|
"total_asset_krw": round(total, 0),
|
|
}
|
|
|
|
|
|
def fetch_portfolio_snapshot(monitor: Monitor) -> dict[str, Any]:
|
|
"""
|
|
API 잔고·시세로 현재 포트폴리오 스냅샷을 조회합니다.
|
|
|
|
Args:
|
|
monitor: Monitor 인스턴스.
|
|
|
|
Returns:
|
|
portfolio_from_balances 결과.
|
|
|
|
Raises:
|
|
RuntimeError: 잔고 API 오류.
|
|
"""
|
|
balances = monitor.load_balances_dict()
|
|
mark = fetch_mark_price(monitor)
|
|
if mark <= 0:
|
|
raise RuntimeError("mark price unavailable")
|
|
return portfolio_from_balances(balances, mark)
|
|
|
|
|
|
def append_portfolio_snapshot(snapshot: dict[str, Any]) -> None:
|
|
"""portfolio_snapshots.jsonl에 1행 추가 후 오래된 행 정리."""
|
|
ensure_dirs()
|
|
PORTFOLIO_SNAPSHOTS_LOG.parent.mkdir(parents=True, exist_ok=True)
|
|
with PORTFOLIO_SNAPSHOTS_LOG.open("a", encoding="utf-8") as f:
|
|
f.write(json.dumps(snapshot, ensure_ascii=False) + "\n")
|
|
_prune_snapshots(DAILY_PNL_SNAPSHOT_RETENTION_DAYS)
|
|
|
|
|
|
def _prune_snapshots(retention_days: int) -> None:
|
|
"""보관 일수 초과 스냅샷 삭제."""
|
|
if not PORTFOLIO_SNAPSHOTS_LOG.is_file():
|
|
return
|
|
cutoff = datetime.now(timezone.utc) - timedelta(days=retention_days)
|
|
kept: list[str] = []
|
|
try:
|
|
for line in PORTFOLIO_SNAPSHOTS_LOG.read_text(encoding="utf-8").splitlines():
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
row = json.loads(line)
|
|
if _parse_ts(row["ts"]) >= cutoff:
|
|
kept.append(line)
|
|
except (json.JSONDecodeError, OSError, KeyError) as exc:
|
|
logger.warning("snapshot prune skipped: %s", exc)
|
|
return
|
|
PORTFOLIO_SNAPSHOTS_LOG.write_text(
|
|
"\n".join(kept) + ("\n" if kept else ""),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
|
|
def load_snapshots() -> list[dict[str, Any]]:
|
|
"""스냅샷 jsonl 전체 로드 (시각 오름차순)."""
|
|
if not PORTFOLIO_SNAPSHOTS_LOG.is_file():
|
|
return []
|
|
rows: list[dict[str, Any]] = []
|
|
for line in PORTFOLIO_SNAPSHOTS_LOG.read_text(encoding="utf-8").splitlines():
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
try:
|
|
rows.append(json.loads(line))
|
|
except json.JSONDecodeError:
|
|
continue
|
|
rows.sort(key=lambda r: _parse_ts(r["ts"]))
|
|
return rows
|
|
|
|
|
|
def _nearest_snapshot(
|
|
snapshots: list[dict[str, Any]],
|
|
target: datetime,
|
|
) -> tuple[dict[str, Any] | None, float]:
|
|
"""
|
|
target에 가장 가까운 스냅샷.
|
|
|
|
Returns:
|
|
(스냅샷, |시차| 시간).
|
|
"""
|
|
if not snapshots:
|
|
return None, 0.0
|
|
best = snapshots[0]
|
|
best_hours = abs((_parse_ts(best["ts"]) - target).total_seconds()) / 3600.0
|
|
for row in snapshots[1:]:
|
|
hours = abs((_parse_ts(row["ts"]) - target).total_seconds()) / 3600.0
|
|
if hours < best_hours:
|
|
best = row
|
|
best_hours = hours
|
|
return best, best_hours
|
|
|
|
|
|
def count_trades_since(path: Path, since: datetime) -> dict[str, int]:
|
|
"""
|
|
live_trades.jsonl에서 구간 내 체결 건수.
|
|
|
|
Returns:
|
|
{"buy": n, "sell": n, "ok": n}.
|
|
"""
|
|
out = {"buy": 0, "sell": 0, "ok": 0}
|
|
if not path.is_file():
|
|
return out
|
|
for line in path.read_text(encoding="utf-8").splitlines():
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
try:
|
|
row = json.loads(line)
|
|
except json.JSONDecodeError:
|
|
continue
|
|
if not row.get("ok"):
|
|
continue
|
|
try:
|
|
ts = _parse_ts(str(row.get("ts", "")))
|
|
except (TypeError, ValueError):
|
|
continue
|
|
if ts < since:
|
|
continue
|
|
side = str(row.get("side", "")).lower()
|
|
if side in out:
|
|
out[side] += 1
|
|
out["ok"] += 1
|
|
return out
|
|
|
|
|
|
def compute_24h_return(
|
|
current: dict[str, Any],
|
|
snapshots: list[dict[str, Any]] | None = None,
|
|
*,
|
|
baseline_krw: float | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
최근 24시간 총자산 수익률을 계산합니다.
|
|
|
|
Args:
|
|
current: 현재 스냅샷.
|
|
snapshots: 과거 스냅샷 목록 (None이면 파일 로드).
|
|
baseline_krw: 앵커 없을 때 대체 기준(초기 자금).
|
|
|
|
Returns:
|
|
리포트 dict (pnl_pct, anchor, trade_counts 등).
|
|
"""
|
|
snapshots = snapshots if snapshots is not None else load_snapshots()
|
|
now = _parse_ts(current["ts"])
|
|
target = now - timedelta(hours=ROLLING_HOURS)
|
|
anchor, skew_h = _nearest_snapshot(snapshots, target)
|
|
|
|
base_asset = float(baseline_krw or GT_INITIAL_CASH_KRW)
|
|
anchor_ts = None
|
|
anchor_note = f"기준=초기자금 ₩{base_asset:,.0f} (24h 스냅샷 없음)"
|
|
|
|
if anchor is not None:
|
|
base_asset = float(anchor["total_asset_krw"])
|
|
anchor_ts = anchor["ts"]
|
|
if skew_h <= MAX_ANCHOR_SKEW_HOURS:
|
|
anchor_note = f"기준=24h 전 스냅샷 ({anchor_ts}, 시차 {skew_h:.1f}h)"
|
|
else:
|
|
anchor_note = (
|
|
f"기준=가장 가까운 스냅샷 ({anchor_ts}, 24h 대비 시차 {skew_h:.1f}h)"
|
|
)
|
|
|
|
final_asset = float(current["total_asset_krw"])
|
|
pnl_krw = final_asset - base_asset
|
|
pnl_pct = (pnl_krw / base_asset * 100.0) if base_asset > 0 else 0.0
|
|
cum_pct = (
|
|
(final_asset - GT_INITIAL_CASH_KRW) / GT_INITIAL_CASH_KRW * 100.0
|
|
if GT_INITIAL_CASH_KRW > 0
|
|
else 0.0
|
|
)
|
|
|
|
trades = count_trades_since(LIVE_TRADES_LOG, target)
|
|
|
|
return {
|
|
"current": current,
|
|
"anchor": anchor,
|
|
"anchor_ts": anchor_ts,
|
|
"anchor_note": anchor_note,
|
|
"anchor_skew_hours": skew_h if anchor else None,
|
|
"base_asset_krw": base_asset,
|
|
"final_asset_krw": final_asset,
|
|
"pnl_krw": pnl_krw,
|
|
"pnl_pct": pnl_pct,
|
|
"cumulative_pnl_pct": cum_pct,
|
|
"trade_counts": trades,
|
|
"window_hours": ROLLING_HOURS,
|
|
}
|
|
|
|
|
|
def build_daily_pnl_message(report: dict[str, Any]) -> str:
|
|
"""
|
|
텔레그램 본문 생성.
|
|
|
|
Args:
|
|
report: compute_24h_return 결과.
|
|
|
|
Returns:
|
|
메시지 문자열.
|
|
"""
|
|
cur = report["current"]
|
|
sign = "+" if report["pnl_pct"] >= 0 else ""
|
|
cum_sign = "+" if report["cumulative_pnl_pct"] >= 0 else ""
|
|
tc = report["trade_counts"]
|
|
tz = _report_tz()
|
|
now_local = _parse_ts(cur["ts"]).astimezone(tz).strftime("%Y-%m-%d %H:%M")
|
|
|
|
lines = [
|
|
f"[DeepCoin 일일 리포트] {COIN_NAME} ({SYMBOL})",
|
|
f"시각: {now_local} ({DAILY_PNL_REPORT_TZ})",
|
|
"",
|
|
f"최근 {report['window_hours']}시간 수익률: {sign}{report['pnl_pct']:.2f}%",
|
|
f" 손익: {sign}₩{report['pnl_krw']:,.0f}",
|
|
f" {report['anchor_note']}",
|
|
f" 24h 전 총자산: ₩{report['base_asset_krw']:,.0f}",
|
|
f" 현재 총자산: ₩{report['final_asset_krw']:,.0f}",
|
|
"",
|
|
f"누적(초기 ₩{GT_INITIAL_CASH_KRW:,} 대비): {cum_sign}{report['cumulative_pnl_pct']:.2f}%",
|
|
"",
|
|
"현재 잔고",
|
|
f" 현금: ₩{float(cur['krw']):,.0f}",
|
|
f" {SYMBOL}: {float(cur['coin_qty']):.4f} (₩{float(cur['holding_value_krw']):,.0f} @ ₩{float(cur['mark_price']):,.0f})",
|
|
"",
|
|
f"24h 체결(성공): 매수 {tc['buy']} · 매도 {tc['sell']} · 합계 {tc['ok']}",
|
|
"※ 총자산=현금+보유×종가. 미실현 포함.",
|
|
]
|
|
return "\n".join(lines)
|
|
|
|
|
|
def maybe_record_portfolio_snapshot(monitor: Monitor) -> None:
|
|
"""
|
|
06 루프용: 설정 시 스냅샷만 기록 (텔레그램 없음).
|
|
|
|
Args:
|
|
monitor: Monitor/LiveTrader 인스턴스.
|
|
"""
|
|
if not DAILY_PNL_SNAPSHOT_ON_LIVE:
|
|
return
|
|
try:
|
|
snap = fetch_portfolio_snapshot(monitor)
|
|
append_portfolio_snapshot(snap)
|
|
except Exception as exc:
|
|
logger.warning("portfolio snapshot skip: %s", exc)
|
|
|
|
|
|
def send_daily_pnl_report(
|
|
monitor: Monitor | None = None,
|
|
*,
|
|
send_telegram: bool = True,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
스냅샷 저장 → 24h 수익률 계산 → 텔레그램 발송.
|
|
|
|
Args:
|
|
monitor: None이면 Monitor() 생성.
|
|
send_telegram: False면 메시지만 반환·콘솔 출력.
|
|
|
|
Returns:
|
|
compute_24h_return 결과 + message 키.
|
|
"""
|
|
if not DAILY_PNL_REPORT_ENABLED:
|
|
raise RuntimeError("DAILY_PNL_REPORT_ENABLED=0")
|
|
|
|
mon = monitor or Monitor(cooldown_file=None)
|
|
current = fetch_portfolio_snapshot(mon)
|
|
append_portfolio_snapshot(current)
|
|
report = compute_24h_return(current)
|
|
msg = build_daily_pnl_message(report)
|
|
report["message"] = msg
|
|
|
|
print(msg)
|
|
if send_telegram:
|
|
if not COIN_TELEGRAM_BOT_TOKEN or not COIN_TELEGRAM_CHAT_ID:
|
|
print("[telegram skip] COIN_TELEGRAM_BOT_TOKEN/CHAT_ID 미설정")
|
|
else:
|
|
mon._send_coin_msg(msg)
|
|
return report
|
|
|
|
|
|
def seconds_until_next_report(
|
|
hour: int | None = None,
|
|
minute: int | None = None,
|
|
) -> float:
|
|
"""
|
|
다음 리포트 시각(로컬 TZ)까지 대기 초.
|
|
|
|
Args:
|
|
hour: 시 (기본 DAILY_PNL_REPORT_HOUR).
|
|
minute: 분 (기본 DAILY_PNL_REPORT_MINUTE).
|
|
|
|
Returns:
|
|
초 (>= 1).
|
|
"""
|
|
tz = _report_tz()
|
|
h = DAILY_PNL_REPORT_HOUR if hour is None else hour
|
|
m = DAILY_PNL_REPORT_MINUTE if minute is None else minute
|
|
now = datetime.now(tz)
|
|
target = now.replace(hour=h, minute=m, second=0, microsecond=0)
|
|
if target <= now:
|
|
target += timedelta(days=1)
|
|
return max((target - now).total_seconds(), 1.0)
|
|
|
|
|
|
def run_schedule_loop(monitor: Monitor | None = None) -> None:
|
|
"""
|
|
매일 지정 시각에 리포트를 발송하는 무한 루프.
|
|
|
|
Args:
|
|
monitor: 재사용할 Monitor (None이면 매 회 생성).
|
|
"""
|
|
tz = _report_tz()
|
|
print(
|
|
f"[07] 일일 수익률 텔레그램 · {DAILY_PNL_REPORT_HOUR:02d}:"
|
|
f"{DAILY_PNL_REPORT_MINUTE:02d} {tz.key} · Ctrl+C 종료"
|
|
)
|
|
while True:
|
|
wait = seconds_until_next_report()
|
|
next_at = datetime.now(tz) + timedelta(seconds=wait)
|
|
print(f"[07] 다음 발송: {next_at:%Y-%m-%d %H:%M:%S} (대기 {wait / 3600:.2f}h)")
|
|
import time
|
|
|
|
time.sleep(wait)
|
|
try:
|
|
send_daily_pnl_report(monitor)
|
|
except Exception as exc:
|
|
print(f"[07] 리포트 오류: {exc}")
|