diff --git a/GridTrading.spec b/GridTrading.spec new file mode 100644 index 0000000..935e58d --- /dev/null +++ b/GridTrading.spec @@ -0,0 +1,53 @@ +# -*- mode: python ; coding: utf-8 -*- + + +a = Analysis( + ['src\\grid_trading\\app.py'], + pathex=['src'], + binaries=[], + datas=[('assets\\app_icon.ico', 'assets')], + hiddenimports=[], + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + noarchive=False, + optimize=0, +) + +# Qt 6 on Windows uses the ICU compatibility DLLs provided by the operating +# system. The Codex runtime also puts Poppler's private ICU 78 directory on +# PATH, which can make PyInstaller collect those incompatible DLLs by name. +# If bundled, they shadow Windows' ICU DLLs and PySide6.QtCore fails to load +# with ERROR_PROC_NOT_FOUND during startup. +_excluded_runtime_dlls = {"icuuc.dll", "icudt78.dll"} +a.binaries = [ + entry + for entry in a.binaries + if entry[0].replace("\\", "/").rsplit("/", 1)[-1].lower() + not in _excluded_runtime_dlls +] + +pyz = PYZ(a.pure) + +exe = EXE( + pyz, + a.scripts, + a.binaries, + a.datas, + [], + name='GridTrading', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + upx_exclude=[], + icon=['assets\\app_icon.ico'], + runtime_tmpdir=None, + console=False, + disable_windowed_traceback=False, + argv_emulation=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None, +) diff --git a/README.md b/README.md index 9bff363..a69c9ad 100644 --- a/README.md +++ b/README.md @@ -8,14 +8,15 @@ - **账户概览**:展示账户权益、现金、持仓市值、浮动盈亏和资金使用率。 - **标的管理**:维护股票或 ETF 的代码、名称、市场、交易单位及零股规则。 -- **成交管理**:手工录入、编辑和删除买卖记录,并区分底仓、网格仓和其他仓位。 +- **成交管理**:手工录入、编辑和删除买卖记录,并标记普通、正向或反向网格类型。 - **费用估算**:按内置费率估算佣金、印花税和过户费,估算后仍可手工调整。 -- **持仓分析**:计算总持仓、T+1 可用数量、剩余成本、已实现盈亏、浮动盈亏及网格利润。 +- **持仓分析**:计算总持仓、可卖数量、剩余成本、已实现盈亏、浮动盈亏及网格利润。 - **回本价计算**:同时提供持仓回本价与账户回本价,便于观察网格收益对成本的影响。 - **实时行情**:异步获取腾讯行情,刷新过程中不会阻塞主界面。 -- **网格建议**:根据实时价格和默认策略,生成最多 100 档的买入价、建议数量、卖出价与预计毛利润。 -- **待卖网格**:按批次展示尚未卖出的网格买入及其目标卖出价、当前状态。 -- **成交配对**:使用 FIFO(先进先出)将网格卖出与历史网格买入配对,一笔卖出可拆分匹配多笔买入。 +- **双向网格建议**:支持正向(先买后卖)、反向(先卖后买)和双向模式,最多生成 100 档建议。 +- **未完成网格**:同时展示等待卖出的正向批次和等待买回的反向批次。 +- **悬浮监控**:每 10 秒自动刷新行情,监控手工固定的开仓价和未完成网格的平仓价。 +- **双向成交配对**:正向与反向成交分别使用 FIFO 配对,支持部分成交和扣费后净利润。 - **本地存储**:账户、标的、策略和成交数据均保存在 SQLite 数据库中。 ## 技术栈 @@ -84,9 +85,11 @@ python -m grid_trading.app --db data/dev.db 1. 点击“账户设置”,填写账户名称和初始资金。 2. 点击“添加标的”,填写证券代码、名称、市场和交易单位。 3. 点击“策略设置”,调整网格间距、每格金额等参数。 -4. 点击“录入成交”,选择买卖方向、仓位分组并填写实际成交信息。 +4. 点击“录入成交”,选择买卖方向和交易类型并填写实际成交信息。 5. 点击“刷新行情”,获取现价并更新持仓市值、浮动盈亏和账户摘要。 -6. 在持仓表中选择一个标的,查看“网格档位”“待卖网格”“配对明细”和“最近成交”。 +6. 在持仓表中选择一个标的,查看“网格档位”“未完成网格”“配对明细”和“最近成交”。 +7. 在“网格档位”中选择正向、反向或双向模式,选中一档后点击“加入开仓监控”。实际开仓成交录入后,目标卖出或买回价会自动加入悬浮窗。 +8. 点击“悬浮监控”可重新显示窗口;双击监控项可回到主界面的对应标的。 ## 行情说明 @@ -109,7 +112,8 @@ http://qt.gtimg.cn/q= - 行情刷新需要网络连接,单次请求超时时间为 5 秒,失败后会自动重试一次。 - 行情快照只保存在当前进程内存中,不会写入 SQLite。 -- 重新启动程序后,需要再次点击“刷新行情”。 +- 程序启动后会自动刷新行情,默认间隔为 10 秒,也可以随时点击“刷新行情”或悬浮窗中的“立即刷新”。 +- 连续两次行情刷新失败后,监控项会回到“等待行情”,不会用过期价格继续判断到价。 - 未刷新行情时,不使用手工价格或最近成交价代替现价,因此市值、浮动盈亏和网格档位可能为空。 ## 计算口径 @@ -118,10 +122,11 @@ http://qt.gtimg.cn/q= - 买入成本 = 成交金额 + 交易费用。 - 卖出净收入 = 成交金额 - 交易费用。 -- 同一仓位分组内的卖出成本按移动平均成本释放。 +- 所有成交使用统一持仓池,卖出成本按标的统一移动平均成本释放。 - 已实现盈亏 = 卖出净收入 - 被释放的持仓成本。 -- 网格利润只统计“网格”分组的已实现盈亏。 -- T+1 可用数量会扣除计算当日的买入数量;卖出数量不得超过可用数量,也不得超过对应分组的持仓数量。 +- 网格利润按照带有网格方向的已配对成交计算,正向和反向都扣除按成交数量分摊的双边费用。 +- 本工具不执行 T+1 限制:当日买入会立即计入可卖数量。 +- 不设置最低底仓保护,可以卖到持仓为 0,但不能录入超过标的总持仓的卖出。 - 修改或删除历史成交后,程序会重新校验后续成交,避免形成负持仓。 ### 回本价与账户摘要 @@ -133,7 +138,7 @@ http://qt.gtimg.cn/q= ### 网格档位 -第 1 档买入价按下式计算,之后逐档复合递减: +正向第 1 档买入价按下式计算,之后逐档复合递减: ```text 买入价 = 上一档参考价 × (1 - 网格间距) @@ -141,14 +146,23 @@ http://qt.gtimg.cn/q= 建议数量 = 每格金额 ÷ 买入价,并按交易单位向下取整 ``` +反向网格向上生成卖出档位,并在回落后买回: + +```text +卖出价 = 上一档参考价 × (1 + 网格间距) +目标买回价 = 卖出价 ÷ (1 + 网格间距) +建议数量 = 每格金额 ÷ 卖出价,并按交易单位和当前持仓向下取整 +``` + 档位表中的“预计单轮毛利润”不扣除交易费用,且建议结果只用于展示,不会自动生成成交记录或下单。 -### 待卖网格与配对明细 +### 未完成网格与配对明细 -- 只有“网格”分组的成交参与待卖批次和配对计算。 -- 网格卖出按照成交日期和记录顺序,优先抵消最早的网格买入。 -- 待卖批次状态包括“未刷新行情”“未到价”和“可卖”。 -- 配对明细展示历史买卖的对应关系和毛利润,不扣除费用。 +- 历史“网格”分组成交自动按正向网格兼容;旧分组字段仅用于数据库兼容,不再影响持仓和卖出校验。 +- 正向按照“买入 → 卖出”配对,反向按照“卖出 → 买回”配对,两套队列互不占用。 +- 平仓成交按照日期和记录顺序,优先抵消同方向最早的开仓批次。 +- 未完成状态包括“未刷新行情”“未到价”“可卖”和“可买回”。 +- 配对明细同时展示毛利润、双边费用和净利润。 ## 默认费用参数 diff --git a/assets/app_icon.ico b/assets/app_icon.ico new file mode 100644 index 0000000..f6a392b Binary files /dev/null and b/assets/app_icon.ico differ diff --git a/assets/app_icon.png b/assets/app_icon.png new file mode 100644 index 0000000..425bc71 Binary files /dev/null and b/assets/app_icon.png differ diff --git a/src/grid_trading/config.py b/src/grid_trading/config.py index 25b622a..a3a7b9b 100644 --- a/src/grid_trading/config.py +++ b/src/grid_trading/config.py @@ -1,12 +1,20 @@ from __future__ import annotations +import sys from dataclasses import dataclass from decimal import Decimal from pathlib import Path -PROJECT_ROOT = Path(__file__).resolve().parents[2] +if getattr(sys, "frozen", False): + # Keep the writable database beside the packaged executable instead of in + # PyInstaller's temporary extraction directory. + PROJECT_ROOT = Path(sys.executable).resolve().parent +else: + PROJECT_ROOT = Path(__file__).resolve().parents[2] +RESOURCE_ROOT = Path(getattr(sys, "_MEIPASS", PROJECT_ROOT)) DEFAULT_DB_PATH = PROJECT_ROOT / "data" / "grid_trading.db" +APP_ICON_PATH = RESOURCE_ROOT / "assets" / "app_icon.ico" @dataclass(frozen=True) diff --git a/src/grid_trading/domain/calculations.py b/src/grid_trading/domain/calculations.py index 29f9518..415c72b 100644 --- a/src/grid_trading/domain/calculations.py +++ b/src/grid_trading/domain/calculations.py @@ -29,7 +29,7 @@ class CalculationError(ValueError): @dataclass -class _GroupState: +class _PositionState: quantity: int = 0 cost: Decimal = Decimal("0") realized_pnl: Decimal = Decimal("0") @@ -71,13 +71,19 @@ def calculate_positions( cashflows = instrument_cashflows or {} quotes = quote_snapshots or {} instrument_by_id = {instrument.id: instrument for instrument in instruments if instrument.id is not None} - states: dict[int, dict[TradeGroup, _GroupState]] = defaultdict( - lambda: {group: _GroupState() for group in TradeGroup} + states: dict[int, _PositionState] = defaultdict(_PositionState) + legacy_group_quantities: dict[int, dict[TradeGroup, int]] = defaultdict( + lambda: {group: 0 for group in TradeGroup} ) net_invested: dict[int, Decimal] = defaultdict(lambda: Decimal("0")) - today_buys: dict[int, int] = defaultdict(int) - for trade in sorted(trades, key=lambda item: (item.trade_date, item.id or 0)): + for trade in sorted( + trades, + key=lambda item: ( + item.trade_date, + item.id if item.id is not None else 2**63 - 1, + ), + ): if trade.trade_date > as_of: continue _validate_trade(trade) @@ -85,45 +91,53 @@ def calculate_positions( if instrument is None: raise CalculationError(f"Trade references unknown instrument {trade.instrument_id}") - group_state = states[trade.instrument_id][trade.trade_group] + state = states[trade.instrument_id] gross = money(trade.gross_amount) fees = money(trade.total_fee) if trade.side is TradeSide.BUY: - group_state.quantity += trade.quantity - group_state.cost = money(group_state.cost + gross + fees) + state.quantity += trade.quantity + state.cost = money(state.cost + gross + fees) + legacy_group_quantities[trade.instrument_id][trade.trade_group] += trade.quantity net_invested[trade.instrument_id] = money(net_invested[trade.instrument_id] + gross + fees) - if trade.trade_date == as_of: - today_buys[trade.instrument_id] += trade.quantity else: - if trade.quantity > group_state.quantity: + if trade.quantity > state.quantity: raise CalculationError( - f"Insufficient {trade.trade_group.value} position for {instrument.code}" + f"{instrument.code} 总持仓不足:当前 {state.quantity}," + f"尝试卖出 {trade.quantity}" ) - average_cost = group_state.cost / Decimal(group_state.quantity) + average_cost = state.cost / Decimal(state.quantity) released_cost = money(average_cost * Decimal(trade.quantity)) net_income = money(gross - fees) realized = money(net_income - released_cost) - group_state.quantity -= trade.quantity - group_state.cost = money(group_state.cost - released_cost) - group_state.realized_pnl = money(group_state.realized_pnl + realized) + state.quantity -= trade.quantity + state.cost = money(state.cost - released_cost) if state.quantity > 0 else Decimal("0.00") + state.realized_pnl = money(state.realized_pnl + realized) + legacy_group_quantities[trade.instrument_id][trade.trade_group] -= trade.quantity net_invested[trade.instrument_id] = money(net_invested[trade.instrument_id] - net_income) summaries: list[PositionSummary] = [] for instrument in instruments: if instrument.id is None: continue - group_states = states[instrument.id] - base_quantity = group_states[TradeGroup.BASE].quantity - grid_quantity = group_states[TradeGroup.GRID].quantity - other_quantity = group_states[TradeGroup.OTHER].quantity - total_quantity = base_quantity + grid_quantity + other_quantity - remaining_cost = money(sum((state.cost for state in group_states.values()), Decimal("0"))) - realized_pnl = money(sum((state.realized_pnl for state in group_states.values()), Decimal("0"))) - grid_profit = money(group_states[TradeGroup.GRID].realized_pnl) + state = states[instrument.id] + group_quantities = legacy_group_quantities[instrument.id] + base_quantity = group_quantities[TradeGroup.BASE] + grid_quantity = group_quantities[TradeGroup.GRID] + other_quantity = group_quantities[TradeGroup.OTHER] + total_quantity = state.quantity + remaining_cost = money(state.cost) + realized_pnl = money(state.realized_pnl) + # Import locally to avoid a module cycle: open-grid calculations reuse money/price helpers. + from grid_trading.domain.open_grid_lots import calculate_grid_profit + + grid_profit = calculate_grid_profit( + [trade for trade in trades if trade.instrument_id == instrument.id], + as_of=as_of, + ) current_price, price_source = _resolve_current_price(quotes.get(instrument.id)) market_value = money(current_price * Decimal(total_quantity)) if current_price is not None else None floating_pnl = money(market_value - remaining_cost) if market_value is not None else None - available_quantity = max(0, total_quantity - today_buys[instrument.id]) + available_quantity = total_quantity adjusted_net_invested = money(net_invested[instrument.id] - cashflows.get(instrument.id, Decimal("0"))) summaries.append( diff --git a/src/grid_trading/domain/grid_alerts.py b/src/grid_trading/domain/grid_alerts.py new file mode 100644 index 0000000..484c977 --- /dev/null +++ b/src/grid_trading/domain/grid_alerts.py @@ -0,0 +1,40 @@ +from __future__ import annotations + +from dataclasses import dataclass +from decimal import Decimal + +from grid_trading.domain.models import GridAlertState, TradeSide + + +@dataclass(frozen=True) +class GridAlertEvaluation: + state: GridAlertState + distance_pct: Decimal | None + + +def evaluate_grid_alert( + *, + side: TradeSide, + current_price: Decimal | None, + target_price: Decimal, + near_threshold: Decimal = Decimal("0.005"), +) -> GridAlertEvaluation: + if target_price <= 0: + raise ValueError("监控目标价必须大于 0") + if near_threshold < 0: + raise ValueError("接近阈值不能小于 0") + if current_price is None or current_price <= 0: + return GridAlertEvaluation(GridAlertState.UNAVAILABLE, None) + + if side is TradeSide.BUY: + distance_pct = (current_price - target_price) / target_price + else: + distance_pct = (target_price - current_price) / target_price + + if distance_pct <= 0: + state = GridAlertState.REACHED + elif distance_pct <= near_threshold: + state = GridAlertState.NEAR + else: + state = GridAlertState.WAITING + return GridAlertEvaluation(state, distance_pct) diff --git a/src/grid_trading/domain/grid_levels.py b/src/grid_trading/domain/grid_levels.py index 41e4ce7..33db7d9 100644 --- a/src/grid_trading/domain/grid_levels.py +++ b/src/grid_trading/domain/grid_levels.py @@ -3,7 +3,7 @@ from __future__ import annotations from decimal import Decimal from grid_trading.domain.calculations import money, price -from grid_trading.domain.models import GridLevelSuggestion +from grid_trading.domain.models import GridDirection, GridLevelSuggestion def generate_grid_levels( @@ -13,6 +13,8 @@ def generate_grid_levels( amount_per_grid: Decimal, lot_size: int, levels: int, + direction: GridDirection = GridDirection.FORWARD, + max_quantity: int | None = None, ) -> list[GridLevelSuggestion]: if current_price <= 0: raise ValueError("现价必须大于 0") @@ -24,13 +26,25 @@ def generate_grid_levels( raise ValueError("交易单位必须大于 0") if levels < 1 or levels > 100: raise ValueError("档数必须在 1 到 100 之间") + if max_quantity is not None and max_quantity < 0: + raise ValueError("最大数量不能为负数") suggestions: list[GridLevelSuggestion] = [] - buy_price = price(current_price * (Decimal("1") - spacing)) + forward_buy_price = price(current_price * (Decimal("1") - spacing)) + reverse_sell_price = price(current_price * (Decimal("1") + spacing)) for level in range(1, levels + 1): - quantity = int(amount_per_grid / buy_price) // lot_size * lot_size - actual_investment = money(buy_price * Decimal(quantity)) - sell_price = price(buy_price * (Decimal("1") + spacing)) + if direction is GridDirection.FORWARD: + buy_price = forward_buy_price + sell_price = price(buy_price * (Decimal("1") + spacing)) + open_price = buy_price + else: + sell_price = reverse_sell_price + buy_price = price(sell_price / (Decimal("1") + spacing)) + open_price = sell_price + quantity = int(amount_per_grid / open_price) // lot_size * lot_size + if max_quantity is not None: + quantity = min(quantity, max_quantity // lot_size * lot_size) + actual_investment = money(open_price * Decimal(quantity)) estimated_gross_profit = money((sell_price - buy_price) * Decimal(quantity)) suggestions.append( GridLevelSuggestion( @@ -41,7 +55,11 @@ def generate_grid_levels( actual_investment=actual_investment, sell_price=sell_price, estimated_gross_profit=estimated_gross_profit, + direction=direction, ) ) - buy_price = price(buy_price * (Decimal("1") - spacing)) + if direction is GridDirection.FORWARD: + forward_buy_price = price(forward_buy_price * (Decimal("1") - spacing)) + else: + reverse_sell_price = price(reverse_sell_price * (Decimal("1") + spacing)) return suggestions diff --git a/src/grid_trading/domain/models.py b/src/grid_trading/domain/models.py index a97eb06..7ba9f3e 100644 --- a/src/grid_trading/domain/models.py +++ b/src/grid_trading/domain/models.py @@ -1,7 +1,7 @@ from __future__ import annotations from dataclasses import dataclass -from datetime import date +from datetime import date, datetime from decimal import Decimal from enum import StrEnum @@ -17,6 +17,29 @@ class TradeGroup(StrEnum): OTHER = "other" +class GridDirection(StrEnum): + FORWARD = "forward" + REVERSE = "reverse" + + +class GridMode(StrEnum): + FORWARD = "forward" + REVERSE = "reverse" + BOTH = "both" + + +class GridAlertState(StrEnum): + UNAVAILABLE = "unavailable" + WAITING = "waiting" + NEAR = "near" + REACHED = "reached" + + +class GridAlertSource(StrEnum): + MANUAL = "manual" + OPEN_GRID_LOT = "open_grid_lot" + + @dataclass(frozen=True) class Account: id: int | None @@ -47,6 +70,7 @@ class StrategyTemplate: max_position_amount: Decimal min_lot: int = 100 is_default: bool = False + grid_mode: GridMode = GridMode.FORWARD @dataclass(frozen=True) @@ -58,6 +82,7 @@ class StrategyOverride: base_target_amount: Decimal | None = None max_position_amount: Decimal | None = None min_lot: int | None = None + grid_mode: GridMode | None = None @dataclass(frozen=True) @@ -74,6 +99,7 @@ class Trade: transfer_fee: Decimal = Decimal("0") trade_group: TradeGroup = TradeGroup.GRID notes: str = "" + grid_direction: GridDirection | None = None @property def gross_amount(self) -> Decimal: @@ -123,20 +149,115 @@ class GridLevelSuggestion: actual_investment: Decimal sell_price: Decimal estimated_gross_profit: Decimal + direction: GridDirection = GridDirection.FORWARD + + @property + def open_side(self) -> TradeSide: + return TradeSide.BUY if self.direction is GridDirection.FORWARD else TradeSide.SELL + + @property + def open_price(self) -> Decimal: + return self.buy_price if self.direction is GridDirection.FORWARD else self.sell_price + + @property + def close_side(self) -> TradeSide: + return TradeSide.SELL if self.direction is GridDirection.FORWARD else TradeSide.BUY + + @property + def close_price(self) -> Decimal: + return self.sell_price if self.direction is GridDirection.FORWARD else self.buy_price + + +@dataclass(frozen=True) +class GridAlertTarget: + id: int | None + target_key: str + instrument_id: int + side: TradeSide + target_price: Decimal + quantity: int + source: GridAlertSource + enabled: bool = True + last_state: GridAlertState = GridAlertState.UNAVAILABLE + alerted: bool = False + last_alerted_at: datetime | None = None + + +@dataclass(frozen=True) +class GridMonitorItem: + target_key: str + instrument_id: int + code: str + name: str + side: TradeSide + target_price: Decimal + quantity: int + current_price: Decimal | None + state: GridAlertState + distance_pct: Decimal | None + source: GridAlertSource + + +@dataclass(frozen=True) +class GridMonitorSnapshot: + items: list[GridMonitorItem] + newly_reached: list[GridMonitorItem] + evaluated_at: datetime @dataclass(frozen=True) class OpenGridLot: - buy_trade_id: int | None - buy_date: date - buy_price: Decimal + direction: GridDirection + open_trade_id: int | None + open_date: date + open_price: Decimal remaining_quantity: int - actual_investment: Decimal - suggested_sell_price: Decimal + open_amount: Decimal + target_price: Decimal estimated_gross_profit: Decimal current_price: Decimal | None status: str + @property + def close_side(self) -> TradeSide: + return TradeSide.SELL if self.direction is GridDirection.FORWARD else TradeSide.BUY + + @property + def buy_trade_id(self) -> int | None: + return self.open_trade_id if self.direction is GridDirection.FORWARD else None + + @property + def sell_trade_id(self) -> int | None: + return self.open_trade_id if self.direction is GridDirection.REVERSE else None + + @property + def buy_date(self) -> date | None: + return self.open_date if self.direction is GridDirection.FORWARD else None + + @property + def sell_date(self) -> date | None: + return self.open_date if self.direction is GridDirection.REVERSE else None + + @property + def buy_price(self) -> Decimal: + return self.open_price if self.direction is GridDirection.FORWARD else self.target_price + + @property + def sell_price(self) -> Decimal: + return self.target_price if self.direction is GridDirection.FORWARD else self.open_price + + @property + def actual_investment(self) -> Decimal: + return self.open_amount + + @property + def suggested_sell_price(self) -> Decimal: + return self.sell_price + + @property + def suggested_buy_price(self) -> Decimal: + return self.buy_price + @dataclass(frozen=True) class GridTradeMatch: @@ -150,6 +271,10 @@ class GridTradeMatch: buy_amount: Decimal sell_amount: Decimal gross_profit: Decimal + direction: GridDirection = GridDirection.FORWARD + buy_fees: Decimal = Decimal("0") + sell_fees: Decimal = Decimal("0") + net_profit: Decimal = Decimal("0") @dataclass(frozen=True) diff --git a/src/grid_trading/domain/open_grid_lots.py b/src/grid_trading/domain/open_grid_lots.py index 1429bda..64e6ef8 100644 --- a/src/grid_trading/domain/open_grid_lots.py +++ b/src/grid_trading/domain/open_grid_lots.py @@ -1,21 +1,35 @@ from __future__ import annotations -from dataclasses import dataclass, replace +from dataclasses import dataclass from datetime import date from decimal import Decimal from grid_trading.domain.calculations import money, price -from grid_trading.domain.models import GridTradeMatch, OpenGridLot, Trade, TradeGroup, TradeSide +from grid_trading.domain.models import ( + GridDirection, + GridTradeMatch, + OpenGridLot, + Trade, + TradeGroup, + TradeSide, +) @dataclass -class _OpenBuyLot: - trade_id: int | None - buy_date: date - buy_price: Decimal +class _OpenLeg: + trade: Trade remaining_quantity: int +def effective_grid_direction(trade: Trade) -> GridDirection | None: + """Treat legacy GRID-group trades as forward-grid trades.""" + if trade.grid_direction is not None: + return trade.grid_direction + if trade.trade_group is TradeGroup.GRID: + return GridDirection.FORWARD + return None + + def calculate_open_grid_lots( trades: list[Trade], *, @@ -26,31 +40,35 @@ def calculate_open_grid_lots( if spacing <= 0 or spacing >= 1: raise ValueError("网格间距必须大于 0 且小于 100%") + queues = _build_open_queues(trades, as_of=as_of) lots: list[OpenGridLot] = [] - for trade in sorted(trades, key=lambda item: (item.trade_date, item.id or 0)): - if trade.trade_date > as_of or trade.trade_group is not TradeGroup.GRID: - continue - if trade.side is TradeSide.BUY: - buy_price = price(trade.price) - suggested_sell_price = price(buy_price * (Decimal("1") + spacing)) + for direction, queue in queues.items(): + for leg in queue: + open_price = price(leg.trade.price) + target_price = ( + price(open_price * (Decimal("1") + spacing)) + if direction is GridDirection.FORWARD + else price(open_price / (Decimal("1") + spacing)) + ) + buy_price = open_price if direction is GridDirection.FORWARD else target_price + sell_price = target_price if direction is GridDirection.FORWARD else open_price lots.append( OpenGridLot( - buy_trade_id=trade.id, - buy_date=trade.trade_date, - buy_price=buy_price, - remaining_quantity=trade.quantity, - actual_investment=money(buy_price * Decimal(trade.quantity)), - suggested_sell_price=suggested_sell_price, + direction=direction, + open_trade_id=leg.trade.id, + open_date=leg.trade.trade_date, + open_price=open_price, + remaining_quantity=leg.remaining_quantity, + open_amount=money(open_price * Decimal(leg.remaining_quantity)), + target_price=target_price, estimated_gross_profit=money( - (suggested_sell_price - buy_price) * Decimal(trade.quantity) + (sell_price - buy_price) * Decimal(leg.remaining_quantity) ), current_price=current_price, - status=_status(current_price, suggested_sell_price), + status=_status(current_price, target_price, direction), ) ) - else: - lots = _match_sell_against_lots(lots, trade.quantity) - return lots + return sorted(lots, key=lambda item: (item.open_date, item.open_trade_id or 0)) def calculate_grid_trade_matches( @@ -58,74 +76,120 @@ def calculate_grid_trade_matches( *, as_of: date, ) -> list[GridTradeMatch]: - open_buys: list[_OpenBuyLot] = [] + queues: dict[GridDirection, list[_OpenLeg]] = { + GridDirection.FORWARD: [], + GridDirection.REVERSE: [], + } matches: list[GridTradeMatch] = [] - for trade in sorted(trades, key=lambda item: (item.trade_date, item.id or 0)): - if trade.trade_date > as_of or trade.trade_group is not TradeGroup.GRID: + for trade in sorted(trades, key=_trade_sort_key): + if trade.trade_date > as_of: continue - if trade.side is TradeSide.BUY: - open_buys.append( - _OpenBuyLot( - trade_id=trade.id, - buy_date=trade.trade_date, - buy_price=price(trade.price), - remaining_quantity=trade.quantity, - ) - ) + direction = effective_grid_direction(trade) + if direction is None: continue - sell_price = price(trade.price) - remaining_sell_quantity = trade.quantity - while remaining_sell_quantity > 0 and open_buys: - buy_lot = open_buys[0] - matched_quantity = min(buy_lot.remaining_quantity, remaining_sell_quantity) + if trade.side is _open_side(direction): + queues[direction].append(_OpenLeg(trade=trade, remaining_quantity=trade.quantity)) + continue + + remaining_close_quantity = trade.quantity + queue = queues[direction] + while remaining_close_quantity > 0 and queue: + open_leg = queue[0] + matched_quantity = min(open_leg.remaining_quantity, remaining_close_quantity) + if direction is GridDirection.FORWARD: + buy_trade = open_leg.trade + sell_trade = trade + else: + buy_trade = trade + sell_trade = open_leg.trade + buy_amount = money(buy_trade.price * Decimal(matched_quantity)) + sell_amount = money(sell_trade.price * Decimal(matched_quantity)) + buy_fees = _allocated_fees(buy_trade, matched_quantity) + sell_fees = _allocated_fees(sell_trade, matched_quantity) + gross_profit = money(sell_amount - buy_amount) matches.append( GridTradeMatch( - sell_trade_id=trade.id, - sell_date=trade.trade_date, - sell_price=sell_price, - buy_trade_id=buy_lot.trade_id, - buy_date=buy_lot.buy_date, - buy_price=buy_lot.buy_price, + sell_trade_id=sell_trade.id, + sell_date=sell_trade.trade_date, + sell_price=price(sell_trade.price), + buy_trade_id=buy_trade.id, + buy_date=buy_trade.trade_date, + buy_price=price(buy_trade.price), matched_quantity=matched_quantity, - buy_amount=money(buy_lot.buy_price * Decimal(matched_quantity)), - sell_amount=money(sell_price * Decimal(matched_quantity)), - gross_profit=money((sell_price - buy_lot.buy_price) * Decimal(matched_quantity)), + buy_amount=buy_amount, + sell_amount=sell_amount, + gross_profit=gross_profit, + direction=direction, + buy_fees=buy_fees, + sell_fees=sell_fees, + net_profit=money(gross_profit - buy_fees - sell_fees), ) ) - buy_lot.remaining_quantity -= matched_quantity - remaining_sell_quantity -= matched_quantity - if buy_lot.remaining_quantity == 0: - open_buys.pop(0) + open_leg.remaining_quantity -= matched_quantity + remaining_close_quantity -= matched_quantity + if open_leg.remaining_quantity == 0: + queue.pop(0) return matches -def _match_sell_against_lots(lots: list[OpenGridLot], quantity: int) -> list[OpenGridLot]: - remaining_sell_quantity = quantity - updated_lots: list[OpenGridLot] = [] - for lot in lots: - if remaining_sell_quantity <= 0: - updated_lots.append(lot) - continue - matched_quantity = min(lot.remaining_quantity, remaining_sell_quantity) - remaining_sell_quantity -= matched_quantity - remaining_quantity = lot.remaining_quantity - matched_quantity - if remaining_quantity > 0: - updated_lots.append(_with_remaining_quantity(lot, remaining_quantity)) - return updated_lots - - -def _with_remaining_quantity(lot: OpenGridLot, quantity: int) -> OpenGridLot: - return replace( - lot, - remaining_quantity=quantity, - actual_investment=money(lot.buy_price * Decimal(quantity)), - estimated_gross_profit=money((lot.suggested_sell_price - lot.buy_price) * Decimal(quantity)), +def calculate_grid_profit(trades: list[Trade], *, as_of: date) -> Decimal: + return money( + sum( + (match.net_profit for match in calculate_grid_trade_matches(trades, as_of=as_of)), + Decimal("0"), + ) ) -def _status(current_price: Decimal | None, suggested_sell_price: Decimal) -> str: +def _build_open_queues( + trades: list[Trade], + *, + as_of: date, +) -> dict[GridDirection, list[_OpenLeg]]: + queues: dict[GridDirection, list[_OpenLeg]] = { + GridDirection.FORWARD: [], + GridDirection.REVERSE: [], + } + for trade in sorted(trades, key=_trade_sort_key): + if trade.trade_date > as_of: + continue + direction = effective_grid_direction(trade) + if direction is None: + continue + queue = queues[direction] + if trade.side is _open_side(direction): + queue.append(_OpenLeg(trade=trade, remaining_quantity=trade.quantity)) + continue + remaining_quantity = trade.quantity + while remaining_quantity > 0 and queue: + leg = queue[0] + matched_quantity = min(leg.remaining_quantity, remaining_quantity) + leg.remaining_quantity -= matched_quantity + remaining_quantity -= matched_quantity + if leg.remaining_quantity == 0: + queue.pop(0) + return queues + + +def _open_side(direction: GridDirection) -> TradeSide: + return TradeSide.BUY if direction is GridDirection.FORWARD else TradeSide.SELL + + +def _trade_sort_key(trade: Trade) -> tuple[date, int]: + return (trade.trade_date, trade.id if trade.id is not None else 2**63 - 1) + + +def _allocated_fees(trade: Trade, quantity: int) -> Decimal: + return money(trade.total_fee * Decimal(quantity) / Decimal(trade.quantity)) + + +def _status( + current_price: Decimal | None, + target_price: Decimal, + direction: GridDirection, +) -> str: if current_price is None: return "未刷新行情" - if current_price >= suggested_sell_price: - return "可卖" - return "未到价" + if direction is GridDirection.FORWARD: + return "可卖" if current_price >= target_price else "未到价" + return "可买回" if current_price <= target_price else "未到价" diff --git a/src/grid_trading/services/trading_service.py b/src/grid_trading/services/trading_service.py index a93460e..f4fa85e 100644 --- a/src/grid_trading/services/trading_service.py +++ b/src/grid_trading/services/trading_service.py @@ -1,9 +1,10 @@ from __future__ import annotations from collections import defaultdict -from datetime import date +from datetime import date, datetime from decimal import Decimal from pathlib import Path +from uuid import uuid4 from grid_trading.config import DEFAULT_FEE_CONFIG from grid_trading.domain.calculations import ( @@ -13,12 +14,20 @@ from grid_trading.domain.calculations import ( estimate_fees, ) from grid_trading.domain.grid_levels import generate_grid_levels +from grid_trading.domain.grid_alerts import evaluate_grid_alert from grid_trading.domain.models import ( Account, AccountSummary, FeeEstimate, FeeRules, + GridAlertSource, + GridAlertState, + GridAlertTarget, + GridDirection, GridLevelSuggestion, + GridMode, + GridMonitorItem, + GridMonitorSnapshot, GridTradeMatch, Instrument, OpenGridLot, @@ -97,6 +106,16 @@ class TradingService: def list_instruments(self) -> list[Instrument]: return self.repository.list_instruments() + def delete_instrument(self, instrument_id: int) -> None: + instrument = self._require_instrument(instrument_id) + if self.repository.list_trades(instrument_id=instrument_id): + raise ValueError( + f"{instrument.code} 已有成交记录,不能直接删除;" + "请先删除该标的的全部成交记录。" + ) + self.repository.delete_instrument(instrument_id) + self._quote_cache.pop(instrument.code, None) + def refresh_quotes(self) -> dict[str, QuoteSnapshot]: instruments = self.repository.list_instruments() quotes = self.fetch_quotes_for_instruments(instruments) @@ -112,6 +131,9 @@ class TradingService: def apply_quote_snapshots(self, quotes: dict[str, QuoteSnapshot]) -> None: self._quote_cache = quotes + def clear_quote_snapshots(self) -> None: + self._quote_cache = {} + def get_default_strategy_template(self) -> StrategyTemplate: self.ensure_defaults() template = self.repository.get_default_strategy_template() @@ -156,8 +178,6 @@ class TradingService: for existing in self.repository.list_trades(account_id=trade.account_id) if existing.id != trade.id ] - if trade.side is TradeSide.SELL: - self._validate_t_plus_one_available(trade, instrument, existing_trades) self._validate_resulting_position(trade, existing_trades) return self.repository.save_trade(trade) @@ -216,6 +236,7 @@ class TradingService: instrument_id: int, *, levels: int = 10, + mode: GridMode | None = None, ) -> list[GridLevelSuggestion]: instrument = self._require_instrument(instrument_id) position = next( @@ -229,14 +250,178 @@ class TradingService: if position is None or position.current_price is None: return [] template = self.get_default_strategy_template() - return generate_grid_levels( - current_price=position.current_price, - spacing=template.grid_spacing_pct, - amount_per_grid=template.amount_per_grid, - lot_size=instrument.lot_size, - levels=levels, + selected_mode = mode or template.grid_mode + directions = { + GridMode.FORWARD: [GridDirection.FORWARD], + GridMode.REVERSE: [GridDirection.REVERSE], + GridMode.BOTH: [GridDirection.FORWARD, GridDirection.REVERSE], + }[selected_mode] + suggestions: list[GridLevelSuggestion] = [] + for direction in directions: + suggestions.extend( + generate_grid_levels( + current_price=position.current_price, + spacing=template.grid_spacing_pct, + amount_per_grid=template.amount_per_grid, + lot_size=instrument.lot_size, + levels=levels, + direction=direction, + max_quantity=( + position.total_quantity + if direction is GridDirection.REVERSE + else None + ), + ) + ) + return sorted(suggestions, key=lambda item: (item.level, item.direction.value)) + + def add_grid_alert( + self, + instrument_id: int, + *, + side: TradeSide, + target_price: Decimal, + quantity: int, + ) -> GridAlertTarget: + self._require_instrument(instrument_id) + if target_price <= 0: + raise ValueError("监控价格必须大于 0") + if quantity <= 0: + raise ValueError("监控数量必须大于 0") + if side is TradeSide.SELL: + position = next( + ( + item + for item in self.get_position_summaries() + if item.instrument_id == instrument_id + ), + None, + ) + held_quantity = position.total_quantity if position is not None else 0 + if quantity > held_quantity: + raise ValueError( + f"持仓数量不足:当前持仓 {held_quantity},监控卖出 {quantity}" + ) + for existing in self.repository.list_grid_alert_targets(): + if ( + existing.instrument_id == instrument_id + and existing.side is side + and existing.source is GridAlertSource.MANUAL + and existing.target_price == target_price + and existing.quantity == quantity + ): + return existing + return self.repository.save_grid_alert_target( + GridAlertTarget( + id=None, + target_key=f"manual:{uuid4().hex}", + instrument_id=instrument_id, + side=side, + target_price=target_price, + quantity=quantity, + source=GridAlertSource.MANUAL, + ) ) + def add_buy_grid_alert( + self, + instrument_id: int, + *, + target_price: Decimal, + quantity: int, + ) -> GridAlertTarget: + return self.add_grid_alert( + instrument_id, + side=TradeSide.BUY, + target_price=target_price, + quantity=quantity, + ) + + def remove_grid_alert(self, target_key: str) -> None: + target = self.repository.get_grid_alert_target(target_key) + if target is None: + return + if target.source is not GridAlertSource.MANUAL: + raise ValueError("未完成网格由成交记录自动维护,不能手工删除") + self.repository.delete_grid_alert_target(target_key) + + def evaluate_grid_alerts( + self, + *, + near_threshold: Decimal = Decimal("0.005"), + ) -> GridMonitorSnapshot: + self._synchronize_open_grid_alerts() + now = datetime.now() + instruments = { + instrument.id: instrument + for instrument in self.repository.list_instruments() + if instrument.id is not None + } + items: list[GridMonitorItem] = [] + newly_reached: list[GridMonitorItem] = [] + for target in self.repository.list_grid_alert_targets(): + instrument = instruments.get(target.instrument_id) + if instrument is None: + continue + quote = self._quote_cache.get(instrument.code) + current_price = quote.price if quote is not None else None + evaluation = evaluate_grid_alert( + side=target.side, + current_price=current_price, + target_price=target.target_price, + near_threshold=near_threshold, + ) + item = GridMonitorItem( + target_key=target.target_key, + instrument_id=target.instrument_id, + code=instrument.code, + name=instrument.name, + side=target.side, + target_price=target.target_price, + quantity=target.quantity, + current_price=current_price, + state=evaluation.state, + distance_pct=evaluation.distance_pct, + source=target.source, + ) + items.append(item) + + alerted = target.alerted + last_alerted_at = target.last_alerted_at + if evaluation.state is GridAlertState.REACHED and not alerted: + newly_reached.append(item) + alerted = True + last_alerted_at = now + elif evaluation.state is GridAlertState.WAITING: + alerted = False + + if ( + evaluation.state is not target.last_state + or alerted != target.alerted + or last_alerted_at != target.last_alerted_at + ): + self.repository.update_grid_alert_state( + target.target_key, + state=evaluation.state, + alerted=alerted, + last_alerted_at=last_alerted_at, + ) + + priority = { + GridAlertState.REACHED: 0, + GridAlertState.NEAR: 1, + GridAlertState.WAITING: 2, + GridAlertState.UNAVAILABLE: 3, + } + items.sort(key=lambda item: (priority[item.state], item.code, item.side.value, item.target_price)) + return GridMonitorSnapshot(items=items, newly_reached=newly_reached, evaluated_at=now) + + def get_setting(self, key: str, default: str | None = None) -> str | None: + return self.repository.get_setting(key, default) + + def set_setting(self, key: str, value: str) -> None: + self.repository.set_setting(key, value) + def get_open_grid_lots( self, instrument_id: int, @@ -275,6 +460,47 @@ class TradingService: trades = self.repository.list_trades(account_id=account.id, instrument_id=instrument_id) return calculate_grid_trade_matches(trades, as_of=as_of_date) + def _synchronize_open_grid_alerts(self) -> None: + retained_keys: set[str] = set() + existing_targets = { + target.target_key: target + for target in self.repository.list_grid_alert_targets() + if target.source is GridAlertSource.OPEN_GRID_LOT + } + for instrument in self.repository.list_instruments(): + if instrument.id is None: + continue + for lot in self.get_open_grid_lots(instrument.id): + if lot.open_trade_id is None: + continue + target_key = f"close:{lot.direction.value}:trade:{lot.open_trade_id}" + retained_keys.add(target_key) + existing = existing_targets.get(target_key) + if ( + existing is not None + and existing.instrument_id == instrument.id + and existing.side is lot.close_side + and existing.target_price == lot.target_price + and existing.quantity == lot.remaining_quantity + ): + continue + self.repository.save_grid_alert_target( + GridAlertTarget( + id=None, + target_key=target_key, + instrument_id=instrument.id, + side=lot.close_side, + target_price=lot.target_price, + quantity=lot.remaining_quantity, + source=GridAlertSource.OPEN_GRID_LOT, + ) + ) + if set(existing_targets) != retained_keys: + self.repository.delete_grid_alert_targets_by_source_except( + GridAlertSource.OPEN_GRID_LOT, + retained_keys, + ) + def _require_account(self, account_id: int) -> Account: account = self.repository.get_account(account_id) if account is None: @@ -297,22 +523,6 @@ class TradingService: if trade.total_fee < 0: raise ValueError("成交费用不能为负数") - def _validate_t_plus_one_available( - self, - trade: Trade, - instrument: Instrument, - existing_trades: list[Trade], - ) -> None: - [position] = calculate_positions( - [instrument], - [item for item in existing_trades if item.instrument_id == instrument.id], - as_of=trade.trade_date, - ) - if trade.quantity > position.available_quantity: - raise ValueError( - f"T+1 可卖数量不足:可卖 {position.available_quantity},尝试卖出 {trade.quantity}" - ) - def _validate_resulting_position(self, trade: Trade, existing_trades: list[Trade]) -> None: self._validate_trade_chain([*existing_trades, trade]) diff --git a/src/grid_trading/storage/database.py b/src/grid_trading/storage/database.py index 7700370..a4ed1b2 100644 --- a/src/grid_trading/storage/database.py +++ b/src/grid_trading/storage/database.py @@ -39,6 +39,7 @@ CREATE TABLE IF NOT EXISTS strategy_templates ( max_position_amount TEXT NOT NULL, min_lot INTEGER NOT NULL DEFAULT 100, is_default INTEGER NOT NULL DEFAULT 0, + grid_mode TEXT NOT NULL DEFAULT 'forward', created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP ); @@ -52,6 +53,7 @@ CREATE TABLE IF NOT EXISTS instrument_strategy_overrides ( base_target_amount TEXT, max_position_amount TEXT, min_lot INTEGER, + grid_mode TEXT, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP ); @@ -67,6 +69,7 @@ CREATE TABLE IF NOT EXISTS trades ( stamp_tax TEXT NOT NULL DEFAULT '0', transfer_fee TEXT NOT NULL DEFAULT '0', trade_group TEXT NOT NULL, + grid_direction TEXT, notes TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP @@ -87,6 +90,25 @@ CREATE TABLE IF NOT EXISTS app_settings ( key TEXT PRIMARY KEY, value TEXT NOT NULL ); + +CREATE TABLE IF NOT EXISTS grid_alert_targets ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + target_key TEXT NOT NULL UNIQUE, + instrument_id INTEGER NOT NULL REFERENCES instruments(id) ON DELETE CASCADE, + side TEXT NOT NULL, + target_price TEXT NOT NULL, + quantity INTEGER NOT NULL, + source TEXT NOT NULL, + enabled INTEGER NOT NULL DEFAULT 1, + last_state TEXT NOT NULL DEFAULT 'unavailable', + alerted INTEGER NOT NULL DEFAULT 0, + last_alerted_at TEXT, + created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP +); + +CREATE INDEX IF NOT EXISTS idx_grid_alert_targets_instrument +ON grid_alert_targets (instrument_id, enabled); """ @@ -101,4 +123,30 @@ def connect_database(db_path: str | Path) -> sqlite3.Connection: def initialize_database(connection: sqlite3.Connection) -> None: connection.executescript(SCHEMA) + _ensure_column( + connection, + "strategy_templates", + "grid_mode", + "TEXT NOT NULL DEFAULT 'forward'", + ) + _ensure_column(connection, "trades", "grid_direction", "TEXT") + _ensure_column(connection, "instrument_strategy_overrides", "grid_mode", "TEXT") + connection.execute( + """ + UPDATE trades + SET grid_direction = 'forward' + WHERE grid_direction IS NULL AND trade_group = 'grid' + """ + ) connection.commit() + + +def _ensure_column( + connection: sqlite3.Connection, + table: str, + column: str, + declaration: str, +) -> None: + columns = {row["name"] for row in connection.execute(f"PRAGMA table_info({table})")} + if column not in columns: + connection.execute(f"ALTER TABLE {table} ADD COLUMN {column} {declaration}") diff --git a/src/grid_trading/storage/repositories.py b/src/grid_trading/storage/repositories.py index 8fd9cce..e504bdc 100644 --- a/src/grid_trading/storage/repositories.py +++ b/src/grid_trading/storage/repositories.py @@ -1,14 +1,19 @@ from __future__ import annotations import sqlite3 -from datetime import date +from dataclasses import replace +from datetime import date, datetime from decimal import Decimal from pathlib import Path -from typing import Sequence from grid_trading.domain.models import ( Account, CashLedgerEntry, + GridAlertSource, + GridAlertState, + GridAlertTarget, + GridDirection, + GridMode, Instrument, StrategyOverride, StrategyTemplate, @@ -127,6 +132,10 @@ class Repository: ).fetchone() return _row_to_instrument(row) if row else None + def delete_instrument(self, instrument_id: int) -> None: + self.connection.execute("DELETE FROM instruments WHERE id = ?", (instrument_id,)) + self.connection.commit() + def save_strategy_template(self, template: StrategyTemplate) -> StrategyTemplate: if template.is_default: self.connection.execute("UPDATE strategy_templates SET is_default = 0") @@ -138,14 +147,15 @@ class Repository: _decimal_to_text(template.max_position_amount), template.min_lot, int(template.is_default), + template.grid_mode.value, ) if template.id is None: cursor = self.connection.execute( """ INSERT INTO strategy_templates (name, grid_spacing_pct, amount_per_grid, base_target_amount, - max_position_amount, min_lot, is_default) - VALUES (?, ?, ?, ?, ?, ?, ?) + max_position_amount, min_lot, is_default, grid_mode) + VALUES (?, ?, ?, ?, ?, ?, ?, ?) """, values, ) @@ -159,13 +169,14 @@ class Repository: max_position_amount=template.max_position_amount, min_lot=template.min_lot, is_default=template.is_default, + grid_mode=template.grid_mode, ) self.connection.execute( """ UPDATE strategy_templates SET name = ?, grid_spacing_pct = ?, amount_per_grid = ?, base_target_amount = ?, max_position_amount = ?, min_lot = ?, - is_default = ?, updated_at = CURRENT_TIMESTAMP + is_default = ?, grid_mode = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? """, (*values, template.id), @@ -188,8 +199,8 @@ class Repository: """ INSERT INTO instrument_strategy_overrides (instrument_id, template_id, grid_spacing_pct, amount_per_grid, - base_target_amount, max_position_amount, min_lot) - VALUES (?, ?, ?, ?, ?, ?, ?) + base_target_amount, max_position_amount, min_lot, grid_mode) + VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(instrument_id) DO UPDATE SET template_id = excluded.template_id, grid_spacing_pct = excluded.grid_spacing_pct, @@ -197,6 +208,7 @@ class Repository: base_target_amount = excluded.base_target_amount, max_position_amount = excluded.max_position_amount, min_lot = excluded.min_lot, + grid_mode = excluded.grid_mode, updated_at = CURRENT_TIMESTAMP """, ( @@ -207,6 +219,7 @@ class Repository: _optional_decimal_to_text(override.base_target_amount), _optional_decimal_to_text(override.max_position_amount), override.min_lot, + override.grid_mode.value if override.grid_mode is not None else None, ), ) self.connection.commit() @@ -220,6 +233,8 @@ class Repository: return _row_to_strategy_override(row) if row else None def save_trade(self, trade: Trade) -> Trade: + if trade.grid_direction is None and trade.trade_group is TradeGroup.GRID: + trade = replace(trade, grid_direction=GridDirection.FORWARD) values = ( trade.account_id, trade.instrument_id, @@ -231,6 +246,7 @@ class Repository: _decimal_to_text(trade.stamp_tax), _decimal_to_text(trade.transfer_fee), trade.trade_group.value, + trade.grid_direction.value if trade.grid_direction is not None else None, trade.notes, ) if trade.id is None: @@ -238,8 +254,8 @@ class Repository: """ INSERT INTO trades (account_id, instrument_id, trade_date, side, price, quantity, - commission, stamp_tax, transfer_fee, trade_group, notes) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + commission, stamp_tax, transfer_fee, trade_group, grid_direction, notes) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, values, ) @@ -257,13 +273,14 @@ class Repository: transfer_fee=trade.transfer_fee, trade_group=trade.trade_group, notes=trade.notes, + grid_direction=trade.grid_direction, ) self.connection.execute( """ UPDATE trades SET account_id = ?, instrument_id = ?, trade_date = ?, side = ?, price = ?, quantity = ?, commission = ?, stamp_tax = ?, transfer_fee = ?, - trade_group = ?, notes = ?, updated_at = CURRENT_TIMESTAMP + trade_group = ?, grid_direction = ?, notes = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? """, (*values, trade.id), @@ -341,6 +358,105 @@ class Repository: ).fetchall() return [_row_to_cash_entry(row) for row in rows] + def save_grid_alert_target(self, target: GridAlertTarget) -> GridAlertTarget: + self.connection.execute( + """ + INSERT INTO grid_alert_targets + (target_key, instrument_id, side, target_price, quantity, source, + enabled, last_state, alerted, last_alerted_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + ON CONFLICT(target_key) DO UPDATE SET + instrument_id = excluded.instrument_id, + side = excluded.side, + target_price = excluded.target_price, + quantity = excluded.quantity, + source = excluded.source, + enabled = excluded.enabled, + updated_at = CURRENT_TIMESTAMP + """, + ( + target.target_key, + target.instrument_id, + target.side.value, + _decimal_to_text(target.target_price), + target.quantity, + target.source.value, + int(target.enabled), + target.last_state.value, + int(target.alerted), + target.last_alerted_at.isoformat() if target.last_alerted_at else None, + ), + ) + self.connection.commit() + saved = self.get_grid_alert_target(target.target_key) + if saved is None: + raise RuntimeError("监控目标保存失败") + return saved + + def get_grid_alert_target(self, target_key: str) -> GridAlertTarget | None: + row = self.connection.execute( + "SELECT * FROM grid_alert_targets WHERE target_key = ?", + (target_key,), + ).fetchone() + return _row_to_grid_alert_target(row) if row else None + + def list_grid_alert_targets(self, *, enabled_only: bool = True) -> list[GridAlertTarget]: + where = "WHERE enabled = 1" if enabled_only else "" + rows = self.connection.execute( + f"SELECT * FROM grid_alert_targets {where} ORDER BY instrument_id, side, target_price" + ).fetchall() + return [_row_to_grid_alert_target(row) for row in rows] + + def update_grid_alert_state( + self, + target_key: str, + *, + state: GridAlertState, + alerted: bool, + last_alerted_at: datetime | None, + ) -> None: + self.connection.execute( + """ + UPDATE grid_alert_targets + SET last_state = ?, alerted = ?, last_alerted_at = ?, + updated_at = CURRENT_TIMESTAMP + WHERE target_key = ? + """, + ( + state.value, + int(alerted), + last_alerted_at.isoformat() if last_alerted_at else None, + target_key, + ), + ) + self.connection.commit() + + def delete_grid_alert_target(self, target_key: str) -> None: + self.connection.execute( + "DELETE FROM grid_alert_targets WHERE target_key = ?", + (target_key,), + ) + self.connection.commit() + + def delete_grid_alert_targets_by_source_except( + self, + source: GridAlertSource, + retained_keys: set[str], + ) -> None: + if not retained_keys: + self.connection.execute( + "DELETE FROM grid_alert_targets WHERE source = ?", + (source.value,), + ) + else: + placeholders = ", ".join("?" for _ in retained_keys) + self.connection.execute( + f"DELETE FROM grid_alert_targets WHERE source = ? " + f"AND target_key NOT IN ({placeholders})", + (source.value, *sorted(retained_keys)), + ) + self.connection.commit() + def set_setting(self, key: str, value: str) -> None: self.connection.execute( """ @@ -400,6 +516,7 @@ def _row_to_strategy_template(row: sqlite3.Row) -> StrategyTemplate: max_position_amount=Decimal(row["max_position_amount"]), min_lot=row["min_lot"], is_default=bool(row["is_default"]), + grid_mode=GridMode(row["grid_mode"]), ) @@ -412,6 +529,7 @@ def _row_to_strategy_override(row: sqlite3.Row) -> StrategyOverride: base_target_amount=_text_to_decimal(row["base_target_amount"]), max_position_amount=_text_to_decimal(row["max_position_amount"]), min_lot=row["min_lot"], + grid_mode=GridMode(row["grid_mode"]) if row["grid_mode"] is not None else None, ) @@ -429,6 +547,11 @@ def _row_to_trade(row: sqlite3.Row) -> Trade: transfer_fee=Decimal(row["transfer_fee"]), trade_group=TradeGroup(row["trade_group"]), notes=row["notes"], + grid_direction=( + GridDirection(row["grid_direction"]) + if row["grid_direction"] is not None + else None + ), ) @@ -442,3 +565,23 @@ def _row_to_cash_entry(row: sqlite3.Row) -> CashLedgerEntry: category=row["category"], notes=row["notes"], ) + + +def _row_to_grid_alert_target(row: sqlite3.Row) -> GridAlertTarget: + return GridAlertTarget( + id=row["id"], + target_key=row["target_key"], + instrument_id=row["instrument_id"], + side=TradeSide(row["side"]), + target_price=Decimal(row["target_price"]), + quantity=row["quantity"], + source=GridAlertSource(row["source"]), + enabled=bool(row["enabled"]), + last_state=GridAlertState(row["last_state"]), + alerted=bool(row["alerted"]), + last_alerted_at=( + datetime.fromisoformat(row["last_alerted_at"]) + if row["last_alerted_at"] + else None + ), + ) diff --git a/src/grid_trading/ui/dialogs.py b/src/grid_trading/ui/dialogs.py index eda49e4..b3c70e2 100644 --- a/src/grid_trading/ui/dialogs.py +++ b/src/grid_trading/ui/dialogs.py @@ -24,6 +24,8 @@ from PySide6.QtWidgets import ( from grid_trading.domain.models import ( Account, + GridDirection, + GridMode, Instrument, StrategyTemplate, Trade, @@ -121,7 +123,13 @@ class StrategyTemplateDialog(QDialog): self.name_edit = QLineEdit(template.name) self.grid_spacing_edit = _percent_spinbox(template.grid_spacing_pct) self.amount_per_grid_edit = _money_spinbox(template.amount_per_grid) - self.base_target_edit = _money_spinbox(template.base_target_amount) + self.grid_mode_edit = QComboBox() + self.grid_mode_edit.addItem("正向(先买后卖)", GridMode.FORWARD.value) + self.grid_mode_edit.addItem("反向(先卖后买)", GridMode.REVERSE.value) + self.grid_mode_edit.addItem("双向", GridMode.BOTH.value) + self.grid_mode_edit.setCurrentIndex( + self.grid_mode_edit.findData(template.grid_mode.value) + ) self.max_position_edit = _money_spinbox(template.max_position_amount) self.min_lot_edit = QSpinBox() self.min_lot_edit.setRange(1, 1_000_000) @@ -131,7 +139,7 @@ class StrategyTemplateDialog(QDialog): form.addRow("模板名称", self.name_edit) form.addRow("网格间距", self.grid_spacing_edit) form.addRow("每格金额", self.amount_per_grid_edit) - form.addRow("底仓目标金额", self.base_target_edit) + form.addRow("网格模式", self.grid_mode_edit) form.addRow("最大投入金额", self.max_position_edit) form.addRow("最小交易单位", self.min_lot_edit) @@ -149,10 +157,11 @@ class StrategyTemplateDialog(QDialog): name=self.name_edit.text().strip(), grid_spacing_pct=Decimal(str(self.grid_spacing_edit.value())) / Decimal("100"), amount_per_grid=Decimal(str(self.amount_per_grid_edit.value())), - base_target_amount=Decimal(str(self.base_target_edit.value())), + base_target_amount=self._template.base_target_amount, max_position_amount=Decimal(str(self.max_position_edit.value())), min_lot=self.min_lot_edit.value(), is_default=True, + grid_mode=GridMode(self.grid_mode_edit.currentData()), ) @@ -191,12 +200,21 @@ class TradeDialog(QDialog): if trade: self.side_edit.setCurrentIndex(self.side_edit.findData(trade.side.value)) - self.group_edit = QComboBox() - self.group_edit.addItem("底仓", TradeGroup.BASE.value) - self.group_edit.addItem("网格", TradeGroup.GRID.value) - self.group_edit.addItem("其他", TradeGroup.OTHER.value) + self.grid_direction_edit = QComboBox() + self.grid_direction_edit.addItem("普通成交(不参与网格配对)", None) + self.grid_direction_edit.addItem("正向(先买后卖)", GridDirection.FORWARD.value) + self.grid_direction_edit.addItem("反向(先卖后买)", GridDirection.REVERSE.value) if trade: - self.group_edit.setCurrentIndex(self.group_edit.findData(trade.trade_group.value)) + direction = trade.grid_direction + if direction is None and trade.trade_group is TradeGroup.GRID: + direction = GridDirection.FORWARD + self.grid_direction_edit.setCurrentIndex( + self.grid_direction_edit.findData(direction.value if direction else None) + ) + else: + self.grid_direction_edit.setCurrentIndex( + self.grid_direction_edit.findData(None) + ) self.price_edit = _money_spinbox(trade.price if trade else Decimal("0")) self.quantity_edit = QSpinBox() @@ -223,7 +241,7 @@ class TradeDialog(QDialog): form.addRow("标的", self.instrument_edit) form.addRow("日期", self.date_edit) form.addRow("方向", self.side_edit) - form.addRow("分组", self.group_edit) + form.addRow("交易类型", self.grid_direction_edit) form.addRow("成交价", self.price_edit) form.addRow("数量", self.quantity_edit) form.addRow(fee_row) @@ -250,8 +268,13 @@ class TradeDialog(QDialog): commission=Decimal(str(self.commission_edit.value())), stamp_tax=Decimal(str(self.stamp_tax_edit.value())), transfer_fee=Decimal(str(self.transfer_fee_edit.value())), - trade_group=TradeGroup(self.group_edit.currentData()), + trade_group=self._trade.trade_group if self._trade else TradeGroup.OTHER, notes=self.notes_edit.text().strip(), + grid_direction=( + GridDirection(self.grid_direction_edit.currentData()) + if self.grid_direction_edit.currentData() is not None + else None + ), ) def accept(self) -> None: diff --git a/src/grid_trading/ui/floating_monitor.py b/src/grid_trading/ui/floating_monitor.py new file mode 100644 index 0000000..391cf72 --- /dev/null +++ b/src/grid_trading/ui/floating_monitor.py @@ -0,0 +1,287 @@ +from __future__ import annotations + +from PySide6.QtCore import Qt, Signal +from PySide6.QtGui import QColor, QMouseEvent +from PySide6.QtWidgets import ( + QAbstractItemView, + QCheckBox, + QFrame, + QHBoxLayout, + QHeaderView, + QLabel, + QPushButton, + QTableWidget, + QTableWidgetItem, + QVBoxLayout, + QWidget, +) + +from grid_trading.domain.models import ( + GridAlertSource, + GridAlertState, + GridMonitorItem, + GridMonitorSnapshot, + TradeSide, +) +from grid_trading.ui.formatters import format_percent, format_price, format_quantity + + +class _DragHandle(QFrame): + def __init__(self, parent=None): + super().__init__(parent) + self._drag_offset = None + + def mousePressEvent(self, event: QMouseEvent) -> None: + if event.button() == Qt.MouseButton.LeftButton: + self._drag_offset = event.globalPosition().toPoint() - self.window().frameGeometry().topLeft() + event.accept() + + def mouseMoveEvent(self, event: QMouseEvent) -> None: + if self._drag_offset is not None and event.buttons() & Qt.MouseButton.LeftButton: + self.window().move(event.globalPosition().toPoint() - self._drag_offset) + event.accept() + + def mouseReleaseEvent(self, event: QMouseEvent) -> None: + self._drag_offset = None + super().mouseReleaseEvent(event) + + +class FloatingMonitorWindow(QWidget): + refresh_requested = Signal() + open_main_requested = Signal(object) + remove_target_requested = Signal(str) + hidden = Signal() + + COLUMNS = ["标的", "方向", "现价", "目标价", "数量", "状态"] + + def __init__(self): + super().__init__(None) + self._items: list[GridMonitorItem] = [] + self._allow_close = False + self.setWindowTitle("网格监控") + self.setWindowFlags( + Qt.WindowType.Tool + | Qt.WindowType.FramelessWindowHint + | Qt.WindowType.WindowStaysOnTopHint + ) + self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground) + self.setWindowOpacity(0.97) + self.resize(600, 280) + self._build_ui() + + @property + def muted(self) -> bool: + return self.mute_button.isChecked() + + @muted.setter + def muted(self, value: bool) -> None: + self.mute_button.setChecked(value) + self._update_mute_text() + + @property + def reached_only(self) -> bool: + return self.reached_only_checkbox.isChecked() + + @reached_only.setter + def reached_only(self, value: bool) -> None: + self.reached_only_checkbox.setChecked(value) + + def set_connection_status(self, text: str, *, ok: bool) -> None: + color = "#15803d" if ok else "#b45309" + self.connection_label.setText(text) + self.connection_label.setStyleSheet(f"color: {color}; font-weight: 700;") + + def update_snapshot(self, snapshot: GridMonitorSnapshot) -> None: + self._items = snapshot.items + self.updated_label.setText(snapshot.evaluated_at.strftime("更新 %H:%M:%S")) + self._render_items() + + def show_and_raise(self) -> None: + self.show() + self.raise_() + self.activateWindow() + + def close_permanently(self) -> None: + self._allow_close = True + self.close() + + def closeEvent(self, event) -> None: + if self._allow_close: + event.accept() + return + event.ignore() + self.hide() + + def hideEvent(self, event) -> None: + self.hidden.emit() + super().hideEvent(event) + + def _build_ui(self) -> None: + container = QFrame(self) + container.setObjectName("monitorContainer") + outer = QVBoxLayout(self) + outer.setContentsMargins(6, 6, 6, 6) + outer.addWidget(container) + + layout = QVBoxLayout(container) + layout.setContentsMargins(10, 8, 10, 8) + layout.setSpacing(7) + + header = _DragHandle() + header_layout = QHBoxLayout(header) + header_layout.setContentsMargins(0, 0, 0, 0) + title = QLabel("网格监控") + title.setObjectName("monitorTitle") + self.connection_label = QLabel("等待行情") + self.updated_label = QLabel("尚未更新") + self.updated_label.setObjectName("monitorSubtle") + open_button = QPushButton("主界面") + open_button.clicked.connect(lambda: self.open_main_requested.emit(None)) + close_button = QPushButton("隐藏") + close_button.clicked.connect(self.hide) + header_layout.addWidget(title) + header_layout.addWidget(self.connection_label) + header_layout.addStretch() + header_layout.addWidget(self.updated_label) + header_layout.addWidget(open_button) + header_layout.addWidget(close_button) + layout.addWidget(header) + + self.table = QTableWidget(0, len(self.COLUMNS)) + self.table.setHorizontalHeaderLabels(self.COLUMNS) + self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers) + self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows) + self.table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection) + self.table.setAlternatingRowColors(True) + self.table.verticalHeader().setVisible(False) + self.table.verticalHeader().setDefaultSectionSize(28) + self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents) + self.table.horizontalHeader().setStretchLastSection(True) + self.table.itemSelectionChanged.connect(self._update_remove_button) + self.table.cellDoubleClicked.connect(self._open_selected_instrument) + layout.addWidget(self.table) + + controls = QHBoxLayout() + self.reached_only_checkbox = QCheckBox("仅看已到价") + self.reached_only_checkbox.toggled.connect(self._render_items) + self.mute_button = QPushButton("声音:开") + self.mute_button.setCheckable(True) + self.mute_button.toggled.connect(self._update_mute_text) + self.remove_button = QPushButton("删除开仓监控") + self.remove_button.setEnabled(False) + self.remove_button.clicked.connect(self._remove_selected_target) + refresh_button = QPushButton("立即刷新") + refresh_button.clicked.connect(self.refresh_requested.emit) + controls.addWidget(self.reached_only_checkbox) + controls.addWidget(self.mute_button) + controls.addWidget(self.remove_button) + controls.addStretch() + controls.addWidget(refresh_button) + layout.addLayout(controls) + + self.setStyleSheet( + """ + QFrame#monitorContainer { + background: #f8fafc; + border: 1px solid #94a3b8; + border-radius: 10px; + } + QLabel#monitorTitle { + color: #0f172a; + font-size: 14px; + font-weight: 800; + } + QLabel#monitorSubtle { color: #64748b; } + QTableWidget { + background: #ffffff; + alternate-background-color: #f8fafc; + border: 1px solid #cbd5e1; + border-radius: 7px; + color: #334155; + gridline-color: #e2e8f0; + selection-background-color: #dbeafe; + selection-color: #0f172a; + } + QHeaderView::section { + background: #e2e8f0; + border: 0; + border-right: 1px solid #cbd5e1; + color: #334155; + font-weight: 700; + padding: 4px; + } + QPushButton { + background: #e2e8f0; + border: 1px solid #cbd5e1; + border-radius: 5px; + color: #334155; + min-height: 24px; + padding: 1px 7px; + } + QPushButton:hover { background: #dbeafe; } + QPushButton:disabled { color: #94a3b8; } + QCheckBox { color: #475569; } + """ + ) + + def _render_items(self) -> None: + visible_items = [ + item + for item in self._items + if not self.reached_only or item.state is GridAlertState.REACHED + ] + self.table.setRowCount(len(visible_items)) + for row, item in enumerate(visible_items): + distance = format_percent(item.distance_pct) if item.distance_pct is not None else "-" + state_text = { + GridAlertState.UNAVAILABLE: "等待行情", + GridAlertState.WAITING: f"相差 {distance}", + GridAlertState.NEAR: f"接近 {distance}", + GridAlertState.REACHED: "已到价", + }[item.state] + values = [ + f"{item.code} {item.name}", + "买入" if item.side is TradeSide.BUY else "卖出", + format_price(item.current_price), + format_price(item.target_price), + format_quantity(item.quantity), + state_text, + ] + color = self._state_color(item) + for column, value in enumerate(values): + cell = QTableWidgetItem(value) + cell.setForeground(color) + cell.setData(Qt.ItemDataRole.UserRole, item.target_key) + cell.setData(Qt.ItemDataRole.UserRole + 1, item.source.value) + cell.setData(Qt.ItemDataRole.UserRole + 2, item.instrument_id) + self.table.setItem(row, column, cell) + self._update_remove_button() + + def _state_color(self, item: GridMonitorItem) -> QColor: + if item.state is GridAlertState.REACHED: + return QColor("#15803d" if item.side is TradeSide.BUY else "#c62828") + if item.state is GridAlertState.NEAR: + return QColor("#b45309") + if item.state is GridAlertState.UNAVAILABLE: + return QColor("#94a3b8") + return QColor("#334155") + + def _update_mute_text(self) -> None: + self.mute_button.setText("声音:关" if self.mute_button.isChecked() else "声音:开") + + def _update_remove_button(self) -> None: + row = self.table.currentRow() + cell = self.table.item(row, 0) if row >= 0 else None + source = cell.data(Qt.ItemDataRole.UserRole + 1) if cell else None + self.remove_button.setEnabled(source == GridAlertSource.MANUAL.value) + + def _remove_selected_target(self) -> None: + row = self.table.currentRow() + cell = self.table.item(row, 0) if row >= 0 else None + if cell is not None: + self.remove_target_requested.emit(cell.data(Qt.ItemDataRole.UserRole)) + + def _open_selected_instrument(self, row: int, _column: int) -> None: + cell = self.table.item(row, 0) + if cell is not None: + self.open_main_requested.emit(cell.data(Qt.ItemDataRole.UserRole + 2)) diff --git a/src/grid_trading/ui/main_window.py b/src/grid_trading/ui/main_window.py index 05fc67b..dfb841e 100644 --- a/src/grid_trading/ui/main_window.py +++ b/src/grid_trading/ui/main_window.py @@ -4,11 +4,12 @@ import sys from decimal import Decimal from pathlib import Path -from PySide6.QtCore import QObject, Qt, QThread, Signal -from PySide6.QtGui import QBrush, QColor, QFont +from PySide6.QtCore import Qt +from PySide6.QtGui import QAction, QBrush, QColor, QFont, QIcon from PySide6.QtWidgets import ( QAbstractItemView, QApplication, + QComboBox, QDialog, QFrame, QGridLayout, @@ -18,6 +19,7 @@ from PySide6.QtWidgets import ( QListWidget, QMainWindow, QMessageBox, + QMenu, QPushButton, QSplitter, QSpinBox, @@ -26,11 +28,16 @@ from PySide6.QtWidgets import ( QTableWidgetItem, QVBoxLayout, QWidget, + QSystemTrayIcon, ) -from grid_trading.config import DEFAULT_DB_PATH +from grid_trading.config import APP_ICON_PATH, DEFAULT_DB_PATH from grid_trading.domain.models import ( + GridDirection, GridLevelSuggestion, + GridMode, + GridMonitorItem, + GridMonitorSnapshot, GridTradeMatch, OpenGridLot, PositionSummary, @@ -39,25 +46,9 @@ from grid_trading.domain.models import ( ) from grid_trading.services.trading_service import TradingService from grid_trading.ui.dialogs import AccountDialog, InstrumentDialog, StrategyTemplateDialog, TradeDialog +from grid_trading.ui.floating_monitor import FloatingMonitorWindow from grid_trading.ui.formatters import format_money, format_percent, format_price, format_quantity - - -class QuoteRefreshWorker(QObject): - finished = Signal(object) - failed = Signal(str) - - def __init__(self, service: TradingService, instruments): - super().__init__() - self._service = service - self._instruments = instruments - - def run(self) -> None: - try: - quotes = self._service.fetch_quotes_for_instruments(self._instruments) - except Exception as exc: - self.failed.emit(str(exc)) - return - self.finished.emit(quotes) +from grid_trading.ui.quote_monitor import QuoteMonitorController class MainWindow(QMainWindow): @@ -71,8 +62,6 @@ class MainWindow(QMainWindow): "现价", "总持仓", "可用", - "底仓", - "网格仓", "持仓成本", "持仓回本价", "账户回本价", @@ -80,36 +69,45 @@ class MainWindow(QMainWindow): "网格利润", "浮动盈亏", ] - TRADE_COLUMNS = ["日期", "方向", "分组", "价格", "数量", "费用", "备注"] + TRADE_COLUMNS = ["代码", "名称", "日期", "方向", "交易类型", "价格", "数量", "费用", "备注"] GRID_LEVEL_COLUMNS = [ + "代码", + "名称", "档位", - "买入价", - "买入金额", - "建议买入股数", - "实际投入", - "卖出价", + "方向", + "开仓价", + "建议数量", + "开仓金额", + "目标平仓价", "预计单轮毛利润", ] OPEN_GRID_LOT_COLUMNS = [ - "买入日期", - "买入价", + "代码", + "名称", + "方向", + "开仓日期", + "开仓价", "剩余股数", - "实际投入", - "建议卖出价", + "开仓金额", + "目标平仓价", "预计毛利润", "当前价", "状态", ] GRID_MATCH_COLUMNS = [ + "代码", + "名称", + "方向", "卖出日期", "卖出价", - "匹配买入日期", + "买入日期", "买入价", "匹配股数", "买入金额", "卖出金额", + "双边费用", "毛利润", - "对应成交", + "净利润", ] def __init__(self, service: TradingService): @@ -119,13 +117,30 @@ class MainWindow(QMainWindow): self._positions: list[PositionSummary] = [] self._selected_instrument_id: int | None = None self._trade_ids_by_row: dict[int, int] = {} - self._quote_thread: QThread | None = None - self._quote_worker: QuoteRefreshWorker | None = None + self._grid_levels_by_row: dict[int, GridLevelSuggestion] = {} self.refresh_quotes_button: QPushButton | None = None + interval_value = self.service.get_setting("grid_monitor_interval_seconds", "10") or "10" + try: + interval_seconds = int(interval_value) + except ValueError: + interval_seconds = 10 + self.quote_monitor = QuoteMonitorController( + service, + interval_ms=interval_seconds * 1000, + parent=self, + ) + self.floating_monitor = FloatingMonitorWindow() + self._tray_icon: QSystemTrayIcon | None = None + self._monitor_started = False + self._close_pending = False + self._close_resources_finalized = False self.setWindowTitle("Grid Trading Manager") self.resize(1280, 780) self._build_ui() + self._connect_monitoring() + self._restore_monitor_settings() + self._create_tray_icon() self.refresh_all() def _build_ui(self) -> None: @@ -172,9 +187,23 @@ class MainWindow(QMainWindow): self.grid_levels_count_edit.setRange(1, 100) self.grid_levels_count_edit.setValue(10) self.grid_levels_count_edit.valueChanged.connect(lambda _value: self._refresh_details()) + self.grid_mode_edit = QComboBox() + self.grid_mode_edit.addItem("正向", GridMode.FORWARD.value) + self.grid_mode_edit.addItem("反向", GridMode.REVERSE.value) + self.grid_mode_edit.addItem("双向", GridMode.BOTH.value) + self.grid_mode_edit.setCurrentIndex( + self.grid_mode_edit.findData(self.service.get_default_strategy_template().grid_mode.value) + ) + self.grid_mode_edit.currentIndexChanged.connect(lambda _value: self._refresh_details()) self.grid_levels_hint = QLabel("请先刷新行情") + add_monitor_button = QPushButton("加入开仓监控") + add_monitor_button.setObjectName("toolbarButton") + add_monitor_button.clicked.connect(self._add_selected_grid_alert) grid_controls.addWidget(QLabel("档数")) grid_controls.addWidget(self.grid_levels_count_edit) + grid_controls.addWidget(QLabel("模式")) + grid_controls.addWidget(self.grid_mode_edit) + grid_controls.addWidget(add_monitor_button) grid_controls.addWidget(self.grid_levels_hint) grid_controls.addStretch() self.grid_levels_table = QTableWidget(0, len(self.GRID_LEVEL_COLUMNS)) @@ -222,7 +251,7 @@ class MainWindow(QMainWindow): trade_layout.addWidget(self.trades_table) self.details_tabs.addTab(grid_tab, "网格档位") - self.details_tabs.addTab(open_grid_tab, "待卖网格") + self.details_tabs.addTab(open_grid_tab, "未完成网格") self.details_tabs.addTab(grid_match_tab, "配对明细") self.details_tabs.addTab(trade_tab, "最近成交") self.details_tabs.setCurrentIndex(1) @@ -424,8 +453,10 @@ class MainWindow(QMainWindow): layout = QHBoxLayout() buttons = [ ("刷新行情", self._refresh_quotes), + ("悬浮监控", self._show_floating_monitor), ("账户设置", self._edit_account), ("添加标的", self._add_instrument), + ("删除标的", self._delete_selected_instrument), ("录入成交", self._add_trade), ("策略设置", self._edit_strategy), ] @@ -456,44 +487,18 @@ class MainWindow(QMainWindow): self._refresh_details() def _refresh_quotes(self) -> None: - if self._quote_thread is not None and self._quote_thread.isRunning(): - return - try: - instruments = self.service.list_instruments() - except Exception as exc: - QMessageBox.warning(self, "行情刷新失败", str(exc)) - return - if not instruments: - QMessageBox.information(self, "行情刷新", "请先添加股票或 ETF 标的。") - return - self._set_quote_refreshing(True) - self._quote_thread = QThread(self) - self._quote_worker = QuoteRefreshWorker(self.service, instruments) - self._quote_worker.moveToThread(self._quote_thread) - self._quote_thread.started.connect(self._quote_worker.run) - self._quote_worker.finished.connect(self._on_quote_refresh_finished) - self._quote_worker.failed.connect(self._on_quote_refresh_failed) - self._quote_worker.finished.connect(self._quote_thread.quit) - self._quote_worker.failed.connect(self._quote_thread.quit) - self._quote_thread.finished.connect(self._quote_worker.deleteLater) - self._quote_thread.finished.connect(self._on_quote_thread_finished) - self._quote_thread.start() + self.quote_monitor.refresh(manual=True) - def _on_quote_refresh_finished(self, quotes: dict) -> None: - try: - self.service.apply_quote_snapshots(quotes) - except Exception as exc: - QMessageBox.warning(self, "行情刷新失败", str(exc)) - return + def _on_quotes_updated(self, _quotes: dict) -> None: + self.floating_monitor.set_connection_status("行情正常", ok=True) + self.statusBar().showMessage("行情已更新", 3_000) self.refresh_all() - def _on_quote_refresh_failed(self, message: str) -> None: - QMessageBox.warning(self, "行情刷新失败", message) - - def _on_quote_thread_finished(self) -> None: - self._set_quote_refreshing(False) - self._quote_thread = None - self._quote_worker = None + def _on_quote_refresh_failed(self, message: str, manual: bool) -> None: + self.floating_monitor.set_connection_status("行情异常", ok=False) + self.statusBar().showMessage(f"行情刷新失败:{message}", 8_000) + if manual: + QMessageBox.warning(self, "行情刷新失败", message) def _set_quote_refreshing(self, refreshing: bool) -> None: if self.refresh_quotes_button is None: @@ -510,8 +515,6 @@ class MainWindow(QMainWindow): format_price(position.current_price), format_quantity(position.total_quantity), format_quantity(position.available_quantity), - format_quantity(position.base_quantity), - format_quantity(position.grid_quantity), format_money(position.remaining_cost), format_price(position.position_breakeven_price), format_price(position.account_breakeven_price), @@ -520,9 +523,9 @@ class MainWindow(QMainWindow): format_money(position.floating_pnl), ] pnl_values = { - 10: position.realized_pnl, - 11: position.grid_profit, - 12: position.floating_pnl, + 8: position.realized_pnl, + 9: position.grid_profit, + 10: position.floating_pnl, } for column, value in enumerate(values): item = self._make_item(value, pnl_values.get(column)) @@ -543,75 +546,92 @@ class MainWindow(QMainWindow): self._refresh_grid_levels(None) self._refresh_open_grid_lots(None) self._refresh_grid_matches(None) - self._fill_trades_table([]) + self._fill_trades_table([], None) return self._refresh_grid_levels(position) self._refresh_open_grid_lots(position) self._refresh_grid_matches(position) - self._fill_trades_table(self.service.list_trades(instrument_id=position.instrument_id)) + self._fill_trades_table( + self.service.list_trades(instrument_id=position.instrument_id), + position, + ) def _refresh_grid_levels(self, position: PositionSummary | None) -> None: if position is None: self.grid_levels_hint.setText("-") - self._fill_grid_levels_table([]) + self._fill_grid_levels_table([], None) return if position.current_price is None: self.grid_levels_hint.setText("请先刷新行情") - self._fill_grid_levels_table([]) + self._fill_grid_levels_table([], position) return try: levels = self.service.get_grid_level_suggestions( position.instrument_id, levels=self.grid_levels_count_edit.value(), + mode=GridMode(self.grid_mode_edit.currentData()), ) except Exception as exc: QMessageBox.warning(self, "网格档位失败", str(exc)) self.grid_levels_hint.setText(str(exc)) - self._fill_grid_levels_table([]) + self._fill_grid_levels_table([], position) return self.grid_levels_hint.setText("") - self._fill_grid_levels_table(levels) + self._fill_grid_levels_table(levels, position) - def _fill_grid_levels_table(self, levels: list[GridLevelSuggestion]) -> None: + def _fill_grid_levels_table( + self, + levels: list[GridLevelSuggestion], + position: PositionSummary | None, + ) -> None: + self._grid_levels_by_row = {} self.grid_levels_table.setRowCount(len(levels)) for row, level in enumerate(levels): + self._grid_levels_by_row[row] = level values = [ + *self._position_cells(position), str(level.level), - format_price(level.buy_price), - format_money(level.buy_amount), + "正向" if level.direction is GridDirection.FORWARD else "反向", + format_price(level.open_price), format_quantity(level.suggested_quantity), format_money(level.actual_investment), - format_price(level.sell_price), + format_price(level.close_price), format_money(level.estimated_gross_profit), ] for column, value in enumerate(values): item = self._make_item( value, - level.estimated_gross_profit if column == 6 else None, + level.estimated_gross_profit if column == 8 else None, ) self.grid_levels_table.setItem(row, column, item) def _refresh_open_grid_lots(self, position: PositionSummary | None) -> None: if position is None: - self._fill_open_grid_lots_table([]) + self._fill_open_grid_lots_table([], None) return try: lots = self.service.get_open_grid_lots(position.instrument_id) except Exception as exc: - QMessageBox.warning(self, "待卖网格失败", str(exc)) - self._fill_open_grid_lots_table([]) + QMessageBox.warning(self, "未完成网格失败", str(exc)) + self._fill_open_grid_lots_table([], position) return - self._fill_open_grid_lots_table(lots) + self._fill_open_grid_lots_table(lots, position) - def _fill_open_grid_lots_table(self, lots: list[OpenGridLot]) -> None: + def _fill_open_grid_lots_table( + self, + lots: list[OpenGridLot], + position: PositionSummary | None, + ) -> None: self.open_grid_lots_table.setRowCount(len(lots)) for row, lot in enumerate(lots): values = [ - lot.buy_date.isoformat(), - format_price(lot.buy_price), + *self._position_cells(position), + "正向" if lot.direction is GridDirection.FORWARD else "反向", + lot.open_date.isoformat(), + format_price(lot.open_price), format_quantity(lot.remaining_quantity), - format_money(lot.actual_investment), - format_price(lot.suggested_sell_price), + format_money(lot.open_amount), + format_price(lot.target_price), format_money(lot.estimated_gross_profit), format_price(lot.current_price), lot.status, @@ -619,26 +639,32 @@ class MainWindow(QMainWindow): for column, value in enumerate(values): item = self._make_item( value, - lot.estimated_gross_profit if column == 5 else None, + lot.estimated_gross_profit if column == 8 else None, ) self.open_grid_lots_table.setItem(row, column, item) def _refresh_grid_matches(self, position: PositionSummary | None) -> None: if position is None: - self._fill_grid_matches_table([]) + self._fill_grid_matches_table([], None) return try: matches = self.service.get_grid_trade_matches(position.instrument_id) except Exception as exc: QMessageBox.warning(self, "配对明细失败", str(exc)) - self._fill_grid_matches_table([]) + self._fill_grid_matches_table([], position) return - self._fill_grid_matches_table(matches) + self._fill_grid_matches_table(matches, position) - def _fill_grid_matches_table(self, matches: list[GridTradeMatch]) -> None: + def _fill_grid_matches_table( + self, + matches: list[GridTradeMatch], + position: PositionSummary | None, + ) -> None: self.grid_matches_table.setRowCount(len(matches)) for row, match in enumerate(matches): values = [ + *self._position_cells(position), + "正向" if match.direction is GridDirection.FORWARD else "反向", match.sell_date.isoformat(), format_price(match.sell_price), match.buy_date.isoformat(), @@ -646,22 +672,34 @@ class MainWindow(QMainWindow): format_quantity(match.matched_quantity), format_money(match.buy_amount), format_money(match.sell_amount), + format_money(match.buy_fees + match.sell_fees), format_money(match.gross_profit), - f"买{match.buy_trade_id or '-'} -> 卖{match.sell_trade_id or '-'}", + format_money(match.net_profit), ] for column, value in enumerate(values): - item = self._make_item(value, match.gross_profit if column == 7 else None) + item = self._make_item(value, match.net_profit if column == 12 else None) self.grid_matches_table.setItem(row, column, item) - def _fill_trades_table(self, trades: list[Trade]) -> None: + def _fill_trades_table( + self, + trades: list[Trade], + position: PositionSummary | None, + ) -> None: self._trade_ids_by_row = {} self.trades_table.setRowCount(len(trades)) for row, trade in enumerate(trades): self._trade_ids_by_row[row] = trade.id values = [ + *self._position_cells(position), trade.trade_date.isoformat(), "买入" if trade.side is TradeSide.BUY else "卖出", - trade.trade_group.value, + ( + "正向" + if trade.grid_direction is GridDirection.FORWARD + else "反向" + if trade.grid_direction is GridDirection.REVERSE + else "-" + ), format_price(trade.price), format_quantity(trade.quantity), format_money(trade.total_fee), @@ -670,6 +708,10 @@ class MainWindow(QMainWindow): for column, value in enumerate(values): self.trades_table.setItem(row, column, QTableWidgetItem(value)) + @staticmethod + def _position_cells(position: PositionSummary | None) -> list[str]: + return [position.code, position.name] if position is not None else ["-", "-"] + def _selected_position(self) -> PositionSummary | None: if self._selected_instrument_id is None: return None @@ -682,6 +724,171 @@ class MainWindow(QMainWindow): None, ) + def _connect_monitoring(self) -> None: + self.quote_monitor.refresh_started.connect(lambda: self._set_quote_refreshing(True)) + self.quote_monitor.refresh_finished.connect(lambda: self._set_quote_refreshing(False)) + self.quote_monitor.quotes_updated.connect(self._on_quotes_updated) + self.quote_monitor.refresh_failed.connect(self._on_quote_refresh_failed) + self.quote_monitor.monitor_updated.connect(self._on_monitor_updated) + self.quote_monitor.targets_reached.connect(self._on_targets_reached) + self.quote_monitor.shutdown_finished.connect(self._complete_pending_close) + self.floating_monitor.refresh_requested.connect( + lambda: self.quote_monitor.refresh(manual=True) + ) + self.floating_monitor.open_main_requested.connect(self._show_main_window) + self.floating_monitor.remove_target_requested.connect(self._remove_grid_alert) + self.floating_monitor.hidden.connect(self._persist_monitor_settings) + + def start_monitoring(self) -> None: + if self._monitor_started: + return + self._monitor_started = True + if self.service.get_setting("grid_monitor_visible", "1") == "1": + self._show_floating_monitor() + self.quote_monitor.start() + + def _show_floating_monitor(self) -> None: + if self.service.get_setting("grid_monitor_x") is None: + screen = QApplication.primaryScreen() + if screen is not None: + area = screen.availableGeometry() + self.floating_monitor.move( + area.right() - self.floating_monitor.width() - 24, + area.top() + 24, + ) + self.floating_monitor.show_and_raise() + self.service.set_setting("grid_monitor_visible", "1") + + def _show_main_window(self, instrument_id=None) -> None: + self.showNormal() + self.raise_() + self.activateWindow() + if instrument_id is None: + return + for row in range(self.holdings_table.rowCount()): + item = self.holdings_table.item(row, 0) + if item is not None and item.data(Qt.ItemDataRole.UserRole) == instrument_id: + self.holdings_table.selectRow(row) + break + + def _add_selected_grid_alert(self) -> None: + position = self._selected_position() + level = self._grid_levels_by_row.get(self.grid_levels_table.currentRow()) + if position is None or level is None: + QMessageBox.information(self, "加入监控", "请先选择一个有行情的网格档位。") + return + if level.suggested_quantity <= 0: + QMessageBox.information(self, "加入监控", "当前持仓或每格金额不足一个交易单位。") + return + try: + self.service.add_grid_alert( + position.instrument_id, + side=level.open_side, + target_price=level.open_price, + quantity=level.suggested_quantity, + ) + except Exception as exc: + QMessageBox.warning(self, "加入监控失败", str(exc)) + return + self.quote_monitor.evaluate_now() + self._show_floating_monitor() + self.statusBar().showMessage( + f"已固定监控 {position.code} " + f"{'买入' if level.open_side is TradeSide.BUY else '卖出'}价 " + f"{format_price(level.open_price)}", + 5_000, + ) + + def _remove_grid_alert(self, target_key: str) -> None: + answer = QMessageBox.question(self, "删除开仓监控", "确定删除选中的开仓监控吗?") + if answer != QMessageBox.StandardButton.Yes: + return + try: + self.service.remove_grid_alert(target_key) + except Exception as exc: + QMessageBox.warning(self, "删除监控失败", str(exc)) + return + self.quote_monitor.evaluate_now() + + def _on_monitor_updated(self, snapshot: GridMonitorSnapshot) -> None: + self.floating_monitor.update_snapshot(snapshot) + + def _on_targets_reached(self, items: list[GridMonitorItem]) -> None: + if not items: + return + lines = [ + f"{item.code} {'买入' if item.side is TradeSide.BUY else '卖出'} " + f"{format_price(item.target_price)}" + for item in items[:3] + ] + if len(items) > 3: + lines.append(f"另有 {len(items) - 3} 项") + message = "\n".join(lines) + self.statusBar().showMessage(f"网格到价:{message.replace(chr(10), ';')}", 10_000) + if not self.floating_monitor.muted: + QApplication.beep() + if self._tray_icon is not None: + self._tray_icon.showMessage( + "网格已到价", + message, + QSystemTrayIcon.MessageIcon.Information, + 8_000, + ) + + def _restore_monitor_settings(self) -> None: + self.floating_monitor.muted = self.service.get_setting("grid_monitor_muted", "0") == "1" + self.floating_monitor.reached_only = ( + self.service.get_setting("grid_monitor_reached_only", "0") == "1" + ) + x = self.service.get_setting("grid_monitor_x") + y = self.service.get_setting("grid_monitor_y") + if x is not None and y is not None: + try: + self.floating_monitor.move(int(x), int(y)) + except ValueError: + pass + + def _persist_monitor_settings(self) -> None: + position = self.floating_monitor.pos() + self.service.set_setting("grid_monitor_x", str(position.x())) + self.service.set_setting("grid_monitor_y", str(position.y())) + self.service.set_setting( + "grid_monitor_muted", + "1" if self.floating_monitor.muted else "0", + ) + self.service.set_setting( + "grid_monitor_reached_only", + "1" if self.floating_monitor.reached_only else "0", + ) + self.service.set_setting( + "grid_monitor_visible", + "1" if self.floating_monitor.isVisible() else "0", + ) + + def _create_tray_icon(self) -> None: + if not QSystemTrayIcon.isSystemTrayAvailable(): + return + self._tray_icon = QSystemTrayIcon(QIcon(str(APP_ICON_PATH)), self) + self._tray_icon.setToolTip("网格交易监控") + menu = QMenu(self) + show_main_action = QAction("打开主界面", self) + show_main_action.triggered.connect(lambda: self._show_main_window()) + show_monitor_action = QAction("显示悬浮监控", self) + show_monitor_action.triggered.connect(self._show_floating_monitor) + exit_action = QAction("退出", self) + exit_action.triggered.connect(self.close) + menu.addAction(show_main_action) + menu.addAction(show_monitor_action) + menu.addSeparator() + menu.addAction(exit_action) + self._tray_icon.setContextMenu(menu) + self._tray_icon.activated.connect(self._on_tray_activated) + self._tray_icon.show() + + def _on_tray_activated(self, reason) -> None: + if reason == QSystemTrayIcon.ActivationReason.DoubleClick: + self._show_main_window() + def _edit_account(self) -> None: dialog = AccountDialog(self.service.get_active_account(), self) if dialog.exec() == QDialog.DialogCode.Accepted: @@ -692,10 +899,40 @@ class MainWindow(QMainWindow): if dialog.exec() == QDialog.DialogCode.Accepted: self._run_action(lambda: self.service.add_instrument(dialog.to_instrument())) + def _delete_selected_instrument(self) -> None: + position = self._selected_position() + if position is None: + QMessageBox.information(self, "请选择标的", "请先在持仓表中选择一个标的。") + return + answer = QMessageBox.question( + self, + "删除标的", + f"确定删除 {position.code} {position.name} 吗?", + ) + if answer != QMessageBox.StandardButton.Yes: + return + instrument_id = position.instrument_id + + def delete_instrument() -> None: + self.service.delete_instrument(instrument_id) + self._selected_instrument_id = None + + self._run_action(delete_instrument) + def _edit_strategy(self) -> None: dialog = StrategyTemplateDialog(self.service.get_default_strategy_template(), self) if dialog.exec() == QDialog.DialogCode.Accepted: - self._run_action(lambda: self.service.save_strategy_template(dialog.to_template())) + template = dialog.to_template() + try: + self.service.save_strategy_template(template) + except Exception as exc: + QMessageBox.warning(self, "操作失败", str(exc)) + return + self.grid_mode_edit.setCurrentIndex( + self.grid_mode_edit.findData(template.grid_mode.value) + ) + self.refresh_all() + self.quote_monitor.evaluate_now() def _add_trade(self) -> None: instruments = self.service.list_instruments() @@ -740,13 +977,44 @@ class MainWindow(QMainWindow): QMessageBox.warning(self, "操作失败", str(exc)) return self.refresh_all() + self.quote_monitor.evaluate_now() + + def closeEvent(self, event) -> None: + if not self._close_pending: + self._persist_monitor_settings() + self._close_pending = True + + if not self.quote_monitor.shutdown(): + self._finalize_close_resources() + self.hide() + event.ignore() + return + + self._finalize_close_resources() + self._close_pending = False + event.accept() + + def _complete_pending_close(self) -> None: + if self._close_pending: + self.close() + + def _finalize_close_resources(self) -> None: + if self._close_resources_finalized: + return + self._close_resources_finalized = True + self.floating_monitor.close_permanently() + if self._tray_icon is not None: + self._tray_icon.hide() def run_gui(db_path: str | Path | None = None) -> int: app = QApplication.instance() or QApplication(sys.argv) + if APP_ICON_PATH.exists(): + app.setWindowIcon(QIcon(str(APP_ICON_PATH))) service = TradingService(db_path or DEFAULT_DB_PATH) window = MainWindow(service) window.show() + window.start_monitoring() result = app.exec() service.close() return result diff --git a/src/grid_trading/ui/quote_monitor.py b/src/grid_trading/ui/quote_monitor.py new file mode 100644 index 0000000..2e8fcb6 --- /dev/null +++ b/src/grid_trading/ui/quote_monitor.py @@ -0,0 +1,157 @@ +from __future__ import annotations + +from PySide6.QtCore import QObject, Qt, QThread, QTimer, Signal + +from grid_trading.services.trading_service import TradingService + + +class QuoteRefreshWorker(QObject): + finished = Signal(object) + failed = Signal(str) + + def __init__(self, service: TradingService, instruments): + super().__init__() + self._service = service + self._instruments = instruments + + def run(self) -> None: + try: + quotes = self._service.fetch_quotes_for_instruments(self._instruments) + except Exception as exc: + self.failed.emit(str(exc)) + return + self.finished.emit(quotes) + + +class QuoteMonitorController(QObject): + refresh_started = Signal() + refresh_finished = Signal() + quotes_updated = Signal(object) + refresh_failed = Signal(str, bool) + monitor_updated = Signal(object) + targets_reached = Signal(object) + shutdown_finished = Signal() + + def __init__( + self, + service: TradingService, + *, + interval_ms: int = 10_000, + parent: QObject | None = None, + ): + super().__init__(parent) + self.service = service + self._thread: QThread | None = None + self._worker: QuoteRefreshWorker | None = None + self._manual_refresh = False + self._failure_count = 0 + self._shutting_down = False + self._timer = QTimer(self) + self._timer.setInterval(max(3_000, interval_ms)) + self._timer.timeout.connect(self.refresh) + + @property + def is_refreshing(self) -> bool: + return self._thread is not None and self._thread.isRunning() + + def start(self) -> None: + self._shutting_down = False + if not self._timer.isActive(): + self._timer.start() + self.evaluate_now() + QTimer.singleShot(0, self.refresh) + + def set_interval(self, interval_ms: int) -> None: + self._timer.setInterval(max(3_000, interval_ms)) + + def refresh(self, manual: bool = False) -> bool: + if self.is_refreshing: + return False + try: + instruments = self.service.list_instruments() + except Exception as exc: + self.refresh_failed.emit(str(exc), manual) + return False + if not instruments: + self.refresh_failed.emit("请先添加股票或 ETF 标的。", manual) + self.evaluate_now() + return False + + self._manual_refresh = manual + self._thread = QThread(self) + self._worker = QuoteRefreshWorker(self.service, instruments) + self._worker.moveToThread(self._thread) + self._thread.started.connect(self._worker.run) + self._worker.finished.connect(self._handle_success) + self._worker.failed.connect(self._handle_failure) + self._worker.finished.connect( + self._thread.quit, + Qt.ConnectionType.DirectConnection, + ) + self._worker.failed.connect( + self._thread.quit, + Qt.ConnectionType.DirectConnection, + ) + self._worker.finished.connect(self._worker.deleteLater) + self._worker.failed.connect(self._worker.deleteLater) + self._thread.finished.connect(self._on_thread_finished) + self._thread.finished.connect(self._thread.deleteLater) + self.refresh_started.emit() + self._thread.start() + return True + + def evaluate_now(self) -> None: + try: + snapshot = self.service.evaluate_grid_alerts() + except Exception as exc: + self.refresh_failed.emit(f"监控状态更新失败:{exc}", False) + return + self.monitor_updated.emit(snapshot) + if snapshot.newly_reached: + self.targets_reached.emit(snapshot.newly_reached) + + def shutdown(self) -> bool: + """Stop scheduling refreshes without blocking the GUI thread. + + A running urllib request cannot be interrupted by ``QThread.quit()``. + Let it finish in the background and notify the window when it is safe + to complete application shutdown instead of waiting synchronously. + """ + self._shutting_down = True + self._timer.stop() + thread = self._thread + if thread is not None and thread.isRunning(): + thread.quit() + return False + self._thread = None + self._worker = None + return True + + def _handle_success(self, quotes: dict) -> None: + if self._shutting_down: + return + try: + self.service.apply_quote_snapshots(quotes) + except Exception as exc: + self._handle_failure(str(exc)) + return + self._failure_count = 0 + self.quotes_updated.emit(quotes) + self.evaluate_now() + + def _handle_failure(self, message: str) -> None: + if self._shutting_down: + return + self._failure_count += 1 + if self._failure_count >= 2: + self.service.clear_quote_snapshots() + self.evaluate_now() + self.refresh_failed.emit(message, self._manual_refresh) + + def _on_thread_finished(self) -> None: + self._thread = None + self._worker = None + self._manual_refresh = False + self.refresh_finished.emit() + if self._shutting_down: + self.shutdown_finished.emit() diff --git a/tests/test_calculations.py b/tests/test_calculations.py index c844138..dd3a936 100644 --- a/tests/test_calculations.py +++ b/tests/test_calculations.py @@ -9,7 +9,16 @@ from grid_trading.domain.calculations import ( calculate_positions, estimate_fees, ) -from grid_trading.domain.models import Account, FeeRules, Instrument, QuoteSnapshot, Trade, TradeGroup, TradeSide +from grid_trading.domain.models import ( + Account, + FeeRules, + GridDirection, + Instrument, + QuoteSnapshot, + Trade, + TradeGroup, + TradeSide, +) def make_trade( @@ -24,6 +33,7 @@ def make_trade( stamp_tax: str = "0", transfer_fee: str = "0", trade_group: TradeGroup = TradeGroup.GRID, + grid_direction: GridDirection | None = None, ) -> Trade: return Trade( id=trade_id, @@ -37,6 +47,7 @@ def make_trade( stamp_tax=Decimal(stamp_tax), transfer_fee=Decimal(transfer_fee), trade_group=trade_group, + grid_direction=grid_direction, ) @@ -100,7 +111,7 @@ def test_buy_sell_grid_profit_and_breakeven(): assert summary.floating_pnl == Decimal("49.00") -def test_t_plus_one_available_quantity_excludes_today_buys(): +def test_available_quantity_includes_today_buys(): today = date(2026, 7, 8) instrument = Instrument(id=1, code="600000", name="浦发银行", manual_price=Decimal("10")) trades = [ @@ -125,7 +136,48 @@ def test_t_plus_one_available_quantity_excludes_today_buys(): [summary] = calculate_positions([instrument], trades, as_of=today) assert summary.total_quantity == 300 - assert summary.available_quantity == 200 + assert summary.available_quantity == 300 + + +def test_reverse_grid_profit_is_realized_when_sell_is_bought_back(): + today = date(2026, 7, 8) + instrument = Instrument(id=1, code="510300", name="沪深300ETF") + trades = [ + make_trade( + trade_id=1, + trade_date=today - timedelta(days=1), + side=TradeSide.BUY, + price="9.00", + quantity=100, + trade_group=TradeGroup.BASE, + ), + make_trade( + trade_id=2, + trade_date=today, + side=TradeSide.SELL, + price="10.30", + quantity=100, + commission="1", + trade_group=TradeGroup.BASE, + grid_direction=GridDirection.REVERSE, + ), + make_trade( + trade_id=3, + trade_date=today, + side=TradeSide.BUY, + price="10.00", + quantity=100, + commission="1", + trade_group=TradeGroup.BASE, + grid_direction=GridDirection.REVERSE, + ), + ] + + [summary] = calculate_positions([instrument], trades, as_of=today) + + assert summary.total_quantity == 100 + assert summary.available_quantity == 100 + assert summary.grid_profit == Decimal("28.00") def test_quote_snapshot_supplies_current_price_for_position_value(): @@ -213,7 +265,7 @@ def test_account_summary_caps_capital_usage_when_cash_is_negative(): assert summary.capital_usage_rate == Decimal("1.0000") -def test_sell_more_than_group_position_raises(): +def test_sell_more_than_total_position_raises(): today = date(2026, 7, 8) instrument = Instrument(id=1, code="159915", name="创业板ETF") trades = [ @@ -235,10 +287,39 @@ def test_sell_more_than_group_position_raises(): ), ] - with pytest.raises(CalculationError, match="Insufficient grid position"): + with pytest.raises(CalculationError, match="总持仓不足"): calculate_positions([instrument], trades, as_of=today) +def test_sell_can_use_holding_recorded_in_a_different_legacy_group(): + today = date(2026, 7, 8) + instrument = Instrument(id=1, code="600588", name="用友网络") + trades = [ + make_trade( + trade_id=1, + trade_date=today - timedelta(days=1), + side=TradeSide.BUY, + price="9.00", + quantity=9400, + trade_group=TradeGroup.BASE, + ), + make_trade( + trade_id=2, + trade_date=today, + side=TradeSide.SELL, + price="9.56", + quantity=9400, + trade_group=TradeGroup.GRID, + grid_direction=GridDirection.REVERSE, + ), + ] + + [summary] = calculate_positions([instrument], trades, as_of=today) + + assert summary.total_quantity == 0 + assert summary.realized_pnl == Decimal("5264.00") + + def test_estimate_fees_uses_min_commission_and_sell_tax(): rules = FeeRules( commission_rate=Decimal("0.00025"), diff --git a/tests/test_grid_alerts.py b/tests/test_grid_alerts.py new file mode 100644 index 0000000..0d8cac3 --- /dev/null +++ b/tests/test_grid_alerts.py @@ -0,0 +1,38 @@ +from decimal import Decimal + +import pytest + +from grid_trading.domain.grid_alerts import evaluate_grid_alert +from grid_trading.domain.models import GridAlertState, TradeSide + + +@pytest.mark.parametrize( + ("side", "current", "target", "expected"), + [ + (TradeSide.BUY, "9.99", "10.00", GridAlertState.REACHED), + (TradeSide.BUY, "10.04", "10.00", GridAlertState.NEAR), + (TradeSide.BUY, "10.10", "10.00", GridAlertState.WAITING), + (TradeSide.SELL, "10.01", "10.00", GridAlertState.REACHED), + (TradeSide.SELL, "9.96", "10.00", GridAlertState.NEAR), + (TradeSide.SELL, "9.90", "10.00", GridAlertState.WAITING), + ], +) +def test_evaluate_grid_alert_handles_buy_and_sell_directions(side, current, target, expected): + result = evaluate_grid_alert( + side=side, + current_price=Decimal(current), + target_price=Decimal(target), + ) + + assert result.state is expected + + +def test_evaluate_grid_alert_marks_missing_quote_unavailable(): + result = evaluate_grid_alert( + side=TradeSide.BUY, + current_price=None, + target_price=Decimal("10"), + ) + + assert result.state is GridAlertState.UNAVAILABLE + assert result.distance_pct is None diff --git a/tests/test_grid_levels.py b/tests/test_grid_levels.py index c29cbed..3fc7377 100644 --- a/tests/test_grid_levels.py +++ b/tests/test_grid_levels.py @@ -3,6 +3,7 @@ from decimal import Decimal import pytest from grid_trading.domain.grid_levels import generate_grid_levels +from grid_trading.domain.models import GridDirection def test_generate_grid_levels_compounds_percentage_spacing_and_rounds_values(): @@ -46,6 +47,25 @@ def test_generate_grid_levels_uses_zero_quantity_when_amount_cannot_buy_one_lot( assert level.estimated_gross_profit == Decimal("0.00") +def test_generate_reverse_grid_levels_sell_high_and_buy_back_lower(): + levels = generate_grid_levels( + current_price=Decimal("10.00"), + spacing=Decimal("0.03"), + amount_per_grid=Decimal("10000"), + lot_size=100, + levels=2, + direction=GridDirection.REVERSE, + max_quantity=500, + ) + + assert [item.direction for item in levels] == [GridDirection.REVERSE] * 2 + assert [item.sell_price for item in levels] == [Decimal("10.30"), Decimal("10.61")] + assert [item.buy_price for item in levels] == [Decimal("10.00"), Decimal("10.30")] + assert [item.suggested_quantity for item in levels] == [500, 500] + assert levels[0].open_price == Decimal("10.30") + assert levels[0].close_price == Decimal("10.00") + + @pytest.mark.parametrize( ("current_price", "spacing", "amount_per_grid", "lot_size", "levels"), [ diff --git a/tests/test_open_grid_lots.py b/tests/test_open_grid_lots.py index e883637..0e1cfe9 100644 --- a/tests/test_open_grid_lots.py +++ b/tests/test_open_grid_lots.py @@ -1,7 +1,7 @@ from datetime import date, timedelta from decimal import Decimal -from grid_trading.domain.models import Trade, TradeGroup, TradeSide +from grid_trading.domain.models import GridDirection, Trade, TradeGroup, TradeSide from grid_trading.domain.open_grid_lots import calculate_grid_trade_matches, calculate_open_grid_lots @@ -13,6 +13,8 @@ def make_trade( price: str, quantity: int, trade_group: TradeGroup = TradeGroup.GRID, + grid_direction: GridDirection | None = None, + commission: str = "0", ) -> Trade: return Trade( id=trade_id, @@ -23,6 +25,8 @@ def make_trade( price=Decimal(price), quantity=quantity, trade_group=trade_group, + grid_direction=grid_direction, + commission=Decimal(commission), ) @@ -149,3 +153,49 @@ def test_calculate_open_grid_lots_reports_not_reached_and_missing_quote_statuses assert not_reached.status == "未到价" assert missing_quote.current_price is None assert missing_quote.status == "未刷新行情" + + +def test_reverse_grid_sell_opens_lot_and_buy_closes_it_fifo(): + today = date(2026, 7, 9) + trades = [ + make_trade( + trade_id=1, + trade_date=today - timedelta(days=2), + side=TradeSide.SELL, + price="10.30", + quantity=300, + trade_group=TradeGroup.BASE, + grid_direction=GridDirection.REVERSE, + commission="3", + ), + make_trade( + trade_id=2, + trade_date=today - timedelta(days=1), + side=TradeSide.BUY, + price="10.00", + quantity=100, + trade_group=TradeGroup.BASE, + grid_direction=GridDirection.REVERSE, + commission="1", + ), + ] + + [lot] = calculate_open_grid_lots( + trades, + spacing=Decimal("0.03"), + current_price=Decimal("9.99"), + as_of=today, + ) + [match] = calculate_grid_trade_matches(trades, as_of=today) + + assert lot.direction is GridDirection.REVERSE + assert lot.open_trade_id == 1 + assert lot.remaining_quantity == 200 + assert lot.open_price == Decimal("10.30") + assert lot.target_price == Decimal("10.00") + assert lot.status == "可买回" + assert match.direction is GridDirection.REVERSE + assert match.sell_trade_id == 1 + assert match.buy_trade_id == 2 + assert match.gross_profit == Decimal("30.00") + assert match.net_profit == Decimal("28.00") diff --git a/tests/test_repositories.py b/tests/test_repositories.py index 063c7eb..3dd76f1 100644 --- a/tests/test_repositories.py +++ b/tests/test_repositories.py @@ -1,7 +1,20 @@ from datetime import date from decimal import Decimal +import sqlite3 -from grid_trading.domain.models import Account, Instrument, StrategyTemplate, Trade, TradeGroup, TradeSide +from grid_trading.domain.models import ( + Account, + GridAlertSource, + GridAlertState, + GridAlertTarget, + GridDirection, + GridMode, + Instrument, + StrategyTemplate, + Trade, + TradeGroup, + TradeSide, +) from grid_trading.storage.repositories import Repository @@ -103,3 +116,100 @@ def test_trade_update_and_delete_are_persistent(tmp_path): reopened.delete_trade(trade.id) assert reopened.get_trade(trade.id) is None assert reopened.list_trades(account_id=account.id) == [] + + +def test_instrument_delete_is_persistent(tmp_path): + repo = Repository(tmp_path / "grid.db") + repo.initialize() + instrument = repo.save_instrument(Instrument(id=None, code="600000", name="浦发银行")) + + repo.delete_instrument(instrument.id) + + assert repo.get_instrument(instrument.id) is None + assert repo.list_instruments() == [] + + +def test_grid_alert_target_round_trips_and_updates_state(tmp_path): + repo = Repository(tmp_path / "grid.db") + repo.initialize() + instrument = repo.save_instrument(Instrument(id=None, code="510300", name="沪深300ETF")) + target = repo.save_grid_alert_target( + GridAlertTarget( + id=None, + target_key="manual:test", + instrument_id=instrument.id, + side=TradeSide.BUY, + target_price=Decimal("3.88"), + quantity=1200, + source=GridAlertSource.MANUAL, + ) + ) + + assert target.id is not None + repo.update_grid_alert_state( + target.target_key, + state=GridAlertState.REACHED, + alerted=True, + last_alerted_at=None, + ) + updated = repo.get_grid_alert_target(target.target_key) + + assert updated.last_state is GridAlertState.REACHED + assert updated.alerted + + repo.delete_grid_alert_target(target.target_key) + assert repo.get_grid_alert_target(target.target_key) is None + + +def test_initialize_migrates_legacy_grid_columns(tmp_path): + db_path = tmp_path / "legacy.db" + connection = sqlite3.connect(db_path) + connection.executescript( + """ + CREATE TABLE strategy_templates ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + grid_spacing_pct TEXT NOT NULL, + amount_per_grid TEXT NOT NULL, + base_target_amount TEXT NOT NULL, + max_position_amount TEXT NOT NULL, + min_lot INTEGER NOT NULL, + is_default INTEGER NOT NULL, + created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP + ); + CREATE TABLE trades ( + id INTEGER PRIMARY KEY, + account_id INTEGER NOT NULL, + instrument_id INTEGER NOT NULL, + trade_date TEXT NOT NULL, + side TEXT NOT NULL, + price TEXT NOT NULL, + quantity INTEGER NOT NULL, + commission TEXT NOT NULL DEFAULT '0', + stamp_tax TEXT NOT NULL DEFAULT '0', + transfer_fee TEXT NOT NULL DEFAULT '0', + trade_group TEXT NOT NULL, + notes TEXT NOT NULL DEFAULT '', + created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP + ); + INSERT INTO strategy_templates + (id, name, grid_spacing_pct, amount_per_grid, base_target_amount, + max_position_amount, min_lot, is_default) + VALUES (1, '旧策略', '0.03', '5000', '0', '80000', 100, 1); + INSERT INTO trades + (id, account_id, instrument_id, trade_date, side, price, quantity, trade_group) + VALUES (1, 1, 1, '2026-07-01', 'buy', '4.00', 100, 'grid'); + """ + ) + connection.commit() + connection.close() + + repo = Repository(db_path) + repo.initialize() + + template = repo.get_default_strategy_template() + trade = repo.get_trade(1) + assert template.grid_mode is GridMode.FORWARD + assert trade.grid_direction is GridDirection.FORWARD diff --git a/tests/test_services.py b/tests/test_services.py index 620b8a7..7e6885b 100644 --- a/tests/test_services.py +++ b/tests/test_services.py @@ -1,9 +1,19 @@ -from datetime import date, timedelta +from datetime import date from decimal import Decimal import pytest -from grid_trading.domain.models import Instrument, QuoteSnapshot, Trade, TradeGroup, TradeSide +from grid_trading.domain.models import ( + GridAlertSource, + GridAlertState, + GridDirection, + GridMode, + Instrument, + QuoteSnapshot, + Trade, + TradeGroup, + TradeSide, +) from grid_trading.services.trading_service import TradingService @@ -21,6 +31,40 @@ class FakeQuoteProvider: } +def test_service_deletes_instrument_without_trades(tmp_path): + service = TradingService(tmp_path / "grid.db") + instrument = service.add_instrument(Instrument(id=None, code="600000", name="浦发银行")) + + service.delete_instrument(instrument.id) + + assert service.list_instruments() == [] + service.close() + + +def test_service_refuses_to_delete_instrument_with_trades(tmp_path): + service = TradingService(tmp_path / "grid.db") + service.ensure_defaults() + account = service.get_active_account() + instrument = service.add_instrument(Instrument(id=None, code="600000", name="浦发银行")) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date(2026, 7, 28), + side=TradeSide.BUY, + price=Decimal("10"), + quantity=100, + ) + ) + + with pytest.raises(ValueError, match="已有成交记录"): + service.delete_instrument(instrument.id) + + assert service.list_instruments() == [instrument] + service.close() + + def test_service_creates_default_account_and_computes_summary(tmp_path): service = TradingService(tmp_path / "grid.db") service.ensure_defaults() @@ -72,7 +116,7 @@ def test_service_creates_default_account_and_computes_summary(tmp_path): assert summary.total_assets == Decimal("98138.97") -def test_service_validates_lot_size_and_available_sell_quantity(tmp_path): +def test_service_validates_lot_size_and_allows_same_day_sell(tmp_path): service = TradingService(tmp_path / "grid.db") service.ensure_defaults() account = service.get_active_account() @@ -105,32 +149,6 @@ def test_service_validates_lot_size_and_available_sell_quantity(tmp_path): ) ) - with pytest.raises(ValueError, match="T\\+1"): - service.save_trade( - Trade( - id=None, - account_id=account.id, - instrument_id=instrument.id, - trade_date=date(2026, 7, 8), - side=TradeSide.SELL, - price=Decimal("10.1"), - quantity=100, - trade_group=TradeGroup.BASE, - ) - ) - - service.save_trade( - Trade( - id=None, - account_id=account.id, - instrument_id=instrument.id, - trade_date=date(2026, 7, 8) - timedelta(days=1), - side=TradeSide.BUY, - price=Decimal("9.9"), - quantity=100, - trade_group=TradeGroup.BASE, - ) - ) saved_sell = service.save_trade( Trade( id=None, @@ -143,9 +161,22 @@ def test_service_validates_lot_size_and_available_sell_quantity(tmp_path): trade_group=TradeGroup.BASE, ) ) - assert saved_sell.id is not None + with pytest.raises(ValueError, match="总持仓不足"): + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date(2026, 7, 8), + side=TradeSide.SELL, + price=Decimal("10.2"), + quantity=100, + trade_group=TradeGroup.BASE, + ) + ) + def test_service_rejects_historical_changes_that_break_future_sells(tmp_path): service = TradingService(tmp_path / "grid.db") @@ -260,6 +291,39 @@ def test_service_returns_empty_grid_levels_without_realtime_price(tmp_path): assert service.get_grid_level_suggestions(instrument.id, levels=10) == [] +def test_service_generates_reverse_levels_capped_by_current_holding(tmp_path): + service = TradingService(tmp_path / "grid.db", quote_provider=FakeQuoteProvider()) + service.ensure_defaults() + account = service.get_active_account() + instrument = service.add_instrument( + Instrument(id=None, code="510300", name="沪深300ETF", market="ETF") + ) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date.today(), + side=TradeSide.BUY, + price=Decimal("4.00"), + quantity=500, + trade_group=TradeGroup.BASE, + ) + ) + service.refresh_quotes() + + [level] = service.get_grid_level_suggestions( + instrument.id, + levels=1, + mode=GridMode.REVERSE, + ) + + assert level.direction is GridDirection.REVERSE + assert level.sell_price == Decimal("4.24") + assert level.buy_price == Decimal("4.12") + assert level.suggested_quantity == 500 + + def test_service_returns_open_grid_lots_with_suggested_sell_price(tmp_path): service = TradingService(tmp_path / "grid.db", quote_provider=FakeQuoteProvider()) service.ensure_defaults() @@ -350,3 +414,112 @@ def test_service_returns_grid_trade_matches(tmp_path): assert matches[0].gross_profit == Decimal("90.00") assert matches[1].matched_quantity == 100 assert matches[1].gross_profit == Decimal("80.00") + + +def test_service_persists_buy_alert_and_synchronizes_open_sell_alert(tmp_path): + service = TradingService(tmp_path / "grid.db", quote_provider=FakeQuoteProvider()) + service.ensure_defaults() + account = service.get_active_account() + instrument = service.add_instrument( + Instrument(id=None, code="510300", name="沪深300ETF", market="ETF") + ) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date.today(), + side=TradeSide.BUY, + price=Decimal("4.00"), + quantity=1000, + trade_group=TradeGroup.GRID, + ) + ) + buy_target = service.add_buy_grid_alert( + instrument.id, + target_price=Decimal("4.10"), + quantity=1200, + ) + service.refresh_quotes() + + first = service.evaluate_grid_alerts() + second = service.evaluate_grid_alerts() + + assert buy_target.source is GridAlertSource.MANUAL + assert {item.side for item in first.items} == {TradeSide.BUY, TradeSide.SELL} + assert any(item.side is TradeSide.SELL and item.state is GridAlertState.REACHED for item in first.items) + assert len(first.newly_reached) == 1 + assert second.newly_reached == [] + + +def test_service_rearms_alert_only_after_price_leaves_near_zone(tmp_path): + service = TradingService(tmp_path / "grid.db") + service.ensure_defaults() + instrument = service.add_instrument(Instrument(id=None, code="510300", name="沪深300ETF")) + service.add_buy_grid_alert( + instrument.id, + target_price=Decimal("4.00"), + quantity=100, + ) + + def apply(price): + service.apply_quote_snapshots( + { + "510300": QuoteSnapshot( + symbol="sh510300", + code="510300", + name="沪深300ETF", + price=Decimal(price), + source="test", + ) + } + ) + return service.evaluate_grid_alerts() + + assert len(apply("4.00").newly_reached) == 1 + assert apply("4.01").newly_reached == [] + assert apply("4.00").newly_reached == [] + assert apply("4.10").newly_reached == [] + assert len(apply("4.00").newly_reached) == 1 + + +def test_reverse_sell_automatically_creates_buyback_alert(tmp_path): + service = TradingService(tmp_path / "grid.db", quote_provider=FakeQuoteProvider()) + service.ensure_defaults() + account = service.get_active_account() + instrument = service.add_instrument( + Instrument(id=None, code="510300", name="沪深300ETF", market="ETF") + ) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date.today(), + side=TradeSide.BUY, + price=Decimal("4.00"), + quantity=500, + trade_group=TradeGroup.BASE, + ) + ) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date.today(), + side=TradeSide.SELL, + price=Decimal("4.24"), + quantity=100, + trade_group=TradeGroup.OTHER, + grid_direction=GridDirection.REVERSE, + ) + ) + service.refresh_quotes() + + snapshot = service.evaluate_grid_alerts() + + [target] = snapshot.items + assert target.side is TradeSide.BUY + assert target.target_price == Decimal("4.12") + assert target.state is GridAlertState.REACHED diff --git a/tests/test_ui.py b/tests/test_ui.py index 958d324..89d2dda 100644 --- a/tests/test_ui.py +++ b/tests/test_ui.py @@ -1,7 +1,19 @@ from decimal import Decimal +from datetime import date, datetime +import threading import time -from grid_trading.domain.models import Instrument +from grid_trading.domain.models import ( + GridDirection, + GridAlertSource, + GridAlertState, + GridMonitorItem, + GridMonitorSnapshot, + Instrument, + Trade, + TradeGroup, + TradeSide, +) def test_formatters_render_money_percent_and_empty_values(): @@ -28,7 +40,14 @@ def test_main_window_can_be_constructed_offscreen(tmp_path, monkeypatch): assert window.windowTitle() == "Grid Trading Manager" assert window.holdings_table.columnCount() > 0 + assert window.holdings_table.columnCount() == 11 + assert "底仓" not in window.HOLDING_COLUMNS + assert "网格仓" not in window.HOLDING_COLUMNS + assert window.trades_table.columnCount() == 9 + assert window.TRADE_COLUMNS[:2] == ["代码", "名称"] + assert "分组" not in window.TRADE_COLUMNS assert any(button.text() == "刷新行情" for button in window.findChildren(QPushButton)) + assert any(button.text() == "删除标的" for button in window.findChildren(QPushButton)) summary_titles = [label.text() for label in window.findChildren(QLabel)] assert "账户权益" in summary_titles assert "总资产" not in summary_titles @@ -50,9 +69,10 @@ def test_main_window_contains_grid_level_table(tmp_path, monkeypatch): service = TradingService(tmp_path / "grid.db") window = MainWindow(service) - assert window.grid_levels_table.columnCount() == 7 + assert window.grid_levels_table.columnCount() == 9 + assert window.GRID_LEVEL_COLUMNS[:2] == ["代码", "名称"] tab_titles = _tab_titles(window.details_tabs) - assert tab_titles == ["网格档位", "待卖网格", "配对明细", "最近成交"] + assert tab_titles == ["网格档位", "未完成网格", "配对明细", "最近成交"] assert isinstance(window.details_tabs, QTabWidget) window.close() @@ -72,9 +92,11 @@ def test_main_window_contains_open_grid_lots_table(tmp_path, monkeypatch): service = TradingService(tmp_path / "grid.db") window = MainWindow(service) - assert window.open_grid_lots_table.columnCount() == 8 - assert "待卖网格" in _tab_titles(window.details_tabs) - assert window.grid_matches_table.columnCount() == 9 + assert window.open_grid_lots_table.columnCount() == 11 + assert window.OPEN_GRID_LOT_COLUMNS[:2] == ["代码", "名称"] + assert "未完成网格" in _tab_titles(window.details_tabs) + assert window.grid_matches_table.columnCount() == 13 + assert window.GRID_MATCH_COLUMNS[:2] == ["代码", "名称"] assert "配对明细" in _tab_titles(window.details_tabs) window.close() @@ -82,6 +104,98 @@ def test_main_window_contains_open_grid_lots_table(tmp_path, monkeypatch): app.processEvents() +def test_detail_tables_show_and_follow_selected_instrument(tmp_path, monkeypatch): + monkeypatch.setenv("QT_QPA_PLATFORM", "offscreen") + + from PySide6.QtWidgets import QApplication + + from grid_trading.services.trading_service import TradingService + from grid_trading.ui.main_window import MainWindow + + app = QApplication.instance() or QApplication([]) + service = TradingService(tmp_path / "grid.db") + service.ensure_defaults() + account = service.get_active_account() + first = service.add_instrument(Instrument(id=None, code="000001", name="平安银行")) + second = service.add_instrument(Instrument(id=None, code="600000", name="浦发银行")) + for instrument in (first, second): + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=instrument.id, + trade_date=date(2026, 7, 27), + side=TradeSide.BUY, + price=Decimal("10"), + quantity=200, + trade_group=TradeGroup.GRID, + grid_direction=GridDirection.FORWARD, + ) + ) + service.save_trade( + Trade( + id=None, + account_id=account.id, + instrument_id=first.id, + trade_date=date(2026, 7, 28), + side=TradeSide.SELL, + price=Decimal("10.3"), + quantity=100, + trade_group=TradeGroup.GRID, + grid_direction=GridDirection.FORWARD, + ) + ) + window = MainWindow(service) + + window.holdings_table.selectRow(0) + app.processEvents() + assert window.trades_table.item(0, 0).text() == "000001" + assert window.trades_table.item(0, 1).text() == "平安银行" + assert window.open_grid_lots_table.item(0, 0).text() == "000001" + assert window.open_grid_lots_table.item(0, 1).text() == "平安银行" + assert window.grid_matches_table.item(0, 0).text() == "000001" + assert window.grid_matches_table.item(0, 1).text() == "平安银行" + + window.holdings_table.selectRow(1) + app.processEvents() + assert window.trades_table.item(0, 0).text() == "600000" + assert window.trades_table.item(0, 1).text() == "浦发银行" + assert window.open_grid_lots_table.item(0, 0).text() == "600000" + assert window.open_grid_lots_table.item(0, 1).text() == "浦发银行" + + window.close() + service.close() + app.processEvents() + + +def test_main_window_deletes_selected_instrument(tmp_path, monkeypatch): + monkeypatch.setenv("QT_QPA_PLATFORM", "offscreen") + + from PySide6.QtWidgets import QApplication, QMessageBox + + from grid_trading.services.trading_service import TradingService + from grid_trading.ui.main_window import MainWindow + + app = QApplication.instance() or QApplication([]) + service = TradingService(tmp_path / "grid.db") + instrument = service.add_instrument(Instrument(id=None, code="600000", name="浦发银行")) + window = MainWindow(service) + window.holdings_table.selectRow(0) + monkeypatch.setattr( + QMessageBox, + "question", + lambda *args, **kwargs: QMessageBox.StandardButton.Yes, + ) + + window._delete_selected_instrument() + + assert service.list_instruments() == [] + assert service.repository.get_instrument(instrument.id) is None + window.close() + service.close() + app.processEvents() + + def test_main_window_applies_light_theme(tmp_path, monkeypatch): monkeypatch.setenv("QT_QPA_PLATFORM", "offscreen") @@ -144,8 +258,8 @@ def test_profit_and_loss_cells_use_a_share_colors(tmp_path, monkeypatch): window._fill_holdings_table() window.holdings_table.blockSignals(False) - profit_item = window.holdings_table.item(0, 10) - loss_item = window.holdings_table.item(0, 11) + profit_item = window.holdings_table.item(0, 8) + loss_item = window.holdings_table.item(0, 9) assert profit_item.foreground().color() == QColor("#c62828") assert profit_item.font().bold() assert loss_item.foreground().color() == QColor("#2e7d32") @@ -210,12 +324,56 @@ def test_trade_dialog_labels_price_as_trade_price(tmp_path, monkeypatch): labels = [label.text() for label in dialog.findChildren(QLabel)] assert "成交价" in labels + assert "交易类型" in labels + assert "分组" not in labels + assert not hasattr(dialog, "group_edit") + assert dialog.to_trade().trade_group is TradeGroup.OTHER dialog.close() service.close() app.processEvents() +def test_floating_monitor_renders_reached_target_offscreen(monkeypatch): + monkeypatch.setenv("QT_QPA_PLATFORM", "offscreen") + + from PySide6.QtWidgets import QApplication + + from grid_trading.ui.floating_monitor import FloatingMonitorWindow + + app = QApplication.instance() or QApplication([]) + window = FloatingMonitorWindow() + window.update_snapshot( + GridMonitorSnapshot( + items=[ + GridMonitorItem( + target_key="manual:test", + instrument_id=1, + code="510300", + name="沪深300ETF", + side=TradeSide.BUY, + target_price=Decimal("3.88"), + quantity=1200, + current_price=Decimal("3.87"), + state=GridAlertState.REACHED, + distance_pct=Decimal("-0.0025"), + source=GridAlertSource.MANUAL, + ) + ], + newly_reached=[], + evaluated_at=datetime(2026, 7, 17, 10, 30), + ) + ) + + assert window.table.rowCount() == 1 + assert window.table.item(0, 5).text() == "已到价" + window.table.selectRow(0) + assert window.remove_button.isEnabled() + + window.close_permanently() + app.processEvents() + + def _tab_titles(tabs): return [tabs.tabText(index) for index in range(tabs.count())] @@ -246,12 +404,63 @@ def test_quote_refresh_does_not_block_main_window(tmp_path, monkeypatch): assert elapsed < 0.15 deadline = time.perf_counter() + 2 - while getattr(window, "_quote_thread", None) is not None and time.perf_counter() < deadline: + while window.quote_monitor.is_refreshing and time.perf_counter() < deadline: app.processEvents() time.sleep(0.01) - assert getattr(window, "_quote_thread", None) is None + assert not window.quote_monitor.is_refreshing window.close() service.close() app.processEvents() + + +def test_close_during_quote_refresh_does_not_block_main_window(tmp_path, monkeypatch): + monkeypatch.setenv("QT_QPA_PLATFORM", "offscreen") + + from PySide6.QtWidgets import QApplication + + from grid_trading.services.trading_service import TradingService + from grid_trading.ui.main_window import MainWindow + + request_started = threading.Event() + release_request = threading.Event() + + class BlockingQuoteProvider: + def fetch_quotes(self, instruments): + request_started.set() + release_request.wait(1) + return {} + + app = QApplication.instance() or QApplication([]) + service = TradingService(tmp_path / "grid.db", quote_provider=BlockingQuoteProvider()) + service.ensure_defaults() + service.add_instrument(Instrument(id=None, code="000001", name="Ping An Bank")) + window = MainWindow(service) + window.show() + window._refresh_quotes() + + deadline = time.perf_counter() + 1 + while not request_started.is_set() and time.perf_counter() < deadline: + app.processEvents() + time.sleep(0.01) + assert request_started.is_set() + + started_at = time.perf_counter() + window.close() + elapsed = time.perf_counter() - started_at + + assert elapsed < 0.15 + assert not window.isVisible() + assert window.quote_monitor.is_refreshing + + release_request.set() + deadline = time.perf_counter() + 2 + while (window.quote_monitor.is_refreshing or window._close_pending) and time.perf_counter() < deadline: + app.processEvents() + time.sleep(0.01) + + assert not window.quote_monitor.is_refreshing + assert not window._close_pending + service.close() + app.processEvents()