cfquant 0.2.38__tar.gz → 0.2.40__tar.gz

{cfquant-0.2.38 → cfquant-0.2.40}/PKG-INFO

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

{cfquant-0.2.38 → cfquant-0.2.40}/cfquant/__init__.py

@@ -12,7 +12,13 @@ cfquant: 面向 QMT 的 xtquant 兼容层。
 from . import xtconstant, xtdata, xttrader, xttype
 from . import cftrader
 from .client import CfquantError, CfquantTimeout, configure, get_client
-from .version import __version__
+from .version import __version__
+from .build_info import build_identity, get_git_commit
+
+_BUILD_IDENTITY = build_identity(__version__)
+GIT_COMMIT = _BUILD_IDENTITY["git_commit"]
+SHORT_GIT_COMMIT = _BUILD_IDENTITY["short_commit"]
+BUILD_VERSION = _BUILD_IDENTITY["build_version"]
 
 __all__ = [
     "xtconstant",
@@ -24,5 +30,10 @@ __all__ = [
     "get_client",
     "CfquantError",
     "CfquantTimeout",
-    "__version__",
-]
+    "__version__",
+    "GIT_COMMIT",
+    "SHORT_GIT_COMMIT",
+    "BUILD_VERSION",
+    "get_git_commit",
+    "build_identity",
+]

cfquant-0.2.40/cfquant/build_info.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""Build and source identity helpers."""
+import os
+import re
+import subprocess
+from functools import lru_cache
+from pathlib import Path
+
+_COMMIT_RE = re.compile(r"^[0-9a-f]{40}$", re.IGNORECASE)
+
+def _valid_commit(value):
+    value = str(value or "").strip().lower()
+    return value if _COMMIT_RE.fullmatch(value) else ""
+
+def _read_git_dir(source_root):
+    marker = Path(source_root) / ".git"
+    if marker.is_dir():
+        return marker
+    if marker.is_file():
+        text = marker.read_text(encoding="utf-8", errors="replace").strip()
+        if text.lower().startswith("gitdir:"):
+            path = Path(text.split(":", 1)[1].strip())
+            return path if path.is_absolute() else (marker.parent / path).resolve()
+    return None
+
+@lru_cache(maxsize=8)
+def get_git_commit(source_root=None):
+    """Return the full source commit, or an empty string when unavailable."""
+    override = _valid_commit(os.environ.get("CFQUANT_GIT_COMMIT"))
+    if override:
+        return override
+    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,
+                                stderr=subprocess.DEVNULL, text=True, timeout=2, check=False)
+        commit = _valid_commit(result.stdout)
+        if commit:
+            return commit
+    except Exception:
+        pass
+    git_dir = _read_git_dir(root)
+    if not git_dir:
+        return ""
+    try:
+        head = (git_dir / "HEAD").read_text(encoding="ascii", errors="ignore").strip()
+        if head.startswith("ref: "):
+            ref = head[5:].strip()
+            ref_path = git_dir / ref
+            if ref_path.is_file():
+                return _valid_commit(ref_path.read_text(encoding="ascii", errors="ignore"))
+            packed = git_dir / "packed-refs"
+            if packed.is_file():
+                for line in packed.read_text(encoding="ascii", errors="ignore").splitlines():
+                    parts = line.split()
+                    if len(parts) == 2 and parts[1] == ref:
+                        return _valid_commit(parts[0])
+        return _valid_commit(head)
+    except Exception:
+        return ""
+
+def build_identity(version, source_root=None):
+    commit = get_git_commit(source_root)
+    short = commit[:7] if commit else ""
+    return {"git_commit": commit, "short_commit": short,
+            "build_version": "%s+g%s" % (version, short) if version and short else str(version or "")}

cfquant-0.2.40/cfquant/callback_dispatcher.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""Serial user callbacks, independent of the RPC receive thread."""
+from collections import deque
+import logging
+import threading
+
+from .protocol import decode_value
+
+
+class CallbackDispatcher(object):
+    def __init__(self, dispatch):
+        self._dispatch = dispatch
+        self._condition = threading.Condition()
+        self._queue = deque()
+        self._generation = 0
+        self._active = False
+        self._thread = None
+        self._context = threading.local()
+
+    def start(self):
+        with self._condition:
+            self._generation += 1
+            self._active = True
+            self._queue.clear()
+            return self._generation
+
+    def stop(self):
+        with self._condition:
+            self._active = False
+            self._generation += 1
+            self._queue.clear()
+            self._condition.notify_all()
+        # Never join: close/stop may be called by a callback itself.
+
+    def submit(self, generation, message):
+        with self._condition:
+            if not self._active or generation != self._generation:
+                return
+            # Do not block the receive thread on a slow user callback. Trade
+            # events cannot be silently dropped or coalesced.
+            self._queue.append((generation, message))
+            if self._thread is None:
+                self._thread = threading.Thread(target=self._run, name="cfquant-event-callback")
+                self._thread.daemon = True
+                self._thread.start()
+            self._condition.notify()
+
+    def is_current_callback(self):
+        generation = getattr(self._context, "generation", None)
+        with self._condition:
+            return generation is None or (self._active and generation == self._generation)
+
+    def check_request(self):
+        if not self.is_current_callback():
+            raise RuntimeError("callback belongs to a closed cfquant connection")
+
+    def _run(self):
+        while True:
+            with self._condition:
+                while self._active and not self._queue:
+                    self._condition.wait()
+                if not self._active:
+                    self._thread = None
+                    return
+                generation, message = self._queue.popleft()
+            self._context.generation = generation
+            try:
+                if self.is_current_callback():
+                    self._dispatch(message)
+            except Exception:
+                logging.getLogger(__name__).exception("callback dispatch failed event=%s", message.get("event"))
+            finally:
+                del self._context.generation
+
+
+def dispatch_callbacks(callbacks, message, is_current):
+    event = message.get("event")
+    data = decode_value(message.get("data"))
+    full_message = dict(message, data=data)
+    deliveries = [(list(callbacks.get("__event__", [])), full_message),
+                  (list(callbacks.get(event, [])), data)]
+    if event and event.startswith("quote:"):
+        quote_message = dict(full_message)
+        if quote_message.get("subscription_id") is not None and quote_message.get("subscribe_id") is None:
+            quote_message["subscribe_id"] = quote_message["subscription_id"]
+        deliveries.append((list(callbacks.get("quote", [])), quote_message))
+    for handlers, payload in deliveries:
+        for callback in handlers:
+            if not is_current():
+                return
+            try:
+                callback(payload)
+            except Exception:
+                logging.getLogger(__name__).exception("user callback failed event=%s", event)

{cfquant-0.2.38 → cfquant-0.2.40}/cfquant/client.py

@@ -6,6 +6,7 @@ import threading
 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
 
 
@@ -114,9 +115,11 @@ class LTtxRpcClient(object):
         self._pending_lock = threading.RLock()
         self._started = False
         self._recv_thread = None
+        self._event_dispatcher = CallbackDispatcher(self._dispatch_event)
 
     def start(self):
         with self._lock:
+            self._event_dispatcher.check_request()
             if self._started:
                 return
             txl = self._load_txl()
@@ -124,12 +127,14 @@ class LTtxRpcClient(object):
             self._tx.start_tx()
             self._tx.start_txg(self.client_id)
             self._started = True
-            self._recv_thread = threading.Thread(target=self._recv_loop)
+            generation = self._event_dispatcher.start()
+            self._recv_thread = threading.Thread(target=self._recv_loop, args=(self._tx, generation))
             self._recv_thread.daemon = True
             self._recv_thread.start()
 
     def close(self):
         with self._lock:
+            self._event_dispatcher.stop()
             self._started = False
             tx = self._tx
             self._tx = None
@@ -150,39 +155,40 @@ class LTtxRpcClient(object):
                         pass
                 self._pending.clear()
 
-    def request(self, action, params=None, timeout=None, request_channel=None):
-        effective_timeout = float(timeout or self.timeout)
-        request_id = new_id("req")
-        raw = pack_request(
-            action,
-            params=params,
+    def request(self, action, params=None, timeout=None, request_channel=None):
+        effective_timeout = float(timeout or self.timeout)
+        request_id = new_id("req")
+        raw = pack_request(
+            action,
+            params=params,
             reply_channel=self.reply_channel,
             client_id=self.client_id,
             request_id=request_id,
-            timeout=effective_timeout,
-        )
-        self.start()
+            timeout=effective_timeout,
+        )
         q = queue.Queue(maxsize=1)
-        with self._pending_lock:
-            self._pending[request_id] = q
         try:
-            self._push("request", raw, request_channel or self.request_channel)
-            try:
-                msg = q.get(timeout=effective_timeout)
-            except queue.Empty:
-                raise CfquantTimeout("cfquant request timeout: %s" % action)
-            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:
-            with self._pending_lock:
-                self._pending.pop(request_id, None)
-
-    def publish_event(self, channel, payload):
-        raw = dumps_message(payload)
-        self.start()
-        self._push("event", raw, channel)
+            with self._lock:
+                self.start()
+                with self._pending_lock:
+                    self._pending[request_id] = q
+                self._push("request", raw, request_channel or self.request_channel)
+            try:
+                msg = q.get(timeout=effective_timeout)
+            except queue.Empty:
+                raise CfquantTimeout("cfquant request timeout: %s" % action)
+            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:
+            with self._pending_lock:
+                self._pending.pop(request_id, None)
+
+    def publish_event(self, channel, payload):
+        raw = dumps_message(payload)
+        self.start()
+        self._push("event", raw, channel)
 
     def add_callback(self, event, callback):
         if callback is None:
@@ -194,11 +200,11 @@ class LTtxRpcClient(object):
         if callback in callbacks:
             callbacks.remove(callback)
 
-    def _recv_loop(self):
+    def _recv_loop(self, expected_tx, generation):
         while self._started:
             try:
-                tx = self._tx
-                if tx is None:
+                tx = expected_tx
+                if tx is None or tx is not self._tx:
                     break
                 raw = tx.Q.get()
                 if raw is None:
@@ -206,44 +212,27 @@ class LTtxRpcClient(object):
                 msg = loads_message(raw)
                 if not msg:
                     continue
-                msg_type = msg.get("type")
-                if msg_type == "response":
-                    with self._pending_lock:
-                        q = self._pending.pop(msg.get("id"), None)
-                    if q:
-                        q.put(msg)
-                elif msg_type == "event":
-                    self._dispatch_event(msg)
-            except Exception:
-                time.sleep(0.05)
-                if not self._started:
-                    break
+                with self._lock:
+                    if not self._started or tx is not self._tx:
+                        return
+                    msg_type = msg.get("type")
+                    if msg_type == "response":
+                        with self._pending_lock:
+                            q = self._pending.pop(msg.get("id"), None)
+                        if q:
+                            q.put(msg)
+                    elif msg_type == "event":
+                        self._event_dispatcher.submit(generation, msg)
+            except Exception:
+                time.sleep(0.05)
+                if not self._started:
+                    break
+        with self._lock:
+            if self._tx is expected_tx:
+                self.close()
 
     def _dispatch_event(self, msg):
-        event = msg.get("event")
-        data = decode_value(msg.get("data"))
-        full_msg = dict(msg)
-        full_msg["data"] = data
-        for callback in list(self._callbacks.get("__event__", [])):
-            try:
-                callback(full_msg)
-            except Exception:
-                pass
-        for callback in list(self._callbacks.get(event, [])):
-            try:
-                callback(data)
-            except Exception:
-                pass
-        if event and event.startswith("quote:"):
-            quote_msg = dict(msg)
-            quote_msg["data"] = data
-            if quote_msg.get("subscription_id") is not None and quote_msg.get("subscribe_id") is None:
-                quote_msg["subscribe_id"] = quote_msg.get("subscription_id")
-            for callback in list(self._callbacks.get("quote", [])):
-                try:
-                    callback(quote_msg)
-                except Exception:
-                    pass
+        dispatch_callbacks(self._callbacks, msg, self._event_dispatcher.is_current_callback)
 
     def _push(self, key, payload, channel):
         tx = self._tx

{cfquant-0.2.38 → cfquant-0.2.40}/cfquant/pipe_client.py

@@ -3,6 +3,7 @@ import queue
 import threading
 
 from .config import get_config
+from .callback_dispatcher import CallbackDispatcher, dispatch_callbacks
 from .pipe_transport import (
     DEFAULT_PIPE_NAME,
     connect_pipe,
@@ -34,9 +35,11 @@ class PipeRpcClient(object):
         self._pending_lock = threading.RLock()
         self._started = False
         self._recv_thread = None
+        self._event_dispatcher = CallbackDispatcher(self._dispatch_event)
 
     def start(self):
         with self._lock:
+            self._event_dispatcher.check_request()
             if self._started and self._recv_thread is not None and self._recv_thread.is_alive():
                 return
             if self._started:
@@ -55,57 +58,60 @@ class PipeRpcClient(object):
                 "client_id": self.client_id,
             }))
             self._started = True
-            self._recv_thread = threading.Thread(target=self._recv_loop, args=(self._rx_conn,))
+            generation = self._event_dispatcher.start()
+            self._recv_thread = threading.Thread(target=self._recv_loop, args=(self._rx_conn, generation))
             self._recv_thread.daemon = True
             self._recv_thread.start()
 
     def close(self):
         with self._lock:
-            self._started = False
-            self._close_conns_locked()
-        self._fail_pending("cfquant pipe client closed")
-
-    def request(self, action, params=None, timeout=None, request_channel=None):
-        effective_timeout = float(timeout or self.timeout)
-        request_id = new_id("req")
-        raw = pack_request(
-            action,
-            params=params,
+            self._event_dispatcher.stop()
+            self._started = False
+            self._close_conns_locked()
+            self._fail_pending("cfquant pipe client closed")
+
+    def request(self, action, params=None, timeout=None, request_channel=None):
+        effective_timeout = float(timeout or self.timeout)
+        request_id = new_id("req")
+        raw = pack_request(
+            action,
+            params=params,
             reply_channel=self.reply_channel,
             client_id=self.client_id,
             request_id=request_id,
-            timeout=effective_timeout,
-        )
-        self.start()
+            timeout=effective_timeout,
+        )
         q = queue.Queue(maxsize=1)
-        with self._pending_lock:
-            self._pending[request_id] = q
         try:
-            try:
-                self._send_request(raw, request_channel or self.request_channel)
-            except Exception:
-                self.close()
-                raise
-            try:
-                msg = q.get(timeout=effective_timeout)
-            except queue.Empty:
-                from .client import CfquantTimeout
-
-                raise CfquantTimeout("cfquant pipe request timeout: %s" % action)
-            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:
-            with self._pending_lock:
-                self._pending.pop(request_id, None)
-
-    def publish_event(self, channel, payload):
-        raw = dumps_message(payload)
-        self.start()
-        self._send_request(raw, channel)
+            with self._lock:
+                self.start()
+                with self._pending_lock:
+                    self._pending[request_id] = q
+                try:
+                    self._send_request(raw, request_channel or self.request_channel)
+                except Exception:
+                    self.close()
+                    raise
+            try:
+                msg = q.get(timeout=effective_timeout)
+            except queue.Empty:
+                from .client import CfquantTimeout
+
+                raise CfquantTimeout("cfquant pipe request timeout: %s" % action)
+            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:
+            with self._pending_lock:
+                self._pending.pop(request_id, None)
+
+    def publish_event(self, channel, payload):
+        raw = dumps_message(payload)
+        self.start()
+        self._send_request(raw, channel)
 
     def add_callback(self, event, callback):
         if callback is None:
@@ -131,7 +137,7 @@ class PipeRpcClient(object):
             "payload": payload,
         }))
 
-    def _recv_loop(self, expected_conn):
+    def _recv_loop(self, expected_conn, generation):
         disconnect_message = "cfquant pipe connection closed"
         while True:
             try:
@@ -151,14 +157,17 @@ class PipeRpcClient(object):
                 msg = loads_message(payload)
                 if not msg:
                     continue
-                msg_type = msg.get("type")
-                if msg_type == "response":
-                    with self._pending_lock:
-                        q = self._pending.pop(msg.get("id"), None)
-                    if q:
-                        q.put(msg)
-                elif msg_type == "event":
-                    self._dispatch_event(msg)
+                with self._lock:
+                    if not self._started or self._rx_conn is not expected_conn:
+                        return
+                    msg_type = msg.get("type")
+                    if msg_type == "response":
+                        with self._pending_lock:
+                            q = self._pending.pop(msg.get("id"), None)
+                        if q:
+                            q.put(msg)
+                    elif msg_type == "event":
+                        self._event_dispatcher.submit(generation, msg)
             except Exception as e:
                 disconnect_message = "cfquant pipe receive failed: %s" % e
                 break
@@ -171,8 +180,9 @@ class PipeRpcClient(object):
             if not self._started and self._rx_conn is None and self._tx_conn is None:
                 return
             self._started = False
-            self._close_conns_locked()
-        self._fail_pending(message)
+            self._event_dispatcher.stop()
+            self._close_conns_locked()
+            self._fail_pending(message)
 
     def _close_conns_locked(self):
         conns = [self._rx_conn, self._tx_conn]
@@ -197,27 +207,4 @@ class PipeRpcClient(object):
                 pass
 
     def _dispatch_event(self, msg):
-        event = msg.get("event")
-        data = decode_value(msg.get("data"))
-        full_msg = dict(msg)
-        full_msg["data"] = data
-        for callback in list(self._callbacks.get("__event__", [])):
-            try:
-                callback(full_msg)
-            except Exception:
-                pass
-        for callback in list(self._callbacks.get(event, [])):
-            try:
-                callback(data)
-            except Exception:
-                pass
-        if event and event.startswith("quote:"):
-            quote_msg = dict(msg)
-            quote_msg["data"] = data
-            if quote_msg.get("subscription_id") is not None and quote_msg.get("subscribe_id") is None:
-                quote_msg["subscribe_id"] = quote_msg.get("subscription_id")
-            for callback in list(self._callbacks.get("quote", [])):
-                try:
-                    callback(quote_msg)
-                except Exception:
-                    pass
+        dispatch_callbacks(self._callbacks, msg, self._event_dispatcher.is_current_callback)

{cfquant-0.2.38 → cfquant-0.2.40}/cfquant/qmt_bridge.py

@@ -18,7 +18,7 @@ from .level2 import (
     require_l2_callable,
     thousand_price,
 )
-from .xttype import filter_cancelable_orders
+from .xttype import _is_zero_time_value, filter_cancelable_orders
 
 
 class CfquantQmtBridge(object):
@@ -1111,23 +1111,26 @@ class CfquantQmtBridge(object):
                 "order_time": self._first_value(obj, (
                     "time",
                     "order_time",
-                    "entrust_time",
+                    "entrust_time",
                     "insert_time",
                     "m_strOrderTime",
                     "m_strEntrustTime",
                     "m_strInsertTime",
-                    "m_nOrderTime",
-                    "m_nEntrustTime",
-                    "m_nInsertTime",
-                )),
+                    "m_nOrderTime",
+                    "m_nEntrustTime",
+                    "m_nInsertTime",
+                ), skip_zero=True),
                 "order_date": self._first_value(obj, (
                     "order_date",
                     "entrust_date",
+                    "insert_date",
                     "m_strOrderDate",
                     "m_strEntrustDate",
+                    "m_strInsertDate",
                     "m_strTradingDay",
                     "m_nOrderDate",
                     "m_nEntrustDate",
+                    "m_nInsertDate",
                 )),
                 "direction": self._get_value(obj, "m_nDirection"),
                 "offset_flag": self._get_value(obj, "m_nOffsetFlag"),
@@ -1205,7 +1208,7 @@ class CfquantQmtBridge(object):
                     "m_strDealTime",
                     "m_nTradeTime",
                     "m_nDealTime",
-                )),
+                ), skip_zero=True),
                 "trade_date": self._first_value(obj, (
                     "trade_date",
                     "deal_date",
@@ -1377,12 +1380,14 @@ class CfquantQmtBridge(object):
         text = " ".join(str(value or "") for value in values).strip().lower()
         return "cfquant" if "cfquant" in text else "other"
 
-    def _first_value(self, obj, names):
-        for name in names:
-            value = self._get_value(obj, name)
-            if value is not None and value != "":
-                return value
-        return None
+    def _first_value(self, obj, names, skip_zero=False):
+        for name in names:
+            value = self._get_value(obj, name)
+            if value is not None and value != "":
+                if skip_zero and _is_zero_time_value(value):
+                    continue
+                return value
+        return None
 
     def _object_to_dict(self, obj):
         if hasattr(obj, "items"):