cfquant 0.2.70__tar.gz → 0.2.71__tar.gz

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

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

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

@@ -15,7 +15,9 @@ from __future__ import annotations
 from dataclasses import dataclass, asdict
 import configparser
 import hashlib
+import http.client
 import json
+import logging
 import os
 from pathlib import Path
 import re
@@ -26,6 +28,7 @@ import time
 from typing import Dict, Optional
 import urllib.error
 import urllib.request
+from urllib.parse import urlencode
 import zipfile
 
 
@@ -33,6 +36,16 @@ class QmtPythonRuntimeError(RuntimeError):
     """A download, validation, activation, or restart operation failed."""
 
 
+class _DownloadSourceError(QmtPythonRuntimeError):
+    """A remote failure that permits trying another copy of the same package."""
+
+
+class _NoMirrorRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        # Never forward the shared mirror key to a redirected host.
+        return None
+
+
 @dataclass(frozen=True)
 class QmtPythonPackage:
     runtime: str
@@ -41,6 +54,8 @@ class QmtPythonPackage:
     filename: str
     md5: str
     force_update: bool = False
+    sha256: str = ""
+    size: int = 0
 
     def as_dict(self):
         return asdict(self)
@@ -67,6 +82,10 @@ _RUNTIME_ALIASES = {"36": "py36", "3.6": "py36", "python36": "py36",
 _PY312_MIN_QMT_VERSION = (2, 1, 33, 0)
 _CONFIG_LOCKS: Dict[str, threading.RLock] = {}
 _CONFIG_LOCKS_GUARD = threading.Lock()
+_MIRROR_BASE = "https://cfquant.org/api/qmt/python-runtime/"
+_MIRROR_KEY_HEADER = "X-CFQuant-Runtime-Key"
+_MIRROR_KEY = "cfq-runtime-v1-4859bf5af16942e38b30f128bd540714"
+_LOG = logging.getLogger(__name__)
 
 
 def _canonical_runtime(runtime: str) -> str:
@@ -118,6 +137,10 @@ class QmtPythonRuntime:
         self.staging_dir = self.state_dir / "staging"
         self.backup_dir = self.state_dir / "backups"
         self._opener = opener or urllib.request.build_opener(urllib.request.ProxyHandler({}))
+        self._mirror_opener = opener or urllib.request.build_opener(
+            urllib.request.ProxyHandler({}), _NoMirrorRedirect())
+        self._mirror_cache = None
+        self._mirror_checked_at = float("-inf")
         self._lock = self._lock_for(str(self.bin_dir))
 
     @staticmethod
@@ -131,10 +154,50 @@ class QmtPythonRuntime:
 
     def _request(self, url, *, headers=None, timeout=None):
         request = urllib.request.Request(url, headers=headers or {}, method="GET")
-        return self._opener.open(request, timeout=timeout or self.timeout)
+        opener = self._mirror_opener if url.startswith(_MIRROR_BASE) else self._opener
+        return opener.open(request, timeout=timeout or self.timeout)
+
+    def _mirror_status(self):
+        if time.monotonic() - self._mirror_checked_at < 5:
+            return self._mirror_cache
+        self._mirror_checked_at = time.monotonic()
+        self._mirror_cache = None
+        try:
+            with self._request(_MIRROR_BASE + "status", headers={_MIRROR_KEY_HEADER: _MIRROR_KEY},
+                               timeout=min(self.timeout, 5)) as response:
+                data = json.loads(response.read(65537).decode("utf-8"))
+            if (not data.get("ok") or data.get("schema") != 1 or not isinstance(data.get("packages"), dict)
+                    or not isinstance(data.get("busy"), bool)):
+                raise ValueError("invalid mirror status")
+            self._mirror_cache = data
+        except (OSError, ValueError, AttributeError, http.client.HTTPException) as exc:
+            _LOG.info("QMT runtime mirror status unavailable: %s", exc)
+        return self._mirror_cache
+
+    @staticmethod
+    def _package_from_mirror(data, runtime):
+        try:
+            item = data["packages"][runtime]
+            if (not re.fullmatch(r"[A-Za-z0-9_.-]+\.zip", item["filename"])
+                    or not re.fullmatch(r"[0-9a-f]{32}", item["md5"])
+                    or not re.fullmatch(r"[0-9a-f]{64}", item["sha256"])
+                    or not item["url"].startswith(("http://", "https://"))
+                    or int(item["size"]) <= 0):
+                return None
+            return QmtPythonPackage(runtime, item["version"], item["url"], item["filename"],
+                                    item["md5"], bool(item.get("force_update")),
+                                    item["sha256"], int(item["size"]))
+        except (KeyError, TypeError, ValueError, AttributeError):
+            return None
 
     def fetch_package(self, runtime="py312") -> QmtPythonPackage:
         runtime = _canonical_runtime(runtime)
+        mirrored = self._package_from_mirror(self._mirror_status(), runtime)
+        if mirrored:
+            return mirrored
+        return self._fetch_upstream_package(runtime)
+
+    def _fetch_upstream_package(self, runtime):
         cfg_url = "http://download.thinktrader.net:8800/download/" + _CONFIG_NAMES[runtime]
         try:
             with self._request(cfg_url) as response:
@@ -350,68 +413,127 @@ class QmtPythonRuntime:
         destination = self.download_dir / package.filename
         partial = destination.with_suffix(destination.suffix + ".part")
         with self._lock:
-            if destination.is_file() and self._md5(destination) == package.md5:
+            if destination.is_file() and self._archive_matches(destination, package):
                 _callback(progress_callback, QmtPythonProgress(
                     runtime, "download_verified", destination.stat().st_size,
                     destination.stat().st_size, 100, 0, 0, "download already verified"))
                 return destination
-            existing = partial.stat().st_size if partial.exists() and keep_existing else 0
-            if not existing and not keep_existing and partial.exists():
+            identity_file = partial.with_suffix(partial.suffix + ".identity")
+            identity = package.md5 + ":" + package.sha256
+            previous = identity_file.read_text("ascii") if identity_file.exists() else ""
+            if partial.exists() and (not keep_existing or previous != identity):
                 partial.unlink()
-            headers = {"Accept-Encoding": "identity"}
-            if existing:
-                headers["Range"] = "bytes=%d-" % existing
-            try:
-                response = self._request(package.url, headers=headers)
-            except (OSError, urllib.error.URLError) as exc:
-                raise QmtPythonRuntimeError("cannot download QMT runtime: %s" % exc) from exc
-            status = getattr(response, "status", response.getcode())
-            if status == 206 and existing:
-                mode, done = "ab", existing
-            elif status == 200:
-                mode, done = "wb", 0
+            identity_file.write_text(identity, encoding="ascii")
+            self._check_cancel(cancel_event)
+            snapshot = self._mirror_status()
+            mirrored = self._package_from_mirror(snapshot, runtime)
+            mirror_url = _MIRROR_BASE + "download?" + urlencode(dict(runtime=runtime, md5=package.md5))
+            sources = []
+            if mirrored and mirrored.md5 == package.md5 and not snapshot["busy"]:
+                sources.append(("官网", mirror_url))
+            sources.extend([("讯投", package.url), ("官网（失败回退）", mirror_url + "&force=1")])
+            errors = []
+            for source, url in sources:
+                self._check_cancel(cancel_event)
+                _LOG.info("QMT runtime download source=%s runtime=%s file=%s", source, runtime, package.filename)
+                _callback(progress_callback, QmtPythonProgress(runtime, "download", message="正在通过%s下载运行库" % source))
+                try:
+                    self._download_source(package, url, partial, source, progress_callback, cancel_event)
+                    break
+                except _DownloadSourceError as exc:
+                    errors.append("%s: %s" % (source, exc))
+                    _LOG.warning("QMT runtime source failed source=%s runtime=%s error=%s", source, runtime, exc)
             else:
-                response.close()
-                raise QmtPythonRuntimeError("unexpected QMT download HTTP status: %s" % status)
-            total_header = response.headers.get("Content-Range", "").split("/")[-1]
-            total = int(total_header) if total_header.isdigit() else int(response.headers.get("Content-Length") or 0) + done
-            started = time.monotonic()
-            _callback(progress_callback, QmtPythonProgress(runtime, "download", done, total,
-                                                            (done / total * 100) if total else 0,
-                                                            0, None, "downloading"))
-            try:
-                with response, open(partial, mode) as stream:
-                    while True:
-                        if cancel_event is not None and cancel_event.is_set():
-                            raise QmtPythonRuntimeError("QMT runtime download cancelled")
-                        chunk = response.read(1024 * 1024)
-                        if not chunk:
-                            break
-                        stream.write(chunk)
-                        done += len(chunk)
-                        elapsed = max(time.monotonic() - started, 0.001)
-                        speed = (done - (existing if mode == "ab" else 0)) / elapsed
-                        eta = ((total - done) / speed) if speed > 0 and total else None
-                        _callback(progress_callback, QmtPythonProgress(
-                            runtime, "download", done, total,
-                            (done / total * 100) if total else 0, speed, eta, "downloading"))
-                    stream.flush()
-                    os.fsync(stream.fileno())
-            except QmtPythonRuntimeError:
-                raise
-            except OSError as exc:
-                raise QmtPythonRuntimeError("cannot write QMT runtime download: %s" % exc) from exc
-            actual = self._md5(partial)
-            if actual != package.md5:
-                raise QmtPythonRuntimeError("QMT runtime MD5 mismatch: expected %s, got %s" %
-                                             (package.md5, actual))
+                raise QmtPythonRuntimeError("QMT runtime download failed; " + "; ".join(errors))
             os.replace(partial, destination)
+            identity_file.unlink()
+            size = destination.stat().st_size
             _callback(progress_callback, QmtPythonProgress(runtime, "download_verified",
-                                                            total or destination.stat().st_size,
-                                                            total or destination.stat().st_size,
+                                                            size, size,
                                                             100, 0, 0, "download verified"))
         return destination
 
+    @staticmethod
+    def _check_cancel(event):
+        if event is not None and event.is_set():
+            raise QmtPythonRuntimeError("QMT runtime download cancelled")
+
+    def _archive_matches(self, path, package):
+        if package.size and path.stat().st_size != package.size:
+            return False
+        if self._md5(path) != package.md5:
+            return False
+        if package.sha256:
+            digest = hashlib.sha256()
+            with path.open("rb") as stream:
+                for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                    digest.update(chunk)
+            return digest.hexdigest() == package.sha256
+        return True
+
+    def _download_source(self, package, url, partial, source, callback, cancel_event):
+        existing = partial.stat().st_size if partial.exists() else 0
+        if existing and self._archive_matches(partial, package):
+            return
+        if package.size and existing >= package.size:
+            partial.unlink()
+            existing = 0
+        headers = {"Accept-Encoding": "identity"}
+        if url.startswith(_MIRROR_BASE):
+            headers[_MIRROR_KEY_HEADER] = _MIRROR_KEY
+        if existing:
+            headers["Range"] = "bytes=%d-" % existing
+        try:
+            response = self._request(url, headers=headers)
+        except (OSError, http.client.HTTPException) as exc:
+            if isinstance(exc, urllib.error.HTTPError) and exc.code == 416:
+                partial.unlink(missing_ok=True)
+            raise _DownloadSourceError("cannot connect: %s" % exc) from exc
+        with response:
+            status = response.getcode()
+            if status == 206 and existing:
+                match = re.fullmatch(r"bytes (\d+)-(\d+)/(\d+)", response.headers.get("Content-Range", ""))
+                if not match or int(match[1]) != existing or int(match[2]) != int(match[3]) - 1:
+                    raise _DownloadSourceError("invalid resume Content-Range")
+                mode, done, total = "ab", existing, int(match[3])
+            elif status == 200:
+                mode, done = "wb", 0
+                try:
+                    total = int(response.headers.get("Content-Length") or package.size)
+                except ValueError as exc:
+                    raise _DownloadSourceError("invalid Content-Length") from exc
+            else:
+                raise _DownloadSourceError("unexpected HTTP status: %s" % status)
+            if package.size and total and total != package.size:
+                raise _DownloadSourceError("package size differs from manifest")
+            started, initial = time.monotonic(), done
+            with partial.open(mode) as stream:
+                while True:
+                    self._check_cancel(cancel_event)
+                    try:
+                        chunk = response.read(1024 * 1024)
+                    except (OSError, http.client.HTTPException) as exc:
+                        raise _DownloadSourceError("connection interrupted: %s" % exc) from exc
+                    if not chunk:
+                        break
+                    stream.write(chunk)  # Local disk failures must not trigger another download.
+                    done += len(chunk)
+                    if total and done > total:
+                        break
+                    speed = (done - initial) / max(time.monotonic() - started, 0.001)
+                    _callback(callback, QmtPythonProgress(
+                        package.runtime, "download", done, total, (done / total * 100) if total else 0,
+                        speed, (total - done) / speed if total and speed else None,
+                        "正在通过%s下载运行库" % source))
+                stream.flush()
+                os.fsync(stream.fileno())
+        self._check_cancel(cancel_event)
+        if total and done < total:
+            raise _DownloadSourceError("download truncated: %d/%d" % (done, total))
+        if not self._archive_matches(partial, package):
+            partial.unlink()
+            raise _DownloadSourceError("QMT runtime MD5/SHA-256 mismatch")
+
     @staticmethod
     def _safe_extract(archive, destination):
         destination = Path(destination).resolve()
@@ -442,7 +564,7 @@ class QmtPythonRuntime:
         runtime = _canonical_runtime(runtime)
         package = package or self.fetch_package(runtime)
         archive = self.download_dir / package.filename
-        if not archive.is_file() or self._md5(archive) != package.md5:
+        if not archive.is_file() or not self._archive_matches(archive, package):
             raise QmtPythonRuntimeError("verified QMT runtime archive is missing")
         with self._lock:
             self.staging_dir.mkdir(parents=True, exist_ok=True)

cfquant-0.2.71/cfquant/tests/test_qmt_python_mirror.py

@@ -0,0 +1,181 @@
+"""Source routing, byte integrity and cancellation without contacting live QMT."""
+from dataclasses import replace
+import hashlib
+import http.client
+import io
+import json
+import threading
+import urllib.error
+
+import pytest
+
+from cfquant import qmt_python_runtime as runtime
+
+DATA = b'QMT test runtime archive' * 100
+
+
+class Response(io.BytesIO):
+    def __init__(self, data=DATA, status=200, headers=None):
+        super().__init__(data)
+        self.status = status
+        self.headers = headers or {'Content-Length': str(len(data))}
+
+    def getcode(self):
+        return self.status
+
+
+@pytest.fixture
+def setup(tmp_path, monkeypatch):
+    manager = runtime.QmtPythonRuntime(tmp_path)
+    package = runtime.QmtPythonPackage('py312', '2.0.3.12', 'http://xuntou.test/runtime.zip',
+                                       'runtime.zip', hashlib.md5(DATA).hexdigest(), True,
+                                       hashlib.sha256(DATA).hexdigest(), len(DATA))
+    snapshot = dict(ok=True, schema=1, busy=False, packages={'py312': package.as_dict()})
+    monkeypatch.setattr(manager, '_mirror_status', lambda: snapshot)
+    calls = []
+    def request(url, **kwargs):
+        calls.append((url, kwargs.get('headers', {})))
+        return Response()
+    monkeypatch.setattr(manager, '_request', request)
+    return manager, package, snapshot, calls
+
+
+def test_mirror_first_and_verified_cache_needs_no_network(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    assert manager.fetch_package() == package
+    assert manager.download(package=package).read_bytes() == DATA
+    assert calls[0][0].startswith(runtime._MIRROR_BASE)
+    assert calls[0][1][runtime._MIRROR_KEY_HEADER] == runtime._MIRROR_KEY
+    monkeypatch.setattr(manager, '_mirror_status', lambda: pytest.fail('cached file should work offline'))
+    manager.download(package=package)
+    assert len(calls) == 1
+
+
+def test_busy_uses_upstream_without_mirror_auth_header(setup):
+    manager, package, snapshot, calls = setup
+    snapshot['busy'] = True
+    manager.download(package=package)
+    assert calls == [(package.url, {'Accept-Encoding': 'identity'})]
+
+
+@pytest.mark.parametrize('busy', [True, False])
+def test_upstream_failure_forces_website_even_when_busy(setup, monkeypatch, busy):
+    manager, package, snapshot, calls = setup
+    snapshot['busy'] = busy
+    def request(url, **kwargs):
+        calls.append(url)
+        if 'force=1' not in url:
+            raise urllib.error.URLError('offline')
+        return Response()
+    monkeypatch.setattr(manager, '_request', request)
+    assert manager.download(package=package).read_bytes() == DATA
+    assert calls[-1].endswith('&force=1')
+    assert calls[-2] == package.url
+    assert len(calls) == (2 if busy else 3)
+
+
+def test_unavailable_status_still_attempts_direct_forced_download(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    monkeypatch.setattr(manager, '_mirror_status', lambda: None)
+    def request(url, **kwargs):
+        calls.append(url)
+        if url == package.url:
+            raise TimeoutError('timeout')
+        return Response()
+    monkeypatch.setattr(manager, '_request', request)
+    manager.download(package=package)
+    assert len(calls) == 2 and calls[-1].endswith('&force=1')
+
+
+def test_corrupt_download_is_discarded_before_fallback(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    def request(url, **kwargs):
+        calls.append((url, kwargs['headers']))
+        return Response(b'x' * len(DATA)) if len(calls) == 1 else Response()
+    monkeypatch.setattr(manager, '_request', request)
+    assert manager.download(package=package).read_bytes() == DATA
+    assert calls[-1][0] == package.url and 'Range' not in calls[-1][1]
+
+
+def test_truncated_response_resumes_at_other_source(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    def request(url, **kwargs):
+        calls.append((url, kwargs['headers']))
+        if len(calls) == 1:
+            return Response(DATA[:100], headers={'Content-Length': str(len(DATA))})
+        assert kwargs['headers']['Range'] == 'bytes=100-'
+        return Response(DATA[100:], status=206,
+                        headers={'Content-Range': 'bytes 100-%d/%d' % (len(DATA)-1, len(DATA))})
+    monkeypatch.setattr(manager, '_request', request)
+    assert manager.download(package=package).read_bytes() == DATA
+    assert len(calls) == 2
+
+
+def test_incorrect_range_cannot_be_appended(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    def request(url, **kwargs):
+        calls.append(url)
+        if len(calls) == 1:
+            return Response(DATA[:100], headers={'Content-Length': str(len(DATA))})
+        if len(calls) == 2:
+            return Response(DATA, status=206, headers={'Content-Range': 'bytes 0-%d/%d' % (len(DATA)-1, len(DATA))})
+        return Response()  # A server may ignore Range and send a complete 200.
+    monkeypatch.setattr(manager, '_request', request)
+    assert manager.download(package=package).read_bytes() == DATA
+    assert len(calls) == 3
+
+
+def test_sha256_failure_cannot_be_installed(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    package = replace(package, sha256='0' * 64)
+    with pytest.raises(runtime.QmtPythonRuntimeError, match='SHA-256 mismatch'):
+        manager.download(package=package)
+    assert len(calls) == 3
+    assert not (manager.download_dir / package.filename).exists()
+
+
+def test_cancel_does_not_fall_back(setup):
+    manager, package, snapshot, calls = setup
+    cancel = threading.Event()
+    def progress(event):
+        if event['bytes_done']:
+            cancel.set()
+    with pytest.raises(runtime.QmtPythonRuntimeError, match='cancelled'):
+        manager.download(package=package, cancel_event=cancel, progress_callback=progress)
+    assert len(calls) == 1
+
+
+def test_local_write_failure_does_not_fall_back(setup, monkeypatch):
+    manager, package, snapshot, calls = setup
+    monkeypatch.setattr(runtime.os, 'fsync', lambda fd: (_ for _ in ()).throw(OSError('disk full')))
+    with pytest.raises(OSError, match='disk full'):
+        manager.download(package=package)
+    assert len(calls) == 1
+
+
+def test_config_fallback_and_status_timeout_cache(tmp_path, monkeypatch):
+    manager = runtime.QmtPythonRuntime(tmp_path)
+    calls = []
+    def request(url, **kwargs):
+        calls.append((url, kwargs))
+        if url.startswith(runtime._MIRROR_BASE):
+            raise TimeoutError('offline')
+        return Response(b'[python]\nversion=2.0.3.12\nurl=http://xuntou.test/runtime.zip\nfilename=runtime.zip\nmd5=' + b'1'*32)
+    monkeypatch.setattr(manager, '_request', request)
+    assert manager.fetch_package().md5 == '1'*32
+    assert manager.fetch_package().md5 == '1'*32
+    assert len(calls) == 3
+    assert calls[0][1]['timeout'] == 5
+    assert 'headers' not in calls[-1][1]
+
+
+def test_manifest_version_mismatch_never_uses_normal_mirror(setup):
+    manager, package, snapshot, calls = setup
+    snapshot['packages']['py312']['md5'] = '0'*32
+    manager.download(package=package)
+    assert calls[0][0] == package.url
+
+
+def test_key_is_not_forwarded_on_redirect():
+    handler = runtime._NoMirrorRedirect()
+    assert handler.redirect_request(None, None, 302, '', {}, 'https://third-party.test') is None

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

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

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

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

{cfquant-0.2.70 → cfquant-0.2.71}/cfquant.egg-info/SOURCES.txt

@@ -198,6 +198,7 @@ cfquant/tests/test_qmt_native_files.py
 cfquant/tests/test_qmt_native_reuse.py
 cfquant/tests/test_qmt_native_worker.py
 cfquant/tests/test_qmt_package_import.py
+cfquant/tests/test_qmt_python_mirror.py
 cfquant/tests/test_qmt_python_runtime.py
 cfquant/tests/test_qmt_strategy_browser.py
 cfquant/tests/test_qmt_strategy_capabilities.py

{cfquant-0.2.70 → cfquant-0.2.71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cfquant"
-version = "0.2.70"
+version = "0.2.71"
 description = "QMT local bridge and xtquant-compatible Python client."
 license = {text = "MIT"}
 readme = "README.md"

{cfquant-0.2.70 → cfquant-0.2.71}/qmt_scripts/CFQUANT_LITE.py

@@ -753,7 +753,7 @@ def _resolve_batch_order_ids(bridge, account, pending, before_ids):
         time.sleep(min(0.05, remaining))
 # END GENERATED CFTRADER BATCH
 
-CORE_VERSION = "0.2.70"
+CORE_VERSION = "0.2.71"
 
 # BEGIN GENERATED DIAGNOSTIC CONTEXT
 """Version context for cfquant diagnostics without changing application logging."""

{cfquant-0.2.70 → cfquant-0.2.71}/qmt_scripts//345/220/214/350/264/246/345/217/267/347/213/254/347/253/213/345/270/202/345/234/272/CFQUANT_LITE_SH.py

@@ -767,7 +767,7 @@ def _resolve_batch_order_ids(bridge, account, pending, before_ids):
         time.sleep(min(0.05, remaining))
 # END GENERATED CFTRADER BATCH
 
-CORE_VERSION = "0.2.70"
+CORE_VERSION = "0.2.71"
 
 # BEGIN GENERATED DIAGNOSTIC CONTEXT
 """Version context for cfquant diagnostics without changing application logging."""

{cfquant-0.2.70 → cfquant-0.2.71}/qmt_scripts//345/220/214/350/264/246/345/217/267/347/213/254/347/253/213/345/270/202/345/234/272/CFQUANT_LITE_SZ.py

@@ -767,7 +767,7 @@ def _resolve_batch_order_ids(bridge, account, pending, before_ids):
         time.sleep(min(0.05, remaining))
 # END GENERATED CFTRADER BATCH
 
-CORE_VERSION = "0.2.70"
+CORE_VERSION = "0.2.71"
 
 # BEGIN GENERATED DIAGNOSTIC CONTEXT
 """Version context for cfquant diagnostics without changing application logging."""

{cfquant-0.2.70 → cfquant-0.2.71}/web_dashboard/app.js

@@ -1,4 +1,4 @@
-const FRONTEND_VERSION = 'web_20261112_01';
+const FRONTEND_VERSION = 'web_20261112_02';
 
 const state = {
   accountId: '',

{cfquant-0.2.70 → cfquant-0.2.71}/web_dashboard/index.html

@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>cfquant 控制台</title>
   <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  <link rel="stylesheet" href="/styles.css?v=web_20261112_01">
+  <link rel="stylesheet" href="/styles.css?v=web_20261112_02">
 </head>
 <body>
   <div id="webAuthOverlay" class="auth-overlay hidden" aria-live="polite">
@@ -3585,7 +3585,7 @@ else:
   <script src="/trading-monitor.js?v=20261111_runtime_window_01"></script>
   <script src="/navigation.js?v=web_20261108_nav_03"></script>
   <script src="/activity-log.js?v=web_20261108_logs_01"></script>
-  <script src="/app.js?v=web_20261112_01"></script>
+  <script src="/app.js?v=web_20261112_02"></script>
   <script src="/remote-management.js?v=20261103"></script>
 </body>
 </html>