Bithumb/scripts/0_ground_truth_futures.py

#!/usr/bin/env python3
"""0단계: 선물 GT 타점 차트 (현물 GT → 롱·숏 4색 마커)."""

from __future__ import annotations

import argparse
import json
import logging
import sys
from copy import deepcopy
from pathlib import Path
from typing import Any

ROOT = Path(__file__).resolve().parents[1]
SRC = ROOT / "src"
if str(SRC) not in sys.path:
    sys.path.insert(0, str(SRC))

from deepcoin.config import Settings, load_settings
from deepcoin.ground_truth.futures import futures_events_from_gt_signals
from deepcoin.ground_truth.futures_chart import render_futures_ground_truth_chart
from deepcoin.ground_truth.ground_truth import save_ground_truth

TIER_DESCRIPTIONS = {
    "v1": "스윙만 (최소 매수·매도)",
    "v2": "스윙 + 눌림목",
    "v3": "스윙 + 눌림목 + 돌파 + 다이버전스",
}


def _configure_logging(verbose: bool) -> None:
    """로깅 레벨을 설정한다."""
    level = logging.DEBUG if verbose else logging.INFO
    logging.basicConfig(
        level=level,
        format="%(asctime)s [%(levelname)s] %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
    )


def _tier_targets(
    settings: Settings,
    tier_arg: str,
) -> list[tuple[str, Path, Path, Path]]:
    """생성할 티어 목록 (tier, spot_json, futures_json, futures_chart)."""
    all_tiers: dict[str, tuple[Path, Path, Path]] = {
        "v1": (
            settings.ground_truth_v1_file,
            settings.ground_truth_futures_v1_file,
            settings.ground_truth_futures_chart_v1_file,
        ),
        "v2": (
            settings.ground_truth_v2_file,
            settings.ground_truth_futures_v2_file,
            settings.ground_truth_futures_chart_v2_file,
        ),
        "v3": (
            settings.ground_truth_file,
            settings.ground_truth_futures_file,
            settings.ground_truth_futures_chart_v3_file,
        ),
    }
    if tier_arg == "all":
        return [(t, *paths) for t, paths in all_tiers.items()]
    return [(tier_arg, *all_tiers[tier_arg])]


def _load_gt(json_path: Path) -> dict[str, Any]:
    """GT JSON을 로드한다."""
    with json_path.open(encoding="utf-8") as fp:
        return json.load(fp)


def _build_futures_gt(spot_gt: dict[str, Any]) -> dict[str, Any]:
    """현물 GT JSON을 선물 GT JSON으로 변환한다."""
    signals = spot_gt.get("signals") or []
    futures_gt = deepcopy(spot_gt)
    futures_gt["meta"] = {
        **spot_gt.get("meta", {}),
        "market_type": "futures",
        "source": "spot_ground_truth",
    }
    futures_gt["futures_events"] = futures_events_from_gt_signals(signals)
    return futures_gt


def _print_summary(
    tier: str,
    gt_result: dict[str, Any],
    json_path: Path,
    chart_path: Path,
) -> None:
    """티어별 선물 GT 요약을 출력한다."""
    meta = gt_result["meta"]
    summary = gt_result["summary"]
    print(f"\n=== 선물 GT {tier.upper()} ({TIER_DESCRIPTIONS[tier]}) ===")
    print(f"대상: {meta['symbol']} ({meta['interval_label']})")
    print(f"GT 기간: {meta['data_from']} ~ {meta['data_to']}")
    print(
        f"선물 GT 타점: 매수 {summary['buy_count']} / 매도 {summary['sell_count']} "
        f"→ 선물 상방·하방 각 {summary['buy_count']}/{summary['sell_count']} 마커"
    )
    print(f"JSON: {json_path}")
    print(f"차트: {chart_path}")


def main() -> int:
    """CLI 진입점."""
    parser = argparse.ArgumentParser(
        description="선물 GT JSON·차트 생성 (현물 GT → 롱·숏 4색)"
    )
    parser.add_argument(
        "--tier",
        choices=("v1", "v2", "v3", "all"),
        default="all",
        help="대상 GT 버전",
    )
    parser.add_argument("-v", "--verbose", action="store_true")
    args = parser.parse_args()

    _configure_logging(args.verbose)
    settings = load_settings()
    tiers = _tier_targets(settings, args.tier)

    print("\n=== 선물 Ground Truth 생성 ===")
    print("현물 GT 타점 → L↑상방매수 L↓상방매도 S↓하방매수 S↑하방매도")

    for tier, spot_json_path, futures_json_path, chart_path in tiers:
        if not spot_json_path.exists():
            logging.error(
                "현물 GT JSON 없음: %s — 먼저 0_ground_truth.py 실행",
                spot_json_path,
            )
            return 1

        spot_gt = _load_gt(spot_json_path)
        futures_gt = _build_futures_gt(spot_gt)
        save_ground_truth(futures_gt, futures_json_path)

        render_futures_ground_truth_chart(
            db_path=settings.db_path,
            symbol=settings.symbol,
            gt_result=spot_gt,
            output_path=chart_path,
            chart_lookback_days=settings.download_days,
        )
        _print_summary(tier, futures_gt, futures_json_path, chart_path)

    return 0


if __name__ == "__main__":
    raise SystemExit(main())