新版深证下单完善

Administrator

2024-04-12 8af3f10903d5735a79237ef6a1d373ca69d41b41

新版深证下单完善

 l2/l2_data_manager_new.py

@@ -404,8 +404,6 @@
                                L2TradeSingleDataProcessor.add_l2_delegate_limit_up_sell_cancel(code,d['val']['orderNo'])
                    except Exception as e:
                        logger_debug.exception(e)


                except:
                    async_log_util.error(logger_l2_error, f"{code} 处理真实下单位置出错")
            # 第1条数据是否为09:30:00

 l2/place_order_single_data_manager.py

@@ -15,7 +15,7 @@

    __latest_limit_up_sell_list_dict = {}

    __latest_limit_up_sell_order_no_index_dict = {}
    __latest_limit_up_sell_order_no_set_dict = {}

    @classmethod
    def add_l2_delegate_limit_up_sell(cls, code, data):
@@ -28,10 +28,15 @@
        if code not in cls.__latest_limit_up_sell_list_dict:
            cls.__latest_limit_up_sell_list_dict[code] = []
        cls.__latest_limit_up_sell_list_dict[code].append(data)
        if code not in cls.__latest_limit_up_sell_order_no_index_dict:
            cls.__latest_limit_up_sell_order_no_index_dict[code] = {}
        cls.__latest_limit_up_sell_order_no_index_dict[code][data['val']['orderNo']] = len(
            cls.__latest_limit_up_sell_list_dict[code]) - 1
        if code not in cls.__latest_limit_up_sell_order_no_set_dict:
            cls.__latest_limit_up_sell_order_no_set_dict[code] = set()
        cls.__latest_limit_up_sell_order_no_set_dict[code].add(data['val']['orderNo'])
        # 只保留前20的数据
        if len(cls.__latest_limit_up_sell_list_dict[code]) > 20:
            cls.__latest_limit_up_sell_list_dict[code] = cls.__latest_limit_up_sell_list_dict[code][-20:]
            # 删除之前的map
            for d in cls.__latest_limit_up_sell_list_dict[code][0:-20]:
                cls.__latest_limit_up_sell_order_no_set_dict[code].discard(d["val"]["orderNo"])

    @classmethod
    def add_l2_delegate_limit_up_sell_cancel(cls, code, order_no):
@@ -41,13 +46,17 @@
        @param order_no:
        @return:
        """
        if code not in cls.__latest_limit_up_sell_order_no_index_dict:
        if code not in cls.__latest_limit_up_sell_order_no_set_dict:
            return
        index = cls.__latest_limit_up_sell_order_no_index_dict[code].get(order_no)
        if index is None:
        order_no_set = cls.__latest_limit_up_sell_order_no_set_dict[code]
        if order_no not in order_no_set:
            return
        cls.__latest_limit_up_sell_order_no_index_dict[code].pop(order_no)
        cls.__latest_limit_up_sell_list_dict[code].pop(index)
        cls.__latest_limit_up_sell_order_no_set_dict[code].discard(order_no)

        for i in range(0, len(cls.__latest_limit_up_sell_list_dict[code])):
            if cls.__latest_limit_up_sell_list_dict[code][i]['val']['orderNo'] == order_no:
                cls.__latest_limit_up_sell_list_dict[code].pop(i)
                break

    @classmethod
    def process_passive_limit_up_sell_data(cls, data):
@@ -78,20 +87,38 @@
                return
            sell_info = sell_list[-1]
            sell_info_num = sell_info['val']['num']
            deal_num = cls.__latest_sell_data[code][1]//100
            deal_num = cls.__latest_sell_data[code][1] // 100

            l2_log.info(code, logger_l2_trade_buy, f"最近涨停卖：{sell_info['val']['orderNo']} 卖量：{sell_info_num} 成交量：{deal_num}")
            l2_log.info(code, logger_l2_trade_buy,
                        f"最近涨停卖：{sell_info['val']['orderNo']} 卖量：{sell_info_num} 成交量：{deal_num}")
            if sell_no == sell_info['val']['orderNo'] and sell_info_num == deal_num:
                # 成交完成
                L2TradeSingleDataManager.set_latest_sell_data(code, data)
                l2_log.info(code, logger_l2_trade_buy,f"{code}#找到最近的被动涨停卖单数据：{sell_info['val']['orderNo']}, 可以触发下单")
                l2_log.info(code, logger_l2_trade_buy, f"{code}#找到最近的被动涨停卖单数据：{sell_info['val']['orderNo']}, 可以触发下单")

                # l2_log.info(code, logger_l2_trade_buy, f"找到最近的被动涨停卖单数据：{data['val']['orderNo']}, 可以触发下单")
        except Exception as e:
            logger_debug.exception(e)


class L2TradeSingleCallback:
    """
    交易信号回调
    """

    def OnTradeSingle(self, code, _type, data):
        """
         交易数据信号回调
        @param code:
        @param _type: 类型：0-TYPE_PASSIVE  1-TYPE_ACTIVE
        @param data: (逐笔成交数据,生效时间)
        @return:
        """


class L2TradeSingleDataManager:
    __callback = None

    TYPE_PASSIVE = 0
    TYPE_ACTIVE = 1

@@ -103,6 +130,10 @@

    # 由被动向主动卖成交转变的数据
    __latest_sell_active_deal_data_dict = {}  # 格式为：{code:(逐笔成交数据,生效时间（带ms）)}

    @classmethod
    def set_callback(cls, callback: L2TradeSingleCallback):
        cls.__callback = callback

    @classmethod
    def set_latest_sell_data(cls, code, data):
@@ -117,6 +148,8 @@
        deal_time = l2_huaxin_util.convert_time(data[3], True)
        # 生效时间在1s以内
        cls.__latest_sell_data_dict[code] = (data, tool.trade_time_add_millionsecond(deal_time, 1000))
        if cls.__callback:
            cls.__callback.OnTradeSingle(code, cls.__latest_sell_data_dict[code])

    @classmethod
    def set_sell_passive_to_active_datas(cls, code, passive_data, active_data):
@@ -132,6 +165,8 @@
        # 生效时间在1s以内
        cls.__latest_sell_active_deal_data_dict[code] = (
            active_data, tool.trade_time_add_millionsecond(deal_time, 1000))
        if cls.__callback:
            cls.__callback.OnTradeSingle(code, cls.__latest_sell_active_deal_data_dict[code])

    @classmethod
    def get_valid_trade_single(cls, code, latest_time_with_ms):

 trade/huaxin/huaxin_trade_server.py

@@ -41,11 +41,12 @@
from l2.l2_sell_manager import L2MarketSellManager
from l2.l2_transaction_data_manager import HuaXinBuyOrderManager
from l2.l2_transaction_data_processor import HuaXinTransactionDatasProcessor
from l2.place_order_single_data_manager import L2TradeSingleCallback, L2TradeSingleDataManager
from log_module import async_log_util, log_export
from log_module.log import hx_logger_contact_debug, hx_logger_trade_callback, \
    hx_logger_l2_orderdetail, hx_logger_l2_transaction, hx_logger_l2_market_data, logger_l2_g_cancel, logger_debug, \
    logger_system, logger_trade, logger_trade_position_api_request, logger_request_api, \
    logger_local_huaxin_l1_trade_info, logger_real_place_order_position
    logger_local_huaxin_l1_trade_info, logger_real_place_order_position, logger_l2_trade_buy
from third_data import block_info, kpl_data_manager, kpl_util
from third_data.code_plate_key_manager import KPLCodeJXBlockManager, CodePlateKeyBuyManager
from third_data.history_k_data_util import JueJinApi, HistoryKDatasUtils
@@ -61,7 +62,8 @@
from trade.l2_trade_factor import L2PlaceOrderParamsManager
from trade.sell import sell_manager
from trade.sell.sell_rule_manager import TradeRuleManager, SellRule
from trade.trade_manager import TradeTargetCodeModeManager, MarketSituationManager, AutoCancelSellModeManager
from trade.trade_manager import TradeTargetCodeModeManager, MarketSituationManager, AutoCancelSellModeManager, \
    CodesTradeStateManager
from utils import socket_util, data_export_util, middle_api_protocol, tool, huaxin_util, output_util, sell_util

trade_data_request_queue = queue.Queue()
@@ -1705,6 +1707,34 @@
        trade_api.set_response(data_json["request_id"], data_json['data'])


class MyL2TradeSingleCallback(L2TradeSingleCallback):
    def OnTradeSingle(self, code, _type, data):
        try:
            # 判断是否下单
            state = CodesTradeStateManager().get_trade_state_cache(code)

            if state == trade_manager.TRADE_STATE_BUY_DELEGATED or state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER or state == trade_manager.TRADE_STATE_BUY_SUCCESS:
                # 已经下单了
                return
            # 找到最近的大买单
            total_datas = l2_data_util.local_today_datas.get(code)
            for i in range(len(total_datas)-1,-1,-1):
                d = total_datas[i]
                val = d['val']
                if not L2DataUtil.is_limit_up_price_buy(val):
                    continue
                if val['num'] * float(val['price']) < 5000:
                    continue
                if val['orderNo'] < data[0][6]:
                    continue
                result = L2TradeSingleDataManager.is_can_place_order(code,d)
                if result and result[0]:
                    l2_log.info(code,logger_l2_trade_buy,f"触发下单：{result[1]}")
        except Exception as e:
            logger_debug.exception(e)



# 回调
my_l2_data_callback = MyL2DataCallback()
my_l2_data_callbacks = [MyL2DataCallback() for i in range(constant.HUAXIN_L2_MAX_CODES_COUNT)]
@@ -1728,6 +1758,7 @@
    schedule.every().day.at("09:10:00").do(huaxin_trade_data_update.add_position_list)
    threading.Thread(target=run_pending, daemon=True).start()
    l2_data_util.load_l2_data_all(True)
    L2TradeSingleDataManager.set_callback(MyL2TradeSingleCallback())


def run(queue_strategy_r_trade_w, queue_l1_w_strategy_r, queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_read,