bug修复/策略完善

Administrator

2025-06-30 bb2c567db00cc12b16808fc71bbb4c91615d110b

bug修复/策略完善

 server/local_data_server.py

@@ -2,19 +2,30 @@
本地http服务器
"""
import json
import threading
import uuid
from http.server import SimpleHTTPRequestHandler, HTTPServer
import urllib.parse as urlparse
from urllib.parse import parse_qs

import constant
from code_attribute import gpcode_manager
from db.mysql_data_delegate import Mysqldb

from strategy.data.data_manager import LowSuctionOriginDataExportManager
from strategy.strategy_variable_factory import DataLoader
from strategy.time_series_backtest import BackTest
from third_data import kpl_util
from utils import tool, output_util, huaxin_util

# 正在运行的回测任务字典
running_task_dict = {}


class CORSRequestHandler(SimpleHTTPRequestHandler):
    # 数据加载字典
    __data_loader_dict = {}

    def end_headers(self):
        # 添加 CORS 头
        self.send_header('Access-Control-Allow-Origin', '*')
@@ -146,9 +157,67 @@
            sql = f" select code, jx_blocks  from kpl_code_blocks where  day = '{date}' and " + " and ".join(
                [f"jx_blocks like '%{p}%'" for p in plates])
            datas = Mysqldb().select_all(sql)
            fdatas = [(x[0], "、".join([ f"<red>{dd}</red>" if dd in plates else dd for dd in json.loads(x[1])])) for x in datas if len(set(json.loads(x[1])) & plates) == len(plates)]
            fdatas = [(x[0], gpcode_manager.get_code_name(x[0]),
                       "、".join([f"<red>{dd}</red>" if dd in plates else dd for dd in json.loads(x[1])])) for x in
                      datas if len(set(json.loads(x[1])) & plates) == len(plates)]
            response_data = json.dumps({"code": 0, "data": fdatas})

        elif url.path == "/get_codes_by_limit_up_count":
            # 根据精选板块获取代码
            plates = ps_dict.get("plates")
            date = ps_dict.get("date")
            plates = set(json.loads(plates))
            if date not in self.__data_loader_dict:
                self.__data_loader_dict[date] = DataLoader(date)

            dates = set(self.__data_loader_dict.keys())
            dates.discard(date)
            for d in dates:
                self.__data_loader_dict.pop(d)
            results = self.__data_loader_dict[date].load_target_plate_and_codes()
            codes = set()
            for p in plates:
                codes |= set(results.get(p))
            fdatas = [(code, gpcode_manager.get_code_name(code)) for code in codes]
            response_data = json.dumps({"code": 0, "data": fdatas})

        elif url.path == "/start_run_backtest":
            def run_backtest(task_id):
                __back_test = BackTest(date, r"D:\workspace\trade_low_suction\strategy\strategy_script_v6.py",
                                       target_codes=codes)
                running_task_dict[task_id] = __back_test
                __back_test.run()

            date = ps_dict.get("date")
            codes = ps_dict.get("codes")
            codes = json.loads(codes)
            # 开始运行回撤
            task_id = str(uuid.uuid1())
            threading.Thread(target=lambda: run_backtest(task_id), daemon=True).start()
            response_data = json.dumps({"code": 0, "data": {"task_id": task_id}})
        elif url.path == "/stop_run_backtest":
            task_id = ps_dict.get("task_id")
            if task_id not in running_task_dict:
                response_data = json.dumps({"code": 1, "msg": "任务不存在"})
            else:
                backtest: BackTest = running_task_dict.pop(task_id)
                del backtest
                response_data = json.dumps({"code": 0, "data": {}})

        elif url.path == "/get_backtest_result":
            task_id = ps_dict.get("task_id")
            if task_id not in running_task_dict:
                response_data = json.dumps({"code": 1, "msg": "任务不存在"})
            else:
                backtest: BackTest = running_task_dict.get(task_id)
                progress = tool.trade_time_sub(backtest.current_time, backtest.RANGE_TIMES[0]) / tool.trade_time_sub(
                    backtest.RANGE_TIMES[1], backtest.RANGE_TIMES[0])
                backtest.backtest_results.sort(key=lambda x: (0 if x[3][0] else 1, x[0]))
                response_data = json.dumps(
                    {"code": 0, "data": {"results": backtest.backtest_results, "finish": backtest.finish,
                                         "progress": round(progress * 100, 2)}},
                    cls=tool.SetEncoder)

        print("GET请求")
        self.send_response(200)
        # 发给请求客户端的响应数据

 strategy/strategy_manager.py

@@ -294,6 +294,7 @@
                                            max_day=days[0]))
        stock_variables.连续老题材 = KPLLimitUpDataAnalyzer.get_continuous_limit_up_reasons(
            self.limit_up_record_data_list, self.data_loader.trade_days[:2])
        stock_variables.连续老题材.clear()

        # 加载Tick信息
        open_price_info = TickSummaryDataManager().open_price_info_dict.get(code_)

 strategy/time_series_backtest.py

@@ -14,7 +14,8 @@

class BackTest:

    def __init__(self, day, script_name="低吸脚本_辨识度_v3.py", settings=StrategyParamsSettingsManager().get_settings()):
    def __init__(self, day, script_name="低吸脚本_辨识度_v3.py", settings=StrategyParamsSettingsManager().get_settings(),
                 target_codes=set()):
        self.day = day
        scripts = ""
        with open(script_name, mode='r', encoding='utf-8') as f:
@@ -27,7 +28,7 @@
        self.settings = settings
        self.scripts = scripts
        self.RANGE_TIMES = ("09:25:00", "11:30:00")
        self.current_time = '09:25:00'
        self.current_time = self.RANGE_TIMES[0]

        self.stock_variables_dict = {}
        self.data_loader: DataLoader = None
@@ -41,6 +42,9 @@
        self.deal_codes = set()
        # 板块已经成交的代码
        self.deal_block_codes = {}
        self.target_codes = target_codes
        self.backtest_results = []
        self.finish = False

    def set_script(self, script):
        self.scripts = script
@@ -250,43 +254,6 @@
        exec(self.scripts, global_dict)
        return global_dict["compute_result"]

    def __filter_codes(self, current_data, timeline_data):
        code_plates = current_data["code_plates"]
        start_time, end_time = self.RANGE_TIMES[0], self.RANGE_TIMES[1]
        fplates = set()
        for i in range(60 * 60 * 5):
            time_str = tool.trade_time_add_second(start_time, i)
            if time_str > end_time:
                break
            self.current_time = time_str
            # 统计当前涨停数据
            current_limit_up_list = current_data["limit_up_list"].get(time_str)
            if current_limit_up_list:
                # 统计板块涨停
                plate_codes_info = {}
                for x in current_limit_up_list:
                    plates = code_plates.get(x[0])
                    if plates:
                        for p in plates:
                            if p not in plate_codes_info:
                                plate_codes_info[p] = []
                            plate_codes_info[p].append((x[0], x[2]))
                # print(time_str, "汽车零部件", plate_codes_info.get("汽车零部件"))
                # 有效的板块
                valid_plates = set([p for p in plate_codes_info if len(plate_codes_info[p]) >= 2])
                fplates |= valid_plates
        codes = set([code for code in code_plates if code_plates[code] & fplates])
        fcodes = set()
        for c in codes:
            if c not in timeline_data["kline_data"]:
                continue
            # 自由流通市值30-300亿
            pre_close = timeline_data["kline_data"].get(c)[0]["close"]
            if 30e8 <= current_data["zylt_volume"].get(c) * pre_close <= 300e8:
                fcodes.add(c)

        return fcodes

    def __get_target_codes_v4(self):
        valid_codes = self.timeline_data["valid_codes"]
        return set(self.current_data["code_plates_for_buy"].keys()) & valid_codes
@@ -321,8 +288,6 @@
        stock_variables.新代码板块 = timeline_data["code_blocks"].get(code_)
        stock_variables.辨识度代码 = self.fcodes
        stock_variables.领涨板块信息 = self.head_rise_code_blocks.get(code_)
        if code_ in DEBUG_CODES:
            print(code_, stock_variables.领涨板块信息)

        for day in [2, 5, 10, 30, 60, 120]:
            days = timeline_data["trade_days"][:day]
@@ -332,8 +297,7 @@
                                            max_day=days[0]))
        stock_variables.连续老题材 = KPLLimitUpDataAnalyzer.get_continuous_limit_up_reasons(
            timeline_data["limit_up_record_data_list"], self.data_loader.trade_days[:2])


        stock_variables.连续老题材.clear()
        self.stock_variables_dict[code_] = stock_variables

    def load_data(self):
@@ -417,391 +381,407 @@
        return ";".join([f"{x[0]}==净额:{x[1]},买单：{x[2]},卖单：{x[3]}" for x in infos])

    def run(self):
        self.load_data()
        # print(self.fcodes)
        limit_up_record_data_dict = {}
        for limit_up_item in self.timeline_data["limit_up_record_data"]:
            if limit_up_item[0] not in limit_up_record_data_dict:
                limit_up_record_data_dict[limit_up_item[0]] = []
            limit_up_record_data_dict[limit_up_item[0]].append(limit_up_item)
        self.timeline_data["limit_up_record_data"] = limit_up_record_data_dict
        next_trade_day = self.timeline_data["next_trade_day"]
        start_time, end_time = "09:25:00", "12:00:00"
        # 分钟K线
        minute_bars_dict = {}
        code_plates = self.current_data["code_plates"]
        code_plates_for_refer = self.current_data["code_plates_for_refer"]
        try:
            self.load_data()
            # print(self.fcodes)
            limit_up_record_data_dict = {}
            for limit_up_item in self.timeline_data["limit_up_record_data"]:
                if limit_up_item[0] not in limit_up_record_data_dict:
                    limit_up_record_data_dict[limit_up_item[0]] = []
                limit_up_record_data_dict[limit_up_item[0]].append(limit_up_item)
            self.timeline_data["limit_up_record_data"] = limit_up_record_data_dict
            next_trade_day = self.timeline_data["next_trade_day"]
            start_time, end_time = "09:25:00", "12:00:00"
            # 分钟K线
            minute_bars_dict = {}
            code_plates = self.current_data["code_plates"]
            code_plates_for_refer = self.current_data["code_plates_for_refer"]

        # 板块涨停代码信息
        kpl_plate_limit_up_codes_info = None
        plate_limit_up_codes_info = None
        kpl_head_plate_limit_up_codes_info = None
            # 板块涨停代码信息
            kpl_plate_limit_up_codes_info = None
            plate_limit_up_codes_info = None
            kpl_head_plate_limit_up_codes_info = None

        latest_current_limit_up_list = None
            latest_current_limit_up_list = None

        latest_block_in_datas = None
            latest_block_in_datas = None

        # 根据板块获取目标票
        target_plate_codes_infos = {}
        for code in self.head_rise_code_blocks:
            for p in self.head_rise_code_blocks[code]:
                if p not in target_plate_codes_infos:
                    target_plate_codes_infos[p] = []
                target_plate_codes_infos[p].append(self.head_rise_code_blocks[code][p])
        for p in target_plate_codes_infos:
            target_plate_codes_infos[p].sort(key=lambda x: x[1], reverse=True)
            # 根据板块获取目标票
            target_plate_codes_infos = {}
            for code in self.head_rise_code_blocks:
                for p in self.head_rise_code_blocks[code]:
                    if p not in target_plate_codes_infos:
                        target_plate_codes_infos[p] = []
                    target_plate_codes_infos[p].append(self.head_rise_code_blocks[code][p])
            for p in target_plate_codes_infos:
                target_plate_codes_infos[p].sort(key=lambda x: x[1], reverse=True)

        all_new_plates = set()
            all_new_plates = set()

        for i in range(60 * 60 * 5):
            time_str = tool.trade_time_add_second(start_time, i)
            # print(f"[{tool.get_now_time_str()}]", time_str)
            if time_str > end_time:
                break
            ticks = self.current_tick_data.get(time_str) if self.current_tick_data else None
            # ===============统计当前涨停数据
            origin_current_limit_up_list = self.current_data["limit_up_list"].get(time_str, [])
            current_limit_up_list = [x for x in origin_current_limit_up_list if kpl_util.get_high_level_count(x[4]) < 3]
            for i in range(60 * 60 * 5):
                if self.finish:
                    break
                time_str = tool.trade_time_add_second(start_time, i)
                # print(f"[{tool.get_now_time_str()}]", time_str)
                if time_str > end_time:
                    break
                self.current_time = time_str
                ticks = self.current_tick_data.get(time_str) if self.current_tick_data else None
                # ===============统计当前涨停数据
                origin_current_limit_up_list = self.current_data["limit_up_list"].get(time_str, [])
                current_limit_up_list = [x for x in origin_current_limit_up_list if
                                         kpl_util.get_high_level_count(x[4]) < 3]

            if current_limit_up_list:
                latest_current_limit_up_list = current_limit_up_list
                if current_limit_up_list:
                    latest_current_limit_up_list = current_limit_up_list

            if current_limit_up_list:
                plate_codes_info = {}
                # 统计板块涨停
                for x in current_limit_up_list:
                    # 按代码的板块统计涨停板块中的代码数量
                    # 涨停过1分钟才算有效涨停
                    if tool.trade_time_sub(time_str, tool.timestamp_format(x[2], "%H:%M:%S")) < 60:
                        continue
                    plates = code_plates.get(x[0])
                    if plates:
                if current_limit_up_list:
                    plate_codes_info = {}
                    # 统计板块涨停
                    for x in current_limit_up_list:
                        # 按代码的板块统计涨停板块中的代码数量
                        # 涨停过1分钟才算有效涨停
                        if tool.trade_time_sub(time_str, tool.timestamp_format(x[2], "%H:%M:%S")) < 60:
                            continue
                        plates = code_plates.get(x[0])
                        if plates:
                            for p in plates:
                                if p not in plate_codes_info:
                                    plate_codes_info[p] = []
                                plate_codes_info[p].append((x[0], x[2]))
                    plate_limit_up_codes_info = plate_codes_info

                    plate_codes_info = {}
                    for x in current_limit_up_list:
                        # 按开盘啦涨停原因统计
                        p = x[5]
                        if p in constant.KPL_INVALID_BLOCKS:
                            continue
                        if p not in plate_codes_info:
                            plate_codes_info[p] = []
                        # 如果领涨代码里面没有当前票就不算这个板块的涨停原因
                        # 获取领涨数据
                        # head_plate_codes_info = self.data_loader.load_plate_codes(x[9], p)
                        # if head_plate_codes_info:
                        #     plate_codes = set([x[0] for x in head_plate_codes_info])
                        # else:
                        #     plate_codes = set()
                        # if x[0] not in plate_codes:
                        #     continue
                        plate_codes_info[p].append((x[0], x[2], x[4]))
                    kpl_plate_limit_up_codes_info = plate_codes_info

                    # {"代码":[(板块代码, 板块名称)]}
                    limit_up_plate_names_of_refer_code = self.current_data["limit_up_plate_names_of_refer_code"]
                    plate_codes_info = {}
                    for x in current_limit_up_list:
                        # 按开盘啦涨停原因统计
                        code = x[0]
                        # if code not in limit_up_plate_names_of_refer_code:
                        #     continue
                        # 如果记录涨停时间过去20分钟就采用涨停队列的涨停原因
                        if tool.trade_time_sub(time_str, tool.timestamp_format(x[2], "%H:%M:%S")) < 60 * 20 or True:
                            plates_infos = limit_up_plate_names_of_refer_code.get(code)
                            plates = set([d[1] for d in plates_infos if d[1] == x[5]]) if plates_infos else set()
                        else:
                            plates = {x[5]}

                        new_plates = set()
                        for p in plates:
                            if p in constant.KPL_INVALID_BLOCKS:
                                continue
                            new_plates.add(p)
                        for p in new_plates:
                            if p not in plate_codes_info:
                                plate_codes_info[p] = []
                            plate_codes_info[p].append((x[0], x[2]))
                plate_limit_up_codes_info = plate_codes_info
                    kpl_head_plate_limit_up_codes_info = plate_codes_info

                plate_codes_info = {}
                for x in current_limit_up_list:
                    # 按开盘啦涨停原因统计
                    p = x[5]
                    if p in constant.KPL_INVALID_BLOCKS:
                        continue
                    if p not in plate_codes_info:
                        plate_codes_info[p] = []
                    # 如果领涨代码里面没有当前票就不算这个板块的涨停原因
                    # 获取领涨数据
                    # head_plate_codes_info = self.data_loader.load_plate_codes(x[9], p)
                    # if head_plate_codes_info:
                    #     plate_codes = set([x[0] for x in head_plate_codes_info])
                    # else:
                    #     plate_codes = set()
                    # if x[0] not in plate_codes:
                    #     continue
                    plate_codes_info[p].append((x[0], x[2], x[4]))
                kpl_plate_limit_up_codes_info = plate_codes_info
                # ==================注入板块流入
                block_in_datas = self.current_data["block_in"].get(time_str)
                if block_in_datas:
                    blocks = [x[0] for x in block_in_datas if x[1] > 0]
                    block_in_datas = blocks[:20]
                    latest_block_in_datas = block_in_datas

                # {"代码":[(板块代码, 板块名称)]}
                limit_up_plate_names_of_refer_code = self.current_data["limit_up_plate_names_of_refer_code"]
                plate_codes_info = {}
                for x in current_limit_up_list:
                    # 按开盘啦涨停原因统计
                    code = x[0]
                    # if code not in limit_up_plate_names_of_refer_code:
                    #     continue
                    # 如果记录涨停时间过去20分钟就采用涨停队列的涨停原因
                    if tool.trade_time_sub(time_str, tool.timestamp_format(x[2], "%H:%M:%S")) < 60 * 20 or True:
                        plates_infos = limit_up_plate_names_of_refer_code.get(code)
                        plates = set([d[1] for d in plates_infos if d[1] == x[5]]) if plates_infos else set()
                    else:
                        plates = {x[5]}
                # ================当前时刻大单
                current_big_orders = self.current_data["big_order"].get(time_str)
                if current_big_orders:
                    for big_order in current_big_orders:
                        # 格式 ("代码", (买单号, 量, 金额, 时间, 最终成交价))
                        self.init_stock_variables(big_order[0], self.timeline_data, self.current_data)
                        stock_variables: StockVariables = self.stock_variables_dict.get(big_order[0])
                        if stock_variables.今日大单数据 is None:
                            stock_variables.今日大单数据 = []
                        stock_variables.今日大单数据.append(big_order[1])
                        # 统计大单均价
                        order_ids = set()
                        total_money = 0
                        total_volume = 0
                        for order in reversed(stock_variables.今日大单数据):
                            if order[0] in order_ids:
                                continue
                            order_ids.add(order[0])
                            total_money += order[2]
                            total_volume += order[1]
                        if total_volume > 0:
                            stock_variables.今日大单均价 = round(total_money / total_volume, 2)
                        else:
                            stock_variables.今日大单均价 = 0
                current_big_sell_orders = self.current_data["big_sell_order"].get(time_str)
                if current_big_sell_orders:
                    for big_order in current_big_sell_orders:
                        # 格式 ("代码", (买单号, 量, 金额, 时间, 最终成交价))
                        self.init_stock_variables(big_order[0], self.timeline_data, self.current_data)
                        stock_variables: StockVariables = self.stock_variables_dict.get(big_order[0])
                        if stock_variables.今日卖大单数据 is None:
                            stock_variables.今日卖大单数据 = []
                        stock_variables.今日卖大单数据.append(big_order[1])

                    new_plates = set()
                    for p in plates:
                        if p in constant.KPL_INVALID_BLOCKS:
                # 开盘啦最正涨停原因
                most_real_kpl_plate_limit_up_codes_info = {}
                # 获取这个板块的目标票
                if kpl_plate_limit_up_codes_info:
                    current_limit_up_dict = {x[0]: x for x in latest_current_limit_up_list}
                    codes = set()
                    for plate in kpl_plate_limit_up_codes_info:
                        kpl_plate_codes = kpl_plate_limit_up_codes_info.get(plate)
                        codes |= set([x[0] for x in kpl_plate_codes])
                    for code in codes:
                        plates = code_plates.get(code)
                        if not plates:
                            plates = {current_limit_up_dict.get(code)[5]}
                        plates -= constant.KPL_INVALID_BLOCKS
                        if plates:
                            for p in plates:
                                if p not in most_real_kpl_plate_limit_up_codes_info:
                                    most_real_kpl_plate_limit_up_codes_info[p] = []
                                most_real_kpl_plate_limit_up_codes_info[p].append(code)
                    # print(time_str, "涨停数大于3个", [p for p in most_real_kpl_plate_limit_up_codes_info if
                    #                             len(most_real_kpl_plate_limit_up_codes_info[p]) >= 3])

                    # ---------测试--------
                    # test_plate = "化工"
                    # if len(most_real_kpl_plate_limit_up_codes_info.get(test_plate, [])) >= 3:
                    #     print("测试开始=========")
                    #     code_plates_for_buy = self.current_data["code_plates_for_buy"]
                    #     plate_codes = [c for c in code_plates_for_buy if test_plate in code_plates_for_buy[c]]
                    #     print(f"{test_plate}满足", time_str, plate_codes)
                    #     for c in plate_codes:
                    #         sv: StockVariables = self.stock_variables_dict.get(c)
                    #         if sv and sv.当前价 > sv.昨日收盘价:
                    #             print(c)
                    #     print("测试完毕=========")

                if ticks:
                    for tick in ticks:
                        code = tick["symbol"][-6:]
                        if code not in self.fcodes:
                            continue
                        new_plates.add(p)
                    for p in new_plates:
                        if p not in plate_codes_info:
                            plate_codes_info[p] = []
                        plate_codes_info[p].append((x[0], x[2]))
                kpl_head_plate_limit_up_codes_info = plate_codes_info

            # ==================注入板块流入
            block_in_datas = self.current_data["block_in"].get(time_str)
            if block_in_datas:
                blocks = [x[0] for x in block_in_datas if x[1] > 0]
                block_in_datas = blocks[:20]
                latest_block_in_datas = block_in_datas

            # ================当前时刻大单
            current_big_orders = self.current_data["big_order"].get(time_str)
            if current_big_orders:
                for big_order in current_big_orders:
                    # 格式 ("代码", (买单号, 量, 金额, 时间, 最终成交价))
                    self.init_stock_variables(big_order[0], self.timeline_data, self.current_data)
                    stock_variables: StockVariables = self.stock_variables_dict.get(big_order[0])
                    if stock_variables.今日大单数据 is None:
                        stock_variables.今日大单数据 = []
                    stock_variables.今日大单数据.append(big_order[1])
                    # 统计大单均价
                    order_ids = set()
                    total_money = 0
                    total_volume = 0
                    for order in reversed(stock_variables.今日大单数据):
                        if order[0] in order_ids:
                        if self.target_codes and code not in self.target_codes:
                            continue
                        order_ids.add(order[0])
                        total_money += order[2]
                        total_volume += order[1]
                    if total_volume > 0:
                        stock_variables.今日大单均价 = round(total_money / total_volume, 2)
                    else:
                        stock_variables.今日大单均价 = 0
            current_big_sell_orders = self.current_data["big_sell_order"].get(time_str)
            if current_big_sell_orders:
                for big_order in current_big_sell_orders:
                    # 格式 ("代码", (买单号, 量, 金额, 时间, 最终成交价))
                    self.init_stock_variables(big_order[0], self.timeline_data, self.current_data)
                    stock_variables: StockVariables = self.stock_variables_dict.get(big_order[0])
                    if stock_variables.今日卖大单数据 is None:
                        stock_variables.今日卖大单数据 = []
                    stock_variables.今日卖大单数据.append(big_order[1])

            # 开盘啦最正涨停原因
            most_real_kpl_plate_limit_up_codes_info = {}
            # 获取这个板块的目标票
            if kpl_plate_limit_up_codes_info:
                current_limit_up_dict = {x[0]: x for x in latest_current_limit_up_list}
                codes = set()
                for plate in kpl_plate_limit_up_codes_info:
                    kpl_plate_codes = kpl_plate_limit_up_codes_info.get(plate)
                    codes |= set([x[0] for x in kpl_plate_codes])
                for code in codes:
                    plates = code_plates.get(code)
                    if not plates:
                        plates = {current_limit_up_dict.get(code)[5]}
                    plates -= constant.KPL_INVALID_BLOCKS
                    if plates:
                        for p in plates:
                            if p not in most_real_kpl_plate_limit_up_codes_info:
                                most_real_kpl_plate_limit_up_codes_info[p] = []
                            most_real_kpl_plate_limit_up_codes_info[p].append(code)
                # print(time_str, "涨停数大于3个", [p for p in most_real_kpl_plate_limit_up_codes_info if
                #                             len(most_real_kpl_plate_limit_up_codes_info[p]) >= 3])
                        if code not in self.stock_variables_dict:
                            # 加载基础数据
                            self.init_stock_variables(code, self.timeline_data, self.current_data)
                        stock_variables: StockVariables = self.stock_variables_dict.get(code)
                        if plate_limit_up_codes_info is not None:
                            stock_variables.板块涨停 = plate_limit_up_codes_info

                # ---------测试--------
                # test_plate = "化工"
                # if len(most_real_kpl_plate_limit_up_codes_info.get(test_plate, [])) >= 3:
                #     print("测试开始=========")
                #     code_plates_for_buy = self.current_data["code_plates_for_buy"]
                #     plate_codes = [c for c in code_plates_for_buy if test_plate in code_plates_for_buy[c]]
                #     print(f"{test_plate}满足", time_str, plate_codes)
                #     for c in plate_codes:
                #         sv: StockVariables = self.stock_variables_dict.get(c)
                #         if sv and sv.当前价 > sv.昨日收盘价:
                #             print(c)
                #     print("测试完毕=========")
                        if kpl_plate_limit_up_codes_info is not None:
                            stock_variables.开盘啦板块涨停 = kpl_plate_limit_up_codes_info

            if ticks:
                for tick in ticks:
                    code = tick["symbol"][-6:]
                    if code not in self.fcodes:
                        continue
                    if DEBUG_CODES and code not in DEBUG_CODES:
                        continue
                        if kpl_head_plate_limit_up_codes_info is not None:
                            stock_variables.开盘啦领涨板块涨停 = kpl_head_plate_limit_up_codes_info

                    if code not in self.stock_variables_dict:
                        # 加载基础数据
                        stock_variables.板块成交代码 = self.deal_block_codes
                        # 板块流入数据
                        if latest_block_in_datas:
                            stock_variables.资金流入板块 = latest_block_in_datas
                        # 暂时不用分钟K线
                        # if code not in minute_bars_dict:
                        #     minute_bars_dict[code] = [tick]
                        # if minute_bars_dict[code][-1]["created_at"][:-2] == tick["created_at"][:-2]:
                        #     # 统计分钟K线
                        #     minute_bars_dict[code][-1] = tick
                        # else:
                        #     # 保存分钟K线最高价
                        #     if not stock_variables.今日最高价:
                        #         stock_variables.今日最高价 = minute_bars_dict[code][-1]["price"]
                        #     if minute_bars_dict[code][-1]["price"] > stock_variables.今日最高价:
                        #         stock_variables.今日最高价 = minute_bars_dict[code][-1]["price"]

                        # 保存开盘价
                        if tick["created_at"][-8:] < '09:30:00':
                            stock_variables.今日开盘价 = tick["price"]
                            # 今日开盘涨幅
                            stock_variables.今日开盘涨幅 = round(
                                (tick["price"] - stock_variables.昨日收盘价) / stock_variables.昨日收盘价,
                                4)
                        stock_variables.今日成交量 = tick["cum_volume"]
                        stock_variables.今日成交额 = tick["cum_amount"]
                        stock_variables.当前价 = tick["price"]
                        if not stock_variables.今日量够信息:
                            if stock_variables.今日成交量 > stock_variables.昨日成交量 * 0.8:
                                stock_variables.今日量够信息 = (time_str, stock_variables.当前价, round(
                                    (stock_variables.当前价 - stock_variables.昨日收盘价) * 100 / stock_variables.昨日收盘价, 2),
                                                          self.__statistic_big_order_info(stock_variables))
                                if VOLUME_LOG_ENABLE:
                                    # 统计大单净额，(50w以上,净额,买单个数/买单总金额,卖单个数/卖单总金额)
                                    print("****量够", code, stock_variables.今日量够信息)

                        # 统计今日最高价
                        # if stock_variables.今日最高价 and tick["price"] > stock_variables.今日最高价:
                        #     print(code, "====突破分时最高价：", tick["created_at"], tick["price"])

                        if not stock_variables.今日最高价信息 or tick["price"] > stock_variables.今日最高价信息[0]:
                            stock_variables.今日最高价信息 = (tick["price"], time_str)

                        if not stock_variables.今日最低价 or tick["price"] < stock_variables.今日最低价:
                            stock_variables.今日最低价 = tick["price"]
                        if most_real_kpl_plate_limit_up_codes_info:
                            stock_variables.开盘啦最正板块涨停 = most_real_kpl_plate_limit_up_codes_info

                        # if time_str >= '09:30:00':
                        #     if stock_variables.今日大单数据 and stock_variables.开盘啦最正板块涨停 and max(
                        #             [len(stock_variables.开盘啦最正板块涨停.get(x, [])) for x in stock_variables.代码板块]) >= 3:
                        #         compute_result = self.__run_backtest(code, stock_variables)
                        #         self.__process_test_result(code, stock_variables, next_trade_day, stock_variables.当前价,
                        #                                    time_str, compute_result)

                        # if len(real_codes) >= 2 and time_str > '09:30:00':
                        #     # print(time_str, plate)
                        #     # 找这个板块领涨次数最多的票
                        #     codes_infos = target_plate_codes_infos.get(plate)
                        #     if codes_infos:
                        #         for code_info in codes_infos:
                        #             code = code_info[0]
                        #             self.init_stock_variables(code, self.timeline_data, self.current_data)
                        #             stock_variables: StockVariables = self.stock_variables_dict.get(code)
                        #             compute_result = self.__run_backtest(code, stock_variables)
                        #             if compute_result[0] and plate not in all_new_plates:
                        #                 all_new_plates.add(plate)
                        #                 print(plate, time_str, code_info, real_codes)
                        #             else:
                        #                 pass

                # 大单驱动
                if current_big_orders and time_str >= '09:30:00':
                    for big_order in current_big_orders:
                        code = big_order[0]
                        if code not in self.fcodes:
                            continue
                        if self.target_codes and code not in self.target_codes:
                            continue
                        self.init_stock_variables(code, self.timeline_data, self.current_data)
                    stock_variables: StockVariables = self.stock_variables_dict.get(code)
                    if plate_limit_up_codes_info is not None:
                        stock_variables.板块涨停 = plate_limit_up_codes_info
                        stock_variables: StockVariables = self.stock_variables_dict.get(code)
                        if plate_limit_up_codes_info is not None:
                            stock_variables.板块涨停 = plate_limit_up_codes_info

                    if kpl_plate_limit_up_codes_info is not None:
                        stock_variables.开盘啦板块涨停 = kpl_plate_limit_up_codes_info
                        if kpl_plate_limit_up_codes_info is not None:
                            stock_variables.开盘啦板块涨停 = kpl_plate_limit_up_codes_info

                    if kpl_head_plate_limit_up_codes_info is not None:
                        stock_variables.开盘啦领涨板块涨停 = kpl_head_plate_limit_up_codes_info
                        if kpl_head_plate_limit_up_codes_info is not None:
                            stock_variables.开盘啦领涨板块涨停 = kpl_head_plate_limit_up_codes_info

                    stock_variables.板块成交代码 = self.deal_block_codes
                    # 板块流入数据
                    if latest_block_in_datas:
                        stock_variables.资金流入板块 = latest_block_in_datas
                    # 暂时不用分钟K线
                    # if code not in minute_bars_dict:
                    #     minute_bars_dict[code] = [tick]
                    # if minute_bars_dict[code][-1]["created_at"][:-2] == tick["created_at"][:-2]:
                    #     # 统计分钟K线
                    #     minute_bars_dict[code][-1] = tick
                    # else:
                    #     # 保存分钟K线最高价
                    #     if not stock_variables.今日最高价:
                    #         stock_variables.今日最高价 = minute_bars_dict[code][-1]["price"]
                    #     if minute_bars_dict[code][-1]["price"] > stock_variables.今日最高价:
                    #         stock_variables.今日最高价 = minute_bars_dict[code][-1]["price"]
                        if most_real_kpl_plate_limit_up_codes_info is not None:
                            stock_variables.开盘啦最正板块涨停 = most_real_kpl_plate_limit_up_codes_info

                    # 保存开盘价
                    if tick["created_at"][-8:] < '09:30:00':
                        stock_variables.今日开盘价 = tick["price"]
                        # 今日开盘涨幅
                        stock_variables.今日开盘涨幅 = round((tick["price"] - stock_variables.昨日收盘价) / stock_variables.昨日收盘价,
                                                       4)
                    stock_variables.今日成交量 = tick["cum_volume"]
                    stock_variables.今日成交额 = tick["cum_amount"]
                    stock_variables.当前价 = tick["price"]
                    if not stock_variables.今日量够信息:
                        if stock_variables.今日成交量 > stock_variables.昨日成交量 * 0.8:
                            stock_variables.今日量够信息 = (time_str, stock_variables.当前价, round(
                                (stock_variables.当前价 - stock_variables.昨日收盘价) * 100 / stock_variables.昨日收盘价, 2),
                                                      self.__statistic_big_order_info(stock_variables))
                            if VOLUME_LOG_ENABLE:
                                # 统计大单净额，(50w以上,净额,买单个数/买单总金额,卖单个数/卖单总金额)
                                print("****量够", code, stock_variables.今日量够信息)
                        if block_in_datas:
                            stock_variables.资金流入板块 = block_in_datas

                    # 统计今日最高价
                    # if stock_variables.今日最高价 and tick["price"] > stock_variables.今日最高价:
                    #     print(code, "====突破分时最高价：", tick["created_at"], tick["price"])
                        stock_variables.当前价 = big_order[1][4]
                        try:
                            compute_result = self.__run_backtest(code, stock_variables)
                            # print(compute_result)
                            self.__process_test_result(code, stock_variables, next_trade_day, big_order[1][4],
                                                       huaxin_util.convert_time(big_order[1][3]), compute_result)
                        except Exception as e:
                            print(time_str)
                            logging.exception(e)

                    if not stock_variables.今日最高价信息 or tick["price"] > stock_variables.今日最高价信息[0]:
                        stock_variables.今日最高价信息 = (tick["price"], time_str)

                    if not stock_variables.今日最低价 or tick["price"] < stock_variables.今日最低价:
                        stock_variables.今日最低价 = tick["price"]
                    if most_real_kpl_plate_limit_up_codes_info:
                        stock_variables.开盘啦最正板块涨停 = most_real_kpl_plate_limit_up_codes_info

                    # if time_str >= '09:30:00':
                    #     if stock_variables.今日大单数据 and stock_variables.开盘啦最正板块涨停 and max(
                    #             [len(stock_variables.开盘啦最正板块涨停.get(x, [])) for x in stock_variables.代码板块]) >= 3:
                    #         compute_result = self.__run_backtest(code, stock_variables)
                    #         self.__process_test_result(code, stock_variables, next_trade_day, stock_variables.当前价,
                    #                                    time_str, compute_result)

                    # if len(real_codes) >= 2 and time_str > '09:30:00':
                    #     # print(time_str, plate)
                    #     # 找这个板块领涨次数最多的票
                    #     codes_infos = target_plate_codes_infos.get(plate)
                    #     if codes_infos:
                    #         for code_info in codes_infos:
                    #             code = code_info[0]
                    #             self.init_stock_variables(code, self.timeline_data, self.current_data)
                    #             stock_variables: StockVariables = self.stock_variables_dict.get(code)
                    #             compute_result = self.__run_backtest(code, stock_variables)
                    #             if compute_result[0] and plate not in all_new_plates:
                    #                 all_new_plates.add(plate)
                    #                 print(plate, time_str, code_info, real_codes)
                    #             else:
                    #                 pass

            # 大单驱动
            if current_big_orders and time_str >= '09:30:00':
                for big_order in current_big_orders:
                    code = big_order[0]
                    if code not in self.fcodes:
                        continue
                    if DEBUG_CODES and code not in DEBUG_CODES:
                        continue
                    self.init_stock_variables(code, self.timeline_data, self.current_data)
                    stock_variables: StockVariables = self.stock_variables_dict.get(code)
                    if plate_limit_up_codes_info is not None:
                        stock_variables.板块涨停 = plate_limit_up_codes_info

                    if kpl_plate_limit_up_codes_info is not None:
                        stock_variables.开盘啦板块涨停 = kpl_plate_limit_up_codes_info

                    if kpl_head_plate_limit_up_codes_info is not None:
                        stock_variables.开盘啦领涨板块涨停 = kpl_head_plate_limit_up_codes_info

                    if most_real_kpl_plate_limit_up_codes_info is not None:
                        stock_variables.开盘啦最正板块涨停 = most_real_kpl_plate_limit_up_codes_info

                    if block_in_datas:
                        stock_variables.资金流入板块 = block_in_datas

                    stock_variables.当前价 = big_order[1][4]
                    try:
                        compute_result = self.__run_backtest(code, stock_variables)
                        # print(compute_result)
                        self.__process_test_result(code, stock_variables, next_trade_day, big_order[1][4],
                                                   huaxin_util.convert_time(big_order[1][3]), compute_result)
                    except Exception as e:
                        print(time_str)
                        logging.exception(e)

        print("可买题材：", all_new_plates)
            print("可买题材：", all_new_plates)
        finally:
            self.finish = True

    def __process_test_result(self, code, stock_variables: StockVariables, next_trade_day, buy_price, time_str,
                              compute_result):

        # if code == '000628':
        #     print(time_str, code, compute_result)
        # (时间,(代码,代码名称), 涨幅 , 买入结果)
        backtest_result = [time_str, (code, gpcode_manager.get_code_name(code)),
                           round((buy_price - stock_variables.昨日收盘价) * 100 / stock_variables.昨日收盘价, 2),
                           compute_result]

        if not compute_result[0]:
            if code in DEBUG_CODES:
                print(time_str, code, compute_result[1])
            # if compute_result[1].find("大单") >= 0 or compute_result[1].find("价格超过昨日最低价") >= 0:
            pass
        try:
            if not compute_result[0]:
                if code in self.target_codes:
                    print(time_str, code, compute_result[1])
                # if compute_result[1].find("大单") >= 0 or compute_result[1].find("价格超过昨日最低价") >= 0:
                pass

        # print(code, time_str,stock_variables.代码板块, compute_result)
            # print(code, time_str,stock_variables.代码板块, compute_result)

        if compute_result[0] and code not in self.deal_codes:
            # 最多买5个
            if len(self.deal_codes) >= 100:
                return
            # if huaxin_util.convert_time(big_order[1][3]) >= "10:30:00" and len(deal_codes) > 0:
            #     break
            self.deal_codes.add(code)
            next_k_bars = self.data_loader.load_kline_data_by_day_and_code(next_trade_day, code)
            current_k_bars = self.data_loader.load_kline_data_by_day_and_code(self.data_loader.now_day,
                                                                              code)
            if next_k_bars and buy_price:
                t_rate = round((next_k_bars[0]["open"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
                t_rate = f"{t_rate}%"
            else:
                # 获取当前的tick线
                if self.data_loader.now_day >= next_trade_day:
                    ticks = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1, frequency='tick',
                                                                               end_date=f"{next_trade_day} 09:30:03")
                else:
                    ticks = None
                if ticks:
                    t_rate = round((ticks[-1]["price"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
            if compute_result[0] and code not in self.deal_codes:
                # 最多买5个
                if len(self.deal_codes) >= 100:
                    return
                # if huaxin_util.convert_time(big_order[1][3]) >= "10:30:00" and len(deal_codes) > 0:
                #     break
                self.deal_codes.add(code)
                next_k_bars = self.data_loader.load_kline_data_by_day_and_code(next_trade_day, code)
                current_k_bars = self.data_loader.load_kline_data_by_day_and_code(self.data_loader.now_day,
                                                                                  code)
                if next_k_bars and buy_price:
                    t_rate = round((next_k_bars[0]["open"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
                    t_rate = f"{t_rate}%"
                else:
                    t_rate = "未知"
            if current_k_bars and buy_price:
                c_rate = round((current_k_bars[0]["close"] - buy_price) * 100 / current_k_bars[0]["pre_close"], 2)
                c_rate = f"{c_rate}%"
            else:
                # 拉取当日K线
                if tool.get_now_date_str() == self.data_loader.now_day and buy_price:
                    tick = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1, frequency='tick',
                                                                              end_date=f"{self.data_loader.now_day} {tool.get_now_time_str()}")
                    c_rate = round((tick[0]["price"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
                else:
                    bar = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1,
                                                                             end_date=f"{self.data_loader.now_day} 15:00:00")
                    if bar:
                        c_rate = round((bar[0]["close"] - buy_price) * 100 / bar[0]["pre_close"], 2)
                    # 获取当前的tick线
                    if self.data_loader.now_day >= next_trade_day:
                        ticks = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1, frequency='tick',
                                                                                   end_date=f"{next_trade_day} 09:30:03")
                    else:
                        c_rate = "未知"
            print(f"{len(self.deal_codes)}==回测结果：", code, gpcode_manager.CodesNameManager().get_code_name(code),
                  f"溢价率：{t_rate},当日盈亏：{c_rate}，下单时间：{time_str}，涨幅：{round((buy_price - stock_variables.昨日收盘价) * 100 / stock_variables.昨日收盘价, 2)}",
                  compute_result[1],
                  compute_result[2])
            for b in compute_result[3]:
                if b not in self.deal_block_codes:
                    self.deal_block_codes[b] = set()
                self.deal_block_codes[b].add(code)
            stock_variables.板块成交代码 = self.deal_block_codes
                        ticks = None
                    if ticks:
                        t_rate = round((ticks[-1]["price"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
                        t_rate = f"{t_rate}%"
                    else:
                        t_rate = "未知"
                if current_k_bars and buy_price:
                    c_rate = round((current_k_bars[0]["close"] - buy_price) * 100 / current_k_bars[0]["pre_close"], 2)
                    c_rate = f"{c_rate}%"
                else:
                    # 拉取当日K线
                    if tool.get_now_date_str() == self.data_loader.now_day and buy_price:
                        tick = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1, frequency='tick',
                                                                                  end_date=f"{self.data_loader.now_day} {tool.get_now_time_str()}")
                        c_rate = round((tick[0]["price"] - buy_price) * 100 / stock_variables.昨日收盘价, 2)
                    else:
                        bar = self.data_loader.jueJinLocalApi.get_history_tick_n(code, 1,
                                                                                 end_date=f"{self.data_loader.now_day} 15:00:00")
                        if bar:
                            c_rate = round((bar[0]["close"] - buy_price) * 100 / bar[0]["pre_close"], 2)
                        else:
                            c_rate = "未知"
                backtest_result.append(c_rate)
                backtest_result.append(t_rate)
                print(f"{len(self.deal_codes)}==回测结果：", code, gpcode_manager.CodesNameManager().get_code_name(code),
                      f"溢价率：{t_rate},当日盈亏：{c_rate}，下单时间：{time_str}，涨幅：{round((buy_price - stock_variables.昨日收盘价) * 100 / stock_variables.昨日收盘价, 2)}",
                      compute_result[1],
                      compute_result[2])
                for b in compute_result[3]:
                    if b not in self.deal_block_codes:
                        self.deal_block_codes[b] = set()
                    self.deal_block_codes[b].add(code)
                stock_variables.板块成交代码 = self.deal_block_codes

        finally:
            self.backtest_results.append(backtest_result)


# 锂电池 ['002882', '002667', '002846', '300530', '002074', '301662', '002580', '300584', '603399', '601515']
# 化工 ['600610', '002427', '002165', '002809', '000565', '002365', '603192', '600370', '600800', '603188']
DEBUG_CODES = ['605005', '002590', '002813', '000826', '002973', '603686', '001230', '600684', '000981', '002232']
# DEBUG_CODES = []

VOLUME_LOG_ENABLE = False
# 备用大单
@@ -818,7 +798,7 @@
            "2025-05-30", "2025-06-03", "2025-06-04", "2025-06-05", "2025-06-06", "2025-06-09", "2025-06-10"]
    days = ["2025-06-03", "2025-06-04", "2025-06-05", "2025-06-06", "2025-06-09", "2025-06-10",
            "2025-06-11", "2025-06-12", "2025-06-13", "2025-06-16", "2025-06-17", "2025-06-18", "2025-06-19",
            "2025-06-20", "2025-06-23", "2025-06-24", "2025-06-25"]
            "2025-06-20", "2025-06-23", "2025-06-24", "2025-06-25", "2025-06-26", "2025-06-27", "2025-06-30"]

    # days = ["2025-05-23"]
    #