xtquant-big-convert 0.3.0__tar.gz → 0.3.2__tar.gz

{xtquant_big_convert-0.3.0/src/xtquant_big_convert.egg-info → xtquant_big_convert-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtquant-big-convert
-Version: 0.3.0
+Version: 0.3.2
 Summary: Big QMT RPC bridge and MiniQMT-compatible adapter layer (redis/zmq/mysql transports)
 Author: litaolemo
 License: MIT
@@ -461,10 +461,15 @@ python -m bigqmt_signal_trader.qmt_launcher restart --dir "D:\国金证券QMT交
 | `exe` | 直接起 `XtItClient.exe`，靠终端自身恢复会话 | 否 |
 | `login` | 起 exe 后向登录框输入账号密码 | 是，需 pywin32 |
 
-**关于「pywinauto/pyautogui 要求 Windows 处于登录状态」**：`login` 模式用的是
-`win32api.SendMessage` 直接投递到窗口句柄，不是 pyautogui 那种按屏幕坐标重放物理输入。
-前者不要求窗口置于前台，锁屏下也能工作（会话还在即可，完全注销则不行）。密码从
-环境变量 `BIGQMT_LOGIN_USER` / `BIGQMT_LOGIN_PASSWORD` 读，不走命令行参数——argv
+**`login` 模式需要未锁屏的交互式桌面。** 它用的是 `keybd_event` / `mouse_event`
+物理输入（经 ctypes），不是 `SendMessage`——消息式输入投不到 Qt 对话框的焦点控件上，
+当别的窗口在前台时会静默失败，什么也不输入。物理输入要求对话框在最前，所以启动前会
+先把它置顶并核验；锁屏或 RDP 注销的会话直接抛 `QmtLauncherError` 而不是打一半密码。
+
+> 需要**无人值守定时重启**的话，用 `linkmini` / `bat` / `exe` 三种模式，它们不碰登录框，
+> 锁屏也能跑。只有 `login` 受这条限制。
+
+密码从环境变量 `BIGQMT_LOGIN_USER` / `BIGQMT_LOGIN_PASSWORD` 读，不走命令行参数——argv
 对同机任何进程可见。
 
 两个设计要点：
@@ -660,6 +665,67 @@ credit_positions = credit_trader.query_stock_positions(credit_acc)
 
 ---
 
+## 与 MiniQMT 的兼容性对照
+
+本项目的目标是让照着 MiniQMT (`xtquant`) 写的代码不改就能跑。下表列出**返回值契约**——类型不对不会报错，只会让判断悄悄反过来，所以单独列出来。
+
+### 返回值：与 MiniQMT 一致
+
+| 接口 | 返回 | 说明 |
+|---|---|---|
+| `order_stock()` | `int` | 成功为正数，失败 `-1` |
+| `order_stock_async()` | `int` | 请求序号 seq，结果走 `on_order_stock_async_response` |
+| `cancel_order_stock()` | `int` | **`0` 成功，`-1` 失败**（不是 True/False） |
+| `cancel_order_stock_sysid()` | `int` | 同上 |
+| `cancel_order_stock_async()` | `int` | seq |
+| `connect()` / `start()` | `int` | `0` 成功 |
+| `subscribe()` / `unsubscribe()` | `int` | `0` 成功 |
+| `query_stock_asset()` | 对象 | `.cash` / `.total_asset` 等属性 |
+| `query_stock_positions()` | `list[对象]` | |
+| `query_stock_orders()` / `query_stock_trades()` | `list[对象]` | |
+| `subscribe_quote()` / `subscribe_whole_quote()` | `int` | 订阅号，传给 `unsubscribe_quote()` |
+| `get_full_tick()` | `dict` | `{code: {...}}` |
+| `get_market_data_ex()` | `dict[str, DataFrame]` | |
+
+### 订单号：既是 int 也是 str
+
+MiniQMT 的 `order_id` 是 int（委托编号），`order_sysid` 是 str（柜台合同编号）。大 QMT **没有前者**——`get_trade_detail_data` 只给 `m_strOrderSysID` 这个字符串。
+
+所以这里的 `order_id` 是一个 int 子类，两种形态同时成立：
+
+```python
+order_id = xt_trader.order_stock(acc, "600000.SH", 23, 100, 11, 10.0, "s", "")
+
+isinstance(order_id, int)   # True —— MiniQMT 写法照常
+order_id > 0                # True
+order_id == -1              # 失败时才 True
+
+str(order_id)               # '合同编号' —— 券商给的原始字符串
+xt_trader.cancel_order_stock(acc, order_id)   # 撤单送回的是原始字符串
+```
+
+合同编号是纯数字时（多数券商），int 值就是那个数字，两种形态完全一致；不是纯数字时 int 是一个稳定的正数替身，而撤单、打印用的仍是真实编号。
+
+把 order_id 存进数据库再取出来（变成普通 int）也能撤单——客户端记着最近 4096 个的对应关系。想要字符串就用 `.order_sysid`，它一直是 str。
+
+同样的规则适用于 `XtOrder.order_id`、`XtTrade.order_id`，以及回调对象 `XtOrderError` / `XtCancelError` / `XtOrderResponse` 里的 `order_id`。
+
+### 行为差异（不是返回值，但会咬人）
+
+| 项目 | MiniQMT | 本项目 |
+|---|---|---|
+| `get_full_tick(["SH"])` | 全市场 | **默认只取股票**（1.08s）；要全部传 `types=["all"]`（7.4s，含地方债等 26744 只） |
+| `get_instrument_detail()` 查不到 | `None` | `{}`（两者都是 falsy，`if not detail` 通用） |
+| `download_history_data()` | 无返回 | 返回 `{"finished": n, "total": n}`（多给的信息，可忽略） |
+| 账户类型 | `StockAccount(id, "CREDIT")` 即可 | 还需服务端 `BIGQMT_ACCOUNT_TYPE = "CREDIT"`，**客户端的类型不会传到服务端** |
+| 委托类型常量 | `xtconstant.order_type` | 内部会翻译成 `passorder` 的 opType（两套编号，专项两融 40–45 → 70–75） |
+
+### 本项目的扩展（MiniQMT 没有）
+
+这些不是兼容项，是多出来的：`order_stock_result()`（返回完整 dict 而非单个 id）、`order_stock_batch()`、`wait_async_orders()`、`ipo_subscribe_all()`、`sync_deployment()`、`get_deployment_info()`、`query_execution_snapshot()`、`local_cache_stats()`。
+
+---
+
 ## 环境要求与依赖安装
 
 本系统分两部分，各自需要自己的 Python 环境和依赖：
@@ -743,6 +809,8 @@ cd D:\国金证券QMT交易端
 
 ## 快速开始
 
+> 第一次部署、只想要最短路径？直接看 [docs/DEPLOY_QUICKSTART.md](docs/DEPLOY_QUICKSTART.md)（单账号五步跑通 + 常见问题表）。
+
 > 前置：客户端已按上面「A. 客户端」装好包；服务端按「B. 服务端」装好所选传输的依赖。下面是从零跑通整套流程的步骤。
 >
 > 只想把配置生成出来的话，跑 [`bigqmt-init`](#配置向导bigqmt-init) 即可——第 3 步的两份配置它会替你写好，选单文件部署还会顺带把构建也做了。
@@ -1231,6 +1299,8 @@ python qmt-trader/scripts/qmt.py buy 600000.SH 100 --price 7.50 --dry-run
 ## 相关文档
 
 - [CHANGELOG.md](CHANGELOG.md) — **版本变更记录**（新增/修复/变更）
+- [docs/DEPLOY_QUICKSTART.md](docs/DEPLOY_QUICKSTART.md) — **单账号部署快速开始**（最短路径 + 部署期常见问题表）
+- [docs/LATENCY_REPORT.md](docs/LATENCY_REPORT.md) — **延迟测试报告**（传输层对比、FormulaServer 直连、下单链路、方法论）
 - [docs/RPC_API_REFERENCE.md](docs/RPC_API_REFERENCE.md) — **全部 RPC 方法参考**（参数、返回值、别名、大 QMT 能力边界）
 - [docs/FORMULA_SERVER_FASTPATH.md](docs/FORMULA_SERVER_FASTPATH.md) — FormulaServer(58600) 直连快速路径：协议、映射表、能力边界与回退行为
 - [docs/SUBSCRIBE_WHOLE_QUOTE_PUSH.md](docs/SUBSCRIBE_WHOLE_QUOTE_PUSH.md) — 全推行情订阅推送机制设计

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/README.md

@@ -426,10 +426,15 @@ python -m bigqmt_signal_trader.qmt_launcher restart --dir "D:\国金证券QMT交
 | `exe` | 直接起 `XtItClient.exe`，靠终端自身恢复会话 | 否 |
 | `login` | 起 exe 后向登录框输入账号密码 | 是，需 pywin32 |
 
-**关于「pywinauto/pyautogui 要求 Windows 处于登录状态」**：`login` 模式用的是
-`win32api.SendMessage` 直接投递到窗口句柄，不是 pyautogui 那种按屏幕坐标重放物理输入。
-前者不要求窗口置于前台，锁屏下也能工作（会话还在即可，完全注销则不行）。密码从
-环境变量 `BIGQMT_LOGIN_USER` / `BIGQMT_LOGIN_PASSWORD` 读，不走命令行参数——argv
+**`login` 模式需要未锁屏的交互式桌面。** 它用的是 `keybd_event` / `mouse_event`
+物理输入（经 ctypes），不是 `SendMessage`——消息式输入投不到 Qt 对话框的焦点控件上，
+当别的窗口在前台时会静默失败，什么也不输入。物理输入要求对话框在最前，所以启动前会
+先把它置顶并核验；锁屏或 RDP 注销的会话直接抛 `QmtLauncherError` 而不是打一半密码。
+
+> 需要**无人值守定时重启**的话，用 `linkmini` / `bat` / `exe` 三种模式，它们不碰登录框，
+> 锁屏也能跑。只有 `login` 受这条限制。
+
+密码从环境变量 `BIGQMT_LOGIN_USER` / `BIGQMT_LOGIN_PASSWORD` 读，不走命令行参数——argv
 对同机任何进程可见。
 
 两个设计要点：
@@ -625,6 +630,67 @@ credit_positions = credit_trader.query_stock_positions(credit_acc)
 
 ---
 
+## 与 MiniQMT 的兼容性对照
+
+本项目的目标是让照着 MiniQMT (`xtquant`) 写的代码不改就能跑。下表列出**返回值契约**——类型不对不会报错，只会让判断悄悄反过来，所以单独列出来。
+
+### 返回值：与 MiniQMT 一致
+
+| 接口 | 返回 | 说明 |
+|---|---|---|
+| `order_stock()` | `int` | 成功为正数，失败 `-1` |
+| `order_stock_async()` | `int` | 请求序号 seq，结果走 `on_order_stock_async_response` |
+| `cancel_order_stock()` | `int` | **`0` 成功，`-1` 失败**（不是 True/False） |
+| `cancel_order_stock_sysid()` | `int` | 同上 |
+| `cancel_order_stock_async()` | `int` | seq |
+| `connect()` / `start()` | `int` | `0` 成功 |
+| `subscribe()` / `unsubscribe()` | `int` | `0` 成功 |
+| `query_stock_asset()` | 对象 | `.cash` / `.total_asset` 等属性 |
+| `query_stock_positions()` | `list[对象]` | |
+| `query_stock_orders()` / `query_stock_trades()` | `list[对象]` | |
+| `subscribe_quote()` / `subscribe_whole_quote()` | `int` | 订阅号，传给 `unsubscribe_quote()` |
+| `get_full_tick()` | `dict` | `{code: {...}}` |
+| `get_market_data_ex()` | `dict[str, DataFrame]` | |
+
+### 订单号：既是 int 也是 str
+
+MiniQMT 的 `order_id` 是 int（委托编号），`order_sysid` 是 str（柜台合同编号）。大 QMT **没有前者**——`get_trade_detail_data` 只给 `m_strOrderSysID` 这个字符串。
+
+所以这里的 `order_id` 是一个 int 子类，两种形态同时成立：
+
+```python
+order_id = xt_trader.order_stock(acc, "600000.SH", 23, 100, 11, 10.0, "s", "")
+
+isinstance(order_id, int)   # True —— MiniQMT 写法照常
+order_id > 0                # True
+order_id == -1              # 失败时才 True
+
+str(order_id)               # '合同编号' —— 券商给的原始字符串
+xt_trader.cancel_order_stock(acc, order_id)   # 撤单送回的是原始字符串
+```
+
+合同编号是纯数字时（多数券商），int 值就是那个数字，两种形态完全一致；不是纯数字时 int 是一个稳定的正数替身，而撤单、打印用的仍是真实编号。
+
+把 order_id 存进数据库再取出来（变成普通 int）也能撤单——客户端记着最近 4096 个的对应关系。想要字符串就用 `.order_sysid`，它一直是 str。
+
+同样的规则适用于 `XtOrder.order_id`、`XtTrade.order_id`，以及回调对象 `XtOrderError` / `XtCancelError` / `XtOrderResponse` 里的 `order_id`。
+
+### 行为差异（不是返回值，但会咬人）
+
+| 项目 | MiniQMT | 本项目 |
+|---|---|---|
+| `get_full_tick(["SH"])` | 全市场 | **默认只取股票**（1.08s）；要全部传 `types=["all"]`（7.4s，含地方债等 26744 只） |
+| `get_instrument_detail()` 查不到 | `None` | `{}`（两者都是 falsy，`if not detail` 通用） |
+| `download_history_data()` | 无返回 | 返回 `{"finished": n, "total": n}`（多给的信息，可忽略） |
+| 账户类型 | `StockAccount(id, "CREDIT")` 即可 | 还需服务端 `BIGQMT_ACCOUNT_TYPE = "CREDIT"`，**客户端的类型不会传到服务端** |
+| 委托类型常量 | `xtconstant.order_type` | 内部会翻译成 `passorder` 的 opType（两套编号，专项两融 40–45 → 70–75） |
+
+### 本项目的扩展（MiniQMT 没有）
+
+这些不是兼容项，是多出来的：`order_stock_result()`（返回完整 dict 而非单个 id）、`order_stock_batch()`、`wait_async_orders()`、`ipo_subscribe_all()`、`sync_deployment()`、`get_deployment_info()`、`query_execution_snapshot()`、`local_cache_stats()`。
+
+---
+
 ## 环境要求与依赖安装
 
 本系统分两部分，各自需要自己的 Python 环境和依赖：
@@ -708,6 +774,8 @@ cd D:\国金证券QMT交易端
 
 ## 快速开始
 
+> 第一次部署、只想要最短路径？直接看 [docs/DEPLOY_QUICKSTART.md](docs/DEPLOY_QUICKSTART.md)（单账号五步跑通 + 常见问题表）。
+
 > 前置：客户端已按上面「A. 客户端」装好包；服务端按「B. 服务端」装好所选传输的依赖。下面是从零跑通整套流程的步骤。
 >
 > 只想把配置生成出来的话，跑 [`bigqmt-init`](#配置向导bigqmt-init) 即可——第 3 步的两份配置它会替你写好，选单文件部署还会顺带把构建也做了。
@@ -1196,6 +1264,8 @@ python qmt-trader/scripts/qmt.py buy 600000.SH 100 --price 7.50 --dry-run
 ## 相关文档
 
 - [CHANGELOG.md](CHANGELOG.md) — **版本变更记录**（新增/修复/变更）
+- [docs/DEPLOY_QUICKSTART.md](docs/DEPLOY_QUICKSTART.md) — **单账号部署快速开始**（最短路径 + 部署期常见问题表）
+- [docs/LATENCY_REPORT.md](docs/LATENCY_REPORT.md) — **延迟测试报告**（传输层对比、FormulaServer 直连、下单链路、方法论）
 - [docs/RPC_API_REFERENCE.md](docs/RPC_API_REFERENCE.md) — **全部 RPC 方法参考**（参数、返回值、别名、大 QMT 能力边界）
 - [docs/FORMULA_SERVER_FASTPATH.md](docs/FORMULA_SERVER_FASTPATH.md) — FormulaServer(58600) 直连快速路径：协议、映射表、能力边界与回退行为
 - [docs/SUBSCRIBE_WHOLE_QUOTE_PUSH.md](docs/SUBSCRIBE_WHOLE_QUOTE_PUSH.md) — 全推行情订阅推送机制设计

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xtquant-big-convert"
-version = "0.3.0"
+version = "0.3.2"
 description = "Big QMT RPC bridge and MiniQMT-compatible adapter layer (redis/zmq/mysql transports)"
 readme = "README.md"
 requires-python = ">=3.8"

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/src/bigqmt_signal_trader/adapters/order_bigqmt.py

@@ -5,6 +5,8 @@ The passorder signature follows src/api/qmt_jq_trade.
 
 import hashlib
 
+from xtquant import xtconstant as _xtconstant
+
 from ..code_utils import normalize_stock_code
 from ..exec_events import date_time_seconds
 from ..models import CancelResult, OrderSnapshot, OrderSubmitResult, SignalAction, TradeSnapshot
@@ -21,6 +23,75 @@ PRICE_TYPE_ALIASES = {
 }
 
 
+# MiniQMT's order_type (xtconstant) and passorder's opType are two different
+# numberings. They agree on 27-32 and diverge on the special-margin family:
+#
+#   meaning            xtconstant           passorder opType (API ref 10.1)
+#   融资买入 .. 直接还款   27-32                27-32      same
+#   担保品买入 / 卖出      -- (CREDIT_BUY/SELL)  33 / 34
+#   专项两融              40-45                70-75      DIFFERENT
+#
+# Sending 40 through unchanged would reach passorder as "期货组合开多", so the
+# translation is not optional. Values are taken from xtconstant by NAME: PR #88
+# asserted them as literals and encoded the same mistake in its tests, which is
+# why they passed while the mapping was wrong.
+_XC = _xtconstant
+
+CREDIT_OPTYPE_BY_ORDER_TYPE = {
+    _XC.CREDIT_FIN_BUY: 27,                    # 融资买入
+    _XC.CREDIT_SLO_SELL: 28,                   # 融券卖出
+    _XC.CREDIT_BUY_SECU_REPAY: 29,             # 买券还券
+    _XC.CREDIT_DIRECT_SECU_REPAY: 30,          # 直接还券
+    _XC.CREDIT_SELL_SECU_REPAY: 31,            # 卖券还款
+    _XC.CREDIT_DIRECT_CASH_REPAY: 32,          # 直接还款
+    _XC.CREDIT_FIN_BUY_SPECIAL: 70,            # 专项融资买入
+    _XC.CREDIT_SLO_SELL_SPECIAL: 71,           # 专项融券卖出
+    _XC.CREDIT_BUY_SECU_REPAY_SPECIAL: 72,     # 专项买券还券
+    _XC.CREDIT_DIRECT_SECU_REPAY_SPECIAL: 73,  # 专项直接还券
+    _XC.CREDIT_SELL_SECU_REPAY_SPECIAL: 74,    # 专项卖券还款
+    _XC.CREDIT_DIRECT_CASH_REPAY_SPECIAL: 75,  # 专项直接还款
+}
+
+# Which side of the book each one is, for bookkeeping only -- the opType above
+# is what actually goes to passorder. Repayment operations that move securities
+# are classified by what they do to the holding.
+_CREDIT_BUY_SIDE = frozenset({
+    _XC.CREDIT_FIN_BUY, _XC.CREDIT_BUY_SECU_REPAY,
+    _XC.CREDIT_FIN_BUY_SPECIAL, _XC.CREDIT_BUY_SECU_REPAY_SPECIAL,
+})
+_CREDIT_SELL_SIDE = frozenset({
+    _XC.CREDIT_SLO_SELL, _XC.CREDIT_SELL_SECU_REPAY,
+    _XC.CREDIT_DIRECT_SECU_REPAY,
+    _XC.CREDIT_SLO_SELL_SPECIAL, _XC.CREDIT_SELL_SECU_REPAY_SPECIAL,
+    _XC.CREDIT_DIRECT_SECU_REPAY_SPECIAL,
+})
+
+
+def credit_action_of(order_type):
+    """BUY / SELL for a credit order_type, or None if it is not one.
+
+    直接还款 (32 / 45) moves cash rather than securities, so it has no side;
+    callers must pass an action for it explicitly.
+    """
+    try:
+        value = int(order_type)
+    except (TypeError, ValueError):
+        return None
+    if value in _CREDIT_BUY_SIDE:
+        return SignalAction.BUY.value
+    if value in _CREDIT_SELL_SIDE:
+        return SignalAction.SELL.value
+    return None
+
+
+def credit_optype_of(order_type):
+    """passorder opType for a MiniQMT credit order_type, or None."""
+    try:
+        return CREDIT_OPTYPE_BY_ORDER_TYPE.get(int(order_type))
+    except (TypeError, ValueError):
+        return None
+
+
 def _action_from_offset_flag(offset_flag):
     return SignalAction.BUY.value if int(offset_flag or 0) == 48 else SignalAction.SELL.value
 
@@ -166,7 +237,14 @@ class BigQmtOrderGateway:
     def submit(self, request):
         passorder = self._require_passorder()
         action = str(request.action).upper()
-        if action == SignalAction.BUY.value:
+        credit_optype = credit_optype_of(getattr(request, "order_type", None))
+        if credit_optype is not None:
+            # A credit operation carries more than a side: mapping it back to
+            # BUY/SELL would turn 融资买入 into an ordinary buy, which is the
+            # bug behind issue #103 -- worse than the rejection it replaced,
+            # because it places a real but different order.
+            op_type = credit_optype
+        elif action == SignalAction.BUY.value:
             op_type = 23
         elif action == SignalAction.SELL.value:
             op_type = 24

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/src/bigqmt_signal_trader/models.py

@@ -329,7 +329,12 @@ class OrderRequest:
         price_type,
         strategy_name,
         remark="",
+        order_type=None,
     ):
+        # MiniQMT-style order_type (xtconstant). Only set for operations a
+        # BUY/SELL action cannot express -- credit financing, repayment and the
+        # special-margin family. None means an ordinary stock order.
+        self.order_type = order_type
         self.signal_id = signal_id
         self.account_id = account_id
         self.action = action

xtquant_big_convert-0.3.2/src/bigqmt_signal_trader/order_id.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+"""An order id that is an int for MiniQMT and a string for the broker.
+
+MiniQMT's ``order_stock`` returns an int: a positive 委托编号, or ``-1`` when the
+submit failed. Big QMT has no such number -- ``get_trade_detail_data`` hands
+back ``m_strOrderSysID``, the broker's 合同编号, which is a string. This bridge
+was returning that string straight through (issue #113), so every caller
+written against MiniQMT broke, and broke quietly:
+
+    order_id = trader.order_stock(...)
+    if order_id == -1:      # never true: "-1" != -1, so a rejected order
+        ...                 # reads as success
+    if order_id > 0:        # TypeError: '>' not supported between str and int
+
+``OrderId`` is both. It *is* an int, so comparisons, ``isinstance`` and
+arithmetic behave the way MiniQMT callers expect; and it carries the exact
+broker string on ``.order_sys_id``, so a cancel sends back what QMT issued
+rather than a number we invented -- including ids that are not numeric at all.
+
+Where the 合同编号 is a plain positive integer (the usual case) the int value is
+that same number and the two representations agree exactly. Where it is not,
+the int is a stable surrogate derived from the string: still positive, so
+``> 0`` keeps separating success from failure, while ``str()`` and the cancel
+path use the real id.
+"""
+
+import zlib
+
+
+# Positive and comfortably inside 32 bits, so the value survives a trip through
+# JSON, a database column, or anything else that is unhappy with big integers.
+_SURROGATE_MASK = 0x3FFFFFFF
+
+_DIGITS = frozenset("0123456789")
+
+
+def _is_ascii_digits(text):
+    # str.isdigit() is True for '１２３' and other unicode digit forms, which
+    # int() then happily parses into something the broker never issued.
+    return bool(text) and all(char in _DIGITS for char in text)
+
+
+def int_value_of(order_sys_id):
+    """The int an ``OrderId`` for this 合同编号 should carry.
+
+    Returns 0 for an empty id -- there is no order, so there is no number.
+    """
+    text = ("" if order_sys_id is None else str(order_sys_id)).strip()
+    if not text:
+        return 0
+    if _is_ascii_digits(text):
+        value = int(text)
+        if value > 0:
+            return value
+    # Alphanumeric 合同编号, or a leading-zero form whose int would not round
+    # trip. Derive a stable surrogate instead of guessing a number: same string
+    # gives the same value in any process, so a caller comparing ids across a
+    # restart still matches. `or 1` keeps it strictly positive.
+    return (zlib.crc32(text.encode("utf-8")) & _SURROGATE_MASK) or 1
+
+
+class OrderId(int):
+    """``int(order_id)`` for MiniQMT, ``str(order_id)`` for the broker."""
+
+    # No __slots__: CPython rejects a nonempty __slots__ on an int subclass
+    # (variable-length builtin), so the instance carries an ordinary __dict__.
+
+    def __new__(cls, order_sys_id, value=None):
+        text = "" if order_sys_id is None else str(order_sys_id)
+        if value is None:
+            value = int_value_of(text)
+        obj = int.__new__(cls, value)
+        obj.order_sys_id = text
+        return obj
+
+    def __str__(self):
+        # int.__str__ is object.__str__ on py3, which routes back through the
+        # __repr__ below; int.__repr__ is the one that prints the number.
+        return self.order_sys_id or int.__repr__(self)
+
+    def __format__(self, spec):
+        # "{}".format(oid) and f"{oid}" go through __format__, not __str__, and
+        # int.__format__ with an empty spec would print the surrogate. Anything
+        # with an actual spec ("%05d"-style) is asking for the number.
+        if not spec:
+            return self.__str__()
+        return int.__format__(self, spec)
+
+    def __repr__(self):
+        return "OrderId(%r, %d)" % (self.order_sys_id, int(self))
+
+
+def order_sys_id_of(value):
+    """Best available broker string for something a caller handed back.
+
+    Accepts an ``OrderId``, a bare string, or the int a caller round-tripped
+    through JSON and lost the string half of.
+    """
+    carried = getattr(value, "order_sys_id", None)
+    if carried:
+        return str(carried)
+    if value is None:
+        return ""
+    return str(value)

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/src/bigqmt_signal_trader/qmt_launcher.py

@@ -159,6 +159,26 @@ def is_qmt_running(install_dir):
     return bool(find_qmt_processes(install_dir))
 
 
+def session_is_locked():
+    """True when the interactive session is at the Windows lock screen.
+
+    Login automation is impossible while locked (physical input lands on the
+    lock screen), so callers can check before closing a running terminal.
+    Heuristic: the foreground window is the lock screen's CoreWindow.
+    """
+    try:
+        import ctypes
+
+        import win32gui
+
+        hwnd = ctypes.windll.user32.GetForegroundWindow()
+        title = win32gui.GetWindowText(hwnd) or ""
+        cls = win32gui.GetClassName(hwnd)
+        return cls == "Windows.UI.Core.CoreWindow" and "锁屏" in title
+    except Exception:
+        return False
+
+
 # ------------------------------------------------------------------ readiness
 def port_is_listening(port=DEFAULT_READY_PORT, host="127.0.0.1", timeout=1.0):
     sock = socket.socket()
@@ -487,6 +507,13 @@ def restart_qmt(install_dir, settle_seconds=5.0, **open_kwargs):
     after the process dies, and the ZMQ transport binds its configured port
     exactly (no scanning), so restarting too eagerly fails the rebind.
     """
+    mode = str(open_kwargs.get("mode") or "auto")
+    if mode in ("login", "auto") and session_is_locked():
+        raise QmtLauncherError(
+            "interactive session is locked; the login dialog cannot be automated "
+            "now. Unlock the session first, or restart without closing "
+            "(the terminal would sit at the login dialog with trading down)."
+        )
     closed = close_qmt(install_dir)
     if closed:
         time.sleep(settle_seconds)

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/src/bigqmt_signal_trader/redis_rpc.py

@@ -32,6 +32,7 @@ RPC_REVISION = "20260715-execution-snapshot-v1"
 READ_METHODS = {
     "ping",
     "get_deployment_info",
+    "probe_capabilities",
     "get_ticks",
     "get_instrument",
     "get_instrument_type",
@@ -340,6 +341,29 @@ def to_jsonable(value):
             }
         except Exception:
             return str(value)
+    # pandas Panel (3-D). QMT ships pandas 0.22, where get_financial_data with
+    # several stocks AND several dates still returns one. A Panel has no
+    # .columns and no .index, so it falls past the DataFrame and Series
+    # branches all the way to the __dict__ fallback -- and vars(panel) is
+    # {'_data': ..., 'is_copy': None}, which the underscore filter reduces to
+    # {'is_copy': None}. That is exactly what callers got back (issue #115):
+    # not an error, just the one public attribute the object happened to have.
+    #
+    # pandas removed Panel in 1.0, so the client cannot rebuild one even if we
+    # sent the axes. Send a DataFrame per item instead; it arrives as a dict.
+    if (hasattr(value, "major_axis") and hasattr(value, "minor_axis")
+            and hasattr(value, "items") and not isinstance(value, dict)):
+        try:
+            labels = [str(item) for item in value.items]
+            return {
+                "__bigqmt_type__": "Panel",
+                "items": labels,
+                "major_axis": [str(item) for item in value.major_axis],
+                "minor_axis": [str(item) for item in value.minor_axis],
+                "data": {str(item): to_jsonable(value[item]) for item in value.items},
+            }
+        except Exception:
+            return str(value)
     if hasattr(value, "tolist") and not isinstance(value, (str, bytes, bytearray)):
         try:
             return to_jsonable(value.tolist())
@@ -527,6 +551,67 @@ class BigQmtRpcHandlers:
             pass
         return info
 
+    # probe 时检查的关键 QMT 运行时全局函数（存在与否决定对应能力可用性）。
+    _PROBE_QMT_GLOBALS = (
+        "passorder", "cancel", "get_trade_detail_data",
+        "download_history_data", "download_history_data2", "down_history_data",
+        "get_history_trade_detail_data", "get_value_by_order_id", "get_last_order_id",
+        "get_ipo_data", "get_new_purchase_limit",
+        "get_assure_contract", "get_enable_short_contract",
+        "get_unclosed_compacts", "get_closed_compacts", "get_debt_contract",
+        "get_option_subject_position", "get_comb_option", "get_hkt_exchange_rate",
+    )
+
+    # probe 时抽查的 ContextInfo 方法。
+    _PROBE_CONTEXT_METHODS = (
+        "get_full_tick", "get_market_data_ex", "get_market_data", "get_local_data",
+        "subscribe_quote", "subscribe_whole_quote", "unsubscribe_quote",
+        "get_trading_dates", "get_financial_data", "get_stock_list_in_sector",
+        "do_back_test", "get_trade_detail_data",
+    )
+
+    def _handle_probe_capabilities(self, params):
+        """只读能力探测：当前部署暴露了哪些 QMT callable。
+
+        部署后跑一次就能回答「这台券商 QMT 缺什么」——只读调用，不触发任何
+        委托。返回三部分：运行时全局函数绑定情况、ContextInfo 方法存在性、
+        信用接口只读探测（调用一次看是否报错/返回行数）。
+        """
+        info = {
+            "account_id": self.account_id,
+            "allow_order_methods": self.allow_order_methods,
+            "settle_orders_inline": self.settle_orders_inline,
+            "order_settle_timeout_seconds": self.order_settle_timeout_seconds,
+            "qmt_globals": {},
+            "contextinfo_methods": {},
+            "credit_probe": {},
+            "server_time": _dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+        for name in self._PROBE_QMT_GLOBALS:
+            info["qmt_globals"][name] = callable(self.qmt_api.get(name))
+        context_info = getattr(self.market_data, "context_info", None)
+        for name in self._PROBE_CONTEXT_METHODS:
+            info["contextinfo_methods"][name] = callable(getattr(context_info, name, None))
+        # 信用接口只读探测：不存在的全局直接标 unavailable；存在的真调一次，
+        # 记录是否报错和返回行数（担保品/融券标的可能很多行，只计数）。
+        for name in ("get_assure_contract", "get_enable_short_contract",
+                     "get_unclosed_compacts", "get_debt_contract"):
+            func = self.qmt_api.get(name)
+            if not callable(func):
+                info["credit_probe"][name] = {"available": False}
+                continue
+            try:
+                rows = func(self.account_id) or []
+                info["credit_probe"][name] = {
+                    "available": True, "ok": True, "rows": len(rows),
+                }
+            except Exception as exc:
+                info["credit_probe"][name] = {
+                    "available": True, "ok": False,
+                    "error": "%s: %s" % (exc.__class__.__name__, exc),
+                }
+        return info
+
     # ------------------------------------------------------------------
     # 全推行情订阅控制（引用计数共享 ContextInfo.subscribe_whole_quote）。
     # 数据本身走推送通道；这里只负责订阅生命周期 + 心跳。
@@ -996,13 +1081,29 @@ class BigQmtRpcHandlers:
         action = str(params.get("action") or "").upper()
         if action:
             return action
-        order_type = str(params.get("order_type") or "").upper()
+        raw = params.get("order_type")
+        order_type = str(raw or "").upper()
         if order_type in BUY_ORDER_TYPES:
             return "BUY"
         if order_type in SELL_ORDER_TYPES:
             return "SELL"
+        # Credit operations carry their side in the type itself (issue #103).
+        # 直接还款 moves cash rather than securities and has no side, so it
+        # still needs an explicit action rather than being guessed at.
+        credit = _credit_action_of(raw)
+        if credit:
+            return credit
+        if _credit_optype_of(raw) is not None:
+            raise ValueError(
+                "order_type %s has no implicit buy/sell side; pass action "
+                "explicitly" % raw)
         raise ValueError("action or order_type is required")
 
+    def _credit_order_type_from_params(self, params):
+        """The MiniQMT order_type to forward, when it is a credit operation."""
+        raw = params.get("order_type")
+        return raw if _credit_optype_of(raw) is not None else None
+
     def _handle_submit_order(self, params):
         if self.order_gateway is None:
             raise RuntimeError("order_gateway is not configured")
@@ -1021,6 +1122,7 @@ class BigQmtRpcHandlers:
             price_type=params.get("price_type") or "LIMIT",
             strategy_name=str(params.get("strategy_name") or "bigqmt_rpc"),
             remark=order_tag,
+            order_type=self._credit_order_type_from_params(params),
         )
         if request.action not in ("BUY", "SELL"):
             raise ValueError("action must be BUY or SELL")
@@ -1262,6 +1364,24 @@ def _bool_value(value, default=False):
     return str(value).strip().lower() in ("1", "true", "yes", "y", "on")
 
 
+def _credit_action_of(order_type):
+    try:
+        from bigqmt_signal_trader.adapters.order_bigqmt import credit_action_of
+
+        return credit_action_of(order_type)
+    except Exception:
+        return None
+
+
+def _credit_optype_of(order_type):
+    try:
+        from bigqmt_signal_trader.adapters.order_bigqmt import credit_optype_of
+
+        return credit_optype_of(order_type)
+    except Exception:
+        return None
+
+
 def _deployed_version():
     """Version of the bridge actually running here, or "" if unknown."""
     try:

{xtquant_big_convert-0.3.0 → xtquant_big_convert-0.3.2}/src/bigqmt_signal_trader/version.py

@@ -21,7 +21,7 @@ copy never happened" and "the copy landed but was not picked up" look identical
 from the outside.
 """
 
-__version__ = "0.2.16"
+__version__ = "0.3.2"
 
 
 def deployment_report(package_dir=None):