cfquant 0.2.63__tar.gz → 0.2.65__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.63
+Version: 0.2.65
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -48,6 +48,7 @@ Requires-Dist: pyzmq>=25; extra == "zmq"
 |---|---|
 | MiniQMT / `xtquant` 兼容调用 | 原有外部 Python 策略可以沿用接近 `xtdata`、`XtQuantTrader`、`StockAccount` 的写法，降低迁移成本。 |
 | 大 QMT 本地桥接 | 把大 QMT 内部的行情、查询、交易、撤单和回调能力桥接给外部 Python 程序和 Web 控制台。 |
+| 大 QMT 原生接口类 | 独立的 `QmtInnerApi` 面向外部数据查询、研究和实盘交易，按系统、行情、交易、回调、扩展数据与因子细分，保留原生函数名与参数，详见 [内置接口说明](docs/大QMT内置接口.md)。 |
 | Web 控制台 | 在浏览器里完成账号绑定、QMT 入口脚本指引、在线检测、接口调试、版本更新和回滚。 |
 | 多账号 / 多 QMT 路由 | 按 `bridge_id`、`account_type`、`account_id` 路由请求，适配多资金账号、普通账户、信用账户和多 QMT 终端。 |
 | 通用、极致、高级三种模式 | 普通环境快速跑通；受限 QMT 使用自包含入口；低延迟场景可拆分普通桥和交易桥。 |
@@ -397,6 +398,7 @@ restart_cfquant.bat     重启
 | QMT 综合部署教程 | [QMT 部署教程](docs/QMT部署教程.md) |
 | cftrader 批量同步/异步下单与撤单 | [cftrader 批量交易与撤单](docs/cftrader批量交易.md)，含 100 单本地基准 |
 | cftrader TWAP / VWAP / POV | [算法交易与共享全推行情](docs/algorithm_trading.md)，含自动订阅、生命周期和接口示例 |
+| 条件单 / 仓位计算 / 下单计划 | [条件单、仓位计算与下单计划](docs/conditional_orders.md)，含止盈止损、到时平仓、回撤 / 保本保护、风险仓位及 Python / HTTP 接口 |
 | 通用模式部署 | [通用模式部署指南](docs/通用模式部署指南.md) |
 | 极致模式部署 | [极致模式部署指南](docs/极致模式部署指南.md) |
 | 高级模式部署 | [高级模式部署指南](docs/高级模式部署指南.md) |

{cfquant-0.2.63 → cfquant-0.2.65}/README.md

@@ -23,6 +23,7 @@
 |---|---|
 | MiniQMT / `xtquant` 兼容调用 | 原有外部 Python 策略可以沿用接近 `xtdata`、`XtQuantTrader`、`StockAccount` 的写法，降低迁移成本。 |
 | 大 QMT 本地桥接 | 把大 QMT 内部的行情、查询、交易、撤单和回调能力桥接给外部 Python 程序和 Web 控制台。 |
+| 大 QMT 原生接口类 | 独立的 `QmtInnerApi` 面向外部数据查询、研究和实盘交易，按系统、行情、交易、回调、扩展数据与因子细分，保留原生函数名与参数，详见 [内置接口说明](docs/大QMT内置接口.md)。 |
 | Web 控制台 | 在浏览器里完成账号绑定、QMT 入口脚本指引、在线检测、接口调试、版本更新和回滚。 |
 | 多账号 / 多 QMT 路由 | 按 `bridge_id`、`account_type`、`account_id` 路由请求，适配多资金账号、普通账户、信用账户和多 QMT 终端。 |
 | 通用、极致、高级三种模式 | 普通环境快速跑通；受限 QMT 使用自包含入口；低延迟场景可拆分普通桥和交易桥。 |
@@ -372,6 +373,7 @@ restart_cfquant.bat     重启
 | QMT 综合部署教程 | [QMT 部署教程](docs/QMT部署教程.md) |
 | cftrader 批量同步/异步下单与撤单 | [cftrader 批量交易与撤单](docs/cftrader批量交易.md)，含 100 单本地基准 |
 | cftrader TWAP / VWAP / POV | [算法交易与共享全推行情](docs/algorithm_trading.md)，含自动订阅、生命周期和接口示例 |
+| 条件单 / 仓位计算 / 下单计划 | [条件单、仓位计算与下单计划](docs/conditional_orders.md)，含止盈止损、到时平仓、回撤 / 保本保护、风险仓位及 Python / HTTP 接口 |
 | 通用模式部署 | [通用模式部署指南](docs/通用模式部署指南.md) |
 | 极致模式部署 | [极致模式部署指南](docs/极致模式部署指南.md) |
 | 高级模式部署 | [高级模式部署指南](docs/高级模式部署指南.md) |

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

@@ -11,6 +11,8 @@ 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
@@ -25,6 +27,11 @@ __all__ = [
     "xtdata",
     "xttrader",
     "cftrader",
+    "QmtInnerApi",
+    "QmtPythonRuntime",
+    "QmtPythonRuntimeError",
+    "QmtPythonPackage",
+    "QmtPythonProgress",
     "xttype",
     "configure",
     "get_client",

{cfquant-0.2.63 → 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.63 → 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.63 → 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.63 → 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.63 → 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.63 → cfquant-0.2.65}/cfquant/cftrader.py

@@ -5,6 +5,7 @@ from .batch_orders import (
     prepare_batch_cancels, prepare_batch_orders, validate_batch_cancel_response, validate_batch_response,
 )
 from .protocol import new_id
+from .position_sizing import calculate_position
 from .xttrader import XtQuantTrader, _account_payload
 import threading
 
@@ -26,7 +27,7 @@ def _algo_rpc(action, params):
     return client.request(action, params)
 
 
-__all__ = ["CfQuantTrader"]
+__all__ = ["CfQuantTrader", "calculate_position"]
 
 class CfQuantTrader:
     """Use CfQuantTrader(trader) with an existing cfquant XtQuantTrader instance.
@@ -57,6 +58,70 @@ class CfQuantTrader:
     def order_twap(self, account, stock_code, order_type, order_volume, limit_price, **options):
         return self.order_algo(account, stock_code, order_type, order_volume, "TWAP", limit_price, **options)
 
+    calculate_position = staticmethod(calculate_position)
+
+    def order_condition(self, account, stock_code, conditions, execution, **options):
+        """Create a persistent sell protection group; manage it with query/pause/cancel_algo."""
+        payload = _account_payload(self._trader._resolve_account(account))
+        params = dict(options, account=payload, stock_code=stock_code, conditions=conditions, execution=execution)
+        params.setdefault("request_key", new_id("condition_request"))
+        task_id = _algo_rpc("cftrader.order_condition", params)
+        self._algo_accounts[task_id] = payload
+        return task_id
+
+    def order_stop_loss(self, account, stock_code, order_volume, stop_price, limit_price, **options):
+        return self.order_condition(account, stock_code, [{"type": "stop_loss", "price": stop_price}],
+                                    {"limit_price": limit_price}, order_volume=order_volume, **options)
+
+    def order_take_profit(self, account, stock_code, order_volume, take_profit_price, limit_price, **options):
+        return self.order_condition(account, stock_code, [{"type": "take_profit", "price": take_profit_price}],
+                                    {"limit_price": limit_price}, order_volume=order_volume, **options)
+
+    def order_trailing_stop(self, account, stock_code, order_volume, drawdown_percent, limit_price,
+                            activation_price=None, **options):
+        rule = dict(type="trailing_stop", drawdown_percent=drawdown_percent)
+        if activation_price is not None:
+            rule["activation_price"] = activation_price
+        return self.order_condition(account, stock_code, [rule], {"limit_price": limit_price},
+                                    order_volume=order_volume, **options)
+
+    def order_breakeven_stop(self, account, stock_code, order_volume, reference_price, activation_percent,
+                             limit_price, offset_amount=0, **options):
+        return self.order_condition(account, stock_code,
+            [dict(type="breakeven_stop", activation_percent=activation_percent, offset_amount=offset_amount)],
+            {"limit_price": limit_price}, order_volume=order_volume, reference_price=reference_price, **options)
+
+    def order_time_exit(self, account, stock_code, order_volume, at, limit_price, only_if_loss=False, **options):
+        return self.order_condition(account, stock_code, [dict(type="time_exit", at=at, only_if_loss=only_if_loss)],
+                                    {"limit_price": limit_price}, order_volume=order_volume, **options)
+
+    def preview_order_plan(self, account, stock_code, sizing, **options):
+        """Persist a preview without ordering; account balances are read by the service."""
+        payload = _account_payload(self._trader._resolve_account(account))
+        params = dict(options, account=payload, stock_code=stock_code, sizing=sizing)
+        params.setdefault("request_key", new_id("plan_request"))
+        plan = _algo_rpc("cftrader.preview_order_plan", params)
+        self._algo_accounts[plan["algo_id"]] = payload
+        return plan
+
+    def _plan_control(self, action, plan_id=None, account=None):
+        payload = _account_payload(self._trader._resolve_account(account or self._algo_accounts.get(plan_id)))
+        return _algo_rpc("cftrader." + action, dict(plan_id=plan_id, account=payload))
+
+    def submit_order_plan(self, plan_id, account=None):
+        """Revalidate and submit once. Repeating the same plan_id returns its current state."""
+        return self._plan_control("submit_order_plan", plan_id, account)
+
+    def query_order_plan(self, plan_id, account=None):
+        return self._plan_control("query_order_plan", plan_id, account)
+
+    def list_order_plans(self, account=None):
+        return self._plan_control("list_order_plans", account=account)
+
+    def cancel_order_plan(self, plan_id, account=None):
+        """Cancel the entry remainder; retain protection for confirmed fills."""
+        return self._plan_control("cancel_order_plan", plan_id, account)
+
     def order_vwap(self, account, stock_code, order_type, order_volume, limit_price, **options):
         return self.order_algo(account, stock_code, order_type, order_volume, "VWAP", limit_price, **options)
 

{cfquant-0.2.63 → 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/conditional_orders.py

@@ -0,0 +1,149 @@
+"""Validated, serializable conditions evaluated against observed quote prices."""
+import copy
+import math
+
+from .algo import positive
+from .algo_broker import execution_time
+
+
+def validate_conditions(conditions, reference_price=None):
+    if not isinstance(conditions, list) or not 1 <= len(conditions) <= 32:
+        raise ValueError("conditions must contain 1 to 32 rules (any matching rule triggers the group)")
+    reference = positive(reference_price, "reference_price") if reference_price is not None else None
+    result = []
+    fields = {
+        "stop_loss": {"price", "percent"}, "take_profit": {"price", "percent"},
+        "time_exit": {"at", "only_if_loss"}, "holding_exit": {"seconds", "trading_days", "opened_at", "exit_time"},
+        "trailing_stop": {"drawdown_percent", "drawdown_amount", "activation_price", "activation_percent"},
+        "breakeven_stop": {"activation_percent", "activation_price", "offset_percent", "offset_amount", "protect_price"},
+        "step_stop": {"steps"},
+    }
+    for index, original in enumerate(conditions):
+        if not isinstance(original, dict):
+            raise ValueError("each condition must be an object")
+        rule = copy.deepcopy(original)
+        kind = rule.get("type")
+        if kind not in fields or set(rule) - (fields.get(kind, set()) | {"type", "name"}):
+            raise ValueError("unknown condition type or fields")
+        rule.setdefault("name", "%s_%d" % (kind, index + 1))
+        if not isinstance(rule["name"], str) or not rule["name"]:
+            raise ValueError("condition name must be nonempty text")
+        if kind in ("stop_loss", "take_profit"):
+            if ("price" in rule) == ("percent" in rule):
+                raise ValueError(kind + " requires exactly one of price or percent")
+            if "percent" in rule:
+                pct = positive(rule["percent"], "percent")
+                if reference is None or (kind == "stop_loss" and pct >= 1):
+                    raise ValueError("percentage conditions require reference_price; stop percent must be below 1")
+                rule["price"] = reference * (1 + pct if kind == "take_profit" else 1 - pct)
+            rule["price"] = positive(rule["price"], "condition price")
+        elif kind == "time_exit":
+            rule["at"] = execution_time(rule.get("at"))
+            if rule["at"] is None:
+                raise ValueError("time_exit requires at")
+            if not isinstance(rule.get("only_if_loss", False), bool):
+                raise ValueError("only_if_loss must be boolean")
+            if rule.get("only_if_loss") and reference is None:
+                raise ValueError("only_if_loss requires reference_price")
+        elif kind == "holding_exit":
+            if ("seconds" in rule) == ("trading_days" in rule):
+                raise ValueError("holding_exit requires exactly one of seconds or trading_days")
+            rule["opened_at"] = execution_time(rule.get("opened_at"))
+            if rule["opened_at"] is None:
+                raise ValueError("holding_exit requires opened_at")
+            if "seconds" in rule:
+                rule["at"] = rule["opened_at"] + positive(rule["seconds"], "seconds")
+            else:
+                rule["trading_days"] = positive(rule["trading_days"], "trading_days", integer=True)
+                if rule["trading_days"] > 2500:
+                    raise ValueError("trading_days must not exceed 2500")
+                import datetime
+                datetime.time.fromisoformat(rule.setdefault("exit_time", "14:50"))
+        elif kind in ("trailing_stop", "breakeven_stop"):
+            if "activation_price" in rule and "activation_percent" in rule:
+                raise ValueError("use one activation threshold")
+            if "activation_percent" in rule:
+                if reference is None:
+                    raise ValueError("activation_percent requires reference_price")
+                rule["activation_price"] = reference * (1 + positive(rule["activation_percent"], "activation_percent", allow_zero=True))
+            if "activation_price" in rule:
+                rule["activation_price"] = positive(rule["activation_price"], "activation_price")
+            if kind == "trailing_stop":
+                if ("drawdown_percent" in rule) == ("drawdown_amount" in rule):
+                    raise ValueError("trailing_stop requires exactly one drawdown threshold")
+                key = "drawdown_percent" if "drawdown_percent" in rule else "drawdown_amount"
+                rule[key] = positive(rule[key], key)
+                if key == "drawdown_percent" and rule[key] >= 1:
+                    raise ValueError("drawdown_percent must be below 1")
+            else:
+                if "activation_price" not in rule:
+                    raise ValueError("breakeven_stop requires activation_price or activation_percent")
+                offsets = set(rule) & {"offset_amount", "offset_percent", "protect_price"}
+                if len(offsets) > 1:
+                    raise ValueError("use one breakeven protection offset")
+                if "protect_price" not in rule:
+                    if reference is None:
+                        raise ValueError("breakeven_stop requires reference_price or protect_price")
+                    rule["protect_price"] = reference + (reference * positive(rule["offset_percent"], "offset_percent", allow_zero=True)
+                        if "offset_percent" in rule else positive(rule.get("offset_amount", 0), "offset_amount", allow_zero=True))
+                rule["protect_price"] = positive(rule["protect_price"], "protect_price")
+                if rule["protect_price"] >= rule["activation_price"]:
+                    raise ValueError("protect_price must be below activation_price")
+        elif kind == "step_stop":
+            if reference is None or not isinstance(rule.get("steps"), list) or not rule["steps"]:
+                raise ValueError("step_stop requires reference_price and steps")
+            previous_gain = previous_stop = -1
+            for step in rule["steps"]:
+                if not isinstance(step, dict) or set(step) != {"gain_percent", "protect_percent"}:
+                    raise ValueError("each step requires gain_percent and protect_percent")
+                gain = positive(step["gain_percent"], "gain_percent", allow_zero=True)
+                protect = positive(step["protect_percent"], "protect_percent", allow_zero=True)
+                if gain <= previous_gain or protect < previous_stop or protect >= gain:
+                    raise ValueError("steps must have increasing gains and nondecreasing protection below each gain")
+                previous_gain, previous_stop = gain, protect
+        result.append(rule)
+    return result
+
+
+def evaluate_conditions(rules, states, price, now, reference, trigger_on_create=True):
+    """Mutate persisted states; return the first trigger. Observed highs never fall."""
+    triggered = None
+    def above(value, threshold):
+        return value >= threshold or math.isclose(value, threshold, rel_tol=1e-12, abs_tol=1e-10)
+    def below(value, threshold):
+        return value <= threshold or math.isclose(value, threshold, rel_tol=1e-12, abs_tol=1e-10)
+    for index, rule in enumerate(rules):
+        state = states.setdefault(str(index), {})
+        kind = rule["type"]
+        hit = False
+        if kind in ("stop_loss", "take_profit"):
+            hit = below(price, rule["price"]) if kind == "stop_loss" else above(price, rule["price"])
+        elif kind in ("time_exit", "holding_exit"):
+            if now >= rule["at"]:
+                # Evaluate the loss gate once, at the first executable fresh snapshot.
+                if "time_decision" not in state:
+                    state["time_decision"] = not rule.get("only_if_loss") or price < reference
+                hit = state["time_decision"]
+        elif kind in ("trailing_stop", "breakeven_stop"):
+            if above(price, rule.get("activation_price", 0)):
+                state.setdefault("activated_at", now)
+            if "activated_at" in state:
+                if kind == "trailing_stop":
+                    state["high"] = max(state.get("high", price), price)
+                    candidate = (state["high"] * (1 - rule["drawdown_percent"]) if "drawdown_percent" in rule
+                                 else state["high"] - rule["drawdown_amount"])
+                else:
+                    candidate = rule["protect_price"]
+                state["stop"] = max(state.get("stop", candidate), candidate)
+                hit = below(price, state["stop"])
+        else:
+            for step in rule["steps"]:
+                if above(price, reference * (1 + step["gain_percent"])):
+                    state["stop"] = max(state.get("stop", 0), reference * (1 + step["protect_percent"]))
+            hit = "stop" in state and below(price, state["stop"])
+        if not hit:
+            state["armed"] = True
+        if hit and (trigger_on_create or state.get("armed") or kind in ("time_exit", "holding_exit")) and triggered is None:
+            triggered = dict(index=index, name=rule["name"], type=kind, price=price, at=now,
+                             threshold=state.get("stop", rule.get("price", rule.get("at"))))
+    return triggered

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.63 → 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.63 → 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.63 → 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):