总抛压大的扫入策略调整

Administrator

2025-03-06 d9b94154c523e631ac6fa38bce9836f12ac9581e

总抛压大的扫入策略调整

 l2/huaxin/huaxin_target_codes_manager.py

@@ -145,12 +145,12 @@
        async_log_util.info(logger_l2_codes_subscript, f"{request_id}接受到L1的数据，预处理完成")
        try:
            tick_datas = first_target_code_data_processor.process_first_codes_datas(flist, request_id)
            block_top_in_list = RealTimeKplMarketData.top_in_list_cache
            in_blocks = [x[1] for  x in block_top_in_list]
            in_blocks = RealTimeKplMarketData.get_top_market_jingxuan_blocks()
            out_blocks = RealTimeKplMarketData.get_top_market_jingxuan_out_blocks()
            yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
            if yesterday_codes is None:
                yesterday_codes = set()
            current_price_process_manager.accept_prices(tick_datas, request_id, in_blocks[:30], yesterday_codes)
            current_price_process_manager.accept_prices(tick_datas, request_id, in_blocks, yesterday_codes, top_out_blocks=out_blocks)
        except Exception as e:
            logger_debug.exception(e)
        finally:

 l2/l2_data_manager_new.py

@@ -28,7 +28,7 @@
from trade import trade_manager, trade_queue_manager, l2_trade_factor, l2_trade_util, \
    trade_result_manager, current_price_process_manager, trade_data_manager, trade_huaxin, trade_record_log_util, \
    trade_constant, buy_open_limit_up_strategy
from trade.buy_radical import radical_buy_data_manager
from trade.buy_radical import radical_buy_data_manager, radical_buy_strategy
from l2 import l2_data_manager, l2_log, l2_data_source_util, code_price_manager, \
    transaction_progress, cancel_buy_strategy, place_order_single_data_manager
from l2.cancel_buy_strategy import DCancelBigNumComputer, \
@@ -883,7 +883,7 @@
        params_desc = cls.__l2PlaceOrderParamsManagerDict[code].get_buy_rank_desc()
        l2_log.debug(code, params_desc)
        #################清除本次下单的大单数据###############
        EveryLimitupBigDealOrderManager.clear(code,"下单成功")
        EveryLimitupBigDealOrderManager.clear(code, "下单成功")
        ############记录下单时的数据############
        try:
            jx_blocks, jx_blocks_by = KPLCodeJXBlockManager().get_jx_blocks_cache(
@@ -1443,6 +1443,7 @@

        # ---------计算激进买入的信号---------
        radical_result = cls.__compute_radical_order_begin_pos(code, compute_start_index, compute_end_index)

        if radical_result[0]:
            buy_single_index, buy_exec_index = radical_result[1], radical_result[1]
            buy_volume_rate = cls.volume_rate_info[code][0]
@@ -1472,7 +1473,35 @@
                # 监听大单
                RDCancelBigNumComputer().set_watch_indexes(code, radical_result[4])
            return
        else:
            radical_result = cls.__compute_radical_order_begin_pos_for_many_sell(code, start_index, end_index)
            if radical_result[0]:
                buy_single_index, buy_exec_index = radical_result[0][0], radical_result[0][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"][
                                                                                    "time"])
                if refer_sell_data:
                    sell_info = (refer_sell_data[0], refer_sell_data[1])
                else:
                    sell_info = (total_datas[buy_single_index]["val"]["time"], 0)
                threshold_money = 0

                order_begin_pos_info = OrderBeginPosInfo(buy_single_index=buy_single_index,
                                                         buy_exec_index=buy_exec_index,
                                                         buy_compute_index=buy_exec_index,
                                                         num=total_datas[buy_single_index]["val"]["num"], count=1,
                                                         max_num_set=set(),
                                                         buy_volume_rate=buy_volume_rate,
                                                         mode=OrderBeginPosInfo.MODE_RADICAL,
                                                         mode_desc=f"总抛压大扫入:{radical_result[2]}",
                                                         sell_info=sell_info,
                                                         threshold_money=threshold_money)
                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[2])
                if ordered:
                    radical_buy_data_manager.BlockPlaceOrderRecordManager().add_record(code, radical_result[2])
        if RadicalBuyDealCodesManager().get_code_blocks(code):
            # 已经扫入下过单
            return
@@ -1909,7 +1938,9 @@
                                                                                             code_volumn_manager.CodeVolumeManager().get_volume_rate_refer_in_5days(
                                                                                                 code),
                                                                                             refer_sell_money,
                                                                                             for_buy=True, is_almost_open_limit_up=radical_data[5])
                                                                                             for_buy=True,
                                                                                             is_almost_open_limit_up=
                                                                                             radical_data[5])
            # 缺乏的大单金额
            lack_money = big_order_deal_enough_result[3]
            # 如果有大单成交就不需要看大单
@@ -2022,6 +2053,71 @@
            async_log_util.info(logger_l2_not_buy_reasons, f"{code}#{result[2]}")
        return result

    # 总卖额参考时间使用记录
    __refer_sell_used_times = {}

    @classmethod
    def __compute_radical_order_begin_pos_for_many_sell(cls, code, start_index, end_index):
        """
        计算深证高抛压的卖的买入信号
        @param code:
        @param start_index:
        @param end_index:
        @return: 信号信息（信号位,执行位）, 消息, 可买入的板块
        """
        if not tool.is_sz_code(code):
            return None, "非深证的票", None
        # 判断抛压是否大于5000w
        total_datas = local_today_datas.get(code)
        refer_sell_data = cls.__L2MarketSellManager.get_refer_sell_data(code, total_datas[-1]["val"]["time"])
        if not refer_sell_data or refer_sell_data[1] < 5e7:
            return None, "总卖额小于5000万", None
        if code in cls.__refer_sell_used_times and refer_sell_data[0] in cls.__refer_sell_used_times:
            return None, f"时间已经被使用：{refer_sell_data[0]}", None

        deal_codes = RadicalBuyDealCodesManager().get_deal_codes()
        if code in deal_codes:
            return None, f"已经成交", None

        f_buy_blocks, orgin_buy_blocks = radical_buy_strategy.compute_can_radical_buy_blocks(code, deal_codes)
        if not f_buy_blocks:
            return None, f"板块不可买入", None

        # 判断是否有涨停买的数据
        has_limit_up = False
        for i in range(start_index, end_index + 1):
            data = total_datas[i]
            val = data["val"]
            if L2DataUtil.is_limit_up_price_buy(val):
                has_limit_up = True
                break
        if not has_limit_up:
            return None, "无涨停买数据", None
        # 查找计数起点
        refer_sell_time_int = int(refer_sell_data[0].replace(":", ""))
        begin_index = start_index
        for i in range(start_index - 1, -1, -1):
            data = total_datas[i]
            val = data["val"]
            if int(val["time"].replace(":", "")) < refer_sell_time_int:
                begin_index = i + 1
                break
        threshold_num = int(round(refer_sell_data[1] / gpcode_manager.get_limit_up_price_as_num(code) / 100))
        total_num = 0
        for i in range(begin_index, end_index + 1):
            data = total_datas[i]
            val = data["val"]
            if L2DataUtil.is_limit_up_price_buy(val):
                total_num += val["num"]
            elif L2DataUtil.is_limit_up_price_buy_cancel(val):
                total_num -= val["num"]
        if total_num > threshold_num:
            if code not in cls.__refer_sell_used_times:
                cls.__refer_sell_used_times[code] = set()
            cls.__refer_sell_used_times[code].add(refer_sell_data[0])
            return (begin_index, end_index), "可以下单", f_buy_blocks
        return None, "总买额不满足", None

    @classmethod
    def test__compute_active_order_begin_pos(cls, code, continue_count, start_index, end_index):
        return cls.__compute_active_order_begin_pos(code, continue_count, start_index, end_index)

 l2/l2_transaction_data_processor.py

@@ -69,15 +69,15 @@
                if order_begin_pos and order_begin_pos.mode == OrderBeginPosInfo.MODE_RADICAL:
                    RadicalBuyDataManager.big_order_deal(code)

            if is_placed_order and bigger_buy_datas:
                # 有大于50w的大单成交
                buyno_map = l2_data_util.local_today_buyno_map.get(code)
                if buyno_map:
                    for buy_data in bigger_buy_datas:
                        order_no = f"{buy_data[0]}"
                        if order_no in buyno_map:
                            LCancelBigNumComputer().add_deal_index(code, buyno_map[order_no]["index"],
                                                                   order_begin_pos.buy_single_index)
                if bigger_buy_datas:
                    # 有大于50w的大单成交
                    buyno_map = l2_data_util.local_today_buyno_map.get(code)
                    if buyno_map:
                        for buy_data in bigger_buy_datas:
                            order_no = f"{buy_data[0]}"
                            if order_no in buyno_map:
                                LCancelBigNumComputer().add_deal_index(code, buyno_map[order_no]["index"],
                                                                       order_begin_pos.buy_single_index)
        except Exception as e:
            logger_debug.exception(e)


 servers/huaxin_trade_server.py

@@ -738,36 +738,12 @@
            can_buy_result = RadicalBuyDataManager.is_code_can_buy(code)
            if can_buy_result[0]:
                # 获取激进买的板块
                result_cache = self.__radical_buy_by_blocks_result_cache.get(code)
                if not result_cache or result_cache[0] < time.time():
                    # 不存在/过期
                    yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
                    if yesterday_codes is None:
                        yesterday_codes = set()
                    # 计算是否可以扫入
                    radical_result = RadicalBuyBlockManager.is_radical_buy(code, yesterday_codes)
                    async_log_util.info(logger_l2_radical_buy, f"计算板块结果：{code}-{radical_result}")
                    result_cache = (time.time() + 3, radical_result)
                    self.__radical_buy_by_blocks_result_cache[code] = result_cache
                    RadicalBuyDealCodesManager().set_code_blocks(code, radical_result[0])
                    if not radical_result[0]:
                        async_log_util.info(logger_l2_not_buy_reasons, f"{code}#{radical_result[1]}")
                # 取缓存
                result = result_cache[1]
                if result[0]:
                f_buy_blocks, orgin_buy_blocks = radical_buy_strategy.compute_can_radical_buy_blocks(code, deal_codes)
                if orgin_buy_blocks:
                    if not f_buy_blocks:
                        return True
                    # 买入的板块
                    buy_blocks = result[0]
                    # 如果关键词包含已成交的原因就不再下单
                    # 获取已经成交代码的板块
                    try:
                        # ---------------判断板块是否还可以买入----------------
                        f_buy_blocks = radical_buy_data_manager.is_block_can_radical_buy(code, buy_blocks, deal_codes)
                        if not f_buy_blocks:
                            return True
                        buy_blocks = f_buy_blocks
                    except Exception as e:
                        logger_debug.exception(e)

                    buy_blocks = f_buy_blocks
                    # 判断当前时间段是否可以买入
                    mode = OrderBeginPosInfo.MODE_RADICAL
                    can_buy, money, msg = BuyMoneyUtil.get_buy_data(tool.get_now_time_str(), mode,

 trade/buy_radical/radical_buy_data_manager.py

@@ -1257,6 +1257,15 @@
            # 今日新板块不考虑净流入
            return True, False

        # 辨识度不在流入的票打回封(回封已经在订阅的时候处理了)
        if is_for_buy:
            # 有辨识度且不在流出
            special_codes = BlockSpecialCodesManager().get_block_codes(block)
            if special_codes and code in special_codes:
                out_blocks = RealTimeKplMarketData.get_top_market_jingxuan_out_blocks()
                if not out_blocks or block not in out_blocks:
                    return True, False

        # 获取当前板块涨停数量
        codes = LimitUpDataConstant.get_current_limit_up_block_codes(block)
        if codes and len(codes) >= 5:

 trade/buy_radical/radical_buy_strategy.py

@@ -2,6 +2,8 @@
激进买策略管理
"""
# 上一个50W的起始时间：{code:"09:30:00.120"}
import time

from code_attribute import code_volumn_manager, gpcode_manager
from l2.code_price_manager import Buy1PriceManager
from l2.huaxin import l2_huaxin_util
@@ -9,9 +11,11 @@
from l2.l2_sell_manager import L2MarketSellManager
from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager, BigOrderDealManager
from log_module import async_log_util
from log_module.log import logger_l2_radical_buy, hx_logger_l2_transaction
from log_module.log import logger_l2_radical_buy, hx_logger_l2_transaction, logger_l2_not_buy_reasons
from third_data import kpl_data_manager
from third_data.kpl_data_constant import LimitUpDataConstant
from trade.buy_radical import radical_buy_data_manager
from trade.buy_radical.radical_buy_data_manager import RadicalBuyBlockManager
from trade.trade_data_manager import RadicalBuyDealCodesManager
from utils import tool

@@ -231,3 +235,40 @@
            else:
                return rate < 0.049
    return True


# 板块缓存
__radical_buy_by_blocks_result_cache = {}


def compute_can_radical_buy_blocks(code, deal_codes):
    """
    计算可以扫入的板块
    @param code:
    @return: 可买板块集合, 过滤后的集合
    """
    result_cache = __radical_buy_by_blocks_result_cache.get(code)
    if not result_cache or result_cache[0] < time.time():
        # 不存在/过期
        yesterday_codes = kpl_data_manager.get_yesterday_limit_up_codes()
        if yesterday_codes is None:
            yesterday_codes = set()
        # 计算是否可以扫入
        radical_result = RadicalBuyBlockManager.is_radical_buy(code, yesterday_codes)
        async_log_util.info(logger_l2_radical_buy, f"计算板块结果：{code}-{radical_result}")
        result_cache = (time.time() + 3, radical_result)
        __radical_buy_by_blocks_result_cache[code] = result_cache
        RadicalBuyDealCodesManager().set_code_blocks(code, radical_result[0])
        if not radical_result[0]:
            async_log_util.info(logger_l2_not_buy_reasons, f"{code}#{radical_result[1]}")
    # 取缓存
    result = result_cache[1]
    if result[0]:
        # 买入的板块
        buy_blocks = result[0]
        # 如果关键词包含已成交的原因就不再下单
        # 获取已经成交代码的板块
        # ---------------判断板块是否还可以买入----------------
        f_buy_blocks = radical_buy_data_manager.is_block_can_radical_buy(code, buy_blocks, deal_codes)
        return f_buy_blocks, result[0]
    return set(), result[0]

 trade/current_price_process_manager.py

@@ -30,7 +30,7 @@
latest_add_codes = set()


def compute_code_order(code, top_in_blocks=None, yesterday_limit_up_codes=None, today_history_limit_up_codes=None):
def compute_code_order(code, top_in_blocks=None, yesterday_limit_up_codes=None, today_history_limit_up_codes=None, top_out_blocks=None):
    """
    计算代码的排序
    @param code:
@@ -42,6 +42,8 @@
        yesterday_limit_up_codes = set()
    if top_in_blocks is None:
        top_in_blocks = []
    if top_out_blocks is None:
        top_out_blocks = []
    if today_history_limit_up_codes is None:
        today_history_limit_up_codes = set()
        # 高位板
@@ -92,6 +94,10 @@
                if b in top_in_blocks:
                    index = top_in_blocks.index(b)
                    return index + 1
                else:
                    # 辨识度的票没在净流入中，只要不在净流出中就订阅
                    if b not in top_out_blocks:
                        return 200
            else:
                # 没有辨识度，新板块订阅前3
                new_blocks = LimitUpCodesBlockRecordManager().get_new_blocks()
@@ -120,7 +126,7 @@
    return 10000


def accept_prices(prices, request_id=None, top_in_blocks=None, yesterday_limit_up_codes=None):
def accept_prices(prices, request_id=None, top_in_blocks=None, yesterday_limit_up_codes=None, top_out_blocks=None):
    """
    接收价格，处理订阅
    @param yesterday_limit_up_codes: 昨日涨停数据
@@ -145,7 +151,7 @@
            if pricePre is not None:
                # 是否是想买单
                order_index = compute_code_order(code, top_in_blocks, yesterday_limit_up_codes,
                                                 today_history_limit_up_codes)
                                                 today_history_limit_up_codes, top_out_blocks=top_out_blocks)
                rate = round((price - pricePre) * 100 / pricePre, 2)
                if tool.is_ge_code(code):
                    # 创业板的涨幅需要打折

 trade/huaxin/huaxin_trade_api.py

@@ -80,6 +80,10 @@
                if huaxin_util.is_deal(order.orderStatus):
                    # 如果成交了需要刷新委托列表
                    huaxin_trade_data_update.add_delegate_list("卖成交")
            else:
                if huaxin_util.is_deal(order.orderStatus):
                    # 如果成交了需要刷新委托列表
                    huaxin_trade_data_update.add_delegate_list("买成交")
            need_cancel = TradeResultProcessor.process_buy_order(order)
            if need_cancel:
                # 需要撤买单