日志调整/L后重新囊括修改

Administrator

2025-03-12 b37fe91f5eed9ac691a4ee9acaec506af1267506

日志调整/L后重新囊括修改

 cancel_strategy/s_l_h_cancel_strategy.py

@@ -222,7 +222,8 @@
            if cancel_result[0]:
                return True, f"S慢砸:{cancel_result[1]}"
        # 卖金额>=均大单才触发重新囊括
        THRESHOLD_MONEY, is_temp_threshold_money = radical_buy_data_manager.BeforeSubDealBigOrderManager().get_big_order_threshold_info(code)
        THRESHOLD_MONEY, is_temp_threshold_money = radical_buy_data_manager.BeforeSubDealBigOrderManager().get_big_order_threshold_info(
            code)
        if total_deal_money >= THRESHOLD_MONEY:
            l2_log.s_cancel_debug(code, "准备更新L后囊括")
            start_order_no = big_sell_order_info[1][-1][4][1]
@@ -1658,6 +1659,84 @@

        return False, None

    # L后重新囊括的时间
    __recompute_l_down_time_dict = {}

    def set_big_sell_order_info(self, code, big_sell_order_info):
        """
        设置大卖单信息
        @param code:
        @param big_sell_order_info:
        @return:
        """
        total_datas = local_today_datas.get(code)
        # 查询是否是真的真实下单位置
        trade_index, is_default = TradeBuyQueue().get_traded_index(code)
        if trade_index is None:
            trade_index = 0
        real_order_index_info = self.get_real_place_order_index_info(code)
        if real_order_index_info is None or real_order_index_info[1]:
            return False, "没找到真实下单位"
        real_order_index = real_order_index_info[0]
        total_deal_money = sum([x[1] * x[2] for x in big_sell_order_info[1]])
        start_order_no = big_sell_order_info[1][0][3][1]
        # 防止分母位0
        total_num = 1
        # 获取正在成交的数据
        dealing_info = HuaXinBuyOrderManager.get_dealing_order_info(code)
        for i in range(trade_index, real_order_index):
            data = total_datas[i]
            val = data['val']
            if not L2DataUtil.is_limit_up_price_buy(val):
                continue
            if int(val['orderNo']) < start_order_no:
                continue
            if i == trade_index and dealing_info and str(total_datas[trade_index]["val"]["orderNo"]) == str(
                    dealing_info[0]):
                # 减去当前正在成交的数据中已经成交了的数据
                total_num -= dealing_info[1] // 100
            left_count = l2_data_source_util.L2DataSourceUtils.get_limit_up_buy_no_canceled_count_v2(code, i,
                                                                                                     total_datas,
                                                                                                     local_today_canceled_buyno_map.get(
                                                                                                         code))
            if left_count > 0:
                total_num += val["num"]

        # 卖金额>=均大单才触发重新囊括
        THRESHOLD_MONEY, is_temp_threshold_money = radical_buy_data_manager.BeforeSubDealBigOrderManager().get_big_order_threshold_info(
            code)
        if total_deal_money >= THRESHOLD_MONEY:
            l2_log.l_cancel_debug(code, "准备更新L后囊括(大卖单)")
            start_order_no = big_sell_order_info[1][-1][4][1]
            latest_deal_time_ms = l2_huaxin_util.convert_time(big_sell_order_info[1][-1][4][0], with_ms=True)
            real_trade_index = None
            for i in range(trade_index, real_order_index):
                data = total_datas[i]
                val = data['val']
                if not L2DataUtil.is_limit_up_price_buy(val):
                    continue
                if int(val['orderNo']) < start_order_no:
                    continue
                real_trade_index = i
                break
            if real_trade_index is None:
                l2_log.l_cancel_debug(code, f"没找到真实的成交进度(大卖单)：start_order_no-{start_order_no} 卖单-{big_sell_order_info}")
                return False, ""
            # 间隔1S以上才能重新囊括
            if code in self.__recompute_l_down_time_dict and tool.trade_time_sub_with_ms(latest_deal_time_ms,
                                                                                         self.__recompute_l_down_time_dict[
                                                                                             code]) < 1000:
                l2_log.s_cancel_debug(code,
                                      f"更新L后囊括(大卖单)：更新间隔在1s内，{latest_deal_time_ms}-{self.__recompute_l_down_time_dict[code]}")
                return False, ""
            self.__recompute_l_down_time_dict[code] = latest_deal_time_ms
            # 重新囊括L后
            # 撤单时间比早成交时间大就需要计算在里面
            self.re_compute_l_down_watch_indexes(code, big_sell_info=(
                real_trade_index, latest_deal_time_ms))
            l2_log.l_cancel_debug(code, f"更新L后囊括完成(大卖单)：{(real_trade_index, latest_deal_time_ms)}")
        return False, ""

    # L后是否还有可能撤单
    def __is_l_down_can_cancel(self, code, buy_exec_index):
        watch_indexes_info = self.__get_watch_indexes_cache(code)

 l2/l2_transaction_data_manager.py

@@ -9,10 +9,9 @@
from db.redis_manager_delegate import RedisUtils
from l2 import l2_log
from l2.huaxin import l2_huaxin_util
from l2.l2_data_util import local_today_sellno_map, local_today_datas
from l2.place_order_single_data_manager import L2TradeSingleDataProcessor, L2TradeSingleDataManager

from log_module import async_log_util, log_export
from log_module import log_export
from log_module.log import hx_logger_l2_transaction_desc, hx_logger_l2_transaction_sell_order, hx_logger_l2_active_sell, \
    hx_logger_l2_transaction_big_buy_order, hx_logger_l2_transaction_big_sell_order, hx_logger_l2_upload

@@ -235,7 +234,7 @@
                        cls.__dealing_order_info_dict[code][7] += money
                else:
                    # 保存上一条数据
                    async_log_util.info(hx_logger_l2_transaction_desc, f"{code}#{cls.__dealing_order_info_dict[code]}")
                    l2_log.info(code, hx_logger_l2_transaction_desc, f"{code}#{cls.__dealing_order_info_dict[code]}")
                    # 设置最近成交完成的一条数据
                    deal_info = cls.__dealing_order_info_dict[code]
                    cls.__latest_deal_order_info_dict[code] = deal_info
@@ -325,7 +324,7 @@
                cls.__dealing_order_info_dict[code][2] += data[2] * data[1]
            else:
                # 保存上一条数据
                async_log_util.info(hx_logger_l2_transaction_desc, f"{code}#{cls.__dealing_order_info_dict[code]}")
                l2_log.info(code, hx_logger_l2_transaction_desc, f"{code}#{cls.__dealing_order_info_dict[code]}")
                # 设置最近成交完成的一条数据
                deal_info = cls.__dealing_order_info_dict[code]
                # 是否为大买单
@@ -466,6 +465,7 @@
        # 是否为主动卖
        def is_active_sell(sell_no, buy_no):
            return sell_no > buy_no

        f_start_time = time.time()
        use_time_list = []
        # q.append((data['SecurityID'], data['TradePrice'], data['TradeVolume'],
@@ -489,7 +489,8 @@

        __start_time = time.time()
        # 是否还有涨停卖剩下
        no_left_limit_up_sell = L2TradeSingleDataProcessor.process_passive_limit_up_sell_data(code, datas, limit_up_price)
        no_left_limit_up_sell = L2TradeSingleDataProcessor.process_passive_limit_up_sell_data(code, datas,
                                                                                              limit_up_price)
        use_time = time.time() - __start_time
        __start_time = time.time()
        use_time_list.append(("处理涨停卖", use_time))
@@ -622,7 +623,7 @@

        use_time = time.time() - f_start_time
        if use_time > 0.01:
            async_log_util.info(hx_logger_l2_upload,
            l2_log.info(code, hx_logger_l2_upload,
                                f"{code}处理成交详细用时：{use_time} 数据数量：{len(datas)}  详情:{use_time_list}")
        return total_sell_info


 l2/l2_transaction_data_processor.py

@@ -156,9 +156,12 @@

                if is_placed_order:

                    need_cancel, cancel_msg = SCancelBigNumComputer().set_big_sell_order_info_for_cancel(code,
                                                                                                         big_sell_order_info,
                                                                                                         order_begin_pos)
                    LCancelBigNumComputer().set_big_sell_order_info(code, big_sell_order_info)

                    # need_cancel, cancel_msg = SCancelBigNumComputer().set_big_sell_order_info_for_cancel(code,
                    #                                                                                      big_sell_order_info,
                    #                                                                                      order_begin_pos)
                    need_cancel, cancel_msg = False, ""
                    cancel_type = None
                    if need_cancel:
                        cancel_msg = f"S撤:{cancel_msg}"

 log_module/log_export.py

@@ -453,6 +453,16 @@
    return cancel_reason_dict



def __parse_content(line):
    line = line.split(" - ")[1]
    time_str = line[line.find("[") + 1:line.find("[") + 9]
    data = line[line.find("]") + 1:].strip()
    if data.find("thread-id=")>-1 and data.find("code=")>-1:
        data = data[data.find("code=")+11:].strip()
    return time_str, data


# 加载l2订单成交数据
@cache_log
def load_huaxin_deal_record(code, date=tool.get_now_date_str()):
@@ -463,9 +473,7 @@
    for line in lines:
        data_index = line.find(f"{code}#")
        if data_index > 0:
            line = line.split(" - ")[1]
            time_str = line[line.find("[") + 1:line.find("[") + 9]
            data = line[line.find("]") + 1:].strip()
            time_str, data = __parse_content(line)
            code = data.split("#")[0]
            data = data.split("#")[1]
            data = eval(data)
@@ -830,8 +838,12 @@


if __name__ == '__main__':
    load_huaxin_transaction_sell_no(code='2024-11-10')
    load_huaxin_transaction_sell_no(code='2024-11-10')
    line = """
    2025-03-12 14:49:15.028 | DEBUG    | log_module.async_log_util:run_sync:66 - [14:49:14.899602] thread-id=3048 code=600841  L前监控范围：{1477, 1478, 1479, 1480, 1481, 1482, 1486, 1487, 1488, 1489, 1492, 1493, 1495, 1498, 1500} 计算范围：1477-1503
    """
    print(__parse_content(line))
    # load_huaxin_transaction_sell_no(code='2024-11-10')
    # load_huaxin_transaction_sell_no(code='2024-11-10')
    # print(get_h_cancel_compute_info("603912"))

    # logger_l2_h_cancel.info("test")

 servers/huaxin_trade_server.py

@@ -757,10 +757,9 @@
                # 不处于可下单状态
                return True
            if transaction_datas:
                async_log_util.info(logger_l2_radical_buy, f"涨停主动买：{code}-{transaction_datas[-1]}")
                l2_log.info(code, logger_l2_radical_buy, f"涨停主动买：{code}-{transaction_datas[-1]}")
            else:
                async_log_util.info(logger_l2_radical_buy,
                                    f"即将炸板：{code}-{is_almost_open_limit_up}-{l2_market_time_str}")
                l2_log.info(code, logger_l2_radical_buy, f"即将炸板：{code}-{is_almost_open_limit_up}-{l2_market_time_str}")
            deal_codes = RadicalBuyDealCodesManager().get_deal_codes()
            # 判断今日扫入的代码数量是否大于阈值
            radical_buy_setting = BuyMoneyAndCountSetting().get_radical_buy_setting()
@@ -768,10 +767,10 @@
            if not WantBuyCodesManager().is_in_cache(code):
                # 加绿不判断板块是否成交
                if len(deal_codes) >= MAX_COUNT:
                    async_log_util.info(logger_l2_radical_buy, f"扫入成交代码个数大于{MAX_COUNT}个：{code}-{deal_codes}")
                    l2_log.info(code, logger_l2_radical_buy, f"扫入成交代码个数大于{MAX_COUNT}个：{code}-{deal_codes}")
                    return True
            if code in deal_codes:
                async_log_util.info(logger_l2_radical_buy, f"该代码已经成交：{code}")
                l2_log.info(code, logger_l2_radical_buy, f"该代码已经成交：{code}")
                return True

            # 单票是否可买
@@ -792,14 +791,14 @@
                                                                    DealAndDelegateWithBuyModeDataManager().get_delegates_codes_info(
                                                                        mode))
                    if not can_buy:
                        async_log_util.info(logger_l2_radical_buy, f"当前时间段已不能扫入：{code}-{msg}")
                        l2_log.info(code, logger_l2_radical_buy, f"当前时间段已不能扫入：{code}-{msg}")
                        return True

                    # -----根据成交比例判断是否可买------
                    result_by_volume = radical_buy_strategy.process_limit_up_active_buy_deal(code, transaction_datas,
                                                                                             is_almost_open_limit_up,
                                                                                             no_left_limit_up_sell=no_left_limit_up_sell)
                    async_log_util.info(logger_l2_radical_buy, f"量买入结果判断：{code}, 结果：{result_by_volume} 板块：{buy_blocks}")
                    l2_log.info(code, logger_l2_radical_buy, f"量买入结果判断：{code}, 结果：{result_by_volume} 板块：{buy_blocks}")
                    in_blocks = RealTimeKplMarketData.get_top_market_jingxuan_blocks()
                    buy_blocks_with_money = [(b, RealTimeKplMarketData.get_jx_block_in_money(b),
                                              in_blocks.index(b) if b in in_blocks else -1) for b in buy_blocks]
@@ -814,8 +813,7 @@
                            # 判断是否开得太高
                            open_price = L1DataManager.get_open_price(code)
                            if not radical_buy_strategy.is_can_buy_with_open_price(code, open_price):
                                async_log_util.info(logger_l2_radical_buy,
                                                    f"开得太高：{code}")
                                l2_log.info(code, logger_l2_radical_buy, f"开得太高：{code}")
                                radical_buy_data_manager.ExcludeIndexComputeCodesManager.add_code(code)
                                return True
                            # if not RadicalCodeMarketInfoManager().is_opened_limit_up(code):
@@ -877,22 +875,22 @@
                                latest_deal_time, buy_blocks_with_money, is_almost_open_limit_up)
                            return False
                    else:
                        async_log_util.info(logger_l2_radical_buy, f"不能下单：{code}-{result_by_volume}")
                        l2_log.info(code, logger_l2_radical_buy, f"不能下单：{code}-{result_by_volume}")
                        return False
                else:
                    volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)
                    async_log_util.info(logger_l2_radical_buy, f"没有可扫入的板块：{code},量比：{volume_rate}")
                    l2_log.info(code, logger_l2_radical_buy, f"没有可扫入的板块：{code},量比：{volume_rate}")
                    return True
            else:
                async_log_util.info(logger_l2_radical_buy, f"目前代码不可交易：{code}-{can_buy_result[1]}")
                l2_log.info(code, logger_l2_radical_buy, f"目前代码不可交易：{code}-{can_buy_result[1]}")
                return True
        except Exception as e:
            async_log_util.info(logger_debug, f"激进买计算异常：{str(e)}")
            l2_log.info(code, logger_debug, f"激进买计算异常：{str(e)}")
            logger_debug.exception(e)
        finally:
            use_time = time.time() - __start_time
            if use_time > 0.005:
                async_log_util.info(logger_debug, f"扫入处理时长：{code}-{use_time}")
                l2_log.info(code, logger_debug, f"扫入处理时长：{code}-{use_time}")

    def OnLimitUpActiveBuy(self, code, transaction_datas, no_left_limit_up_sell):
        can_clear_before_data = self.process_limit_up_active_buy(code, transaction_datas,
@@ -953,7 +951,7 @@
                    result = huaxin_trade_api.order(huaxin_trade_api.TRADE_DIRECTION_BUY, code, volume, limit_up_price,
                                                    blocking=False,
                                                    shadow_price=shadow_price, shadow_volume=volume)
                    async_log_util.info(logger_trade, f"{code}下单结束：{result}")
                    l2_log.info(code, logger_trade, f"{code}下单结束：{result}")
                    buy_open_limit_up_strategy.BuyOpenLimitupDataManager().set_place_order_info(code, volume, volume,
                                                                                                result.get("order_ref"))
                except Exception as e: