345 lines
13 KiB
Python
345 lines
13 KiB
Python
# coding:utf-8
|
||
import time, datetime, traceback, sys, json, os
|
||
import logging
|
||
import redis
|
||
from xtquant import xtdata
|
||
from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
|
||
from xtquant.xttype import StockAccount
|
||
from xtquant import xtconstant
|
||
|
||
# 全局变量记录当前日志日期，用于跨天判断
|
||
CURRENT_LOG_DATE = None
|
||
|
||
# ================= 1. 日志系统 (按日期直写) =================
|
||
def setup_logger():
|
||
"""
|
||
配置日志系统：
|
||
1. 确保日志目录存在
|
||
2. 生成当天日期的日志文件 (YYYY-MM-DD.log)
|
||
3. 同时输出到控制台
|
||
"""
|
||
global CURRENT_LOG_DATE
|
||
|
||
log_dir = "logs"
|
||
if not os.path.exists(log_dir):
|
||
os.makedirs(log_dir)
|
||
|
||
# 获取今日日期
|
||
today_str = datetime.date.today().strftime('%Y-%m-%d')
|
||
CURRENT_LOG_DATE = today_str # 更新全局变量
|
||
|
||
# 文件名直接就是日期: logs/2025-12-05.log
|
||
log_file = os.path.join(log_dir, f"{today_str}.log")
|
||
|
||
logger = logging.getLogger("QMT_Trader")
|
||
logger.setLevel(logging.INFO)
|
||
|
||
# 【关键】清除旧的 handler，防止跨天后重复打印或写入旧文件
|
||
if logger.handlers:
|
||
for handler in logger.handlers[:]:
|
||
try:
|
||
handler.close()
|
||
logger.removeHandler(handler)
|
||
except: pass
|
||
|
||
formatter = logging.Formatter(
|
||
'[%(asctime)s] [%(levelname)s] %(message)s',
|
||
datefmt='%Y-%m-%d %H:%M:%S'
|
||
)
|
||
|
||
# Handler 1: 普通文件输出 (追加模式)
|
||
file_handler = logging.FileHandler(log_file, mode='a', encoding='utf-8')
|
||
file_handler.setFormatter(formatter)
|
||
|
||
# Handler 2: 控制台
|
||
stream_handler = logging.StreamHandler(sys.stdout)
|
||
stream_handler.setFormatter(formatter)
|
||
|
||
logger.addHandler(file_handler)
|
||
logger.addHandler(stream_handler)
|
||
|
||
return logger
|
||
|
||
# 初次初始化
|
||
logger = setup_logger()
|
||
|
||
# ================= 全局变量 =================
|
||
CONFIG = {}
|
||
ORDER_CACHE = {}
|
||
|
||
# ================= 配置加载 =================
|
||
def load_config(config_file='config.json'):
|
||
if getattr(sys, 'frozen', False):
|
||
base_path = os.path.dirname(sys.executable)
|
||
else:
|
||
base_path = os.path.dirname(os.path.abspath(__file__))
|
||
full_path = os.path.join(base_path, config_file)
|
||
if not os.path.exists(full_path):
|
||
if os.path.exists(config_file): full_path = config_file
|
||
else:
|
||
logger.error(f"找不到配置文件: {full_path}")
|
||
sys.exit(1)
|
||
try:
|
||
with open(full_path, 'r', encoding='utf-8') as f:
|
||
return json.load(f)
|
||
except Exception as e:
|
||
logger.error(f"配置文件错误: {e}")
|
||
sys.exit(1)
|
||
|
||
# ================= 业务逻辑类 =================
|
||
class PositionManager:
|
||
def __init__(self, r_client):
|
||
self.r = r_client
|
||
def _get_key(self, strategy_name):
|
||
return f"POS:{strategy_name}"
|
||
def mark_holding(self, strategy_name, code):
|
||
self.r.hsetnx(self._get_key(strategy_name), code, 0)
|
||
def rollback_holding(self, strategy_name, code):
|
||
key = self._get_key(strategy_name)
|
||
val = self.r.hget(key, code)
|
||
if val is not None and int(val) == 0:
|
||
self.r.hdel(key, code)
|
||
def update_actual_volume(self, strategy_name, code, delta_vol):
|
||
key = self._get_key(strategy_name)
|
||
new_vol = self.r.hincrby(key, code, int(delta_vol))
|
||
if new_vol <= 0:
|
||
self.r.hdel(key, code)
|
||
new_vol = 0
|
||
return new_vol
|
||
def get_position(self, strategy_name, code):
|
||
vol = self.r.hget(self._get_key(strategy_name), code)
|
||
return int(vol) if vol else 0
|
||
def get_holding_count(self, strategy_name):
|
||
return self.r.hlen(self._get_key(strategy_name))
|
||
def get_all_virtual_positions(self, strategy_name):
|
||
return self.r.hgetall(self._get_key(strategy_name))
|
||
def force_delete(self, strategy_name, code):
|
||
self.r.hdel(self._get_key(strategy_name), code)
|
||
|
||
class DailySettlement:
|
||
def __init__(self, xt_trader, acc, pos_mgr, strategies):
|
||
self.trader = xt_trader
|
||
self.acc = acc
|
||
self.pos_mgr = pos_mgr
|
||
self.strategies = strategies
|
||
self.has_settled = False
|
||
def run_settlement(self):
|
||
logger.info("="*40)
|
||
logger.info("执行收盘清算...")
|
||
try:
|
||
orders = self.trader.query_stock_orders(self.acc, cancelable_only=True)
|
||
if orders:
|
||
for o in orders:
|
||
self.trader.cancel_order_stock(self.acc, o.order_id)
|
||
time.sleep(2)
|
||
except: pass
|
||
real_positions = self.trader.query_stock_positions(self.acc)
|
||
real_pos_map = {}
|
||
if real_positions:
|
||
for p in real_positions:
|
||
if p.volume > 0: real_pos_map[p.stock_code] = p.volume
|
||
for strategy in self.strategies:
|
||
virtual = self.pos_mgr.get_all_virtual_positions(strategy)
|
||
for code, v in virtual.items():
|
||
if code not in real_pos_map:
|
||
logger.warning(f" [修正] {strategy} 幽灵持仓 {code} -> 释放")
|
||
self.pos_mgr.force_delete(strategy, code)
|
||
logger.info("清算完成")
|
||
self.has_settled = True
|
||
def reset_flag(self):
|
||
self.has_settled = False
|
||
|
||
# ================= 回调类 =================
|
||
class MyXtQuantTraderCallback(XtQuantTraderCallback):
|
||
def __init__(self, pos_mgr):
|
||
self.pos_mgr = pos_mgr
|
||
self.is_connected = False
|
||
|
||
def on_disconnected(self):
|
||
logger.warning(">> 回调通知: 交易端连接断开")
|
||
self.is_connected = False
|
||
|
||
def on_stock_trade(self, trade):
|
||
try:
|
||
cache_info = ORDER_CACHE.get(trade.order_id)
|
||
if not cache_info: return
|
||
strategy, _, action = cache_info
|
||
|
||
logger.info(f">>> [成交] {strategy} {trade.stock_code} {trade.traded_volume}")
|
||
if action == 'BUY': self.pos_mgr.update_actual_volume(strategy, trade.stock_code, trade.traded_volume)
|
||
elif action == 'SELL': self.pos_mgr.update_actual_volume(strategy, trade.stock_code, -trade.traded_volume)
|
||
except: traceback.print_exc()
|
||
|
||
def on_order_error(self, err):
|
||
try:
|
||
logger.error(f"下单失败: {err.error_msg}")
|
||
cache = ORDER_CACHE.get(err.order_id)
|
||
if cache and cache[2] == 'BUY':
|
||
self.pos_mgr.rollback_holding(cache[0], cache[1])
|
||
del ORDER_CACHE[err.order_id]
|
||
except: pass
|
||
|
||
# ================= 消息处理 =================
|
||
def process_strategy_queue(strategy_name, r_client, xt_trader, acc, pos_manager):
|
||
queue_key = f"{strategy_name}_real"
|
||
msg_json = r_client.lpop(queue_key)
|
||
if not msg_json: return
|
||
|
||
try:
|
||
r_client.rpush(f"{queue_key}:history", msg_json)
|
||
data = json.loads(msg_json)
|
||
if data.get('is_backtest'): return
|
||
|
||
# 简单日期校验
|
||
if data.get('timestamp', '').split(' ')[0] != datetime.date.today().strftime('%Y-%m-%d'):
|
||
return
|
||
|
||
stock_code = data['stock_code']
|
||
action = data['action']
|
||
price = float(data['price'])
|
||
total_slots = int(data.get('total_slots', 1))
|
||
|
||
if action == 'BUY':
|
||
holding = pos_manager.get_holding_count(strategy_name)
|
||
empty = total_slots - holding
|
||
if empty <= 0: return
|
||
|
||
asset = xt_trader.query_stock_asset(acc)
|
||
if not asset: return
|
||
|
||
amt = asset.cash / empty
|
||
if amt < 2000: return
|
||
|
||
if price<=0: price=1.0
|
||
vol = int(amt/price/100)*100
|
||
if vol >= 100:
|
||
oid = xt_trader.order_stock(acc, stock_code, xtconstant.STOCK_BUY, vol, xtconstant.FIX_PRICE, price, strategy_name, 'PyBuy')
|
||
if oid != -1:
|
||
logger.info(f"[{strategy_name}] 买入 {stock_code} {vol}股")
|
||
ORDER_CACHE[oid] = (strategy_name, stock_code, 'BUY')
|
||
pos_manager.mark_holding(strategy_name, stock_code)
|
||
|
||
elif action == 'SELL':
|
||
v_vol = pos_manager.get_position(strategy_name, stock_code)
|
||
if v_vol > 0:
|
||
real_pos = xt_trader.query_stock_positions(acc)
|
||
rp = next((p for p in real_pos if p.stock_code==stock_code), None)
|
||
can_use = rp.can_use_volume if rp else 0
|
||
final = min(v_vol, can_use)
|
||
if final > 0:
|
||
oid = xt_trader.order_stock(acc, stock_code, xtconstant.STOCK_SELL, final, xtconstant.FIX_PRICE, price, strategy_name, 'PySell')
|
||
if oid != -1:
|
||
logger.info(f"[{strategy_name}] 卖出 {stock_code} {final}")
|
||
ORDER_CACHE[oid] = (strategy_name, stock_code, 'SELL')
|
||
except:
|
||
logger.error("消息处理异常", exc_info=True)
|
||
|
||
|
||
# ================= QMT对象初始化 =================
|
||
def init_qmt_trader(qmt_path, account_id, account_type, pos_manager):
|
||
try:
|
||
session_id = int(time.time())
|
||
trader = XtQuantTrader(qmt_path, session_id)
|
||
acc = StockAccount(account_id, account_type)
|
||
callback = MyXtQuantTraderCallback(pos_manager)
|
||
trader.register_callback(callback)
|
||
trader.start()
|
||
res = trader.connect()
|
||
if res == 0:
|
||
logger.info(f"QMT 连接成功 [Session:{session_id}]")
|
||
trader.subscribe(acc)
|
||
callback.is_connected = True
|
||
return trader, acc, callback
|
||
else:
|
||
logger.error(f"QMT 连接失败 Code:{res}")
|
||
return None, None, None
|
||
except Exception as e:
|
||
logger.error(f"初始化异常: {e}")
|
||
return None, None, None
|
||
|
||
# ================= 主程序 =================
|
||
if __name__ == '__main__':
|
||
logger.info("系统启动...")
|
||
|
||
CONFIG = load_config('config.json')
|
||
redis_cfg = CONFIG['redis']
|
||
qmt_cfg = CONFIG['qmt']
|
||
watch_list = CONFIG['strategies']
|
||
|
||
try:
|
||
r = redis.Redis(**redis_cfg, decode_responses=True)
|
||
r.ping()
|
||
pos_manager = PositionManager(r)
|
||
except Exception as e:
|
||
logger.critical(f"Redis 连接失败: {e}")
|
||
sys.exit(1)
|
||
|
||
xt_trader, acc, callback = init_qmt_trader(
|
||
qmt_cfg['path'], qmt_cfg['account_id'], qmt_cfg['account_type'], pos_manager
|
||
)
|
||
|
||
settler = None
|
||
if xt_trader:
|
||
settler = DailySettlement(xt_trader, acc, pos_manager, watch_list)
|
||
|
||
logger.info("进入主循环...")
|
||
|
||
while True:
|
||
try:
|
||
# === [新增] 日志跨天检查 ===
|
||
# 如果日期变更了，重新初始化日志，这会自动创建新日期的文件
|
||
today_str = datetime.date.today().strftime('%Y-%m-%d')
|
||
if today_str != CURRENT_LOG_DATE:
|
||
logger.info(f"检测到跨天 ({CURRENT_LOG_DATE} -> {today_str})，切换日志文件...")
|
||
logger = setup_logger()
|
||
logger.info(f"日志切换完成，当前写入: logs/{today_str}.log")
|
||
|
||
# === 断线重连 ===
|
||
need_reconnect = (xt_trader is None) or (callback is None) or (not callback.is_connected)
|
||
if need_reconnect:
|
||
logger.warning("连接丢失，执行硬重连...")
|
||
if xt_trader:
|
||
try: xt_trader.stop()
|
||
except: pass
|
||
|
||
xt_trader, acc, callback = init_qmt_trader(
|
||
qmt_cfg['path'], qmt_cfg['account_id'], qmt_cfg['account_type'], pos_manager
|
||
)
|
||
|
||
if xt_trader:
|
||
settler = DailySettlement(xt_trader, acc, pos_manager, watch_list)
|
||
logger.info("重连成功")
|
||
else:
|
||
logger.error("重连失败，60秒后重试")
|
||
time.sleep(60)
|
||
continue
|
||
|
||
# === 业务轮询 ===
|
||
now = datetime.datetime.now()
|
||
current_time_str = now.strftime('%H%M')
|
||
sleep_sec = 60
|
||
|
||
if '0900' <= current_time_str <= '1500':
|
||
if '0920' <= current_time_str <= '1000':
|
||
sleep_sec = 10
|
||
else:
|
||
sleep_sec = 60
|
||
|
||
if settler and settler.has_settled:
|
||
settler.reset_flag()
|
||
|
||
for s in watch_list:
|
||
process_strategy_queue(s, r, xt_trader, acc, pos_manager)
|
||
|
||
elif '1505' <= current_time_str <= '1510':
|
||
if settler and not settler.has_settled:
|
||
settler.run_settlement()
|
||
|
||
time.sleep(sleep_sec)
|
||
|
||
except KeyboardInterrupt:
|
||
logger.info("用户停止")
|
||
break
|
||
except Exception as e:
|
||
logger.critical("主循环未捕获异常", exc_info=True)
|
||
time.sleep(10) |