扫入策略修改

Administrator

2024-10-22 3be964f68aab1128f6a96894a92e73130b516d97

 l2/l2_transaction_data_processor.py

@@ -2,19 +2,27 @@
import time

import constant
from cancel_strategy.s_l_h_cancel_strategy import HourCancelBigNumComputer
from cancel_strategy.s_l_h_cancel_strategy import LCancelBigNumComputer, LCancelRateManager
from cancel_strategy.s_l_h_cancel_strategy import SCancelBigNumComputer
from code_attribute import gpcode_manager
from l2 import l2_data_util, l2_data_manager, transaction_progress
from l2.cancel_buy_strategy import FCancelBigNumComputer, LCancelBigNumComputer, LCancelRateManager, \
    GCancelBigNumComputer, SCancelBigNumComputer, HourCancelBigNumComputer, NewGCancelBigNumComputer
from l2.cancel_buy_strategy import FCancelBigNumComputer, \
    NewGCancelBigNumComputer, \
    NBCancelBigNumComputer
from l2.huaxin import l2_huaxin_util
from l2.l2_data_manager import OrderBeginPosInfo
from l2.l2_data_manager_new import L2TradeDataProcessor
from l2.l2_data_util import L2DataUtil
from l2.l2_limitup_sell_data_manager import L2LimitUpSellDataManager
from l2.l2_transaction_data_manager import HuaXinBuyOrderManager, HuaXinSellOrderStatisticManager, BigOrderDealManager
from log_module import async_log_util
from log_module.log import hx_logger_l2_debug, logger_l2_trade_buy_queue, logger_debug, hx_logger_l2_upload
from trade import current_price_process_manager
from trade.deal_big_money_manager import DealOrderNoManager
from trade import current_price_process_manager, trade_constant
import concurrent.futures

from trade.radical_buy_data_manager import RedicalBuyDataManager
from utils import tool


class HuaXinTransactionDatasProcessor:
@@ -29,21 +37,25 @@
            d = datas[i]
            buy_no = f"{d[6]}"
            if buyno_map and buy_no in buyno_map:
                buy_progress_index = buyno_map[buy_no]["index"]
                # 成交进度位必须是涨停买
                if L2DataUtil.is_limit_up_price_buy(buyno_map[buy_no]["val"]):
                    buy_progress_index = buyno_map[buy_no]["index"]
                break
        return buy_progress_index

    @classmethod
    def statistic_big_order_infos(cls, code, datas, order_begin_pos:OrderBeginPosInfo):
    def statistic_big_order_infos(cls, code, datas, order_begin_pos: OrderBeginPosInfo):
        """
        统计大单成交
        @param code:
        @param datas:
        @return:
        """
        buy_datas, bigger_buy_datas = HuaXinBuyOrderManager.statistic_big_buy_data(code, datas)
        limit_up_price = round(float(gpcode_manager.get_limit_up_price(code)), 2)
        buy_datas, bigger_buy_datas = HuaXinBuyOrderManager.statistic_big_buy_data(code, datas, limit_up_price)
        if buy_datas:
            BigOrderDealManager().add_buy_datas(code, buy_datas)
            RedicalBuyDataManager.big_order_deal(code)
        try:
            is_placed_order = l2_data_manager.TradePointManager.is_placed_order(order_begin_pos)
            if is_placed_order and bigger_buy_datas:
@@ -53,7 +65,8 @@
                    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)
                            LCancelBigNumComputer().add_deal_index(code, buyno_map[order_no]["index"],
                                                                   order_begin_pos.buy_single_index)
        except Exception as e:
            logger_debug.exception(e)

@@ -69,8 +82,12 @@
    @classmethod
    def process_huaxin_transaction_datas(cls, code, datas):
        __start_time = time.time()
        limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
        # 设置成交价
        current_price_process_manager.set_trade_price(code, datas[-1][1])
        try:
            current_price_process_manager.set_trade_price(code, datas[-1][1])
        except:
            pass
        total_datas = l2_data_util.local_today_datas.get(code)
        use_time_list = []
        try:
@@ -84,53 +101,62 @@

            big_sell_order_info = None
            try:
                limit_up_price = gpcode_manager.get_limit_up_price(code)
                if limit_up_price:
                    limit_up_price = round(float(limit_up_price), 2)
                # 统计上板时间
                try:
                    for d in datas:
                        if d[6] > d[7]:
                            # 主动买
                            if d[1] == limit_up_price:
                                # 涨停
                                current_price_process_manager.set_latest_not_limit_up_time(code,
                                                                                           l2_huaxin_util.convert_time(
                                                                                               d[3], with_ms=True))
                        else:
                            # 主动卖（板上）
                            if d[1] == limit_up_price:
                                L2LimitUpSellDataManager.clear_data(code)
                                break
                except:
                    pass

                # 统计卖单
                big_sell_order_info = HuaXinSellOrderStatisticManager.add_transaction_datas(code, datas, limit_up_price)

                _start_time = time.time()
                use_time_list.append(("处理卖单成交数据", _start_time - __start_time))
                if is_placed_order:

                    need_cancel, cancel_msg = SCancelBigNumComputer().set_big_sell_order_info_for_cancel(code,
                                                                                                         big_sell_order_info,
                                                                                                         order_begin_pos)
                    cancel_type = None
                    if need_cancel:
                        cancel_msg = f"S撤:{cancel_msg}"
                        cancel_type = trade_constant.CANCEL_TYPE_S
                    if not need_cancel:
                        need_cancel, cancel_msg = FCancelBigNumComputer().need_cancel_for_p(code, big_sell_order_info,
                        need_cancel, cancel_msg = FCancelBigNumComputer().need_cancel_for_p(code,
                                                                                            order_begin_pos)
                        cancel_type = trade_constant.CANCEL_TYPE_F
                    # 判断时间是否与本地时间相差5s以上
                    if tool.trade_time_sub(tool.get_now_time_str(), l2_huaxin_util.convert_time(datas[-1][3])) > 10:
                        now_seconds = int(tool.get_now_time_str().replace(":", ""))
                        if now_seconds < int("093200"):  # or int("130000") <= now_seconds < int("130200"):
                            need_cancel, cancel_msg = True, f"成交时间与本地时间相差10S以上，{l2_huaxin_util.convert_time(datas[-1][3])}"
                            cancel_type = trade_constant.CANCEL_TYPE_L2_DELAY
                    if need_cancel:
                        L2TradeDataProcessor.cancel_buy(code, cancel_msg)
                        L2TradeDataProcessor.cancel_buy(code, cancel_msg, cancel_type=cancel_type)

                    # GCancelBigNumComputer().set_big_sell_order_info(code, big_sell_order_info)
                    use_time_list.append(("处理卖单相关撤数据", time.time() - _start_time))
                    _start_time = time.time()
                # 统计涨停卖成交
                HuaXinSellOrderStatisticManager.statistic_total_deal_volume(code, datas, limit_up_price)
                use_time_list.append(("统计成交量数据", time.time() - _start_time))
            except Exception as e:
                async_log_util.error(logger_debug, f"卖单统计异常：{big_sell_order_info}")
                logger_debug.exception(e)

            _start_time = time.time()
            # 计算已经成交的大单
            # big_money_count = 0
            # for d in datas:
            #     data = buyno_map.get(f"{d[6]}")
            #     buy_num = None
            #     if data:
            #         buy_num = data["val"]["num"] * 100
            #     # 统计成交单
            #     deal_info = HuaXinBuyOrderManager.statistic_deal_desc(code, d, buy_num)
            #     if deal_info and deal_info[1]:
            #         data = buyno_map.get(f"{deal_info[0]}")
            #         print("已经成交索引：", data["index"])
            #         val = data["val"]
            #         if l2_data_util.is_big_money(val) and L2DataUtil.is_limit_up_price_buy(val):
            #             big_money_count += 1
            #             DealOrderNoManager().add_orderno(code, f"{deal_info[0]}")
            #         # L后是否有成交，如果有成交就需要除去当前笔数，然后重新囊括一笔
            #         # 暂时不需要这种复杂的机制
            #         # LCancelBigNumComputer().add_deal_index(code, data["index"], order_begin_pos.buy_single_index)
            L2LimitUpSellDataManager.set_deal_datas(code, datas)
            cls.__statistic_thread_pool.submit(cls.statistic_big_order_infos, code, datas, order_begin_pos)

            use_time_list.append(("统计买单数据", time.time() - _start_time))
@@ -153,7 +179,24 @@
                                                               total_datas)
                    cancel_result = FCancelBigNumComputer().need_cancel_for_deal_fast(code, buy_progress_index)
                    if cancel_result[0]:
                        L2TradeDataProcessor.cancel_buy(code, f"F撤:{cancel_result[1]}")
                        L2TradeDataProcessor.cancel_buy(code, f"F撤:{cancel_result[1]}",
                                                        cancel_type=trade_constant.CANCEL_TYPE_F)
                    if not cancel_result[0]:
                        try:
                            cancel_result = NBCancelBigNumComputer().need_cancel(code, buy_progress_index)
                            if cancel_result[0]:
                                L2TradeDataProcessor.cancel_buy(code, f"大市值无大单撤:{cancel_result[1]}",
                                                                cancel_type=trade_constant.CANCEL_TYPE_NB)
                        except:
                            pass

                    if not cancel_result[0] and buy_progress_index_changed:
                        try:
                            cancel_result = FCancelBigNumComputer().need_cancel_for_w(code)
                            if cancel_result[0]:
                                L2TradeDataProcessor.cancel_buy(code, f"W撤:{cancel_result[1]}", cancel_type=trade_constant.CANCEL_TYPE_W)
                        except:
                            pass

                    SCancelBigNumComputer().set_transaction_index(code, order_begin_pos.buy_single_index,
                                                                  buy_progress_index)
@@ -172,4 +215,5 @@
        finally:
            use_time = int((time.time() - __start_time) * 1000)
            if use_time > 5:
                async_log_util.info(hx_logger_l2_upload, f"{code}处理成交用时：{use_time}  详情:{use_time_list}")
                async_log_util.info(hx_logger_l2_upload,
                                    f"{code}处理成交用时：{use_time} 数据数量：{len(datas)}  详情:{use_time_list}")