cfquant 0.2.47__tar.gz → 0.2.49__tar.gz

{cfquant-0.2.47 → cfquant-0.2.49}/PKG-INFO

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

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant/qmt_strategy_deploy.py

@@ -23,7 +23,10 @@ MODE_ALIASES = {
     "ctypes": "ctypes", "pipe": "ctypes", "named_pipe": "ctypes",
     "lite": "lite", "extreme": "lite", "extreme_lite": "lite",
     "lite_extreme": "lite", "ultimate": "lite",
+    "lite_extreme_pipe": "lite", "extreme_pipe": "lite", "cfquant_lite": "lite",
+    "named-pipe": "ctypes", "universal": "ctypes", "universal_ctypes": "ctypes",
     "lttx": "lttx", "socket": "lttx", "normal": "lttx",
+    "default": "lttx",
 }
 LEGACY_NAMES = {Path(name).stem for name in SCRIPTS.values()} | {"CFQUANT_TRADE_LOWLAT"}
 LEGACY_NAMES |= {name + "_" + market for name in tuple(LEGACY_NAMES) for market in ("SH", "SZ")}
@@ -68,9 +71,42 @@ def normalize_strategy_mode(value):
         return MODE_ALIASES[mode]
     except KeyError:
         raise ValueError("unknown QMT strategy mode: %s" % mode)
-
-
-def qmt_root(directory, validate=False):
+
+
+def entry_script_for_mode(mode, role="normal", market=""):
+    """One mapping for raw copies and the packages QMT actually imports."""
+    mode = normalize_strategy_mode(mode)
+    market = str(market or "").strip().upper()
+    if market and market not in ("SH", "SZ"):
+        raise ValueError("unknown QMT entry market: %s" % market)
+    filename = SCRIPTS[mode]
+    if mode == "lttx" and (role != "normal" or market):
+        filename = "CFQUANT_TRADE_LOWLAT.py"
+    if market:
+        return "同账号独立市场/%s_%s.py" % (Path(filename).stem, market)
+    return filename
+
+
+def read_entry_source(path):
+    """Reject a generic entry accidentally saved under a Lite filename."""
+    path = Path(path)
+    with tokenize.open(str(path)) as stream:
+        source = stream.read()
+    if path.stem.startswith("CFQUANT_LITE"):
+        tree = ast.parse(source)
+        constants = {target.id for node in tree.body if isinstance(node, ast.Assign)
+                     for target in node.targets if isinstance(target, ast.Name)}
+        imports_core = any(
+            (isinstance(node, ast.ImportFrom) and (node.module or "").split(".")[0] == "cfquant")
+            or (isinstance(node, ast.Import) and any(alias.name.split(".")[0] == "cfquant"
+                                                    for alias in node.names))
+            for node in ast.walk(tree))
+        if "LITE_ENTRY_VERSION" not in constants or imports_core:
+            raise ValueError("极致模式入口内容不匹配，拒绝部署通用模式代码: %s" % path)
+    return source
+
+
+def qmt_root(directory, validate=False):
     path = Path(str(directory)).expanduser().resolve()
     if path.name.lower() in ("bin.x64", "bin", "python"):
         path = path.parent
@@ -283,9 +319,8 @@ def _resolve_account_binding(root, document, account_id, account_type, supplied=
     return None
 
 
-def managed_source(source_path, identity_path, identity, descriptor):
-    with tokenize.open(str(source_path)) as stream:
-        source = stream.read()
+def managed_source(source_path, identity_path, identity, descriptor):
+    source = read_entry_source(source_path)
     lines = source.splitlines(keepends=True)
     tree = ast.parse(source)
     replacements = []
@@ -308,13 +343,23 @@ def managed_source(source_path, identity_path, identity, descriptor):
     for start, end, text in sorted(replacements, reverse=True):
         lines[start:end] = [text]
     lines[0] = "# coding: utf-8\n"
-    source = "".join(lines)
-    ast.parse(source, feature_version=(3, 6))
-    helper = Path(__file__).with_name("qmt_strategy_runtime.py").read_text(encoding="utf-8")
-    generated = ("# coding: utf-8\n" + helper + "\n_cq_descriptor = " + ascii(descriptor)
-            + "\n_cq_guard = _CqStrategyLease(_cq_descriptor).acquire()\n"
-            + "_cq_guard.namespace = globals()\ntry:\n"
-            + "    exec(compile(%s, %s, 'exec'), globals())\n" % (ascii(source), ascii(str(source_path)))
+    source = "".join(lines)
+    ast.parse(source, feature_version=(3, 6))
+    helper = Path(__file__).with_name("qmt_strategy_runtime.py").read_text(encoding="utf-8")
+    source_lines = source.splitlines(keepends=True)
+    # Adjacent literals compile to the same source string, while keeping every
+    # entry line visible in QMT's editor. A single ascii(source) hid thousands
+    # of Lite lines behind the same short lease wrapper as the other modes.
+    embedded = "\n".join("        " + ascii(line) for line in source_lines)
+    header = ("# coding: utf-8\n# cfquant managed strategy\n"
+              + "# Mode: " + ascii(descriptor["mode"]) + "\n"
+              + "# Entry: " + ascii(Path(source_path).name) + "\n"
+              + "# Embedded entry: %d lines, preserved line by line below.\n" % len(source_lines)
+              + "# The lease wrapper is shared by all modes.\n\n")
+    generated = (header + helper + "\n_cq_descriptor = " + ascii(descriptor)
+            + "\n_cq_guard = _CqStrategyLease(_cq_descriptor).acquire()\n"
+            + "_cq_guard.namespace = globals()\ntry:\n"
+            + "    exec(compile((\n%s\n    ), %s, 'exec'), globals())\n" % (embedded, ascii(str(source_path)))
             + "    for _cq_name in ('_cf_bridge', '_normal_bridge', '_trade_bridge'):\n"
             + "        if globals().get(_cq_name) is not None:\n"
             + "            globals()[_cq_name].account_type = %s\n" % ascii(identity["account_type"])
@@ -373,13 +418,17 @@ class QmtStrategyManager:
             job.pop("deploy_retry_count", None)
             job.pop("deploy_retry_after", None)
 
-    def _clear_generation_transition(self, job):
-        changed = False
-        for key in ("control_generation", "accepted_generations"):
-            if key in job:
-                job.pop(key, None)
-                changed = True
-        return changed
+    def _clear_generation_transition(self, job):
+        changed = False
+        for key in ("control_generation", "accepted_generations"):
+            if key in job:
+                job.pop(key, None)
+                changed = True
+        for role in job.get("roles", []):
+            if "reimport_from_generation" in role:
+                role.pop("reimport_from_generation", None)
+                changed = True
+        return changed
 
     def _prepare_generation_transition(self, job, previous=None):
         """Keep old same-name containers valid until the replacement starts."""
@@ -432,19 +481,23 @@ class QmtStrategyManager:
         )
         job["control_generation"] = legacy
         job["accepted_generations"] = accepted
-        if previous is None:
-            for role in job.get("roles", []):
-                if _runtime_generation(role) == legacy:
-                    updates = {
-                        "reimport_required": True,
-                        "imported": False,
-                        "queued": False,
-                        "model_prepared": False,
-                    }
-                    for key, value in updates.items():
-                        if role.get(key) != value:
-                            role[key] = value
-                            changed = True
+        for role in job.get("roles", []):
+            if (_runtime_generation(role) == legacy
+                    and role.get("reimport_from_generation") != legacy):
+                # The old report survives QMT shutdown and import. Handle it
+                # once per replacement job, including across Web restarts;
+                # resetting every poll destroys the prepared/imported model.
+                updates = {
+                    "reimport_from_generation": legacy,
+                    "reimport_required": True,
+                    "imported": False,
+                    "queued": False,
+                    "model_prepared": False,
+                }
+                for key, value in updates.items():
+                    if role.get(key) != value:
+                        role[key] = value
+                        changed = True
         if changed and job.get("state") == "error":
             self._state(job, "waiting_exit")
         return changed
@@ -463,12 +516,13 @@ class QmtStrategyManager:
                 result.update(error=self.load_error, message=self.load_error)
             return result
 
-    def configure(self, row, identities, force=False):
+    def configure(self, row, identities, force=False, scripts_dir=None):
         if self.load_error:
             raise ValueError(self.load_error)
         settings = normalize_strategy_settings(row.get("qmt_strategy"))
         mode = normalize_strategy_mode(row.get("mode"))
-        enabled = row.get("enabled", True) and settings["enabled"]
+        enabled = row.get("enabled", True) and settings["enabled"]
+        scripts_dir = Path(scripts_dir) if scripts_dir is not None else self.scripts_dir
         with self.lock:
             wanted = set()
             grouped = {}
@@ -486,19 +540,16 @@ class QmtStrategyManager:
                                         "account_key": row["account_key"]}])
                     market = info.get("market") or identity.get("market") or ""
                     role = market or info.get("qmt_role") or "normal"
-                    filename = SCRIPTS[mode]
-                    if mode == "lttx" and role != "normal":
-                        filename = "CFQUANT_TRADE_LOWLAT.py"
-                    source_path = self.scripts_dir / filename
-                    if market:
-                        source_path = self.scripts_dir / "同账号独立市场" / (Path(filename).stem + "_" + market + ".py")
-                    if not source_path.is_file():
-                        raise ValueError("QMT 内置脚本不存在: %s" % source_path)
+                    filename = entry_script_for_mode(mode, role, market)
+                    source_path = scripts_dir / filename
+                    if not source_path.is_file():
+                        raise ValueError("QMT 内置脚本不存在: %s" % source_path)
+                    read_entry_source(source_path)
                     for key in ("updated_at", "updated_at_text"):
                         identity.pop(key, None)
                     group_key = _digest([os.path.normcase(str(root)), row["account_id"]])[:24]
                     grouped.setdefault(group_key, {"root": str(root), "roles": []})["roles"].append({
-                        "role": role, "source": str(source_path), "identity": identity,
+                        "role": role, "source": str(source_path), "entry_script": filename, "identity": identity,
                         "source_sha256": hashlib.sha256(source_path.read_bytes()).hexdigest(),
                         "account_key": settings["account_keys"].get(role, "")})
                 if not grouped:

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant/tests/15_/347/275/221/351/241/265/347/212/266/346/200/201/347/274/223/345/255/230/346/265/213/350/257/225.py

@@ -372,7 +372,7 @@ def test_auto_deploy_local_core_skips_when_target_matches(tmp_path):
 def test_local_entry_sync_overwrites_bound_qmt_python_script(tmp_path):
     source = tmp_path / "source"
     (source / "qmt_scripts").mkdir(parents=True)
-    (source / "qmt_scripts" / "CFQUANT_LITE.py").write_bytes(b"new-entry\n")
+    (source / "qmt_scripts" / "CFQUANT_LITE.py").write_bytes(b'LITE_ENTRY_VERSION = "test"\n')
     qmt_root = tmp_path / "QMT"
     (qmt_root / "bin.x64").mkdir(parents=True)
     (qmt_root / "python").mkdir()
@@ -389,7 +389,7 @@ def test_local_entry_sync_overwrites_bound_qmt_python_script(tmp_path):
     )
 
     assert result["updated"] is True
-    assert entry.read_bytes() == b"new-entry\n"
+    assert entry.read_bytes() == b'LITE_ENTRY_VERSION = "test"\n'
     assert result["entry_file"] == str(entry)
     assert result["backup"]
     assert (qmt_root / "bin.x64" / ".cfquant_updates" / "entry_backups").is_dir()
@@ -402,7 +402,7 @@ def test_auto_deploy_project_update_copies_bound_mode_entry(tmp_path, monkeypatc
     for name in ("__init__.py", "client.py", "protocol.py"):
         (source_core / name).write_text("# source\n", encoding="utf-8")
     (source / "qmt_scripts").mkdir()
-    (source / "qmt_scripts" / "CFQUANT_LITE.py").write_bytes(b"latest-lite\n")
+    (source / "qmt_scripts" / "CFQUANT_LITE.py").write_bytes(b'LITE_ENTRY_VERSION = "latest"\n')
 
     qmt_root = tmp_path / "QMT"
     target_core = qmt_root / "bin.x64" / "cfquant"
@@ -423,7 +423,7 @@ def test_auto_deploy_project_update_copies_bound_mode_entry(tmp_path, monkeypatc
 
     assert result["summary"]["ok"] is True
     assert result["summary"]["entry_updated_count"] == 1
-    assert (qmt_root / "python" / "CFQUANT_LITE.py").read_bytes() == b"latest-lite\n"
+    assert (qmt_root / "python" / "CFQUANT_LITE.py").read_bytes() == b'LITE_ENTRY_VERSION = "latest"\n'
     assert result["results"][0]["entry_script"] == "CFQUANT_LITE.py"
 
 

cfquant-0.2.49/cfquant/tests/test_lite_deployment_paths.py

@@ -0,0 +1,169 @@
+"""Verify the bytes copied and imported for Lite across binding/update paths."""
+
+import ast
+import json
+from pathlib import Path
+import shutil
+
+import pytest
+
+from cfquant.qmt_strategy_deploy import QmtStrategyManager
+from cfquant.qmt_strategy_package import _cipher
+from cfquant.tests.test_qmt_strategy_deploy import deployment, finish_import, models, SCRIPTS
+
+
+def embedded_source(package):
+    content = json.loads(_cipher().decrypt(package.read_bytes()).decode("utf-8", "surrogateescape"))["content"]
+    return next(node.args[0].value for node in ast.walk(ast.parse(content))
+                if isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+                and node.func.id == "compile" and isinstance(node.args[0], ast.Constant))
+
+
+def assert_lite_package(manager, root):
+    job = next(job for job in manager.jobs.values() if job.get("enabled"))
+    assert job["mode"] == "lite"
+    for role in job["roles"]:
+        source = embedded_source(root / "formulas" / (role["name"] + ".rzrk"))
+        assert "LITE_ENTRY_VERSION =" in source
+        assert "def account_route_client_ids(" in source
+        assert not any(isinstance(node, ast.ImportFrom) and (node.module or "").startswith("cfquant")
+                       for node in ast.walk(ast.parse(source)))
+        assert Path(role["source"]).name.startswith("CFQUANT_LITE")
+    return job
+
+
+@pytest.fixture
+def web_deployment(deployment, tmp_path, monkeypatch):
+    import cfquant_web_server as web
+    manager, row, infos, running, root = deployment
+    config = web.WebRuntimeConfig(str(tmp_path / "web.json"), str(tmp_path / "web.db"))
+    config._data["account_configs"] = {row["account_key"]: row}
+    monkeypatch.setattr(web, "WEB_CONFIG", config)
+    monkeypatch.setattr(web, "BASE_DIR", str(SCRIPTS.parent))
+    monkeypatch.setattr(web, "QMT_STRATEGIES", manager)
+    updater = web.CfquantUpdater(config)
+    monkeypatch.setattr(updater, "install_local_core_to_qmt_dir", lambda *args, **kwargs: {"skipped": True})
+    monkeypatch.setattr(web, "UPDATER", updater)
+    monkeypatch.setattr(web, "write_qmt_bridge_identity", lambda row: dict(infos[0]))
+    monkeypatch.setattr(web, "write_qmt_market_bridge_identities", lambda row: [])
+    monkeypatch.setattr(web, "sync_qmt_bridge_identities", lambda: [])
+    monkeypatch.setattr(web, "qmt_process_preflight", lambda **kwargs: None)
+    monkeypatch.setattr(web, "qmt_auto_login_apply_for_account", lambda *args, **kwargs: {})
+    monkeypatch.setattr(web, "ensure_account_runtime", lambda mode: {})
+    monkeypatch.setattr(web.ACCOUNT_CACHE, "prime_configured_accounts", lambda: None)
+    monkeypatch.setattr(web.STATUS_MONITOR, "wake", lambda: None)
+    monkeypatch.setattr(web.CALLBACKS, "refresh_channels", lambda channels: None)
+    return web, manager, row, infos, root
+
+
+@pytest.mark.parametrize("action", ["bind", "account_update", "project_update", "startup"])
+def test_selected_lite_replaces_imported_generic_code(action, web_deployment, monkeypatch):
+    web, manager, row, infos, root = web_deployment
+    manager.configure(row, infos)
+    finish_import(manager, root)
+    manager.process_once()
+    generic_name = next(iter(manager.jobs.values()))["roles"][0]["name"]
+    # Simulate an older installation with a Lite binding and a generic import.
+    row["mode"] = "lite"
+    if action == "bind":
+        result = web.save_account_runtime_config({
+            key: row[key] for key in ("account_id", "account_type", "bridge_id", "qmt_dir", "mode")})
+        assert result["account"]["mode"] == "lite"
+        assert not result["qmt_strategy_deploy"].get("error")
+    elif action == "account_update":
+        monkeypatch.setattr(web, "account_config_for_request", lambda body: row)
+        result = web.update_account_qmt_core({"account_key": row["account_key"]})
+        assert not result["qmt_strategy_deploy"].get("error")
+    elif action == "project_update":
+        result = web.auto_deploy_qmt_core_for_all_accounts(str(SCRIPTS.parent), sync_entry_scripts=True)
+        assert result["summary"]["ok"]
+    else:
+        # Persisted jobs must be repaired on first start after an old updater.
+        manager = QmtStrategyManager(manager.path, SCRIPTS, lambda root: False)
+        monkeypatch.setattr(web, "QMT_STRATEGIES", manager)
+        result = web.refresh_bound_qmt_strategies()
+        assert not result[0].get("error")
+    assert_lite_package(manager, root)
+    assert models(root)[generic_name].getAttribute("startupAutorun") == "0"
+    if action != "startup":
+        assert (root / "python" / "CFQUANT_LITE.py").read_bytes() == (SCRIPTS / "CFQUANT_LITE.py").read_bytes()
+
+
+def test_edit_without_mode_preserves_lite_binding_and_payload(web_deployment):
+    web, manager, row, _, root = web_deployment
+    row["mode"] = "lite"
+    result = web.save_account_runtime_config({
+        key: row[key] for key in ("account_id", "account_type", "bridge_id", "qmt_dir")})
+    assert result["account"]["mode"] == "lite"
+    assert_lite_package(manager, root)
+
+
+def test_edit_advanced_binding_to_lite_retires_both_advanced_models(web_deployment):
+    web, manager, row, infos, root = web_deployment
+    trade_root = root.with_name("QMT_trade")
+    shutil.copytree(root, trade_root)
+    row.update(mode="lttx", qmt_trade_dir=str(trade_root / "bin.x64"))
+    row["qmt_strategy"]["autorun"] = True
+    trade_info = dict(infos[0], qmt_role="trade", core_dir=str(trade_root / "bin.x64"),
+                      path=str(trade_root / "bin.x64" / "cfquant_bridge_config.json"))
+    manager.configure(row, infos + [trade_info])
+    advanced_name = "CFQ_%s_LTTX" % row["account_id"]
+    assert models(root)[advanced_name].getAttribute("startupAutorun") == "1"
+    assert models(trade_root)[advanced_name].getAttribute("startupAutorun") == "1"
+
+    body = {key: row[key] for key in ("account_id", "account_type", "bridge_id", "qmt_dir")}
+    result = web.save_account_runtime_config(dict(body, mode="lite", qmt_trade_dir=""))
+
+    assert result["account"]["mode"] == "lite"
+    assert result["account"]["qmt_trade_dir"] == ""
+    assert not result["qmt_strategy_deploy"].get("error")
+    job = assert_lite_package(manager, root)
+    assert job["roles"][0]["name"] == "CFQ_%s_LITE" % row["account_id"]
+    assert models(root)[job["roles"][0]["name"]].getAttribute("startupAutorun") == "1"
+    assert models(root)[advanced_name].getAttribute("startupAutorun") == "0"
+    assert models(trade_root)[advanced_name].getAttribute("startupAutorun") == "0"
+    trade_job = next(job for job in manager.jobs.values() if job["root"] == str(trade_root))
+    assert trade_job["enabled"] is False
+    assert trade_job["state"] == "disabled"
+
+
+@pytest.mark.parametrize("single_account", [False, True])
+def test_shared_qmt_directory_does_not_drop_lite_market_entries(single_account, web_deployment):
+    web, _, row, _, root = web_deployment
+    row.update(mode="lite", market_routing_enabled=True,
+               qmt_strategy={"enabled": False}, market_bridges={
+                   market: {"qmt_dir": str(root), "bridge_id": "bridge_" + market}
+                   for market in ("SH", "SZ")})
+    if single_account:
+        result = web.auto_deploy_qmt_core_for_account(row)
+    else:
+        # The earlier binding must not win solely because it shares a directory.
+        generic = dict(row, account_key="generic", account_id="222", mode="ctypes", market_routing_enabled=False)
+        web.WEB_CONFIG._data["account_configs"] = {"generic": generic, row["account_key"]: row}
+        result = web.auto_deploy_qmt_core_for_all_accounts(str(SCRIPTS.parent), sync_entry_scripts=True)
+    assert result["summary"]["ok"]
+    for name, directory in (("CFQUANT_LITE.py", SCRIPTS),
+                            ("CFQUANT_LITE_SH.py", SCRIPTS / "同账号独立市场"),
+                            ("CFQUANT_LITE_SZ.py", SCRIPTS / "同账号独立市场")):
+        assert (root / "python" / name).read_bytes() == (directory / name).read_bytes()
+
+
+def test_update_uses_new_source_and_rejects_mislabeled_generic_entry(web_deployment, tmp_path):
+    web, manager, row, _, root = web_deployment
+    row["mode"] = "lite"
+    source = tmp_path / "updated_project"
+    (source / "qmt_scripts").mkdir(parents=True)
+    entry = source / "qmt_scripts" / "CFQUANT_LITE.py"
+    entry.write_bytes((SCRIPTS / entry.name).read_bytes() + b'\nRELEASE_TEST_MARKER = "new-source"\n')
+    result = web.auto_deploy_qmt_core_for_all_accounts(str(source), sync_entry_scripts=True)
+    assert result["summary"]["ok"]
+    job = assert_lite_package(manager, root)
+    assert 'RELEASE_TEST_MARKER = "new-source"' in embedded_source(
+        root / "formulas" / (job["roles"][0]["name"] + ".rzrk"))
+    previous = (root / "python" / entry.name).read_bytes()
+    shutil.copyfile(SCRIPTS / "CFQUANT_CTYPE_ALL_LOWLAT.py", entry)
+    result = web.auto_deploy_qmt_core_for_all_accounts(str(source), sync_entry_scripts=True)
+    assert not result["summary"]["ok"]
+    assert result["summary"]["strategy_error_count"] == 1
+    assert "通用模式代码" in result["summary"]["message"]
+    assert (root / "python" / entry.name).read_bytes() == previous

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant/tests/test_qmt_strategy_deploy.py

@@ -15,6 +15,7 @@ from cfquant.qmt_strategy_deploy import (
     QmtStrategyManager, _account_binding, _atomic_write, _read_document,
     _write_json, _resolve_account_binding, account_qmt_roots, managed_source, normalize_strategy_settings,
     normalize_strategy_mode,
+    entry_script_for_mode, read_entry_source,
     _strategy_slot_name,
 )
 from cfquant.qmt_strategy_package import _cipher, build_package
@@ -31,6 +32,14 @@ def test_strategy_mode_aliases_are_canonical(value, expected):
     assert normalize_strategy_mode(value) == expected
 
 
+def test_lite_entry_mapping_rejects_generic_source(tmp_path):
+    assert entry_script_for_mode("extreme") == "CFQUANT_LITE.py"
+    source = tmp_path / "CFQUANT_LITE.py"
+    source.write_text("from cfquant import __version__\n", encoding="utf-8")
+    with pytest.raises(ValueError, match="通用模式代码"):
+        read_entry_source(source)
+
+
 def test_strategy_name_contains_mode_and_shortens_long_account():
     name = _strategy_slot_name("ACCOUNT-12345678901234567890", "lite")
     assert name == "CFQ_67890_LITE"
@@ -455,6 +464,8 @@ def test_all_managed_entry_variants_compile_without_executing(mode, deployment):
     assert document["detail"]["realName"] == role["name"] + ".py"
     assert document["formulaCatalog"][0].encode("utf-8", "surrogateescape").hex() == "ced2b5c4b2dfc2d4"
     ast.parse(document["content"], feature_version=(3, 6))
+    assert "# Mode: %r\n" % mode in document["content"]
+    assert "# Entry: %r\n" % Path(role["source"]).name in document["content"]
     if mode == "lite":
         embedded = [node.args[0].value for node in ast.walk(ast.parse(document["content"]))
                     if isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
@@ -468,6 +479,8 @@ def test_all_managed_entry_variants_compile_without_executing(mode, deployment):
                                     if isinstance(node, (ast.FunctionDef, ast.ClassDef))}
         assert definitions(actual) == definitions(original)
         assert len(embedded[0].splitlines()) > 7000
+        assert len(document["content"].splitlines()) > 7000
+        assert max(map(len, document["content"].splitlines())) < 2000
     descriptor = {"mode": mode, "generation": "test", "role": "SH", "control_path": "test", "lease_dir": "test"}
     variants = list((SCRIPTS / "同账号独立市场").glob("*.py")) + [SCRIPTS / "CFQUANT_TRADE_LOWLAT.py"]
     for path in variants:
@@ -513,6 +526,64 @@ def test_process_once_detects_stale_runtime_generation_and_queues_reimport(deplo
     assert (root / "formulas" / (role["name"] + ".rzrk")).is_file()
 
 
+@pytest.mark.parametrize("report_state", ["running", "stopped"])
+@pytest.mark.parametrize("previous_mode", ["lite", "lttx"])
+def test_old_runtime_report_does_not_reset_prepared_replacement(deployment, report_state, previous_mode):
+    manager, row, infos, running, root = deployment
+    row["mode"] = "lite"
+    manager.configure(row, infos)
+    finish_import(manager, root)
+    manager.process_once()
+    first = copy.deepcopy(next(iter(manager.jobs.values())))
+    _write_json(first["roles"][0]["runtime_status_path"], {
+        "state": report_state, "generation": first["generation"], "updated_at": time.time() - 120,
+    })
+    if previous_mode != "lite":
+        row["mode"] = previous_mode
+        manager.configure(row, infos)
+        finish_import(manager, root)
+        manager.process_once()
+
+    row["mode"] = "lite"
+    manager.configure(row, infos, force=True)
+    job = next(iter(manager.jobs.values()))
+    role = job["roles"][0]
+    queue = root / "formulas" / (role["name"] + ".rzrk")
+    assert queue.is_file()
+    assert role["model_prepared"] is True
+
+    # The old heartbeat remains on disk until QMT has imported and started
+    # the new strategy. Repeated polling or a Web restart must not undo it.
+    manager = QmtStrategyManager(manager.path, SCRIPTS, lambda root: running[0])
+    job = next(iter(manager.jobs.values()))
+    role = job["roles"][0]
+    running[0] = True
+    manager.process_once()
+    manager.process_once()
+    assert role["reimport_required"] is False
+    assert role["model_prepared"] is True
+    assert role["queued"] is True
+    assert job["state"] == "waiting_manual_start"
+
+    finish_import(manager, root)
+    container = root / "python" / (role["name"] + ".py")
+    running[0] = False
+    manager.process_once()
+    manager.process_once()
+    assert container.is_file()
+    assert not queue.exists()
+    assert role["imported"] is True
+    assert job["state"] == "configured"
+
+    _write_json(role["runtime_status_path"], {
+        "state": "running", "generation": job["generation"], "updated_at": time.time(),
+    })
+    running[0] = True
+    manager.process_once()
+    assert job["state"] == "running"
+    assert not job.get("control_generation")
+
+
 @pytest.mark.parametrize("encoding", ["utf-8", "gbk", "gb18030"])
 def test_managed_package_executes_after_qmt_encoding_with_chinese_paths(tmp_path, encoding):
     directory = tmp_path / "\u534e\u6cf0\u8bc1\u5238 QMT \u6a21\u62df"

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant/tests/test_qmt_strategy_web.py

@@ -282,8 +282,9 @@ def test_save_and_delete_call_deployment_manager(web_config, monkeypatch):
     class Manager:
         def reconcile(self, accounts):
             calls.append(("reconcile", set(accounts)))
-        def configure(self, row, identities, force=False):
+        def configure(self, row, identities, force=False, scripts_dir=None):
             assert force is True
+            assert scripts_dir == os.path.join(web.BASE_DIR, "qmt_scripts")
             calls.append(("configure", row["qmt_strategy"], identities))
             return {"enabled": True, "targets": [{"state": "waiting_exit"}]}
     monkeypatch.setattr(web, "QMT_STRATEGIES", Manager())
@@ -303,7 +304,7 @@ def test_save_and_delete_call_deployment_manager(web_config, monkeypatch):
     assert calls[-1] == ("reconcile", set())
 
 
-def test_save_can_start_qmt_auto_login_and_persist_restart_times(web_config, monkeypatch):
+def test_save_can_start_qmt_auto_login_and_persist_restart_times(web_config, monkeypatch, tmp_path):
     web, config = web_config
     calls = []
     monkeypatch.setattr(web, "auto_deploy_qmt_core_for_account", lambda *args, **kwargs: {})
@@ -324,7 +325,7 @@ def test_save_can_start_qmt_auto_login_and_persist_restart_times(web_config, mon
     data = web.save_account_runtime_config({
         "account_id": "8885060548",
         "display_name": "国金证券",
-        "qmt_dir": r"D:\国金证券QMT交易端\bin.x64",
+        "qmt_dir": str(tmp_path / "QMT" / "bin.x64"),
         "qmt_auto_login": {"enabled": True, "restart_times": ["6:30", "06:30", "18:05"]},
     })
     assert data["qmt_auto_login"]["pid"] == 1234

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant/version.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 """cfquant core version metadata."""
 
-__version__ = "0.2.47"
-WEB_VERSION = "web_20261011_01"
+__version__ = "0.2.49"
+WEB_VERSION = "web_20261012_01"

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant.egg-info/PKG-INFO

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

{cfquant-0.2.47 → cfquant-0.2.49}/cfquant.egg-info/SOURCES.txt

@@ -99,6 +99,7 @@ cfquant/tests/test_cftrader_web.py
 cfquant/tests/test_credit_compat.py
 cfquant/tests/test_json_serialization.py
 cfquant/tests/test_lite_account_routing.py
+cfquant/tests/test_lite_deployment_paths.py
 cfquant/tests/test_local_trading_calendar.py
 cfquant/tests/test_log_management.py
 cfquant/tests/test_management.py