cfquant 0.2.67__tar.gz → 0.2.70__tar.gz

{cfquant-0.2.67 → cfquant-0.2.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.67
+Version: 0.2.70
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/__init__.py

@@ -12,7 +12,7 @@ cfquant: 面向 QMT 的 xtquant 兼容层。
 import sys as _sys
 
 from . import xtconstant, xtdata, xttrader, xttype
-from . import cftrader
+from . import cftrader, notify
 from .qmt_inner import QmtInnerApi
 from .client import CfquantError, CfquantTimeout, configure, get_client
 from .version import __version__
@@ -28,6 +28,7 @@ __all__ = [
     "xtdata",
     "xttrader",
     "cftrader",
+    "notify",
     "QmtInnerApi",
     "xttype",
     "configure",

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/client.py

@@ -472,6 +472,8 @@ def configure(**kwargs):
     from .config import configure as configure_config
 
     configure_config(**kwargs)
+    from . import notify
+    notify.close()
     global _default_client
     with _client_lock:
         if _default_client is not None:

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/monitor_notifications.py

@@ -6,11 +6,9 @@ never perform SMTP or HTTP work on a QMT callback/status thread.
 """
 
 import copy
-import base64
 from datetime import datetime, timedelta, timezone
 from email.message import EmailMessage
 import hashlib
-import hmac
 import json
 import os
 from pathlib import Path
@@ -20,9 +18,7 @@ import ssl
 import tempfile
 import threading
 import time
-import urllib.error
-import urllib.parse
-import urllib.request
+from .webhook import send_webhook
 
 
 SHANGHAI = timezone(timedelta(hours=8))
@@ -566,28 +562,5 @@ class MonitorNotificationService:
                 server.send_message(msg)
 
     def _send_webhook(self, config, event):
-        url = str(config.get("url") or "").strip()
-        if not url:
-            raise ValueError("webhook url is required")
-        kind = str(config.get("type") or "generic").lower()
-        if kind == "dingtalk" and config.get("secret"):
-            timestamp = str(int(time.time() * 1000))
-            secret = str(config.get("secret"))
-            raw = "%s\n%s" % (timestamp, secret)
-            sign = base64.b64encode(hmac.new(secret.encode("utf-8"), raw.encode("utf-8"), hashlib.sha256).digest()).decode("ascii")
-            separator = "&" if "?" in url else "?"
-            url = "%s%stimestamp=%s&sign=%s" % (url, separator, urllib.parse.quote(timestamp), urllib.parse.quote(sign))
-        text = self._format_text(event)
-        if kind == "feishu":
-            body = {"msg_type": "text", "content": {"text": text}}
-        elif kind in ("dingtalk", "wecom"):
-            body = {"msgtype": "text", "text": {"content": text}}
-        else:
-            body = {"event_type": event.get("event_type"), "title": event.get("title"),
-                    "message": event.get("message"), "payload": event.get("payload"),
-                    "occurred_at": event.get("occurred_at")}
-        request = urllib.request.Request(url, data=json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"),
-                                         headers={"Content-Type": "application/json; charset=utf-8", "User-Agent": "cfquant-monitor"}, method="POST")
-        with urllib.request.urlopen(request, timeout=8) as response:
-            if int(getattr(response, "status", 200)) >= 400:
-                raise urllib.error.HTTPError(url, response.status, "webhook returned %s" % response.status, response.headers, None)
+        payload = {key: event.get(key) for key in ("event_type", "title", "message", "payload", "occurred_at")}
+        return send_webhook(config, self._format_text(event), payload=payload)

cfquant-0.2.70/cfquant/notify.py

@@ -0,0 +1,52 @@
+"""User-authored messages: explicit Webhook first, otherwise account binding."""
+
+import atexit
+import threading
+
+from .webhook import WebhookError, normalize_webhook, send_webhook, validate_message
+
+_client = None
+_client_lock = threading.Lock()
+
+
+def close():
+    """Release the notification RPC connection; the next call reconnects."""
+    global _client
+    with _client_lock:
+        client, _client = _client, None
+    if client is not None:
+        client.close()
+
+
+atexit.register(close)
+
+
+def send(message, account_id=None, *, title="", webhook_url=None, provider=None,
+         secret=None, account_type=None, account_key=None, bridge_id=None, timeout=8):
+    """Send text synchronously; returns sent/provider/source, or raises on failure.
+
+    webhook_url and provider must be supplied together and override the binding
+    completely (including its secret). Account-based sends require cfquant Web
+    and LTtx, but do not require QMT to be online. No automatic retry is performed.
+    """
+    timeout = validate_message(message, title, timeout)
+    if webhook_url is not None or provider is not None or secret is not None:
+        if not webhook_url or not provider:
+            raise ValueError("调用时覆盖推送配置必须同时提供 webhook_url 和 provider")
+        config = normalize_webhook({"enabled": True, "url": webhook_url, "provider": provider, "secret": secret})
+        return dict(send_webhook(config, message, title=title, timeout=timeout), source="explicit")
+    if not str(account_id or "").strip() and not str(account_key or "").strip():
+        raise ValueError("请指定资金账号 account_id 或 account_key，或提供 webhook_url 和 provider")
+    params = {"message": message, "title": title, "timeout": timeout}
+    params.update({key: value for key, value in dict(account_id=account_id, account_type=account_type,
+        account_key=account_key, bridge_id=bridge_id).items() if value is not None})
+    global _client
+    with _client_lock:
+        if _client is None:
+            from .client import create_rpc_client
+            _client = create_rpc_client(transport="web_lttx")
+        client = _client
+    return client.request("cfquant.notify.send", params, timeout=timeout + 5)
+
+
+__all__ = ["send", "close", "WebhookError"]

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/qmt_bridge.py

@@ -1,6 +1,7 @@
 from .diagnostic_context import versioned_message
 # -*- coding: utf-8 -*-
 import os
+import gc
 import queue
 import sys
 import threading
@@ -516,47 +517,91 @@ class CfquantQmtBridge(object):
                 })
             raise NotImplementedError("当前QMT环境未提供download_history_data2")
 
-        def callback(data):
+        stock_list = params.get("stock_list", params.get("code_list", []))
+        if isinstance(stock_list, str):
+            stock_list = [item.strip() for item in stock_list.replace("，", ",").split(",") if item.strip()]
+        else:
+            stock_list = list(stock_list or [])
+        batches = self._history_download_batches(stock_list, params)
+        total = len(stock_list)
+        completed = 0
+
+        def callback(data, batch_offset=0, batch_index=0, batch_total=1):
             if callback_event and client_id:
+                payload = dict(data) if isinstance(data, dict) else {"message": str(data)}
+                batch_finished = payload.get("finished")
+                try:
+                    batch_finished = max(0, min(int(batch_finished), len(batches[batch_index])))
+                except (TypeError, ValueError, IndexError):
+                    batch_finished = 0
+                payload.update({
+                    "finished": min(total, batch_offset + batch_finished),
+                    "total": total,
+                    "batch_index": batch_index + 1,
+                    "batch_total": batch_total,
+                    "batch_finished": batch_finished,
+                    "batch_size": len(batches[batch_index]) if batch_index < len(batches) else 0,
+                })
                 self._send_event(
                     client_id,
                     callback_event,
-                    data,
+                    payload,
                     meta=self._download_event_meta(params, "history", "progress"),
                 )
 
-        callback_func = callback if callback_event else None
-        variants = []
-        incrementally = params.get("incrementally")
-        if incrementally is not None:
-            variants.append((
-                (
-                    params.get("stock_list", params.get("code_list", [])),
-                    params.get("period", "1d"),
-                    params.get("start_time", ""),
-                    params.get("end_time", ""),
-                    callback_func,
-                    incrementally,
-                ),
-                {},
-            ))
-        variants.append((
-            (
-                params.get("stock_list", params.get("code_list", [])),
-                params.get("period", "1d"),
-                params.get("start_time", ""),
-                params.get("end_time", ""),
-                callback_func,
-            ),
-            {},
-        ))
         if emit_lifecycle:
             self._send_download_event(client_id, params, "history", "submitted", {
                 "stage": "submitted",
                 "message": "history download request submitted",
+                "total": total,
+                "batch_total": len(batches),
+                "batch_size": self._history_download_batch_size(params),
             })
         try:
-            result = self._call_variants(func, variants)
+            incrementally = params.get("incrementally")
+            batch_total = len(batches)
+            for batch_index, batch in enumerate(batches):
+                batch_offset = completed
+                callback_func = (
+                    (lambda data, offset=batch_offset, index=batch_index:
+                     callback(data, offset, index, batch_total))
+                    if callback_event else None
+                )
+                variants = []
+                if incrementally is not None:
+                    variants.append((
+                        (
+                            batch,
+                            params.get("period", "1d"),
+                            params.get("start_time", ""),
+                            params.get("end_time", ""),
+                            callback_func,
+                            incrementally,
+                        ),
+                        {},
+                    ))
+                variants.append((
+                    (
+                        batch,
+                        params.get("period", "1d"),
+                        params.get("start_time", ""),
+                        params.get("end_time", ""),
+                        callback_func,
+                    ),
+                    {},
+                ))
+                self._call_variants(func, variants)
+                completed += len(batch)
+                if emit_lifecycle:
+                    self._send_download_event(client_id, params, "history", "batch_done", {
+                        "stage": "batch_done",
+                        "finished": completed,
+                        "total": total,
+                        "batch_index": batch_index + 1,
+                        "batch_total": batch_total,
+                        "batch_size": len(batch),
+                    })
+                gc.collect()
         except Exception as e:
             if emit_lifecycle:
                 self._send_download_event(client_id, params, "history", "error", {
@@ -567,9 +612,39 @@ class CfquantQmtBridge(object):
         if emit_lifecycle:
             self._send_download_event(client_id, params, "history", "request_done", {
                 "stage": "request_done",
-                "result": result,
+                "result": None,
+                "finished": completed,
+                "total": total,
             })
-        return result
+        return None
+
+    @staticmethod
+    def _history_download_batch_size(params):
+        params = params or {}
+        value = params.get("download_batch_size", params.get("batch_size"))
+        if value is None:
+            value = os.environ.get("CFQUANT_HISTORY_DOWNLOAD_BATCH_SIZE")
+        if value is None or str(value).strip() == "":
+            period = str(params.get("period") or "").lower()
+            if period == "tick":
+                return 20
+            if period == "1m":
+                return 50
+            if period.endswith("m") or period.endswith("h"):
+                return 100
+            return 200
+        try:
+            value = int(value)
+        except (TypeError, ValueError):
+            return 50
+        return max(1, value)
+
+    @classmethod
+    def _history_download_batches(cls, stock_list, params):
+        if not stock_list:
+            return [stock_list]
+        size = cls._history_download_batch_size(params)
+        return [stock_list[index:index + size] for index in range(0, len(stock_list), size)]
 
     def _get_instrument_detail(self, params):
         func = getattr(self.context, "get_instrument_detail")

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/qmt_python_runtime.py

@@ -593,7 +593,8 @@ class QmtPythonRuntime:
             time.sleep(0.25)
         raise QmtPythonRuntimeError("QMT did not start after runtime switch")
 
-    def validate_selection(self, runtime, *, account_id=None):
+    def validate_selection(self, runtime, *, account_id=None,
+                           allow_missing_account_config=False):
         runtime = _canonical_runtime(runtime)
         effective_account = account_id if account_id is not None else self.account_id
         binding = self.binding_status(account_id=effective_account)
@@ -603,6 +604,8 @@ class QmtPythonRuntime:
                 % (binding.get("qmt_version") or "unknown"))
         if effective_account:
             if not binding["config_exists"]:
+                if allow_missing_account_config and binding["state"] == "account_config_missing":
+                    return binding
                 raise QmtPythonRuntimeError("QMT account Config.xml not found: %s; log in to QMT first" % effective_account)
             text = Path(binding["config"]).read_text(encoding="utf-8")
             if not re.search(r'<python\b[^>]*\blibs_path="[^"]*"', text):
@@ -611,9 +614,19 @@ class QmtPythonRuntime:
 
     def download_and_switch(self, runtime="py312", *, restart=True, account_id=None,
                             progress_callback=None, cancel_event=None,
-                            restart_callback=None, reuse_installed=False):
+                            restart_callback=None, reuse_installed=False,
+                            allow_missing_account_config=False):
         runtime = _canonical_runtime(runtime)
-        binding = self.validate_selection(runtime, account_id=account_id)
+        binding = self.validate_selection(
+            runtime,
+            account_id=account_id,
+            allow_missing_account_config=allow_missing_account_config,
+        )
+        deferred_account_config = bool(
+            allow_missing_account_config
+            and (account_id or self.account_id)
+            and binding.get("state") == "account_config_missing"
+        )
         reuse = bool(reuse_installed and binding["runtimes"][runtime]["installed"])
         package, archive = None, None
         if reuse:
@@ -624,17 +637,30 @@ class QmtPythonRuntime:
                                     cancel_event=cancel_event)
         if cancel_event and cancel_event.is_set():
             raise QmtPythonRuntimeError("QMT Python runtime operation cancelled")
-        _callback(progress_callback, QmtPythonProgress(runtime, "activating", message="正在停止 QMT 并配置执行器"))
-        if restart and self._qmt_processes():
+        _callback(progress_callback, QmtPythonProgress(
+            runtime, "activating",
+            message=("正在停止 QMT 并安装运行库" if deferred_account_config
+                     else "正在停止 QMT 并配置执行器"),
+        ))
+        was_running = bool(self._qmt_processes())
+        if restart and was_running:
             self._stop_for_switch()
-        elif not restart and self._qmt_processes():
+        elif not restart and was_running:
             raise QmtPythonRuntimeError(
-                "QMT is running; set restart=True before activating a Python runtime")
+                "QMT is running; set restart=True before installing or activating a Python runtime")
         try:
             installed = self.inspect(runtime, refresh_remote=False) if reuse else self.install(runtime, package=package, progress_callback=progress_callback)
-            switched = self.switch_account(runtime, account_id=account_id) if (account_id or self.account_id) else None
+            switched = None if deferred_account_config else (
+                self.switch_account(runtime, account_id=account_id)
+                if (account_id or self.account_id) else None
+            )
         finally:
-            if restart:
+            # A managed Web binding can supply a bootstrap callback that starts
+            # QMT, waits for the first login to create Config.xml, and then
+            # performs the final runtime switch/restart.  Keep the standalone
+            # API's old safe behavior (leave a brand-new, unconfigured QMT
+            # stopped) when no callback was supplied.
+            if restart and (not deferred_account_config or was_running or restart_callback):
                 _callback(progress_callback, QmtPythonProgress(runtime, "restarting", message="正在重新启动 QMT"))
                 if restart_callback:
                     restarted = restart_callback()
@@ -646,7 +672,10 @@ class QmtPythonRuntime:
                 restarted = None
         return {"runtime": runtime, "package": package.as_dict() if package else None,
                 "archive": str(archive) if archive else None, "reused_installed": reuse,
-                "installed": installed, "switched": switched, "restarted": restarted}
+                "installed": installed, "switched": switched, "restarted": restarted,
+                "account_config_required": deferred_account_config,
+                "message": ("运行库已安装；请先在 QMT 登录此账号，再重新检测并应用执行器。"
+                             if deferred_account_config else "")}
 
     def _stop_for_switch(self):
         for process in self._qmt_processes():

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/qmt_strategy_deploy.py

@@ -82,7 +82,7 @@ STATES = {
     "waiting_start": "QMT 已启动，等待托管策略启动及通道连接",
     "waiting_manual_start": "QMT 已启动，自启未开启，请在模型交易中运行托管策略",
     "running": "托管策略已运行",
-    "waiting_account": "未找到此资金账号的 QMT 绑定键，请补充模型账号 Key",
+    "waiting_account": "等待 QMT 登录生成账号绑定键；首次登录后请正常退出 QMT，再重新启动以完成策略部署。仍无法识别时再补充模型账号 Key",
     "configured": "模型已配置，等待下次启动 QMT 生效",
     "disabled": "自动运行已关闭，托管策略已禁用",
     "error": "策略部署失败",
@@ -915,15 +915,16 @@ class QmtStrategyManager:
                 self._save()
 
     def prepare_for_start(self, directory):
-        """Finish this terminal's offline deployment before allowing launch."""
+        """Finish offline deployment, or allow login to supply a missing key."""
         root = qmt_root(directory)
+        waiting_account = []
         with self.lock:
             if self.load_error:
                 raise ValueError(self.load_error)
             jobs = [job for job in self.jobs.values()
                     if os.path.normcase(str(qmt_root(job["root"]))) == os.path.normcase(str(root))]
             if not jobs:
-                return
+                return {"waiting_account": waiting_account}
             if self.process_checker(root):
                 raise RuntimeError("QMT 尚未完全退出，无法完成启动前策略部署")
             try:
@@ -957,6 +958,12 @@ class QmtStrategyManager:
                         job["deploy_retry_after"] = time.time() + min(10.0, 2.0 * count)
                         self._state(job, "error", str(error))
                         raise
+                    if job.get("state") == "waiting_account":
+                        # QMT creates its account authorization on first login.
+                        # Do not fabricate a model key or make login depend on
+                        # the model that can only be prepared after that login.
+                        waiting_account.append(job["account_id"])
+                        continue
                     if (job.get("state") not in ("configured", "waiting_import", "disabled")
                             or (job.get("enabled") and any(
                                 not role.get("model_prepared") or role.get("reimport_required")
@@ -965,6 +972,7 @@ class QmtStrategyManager:
                                            (job.get("message") or job.get("state", "")))
             finally:
                 self._save()
+        return {"waiting_account": waiting_account}
 
     def _advance(self, job):
         root = qmt_root(job["root"])

{cfquant-0.2.67 → cfquant-0.2.70}/cfquant/tests/test_binding_python_runtime_browser.py

@@ -81,6 +81,15 @@ def test_selected_executor_is_applied_through_existing_job_until_restart_finishe
     expect(button).to_be_disabled()
     assert not page.locator("#bindingPythonRuntimeProgressBar").evaluate("node => node.classList.contains('is-done')")
     expect(page.locator("#bindingPythonRuntimeProgressMeta")).to_contain_text("等待切换")
+    for phase in ("extract", "activating", "restarting"):
+        page.evaluate("""phase => bindingPythonRuntimeProgressEvent({
+            meta: {job_id: state.bindingPythonRuntimeJobId, stage: phase},
+            data: {phase, percent: 0, eta: null}
+        })""", phase)
+        expect(page.locator("#bindingPythonRuntimeProgressMeta")).not_to_contain_text("0%")
+        expect(page.locator("#bindingPythonRuntimeProgressMeta")).not_to_contain_text("剩余约 0")
+        assert page.locator("#bindingPythonRuntimeProgressBar").evaluate("node => node.getBoundingClientRect().width > 0")
+        assert page.evaluate("!!state.bindingPythonRuntimeJobId")
     status["binding"].update(selected_runtime="py312", configured_runtime="py312", state="ready")
     status["binding"]["runtimes"]["py312"]["installed"] = True
     page.evaluate("""bindingPythonRuntimeProgressEvent({
@@ -95,6 +104,45 @@ def test_selected_executor_is_applied_through_existing_job_until_restart_finishe
     assert not errors
 
 
+def test_lost_job_record_releases_busy_state_without_claiming_success(page, frontend_url):
+    errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
+    page.route("**/api/qmt/python-runtime/download", lambda route: route.fulfill(json={"ok": True, "data": {"state": "queued"}}))
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(status=404, json={"ok": False, "error": "job not found"}))
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("!state.bindingPythonRuntimeJobId && state.bindingPythonRuntimeProgress?.meta?.stage === 'error'")
+    expect(page.locator("#bindingPythonRuntimeProgressText")).to_contain_text("记录已失效")
+    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_enabled()
+    assert not errors
+
+
+def test_save_rechecks_completed_runtime_job_even_without_progress_notification(page, frontend_url):
+    errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(json={
+        "ok": True, "data": {"state": "done", "result": {"account_config_required": True}}}))
+    saved = []
+    def save(route):
+        body = route.request.post_data_json
+        saved.append(body)
+        row = dict(body, account_key="TEST_ONLY|STOCK|test", bridge_id="test")
+        route.fulfill(json={"ok": True, "data": {
+            "account": row, "account_configs": {row["account_key"]: row}, "account_pairs": {},
+            "bridges": {"test": {"name": "Test"}}, "qmt_strategy_deploy": {"enabled": False},
+            "qmt_auto_login": {"enabled": False}}})
+    page.route("**/api/account-config", save)
+    page.locator("#bindingQmtAutoLogin").uncheck()
+    page.evaluate("""() => {
+        fillQmtStrategySettings('binding', {enabled: false});
+        state.bindingPythonRuntimeJobId = 'missed-done';
+        state.bindingPythonRuntimeJobContext = bindingPythonRuntimeContextKey();
+        state.bindingPythonRuntimeJobRuntime = 'py36';
+    }""")
+    page.locator('#bindingForm [type="submit"]').click()
+    expect(page.locator("#bindingDialogOverlay")).not_to_be_visible()
+    assert len(saved) == 1
+    assert not page.evaluate("state.bindingPythonRuntimeJobId")
+    assert not errors
+
+
 def test_directory_change_invalidates_options_and_discards_late_response(page, frontend_url):
     errors = open_runtime(page, frontend_url, runtime_status())
     pending = []
@@ -119,6 +167,38 @@ def test_missing_account_config_shows_capabilities_but_requires_login(page, fron
     errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
     expect(page.locator("#bindingPythonRuntimeSelect option")).to_have_count(2)
     page.locator("#bindingPythonRuntimeSelect").select_option("py312")
-    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_disabled()
-    expect(page.locator("#bindingPythonRuntimeChoiceHint")).to_contain_text("登录")
+    submitted = []
+    page.route("**/api/qmt/python-runtime/download", lambda route: (
+        submitted.append(route.request.post_data_json),
+        route.fulfill(json={"ok": True, "data": {"state": "queued"}})))
+    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_enabled()
+    expect(page.locator("#bindingPythonRuntimeChoiceHint")).to_contain_text("先下载")
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("state.bindingPythonRuntimeJobId")
+    assert submitted[0]["allow_missing_account_config"] is True
+    assert not errors
+
+
+@pytest.mark.parametrize("socket_throws", [False, True], ids=["socket-disconnected", "socket-unavailable"])
+def test_poll_completion_before_first_login_unlocks_binding(page, frontend_url, socket_throws):
+    status = runtime_status(config_exists=False)
+    errors = open_runtime(page, frontend_url, status)
+    submitted = []
+    page.route("**/api/qmt/python-runtime/download", lambda route: (
+        submitted.append(route.request.post_data_json),
+        route.fulfill(json={"ok": True, "data": {"state": "queued"}})))
+    # The last progress event is not a terminal event. HTTP state/result must
+    # recover completion even if the WebSocket notification never arrived.
+    page.route("**/api/qmt/python-runtime/jobs?*", lambda route: route.fulfill(json={
+        "ok": True, "data": {"state": "done", "progress": {"phase": "installed", "percent": 100},
+        "result": {"account_config_required": True, "restarted": None}}}))
+    if socket_throws:
+        page.evaluate("() => { window.WebSocket = function() { throw new Error('WebSocket unavailable'); }; }")
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("state.bindingPythonRuntimeJobId === '' && state.bindingPythonRuntimeProgress?.meta?.stage === 'done'")
+    assert len(submitted) == 1
+    assert page.evaluate("state.bindingPythonRuntimeDeferred")
+    assert not page.evaluate("state.bindingPythonRuntimeChoiceDirty")
+    expect(page.locator("#bindingPythonRuntimeProgressMeta")).to_contain_text("100%")
+    expect(page.locator("#bindingPythonRuntimeProgressText")).to_contain_text("登录")
     assert not errors