dev zt

py-client/strategy/zt/boot.py

@@ -1,196 +1,96 @@
-"""做 T 策略启动器。
+"""ZT 启动与串行调度：成交同步、买回、卖出、建仓。"""
 
-该模块负责组合 SDK、配置、状态存储和做 T 策略组件，供 main.py 调用。
-"""
-
-from concurrent.futures import Future, ThreadPoolExecutor
 import logging as log
 import time
-from datetime import datetime, time as clock_time
+from datetime import datetime
 from pathlib import Path
 
 import config
 from libs.calc import trading_time
-from libs.market import market_allow_open
-from libs.signal import SignalItem, init_signals
 from libs.collector import collector_push
 from libs.grid_take_profit import GridTrailingTracker
-from sdk import Client
+from libs.market import market_allow_open
+from libs.order import OrderBook
 from libs.overview import Overview
-from libs.order import BUSY_STATUSES, OrderBook
-from libs.watch import DipWatch
 from libs.runtime import Runtime
+from libs.signal import SignalItem, init_signals
+from libs.state import State
+from libs.watch import DipWatch
+from sdk import Client, DealItem, PositionItem
 from .open import open_signal
-from .positions import manage_positions
+from .positions import manage_positions, t_rounds
 
 
 def StartZT() -> None:
-    """初始化做 T 策略，并以 30 秒间隔持续执行。"""
-    with Client(
-        config.global_config.qmt_base_url,
-        config.global_config.qmt_token,
-        config.HTTP_TIMEOUT,
-    ) as client:
-        # state = TState(
-        #     Path(config.global_config.qmt_data_dir)
-        #     / f"zt_{config.account_config.account_id}_state.db"
-        # )
-        executor = ThreadPoolExecutor(max_workers=3, thread_name_prefix="zt")
+    with Client(config.global_config.qmt_base_url, config.global_config.qmt_token, config.HTTP_TIMEOUT) as client:
+        state = State(Path(config.global_config.qmt_data_dir) / f'zt_{config.account_config.account_id}_state.db')
         run = Runtime(
-            client=client,
-            global_cfg=config.global_config,
-            account_cfg=config.account_config,
-            orders=OrderBook("zt"),
-            open_watch=DipWatch(),
-            add_watch=DipWatch(),
+            client=client, global_cfg=config.global_config, account_cfg=config.account_config,
+            orders=OrderBook('zt'), open_watch=DipWatch(), add_watch=DipWatch(),
             profit_tracker=GridTrailingTracker(config.account_config.grid_step_pct),
-            executor=executor
         )
-
+        # 先读取成交，再读取持仓，减少成交已入账而快照仍未更新的情况。
+        deals = client.deals()
         portfolio = client.portfolio()
-        assets = portfolio.assets
         positions = list(portfolio.positions.values())
+        sync_account_state(state, positions, deals, initialize=not state.state and not state.deals)
         run.orders.refresh(client, portfolio.orders)
-        
-        # 获取本策略的信号开仓数据
-        signals = init_signals(config.global_config,["dcm"])
-        log.info("[启动] ZT 策略已启动，账户=%s，信号=%d，持仓=%d",
-            config.account_config.account_id,
-            len(signals),
-            len(positions),
-        )
-
-        Overview(assets, positions, config.account_config)
-
-        DEFAULT_TICK_INTERVAL = 30
-        while True:
-            lt = time.localtime()
-            if (lt.tm_hour, lt.tm_min, lt.tm_sec) >= (15, 0, 0):
-                log.info("[Trend] 已到 15:00，结束趋势策略")
-                return
-            current_sec = lt.tm_sec
-        
-            # 计算距离下一个目标时间点（0秒或30秒）的等待时间
-            if current_sec < DEFAULT_TICK_INTERVAL:
-                wait_seconds = DEFAULT_TICK_INTERVAL - current_sec
-            elif current_sec < 60:
-                wait_seconds = 60 - current_sec
-            else:
-                wait_seconds = DEFAULT_TICK_INTERVAL
-
-            # 等待到目标时间点
-            time.sleep(wait_seconds)
-
-            # 单轮失败不能杀死唯一的交易定时线程。
+        signals = init_signals(config.global_config, ['dcm'])
+        Overview(portfolio.assets, positions, config.account_config)
+        log.info('[ZT] 启动，账户=%s，信号=%d', config.account_config.account_id, len(signals))
+        while datetime.now().hour < 15:
             try:
                 RunOnce(run, state, signals)
-            except Exception as e:
-                log.error(
-                    f"[Trend] 本 tick 执行失败，下一 tick 继续: {e}", exc_info=True
-                )
+            except Exception:
+                log.exception('[ZT] 本轮失败，下一轮重试')
+            time.sleep(30 - time.time() % 30)
+        # 收盘后补记最后一轮成交，不再下单。
+        sync_account_state(state, list(client.portfolio().positions.values()), client.deals())
 
-def RunOnce(run: Runtime, state: TState, signals: list[SignalItem]) -> None:
-    """账户快照 → 成交对账 → 做 T 管理 → dcm 建仓，共用一份资金预算。"""
+
+def RunOnce(run: Runtime, state: State, signals: list[SignalItem]) -> None:
     now = datetime.now()
     if not trading_time(now):
         return
-    
-    started_at = time.monotonic()
-
-    # 1. 一次获取资产、持仓和订单，并清理过期订单。
-    try:
-        portfolio = run.client.portfolio()
-        assets = portfolio.assets
-        deals = run.client.deals()
-        position_codes = list(portfolio.positions)
-        positions = list(portfolio.positions.values())
-        run.orders.refresh(run.client, portfolio.orders)
-        state.reconcile(positions,deals)
-    except Exception:
-        log.exception("[Portfolio] 刷新账户快照失败")
+    deals = run.client.deals()
+    portfolio = run.client.portfolio()
+    assets = portfolio.assets
+    positions = list(portfolio.positions.values())
+    run.orders.refresh(run.client, portfolio.orders)
+    sync_account_state(state, positions, deals)
+    # 收盘集合竞价前停止提交新委托，继续保存成交。
+    if (now.hour, now.minute) >= (14, 57):
         return
-
-    futures: list[tuple[str, Future]] = [
-        (
-            "数据提交",
-            run.executor.submit(
-                collector_push,
-                run.account_cfg.account_id,
-                assets,
-                positions,
-            ),
-        )
-    ]
-
-    # 2. 验证可用资金；低于资金安全线时禁止开新仓。
-    allow_open_by_cash = (
-        assets.available >= assets.total * run.account_cfg.min_cash_ratio
-    )
-    if not allow_open_by_cash:
-        log.info(
-            "[Status] 禁止开仓：可用资金不足，可用=%.2f，总资产=%.2f",
-            assets.available,
-            assets.total,
-        )
-
-    # 3. 获取大盘状态，只有大盘信号允许时才执行开仓。
-    market_ok = market_allow_open()
-
-    # 4. 验证有效开仓信号：排除已有持仓和未决订单。
-    allow_open: list[SignalItem] = []
-    allow_codes: list[str] = []
-    for signal in signals:
-        if signal.code not in portfolio.positions:
-            allow_open.append(signal)
-            allow_codes.append(signal.code)
-
-    if allow_open and not market_ok:
-        log.info("[开仓] 禁止开仓：大盘信号不允许，候选=%d", len(allow_open))
-
-    # 5. 获取持仓和待开仓证券的实时行情 tick。
-    all_codes = list(dict.fromkeys(position_codes + allow_codes))
+    rounds = t_rounds(state)
+    pending = {code for code, item in rounds.items() if item['sold'] > item['bought']}
+    candidates = {s.code: s for s in signals if s.code not in portfolio.positions
+                  and s.code not in state.state and s.code not in pending}
+    codes = list(dict.fromkeys(list(state.state) + sorted(pending) + list(candidates)))
+    ticks = run.client.full_tick(codes) if codes else {}
+    force = (now.hour, now.minute) >= (14, 50)
+    available = manage_positions(run, state, ticks, positions, rounds, assets.available, now.date().isoformat(), force)
+    # 尚未买回时不分走资金；买回与新建仓使用同一份剩余资金。
+    if not force and not pending and available >= assets.total * run.account_cfg.min_cash_ratio:
+        if candidates and market_allow_open():
+            budget = max(0.0, available - assets.total * run.account_cfg.min_cash_ratio)
+            open_signal(run, ticks, list(candidates.values()), budget)
     try:
-        ticks = run.client.full_tick(all_codes)
+        collector_push(run.account_cfg.account_id, assets, positions)
     except Exception:
-        log.exception("[行情] 获取行情失败，代码数量=%d", len(all_codes))
+        log.exception('[ZT] 持仓上报失败')
+
+
+def sync_account_state(
+    state: State, positions: list[PositionItem], deals: list[DealItem], *, initialize: bool = False,
+) -> None:
+    """初次持仓作为底仓；后续只按成交减仓，避免延迟快照删除持仓。"""
+    zt_deals = [d for d in deals if d.get_local_order_id.startswith('zt-')]
+    state.sync_deals(zt_deals, archived=initialize)
+    if initialize:
+        state.sync_state(positions)
         return
-
-    log.info(
-        "[RunOnce] 本轮就绪，持仓=%d，候选=%d，大盘允许=%s，资金允许=%s",
-        len(positions),
-        len(allow_open),
-        market_ok,
-        allow_open_by_cash,
-    )
-
-    # 启动线程，开始计算
-    # 7. 持仓计算。
-    futures.append(
-        (
-            "持仓计算",
-            run.executor.submit(
-                manage_positions, run, ticks, positions, market_ok, assets.available
-            ),
-        )
-    )
-
-    # 8. 开仓计算：必须同时存在有效信号且大盘允许开仓。
-    if allow_open and market_ok and allow_open_by_cash:
-        futures.append(
-            ("开仓计算", run.executor.submit(open_signal, run, ticks, allow_open))
-        )
-
-    # 9. 开始执行
-    for name, future in futures:
-        _wait_worker(name, future)
-    log.info(
-        "[RunOnce] 本轮完成，耗时=%d毫秒", int((time.monotonic() - started_at) * 1000)
-    )
-
-
-def _wait_worker(name: str, future: Future) -> None:
-    """保留单轮继续运行的语义，分别记录工作线程异常。"""
-    try:
-        future.result()
-    except Exception:
-        log.exception("[运行] %s线程失败", name)
+    errors = state.archiving(base_order_prefix='zt-base-')
+    if errors:
+        raise ValueError(f'ZT 成交归档失败：{errors}')
+    traded = {d['stock_code'] for d in state.deals.values()}
+    state.sync_state([p for p in positions if p.stock_code not in traded], remove_missing=False)