bug修复

Administrator

2025-05-27 7c6d06136079b73c5676c716c992fdebb23cca7c

 l2/l2_data_manager_new.py

@@ -262,6 +262,7 @@
        """
        if code in cls.__human_radical_buy_mark_info:
            return True
        return False

    @classmethod
    def is_valid(cls, code, data):
@@ -1040,7 +1041,6 @@
            else:

                try:

                    # 判断是否为首封下单
                    order_begin_pos.first_limit_up_buy = radical_buy_data_manager.is_first_limit_up_buy(code)

@@ -1053,7 +1053,7 @@
                                                                 order_begin_pos.buy_exec_index,
                                                                 local_today_datas.get(code))
                        return False
                    l2_log.debug(code, "可以下单，原因：{}， 下单模式：{}", reason, order_begin_pos.mode)
                    l2_log.debug(code, "可以下单，原因：{}， 下单模式：{} 最小订单号：{}", reason, order_begin_pos.mode, order_begin_pos.min_order_no)
                    l2_log.debug(code, "开始执行买入")
                    trade_manager.start_buy(code, capture_timestamp, last_data,
                                            last_data_index, order_begin_pos.mode, order_begin_pos.buy_exec_index)
@@ -1521,32 +1521,35 @@
        _start_time = tool.get_now_timestamp()
        total_datas = local_today_datas[code]

        if not HumanRadicalBuySingleManager.has_single(code):
            # ---------计算激进买入的信号---------
            radical_result = cls.__compute_radical_order_begin_pos(code, compute_start_index, compute_end_index)
        else:
            human_radical_result = cls.__compute_human_radical_order_begin_pos(code, compute_start_index,
                                                                               compute_end_index)
            l2_log.debug(code, f"大单足够，人为下单计算结果({compute_start_index}-{compute_end_index}):{human_radical_result}")
            if human_radical_result[0]:
                radical_result = list(human_radical_result[2])
                # 改变执行位置
                radical_result[1] = human_radical_result[1]["index"]
            else:
                radical_result = None
        # 不需要根据人为下单来下单
        # if not HumanRadicalBuySingleManager.has_single(code):
        #     # ---------计算激进买入的信号---------
        #     radical_result = cls.__compute_radical_order_begin_pos(code, compute_start_index, compute_end_index)
        # else:
        #     human_radical_result = cls.__compute_human_radical_order_begin_pos(code, compute_start_index,
        #                                                                        compute_end_index)
        #     l2_log.debug(code, f"大单足够，人为下单计算结果({compute_start_index}-{compute_end_index}):{human_radical_result}")
        #     if human_radical_result[0]:
        #         radical_result = list(human_radical_result[2])
        #         # 改变执行位置
        #         radical_result[1] = human_radical_result[1]["index"]
        #     else:
        #         radical_result = None

        radical_result = cls.__compute_radical_order_begin_pos(code, compute_start_index, compute_end_index)
        if radical_result and radical_result[0]:

            if not HumanRadicalBuySingleManager.has_single(code):
                big_order_deal_enough_result = radical_buy_data_manager.is_big_order_deal_enough(code,
                                                                                                 code_volumn_manager.CodeVolumeManager().get_volume_rate_refer_in_5days(
                                                                                                     code), 0)
                if big_order_deal_enough_result[6] <= 0:
                    HumanRadicalBuySingleManager.add_single(code, total_datas[-1], radical_result)
                    async_log_util.info(logger_l2_not_buy_reasons, f"{code}#大单足够，需要根据人为下单({compute_start_index}-{compute_end_index})：{radical_result[1]}")
                    return
            # 下单前一步，移除人为下单信号
            is_human_radical_buy = HumanRadicalBuySingleManager.has_single(code)
            HumanRadicalBuySingleManager.remove_single(code)
            # if not HumanRadicalBuySingleManager.has_single(code):
            #     big_order_deal_enough_result = radical_buy_data_manager.is_big_order_deal_enough(code,
            #                                                                                      code_volumn_manager.CodeVolumeManager().get_volume_rate_refer_in_5days(
            #                                                                                          code), 0)
            #     if big_order_deal_enough_result[6] <= 0:
            #         HumanRadicalBuySingleManager.add_single(code, total_datas[-1], radical_result)
            #         async_log_util.info(logger_l2_not_buy_reasons, f"{code}#大单足够，需要根据人为下单({compute_start_index}-{compute_end_index})：{radical_result[1]}")
            #         return
            # #下单前一步，移除人为下单信号
            # is_human_radical_buy = HumanRadicalBuySingleManager.has_single(code)
            # HumanRadicalBuySingleManager.remove_single(code)

            buy_single_index, buy_exec_index = radical_result[1], radical_result[1]
            buy_volume_rate = cls.volume_rate_info[code][0]
@@ -1565,9 +1568,11 @@
                                                     max_num_set=set(),
                                                     buy_volume_rate=buy_volume_rate,
                                                     mode=OrderBeginPosInfo.MODE_RADICAL,
                                                     mode_desc=f"大单不足扫入:{radical_result[2]} 是否跟人买入-{is_human_radical_buy}",
                                                     mode_desc=f"大单不足扫入:{radical_result[2]}",
                                                     sell_info=sell_info,
                                                     threshold_money=threshold_money)
                                                     threshold_money=threshold_money,
                                                     min_order_no=radical_result[5]
                                                     )
            order_begin_pos_info.at_limit_up = cls.__is_at_limit_up_buy(code)
            ordered = cls.__process_with_find_exec_index(code, order_begin_pos_info, compute_end_index,
                                                         block_info=radical_result[3])
@@ -2020,11 +2025,10 @@
        @param code:
        @param start_index:
        @param end_index:
        @return: (是否获取到信号, 信号位置, 扫入板块/消息, 扫入板块大单流入信息, 需要监听的大单)
        @return: (是否获取到信号, 信号位置, 扫入板块/消息, 扫入板块大单流入信息, 需要监听的大单, 统计上板大单成交的最小订单号)
        """

        # 激进买信号的时间

        def __can_order():
            # 判断是否是板上放量
            # if cls.__is_at_limit_up_buy(code, start_index):
@@ -2125,8 +2129,13 @@
                    single_index = i
                    break
            if single_index is not None:
                return True, single_index, f"有大单,大单情况：{big_order_deal_enough_result[1]}", watch_indexes
            return False, None, f"大单不足：{trade_index}-{end_index}  缺少的大单-{max(current_lack_money, total_lack_money)}  大单情况：{big_order_deal_enough_result[1]}", watch_indexes
                every_time_big_orders = EveryLimitupBigDealOrderManager.list_big_buy_deal_orders(code)
                if every_time_big_orders:
                    min_order_no = min(min(every_time_big_orders, key=lambda e: e[0])[0], radical_data[1])
                else:
                    min_order_no = radical_data[1]
                return True, single_index, f"有大单,大单情况：{big_order_deal_enough_result[1]}", watch_indexes, min_order_no
            return False, None, f"大单不足：{trade_index}-{end_index}  缺少的大单-{max(current_lack_money, total_lack_money)}  大单情况：{big_order_deal_enough_result[1]}", watch_indexes, None

        radical_data = RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict.get(code)
        record_codes = radical_buy_data_manager.BlockPlaceOrderRecordManager().get_codes()
@@ -2170,7 +2179,7 @@
            # 如果板上放量不可买入就需要删除信号
            if not constant.CAN_RADICAL_BUY_AT_LIMIT_UP and code in RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict:
                RadicalBuyDealCodesManager.buy_by_l2_delegate_expire_time_dict.pop(code)
            return True, result[1], radical_data[2], radical_data[4], result[3]
            return True, result[1], radical_data[2], radical_data[4], result[3], result[4]
        else:
            async_log_util.info(logger_l2_not_buy_reasons, f"{code}#{result[2]}")
        return result
@@ -2216,7 +2225,8 @@
                return False, None, "超过信号生效时间"
            is_valid = False
            # 判断距离上个50w买单的时间是否超过了space_time_ms
            for ii in range(i - 1, -1, -1):
            buy_exec_index = radical_result[1]
            for ii in range(i - 1, buy_exec_index, -1):
                data_child = total_datas[ii]
                val_child = data_child["val"]
                if not L2DataUtil.is_limit_up_price_buy(val_child):
@@ -2243,6 +2253,8 @@
        @param end_index:
        @return: 信号信息（信号位,执行位）, 消息, 可买入的板块
        """
        if True:
            return None, "此条不生效", None
        if not tool.is_sz_code(code):
            return None, "非深证的票", None
        # 判断抛压是否大于5000w