xtquant-big-convert 0.2.0__py3-none-any.whl

BIGQMT_REDIS_DRYRUN.py

@@ -0,0 +1,254 @@
+#coding:gbk
+"""QMT bridge entry using the same file-loader pattern as qmt_realtime strategies.
+
+Broker QMT strategy sandboxes may reject local package names through their
+normal ``import`` allowlist.  The realtime QMT strategies in gupiao_ztfx load
+their colocated helpers through ``importlib.util.spec_from_file_location``.
+This entry applies path-based loading to the bridge package, including its
+internal relative imports, while leaving all standard-library and QMT imports
+untouched.  This terminal's spec loader ignores custom builtins for nested
+package imports, so local bridge files are compiled explicitly after resolving
+their path.
+"""
+import builtins as _builtins
+import importlib as _importlib
+import os
+import sys
+import types
+
+
+_LOCAL_ROOTS = (
+    "bigqmt_signal_trader",
+    "bigqmt_signal_trader_strategy",
+    "bigqmt_signal_trader_redis_rpc_runtime",
+    "bigqmt_signal_trader_local_config",
+)
+_ORIGINAL_IMPORT = _builtins.__import__
+_ORIGINAL_IMPORT_MODULE = _importlib.import_module
+_ORIGINAL_RELOAD = _importlib.reload
+
+
+def _known_qmt_python_dir():
+    # Find the QMT python dir from sys.path instead of a hardcoded path, so
+    # the bridge loads regardless of broker install location or launch mode
+    # (editor / paste-run / exec). Falls back to empty when not found.
+    for p in sys.path:
+        if p and r"\python" in p and os.path.isdir(p):
+            return p
+    return ""
+
+
+try:
+    _SOURCE_ROOT = os.path.dirname(os.path.abspath(__file__))
+except Exception:
+    _SOURCE_ROOT = _known_qmt_python_dir()
+if not _SOURCE_ROOT:
+    _SOURCE_ROOT = _known_qmt_python_dir()
+
+
+def _is_local_module(name):
+    return any(name == root or name.startswith(root + ".") for root in _LOCAL_ROOTS)
+
+
+def _resolve_name(name, module_globals, level):
+    if not level:
+        return name
+    package = (module_globals or {}).get("__package__") or (module_globals or {}).get("__name__", "")
+    if not package:
+        raise ImportError("relative import without package")
+    for unused in range(level - 1):
+        if "." not in package:
+            raise ImportError("relative import beyond top-level package")
+        package = package.rsplit(".", 1)[0]
+    return package + ("." + name if name else "")
+
+
+def _find_local_source(name):
+    relative = name.replace(".", os.sep)
+    dirs = []
+    if _SOURCE_ROOT:
+        dirs.append(_SOURCE_ROOT)
+    for p in sys.path:
+        if p and os.path.isdir(p) and p not in dirs:
+            dirs.append(p)
+    for d in dirs:
+        package_init = os.path.join(d, relative, "__init__.py")
+        if os.path.isfile(package_init):
+            return package_init, True
+        module_file = os.path.join(d, relative + ".py")
+        if os.path.isfile(module_file):
+            return module_file, False
+    raise ModuleNotFoundError("local source not found: %s" % name, name=name)
+
+
+def _set_parent_attribute(name, module):
+    if "." not in name:
+        return
+    parent_name, child_name = name.rsplit(".", 1)
+    parent = _load_local_module(parent_name)
+    setattr(parent, child_name, module)
+
+
+def _load_local_module(name):
+    existing = sys.modules.get(name)
+    if existing is not None:
+        return existing
+    source_path, is_package = _find_local_source(name)
+    if "." in name:
+        _load_local_module(name.rsplit(".", 1)[0])
+    module = types.ModuleType(name)
+    module.__file__ = source_path
+    module.__package__ = name if is_package else name.rpartition(".")[0]
+    if is_package:
+        module.__path__ = [os.path.dirname(source_path)]
+    module_builtins = dict(_builtins.__dict__)
+    module_builtins["__import__"] = _local_import
+    module.__dict__["__builtins__"] = module_builtins
+    module.__dict__["__bigqmt_load_local_module"] = _load_local_module
+    sys.modules[name] = module
+    # QMT native allowlist rejects the root package eager exports.
+    if name == "bigqmt_signal_trader":
+        return module
+    try:
+        with open(source_path, "rb") as source_file:
+            source = source_file.read()
+        exec(compile(source, source_path, "exec"), module.__dict__)
+    except Exception:
+        sys.modules.pop(name, None)
+        raise
+    _set_parent_attribute(name, module)
+    return module
+
+
+def _local_import(name, module_globals=None, module_locals=None, fromlist=(), level=0):
+    absolute_name = _resolve_name(name, module_globals, level)
+    if not _is_local_module(absolute_name):
+        return _ORIGINAL_IMPORT(name, module_globals, module_locals, fromlist, level)
+    module = _load_local_module(absolute_name)
+    for child in fromlist or ():
+        if child != "*":
+            try:
+                _load_local_module(absolute_name + "." + child)
+            except ModuleNotFoundError:
+                pass
+    if fromlist:
+        return module
+    return _load_local_module(absolute_name.split(".", 1)[0])
+
+
+def _local_import_module(name, package=None):
+    if _is_local_module(name):
+        return _load_local_module(name)
+    return _ORIGINAL_IMPORT_MODULE(name, package)
+
+
+def _local_reload(module):
+    if _is_local_module(getattr(module, "__name__", "")):
+        return _load_local_module(module.__name__)
+    return _ORIGINAL_RELOAD(module)
+
+
+def _clear_local_modules():
+    for name in list(sys.modules):
+        if _is_local_module(name):
+            sys.modules.pop(name, None)
+
+
+def _stop_previous_rpc_service():
+    """Release the previous QMT strategy's socket before clearing its module.
+
+    QMT can re-execute this entry in the same Python process.  The old strategy
+    module owns the RPC service and its ZMQ ROUTER socket, so dropping that
+    module from ``sys.modules`` first would make the service unreachable and
+    leave its port bound for the next strategy start.
+    """
+    previous = sys.modules.get("bigqmt_signal_trader_strategy")
+    reset = getattr(previous, "reset_app", None)
+    if not callable(reset):
+        return
+    try:
+        reset()
+        print("[bigqmt_shell] previous rpc service stopped")
+    except Exception as exc:
+        # Continue the reload so a broken old instance does not prevent QMT
+        # from reporting its normal startup error.
+        print("[bigqmt_shell] previous rpc service stop failed: %s" % exc)
+
+
+_stop_previous_rpc_service()
+_clear_local_modules()
+_importlib.import_module = _local_import_module
+_importlib.reload = _local_reload
+print("[bigqmt_shell] importlib entry source_root=%s" % _SOURCE_ROOT)
+
+
+def _fallback_account_id():
+    for name in ("BIGQMT_ACCOUNT_ID", "account", "account_id", "accountID"):
+        value = globals().get(name)
+        if value:
+            return str(value)
+    return ""
+
+
+try:
+    _local_import("bigqmt_signal_trader.adapters.redis_common", globals(), fromlist=("*",))
+    _local_import("bigqmt_signal_trader.redis_rpc", globals(), fromlist=("*",))
+    _strategy = _local_import("bigqmt_signal_trader_strategy", globals(), fromlist=("*",))
+    _strategy.reset_app()
+except Exception as bridge_preload_error:
+    print("[bigqmt_shell] bridge preload failed: %s" % bridge_preload_error)
+
+_runtime = _local_import("bigqmt_signal_trader_redis_rpc_runtime", globals(), fromlist=("*",))
+
+
+def _load_local_config():
+    return _local_import("bigqmt_signal_trader_local_config", globals(), fromlist=("*",))
+
+
+try:
+    _config = _load_local_config()
+    BIGQMT_REDIS_CONFIG = getattr(_config, "BIGQMT_REDIS_CONFIG", {})
+    print("[bigqmt_shell] local redis config loaded keys=%s" % sorted((BIGQMT_REDIS_CONFIG or {}).keys()))
+    _runtime.configure_runtime_redis(BIGQMT_REDIS_CONFIG)
+except Exception as redis_config_error:
+    print("[bigqmt_shell] local redis config load failed: %s" % redis_config_error)
+
+try:
+    _config = _load_local_config()
+    BIGQMT_ACCOUNT_ID = getattr(_config, "BIGQMT_ACCOUNT_ID", "")
+    print("[bigqmt_shell] local account config loaded=%s" % bool(BIGQMT_ACCOUNT_ID))
+    _runtime.configure_runtime_account(BIGQMT_ACCOUNT_ID)
+except Exception as account_config_error:
+    print("[bigqmt_shell] local account config load failed: %s" % account_config_error)
+    account_id = _fallback_account_id()
+    if account_id:
+        _runtime.configure_runtime_account(account_id)
+
+try:
+    qmt_extra = {}
+    for function_name in (
+        "get_history_trade_detail_data", "get_value_by_order_id", "get_last_order_id",
+        "get_ipo_data", "get_new_purchase_limit", "get_assure_contract",
+        "get_enable_short_contract", "get_unclosed_compacts", "get_closed_compacts",
+        "get_debt_contract", "get_option_subject_position", "get_comb_option",
+        "get_hkt_exchange_rate",
+        "download_history_data", "download_history_data2",
+    ):
+        if function_name in globals():
+            qmt_extra[function_name] = globals()[function_name]
+    print("[bigqmt_shell] down_history_data bound=%s" % ("down_history_data" in qmt_extra))
+    _runtime.bind_runtime_api(
+        passorder_func=globals().get("passorder"),
+        cancel_func=globals().get("cancel"),
+        get_trade_detail_data_func=globals().get("get_trade_detail_data"),
+        extra_funcs=qmt_extra or None,
+    )
+except NameError:
+    pass
+
+
+init = _runtime.init
+handlebar = _runtime.handlebar
+adjust = _runtime.adjust
+order_callback = _runtime.order_callback
+deal_callback = _runtime.deal_callback

BIGQMT_ZMQ_BACKTEST.py

@@ -0,0 +1,152 @@
+#coding:gbk
+"""Isolated QMT backtest entry for external ZMQ strategies.
+
+This file is ASCII-only. It loads only the bigqmt_backtest package and never
+loads or mutates the live bridge package.
+"""
+
+import builtins as _builtins
+import os
+import sys
+import types
+
+
+BACKTEST_ZMQ_CONFIG = {
+    "bind_endpoint": "tcp://127.0.0.1:16662",
+    "run_id": "",
+    "account_id": "",
+    "account_type": "STOCK",
+    "strategy_name": "ZMQ_BACKTEST",
+    "combo_type": 1101,
+    "quick_trade": 2,
+    "market_price_type": 5,
+    "limit_price_type": 11,
+    "bar_wait_timeout_seconds": 60,
+    "require_qmt_backtest": True,
+}
+
+
+_LOCAL_ROOT = "bigqmt_backtest"
+_ORIGINAL_IMPORT = _builtins.__import__
+
+
+def _known_qmt_python_dir():
+    for p in sys.path:
+        if p and r"\python" in p and os.path.isdir(p):
+            return p
+    return ""
+
+
+try:
+    _SOURCE_ROOT = os.path.dirname(os.path.abspath(__file__))
+except Exception:
+    _SOURCE_ROOT = _known_qmt_python_dir()
+if not _SOURCE_ROOT:
+    _SOURCE_ROOT = _known_qmt_python_dir()
+
+
+def _is_local(name):
+    return name == _LOCAL_ROOT or name.startswith(_LOCAL_ROOT + ".")
+
+
+def _resolve_name(name, module_globals, level):
+    if not level:
+        return name
+    package = (module_globals or {}).get("__package__") or ""
+    if not package:
+        raise ImportError("relative import without package")
+    for unused in range(level - 1):
+        package = package.rsplit(".", 1)[0]
+    return package + (("." + name) if name else "")
+
+
+def _find_source(name):
+    relative = name.replace(".", os.sep)
+    dirs = []
+    if _SOURCE_ROOT:
+        dirs.append(_SOURCE_ROOT)
+    for p in sys.path:
+        if p and os.path.isdir(p) and p not in dirs:
+            dirs.append(p)
+    for d in dirs:
+        package_init = os.path.join(d, relative, "__init__.py")
+        if os.path.isfile(package_init):
+            return package_init, True
+        module_file = os.path.join(d, relative + ".py")
+        if os.path.isfile(module_file):
+            return module_file, False
+    raise ModuleNotFoundError("local source not found: %s" % name, name=name)
+
+
+def _load_local_module(name):
+    existing = sys.modules.get(name)
+    if existing is not None:
+        return existing
+    source_path, is_package = _find_source(name)
+    if "." in name:
+        _load_local_module(name.rsplit(".", 1)[0])
+    module = types.ModuleType(name)
+    module.__file__ = source_path
+    module.__package__ = name if is_package else name.rpartition(".")[0]
+    if is_package:
+        module.__path__ = [os.path.dirname(source_path)]
+    module_builtins = dict(_builtins.__dict__)
+    module_builtins["__import__"] = _local_import
+    module.__dict__["__builtins__"] = module_builtins
+    sys.modules[name] = module
+    if name == _LOCAL_ROOT:
+        return module
+    try:
+        with open(source_path, "rb") as source_file:
+            source = source_file.read()
+        exec(compile(source, source_path, "exec"), module.__dict__)
+    except Exception:
+        sys.modules.pop(name, None)
+        raise
+    if "." in name:
+        parent_name, child_name = name.rsplit(".", 1)
+        setattr(_load_local_module(parent_name), child_name, module)
+    return module
+
+
+def _local_import(name, module_globals=None, module_locals=None, fromlist=(), level=0):
+    absolute_name = _resolve_name(name, module_globals, level)
+    if not _is_local(absolute_name):
+        return _ORIGINAL_IMPORT(name, module_globals, module_locals, fromlist, level)
+    module = _load_local_module(absolute_name)
+    for child in fromlist or ():
+        if child != "*":
+            try:
+                _load_local_module(absolute_name + "." + child)
+            except ModuleNotFoundError:
+                pass
+    if fromlist:
+        return module
+    return _load_local_module(absolute_name.split(".", 1)[0])
+
+
+for _name in sorted(
+    [name for name in list(sys.modules) if _is_local(name)],
+    key=lambda item: item.count("."),
+    reverse=True,
+):
+    sys.modules.pop(_name, None)
+
+
+_runtime = _load_local_module("bigqmt_backtest.qmt_runtime")
+_runtime.configure(**BACKTEST_ZMQ_CONFIG)
+_runtime.bind_qmt_api(
+    passorder_func=globals().get("passorder") or getattr(_builtins, "passorder", None),
+    cancel_func=globals().get("cancel") or getattr(_builtins, "cancel", None),
+    get_trade_detail_data_func=(
+        globals().get("get_trade_detail_data")
+        or getattr(_builtins, "get_trade_detail_data", None)
+    ),
+)
+
+init = _runtime.init
+handlebar = _runtime.handlebar
+order_callback = _runtime.order_callback
+deal_callback = _runtime.deal_callback
+stop = _runtime.stop
+after_backtest = _runtime.after_backtest

bigqmt_backtest/__init__.py

@@ -0,0 +1,23 @@
+"""Isolated ZMQ bridge for QMT-native and standalone backtests.
+
+This package deliberately does not import ``bigqmt_signal_trader``.  The live
+bridge and both backtest backends therefore have separate module state,
+identities, and order gateways.  QMT-native mode never uses the local broker.
+"""
+
+from .client import BacktestZmqClient
+from .data_feed import CsvBarFeed, InMemoryBarFeed
+from .engine import BacktestConfig, BacktestEngine
+from .protocol import BacktestBridgeProtocol
+
+
+__all__ = [
+    "BacktestBridgeProtocol",
+    "BacktestConfig",
+    "BacktestEngine",
+    "BacktestZmqClient",
+    "CsvBarFeed",
+    "InMemoryBarFeed",
+]
+
+__version__ = "1.0.0"

bigqmt_backtest/__main__.py

@@ -0,0 +1,5 @@
+from .server import main
+
+
+if __name__ == "__main__":
+    main()