500 lines
18 KiB
Python
500 lines
18 KiB
Python
"""
|
||
Beast Trader API — 市场结构、信号诊断、交易监测数据
|
||
"""
|
||
import os
|
||
import time
|
||
import hmac
|
||
import hashlib
|
||
import json
|
||
import sqlite3
|
||
import ccxt
|
||
import pandas as pd
|
||
import numpy as np
|
||
from datetime import datetime, timezone, timedelta
|
||
from typing import Optional
|
||
from fastapi import FastAPI, HTTPException, Request, Query
|
||
from fastapi.middleware.cors import CORSMiddleware
|
||
from fastapi.responses import FileResponse
|
||
from pydantic import BaseModel
|
||
import uvicorn
|
||
|
||
from indicators import compute_all_indicators
|
||
|
||
# =============================================
|
||
# 配置
|
||
# =============================================
|
||
API_KEY = os.environ.get("BEAST_API_KEY", "beast2025")
|
||
BINANCE_RATE_LIMIT_DELAY = 1.0 # 秒
|
||
DATA_CACHE_SECONDS = 30 # 缓存时间
|
||
|
||
# Freqtrade 数据库路径（只读）
|
||
FREQTRADE_DB = os.environ.get(
|
||
"FREQTRADE_DB",
|
||
os.path.expanduser("~/freqtrade/user_data/tradesv3.sqlite")
|
||
)
|
||
INITIAL_WALLET = float(os.environ.get("INITIAL_WALLET", 10000))
|
||
|
||
app = FastAPI(title="Beast Trader API", version="1.0")
|
||
|
||
app.add_middleware(
|
||
CORSMiddleware,
|
||
allow_origins=["*"],
|
||
allow_credentials=True,
|
||
allow_methods=["*"],
|
||
allow_headers=["*"],
|
||
)
|
||
|
||
# =============================================
|
||
# 缓存
|
||
# =============================================
|
||
_cache = {"data": None, "timestamp": 0}
|
||
|
||
# =============================================
|
||
# 认证中间件
|
||
# =============================================
|
||
@app.middleware("http")
|
||
async def auth_middleware(request: Request, call_next):
|
||
if request.method == "OPTIONS" or request.url.path in ["/api/health", "/", "/index.html"]:
|
||
return await call_next(request)
|
||
|
||
auth = request.headers.get("X-API-Key")
|
||
if not auth or auth != API_KEY:
|
||
raise HTTPException(status_code=401, detail="Invalid API Key")
|
||
return await call_next(request)
|
||
|
||
|
||
# =============================================
|
||
# 数据获取
|
||
# =============================================
|
||
def fetch_binance_data():
|
||
"""获取 BTC 和 ETH 的 D1/4H/1H K线数据 + 实时ticker"""
|
||
exchange = ccxt.binance({
|
||
"enableRateLimit": True,
|
||
})
|
||
|
||
now = exchange.milliseconds()
|
||
since_1d = now - 180 * 24 * 60 * 60 * 1000 # 180天 D1
|
||
since_4h = now - 60 * 24 * 60 * 60 * 1000 # 60天 4H
|
||
since_1h = now - 14 * 24 * 60 * 60 * 1000 # 14天 1H
|
||
|
||
result = {}
|
||
|
||
for symbol in ["ETH/USDT", "BTC/USDT"]:
|
||
try:
|
||
ohlcv_1d = exchange.fetch_ohlcv(symbol, "1d", since_1d, 200)
|
||
ohlcv_4h = exchange.fetch_ohlcv(symbol, "4h", since_4h, 400)
|
||
ohlcv_1h = exchange.fetch_ohlcv(symbol, "1h", since_1h, 400)
|
||
ticker = exchange.fetch_ticker(symbol)
|
||
|
||
df_1d = pd.DataFrame(ohlcv_1d, columns=["timestamp", "open", "high", "low", "close", "volume"])
|
||
df_1d["timestamp"] = pd.to_datetime(df_1d["timestamp"], unit="ms")
|
||
df_1d.set_index("timestamp", inplace=True)
|
||
|
||
df_4h = pd.DataFrame(ohlcv_4h, columns=["timestamp", "open", "high", "low", "close", "volume"])
|
||
df_4h["timestamp"] = pd.to_datetime(df_4h["timestamp"], unit="ms")
|
||
df_4h.set_index("timestamp", inplace=True)
|
||
|
||
df_1h = pd.DataFrame(ohlcv_1h, columns=["timestamp", "open", "high", "low", "close", "volume"])
|
||
df_1h["timestamp"] = pd.to_datetime(df_1h["timestamp"], unit="ms")
|
||
df_1h.set_index("timestamp", inplace=True)
|
||
|
||
result[symbol] = {"1d": df_1d, "4h": df_4h, "1h": df_1h, "ticker": ticker}
|
||
time.sleep(0.5) # rate limit
|
||
except Exception as e:
|
||
print(f"Error fetching {symbol}: {e}")
|
||
|
||
return result
|
||
|
||
|
||
def get_cached_data():
|
||
"""获取缓存数据或刷新"""
|
||
now = time.time()
|
||
if now - _cache["timestamp"] < DATA_CACHE_SECONDS and _cache["data"] is not None:
|
||
return _cache["data"]
|
||
|
||
raw = fetch_binance_data()
|
||
result = {}
|
||
for symbol, frames in raw.items():
|
||
try:
|
||
computed = compute_all_indicators(frames["1h"], frames["4h"], frames["1d"])
|
||
# 用实时ticker覆盖current_price（指标里用的是1H open，不实时）
|
||
price = frames.get("ticker", {}).get("last")
|
||
if price is not None:
|
||
computed["current_price"] = round(float(price), 2)
|
||
result[symbol] = computed
|
||
# 附加最近K线数据用于图表
|
||
result[symbol]["price_history"] = {
|
||
"1h": {
|
||
"timestamps": frames["1h"].index[-48:].strftime("%m-%d %H:%M").tolist(),
|
||
"close": [round(float(x), 2) for x in frames["1h"]["close"].iloc[-48:].tolist()],
|
||
}
|
||
}
|
||
except Exception as e:
|
||
print(f"Error computing {symbol}: {e}")
|
||
result[symbol] = {"error": str(e)}
|
||
|
||
_cache["data"] = result
|
||
_cache["timestamp"] = now
|
||
return result
|
||
|
||
|
||
# =============================================
|
||
# API 路由
|
||
# =============================================
|
||
|
||
@app.get("/api/health")
|
||
def health():
|
||
return {"status": "ok", "time": datetime.now(timezone.utc).isoformat()}
|
||
|
||
|
||
@app.get("/api/market-structure")
|
||
def market_structure():
|
||
"""
|
||
市场结构分析：S/R 位、Swing Point、趋势方向、供需区
|
||
"""
|
||
data = get_cached_data()
|
||
eth = data.get("ETH/USDT", {})
|
||
btc = data.get("BTC/USDT", {})
|
||
|
||
if "error" in eth:
|
||
raise HTTPException(status_code=500, detail=eth["error"])
|
||
|
||
return {
|
||
"eth": {
|
||
"current_price": eth.get("current_price"),
|
||
"support": eth.get("diagnosis", {}).get("support"),
|
||
"resistance": eth.get("diagnosis", {}).get("resistance"),
|
||
"zone_width_pct": eth.get("diagnosis", {}).get("zone_width_pct"),
|
||
"price_position_pct": eth.get("diagnosis", {}).get("price_position_in_zone"),
|
||
"trend_1d": eth.get("trend_1d"),
|
||
"trend_strength_4h": eth.get("trend_strength_4h"),
|
||
"swing_points": eth.get("swing_points"),
|
||
"price_history_1h": eth.get("price_history", {}).get("1h"),
|
||
},
|
||
"btc": {
|
||
"current_price": btc.get("current_price") if "error" not in btc else None,
|
||
"support_4h": btc.get("diagnosis", {}).get("support_4h"),
|
||
"resistance_4h": btc.get("diagnosis", {}).get("resistance_4h"),
|
||
"trend_1d": btc.get("trend_1d"),
|
||
},
|
||
"cached_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
|
||
|
||
@app.get("/api/signal-diagnosis")
|
||
def signal_diagnosis():
|
||
"""
|
||
信号诊断：8 层过滤条件逐一检查
|
||
"""
|
||
data = get_cached_data()
|
||
eth = data.get("ETH/USDT", {})
|
||
btc = data.get("BTC/USDT", {})
|
||
|
||
if "error" in eth:
|
||
raise HTTPException(status_code=500, detail=eth["error"])
|
||
|
||
return {
|
||
"eth": {
|
||
"can_enter_long": eth.get("can_enter_long"),
|
||
"can_enter_short": eth.get("can_enter_short"),
|
||
"diagnosis": eth.get("diagnosis"),
|
||
"filters": eth.get("filters"),
|
||
"candle_1h": eth.get("candle_1h"),
|
||
"trend_strength_4h": eth.get("trend_strength_4h"),
|
||
},
|
||
"btc": {
|
||
"can_enter_long": btc.get("can_enter_long"),
|
||
"can_enter_short": btc.get("can_enter_short"),
|
||
"diagnosis": btc.get("diagnosis"),
|
||
"filters": btc.get("filters"),
|
||
} if "error" not in btc else {"error": btc.get("error")},
|
||
"cached_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
|
||
|
||
# =============================================
|
||
# 静态文件服务（前端）
|
||
# =============================================
|
||
FRONTEND_DIR = os.path.join(os.path.dirname(__file__), "..", "frontend")
|
||
|
||
@app.get("/")
|
||
def serve_index():
|
||
return FileResponse(os.path.join(FRONTEND_DIR, "index.html"))
|
||
|
||
|
||
# =============================================
|
||
# 交易监测 API（读取 freqtrade SQLite 数据库）
|
||
# =============================================
|
||
|
||
def _get_db():
|
||
"""获取只读数据库连接"""
|
||
conn = sqlite3.connect(FREQTRADE_DB)
|
||
conn.row_factory = sqlite3.Row
|
||
return conn
|
||
|
||
|
||
def _row_to_dict(row):
|
||
"""将 sqlite3.Row 转为 dict，处理 datetime 和 boolean"""
|
||
if row is None:
|
||
return None
|
||
d = {}
|
||
for k in row.keys():
|
||
v = row[k]
|
||
if isinstance(v, bytes):
|
||
d[k] = v.decode("utf-8", errors="replace")
|
||
elif hasattr(v, "isoformat"):
|
||
d[k] = v.isoformat() if v else None
|
||
else:
|
||
d[k] = v
|
||
return d
|
||
|
||
|
||
@app.get("/api/account")
|
||
def account_overview():
|
||
"""
|
||
账户概览：当前余额、盈亏统计、策略信息
|
||
数据来源：freqtrade SQLite 数据库 (wallet_history + trades)
|
||
"""
|
||
try:
|
||
conn = _get_db()
|
||
|
||
# 最新钱包余额
|
||
wallet = conn.execute(
|
||
"SELECT * FROM wallet_history ORDER BY timestamp DESC LIMIT 1"
|
||
).fetchone()
|
||
|
||
# 交易统计
|
||
stats = conn.execute("""
|
||
SELECT
|
||
COUNT(*) as total_trades,
|
||
SUM(CASE WHEN is_open = 1 THEN 1 ELSE 0 END) as open_trades,
|
||
SUM(CASE WHEN is_open = 0 THEN 1 ELSE 0 END) as closed_trades,
|
||
SUM(CASE WHEN is_open = 0 AND close_profit > 0 THEN 1 ELSE 0 END) as winning_trades,
|
||
SUM(CASE WHEN is_open = 0 AND close_profit <= 0 THEN 1 ELSE 0 END) as losing_trades,
|
||
ROUND(SUM(close_profit_abs), 8) as total_profit_abs,
|
||
ROUND(AVG(CASE WHEN is_open = 0 THEN close_profit ELSE NULL END), 6) as avg_profit_pct,
|
||
ROUND(MAX(CASE WHEN is_open = 0 THEN close_profit ELSE NULL END), 6) as best_trade_pct,
|
||
ROUND(MIN(CASE WHEN is_open = 0 THEN close_profit ELSE NULL END), 6) as worst_trade_pct
|
||
FROM trades
|
||
""").fetchone()
|
||
|
||
# 当前持仓详情
|
||
open_positions = conn.execute("""
|
||
SELECT id, pair, is_short, open_rate, stake_amount, amount,
|
||
open_date, stop_loss, max_rate, min_rate,
|
||
ROUND((open_rate - ?) / open_rate * 100, 4) as unrealized_pnl_pct
|
||
FROM trades
|
||
WHERE is_open = 1
|
||
ORDER BY open_date DESC
|
||
""", [0]).fetchall() # placeholder, real current price handled in response
|
||
|
||
# 策略名称
|
||
strategy_row = conn.execute(
|
||
"SELECT DISTINCT strategy FROM trades WHERE strategy IS NOT NULL ORDER BY id DESC LIMIT 1"
|
||
).fetchone()
|
||
strategy_name = strategy_row["strategy"] if strategy_row else "v2.2c"
|
||
|
||
# 近期每日盈亏（近30天）
|
||
daily_pnl = conn.execute("""
|
||
SELECT DATE(close_date) as day,
|
||
ROUND(SUM(close_profit_abs), 8) as pnl_abs,
|
||
COUNT(*) as trade_count,
|
||
SUM(CASE WHEN close_profit > 0 THEN 1 ELSE 0 END) as wins
|
||
FROM trades
|
||
WHERE is_open = 0 AND close_date IS NOT NULL
|
||
GROUP BY DATE(close_date)
|
||
ORDER BY day DESC
|
||
LIMIT 30
|
||
""").fetchall()
|
||
|
||
conn.close()
|
||
|
||
# 计算当前余额
|
||
if wallet:
|
||
current_balance = wallet["total_quote"] or wallet["balance"]
|
||
last_update = _row_to_dict(wallet)["timestamp"]
|
||
else:
|
||
current_balance = INITIAL_WALLET
|
||
last_update = None
|
||
|
||
# 计算总收益
|
||
total_pnl_pct = round((current_balance - INITIAL_WALLET) / INITIAL_WALLET * 100, 2) if current_balance else 0
|
||
|
||
# 胜率
|
||
closed = stats["closed_trades"] or 0
|
||
wins = stats["winning_trades"] or 0
|
||
win_rate = round(wins / closed * 100, 1) if closed > 0 else 0
|
||
|
||
return {
|
||
"account": {
|
||
"initial_wallet": INITIAL_WALLET,
|
||
"current_balance": round(current_balance, 2),
|
||
"total_pnl_pct": total_pnl_pct,
|
||
"total_pnl_abs": round(current_balance - INITIAL_WALLET, 2),
|
||
"last_update": last_update,
|
||
"strategy": strategy_name,
|
||
},
|
||
"stats": {
|
||
"total_trades": stats["total_trades"] or 0,
|
||
"open_trades": stats["open_trades"] or 0,
|
||
"closed_trades": closed,
|
||
"win_rate": win_rate,
|
||
"wins": wins,
|
||
"losses": stats["losing_trades"] or 0,
|
||
"avg_profit_pct": stats["avg_profit_pct"],
|
||
"best_trade_pct": stats["best_trade_pct"],
|
||
"worst_trade_pct": stats["worst_trade_pct"],
|
||
"total_profit_abs": stats["total_profit_abs"] or 0,
|
||
},
|
||
"open_positions": [_row_to_dict(r) for r in open_positions],
|
||
"daily_pnl": [_row_to_dict(r) for r in daily_pnl],
|
||
"cached_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
|
||
|
||
|
||
@app.get("/api/trades")
|
||
def trade_list(
|
||
limit: int = Query(default=30, ge=1, le=200),
|
||
offset: int = Query(default=0, ge=0),
|
||
status: str = Query(default="all", pattern="^(all|open|closed)$"),
|
||
sort: str = Query(default="desc", pattern="^(asc|desc)$"),
|
||
):
|
||
"""
|
||
交易列表：支持分页和状态筛选
|
||
"""
|
||
try:
|
||
conn = _get_db()
|
||
|
||
where_clause = ""
|
||
if status == "open":
|
||
where_clause = "WHERE is_open = 1"
|
||
elif status == "closed":
|
||
where_clause = "WHERE is_open = 0"
|
||
|
||
order = "DESC" if sort == "desc" else "ASC"
|
||
|
||
rows = conn.execute(f"""
|
||
SELECT id, pair, is_open, is_short, open_rate, close_rate,
|
||
close_profit, close_profit_abs, stake_amount, amount,
|
||
open_date, close_date, exit_reason, strategy,
|
||
max_rate, min_rate, stop_loss, initial_stop_loss,
|
||
enter_tag, leverage
|
||
FROM trades
|
||
{where_clause}
|
||
ORDER BY open_date {order}
|
||
LIMIT ? OFFSET ?
|
||
""", [limit, offset]).fetchall()
|
||
|
||
total = conn.execute(f"SELECT COUNT(*) as cnt FROM trades {where_clause}").fetchone()
|
||
|
||
conn.close()
|
||
|
||
return {
|
||
"trades": [_row_to_dict(r) for r in rows],
|
||
"pagination": {
|
||
"total": total["cnt"],
|
||
"limit": limit,
|
||
"offset": offset,
|
||
"has_more": offset + limit < total["cnt"],
|
||
},
|
||
"cached_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
|
||
|
||
|
||
@app.get("/api/trades/stats")
|
||
def trade_stats():
|
||
"""
|
||
交易统计：按方向/时间/策略维度的聚合数据
|
||
"""
|
||
try:
|
||
conn = _get_db()
|
||
|
||
# 按方向
|
||
by_direction = conn.execute("""
|
||
SELECT
|
||
CASE WHEN is_short = 1 THEN 'SHORT' ELSE 'LONG' END as direction,
|
||
COUNT(*) as total,
|
||
SUM(CASE WHEN is_open = 0 AND close_profit > 0 THEN 1 ELSE 0 END) as wins,
|
||
SUM(CASE WHEN is_open = 0 AND close_profit <= 0 THEN 1 ELSE 0 END) as losses,
|
||
ROUND(AVG(CASE WHEN is_open = 0 THEN close_profit ELSE NULL END), 6) as avg_profit_pct,
|
||
ROUND(SUM(CASE WHEN is_open = 0 THEN close_profit_abs ELSE 0 END), 8) as total_pnl_abs
|
||
FROM trades
|
||
WHERE is_open = 0
|
||
GROUP BY is_short
|
||
""").fetchall()
|
||
|
||
# 按退出原因
|
||
by_exit = conn.execute("""
|
||
SELECT
|
||
exit_reason,
|
||
COUNT(*) as count,
|
||
ROUND(AVG(close_profit), 6) as avg_profit_pct,
|
||
ROUND(SUM(close_profit_abs), 8) as total_pnl_abs
|
||
FROM trades
|
||
WHERE is_open = 0 AND exit_reason IS NOT NULL
|
||
GROUP BY exit_reason
|
||
ORDER BY count DESC
|
||
LIMIT 10
|
||
""").fetchall()
|
||
|
||
# 月度表现
|
||
monthly = conn.execute("""
|
||
SELECT
|
||
strftime('%Y-%m', open_date) as month,
|
||
COUNT(*) as total,
|
||
SUM(CASE WHEN close_profit > 0 THEN 1 ELSE 0 END) as wins,
|
||
ROUND(AVG(close_profit), 6) as avg_profit_pct,
|
||
ROUND(SUM(close_profit_abs), 8) as total_pnl_abs
|
||
FROM trades
|
||
WHERE is_open = 0
|
||
GROUP BY strftime('%Y-%m', open_date)
|
||
ORDER BY month DESC
|
||
LIMIT 12
|
||
""").fetchall()
|
||
|
||
# 盈亏分布（区间统计）
|
||
distribution = conn.execute("""
|
||
SELECT
|
||
CASE
|
||
WHEN close_profit <= -0.10 THEN '≤ -10%'
|
||
WHEN close_profit <= -0.05 THEN '-10% ~ -5%'
|
||
WHEN close_profit <= -0.02 THEN '-5% ~ -2%'
|
||
WHEN close_profit < 0 THEN '-2% ~ 0%'
|
||
WHEN close_profit = 0 THEN '0%'
|
||
WHEN close_profit <= 0.02 THEN '0% ~ 2%'
|
||
WHEN close_profit <= 0.05 THEN '2% ~ 5%'
|
||
WHEN close_profit <= 0.10 THEN '5% ~ 10%'
|
||
WHEN close_profit <= 0.20 THEN '10% ~ 20%'
|
||
ELSE '> 20%'
|
||
END as profit_range,
|
||
COUNT(*) as count
|
||
FROM trades
|
||
WHERE is_open = 0
|
||
GROUP BY 1
|
||
ORDER BY MIN(close_profit)
|
||
""").fetchall()
|
||
|
||
conn.close()
|
||
|
||
return {
|
||
"by_direction": [_row_to_dict(r) for r in by_direction],
|
||
"by_exit_reason": [_row_to_dict(r) for r in by_exit],
|
||
"monthly": [_row_to_dict(r) for r in monthly],
|
||
"profit_distribution": [_row_to_dict(r) for r in distribution],
|
||
"cached_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
|
||
|
||
|
||
# =============================================
|
||
# 启动
|
||
# =============================================
|
||
if __name__ == "__main__":
|
||
port = int(os.environ.get("PORT", 8000))
|
||
uvicorn.run("main:app", host="0.0.0.0", port=port, reload=False)
|