#!/usr/bin/env python # -*- coding: utf-8 -*- """ qmt.py - QMT 交易/行情统一 CLI 入口 设计目标：让大模型通过确定性命令调用 QMT 全部能力（行情、持仓、委托、下单、撤单）， 避免每次现场写 Python。所有子命令默认输出 JSON，加 --table 可切换人类可读表格。 配置来源（按优先级）： 1. 环境变量 BIGQMT_ACCOUNT_ID / BIGQMT_REDIS_HOST / ... 2. bigqmt_signal_trader_client_config 模块（在 PYTHONPATH 中） 3. bigqmt_signal_trader_local_config 模块 4. 本脚本所在仓库的 src/ 自动加入 sys.path（开发模式） 用法示例： python qmt.py ping python qmt.py account python qmt.py positions python qmt.py orders --cancelable python qmt.py trades python qmt.py tick 600000.SH 000001.SZ python qmt.py kline 600000.SH --period 1d --count 60 python qmt.py instrument 600000.SH python qmt.py sector "沪深A股" python qmt.py trading-dates --count 10 python qmt.py north python qmt.py longhubang 600000.SH --count 5 python qmt.py buy 600000.SH 100 --price 7.50 --strategy my_strat python qmt.py sell 600000.SH 100 --price 7.50 python qmt.py cancel 12345 --market SH """ from __future__ import annotations import argparse import json import os import sys import time import traceback from datetime import datetime from pathlib import Path # --------------------------------------------------------------------------- # 路径自动发现：把仓库 src/ 加到 sys.path，确保开发模式也能 import # --------------------------------------------------------------------------- def _ensure_src_on_path() -> None: here = Path(__file__).resolve().parent # skill/scripts/qmt.py -> 上溯到仓库根 for ancestor in [here, *here.parents]: candidate = ancestor / "src" if (candidate / "bigqmt_signal_trader" / "__init__.py").exists(): src_str = str(candidate) if src_str not in sys.path: sys.path.insert(0, src_str) return # 没找到仓库 src，假设用户已 pip install return def _ensure_qmt_python_on_path() -> None: """把 QMT 的 python 目录加到 sys.path，让 local_config.py 能被发现。 这样客户端能读到 QMT 端的 transport=zmq 配置（服务端用 zmq 时客户端也得用）。 通过环境变量 BIGQMT_QMT_PYTHON_DIR 指定，或自动从常见路径/当前目录探测。 """ candidates = [] env_dir = os.environ.get("BIGQMT_QMT_PYTHON_DIR") if env_dir: candidates.append(env_dir) # 常见 QMT 安装路径（国金证券、华泰等） for root in ("D:\\", "C:\\", "E:\\"): if not os.path.isdir(root): continue try: for entry in os.listdir(root): if "QMT" in entry.upper(): p = os.path.join(root, entry, "python") if os.path.isdir(p): candidates.append(p) except Exception: continue # 当前工作目录（如果就在 QMT python 目录里） cwd = os.getcwd() if cwd.endswith(r"\python") or cwd.endswith("/python"): candidates.append(cwd) for c in candidates: local_cfg = os.path.join(c, "bigqmt_signal_trader_local_config.py") if os.path.isfile(local_cfg): if c not in sys.path: sys.path.insert(0, c) return _ensure_src_on_path() _ensure_qmt_python_on_path() # --------------------------------------------------------------------------- # 工具函数 # --------------------------------------------------------------------------- def _json_default(o): """JSON 序列化兜底：处理 pandas / numpy / CompatObject / Decimal 等。""" # pandas DataFrame / Series if hasattr(o, "to_dict"): try: if hasattr(o, "index") and hasattr(o, "columns"): # DataFrame -> list of dict records return o.reset_index().to_dict(orient="records") return o.to_dict() except Exception: pass # numpy if hasattr(o, "tolist"): return o.tolist() if hasattr(o, "isoformat"): return o.isoformat() # CompatObject（xtquant_compat 的属性包对象） if hasattr(o, "__dict__") and not isinstance(o, type): return {k: v for k, v in o.__dict__.items() if not k.startswith("_")} if isinstance(o, (set, tuple)): return list(o) if isinstance(o, bytes): return o.decode("utf-8", errors="replace") return str(o) def _print_json(data, indent=2): print(json.dumps(data, ensure_ascii=False, indent=indent, default=_json_default)) def _print_table(rows, headers=None): """简易表格输出。""" if not rows: print("(empty)") return if isinstance(rows, list) and rows and isinstance(rows[0], dict): headers = headers or list(rows[0].keys()) lines = [] widths = [max(len(str(h)), *(len(str(r.get(h, ""))) for r in rows)) for h in headers] lines.append(" ".join(str(h).ljust(w) for h, w in zip(headers, widths))) lines.append(" ".join("-" * w for w in widths)) for r in rows: lines.append(" ".join(str(r.get(h, "")).ljust(w) for h, w in zip(headers, widths))) print("\n".join(lines)) else: for r in rows: print(r) def _ok(data, table=False, headers=None): out = {"ok": True, "data": data, "ts": datetime.now().isoformat(timespec="seconds")} if table: _print_table(data if isinstance(data, list) else [data], headers) else: _print_json(out) def _err(msg, detail=None, code=None): out = {"ok": False, "error": msg, "ts": datetime.now().isoformat(timespec="seconds")} if detail: out["detail"] = detail if code: out["code"] = code _print_json(out) sys.exit(1) def _position_to_dict(p): """持仓对象转 dict，补充计算字段。""" d = {} for attr in [ "account_id", "stock_code", "stock_name", "volume", "can_use_volume", "available_amount", "enable_amount", "avg_price", "price", "open_price", "cost_price", "market_value", "frozen_volume", "yesterday_volume", "direction", ]: d[attr] = getattr(p, attr, None) vol = d.get("volume") or 0 price = d.get("price") or 0 d["market_value"] = d.get("market_value") or round(vol * price, 2) d["profit"] = None if d.get("avg_price") and vol: d["profit"] = round((price - d["avg_price"]) * vol, 2) d["profit_pct"] = round((price - d["avg_price"]) / d["avg_price"] * 100, 2) if d["avg_price"] else 0 return d def _order_to_dict(o): d = {} for attr in [ "account_id", "stock_code", "order_type", "order_status", "order_volume", "traded_volume", "price", "order_sysid", "order_id", "strategy_name", "order_remark", "order_time", ]: d[attr] = getattr(o, attr, None) # 语义化 d["order_type_name"] = {23: "BUY", 24: "SELL"}.get(d.get("order_type"), str(d.get("order_type", ""))) status_map = { 48: "UNREPORTED", 49: "WAIT_REPORTING", 50: "REPORTED", 51: "REPORTED_CANCEL", 52: "PARTSUCC_CANCEL", 53: "PART_CANCEL", 54: "CANCELED", 55: "PART_SUCC", 56: "SUCCEEDED", 57: "JUNK", 255: "UNKNOWN", } d["order_status_name"] = status_map.get(d.get("order_status"), str(d.get("order_status", ""))) d["cancelable"] = d.get("order_status") in (49, 50, 55) return d def _trade_to_dict(t): d = {} for attr in [ "account_id", "stock_code", "order_type", "order_sysid", "order_id", "trade_id", "traded_volume", "traded_price", "traded_at", "order_remark", ]: d[attr] = getattr(t, attr, None) d["order_type_name"] = {23: "BUY", 24: "SELL"}.get(d.get("order_type"), str(d.get("order_type", ""))) return d # --------------------------------------------------------------------------- # 延迟初始化的兼容层对象 # --------------------------------------------------------------------------- _xt_trader = None _xtdata = None _acc = None def _init(): """延迟初始化 xt_trader / xtdata / acc，避免 import 失败时整个 CLI 崩溃。""" global _xt_trader, _xtdata, _acc if _xt_trader is not None: return _xt_trader, _xtdata, _acc try: from bigqmt_signal_trader.xtquant_compat import ( StockAccount, configure, xt_trader, xtdata, ) except ImportError as e: _err( "无法导入 bigqmt_signal_trader。请确保：\n" " 1) 已 pip install xtquant-big-convert，或\n" " 2) 仓库 src/ 在 PYTHONPATH 中，或\n" " 3) 在仓库目录下运行", detail=str(e), code="IMPORT_FAIL", ) try: configure() except Exception as e: _err( "configure() 失败。请检查配置：\n" " - 环境变量 BIGQMT_ACCOUNT_ID / BIGQMT_REDIS_HOST 等\n" " - 或 bigqmt_signal_trader_client_config.py 配置文件", detail=str(e), code="CONFIG_FAIL", ) _xt_trader = xt_trader _xtdata = xtdata try: _acc = StockAccount(xt_trader.client.account_id, "STOCK") except Exception: _acc = None return _xt_trader, _xtdata, _acc def _acc_or(acc_arg): """用传入的 account_id 或全局 _acc。""" from bigqmt_signal_trader.xtquant_compat import StockAccount if acc_arg: return StockAccount(acc_arg, "STOCK") _, _, acc = _init() if acc is None: _err("无法确定 account_id，请用 --account 显式指定") return acc # =========================================================================== # 子命令实现 # =========================================================================== def cmd_ping(args): tr, _, _ = _init() t0 = time.time() try: result = tr.client.call("ping", {}) except Exception as e: _err("ping 失败", detail=str(e), code="PING_FAIL") elapsed = round((time.time() - t0) * 1000, 1) _ok({"result": result, "latency_ms": elapsed}) def cmd_account(args): tr, _, _ = _init() acc = _acc_or(args.account) try: asset = tr.query_stock_asset(acc) except Exception as e: _err("查询资产失败", detail=str(e), code="QUERY_FAIL") if asset is None: _err("查询资产返回空") d = { "account_id": getattr(asset, "account_id", None), "cash": getattr(asset, "cash", None), "available_cash": getattr(asset, "available_cash", None), "frozen_cash": getattr(asset, "frozen_cash", 0), "total_asset": getattr(asset, "total_asset", None), "market_value": getattr(asset, "market_value", None), } _ok(d, table=args.table, headers=["account_id", "cash", "frozen_cash", "market_value", "total_asset"]) def cmd_positions(args): tr, _, _ = _init() acc = _acc_or(args.account) try: positions = tr.query_stock_positions(acc) except Exception as e: _err("查询持仓失败", detail=str(e), code="QUERY_FAIL") if args.code: positions = [p for p in (positions or []) if getattr(p, "stock_code", "") == args.code] rows = [_position_to_dict(p) for p in (positions or [])] # 汇总 summary = { "count": len(rows), "total_market_value": round(sum(r.get("market_value") or 0 for r in rows), 2), "total_profit": round(sum(r.get("profit") or 0 for r in rows), 2), } _ok({"positions": rows, "summary": summary}, table=args.table, headers=["stock_code", "stock_name", "volume", "can_use_volume", "avg_price", "price", "market_value", "profit", "profit_pct"]) def cmd_orders(args): tr, _, _ = _init() acc = _acc_or(args.account) try: orders = tr.query_stock_orders( acc, cancelable_only=args.cancelable, strategy_name=args.strategy or "", ) except Exception as e: _err("查询委托失败", detail=str(e), code="QUERY_FAIL") rows = [_order_to_dict(o) for o in (orders or [])] _ok({"orders": rows, "count": len(rows)}, table=args.table, headers=["stock_code", "order_type_name", "order_status_name", "order_volume", "traded_volume", "price", "order_sysid", "cancelable"]) def cmd_trades(args): tr, _, _ = _init() acc = _acc_or(args.account) try: trades = tr.query_stock_trades(acc, strategy_name=args.strategy or "") except Exception as e: _err("查询成交失败", detail=str(e), code="QUERY_FAIL") rows = [_trade_to_dict(t) for t in (trades or [])] _ok({"trades": rows, "count": len(rows)}, table=args.table, headers=["stock_code", "order_type_name", "traded_volume", "traded_price", "traded_at", "order_sysid"]) def cmd_tick(args): _, xtdata, _ = _init() codes = args.codes if not codes: _err("请指定股票代码，如: tick 600000.SH 000001.SZ") try: ticks = xtdata.get_full_tick(codes) except Exception as e: _err("查询行情失败", detail=str(e), code="QUERY_FAIL") # 精简输出 result = {} for code, tick in (ticks or {}).items(): t = dict(tick) if hasattr(tick, "items") else {} # 只保留关键字段 compact = { "code": code, "lastPrice": t.get("lastPrice"), "open": t.get("open"), "high": t.get("high"), "low": t.get("low"), "lastClose": t.get("lastClose"), "volume": t.get("volume"), "amount": t.get("amount"), "bidPrice": (t.get("bidPrice") or [])[:5], "bidVol": (t.get("bidVol") or [])[:5], "askPrice": (t.get("askPrice") or [])[:5], "askVol": (t.get("askVol") or [])[:5], "time": t.get("time"), "stime": t.get("stime"), } # 涨跌幅 if t.get("lastClose") and t.get("lastPrice"): compact["change_pct"] = round( (t["lastPrice"] - t["lastClose"]) / t["lastClose"] * 100, 2 ) result[code] = compact _ok(result, table=args.table, headers=["code", "lastPrice", "change_pct", "bidPrice", "askPrice", "volume"]) def cmd_kline(args): _, xtdata, _ = _init() fields = args.fields.split(",") if args.fields else None try: result = xtdata.get_market_data_ex( field_list=fields, stock_list=[args.code], period=args.period, start_time=args.start or "", end_time=args.end or "", count=args.count, dividend_type=args.dividend, fill_data=not args.no_fill, ) except Exception as e: _err("查询 K 线失败", detail=str(e), code="QUERY_FAIL") if not result or args.code not in result: _err("未获取到 K 线数据", code="NO_DATA") df = result[args.code] if df is None or len(df) == 0: _err("K 线数据为空") # 转为 list of dict records = df.reset_index().to_dict(orient="records") # 精简大数字字段 for r in records: for k, v in list(r.items()): if hasattr(v, "item"): r[k] = v.item() # 统计 closes = [r.get("close") for r in records if r.get("close") is not None] stats = {} if closes: stats["count"] = len(closes) stats["first_close"] = closes[0] stats["last_close"] = closes[-1] stats["high"] = max(closes) stats["low"] = min(closes) stats["change_pct"] = round((closes[-1] - closes[0]) / closes[0] * 100, 2) if closes[0] else None # 简单均线 if len(closes) >= 5: stats["ma5"] = round(sum(closes[-5:]) / 5, 3) if len(closes) >= 20: stats["ma20"] = round(sum(closes[-20:]) / 20, 3) if len(closes) >= 60: stats["ma60"] = round(sum(closes[-60:]) / 60, 3) _ok({"code": args.code, "period": args.period, "bars": records, "stats": stats}, table=args.table, headers=["time", "open", "high", "low", "close", "volume"]) def cmd_instrument(args): _, xtdata, _ = _init() try: detail = xtdata.get_instrument_detail(args.code) except Exception as e: _err("查询合约详情失败", detail=str(e), code="QUERY_FAIL") if detail is None: _err("未找到合约: %s" % args.code) _ok(detail, table=args.table) def cmd_sector(args): _, xtdata, _ = _init() if args.name: try: stocks = xtdata.get_stock_list_in_sector(args.name) except Exception as e: _err("查询板块成分股失败", detail=str(e), code="QUERY_FAIL") _ok({"sector": args.name, "count": len(stocks or []), "stocks": stocks or []}) else: try: sectors = xtdata.get_sector_list() except Exception as e: _err("查询板块列表失败", detail=str(e), code="QUERY_FAIL") _ok({"sectors": sectors or []}) def cmd_trading_dates(args): _, xtdata, _ = _init() try: dates = xtdata.get_trading_dates( market=args.market, start_time=args.start or "", end_time=args.end or "", count=args.count if args.count > 0 else -1, ) except Exception as e: _err("查询交易日历失败", detail=str(e), code="QUERY_FAIL") _ok({"dates": dates or []}) def cmd_north(args): _, xtdata, _ = _init() try: data = xtdata.get_north_finance_change(period=args.period or "1d") except Exception as e: _err("查询北向资金失败", detail=str(e), code="QUERY_FAIL") # data 可能是 dict[code -> DataFrame] if isinstance(data, dict): result = {} for k, v in data.items(): if hasattr(v, "to_dict"): result[k] = v.reset_index().to_dict(orient="records") else: result[k] = v elif hasattr(data, "to_dict"): result = data.reset_index().to_dict(orient="records") else: result = data _ok({"north_finance": result}) def cmd_longhubang(args): _, xtdata, _ = _init() try: df = xtdata.get_longhubang( stock_list=[args.code], start_time=args.start or "", end_time=args.end or "", count=args.count if args.count > 0 else 5, ) except Exception as e: _err("查询龙虎榜失败", detail=str(e), code="QUERY_FAIL") if df is None: _err("龙虎榜数据为空") if hasattr(df, "to_dict"): records = df.reset_index().to_dict(orient="records") else: records = df _ok({"longhubang": records}) def cmd_financial(args): _, xtdata, _ = _init() tables = args.tables.split(",") if args.tables else ["Capital.CAPITAL"] try: data = xtdata.get_financial_data( stock_list=args.codes, table_list=tables, start_time=args.start or "", end_time=args.end or "", ) except Exception as e: _err("查询财务数据失败", detail=str(e), code="QUERY_FAIL") result = {} for code, df in (data or {}).items(): if hasattr(df, "to_dict"): result[code] = df.reset_index().to_dict(orient="records") else: result[code] = df _ok({"financial": result}) def cmd_download(args): _, xtdata, _ = _init() try: result = xtdata.download_history_data2( stock_list=args.codes, period=args.period, start_time=args.start or "", end_time=args.end or "", dividend_type=args.dividend, ) except Exception as e: _err("下载数据失败", detail=str(e), code="DOWNLOAD_FAIL") _ok({"download_result": result}) def _place_order(args, action): """下单通用逻辑。action = 'BUY' 或 'SELL'。""" tr, _, _ = _init() acc = _acc_or(args.account) from bigqmt_signal_trader.xtquant_compat import ( STOCK_BUY, STOCK_SELL, FIX_PRICE, LATEST_PRICE, ) order_type = STOCK_BUY if action == "BUY" else STOCK_SELL if args.latest: price_type = LATEST_PRICE price = 0.0 else: if args.price is None: _err("限价单必须指定 --price，或用 --latest 使用最新价") price_type = FIX_PRICE price = args.price strategy = args.strategy or "llm_agent" remark = args.remark or "llm_%s_%d" % (action.lower(), int(time.time())) # 干跑模式 if args.dry_run: _ok({ "dry_run": True, "action": action, "stock_code": args.code, "volume": args.volume, "price": price, "price_type": "LATEST" if args.latest else "LIMIT", "strategy_name": strategy, "order_remark": remark, }) # 真实下单 try: order_id = tr.order_stock( acc, args.code, order_type, args.volume, price_type, price, strategy, remark, ) except PermissionError as e: _err("下单被拒绝：服务端未开启下单权限（rpc_allow_order_methods=False）", detail=str(e), code="ORDER_DISABLED") except TimeoutError as e: _err( "下单超时——委托可能已提交但未收到响应。请先用 query_orders 确认，避免重复下单", detail=str(e), code="ORDER_TIMEOUT", ) except Exception as e: _err("下单失败", detail=str(e), code="ORDER_FAIL") if order_id == -1: _err("下单返回 -1（失败），请检查：1) 账户权限 2) 价格范围 3) QMT 风控", code="ORDER_REJECTED") # 等 0.5 秒后查委托确认 time.sleep(0.5) try: orders = tr.query_stock_orders(acc, strategy_name=strategy) except Exception: orders = None placed_order = None if orders: for o in orders: if getattr(o, "order_remark", "") == remark or getattr(o, "order_sysid", "") == str(order_id): placed_order = _order_to_dict(o) break _ok({ "order_sys_id": str(order_id), "action": action, "stock_code": args.code, "volume": args.volume, "price": price, "strategy_name": strategy, "order_remark": remark, "confirmed_order": placed_order, }) def cmd_buy(args): _place_order(args, "BUY") def cmd_sell(args): _place_order(args, "SELL") def cmd_cancel(args): tr, _, _ = _init() acc = _acc_or(args.account) if args.dry_run: _ok({"dry_run": True, "order_sysid": args.order_id, "market": args.market or ""}) try: success = tr.cancel_order_stock_sysid(acc, args.market or "", args.order_id) except Exception as e: _err("撤单失败", detail=str(e), code="CANCEL_FAIL") _ok({"order_sysid": args.order_id, "market": args.market or "", "success": bool(success)}) def cmd_snapshot(args): """一键快照：资产+持仓+今日委托+今日成交，一次返回。""" tr, _, _ = _init() acc = _acc_or(args.account) result = {} # 资产 try: asset = tr.query_stock_asset(acc) if asset: result["asset"] = { "account_id": getattr(asset, "account_id", None), "cash": getattr(asset, "cash", None), "frozen_cash": getattr(asset, "frozen_cash", 0), "total_asset": getattr(asset, "total_asset", None), "market_value": getattr(asset, "market_value", None), } except Exception as e: result["asset_error"] = str(e) # 持仓 try: positions = tr.query_stock_positions(acc) result["positions"] = [_position_to_dict(p) for p in (positions or [])] result["position_count"] = len(result["positions"]) except Exception as e: result["position_error"] = str(e) # 委托 try: orders = tr.query_stock_orders(acc, strategy_name="") result["orders"] = [_order_to_dict(o) for o in (orders or [])] result["order_count"] = len(result["orders"]) except Exception as e: result["order_error"] = str(e) # 成交 try: trades = tr.query_stock_trades(acc, strategy_name="") result["trades"] = [_trade_to_dict(t) for t in (trades or [])] result["trade_count"] = len(result["trades"]) except Exception as e: result["trade_error"] = str(e) _ok(result, table=args.table) def cmd_rpc(args): """通用 RPC 调用入口：任意白名单方法 + JSON 参数。 用于调用没有专用子命令的 API（如 get_holidays、get_sector_info、 get_hkt_statistics、bsm_price 等）。 用法： python qmt.py rpc get_holidays python qmt.py rpc get_stock_name '{"stock":"600000.SH"}' python qmt.py rpc bsm_price '{"opt_type":"C","target_price":3.0,"strike_price":2.8,"risk_free":0.03,"sigma":0.3,"days":30}' """ tr, _, _ = _init() params = {} if args.params: try: params = json.loads(args.params) if not isinstance(params, dict): _err("params 必须是 JSON 对象（如 '{\"key\":\"value\"}'）", code="PARAM_ERROR") except json.JSONDecodeError as e: _err("params JSON 解析失败", detail=str(e), code="PARAM_ERROR") try: result = tr.client.call(args.method, params) except Exception as e: _err("RPC 调用失败: %s" % args.method, detail=str(e), code="RPC_FAIL") _ok({"method": args.method, "result": result}, table=args.table) def cmd_quote_subscribe(args): """订阅全推行情（打印前 N 条后退出）。""" _, xtdata, _ = _init() received = [] def on_quote(data): for code, tick in (data or {}).items(): entry = { "code": code, "lastPrice": tick.get("lastPrice"), "volume": tick.get("volume"), "time": tick.get("time"), } received.append(entry) print(json.dumps(entry, ensure_ascii=False)) if len(received) >= args.max: xtdata.unsubscribe_quote(sub_id) # 给一点时间让退订生效 time.sleep(0.5) os._exit(0) try: sub_id = xtdata.subscribe_whole_quote(args.codes, callback=on_quote) except Exception as e: _err("订阅行情失败", detail=str(e), code="SUBSCRIBE_FAIL") print("# subscribed id=%s, waiting for quotes (max %d)..." % (sub_id, args.max), file=sys.stderr) # 等待 timeout = args.timeout t0 = time.time() try: while time.time() - t0 < timeout: time.sleep(0.5) except KeyboardInterrupt: pass try: xtdata.unsubscribe_quote(sub_id) except Exception: pass _ok({"sub_id": sub_id, "received": received, "count": len(received)}) # =========================================================================== # argparse 路由 # =========================================================================== def build_parser(): p = argparse.ArgumentParser( prog="qmt.py", description="QMT 交易/行情统一 CLI（给大模型用）", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=__doc__, ) p.add_argument("--account", default=None, help="指定账号 ID（覆盖配置）") p.add_argument("--table", action="store_true", help="输出表格而非 JSON") sub = p.add_subparsers(dest="command", required=True) # ping sub.add_parser("ping", help="连通性检测").set_defaults(func=cmd_ping) # account sub.add_parser("account", help="查询账户资产").set_defaults(func=cmd_account) # positions sp = sub.add_parser("positions", help="查询持仓") sp.add_argument("code", nargs="?", default=None, help="可选：只查指定股票") sp.set_defaults(func=cmd_positions) # orders sp = sub.add_parser("orders", help="查询今日委托") sp.add_argument("--cancelable", action="store_true", help="只查可撤委托") sp.add_argument("--strategy", default=None, help="按策略名过滤（空=全部）") sp.set_defaults(func=cmd_orders) # trades sp = sub.add_parser("trades", help="查询今日成交") sp.add_argument("--strategy", default=None, help="按策略名过滤") sp.set_defaults(func=cmd_trades) # tick sp = sub.add_parser("tick", help="实时五档盘口") sp.add_argument("codes", nargs="+", help="股票代码，如 600000.SH 000001.SZ") sp.set_defaults(func=cmd_tick) # kline sp = sub.add_parser("kline", help="K线/历史行情") sp.add_argument("code", help="股票代码") sp.add_argument("--period", default="1d", help="周期: 1d/1m/5m/15m/30m/60m/tick") sp.add_argument("--count", type=int, default=-1, help="获取根数（-1=全部）") sp.add_argument("--start", default=None, help="开始日期 YYYYMMDD") sp.add_argument("--end", default=None, help="结束日期 YYYYMMDD") sp.add_argument("--fields", default=None, help="字段逗号分隔，如 close,open,volume") sp.add_argument("--dividend", default="none", help="复权: none/front/back") sp.add_argument("--no-fill", action="store_true", help="不填充缺失数据") sp.set_defaults(func=cmd_kline) # instrument sp = sub.add_parser("instrument", help="合约详情") sp.add_argument("code", help="股票代码") sp.set_defaults(func=cmd_instrument) # sector sp = sub.add_parser("sector", help="板块查询") sp.add_argument("name", nargs="?", default=None, help="板块名（不填则列板块）") sp.set_defaults(func=cmd_sector) # trading-dates sp = sub.add_parser("trading-dates", help="交易日历") sp.add_argument("--market", default="SH", help="市场 SH/SZ") sp.add_argument("--count", type=int, default=10, help="获取天数") sp.add_argument("--start", default=None) sp.add_argument("--end", default=None) sp.set_defaults(func=cmd_trading_dates) # north sp = sub.add_parser("north", help="北向资金") sp.add_argument("--period", default="1d") sp.set_defaults(func=cmd_north) # longhubang sp = sub.add_parser("longhubang", help="龙虎榜") sp.add_argument("code", help="股票代码") sp.add_argument("--count", type=int, default=5) sp.add_argument("--start", default=None) sp.add_argument("--end", default=None) sp.set_defaults(func=cmd_longhubang) # financial sp = sub.add_parser("financial", help="财务数据") sp.add_argument("codes", nargs="+", help="股票代码") sp.add_argument("--tables", default=None, help="表名逗号分隔，如 Capital.CAPITAL,Performance.EXPRESS") sp.add_argument("--start", default=None) sp.add_argument("--end", default=None) sp.set_defaults(func=cmd_financial) # download sp = sub.add_parser("download", help="下载历史数据到服务端") sp.add_argument("codes", nargs="+", help="股票代码") sp.add_argument("--period", default="1d") sp.add_argument("--start", default=None) sp.add_argument("--end", default=None) sp.add_argument("--dividend", default="none") sp.set_defaults(func=cmd_download) # buy sp = sub.add_parser("buy", help="买入下单") sp.add_argument("code", help="股票代码") sp.add_argument("volume", type=int, help="委托数量（股）") sp.add_argument("--price", type=float, default=None, help="限价单价格") sp.add_argument("--latest", action="store_true", help="用最新价下单") sp.add_argument("--strategy", default=None, help="策略名") sp.add_argument("--remark", default=None, help="委托备注/user_order_id") sp.add_argument("--dry-run", action="store_true", help="只打印不下单") sp.set_defaults(func=cmd_buy) # sell sp = sub.add_parser("sell", help="卖出下单") sp.add_argument("code", help="股票代码") sp.add_argument("volume", type=int, help="委托数量（股）") sp.add_argument("--price", type=float, default=None, help="限价单价格") sp.add_argument("--latest", action="store_true", help="用最新价下单") sp.add_argument("--strategy", default=None, help="策略名") sp.add_argument("--remark", default=None, help="委托备注/user_order_id") sp.add_argument("--dry-run", action="store_true", help="只打印不下单") sp.set_defaults(func=cmd_sell) # cancel sp = sub.add_parser("cancel", help="撤单") sp.add_argument("order_id", help="委托号 order_sysid") sp.add_argument("--market", default=None, help="市场 SH/SZ") sp.add_argument("--dry-run", action="store_true", help="只打印不撤单") sp.set_defaults(func=cmd_cancel) # snapshot sub.add_parser("snapshot", help="一键快照：资产+持仓+委托+成交").set_defaults(func=cmd_snapshot) # rpc — 通用 RPC 调用（兜底所有白名单方法） sp = sub.add_parser("rpc", help="通用 RPC 调用（任意白名单方法 + JSON 参数）") sp.add_argument("method", help="方法名，如 get_holidays / get_stock_name / bsm_price") sp.add_argument("params", nargs="?", default=None, help='JSON 参数，如 \'{"stock":"600000.SH"}\'') sp.set_defaults(func=cmd_rpc) # ---- 高频快捷命令（转发到 xtdata 对应方法） ---- def _quick(name, help_text, method, params_builder): def make(args): tr, xtdata, _ = _init() params = params_builder(args) try: fn = getattr(xtdata, method) result = fn(**params) if isinstance(params, dict) else fn(*params) except AttributeError: # 方法不存在时回退到 RPC 调用 result = tr.client.call(method, params if isinstance(params, dict) else {}) except Exception as e: _err("%s 失败" % name, detail=str(e), code="QUERY_FAIL") _ok({"result": result}, table=getattr(args, "table", False)) sp2 = sub.add_parser(name, help=help_text) sp2.add_argument("args", nargs="*", help="位置参数（按方法签名顺序）") sp2.set_defaults(func=make) return sp2 # 节假日 _quick("holiday", "节假日列表", "get_holidays", lambda a: {}) # 股票名称 _quick("stock-name", "股票名称", "get_stock_name", lambda a: {"stock": a.args[0] if a.args else _err("需传股票代码")}) # 品种类型 _quick("instrument-type", "品种类型(stock/fund/etf/bond/index)", "get_instrument_type", lambda a: {"stock_code": a.args[0] if a.args else _err("需传代码")}) # 除权除息因子 _quick("divid-factors", "除权除息因子", "get_divid_factors", lambda a: {"stock_code": a.args[0] if a.args else _err("需传代码"), "start_time": a.args[1] if len(a.args) > 1 else "", "end_time": a.args[2] if len(a.args) > 2 else ""}) # 交易时段 _quick("market-times", "日内交易时段", "get_trade_times", lambda a: {"stockcode": a.args[0] if a.args else "SH"}) # 交易日历（含时段） _quick("trading-calendar", "交易日历(含时段)", "get_trading_calendar", lambda a: {"market": a.args[0] if a.args else "SH", "start_time": a.args[1] if len(a.args) > 1 else "", "end_time": a.args[2] if len(a.args) > 2 else ""}) # 期权列表 _quick("option-list", "期权列表", "get_option_list", lambda a: {"undl_code": a.args[0] if a.args else _err("需传标的代码"), "dedate": a.args[1] if len(a.args) > 1 else ""}) # BSM 期权定价 _quick("bsm-price", "BSM 期权定价", "bsm_price", lambda a: {"opt_type": a.args[0] if a.args else "C", "target_price": float(a.args[1]) if len(a.args) > 1 else 3.0, "strike_price": float(a.args[2]) if len(a.args) > 2 else 2.8, "risk_free": float(a.args[3]) if len(a.args) > 3 else 0.03, "sigma": float(a.args[4]) if len(a.args) > 4 else 0.3, "days": int(a.args[5]) if len(a.args) > 5 else 30}) # BSM 隐含波动率 _quick("bsm-iv", "BSM 隐含波动率", "bsm_iv", lambda a: {"opt_type": a.args[0] if a.args else "C", "target_price": float(a.args[1]) if len(a.args) > 1 else 3.0, "strike_price": float(a.args[2]) if len(a.args) > 2 else 2.8, "option_price": float(a.args[3]) if len(a.args) > 3 else 0.25, "risk_free": float(a.args[4]) if len(a.args) > 4 else 0.03, "days": int(a.args[5]) if len(a.args) > 5 else 30}) # 港股通统计 _quick("hkt-stats", "港股通统计", "get_hkt_statistics", lambda a: {"stock_code": a.args[0] if a.args else _err("需传代码")}) # 港股通明细 _quick("hkt-details", "港股通明细", "get_hkt_details", lambda a: {"stock_code": a.args[0] if a.args else _err("需传代码")}) # 港股通汇率 _quick("hkt-rate", "港股通汇率", "get_hkt_exchange_rate", lambda a: {}) # 十大股东 _quick("top10-holder", "十大股东", "get_top10_share_holder", lambda a: {"stock_list": [a.args[0] if a.args else _err("需传代码")], "data_name": "holder", "start_time": a.args[1] if len(a.args) > 1 else "", "end_time": a.args[2] if len(a.args) > 2 else ""}) # 股东户数 _quick("holder-num", "股东户数", "get_holder_num", lambda a: {"stock_list": [a.args[0] if a.args else _err("需传代码")]}) # 新股数据 _quick("ipo", "新股数据", "get_ipo_data", lambda a: {}) # 新股申购额度 _quick("ipo-limit", "新股申购额度", "get_new_purchase_limit", lambda a: {}) # 融资融券担保品 _quick("credit-assure", "融资融券担保品合约", "get_assure_contract", lambda a: {}) # 融资融券融券标的 _quick("credit-short", "融券标的合约", "get_enable_short_contract", lambda a: {}) # 负债合约 _quick("credit-debt", "负债合约", "get_debt_contract", lambda a: {}) # 历史 ST _quick("his-st", "历史 ST 数据", "get_his_st_data", lambda a: {"stock_code": a.args[0] if a.args else _err("需传代码")}) # 指数权重 _quick("index-weight", "指数权重", "get_index_weight", lambda a: {"index_code": a.args[0] if a.args else _err("需传指数代码")}) # 行业 _quick("industry", "行业成分", "get_industry", lambda a: {"industry_name": a.args[0] if a.args else _err("需传行业名")}) # 板块信息 _quick("sector-info", "板块详情", "get_sector_info", lambda a: {"sector_name": a.args[0] if a.args else ""}) # 时间转换 _quick("timetag2dt", "毫秒时间戳转日期", "timetag_to_datetime", lambda a: {"timetag": int(a.args[0]) if a.args else _err("需传毫秒时间戳"), "format": a.args[1] if len(a.args) > 1 else "%Y%m%d %H:%M:%S"}) _quick("dt2timetag", "日期转毫秒时间戳", "datetime_to_timetag", lambda a: {"datetime_str": a.args[0] if a.args else _err("需传日期字符串"), "format": a.args[1] if len(a.args) > 1 else "%Y%m%d%H%M%S"}) # 本地数据（缓存） _quick("local-data", "本地缓存数据", "get_local_data", lambda a: {"field_list": ["close"], "stock_list": [a.args[0] if a.args else _err("需传代码")], "period": a.args[1] if len(a.args) > 1 else "1d", "count": -1}) # quote-subscribe sp = sub.add_parser("quote-subscribe", help="订阅全推行情（实时推送）") sp.add_argument("codes", nargs="+", help="代码或市场，如 SH SZ 600000.SH") sp.add_argument("--max", type=int, default=10, help="收到 N 条后退出") sp.add_argument("--timeout", type=int, default=30, help="超时秒数") sp.set_defaults(func=cmd_quote_subscribe) return p def main(): parser = build_parser() args = parser.parse_args() if not hasattr(args, "func"): parser.print_help() sys.exit(1) try: args.func(args) except SystemExit: raise except KeyboardInterrupt: print("\n(interrupted)", file=sys.stderr) sys.exit(130) except Exception as e: _err("未预期错误", detail=traceback.format_exc(), code="UNEXPECTED") if __name__ == "__main__": main()