新版深证下单完善

Administrator

2024-04-12 b92c5507bc73f043882ccf39fa5376686b4684d6

新版深证下单完善

 l2/l2_data_manager_new.py

@@ -8,7 +8,7 @@
from l2.huaxin import l2_huaxin_util, huaxin_delegate_postion_manager
from l2.l2_sell_manager import L2MarketSellManager, L2LimitUpSellManager
from l2.l2_transaction_data_manager import HuaXinSellOrderStatisticManager
from l2.place_order_single_data_manager import L2TradeSingleManager
from l2.place_order_single_data_manager import L2TradeSingleDataProcessor
from l2.transaction_progress import TradeBuyQueue
from log_module import async_log_util, log_export
from third_data import kpl_data_manager, block_info
@@ -399,9 +399,9 @@
                    try:
                        for d in add_datas:
                            if L2DataUtil.is_limit_up_price_sell(d['val']):
                                L2TradeSingleManager.add_l2_delegate_limit_up_sell(code,d)
                                L2TradeSingleDataProcessor.add_l2_delegate_limit_up_sell(code,d)
                            elif  L2DataUtil.is_limit_up_price_sell_cancel(d['val']):
                                L2TradeSingleManager.add_l2_delegate_limit_up_sell_cancel(code,d['val']['orderNo'])
                                L2TradeSingleDataProcessor.add_l2_delegate_limit_up_sell_cancel(code,d['val']['orderNo'])
                    except Exception as e:
                        logger_debug.exception(e)


 l2/l2_transaction_data_manager.py

@@ -8,7 +8,7 @@
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 L2TradeSingleManager
from l2.place_order_single_data_manager import L2TradeSingleDataProcessor, L2TradeSingleDataManager

from log_module import async_log_util
from log_module.log import hx_logger_l2_transaction_desc, hx_logger_l2_transaction_sell_order
@@ -108,6 +108,8 @@
    # 保存最近成交的价格
    __latest_trade_price_dict = {}

    __last_trade_data_dict = {}

    # 返回最近1s的大单卖：(总卖金额,[(卖单号,总手数,价格,（'开始时间',买单号）,（'结束时间',买单号）),...])
    @classmethod
    def add_transaction_datas(cls, code, datas, limit_up_price=None):
@@ -141,41 +143,53 @@

        for d in datas:
            # 获取当前是否为主动买
            _is_active_sell = is_active_sell(d[7], d[6])
            if not _is_active_sell and d[1] == limit_up_price:
                # 被动涨停卖,这个卖的订单是否在最近的涨停卖列表中
                L2TradeSingleManager.process_passive_limit_up_sell_data(d)
            try:
                _is_active_sell = is_active_sell(d[7], d[6])
                if not _is_active_sell and d[1] == limit_up_price:
                    # 被动涨停卖,这个卖的订单是否在最近的涨停卖列表中
                    L2TradeSingleDataProcessor.process_passive_limit_up_sell_data(d)

            if not _is_active_sell:
                continue
            cls.__latest_sell_order_info_list_dict[code].append(d)
            if code not in cls.__latest_sell_order_dict:
                cls.__latest_sell_order_dict[code] = [d[7], d[2], d[1], (d[3], d[6]), (d[3], d[6])]
            else:
                if cls.__latest_sell_order_dict[code][0] == d[7]:
                    cls.__latest_sell_order_dict[code][1] += d[2]
                    cls.__latest_sell_order_dict[code][2] = d[1]
                    cls.__latest_sell_order_dict[code][4] = (d[3], d[6])
                else:
                    info = cls.__latest_sell_order_dict[code]
                if not _is_active_sell:
                    continue

                    # 上个卖单成交完成
                    # 封存数据，计算新起点
                    # 大于50w的卖单才会保存
                    # 大于50w加入卖单
                    money = info[1] * info[2]
                    if money >= 500000:
                        # 订单里面有成交是主动卖就算主动卖
                        l2_log.info(code, hx_logger_l2_transaction_sell_order,
                                    f"{cls.__latest_sell_order_dict[code]}")
                        cls.__big_sell_order_ids_dict[code].add(info[0])
                        cls.__big_sell_order_info_dict[code][info[0]] = info
                        cls.__big_sell_order_info_list_dict[code].append(info)
                    # 只保留10w以上的单
                    if money > 100000:
                        cls.__latest_all_sell_orders_dict[code].append(info)

                # 判断是否是涨停被动变主动
                last_trade_data = cls.__last_trade_data_dict.get(code)
                if last_trade_data and not is_active_sell(last_trade_data[7], last_trade_data[6]) and last_trade_data[
                    1] == limit_up_price:
                    if d[1] == limit_up_price:
                        # 涨停被动变主动
                        L2TradeSingleDataManager.set_sell_passive_to_active_datas(code, last_trade_data, d)
                cls.__latest_sell_order_info_list_dict[code].append(d)
                if code not in cls.__latest_sell_order_dict:
                    cls.__latest_sell_order_dict[code] = [d[7], d[2], d[1], (d[3], d[6]), (d[3], d[6])]
                else:
                    if cls.__latest_sell_order_dict[code][0] == d[7]:
                        cls.__latest_sell_order_dict[code][1] += d[2]
                        cls.__latest_sell_order_dict[code][2] = d[1]
                        cls.__latest_sell_order_dict[code][4] = (d[3], d[6])
                    else:
                        info = cls.__latest_sell_order_dict[code]

                        # 上个卖单成交完成
                        # 封存数据，计算新起点
                        # 大于50w的卖单才会保存
                        # 大于50w加入卖单
                        money = info[1] * info[2]
                        if money >= 500000:
                            # 订单里面有成交是主动卖就算主动卖
                            l2_log.info(code, hx_logger_l2_transaction_sell_order,
                                        f"{cls.__latest_sell_order_dict[code]}")
                            cls.__big_sell_order_ids_dict[code].add(info[0])
                            cls.__big_sell_order_info_dict[code][info[0]] = info
                            cls.__big_sell_order_info_list_dict[code].append(info)
                        # 只保留10w以上的单
                        if money > 100000:
                            cls.__latest_all_sell_orders_dict[code].append(info)

                        cls.__latest_sell_order_dict[code] = [d[7], d[2], d[1], (d[3], d[6]), (d[3], d[6])]
            finally:
                cls.__last_trade_data_dict[code] = d

        latest_time = l2_huaxin_util.convert_time(datas[-1][3], with_ms=True)
        min_time = tool.trade_time_add_millionsecond(latest_time, -1000)
        min_time_int = int(min_time.replace(":", "").replace(".", ""))

 l2/place_order_single_data_manager.py

@@ -2,10 +2,12 @@
下单信号管理
"""
from l2 import l2_log
from l2.huaxin import l2_huaxin_util
from log_module.log import logger_l2_trade_buy, logger_debug
from utils import tool


class L2TradeSingleManager:
class L2TradeSingleDataProcessor:
    """
    L2逐笔成交数据信号管理
    """
@@ -23,7 +25,6 @@
        @param data:
        @return:
        """
        l2_log.info(code, logger_l2_trade_buy, f"涨停卖数据：{data['val']['orderNo']}")
        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)
@@ -69,15 +70,104 @@
                else:
                    cls.__latest_sell_data[code] = [sell_no, data[2]]
            # 判断是否是最后一笔卖单
            l2_log.info(code, logger_l2_trade_buy, f"被动卖数据：{data}")

            # 判断这个订单号是否成交完
            sell_list = cls.__latest_limit_up_sell_list_dict.get(code)
            if not sell_list:
                return
            sell_info = sell_list[-1]
            l2_log.info(code, logger_l2_trade_buy, f"最近涨停卖：{sell_info['val']['orderNo']}")
            if sell_no == sell_info['val']['orderNo'] and sell_info["val"]["num"] == cls.__latest_sell_data[code][
                1] // 100:
                # 成交完成
                l2_log.info(code, logger_l2_trade_buy, f"找到最近的被动涨停卖单数据：{data['val']['orderNo']}, 可以触发下单")
                L2TradeSingleDataManager.set_latest_sell_data(code, data)
                logger_l2_trade_buy.info(f"{code}#找到最近的被动涨停卖单数据：{data['val']['orderNo']}, 可以触发下单")
                # l2_log.info(code, logger_l2_trade_buy, f"找到最近的被动涨停卖单数据：{data['val']['orderNo']}, 可以触发下单")
        except Exception as e:
            logger_debug.exception(e)


class L2TradeSingleDataManager:
    TYPE_PASSIVE = 0
    TYPE_ACTIVE = 1

    """
    买入信号管理
    """
    # 最近的涨停卖被动成交数据
    __latest_sell_data_dict = {}  # 格式为：{code:(逐笔成交数据,生效时间（带ms）)}

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

    @classmethod
    def set_latest_sell_data(cls, code, data):
        """
        设置最近成交的涨停卖被动成交数据
        @param code: 代码
        @param data: L2逐笔成交数据  数据格式：(data['SecurityID'], data['TradePrice'], data['TradeVolume'],
        #           data['OrderTime'], data['MainSeq'], data['SubSeq'], data['BuyNo'],
        #           data['SellNo'], data['ExecType'])
        @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))

    @classmethod
    def set_sell_passive_to_active_datas(cls, code, passive_data, active_data):
        """
        设置被动卖成交向主动卖成交的转变数据
        @param code: 代码
        @param passive_data: 被动卖成交逐笔
        @param active_data: 主动卖成交逐笔
        @return:
        """
        deal_time = l2_huaxin_util.convert_time(passive_data[3], True)
        # 生效时间在1s以内
        cls.__latest_sell_active_deal_data_dict[code] = (
            active_data, tool.trade_time_add_millionsecond(deal_time, 1000))

    @classmethod
    def get_valid_trade_single(cls, code, latest_time_with_ms):
        """
        获取有效的成交下单信号
        @param code:
        @param latest_time_with_ms:
        @return: （逐笔成交数据, 类型）
        """
        # 如果有最近卖涨停成交完就用最近的数据
        data = cls.__latest_sell_data_dict.get(code)
        if data and tool.trade_time_sub_with_ms(latest_time_with_ms, data[1]) <= 0:
            return data, cls.TYPE_PASSIVE
        data = cls.__latest_sell_active_deal_data_dict.get(code)
        if data and tool.trade_time_sub_with_ms(latest_time_with_ms, data[1]) <= 0:
            return data, cls.TYPE_ACTIVE
        return None

    @classmethod
    def is_can_place_order(cls, code, buy_data):
        """
        是否可以下单
        @param code: 代码
        @param buy_data: L2逐笔委托大于50w的买入数据
        @return: (是否可以下单, 原因)
        """
        buy_data_time_with_ms = tool.to_time_with_ms(buy_data['val']['time'], buy_data['val']['tms'])
        single = cls.get_valid_trade_single(code, buy_data_time_with_ms)
        if not single:
            return False, "没有找到可用信号"
        if single[0][6] < buy_data['val']['orderNo']:
            # 信号位置的成交买单号要小于买入数据的买单号才行
            return True, f"找到信号：{single}"
        else:
            return False, f"买单没有在信号位之后 信号：{single}"

    @classmethod
    def clear_data(cls, code):
        if code in cls.__latest_sell_data_dict:
            cls.__latest_sell_data_dict.pop(code)

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

 utils/tool.py

@@ -244,6 +244,16 @@
    return time_seconds_format(s - 2 - cha)


def to_time_with_ms(time_s_str, time_ms):
    """
    将时间+毫秒数 转为字符串
    @param time_s_str: 时间如:10:00:00
    @param time_ms: 毫秒如: 12
    @return: 如:10:00:00.001
    """
    return f"{time_s_str}." + "{0:0>3}".format(time_ms)


# 全角转半角
def strQ2B(ustring):
    rstring = ""
@@ -329,4 +339,4 @@


if __name__ == "__main__":
    print(trade_time_add_second("11:29:50",15))
    print(to_time_with_ms("11:29:50", 15))