Create app.py

app.py

@@ -0,0 +1,160 @@
+import logging
+import sys
+import json
+from typing import Optional, List
+
+import pandas as pd
+
+from config import DEFAULT_SYMBOLS, TOP_N_TOKENS, TIMEFRAME, CANDLE_LIMIT
+from data_fetcher import fetch_multiple, fetch_instruments
+from regime import detect_regime
+from volume_analysis import analyze_volume
+from risk_engine import evaluate_risk
+from veto import apply_veto
+from scorer import compute_structure_score, score_token, rank_tokens
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+logger = logging.getLogger("main")
+
+
+def analyze_symbol(symbol: str, df: pd.DataFrame, account_equity: float = 10000.0):
+    regime_data = detect_regime(df)
+    volume_data = analyze_volume(df)
+
+    structure_score = compute_structure_score(regime_data)
+
+    vetoed, veto_reason = apply_veto(regime_data, volume_data, structure_score)
+
+    scores = score_token(regime_data, volume_data, vetoed)
+
+    risk_data = evaluate_risk(
+        df_last_close=df["close"].iloc[-1],
+        atr=regime_data["atr"],
+        atr_pct=regime_data["atr_pct"],
+        regime_score=regime_data["regime_score"],
+        vol_ratio=regime_data["vol_ratio"],
+        account_equity=account_equity,
+    )
+
+    return {
+        "symbol": symbol,
+        "close": round(df["close"].iloc[-1], 8),
+        "trend": regime_data["trend"],
+        "vol_ratio": round(regime_data["vol_ratio"], 3),
+        "volatility_expanding": regime_data["volatility_expanding"],
+        "volume_spike": volume_data["spike"],
+        "volume_climax": volume_data["climax"],
+        "breakout": volume_data["breakout"],
+        "vetoed": vetoed,
+        "veto_reason": veto_reason,
+        "regime_score": scores["regime_score"],
+        "volume_score": scores["volume_score"],
+        "structure_score": scores["structure_score"],
+        "total_score": scores["total_score"],
+        "risk": risk_data,
+    }
+
+
+def run(
+    symbols: Optional[List[str]] = None,
+    account_equity: float = 10000.0,
+    fetch_live_instruments: bool = False,
+    max_symbols: Optional[int] = None,
+    top_n: int = TOP_N_TOKENS,
+):
+    if fetch_live_instruments:
+        logger.info("Fetching live instrument list from OKX...")
+        live_symbols = fetch_instruments("SPOT")
+        if live_symbols:
+            symbols = live_symbols
+            logger.info(f"Found {len(symbols)} live USDT spot instruments")
+        else:
+            logger.warning("Failed to fetch instruments, using defaults")
+            symbols = DEFAULT_SYMBOLS
+    elif symbols is None:
+        symbols = DEFAULT_SYMBOLS
+
+    logger.info(f"Fetching OHLCV data for {len(symbols)} symbols...")
+    ohlcv_map = fetch_multiple(symbols, timeframe=TIMEFRAME, limit=CANDLE_LIMIT, max_symbols=max_symbols)
+    logger.info(f"Successfully fetched {len(ohlcv_map)} symbols")
+
+    results = {}
+    for sym, df in ohlcv_map.items():
+        try:
+            result = analyze_symbol(sym, df, account_equity=account_equity)
+            results[sym] = result
+        except Exception as e:
+            logger.error(f"Error analyzing {sym}: {e}", exc_info=True)
+
+    ranked = rank_tokens({sym: r for sym, r in results.items()})
+
+    logger.info("\n" + "=" * 80)
+    logger.info(f"TOP {top_n} SETUPS RANKED BY TOTAL SCORE")
+    logger.info("=" * 80)
+
+    top_results = []
+    for rank, (sym, data) in enumerate(ranked[:top_n], 1):
+        veto_str = f" [VETOED: {data['veto_reason']}]" if data["vetoed"] else ""
+        logger.info(
+            f"#{rank:>3} {sym:<15} "
+            f"Score={data['total_score']:.4f} "
+            f"(R={data['regime_score']:.2f} V={data['volume_score']:.2f} S={data['structure_score']:.2f}) "
+            f"Trend={data['trend']:<8} "
+            f"VolRatio={data['vol_ratio']:.2f} "
+            f"Spike={data['volume_spike']} "
+            f"Breakout={data['breakout']:>2}"
+            f"{veto_str}"
+        )
+        top_results.append(data)
+
+    logger.info("=" * 80)
+
+    non_vetoed = [(s, d) for s, d in ranked if not d["vetoed"]]
+    if non_vetoed:
+        best_sym, best_data = non_vetoed[0]
+        logger.info(f"\nBEST SETUP: {best_sym}")
+        risk = best_data["risk"]
+        logger.info(f"  Entry:          {risk['entry_price']:.8f}")
+        logger.info(f"  Stop (Long):    {risk['stop_price_long']:.8f}")
+        logger.info(f"  Target (Long):  {risk['target_long']:.8f}")
+        logger.info(f"  ATR:            {risk['atr']:.8f} ({risk['atr_pct']*100:.2f}%)")
+        logger.info(f"  Risk Fraction:  {risk['risk_fraction']*100:.2f}%")
+        logger.info(f"  Position Size:  ${risk['position_notional']:.2f} notional")
+
+    return {
+        "all_results": results,
+        "ranked": ranked,
+        "top_n": top_results,
+    }
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="OKX Trading Analysis Engine")
+    parser.add_argument("--equity", type=float, default=10000.0, help="Account equity in USD")
+    parser.add_argument("--top", type=int, default=TOP_N_TOKENS, help="Number of top setups to display")
+    parser.add_argument("--max-symbols", type=int, default=None, help="Limit number of symbols analyzed")
+    parser.add_argument("--live-instruments", action="store_true", help="Fetch live instrument list from OKX")
+    parser.add_argument("--output", type=str, default=None, help="Save results to JSON file")
+    args = parser.parse_args()
+
+    output = run(
+        account_equity=args.equity,
+        fetch_live_instruments=args.live_instruments,
+        max_symbols=args.max_symbols,
+        top_n=args.top,
+    )
+
+    if args.output:
+        serializable = {
+            sym: {k: v for k, v in data.items() if k != "risk"}
+            for sym, data in output["all_results"].items()
+        }
+        with open(args.output, "w") as f:
+            json.dump(serializable, f, indent=2, default=str)
+        logger.info(f"Results saved to {args.output}")