feat(ECR-009): Crypto Wyckoff Screener 独立页（D/W/M）
移植 A_Share_DP 引擎；本地缓存与 60s tip；月线由日线 UTC 聚合；不碰主站 analyze/缠论叠层。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jackyu66git
@@ -0,0 +1,3 @@
|
||||
from crypto_wyckoff.rules.registry import rule_registry
|
||||
|
||||
__all__ = ["rule_registry"]
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Rule protocol for Wyckoff Rule Registry."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any
|
||||
|
||||
|
||||
@dataclass
|
||||
class RuleHit:
|
||||
"""A single rule match."""
|
||||
|
||||
rule_id: str
|
||||
event: str | None = None
|
||||
phase: str | None = None
|
||||
cycle: str | None = None
|
||||
confidence: float = 0.0
|
||||
score: float = 0.0
|
||||
reasons: list[str] = field(default_factory=list)
|
||||
metrics: dict[str, Any] = field(default_factory=dict)
|
||||
|
||||
|
||||
class WyckoffRule(ABC):
|
||||
"""Pluggable rule. Engines iterate registry; never hardcode rule lists."""
|
||||
|
||||
rule_id: str
|
||||
category: str # cycle | phase | event
|
||||
timeframes: tuple[str, ...] = ("1d", "1w", "1M")
|
||||
|
||||
@abstractmethod
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
"""Return RuleHit if matched, else None. Pure — no I/O."""
|
||||
@@ -0,0 +1,126 @@
|
||||
"""Cycle classification rules (monthly / weekly)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from crypto_wyckoff.domain_models import WyckoffCycle
|
||||
from crypto_wyckoff.rules.base import RuleHit, WyckoffRule
|
||||
|
||||
|
||||
def _f(ctx: dict[str, Any], key: str, default: float = 0.0) -> float:
|
||||
v = ctx.get("features", {}).get(key, default)
|
||||
try:
|
||||
return float(v) if v is not None else default
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
class MarkupCycleRule(WyckoffRule):
|
||||
rule_id = "cycle_markup"
|
||||
category = "cycle"
|
||||
timeframes = ("1M", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
close = _f(context, "close")
|
||||
ma20 = _f(context, "ma20")
|
||||
ma60 = _f(context, "ma60")
|
||||
ma120 = _f(context, "ma120")
|
||||
adx = _f(context, "adx")
|
||||
slope = _f(context, "ma60_slope")
|
||||
if close > ma20 > ma60 and (ma60 >= ma120 or slope > 0) and adx >= 18:
|
||||
conf = min(95.0, 55 + adx + (10 if close > ma120 else 0))
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
cycle=WyckoffCycle.MARKUP.value,
|
||||
confidence=conf,
|
||||
score=conf,
|
||||
reasons=["价格位于均线多头排列", f"ADX={adx:.1f}"],
|
||||
metrics={"adx": adx, "slope": slope},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class MarkdownCycleRule(WyckoffRule):
|
||||
rule_id = "cycle_markdown"
|
||||
category = "cycle"
|
||||
timeframes = ("1M", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
close = _f(context, "close")
|
||||
ma20 = _f(context, "ma20")
|
||||
ma60 = _f(context, "ma60")
|
||||
ma120 = _f(context, "ma120")
|
||||
adx = _f(context, "adx")
|
||||
slope = _f(context, "ma60_slope")
|
||||
if close < ma20 < ma60 and (ma60 <= ma120 or slope < 0) and adx >= 18:
|
||||
conf = min(95.0, 55 + adx + (10 if close < ma120 else 0))
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
cycle=WyckoffCycle.MARKDOWN.value,
|
||||
confidence=conf,
|
||||
score=conf,
|
||||
reasons=["价格位于均线空头排列", f"ADX={adx:.1f}"],
|
||||
metrics={"adx": adx},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class AccumulationCycleRule(WyckoffRule):
|
||||
rule_id = "cycle_accumulation"
|
||||
category = "cycle"
|
||||
timeframes = ("1M", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
adx = _f(context, "adx")
|
||||
range_pct = _f(context, "range_pct_60")
|
||||
close = _f(context, "close")
|
||||
ma120 = _f(context, "ma120")
|
||||
vol_trend = _f(context, "volume_trend")
|
||||
# Range-bound after decline: strictly at/below MA120 (mutually exclusive vs Distribution)
|
||||
if adx < 22 and range_pct < 0.28 and close <= ma120:
|
||||
conf = 60 + (10 if vol_trend > 0 else 0) + (10 if close < ma120 else 0)
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
cycle=WyckoffCycle.ACCUMULATION.value,
|
||||
confidence=min(90.0, conf),
|
||||
score=min(90.0, conf),
|
||||
reasons=["低趋势强度区间震荡", "疑似吸筹区间"],
|
||||
metrics={"adx": adx, "range_pct_60": range_pct},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class DistributionCycleRule(WyckoffRule):
|
||||
rule_id = "cycle_distribution"
|
||||
category = "cycle"
|
||||
timeframes = ("1M", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
adx = _f(context, "adx")
|
||||
range_pct = _f(context, "range_pct_60")
|
||||
close = _f(context, "close")
|
||||
ma120 = _f(context, "ma120")
|
||||
vol_trend = _f(context, "volume_trend")
|
||||
# Range-bound near highs: strictly above MA120 (mutually exclusive vs Accumulation)
|
||||
if adx < 22 and range_pct < 0.28 and close > ma120:
|
||||
conf = 60 + (10 if vol_trend < 0 else 0) + (10 if close > ma120 else 0)
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
cycle=WyckoffCycle.DISTRIBUTION.value,
|
||||
confidence=min(90.0, conf),
|
||||
score=min(90.0, conf),
|
||||
reasons=["高位低趋势震荡", "疑似派发区间"],
|
||||
metrics={"adx": adx, "range_pct_60": range_pct},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
def build_rules() -> list[WyckoffRule]:
|
||||
# Order: trend cycles first (more decisive), then range cycles
|
||||
return [
|
||||
MarkupCycleRule(),
|
||||
MarkdownCycleRule(),
|
||||
AccumulationCycleRule(),
|
||||
DistributionCycleRule(),
|
||||
]
|
||||
@@ -0,0 +1,254 @@
|
||||
"""Event rules: Spring/SOS/LPS/UTAD/SC/AR/ST/..."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from crypto_wyckoff.domain_models import WyckoffCycle, WyckoffEvent, WyckoffPhase
|
||||
from crypto_wyckoff.rules.base import RuleHit, WyckoffRule
|
||||
|
||||
|
||||
def _f(ctx: dict[str, Any], key: str, default: float = 0.0) -> float:
|
||||
v = ctx.get("features", {}).get(key, default)
|
||||
try:
|
||||
return float(v) if v is not None else default
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
def _cycle(ctx: dict[str, Any]) -> str:
|
||||
return (ctx.get("cycle") or {}).get("cycle") or ""
|
||||
|
||||
|
||||
def _phase(ctx: dict[str, Any]) -> str:
|
||||
return (ctx.get("phase") or {}).get("phase") or ""
|
||||
|
||||
|
||||
class SpringRule(WyckoffRule):
|
||||
rule_id = "event_spring"
|
||||
category = "event"
|
||||
timeframes = ("1d",)
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
if cycle not in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.RE_ACCUMULATION.value,
|
||||
WyckoffCycle.MARKUP.value):
|
||||
# Allow spring only in accumulative contexts; Decision will filter MTF
|
||||
if cycle == WyckoffCycle.DISTRIBUTION.value:
|
||||
pass # still detect for facts but lower confidence
|
||||
pierce = _f(context, "pierce_below_range")
|
||||
reclaim = _f(context, "reclaim_speed")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
close_in_range = _f(context, "close_back_in_range")
|
||||
if pierce >= 0.002 and close_in_range >= 0.5 and reclaim >= 0.3:
|
||||
strength = min(98.0, 50 + pierce * 2000 + reclaim * 20 + (15 if vol_ratio < 1.2 else 5))
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.SPRING.value,
|
||||
confidence=strength,
|
||||
score=strength,
|
||||
reasons=[
|
||||
f"跌破区间后收回 (pierce={pierce:.3%})",
|
||||
f"回收速度={reclaim:.2f}",
|
||||
f"量比={vol_ratio:.2f}",
|
||||
],
|
||||
metrics={"pierce": pierce, "reclaim": reclaim, "volume_ratio": vol_ratio},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class TestRule(WyckoffRule):
|
||||
rule_id = "event_test"
|
||||
category = "event"
|
||||
timeframes = ("1d", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
pos = _f(context, "range_position")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
near_low = pos < 0.2
|
||||
if near_low and vol_ratio < 0.85:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.TEST.value,
|
||||
confidence=68.0,
|
||||
score=65.0,
|
||||
reasons=["低位缩量回测"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class SOSRule(WyckoffRule):
|
||||
rule_id = "event_sos"
|
||||
category = "event"
|
||||
timeframes = ("1d", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
breakout = _f(context, "breakout_above_range")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
close = _f(context, "close")
|
||||
ma20 = _f(context, "ma20")
|
||||
if breakout >= 0.0 and vol_ratio >= 1.2 and close > ma20:
|
||||
conf = min(95.0, 70 + vol_ratio * 8)
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.SOS.value,
|
||||
confidence=conf,
|
||||
score=conf,
|
||||
reasons=["放量突破区间上沿 (SOS)"],
|
||||
metrics={"vol_ratio": vol_ratio},
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class LPSRule(WyckoffRule):
|
||||
rule_id = "event_lps"
|
||||
category = "event"
|
||||
timeframes = ("1d", "1w")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
# Pullback hold above broken range / MA20 after prior strength
|
||||
pullback = _f(context, "pullback_hold")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
above_ma = _f(context, "close") > _f(context, "ma20")
|
||||
if pullback >= 0.5 and above_ma and vol_ratio <= 1.1:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.LPS.value,
|
||||
confidence=74.0,
|
||||
score=76.0,
|
||||
reasons=["突破后缩量回踩支撑 (LPS)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class SCRule(WyckoffRule):
|
||||
rule_id = "event_sc"
|
||||
category = "event"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
bar_range = _f(context, "bar_range_atr")
|
||||
pos = _f(context, "range_position")
|
||||
if vol_ratio >= 1.8 and bar_range >= 1.5 and pos < 0.35:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.SC.value,
|
||||
confidence=72.0,
|
||||
score=70.0,
|
||||
reasons=["低位放量宽幅，疑似 Selling Climax"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class ARRule(WyckoffRule):
|
||||
rule_id = "event_ar"
|
||||
category = "event"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
# Automatic rally: bounce from lows
|
||||
bounce = _f(context, "bounce_from_low")
|
||||
if bounce >= 0.04:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.AR.value,
|
||||
confidence=65.0,
|
||||
score=62.0,
|
||||
reasons=["低点后自动反弹 (AR)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class STRule(WyckoffRule):
|
||||
rule_id = "event_st"
|
||||
category = "event"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
pos = _f(context, "range_position")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
if 0.15 < pos < 0.45 and vol_ratio < 1.0:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.ST.value,
|
||||
confidence=60.0,
|
||||
score=58.0,
|
||||
reasons=["次级测试 (ST)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class UTADRule(WyckoffRule):
|
||||
rule_id = "event_utad"
|
||||
category = "event"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
pierce_up = _f(context, "pierce_above_range")
|
||||
fail = _f(context, "fail_back_into_range")
|
||||
if cycle in (WyckoffCycle.DISTRIBUTION.value, WyckoffCycle.RE_DISTRIBUTION.value,
|
||||
WyckoffCycle.MARKUP.value):
|
||||
if pierce_up >= 0.002 and fail >= 0.5:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.UTAD.value,
|
||||
confidence=76.0,
|
||||
score=74.0,
|
||||
reasons=["冲高失败回到区间 (UTAD)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class JumpRule(WyckoffRule):
|
||||
rule_id = "event_jump"
|
||||
category = "event"
|
||||
timeframes = ("1d",)
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
gap = _f(context, "gap_up_pct")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
if gap >= 0.03 and vol_ratio >= 1.3:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.JUMP.value,
|
||||
confidence=70.0,
|
||||
score=72.0,
|
||||
reasons=["放量向上跳跃 (Jump)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class BackupRule(WyckoffRule):
|
||||
rule_id = "event_backup"
|
||||
category = "event"
|
||||
timeframes = ("1d",)
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
pullback = _f(context, "pullback_hold")
|
||||
after_jump = _f(context, "after_strength")
|
||||
if after_jump >= 0.5 and pullback >= 0.5:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
event=WyckoffEvent.BACKUP.value,
|
||||
confidence=68.0,
|
||||
score=70.0,
|
||||
reasons=["跳跃后回踩 (Backup)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
def build_rules() -> list[WyckoffRule]:
|
||||
return [
|
||||
SpringRule(),
|
||||
UTADRule(),
|
||||
SOSRule(),
|
||||
LPSRule(),
|
||||
SCRule(),
|
||||
JumpRule(),
|
||||
BackupRule(),
|
||||
TestRule(),
|
||||
ARRule(),
|
||||
STRule(),
|
||||
]
|
||||
@@ -0,0 +1,163 @@
|
||||
"""Phase A–E rules (primarily weekly)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from crypto_wyckoff.domain_models import WyckoffCycle, WyckoffPhase
|
||||
from crypto_wyckoff.rules.base import RuleHit, WyckoffRule
|
||||
|
||||
|
||||
def _f(ctx: dict[str, Any], key: str, default: float = 0.0) -> float:
|
||||
v = ctx.get("features", {}).get(key, default)
|
||||
try:
|
||||
return float(v) if v is not None else default
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
def _cycle(ctx: dict[str, Any]) -> str:
|
||||
return (ctx.get("cycle") or {}).get("cycle") or WyckoffCycle.UNKNOWN.value
|
||||
|
||||
|
||||
class PhaseARule(WyckoffRule):
|
||||
rule_id = "phase_a"
|
||||
category = "phase"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
if cycle not in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.DISTRIBUTION.value,
|
||||
WyckoffCycle.RE_ACCUMULATION.value, WyckoffCycle.RE_DISTRIBUTION.value):
|
||||
return None
|
||||
# Stopping action: high vol + large range recently, still range-bound
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
range_last = _f(context, "bar_range_atr")
|
||||
if vol_ratio >= 1.4 and range_last >= 1.2:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.A.value,
|
||||
confidence=70.0,
|
||||
score=65.0,
|
||||
reasons=["放量宽幅波动，疑似 Phase A 停止行为"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class PhaseBRule(WyckoffRule):
|
||||
rule_id = "phase_b"
|
||||
category = "phase"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
if cycle not in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.DISTRIBUTION.value):
|
||||
return None
|
||||
adx = _f(context, "adx")
|
||||
range_pct = _f(context, "range_pct_60")
|
||||
pos = _f(context, "range_position") # 0=low 1=high of range
|
||||
if adx < 20 and 0.25 < pos < 0.75 and range_pct < 0.30:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.B.value,
|
||||
confidence=72.0,
|
||||
score=68.0,
|
||||
reasons=["区间中部震荡，疑似 Phase B 建仓/派发"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class PhaseCRule(WyckoffRule):
|
||||
rule_id = "phase_c"
|
||||
category = "phase"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
pos = _f(context, "range_position")
|
||||
spring_like = _f(context, "spring_score_hint")
|
||||
utad_like = _f(context, "utad_score_hint")
|
||||
if cycle in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.RE_ACCUMULATION.value):
|
||||
if pos < 0.25 or spring_like >= 50:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.C.value,
|
||||
confidence=75.0 + min(15.0, spring_like * 0.15),
|
||||
score=78.0,
|
||||
reasons=["区间低位测试，疑似 Phase C (Spring/Test)"],
|
||||
)
|
||||
if cycle in (WyckoffCycle.DISTRIBUTION.value, WyckoffCycle.RE_DISTRIBUTION.value):
|
||||
if pos > 0.75 or utad_like >= 50:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.C.value,
|
||||
confidence=75.0,
|
||||
score=78.0,
|
||||
reasons=["区间高位测试，疑似 Phase C (UTAD)"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class PhaseDRule(WyckoffRule):
|
||||
rule_id = "phase_d"
|
||||
category = "phase"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
close = _f(context, "close")
|
||||
ma20 = _f(context, "ma20")
|
||||
range_high = _f(context, "range_high")
|
||||
range_low = _f(context, "range_low")
|
||||
vol_ratio = _f(context, "volume_ratio")
|
||||
if cycle in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.RE_ACCUMULATION.value):
|
||||
if close > ma20 and range_high > 0 and close >= range_high * 0.98 and vol_ratio >= 1.1:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.D.value,
|
||||
confidence=80.0,
|
||||
score=82.0,
|
||||
reasons=["突破区间上沿放量，疑似 Phase D SOS"],
|
||||
)
|
||||
if cycle in (WyckoffCycle.DISTRIBUTION.value, WyckoffCycle.RE_DISTRIBUTION.value):
|
||||
if close < ma20 and range_low > 0 and close <= range_low * 1.02:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.D.value,
|
||||
confidence=80.0,
|
||||
score=82.0,
|
||||
reasons=["跌破区间下沿，疑似 Phase D SOW"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
class PhaseERule(WyckoffRule):
|
||||
rule_id = "phase_e"
|
||||
category = "phase"
|
||||
timeframes = ("1w", "1d")
|
||||
|
||||
def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
|
||||
cycle = _cycle(context)
|
||||
# Markup/Markdown already imply trend continuation (Phase E of prior structure)
|
||||
if cycle == WyckoffCycle.MARKUP.value:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.E.value,
|
||||
confidence=78.0,
|
||||
score=80.0,
|
||||
reasons=["趋势上行，对应 Phase E Markup"],
|
||||
)
|
||||
if cycle == WyckoffCycle.MARKDOWN.value:
|
||||
return RuleHit(
|
||||
rule_id=self.rule_id,
|
||||
phase=WyckoffPhase.E.value,
|
||||
confidence=78.0,
|
||||
score=80.0,
|
||||
reasons=["趋势下行，对应 Phase E Markdown"],
|
||||
)
|
||||
return None
|
||||
|
||||
|
||||
def build_rules() -> list[WyckoffRule]:
|
||||
# More specific phases first
|
||||
return [PhaseDRule(), PhaseCRule(), PhaseARule(), PhaseBRule(), PhaseERule()]
|
||||
@@ -0,0 +1,39 @@
|
||||
"""Rule Registry — register Wyckoff rules without modifying engines."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from crypto_wyckoff.rules.base import WyckoffRule
|
||||
|
||||
|
||||
class RuleRegistry:
|
||||
def __init__(self) -> None:
|
||||
self._rules: dict[str, WyckoffRule] = {}
|
||||
|
||||
def register(self, rule: WyckoffRule) -> None:
|
||||
self._rules[rule.rule_id] = rule
|
||||
|
||||
def get(self, rule_id: str) -> WyckoffRule | None:
|
||||
return self._rules.get(rule_id)
|
||||
|
||||
def by_category(self, category: str, timeframe: str | None = None) -> list[WyckoffRule]:
|
||||
out = [r for r in self._rules.values() if r.category == category]
|
||||
if timeframe:
|
||||
out = [r for r in out if timeframe in r.timeframes]
|
||||
return out
|
||||
|
||||
def all(self) -> list[WyckoffRule]:
|
||||
return list(self._rules.values())
|
||||
|
||||
|
||||
rule_registry = RuleRegistry()
|
||||
|
||||
|
||||
def _register_defaults() -> None:
|
||||
from crypto_wyckoff.rules import cycle_rules, event_rules, phase_rules
|
||||
|
||||
for mod in (cycle_rules, phase_rules, event_rules):
|
||||
for rule in mod.build_rules():
|
||||
rule_registry.register(rule)
|
||||
|
||||
|
||||
_register_defaults()
|
||||
Reference in New Issue
Block a user