cfquant 0.2.64__tar.gz → 0.2.65__tar.gz

{cfquant-0.2.64 → cfquant-0.2.65}/PKG-INFO

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

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/__init__.py

@@ -12,6 +12,7 @@ cfquant: 面向 QMT 的 xtquant 兼容层。
 from . import xtconstant, xtdata, xttrader, xttype
 from . import cftrader
 from .qmt_inner import QmtInnerApi
+from .qmt_python_runtime import QmtPythonRuntime, QmtPythonRuntimeError, QmtPythonPackage, QmtPythonProgress
 from .client import CfquantError, CfquantTimeout, configure, get_client
 from .version import __version__
 from .build_info import build_identity, get_git_commit
@@ -27,6 +28,10 @@ __all__ = [
     "xttrader",
     "cftrader",
     "QmtInnerApi",
+    "QmtPythonRuntime",
+    "QmtPythonRuntimeError",
+    "QmtPythonPackage",
+    "QmtPythonProgress",
     "xttype",
     "configure",
     "get_client",

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/_editable_install.py

@@ -12,7 +12,15 @@ from pathlib import Path
 if __package__:
     from .qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 else:
-    from qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
+    # The Windows launcher executes this file by path (``python
+    # cfquant\\_editable_install.py``), so Python puts the package directory on
+    # sys.path and leaves ``__package__`` empty.  Import through the package in
+    # that mode as well; qmt_dependencies uses relative imports and cannot be
+    # loaded as a top-level module.
+    _PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(_PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(_PROJECT_ROOT))
+    from cfquant.qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 
 
 PACKAGE_NAME = "cfquant"

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/algo.py

@@ -2,7 +2,7 @@
 import copy
 import datetime as dt
 import json
-import logging
+from .diagnostic_context import get_logger
 import math
 import os
 import sqlite3
@@ -488,7 +488,7 @@ class AlgoEngine:
                 except Exception:
                     # Persistence is a prerequisite for further order submission.
                     task["status"] = "PAUSED"
-                    logging.getLogger(__name__).exception("algorithm persistence failed")
+                    get_logger(__name__).exception("algorithm persistence failed")
         finally:
             with self._lock:
                 self._busy.discard(algo_id)

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/algo_broker.py

@@ -1,4 +1,6 @@
 """Existing cfquant account/market routes adapted to the execution engine."""
+
+from .diagnostic_context import VersionedErrorMixin
 import datetime as dt
 import math
 import threading
@@ -10,7 +12,7 @@ from .xttype import XtAsset, XtOrder, XtPosition
 from .batch_orders import prepare_batch_orders, prepare_batch_cancels
 
 
-class AlgoOrderRejected(RuntimeError):
+class AlgoOrderRejected(VersionedErrorMixin, RuntimeError):
     dispatched = False
 
 

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/batch_orders.py

@@ -2,6 +2,7 @@
 
 import math
 import os
+import re
 import time
 from collections.abc import Mapping
 from numbers import Integral, Real
@@ -19,6 +20,13 @@ _BATCH_ORDER_FIELDS = {"stock_code", "order_type", "order_volume", "price_type",
                        "strategy_name", "order_remark", "cfquant_order_remark"}
 _BATCH_REQUIRED_FIELDS = {"stock_code", "order_type", "order_volume", "price_type", "price"}
 _BATCH_CANCEL_FIELDS = {"order_id", "stock_code", "market", "order_remark"}
+_VERSION_SUFFIX = re.compile(r"\s+\[cfquant\s+[^\]]+\]\s*$")
+
+
+def _batch_error_text(error):
+    """Keep row-level compatibility while request errors retain diagnostics."""
+    text = str(error) or type(error).__name__
+    return _VERSION_SUFFIX.sub("", text)
 
 
 def batch_positive_id(value):
@@ -206,14 +214,14 @@ def batch_result(account, batch_id, asynchronous, results, operation="order"):
 
 def batch_unknown(rows, error):
     for row in rows:
-        row.update(status="unknown", ok=None, error=str(error) or type(error).__name__)
+        row.update(status="unknown", ok=None, error=_batch_error_text(error))
 
 
 def batch_rejected(rows, error):
     """Mark a rejection known to happen before QMT dispatch."""
     details = getattr(error, "error_details", None)
     details = details if isinstance(details, dict) else {}
-    message = str(error) or type(error).__name__
+    message = _batch_error_text(error)
     for row in rows:
         row.update(status="failed", ok=False, error=message, dispatched=False,
                    safe_to_retry=details.get("safe_to_retry") is True,

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/callback_dispatcher.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Serial user callbacks, independent of the RPC receive thread."""
 from collections import deque
-import logging
+from .diagnostic_context import get_logger
 import os
 import tempfile
 import threading
@@ -90,7 +90,7 @@ class CallbackDispatcher(object):
             item[1] = item[3] = None
         if self._queue and len(self._queue) >= 1000 and time.monotonic() - self._last_warning >= 5:
             self._last_warning = time.monotonic()
-            logging.getLogger(__name__).warning("callback backlog count=%s oldest_ms=%.1f spooled_bytes=%s",
+            get_logger(__name__).warning("callback backlog count=%s oldest_ms=%.1f spooled_bytes=%s",
                                                len(self._queue), (time.monotonic() - self._queue[0][2]) * 1000, self._spool_live)
 
     def _take_message(self, item):
@@ -168,7 +168,7 @@ class CallbackDispatcher(object):
                     if message is None:
                         raise ValueError("invalid preserved callback message")
             except Exception as error:
-                logging.getLogger(__name__).exception("callback backlog failed; connection must be restarted")
+                get_logger(__name__).exception("callback backlog failed; connection must be restarted")
                 with self._condition:
                     if generation != self._generation:
                         continue  # An old connection must not close its replacement.
@@ -185,7 +185,7 @@ class CallbackDispatcher(object):
                 if self.is_current_callback():
                     self._dispatch(message)
             except Exception:
-                logging.getLogger(__name__).exception("callback dispatch failed event=%s", message.get("event"))
+                get_logger(__name__).exception("callback dispatch failed event=%s", message.get("event"))
             finally:
                 self._last_callback_ms = (time.monotonic() - started) * 1000
                 del self._context.generation
@@ -215,4 +215,4 @@ def dispatch_callbacks(callbacks, message, is_current):
             try:
                 callback(payload)
             except Exception:
-                logging.getLogger(__name__).exception("user callback failed event=%s", event)
+                get_logger(__name__).exception("user callback failed event=%s", event)

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/client.py

@@ -10,14 +10,16 @@ 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 .rpc_timing import RpcTiming
+from .diagnostic_context import CFQUANT_VERSION, VersionedErrorMixin
 
 
-class CfquantError(RuntimeError):
+class CfquantError(VersionedErrorMixin, RuntimeError):
     """RPC failure retaining the server's structured rejection details."""
 
     def __init__(self, message="", details=None):
         super(CfquantError, self).__init__(message)
         self.error_details = dict(details) if isinstance(details, dict) else {}
+        self.error_details.setdefault("cfquant_version", CFQUANT_VERSION)
         self.code = self.error_details.get("code", "")
         self.stage = self.error_details.get("stage", "")
         self.dispatched = self.error_details.get("dispatched")
@@ -25,7 +27,7 @@ class CfquantError(RuntimeError):
         self.retry_when = self.error_details.get("retry_when", "")
 
 
-class CfquantTimeout(TimeoutError):
+class CfquantTimeout(VersionedErrorMixin, TimeoutError):
     pass
 
 
@@ -157,7 +159,7 @@ class LTtxRpcClient(object):
                 if not getattr(self._tx, "run_on", True):
                     raise CfquantError("cfquant client closed during connection startup")
             except BaseException:
-                self.close()
+                LTtxRpcClient.close(self)
                 raise
             self._started = True
             self._closed = False
@@ -286,7 +288,7 @@ class LTtxRpcClient(object):
                     break
         with self._lock:
             if self._tx is expected_tx:
-                self.close()
+                LTtxRpcClient.close(self)
 
     def _dispatch_event(self, msg):
         dispatch_callbacks(self._callbacks, msg, self._event_dispatcher.is_current_callback)
@@ -355,6 +357,38 @@ class WebLttxRpcClient(LTtxRpcClient):
             timeout=timeout,
             client_id=client_id,
         )
+        self._subscription_session = None
+        self._subscription_protocol = None
+        self._subscription_init_lock = threading.Lock()
+
+    def _subscription_raw_request(self, action, params, timeout=None):
+        return super(WebLttxRpcClient, self).request(action, params, timeout=timeout)
+
+    def request(self, action, params=None, timeout=None, request_channel=None, response_meta=None):
+        from .subscription_client import managed_request
+        handled, result = managed_request(self, self._subscription_raw_request, action, params, timeout)
+        if handled:
+            return result
+        return super(WebLttxRpcClient, self).request(action, params, timeout, request_channel, response_meta)
+
+    def _dispatch_event(self, msg):
+        if msg.get('event') == 'cfquant.managed_subscription':
+            data = msg.get('data')
+            if isinstance(data, dict):
+                if self._subscription_session is None or data.get('key') not in self._subscription_session.specs:
+                    return
+                msg = dict(msg, event=data.get('event'), data=data.get('payload'))
+        sid = (msg.get('meta') or {}).get('managed_subscription_id')
+        if sid is not None and (self._subscription_session is None or str(sid) not in self._subscription_session.specs):
+            return
+        super(WebLttxRpcClient, self)._dispatch_event(msg)
+
+    def close(self):
+        session = getattr(self, '_subscription_session', None)
+        if session is not None:
+            self._subscription_session = None
+            session.close()
+        super(WebLttxRpcClient, self).close()
 
 
 def _registry_has_web_route(registry):

cfquant-0.2.65/cfquant/diagnostic_context.py

@@ -0,0 +1,35 @@
+"""Version context for cfquant diagnostics without changing application logging."""
+import logging
+
+from .version import __version__ as CFQUANT_VERSION
+
+
+def versioned_message(message):
+    text = str(message)
+    tag = "[cfquant %s]" % CFQUANT_VERSION
+    return text if tag in text else "%s %s" % (text, tag)
+
+
+class VersionedErrorMixin:
+    cfquant_version = CFQUANT_VERSION
+
+    def __str__(self):
+        # Keep .args and structured error codes intact for existing callers.
+        return versioned_message(super(VersionedErrorMixin, self).__str__())
+
+
+class _VersionFilter(logging.Filter):
+    def filter(self, record):
+        record.msg = versioned_message(record.getMessage())
+        record.args = ()
+        record.cfquant_version = CFQUANT_VERSION
+        return True
+
+
+_VERSION_FILTER = _VersionFilter()
+
+
+def get_logger(name):
+    logger = logging.getLogger(name)
+    logger.addFilter(_VERSION_FILTER)
+    return logger

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/flow_control.py

@@ -1,6 +1,6 @@
 """Ordered, bounded background work. No QMT API calls run in these workers."""
 from collections import deque
-import logging
+from .diagnostic_context import get_logger
 import threading
 import time
 
@@ -163,7 +163,7 @@ class KeyedExecutor(object):
         try:
             item[2](error)
         except Exception:
-            logging.getLogger(__name__).exception("Web route could not deliver request failure")
+            get_logger(__name__).exception("Web route could not deliver request failure")
 
     def status(self):
         with self._condition:

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/hub.py

@@ -7,6 +7,7 @@ import threading
 import time
 
 from .protocol import loads_message
+from .diagnostic_context import versioned_message
 
 
 def default_status_file(filename):
@@ -263,7 +264,7 @@ class CfquantHub(object):
 
     def _log(self, msg):
         if self.show:
-            print("%s %s" % (self._timestamp_ms(), msg), flush=True)
+            print("%s %s" % (self._timestamp_ms(), versioned_message(msg)), flush=True)
 
     def _timestamp_ms(self):
         now = time.time()

{cfquant-0.2.64 → cfquant-0.2.65}/cfquant/management.py

@@ -5,6 +5,8 @@ The service has its own source directory. Updating it never installs packages
 into, or reloads modules in, the calling application's Python environment.
 """
 
+from .diagnostic_context import VersionedErrorMixin
+
 import importlib.util
 import json
 import os
@@ -23,7 +25,7 @@ import urllib.request
 _UNSET = object()
 
 
-class ManagementError(RuntimeError):
+class ManagementError(VersionedErrorMixin, RuntimeError):
     """Management failure, including the server's status and response details."""
 
     def __init__(self, message, code="management_error", status=None, details=None):