cfquant 0.2.50__tar.gz → 0.2.51__tar.gz

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

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

{cfquant-0.2.50 → 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.50 → 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:
@@ -894,6 +900,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.51}/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.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)

{cfquant-0.2.50 → cfquant-0.2.51}/cfquant/qmt_strategy_deploy.py

@@ -2,8 +2,9 @@
 
 import ast
 import copy
-import hashlib
-import json
+import hashlib
+import io
+import json
 import os
 from pathlib import Path
 import re
@@ -319,14 +320,36 @@ def _resolve_account_binding(root, document, account_id, account_type, supplied=
     return None
 
 
+def _ascii_entry_source(source):
+    """Preserve executable source through QMT's possible Windows ANSI recoding."""
+    tokens = []
+    for token in tokenize.generate_tokens(io.StringIO(source).readline):
+        if not token.string.isascii():
+            if token.type == tokenize.STRING:
+                # Escape string values, not the whole program. In particular,
+                # raw strings must retain their literal backslashes.
+                prefix = "u" if token.string[:1].lower() == "u" else ""
+                token = token._replace(string=prefix + ascii(ast.literal_eval(token.string)))
+            elif token.type == tokenize.COMMENT:
+                token = token._replace(string=token.string.encode("ascii", "backslashreplace").decode("ascii"))
+        tokens.append(token)
+    return tokenize.untokenize(tokens)
+
+
 def managed_source(source_path, identity_path, identity, descriptor):
     source = read_entry_source(source_path)
+    fileless = normalize_strategy_mode(descriptor["mode"]) in ("ctypes", "lite")
     lines = source.splitlines(keepends=True)
     tree = ast.parse(source)
     replacements = []
     constants = {"DEFAULT_ACCOUNT_ID": identity["account_id"], "DEFAULT_ACCOUNT_TYPE": identity["account_type"],
                  "USER_BRIDGE_ID": identity["bridge_id"], "BRIDGE_ID": identity["bridge_id"],
-                 "QMT_MARKET": identity.get("market", "")}
+                 "QMT_MARKET": identity.get("market", "")}
+    if fileless:
+        config = dict(identity)
+        config["managed_strategy"] = {key: descriptor[key] for key in ("mode", "generation", "role")}
+        config["managed_strategy"]["runtime_key"] = descriptor.get("runtime_key") or _digest(str(identity_path))[:24]
+        constants["EMBEDDED_RUNTIME_CONFIG"] = config
     seen = set()
     for node in tree.body:
         if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
@@ -334,7 +357,7 @@ def managed_source(source_path, identity_path, identity, descriptor):
             if name in constants and (name not in seen or name == "QMT_MARKET"):
                 replacements.append((node.lineno - 1, node.end_lineno, name + " = " + ascii(constants[name]) + "\n"))
                 seen.add(name)
-        elif isinstance(node, ast.FunctionDef) and node.name == "_runtime_config_paths":
+        elif not fileless and isinstance(node, ast.FunctionDef) and node.name == "_runtime_config_paths":
             replacements.append((node.lineno - 1, node.end_lineno,
                                  "def _runtime_config_paths():\n    return [%s]\n" % ascii(str(identity_path))))
         elif isinstance(node, ast.FunctionDef) and node.name == "_env_allows_runtime_override":
@@ -345,36 +368,84 @@ def managed_source(source_path, identity_path, identity, descriptor):
     lines[0] = "# coding: utf-8\n"
     source = "".join(lines)
     ast.parse(source, feature_version=(3, 6))
+    if fileless:
+        if "EMBEDDED_RUNTIME_CONFIG" not in seen:
+            raise ValueError("QMT Pipe entry does not support embedded account configuration; update the entry source.")
+        # Deploy the entry itself. No file lease, exec wrapper, or surrounding try block.
+        generated = _ascii_entry_source(source)
+        generated.encode("ascii")
+        ast.parse(generated, feature_version=(3, 6))
+        return generated
     helper = Path(__file__).with_name("qmt_strategy_runtime.py").read_text(encoding="utf-8")
     source_lines = source.splitlines(keepends=True)
-    # Adjacent literals compile to the same source string, while keeping every
-    # entry line visible in QMT's editor. A single ascii(source) hid thousands
-    # of Lite lines behind the same short lease wrapper as the other modes.
     embedded = "\n".join("        " + ascii(line) for line in source_lines)
+    entry = "    exec(compile((\n%s\n    ), %s, 'exec'), globals())\n" % (embedded, ascii(str(source_path)))
+    description = "# Embedded entry: %d lines, preserved line by line below.\n" % len(source_lines)
     header = ("# coding: utf-8\n# cfquant managed strategy\n"
               + "# Mode: " + ascii(descriptor["mode"]) + "\n"
               + "# Entry: " + ascii(Path(source_path).name) + "\n"
-              + "# Embedded entry: %d lines, preserved line by line below.\n" % len(source_lines)
+              + description
               + "# The lease wrapper is shared by all modes.\n\n")
     generated = (header + helper + "\n_cq_descriptor = " + ascii(descriptor)
             + "\n_cq_guard = _CqStrategyLease(_cq_descriptor).acquire()\n"
             + "_cq_guard.namespace = globals()\ntry:\n"
-            + "    exec(compile((\n%s\n    ), %s, 'exec'), globals())\n" % (embedded, ascii(str(source_path)))
+            + entry
             + "    for _cq_name in ('_cf_bridge', '_normal_bridge', '_trade_bridge'):\n"
             + "        if globals().get(_cq_name) is not None:\n"
             + "            globals()[_cq_name].account_type = %s\n" % ascii(identity["account_type"])
             + "    _cq_guard.bind(globals())\nexcept BaseException as _cq_error:\n"
             + "    _cq_guard.failure = str(_cq_error)\n    _cq_guard.close()\n    raise\n")
-    # QMT may recode source through the Windows ANSI code page before compiling.
-    generated.encode("ascii")
-    return generated
-
-
-class QmtStrategyManager:
-    def __init__(self, state_path, scripts_dir, process_checker=qmt_is_running):
+    # QMT may recode source through the Windows ANSI code page before compiling.
+    generated.encode("ascii")
+    ast.parse(generated, feature_version=(3, 6))
+    return generated
+
+
+def configured_pipe_source(source, identity):
+    """Embed a standalone entry's config while still in the external deployer."""
+    lines = source.splitlines(keepends=True)
+    for node in ast.parse(source).body:
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name) and node.targets[0].id == "EMBEDDED_RUNTIME_CONFIG"):
+            lines[node.lineno - 1:node.end_lineno] = ["EMBEDDED_RUNTIME_CONFIG = " + ascii(identity) + "\n"]
+            return "".join(lines)
+    raise ValueError("QMT Pipe entry is missing EMBEDDED_RUNTIME_CONFIG")
+
+
+class PipeStrategyController:
+    """External Web-side client; QMT receives desired state without opening files."""
+    def __init__(self):
+        self.clients = {}
+
+    def __call__(self, identity, desired):
+        from .channels import channels_for_bridge
+        from .pipe_client import PipeRpcClient
+        channel = ((identity.get("channels") or {}).get("normal") or identity.get("normal_channel")
+                   or channels_for_bridge(identity.get("bridge_id"))["normal"])
+        key = (identity.get("pipe_name"), channel)
+        client = self.clients.get(key)
+        if client is None:
+            client = self.clients[key] = PipeRpcClient(pipe_name=key[0], request_channel=channel,
+                                                       timeout=0.5, connect_timeout_ms=150)
+        try:
+            return client.request("cfquant.strategy.control", desired)
+        except Exception:
+            self.clients.pop(key, None)
+            client.close()
+            raise
+
+    def close(self):
+        for client in self.clients.values():
+            client.close()
+        self.clients.clear()
+
+
+class QmtStrategyManager:
+    def __init__(self, state_path, scripts_dir, process_checker=qmt_is_running, runtime_request=None):
         self.path = Path(state_path)
         self.scripts_dir = Path(scripts_dir)
-        self.process_checker = process_checker
+        self.process_checker = process_checker
+        self.runtime_request = runtime_request
         self.lock = threading.RLock()
         self.event = threading.Event()
         self.stopping = threading.Event()
@@ -562,7 +633,7 @@ class QmtStrategyManager:
                     role.pop("account_key", None)
                 fingerprint = _digest([source_group, mode, [
                     hashlib.sha256(Path(__file__).with_name(filename).read_bytes()).hexdigest()
-                    for filename in ("qmt_strategy_runtime.py", "qmt_strategy_package.py", "qmt_strategy_deploy.py")]])
+                    for filename in ("qmt_strategy_runtime.py", "qmt_pipe_runtime.py", "qmt_strategy_package.py", "qmt_strategy_deploy.py")]])
                 if not force and previous.get("fingerprint") == fingerprint and previous.get("enabled"):
                     previous["account_key"] = row["account_key"]
                     self._prepare_generation_transition(previous)
@@ -601,11 +672,18 @@ class QmtStrategyManager:
                     if isinstance(role, dict) and role.get("name")
                 )
                 retired.difference_update(current_names)
-                job = dict(group, account_key=row["account_key"], account_id=row["account_id"],
+                job = dict(group, account_key=row["account_key"], account_id=row["account_id"],
                            account_type=row["account_type"], mode=mode, settings=settings,
                            enabled=True, generation=generation, fingerprint=fingerprint,
                            control_path=str(directory / "desired.json"),
-                           retired=sorted(retired))
+                           retired=sorted(retired))
+                current_endpoints = {self._role_endpoint(role) for role in job["roles"]}
+                old_endpoints = {}
+                for old_role in previous.get("roles", []) + previous.get("retired_roles", []):
+                    endpoint = self._role_endpoint(old_role)
+                    if endpoint not in current_endpoints:
+                        old_endpoints[endpoint] = {"identity": old_role["identity"], "role": old_role["role"]}
+                job["retired_roles"] = list(old_endpoints.values())
                 for role in job["roles"]:
                     role["name"] = role_names[role["role"]]
                     # Every new generation needs its own imported container.
@@ -616,7 +694,8 @@ class QmtStrategyManager:
                     role["identity_path"] = str(directory / (role["name"] + ".json"))
                     _write_json(role["identity_path"], role["identity"])
                     role["runtime_status_path"] = str(directory / (role["name"] + ".status.json"))
-                    descriptor = {"mode": job["mode"], "generation": generation, "role": role["role"],
+                    descriptor = {"mode": job["mode"], "generation": generation, "role": role["role"],
+                                  "runtime_key": _digest([os.path.normcase(job["root"]), job["account_id"]])[:24],
                                   "control_path": job["control_path"], "lease_dir": str(directory / "leases"),
                                   "runtime_status_path": role["runtime_status_path"]}
                     source = managed_source(Path(role["source"]), role["identity_path"], role["identity"], descriptor)
@@ -642,14 +721,45 @@ class QmtStrategyManager:
             self.event.set()
             return self.status(row["account_key"])
 
-    def _control(self, job):
+    def _control(self, job):
+        _write_json(job["control_path"], self._desired(job))
+
+    def _desired(self, job):
         generation = str(job.get("control_generation") or job.get("generation") or "")
         payload = {"enabled": bool(job.get("enabled")), "generation": generation, "mode": job.get("mode", "")}
         accepted = [item for item in _generation_values(job.get("accepted_generations"))
                     if item and item != generation]
         if accepted:
             payload["accepted_generations"] = accepted
-        _write_json(job["control_path"], payload)
+        payload["runtime_key"] = _digest([os.path.normcase(job["root"]), job["account_id"]])[:24]
+        return payload
+
+    def _sync_pipe_runtime(self, job):
+        if self.runtime_request is None:
+            return
+        desired = self._desired(job)
+        for role in job.get("retired_roles", []):
+            try:
+                self.runtime_request(role["identity"], dict(desired, enabled=False))
+            except Exception:
+                pass
+        for role in job["roles"]:
+            try:
+                report = self.runtime_request(role["identity"], desired)
+                if (isinstance(report, dict) and report.get("runtime_key") == desired["runtime_key"]
+                        and report.get("role") == role["role"]):
+                    # Only the external manager writes status files.
+                    _write_json(role["runtime_status_path"], report)
+            except Exception:
+                # A stopped/not-yet-imported strategy has no Pipe endpoint.
+                # Existing reports expire normally in _observe_runtime.
+                pass
+
+    @staticmethod
+    def _role_endpoint(role):
+        identity = role.get("identity") or {}
+        return (identity.get("pipe_name"), (identity.get("channels") or {}).get("normal")
+                or identity.get("normal_channel") or identity.get("bridge_id"))
 
     def reconcile(self, accounts):
         with self.lock:
@@ -718,9 +828,11 @@ class QmtStrategyManager:
 
     def _advance(self, job):
         root = qmt_root(job["root"], validate=True)
-        if self.process_checker(root):
-            self._observe_runtime(job)
-            return
+        if self.process_checker(root):
+            self._sync_pipe_runtime(job)
+            self._observe_runtime(job)
+            return
+        job["retired_roles"] = []
         if (job.get("state") in ("configured", "running", "waiting_start", "waiting_manual_start")
                 and all(role.get("imported") for role in job["roles"])):
             self._state(job, "configured")
@@ -916,8 +1028,11 @@ class QmtStrategyManager:
             self.event.wait(2.0)
             self.event.clear()
 
-    def close(self):
+    def close(self):
         self.stopping.set()
         self.event.set()
-        if self.worker:
-            self.worker.join(timeout=5.0)
+        if self.worker:
+            self.worker.join(timeout=5.0)
+        close = getattr(self.runtime_request, "close", None)
+        if callable(close) and not (self.worker and self.worker.is_alive()):
+            close()

{cfquant-0.2.50 → cfquant-0.2.51}/cfquant/qmt_strategy_runtime.py

@@ -2,6 +2,7 @@
 
 import functools as _cq_functools
 import glob as _cq_glob
+import io as _cq_io
 import json as _cq_json
 import os as _cq_os
 import threading as _cq_threading
@@ -9,7 +10,7 @@ import time as _cq_time
 
 
 def _cq_lock(path):
-    stream = open(path, "a+b")
+    stream = _cq_io.open(path, "a+b")
     try:
         stream.seek(0)
         if _cq_os.name == "nt":
@@ -62,7 +63,7 @@ class _CqStrategyLease(object):
         try:
             payload = {"state": state, "error": error, "generation": self.descriptor["generation"],
                        "pid": _cq_os.getpid(), "updated_at": _cq_time.time()}
-            with open(temporary, "w", encoding="utf-8") as stream:
+            with _cq_io.open(temporary, "w", encoding="utf-8") as stream:
                 _cq_json.dump(payload, stream, ensure_ascii=True)
             _cq_os.replace(temporary, path)
             self.last_report = payload["updated_at"]
@@ -75,10 +76,18 @@ class _CqStrategyLease(object):
             except OSError:
                 pass
 
+    def _read_control(self):
+        # QMT can supply its own open() in the strategy namespace. Use the
+        # standard-library IO API, as the standalone Lite entry already does.
+        with _cq_io.open(self.descriptor["control_path"], encoding="utf-8") as stream:
+            desired = _cq_json.load(stream)
+        if not isinstance(desired, dict):
+            raise ValueError("control file must contain a JSON object")
+        return desired
+
     def allowed(self):
         try:
-            with open(self.descriptor["control_path"], encoding="utf-8") as stream:
-                desired = _cq_json.load(stream)
+            desired = self._read_control()
             accepted = desired.get("accepted_generations")
             if not isinstance(accepted, (list, tuple, set)):
                 accepted = ()
@@ -87,13 +96,12 @@ class _CqStrategyLease(object):
             return (desired.get("enabled") is True
                     and self.descriptor["generation"] in allowed_generations
                     and desired.get("mode") == self.descriptor["mode"])
-        except (OSError, ValueError):
+        except (OSError, ValueError, TypeError):
             return False
 
     def _denial_reason(self):
         try:
-            with open(self.descriptor["control_path"], encoding="utf-8") as stream:
-                desired = _cq_json.load(stream)
+            desired = self._read_control()
             if desired.get("enabled") is not True:
                 return "control_enabled=false"
             if desired.get("mode") != self.descriptor["mode"]:
@@ -107,8 +115,9 @@ class _CqStrategyLease(object):
             if self.descriptor["generation"] not in allowed_generations:
                 return "generation_mismatch expected=%s actual=%s" % (
                     desired.get("generation"), self.descriptor["generation"])
-        except (OSError, ValueError, TypeError):
-            return "control_file_unavailable"
+        except (OSError, ValueError, TypeError) as error:
+            return "control_file_unavailable path=%s error=%s: %s" % (
+                ascii(self.descriptor.get("control_path")), type(error).__name__, str(error))
         return "control_state_changed"
 
     def acquire(self, timeout=10.0):
@@ -126,7 +135,7 @@ class _CqStrategyLease(object):
                             _cq_unlock(probe)
                             continue
                         try:
-                            with open(path + ".json", encoding="utf-8") as stream:
+                            with _cq_io.open(path + ".json", encoding="utf-8") as stream:
                                 owner = _cq_json.load(stream)
                             compatible = owner.get("generation") == self.descriptor["generation"]
                         except (OSError, ValueError):
@@ -137,7 +146,7 @@ class _CqStrategyLease(object):
                     if not busy and self.allowed():
                         self.lease = _cq_lock(own_path)
                         if self.lease is not None:
-                            with open(own_path + ".json", "w", encoding="utf-8") as stream:
+                            with _cq_io.open(own_path + ".json", "w", encoding="utf-8") as stream:
                                 _cq_json.dump(self.descriptor, stream, ensure_ascii=True)
                             self.active = True
                             return self