cfquant 0.2.50__tar.gz → 0.2.52__tar.gz

{cfquant-0.2.50 → cfquant-0.2.52}/PKG-INFO

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

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/build_info.py

@@ -29,6 +29,8 @@ def get_git_commit(source_root=None):
     override = _valid_commit(os.environ.get("CFQUANT_GIT_COMMIT"))
     if override:
         return override
+    if os.environ.get("CFQUANT_QMT_NO_FILE_IO") == "1":
+        return ""
     root = Path(source_root or Path(__file__).resolve().parent.parent).resolve()
     try:
         result = subprocess.run(["git", "-C", str(root), "rev-parse", "HEAD"], stdout=subprocess.PIPE,

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/client.py

@@ -7,7 +7,8 @@ import time
 
 from .config import get_config
 from .callback_dispatcher import CallbackDispatcher, dispatch_callbacks
-from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .rpc_timing import RpcTiming
 
 
 class CfquantError(RuntimeError):
@@ -155,7 +156,7 @@ class LTtxRpcClient(object):
                         pass
                 self._pending.clear()
 
-    def request(self, action, params=None, timeout=None, request_channel=None):
+    def request(self, action, params=None, timeout=None, request_channel=None, response_meta=None):
         effective_timeout = float(timeout or self.timeout)
         request_id = new_id("req")
         raw = pack_request(
@@ -167,6 +168,7 @@ class LTtxRpcClient(object):
             timeout=effective_timeout,
         )
         q = queue.Queue(maxsize=1)
+        timing = RpcTiming(response_meta, request_id)
         try:
             with self._lock:
                 self.start()
@@ -177,11 +179,13 @@ class LTtxRpcClient(object):
                 msg = q.get(timeout=effective_timeout)
             except queue.Empty:
                 raise CfquantTimeout("cfquant request timeout: %s" % action)
-            if not msg.get("ok"):
+            timing.received(msg)
+            if not msg.get("ok"):
                 err = msg.get("error") or {}
                 raise CfquantError(err.get("message") or str(err))
-            return decode_value(msg.get("result"))
-        finally:
+            return timing.decode(msg.get("result"), decode_value)
+        finally:
+            timing.finish()
             with self._pending_lock:
                 self._pending.pop(request_id, None)
 

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/level2.py

@@ -1,5 +1,7 @@
 """Level2 data adapters shared by the SDK and QMT bridges."""
 
+from .protocol import dataframe_numeric_rows
+
 L2_PERIODS = (
     "l2quote", "l2quoteaux", "l2order", "l2transaction",
     "l2transactioncount", "l2orderqueue",
@@ -93,7 +95,11 @@ def quote_plain(value):
 
 def quote_records(value):
     if hasattr(value, "columns") and hasattr(value, "to_dict"):
-        # DataFrame.values can round large integer IDs in a mixed float/int table.
+        rows = dataframe_numeric_rows(value)
+        if rows is not None:
+            columns = list(value.columns)
+            return quote_plain([dict(zip(columns, row)) for row in rows])
+        # Keep pandas' scalar boxing for nullable, date-like and object fields.
         return quote_plain(value.to_dict("records"))
     names = getattr(getattr(value, "dtype", None), "names", None)
     if names:

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/normal_bridge.py

@@ -10,7 +10,7 @@ import threading
 import time
 
 from . import order_meta
-from .order_identity import prepare_order_remark, order_remark_key, restore_order_remark
+from .order_identity import prepare_order_remark, order_remark_key, restore_order_remark, restore_strategy_name
 from .level2 import L2_THOUSAND_SUBSCRIPTIONS, quote_callback_data, quote_plain, require_l2_callable, thousand_price
 from .protocol import loads_message, pack_event, pack_response
 from .tx_trade_bridge import TxTradeBridge, relay_sync_order_callback
@@ -184,6 +184,7 @@ class NormalQmtBridge(TxTradeBridge):
         msg = loads_message(raw)
         if not msg or msg.get("type") != "request":
             return
+        msg["_received_monotonic"] = time.perf_counter()
         action = msg.get("action")
         if action == "cfquant.ping":
             self._send_response(msg, {"pong": True, "ts": time.time(), "request_channel": self.request_channel})
@@ -191,6 +192,12 @@ class NormalQmtBridge(TxTradeBridge):
         if action == "cfquant.status":
             self._send_response(msg, self._status())
             return
+        if action == "cfquant.strategy.control":
+            try:
+                self._send_response(msg, self._dispatch(action, msg.get("params") or {}, msg))
+            except Exception as error:
+                self._send_error(msg, error)
+            return
         if self._try_enqueue_coalesced_request(msg):
             return
         try:
@@ -834,7 +841,7 @@ class NormalQmtBridge(TxTradeBridge):
         client_id = msg.get("client_id") or msg.get("reply_channel")
         if not client_id:
             return
-        response = pack_response(msg.get("id"), ok=True, result=result)
+        response = pack_response(msg.get("id"), ok=True, result=result, meta=msg.get("_response_meta"))
         self.tx.push("response", response, client_id)
 
     def _send_error(self, msg, error):
@@ -845,7 +852,7 @@ class NormalQmtBridge(TxTradeBridge):
             "normal bridge send_error action=%s id=%s client_id=%s error=%s"
             % (msg.get("action"), msg.get("id"), client_id, error)
         )
-        response = pack_response(msg.get("id"), ok=False, error=error)
+        response = pack_response(msg.get("id"), ok=False, error=error, meta=msg.get("_response_meta"))
         self.tx.push("response", response, client_id)
 
     def publish_callback_event(self, event_name, obj):
@@ -894,6 +901,7 @@ class NormalQmtBridge(TxTradeBridge):
             relay_sync_order_callback(self.context, data)
             self._handle_async_order_callback(data)
             self._remember_order_callback_fields(data)
+        restore_strategy_name(data)
         payload = {
             "type": "event",
             "event": event_name,

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/order_identity.py

@@ -12,6 +12,23 @@ from collections import OrderedDict
 
 
 _ORDER_REMARK_SUFFIX = re.compile(r"__cfq_([0-9a-f]{32})$")
+_STRATEGY_NAME_SUFFIX = re.compile(r"(?:&&&_cfq_|^cfq_)[0-9a-f]{12}\Z")
+
+
+def restore_strategy_name(data):
+    """Remove our request token only at the public callback/object boundary.
+
+    Keep the full strategy until error-context matching has finished. Match
+    the generated suffix precisely so user underscores and delimiters survive.
+    """
+    if isinstance(data, dict):
+        for name in ("strategy_name", "m_strStrategyName", "mstrStrategyName", "strategyName"):
+            value = data.get(name)
+            if isinstance(value, str):
+                match = _STRATEGY_NAME_SUFFIX.search(value)
+                if match:
+                    data[name] = value[:match.start()]
+    return data
 
 
 def original_order_remark(value):

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/pipe_bridge.py

@@ -8,7 +8,9 @@ from .pipe_transport import DEFAULT_PIPE_NAME, PipeTxClient
 from .tx_trade_bridge import TxTradeBridge
 
 
-class PipeNormalQmtBridge(NormalQmtBridge):
+class PipeNormalQmtBridge(NormalQmtBridge):
+    file_io_enabled = False
+
     def __init__(
         self,
         context,
@@ -48,6 +50,9 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         self.connect_timeout_ms = int(connect_timeout_ms)
 
     def start(self):
+        runtime = self.globals_dict.get("_managed_runtime")
+        if runtime is not None:
+            runtime.attach_bridge(self)
         if self.running:
             return self
         self.running = True
@@ -61,7 +66,9 @@ class PipeNormalQmtBridge(NormalQmtBridge):
             endpoint_name="normal",
             show=self.show,
             connect_timeout_ms=self.connect_timeout_ms,
-        ).start()
+        )
+        self.tx._log = self._log
+        self.tx.start()
         self.tx.start_txg(self.request_channel)
         self.recv_thread = threading.Thread(target=self._recv_loop)
         self.recv_thread.daemon = True
@@ -103,7 +110,9 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         return data
 
 
-class PipeTradeBridge(TxTradeBridge):
+class PipeTradeBridge(TxTradeBridge):
+    file_io_enabled = False
+
     def __init__(
         self,
         context,
@@ -131,6 +140,9 @@ class PipeTradeBridge(TxTradeBridge):
         self.connect_timeout_ms = int(connect_timeout_ms)
 
     def start(self):
+        runtime = self.globals_dict.get("_managed_runtime")
+        if runtime is not None:
+            runtime.attach_bridge(self)
         if self.running:
             return self
         self.running = True
@@ -143,7 +155,9 @@ class PipeTradeBridge(TxTradeBridge):
             endpoint_name="trade",
             show=self.show,
             connect_timeout_ms=self.connect_timeout_ms,
-        ).start()
+        )
+        self.tx._log = self._log
+        self.tx.start()
         self.tx.start_txg(self.request_channel)
         self._log(
             "pipe trade bridge started pipe=%s request_channel=%s"

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/pipe_client.py

@@ -11,7 +11,8 @@ from .pipe_transport import (
     loads_pipe_message,
     normalize_pipe_name,
 )
-from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .rpc_timing import RpcTiming
 
 
 class PipeRpcClient(object):
@@ -70,7 +71,7 @@ class PipeRpcClient(object):
             self._close_conns_locked()
             self._fail_pending("cfquant pipe client closed")
 
-    def request(self, action, params=None, timeout=None, request_channel=None):
+    def request(self, action, params=None, timeout=None, request_channel=None, response_meta=None):
         effective_timeout = float(timeout or self.timeout)
         request_id = new_id("req")
         raw = pack_request(
@@ -82,6 +83,7 @@ class PipeRpcClient(object):
             timeout=effective_timeout,
         )
         q = queue.Queue(maxsize=1)
+        timing = RpcTiming(response_meta, request_id)
         try:
             with self._lock:
                 self.start()
@@ -98,13 +100,15 @@ class PipeRpcClient(object):
                 from .client import CfquantTimeout
 
                 raise CfquantTimeout("cfquant pipe request timeout: %s" % action)
-            if not msg.get("ok"):
+            timing.received(msg)
+            if not msg.get("ok"):
                 err = msg.get("error") or {}
                 from .client import CfquantError
 
                 raise CfquantError(err.get("message") or str(err))
-            return decode_value(msg.get("result"))
-        finally:
+            return timing.decode(msg.get("result"), decode_value)
+        finally:
+            timing.finish()
             with self._pending_lock:
                 self._pending.pop(request_id, None)
 

{cfquant-0.2.50 → cfquant-0.2.52}/cfquant/protocol.py

@@ -80,8 +80,8 @@ def loads_message(raw):
         raw = raw.decode("utf-8", errors="replace")
     if not isinstance(raw, str):
         return None
-    if "|" in raw:
-        _, raw = raw.split("|", 1)
+    if not raw.startswith(MESSAGE_PREFIX) and "|" in raw:
+        _, raw = raw.split("|", 1)
     if not raw.startswith(MESSAGE_PREFIX):
         return None
     try:
@@ -107,14 +107,20 @@ def pack_request(action, params=None, reply_channel=None, client_id=None, reques
     return dumps_message(payload)
 
 
-def pack_response(request_id, ok=True, result=None, error=None, meta=None):
-    return dumps_message({
+def pack_response(request_id, ok=True, result=None, error=None, meta=None):
+    started = time.perf_counter()
+    encoded = encode_value(result)
+    meta = dict(meta or {})
+    timing = meta.get("timing")
+    if isinstance(timing, dict) and isinstance(timing.get("qmt"), dict):
+        timing["qmt"]["encode_ms"] = round((time.perf_counter() - started) * 1000, 3)
+    return dumps_message({
         "type": "response",
         "id": request_id,
         "ok": bool(ok),
-        "result": encode_value(result),
+        "result": encoded,
         "error": encode_error(error),
-        "meta": meta or {},
+        "meta": meta,
     })
 
 
@@ -212,25 +218,60 @@ def _looks_like_series(value):
     )
 
 
-def _clean_cell(value):
+def _clean_cell(value):
     if value is None:
         return None
     if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
         return None
-    return encode_value(value)
-
-
+    return encode_value(value)
+
+
+def dataframe_numeric_rows(value):
+    """Bulk rows for plain numeric frames; None keeps pandas' other semantics."""
+    columns = getattr(value, "columns", None)
+    dtypes = getattr(value, "dtypes", None)
+    if columns is None or not len(columns) or dtypes is None or not getattr(columns, "is_unique", False):
+        return None
+    # Nullable, object and date-like columns need pandas' scalar boxing rules.
+    # Restrict this fast path so callers keep their existing null/date behavior.
+    for dtype in dtypes:
+        if (type(dtype).__module__.split(".", 1)[0] != "numpy"
+                or dtype.kind not in ("b", "i", "u", "f") or dtype.itemsize > 8):
+            return None
+    # Combining mixed numeric blocks before this cast can round large IDs.
+    return value.astype(object, copy=False).values.tolist()
+
+
 def _encode_dataframe(value):
     try:
-        raw_rows = list(value.itertuples(index=False, name=None))
+        # itertuples builds a Series per column, which is expensive for QMT's
+        # stock-by-date history frames. Cast BEFORE combining the blocks: using
+        # values directly can round int64/uint64 IDs in mixed float/int frames.
+        # astype also works with QMT's pandas 0.22 (which has no to_numpy).
+        raw_rows = value.astype(object, copy=False).values.tolist() if len(value.columns) else []
     except Exception:
         try:
-            raw_rows = value.values.tolist()
+            raw_rows = list(value.itertuples(index=False, name=None))
         except Exception:
-            raw_rows = []
-    rows = []
-    for row in raw_rows:
-        rows.append([_clean_cell(v) for v in row])
+            try:
+                raw_rows = value.values.tolist()
+            except Exception:
+                raw_rows = []
+    rows = []
+    for row in raw_rows:
+        rows.append([_clean_cell(v) for v in row])
+    # Thousands of date columns usually share one dtype. Formatting its name
+    # repeatedly can cost more than extracting the actual values.
+    dtype_flags = {}
+    object_columns = []
+    for name, dtype in getattr(value, "dtypes", {}).items():
+        is_object = dtype_flags.get(dtype)
+        if is_object is None:
+            dtype_name = str(dtype)
+            is_object = dtype_name == "object" or dtype_name.startswith(("Int", "UInt"))
+            dtype_flags[dtype] = is_object
+        if is_object:
+            object_columns.append(_encode_label(name))
     index_name = getattr(getattr(value, "index", None), "name", None)
     return {
         "__cf_type__": "dataframe",
@@ -238,8 +279,7 @@ def _encode_dataframe(value):
         "index": [_encode_label(i) for i in getattr(value, "index", [])],
         "data": rows,
         "index_name": _encode_label(index_name) if index_name is not None else None,
-        "object_columns": [_encode_label(name) for name, dtype in getattr(value, "dtypes", {}).items()
-                           if str(dtype) == "object" or str(dtype).startswith(("Int", "UInt"))],
+        "object_columns": object_columns,
     }
 
 
@@ -328,6 +368,13 @@ def decode_value(value):
                     parts[2] = tuple(parts[2])
                 dtype_descr.append(tuple(parts))
             dtype = np.dtype(dtype_descr)
+            # JSON turns each structured record tuple into a list. NumPy
+            # treats that list as another array dimension unless restored.
+            def record_tuples(items, dimensions):
+                if dimensions == 0:
+                    return tuple(items)
+                return [record_tuples(item, dimensions - 1) for item in items]
+            data = record_tuples(data, len(value.get("shape", [len(data)])))
         elif value.get("dtype"):
             try:
                 dtype = np.dtype(value.get("dtype"))

cfquant-0.2.52/cfquant/qmt_binding_settings.py

@@ -0,0 +1,39 @@
+"""Persisted per-binding QMT scheduling and log preferences."""
+DEFAULT_TIMER_INTERVAL_MS = 1
+MIN_TIMER_INTERVAL_MS = 1
+MAX_TIMER_INTERVAL_MS = 1000
+
+
+def normalize_qmt_runtime_settings(value=None, existing=None, strict=False):
+    if value is not None and not isinstance(value, dict):
+        if strict:
+            raise ValueError("QMT runtime settings must be an object")
+        value = None
+    data = dict(existing or {})
+    data.update(value or {})
+    interval = data.get("timer_interval_ms", DEFAULT_TIMER_INTERVAL_MS)
+    try:
+        if isinstance(interval, bool) or str(interval).strip() != str(int(interval)):
+            raise ValueError()
+        interval = int(interval)
+        if not MIN_TIMER_INTERVAL_MS <= interval <= MAX_TIMER_INTERVAL_MS:
+            raise ValueError()
+    except (TypeError, ValueError, OverflowError):
+        if strict:
+            raise ValueError("QMT 调度间隔必须是 1–1000 ms 的整数")
+        interval = DEFAULT_TIMER_INTERVAL_MS
+    enabled = data.get("log_enabled")  # None preserves legacy global preferences.
+    if enabled is not None and not isinstance(enabled, bool):
+        if strict:
+            raise ValueError("QMT 日志设置必须为 true、false 或 null（跟随全局）")
+        enabled = None
+    return {"timer_interval_ms": interval, "log_enabled": enabled}
+
+
+def qmt_runtime_identity(row, global_log_enabled=True):
+    settings = normalize_qmt_runtime_settings((row or {}).get("qmt_runtime"))
+    enabled = settings["log_enabled"]
+    if (row or {}).get("mode") == "lttx":
+        enabled = None  # Advanced entries keep their existing global controls.
+    return {"qmt_timer_interval_ms": settings["timer_interval_ms"],
+            "qmt_log_enabled": bool(global_log_enabled) if enabled is None else enabled}

cfquant-0.2.52/cfquant/qmt_pipe_runtime.py

@@ -0,0 +1,166 @@
+"""In-memory managed strategy control over the existing Pipe connection (QMT 3.6+)."""
+
+import functools as _cq_functools
+import os as _cq_os
+import sys as _cq_sys
+import threading as _cq_threading
+import time as _cq_time
+
+
+class ManagedPipeRuntime(object):
+    def __init__(self, descriptor=None):
+        self.descriptor = dict(descriptor or {})
+        self.active = False
+        self.approved = False
+        self.revoked = False
+        self.namespace = {}
+        self.original_stop = None
+        self.failure = ""
+        self.calls = 0
+        self.bridges_closed = False
+        self.attached_bridges = []
+        self.mutex = _cq_threading.RLock()
+
+    def acquire(self):
+        if not self.descriptor:
+            self.active = True
+            return self
+        # sys survives strategy namespace reloads inside one QMT process.
+        # Across processes the Pipe hub arbitrates ownership of request channels.
+        registry = _cq_sys.__dict__.setdefault("_cfquant_pipe_strategies", {})
+        lock = _cq_sys.__dict__.setdefault("_cfquant_pipe_strategies_lock", _cq_threading.RLock())
+        with lock:
+            key = (self.descriptor["runtime_key"], self.descriptor["role"])
+            incompatible = any(scope[0] == key[0] and (
+                owner.descriptor.get("mode") != self.descriptor["mode"]
+                or owner.descriptor.get("generation") != self.descriptor["generation"])
+                for scope, owner in registry.items())
+            if key in registry or incompatible:
+                raise RuntimeError("Another cfquant strategy still owns this QMT account role.")
+            registry[key] = self
+            self.active = True
+        return self
+
+    def status(self):
+        bridges = [self.namespace.get(name) for name in ("_normal_bridge", "_trade_bridge")
+                   if self.namespace.get(name) is not None]
+        ready = bool(bridges) and all(getattr(bridge, "running", False)
+                                     and getattr(bridge, "context", None) is not None for bridge in bridges)
+        state = "error" if self.failure else ("stopped" if not self.active or self.revoked
+                                              else ("running" if ready and self.approved else "loaded"))
+        return dict(self.descriptor, state=state, error=self.failure,
+                    pid=_cq_os.getpid(), updated_at=_cq_time.time())
+
+    def control(self, desired):
+        if desired.get("runtime_key") != self.descriptor.get("runtime_key"):
+            raise ValueError("Managed strategy account scope mismatch")
+        accepted = desired.get("accepted_generations") or []
+        if not isinstance(accepted, (tuple, list)):
+            accepted = []
+        allowed = (desired.get("enabled") is True
+                   and desired.get("mode") == self.descriptor["mode"]
+                   and self.descriptor["generation"] in [desired.get("generation")] + accepted)
+        with self.mutex:
+            self.approved = allowed and self.active and not self.revoked
+            if not allowed and not self.revoked:
+                self.revoked = True
+                # Block requests immediately; let the control response leave before closing Pipe.
+                worker = _cq_threading.Timer(0.1, self.close)
+                worker.daemon = True
+                worker.start()
+        return self.status()
+
+    def dispatch(self, function):
+        dispatch_request = self.wrap(function, reject=True)
+        @_cq_functools.wraps(function)
+        def guarded(action, params, msg):
+            if action == "cfquant.strategy.control":
+                return self.control(params or {})
+            if action == "cfquant.status":
+                return function(action, params, msg)
+            if not self.approved:
+                raise RuntimeError("Managed strategy is awaiting account mode confirmation from cfquant Web.")
+            return dispatch_request(action, params, msg)
+        return guarded
+
+    def wrap(self, function, reject=False):
+        @_cq_functools.wraps(function)
+        def guarded(*args, **kwargs):
+            with self.mutex:
+                if not self.active or self.revoked:
+                    if reject:
+                        raise RuntimeError("The account's cfquant strategy mode has changed.")
+                    return None
+                self.calls += 1
+            try:
+                return function(*args, **kwargs)
+            except Exception as error:
+                if function.__name__ == "init":
+                    self.failure = str(error)
+                    self.close()
+                raise
+            finally:
+                with self.mutex:
+                    self.calls -= 1
+                    self.release_if_idle()
+        return guarded
+
+    def bind(self, namespace):
+        if not self.descriptor:
+            return
+        self.namespace = namespace
+        self.original_stop = namespace.get("stop")
+        for name, value in list(namespace.items()):
+            if (name in ("init", "after_init", "handlebar", "cfquant_normal_timer", "cfquant_ctype_trade_timer")
+                    or name.endswith("_callback")) and callable(value):
+                namespace[name] = self.wrap(value)
+        for name in ("_normal_bridge", "_trade_bridge"):
+            bridge = namespace.get(name)
+            if bridge is not None:
+                self.attach_bridge(bridge)
+        namespace["stop"] = self.close
+
+    def attach_bridge(self, bridge):
+        if bridge not in self.attached_bridges:
+            self.attached_bridges.append(bridge)
+        if not self.descriptor or getattr(bridge, "managed_runtime", None) is self:
+            return
+        bridge.managed_runtime = self
+        bridge._dispatch = self.dispatch(bridge._dispatch)
+        for method in ("start", "poll", "pump"):
+            function = getattr(bridge, method, None)
+            if callable(function):
+                setattr(bridge, method, self.wrap(function))
+
+    def release_if_idle(self):
+        if self.bridges_closed and self.calls == 0:
+            registry = _cq_sys.__dict__.get("_cfquant_pipe_strategies", {})
+            key = (self.descriptor.get("runtime_key"), self.descriptor.get("role"))
+            lock = _cq_sys.__dict__.setdefault("_cfquant_pipe_strategies_lock", _cq_threading.RLock())
+            with lock:
+                if registry.get(key) is self:
+                    registry.pop(key, None)
+
+    def close(self, context=None):
+        with self.mutex:
+            if not self.active:
+                return
+            self.active = False
+            self.approved = False
+        try:
+            if self.original_stop is not None:
+                self.original_stop(context)
+            else:
+                bridges = list(self.attached_bridges)
+                for name in ("_normal_bridge", "_trade_bridge"):
+                    bridge = self.namespace.get(name)
+                    if bridge is not None and bridge not in bridges:
+                        bridges.append(bridge)
+                for bridge in bridges:
+                    bridge.close()
+            with self.mutex:
+                self.bridges_closed = True
+                self.release_if_idle()
+        except Exception as error:
+            self.failure = str(error)
+            print("cfquant strategy shutdown failed: %s" % error)