Update main.py

main.py

@@ -23,21 +23,17 @@ GATE_API_BASE = os.getenv("GATE_API_BASE", "https://api.gate.io/api/v4")
 LOG_FILE = os.getenv("TRADE_LOG_FILE", "trading_log.jsonl")
 BAL_FILE = os.getenv("BALANCE_SNAP_FILE", "balance_snapshots.jsonl")
 
-LLM_ENDPOINT = os.getenv("LLM_ENDPOINT")  # HF Inference endpoint or similar
-LLM_API_KEY = os.getenv("LLM_API_KEY")    # optional bearer token
+LLM_ENDPOINT = os.getenv("LLM_ENDPOINT")
+LLM_API_KEY = os.getenv("LLM_API_KEY")
 
-if not GATE_API_KEY or not GATE_API_SECRET:
-    raise RuntimeError("GATE_API_KEY and GATE_API_SECRET must be set")
+# DRY_RUN = true when explicitly set OR when exchange keys are missing
+DRY_RUN = os.getenv("DRY_RUN", "0") == "1" or not (GATE_API_KEY and GATE_API_SECRET)
 
-# -----------------------------------------------------------------------------
-# FastAPI app
-# -----------------------------------------------------------------------------
-
-app = FastAPI(title="gate4-alpha-api", version="0.2.0")
+app = FastAPI(title="gate4-alpha-api", version="0.3.0", docs_url="/docs", redoc_url="/redoc")
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # restrict in real deployment
+    allow_origins=["*"],  # tighten for prod
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -81,7 +77,6 @@ class KPIResponse(BaseModel):
 class AlphaRequest(BaseModel):
     contract: str
     context: Optional[str] = None
-    # Optional overrides for KPI input if caller wants to inject their data
     kpis_override: Optional[Dict[str, float]] = None
 
 
@@ -96,7 +91,54 @@ class AlphaDecision(BaseModel):
 
 
 # -----------------------------------------------------------------------------
-# Gate.io helpers
+# File-backed state
+# -----------------------------------------------------------------------------
+
+def _safe_read_lines(path: str) -> List[str]:
+    if not os.path.exists(path):
+        return []
+    with open(path, "r") as f:
+        return [line for line in f if line.strip()]
+
+
+def load_trades() -> List[TradeLog]:
+    lines = _safe_read_lines(LOG_FILE)
+    out: List[TradeLog] = []
+    for line in lines:
+        try:
+            raw = json.loads(line)
+            out.append(TradeLog(**raw))
+        except (json.JSONDecodeError, ValidationError):
+            continue
+    return out
+
+
+def load_balances() -> List[BalanceSnapshot]:
+    lines = _safe_read_lines(BAL_FILE)
+    out: List[BalanceSnapshot] = []
+    for line in lines:
+        try:
+            raw = json.loads(line)
+            out.append(BalanceSnapshot(**raw))
+        except (json.JSONDecodeError, ValidationError):
+            continue
+    return out
+
+
+def append_trade(trade: TradeLog) -> None:
+    with _log_lock, open(LOG_FILE, "a") as f:
+        f.write(trade.model_json() + "\n")
+
+
+def append_balance_snapshot(balance: float) -> BalanceSnapshot:
+    snap = BalanceSnapshot(timestamp=int(time.time()), balance=balance)
+    with _bal_lock, open(BAL_FILE, "a") as f:
+        f.write(snap.model_json() + "\n")
+    return snap
+
+
+# -----------------------------------------------------------------------------
+# Gate.io helpers (dry-run aware)
 # -----------------------------------------------------------------------------
 
 def sign_request(method: str, path: str, query_string: str, body: str, timestamp: str) -> str:
@@ -109,6 +151,9 @@ def sign_request(method: str, path: str, query_string: str, body: str, timestamp
 
 
 def gate_private_get(path: str, query: str = "") -> Any:
+    if DRY_RUN:
+        raise HTTPException(status_code=503, detail="Exchange private API disabled in dry-run mode")
+
     method = "GET"
     timestamp = str(int(time.time()))
     body = ""
@@ -128,14 +173,17 @@ def gate_private_get(path: str, query: str = "") -> Any:
         res.raise_for_status()
     except requests.RequestException as e:
         raise HTTPException(status_code=502, detail=f"Gate.io request failed: {e}")
-
     return res.json()
 
 
 def gate_public_get(path: str, query: str = "") -> Any:
+    if DRY_RUN:
+        raise HTTPException(status_code=503, detail="Exchange public API disabled in dry-run mode")
+
     url = f"{GATE_API_BASE}{path}"
     if query:
         url = f"{url}?{query}"
+
     try:
         res = requests.get(url, timeout=10)
         res.raise_for_status()
@@ -145,9 +193,15 @@ def gate_public_get(path: str, query: str = "") -> Any:
 
 
 def get_futures_account_total_balance() -> float:
+    if DRY_RUN:
+        # In dry-run: use last balance if exists, else deterministic constant
+        balances = load_balances()
+        if balances:
+            return balances[-1].balance
+        return float(os.getenv("DRY_RUN_BALANCE", "10000.0"))
+
     path = "/futures/usdt/accounts"
     accounts = gate_private_get(path)
-    # Gate futures account endpoint returns a list of account objects
     total = 0.0
     for acc in accounts:
         try:
@@ -158,9 +212,10 @@ def get_futures_account_total_balance() -> float:
 
 
 def get_contract_spread_bps(contract: str) -> float:
-    """
-    Uses futures ticker to derive bid/ask spread in basis points.
-    """
+    if DRY_RUN:
+        # Deterministic spread for offline mode; override via env if needed
+        return float(os.getenv("DRY_RUN_SPREAD_BPS", "5.0"))
+
     path = "/futures/usdt/tickers"
     query = f"contract={contract}"
     tickers = gate_public_get(path, query=query)
@@ -183,54 +238,6 @@ def get_contract_spread_bps(contract: str) -> float:
     return spread_bps
 
 
-# -----------------------------------------------------------------------------
-# File-backed state
-# -----------------------------------------------------------------------------
-
-def _safe_read_lines(path: str) -> List[str]:
-    if not os.path.exists(path):
-        return []
-    with open(path, "r") as f:
-        return [line for line in f if line.strip()]
-
-
-def load_trades() -> List[TradeLog]:
-    lines = _safe_read_lines(LOG_FILE)
-    out: List[TradeLog] = []
-    for line in lines:
-        try:
-            raw = json.loads(line)
-            out.append(TradeLog(**raw))
-        except (json.JSONDecodeError, ValidationError):
-            # skip malformed line
-            continue
-    return out
-
-
-def load_balances() -> List[BalanceSnapshot]:
-    lines = _safe_read_lines(BAL_FILE)
-    out: List[BalanceSnapshot] = []
-    for line in lines:
-        try:
-            raw = json.loads(line)
-            out.append(BalanceSnapshot(**raw))
-        except (json.JSONDecodeError, ValidationError):
-            continue
-    return out
-
-
-def append_trade(trade: TradeLog) -> None:
-    with _log_lock, open(LOG_FILE, "a") as f:
-        f.write(trade.model_json() + "\n")
-
-
-def append_balance_snapshot(balance: float) -> BalanceSnapshot:
-    snap = BalanceSnapshot(timestamp=int(time.time()), balance=balance)
-    with _bal_lock, open(BAL_FILE, "a") as f:
-        f.write(snap.model_json() + "\n")
-    return snap
-
-
 # -----------------------------------------------------------------------------
 # KPI logic
 # -----------------------------------------------------------------------------
@@ -282,7 +289,7 @@ def kpis_to_feature_dict(kpis: KPIResponse) -> Dict[str, float]:
 
 
 # -----------------------------------------------------------------------------
-# LLM integration
+# LLM integration (dry-run aware)
 # -----------------------------------------------------------------------------
 
 def _build_alpha_prompt(req: AlphaRequest, spread_bps: float, kpis: Dict[str, float]) -> str:
@@ -306,11 +313,16 @@ def _build_alpha_prompt(req: AlphaRequest, spread_bps: float, kpis: Dict[str, fl
 
 def call_llm_for_alpha(prompt: str) -> Dict[str, Any]:
     if not LLM_ENDPOINT:
-        raise HTTPException(status_code=500, detail="LLM_ENDPOINT not configured")
+        # Dry-run LLM: force flat, no external call
+        return {
+            "action": "flat",
+            "confidence": 0.0,
+            "size_factor": 0.0,
+            "comment": "LLM endpoint not configured; dry-run flat policy.",
+        }
 
     payload = {
         "inputs": prompt,
-        # HF / generic text generation params; adjust per endpoint
         "parameters": {
             "max_new_tokens": 256,
             "temperature": 0.1,
@@ -333,18 +345,14 @@ def call_llm_for_alpha(prompt: str) -> Dict[str, Any]:
     except json.JSONDecodeError:
         raise HTTPException(status_code=502, detail="LLM returned non-JSON payload")
 
-    # HF endpoints often return [{"generated_text": "..."}]
     if isinstance(data, list) and data and isinstance(data[0], dict) and "generated_text" in data[0]:
         text = data[0]["generated_text"]
     elif isinstance(data, dict) and "generated_text" in data:
         text = data["generated_text"]
     else:
-        # assume raw text
         text = str(data)
 
-    # extract JSON from text
     text = text.strip()
-    # best-effort: find first '{' ... last '}'
     start = text.find("{")
     end = text.rfind("}")
     if start == -1 or end == -1 or end <= start:
@@ -365,7 +373,7 @@ def build_alpha_decision(
     kpi_features: Dict[str, float],
     raw_model_out: Dict[str, Any],
 ) -> AlphaDecision:
-    action = raw_model_out.get("action", "").lower().strip()
+    action = str(raw_model_out.get("action", "")).lower().strip()
     if action not in ("long", "short", "flat"):
         action = "flat"
 
@@ -373,7 +381,6 @@ def build_alpha_decision(
     size_factor = float(raw_model_out.get("size_factor", 0.0))
     comment = str(raw_model_out.get("comment", "")).strip()[:240]
 
-    # Hard safety clamps
     if confidence < 0.0:
         confidence = 0.0
     if confidence > 1.0:
@@ -383,9 +390,7 @@ def build_alpha_decision(
     if size_factor > 1.0:
         size_factor = 1.0
 
-    # Deterministic risk gating based on KPIs
     if kpi_features.get("max_drawdown_pct", 0.0) < -30.0:
-        # lock system to flat on deep drawdown
         action = "flat"
         confidence = min(confidence, 0.3)
         size_factor = 0.0
@@ -404,7 +409,7 @@ def build_alpha_decision(
         spread_bps=spread_bps,
         kpis=kpi_features,
         comment=comment,
-        raw_model_output=raw_model_out,
+        raw_model_output=raw_model_out if LLM_ENDPOINT else None,
     )
 
 
@@ -414,10 +419,11 @@ def build_alpha_decision(
 
 @app.get("/", response_class=HTMLResponse)
 def home() -> str:
-    return """
+    mode = "DRY-RUN" if DRY_RUN else "LIVE"
+    return f"""
     <html>
       <body>
-        <h2>gate4-alpha-api</h2>
+        <h2>gate4-alpha-api ({mode})</h2>
         <p>Endpoints:</p>
         <ul>
           <li>GET /balance</li>
@@ -426,6 +432,7 @@ def home() -> str:
           <li>POST /log_trade</li>
           <li>POST /alpha/entry</li>
           <li>GET /openapi.yaml</li>
+          <li>GET /docs</li>
         </ul>
       </body>
     </html>
@@ -434,9 +441,6 @@ def home() -> str:
 
 @app.get("/openapi.yaml")
 def get_openapi():
-    """
-    Serve static OpenAPI file if you generate one externally.
-    """
     if not os.path.exists("openapi.yaml"):
         raise HTTPException(status_code=404, detail="openapi.yaml not found")
     return FileResponse("openapi.yaml", media_type="text/yaml")
@@ -444,26 +448,21 @@ def get_openapi():
 
 @app.get("/balance")
 def get_balance():
-    """
-    Snapshot Gate.io USDT futures account and persist balance curve.
-    """
     total = get_futures_account_total_balance()
     snap = append_balance_snapshot(total)
     return {
         "timestamp": snap.timestamp,
         "balance": round(snap.balance, 6),
+        "dry_run": DRY_RUN,
     }
 
 
 @app.get("/performance")
 def get_performance():
-    """
-    Human-readable PnL summary + last few trades.
-    """
     trades = load_trades()
     balances = load_balances()
     if not trades and not balances:
-        return {"summary": "No trades or balances logged yet."}
+        return {"summary": "No trades or balances logged yet.", "dry_run": DRY_RUN}
 
     kpis = compute_kpis(trades, balances)
     summary = (
@@ -491,14 +490,12 @@ def get_performance():
         "summary": summary,
         "last_trades": tail,
         "kpis": kpis.model_dump(),
+        "dry_run": DRY_RUN,
     }
 
 
 @app.get("/kpis", response_model=KPIResponse)
 def get_kpis():
-    """
-    Machine-consumable KPI surface for external systems.
-    """
     trades = load_trades()
     balances = load_balances()
     return compute_kpis(trades, balances)
@@ -506,10 +503,6 @@ def get_kpis():
 
 @app.post("/log_trade", response_model=TradeLog)
 async def log_trade(request: Request):
-    """
-    Append a trade event into the trading log.
-    Request body must match TradeLog schema (fields can be omitted if defaulted).
-    """
     payload = await request.json()
     try:
         trade = TradeLog(**payload)
@@ -521,12 +514,6 @@ async def log_trade(request: Request):
 
 @app.post("/alpha/entry", response_model=AlphaDecision)
 async def alpha_entry(req: AlphaRequest):
-    """
-    LLM-based entry decision:
-    - Derives KPIs from logs unless overridden.
-    - Computes current spread in bps for the requested contract.
-    - Calls LLM policy layer and enforces deterministic risk clamps.
-    """
     trades = load_trades()
     balances = load_balances()
     base_kpis = compute_kpis(trades, balances)