fix bug

py-client/strategy/zt/positions.py

@@ -1,101 +1,215 @@
-"""先卖后买做 T；持仓存在 State，未买回数量从实际成交计算。"""
+"""趋势策略持仓止盈与分级补仓。"""
 
-import logging as log
-import math
+from dataclasses import dataclass
 
+from libs.calc import calc_buy_volume, calculate_min_profit_rate
 from libs.grid_take_profit import GridState
+from sdk import OP_BUY, OP_SELL, PositionItem, Tick
+from libs.state import State
 from libs.order import PlaceOrderRequest
 from libs.runtime import Runtime
-from libs.state import State
-from sdk import OP_BUY, OP_SELL, PositionItem
+import logging as log
+
+LOSS_TIERS = -30.0
 
 
-def t_rounds(store: State) -> dict[str, dict]:
-    """每只证券保留最近一轮 T，跨日未买回的数量继续保留。"""
-    rounds = {}
-    for deal in sorted(store.deals.values(), key=lambda d: (
-        d['trade_date'], d['trade_time'].replace(':', ''), d['id']
-    )):
-        order = deal['order_local_id']
-        code = deal['stock_code']
-        if order.startswith('zt-t-sell-') and deal['offset_flag'] in (24, 49):
-            item = rounds.get(code)
-            if item is None or item['bought'] >= item['sold']:
-                item = rounds[code] = dict(sold=0, bought=0, amount=0.0, date='')
-            item['sold'] += deal['volume']
-            item['amount'] += deal['trade_amount']
-            item['date'] = deal['trade_date']
-        elif order.startswith('zt-t-buy-') and deal['offset_flag'] in (23, 48) and code in rounds:
-            rounds[code]['bought'] += deal['volume']
-            rounds[code]['date'] = deal['trade_date']
-    return rounds
+@dataclass(slots=True)
+class TradeDecision:
+    """一次止盈或补仓判断的统一结果。"""
+
+    submitted: bool
+    message: str = ""
+    reserved_cash: float = 0.0
 
 
 def manage_positions(
-    run: Runtime, store: State, ticks, positions: list[PositionItem],
-    rounds: dict[str, dict], available: float, today: str, force_buy_back: bool = False,
-) -> float:
-    """先偿还买回欠仓；同一证券当天完成一轮后不再卖出。"""
-    by_code = {p.stock_code: p for p in positions}
-    codes = dict.fromkeys(list(rounds) + list(store.state))
-    for code in sorted(codes, key=lambda c: not (c in rounds and rounds[c]['sold'] > rounds[c]['bought'])):
+    runtime: Runtime,
+    ticks: dict[str, Tick],
+    positions: list[PositionItem],
+    market_ok: bool,
+    available: float,
+    state:State,
+) -> None:
+    # 遍历处理每个持仓
+    for position in positions:
         try:
-            if code in run.account_cfg.excluded_codes:
-                continue
-            if run.orders.busy(code, 'BUY') or run.orders.busy(code, 'SELL'):
-                continue
+            available = max(0, available)
+            code = position.stock_code
             tick = ticks.get(code)
-            price = tick.last_price if tick else 0.0
-            if not math.isfinite(price) or price <= 0:
+            if code in runtime.account_cfg.excluded_codes:
+                log.info(
+                    "[Position - ] 代码=%s，名称=%s，止盈=跳过，补仓=跳过，原因=已配置为排除股票",
+                    code,
+                    position.stock_name,
+                )
                 continue
-            item = rounds.get(code)
-            row = store.state.get(code, {})
-            position = by_code.get(code)
-            recorded = row.get('base_qty', 0) + row.get('added_qty', 0)
-            if recorded != (position.volume if position else 0):
-                log.warning('[ZT] %s 持仓快照与成交未对齐，等待下一轮', code)
+            if (
+                not code
+                or position.open_price <= 0
+                or position.volume <= 0
+                or tick is None
+                or tick.last_price <= 0
+            ):
+                log.warning(
+                    "[Position - ] 代码=%s，名称=%s，止盈=跳过，补仓=跳过，原因=持仓或行情数据无效",
+                    code or "未知",
+                    position.stock_name,
+                )
                 continue
-            if item and item['sold'] > item['bought']:
-                volume = item['sold'] - item['bought']
-                # 部分成交后的零股欠仓不能按普通买入申报，不扩大买回数量。
-                minimum = 200 if code.startswith('688') else 100
-                if not code.startswith('688'):
-                    volume = volume // 100 * 100
-                if volume < minimum:
-                    log.warning('[ZT] %s 剩余买回 %d 股不满足申报数量，保留欠仓', code, item['sold'] - item['bought'])
-                    continue
-                target = item['amount'] / item['sold'] * (1 - run.account_cfg.zt_buy_fall_pct / 100)
-                if not force_buy_back and price > target:
-                    continue
-                amount = price * volume * 1.01
-                if amount > available:
-                    log.warning('[ZT] %s 买回资金不足，需要 %.2f，可用 %.2f', code, amount, available)
-                    continue
-                if not force_buy_back and not run.add_watch.triggered('ZT 买回', code, price):
-                    continue
-                available -= amount
-                request = PlaceOrderRequest(OP_BUY, code, volume, run.orders.new_order_id('zt', 't-buy'), 'zt')
-                if run.orders.place(run.client, request):
-                    run.add_watch.forget(code)
-                    log.info('[ZT 买回] %s %d 股%s', code, volume, '，尾盘买回' if force_buy_back else '')
+
+            posState = state.get_by_code(position.stock_code)
+            if not posState:
                 continue
-            if force_buy_back or (item and item['date'] >= today) or not position or recorded <= 0:
-                continue
-            if price > run.account_cfg.zt_max_price:
-                continue
-            cost = (row['base_qty'] * row['base_price'] + row['added_qty'] * row['added_price']) / recorded
-            if cost <= 0:
-                continue
-            pnl = (price / cost - 1) * 100
-            observation = run.profit_tracker.observe(f'{run.account_cfg.account_id}:{code}:{today}', pnl)
-            if observation.state != GridState.RETREAT or pnl < run.account_cfg.min_profit_pct:
-                continue
-            volume = int(min(position.can_use_volume, recorded * run.account_cfg.zt_sell_ratio)) // 100 * 100
-            if volume < (200 if code.startswith('688') else 100):
-                continue
-            request = PlaceOrderRequest(OP_SELL, code, volume, run.orders.new_order_id('zt', 't-sell'), 'zt')
-            if run.orders.place(run.client, request):
-                log.info('[ZT 卖出] %s %d 股，按实际成交买回', code, volume)
+
+            volume = position.can_use_volume
+            cost_price = position.open_price
+            if posState.get('added_qty',0) >=100:
+                volume = posState.get('added_qty',0)
+                cost_price = posState.get('added_price',0)
+
+
+            pnl_rate = round(
+                (tick.last_price - cost_price) / cost_price * 100,
+                2,
+            )
+            minimum_profit = calculate_min_profit_rate(cost_price, 1)
+            profit_decision = handle_profit(
+                runtime=runtime,
+                stock_code=position.stock_code,
+                volume=volume,
+                tick=tick,
+                pnl_rate=pnl_rate,
+                minimum_profit=minimum_profit,
+            )
+            profit_action = profit_decision.message or "未触发"
+            loss_add_action = "未启用"
+            if runtime.account_cfg.enable_loss_add_position and market_ok:
+                loss_decision = handle_loss(
+                    runtime=runtime,
+                    position=position,
+                    tick=tick,
+                    pnl_rate=pnl_rate,
+                    available=available,
+                )
+                available = available - loss_decision.reserved_cash
+                loss_add_action = loss_decision.message or "未触发"
+            elif runtime.account_cfg.enable_loss_add_position:
+                loss_add_action = "大盘信号不允许"
+
+            strTag = "-"
+            if pnl_rate >= minimum_profit:
+                strTag = "↑"
+            elif pnl_rate< LOSS_TIERS[0]:
+                strTag = "↓"
+
+            if strTag != "-":
+                log.info(
+                    "[Position %s ] %s %s，盈亏=%.2f%%，止盈=%s，补仓=%s",
+                    strTag,
+                    code,
+                    position.stock_name,
+                    pnl_rate,
+                    profit_action,
+                    loss_add_action,
+                )
         except Exception:
-            log.exception('[ZT 持仓] %s 处理失败', code)
-    return available
+            log.exception(
+                "[Position] 持仓处理异常，代码=%s，继续处理后续持仓",
+                position.stock_code,
+            )
+
+
+def handle_profit(
+    runtime: Runtime,
+    stock_code: str,
+    volume:int,
+    tick: Tick,
+    pnl_rate: float,
+    minimum_profit: float,
+) -> TradeDecision:
+    """基于跨轮保存的最高盈利网格判断是否提交止盈。"""
+    if pnl_rate < minimum_profit:
+        return TradeDecision(False)
+
+    key = _position_key(runtime, stock_code)
+    observation = runtime.profit_tracker.observe(key, pnl_rate)
+    if observation.state == GridState.ARMED:
+        return TradeDecision(
+            False,
+            f"首次, PNL:{pnl_rate:.2f}%，网格={observation.current_grid}",
+        )
+    if observation.state == GridState.RAISED:
+        return TradeDecision(
+            False,
+            f"突破, PNL:{pnl_rate:.2f}%，网格={observation.current_grid}",
+        )
+    if observation.state == GridState.STEADY:
+        return TradeDecision(False,f"持平, PNL:{pnl_rate:.2f}%，网格={observation.current_grid}",)
+    if runtime.orders.busy(stock_code, "SELL"):
+        return TradeDecision(False, "卖出委托处理中")
+
+    volume = volume % 100
+    if volume <= 0:
+        return TradeDecision(False, "无可用整手持仓")
+    order_id = runtime.orders.new_order_id("zt","SELL")
+    request = PlaceOrderRequest(
+        op=OP_SELL,
+        code=stock_code,
+        volume=volume,
+        order_id=order_id,
+        strategy_name=runtime.account_cfg.strategy,
+    )
+    if not runtime.orders.place(runtime.client, request):
+        return TradeDecision(False, "止盈委托失败")
+
+    return TradeDecision(True, f"[止盈卖出] {volume} 股，订单={order_id}")
+
+
+def handle_loss(
+    runtime: Runtime,
+    stock_code: str,
+    volume:int,
+    tick: Tick,
+    pnl_rate: float,
+    available: float,
+) -> TradeDecision:
+    """按亏损档位、反弹确认和本轮剩余预算提交补仓。"""
+    if pnl_rate > LOSS_TIERS:
+        return TradeDecision(False)
+    if not runtime.add_watch.triggered("补仓", stock_code, tick.last_price):
+        return TradeDecision(False, "等待价格反弹确认")
+    if runtime.orders.busy(stock_code, "BUY"):
+        return TradeDecision(False, "买入委托处理中")
+
+    volume = calc_buy_volume(tick.last_price, runtime.account_cfg.buy_value)
+    amount = tick.last_price * volume
+    if volume <= 0 or amount > available:
+        return TradeDecision(False, "本轮可用资金不足")
+
+    order_id = runtime.orders.new_order_id("zt","added")
+    request = PlaceOrderRequest(
+        op=OP_BUY,
+        code=stock_code,
+        volume=volume,
+        order_id=order_id,
+        strategy_name=runtime.account_cfg.strategy,
+        kind="add",
+    )
+
+    if not runtime.orders.place(runtime.client, request):
+        return TradeDecision(False, "补仓订单委托失败")
+
+    runtime.add_watch.forget(position.stock_code)
+    return TradeDecision(True, f"[补仓买入] {volume} 股，订单={order_id}", amount)
+
+
+def _position_key(runtime: Runtime, code: str) -> str:
+    return f"{runtime.account_cfg.account_id}:{code}"
+
+
+def get_add_num(hands: int, market_value: float) -> int:
+    if market_value > 10000:
+        return -1
+    if hands < 2:
+        return 0
+    return -1