Spaces:

luguog
/

gate5

Sleeping

App Files Files Community

luguog commited on Nov 24, 2025

Commit

b833c19

verified ·

1 Parent(s): f477e21

Update main.py

Browse files

Files changed (1) hide show

main.py +515 -57

main.py CHANGED Viewed

@@ -1,86 +1,544 @@
-from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, FileResponse
-import os, time, hmac, hashlib, requests, json
-app = FastAPI()
 GATE_API_KEY = os.getenv("GATE_API_KEY")
 GATE_API_SECRET = os.getenv("GATE_API_SECRET")
-GATE_API_BASE = "https://api.gate.io/api/v4"
-LOG_FILE = "trading_log.json"
-BAL_FILE = "balance_snapshots.json"
-@app.get("/")
-def home():
-    return HTMLResponse("""
-    <html><body>
-    <h2>🚀 gate4: Live Gate.io GPT API</h2>
-    <p>Endpoints:</p>
-    <ul>
-        <li>/balance</li>
-        <li>/performance</li>
-        <li>/log_trade</li>
-        <li>/openapi.yaml</li>
-    </ul>
-    </body></html>
-    """)
-@app.get("/openapi.yaml")
-def get_openapi():
-    return FileResponse("openapi.yaml", media_type="text/yaml")
-@app.get("/balance")
-def get_balance():
-    path = "/futures/usdt/accounts"
     method = "GET"
     timestamp = str(int(time.time()))
     body = ""
-    query = ""
-    sign = sign_request(method, path, query, body, timestamp)
     headers = {
         "KEY": GATE_API_KEY,
         "Timestamp": timestamp,
-        "SIGN": sign
     }
     url = f"{GATE_API_BASE}{path}"
-    res = requests.get(url, headers=headers)
-    res.raise_for_status()
-    accounts = res.json()
-    total = sum(float(acc.get("available", 0)) for acc in accounts)
-    log_balance(total)
-    return {"balance": round(total, 2)}
 @app.get("/performance")
 def get_performance():
-    if not os.path.exists(LOG_FILE):
-        return {"summary": "No trades logged yet."}
-    with open(LOG_FILE, "r") as f:
-        trades = [json.loads(line) for line in f if line.strip()]
-    total_pnl = sum(t.get("pnl_estimate", 0) for t in trades)
-    summary = f"📊 Total PnL: ${total_pnl:.2f} from {len(trades)} trades."
     for t in trades[-5:]:
-        summary += f"\n• {t['action']} {t['contract']} → ${t['pnl_estimate']} ({t['reason']})"
-    return {"summary": summary}
-@app.post("/log_trade")
 async def log_trade(request: Request):
-    trade = await request.json()
-    with open(LOG_FILE, "a") as f:
-        f.write(json.dumps(trade) + "\n")
-    return {"status": "logged", "trade": trade}
-def log_balance(balance):
-    entry = {"timestamp": int(time.time()), "balance": balance}
-    with open(BAL_FILE, "a") as f:
-        f.write(json.dumps(entry) + "\n")
-def sign_request(method, path, query_string, body, timestamp):
-    message = f"{method}\n{path}\n{query_string}\n{body}\n{timestamp}"
-    return hmac.new(GATE_API_SECRET.encode(), message.encode(), hashlib.sha512).hexdigest()

+import os
+import time
+import json
+import hmac
+import hashlib
+import threading
+from typing import Any, Dict, List, Optional, Literal
+import requests
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field, ValidationError
+# -----------------------------------------------------------------------------
+# Config
+# -----------------------------------------------------------------------------
 GATE_API_KEY = os.getenv("GATE_API_KEY")
 GATE_API_SECRET = os.getenv("GATE_API_SECRET")
+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
+if not GATE_API_KEY or not GATE_API_SECRET:
+    raise RuntimeError("GATE_API_KEY and GATE_API_SECRET must be set")
+# -----------------------------------------------------------------------------
+# FastAPI app
+# -----------------------------------------------------------------------------
+app = FastAPI(title="gate4-alpha-api", version="0.2.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # restrict in real deployment
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+_log_lock = threading.Lock()
+_bal_lock = threading.Lock()
+# -----------------------------------------------------------------------------
+# Models
+# -----------------------------------------------------------------------------
+class TradeLog(BaseModel):
+    timestamp: int = Field(default_factory=lambda: int(time.time()))
+    action: Literal["long", "short", "flat", "close"]
+    contract: str
+    size: float
+    entry_price: float
+    exit_price: Optional[float] = None
+    pnl_realized: float = 0.0
+    pnl_estimate: float = 0.0
+    reason: Optional[str] = None
+    meta: Dict[str, Any] = Field(default_factory=dict)
+class BalanceSnapshot(BaseModel):
+    timestamp: int
+    balance: float
+class KPIResponse(BaseModel):
+    total_pnl: float
+    realized_pnl: float
+    trade_count: int
+    win_rate: float
+    max_drawdown_pct: float
+    avg_pnl_per_trade: float
+    equity_curve: List[BalanceSnapshot]
+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
+class AlphaDecision(BaseModel):
+    action: Literal["long", "short", "flat"]
+    confidence: float = Field(ge=0.0, le=1.0)
+    size_factor: float = Field(ge=0.0, le=1.0)
+    spread_bps: float
+    kpis: Dict[str, float]
+    comment: str
+    raw_model_output: Optional[Any] = None
+# -----------------------------------------------------------------------------
+# Gate.io helpers
+# -----------------------------------------------------------------------------
+def sign_request(method: str, path: str, query_string: str, body: str, timestamp: str) -> str:
+    message = f"{method}\n{path}\n{query_string}\n{body}\n{timestamp}"
+    return hmac.new(
+        GATE_API_SECRET.encode(),
+        message.encode(),
+        hashlib.sha512,
+    ).hexdigest()
+def gate_private_get(path: str, query: str = "") -> Any:
     method = "GET"
     timestamp = str(int(time.time()))
     body = ""
+    sign = sign_request(method, path, query, body, timestamp)
     headers = {
         "KEY": GATE_API_KEY,
         "Timestamp": timestamp,
+        "SIGN": sign,
     }
+    url = f"{GATE_API_BASE}{path}"
+    if query:
+        url = f"{url}?{query}"
+    try:
+        res = requests.get(url, headers=headers, timeout=10)
+        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:
     url = f"{GATE_API_BASE}{path}"
+    if query:
+        url = f"{url}?{query}"
+    try:
+        res = requests.get(url, timeout=10)
+        res.raise_for_status()
+    except requests.RequestException as e:
+        raise HTTPException(status_code=502, detail=f"Gate.io public request failed: {e}")
+    return res.json()
+def get_futures_account_total_balance() -> float:
+    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:
+            total += float(acc.get("available", 0.0))
+        except (TypeError, ValueError):
+            continue
+    return total
+def get_contract_spread_bps(contract: str) -> float:
+    """
+    Uses futures ticker to derive bid/ask spread in basis points.
+    """
+    path = "/futures/usdt/tickers"
+    query = f"contract={contract}"
+    tickers = gate_public_get(path, query=query)
+    if not tickers:
+        raise HTTPException(status_code=404, detail=f"No ticker data for {contract}")
+    t = tickers[0]
+    try:
+        bid = float(t.get("bid", 0.0))
+        ask = float(t.get("ask", 0.0))
+    except (TypeError, ValueError):
+        raise HTTPException(status_code=502, detail="Malformed ticker from Gate.io")
+    if bid <= 0 or ask <= 0 or ask <= bid:
+        return 0.0
+    mid = 0.5 * (bid + ask)
+    spread_bps = (ask - bid) / mid * 1e4
+    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
+# -----------------------------------------------------------------------------
+def compute_kpis(trades: List[TradeLog], balances: List[BalanceSnapshot]) -> KPIResponse:
+    realized_pnls = [t.pnl_realized for t in trades]
+    est_pnls = [t.pnl_estimate for t in trades]
+    realized_pnl = float(sum(realized_pnls))
+    total_pnl = float(realized_pnl + sum(est_pnls))
+    trade_count = len(trades)
+    wins = sum(1 for t in trades if t.pnl_realized > 0)
+    win_rate = float(wins / trade_count) if trade_count > 0 else 0.0
+    avg_pnl_per_trade = float(realized_pnl / trade_count) if trade_count > 0 else 0.0
+    equity_curve = balances
+    max_drawdown_pct = 0.0
+    if equity_curve:
+        peak = equity_curve[0].balance
+        for point in equity_curve:
+            if point.balance > peak:
+                peak = point.balance
+            if peak > 0:
+                dd = (point.balance - peak) / peak * 100.0
+                if dd < max_drawdown_pct:
+                    max_drawdown_pct = dd
+    return KPIResponse(
+        total_pnl=total_pnl,
+        realized_pnl=realized_pnl,
+        trade_count=trade_count,
+        win_rate=win_rate,
+        max_drawdown_pct=max_drawdown_pct,
+        avg_pnl_per_trade=avg_pnl_per_trade,
+        equity_curve=equity_curve,
+    )
+def kpis_to_feature_dict(kpis: KPIResponse) -> Dict[str, float]:
+    return {
+        "total_pnl": kpis.total_pnl,
+        "realized_pnl": kpis.realized_pnl,
+        "trade_count": float(kpis.trade_count),
+        "win_rate": kpis.win_rate,
+        "max_drawdown_pct": kpis.max_drawdown_pct,
+        "avg_pnl_per_trade": kpis.avg_pnl_per_trade,
+    }
+# -----------------------------------------------------------------------------
+# LLM integration
+# -----------------------------------------------------------------------------
+def _build_alpha_prompt(req: AlphaRequest, spread_bps: float, kpis: Dict[str, float]) -> str:
+    kpi_json = json.dumps(kpis, sort_keys=True)
+    ctx = req.context or ""
+    return (
+        "You are a deterministic trading policy engine.\n"
+        "Given KPIs and spread metrics, choose ONE action: long, short, or flat.\n"
+        "Respond ONLY with a compact JSON object:\n"
+        '{ "action": "...", "confidence": 0.0-1.0, "size_factor": 0.0-1.0, "comment": "..." }\n\n'
+        f"Contract: {req.contract}\n"
+        f"Spread_bps: {spread_bps:.4f}\n"
+        f"KPIs: {kpi_json}\n"
+        f"Context: {ctx}\n"
+        "Constraints:\n"
+        "- If max_drawdown_pct < -25 or win_rate < 0.4 ⇒ prefer flat.\n"
+        "- If trade_count < 10 ⇒ confidence <= 0.4.\n"
+        "- size_factor must be <= 0.3 if spread_bps > 10.\n"
+    )
+def call_llm_for_alpha(prompt: str) -> Dict[str, Any]:
+    if not LLM_ENDPOINT:
+        raise HTTPException(status_code=500, detail="LLM_ENDPOINT not configured")
+    payload = {
+        "inputs": prompt,
+        # HF / generic text generation params; adjust per endpoint
+        "parameters": {
+            "max_new_tokens": 256,
+            "temperature": 0.1,
+            "top_p": 0.9,
+            "return_full_text": False,
+        },
+    }
+    headers = {"Content-Type": "application/json"}
+    if LLM_API_KEY:
+        headers["Authorization"] = f"Bearer {LLM_API_KEY}"
+    try:
+        res = requests.post(LLM_ENDPOINT, headers=headers, json=payload, timeout=20)
+        res.raise_for_status()
+    except requests.RequestException as e:
+        raise HTTPException(status_code=502, detail=f"LLM request failed: {e}")
+    try:
+        data = res.json()
+    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:
+        raise HTTPException(status_code=502, detail="LLM output missing JSON object")
+    snippet = text[start : end + 1]
+    try:
+        parsed = json.loads(snippet)
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=502, detail=f"LLM JSON parse failed: {e}")
+    return parsed
+def build_alpha_decision(
+    req: AlphaRequest,
+    spread_bps: float,
+    kpi_features: Dict[str, float],
+    raw_model_out: Dict[str, Any],
+) -> AlphaDecision:
+    action = raw_model_out.get("action", "").lower().strip()
+    if action not in ("long", "short", "flat"):
+        action = "flat"
+    confidence = float(raw_model_out.get("confidence", 0.0))
+    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:
+        confidence = 1.0
+    if size_factor < 0.0:
+        size_factor = 0.0
+    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
+        comment = (comment + " [forced_flat_due_to_drawdown]").strip()
+    if kpi_features.get("trade_count", 0.0) < 10:
+        confidence = min(confidence, 0.4)
+    if spread_bps > 10.0 and size_factor > 0.3:
+        size_factor = 0.3
+    return AlphaDecision(
+        action=action,
+        confidence=confidence,
+        size_factor=size_factor,
+        spread_bps=spread_bps,
+        kpis=kpi_features,
+        comment=comment,
+        raw_model_output=raw_model_out,
+    )
+# -----------------------------------------------------------------------------
+# Routes
+# -----------------------------------------------------------------------------
+@app.get("/", response_class=HTMLResponse)
+def home() -> str:
+    return """
+    <html>
+      <body>
+        <h2>gate4-alpha-api</h2>
+        <p>Endpoints:</p>
+        <ul>
+          <li>GET /balance</li>
+          <li>GET /performance</li>
+          <li>GET /kpis</li>
+          <li>POST /log_trade</li>
+          <li>POST /alpha/entry</li>
+          <li>GET /openapi.yaml</li>
+        </ul>
+      </body>
+    </html>
+    """
+@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")
+@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),
+    }
 @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."}
+    kpis = compute_kpis(trades, balances)
+    summary = (
+        f"Total PnL: {kpis.total_pnl:.2f}, "
+        f"Realized: {kpis.realized_pnl:.2f}, "
+        f"Trades: {kpis.trade_count}, "
+        f"Win rate: {kpis.win_rate:.2%}, "
+        f"Max DD: {kpis.max_drawdown_pct:.2f}%"
+    )
+    tail = []
     for t in trades[-5:]:
+        tail.append(
+            {
+                "ts": t.timestamp,
+                "action": t.action,
+                "contract": t.contract,
+                "pnl_realized": t.pnl_realized,
+                "pnl_estimate": t.pnl_estimate,
+                "reason": t.reason,
+            }
+        )
+    return {
+        "summary": summary,
+        "last_trades": tail,
+        "kpis": kpis.model_dump(),
+    }
+@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)
+@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)
+    except ValidationError as e:
+        raise HTTPException(status_code=422, detail=e.errors())
+    append_trade(trade)
+    return trade
+@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)
+    base_features = kpis_to_feature_dict(base_kpis)
+    if req.kpis_override:
+        features = {**base_features, **req.kpis_override}
+    else:
+        features = base_features
+    spread_bps = get_contract_spread_bps(req.contract)
+    prompt = _build_alpha_prompt(req, spread_bps, features)
+    raw_model_out = call_llm_for_alpha(prompt)
+    decision = build_alpha_decision(req, spread_bps, features, raw_model_out)
+    return decision