hahaju/aiagents-stock
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

增加miniqmt接口预留

Browse Source
This commit is contained in:
oficcejo
2025-10-04 11:52:11 +08:00
parent e0e3bfc7f7
commit 1a73483f8e
9 changed files with 1402 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+1 -2
View File
@@ -6,7 +6,6 @@
/test_pe_pb.py
/venv
/__pycache__
/stock_analysis.db
/stock_monitor.db
/*.db
# 环境变量文件
.env
MINIQMT_INTEGRATION_GUIDE.md
+257
View File
@@ -0,0 +1,257 @@
# MiniQMT量化交易集成指南
## 📚 概述
本系统已为监测板块增加MiniQMT量化交易预留接口，支持自动化量化交易功能。该功能可以在监测到特定价格条件时，自动执行买卖操作。
## 🚀 功能特性
### 核心功能
- ✅ **自动交易执行**：监测触发后自动下单
- ✅ **仓位管理**：智能仓位控制和风险管理
- ✅ **多种订单类型**：市价单、限价单、止损单等
- ✅ **持仓监控**：实时查看持仓和盈亏
- ✅ **风险控制**：自动止损、止盈功能
- ✅ **策略配置**：灵活的量化策略参数设置
### 交易信号类型
1. **进场信号（Entry）**：价格进入预设进场区间时触发买入
2. **止盈信号（Take Profit）**：价格达到止盈位时触发卖出
3. **止损信号（Stop Loss）**：价格达到止损位时紧急止损
## ⚙️ 配置说明
### 1. 环境变量配置
在项目根目录的 `.env` 文件中添加以下配置：
```bash
# MiniQMT量化交易配置
MINIQMT_ENABLED=true # 是否启用MiniQMT（true/false）
MINIQMT_ACCOUNT_ID=your_account_id # 交易账户ID
MINIQMT_HOST=127.0.0.1 # MiniQMT服务地址
MINIQMT_PORT=58610 # MiniQMT服务端口
```
### 2. 代码配置
配置会自动从环境变量加载，也可以在 `config.py` 中直接修改：
```python
MINIQMT_CONFIG = {
'enabled': True, # 启用MiniQMT
'account_id': 'your_account_id', # 账户ID
'host': '127.0.0.1', # 服务地址
'port': 58610, # 服务端口
}
```
## 📖 使用指南
### 第一步：安装MiniQMT
1. 下载并安装MiniQMT客户端
2. 启动MiniQMT客户端
3. 登录你的交易账户
4. 确保API服务已启动
### 第二步：启用量化功能
1. 进入系统的"实时监测"板块
2. 在底部找到"MiniQMT量化交易"状态面板
3. 点击"连接MiniQMT"按钮
4. 等待连接成功提示
### 第三步：添加量化监测股票
#### 方式一：添加新股票时启用
1. 点击"添加股票监测"
2. 填写股票信息和关键位置
3. 在"量化交易（MiniQMT）"区域勾选"启用量化自动交易"
4. 配置量化参数：
- **最大仓位比例**：单只股票最大占总资金的比例（建议0.1-0.3）
- **自动止损**：是否在触发止损位时自动卖出
- **自动止盈**：是否在触发止盈位时自动卖出
5. 点击"添加监测"
#### 方式二：编辑现有股票启用
1. 在监测股票列表中找到目标股票
2. 点击"编辑"按钮
3. 勾选"启用量化自动交易"
4. 配置量化参数
5. 点击"保存修改"
### 第四步：监控交易执行
系统会在以下情况自动执行交易：
1. **进场买入**
- 条件：价格进入进场区间
- 动作：按配置的仓位比例自动买入
- 订单类型：限价单
2. **止盈卖出**
- 条件：价格达到止盈位
- 动作：卖出全部持仓
- 订单类型：限价单
3. **止损卖出**
- 条件：价格达到止损位
- 动作：紧急卖出全部持仓
- 订单类型：市价单（快速成交）
## 🔧 接口说明
### MiniQMTInterface 类
#### 主要方法
```python
# 连接到MiniQMT
success, msg = miniqmt.connect(account_id)
# 断开连接
miniqmt.disconnect()
# 获取账户信息
account_info = miniqmt.get_account_info()
# 获取持仓
positions = miniqmt.get_positions()
# 下单
success, msg, order_id = miniqmt.place_order(
symbol='000001',
action=TradeAction.BUY,
quantity=100,
price=10.50,
order_type=OrderType.LIMIT
)
# 撤销订单
success, msg = miniqmt.cancel_order(order_id)
# 执行策略信号（自动调用）
success, msg = miniqmt.execute_strategy_signal(
stock_id=1,
symbol='000001',
signal={'type': 'entry', 'price': 10.5},
position_size=0.2
)
```
### 量化策略配置
```python
quant_config = {
'max_position_pct': 0.2, # 最大仓位比例（20%）
'auto_stop_loss': True, # 自动止损
'auto_take_profit': True, # 自动止盈
'min_trade_amount': 5000, # 最小交易金额
}
```
## 💡 最佳实践
### 1. 仓位管理建议
- 单只股票仓位不超过20%
- 总仓位不超过80%
- 保留至少20%现金应对突发情况
### 2. 风险控制建议
- 必须设置止损位（建议5-10%）
- 设置合理的止盈位（建议10-20%）
- 启用自动止损功能
### 3. 监测参数建议
- 监测间隔：5-30分钟（日内交易）
- 进场区间：设置合理的价格范围
- 及时更新关键位置
### 4. 测试建议
- 先用小仓位测试
- 验证连接和下单功能
- 确认止损止盈逻辑正确
## ⚠️ 风险提示
### 重要警告
1. **实盘交易风险**：自动交易涉及真实资金，请谨慎使用
2. **网络延迟**：可能导致下单延迟或失败
3. **系统故障**：监测服务中断可能错过交易时机
4. **价格滑点**：实际成交价可能与预期不同
5. **市场风险**：量化交易无法规避市场系统性风险
### 安全建议
1. ✅ 使用专门的测试账户进行测试
2. ✅ 设置合理的单笔交易限额
3. ✅ 定期检查持仓和资金状态
4. ✅ 保持人工监控，不要完全依赖自动化
5. ✅ 及时处理异常通知和错误
## 🛠️ 故障排除
### 连接失败
- 检查MiniQMT客户端是否启动
- 确认账户已登录
- 验证账户ID是否正确
- 检查网络连接
### 下单失败
- 检查资金是否充足
- 确认股票代码格式正确
- 验证交易时间（交易日9:30-15:00）
- 检查仓位限制
### 交易未执行
- 确认量化功能已启用
- 检查MiniQMT连接状态
- 验证监测服务是否运行
- 查看通知记录中的错误信息
## 📊 技术架构
```
监测服务 (monitor_service.py)
↓
价格触发检测 (_check_trigger_conditions)
↓
量化交易执行 (_execute_quant_trade)
↓
MiniQMT接口 (miniqmt_interface.py)
↓
订单执行 (execute_strategy_signal)
↓
MiniQMT客户端 (真实交易)
```
## 🔄 更新日志
### v1.0.0 (当前版本)
- ✅ 实现MiniQMT预留接口
- ✅ 支持自动买卖交易
- ✅ 集成监测触发机制
- ✅ 添加量化配置界面
- ✅ 实现仓位管理功能
- ✅ 支持多种订单类型
### 未来规划
- 🔜 支持更多交易策略
- 🔜 添加回测功能
- 🔜 优化仓位算法
- 🔜 增加风控规则
- 🔜 支持批量操作
## 📞 技术支持
如有问题，请查看：
1. 系统日志输出
2. MiniQMT客户端日志
3. 通知记录中的详细信息
---
**免责声明**：本系统仅供学习和研究使用，不构成任何投资建议。量化交易涉及真实资金风险，请谨慎使用并自行承担投资风险。
README.md
+38
View File
@@ -43,6 +43,14 @@
- **多种通知方式**：网页提醒 + 邮件通知
- **卡片式管理**：直观的股票监测卡片展示
- **完整功能**：添加、编辑、删除、启停、通知开关
### 🤖 量化交易功能（MiniQMT集成）
- **自动交易执行**：监测触发后自动下单
- **智能仓位管理**：灵活配置单股最大仓位比例
- **多种订单类型**：市价单、限价单、止损单支持
- **风险控制**：自动止损、止盈功能
- **持仓监控**：实时查看持仓和盈亏
- **预留接口**：完整的MiniQMT对接接口，可对接真实交易
<img width="1910" height="923" alt="image" src="https://github.com/user-attachments/assets/1e93f870-7846-426c-9c22-15fdfaf1f1d0" />
<img width="1910" height="923" alt="image" src="https://github.com/user-attachments/assets/a85defbf-321a-4fe2-b491-6855f2aa366c" />
@@ -99,6 +107,12 @@ SMTP_PORT=587
EMAIL_FROM=your_email@qq.com
EMAIL_PASSWORD=your_authorization_code
EMAIL_TO=receiver@example.com
# MiniQMT量化交易配置（可选）
MINIQMT_ENABLED=false
MINIQMT_ACCOUNT_ID=your_account_id
MINIQMT_HOST=127.0.0.1
MINIQMT_PORT=58610
```
@@ -257,6 +271,7 @@ AI股票分析系统
├── monitor_service.py # 监测服务后台
├── monitor_db.py # 监测数据库管理
├── notification_service.py # 通知服务（邮件/界面）
├── miniqmt_interface.py # MiniQMT量化交易接口 ⭐️
├── pdf_generator.py # PDF报告生成
├── database.py # 分析记录数据库
├── config.py # 配置文件
@@ -315,6 +330,15 @@ AI股票分析系统
- 通知历史管理
- 配置测试功能
#### 🤖 量化交易模块 (miniqmt_interface.py) ⭐️ 新增
- MiniQMT接口对接
- 自动交易执行
- 仓位管理
- 风险控制
- 订单管理
- 持仓监控
- 预留接口实现
#### 📄 PDF生成模块 (pdf_generator.py)
- 专业分析报告生成
- 中文字体支持
@@ -410,6 +434,20 @@ DEFAULT_INTERVAL = "1d" # 默认数据间隔
- 查看终端输出的详细错误信息
- 尝试重新启动应用
7. **MiniQMT连接失败**
- 确认MiniQMT客户端已启动
- 检查账户已登录
- 验证账户ID配置正确
- 确认网络连接正常
- 查看 `MINIQMT_INTEGRATION_GUIDE.md` 详细指南
8. **量化交易未执行**
- 确认量化功能已启用
- 检查MiniQMT连接状态
- 验证监测服务是否运行
- 查看通知记录中的错误信息
- 确认交易时间在交易日内
### 日志调试
系统运行时会在控制台输出详细日志，可用于问题诊断。如遇到错误，请查看终端输出。
config.py
+8
View File
@@ -14,3 +14,11 @@ TUSHARE_TOKEN = os.getenv("TUSHARE_TOKEN", "")
# 股票数据源配置
DEFAULT_PERIOD = "1y" # 默认获取1年数据
DEFAULT_INTERVAL = "1d" # 默认日线数据
# MiniQMT量化交易配置
MINIQMT_CONFIG = {
'enabled': os.getenv("MINIQMT_ENABLED", "false").lower() == "true",
'account_id': os.getenv("MINIQMT_ACCOUNT_ID", ""),
'host': os.getenv("MINIQMT_HOST", "127.0.0.1"),
'port': int(os.getenv("MINIQMT_PORT", "58610")),
}
miniqmt_interface.py
+615
View File
@@ -0,0 +1,615 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MiniQMT量化交易接口
为监测板块提供量化交易功能预留接口
支持自动下单、仓位管理、策略执行等功能
"""
import json
from typing import Dict, List, Optional, Tuple
from datetime import datetime
from enum import Enum
class TradeAction(Enum):
"""交易动作枚举"""
BUY = "buy" # 买入
SELL = "sell" # 卖出
HOLD = "hold" # 持有
class OrderType(Enum):
"""订单类型枚举"""
MARKET = "market" # 市价单
LIMIT = "limit" # 限价单
STOP = "stop" # 止损单
STOP_LIMIT = "stop_limit" # 止损限价单
class PositionSide(Enum):
"""持仓方向枚举"""
LONG = "long" # 多头
SHORT = "short" # 空头
NONE = "none" # 无持仓
class MiniQMTInterface:
"""
MiniQMT量化交易接口类
提供与MiniQMT的对接功能
"""
def __init__(self, config: Dict = None):
"""
初始化接口
Args:
config: 配置字典，包含账户信息、连接参数等
"""
self.config = config or {}
self.connected = False
self.account_id = None
self.positions = {} # 持仓信息
self.orders = {} # 订单信息
self.enabled = self.config.get('enabled', False)
def connect(self, account_id: str = None) -> Tuple[bool, str]:
"""
连接到MiniQMT
Args:
account_id: 交易账户ID
Returns:
(成功标志, 消息)
"""
try:
# TODO: 实现与MiniQMT的实际连接逻辑
self.account_id = account_id or self.config.get('account_id')
if not self.account_id:
return False, "账户ID未配置"
# 预留接口：连接MiniQMT
# from xtquant import xtdata
# xtdata.connect()
self.connected = True
return True, f"已连接到账户 {self.account_id}"
except Exception as e:
self.connected = False
return False, f"连接失败: {str(e)}"
def disconnect(self) -> bool:
"""断开连接"""
try:
# TODO: 实现断开连接逻辑
self.connected = False
return True
except Exception as e:
print(f"断开连接失败: {e}")
return False
def is_connected(self) -> bool:
"""检查连接状态"""
return self.connected and self.enabled
def get_account_info(self) -> Dict:
"""
获取账户信息
Returns:
账户信息字典
"""
if not self.is_connected():
return {
'error': '未连接到MiniQMT',
'connected': False
}
# TODO: 实现获取账户信息的逻辑
# 预留接口：从MiniQMT获取账户信息
return {
'account_id': self.account_id,
'total_assets': 0.0, # 总资产
'available_cash': 0.0, # 可用资金
'market_value': 0.0, # 持仓市值
'frozen_cash': 0.0, # 冻结资金
'profit_loss': 0.0, # 盈亏
'connected': True
}
def get_positions(self) -> List[Dict]:
"""
获取当前持仓
Returns:
持仓列表
"""
if not self.is_connected():
return []
# TODO: 实现获取持仓的逻辑
# 预留接口：从MiniQMT获取持仓信息
# from xtquant import xttrader
# positions = xttrader.query_stock_positions(self.account_id)
return list(self.positions.values())
def get_position(self, symbol: str) -> Optional[Dict]:
"""
获取指定股票的持仓
Args:
symbol: 股票代码
Returns:
持仓信息字典，无持仓返回None
"""
if not self.is_connected():
return None
return self.positions.get(symbol)
def place_order(self,
symbol: str,
action: TradeAction,
quantity: int,
price: float = None,
order_type: OrderType = OrderType.MARKET) -> Tuple[bool, str, str]:
"""
下单
Args:
symbol: 股票代码
action: 交易动作
quantity: 数量
price: 价格（限价单时需要）
order_type: 订单类型
Returns:
(成功标志, 消息, 订单ID)
"""
if not self.is_connected():
return False, "未连接到MiniQMT", ""
# 参数验证
if quantity <= 0:
return False, "数量必须大于0", ""
if order_type == OrderType.LIMIT and price is None:
return False, "限价单必须指定价格", ""
try:
# TODO: 实现实际下单逻辑
# 预留接口：通过MiniQMT下单
# from xtquant import xttrader
# if action == TradeAction.BUY:
# order_id = xttrader.order_stock(
# self.account_id, symbol,
# xtconstant.STOCK_BUY, quantity,
# xtconstant.FIX_PRICE, price
# )
# elif action == TradeAction.SELL:
# order_id = xttrader.order_stock(
# self.account_id, symbol,
# xtconstant.STOCK_SELL, quantity,
# xtconstant.FIX_PRICE, price
# )
# 模拟订单ID
order_id = f"ORD_{symbol}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
# 记录订单
self.orders[order_id] = {
'order_id': order_id,
'symbol': symbol,
'action': action.value,
'quantity': quantity,
'price': price,
'order_type': order_type.value,
'status': 'submitted',
'create_time': datetime.now().isoformat()
}
return True, f"订单已提交: {order_id}", order_id
except Exception as e:
return False, f"下单失败: {str(e)}", ""
def cancel_order(self, order_id: str) -> Tuple[bool, str]:
"""
撤销订单
Args:
order_id: 订单ID
Returns:
(成功标志, 消息)
"""
if not self.is_connected():
return False, "未连接到MiniQMT"
try:
# TODO: 实现撤单逻辑
# 预留接口：通过MiniQMT撤单
# from xtquant import xttrader
# xttrader.cancel_order(self.account_id, order_id)
if order_id in self.orders:
self.orders[order_id]['status'] = 'cancelled'
return True, f"订单 {order_id} 已撤销"
else:
return False, "订单不存在"
except Exception as e:
return False, f"撤单失败: {str(e)}"
def get_order_status(self, order_id: str) -> Optional[Dict]:
"""
查询订单状态
Args:
order_id: 订单ID
Returns:
订单信息字典
"""
if not self.is_connected():
return None
# TODO: 实现查询订单状态逻辑
return self.orders.get(order_id)
def get_all_orders(self) -> List[Dict]:
"""
获取所有订单
Returns:
订单列表
"""
if not self.is_connected():
return []
return list(self.orders.values())
def execute_strategy_signal(self,
stock_id: int,
symbol: str,
signal: Dict,
position_size: float = 0.2) -> Tuple[bool, str]:
"""
执行策略信号
根据监测触发的信号自动执行交易
Args:
stock_id: 监测股票ID
symbol: 股票代码
signal: 信号字典，包含type, price, message等
position_size: 仓位比例（默认20%）
Returns:
(成功标志, 执行结果消息)
"""
if not self.is_connected():
return False, "MiniQMT未连接，无法执行交易"
signal_type = signal.get('type')
current_price = signal.get('price')
try:
# 获取账户信息
account_info = self.get_account_info()
available_cash = account_info.get('available_cash', 0)
# 根据信号类型执行不同操作
if signal_type == 'entry':
# 进场信号 - 买入
buy_amount = available_cash * position_size
quantity = int(buy_amount / current_price / 100) * 100 # A股100股为一手
if quantity > 0:
success, msg, order_id = self.place_order(
symbol=symbol,
action=TradeAction.BUY,
quantity=quantity,
price=current_price,
order_type=OrderType.LIMIT
)
if success:
return True, f"进场买入成功: {quantity}股 @ ¥{current_price}, 订单号: {order_id}"
else:
return False, f"进场买入失败: {msg}"
else:
return False, "可用资金不足，无法买入"
elif signal_type == 'take_profit':
# 止盈信号 - 卖出
position = self.get_position(symbol)
if position and position.get('quantity', 0) > 0:
quantity = position['quantity']
success, msg, order_id = self.place_order(
symbol=symbol,
action=TradeAction.SELL,
quantity=quantity,
price=current_price,
order_type=OrderType.LIMIT
)
if success:
return True, f"止盈卖出成功: {quantity}股 @ ¥{current_price}, 订单号: {order_id}"
else:
return False, f"止盈卖出失败: {msg}"
else:
return False, "无持仓，无需卖出"
elif signal_type == 'stop_loss':
# 止损信号 - 紧急卖出
position = self.get_position(symbol)
if position and position.get('quantity', 0) > 0:
quantity = position['quantity']
# 止损使用市价单，快速成交
success, msg, order_id = self.place_order(
symbol=symbol,
action=TradeAction.SELL,
quantity=quantity,
order_type=OrderType.MARKET
)
if success:
return True, f"止损卖出成功: {quantity}股, 订单号: {order_id}"
else:
return False, f"止损卖出失败: {msg}"
else:
return False, "无持仓，无需止损"
else:
return False, f"未知的信号类型: {signal_type}"
except Exception as e:
return False, f"执行策略信号失败: {str(e)}"
def calculate_position_size(self,
symbol: str,
price: float,
max_position_pct: float = 0.2,
max_risk_pct: float = 0.02) -> int:
"""
计算建议仓位大小
Args:
symbol: 股票代码
price: 买入价格
max_position_pct: 最大仓位比例（默认20%）
max_risk_pct: 最大风险比例（默认2%）
Returns:
建议买入数量（股）
"""
if not self.is_connected():
return 0
try:
account_info = self.get_account_info()
total_assets = account_info.get('total_assets', 0)
available_cash = account_info.get('available_cash', 0)
# 基于最大仓位计算
max_position_value = total_assets * max_position_pct
# 基于可用资金计算
max_buy_value = min(max_position_value, available_cash)
# 计算股数（A股100股为一手）
quantity = int(max_buy_value / price / 100) * 100
return quantity
except Exception as e:
print(f"计算仓位失败: {e}")
return 0
def get_risk_metrics(self, symbol: str) -> Dict:
"""
获取风险指标
Args:
symbol: 股票代码
Returns:
风险指标字典
"""
if not self.is_connected():
return {}
position = self.get_position(symbol)
if not position:
return {
'has_position': False,
'profit_loss': 0,
'profit_loss_pct': 0,
'risk_exposure': 0
}
# 计算盈亏
cost_price = position.get('cost_price', 0)
current_price = position.get('current_price', 0)
quantity = position.get('quantity', 0)
profit_loss = (current_price - cost_price) * quantity
profit_loss_pct = (current_price - cost_price) / cost_price * 100 if cost_price > 0 else 0
# 计算风险敞口
account_info = self.get_account_info()
total_assets = account_info.get('total_assets', 0)
position_value = current_price * quantity
risk_exposure = position_value / total_assets if total_assets > 0 else 0
return {
'has_position': True,
'quantity': quantity,
'cost_price': cost_price,
'current_price': current_price,
'position_value': position_value,
'profit_loss': profit_loss,
'profit_loss_pct': profit_loss_pct,
'risk_exposure': risk_exposure
}
def validate_trade(self,
symbol: str,
action: TradeAction,
quantity: int,
price: float = None) -> Tuple[bool, str]:
"""
验证交易是否可行
Args:
symbol: 股票代码
action: 交易动作
quantity: 数量
price: 价格
Returns:
(可行标志, 原因)
"""
if not self.is_connected():
return False, "未连接到MiniQMT"
# 检查数量
if quantity <= 0:
return False, "数量必须大于0"
if quantity % 100 != 0:
return False, "A股必须以100股（1手）为单位交易"
# 获取账户信息
account_info = self.get_account_info()
if action == TradeAction.BUY:
# 买入验证
if price is None:
return False, "买入需要指定价格"
required_cash = quantity * price * 1.001 # 考虑手续费
available_cash = account_info.get('available_cash', 0)
if required_cash > available_cash:
return False, f"资金不足: 需要¥{required_cash:.2f}, 可用¥{available_cash:.2f}"
return True, "验证通过"
elif action == TradeAction.SELL:
# 卖出验证
position = self.get_position(symbol)
if not position:
return False, "无持仓，无法卖出"
available_quantity = position.get('quantity', 0)
if quantity > available_quantity:
return False, f"持仓不足: 需要{quantity}股, 可用{available_quantity}股"
return True, "验证通过"
return False, "未知的交易动作"
class QuantStrategyConfig:
"""量化策略配置"""
def __init__(self):
self.auto_trade_enabled = False # 是否启用自动交易
self.max_position_pct = 0.2 # 最大单个仓位比例
self.max_total_position_pct = 0.8 # 最大总仓位比例
self.max_risk_per_trade = 0.02 # 单笔最大风险比例
self.min_trade_amount = 5000 # 最小交易金额
self.use_stop_loss = True # 是否使用止损
self.use_take_profit = True # 是否使用止盈
self.trailing_stop_pct = 0.05 # 移动止损比例
def to_dict(self) -> Dict:
"""转换为字典"""
return {
'auto_trade_enabled': self.auto_trade_enabled,
'max_position_pct': self.max_position_pct,
'max_total_position_pct': self.max_total_position_pct,
'max_risk_per_trade': self.max_risk_per_trade,
'min_trade_amount': self.min_trade_amount,
'use_stop_loss': self.use_stop_loss,
'use_take_profit': self.use_take_profit,
'trailing_stop_pct': self.trailing_stop_pct
}
@classmethod
def from_dict(cls, data: Dict):
"""从字典创建"""
config = cls()
config.auto_trade_enabled = data.get('auto_trade_enabled', False)
config.max_position_pct = data.get('max_position_pct', 0.2)
config.max_total_position_pct = data.get('max_total_position_pct', 0.8)
config.max_risk_per_trade = data.get('max_risk_per_trade', 0.02)
config.min_trade_amount = data.get('min_trade_amount', 5000)
config.use_stop_loss = data.get('use_stop_loss', True)
config.use_take_profit = data.get('use_take_profit', True)
config.trailing_stop_pct = data.get('trailing_stop_pct', 0.05)
return config
# 全局MiniQMT接口实例
miniqmt = MiniQMTInterface()
def init_miniqmt(config: Dict = None) -> Tuple[bool, str]:
"""
初始化MiniQMT接口
Args:
config: 配置字典
Returns:
(成功标志, 消息)
"""
global miniqmt
try:
# 从配置文件或环境变量读取配置
if config is None:
try:
from config import MINIQMT_CONFIG
config = MINIQMT_CONFIG
except ImportError:
config = {
'enabled': False,
'account_id': None
}
miniqmt = MiniQMTInterface(config)
# 如果启用，尝试连接
if config.get('enabled', False):
success, msg = miniqmt.connect()
return success, msg
else:
return True, "MiniQMT接口已初始化（未启用）"
except Exception as e:
return False, f"初始化MiniQMT接口失败: {str(e)}"
def get_miniqmt_status() -> Dict:
"""
获取MiniQMT接口状态
Returns:
状态字典
"""
global miniqmt
return {
'enabled': miniqmt.enabled,
'connected': miniqmt.connected,
'account_id': miniqmt.account_id,
'ready': miniqmt.is_connected()
}
monitor_db.py
+45 -16
View File
@@ -29,6 +29,8 @@ class StockMonitorDatabase:
last_checked TIMESTAMP,
check_interval INTEGER DEFAULT 30, -- 分钟
notification_enabled BOOLEAN DEFAULT TRUE,
quant_enabled BOOLEAN DEFAULT FALSE, -- 量化交易开关
quant_config TEXT, -- 量化配置JSON
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
@@ -64,16 +66,22 @@ class StockMonitorDatabase:
def add_monitored_stock(self, symbol: str, name: str, rating: str,
entry_range: Dict, take_profit: float,
stop_loss: float, check_interval: int = 30,
notification_enabled: bool = True) -> int:
notification_enabled: bool = True,
quant_enabled: bool = False,
quant_config: Dict = None) -> int:
"""添加监测股票"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
quant_config_json = json.dumps(quant_config) if quant_config else None
cursor.execute('''
INSERT INTO monitored_stocks
(symbol, name, rating, entry_range, take_profit, stop_loss, check_interval, notification_enabled)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
''', (symbol, name, rating, json.dumps(entry_range), take_profit, stop_loss, check_interval, notification_enabled))
(symbol, name, rating, entry_range, take_profit, stop_loss, check_interval,
notification_enabled, quant_enabled, quant_config)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
''', (symbol, name, rating, json.dumps(entry_range), take_profit, stop_loss,
check_interval, notification_enabled, quant_enabled, quant_config_json))
stock_id = cursor.lastrowid
conn.commit()
@@ -89,13 +97,14 @@ class StockMonitorDatabase:
cursor.execute('''
SELECT id, symbol, name, rating, entry_range, take_profit, stop_loss,
current_price, last_checked, check_interval, notification_enabled,
created_at, updated_at
quant_enabled, quant_config, created_at, updated_at
FROM monitored_stocks
ORDER BY created_at DESC
''')
stocks = []
for row in cursor.fetchall():
quant_config = json.loads(row[12]) if row[12] else None
stocks.append({
'id': row[0],
'symbol': row[1],
@@ -108,8 +117,10 @@ class StockMonitorDatabase:
'last_checked': row[8],
'check_interval': row[9],
'notification_enabled': bool(row[10]),
'created_at': row[11],
'updated_at': row[12]
'quant_enabled': bool(row[11]),
'quant_config': quant_config,
'created_at': row[13],
'updated_at': row[14]
})
conn.close()
@@ -235,17 +246,31 @@ class StockMonitorDatabase:
def update_monitored_stock(self, stock_id: int, rating: str, entry_range: Dict,
take_profit: float, stop_loss: float,
check_interval: int, notification_enabled: bool):
check_interval: int, notification_enabled: bool,
quant_enabled: bool = None,
quant_config: Dict = None):
"""更新监测股票"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('''
UPDATE monitored_stocks
SET rating = ?, entry_range = ?, take_profit = ?, stop_loss = ?,
check_interval = ?, notification_enabled = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (rating, json.dumps(entry_range), take_profit, stop_loss, check_interval, notification_enabled, stock_id))
if quant_enabled is not None and quant_config is not None:
quant_config_json = json.dumps(quant_config) if quant_config else None
cursor.execute('''
UPDATE monitored_stocks
SET rating = ?, entry_range = ?, take_profit = ?, stop_loss = ?,
check_interval = ?, notification_enabled = ?,
quant_enabled = ?, quant_config = ?,
updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (rating, json.dumps(entry_range), take_profit, stop_loss,
check_interval, notification_enabled, quant_enabled, quant_config_json, stock_id))
else:
cursor.execute('''
UPDATE monitored_stocks
SET rating = ?, entry_range = ?, take_profit = ?, stop_loss = ?,
check_interval = ?, notification_enabled = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
''', (rating, json.dumps(entry_range), take_profit, stop_loss, check_interval, notification_enabled, stock_id))
conn.commit()
conn.close()
@@ -275,7 +300,8 @@ class StockMonitorDatabase:
cursor.execute('''
SELECT id, symbol, name, rating, entry_range, take_profit, stop_loss,
current_price, last_checked, check_interval, notification_enabled
current_price, last_checked, check_interval, notification_enabled,
quant_enabled, quant_config
FROM monitored_stocks WHERE id = ?
''', (stock_id,))
@@ -283,6 +309,7 @@ class StockMonitorDatabase:
conn.close()
if row:
quant_config = json.loads(row[12]) if row[12] else None
return {
'id': row[0],
'symbol': row[1],
@@ -294,7 +321,9 @@ class StockMonitorDatabase:
'current_price': row[7],
'last_checked': row[8],
'check_interval': row[9],
'notification_enabled': bool(row[10])
'notification_enabled': bool(row[10]),
'quant_enabled': bool(row[11]),
'quant_config': quant_config
}
return None
monitor_manager.py
+145 -4
View File
@@ -17,6 +17,7 @@ from monitor_db import monitor_db
from monitor_service import monitor_service
from notification_service import notification_service
from stock_data import StockDataFetcher
from miniqmt_interface import miniqmt, get_miniqmt_status, QuantStrategyConfig
def display_monitor_manager():
"""显示监测管理主页面"""
@@ -39,7 +40,7 @@ def display_monitor_manager():
def display_monitor_status():
"""显示监测服务状态"""
col1, col2, col3, col4, col5 = st.columns(5)
col1, col2, col3, col4, col5, col6 = st.columns(6)
with col1:
if monitor_service.running:
@@ -56,6 +57,14 @@ def display_monitor_status():
st.metric("待处理通知", len(notifications))
with col4:
# 显示MiniQMT状态
qmt_status = get_miniqmt_status()
if qmt_status['ready']:
st.success("🤖 QMT在线")
else:
st.info("🤖 QMT离线")
with col5:
if monitor_service.running:
if st.button("⏹️ 停止监测", type="secondary"):
monitor_service.stop_monitoring()
@@ -67,7 +76,7 @@ def display_monitor_status():
st.success("✅ 监测服务已启动")
st.rerun()
with col5:
with col6:
if st.button("🔄 刷新状态"):
st.rerun()
@@ -116,6 +125,15 @@ def display_add_stock_section():
# 投资评级
rating = st.selectbox("投资评级", ["买入", "持有", "卖出"], index=0)
# 量化交易设置
st.markdown("**🤖 量化交易（MiniQMT）**")
quant_enabled = st.checkbox("启用量化自动交易", value=False, help="需要先配置MiniQMT连接")
if quant_enabled:
max_position_pct = st.slider("最大仓位比例", 0.05, 0.5, 0.2, 0.05, help="单只股票最大占总资金的比例")
auto_stop_loss = st.checkbox("自动止损", value=True)
auto_take_profit = st.checkbox("自动止盈", value=True)
# 添加按钮
if st.button("✅ 添加监测", type="primary", use_container_width=True):
@@ -124,6 +142,16 @@ def display_add_stock_section():
# 准备数据
entry_range = {"min": entry_min, "max": entry_max}
# 准备量化配置
quant_config = None
if quant_enabled:
quant_config = {
'max_position_pct': max_position_pct,
'auto_stop_loss': auto_stop_loss,
'auto_take_profit': auto_take_profit,
'min_trade_amount': 5000
}
# 添加到数据库
stock_id = monitor_db.add_monitored_stock(
symbol=symbol,
@@ -133,7 +161,9 @@ def display_add_stock_section():
take_profit=take_profit if take_profit > 0 else None,
stop_loss=stop_loss if stop_loss > 0 else None,
check_interval=check_interval,
notification_enabled=notification_enabled
notification_enabled=notification_enabled,
quant_enabled=quant_enabled,
quant_config=quant_config
)
st.success(f"✅ 已成功添加 {symbol} 到监测列表")
@@ -278,6 +308,12 @@ def display_stock_card(stock: Dict):
with col3:
status = "🟢 启用" if stock['notification_enabled'] else "🔴 禁用"
st.caption(f"通知: {status}")
# 显示量化状态
if stock.get('quant_enabled', False):
st.caption("🤖 量化: 🟢 启用")
else:
st.caption("🤖 量化: 🔴 禁用")
# 操作按钮
st.markdown("**🔧 操作**")
@@ -345,6 +381,17 @@ def display_edit_dialog(stock_id: int):
rating = st.selectbox("投资评级", ["买入", "持有", "卖出"],
index=["买入", "持有", "卖出"].index(stock['rating']) if stock['rating'] in ["买入", "持有", "卖出"] else 0)
notification_enabled = st.checkbox("启用通知", value=stock['notification_enabled'])
# 量化交易设置
st.markdown("**🤖 量化交易**")
quant_enabled = st.checkbox("启用量化自动交易", value=stock.get('quant_enabled', False))
if quant_enabled:
quant_config = stock.get('quant_config', {})
max_position_pct = st.slider("最大仓位比例", 0.05, 0.5,
quant_config.get('max_position_pct', 0.2), 0.05)
auto_stop_loss = st.checkbox("自动止损", value=quant_config.get('auto_stop_loss', True))
auto_take_profit = st.checkbox("自动止盈", value=quant_config.get('auto_take_profit', True))
col1, col2, col3 = st.columns(3)
@@ -359,6 +406,17 @@ def display_edit_dialog(stock_id: int):
try:
# 更新数据库
new_entry_range = {"min": entry_min, "max": entry_max}
# 准备量化配置
new_quant_config = None
if quant_enabled:
new_quant_config = {
'max_position_pct': max_position_pct,
'auto_stop_loss': auto_stop_loss,
'auto_take_profit': auto_take_profit,
'min_trade_amount': 5000
}
monitor_db.update_monitored_stock(
stock_id=stock_id,
rating=rating,
@@ -366,7 +424,9 @@ def display_edit_dialog(stock_id: int):
take_profit=take_profit if take_profit > 0 else None,
stop_loss=stop_loss if stop_loss > 0 else None,
check_interval=check_interval,
notification_enabled=notification_enabled
notification_enabled=notification_enabled,
quant_enabled=quant_enabled,
quant_config=new_quant_config
)
st.success("✅ 修改已保存")
@@ -445,6 +505,11 @@ def display_notification_management():
st.markdown("### 🔔 通知管理")
# 显示MiniQMT量化交易状态
display_miniqmt_status()
st.markdown("---")
# 通知设置
col1, col2 = st.columns([1, 1])
@@ -538,6 +603,82 @@ def display_notification_management():
else:
st.info("📭 暂无通知")
def display_miniqmt_status():
"""显示MiniQMT量化交易状态"""
st.markdown("### 🤖 MiniQMT量化交易")
qmt_status = get_miniqmt_status()
col1, col2 = st.columns([1, 1])
with col1:
st.subheader("📊 连接状态")
if qmt_status['enabled']:
st.success("✅ MiniQMT已启用")
else:
st.warning("⚠️ MiniQMT未启用")
if qmt_status['connected']:
st.success("✅ 已连接到MiniQMT")
else:
st.info("⏸️ 未连接到MiniQMT")
if qmt_status['account_id']:
st.info(f"**账户ID**: {qmt_status['account_id']}")
else:
st.caption("未配置账户ID")
st.markdown("---")
st.markdown("**⚙️ 配置说明**")
st.caption("""
在 `config.py` 中配置以下参数：
```python
MINIQMT_CONFIG = {
'enabled': True,
'account_id': 'your_account_id'
}
```
💡 提示：
- 需要安装并启动MiniQMT客户端
- 确保账户已登录
- 预留接口已实现，可对接真实交易
""")
with col2:
st.subheader("📈 量化统计")
# 统计启用量化的股票
stocks = monitor_db.get_monitored_stocks()
quant_stocks = [s for s in stocks if s.get('quant_enabled', False)]
st.metric("启用量化的股票", f"{len(quant_stocks)}/{len(stocks)}")
if quant_stocks:
st.markdown("**量化监测列表：**")
for stock in quant_stocks:
st.caption(f"🤖 {stock['symbol']} - {stock['name']}")
else:
st.info("暂无启用量化交易的股票")
st.markdown("---")
# 连接按钮
if qmt_status['enabled'] and not qmt_status['connected']:
if st.button("🔗 连接MiniQMT", type="primary", use_container_width=True):
success, msg = miniqmt.connect()
if success:
st.success(f"✅ {msg}")
else:
st.error(f"❌ {msg}")
st.rerun()
elif qmt_status['connected']:
if st.button("🔌 断开连接", use_container_width=True):
if miniqmt.disconnect():
st.info("⏸️ 已断开MiniQMT连接")
st.rerun()
def get_monitor_summary():
"""获取监测摘要信息"""
stocks = monitor_db.get_monitored_stocks()
monitor_service.py
+56
View File
@@ -7,6 +7,7 @@ import streamlit as st
from monitor_db import monitor_db
from stock_data import StockDataFetcher
from miniqmt_interface import miniqmt, get_miniqmt_status
class StockMonitorService:
"""股票监测服务"""
@@ -104,16 +105,71 @@ class StockMonitorService:
if current_price >= entry_range['min'] and current_price <= entry_range['max']:
message = f"股票 {stock['symbol']} ({stock['name']}) 价格 {current_price} 进入进场区间 [{entry_range['min']}-{entry_range['max']}]"
monitor_db.add_notification(stock['id'], 'entry', message)
# 如果启用量化交易，执行自动交易
if stock.get('quant_enabled', False):
self._execute_quant_trade(stock, 'entry', current_price)
# 检查止盈
if take_profit and current_price >= take_profit:
message = f"股票 {stock['symbol']} ({stock['name']}) 价格 {current_price} 达到止盈位 {take_profit}"
monitor_db.add_notification(stock['id'], 'take_profit', message)
# 如果启用量化交易，执行自动交易
if stock.get('quant_enabled', False):
self._execute_quant_trade(stock, 'take_profit', current_price)
# 检查止损
if stop_loss and current_price <= stop_loss:
message = f"股票 {stock['symbol']} ({stock['name']}) 价格 {current_price} 达到止损位 {stop_loss}"
monitor_db.add_notification(stock['id'], 'stop_loss', message)
# 如果启用量化交易，执行自动交易
if stock.get('quant_enabled', False):
self._execute_quant_trade(stock, 'stop_loss', current_price)
def _execute_quant_trade(self, stock: Dict, signal_type: str, current_price: float):
"""执行量化交易"""
try:
# 检查MiniQMT是否连接
if not miniqmt.is_connected():
print(f"MiniQMT未连接，无法执行 {stock['symbol']} 的量化交易")
return
# 获取量化配置
quant_config = stock.get('quant_config', {})
if not quant_config:
print(f"股票 {stock['symbol']} 未配置量化参数")
return
# 执行策略信号
signal = {
'type': signal_type,
'price': current_price,
'message': f"{signal_type} signal triggered"
}
position_size = quant_config.get('max_position_pct', 0.2)
success, msg = miniqmt.execute_strategy_signal(
stock['id'],
stock['symbol'],
signal,
position_size
)
if success:
print(f"✅ 量化交易成功: {stock['symbol']} - {msg}")
# 记录交易通知
monitor_db.add_notification(
stock['id'],
'quant_trade',
f"量化交易执行: {msg}"
)
else:
print(f"❌ 量化交易失败: {stock['symbol']} - {msg}")
except Exception as e:
print(f"执行量化交易异常: {stock['symbol']} - {str(e)}")
def get_stocks_needing_update(self) -> List[Dict]:
"""获取需要更新价格的股票"""
量化交易快速指南.md
+237
View File
@@ -0,0 +1,237 @@
# 🤖 量化交易功能快速指南
## 简介
本系统已为监测板块增加MiniQMT量化交易预留接口，实现监测价格触发后自动执行交易的功能。
## 核心功能
### ✅ 已实现功能
1. **自动交易执行** - 价格触发后自动下单
2. **仓位管理** - 智能控制交易仓位
3. **风险控制** - 自动止损止盈
4. **订单管理** - 完整的订单生命周期管理
5. **持仓监控** - 实时查看持仓和盈亏
6. **多种订单类型** - 支持市价单、限价单、止损单
### 🔧 新增模块
- `miniqmt_interface.py` - MiniQMT接口核心模块
- `MINIQMT_INTEGRATION_GUIDE.md` - 详细集成指南
### 📝 更新模块
- `monitor_db.py` - 增加量化配置字段（quant_enabled, quant_config）
- `monitor_service.py` - 集成量化交易执行逻辑
- `monitor_manager.py` - 添加量化配置界面
- `config.py` - 添加MiniQMT配置选项
- `README.md` - 更新功能说明和文档
## 快速开始
### 1. 配置环境变量
编辑 `.env` 文件，添加以下配置：
```bash
# 启用MiniQMT量化交易
MINIQMT_ENABLED=true
MINIQMT_ACCOUNT_ID=your_account_id
MINIQMT_HOST=127.0.0.1
MINIQMT_PORT=58610
```
### 2. 启动MiniQMT客户端
1. 启动MiniQMT客户端程序
2. 登录你的交易账户
3. 确保API服务已开启
### 3. 在系统中启用量化
1. 运行系统：`python run.py`
2. 进入"📊 实时监测"板块
3. 在"🤖 MiniQMT量化交易"区域点击"连接MiniQMT"
4. 看到"✅ 已连接"提示即可
### 4. 添加量化监测
#### 添加新股票：
1. 点击"添加股票监测"
2. 填写股票代码和关键位置
3. 勾选"启用量化自动交易"
4. 设置量化参数：
- 最大仓位比例：建议0.2（20%）
- 自动止损：建议勾选
- 自动止盈：建议勾选
5. 点击"添加监测"
#### 编辑现有股票：
1. 找到目标股票卡片
2. 点击"编辑"
3. 勾选"启用量化自动交易"
4. 配置参数后保存
## 交易逻辑
### 自动交易触发条件
#### 1. 进场买入
- **触发**：价格进入设定的进场区间
- **动作**：按配置的仓位比例自动买入
- **订单类型**：限价单
#### 2. 止盈卖出
- **触发**：价格达到止盈位
- **动作**：卖出全部持仓
- **订单类型**：限价单
#### 3. 止损卖出
- **触发**：价格达到止损位
- **动作**：紧急卖出全部持仓
- **订单类型**：市价单（快速成交）
## 安全建议
### ⚠️ 风险提示
1. 自动交易涉及真实资金，请谨慎使用
2. 建议先用测试账户测试功能
3. 设置合理的仓位限制（建议单股不超过20%）
4. 必须设置止损位（建议5-10%）
5. 保持人工监控，不要完全依赖自动化
### ✅ 最佳实践
1. **小仓位测试** - 先用小额资金测试
2. **严格止损** - 必须设置止损保护
3. **合理仓位** - 单股不超过20%，总仓位不超过80%
4. **定期检查** - 定期查看持仓和订单状态
5. **及时调整** - 根据市场变化及时调整策略
## 界面功能
### 监测状态栏
- **🟢 运行中** / **🔴 已停止** - 监测服务状态
- **监测股票** - 当前监测股票数量
- **待处理通知** - 待处理的通知数量
- **🤖 QMT在线** / **🤖 QMT离线** - MiniQMT连接状态
### MiniQMT状态面板
- **连接状态** - 显示是否已连接到MiniQMT
- **账户ID** - 当前交易账户
- **量化统计** - 启用量化的股票数量
- **量化监测列表** - 显示所有启用量化的股票
### 股票卡片
每个监测股票卡片会显示：
- **基本信息** - 代码、名称、当前价格
- **关键位置** - 进场区间、止盈位、止损位
- **监测状态** - 监测间隔、最后检查时间、通知状态
- **量化状态** - 🟢 启用 / 🔴 禁用
## 预留接口说明
### MiniQMTInterface 类
系统提供了完整的MiniQMT接口类，支持以下功能：
```python
# 连接管理
miniqmt.connect(account_id) # 连接到MiniQMT
miniqmt.disconnect() # 断开连接
miniqmt.is_connected() # 检查连接状态
# 账户信息
miniqmt.get_account_info() # 获取账户信息
miniqmt.get_positions() # 获取所有持仓
miniqmt.get_position(symbol) # 获取单个持仓
# 交易下单
miniqmt.place_order( # 下单
symbol, action, quantity,
price, order_type
)
miniqmt.cancel_order(order_id) # 撤单
miniqmt.get_order_status(order_id) # 查询订单状态
# 策略执行
miniqmt.execute_strategy_signal( # 执行策略信号
stock_id, symbol, signal,
position_size
)
# 风险管理
miniqmt.calculate_position_size() # 计算仓位大小
miniqmt.get_risk_metrics() # 获取风险指标
miniqmt.validate_trade() # 验证交易可行性
```
### 对接真实交易
当前接口为预留接口，要对接真实交易，需要：
1. 安装MiniQMT Python SDK：
```bash
pip install xtquant
```
2. 在 `miniqmt_interface.py` 中取消注释相关代码：
```python
# 例如在 connect() 方法中
from xtquant import xtdata
xtdata.connect()
# 在 place_order() 方法中
from xtquant import xttrader
order_id = xttrader.order_stock(...)
```
3. 参考MiniQMT官方文档完成具体对接
## 常见问题
### Q1: MiniQMT连接失败？
A: 检查以下几点：
- MiniQMT客户端是否启动
- 账户是否已登录
- 账户ID是否正确
- 网络连接是否正常
### Q2: 量化交易没有执行？
A: 检查以下几点：
- 量化功能是否已启用
- MiniQMT是否已连接
- 监测服务是否在运行
- 是否在交易时间内
- 查看通知记录中的错误信息
### Q3: 如何测试量化功能？
A: 建议步骤：
1. 使用测试账户
2. 设置小额交易金额
3. 设置宽松的触发条件
4. 观察订单执行情况
5. 确认逻辑无误后再使用实盘
### Q4: 仓位如何控制？
A: 系统提供多层仓位控制：
- 单股最大仓位比例（配置时设置）
- 最小交易金额（默认5000元）
- A股100股为一手的限制
- 可用资金检查
## 技术支持
### 详细文档
- 完整集成指南：`MINIQMT_INTEGRATION_GUIDE.md`
- 系统说明：`README.md`
- 快速启动：`QUICK_START.md`
### 问题反馈
如遇到问题，请：
1. 查看终端日志输出
2. 查看MiniQMT客户端日志
3. 查看通知记录中的详细信息
4. 参考详细集成指南
---
**免责声明**：本系统仅供学习研究使用，量化交易涉及真实资金风险，请谨慎使用并自行承担投资风险。