845 lines
31 KiB
Python
845 lines
31 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
智能荐股系统 - Flask 主应用
|
|
页面：仪表盘 / 股票池 / 荐股中心 / 财经新闻 / 机构动向 / 数据管理 / 个股详情
|
|
"""
|
|
import json
|
|
import logging
|
|
import os
|
|
import time
|
|
|
|
from flask import Flask, jsonify, render_template, request
|
|
|
|
from config import (IS_MOCK, SERVICE_HOST, SERVICE_NAME, SERVICE_PORT,
|
|
CHROMA_NEWS_COLLECTION, CHROMA_PROFILE_COLLECTION)
|
|
from database import init_db, query, query_one, execute, table_count
|
|
from engine import scoring
|
|
from engine.indicators import compute_indicators
|
|
from rag import vector_store as vs
|
|
|
|
logging.basicConfig(level=logging.INFO,
|
|
format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
|
log = logging.getLogger("app")
|
|
|
|
app = Flask(__name__)
|
|
|
|
|
|
# ===================================================================== 页面
|
|
@app.route("/")
|
|
def page_index():
|
|
return render_template("index.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/stocks")
|
|
def page_stocks():
|
|
return render_template("stocks.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/recommend")
|
|
def page_recommend():
|
|
return render_template("recommend.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/news")
|
|
def page_news():
|
|
return render_template("news.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/institutions")
|
|
def page_institutions():
|
|
return render_template("institutions.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/strategies")
|
|
def page_strategies():
|
|
return render_template("strategies.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/tracking")
|
|
def page_tracking():
|
|
return render_template("tracking.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/automation")
|
|
def page_automation():
|
|
return render_template("automation.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/admin")
|
|
def page_admin():
|
|
return render_template("admin.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/settings")
|
|
def page_settings():
|
|
return render_template("settings.html", service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/stock/<code>")
|
|
def page_stock(code):
|
|
return render_template("stock_detail.html", code=code,
|
|
service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
@app.route("/analysis/<int:aid>")
|
|
def page_analysis(aid):
|
|
return render_template("analysis_detail.html", aid=aid,
|
|
service=SERVICE_NAME, is_mock=IS_MOCK)
|
|
|
|
|
|
# ===================================================================== 公共
|
|
def _indicators(code):
|
|
rows = query("SELECT date,open,high,low,close,volume FROM stock_daily "
|
|
"WHERE code=? ORDER BY date ASC", (code,))
|
|
return compute_indicators(rows)
|
|
|
|
|
|
def _news_score(code):
|
|
n = query_one(
|
|
"SELECT AVG(sentiment) AS s FROM news WHERE (related_stocks=? OR related_stocks LIKE ? OR related_stocks LIKE ?) "
|
|
"AND publish_date >= date('now','-7 day')",
|
|
(code, f"%,{code}", f"{code},%"))
|
|
return n["s"] if n and n["s"] is not None else 0.0
|
|
|
|
|
|
def _inst_score(code):
|
|
st = query_one(
|
|
"SELECT COUNT(*) AS c FROM inst_ratings WHERE stock_code=? AND rating IN ('买入','增持') "
|
|
"AND rating_date >= date('now','-30 day')", (code,))
|
|
cnt = st["c"] if st else 0
|
|
return min(1.0, cnt / 4.0)
|
|
|
|
|
|
def _scored_stock(code):
|
|
stock = query_one("SELECT * FROM stocks WHERE code=?", (code,))
|
|
if not stock:
|
|
return None
|
|
ind = _indicators(code)
|
|
news_s = _news_score(code)
|
|
inst_s = _inst_score(code)
|
|
sc = scoring.score_stock(ind, news_s, inst_s)
|
|
# 机构正面评级数 / 增持数
|
|
up = query_one("SELECT COUNT(*) c FROM inst_ratings WHERE stock_code=? AND rating IN ('买入','增持') "
|
|
"AND rating_date >= date('now','-30 day')", (code,))
|
|
hold_up = query_one("SELECT COUNT(*) c FROM fund_holdings WHERE stock_code=? AND change_pct>0 AND quarter="
|
|
"(SELECT MAX(quarter) FROM fund_holdings)", (code,))
|
|
reasons = scoring.build_reasons(ind, news_s, up["c"] if up else 0, hold_up["c"] if hold_up else 0)
|
|
return {
|
|
"stock": stock, "ind": ind, "score": sc,
|
|
"reasons": reasons,
|
|
"inst_up": up["c"] if up else 0,
|
|
"hold_up": hold_up["c"] if hold_up else 0,
|
|
"news_score": round(news_s, 2),
|
|
"inst_score": round(inst_s, 2),
|
|
}
|
|
|
|
|
|
def _fmt(row):
|
|
"""转 JSON 安全（bytes 等）"""
|
|
return row
|
|
|
|
|
|
# ===================================================================== API
|
|
@app.route("/api/health")
|
|
def api_health():
|
|
return jsonify({"status": "ok", "service": SERVICE_NAME,
|
|
"is_mock": IS_MOCK, "time": time.strftime("%Y-%m-%d %H:%M:%S")})
|
|
|
|
|
|
@app.route("/api/overview")
|
|
def api_overview():
|
|
"""仪表盘：指数 / 市场情绪 / 行业热度 / 今日荐股 / 自选 / 要闻"""
|
|
idx = query("SELECT * FROM market_index ORDER BY date DESC LIMIT 2")
|
|
latest = idx[0] if idx else {}
|
|
prev = idx[1] if len(idx) > 1 else latest
|
|
inds = []
|
|
for k, label in (("sh", "上证指数"), ("sz", "深证成指"), ("cy", "创业板指")):
|
|
cur, old = latest.get(k, 0), prev.get(k, 0) or 1
|
|
inds.append({"key": k, "label": label, "value": cur,
|
|
"chg": round((cur - old) / old * 100, 2)})
|
|
|
|
# 今日涨跌统计
|
|
stat = query_one(
|
|
"SELECT COUNT(*) total, SUM(CASE WHEN change_pct>0 THEN 1 ELSE 0 END) up,"
|
|
"SUM(CASE WHEN change_pct<0 THEN 1 ELSE 0 END) down,"
|
|
"SUM(CASE WHEN change_pct>=9.8 THEN 1 ELSE 0 END) limit_up,"
|
|
"SUM(CASE WHEN change_pct<=-9.8 THEN 1 ELSE 0 END) limit_down,"
|
|
"ROUND(SUM(amount)/10000,2) amount_yi "
|
|
"FROM stock_daily WHERE date=(SELECT MAX(date) FROM stock_daily)")
|
|
|
|
# 行业热度（今日平均涨跌幅）
|
|
heat = query(
|
|
"SELECT s.industry, ROUND(AVG(d.change_pct),2) chg, COUNT(*) cnt "
|
|
"FROM stock_daily d JOIN stocks s ON s.code=d.code "
|
|
"WHERE d.date=(SELECT MAX(date) FROM stock_daily) GROUP BY s.industry "
|
|
"ORDER BY chg DESC LIMIT 8")
|
|
|
|
# 今日荐股 Top5（重算）
|
|
rec = _top_recommend(5, "all")
|
|
|
|
# 自选
|
|
watch = []
|
|
for w in query("SELECT code FROM watchlist ORDER BY added_at DESC"):
|
|
d = _scored_stock(w["code"])
|
|
if d:
|
|
watch.append({"code": w["code"], "name": d["stock"]["name"],
|
|
"close": d["ind"].get("close"), "chg": d["ind"].get("change_pct"),
|
|
"rating": d["score"]["rating"], "score": d["score"]["total"]})
|
|
|
|
news = query("SELECT id,title,source,category,sentiment,publish_date,related_stocks "
|
|
"FROM news ORDER BY publish_date DESC, id DESC LIMIT 6")
|
|
|
|
return jsonify({
|
|
"indexes": inds, "stat": stat, "heat": heat,
|
|
"top": rec, "watchlist": watch, "news": news,
|
|
})
|
|
|
|
|
|
@app.route("/api/stocks")
|
|
def api_stocks():
|
|
keyword = request.args.get("keyword", "").strip()
|
|
industry = request.args.get("industry", "").strip()
|
|
board = request.args.get("board", "").strip()
|
|
sort = request.args.get("sort", "code")
|
|
order = request.args.get("order", "asc")
|
|
page = max(1, int(request.args.get("page", 1)))
|
|
per = min(100, int(request.args.get("per", 20)))
|
|
rated = request.args.get("rating", "").strip()
|
|
|
|
conds, args = [], []
|
|
if keyword:
|
|
conds.append("(s.name LIKE ? OR s.code LIKE ?)")
|
|
args += [f"%{keyword}%", f"%{keyword}%"]
|
|
if industry:
|
|
conds.append("s.industry=?")
|
|
args.append(industry)
|
|
if board:
|
|
conds.append("s.board=?")
|
|
args.append(board)
|
|
where = ("WHERE " + " AND ".join(conds)) if conds else ""
|
|
|
|
all_rows = query(
|
|
f"SELECT s.*, d.close, d.change_pct, d.volume, d.amount "
|
|
f"FROM stocks s LEFT JOIN stock_daily d ON d.code=s.code AND d.date=(SELECT MAX(date) FROM stock_daily) "
|
|
f"{where}", args)
|
|
out = []
|
|
for r in all_rows:
|
|
sc = _scored_stock(r["code"])
|
|
if not sc:
|
|
continue
|
|
if rated and sc["score"]["rating"] != rated:
|
|
continue
|
|
out.append({
|
|
"code": r["code"], "name": r["name"], "industry": r["industry"],
|
|
"board": r["board"], "close": r["close"], "change_pct": r["change_pct"],
|
|
"amount": r["amount"], "market_cap": r["market_cap"], "pe": r["pe"],
|
|
"score": sc["score"]["total"], "rating": sc["score"]["rating"],
|
|
"reasons": sc["reasons"], "vol_ratio": sc["ind"].get("vol_ratio"),
|
|
"chg_5d": sc["ind"].get("chg_5d"),
|
|
})
|
|
|
|
allowed = {"code", "name", "close", "change_pct", "score", "amount", "market_cap"}
|
|
if sort in allowed:
|
|
out.sort(key=lambda x: (x[sort] is None, x[sort]), reverse=(order == "desc"))
|
|
total = len(out)
|
|
start = (page - 1) * per
|
|
return jsonify({"total": total, "page": page, "per": per,
|
|
"items": out[start:start + per]})
|
|
|
|
|
|
@app.route("/api/stock/<code>")
|
|
def api_stock(code):
|
|
d = _scored_stock(code)
|
|
if not d:
|
|
return jsonify({"error": "not found"}), 404
|
|
stock = d["stock"]
|
|
stock["is_watch"] = bool(query_one("SELECT 1 FROM watchlist WHERE code=?", (code,)))
|
|
stock["week_change"] = d["ind"].get("chg_5d")
|
|
stock["month_change"] = d["ind"].get("chg_20d")
|
|
return jsonify({"stock": stock, "ind": {k: v for k, v in d["ind"].items() if k != "bars"},
|
|
"score": d["score"], "reasons": d["reasons"],
|
|
"news_score": d["news_score"], "inst_score": d["inst_score"],
|
|
"inst_up": d["inst_up"], "hold_up": d["hold_up"]})
|
|
|
|
|
|
@app.route("/api/stock/<code>/kline")
|
|
def api_kline(code):
|
|
days = min(250, int(request.args.get("days", 120)))
|
|
rows = query("SELECT date,open,high,low,close,volume FROM stock_daily "
|
|
"WHERE code=? ORDER BY date DESC LIMIT ?", (code, days))
|
|
rows.reverse()
|
|
ind = compute_indicators(rows)
|
|
bars = ind.get("bars", [])
|
|
# 附 MA 序列
|
|
def ma_series(n):
|
|
out = []
|
|
for i in range(len(bars)):
|
|
seg = bars[max(0, i + 1 - n):i + 1]
|
|
if len(seg) < n:
|
|
out.append(None)
|
|
else:
|
|
out.append(round(sum(b["close"] for b in seg) / n, 2))
|
|
return out
|
|
return jsonify({
|
|
"dates": [b["date"] for b in bars],
|
|
"kline": [[b["open"], b["close"], b["low"], b["high"]] for b in bars],
|
|
"volumes": [b["volume"] for b in bars],
|
|
"ma5": ma_series(5), "ma10": ma_series(10), "ma20": ma_series(20),
|
|
"ma60": ma_series(60),
|
|
})
|
|
|
|
|
|
@app.route("/api/stock/<code>/news")
|
|
def api_stock_news(code):
|
|
rows = query("SELECT id,title,source,category,sentiment,publish_date,related_stocks "
|
|
"FROM news WHERE (related_stocks=? OR related_stocks LIKE ? OR related_stocks LIKE ?) "
|
|
"ORDER BY publish_date DESC LIMIT 30",
|
|
(code, f"%,{code}", f"{code},%"))
|
|
return jsonify({"items": rows})
|
|
|
|
|
|
@app.route("/api/stock/<code>/institutions")
|
|
def api_stock_inst(code):
|
|
ratings = query(
|
|
"SELECT inst_name, rating, target_price, rating_date, prev_rating FROM inst_ratings "
|
|
"WHERE stock_code=? ORDER BY rating_date DESC", (code,))
|
|
holdings = query(
|
|
"SELECT inst_name, quarter, hold_shares, hold_value, change_pct FROM fund_holdings "
|
|
"WHERE stock_code=? ORDER BY quarter DESC, hold_value DESC", (code,))
|
|
return jsonify({"ratings": ratings, "holdings": holdings})
|
|
|
|
|
|
@app.route("/api/news")
|
|
def api_news():
|
|
keyword = request.args.get("keyword", "").strip()
|
|
category = request.args.get("category", "").strip()
|
|
code = request.args.get("code", "").strip()
|
|
page = max(1, int(request.args.get("page", 1)))
|
|
per = 15
|
|
conds, args = [], []
|
|
if keyword:
|
|
conds.append("(title LIKE ? OR content LIKE ?)")
|
|
args += [f"%{keyword}%", f"%{keyword}%"]
|
|
if category:
|
|
conds.append("category=?")
|
|
args.append(category)
|
|
if code:
|
|
conds.append("(related_stocks=? OR related_stocks LIKE ? OR related_stocks LIKE ?)")
|
|
args += [code, f"%,{code}", f"{code},%"]
|
|
where = ("WHERE " + " AND ".join(conds)) if conds else ""
|
|
total = query_one(f"SELECT COUNT(*) c FROM news {where}", args)["c"]
|
|
items = query(f"SELECT * FROM news {where} ORDER BY publish_date DESC, id DESC LIMIT ? OFFSET ?",
|
|
args + [per, (page - 1) * per])
|
|
cats = query("SELECT category, COUNT(*) c FROM news GROUP BY category ORDER BY c DESC")
|
|
return jsonify({"total": total, "page": page, "per": per, "items": items, "cats": cats})
|
|
|
|
|
|
@app.route("/api/news/<int:nid>")
|
|
def api_news_detail(nid):
|
|
n = query_one("SELECT * FROM news WHERE id=?", (nid,))
|
|
if not n:
|
|
return jsonify({"error": "not found"}), 404
|
|
# 关联股票信息
|
|
stocks = []
|
|
for code in (n["related_stocks"] or "").split(","):
|
|
if not code:
|
|
continue
|
|
s = query_one("SELECT code,name,industry FROM stocks WHERE code=?", (code,))
|
|
if s:
|
|
stocks.append(s)
|
|
return jsonify({"news": n, "stocks": stocks})
|
|
|
|
|
|
def _top_recommend(limit=10, rating_filter="all"):
|
|
"""全市场评分排序"""
|
|
rows = query("SELECT code FROM stocks")
|
|
items = []
|
|
for r in rows:
|
|
d = _scored_stock(r["code"])
|
|
if not d:
|
|
continue
|
|
if rating_filter != "all" and d["score"]["rating"] != rating_filter:
|
|
continue
|
|
items.append({
|
|
"code": r["code"], "name": d["stock"]["name"], "industry": d["stock"]["industry"],
|
|
"close": d["ind"].get("close"), "change_pct": d["ind"].get("change_pct"),
|
|
"score": d["score"], "reasons": d["reasons"], "chg_5d": d["ind"].get("chg_5d"),
|
|
"vol_ratio": d["ind"].get("vol_ratio"),
|
|
})
|
|
items.sort(key=lambda x: x["score"]["total"], reverse=True)
|
|
return items[:limit]
|
|
|
|
|
|
@app.route("/api/recommend")
|
|
def api_recommend():
|
|
rating = request.args.get("rating", "all")
|
|
limit = min(80, int(request.args.get("limit", 30)))
|
|
return jsonify({"items": _top_recommend(limit, rating)})
|
|
|
|
|
|
# ------------------------------------------------------------------ AI 分析
|
|
@app.route("/api/stock/<code>/analyze", methods=["POST"])
|
|
def api_analyze(code):
|
|
from engine import analyst
|
|
body = request.get_json(silent=True) or {}
|
|
focus = (body.get("focus") or "").strip()
|
|
res = analyst.submit_report(code, focus)
|
|
return jsonify(res)
|
|
|
|
|
|
@app.route("/api/stock/<code>/analyze/status")
|
|
def api_analyze_status(code):
|
|
from engine import analyst
|
|
st = analyst.report_status(code)
|
|
if st:
|
|
return jsonify(st)
|
|
# 无运行中任务：返回最近一次历史分析
|
|
hist = analyst.list_history(code, limit=1)
|
|
if hist:
|
|
detail = analyst.get_history(hist[0]["id"])
|
|
return jsonify({"status": "done", "report": detail["report"],
|
|
"history_id": detail["id"], "created_at": detail["created_at"],
|
|
"cached": True})
|
|
return jsonify({"status": "idle"})
|
|
|
|
|
|
@app.route("/api/stock/<code>/analyses")
|
|
def api_stock_analyses(code):
|
|
from engine import analyst
|
|
return jsonify({"items": analyst.list_history(code)})
|
|
|
|
|
|
@app.route("/api/analyses/<int:aid>")
|
|
def api_analysis_detail(aid):
|
|
from engine import analyst
|
|
d = analyst.get_history(aid)
|
|
if not d:
|
|
return jsonify({"error": "记录不存在"}), 404
|
|
stock = query_one("SELECT code, name, industry, board FROM stocks WHERE code=?", (d["code"],))
|
|
return jsonify({"analysis": d, "stock": stock})
|
|
|
|
|
|
# ------------------------------------------------------------------ 自选
|
|
@app.route("/api/watchlist", methods=["GET"])
|
|
def api_watchlist():
|
|
items = []
|
|
for w in query("SELECT code, added_at FROM watchlist ORDER BY added_at DESC"):
|
|
d = _scored_stock(w["code"])
|
|
if d:
|
|
items.append({"code": w["code"], "name": d["stock"]["name"],
|
|
"industry": d["stock"]["industry"],
|
|
"close": d["ind"].get("close"), "change_pct": d["ind"].get("change_pct"),
|
|
"rating": d["score"]["rating"], "score": d["score"]["total"],
|
|
"added_at": w["added_at"]})
|
|
return jsonify({"items": items})
|
|
|
|
|
|
@app.route("/api/watchlist/<code>", methods=["POST"])
|
|
def api_watch_add(code):
|
|
execute("INSERT OR IGNORE INTO watchlist(code) VALUES(?)", (code,))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
@app.route("/api/watchlist/<code>", methods=["DELETE"])
|
|
def api_watch_del(code):
|
|
execute("DELETE FROM watchlist WHERE code=?", (code,))
|
|
return jsonify({"ok": True})
|
|
|
|
|
|
# ------------------------------------------------------------------ 机构
|
|
@app.route("/api/institutions")
|
|
def api_institutions():
|
|
typ = request.args.get("type", "").strip()
|
|
cond, args = "", []
|
|
if typ:
|
|
cond, args = "WHERE type=?", [typ]
|
|
items = query(f"SELECT * FROM institutions {cond} ORDER BY type, id", args)
|
|
return jsonify({"items": items})
|
|
|
|
|
|
@app.route("/api/institutions/<int:iid>")
|
|
def api_institution_detail(iid):
|
|
inst = query_one("SELECT * FROM institutions WHERE id=?", (iid,))
|
|
if not inst:
|
|
return jsonify({"error": "not found"}), 404
|
|
ratings = query(
|
|
"SELECT r.stock_code, s.name, r.rating, r.target_price, r.rating_date, r.prev_rating "
|
|
"FROM inst_ratings r JOIN stocks s ON s.code=r.stock_code WHERE r.inst_id=? "
|
|
"ORDER BY r.rating_date DESC LIMIT 20", (iid,))
|
|
holdings = query(
|
|
"SELECT h.stock_code, s.name, h.quarter, h.hold_value, h.change_pct "
|
|
"FROM fund_holdings h JOIN stocks s ON s.code=h.stock_code WHERE h.inst_id=? "
|
|
"ORDER BY h.quarter DESC, h.hold_value DESC LIMIT 20", (iid,))
|
|
return jsonify({"institution": inst, "ratings": ratings, "holdings": holdings})
|
|
|
|
|
|
@app.route("/api/ratings/upgrades")
|
|
def api_ratings_upgrades():
|
|
"""评级上调/下调榜"""
|
|
rows = query(
|
|
"SELECT r.stock_code, s.name, r.inst_name, r.rating, r.prev_rating, r.rating_date, r.target_price "
|
|
"FROM inst_ratings r JOIN stocks s ON s.code=r.stock_code "
|
|
"WHERE r.rating_date >= date('now','-45 day') "
|
|
"ORDER BY r.rating_date DESC, r.id DESC LIMIT 30")
|
|
return jsonify({"items": rows})
|
|
|
|
|
|
@app.route("/api/holdings/moves")
|
|
def api_holdings_moves():
|
|
q = query_one("SELECT MAX(quarter) q FROM fund_holdings")
|
|
latest = q["q"] if q else "2026Q2"
|
|
inc = query(
|
|
"SELECT h.stock_code, s.name, h.inst_name, h.hold_value, h.change_pct, h.quarter "
|
|
"FROM fund_holdings h JOIN stocks s ON s.code=h.stock_code "
|
|
"WHERE h.quarter=? AND h.change_pct>0 ORDER BY h.change_pct DESC LIMIT 10", (latest,))
|
|
dec = query(
|
|
"SELECT h.stock_code, s.name, h.inst_name, h.hold_value, h.change_pct, h.quarter "
|
|
"FROM fund_holdings h JOIN stocks s ON s.code=h.stock_code "
|
|
"WHERE h.quarter=? AND h.change_pct<0 ORDER BY h.change_pct ASC LIMIT 10", (latest,))
|
|
return jsonify({"quarter": latest, "increase": inc, "decrease": dec})
|
|
|
|
|
|
# ------------------------------------------------------------------ 量化策略
|
|
@app.route("/api/strategies")
|
|
def api_strategies():
|
|
from engine.strategies import STRATEGIES, strategy_summary
|
|
items = []
|
|
for key, cfg in STRATEGIES.items():
|
|
items.append({"key": key, "name": cfg["name"], "icon": cfg["icon"],
|
|
"params": cfg["params"], "desc": cfg["desc"], "tags": cfg["tags"],
|
|
"summary": strategy_summary(key)})
|
|
return jsonify({"items": items})
|
|
|
|
|
|
@app.route("/api/backtest/market")
|
|
def api_backtest_market():
|
|
from engine.strategies import market_rank
|
|
key = request.args.get("strategy", "ma_cross")
|
|
return jsonify({"items": market_rank(key)})
|
|
|
|
|
|
@app.route("/api/backtest")
|
|
def api_backtest():
|
|
"""单股×单策略回测详情（从预计算表读取）"""
|
|
from engine.strategies import STRATEGIES
|
|
import json as _json
|
|
key = request.args.get("strategy", "ma_cross")
|
|
code = request.args.get("code", "")
|
|
if key not in STRATEGIES or not code:
|
|
return jsonify({"error": "参数错误"}), 400
|
|
row = query_one("SELECT * FROM strategy_backtests WHERE strategy=? AND code=?", (key, code))
|
|
if not row:
|
|
return jsonify({"error": "回测数据不存在，请先在数据管理页重建"}), 404
|
|
stock = query_one("SELECT name, industry, board FROM stocks WHERE code=?", (code,))
|
|
return jsonify({
|
|
"strategy": key,
|
|
"config": STRATEGIES[key],
|
|
"code": code, "stock_name": row["stock_name"], "stock": stock,
|
|
"metrics": _json.loads(row["metrics"]),
|
|
"equity": _json.loads(row["equity"]),
|
|
"trades": _json.loads(row["trades"]),
|
|
"run_at": row["run_at"],
|
|
})
|
|
|
|
|
|
@app.route("/api/backtest/rebuild", methods=["POST"])
|
|
def api_backtest_rebuild():
|
|
import threading
|
|
|
|
def run():
|
|
from engine.strategies import build_all
|
|
try:
|
|
build_all()
|
|
except Exception as e:
|
|
log.error("backtest rebuild fail: %s", e)
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return jsonify({"ok": True, "msg": "全市场回测重建已启动"})
|
|
|
|
|
|
# ------------------------------------------------------------------ 设置与舆情监控
|
|
@app.route("/api/settings")
|
|
def api_settings():
|
|
from settings import all_settings, mail_config, monitor_config, monitor_state, \
|
|
tracking_config, tracking_state, quiet_config
|
|
from config import LLM_BASE_URL, LLM_API_KEY, LLM_MODEL
|
|
s = all_settings()
|
|
mail = mail_config()
|
|
mono = monitor_config()
|
|
track = tracking_config()
|
|
return jsonify({
|
|
"mail": mail,
|
|
"monitor": mono,
|
|
"tracking": {**track, **tracking_state()},
|
|
"quiet": { # 各自动化任务的静默期配置
|
|
"monitor": quiet_config("monitor"),
|
|
"tracking": quiet_config("tracking"),
|
|
"report": quiet_config("report"),
|
|
},
|
|
"llm": {
|
|
"base_url": s.get("llm_base_url", LLM_BASE_URL),
|
|
"api_key": s.get("llm_api_key", LLM_API_KEY),
|
|
"model": s.get("llm_model", LLM_MODEL),
|
|
},
|
|
"state": monitor_state(),
|
|
})
|
|
|
|
|
|
@app.route("/api/settings", methods=["POST"])
|
|
def api_settings_save():
|
|
from settings import save_all, set_setting, _bool_str
|
|
body = request.get_json(silent=True) or {}
|
|
mail = body.get("mail") or {}
|
|
llm = body.get("llm") or {}
|
|
mono = body.get("monitor") or {}
|
|
# 邮件（布尔规范化）
|
|
for k in ("smtp_host", "smtp_port", "smtp_user", "smtp_pass", "smtp_mode",
|
|
"email_to", "sender_name"):
|
|
if k in mail:
|
|
set_setting(k, mail[k])
|
|
if "email_enabled" in mail:
|
|
set_setting("email_enabled", _bool_str(mail["email_enabled"]))
|
|
# LLM
|
|
for k in ("llm_base_url", "llm_api_key", "llm_model"):
|
|
if k in llm:
|
|
set_setting(k, str(llm[k]).strip())
|
|
# 监控
|
|
for k in ("monitor_interval", "monitor_categories",
|
|
"monitor_sentiment", "monitor_importance", "monitor_keywords"):
|
|
if k in mono:
|
|
set_setting(k, mono[k])
|
|
if "monitor_enabled" in mono:
|
|
set_setting("monitor_enabled", _bool_str(mono["monitor_enabled"]))
|
|
# 持仓跟踪
|
|
track = body.get("tracking") or {}
|
|
for k in ("tracking_interval", "tracking_impact_threshold"):
|
|
if k in track:
|
|
set_setting(k, track[k])
|
|
if "tracking_enabled" in track:
|
|
set_setting("tracking_enabled", _bool_str(track["tracking_enabled"]))
|
|
if "tracking_notify" in track:
|
|
set_setting("tracking_notify", _bool_str(track["tracking_notify"]))
|
|
# 静默期（各自动化任务独立配置）
|
|
quiet = body.get("quiet") or {}
|
|
for prefix in ("monitor", "tracking", "report"):
|
|
q = quiet.get(prefix) or {}
|
|
if "enabled" in q:
|
|
set_setting(f"{prefix}_quiet_enabled", _bool_str(q["enabled"]))
|
|
if "ranges" in q:
|
|
set_setting(f"{prefix}_quiet_ranges", str(q["ranges"] or "").strip())
|
|
return jsonify({"ok": True, "msg": "设置已保存"})
|
|
|
|
|
|
@app.route("/api/settings/test-email", methods=["POST"])
|
|
def api_settings_test_email():
|
|
from settings import mail_config
|
|
from engine.notifier import send_email
|
|
body = request.get_json(silent=True) or {}
|
|
try:
|
|
cfg = mail_config()
|
|
send_email(
|
|
"[智能荐股] 邮件配置测试",
|
|
"<h3>✅ 邮件配置生效</h3><p>如果你收到这封邮件，说明 SMTP 设置正确，舆情通知将正常送达。</p>"
|
|
"<p style='color:#888'>发送时间：" + time.strftime("%Y-%m-%d %H:%M:%S") + "</p>",
|
|
cfg=cfg)
|
|
return jsonify({"ok": True, "msg": f"测试邮件已发送到 {cfg['email_to']}"})
|
|
except Exception as e:
|
|
return jsonify({"ok": False, "error": str(e)}), 500
|
|
|
|
|
|
@app.route("/api/settings/test-llm", methods=["POST"])
|
|
def api_settings_test_llm():
|
|
from settings import llm_config
|
|
from engine.analyst import llm_chat
|
|
try:
|
|
cfg = llm_config()
|
|
rep = llm_chat([{"role": "user", "content": "回复'连接正常'四个字"}], max_tokens=20)
|
|
return jsonify({"ok": True, "msg": f"连接成功（{cfg['model']}）：{rep[:60]}"})
|
|
except Exception as e:
|
|
return jsonify({"ok": False, "error": str(e)}), 500
|
|
|
|
|
|
@app.route("/api/monitor/scan", methods=["POST"])
|
|
def api_monitor_scan():
|
|
from engine.notifier import scan_news
|
|
try:
|
|
r = scan_news(force=True)
|
|
return jsonify({"ok": True, **r})
|
|
except Exception as e:
|
|
return jsonify({"ok": False, "error": str(e)}), 500
|
|
|
|
|
|
@app.route("/api/monitor/log")
|
|
def api_monitor_log():
|
|
from engine.notifier import notification_log
|
|
return jsonify({"items": notification_log()})
|
|
|
|
|
|
# ------------------------------------------------------------------ 持仓跟踪
|
|
@app.route("/api/tracking")
|
|
def api_tracking_list():
|
|
from engine.agent import list_reports
|
|
return jsonify({"items": list_reports()})
|
|
|
|
|
|
@app.route("/api/tracking/stock/<code>")
|
|
def api_tracking_stock(code):
|
|
from engine.agent import latest_reports
|
|
return jsonify({"items": latest_reports(code)})
|
|
|
|
|
|
@app.route("/api/tracking/<int:rid>")
|
|
def api_tracking_detail(rid):
|
|
from engine.agent import get_report
|
|
import json as _json
|
|
r = get_report(rid)
|
|
if not r:
|
|
return jsonify({"error": "记录不存在"}), 404
|
|
r["meta"] = _json.loads(r["meta"] or "{}")
|
|
r["sources"] = _json.loads(r["sources"] or "{}")
|
|
return jsonify(r)
|
|
|
|
|
|
@app.route("/api/tracking/run", methods=["POST"])
|
|
def api_tracking_run():
|
|
"""立即跟踪全部目标（持仓+概念/主题/股票，后台）"""
|
|
import threading
|
|
|
|
def run():
|
|
from engine.agent import track_all
|
|
try:
|
|
track_all()
|
|
except Exception as e:
|
|
log.error("track run fail: %s", e)
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return jsonify({"ok": True, "msg": "跟踪任务已启动（逐目标分析，约每只30-60秒）"})
|
|
|
|
|
|
@app.route("/api/tracking/run/<code>", methods=["POST"])
|
|
def api_tracking_run_one(code):
|
|
from engine.agent import track_stock
|
|
import threading
|
|
|
|
def run():
|
|
try:
|
|
track_stock(code)
|
|
except Exception as e:
|
|
log.error("track %s fail: %s", code, e)
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return jsonify({"ok": True, "msg": "跟踪已启动"})
|
|
|
|
|
|
@app.route("/api/targets")
|
|
def api_targets_list():
|
|
from engine.agent import list_targets
|
|
return jsonify({"items": list_targets()})
|
|
|
|
|
|
@app.route("/api/targets", methods=["POST"])
|
|
def api_targets_add():
|
|
from engine.agent import add_target
|
|
body = request.get_json(silent=True) or {}
|
|
r = add_target(body.get("type", "concept"), body.get("name", ""),
|
|
body.get("code", ""), body.get("keywords", ""))
|
|
if r.get("error"):
|
|
return jsonify(r), 400
|
|
return jsonify(r)
|
|
|
|
|
|
@app.route("/api/targets/<int:tid>", methods=["DELETE"])
|
|
def api_targets_delete(tid):
|
|
from engine.agent import delete_target
|
|
return jsonify(delete_target(tid))
|
|
|
|
|
|
# ------------------------------------------------------------------ 定时报告
|
|
@app.route("/api/report/send", methods=["POST"])
|
|
def api_report_send():
|
|
"""手动触发定时报告（后台生成 + 邮件）"""
|
|
from engine.report import send_daily_report
|
|
import threading
|
|
body = request.get_json(silent=True) or {}
|
|
kind = body.get("kind", "premarket")
|
|
|
|
def run():
|
|
try:
|
|
r = send_daily_report(kind)
|
|
log.info("report send: %s", r)
|
|
except Exception as e:
|
|
log.error("report send fail: %s", e)
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return jsonify({"ok": True, "msg": f"{'盘前分析' if kind == 'premarket' else '盘后总结'}生成已启动，约需 1-2 分钟"})
|
|
|
|
|
|
@app.route("/api/report/log")
|
|
def api_report_log():
|
|
from engine.report import report_log
|
|
return jsonify({"items": report_log()})
|
|
|
|
|
|
# ------------------------------------------------------------------ 数据管理
|
|
@app.route("/api/admin/stats")
|
|
def api_admin_stats():
|
|
tables = ("stocks", "stock_daily", "news", "institutions", "inst_ratings",
|
|
"fund_holdings", "watchlist", "analysis_cache", "analysis_history",
|
|
"strategy_backtests", "market_index")
|
|
return jsonify({
|
|
"tables": {t: table_count(t) for t in tables},
|
|
"vector": {
|
|
"news": vs.collection_count(CHROMA_NEWS_COLLECTION),
|
|
"profiles": vs.collection_count(CHROMA_PROFILE_COLLECTION),
|
|
},
|
|
"is_mock": IS_MOCK,
|
|
"db": "stock_advisor.db",
|
|
})
|
|
|
|
|
|
@app.route("/api/admin/reseed", methods=["POST"])
|
|
def api_admin_reseed():
|
|
"""一键重灌数据（含向量重建），后台执行"""
|
|
import subprocess
|
|
import threading
|
|
|
|
def run():
|
|
py = "/home/hz1/miniconda3/envs/openclaw/bin/python3"
|
|
subprocess.run([py, os.path.join(os.path.dirname(os.path.abspath(__file__)), "seed_data.py")],
|
|
cwd=os.path.dirname(os.path.abspath(__file__)),
|
|
stdout=open(os.path.join(LOG_DIR, "reseed.log"), "w"),
|
|
stderr=subprocess.STDOUT)
|
|
|
|
threading.Thread(target=run, daemon=True).start()
|
|
return jsonify({"ok": True, "msg": "重灌任务已启动，可在数据管理页刷新查看进度"})
|
|
|
|
|
|
@app.route("/api/admin/healthcheck")
|
|
def api_admin_healthcheck():
|
|
"""外部依赖连通性检查"""
|
|
import requests
|
|
from config import EMBEDDING_API_URL, CHROMA_HOST, CHROMA_PORT, LLM_BASE_URL
|
|
out = {}
|
|
try:
|
|
r = requests.get(f"http://{CHROMA_HOST}:{CHROMA_PORT}/api/v2/tenants/default_tenant/databases/default_database/collections", timeout=5)
|
|
out["chroma"] = "ok" if r.status_code == 200 else f"http {r.status_code}"
|
|
except Exception as e:
|
|
out["chroma"] = f"fail {e}"
|
|
try:
|
|
r = requests.post(EMBEDDING_API_URL, json={"model": "bge-large-zh-v1.5", "input": ["测试"]}, timeout=10)
|
|
out["embedding"] = "ok" if r.status_code == 200 else f"http {r.status_code}"
|
|
except Exception as e:
|
|
out["embedding"] = f"fail {e}"
|
|
out["llm"] = "配置已就绪（调用时校验）"
|
|
return jsonify(out)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
init_db()
|
|
from engine.notifier import start_monitor
|
|
from engine.agent import start_tracking
|
|
start_monitor()
|
|
start_tracking()
|
|
print(f"✅ {SERVICE_NAME} 启动: http://0.0.0.0:{SERVICE_PORT}")
|
|
app.run(host=SERVICE_HOST, port=SERVICE_PORT, threaded=True)
|