cls/qmt_strategy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

自用策略初始提交

Browse Source
This commit is contained in:
cls
2025-11-06 10:26:02 +08:00
commit 8a7583f111
90 changed files with 1053065 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
聚宽跟单/索普量化聚宽交易服务器/索普量化聚宽交易服务器.py
+414
View File
@@ -0,0 +1,414 @@
'''
索普量化聚宽交易服务器2.0
作者索普量化
微信:xms_quants1
'''
from dash import html, dcc, Input, Output, dash_table, dash
import pandas as pd
import os
from datetime import datetime
from pathlib import Path
import logging
from typing import Dict, Any, Optional
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class TradingDataManager:
"""交易数据管理类"""
def __init__(self, base_path: str):
self.base_path = Path(base_path)
self.realtime_data_dir = self.base_path / "data" / "实时数据"
self.historical_data_dir = self.base_path / "实时数据" / "历史数据"
self.auth_file = self.base_path / "授权表" / "授权表.xlsx"
# 创建必要的目录
self.realtime_data_dir.mkdir(parents=True, exist_ok=True)
self.historical_data_dir.mkdir(parents=True, exist_ok=True)
self.auth_file.parent.mkdir(parents=True, exist_ok=True)
def get_user_file_path(self, user_id: str, data_type: str) -> Path:
"""获取用户数据文件路径"""
if data_type == "实时数据":
return self.realtime_data_dir / f"{user_id}实时数据.csv"
elif data_type == "历史数据":
return self.historical_data_dir / f"{user_id}历史数据.csv"
else:
raise ValueError(f"不支持的数据类型: {data_type}")
def load_user_data(self, user_id: str, data_type: str) -> pd.DataFrame:
"""加载用户数据"""
file_path = self.get_user_file_path(user_id, data_type)
try:
if file_path.exists():
df = pd.read_csv(file_path)
# 清理可能的索引列
df = df.drop(columns=['Unnamed: 0'], errors='ignore')
return df
return pd.DataFrame()
except Exception as e:
logger.error(f"加载用户数据失败: {e}")
return pd.DataFrame()
def save_user_data(self, user_id: str, data_type: str, df: pd.DataFrame):
"""保存用户数据"""
file_path = self.get_user_file_path(user_id, data_type)
try:
df.to_csv(file_path, index=False)
except Exception as e:
logger.error(f"保存用户数据失败: {e}")
def load_auth_data(self) -> pd.DataFrame:
"""加载授权数据"""
try:
if self.auth_file.exists():
df = pd.read_excel(self.auth_file, dtype='object')
df = df.drop(columns=['Unnamed: 0'], errors='ignore')
return df
return pd.DataFrame(columns=['用户名称', '到期时间'])
except Exception as e:
logger.error(f"加载授权数据失败: {e}")
return pd.DataFrame(columns=['用户名称', '到期时间'])
class AuthManager:
"""授权管理类"""
@staticmethod
def calculate_days_remaining(start_date: str, end_date: str) -> int:
"""计算剩余天数"""
try:
start = datetime.strptime(start_date, '%Y-%m-%d')
end = datetime.strptime(end_date, '%Y-%m-%d')
return (end - start).days
except Exception as e:
logger.error(f"计算天数失败: {e}")
return -1
@staticmethod
def validate_user(auth_df: pd.DataFrame, user_id: str) -> Dict[str, Any]:
"""验证用户授权"""
try:
auth_df['用户名称'] = auth_df['用户名称'].astype(str)
auth_df['到期时间'] = auth_df['到期时间'].astype(str)
if user_id not in auth_df['用户名称'].values:
return {"valid": False, "message": "用户没有注册请注册/联系作者微信15117320079"}
user_data = auth_df[auth_df['用户名称'] == user_id].iloc[0]
end_date = str(user_data['到期时间'])[:10]
current_date = datetime.now().strftime('%Y-%m-%d')
days_remaining = AuthManager.calculate_days_remaining(current_date, end_date)
if days_remaining >= 1:
return {
"valid": True,
"days_remaining": days_remaining,
"user_data": user_data
}
else:
return {"valid": False, "message": "授权码到期找作者获取"}
except Exception as e:
logger.error(f"用户验证失败: {e}")
return {"valid": False, "message": "授权验证失败"}
class DataProcessor:
"""数据处理类"""
@staticmethod
def parse_signal_text(text: str) -> Dict[str, Any]:
"""解析信号文本"""
try:
cleaned_text = '\n'.join([
line.strip().lstrip()
for line in text.split('\n')
if line.strip()
])
return eval(cleaned_text)
except Exception as e:
logger.error(f"解析信号文本失败: {e}")
return {}
@staticmethod
def process_stock_data(df: pd.DataFrame) -> pd.DataFrame:
"""处理股票数据"""
if df.empty:
return df
# 清理股票代码
if '股票代码' in df.columns:
df['证券代码'] = df['股票代码'].apply(
lambda x: str(x).split('.XSHE')[0].split('.XSHG')[0]
)
df['数据长度'] = df['证券代码'].apply(lambda x: len(str(x)))
df = df[df['数据长度'] >= 6]
df = df.drop(columns=['数据长度'], errors='ignore')
return df
@staticmethod
def create_signal_data(signal_dict: Dict[str, Any]) -> pd.DataFrame:
"""创建信号数据"""
return pd.DataFrame([signal_dict])
class TradingApp:
"""交易应用主类"""
def __init__(self):
self.path = os.path.dirname(os.path.abspath(__file__))
self.data_manager = TradingDataManager(self.path)
self.auth_manager = AuthManager()
self.data_processor = DataProcessor()
self.select_options = [
'用户信息', '发送信号', '实时数据', '历史数据',
'清空实时数据', '清空历史数据'
]
self.app = dash.Dash(__name__)
self.setup_layout()
self.setup_callbacks()
def setup_layout(self):
"""设置应用布局"""
self.app.layout = html.Div([
html.H1([html.A('索普聚宽交易使用教程2.0',href='https://gitee.com/li-xingguo11111/big_qmt_joinquant_trader',style={'textAlign': 'center'}),]),
html.H3('索普量化,找作者获取授权码 微信xms_quants1,交易函数数据函数分离,平台只是一个信号的中转平台,聚宽的策略仔细研究避免未来函数,投资有风险,平台不做投资参考',style={'textAlign': 'center'}),
self._create_control_table(),
self._create_text_area(),
html.H3('数据展示'),
self._create_data_table(),
dcc.Download(id='joinquant_trader_table_down')
])
def _create_control_table(self):
"""创建控制表格"""
return html.Table([
html.Tr([
html.Td('用户名称', style={'border': '1px solid', 'width': '200px'}),
html.Td('数据类型', style={'border': '1px solid', 'width': '200px'}),
html.Td('运行程序', style={'border': '1px solid', 'width': '200px'}),
html.Td('下载数据', style={'border': '1px solid', 'width': '200px'})
]),
html.Tr([
html.Td(
dcc.Input(value='123456', id='joinquant_trader_password'),
style={'border': '1px solid', 'width': '200px'}
),
html.Td(
dcc.Dropdown(
options=self.select_options,
value='用户信息',
id='joinquant_trader_data_type'
),
style={'border': '1px solid', 'width': '200px'}
),
html.Td(
dcc.Dropdown(
options=['运行', '不运行'],
id='joinquant_trader_run',
value='不运行'
),
style={'border': '1px solid', 'width': '200px'}
),
html.Td(
dcc.RadioItems(
options={'下载数据': "下载数据", "不下载数据": "不下载数据"},
id='joinquant_trader_down_data',
value='不下载数据'
),
style={'border': '1px solid', 'width': '200px'}
)
]),
])
def _create_text_area(self):
"""创建文本区域"""
return dcc.Textarea(
value="""
{'状态': 'held', '订单添加时间': 'datetime.datetime(2024, 4, 23, 9, 30)', '买卖': 'False', '下单数量': '9400', '已经成交': '9400', '股票代码': '', '订单ID': '1732208241', '平均成交价格': '10.5', '持仓成本': '10.59', '多空': 'long', '交易费用': '128.31'}
""",
id='joinquant_trader_text',
style={'width': '80%', 'height': 200, "text-align": "left"}
)
def _create_data_table(self):
"""创建数据表格"""
return dash_table.DataTable(
id='joinquant_trader_table',
page_size=10,
style_table={'font-size': 15},
sort_action='native'
)
def setup_callbacks(self):
"""设置回调函数"""
# 主数据回调
@self.app.callback(
Output('joinquant_trader_table', 'data', allow_duplicate=True),
Input('joinquant_trader_password', 'value'),
Input('joinquant_trader_data_type', 'value'),
Input('joinquant_trader_text', 'value'),
Input('joinquant_trader_run', 'value'),
Input('joinquant_trader_down_data', 'value'),
prevent_initial_call=True
)
def update_table(password, data_type, text, run, down_data):
return self._handle_data_update(password, data_type, text, run, down_data)
# 下载回调
@self.app.callback(
Output('joinquant_trader_table_down', 'data', allow_duplicate=True),
Input('joinquant_trader_password', 'value'),
Input('joinquant_trader_data_type', 'value'),
Input('joinquant_trader_text', 'value'),
Input('joinquant_trader_run', 'value'),
Input('joinquant_trader_down_data', 'value'),
prevent_initial_call=True
)
def download_data(password, data_type, text, run, down_data):
return self._handle_download(password, data_type, text, run, down_data)
def _handle_data_update(self, password: str, data_type: str, text: str,
run: str, down_data: str) -> list:
"""处理数据更新"""
if run != '运行':
return self._create_message_df("没有点击运行选择", False).to_dict('records')
auth_df = self.data_manager.load_auth_data()
auth_result = self.auth_manager.validate_user(auth_df, str(password))
if not auth_result["valid"]:
return self._create_message_df(auth_result["message"], False).to_dict('records')
return self._process_data_type(
password, data_type, text, auth_result
).to_dict('records')
def _process_data_type(self, user_id: str, data_type: str, text: str,
auth_result: Dict[str, Any]) -> pd.DataFrame:
"""处理不同类型的数据请求"""
current_date = datetime.now().strftime('%Y-%m-%d')
if data_type == '用户信息':
return self._handle_user_info(auth_result)
elif data_type == '发送信号':
return self._handle_send_signal(user_id, text, current_date)
elif data_type in ['实时数据', '历史数据']:
return self._handle_data_query(user_id, data_type)
elif data_type in ['清空实时数据', '清空历史数据']:
return self._handle_clear_data(user_id, data_type)
else:
return self._create_message_df("未知的数据类型", False)
def _handle_user_info(self, auth_result: Dict[str, Any]) -> pd.DataFrame:
"""处理用户信息请求"""
user_data = auth_result["user_data"].copy()
user_data['到期天数'] = auth_result["days_remaining"]
user_data['信息推送'] = '授权码正常'
user_data['数据状态'] = True
return pd.DataFrame([user_data])
def _handle_send_signal(self, user_id: str, text: str, current_date: str) -> pd.DataFrame:
"""处理发送信号"""
signal_data = self.data_processor.parse_signal_text(text)
if not signal_data:
return self._create_message_df("信号数据解析失败", False)
# 处理实时数据
realtime_df = self.data_manager.load_user_data(user_id, "实时数据")
realtime_df = self.data_processor.process_stock_data(realtime_df)
# 处理历史数据
historical_df = self.data_manager.load_user_data(user_id, "历史数据")
historical_df = self.data_processor.process_stock_data(historical_df)
# 创建新信号数据
new_signal = self.data_processor.create_signal_data(signal_data)
new_signal['交易日'] = current_date
new_signal['数据状态'] = True
# 合并数据并去重
realtime_updated = self._merge_and_deduplicate(realtime_df, new_signal, current_date)
historical_updated = self._merge_and_deduplicate(historical_df, new_signal, current_date)
# 保存更新后的数据
self.data_manager.save_user_data(user_id, "实时数据", realtime_updated)
self.data_manager.save_user_data(user_id, "历史数据", historical_updated)
return new_signal
def _handle_data_query(self, user_id: str, data_type: str) -> pd.DataFrame:
"""处理数据查询"""
df = self.data_manager.load_user_data(user_id, data_type)
df = self.data_processor.process_stock_data(df)
return df if not df.empty else self._create_message_df(f"{data_type}为空", True)
def _handle_clear_data(self, user_id: str, data_type: str) -> pd.DataFrame:
"""处理清空数据"""
clear_type = "实时数据" if "实时" in data_type else "历史数据"
self.data_manager.save_user_data(user_id, clear_type, pd.DataFrame())
return self._create_message_df(f"{clear_type}已清空", True)
def _merge_and_deduplicate(self, existing_df: pd.DataFrame,
new_df: pd.DataFrame, current_date: str) -> pd.DataFrame:
"""合并数据并去重"""
merged_df = pd.concat([existing_df, new_df], ignore_index=True)
merged_df['交易日'] = current_date
# 去重逻辑
dup_cols = ['股票代码', '下单数量', '买卖', '多空']
if all(col in merged_df.columns for col in dup_cols):
merged_df = merged_df.drop_duplicates(subset=dup_cols, keep='last')
return merged_df
def _handle_download(self, password: str, data_type: str, text: str,
run: str, down_data: str):
"""处理数据下载"""
if down_data != '下载数据':
return None
if data_type not in ['实时数据', '历史数据']:
return None
auth_df = self.data_manager.load_auth_data()
auth_result = self.auth_manager.validate_user(auth_df, str(password))
if not auth_result["valid"]:
return None
df = self.data_manager.load_user_data(str(password), data_type)
current_date = datetime.now().strftime('%Y-%m-%d')
return dcc.send_data_frame(
df.to_excel,
filename=f'{current_date}{data_type}.xlsx'
)
@staticmethod
def _create_message_df(message: str, status: bool) -> pd.DataFrame:
"""创建消息DataFrame"""
return pd.DataFrame({'信息提示': [message], '数据状态': [status]})
def run(self, host: str = '127.0.0.1', port: str = '8025'):
"""运行应用"""
try:
self.app.run(debug=True, host=host, port=port)
except Exception as e:
logger.error(f"启动应用失败: {e}")
# 尝试备用端口
try:
self.app.run_server(debug=True, host=host, port=port)
except Exception as e:
logger.error(f"备用端口启动也失败: {e}")
if __name__ == '__main__':
host = '127.0.0.1'
port = '8025'
app = TradingApp()
app.run(host=host,port=port)