cfquant 0.2.0__py3-none-any.whl

cfquant/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""
+cfquant: 面向 QMT 的 xtquant 兼容层。
+
+外部程序导入本包后，可以按常见 xtquant 方式使用：
+
+    from cfquant import xtdata, xtconstant
+    from cfquant.xttrader import XtQuantTrader
+    from cfquant.xttype import StockAccount
+"""
+
+from . import xtconstant, xtdata, xttrader, xttype
+from .client import CfquantError, CfquantTimeout, configure, get_client
+from .version import __version__
+
+__all__ = [
+    "xtconstant",
+    "xtdata",
+    "xttrader",
+    "xttype",
+    "configure",
+    "get_client",
+    "CfquantError",
+    "CfquantTimeout",
+    "__version__",
+]

cfquant/account_routing.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+import threading
+
+
+_lock = threading.RLock()
+_subscribers = {}
+_client_accounts = {}
+
+
+def _account_type(account_type):
+    value = str(account_type or "STOCK").strip().upper()
+    mapping = {
+        "2": "STOCK",
+        "SECURITY": "STOCK",
+        "SECURITY_ACCOUNT": "STOCK",
+        "STOCK_ACCOUNT": "STOCK",
+        "3": "CREDIT",
+        "CREDIT_ACCOUNT": "CREDIT",
+        "MARGIN": "CREDIT",
+    }
+    return mapping.get(value, value or "STOCK")
+
+
+def _key(bridge_id, account_id, account_type=None):
+    return (
+        str(bridge_id or "default").strip(),
+        _account_type(account_type),
+        str(account_id or "").strip(),
+    )
+
+
+def subscribe(bridge_id, account_id, client_id, account_type=None):
+    bridge_id, account_type, account_id = _key(bridge_id, account_id, account_type)
+    client_id = str(client_id or "").strip()
+    if not account_id or not client_id:
+        return
+    with _lock:
+        _subscribers.setdefault((bridge_id, account_type, account_id), set()).add(client_id)
+        _client_accounts.setdefault((bridge_id, client_id), set()).add((account_type, account_id))
+
+
+def unsubscribe(bridge_id, account_id=None, client_id=None, account_type=None):
+    bridge_id = str(bridge_id or "default").strip()
+    account_type = _account_type(account_type) if account_type not in (None, "") else ""
+    account_id = str(account_id or "").strip()
+    client_id = str(client_id or "").strip()
+    with _lock:
+        if account_id and client_id:
+            if account_type:
+                _remove_pair(bridge_id, account_id, client_id, account_type)
+            else:
+                for item_type in _account_types_for_account_locked(bridge_id, account_id):
+                    _remove_pair(bridge_id, account_id, client_id, item_type)
+            return
+        if client_id:
+            accounts = _client_accounts.pop((bridge_id, client_id), set())
+            for item in accounts:
+                if isinstance(item, tuple):
+                    item_type, item_account_id = item
+                else:
+                    item_type, item_account_id = "STOCK", item
+                subscribers = _subscribers.get((bridge_id, item_type, item_account_id))
+                if subscribers:
+                    subscribers.discard(client_id)
+                    if not subscribers:
+                        _subscribers.pop((bridge_id, item_type, item_account_id), None)
+            return
+        if account_id:
+            types = [account_type] if account_type else _account_types_for_account_locked(bridge_id, account_id)
+            for item_type in types:
+                subscribers = _subscribers.pop((bridge_id, item_type, account_id), set())
+                for item in subscribers:
+                    accounts = _client_accounts.get((bridge_id, item))
+                    if accounts:
+                        accounts.discard((item_type, account_id))
+                        accounts.discard(account_id)
+                        if not accounts:
+                            _client_accounts.pop((bridge_id, item), None)
+
+
+def client_ids(bridge_id, account_id, account_type=None):
+    bridge_id, account_type, account_id = _key(bridge_id, account_id, account_type)
+    if not account_id:
+        return []
+    with _lock:
+        return sorted(_subscribers.get((bridge_id, account_type, account_id), set()))
+
+
+def status(bridge_id):
+    bridge_id = str(bridge_id or "default").strip()
+    with _lock:
+        return dict(
+            ("%s:%s" % (account_type, account_id), len(client_ids))
+            for (item_bridge_id, account_type, account_id), client_ids in _subscribers.items()
+            if item_bridge_id == bridge_id
+        )
+
+
+def _account_types_for_account_locked(bridge_id, account_id):
+    return [
+        account_type
+        for item_bridge_id, account_type, item_account_id in _subscribers.keys()
+        if item_bridge_id == bridge_id and item_account_id == account_id
+    ] or ["STOCK"]
+
+
+def _remove_pair(bridge_id, account_id, client_id, account_type="STOCK"):
+    account_type = _account_type(account_type)
+    subscribers = _subscribers.get((bridge_id, account_type, account_id))
+    if subscribers:
+        subscribers.discard(client_id)
+        if not subscribers:
+            _subscribers.pop((bridge_id, account_type, account_id), None)
+    accounts = _client_accounts.get((bridge_id, client_id))
+    if accounts:
+        accounts.discard((account_type, account_id))
+        accounts.discard(account_id)
+        if not accounts:
+            _client_accounts.pop((bridge_id, client_id), None)

cfquant/channels.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+
+
+LEGACY_NORMAL_REQUEST_CHANNEL = "cfquant.normal.request"
+LEGACY_TRADE_REQUEST_CHANNEL = "cfquant.trade.request"
+LEGACY_CALLBACK_EVENT_CHANNEL = "cfquant.callback.event"
+
+
+def normalize_bridge_id(value=None):
+    value = str(value or "").strip()
+    if not value:
+        return "default"
+    value = re.sub(r"[^0-9A-Za-z_.-]+", "_", value)
+    return value or "default"
+
+
+def bridge_id_from_env(default="default"):
+    return normalize_bridge_id(os.environ.get("CFQUANT_BRIDGE_ID") or default)
+
+
+def bridge_env_prefix(bridge_id):
+    safe = re.sub(r"[^0-9A-Za-z]+", "_", normalize_bridge_id(bridge_id)).upper()
+    return "CFQUANT_BRIDGE_%s_" % safe
+
+
+def channels_for_bridge(bridge_id=None):
+    bridge_id = normalize_bridge_id(bridge_id or bridge_id_from_env())
+    prefix = bridge_env_prefix(bridge_id)
+    if bridge_id == "default":
+        default_normal = os.environ.get("CFQUANT_NORMAL_REQUEST_CHANNEL", LEGACY_NORMAL_REQUEST_CHANNEL)
+        default_trade = os.environ.get("CFQUANT_TRADE_REQUEST_CHANNEL", LEGACY_TRADE_REQUEST_CHANNEL)
+        default_callback = os.environ.get("CFQUANT_CALLBACK_EVENT_CHANNEL", LEGACY_CALLBACK_EVENT_CHANNEL)
+    else:
+        default_normal = "cfquant.%s.normal.request" % bridge_id
+        default_trade = "cfquant.%s.trade.request" % bridge_id
+        default_callback = "cfquant.%s.callback.event" % bridge_id
+    return {
+        "normal": os.environ.get(prefix + "NORMAL_REQUEST_CHANNEL", default_normal),
+        "trade": os.environ.get(prefix + "TRADE_REQUEST_CHANNEL", default_trade),
+        "callback": os.environ.get(prefix + "CALLBACK_EVENT_CHANNEL", default_callback),
+    }
+
+
+def bridge_name(bridge_id):
+    bridge_id = normalize_bridge_id(bridge_id)
+    prefix = bridge_env_prefix(bridge_id)
+    return os.environ.get(prefix + "NAME", bridge_id)
+
+
+def configured_bridge_ids():
+    raw = os.environ.get("CFQUANT_BRIDGE_IDS")
+    if raw:
+        ids = [normalize_bridge_id(item) for item in raw.split(",") if item.strip()]
+    else:
+        ids = [bridge_id_from_env()]
+    seen = set()
+    result = []
+    for bridge_id in ids:
+        if bridge_id in seen:
+            continue
+        seen.add(bridge_id)
+        result.append(bridge_id)
+    return result or ["default"]
+
+
+def configured_bridges():
+    result = {}
+    for bridge_id in configured_bridge_ids():
+        result[bridge_id] = {
+            "id": bridge_id,
+            "name": bridge_name(bridge_id),
+            "channels": channels_for_bridge(bridge_id),
+        }
+    return result

cfquant/cli.py

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+"""Command-line entry points for the installed cfquant package."""
+
+from __future__ import print_function
+
+import argparse
+import os
+import shutil
+import socket
+import sys
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+from .version import WEB_VERSION, __version__ as CORE_VERSION
+
+
+QMT_SCRIPT_FILES = (
+    "CFQUANT.py",
+    "CFQUANT_CTYPE_ALL_LOWLAT.py",
+    "CFQUANT_LITE.py",
+    "CFQUANT_TRADE_LOWLAT.py",
+    "同账号独立市场/CFQUANT_CTYPE_ALL_LOWLAT_SH.py",
+    "同账号独立市场/CFQUANT_CTYPE_ALL_LOWLAT_SZ.py",
+    "同账号独立市场/CFQUANT_LITE_SH.py",
+    "同账号独立市场/CFQUANT_LITE_SZ.py",
+    "同账号独立市场/CFQUANT_TRADE_LOWLAT_SH.py",
+    "同账号独立市场/CFQUANT_TRADE_LOWLAT_SZ.py",
+    "同账号独立市场/readme.md",
+)
+
+
+def _package_version():
+    try:
+        from importlib import metadata
+
+        return metadata.version("cfquant")
+    except Exception:
+        return "unknown"
+
+
+def _port(value):
+    try:
+        port = int(value)
+    except (TypeError, ValueError):
+        raise argparse.ArgumentTypeError("port must be an integer")
+    if port < 1 or port > 65535:
+        raise argparse.ArgumentTypeError("port must be between 1 and 65535")
+    return port
+
+
+def _path(value):
+    value = str(value or "").strip()
+    if not value:
+        return ""
+    return os.path.abspath(os.path.expandvars(os.path.expanduser(value)))
+
+
+def _apply_web_environment(args):
+    mappings = (
+        ("home", "CFQUANT_HOME"),
+        ("runtime_dir", "CFQUANT_RUNTIME_DIR"),
+        ("log_dir", "CFQUANT_LOG_DIR"),
+        ("config", "CFQUANT_WEB_CONFIG_FILE"),
+        ("pipe_name", "CFQUANT_PIPE_NAME"),
+        ("lttx_host", "CFQUANT_LTTX_HOST"),
+        ("account_id", "CFQUANT_ACCOUNT_ID"),
+    )
+    for attribute, variable in mappings:
+        value = getattr(args, attribute, None)
+        if value:
+            os.environ[variable] = _path(value) if variable.endswith(("_DIR", "_FILE", "_HOME")) else str(value)
+    if getattr(args, "lttx_port", None):
+        os.environ["CFQUANT_LTTX_PORT"] = str(args.lttx_port)
+
+
+def _serve_parser(prog="cfquant"):
+    help_command = "%s serve --help" % prog if prog == "cfquant" else "%s --help" % prog
+    if prog == "cfquant":
+        epilog = (
+            "Commands:\n"
+            "  cfquant pipe-hub [options]             Start only the named-pipe hub.\n"
+            "  cfquant qmt-scripts --output DIRECTORY Export bundled QMT entry scripts.\n"
+            "  cfquant version                         Show installed package details.\n"
+            "Use '%s' for dashboard options." % help_command
+        )
+    else:
+        epilog = "Use '%s' for dashboard options." % help_command
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description="Start the cfquant local web dashboard.",
+        epilog=epilog,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--host", help="Web bind address. Defaults to localhost or saved configuration.")
+    parser.add_argument("--port", type=_port, help="Web listen port. Defaults to saved configuration or 8765.")
+    parser.add_argument(
+        "--home",
+        "--state-dir",
+        dest="home",
+        help="Writable cfquant state directory for runtime data, configuration, and logs.",
+    )
+    parser.add_argument("--runtime-dir", help="Override the runtime subdirectory.")
+    parser.add_argument("--log-dir", help="Override the log directory.")
+    parser.add_argument("--config", help="Path to the web configuration JSON file.")
+    parser.add_argument("--pipe-name", help=r"Override the QMT named pipe, e.g. \\.\pipe\cfquant_pipe_hub.")
+    parser.add_argument("--lttx-host", help="LTtx host. Defaults to 127.0.0.1.")
+    parser.add_argument("--lttx-port", type=_port, help="LTtx port. Defaults to 2049.")
+    parser.add_argument("--account-id", help="Default account ID before the web setup wizard is completed.")
+    parser.add_argument("--open-browser", action="store_true", help="Open the dashboard in the default browser after it is ready.")
+    parser.add_argument("--dry-run", action="store_true", help="Print the effective startup settings without starting services.")
+    parser.add_argument("--version", action="version", version=_version_text())
+    return parser
+
+
+def _version_text():
+    return "cfquant package %s\ncore %s\nweb %s" % (_package_version(), CORE_VERSION, WEB_VERSION)
+
+
+def _browser_url(host, port):
+    host = str(host or "").strip()
+    if not host or host in ("0.0.0.0", "::"):
+        host = "127.0.0.1"
+    if ":" in host and not host.startswith("["):
+        host = "[%s]" % host
+    return "http://%s:%s/" % (host, port)
+
+
+def _wait_and_open_browser(host, port):
+    connect_host = str(host or "").strip()
+    if not connect_host or connect_host in ("0.0.0.0", "::"):
+        connect_host = "127.0.0.1"
+    url = _browser_url(connect_host, port)
+    deadline = time.monotonic() + 30.0
+    while time.monotonic() < deadline:
+        try:
+            with socket.create_connection((connect_host.strip("[]"), int(port)), timeout=0.4):
+                webbrowser.open(url)
+                return
+        except OSError:
+            time.sleep(0.25)
+
+
+def _serve(argv, prog="cfquant"):
+    parser = _serve_parser(prog)
+    args = parser.parse_args(argv)
+    _apply_web_environment(args)
+    if args.dry_run:
+        print("cfquant package=%s core=%s web=%s" % (_package_version(), CORE_VERSION, WEB_VERSION))
+        for key in (
+            "CFQUANT_HOME",
+            "CFQUANT_RUNTIME_DIR",
+            "CFQUANT_LOG_DIR",
+            "CFQUANT_WEB_CONFIG_FILE",
+            "CFQUANT_PIPE_NAME",
+            "CFQUANT_LTTX_HOST",
+            "CFQUANT_LTTX_PORT",
+            "CFQUANT_ACCOUNT_ID",
+        ):
+            if os.environ.get(key):
+                print("%s=%s" % (key, os.environ[key]))
+        return 0
+
+    from cfquant_web_server import main as web_main
+
+    server_args = []
+    if args.host:
+        server_args.extend(["--host", args.host])
+    if args.port:
+        server_args.extend(["--port", str(args.port)])
+    if args.open_browser:
+        from cfquant_web_server import WEB_CONFIG, normalize_web_port
+
+        host = args.host or os.environ.get("CFQUANT_WEB_HOST")
+        if not host:
+            host = "0.0.0.0" if WEB_CONFIG.allow_remote() else "127.0.0.1"
+        port = args.port
+        if port is None:
+            port = normalize_web_port(
+                os.environ.get("CFQUANT_WEB_PORT"),
+                default=WEB_CONFIG.web_port(),
+            )
+        thread = threading.Thread(target=_wait_and_open_browser, args=(host, port))
+        thread.daemon = True
+        thread.start()
+    return web_main(server_args)
+
+
+def _qmt_scripts_source_dir():
+    import qmt_scripts
+
+    return Path(qmt_scripts.__file__).resolve().parent
+
+
+def _qmt_scripts_parser():
+    parser = argparse.ArgumentParser(
+        prog="cfquant qmt-scripts",
+        description="Export the QMT entry scripts bundled with this cfquant installation.",
+    )
+    parser.add_argument("--output", "-o", required=True, help="Destination directory for QMT scripts.")
+    parser.add_argument("--force", action="store_true", help="Overwrite existing files in the destination.")
+    return parser
+
+
+def _export_qmt_scripts(argv):
+    parser = _qmt_scripts_parser()
+    args = parser.parse_args(argv)
+    output_dir = Path(_path(args.output))
+    if output_dir.exists() and not output_dir.is_dir():
+        parser.error("output path is not a directory: %s" % output_dir)
+
+    source_dir = _qmt_scripts_source_dir()
+    missing = [name for name in QMT_SCRIPT_FILES if not (source_dir / name).is_file()]
+    if missing:
+        raise RuntimeError("installed cfquant package is missing QMT scripts: %s" % ", ".join(missing))
+    existing = [name for name in QMT_SCRIPT_FILES if (output_dir / name).exists()]
+    if existing and not args.force:
+        parser.error("destination already has files; use --force to replace: %s" % ", ".join(existing))
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    for relative_name in QMT_SCRIPT_FILES:
+        source = source_dir / relative_name
+        target = output_dir / relative_name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(str(source), str(target))
+    print("Exported %s QMT files to %s" % (len(QMT_SCRIPT_FILES), output_dir))
+    return 0
+
+
+def _print_version():
+    package_root = Path(__file__).resolve().parent
+    qmt_scripts_dir = _qmt_scripts_source_dir()
+    print(_version_text())
+    print("package_root %s" % package_root)
+    print("qmt_scripts %s" % qmt_scripts_dir)
+    return 0
+
+
+def web_main(argv=None):
+    """Backward-compatible entry point for the ``cfquant-web`` command."""
+    return _serve(list(sys.argv[1:] if argv is None else argv), prog="cfquant-web")
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if not argv:
+        return _serve([])
+    command = argv[0]
+    if command in ("serve", "web"):
+        return _serve(argv[1:])
+    if command == "pipe-hub":
+        from cfquant_pipe_hub import main as pipe_hub_main
+
+        return pipe_hub_main(argv[1:])
+    if command in ("qmt-scripts", "qmt"):
+        return _export_qmt_scripts(argv[1:])
+    if command in ("version", "info"):
+        return _print_version()
+    if command in ("help", "-h", "--help"):
+        return _serve(["--help"])
+    return _serve(argv)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())