cfquant 0.2.49__tar.gz → 0.2.51__tar.gz

{cfquant-0.2.49 → cfquant-0.2.51}/PKG-INFO

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

{cfquant-0.2.49 → cfquant-0.2.51}/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.49 → cfquant-0.2.51}/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
@@ -191,6 +191,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:
@@ -893,6 +899,8 @@ class NormalQmtBridge(TxTradeBridge):
             self._resolve_pending_sync_order_callback(data)
             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.51/cfquant/order_identity.py

@@ -0,0 +1,190 @@
+"""Per-submission QMT remarks, compatible with embedded Python 3.6.
+
+The public remark is user data, never a unique order key. Keep a UUID in the
+native remark so independent QMT processes and restarts can recover both.
+"""
+
+import re
+import threading
+import time
+import uuid
+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):
+    text = str(value or "")
+    match = _ORDER_REMARK_SUFFIX.search(text)
+    return text[:match.start()] if match else text
+
+
+def is_unique_order_remark(value):
+    return bool(_ORDER_REMARK_SUFFIX.search(str(value or "")))
+
+
+def prepare_order_remark(params, fallback=""):
+    original = next((params[name] for name in ("order_remark", "remark", "strategy_name")
+                     if params.get(name) not in (None, "")), "")
+    original = str(original or "")
+    internal = params.get("cfquant_order_remark")
+    if not (is_unique_order_remark(internal) and
+            original_order_remark(internal) in (original, original or str(fallback or ""))):
+        original = original or str(fallback or "")
+        internal = original + "__cfq_" + uuid.uuid4().hex
+    params["cfquant_order_remark"] = internal
+    return internal
+
+
+def order_remark_key(data):
+    getter = data.get if isinstance(data, dict) else lambda name: getattr(data, name, None)
+    values = [getter(name) for name in (
+        "cfquant_order_remark", "user_order_id", "client_order_id",
+        "order_remark", "m_strRemark", "m_strOrderRemark", "remark",
+    )]
+    for value in values:
+        if is_unique_order_remark(value):
+            return str(value)
+    return next((str(value) for value in values if value not in (None, "")), "")
+
+
+def restore_order_remark(data):
+    if isinstance(data, dict):
+        internal = order_remark_key(data)
+        if is_unique_order_remark(internal):
+            data["cfquant_order_remark"] = internal
+            data["order_remark"] = original_order_remark(internal)
+    return data
+
+
+def order_remark_matches_reference(expected, actual):
+    """Compare remarks only AFTER an order reference has matched.
+
+    Some DEAL reports echo the public remark without our UUID. A different
+    UUID still identifies a different submission, even with the same text.
+    """
+    return (not actual or expected == actual or
+            (is_unique_order_remark(expected) and
+             not is_unique_order_remark(actual) and
+             original_order_remark(expected) == actual))
+
+
+class OrderCallbackCache(object):
+    """Bounded, daily order metadata indexed by separate local/broker IDs."""
+
+    def __init__(self, max_orders=4096):
+        self.max_orders = max_orders
+        self.lock = threading.RLock()
+        self.day = ""
+        self.records = OrderedDict()
+        self.by_ref = {}
+
+    def _identity(self, data, account_type):
+        day = time.strftime("%Y%m%d")
+        if day != self.day:
+            self.records.clear()
+            self.by_ref.clear()
+            self.day = day
+        # Historical query rows must not seed today's broker-ID mapping.
+        for name in ("order_date", "trade_date", "m_strInsertDate", "m_strTradeDate", "m_strTradingDay"):
+            value = str(data.get(name) or "").replace("-", "").replace("/", "")
+            if len(value) == 8 and value.isdigit() and value != day:
+                return None, set()
+        account = str(data.get("account_id") or data.get("m_strAccountID") or "").strip()
+        stock = str(data.get("stock_code") or data.get("m_strInstrumentID") or "").strip().upper()
+        market = str(data.get("market") or data.get("m_strExchangeID") or "").strip().upper()
+        if "." in stock:
+            stock, market = stock.rsplit(".", 1)
+        if not account or not stock:
+            return None, set()
+        scope = (account_type, account, stock, market)
+        refs = set()
+        for name in ("order_id", "m_nRef", "m_nOrderID", "m_strOrderRef", "m_strOrderID"):
+            value = str(data.get(name) or "").strip()
+            if value.isdigit() and int(value) > 0:
+                refs.add(("local", str(int(value))))
+        for name in ("order_sysid", "m_strOrderSysID"):
+            value = str(data.get(name) or "").strip()
+            if value and value not in ("0", "-1"):
+                refs.add(("broker", value))
+        return scope, refs
+
+    def _matches(self, scope, refs, data):
+        groups = [self.by_ref[(scope, ref)] for ref in refs if (scope, ref) in self.by_ref]
+        candidates = set.intersection(*groups) if groups else set()
+        matches = []
+        for key in candidates:
+            record = self.records[key]
+            expected, actual = order_remark_key(record["data"]), order_remark_key(data)
+            if expected and not order_remark_matches_reference(expected, actual):
+                continue
+            local = {ref for ref in refs if ref[0] == "local"}
+            known = {ref for ref in record["refs"] if ref[0] == "local"}
+            if local and known and not local.intersection(known):
+                continue
+            matches.append(key)
+        return matches
+
+    def remember(self, data, account_type):
+        if not (data.get("strategy_name") or data.get("m_strStrategyName") or order_remark_key(data)):
+            return
+        with self.lock:
+            scope, refs = self._identity(data, account_type)
+            if scope is None or not refs:
+                return
+            matches = self._matches(scope, refs, data)
+            remark = order_remark_key(data)
+            local = sorted(ref for ref in refs if ref[0] == "local")
+            identity = ("remark", remark) if is_unique_order_remark(remark) else (local or sorted(refs))[0]
+            key = (scope, identity)
+            if len(matches) == 1:
+                key = matches[0]
+            record = self.records.get(key, {"data": {}, "refs": set()})
+            record["data"].update({name: value for name, value in data.items() if value not in (None, "")})
+            record["refs"].update(refs)
+            self.records[key] = record
+            self.records.move_to_end(key)
+            for ref in refs:
+                self.by_ref.setdefault((scope, ref), set()).add(key)
+            while len(self.records) > self.max_orders:
+                old_key, old = self.records.popitem(last=False)
+                for ref in old["refs"]:
+                    index = (old_key[0], ref)
+                    self.by_ref[index].discard(old_key)
+                    if not self.by_ref[index]:
+                        del self.by_ref[index]
+
+    def enrich(self, data, account_type):
+        with self.lock:
+            scope, refs = self._identity(data, account_type)
+            matches = self._matches(scope, refs, data) if scope is not None else []
+            if len(matches) != 1:
+                return data
+            saved = self.records[matches[0]]["data"]
+            strategy = saved.get("strategy_name") or saved.get("m_strStrategyName")
+            remark = order_remark_key(saved)
+            for name, value in (("strategy_name", strategy), ("m_strStrategyName", strategy),
+                                ("order_remark", remark), ("m_strRemark", remark), ("m_strOrderRemark", remark)):
+                if value and not data.get(name):
+                    data[name] = value
+            if is_unique_order_remark(remark):
+                data["cfquant_order_remark"] = remark
+        return restore_order_remark(data)

{cfquant-0.2.49 → cfquant-0.2.51}/cfquant/order_meta.py

@@ -13,6 +13,7 @@ import re
 import threading
 from .stock_connect import connect_account_type
 from .order_identity import order_remark_key, restore_order_remark, is_unique_order_remark
+from .order_identity import order_remark_matches_reference
 import time
 
 
@@ -609,7 +610,7 @@ class OrderMetaCache(object):
             for order_ref in order_refs:
                 record = self.by_ref.get(self._ctx(callback_record) + (order_ref,))
                 if record and user_order_id and is_unique_order_remark(user_order_id_from_data(record)):
-                    if user_order_id != user_order_id_from_data(record):
+                    if not order_remark_matches_reference(user_order_id_from_data(record), user_order_id):
                         record = None
                 if record:
                     confidence = "order_ref"

{cfquant-0.2.49 → cfquant-0.2.51}/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
@@ -103,7 +108,9 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         return data
 
 
-class PipeTradeBridge(TxTradeBridge):
+class PipeTradeBridge(TxTradeBridge):
+    file_io_enabled = False
+
     def __init__(
         self,
         context,
@@ -131,6 +138,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

cfquant-0.2.51/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)