完善大单够了加白机制

Administrator

2025-05-26 a846b46f15ad309a62fe400cf78dd7fc888155d7

 l2/l2_data_manager_new.py

@@ -219,6 +219,70 @@
        #                                      round(t.time() * 1000) - start_time))


class HumanRadicalBuySingleManager:
    """
    人为买入管理
    """
    # 人为下单标记:{"代码":(信号时间, 间隔时间,信号截至时间, radical_result)}
    __human_radical_buy_mark_info = {}

    @classmethod
    def add_single(cls, code, latest_data, radical_result):
        """
        添加买入信号
        @param code:
        @param latest_data:
        @param radical_result:
        @return:
        """
        start_time_with_ms = L2DataUtil.get_time_with_ms(latest_data["val"])
        if tool.is_sh_code(code):
            cls.__human_radical_buy_mark_info[code] = (
                start_time_with_ms, 400, tool.trade_time_add_millionsecond(start_time_with_ms, 3000), radical_result)
        else:
            cls.__human_radical_buy_mark_info[code] = (
                start_time_with_ms, 30, tool.trade_time_add_millionsecond(start_time_with_ms, 2000), radical_result)

    @classmethod
    def remove_single(cls, code):
        """
        移除信号
        @param code:
        @return:
        """
        if code in cls.__human_radical_buy_mark_info:
            cls.__human_radical_buy_mark_info.pop(code)

    @classmethod
    def has_single(cls, code):
        """
        是否有信号
        @param code:
        @return:
        """
        if code in cls.__human_radical_buy_mark_info:
            return True
        return False

    @classmethod
    def is_valid(cls, code, data):
        """
        信号是否有效
        @param code:
        @return: 是否有效，无效消息/有效对象
        """
        if code not in cls.__human_radical_buy_mark_info:
            return False, "没有人买入信号"
        single_time_ms, space_time_ms, expire_time_ms, _ = cls.__human_radical_buy_mark_info[code]
        now_time_ms = L2DataUtil.get_time_with_ms(data["val"])
        if tool.trade_time_sub_with_ms(now_time_ms,
                                       expire_time_ms) > 0:
            cls.__human_radical_buy_mark_info.pop(code)
            async_log_util.info(logger_l2_not_buy_reasons, f"{code}#大单足够，人为下单： 超过信号生效时间-{now_time_ms}/{expire_time_ms}")
            return False, "超过信号生效时间"
        return True, cls.__human_radical_buy_mark_info[code]


class L2TradeDataProcessor:
    unreal_buy_dict = {}
    volume_rate_info = {}
@@ -1458,10 +1522,36 @@
        _start_time = tool.get_now_timestamp()
        total_datas = local_today_datas[code]

        # ---------计算激进买入的信号---------
        radical_result = cls.__compute_radical_order_begin_pos(code, compute_start_index, compute_end_index)
        # 不需要根据人为下单来下单
        # 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 radical_result[0]:
        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)

            buy_single_index, buy_exec_index = radical_result[1], radical_result[1]
            buy_volume_rate = cls.volume_rate_info[code][0]
            refer_sell_data = cls.__L2MarketSellManager.get_refer_sell_data(code, total_datas[buy_single_index]["val"][
@@ -1481,7 +1571,9 @@
                                                     mode=OrderBeginPosInfo.MODE_RADICAL,
                                                     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])
@@ -1934,11 +2026,10 @@
        @param code:
        @param start_index:
        @param end_index:
        @return: (是否获取到信号, 信号位置, 扫入板块/消息, 扫入板块大单流入信息, 需要监听的大单)
        @return: (是否获取到信号, 信号位置, 扫入板块/消息, 扫入板块大单流入信息, 需要监听的大单, 统计上板大单成交的最小订单号)
        """

        # 激进买信号的时间

        def __can_order():
            # 判断是否是板上放量
            # if cls.__is_at_limit_up_buy(code, start_index):
@@ -2039,8 +2130,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()
@@ -2084,10 +2180,67 @@
            # 如果板上放量不可买入就需要删除信号
            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

    @classmethod
    def __compute_human_radical_order_begin_pos(cls, code, start_index, end_index):
        """
        处理跟人买
        @param code:
        @param start_index:
        @param end_index:
        @return:
        """
        total_datas = local_today_datas.get(code)
        result = HumanRadicalBuySingleManager.is_valid(code, total_datas[start_index])
        if not result[0]:
            return False, None, result[1]
        result = result[1]
        single_time_ms, space_time_ms, expire_time_ms, radical_result = result[0], result[1], result[2], result[3]

        bigger_num = l2_data_util.get_big_money_val(gpcode_manager.get_limit_up_price_as_num(code),
                                                    tool.is_ge_code(code)) // (
                             gpcode_manager.get_limit_up_price_as_num(code) * 100)
        canceled_buyno_map = local_today_buyno_map.get(code)
        for i in range(start_index, end_index + 1):
            data = total_datas[i]
            val = data["val"]
            if not L2DataUtil.is_limit_up_price_buy(val):
                continue
            if val["num"] < bigger_num:
                continue

            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code, i,
                                                                                                     total_datas,
                                                                                                     canceled_buyno_map)
            if left_count == 0:
                continue

            # 判断是否超过生效时间
            if tool.trade_time_sub_with_ms(L2DataUtil.get_time_with_ms(total_datas[i]["val"]),
                                           expire_time_ms) > 0:
                HumanRadicalBuySingleManager.remove_single(code)
                return False, None, "超过信号生效时间"
            is_valid = False
            # 判断距离上个50w买单的时间是否超过了space_time_ms
            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):
                    continue
                if val_child["num"] * float(val_child["price"]) < 5000:
                    continue
                if tool.trade_time_sub_with_ms(L2DataUtil.get_time_with_ms(val),
                                               L2DataUtil.get_time_with_ms(val_child)) > space_time_ms:
                    is_valid = True
                    break
            if is_valid:
                return True, data, radical_result
        return False, None, "没有有效信号"

    # 总卖额参考时间使用记录
    __refer_sell_used_times = {}
@@ -2101,6 +2254,8 @@
        @param end_index:
        @return: 信号信息（信号位,执行位）, 消息, 可买入的板块
        """
        if True:
            return None, "此条不生效", None
        if not tool.is_sz_code(code):
            return None, "非深证的票", None
        # 判断抛压是否大于5000w