cfquant 0.2.47__tar.gz → 0.2.48__tar.gz

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

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

{cfquant-0.2.47 → cfquant-0.2.48}/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 = []
@@ -463,12 +498,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 +522,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.48}/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.48/cfquant/tests/test_lite_deployment_paths.py

@@ -0,0 +1,140 @@
+"""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)
+
+
+@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.48}/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"

{cfquant-0.2.47 → cfquant-0.2.48}/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())

{cfquant-0.2.47 → cfquant-0.2.48}/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.48"
+WEB_VERSION = "web_20261011_02"

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

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

{cfquant-0.2.47 → cfquant-0.2.48}/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