cfquant 0.2.68__tar.gz → 0.2.70__tar.gz

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

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

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

@@ -655,7 +655,12 @@ class QmtPythonRuntime:
                 if (account_id or self.account_id) else None
             )
         finally:
-            if restart and (not deferred_account_config or was_running):
+            # 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()

{cfquant-0.2.68 → 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.68 → 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 = []
@@ -129,3 +177,28 @@ def test_missing_account_config_shows_capabilities_but_requires_login(page, fron
     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

{cfquant-0.2.68 → cfquant-0.2.70}/cfquant/tests/test_qmt_auto_login_integration.py

@@ -8,6 +8,7 @@ from types import SimpleNamespace
 import pytest
 
 from cfquant.tests.test_qmt_strategy_web import web_config, login_credentials
+from cfquant.tests.test_qmt_strategy_deploy import deployment
 from cfquant.tests.test_management import service
 from cfquant.qmt_credentials import QmtCredentialStore
 from cfquant.trading_calendar import is_trading_day
@@ -286,6 +287,37 @@ def test_failed_offline_deployment_blocks_launch_and_login(web_config, monkeypat
     assert not result["started"] and not result["configured"]
 
 
+@pytest.mark.parametrize("auto_fill", [True, False])
+@pytest.mark.parametrize("restart", [True, False])
+def test_first_login_without_model_key_launches_and_reports_pending_deployment(
+        web_config, deployment, monkeypatch, tmp_path, auto_fill, restart):
+    web, _ = web_config
+    manager, row, infos, running, root = deployment
+    (root / "config" / "indexUserConfig.xml").write_text(
+        '<ICUserConfigFile><FormulaCatalog/><strategyTrade/></ICUserConfigFile>', encoding="utf-8")
+    manager.configure(row, infos)
+    row["qmt_auto_login"] = {"enabled": True, "auto_fill_credentials": auto_fill, "auto_update": True}
+    monkeypatch.setenv("CFQUANT_QMT_AUTO_START", "saved")
+    monkeypatch.setattr(web, "QMT_AUTO_LOGIN_STATE_FILE", str(tmp_path / "sessions.json"))
+    monkeypatch.setattr(web, "QMT_COMPONENT_JOBS", {})
+    monkeypatch.setattr(web, "QMT_STRATEGIES", manager)
+    paths = {"bin_dir": str(root / "bin.x64"), "exe_path": "fixture.exe"}
+    monkeypatch.setattr(web, "_qmt_auto_login_paths", lambda _: paths)
+    monkeypatch.setattr(web, "_qmt_component_login_preflight", lambda *a: None)
+    monkeypatch.setattr(web, "_qmt_auto_login_processes", lambda *a, **k: [])
+    monkeypatch.setattr(web, "_qmt_auto_login_stop_xtitclient", lambda *a, **k: {})
+    calls = []
+    monkeypatch.setattr(web, "_qmt_auto_login_start_xtitclient", lambda *a, **k: calls.append("start") or {"pid": 456})
+    monkeypatch.setattr(web, "_qmt_queue_component_login", lambda *a: calls.append("login"))
+    result = web.qmt_auto_login_apply_for_account(row, restart=restart)
+    assert result["configured"] and not result.get("error")
+    assert result["strategy_deploy_deferred"]
+    assert calls == ["start", "login"]
+    session = web._qmt_auto_login_saved_session(row)
+    assert session["strategy_deploy_deferred"] and not session["error"]
+    assert "首次登录" in session["message"]
+
+
 def test_worker_records_success_and_supplies_saved_password_only_on_request(web_config, monkeypatch, tmp_path):
     import cfquant.qmt_component_login as component
     web, config = web_config

{cfquant-0.2.68 → cfquant-0.2.70}/cfquant/tests/test_qmt_python_runtime.py

@@ -250,6 +250,36 @@ def test_missing_account_config_can_install_runtime_before_first_login(tmp_path,
     assert not (root / "userdata" / "users" / "55009948" / "Config.xml").exists()
 
 
+def test_missing_account_config_invokes_managed_restart_callback(tmp_path, monkeypatch):
+    root = tmp_path / "qmt"
+    (root / "bin.x64").mkdir(parents=True)
+    manager = QmtPythonRuntime(root, account_id="55009948")
+    archive = manager.download_dir / "Python36-managed-bootstrap.zip"
+    archive.parent.mkdir(parents=True)
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("python36.dll", "new-dll")
+        bundle.writestr("Lib/site.py", "# test")
+    package = _package("py36", archive)
+    monkeypatch.setattr(manager, "fetch_package", lambda runtime: package)
+    monkeypatch.setattr(manager, "download", lambda *args, **kwargs: archive)
+    monkeypatch.setattr(manager, "_qmt_processes", lambda: [])
+    calls = []
+
+    def restart_callback():
+        calls.append("restart")
+        return {"started": True, "bootstrap_completed": True}
+
+    result = manager.download_and_switch(
+        "py36", account_id="55009948", restart=True,
+        allow_missing_account_config=True, restart_callback=restart_callback,
+    )
+
+    assert calls == ["restart"]
+    assert result["account_config_required"] is True
+    assert result["restarted"]["bootstrap_completed"] is True
+    assert not (root / "userdata" / "users" / "55009948" / "Config.xml").exists()
+
+
 def test_runtime_status_without_account_still_exposes_capabilities(tmp_path, monkeypatch):
     import cfquant_web_server as web
     manager = runtime_fixture(tmp_path)
@@ -307,3 +337,112 @@ def test_runtime_job_rejects_unsupported_selection_before_scheduling(tmp_path, m
     with pytest.raises(QmtPythonRuntimeError, match="only supports"):
         web.start_qmt_python_runtime_job({"qmt_dir": str(manager.qmt_dir), "account_id": "TEST_ONLY", "runtime": "py312"})
     assert not jobs
+
+
+def test_runtime_job_completion_survives_notification_failure(tmp_path, monkeypatch):
+    import cfquant_web_server as web
+    manager = runtime_fixture(tmp_path)
+    jobs = {}
+    monkeypatch.setattr(web, "QMT_PYTHON_RUNTIME_JOBS", jobs)
+    monkeypatch.setattr(web.threading.Thread, "start", lambda self: None)
+    def unavailable(*args, **kwargs):
+        raise RuntimeError("callback transport unavailable")
+    monkeypatch.setattr(web, "emit_download_progress", unavailable)
+    result = {"account_config_required": True, "installed": {"installed": True}, "restarted": None}
+    def switch(self, runtime, **kwargs):
+        kwargs["progress_callback"]({"phase": "download", "percent": 50})
+        kwargs["progress_callback"]({"phase": "installed", "percent": 100})
+        return result
+    monkeypatch.setattr(QmtPythonRuntime, "download_and_switch", switch)
+    body = {"qmt_dir": str(manager.qmt_dir), "account_id": "TEST_ONLY", "runtime": "py36", "job_id": "notify-failure"}
+    web.start_qmt_python_runtime_job(body)
+    web._run_qmt_python_runtime_job(body["job_id"], body)
+    job = web._qmt_python_job_snapshot(body["job_id"])
+    assert job["state"] == "done"
+    assert job["result"] == result
+    assert job["progress"]["phase"] == "done"
+    assert job["progress"]["percent"] == 100
+
+
+def test_runtime_job_initialization_failure_is_terminal(tmp_path, monkeypatch):
+    import cfquant_web_server as web
+    manager = runtime_fixture(tmp_path)
+    monkeypatch.setattr(web, "QMT_PYTHON_RUNTIME_JOBS", {})
+    monkeypatch.setattr(web.threading.Thread, "start", lambda self: None)
+    monkeypatch.setattr(web, "emit_download_progress", lambda *a, **kw: None)
+    body = {"qmt_dir": str(manager.qmt_dir), "runtime": "py36", "job_id": "init-failure"}
+    web.start_qmt_python_runtime_job(body)
+    def invalid(_):
+        raise ValueError("QMT directory unavailable")
+    monkeypatch.setattr(web, "_qmt_python_runtime_row", invalid)
+    web._run_qmt_python_runtime_job(body["job_id"], body)
+    assert web._qmt_python_job_snapshot(body["job_id"])["state"] == "error"
+
+
+@pytest.mark.parametrize("restart_failed", [False, True])
+def test_runtime_job_uses_managed_restart_without_inline_login_or_bypassing_errors(tmp_path, monkeypatch, restart_failed):
+    from types import SimpleNamespace
+    import cfquant_web_server as web
+    manager = runtime_fixture(tmp_path)
+    row = {"account_id": "TEST_ONLY", "qmt_dir": str(manager.qmt_dir)}
+    monkeypatch.setattr(web, "WEB_CONFIG", SimpleNamespace(account_configs=lambda: {"test": row}))
+    monkeypatch.setattr(web, "QMT_PYTHON_RUNTIME_JOBS", {})
+    monkeypatch.setattr(web.threading.Thread, "start", lambda self: None)
+    monkeypatch.setattr(web, "emit_download_progress", lambda *a, **kw: None)
+    monkeypatch.setattr(QmtPythonRuntime, "_qmt_processes", lambda self: [])
+    monkeypatch.setattr(QmtPythonRuntime, "restart_qmt", lambda self: pytest.fail("must not bypass managed restart"))
+    restart = {"configured": False, "error": "deployment write failed"} if restart_failed else {
+        "configured": True, "pid": 456, "login_state": "logging_in"}
+    monkeypatch.setattr(web, "qmt_auto_login_restart_for_account", lambda *a, **kw: restart)
+    body = {"qmt_dir": str(manager.qmt_dir), "account_id": "TEST_ONLY", "runtime": "py36",
+            "reuse_installed": True, "restart": True, "job_id": "managed-restart"}
+    web.start_qmt_python_runtime_job(body)
+    web._run_qmt_python_runtime_job(body["job_id"], body)
+    job = web._qmt_python_job_snapshot(body["job_id"])
+    assert job["state"] == ("error" if restart_failed else "done")
+    if restart_failed:
+        assert "deployment write failed" in job["error"]
+    else:
+        assert job["result"]["restarted"] == restart
+    assert manager.binding_status()["state"] == "ready"
+
+
+def test_runtime_bootstrap_starts_stops_and_starts_managed_qmt(tmp_path, monkeypatch):
+    from types import SimpleNamespace
+    import cfquant_web_server as web
+
+    row = {
+        "account_key": "bootstrap-account",
+        "account_id": "55009948",
+        "qmt_dir": str(tmp_path / "qmt"),
+        "qmt_strategy": {"enabled": True},
+        "qmt_auto_login": {"enabled": True, "auto_fill_credentials": True},
+    }
+    manager = SimpleNamespace(
+        binding_status=lambda account_id=None: {"state": "account_config_missing"},
+        switch_account=lambda runtime, account_id=None: {"runtime": runtime, "account_id": account_id},
+    )
+    paths = {"bin_dir": str(tmp_path / "qmt" / "bin.x64"), "exe_path": "fixture.exe"}
+    monkeypatch.setattr(web, "_qmt_auto_login_paths", lambda _: paths)
+    monkeypatch.setattr(web, "_qmt_wait_for_runtime_bootstrap_login",
+                        lambda row, paths: {"login_succeeded": True, "login_state": "logged_in"})
+    monkeypatch.setattr(web, "_qmt_auto_login_stop_xtitclient",
+                        lambda *args, **kwargs: {"exit_confirmed": True})
+    calls = []
+
+    def restart(account_row, settings, reason):
+        calls.append(reason)
+        if reason.endswith("first"):
+            return {"configured": True, "pid": 101, "strategy_deploy_deferred": True}
+        return {"configured": True, "pid": 202, "strategy_deploy_deferred": False}
+
+    monkeypatch.setattr(web, "qmt_auto_login_restart_for_account", restart)
+    result = web._qmt_python_runtime_bootstrap_restart(
+        row, row["qmt_auto_login"], manager, "py36", row["account_id"],
+        body={"allow_missing_account_config": True},
+    )
+
+    assert calls == ["python-runtime-bootstrap-first", "python-runtime-bootstrap-final"]
+    assert result["bootstrap_completed"] is True
+    assert result["pid"] == 202
+    assert result["runtime_switch"]["runtime"] == "py36"

{cfquant-0.2.68 → cfquant-0.2.70}/cfquant/tests/test_qmt_strategy_deploy.py

@@ -488,6 +488,25 @@ def test_no_account_binding_is_never_fabricated(deployment):
         _account_binding(document, ACCOUNT, "STOCK", ACCOUNT_KEY)
 
 
+def test_first_login_can_start_and_next_start_prepares_real_binding(deployment):
+    manager, row, infos, running, root = deployment
+    config = root / "config" / "indexUserConfig.xml"
+    config.write_text('<ICUserConfigFile><FormulaCatalog/><strategyTrade/></ICUserConfigFile>', encoding="utf-8")
+    manager.configure(row, infos)
+    prepared = manager.prepare_for_start(root)
+    assert prepared["waiting_account"]
+    assert not models(root)
+    finish_import(manager, root)
+    auth = root / "userdata" / "users" / "test_user" / "authAndConfig.xml"
+    auth.parent.mkdir(parents=True)
+    auth.write_text('<TTAuthAndConfigFile><TTAlgoConfigFile><AccountAuth key="%s" strategys="1"/>'
+                    '</TTAlgoConfigFile></TTAuthAndConfigFile>' % ACCOUNT_KEY, encoding="utf-8")
+    assert not manager.prepare_for_start(root)["waiting_account"]
+    role = next(iter(manager.jobs.values()))["roles"][0]
+    assert role["model_prepared"]
+    assert models(root)[role["name"]].getAttribute("m_strAccountKey") == ACCOUNT_KEY
+
+
 def test_first_start_has_a_credit_model_even_without_an_existing_model(deployment):
     manager, row, infos, running, root = deployment
     config = root / "config" / "indexUserConfig.xml"

{cfquant-0.2.68 → cfquant-0.2.70}/cfquant/version.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 """cfquant core version metadata."""
 
-__version__ = "0.2.68"
-WEB_VERSION = "web_20261111_02"
+__version__ = "0.2.70"
+WEB_VERSION = "web_20261112_01"

{cfquant-0.2.68 → cfquant-0.2.70}/cfquant.egg-info/PKG-INFO

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