历史板块判断调整/有效执行位判断

Administrator

2024-09-03 794d154fb8dd8aaf2f4a670a59f85302287d5b2b

历史板块判断调整/有效执行位判断

 l2/l2_data_manager_new.py

@@ -731,7 +731,7 @@
                return False
            __start_time = tool.get_now_timestamp()

            can, need_clear_data, reason = cls.__can_buy_first(code)
            can, need_clear_data, reason, is_valid_exec_index = cls.__can_buy_first(code)

            # __start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - __start_time, "最后判断是否能下单", force=True)
            # 删除虚拟下单
@@ -741,6 +741,11 @@
            order_begin_pos = cls.__get_order_begin_pos(
                code)
            if not can:
                if not is_valid_exec_index:
                    if cls.__latest_exec_indexes.get(code) and cls.__latest_exec_indexes[code][
                        -1] == order_begin_pos.buy_exec_index:
                        # 如果执行位置算做无效，就需要删除当前执行位置
                        cls.__latest_exec_indexes[code].pop()
                l2_log.debug(code, "不可以下单，原因：{}", reason)
                trade_record_log_util.add_cant_place_order_log(code, reason)
                if need_clear_data:
@@ -848,26 +853,29 @@

    @classmethod
    def __can_buy_first(cls, code):
        # if code.find("60") == 0:
        #     return False, True, f"上证暂不交易"
        """
        是否可以下单
        @param code:
        @return:(是否可以下单, 是否清理信号数据, 不能下单消息, 是否算有效执行)
        """

        if not cls.__TradeStateManager.is_can_buy_cache():
            return False, True, f"今日已禁止交易"
            return False, True, f"今日已禁止交易", True

        if l2_trade_util.is_in_forbidden_trade_codes(code):
            return False, True, f"代码禁止交易"
            return False, True, f"代码禁止交易", True

        if cls.__PauseBuyCodesManager.is_in_cache(code):
            return False, True, f"该代码被暂停交易"
            return False, True, f"该代码被暂停交易", True
        now_time_int = int(tool.get_now_time_str().replace(":", ""))
        if now_time_int >= 145700:
            return False, True, f"14:57后不能交易"
            return False, True, f"14:57后不能交易", True
        if 130100 >= now_time_int >= 112900 or now_time_int < 93100:
            if now_time_int < 93100:
                # 判断近120天是否有涨停
                k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
                if k_format and len(k_format) >= 12 and not k_format[11]:
                    return False, True, f"09:31:00之前下单，90个交易日无涨停"
                    return False, True, f"09:31:00之前下单，90个交易日无涨停", True

                # 判断成交的大单数量
                data_list = BigOrderDealManager().get_total_buy_money_list(code)
@@ -879,20 +887,15 @@
                    fdatas.append(d)
                thresh_count = 3 if tool.is_sh_code(code) else 1
                if len(fdatas) < thresh_count:
                    return False, True, f"09:31:00之前下单，成交大单数量（{len(fdatas)}）不足{thresh_count}个"
                    return False, True, f"09:31:00之前下单，成交大单数量（{len(fdatas)}）不足{thresh_count}个", True
                else:
                    # 判断数据是否卡
                    total_datas = local_today_datas.get(code)
                    if tool.trade_time_sub_with_ms(tool.get_now_time_with_ms_str(),
                                                   L2DataUtil.get_time_with_ms(total_datas[-1]["val"])) > 500:
                        return False, True, f"09:31:00之前下单，L2数据时间相差500ms以上"
                        return False, True, f"09:31:00之前下单，L2数据时间相差500ms以上", True
            else:
                return False, True, f"09:31:00之前，11:29:00-13:01:00不能交易"

        # place_order_count = cls.__PlaceOrderCountManager.get_place_order_count(code)
        # if place_order_count > 0 and now_time_int >= 140000:
        #     # 14:00:00后只打老大的回封
        #     return False, True, f"14:00:00不打回封"
                return False, True, f"09:31:00之前，11:29:00-13:01:00不能交易", True

        limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)

@@ -904,9 +907,9 @@
            # 小市值高股价可买
            zyltgb = global_util.zyltgb_map.get(code)
            if zyltgb > 25e8 or limit_up_price > constant.MAX_SUBSCRIPT_CODE_PRICE:
                return False, True, f"股价大于{constant.MAX_CODE_PRICE}块/小于{constant.MIN_CODE_PRICE}块"
                return False, True, f"股价大于{constant.MAX_CODE_PRICE}块/小于{constant.MIN_CODE_PRICE}块", True
        else:
            return False, True, f"股价小于{constant.MIN_CODE_PRICE}块"
            return False, True, f"股价小于{constant.MIN_CODE_PRICE}块", True

        # place_order_count = cls.__PlaceOrderCountManager.get_place_order_count(code)
        # if place_order_count and place_order_count >= 10:
@@ -916,7 +919,7 @@
        # ---------均价约束-------------
        average_rate = cls.__Buy1PriceManager.get_average_rate(code)
        if average_rate and average_rate <= 0.01 and tool.trade_time_sub(tool.get_now_time_str(), "10:30:00") >= 0:
            return False, True, f"均价涨幅({average_rate})小于1%"
            return False, True, f"均价涨幅({average_rate})小于1%", True

        total_data = local_today_datas.get(code)

@@ -927,26 +930,26 @@
            if limit_up_data:
                limit_up_time = tool.to_time_str(limit_up_data[2])
                if int(limit_up_time.replace(":", "")) < int("093000"):
                    return False, True, f"上证开一09:32之前不下单"
                    return False, True, f"上证开一09:32之前不下单", True

        # ------------挂单时间约束----------
        order_begin_pos = cls.__get_order_begin_pos(
            code)
        if not trade_result_manager.can_place_order_for_cancel_time(code, total_data[order_begin_pos.buy_exec_index]):
            return False, True, f"距离上次挂单小于时间限制"
            return False, True, f"距离上次挂单小于时间限制", True

        # ------------板块约束-------------
        if not cls.__WantBuyCodesManager.is_in_cache(code):
            # 想买单无板块约束
            block_buy_result = buy_strategy_util.is_block_can_buy(code, cls.__get_can_buy_block(code))
            if not block_buy_result[0]:
                return block_buy_result
                return block_buy_result[0], block_buy_result[1], block_buy_result[2], True

        if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_HUAXIN:
            # ---------------------判断是否为板上放量----------------------
            trade_price = current_price_process_manager.get_trade_price(code)
            if trade_price is None:
                return False, True, f"尚未获取到当前成交价"
                return False, True, f"尚未获取到当前成交价", True
            # 判断是否为板上放量：
            # 1.当前成交价为涨停价
            # 2.距离最近的非板上成交的时间大于一个阈值
@@ -990,13 +993,13 @@
                                                                                                    trade_index,
                                                                                                    order_begin_pos.buy_single_index)
                                if not cancel_rate_reieved_info[0]:
                                    return False, True, f"板上放量距离远({not_limit_up_trade_time_with_ms})，有小群撤, 整体撤单比例不足（{trade_index}-{order_begin_pos.buy_single_index}）{cancel_rate_reieved_info[1]}"
                                    return False, True, f"板上放量距离远({not_limit_up_trade_time_with_ms})，有小群撤, 整体撤单比例不足（{trade_index}-{order_begin_pos.buy_single_index}）{cancel_rate_reieved_info[1]}", False
                            else:
                                return False, True, f"板上放量距离远({not_limit_up_trade_time_with_ms})，没有小群撤（{trade_index}-{order_begin_pos.buy_single_index}）"
                                return False, True, f"板上放量距离远({not_limit_up_trade_time_with_ms})，没有小群撤（{trade_index}-{order_begin_pos.buy_single_index}）", False
                        except Exception as e:
                            l2_log.info(code, logger_l2_error, f"板上放量({not_limit_up_trade_time_with_ms})不足异常：{str(e)}")
                            logger_l2_error.exception(e)
                            return False, True, f"板上放量计算异常"
                            return False, True, f"板上放量计算异常", False

                    # -------是否距离成交进度位太远--------
                    buy1_money = code_price_manager.Buy1PriceManager().get_latest_buy1_money(code)
@@ -1007,7 +1010,7 @@
                    if not buy1_money:
                        buy1_money = 1
                    if buy_strategy_util.is_far_away_from_trade_index(code, trade_index, buy1_money):
                        return False, True, f"距离成交进度位太远：成交进度-{trade_index} 买1-{buy1_money}"
                        return False, True, f"距离成交进度位太远：成交进度-{trade_index} 买1-{buy1_money}", False

            # ------------------上证下单需要有成交大单（包含主动买与被动买）或者挂买的大单-----------------
            if tool.is_sh_code(code):
@@ -1028,7 +1031,7 @@
                                                                                                          limit_up_price,
                                                                                                          min_money=min_money)
                    if left_count < 1:
                        return False, False, f"没有已挂或者成交的大单"
                        return False, False, f"没有已挂或者成交的大单", False
            place_order_count = trade_data_manager.PlaceOrderCountManager().get_place_order_count(code)
            # ------------------第一和第二次下单都必须要有至少一笔未成交的大单--------------------------
            # 计算大单
@@ -1042,7 +1045,7 @@
                                                                                total_datas[-1]["index"],
                                                                                limit_up_price, min_money)
                if left_count < 1:
                    return False, False, f"第{place_order_count + 1}下单无待成交的大单"
                    return False, False, f"第{place_order_count + 1}下单无待成交的大单", False

            # -------判断是否是量化下单，如果是就不跟到下单--------
            # 重要：量化下单会增加下单次数，板块下单中有下单次数的使用，所以板块需要在量化判断之前
@@ -1053,8 +1056,8 @@
                is_quantization_result = buy_strategy_util.is_quantization(code, range_indexes[0], range_indexes[1])
                if is_quantization_result[0]:
                    cls.__next_buy_time_dict[code] = is_quantization_result[1]
                    return False, True, is_quantization_result[2]
        return True, False, "满足下单条件"
                    return False, True, is_quantization_result[2], True
        return True, False, "满足下单条件", True

    # 获取可以买的板块
    @classmethod

 third_data/code_plate_key_manager.py

@@ -490,6 +490,9 @@
            return self.__history_blocks_dict_cache.get(code)
        try:
            kpl_results = KPLLimitUpDataUtil.get_latest_block_infos(code=code)
            # 取最近2条数据
            if kpl_results and len(kpl_results) > 2:
                kpl_results = kpl_results[-2:]
            keys = set()
            if kpl_results:
                keys |= set([x[2] for x in kpl_results])
@@ -1217,13 +1220,13 @@
            if history_index == 0 and current_index == 0:
                return True, f"开1数量：{count}"
            else:
                return False, f"开1数量：{count}，非开1首板身位不匹配：历史-{history_index+1} 实时-{current_index+1}"
                return False, f"开1数量：{count}，非开1首板身位不匹配：历史-{history_index + 1} 实时-{current_index + 1}"
        else:
            # 买老3
            if history_index == 1 and current_index == 1:
                return True, f"开1数量：{count}"
            else:
                return False, f"开1数量：{count}，非开1首板身位不匹配：历史-{history_index+1} 实时-{current_index+1}"
                return False, f"开1数量：{count}，非开1首板身位不匹配：历史-{history_index + 1} 实时-{current_index + 1}"

    @classmethod
    def __is_radical_buy_with_block_up(cls, code, block, yesterday_limit_up_codes):

 utils/kpl_data_db_util.py

@@ -4,13 +4,15 @@

class KPLLimitUpDataUtil:
    @classmethod
    def get_latest_block_infos(cls, min_day=tool.date_sub(tool.get_now_date_str(), 180), code=None):
    def get_latest_block_infos(cls, min_day=tool.date_sub(tool.get_now_date_str(), 180), code=None,
                               max_day=tool.get_now_date_str()):
        """
        @param min_day: 默认获取180天之前的
        @param code: 代码
        @return: 最近的涨停板块信息
        """
        sql = f"SELECT r.`_code`, r.`_day`, r.`_hot_block_name`, r.`_blocks` FROM `kpl_limit_up_record` r WHERE r.`_day`>'{min_day}'"
        sql = f"SELECT r.`_code`, r.`_day`, r.`_hot_block_name`, r.`_blocks` FROM `kpl_limit_up_record` r WHERE r.`_day`>'{min_day}' and r.`_day` <'{max_day}'"

        if code:
            sql += f" AND _code='{code}'"
        sql += " order by _create_time"