feat(ECR-009): Crypto Wyckoff Screener 独立页（D/W/M）

移植 A_Share_DP 引擎；本地缓存与 60s tip；月线由日线 UTC 聚合；不碰主站 analyze/缠论叠层。

Co-authored-by: Cursor <cursoragent@cursor.com>

crypto_wyckoff/pipeline.py

@@ -0,0 +1,157 @@
+"""Scan pipeline: load local frames → engines → store."""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import date, datetime, timezone
+
+from crypto_wyckoff.cycle import CycleEngine
+from crypto_wyckoff.decision import DecisionEngine
+from crypto_wyckoff.domain_models import WyckoffScanRow
+from crypto_wyckoff.event import EventEngine
+from crypto_wyckoff.features import FeatureEngine
+from crypto_wyckoff.io import LOOKBACK, TF_LIST, load_frame
+from crypto_wyckoff.phase import PhaseEngine
+from crypto_wyckoff.plan import PlanEngine
+from crypto_wyckoff.signal import SignalEngine
+from crypto_wyckoff.store import upsert_row
+from crypto_wyckoff.version import WYCKOFF_ENGINE_VERSION
+
+logger = logging.getLogger(__name__)
+
+
+def analyze_symbol(
+    daily_frame,
+    weekly_frame,
+    monthly_frame,
+    *,
+    feature_eng: FeatureEngine,
+    cycle_eng: CycleEngine,
+    phase_eng: PhaseEngine,
+    event_eng: EventEngine,
+    signal_eng: SignalEngine,
+    decision_eng: DecisionEngine,
+    plan_eng: PlanEngine,
+) -> dict:
+    f_d = feature_eng.run(daily_frame, "1d")
+    f_w = feature_eng.run(weekly_frame, "1w")
+    f_m = feature_eng.run(monthly_frame, "1M")
+
+    c_m = cycle_eng.run(f_m, "1M")
+    c_w = cycle_eng.run(f_w, "1w")
+
+    p_w = phase_eng.run(c_w, f_w, "1w")
+    p_d = phase_eng.run(c_w, f_d, "1d")
+
+    e_w = event_eng.run(c_w, p_w, f_w, "1w")
+    e_d = event_eng.run(c_w, p_d, f_d, "1d")
+
+    s_d = signal_eng.run(e_d, p_d)
+    decision = decision_eng.run(c_m, c_w, p_w, e_w, e_d, s_d)
+    plan = plan_eng.run(f_d, decision)
+
+    return {
+        "f_d": f_d, "f_w": f_w, "f_m": f_m,
+        "c_m": c_m, "c_w": c_w, "p_w": p_w,
+        "e_w": e_w, "e_d": e_d, "s_d": s_d,
+        "decision": decision, "plan": plan,
+    }
+
+
+def _to_row(trade_date: date, symbol: str, result: dict) -> WyckoffScanRow:
+    d = result["decision"]
+    p = result["plan"]
+    c_m, c_w, p_w = result["c_m"], result["c_w"], result["p_w"]
+    e_w, e_d, s_d = result["e_w"], result["e_d"], result["s_d"]
+    f_d, f_w, f_m = result["f_d"], result["f_w"], result["f_m"]
+
+    snapshot = {
+        "daily": {k: f_d.payload.get(k) for k in (
+            "ma20", "ma60", "ma120", "atr", "adx", "volume_ratio",
+            "range_high", "range_low", "swing_high", "swing_low", "close",
+        )},
+        "weekly": {k: f_w.payload.get(k) for k in ("ma20", "ma60", "adx", "close")},
+        "monthly": {k: f_m.payload.get(k) for k in ("ma20", "ma60", "adx", "close")},
+    }
+    markers = []
+    for key, typ in (("entry", "entry"), ("stop", "stop"), ("target1", "target1"), ("target2", "target2")):
+        if p.payload.get(key) is not None:
+            markers.append({"type": typ, "price": p.payload[key]})
+
+    return WyckoffScanRow(
+        trade_date=trade_date,
+        ts_code=symbol,
+        name=symbol,
+        industry="crypto",
+        engine_version=WYCKOFF_ENGINE_VERSION,
+        m_cycle=c_m.payload.get("cycle", "Unknown"),
+        cycle_confidence=c_m.confidence,
+        trend_score=float(d.payload.get("trend_score", c_m.score)),
+        w_cycle=c_w.payload.get("cycle", "Unknown"),
+        w_phase=p_w.payload.get("phase", "None"),
+        w_current_event=e_w.payload.get("current_event", "None"),
+        w_recent_events_json=json.dumps(
+            e_w.payload.get("active_events") or e_w.payload.get("recent_events") or [],
+            ensure_ascii=False,
+        ),
+        phase_confidence=p_w.confidence,
+        structure_score=float(d.payload.get("structure_score", p_w.score)),
+        d_current_event=e_d.payload.get("current_event", "None"),
+        d_recent_events_json=json.dumps(
+            e_d.payload.get("active_events") or e_d.payload.get("recent_events") or [],
+            ensure_ascii=False,
+        ),
+        event_confidence=e_d.confidence,
+        entry_score=float(d.payload.get("entry_score", e_d.score)),
+        entry=p.payload.get("entry"),
+        stop=p.payload.get("stop"),
+        target1=p.payload.get("target1"),
+        target2=p.payload.get("target2"),
+        rr=p.payload.get("rr"),
+        alignment=float(d.payload.get("alignment", 0)),
+        stars=int(d.payload.get("stars", 1)),
+        decision_signal=d.payload.get("decision_signal", "Watch"),
+        signal_confidence=s_d.confidence,
+        overall_confidence=float(d.payload.get("overall_confidence", d.confidence)),
+        overall_score=float(d.payload.get("overall_score", d.score)),
+        risk=d.payload.get("risk", "Medium"),
+        reasons_json=json.dumps(d.reasons + d.warnings, ensure_ascii=False),
+        feature_snapshot_json=json.dumps(snapshot, ensure_ascii=False),
+        markers_json=json.dumps(markers, ensure_ascii=False),
+        scanned_at=datetime.now(timezone.utc),
+    )
+
+
+_ENGINES = None
+
+
+def _engines():
+    global _ENGINES
+    if _ENGINES is None:
+        _ENGINES = {
+            "feature_eng": FeatureEngine(),
+            "cycle_eng": CycleEngine(),
+            "phase_eng": PhaseEngine(),
+            "event_eng": EventEngine(),
+            "signal_eng": SignalEngine(),
+            "decision_eng": DecisionEngine(),
+            "plan_eng": PlanEngine(),
+        }
+    return _ENGINES
+
+
+def analyze_and_store(symbol: str, trade_date: date | None = None) -> WyckoffScanRow | None:
+    eng = _engines()
+    daily = load_frame(symbol, "1d", LOOKBACK["1d"])
+    weekly = load_frame(symbol, "1w", LOOKBACK["1w"])
+    monthly = load_frame(symbol, "1M", LOOKBACK["1M"])
+    if daily is None or len(daily) < 40:
+        return None
+    result = analyze_symbol(daily, weekly, monthly, **eng)
+    td = trade_date or (
+        daily.trade_dates[-1] if daily.trade_dates else datetime.now(timezone.utc).date()
+    )
+    row = _to_row(td, symbol, result)
+    upsert_row(row)
+    return row