涨停后板块不是老大撤单

Administrator

2023-09-09 8165b72761b0729e5cc3ca00c9f2f52215055229

涨停后板块不是老大撤单

 third_data/code_plate_key_manager.py

@@ -428,6 +428,47 @@
        l2_trade_util.forbidden_trade(code)
        logger_kpl_block_can_buy.info(msg)

    @classmethod
    def __is_block_can_buy(cls, code, block, current_limit_up_datas, code_limit_up_reason_dict,
                           yesterday_current_limit_up_codes, limit_up_record_datas):
        log.logger_kpl_debug.info(f"判断板块是否可买：{block}")
        # is_top_8_record, top_8_record = kpl_block_util.is_record_top_block(code, block, limit_up_record_datas,
        #                                                                    yesterday_current_limit_up_codes, 50)
        # is_top_4_current, top_4_current = kpl_block_util.is_current_top_block(code, block, current_limit_up_datas,
        #                                                                       yesterday_current_limit_up_codes, 50)
        # is_top_4 = is_top_8_record and is_top_4_current
        # msg_list.append(f"\n实时top10(涨停数量：{len(current_limit_up_datas)})")
        # msg_list.append(f"历史top20(涨停数量：{len(top_8_record)})")

        # 获取主板实时身位,剔除高位板
        current_shsz_rank = kpl_block_util.get_code_current_rank(code, block, current_limit_up_datas,
                                                                 code_limit_up_reason_dict,
                                                                 yesterday_current_limit_up_codes, shsz=True)
        record_shsz_rank = kpl_block_util.get_code_record_rank(code, block, limit_up_record_datas,
                                                               code_limit_up_reason_dict,
                                                               yesterday_current_limit_up_codes, shsz=True)
        # 获取主板历史身位

        pen_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
                                                                         code_limit_up_reason_dict)
        if pen_limit_up_codes:
            # 主板开1
            if current_shsz_rank < len(pen_limit_up_codes) + 1 and record_shsz_rank < len(pen_limit_up_codes) + 1:
                # 属于龙1,龙2
                return True, f"{tool.get_now_time_str()} {block}：top10涨停板块，主板开1({pen_limit_up_codes}),属于主板前龙{len(pen_limit_up_codes) + 1}(实时身位-{current_shsz_rank}/{len(current_limit_up_datas)})"
            else:
                if record_shsz_rank >= len(pen_limit_up_codes) + 1:
                    cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")
                return False, f"板块-{block}: top4涨停板块，主板开1（{pen_limit_up_codes}）,不为主板前龙{len(pen_limit_up_codes) + 1}（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）"
        else:
            if current_shsz_rank == 0 and record_shsz_rank < 2:
                return True, f"{tool.get_now_time_str()} {block}：top4涨停板块，非主板开1，属于龙1，实时涨停列表数量({len(current_limit_up_datas)})"
            else:
                if record_shsz_rank >= 2:
                    cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")

                return False, f"板块-{block}: top4涨停板块，非主板开1,不为主板龙1（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）"

    # 获取可以买的板块
    # current_limit_up_datas: 今日实时涨停
    # latest_2_day_limit_up_datas：最近2天的实时涨停（不含今日）
@@ -445,6 +486,7 @@
                else:
                    code_limit_up_reason_dict[d[3]] = d[2]
            return code_limit_up_reason_dict

        if current_limit_up_datas is None:
            current_limit_up_datas = []

@@ -474,67 +516,13 @@

        can_buy_blocks = []
        for block in keys:
            log.logger_kpl_debug.info(f"判断板块是否可买：{block}")
            # is_top_8_record, top_8_record = kpl_block_util.is_record_top_block(code, block, limit_up_record_datas,
            #                                                                    yesterday_current_limit_up_codes, 50)
            # is_top_4_current, top_4_current = kpl_block_util.is_current_top_block(code, block, current_limit_up_datas,
            #                                                                       yesterday_current_limit_up_codes, 50)
            # is_top_4 = is_top_8_record and is_top_4_current
            # msg_list.append(f"\n实时top10(涨停数量：{len(current_limit_up_datas)})")
            # msg_list.append(f"历史top20(涨停数量：{len(top_8_record)})")

            # 获取主板实时身位,剔除高位板
            current_shsz_rank = kpl_block_util.get_code_current_rank(code, block, current_limit_up_datas,
                                                                     code_limit_up_reason_dict,
                                                                     yesterday_current_limit_up_codes, shsz=True)
            record_shsz_rank = kpl_block_util.get_code_record_rank(code, block, limit_up_record_datas,
                                                                   code_limit_up_reason_dict,
                                                                   yesterday_current_limit_up_codes, shsz=True)
            # 获取主板历史身位
            if True:
                pen_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
                                                                                 code_limit_up_reason_dict)
                if pen_limit_up_codes:
                    # 主板开1
                    if current_shsz_rank < len(pen_limit_up_codes) + 1 and record_shsz_rank < len(pen_limit_up_codes) + 1:
                        # 属于龙1,龙2
                        can_buy_blocks.append((block,
                                               f"{tool.get_now_time_str()} {block}：top10涨停板块，主板开1({pen_limit_up_codes}),属于主板前龙{len(pen_limit_up_codes) + 1}(实时身位-{current_shsz_rank}/{len(current_limit_up_datas)})"))
                        continue
                    else:
                        if record_shsz_rank >= len(pen_limit_up_codes) + 1:
                            cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")
                        msg_list.append(
                            f"板块-{block}: top4涨停板块，主板开1（{pen_limit_up_codes}）,不为主板前龙{len(pen_limit_up_codes) + 1}（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）")
                        continue
                else:
                    if current_shsz_rank == 0 and record_shsz_rank < 2:
                        can_buy_blocks.append((block, f"{tool.get_now_time_str()} {block}：top4涨停板块，非主板开1，属于龙1，实时涨停列表数量({len(current_limit_up_datas)})"))
                        continue
                    else:
                        if record_shsz_rank >= 2:
                            cls.__remove_from_l2(code, f"{code}根据身位禁止买入：【{block}】历史身位{record_shsz_rank}")

                        msg_list.append(
                            f"板块-{block}: top4涨停板块，非主板开1,不为主板龙1（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）")
                        continue
            can_buy, msg = cls.__is_block_can_buy(code, block, current_limit_up_datas, code_limit_up_reason_dict,
                                                  yesterday_current_limit_up_codes, limit_up_record_datas)
            if can_buy:
                can_buy_blocks.append((block, msg))
            else:
                pass
                # # 是否满足行业精选流入要求
                # is_in_top_input = RealTimeKplMarketData.is_in_top(set([block]))[0]
                # if not is_in_top_input:
                #     msg_list.append(
                #         f"板块-{block}: 非top4涨停板块，不满足精选/行业流入要求")
                #     continue
                # else:
                #     # 是否为主板龙1（实时龙1，历史龙2以内）
                #     if current_shsz_rank == 0 and record_shsz_rank < 2:
                #         can_buy_blocks.append((block, f"{block}：不是top4涨停板块，满足精选/行业流入要求，满足主板龙1"))
                #         continue
                #     else:
                #         msg_list.append(
                #             f"板块-{block}: 不是top4涨停板块，满足精选/行业流入要求,不为主板龙1（实时身位-{current_shsz_rank},历史身位-{record_shsz_rank}）")
                #         continue
                msg_list.append(msg)
        if len(can_buy_blocks) == len(keys):
            blocks = [x[0] for x in can_buy_blocks]
            blocks_msg = "\n".join([x[1] for x in can_buy_blocks])
@@ -604,6 +592,7 @@

        return False, ",".join(msg_list)

    # 更新代码板块判断是否可以买的结果
    @classmethod
    def update_can_buy_blocks(cls, code, current_limit_up_datas, limit_up_record_datas,
                              yesterday_current_limit_up_codes,
@@ -614,6 +603,40 @@
        # 保存板块计算结果
        cls.__can_buy_compute_result_dict[code] = (can_buy, msg)

    # 判断是否为真老大
    @classmethod
    def __is_real_first_limit_up(cls, code, block, current_limit_up_datas, limit_up_record_datas,
                                 yesterday_current_limit_up_codes,
                                 before_blocks_dict):
        # 加载涨停代码的目标板块
        def load_code_block():
            for d in limit_up_record_datas:
                if d[2] in constant.KPL_INVALID_BLOCKS and d[3] in before_blocks_dict:
                    code_limit_up_reason_dict[d[3]] = list(before_blocks_dict.get(d[3]))[0]
                else:
                    code_limit_up_reason_dict[d[3]] = d[2]
            return code_limit_up_reason_dict

        if current_limit_up_datas is None:
            current_limit_up_datas = []
        code_limit_up_reason_dict = {}
        load_code_block()
        can_buy, msg = cls.__is_block_can_buy(code, block, current_limit_up_datas, code_limit_up_reason_dict,
                                              yesterday_current_limit_up_codes, limit_up_record_datas)
        return can_buy, msg

    @classmethod
    def is_need_cancel(cls, code, limit_up_reason, current_limit_up_datas, limit_up_record_datas,
                       yesterday_current_limit_up_codes,
                       before_blocks_dict):
        can_buy, msg = cls.__is_real_first_limit_up(code, limit_up_reason, current_limit_up_datas,
                                                    limit_up_record_datas,
                                                    yesterday_current_limit_up_codes,
                                                    before_blocks_dict)
        if not can_buy:
            logger_kpl_block_can_buy.warning(f"{code} 根据涨停原因（{limit_up_reason}）匹配不能买")
        return not can_buy


if __name__ == "__main__":
    pass

 third_data/data_server.py

@@ -10,11 +10,11 @@
from utils import global_util, tool
from code_attribute import gpcode_manager
from log_module import log, log_analyse, log_export
from l2 import code_price_manager, l2_data_util
from l2 import code_price_manager, l2_data_util, l2_data_manager_new
from l2.cancel_buy_strategy import HourCancelBigNumComputer
from output.limit_up_data_filter import IgnoreCodeManager
from third_data import kpl_util, kpl_data_manager, kpl_api
from third_data.code_plate_key_manager import RealTimeKplMarketData, KPLPlateForbiddenManager
from third_data import kpl_util, kpl_data_manager, kpl_api, block_info
from third_data.code_plate_key_manager import RealTimeKplMarketData, KPLPlateForbiddenManager, CodePlateKeyBuyManager
from third_data.history_k_data_util import HistoryKDatasUtils
from third_data.kpl_data_manager import KPLDataManager, KPLLimitUpDataRecordManager, \
    KPLCodeLimitUpReasonManager
@@ -23,7 +23,7 @@
from urllib.parse import parse_qs
from output import code_info_output, limit_up_data_filter, output_util, kp_client_msg_manager

from trade import bidding_money_manager, trade_manager
from trade import bidding_money_manager, trade_manager, l2_trade_util
from trade.l2_trade_util import BlackListCodeManager


@@ -41,6 +41,7 @@
    # 精选,行业数据缓存
    __jingxuan_cache_dict = {}
    __industry_cache_dict = {}
    __latest_limit_up_codes_set = set()

    def __get_limit_up_list(self):
        # 统计目前为止的代码涨停数量（分涨停原因）
@@ -481,11 +482,34 @@
        def do_limit_up(result_list_):
            if result_list_:
                # 保存涨停时间
                codes_set = set()
                limit_up_reasons = {}
                for d in result_list_:
                    code = d[0]
                    limit_up_reasons[code] = d[5]
                    codes_set.add(code)
                    if code.find("00") == 0 or code.find("60") == 0:
                        limit_up_time = time.strftime("%H:%M:%S", time.localtime(d[2]))
                        code_price_manager.Buy1PriceManager().set_limit_up_time(code, limit_up_time)
                add_codes = codes_set - self.__latest_limit_up_codes_set
                self.__latest_limit_up_codes_set = codes_set
                if add_codes:
                    for code in add_codes:
                        # 根据涨停原因判断是否可以买
                        if code.find("00") == 0 or code.find("60") == 0:
                            # 判断是否下单
                            trade_state = trade_manager.CodesTradeStateManager().get_trade_state(code)
                            if trade_state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_manager.TRADE_STATE_BUY_DELEGATED:
                                # 委托中的订单，判断是否需要撤单
                                if not gpcode_manager.WantBuyCodesManager().is_in_cache(code):
                                    yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
                                    current_limit_up_datas, limit_up_record_datas, yesterday_current_limit_up_codes, before_blocks_dict = kpl_data_manager.KPLLimitUpDataRecordManager.latest_origin_datas, kpl_data_manager.KPLLimitUpDataRecordManager.total_datas, yesterday_codes, block_info.get_before_blocks_dict()
                                    if CodePlateKeyBuyManager.is_need_cancel(code, limit_up_reasons.get(code),
                                                                             current_limit_up_datas,
                                                                             limit_up_record_datas,
                                                                             yesterday_current_limit_up_codes,
                                                                             before_blocks_dict):
                                        l2_data_manager_new.L2TradeDataProcessor.cancel_buy(code, f"涨停原因（{ limit_up_reasons.get(code)}）不是老大撤单", "板块撤")
                kpl_data_manager.KPLLimitUpDataRecordManager.save_record(tool.get_now_date_str(), result_list_)
                self.__kplDataManager.save_data(type_, result_list_)