jackyu66git
50a609f7b9
- Change provider_url to https://provider.jackyu66.com - Update top50_symbols to match provider's actual 20 symbols - Fix cmd_score crash: all_scores keys are already strings, not enums - Add .gitignore to exclude data/ directory
365 lines
13 KiB
Python
365 lines
13 KiB
Python
"""
|
|
cli.py — Command-line interface for ChanMacro.
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import logging
|
|
from datetime import date as Date, datetime, timedelta
|
|
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
|
|
)
|
|
logger = logging.getLogger("chanmacro")
|
|
|
|
|
|
def parse_date(date_str: str) -> Date:
|
|
"""Parse YYYY-MM-DD string to Date."""
|
|
return datetime.strptime(date_str, "%Y-%m-%d").date()
|
|
|
|
|
|
def _build_market_state(target: Date) -> tuple:
|
|
"""Shared helper: compute all scores → (MarketStateVector, RegimeResult)."""
|
|
from config import config
|
|
from scoring.price_structure import PriceStructureScorer
|
|
from scoring.breadth_scorer import BreadthScorer
|
|
from scoring.oi_matrix import OIMatrixScorer
|
|
from scoring.volatility_regime import VolatilityRegimeScorer
|
|
from regime_detector import RegimeDetector
|
|
from models import MarketStateVector
|
|
|
|
ps = PriceStructureScorer().compute(target)
|
|
br = BreadthScorer().compute(target)
|
|
oi = OIMatrixScorer().compute(target)
|
|
vol = VolatilityRegimeScorer().compute(target)
|
|
|
|
detector = RegimeDetector()
|
|
detector.load_state(config.db_path)
|
|
r = detector.detect(ps.score, br.breadth_top50, vol.vol_regime.value, target)
|
|
|
|
state = MarketStateVector(
|
|
date=target, regime=r.regime, regime_confidence=r.confidence,
|
|
regime_version=r.regime_version, regime_maturity_score=r.maturity_score,
|
|
breadth_top20=br.breadth_top20, breadth_top30=br.breadth_top30,
|
|
breadth_top50=br.breadth_top50, breadth_bucket=br.breadth_bucket,
|
|
breadth_divergence=br.breadth_divergence,
|
|
oi_state=oi.oi_state, volatility_regime=vol.vol_regime,
|
|
price_structure_score=ps, breadth_score=br,
|
|
oi_matrix_score=oi, volatility_regime_score=vol,
|
|
)
|
|
state.market_state_hash = state.compute_hash()
|
|
return state, r
|
|
|
|
|
|
def cmd_fetch(args):
|
|
"""Fetch raw data and store to DB."""
|
|
from database import init_db
|
|
from fetchers.ohlcv import OHLCVFetcher
|
|
from fetchers.breadth import BreadthFetcher
|
|
|
|
target = parse_date(args.date) if args.date else Date.today()
|
|
init_db()
|
|
|
|
module = args.module or "all"
|
|
|
|
if module in ("ohlcv", "all"):
|
|
logger.info(f"Fetching OHLCV for {target}...")
|
|
fetcher = OHLCVFetcher()
|
|
df = fetcher.fetch(target)
|
|
if not df.empty:
|
|
n = fetcher.store_df(df)
|
|
logger.info(f"OHLCV: stored {n} rows")
|
|
|
|
if module in ("breadth", "all"):
|
|
logger.info(f"Fetching Breadth for {target}...")
|
|
fetcher = BreadthFetcher()
|
|
record = fetcher.fetch(target)
|
|
if record:
|
|
fetcher.store(record=record)
|
|
logger.info(f"Breadth: stored (adv={record.get('advance_top50')}, "
|
|
f"dec={record.get('decline_top50')}, "
|
|
f"ema20={record.get('above_ema20_top50')})")
|
|
|
|
if module in ("derivatives", "all"):
|
|
logger.info(f"Fetching Derivatives for {target}...")
|
|
from fetchers.derivatives import DerivativesFetcher
|
|
fetcher = DerivativesFetcher()
|
|
records = fetcher.fetch(target)
|
|
if records:
|
|
n = fetcher.store(records=records)
|
|
logger.info(f"Derivatives: stored {n} records")
|
|
|
|
|
|
def cmd_score(args):
|
|
"""Compute all factor scores and regime for a date."""
|
|
from database import init_db, get_connection
|
|
|
|
target = parse_date(args.date) if args.date else Date.today()
|
|
init_db()
|
|
logger.info(f"Computing scores for {target}...")
|
|
|
|
state, regime_result = _build_market_state(target)
|
|
|
|
# Output
|
|
ps = state.price_structure_score
|
|
br = state.breadth_score
|
|
oi = state.oi_matrix_score
|
|
vol = state.volatility_regime_score
|
|
|
|
print(f"\n{'='*60}")
|
|
print(f" {target} Market State")
|
|
print(f"{'='*60}")
|
|
print(f" Regime: {state.regime.value} (conf={state.regime_confidence:.2f}, "
|
|
f"v={state.regime_version})")
|
|
print(f" Maturity: {state.regime_maturity_score:.0f}/100")
|
|
print(f" Breadth: {state.breadth_bucket.value} "
|
|
f"(T20={state.breadth_top20:.0f} T30={state.breadth_top30:.0f} "
|
|
f"T50={state.breadth_top50:.0f} div={state.breadth_divergence:+.0f})")
|
|
print(f" OI State: {state.oi_state.value}")
|
|
print(f" Volatility: {state.volatility_regime.value}")
|
|
print(f"{'='*60}")
|
|
print(f" Scores:")
|
|
print(f" Price Structure: {ps.score:.0f} {ps.label}")
|
|
print(f" Breadth: {br.score:.0f} {br.breadth_bucket.value}")
|
|
print(f" OI Matrix: {oi.score:.0f} {oi.oi_state.value}")
|
|
print(f" Volatility: {vol.score:.0f} {vol.vol_regime.value}")
|
|
print(f"{'='*60}")
|
|
print(f" Market State Hash: {state.market_state_hash}")
|
|
print()
|
|
|
|
# Store regime to DB
|
|
conn = get_connection()
|
|
conn.execute("""
|
|
INSERT OR REPLACE INTO regime_history
|
|
(date, regime, confidence, regime_version, maturity_score, all_scores_json,
|
|
prior_regime, confirmation_days)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
""", (
|
|
str(target),
|
|
state.regime.value,
|
|
state.regime_confidence,
|
|
state.regime_version,
|
|
state.regime_maturity_score,
|
|
json.dumps(regime_result.all_scores),
|
|
regime_result.prior_regime.value if regime_result.prior_regime else None,
|
|
regime_result.confirmation_days,
|
|
))
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
return state
|
|
|
|
|
|
def cmd_regime(args):
|
|
"""Show regime history."""
|
|
from database import get_connection
|
|
days = args.days or 30
|
|
conn = get_connection()
|
|
rows = conn.execute(
|
|
"SELECT date, regime, confidence, maturity_score, confirmation_days "
|
|
"FROM regime_history ORDER BY date DESC LIMIT ?",
|
|
(days,)
|
|
).fetchall()
|
|
conn.close()
|
|
|
|
print(f"\n{'='*50}")
|
|
print(f" Regime History (last {days} days)")
|
|
print(f"{'='*50}")
|
|
for r in rows:
|
|
print(f" {r['date']} {r['regime']:7s} conf={r['confidence']:.2f} "
|
|
f"mat={r['maturity_score']:.0f} days={r['confirmation_days']}")
|
|
print()
|
|
|
|
|
|
def cmd_track(args):
|
|
"""Record a trading signal with current market state."""
|
|
from database import init_db
|
|
from expectancy.tracker import SignalTracker
|
|
|
|
target = parse_date(args.date) if args.date else Date.today()
|
|
init_db()
|
|
|
|
logger.info(f"Recording {args.signal} on {target} @ {args.price}")
|
|
|
|
state, _ = _build_market_state(target)
|
|
|
|
tracker = SignalTracker()
|
|
rid = tracker.record(
|
|
date=target, signal_type=args.signal, entry_price=args.price,
|
|
state=state, signal_grade=args.grade, signal_strength=args.strength,
|
|
)
|
|
logger.info(f"Signal recorded: id={rid}")
|
|
|
|
|
|
def cmd_backfill(args):
|
|
"""Backfill historical scores and/or signals."""
|
|
from datetime import date as Date, timedelta
|
|
from database import init_db, get_connection
|
|
from fetchers.ohlcv import OHLCVFetcher
|
|
|
|
start = parse_date(args.from_date)
|
|
end = parse_date(args.to_date) if args.to_date else Date.today()
|
|
init_db()
|
|
|
|
# First, backfill OHLCV data
|
|
logger.info(f"Backfilling OHLCV from {start} to {end}...")
|
|
fetcher = OHLCVFetcher()
|
|
df = fetcher.fetch()
|
|
if not df.empty:
|
|
fetcher.store_df(df)
|
|
|
|
# Then compute scores for each date
|
|
from scoring.price_structure import PriceStructureScorer
|
|
from scoring.breadth_scorer import BreadthScorer
|
|
from scoring.oi_matrix import OIMatrixScorer
|
|
from scoring.volatility_regime import VolatilityRegimeScorer
|
|
from regime_detector import RegimeDetector
|
|
|
|
detector = RegimeDetector()
|
|
conn = get_connection()
|
|
|
|
current = start
|
|
count = 0
|
|
while current <= end:
|
|
try:
|
|
ps = PriceStructureScorer().compute(current)
|
|
br = BreadthScorer().compute(current)
|
|
if br.score == 50.0 and br.label == "No Data":
|
|
current += timedelta(days=1)
|
|
continue
|
|
|
|
oi = OIMatrixScorer().compute(current)
|
|
vol = VolatilityRegimeScorer().compute(current)
|
|
r = detector.detect(ps.score, br.breadth_top50,
|
|
vol.vol_regime.value, current)
|
|
|
|
conn.execute("""
|
|
INSERT OR REPLACE INTO regime_history
|
|
(date, regime, confidence, regime_version, maturity_score,
|
|
all_scores_json, confirmation_days)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
""", (
|
|
str(current), r.regime.value, r.confidence,
|
|
r.regime_version, r.maturity_score,
|
|
json.dumps(r.all_scores), r.confirmation_days,
|
|
))
|
|
count += 1
|
|
if count % 30 == 0:
|
|
conn.commit()
|
|
logger.info(f" Backfilled {count} days... ({current})")
|
|
except Exception as e:
|
|
logger.debug(f" Skip {current}: {e}")
|
|
current += timedelta(days=1)
|
|
|
|
conn.commit()
|
|
conn.close()
|
|
logger.info(f"Backfill complete: {count} days scored")
|
|
|
|
|
|
def cmd_expectancy(args):
|
|
"""Query signal expectancy for current market state."""
|
|
from database import init_db
|
|
from expectancy.engine import BayesianExpectancyEngine
|
|
|
|
target = parse_date(args.date) if args.date else Date.today()
|
|
init_db()
|
|
|
|
state, _ = _build_market_state(target)
|
|
|
|
engine = BayesianExpectancyEngine()
|
|
signal = args.signal or "B3"
|
|
report = engine.estimate(state, signal_type=signal, target_date=target)
|
|
|
|
print(f"\n{'='*60}")
|
|
print(f" {target} Signal Expectancy: {signal}")
|
|
print(f"{'='*60}")
|
|
print(f" Regime: {state.regime.value} (conf={state.regime_confidence:.2f})")
|
|
print(f" Breadth: {state.breadth_bucket.value} (T50={state.breadth_top50:.0f})")
|
|
print(f" OI State: {state.oi_state.value}")
|
|
print(f" Volatility: {state.volatility_regime.value}")
|
|
print(f"{'='*60}")
|
|
|
|
for layer in report.layers:
|
|
print(f" {layer.name:15s} N={layer.samples:4d} eff={layer.effective_samples:.0f} "
|
|
f"raw={layer.raw_winrate or 0:.1%} post={layer.posterior_winrate:.1%} "
|
|
f"ret={layer.avg_return or 0:+.1f}%")
|
|
|
|
print(f"{'='*60}")
|
|
print(f" Final: {report.final_estimate:.1%} "
|
|
f"(sufficiency={report.sufficiency.value}, source={report.source})")
|
|
if report.profit_factor:
|
|
print(f" PF={report.profit_factor} MAE={report.max_adverse_excursion}%")
|
|
print()
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="ChanMacro — Crypto Market Memory System"
|
|
)
|
|
sub = parser.add_subparsers(dest="command", help="Commands")
|
|
|
|
# fetch
|
|
p_fetch = sub.add_parser("fetch", help="Fetch raw data")
|
|
p_fetch.add_argument("--date", help="Target date (YYYY-MM-DD)")
|
|
p_fetch.add_argument("--module", choices=["ohlcv", "breadth", "derivatives", "all"])
|
|
|
|
# score
|
|
p_score = sub.add_parser("score", help="Compute scores and regime")
|
|
p_score.add_argument("--date", help="Target date (YYYY-MM-DD)")
|
|
|
|
# regime
|
|
p_regime = sub.add_parser("regime", help="Show regime history")
|
|
p_regime.add_argument("--days", type=int, default=30)
|
|
|
|
# track
|
|
p_track = sub.add_parser("track", help="Record a trading signal")
|
|
p_track.add_argument("--date", help="Signal date (YYYY-MM-DD)")
|
|
p_track.add_argument("--signal", required=True, help="Signal type (B1/B2/B3/S1/S2/S3)")
|
|
p_track.add_argument("--price", type=float, required=True, help="Entry price")
|
|
p_track.add_argument("--grade", choices=["A", "B", "C"], help="Signal quality grade")
|
|
p_track.add_argument("--strength", type=float, help="Signal strength 0-100")
|
|
|
|
# backfill
|
|
p_backfill = sub.add_parser("backfill", help="Backfill historical scores")
|
|
p_backfill.add_argument("--from", dest="from_date", required=True)
|
|
p_backfill.add_argument("--to", dest="to_date")
|
|
|
|
# expectancy
|
|
p_expectancy = sub.add_parser("expectancy", help="Query signal expectancy")
|
|
p_expectancy.add_argument("--date", help="Target date (YYYY-MM-DD)")
|
|
p_expectancy.add_argument("--signal", default="B3", help="Signal type")
|
|
|
|
# validate
|
|
p_validate = sub.add_parser("validate", help="Run validation framework")
|
|
|
|
# serve
|
|
p_serve = sub.add_parser("serve", help="Start web dashboard")
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.command == "fetch":
|
|
cmd_fetch(args)
|
|
elif args.command == "score":
|
|
cmd_score(args)
|
|
elif args.command == "regime":
|
|
cmd_regime(args)
|
|
elif args.command == "track":
|
|
cmd_track(args)
|
|
elif args.command == "backfill":
|
|
cmd_backfill(args)
|
|
elif args.command == "expectancy":
|
|
cmd_expectancy(args)
|
|
elif args.command == "validate":
|
|
from validation.reporter import ValidationReporter
|
|
report = ValidationReporter().run_all()
|
|
print(report)
|
|
elif args.command == "serve":
|
|
logger.info("Web dashboard not yet implemented (Phase 7)")
|
|
else:
|
|
parser.print_help()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|