激进下单

Administrator

2024-04-19 69326ac0e494b819016f28862c9822c7155d0fd8

激进下单

 l2/place_order_single_data_manager.py

@@ -22,6 +22,27 @@
    # 主动卖订单号集合
    __active_sell_order_no_set_dict = {}

    # 主动买单数据,格式：{"code":[买单号，当前成交手数, 当前成交金额, 开始时间, 结束时间]}
    __latest_active_buy_order_data_dict = {}
    # 所有的买单数据，格式：{code:[[买单数据],...]}
    __active_buy_order_datas_dict = {}

    @classmethod
    def clear_passive_sell_data(cls, code):
        """
        清除被动卖相关的数据
        @param code:
        @return:
        """
        if code in cls.__latest_active_buy_order_data_dict:
            cls.__latest_active_buy_order_data_dict.pop(code)
        if code in cls.__active_buy_order_datas_dict:
            cls.__active_buy_order_datas_dict.pop(code)
        if code in cls.__latest_limit_up_sell_list_dict:
            cls.__latest_limit_up_sell_list_dict.pop(code)
        if code in cls.__latest_limit_up_sell_order_no_set_dict:
            cls.__latest_limit_up_sell_order_no_set_dict.pop(code)

    @classmethod
    def add_l2_delegate_limit_up_sell(cls, code, data):
        """
@@ -86,7 +107,36 @@
                return
            sell_info = sell_list[-1]
            for data in datas:
                if data[6] < data[7] or data[1] != limit_up_price:
                # 过滤被动买
                if data[6] < data[7]:
                    # 出现被动买需要将历史大单清空
                    if cls.__active_buy_order_datas_dict.get(code):
                        cls.__active_buy_order_datas_dict[code].clear()
                    continue
                # 统计买单数据
                if code not in cls.__latest_active_buy_order_data_dict:
                    # [买单号，当前成交股数, 当前成交金额, 开始时间, 结束时间]
                    cls.__latest_active_buy_order_data_dict[code] = [data[6], data[2], data[2] * data[1], data[3],
                                                                     data[3]]
                else:
                    if data[6] == cls.__latest_active_buy_order_data_dict[code][0]:
                        # 同一买单号
                        cls.__latest_active_buy_order_data_dict[code][1] += data[2]
                        cls.__latest_active_buy_order_data_dict[code][2] += data[2] * data[1]
                        cls.__latest_active_buy_order_data_dict[code][4] = data[3]
                    else:
                        # 不同买单号
                        if cls.__latest_active_buy_order_data_dict[code][2] >= 2990000:
                            # 加入大单列表
                            if code not in cls.__active_buy_order_datas_dict:
                                cls.__active_buy_order_datas_dict[code] = []
                            cls.__active_buy_order_datas_dict[code].append(
                                cls.__latest_active_buy_order_data_dict[code])

                        cls.__latest_active_buy_order_data_dict[code] = [data[6], data[2], data[2] * data[1], data[3],
                                                                         data[3]]

                if data[1] != limit_up_price:
                    # 排除主动卖/非涨停卖
                    continue
                sell_no = data[7]
@@ -106,8 +156,14 @@
                    use_time = round((time.time() - start_time) * 1000, 3)
                    l2_log.info(code, logger_l2_trade_buy,
                                f"找到最近的被动涨停卖单数据：{sell_info['val']['orderNo']}, 成交数据：{data} 计算耗时：{use_time}ms, 可以触发下单")
                    # 将历史大单列表与最近的大单加入列表
                    big_buy_order_datas = []
                    if code in cls.__active_buy_order_datas_dict:
                        big_buy_order_datas.extend(cls.__active_buy_order_datas_dict[code])
                    if cls.__latest_active_buy_order_data_dict[code][2] >= 2990000:
                        big_buy_order_datas.append(cls.__latest_active_buy_order_data_dict[code])
                    # 成交完成
                    L2TradeSingleDataManager.set_latest_sell_data(code, data)
                    L2TradeSingleDataManager.set_latest_sell_data(code, data, big_buy_order_datas)
                    l2_log.info(code, logger_l2_trade_buy, "被动卖数据处理完毕")
                    break
                    # l2_log.info(code, logger_l2_trade_buy, f"找到最近的被动涨停卖单数据：{data['val']['orderNo']}, 可以触发下单")
@@ -137,10 +193,11 @@
    交易信号回调
    """

    def OnTradeSingle(self, code, _type, data):
    def OnTradeSingle(self, code, big_buy_order_count, _type, data):
        """
         交易数据信号回调
        @param code:
        @param big_buy_order_count: 大买单数量
        @param _type: 类型：0-TYPE_PASSIVE  1-TYPE_ACTIVE
        @param data: (逐笔成交数据,生效时间)
        @return:
@@ -167,20 +224,29 @@
        cls.__callback = callback

    @classmethod
    def set_latest_sell_data(cls, code, data):
    def set_latest_sell_data(cls, code, data, big_active_buy_order_datas):

        """
        设置最近成交的涨停卖被动成交数据
        @param code: 代码
        @param data: L2逐笔成交数据  数据格式：(data['SecurityID'], data['TradePrice'], data['TradeVolume'],
        #           data['OrderTime'], data['MainSeq'], data['SubSeq'], data['BuyNo'],
        #           data['SellNo'], data['ExecType'])
        @param big_active_buy_order_datas: 大主动买单数据：[[买单号，当前成交股数, 当前成交金额, 开始时间, 结束时间],....]
        @return:
        """
        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.TYPE_PASSIVE, cls.__latest_sell_data_dict[code])
            big_buy_order_count = 0
            if big_active_buy_order_datas:
                for b in big_active_buy_order_datas:
                    if b[0] > data[7]:
                        # 买单在卖单之后
                        big_buy_order_count += 1

            cls.__callback.OnTradeSingle(code, big_buy_order_count, cls.TYPE_PASSIVE, cls.__latest_sell_data_dict[code])

    @classmethod
    def set_sell_passive_to_active_datas(cls, code, passive_data, active_data):
@@ -197,7 +263,7 @@
        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.TYPE_ACTIVE, cls.__latest_sell_active_deal_data_dict[code])
            cls.__callback.OnTradeSingle(code, 0, cls.TYPE_ACTIVE, cls.__latest_sell_active_deal_data_dict[code])

    @classmethod
    def get_valid_trade_single(cls, code, latest_time_with_ms):
@@ -241,3 +307,5 @@

        if code in cls.__latest_sell_active_deal_data_dict:
            cls.__latest_sell_active_deal_data_dict.pop(code)

        L2TradeSingleDataProcessor.clear_passive_sell_data(code)

 test/test_sell.py

@@ -2,6 +2,7 @@
from l2.l2_data_manager import OrderBeginPosInfo
from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager
from l2 import l2_data_util, cancel_buy_strategy
from l2.place_order_single_data_manager import L2TradeSingleDataProcessor
from log_module import log_export, async_log_util
from utils import tool

@@ -68,7 +69,7 @@
    for data in datas:
        for d in data:
            if d[6] == 24975654:
                print(d[1]*d[2], d)
                print(d[1] * d[2], d)

            type = -1
            if d[7] > d[6]:
@@ -148,13 +149,26 @@
        # print(i, sum([x[1] * x[2] for x in big_sell_order_info[1]]), big_sell_order_info)


def test_process_transaction_datas():
    data_map = log_export.load_huaxin_transaction_map(date="2024-04-17")
    code = "002376"
    datas = data_map.get(code)
    l2_data_util.load_l2_data(code)

    L2TradeSingleDataProcessor.add_l2_delegate_limit_up_sell(code, {"val": {"orderNo": 123123}, "index": 123})

    for data in datas:
        L2TradeSingleDataProcessor.process_passive_limit_up_sell_data(code, data, 5.78)


if __name__ == '__main__':
    # s
    real_order_time_ms = "09:30:47" + ".{0:0>3}".format(220)
    big_sell_order_info = [1809599, [[7351750, 208000, 8.7, (11042670, 527268), (11042670, 527275)]]]
    max_money = 0
    for x in big_sell_order_info[1]:
        deal_time = l2_huaxin_util.convert_time(x[4][0], with_ms=True)
        if real_order_time_ms:
            if tool.trade_time_sub_with_ms(deal_time, real_order_time_ms) >= 0:
                print("123123")
    # real_order_time_ms = "09:30:47" + ".{0:0>3}".format(220)
    # big_sell_order_info = [1809599, [[7351750, 208000, 8.7, (11042670, 527268), (11042670, 527275)]]]
    # max_money = 0
    # for x in big_sell_order_info[1]:
    #     deal_time = l2_huaxin_util.convert_time(x[4][0], with_ms=True)
    #     if real_order_time_ms:
    #         if tool.trade_time_sub_with_ms(deal_time, real_order_time_ms) >= 0:
    #             print("123123")
    test_process_transaction_datas()

 trade/huaxin/huaxin_trade_server.py

@@ -1712,7 +1712,7 @@


class MyL2TradeSingleCallback(L2TradeSingleCallback):
    def OnTradeSingle(self, code, _type, data):
    def OnTradeSingle(self, code, big_buy_order_count, _type, data):
        # 只处理深证的票
        if code.find("00") != 0:
            return
@@ -1723,37 +1723,58 @@
                # 已经下单了
                return

            l2_log.debug(code, "成交触发买入计算 触发模式：{}", _type)
            # 找到最近的大买单
            l2_log.debug(code, "成交触发买入计算 触发模式：{} 大单数量:{}", _type, big_buy_order_count)

            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]:
                    volume_rate = code_volumn_manager.get_volume_rate(code)
                    order_begin_pos = OrderBeginPosInfo(buy_single_index=i,
                                                        buy_exec_index=i,
                                                        buy_compute_index=i,
                                                        num=0, count=1,
                                                        max_num_set=set(),
                                                        buy_volume_rate=volume_rate,
                                                        mode=OrderBeginPosInfo.MODE_ACTIVE,
                                                        sell_info=None,
                                                        threshold_money=0)
                    l2_data_manager_new.L2TradeDataProcessor.save_order_begin_data(code, order_begin_pos)
                    l2_log.debug(code, "获取到买入执行位置：{} 成交数据触发模式：{}",
                                 order_begin_pos.buy_exec_index,
                                 _type)
                    l2_data_manager_new.L2TradeDataProcessor.start_buy(code, total_datas[-1], total_datas[-1]["index"],
                                                                       True)
                    break
            if _type == L2TradeSingleDataManager.TYPE_PASSIVE and big_buy_order_count > 0:
                # 被动下单且大单数量大于0就可以激进下单
                last_index = total_datas[-1]["index"]
                volume_rate = code_volumn_manager.get_volume_rate(code)
                order_begin_pos = OrderBeginPosInfo(buy_single_index=last_index,
                                                    buy_exec_index=last_index,
                                                    buy_compute_index=last_index,
                                                    num=0, count=1,
                                                    max_num_set=set(),
                                                    buy_volume_rate=volume_rate,
                                                    mode=OrderBeginPosInfo.MODE_ACTIVE,
                                                    sell_info=None,
                                                    threshold_money=0)
                l2_data_manager_new.L2TradeDataProcessor.save_order_begin_data(code, order_begin_pos)
                l2_log.debug(code, "激进下单，获取到买入执行位置：{} 成交数据触发模式：{} 大单数量：{}",
                             order_begin_pos.buy_exec_index,
                             _type, big_buy_order_count)
                l2_data_manager_new.L2TradeDataProcessor.start_buy(code, total_datas[-1], total_datas[-1]["index"],
                                                                   True)
            else:
                # 找到最近的大买单
                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]:
                        volume_rate = code_volumn_manager.get_volume_rate(code)
                        order_begin_pos = OrderBeginPosInfo(buy_single_index=i,
                                                            buy_exec_index=i,
                                                            buy_compute_index=i,
                                                            num=0, count=1,
                                                            max_num_set=set(),
                                                            buy_volume_rate=volume_rate,
                                                            mode=OrderBeginPosInfo.MODE_ACTIVE,
                                                            sell_info=None,
                                                            threshold_money=0)
                        l2_data_manager_new.L2TradeDataProcessor.save_order_begin_data(code, order_begin_pos)
                        l2_log.debug(code, "非激进下单，获取到买入执行位置：{} 成交数据触发模式：{}",
                                     order_begin_pos.buy_exec_index,
                                     _type)
                        l2_data_manager_new.L2TradeDataProcessor.start_buy(code, total_datas[-1], total_datas[-1]["index"],
                                                                           True)
                        break
        except Exception as e:
            logger_debug.exception(e)