feat: ECR-003 主站威科夫分析与图表叠层（已审）

独立 wyckoff 引擎 + 按需 include_wyckoff；主站 Lightweight 绘制区间/阶段/事件/VP。

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

chanlun/analysis/wyckoff/__init__.py

@@ -0,0 +1,6 @@
+"""威科夫分析（启发式）：交易区间 / 阶段 / 事件 / Volume Profile。"""
+from __future__ import annotations
+
+from .engine import analyze_wyckoff
+
+__all__ = ["analyze_wyckoff"]

chanlun/analysis/wyckoff/engine.py

@@ -0,0 +1,80 @@
+"""威科夫分析入口。"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import pandas as pd
+
+from .events import build_phases, detect_bias_and_events
+from .range import detect_trading_range
+from .volume_profile import compute_volume_profile
+
+
+def _fmt_time(v) -> Optional[str]:
+	if v is None:
+		return None
+	if hasattr(v, "isoformat"):
+		try:
+			return v.isoformat()
+		except Exception:
+			pass
+	return str(v)
+
+
+def analyze_wyckoff(df: pd.DataFrame, lookback: int = 120, vp_bins: int = 50) -> Dict[str, Any]:
+	"""
+	对主周期 OHLCV DataFrame 做威科夫启发式分析。
+	需要列: open, high, low, close, volume；建议有 date 或 timestamp。
+	"""
+	empty = {
+		"trading_range": None,
+		"bias": "unknown",
+		"phases": [],
+		"events": [],
+		"volume_profile": {"bins": [], "poc": None, "vah": None, "val": None, "bin_count": vp_bins},
+		"volume_confirm": {"avg_volume": 0.0, "event_checks": {}},
+	}
+	if df is None or len(df) < 30:
+		return empty
+	if not all(c in df.columns for c in ("open", "high", "low", "close")):
+		return empty
+	work = df.copy()
+	if "volume" not in work.columns:
+		work["volume"] = 1.0
+
+	tr = detect_trading_range(work, lookback=lookback)
+	if tr is None:
+		return empty
+
+	bias, events, volume_confirm = detect_bias_and_events(work, tr)
+	phases = build_phases(work, tr, bias, events)
+	vp = compute_volume_profile(
+		work,
+		int(tr["abs_start_idx"]),
+		int(tr["abs_end_idx"]),
+		bin_count=vp_bins,
+	)
+
+	trading_range = {
+		"start_time": _fmt_time(tr.get("start_time")),
+		"end_time": _fmt_time(tr.get("end_time")),
+		"high": float(tr["high"]),
+		"low": float(tr["low"]),
+		"mid": float(tr["mid"]),
+		"active": bool(tr.get("active", True)),
+		"bars": int(tr.get("bars", 0)),
+	}
+	for ev in events:
+		ev["time"] = _fmt_time(ev.get("time"))
+	for ph in phases:
+		ph["start_time"] = _fmt_time(ph.get("start_time"))
+		ph["end_time"] = _fmt_time(ph.get("end_time"))
+
+	return {
+		"trading_range": trading_range,
+		"bias": bias,
+		"phases": phases,
+		"events": events,
+		"volume_profile": vp,
+		"volume_confirm": volume_confirm,
+	}

chanlun/analysis/wyckoff/events.py

@@ -0,0 +1,240 @@
+"""威科夫阶段与事件（启发式）。"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+import pandas as pd
+
+
+def _bar_time(df: pd.DataFrame, i: int):
+	row = df.iloc[i]
+	if "date" in df.columns and pd.notna(row["date"]):
+		return row["date"]
+	if "timestamp" in df.columns:
+		return row["timestamp"]
+	return i
+
+
+def _avg_vol(df: pd.DataFrame, i: int, win: int = 20) -> float:
+	a = max(0, i - win + 1)
+	v = df["volume"].astype(float).iloc[a : i + 1]
+	m = float(v.mean()) if len(v) else 0.0
+	return m if m > 0 else 1.0
+
+
+def detect_bias_and_events(
+	df: pd.DataFrame,
+	tr: Dict[str, Any],
+) -> Tuple[str, List[Dict[str, Any]], Dict[str, Any]]:
+	"""
+	返回 bias、events、volume_confirm。
+	"""
+	hi = float(tr["high"])
+	lo = float(tr["low"])
+	mid = float(tr["mid"])
+	tol = float(tr.get("tol") or (hi - lo) * 0.05)
+	s = int(tr["abs_start_idx"])
+	e = int(tr["abs_end_idx"])
+	events: List[Dict[str, Any]] = []
+
+	# 扫描区间内及之后（含 tail_reserve）
+	scan_end = int(tr.get("abs_scan_end_idx", min(len(df) - 1, e + 15)))
+	scan_end = min(len(df) - 1, max(scan_end, e))
+	spring = None
+	utad = None
+	sos = None
+	sod = None  # sign of weakness / distribution breakdown
+	lps = None
+	lpsy = None
+
+	for i in range(s + 2, scan_end + 1):
+		row = df.iloc[i]
+		low = float(row["low"])
+		high = float(row["high"])
+		close = float(row["close"])
+		vol = float(row["volume"]) if "volume" in df.columns else 0.0
+		avg_v = _avg_vol(df, i)
+		ratio = vol / avg_v if avg_v else 0.0
+
+		# Spring: pierce below low then close back above low
+		if spring is None and low < lo - tol * 0.5 and close >= lo - tol * 0.2:
+			vol_ok = ratio <= 1.35 or (i + 1 <= scan_end and float(df.iloc[min(i + 1, scan_end)]["volume"]) / avg_v < 1.2)
+			spring = {
+				"type": "Spring",
+				"time": _bar_time(df, i),
+				"price": low,
+				"note": "假破下沿后收回",
+				"volume_ratio": round(ratio, 3),
+				"volume_ok": bool(vol_ok),
+				"idx": i,
+			}
+
+		# UTAD: pierce above high then close back below
+		if utad is None and high > hi + tol * 0.5 and close <= hi + tol * 0.2:
+			vol_ok = ratio >= 0.8
+			utad = {
+				"type": "UTAD",
+				"time": _bar_time(df, i),
+				"price": high,
+				"note": "假破上沿后跌回",
+				"volume_ratio": round(ratio, 3),
+				"volume_ok": bool(vol_ok),
+				"idx": i,
+			}
+
+		# SOS: close above high with volume
+		if sos is None and close > hi + tol * 0.15:
+			vol_ok = ratio >= 1.15
+			sos = {
+				"type": "SOS",
+				"time": _bar_time(df, i),
+				"price": close,
+				"note": "放量上破交易区间",
+				"volume_ratio": round(ratio, 3),
+				"volume_ok": bool(vol_ok),
+				"idx": i,
+			}
+
+		# SOW / breakdown
+		if sod is None and close < lo - tol * 0.15:
+			vol_ok = ratio >= 1.15
+			sod = {
+				"type": "SOW",
+				"time": _bar_time(df, i),
+				"price": close,
+				"note": "放量下破交易区间",
+				"volume_ratio": round(ratio, 3),
+				"volume_ok": bool(vol_ok),
+				"idx": i,
+			}
+
+	# LPS after SOS: pullback that holds above mid/high-band with lighter volume
+	if sos is not None:
+		si = int(sos["idx"])
+		for i in range(si + 1, min(len(df), si + 25)):
+			row = df.iloc[i]
+			low = float(row["low"])
+			close = float(row["close"])
+			vol = float(row["volume"]) if "volume" in df.columns else 0.0
+			avg_v = _avg_vol(df, i)
+			ratio = vol / avg_v if avg_v else 0.0
+			if low >= mid - tol and close >= hi - tol * 2:
+				vol_ok = ratio <= 1.05
+				lps = {
+					"type": "LPS",
+					"time": _bar_time(df, i),
+					"price": low,
+					"note": "突破后缩量回踩不破",
+					"volume_ratio": round(ratio, 3),
+					"volume_ok": bool(vol_ok),
+					"idx": i,
+				}
+				break
+
+	if sod is not None:
+		si = int(sod["idx"])
+		for i in range(si + 1, min(len(df), si + 25)):
+			row = df.iloc[i]
+			high = float(row["high"])
+			close = float(row["close"])
+			vol = float(row["volume"]) if "volume" in df.columns else 0.0
+			avg_v = _avg_vol(df, i)
+			ratio = vol / avg_v if avg_v else 0.0
+			if high <= mid + tol and close <= lo + tol * 2:
+				vol_ok = ratio <= 1.05
+				lpsy = {
+					"type": "LPSY",
+					"time": _bar_time(df, i),
+					"price": high,
+					"note": "下跌突破后缩量反抽不过",
+					"volume_ratio": round(ratio, 3),
+					"volume_ok": bool(vol_ok),
+					"idx": i,
+				}
+				break
+
+	for ev in (spring, sos, lps, utad, sod, lpsy):
+		if ev:
+			events.append({k: v for k, v in ev.items() if k != "idx"})
+
+	# bias
+	last_c = float(df["close"].iloc[-1])
+	bias = "unknown"
+	if sos and (not sod or int(sos.get("idx", 0)) >= int(sod.get("idx", 0))):
+		bias = "accumulation"
+	elif sod and (not sos or int(sod.get("idx", 0)) > int(sos.get("idx", 0))):
+		bias = "distribution"
+	elif spring and not utad:
+		bias = "accumulation"
+	elif utad and not spring:
+		bias = "distribution"
+	elif last_c >= mid:
+		bias = "accumulation"
+	else:
+		bias = "distribution"
+
+	avg_volume = float(df["volume"].astype(float).iloc[max(0, e - 20) : e + 1].mean()) if "volume" in df.columns else 0.0
+	volume_confirm = {
+		"avg_volume": avg_volume,
+		"event_checks": {ev["type"]: {"volume_ok": ev.get("volume_ok"), "volume_ratio": ev.get("volume_ratio")} for ev in events},
+	}
+	return bias, events, volume_confirm
+
+
+def build_phases(
+	df: pd.DataFrame,
+	tr: Dict[str, Any],
+	bias: str,
+	events: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+	"""按时间切分 A–E 粗阶段。"""
+	s = int(tr["abs_start_idx"])
+	e = int(tr["abs_end_idx"])
+	hi = float(tr["high"])
+	lo = float(tr["low"])
+	mid = float(tr["mid"])
+	tol = float(tr.get("tol") or (hi - lo) * 0.05)
+
+	event_idx = {}
+	for ev in events:
+		# 找回 idx 近似：按时间匹配
+		t = ev.get("time")
+		for i in range(s, min(len(df), e + 20)):
+			if _bar_time(df, i) == t:
+				event_idx[ev["type"]] = i
+				break
+
+	# 分段点
+	a_end = s + max(3, (e - s) // 5)
+	c_anchor = event_idx.get("Spring") or event_idx.get("UTAD") or (s + (e - s) // 2)
+	d_anchor = event_idx.get("SOS") or event_idx.get("SOW") or e
+	e_start = d_anchor
+
+	def _lab(phase: str) -> str:
+		if bias == "distribution":
+			m = {"A": "A停止上涨", "B": "B筑顶", "C": "C测试", "D": "D派发", "E": "E下跌"}
+		else:
+			m = {"A": "A停止下跌", "B": "B筑底", "C": "C测试", "D": "D拉升", "E": "E离开"}
+		return m.get(phase, phase)
+
+	cuts = [
+		("A", s, a_end),
+		("B", a_end, max(a_end + 1, c_anchor)),
+		("C", max(a_end + 1, c_anchor), max(c_anchor + 1, d_anchor)),
+		("D", max(c_anchor + 1, d_anchor), max(d_anchor + 1, min(len(df) - 1, e_start + max(3, (e - s) // 6)))),
+		("E", max(d_anchor, e_start), min(len(df) - 1, max(e, e_start + 5))),
+	]
+	phases = []
+	for phase, a, b in cuts:
+		a = int(np.clip(a, 0, len(df) - 1))
+		b = int(np.clip(b, a, len(df) - 1))
+		phases.append(
+			{
+				"phase": phase,
+				"label": _lab(phase),
+				"start_time": _bar_time(df, a),
+				"end_time": _bar_time(df, b),
+			}
+		)
+	return phases

chanlun/analysis/wyckoff/range.py

@@ -0,0 +1,108 @@
+"""交易区间检测：ATR 容差下的近期震荡箱。"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def _atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
+	high = df["high"].astype(float)
+	low = df["low"].astype(float)
+	close = df["close"].astype(float)
+	prev_close = close.shift(1)
+	tr = pd.concat(
+		[
+			(high - low).abs(),
+			(high - prev_close).abs(),
+			(low - prev_close).abs(),
+		],
+		axis=1,
+	).max(axis=1)
+	return tr.rolling(period, min_periods=max(3, period // 2)).mean()
+
+
+def detect_trading_range(
+	df: pd.DataFrame,
+	lookback: int = 120,
+	min_bars: int = 24,
+	atr_mult: float = 1.2,
+	tail_reserve: int = 12,
+) -> Optional[Dict[str, Any]]:
+	"""
+	在最近 lookback 根内寻找高低点波动受控的连续段作为交易区间。
+	尾部预留 tail_reserve 根用于事件（Spring/SOS），不参与箱体边界计算。
+	"""
+	if df is None or len(df) < min_bars + 5:
+		return None
+	work = df.tail(lookback).reset_index(drop=True)
+	n = len(work)
+	reserve = min(tail_reserve, max(0, n - min_bars - 2))
+	core_end = n - reserve if reserve > 0 else n
+	core = work.iloc[:core_end]
+	if len(core) < min_bars:
+		core = work
+		core_end = n
+		reserve = 0
+
+	atr = _atr(work)
+	last_atr = float(atr.iloc[core_end - 1]) if atr.notna().iloc[:core_end].any() else float(
+		(core["high"] - core["low"]).mean()
+	)
+	if not np.isfinite(last_atr) or last_atr <= 0:
+		last_atr = float(core["close"].iloc[-1]) * 0.01
+
+	best = None
+	cn = len(core)
+	for length in range(min(cn, lookback), min_bars - 1, -4):
+		seg = core.iloc[-length:]
+		hi = float(seg["high"].max())
+		lo = float(seg["low"].min())
+		width = hi - lo
+		if width <= 0 or width > last_atr * atr_mult * 3.5:
+			continue
+		tol = last_atr * atr_mult * 0.35
+		near_hi = int((seg["high"] >= hi - tol).sum())
+		near_lo = int((seg["low"] <= lo + tol).sum())
+		if near_hi < 2 or near_lo < 2:
+			continue
+		inside = ((seg["close"] >= lo - tol) & (seg["close"] <= hi + tol)).mean()
+		if inside < 0.75:
+			continue
+		start_i = cn - length
+		end_i = cn - 1
+		mid = (hi + lo) / 2.0
+		last_c = float(work["close"].iloc[-1])
+		active = (lo - tol * 1.5) <= last_c <= (hi + tol * 1.5)
+		best = {
+			"start_idx": int(start_i),
+			"end_idx": int(end_i),
+			"high": hi,
+			"low": lo,
+			"mid": mid,
+			"active": bool(active),
+			"atr": last_atr,
+			"tol": tol,
+			"bars": int(length),
+		}
+		break
+
+	if best is None:
+		return None
+
+	def _ts(row) -> Any:
+		if "date" in work.columns and pd.notna(row["date"]):
+			return row["date"]
+		if "timestamp" in work.columns:
+			return row["timestamp"]
+		return None
+
+	best["start_time"] = _ts(work.iloc[best["start_idx"]])
+	# 区间时间结束取 core 末，事件可落在其后
+	best["end_time"] = _ts(work.iloc[best["end_idx"]])
+	offset = len(df) - len(work)
+	best["abs_start_idx"] = offset + best["start_idx"]
+	best["abs_end_idx"] = offset + best["end_idx"]
+	best["abs_scan_end_idx"] = offset + n - 1
+	return best

chanlun/analysis/wyckoff/volume_profile.py

@@ -0,0 +1,72 @@
+"""区间内 Volume Profile。"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+import numpy as np
+import pandas as pd
+
+
+def compute_volume_profile(
+	df: pd.DataFrame,
+	start_idx: int,
+	end_idx: int,
+	bin_count: int = 50,
+	value_area_pct: float = 0.70,
+) -> Dict[str, Any]:
+	seg = df.iloc[start_idx : end_idx + 1]
+	if seg.empty:
+		return {"bins": [], "poc": None, "vah": None, "val": None, "bin_count": bin_count}
+
+	typical = (seg["high"].astype(float) + seg["low"].astype(float) + seg["close"].astype(float)) / 3.0
+	vol = seg["volume"].astype(float).fillna(0.0)
+	lo = float(seg["low"].min())
+	hi = float(seg["high"].max())
+	if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo:
+		mid = float(seg["close"].iloc[-1])
+		return {
+			"bins": [{"price": mid, "volume": float(vol.sum())}],
+			"poc": mid,
+			"vah": mid,
+			"val": mid,
+			"bin_count": 1,
+		}
+
+	edges = np.linspace(lo, hi, bin_count + 1)
+	# 右开最后一桶闭合
+	idx = np.clip(np.digitize(typical.values, edges) - 1, 0, bin_count - 1)
+	vols = np.zeros(bin_count, dtype=float)
+	for i, v in zip(idx, vol.values):
+		vols[i] += float(v)
+
+	centers = (edges[:-1] + edges[1:]) / 2.0
+	poc_i = int(np.argmax(vols)) if vols.sum() > 0 else bin_count // 2
+	poc = float(centers[poc_i])
+
+	# Value Area：从 POC 向两侧扩展直到累计 >= value_area_pct
+	total = float(vols.sum()) or 1.0
+	target = total * value_area_pct
+	left = right = poc_i
+	acc = float(vols[poc_i])
+	while acc < target and (left > 0 or right < bin_count - 1):
+		left_v = vols[left - 1] if left > 0 else -1.0
+		right_v = vols[right + 1] if right < bin_count - 1 else -1.0
+		if right_v >= left_v and right < bin_count - 1:
+			right += 1
+			acc += float(vols[right])
+		elif left > 0:
+			left -= 1
+			acc += float(vols[left])
+		else:
+			break
+
+	bins: List[Dict[str, float]] = [
+		{"price": float(centers[i]), "volume": float(vols[i])} for i in range(bin_count)
+	]
+	return {
+		"bins": bins,
+		"poc": poc,
+		"vah": float(centers[right]),
+		"val": float(centers[left]),
+		"bin_count": bin_count,
+	}