华鑫托管改造初步设计

Administrator

2023-08-10 d534b71782e55c0d5d63da74fe3a3719faf86987

华鑫托管改造初步设计

 huaxin/_lev2mdapi.cp37-win32.pyd

Binary files differ

 huaxin/_lev2mdapi.cp37-win_amd64.pyd

Binary files differ

 huaxin/_lev2mdapi.cpython-37m-x86_64-linux-gnu.so

Binary files differ

 huaxin/_traderapi.cp37-win32.pyd

Binary files differ

 huaxin/_traderapi.cp37-win_amd64.pyd

Binary files differ

 huaxin/_traderapi.cpython-37m-x86_64-linux-gnu.so

Binary files differ

 huaxin/_xmdapi.cp37-win32.pyd

Binary files differ

 huaxin/_xmdapi.cp37-win_amd64.pyd

Binary files differ

 huaxin/_xmdapi.cpython-37m-x86_64-linux-gnu.so

Binary files differ

 huaxin/client_main.py

New file
@@ -0,0 +1,10 @@
import multiprocessing

from huaxin import l2_client
from huaxin import trade_client




if __name__ == '__main__':
    pass

 huaxin/client_network.py

New file
@@ -0,0 +1,81 @@
import json
import socket

from huaxin import constant
from huaxin import socket_util


class SendResponseSkManager:
    __send_response_sk_dict = {}

    @classmethod
    def get_send_response_sk(cls, type):
        if type not in cls.__send_response_sk_dict:
            client = cls.create_send_response_sk()
            cls.__send_response_sk_dict[type] = client
        return cls.__send_response_sk_dict[type]

    @classmethod
    def del_send_response_sk(cls, type_):
        if type_ in cls.__send_response_sk_dict:
            sk = cls.__send_response_sk_dict[type_]
            cls.__send_response_sk_dict.pop(type_)
            try:
                sk.close()
            except:
                pass

    @classmethod
    def create_send_response_sk(cls):
        addr, port = constant.SERVER_IP, constant.SERVER_PORT
        client = socket.socket()  # 生成socket，连接server
        client.connect((addr, port))
        return client

    @classmethod
    def send_error_response(cls, type, request_id, client_id, msg):
        cls.send_normal_response(type, cls.load_response(client_id, request_id, {"code": 1, "msg": msg}))

    @classmethod
    def __send_normal_response(cls, sk, msg):
        # 添加内容长度头
        msg = cls.format_response(msg)
        sk.send(msg)
        result, header_str = socket_util.recv_data(sk)
        # print("响应", result)
        if result:
            result_json = json.loads(result)
            if result_json.get("code") == 0:
                return True
        return False

    # 发送消息
    @classmethod
    def send_normal_response(cls, type, msg):
        try:
            sk = SendResponseSkManager.get_send_response_sk(type)
            if cls.__send_normal_response(sk, msg):
                return True
            else:
                # 再次发送
                sk = SendResponseSkManager.get_send_response_sk(type)
                return cls.__send_normal_response(sk, msg)
        except ConnectionResetError as e:
            SendResponseSkManager.del_send_response_sk(type)
            sk = SendResponseSkManager.get_send_response_sk(type)
            return cls.__send_normal_response(sk, msg)
        except BrokenPipeError as e:
            SendResponseSkManager.del_send_response_sk(type)
            sk = SendResponseSkManager.get_send_response_sk(type)
            return cls.__send_normal_response(sk, msg)

    @classmethod
    def load_response(cls, client_id, request_id, data_json):
        return json.dumps({"type": "response", "data": data_json, "client_id": client_id,
                           "request_id": request_id}).encode(
            'utf-8')

    @classmethod
    def format_response(cls, data_bytes):
        slen = '##%08d' % len(data_bytes)
        return slen.encode("utf-8") + data_bytes

 huaxin/command_manager.py

New file
@@ -0,0 +1,160 @@
"""
命令管理器
"""
import json
import logging
import random
import socket
import threading
import time

# 心跳信息
import crypt
from huaxin import socket_util
from huaxin.client_network import SendResponseSkManager

MSG_TYPE_HEART = "heart"
# 命令信息
MSG_TYPE_CMD = "cmd"

CLIENT_TYPE_TRADE = "trade"
CLIENT_TYPE_DELEGATE_LIST = "delegate_list"
CLIENT_TYPE_DEAL_LIST = "deal_list"
CLIENT_TYPE_POSITION_LIST = "position_list"
CLIENT_TYPE_MONEY = "money"
CLIENT_TYPE_DEAL = "deal"

CLIENT_TYPE_CMD_L2 = "l2_cmd"

# 心跳时间间隔
HEART_SPACE_TIME = 3


class TradeActionCallback(object):
    # 交易
    def OnTrade(self, client_id, request_id, type_, data):
        pass

    # 委托列表
    def OnDelegateList(self, client_id, request_id):
        pass

    # 成交列表
    def OnDealList(self, client_id, request_id):
        pass

    # 成交列表
    def OnPositionList(self, client_id, request_id):
        pass

    # 获取资金信息
    def OnMoney(self, client_id, request_id):
        pass


class L2ActionCallback(object):
    # 监听L2数据
    def OnSetL2Position(self, client_id, request_id, codes_data):
        pass


# 交易指令管理
class TradeCommandManager:
    trade_client_dict = {}
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

    @classmethod
    def init(cls, trade_action_callback, pipe_l2, pipe_strategy):
        cls.action_callback = trade_action_callback
        cls.pipe_strategy = pipe_strategy
        cls.pipe_l2 = pipe_l2

    @classmethod
    def __process_command(cls, _type, client_id, result_json):
        data = result_json["data"]
        print("接收内容", result_json)
        request_id = result_json.get('request_id')
        if not socket_util.is_client_params_sign_right(result_json):
            print("签名错误")
            # 签名出错
            SendResponseSkManager.send_error_response(_type, request_id, client_id,
                                                      {"code": -1, "msg": "签名错误"})
            return

        if _type == CLIENT_TYPE_TRADE:
            # 交易
            ctype = data["trade_type"]
            cls.action_callback.OnTrade(client_id, request_id, ctype, data)
        elif _type == CLIENT_TYPE_MONEY:
            cls.action_callback.OnMoney(client_id, request_id)
        elif _type == CLIENT_TYPE_DEAL_LIST:
            cls.action_callback.OnDealList(client_id, request_id)
        elif _type == CLIENT_TYPE_DELEGATE_LIST:
            can_cancel = data["can_cancel"]
            cls.action_callback.OnDelegateList(client_id, request_id, can_cancel)
        elif _type == CLIENT_TYPE_POSITION_LIST:
            cls.action_callback.OnPositionList(client_id, request_id)

    @classmethod
    def run_process_command(cls, pipe_strategy):
        if pipe_strategy is None:
            return
        # 本地命令接收
        while True:
            try:
                val = pipe_strategy.recv()
                if val:
                    val = json.loads(val)
                    _type = val["cmd"]
                    _data = val["data"]
                    # 查看是否是设置L2的代码
                    if _type == CLIENT_TYPE_CMD_L2:
                        cls.pipe_l2.send(
                            json.dumps({"type": "set_l2_codes", "data": _data}))
                    else:
                        t1 = threading.Thread(target=lambda: cls.__process_command(_type, None, _data), daemon=True)
                        t1.start()
            except Exception as e:
                logging.exception(e)

    # 维护连接数的稳定
    def run(self, blocking=True):
        if blocking:
            self.run_process_command(self.pipe_strategy)
        else:
            # 接受命令
            t1 = threading.Thread(target=lambda: self.run_process_command(self.pipe_strategy), daemon=True)
            t1.start()


# L2指令管理
class L2CommandManager:

    @classmethod
    def init(cls, l2_action_callback):
        cls.action_callback = l2_action_callback

    @classmethod
    def process_command(cls, _type, client_id, result_json):
        data = result_json["data"]
        request_id = result_json["request_id"]
        ctype = data["type"]
        if not socket_util.is_client_params_sign_right(result_json):
            # 签名出错
            SendResponseSkManager.send_error_response(_type, request_id, client_id,
                                                      {"code": -1, "msg": "签名错误"})
            return
        codes_data = data["data"]
        if ctype == CLIENT_TYPE_CMD_L2:
            cls.action_callback.OnSetL2Position(client_id, request_id, codes_data)


if __name__ == "__main__":
    manager = TradeCommandManager("127.0.0.1", 10008, None)
    manager.run()
    input()

 huaxin/constant.py

New file
@@ -0,0 +1,4 @@
# addr, port = "111.230.16.67", 10008
SERVER_IP = '43.138.167.68'
SERVER_PORT = 10008
TEST = True

 huaxin/crypt.py

New file
@@ -0,0 +1,7 @@
import hashlib


def md5_encrypt(value):
    md5 = hashlib.md5()
    md5.update(value.encode('utf-8'))
    return md5.hexdigest()

 huaxin/document.html

New file
Diff too large

 huaxin/huaxin_trade_api.py

New file
@@ -0,0 +1,242 @@
"""
交易API
"""
import json
import logging
import random
import threading
import time

import crypt
from huaxin import socket_util


class ClientSocketManager:
    # 客户端类型
    CLIENT_TYPE_TRADE = "trade"
    CLIENT_TYPE_DELEGATE_LIST = "delegate_list"
    CLIENT_TYPE_DEAL_LIST = "deal_list"
    CLIENT_TYPE_POSITION_LIST = "position_list"
    CLIENT_TYPE_MONEY = "money"
    CLIENT_TYPE_DEAL = "deal"
    CLIENT_TYPE_CMD_L2 = "l2_cmd"
    socket_client_dict = {}
    socket_client_lock_dict = {}
    active_client_dict = {}

    @classmethod
    def add_client(cls, _type, rid, sk):
        if _type == cls.CLIENT_TYPE_TRADE:
            # 交易列表
            if _type not in cls.socket_client_dict:
                cls.socket_client_dict[_type] = []
            cls.socket_client_dict[_type].append((rid, sk))
            cls.socket_client_lock_dict[rid] = threading.Lock()
        else:
            cls.socket_client_dict[_type] = (rid, sk)
            cls.socket_client_lock_dict[rid] = threading.Lock()

    @classmethod
    def acquire_client(cls, _type):
        if _type == cls.CLIENT_TYPE_TRADE:
            if _type in cls.socket_client_dict:
                # 根据排序活跃时间排序
                client_list = sorted(cls.socket_client_dict[_type], key=lambda x: cls.active_client_dict.get(x[0]) if x[
                                                                                                                          0] in cls.active_client_dict else 0,
                                     reverse=True)
                for d in client_list:
                    if d[0] in cls.socket_client_lock_dict:
                        try:
                            if cls.socket_client_lock_dict[d[0]].acquire(blocking=False):
                                return d
                        except threading.TimeoutError:
                            pass
        else:
            if _type in cls.socket_client_dict:
                try:
                    d = cls.socket_client_dict[_type]
                    if d[0] in cls.socket_client_lock_dict:
                        if cls.socket_client_lock_dict[d[0]].acquire(blocking=False):
                            return d
                except threading.TimeoutError:
                    pass
        return None

    @classmethod
    def release_client(cls, rid):
        if rid in cls.socket_client_lock_dict:
            # 释放锁
            cls.socket_client_lock_dict[rid].release()

    @classmethod
    def del_client(cls, rid):
        # 删除线程锁
        if rid in cls.socket_client_lock_dict:
            cls.socket_client_lock_dict.pop(rid)
        # 删除sk
        for t in cls.socket_client_dict:
            if type(cls.socket_client_dict[t]) == list:
                for d in cls.socket_client_dict[t]:
                    if d[0] == rid:
                        cls.socket_client_dict[t].remove(d)
                        break

            elif type(cls.socket_client_dict[t]) == tuple:
                if cls.socket_client_dict[t][0] == rid:
                    cls.socket_client_dict.pop(t)
                    break

    # 心跳信息
    @classmethod
    def heart(cls, rid):
        cls.active_client_dict[rid] = time.time()


TRADE_DIRECTION_BUY = 1
TRADE_DIRECTION_SELL = 2

# 超时时间2s
TIMEOUT = 2.0

# 等待响应的request_id
__request_response_dict = {}


def __get_request_id(type):
    return f"{type}_{round(time.time() * 10000)}_{random.randint(0, 100000)}"


# 网络请求
def __request(_type, data):
    client = ClientSocketManager.acquire_client(_type)
    if not client:
        raise Exception("无可用的交易client")
    try:
        request_id = __get_request_id(_type)
        root_data = {"type": "cmd",
                     "data": data,
                     "request_id": request_id}
        str_list = []
        for k in root_data:
            if type(root_data[k]) == dict:
                str_list.append(f"{k}={json.dumps(root_data[k])}")
            else:
                str_list.append(f"{k}={root_data[k]}")
        str_list.sort()
        str_list.append("%Yeshi2014@#.")
        root_data["sign"] = crypt.md5_encrypt("&".join(str_list))
        print("请求前对象", root_data)
        # 添加请求头
        client[1].sendall(socket_util.load_header(json.dumps(root_data).encode(encoding='utf-8')))
        result = client[1].recv(1024)
        print("请求发送成功", result.decode(encoding='utf-8'))
    except BrokenPipeError as e:
        ClientSocketManager.del_client(client[0])
        raise e
    except Exception as e:
        logging.exception(e)
        raise e
    return request_id, client


def __read_response(client, request_id, blocking, timeout=TIMEOUT):
    if blocking:
        start_time = time.time()
        while True:
            time.sleep(0.01)
            if request_id in __request_response_dict:
                # 获取到了响应内容
                result = __request_response_dict.pop(request_id)
                return result
            if time.time() - start_time > timeout:
                ClientSocketManager.release_client(client[0])
                raise Exception(f"读取内容超时: request_id={request_id}")
    return None


def set_response(client_id, request_id, response):
    if client_id and request_id:
        # 主动触发
        ClientSocketManager.release_client(client_id)
        __request_response_dict[request_id] = response
    else:
        # 被动触发
        pass


# 下单委托
# direction 1-买  2-卖
# code:代码
# volume：交易量
# price：价格（如果是卖时不传价格就按照5挡价卖）
# blocking是否阻塞进程
def order(direction, code, volume, price, price_type=2, blocking=True):
    print("客户端", ClientSocketManager.socket_client_dict)
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                                   {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 1,
                                    "direction": direction,
                                    "code": code,
                                    "volume": volume,
                                    "price_type": price_type,
                                    "price": price, "sinfo": f"b_{code}_{round(time.time() * 1000)}"})

    return __read_response(client, request_id, blocking)


def cancel_order(direction, code, orderSysID, blocking=False):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                                   {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 2,
                                    "direction": direction,
                                    "code": code,
                                    "orderSysID": orderSysID, "sinfo": f"cb_{code}_{round(time.time() * 1000)}"})

    return __read_response(client, request_id, blocking)


# CLIENT_TYPE_DELEGATE_LIST = "delegate_list"
# CLIENT_TYPE_DEAL_LIST = "deal_list"
# CLIENT_TYPE_POSITION_LIST = "position_list"
# CLIENT_TYPE_MONEY = "money"
# CLIENT_TYPE_DEAL = "deal"

# 获取委托列表
# can_cancel:是否可以撤
def get_delegate_list(can_cancel=True, blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                                    "can_cancel": 1 if can_cancel else 0})

    return __read_response(client, request_id, blocking)


# 获取成交列表
def get_deal_list(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_DEAL_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_DEAL_LIST})
    return __read_response(client, request_id, blocking)


# 获取持仓列表
def get_position_list(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_POSITION_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_POSITION_LIST})
    return __read_response(client, request_id, blocking)


# 获取账户资金状况
def get_money(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_MONEY,
                                   {"type": ClientSocketManager.CLIENT_TYPE_MONEY})
    return __read_response(client, request_id, blocking)


# 设置L2订阅数据
def set_l2_codes_data(codes_data, blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_CMD_L2,
                                   {"type": ClientSocketManager.CLIENT_TYPE_CMD_L2, "data": codes_data})
    return __read_response(client, request_id, blocking)


if __name__ == "__main__":
    d = {"id": "123123"}
    print(d.pop("id"))

 huaxin/l1_client.py

New file
@@ -0,0 +1,214 @@
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import json
import logging
import threading
import time

from huaxin import socket_util
from huaxin import tool
from huaxin import xmdapi
from huaxin.client_network import SendResponseSkManager

level1_data_dict = {

}


def __send_response(sk, msg):
    msg = socket_util.load_header(msg)
    sk.sendall(msg)
    result, header_str = socket_util.recv_data(sk)
    if result:
        result_json = json.loads(result)
        if result_json.get("code") == 0:
            return True
    return False


def get_level1_codes():
    type_ = "get_level1_codes"
    fdata = json.dumps(
        {"type": type_, "data": {}})
    msg = fdata.encode("utf-8")
    # 发送消息
    for i in range(3):
        try:
            sk = SendResponseSkManager.create_send_response_sk()
            msg = socket_util.load_header(msg)
            sk.sendall(msg)
            result, header_str = socket_util.recv_data(sk)
            # 读取代码
            result_json = json.loads(result)
            if result_json["code"] == 0:
                codes = result_json["data"]
                codes_sh = []
                codes_sz = []
                for code in codes:
                    if code.find("00") == 0:
                        codes_sz.append(code.encode("utf-8"))
                    else:
                        codes_sh.append(code.encode("utf-8"))
                return codes_sh, codes_sz
        except ConnectionResetError:
            SendResponseSkManager.del_send_response_sk(type_)
        except BrokenPipeError:
            SendResponseSkManager.del_send_response_sk(type_)
    return None, None


class MdSpi(xmdapi.CTORATstpXMdSpi):
    def __init__(self, api):
        self.codes_sh, self.codes_sz = get_level1_codes()
        xmdapi.CTORATstpXMdSpi.__init__(self)
        self.__api = api

    def OnFrontConnected(self):
        print("OnFrontConnected")

        # 请求登录，目前未校验登录用户，请求域置空即可
        login_req = xmdapi.CTORATstpReqUserLoginField()
        self.__api.ReqUserLogin(login_req, 1)

    def OnRspUserLogin(self, pRspUserLoginField, pRspInfoField, nRequestID):
        if pRspInfoField.ErrorID == 0:
            print('Login success! [%d]' % nRequestID)

            '''
            订阅行情
            当sub_arr中只有一个"00000000"的合约且ExchangeID填TORA_TSTP_EXD_SSE或TORA_TSTP_EXD_SZSE时，订阅单市场所有合约行情
            当sub_arr中只有一个"00000000"的合约且ExchangeID填TORA_TSTP_EXD_COMM时，订阅全市场所有合约行情
            其它情况，订阅sub_arr集合中的合约行情
            '''

            print(f"订阅数量：sh-{len(self.codes_sh)}  sz-{len(self.codes_sz)}")
            if self.codes_sh:
                ret = self.__api.SubscribeMarketData(self.codes_sh, xmdapi.TORA_TSTP_EXD_SSE)
                if ret != 0:
                    print('SubscribeMarketData fail, ret[%d]' % ret)
                else:
                    print('SubscribeMarketData success, ret[%d]' % ret)

            if self.codes_sz:
                ret = self.__api.SubscribeMarketData(self.codes_sz, xmdapi.TORA_TSTP_EXD_SZSE)
                if ret != 0:
                    print('SubscribeMarketData fail, ret[%d]' % ret)
                else:
                    print('SubscribeMarketData success, ret[%d]' % ret)

            # sub_arr = [b'600004']
            # ret = self.__api.UnSubscribeMarketData(sub_arr, xmdapi.TORA_TSTP_EXD_SSE)
            # if ret != 0:
            #     print('UnSubscribeMarketData fail, ret[%d]' % ret)
            # else:
            #     print('SubscribeMarketData success, ret[%d]' % ret)


        else:
            print('Login fail!!! [%d] [%d] [%s]'
                  % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspSubMarketData(self, pSpecificSecurityField, pRspInfoField):
        if pRspInfoField.ErrorID == 0:
            print('OnRspSubMarketData: OK!')
        else:
            print('OnRspSubMarketData: Error! [%d] [%s]'
                  % (pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspUnSubMarketData(self, pSpecificSecurityField, pRspInfoField):
        if pRspInfoField.ErrorID == 0:
            print('OnRspUnSubMarketData: OK!')
        else:
            print('OnRspUnSubMarketData: Error! [%d] [%s]'
                  % (pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRtnMarketData(self, pMarketDataField):
        if pMarketDataField.SecurityName.find("S") == 0:
            return
        if pMarketDataField.SecurityName.find("ST") >= 0:
            return
        close_price = round(pMarketDataField.UpperLimitPrice / 1.1, 2)
        rate = round((pMarketDataField.LastPrice - close_price) * 100 / close_price, 2)
        # print(pMarketDataField.SecurityID, pMarketDataField.SecurityName, rate, pMarketDataField.Volume)

        level1_data_dict[pMarketDataField.SecurityID] = (
            pMarketDataField.SecurityID, pMarketDataField.LastPrice, rate, pMarketDataField.Volume, time.time())
        # print(
        #     "SecurityID[%s] SecurityName[%s] LastPrice[%.2f] Volume[%d] Turnover[%.2f] BidPrice1[%.2f] BidVolume1[%d] AskPrice1[%.2f] AskVolume1[%d] UpperLimitPrice[%.2f] LowerLimitPrice[%.2f]"
        #     % (pMarketDataField.SecurityID, pMarketDataField.SecurityName, pMarketDataField.LastPrice,
        #        pMarketDataField.Volume,
        #        pMarketDataField.Turnover, pMarketDataField.BidPrice1, pMarketDataField.BidVolume1,
        #        pMarketDataField.AskPrice1,
        #        pMarketDataField.AskVolume1, pMarketDataField.UpperLimitPrice, pMarketDataField.LowerLimitPrice))


def __upload_codes_info(pipe_l2, datas):
    if not tool.is_trade_time():
        return
    # 上传数据
    type_ = "set_target_codes"
    fdata = json.dumps(
        {"type": type_, "data": {"data": datas}})
    if pipe_l2 is not None:
        pipe_l2.send(fdata)



def run(pipe_l2):
    # 打印接口版本号
    print(xmdapi.CTORATstpXMdApi_GetApiVersion())

    # 创建接口对象
    api = xmdapi.CTORATstpXMdApi_CreateTstpXMdApi(xmdapi.TORA_TSTP_MST_MCAST)

    # 创建回调对象
    spi = MdSpi(api)

    # 注册回调接口
    api.RegisterSpi(spi)

    # 注册单个行情前置服务地址
    # api.RegisterFront("tcp://224.224.1.19:7880")
    # 注册多个行情前置服务地址，用逗号隔开
    # api.RegisterFront("tcp://10.0.1.101:6402,tcp://10.0.1.101:16402")
    # 注册名字服务器地址，支持多服务地址逗号隔开
    # api.RegisterNameServer('tcp://224.224.3.19:7888')
    # api.RegisterNameServer('tcp://10.0.1.101:52370,tcp://10.0.1.101:62370')
    api.RegisterMulticast("udp://224.224.1.19:7880", None, "")

    # 启动接口
    api.Init()

    # 等待程序结束
    while True:
        print("数量", len(level1_data_dict))
        try:
            if len(level1_data_dict) < 1:
                continue
            # 根据涨幅排序
            list_ = [level1_data_dict[k] for k in level1_data_dict]
            flist = []
            for d in list_:
                if d[2] >= 5:
                    # 涨幅小于5%的需要删除
                    flist.append(d)
            flist.sort(key=lambda x: x[2], reverse=True)
            datas = flist[:100]
            codes = [x[0] for x in datas]
            print("代码数量:", len(datas), codes)
            __upload_codes_info(pipe_l2, datas)
        except Exception as e:
            logging.exception(e)
        finally:
            time.sleep(3)
    # 释放接口对象
    api.Release()


def run_async(pipe_l2):
    t1 = threading.Thread(target=lambda: run(pipe_l2), daemon=True)
    t1.start()


if __name__ == "__main__":
    run(None)

 huaxin/l2_client.py

New file
@@ -0,0 +1,550 @@
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import json
import logging
import queue
import threading
import time

from huaxin import command_manager
from huaxin import constant
from huaxin import l2_data_manager
from huaxin import lev2mdapi
from huaxin.command_manager import L2ActionCallback
from huaxin.mylog import logger_l2_orderdetail, logger_l2_transaction, logger_l2_subscript

Front_Address = "tcp://10.0.1.101:6900"
Multicast_Address = "udp://224.224.2.19:7889"
Multicast_Address2 = "udp://224.224.224.234:7890"
Local_Interface_Address = "192.168.84.75"
Sender_Interface_Address = "10.0.1.101"

g_SubMarketData = False
g_SubTransaction = False
g_SubOrderDetail = False
g_SubXTSTick = False
g_SubXTSMarketData = False
g_SubNGTSTick = False
g_SubBondMarketData = False
g_SubBondTransaction = False
g_SubBondOrderDetail = False

SH_Securities = [b"603000", b"600225", b"600469", b"600616", b"600059", b"002849", b"605188", b"603630", b"600105",
                 b"603773", b"603915", b"603569", b"603322", b"603798", b"605198", b"603079", b"600415", b"600601"]
SH_XTS_Securities = [b"018003", b"113565"]

SZ_Securities = [b"002456", b"002849", b"002281", b"002336", b"000936", b"000920", b"000757", b"002896", b"002725",
                 b"000952", b"000526", b"000753", b"000681", b"002088", b"002436"]
SZ_Bond_Securities = [b"100303", b"109559", b"112617"]
spi = None
set_codes_data_queue = queue.Queue()
market_code_dict = {}


class Lev2MdSpi(lev2mdapi.CTORATstpLev2MdSpi):
    latest_codes_set = set()
    codes_volume_and_price_dict = {}
    special_code_volume_for_order_dict = {}
    # 已经订阅的代码
    subscripted_codes = set()

    def __init__(self, api):
        lev2mdapi.CTORATstpLev2MdSpi.__init__(self)
        self.__api = api
        self.is_login = False

    def __split_codes(self, codes):
        szse_codes = []
        sse_codes = []
        for code in codes:
            if code.find("00") == 0:
                szse_codes.append(code.encode())
            elif code.find("60") == 0:
                sse_codes.append(code.encode())
        return sse_codes, szse_codes

    # 新增订阅

    # 取消订阅
    def __unsubscribe(self, _codes):
        sh, sz = self.__split_codes(_codes)
        logger_l2_subscript.info(f"取消订阅上证：{sh}")
        logger_l2_subscript.info(f"取消订阅深证：{sz}")
        if sh:
            # 取消订阅逐笔委托
            self.__api.UnSubscribeOrderDetail(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
            # 取消订阅逐笔成交
            self.__api.UnSubscribeTransaction(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
            self.__api.UnSubscribeMarketData(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
        if sz:
            self.__api.UnSubscribeOrderDetail(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)
            self.__api.UnSubscribeTransaction(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)
            self.__api.UnSubscribeMarketData(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)

    def __subscribe(self, _codes):
        sh, sz = self.__split_codes(_codes)
        logger_l2_subscript.info(f"订阅上证：{sh}")
        logger_l2_subscript.info(f"订阅深证：{sz}")
        if sh:
            # 订阅逐笔委托
            result = self.__api.SubscribeOrderDetail(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
            logger_l2_subscript.info(f"逐笔委托订阅结果sh：{result}")
            # 订阅逐笔成交
            result = self.__api.SubscribeTransaction(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
            logger_l2_subscript.info(f"逐笔成交订阅结果sh：{result}")

            result = self.__api.SubscribeMarketData(sh, lev2mdapi.TORA_TSTP_EXD_SSE)
            logger_l2_subscript.info(f"市场订阅结果sh：{result}")
        if sz:
            result = self.__api.SubscribeOrderDetail(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)
            logger_l2_subscript.info(f"逐笔委托订阅结果sz：{result}")
            result = self.__api.SubscribeTransaction(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)
            logger_l2_subscript.info(f"逐笔成交订阅结果sz：{result}")
            result = self.__api.SubscribeMarketData(sz, lev2mdapi.TORA_TSTP_EXD_SZSE)
            logger_l2_subscript.info(f"市场订阅结果sz：{result}")

    def __process_codes_data(self, codes_data):

        if not self.is_login and not constant.TEST:
            raise Exception("L2尚未登录")

        codes = set()
        for d in codes_data:
            code = d[0]
            codes.add(code)
            self.codes_volume_and_price_dict[code] = (d[1], d[2])
        add_codes = codes - self.subscripted_codes
        del_codes = self.subscripted_codes - codes
        print("add del codes", add_codes, del_codes)
        for c in codes:
            l2_data_manager.target_codes.add(c)
        for c in del_codes:
            l2_data_manager.target_codes.discard(c)
        for c in add_codes:
            l2_data_manager.run_upload_task(c)
        self.__subscribe(add_codes)
        self.__unsubscribe(del_codes)

        # 设置最近的代码列表
        self.latest_codes_set = codes

    # 订阅代码,[(代码,最低手数,涨停价)]
    def set_codes_data(self, codes_data):
        self.__process_codes_data(codes_data)

    def set_code_special_watch_volume(self, code, volume):
        # 有效期为3s
        self.special_code_volume_for_order_dict[code] = (volume, time.time() + 3)

    def OnFrontConnected(self):
        print("OnFrontConnected")

        logout_req = lev2mdapi.CTORATstpUserLogoutField()
        self.__api.ReqUserLogout(logout_req, 1)
        time.sleep(1)
        # 请求登录
        login_req = lev2mdapi.CTORATstpReqUserLoginField()
        self.__api.ReqUserLogin(login_req, 2)

    def OnRspUserLogin(self, pRspUserLogin, pRspInfo, nRequestID, bIsLast):
        print("OnRspUserLogin: ErrorID[%d] ErrorMsg[%s] RequestID[%d] IsLast[%d]" % (
            pRspInfo['ErrorID'], pRspInfo['ErrorMsg'], nRequestID, bIsLast))
        if pRspInfo['ErrorID'] == 0:
            print("----L2行情登录成功----")
            self.is_login = True
            # t1 = threading.Thread(target=lambda: self.__set_codes_data(), daemon=True)
            # # 后台运行
            # t1.start()

    def OnRspSubMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubMarketData")

    def OnRspSubIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubIndex")

    def OnRspSubTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubTransaction")

    def OnRspSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubOrderDetail", pRspInfo)
        # try:
        print("订阅结果：", pSpecificSecurity["ExchangeID"], pSpecificSecurity["SecurityID"], pRspInfo["ErrorID"],
              pRspInfo["ErrorMsg"])
        logger_l2_subscript.info(
            f"订阅结果：{pSpecificSecurity['SecurityID']} {pRspInfo['ErrorID']} {pRspInfo['ErrorMsg']}")
        if pRspInfo["ErrorID"] == 0:
            print("订阅成功")
            self.subscripted_codes.add(pSpecificSecurity['SecurityID'])
        if bIsLast == 1:
            print("订阅响应结束", self.subscripted_codes)
            l2_data_manager.add_subscript_codes(self.subscripted_codes)

    def OnRspUnSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspUnSubOrderDetail", bIsLast)
        try:
            code = pSpecificSecurity['SecurityID']
            self.subscripted_codes.discard(code)
            if bIsLast == 1:
                print("取消订阅响应结束", self.subscripted_codes)
                l2_data_manager.add_subscript_codes(self.subscripted_codes)
        except Exception as e:
            logging.exception(e)

    def OnRspSubBondMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubBondMarketData")

    def OnRspSubBondTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubBondTransaction")

    def OnRspSubBondOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubBondOrderDetail")

    def OnRspSubXTSMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubXTSMarketData")

    def OnRspSubXTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubXTSTick")

    # 4.0.5版本接口
    def OnRspSubNGTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        print("OnRspSubNGTSTick")

    def OnRtnMarketData(self, pDepthMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum,
                        FirstLevelSellOrderVolumes):
        # 传入：时间，现价,成交总量,买1，买2，买3,买4,买5,卖1,卖2,卖3,卖4,卖5
        d = {"dataTimeStamp": pDepthMarketData['DataTimeStamp'], "securityID": pDepthMarketData['SecurityID'],
             "lastPrice": pDepthMarketData['LastPrice'],
             "totalVolumeTrade": pDepthMarketData['TotalVolumeTrade'],
             "buy": [(pDepthMarketData['BidPrice1'], pDepthMarketData['BidVolume1']),
                     (pDepthMarketData['BidPrice2'], pDepthMarketData['BidVolume2']),
                     (pDepthMarketData['BidPrice3'], pDepthMarketData['BidVolume3']),
                     (pDepthMarketData['BidPrice4'], pDepthMarketData['BidVolume4']),
                     (pDepthMarketData['BidPrice5'], pDepthMarketData['BidVolume5'])],
             "sell": [
                 (pDepthMarketData['AskPrice1'], pDepthMarketData['AskVolume1']),
                 (pDepthMarketData['AskPrice2'], pDepthMarketData['AskVolume2']),
                 (pDepthMarketData['AskPrice3'], pDepthMarketData['AskVolume3']),
                 (pDepthMarketData['AskPrice4'], pDepthMarketData['AskVolume4']),
                 (pDepthMarketData['AskPrice5'], pDepthMarketData['AskVolume5'])
             ]}
        market_code_dict[pDepthMarketData['SecurityID']] = time.time()

        l2_data_manager.add_market_data(d)

        # 输出行情快照数据
        # print(
        #     "OnRtnMarketData SecurityID[%s] LastPrice[%.2f] TotalVolumeTrade[%d] TotalValueTrade[%.2f] BidPrice1[%.2f] BidVolume1[%d] AskPrice1[%.2f] AskVolume1[%d]" % (
        #         pDepthMarketData['SecurityID'],
        #         pDepthMarketData['LastPrice'],
        #         pDepthMarketData['TotalValueTrade'],
        #         pDepthMarketData['TotalValueTrade'],
        #         pDepthMarketData['BidPrice1'],
        #         pDepthMarketData['BidVolume1'],
        #         pDepthMarketData['AskPrice1'],
        #         pDepthMarketData['AskVolume1']))
        # # 输出一档价位买队列前50笔委托数量
        # for buy_index in range(0, FirstLevelBuyNum):
        #     print("first level buy  [%d] : [%d]" % (buy_index, FirstLevelBuyOrderVolumes[buy_index]))
        #
        # # 输出一档价位卖队列前50笔委托数量
        # for sell_index in range(0, FirstLevelSellNum):
        #     print("first level sell [%d] : [%d]" % (sell_index, FirstLevelSellOrderVolumes[sell_index]))

    def OnRtnIndex(self, pIndex):
        # 输出指数行情数据
        print(
            "OnRtnIndex SecurityID[%s] LastIndex[%.2f] LowIndex[%.2f] HighIndex[%.2f] TotalVolumeTraded[%d] Turnover[%.2f]" % (
                pIndex['SecurityID'],
                pIndex['LastIndex'],
                pIndex['LowIndex'],
                pIndex['HighIndex'],
                pIndex['TotalVolumeTraded'],
                pIndex['Turnover']))

    def OnRtnTransaction(self, pTransaction):
        code = str(pTransaction['SecurityID'])
        min_volume, limit_up_price = self.codes_volume_and_price_dict.get(code)
        # 输出逐笔成交数据
        if pTransaction['ExecType'] == b"2":
            if min_volume is None:
                # 默认筛选50w
                if pTransaction['TradePrice'] * pTransaction['Volume'] < 500000:
                    return
            elif pTransaction['TradeVolume'] < min_volume:
                return
            # 撤单
            item = {"SecurityID": pTransaction['SecurityID'], "Price": pTransaction['TradePrice'],
                    "Volume": pTransaction['TradeVolume'],
                    "OrderType": "2",
                    "OrderTime": pTransaction['TradeTime'], "MainSeq": pTransaction['MainSeq'],
                    "SubSeq": pTransaction['SubSeq'],
                    "OrderStatus": "D"}
            buyNo = pTransaction['BuyNo']
            sellNo = pTransaction['SellNo']
            if buyNo > 0:
                # 买
                item["OrderNO"] = buyNo
                item["Side"] = "1"
            elif sellNo > 0:
                # 卖
                item["OrderNO"] = sellNo
                item["Side"] = "2"
            # 深证撤单
            print("逐笔委托", item)
            l2_data_manager.add_l2_order_detail(item, True)
        else:
            if abs(pTransaction['TradePrice'] - limit_up_price) < 0.201:
                # 涨停价
                # 成交
                item = {"SecurityID": pTransaction['SecurityID'], "TradePrice": pTransaction['TradePrice'],
                        "TradeVolume": pTransaction['TradeVolume'],
                        "OrderTime": pTransaction['TradeTime'], "MainSeq": pTransaction['MainSeq'],
                        "SubSeq": pTransaction['SubSeq'], "BuyNo": pTransaction['BuyNo'],
                        "SellNo": pTransaction['SellNo'],
                        "ExecType": pTransaction['ExecType'].decode()}
                # print("逐笔成交", item)
                l2_data_manager.add_transaction_detail(item)

        logger_l2_transaction.info(
            "OnRtnTransaction SecurityID[%s] TradePrice[%.2f] TradeVolume[%d] TradeTime[%d] MainSeq[%d] SubSeq[%d] BuyNo[%d] SellNo[%d] ExecType[%s]" % (
                pTransaction['SecurityID'],
                pTransaction['TradePrice'],
                pTransaction['TradeVolume'],
                pTransaction['TradeTime'],
                pTransaction['MainSeq'],
                pTransaction['SubSeq'],
                pTransaction['BuyNo'],
                pTransaction['SellNo'],
                pTransaction['ExecType'],
            ))

    def OnRtnOrderDetail(self, pOrderDetail):
        can_listen = False
        code = str(pOrderDetail['SecurityID'])
        if code in self.special_code_volume_for_order_dict and self.special_code_volume_for_order_dict[code][0] == \
                pOrderDetail['Volume']:
            if self.special_code_volume_for_order_dict[code][1] > time.time():
                # 特殊量监听
                can_listen = True
            else:
                self.special_code_volume_for_order_dict.pop(code)
        if not can_listen:
            min_volume, limit_up_price = self.codes_volume_and_price_dict.get(code)
            if min_volume is None:
                # 默认筛选50w
                if pOrderDetail['Price'] * pOrderDetail['Volume'] < 500000:
                    return
            elif pOrderDetail['Volume'] < min_volume:
                return
        # 输出逐笔委托数据
        # 上证OrderStatus=b"D"表示撤单
        item = {"SecurityID": pOrderDetail['SecurityID'], "Price": pOrderDetail['Price'],
                "Volume": pOrderDetail['Volume'],
                "Side": pOrderDetail['Side'].decode(), "OrderType": pOrderDetail['OrderType'].decode(),
                "OrderTime": pOrderDetail['OrderTime'], "MainSeq": pOrderDetail['MainSeq'],
                "SubSeq": pOrderDetail['SubSeq'], "OrderNO": pOrderDetail['OrderNO'],
                "OrderStatus": pOrderDetail['OrderStatus'].decode()}
        print("逐笔委托", item)
        l2_data_manager.add_l2_order_detail(item)

        logger_l2_orderdetail.info(
            "OnRtnOrderDetail SecurityID[%s] Price[%.2f] Volume[%d] Side[%s] OrderType[%s] OrderTime[%d] MainSeq[%d] SubSeq[%d] OrderNO[%s] OrderStatus[%s] Info1[%d] Info2[%d] Info3[%d]" % (
                pOrderDetail['SecurityID'],
                pOrderDetail['Price'],
                pOrderDetail['Volume'],
                pOrderDetail['Side'],
                pOrderDetail['OrderType'],
                pOrderDetail['OrderTime'],
                pOrderDetail['MainSeq'],
                pOrderDetail['SubSeq'],
                pOrderDetail['OrderNO'],
                pOrderDetail['OrderStatus'],
                pOrderDetail['Info1'],
                pOrderDetail['Info2'],
                pOrderDetail['Info3']
            ))

    def OnRtnBondMarketData(self, pDepthMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum,
                            FirstLevelSellOrderVolumes):
        # 输出行情快照数据
        print(
            "OnRtnBondMarketData SecurityID[%s] LastPrice[%.2f] TotalVolumeTrade[%d] TotalValueTrade[%.2f] BidPrice1[%.2f] BidVolume1[%d] AskPrice1[%.2f] AskVolume1[%d]" % (
                pDepthMarketData['SecurityID'],
                pDepthMarketData['LastPrice'],
                pDepthMarketData['TotalValueTrade'],
                pDepthMarketData['TotalValueTrade'],
                pDepthMarketData['BidPrice1'],
                pDepthMarketData['BidVolume1'],
                pDepthMarketData['AskPrice1'],
                pDepthMarketData['AskVolume1']))

        # 输出一档价位买队列前50笔委托数量
        for buy_index in range(0, FirstLevelBuyNum):
            print("first level buy  [%d] : [%d]" % (buy_index, FirstLevelBuyOrderVolumes[buy_index]))

        # 输出一档价位卖队列前50笔委托数量
        for sell_index in range(0, FirstLevelSellNum):
            print("first level sell [%d] : [%d]" % (sell_index, FirstLevelSellOrderVolumes[sell_index]))

    def OnRtnBondTransaction(self, pTransaction):
        # 输出逐笔成交数据
        print(
            "OnRtnBondTransaction SecurityID[%s] TradePrice[%.2f] TradeVolume[%d] TradeTime[%d] MainSeq[%d] SubSeq[%d] BuyNo[%d] SellNo[%d] ExecType[%d]" % (
                pTransaction['SecurityID'],
                pTransaction['TradePrice'],
                pTransaction['TradeVolume'],
                pTransaction['TradeTime'],
                pTransaction['MainSeq'],
                pTransaction['SubSeq'],
                pTransaction['BuyNo'],
                pTransaction['SellNo'],
                pTransaction['ExecType'],
            ))

    def OnRtnBondOrderDetail(self, pOrderDetail):
        # 输出逐笔委托数据
        print(
            "OnRtnBondOrderDetail SecurityID[%s] Price[%.2f] Volume[%d] Side[%s] OrderType[%s] OrderTime[%d] MainSeq[%d] SubSeq[%d]" % (
                pOrderDetail['SecurityID'],
                pOrderDetail['Price'],
                pOrderDetail['Volume'],
                pOrderDetail['Side'],
                pOrderDetail['OrderType'],
                pOrderDetail['OrderTime'],
                pOrderDetail['MainSeq'],
                pOrderDetail['SubSeq']))

    def OnRtnXTSMarketData(self, pDepthMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum,
                           FirstLevelSellOrderVolumes):
        # 输出行情快照数据
        print(
            "OnRtnXTSMarketData SecurityID[%s] LastPrice[%.2f] TotalVolumeTrade[%d] TotalValueTrade[%.2f] BidPrice1[%.2f] BidVolume1[%d] AskPrice1[%.2f] AskVolume1[%d]" % (
                pDepthMarketData['SecurityID'],
                pDepthMarketData['LastPrice'],
                pDepthMarketData['TotalValueTrade'],
                pDepthMarketData['TotalValueTrade'],
                pDepthMarketData['BidPrice1'],
                pDepthMarketData['BidVolume1'],
                pDepthMarketData['AskPrice1'],
                pDepthMarketData['AskVolume1']))

        # 输出一档价位买队列前50笔委托数量
        for buy_index in range(0, FirstLevelBuyNum):
            print("first level buy  [%d] : [%d]" % (buy_index, FirstLevelBuyOrderVolumes[buy_index]))

        # 输出一档价位卖队列前50笔委托数量
        for sell_index in range(0, FirstLevelSellNum):
            print("first level sell [%d] : [%d]" % (sell_index, FirstLevelSellOrderVolumes[sell_index]))

    def OnRtnXTSTick(self, pTick):
        # 输出上海债券逐笔数据’
        print(
            "OnXTSTick TickType[%s] SecurityID[%s] Price[%.2f] Volume[%d] TickTime[%d] MainSeq[%d] SubSeq[%d] BuyNo[%d] SellNo[%d]" % (
                pTick['TickType'],
                pTick['SecurityID'],
                pTick['Price'],
                pTick['Volume'],
                pTick['TickTime'],
                pTick['MainSeq'],
                pTick['SubSeq'],
                pTick['BuyNo'],
                pTick['SellNo']))

    def OnRtnNGTSTick(self, pTick):
        # 输出上海股基逐笔数据’
        print(
            "OnRtnNGTSTick TickType[%s] SecurityID[%s] Price[%.2f] Volume[%d] TickTime[%d] MainSeq[%d] SubSeq[%d] BuyNo[%d] SellNo[%d]" % (
                pTick['TickType'],
                pTick['SecurityID'],
                pTick['Price'],
                pTick['Volume'],
                pTick['TickTime'],
                pTick['MainSeq'],
                pTick['SubSeq'],
                pTick['BuyNo'],
                pTick['SellNo']))


class MyL2ActionCallback(L2ActionCallback):

    def OnSetL2Position(self, client_id, request_id, codes_data):
        print("接受到命令", client_id, request_id, codes_data)
        try:
            spi.set_codes_data(codes_data)
            SendResponseSkManager.send_normal_response("l2_cmd",
                                                       SendResponseSkManager.load_response(client_id, request_id,
                                                                                           {"code": 0, "msg": "设置成功"}))


        except Exception as e:
            logging.exception(e)
            SendResponseSkManager.send_error_response("common", request_id, client_id, str(e))


def __init_l2():
    print(lev2mdapi.CTORATstpLev2MdApi_GetApiVersion())
    # case 1: Tcp方式
    # g_SubMode=lev2mdapi.TORA_TSTP_MST_TCP
    # case 2: 组播方式
    g_SubMode = lev2mdapi.TORA_TSTP_MST_MCAST

    # case 1缓存模式
    api = lev2mdapi.CTORATstpLev2MdApi_CreateTstpLev2MdApi(g_SubMode, True)
    # case 2非缓存模式
    # api = lev2mdapi.CTORATstpLev2MdApi_CreateTstpLev2MdApi(g_SubMode, False)
    global spi
    spi = Lev2MdSpi(api)
    api.RegisterSpi(spi)

    if g_SubMode != lev2mdapi.TORA_TSTP_MST_MCAST:
        api.RegisterFront(Front_Address)
    else:
        # case 1 从一个组播地址收取行情
        api.RegisterMulticast(Multicast_Address, Local_Interface_Address, "")

    # case 2:注册多个组播地址同时收行情
    # api.RegisterMulticast(Multicast_Address, Local_Interface_Address, Sender_Interface_Address);
    # api.RegisterMulticast(Multicast_Address2, Local_Interface_Address, Sender_Interface_Address);

    # case 3:efvi模式收行情
    # api.RegisterMulticast(Multicast_Address, Local_Interface_Address, Sender_Interface_Address, "enp101s0f0",4096, True);

    # case 1 不绑核运行
    api.Init()


def __receive_from_pipe(pipe):
    while True:
        try:
            value = pipe.recv()
            if value:
                value = value.decode("utf-8")
                data = json.loads(value)
                if data["type"] == "listen_volume":
                    volume = data["data"]["volume"]
                    code = data["data"]["code"]
                    spi.set_code_special_watch_volume(code, volume)
                elif data["type"] == "set_l2_codes":
                    data = data["data"]
                    l2CommandManager.process_command(command_manager.CLIENT_TYPE_CMD_L2, None, data)
        except:
            pass


def run(pipe_trade=None):
    __init_l2()
    if pipe_trade is not None:
        t1 = threading.Thread(target=lambda: __receive_from_pipe(pipe_trade), daemon=True)
        t1.start()
    l2_data_manager.run_upload_common()
    global l2CommandManager
    l2CommandManager = command_manager.L2CommandManager()
    l2CommandManager.init(MyL2ActionCallback())

    print("l2_client启动成功")


if __name__ == "__main__":
    run()
    # spi.set_codes_data([("000333", 12000)])
    input()

 huaxin/l2_data_manager.py

New file
@@ -0,0 +1,212 @@
import json
import logging
import queue
import random
import threading
import time
from huaxin import socket_util

from huaxin.client_network import SendResponseSkManager
from huaxin.mylog import logger_l2_error, logger_l2_upload

# 活动时间
order_detail_upload_active_time_dict = {}
transaction_upload_active_time_dict = {}
# 临时数据
tmep_order_detail_queue_dict = {}
tmep_transaction_queue_dict = {}
target_codes = set()
common_queue = queue.Queue()


# 添加委托详情
def add_l2_order_detail(data, istransaction=False):
    code = data["SecurityID"]
    if code not in tmep_order_detail_queue_dict:
        tmep_order_detail_queue_dict[code] = queue.Queue()
    if istransaction:
        pass
    else:
        pass
    # 原来的格式
    # {"SecurityID": pOrderDetail['SecurityID'], "Price": pOrderDetail['Price'],
    #                 "Volume": pOrderDetail['Volume'],
    #                 "Side": pOrderDetail['Side'].decode(), "OrderType": pOrderDetail['OrderType'].decode(),
    #                 "OrderTime": pOrderDetail['OrderTime'], "MainSeq": pOrderDetail['MainSeq'],
    #                 "SubSeq": pOrderDetail['SubSeq'], "OrderNO": pOrderDetail['OrderNO'],
    #                 "OrderStatus": pOrderDetail['OrderStatus'].decode()}

    tmep_order_detail_queue_dict[code].put(
        (data['SecurityID'], data['Price'], data['Volume'], data['Side'], data['OrderType'], data['OrderTime'],
         data['MainSeq'], data['SubSeq'], data['OrderNO'], data['OrderStatus']))


# 添加逐笔成交
def add_transaction_detail(data):
    code = data["SecurityID"]
    if code not in tmep_transaction_queue_dict:
        tmep_transaction_queue_dict[code] = queue.Queue()

    # 原来的格式
    #  item = {"SecurityID": pTransaction['SecurityID'], "TradePrice": pTransaction['TradePrice'],
    #                     "TradeVolume": pTransaction['TradeVolume'],
    #                     "OrderTime": pTransaction['TradeTime'], "MainSeq": pTransaction['MainSeq'],
    #                     "SubSeq": pTransaction['SubSeq'], "BuyNo": pTransaction['BuyNo'], "SellNo": pTransaction['SellNo'],
    #                     "ExecType": pTransaction['ExecType'].decode()}

    tmep_transaction_queue_dict[code].put((data['SecurityID'], data['TradePrice'], data['TradeVolume'],
                                           data['OrderTime'], data['MainSeq'], data['SubSeq'], data['BuyNo'],
                                           data['SellNo'], data['ExecType']))


def add_market_data(data):
    code = data['securityID']
    # 加入上传队列
    common_queue.put((code, "l2_market_data", data))


def add_subscript_codes(codes):
    print("add_subscript_codes", codes)
    # 加入上传队列
    common_queue.put(('', "l2_subscript_codes", list(codes)))


def __send_response(sk, msg):
    msg = socket_util.load_header(msg)
    sk.sendall(msg)
    result, header_str = socket_util.recv_data(sk)
    if result:
        result_json = json.loads(result)
        if result_json.get("code") == 0:
            return True
    return False


# 发送消息
def send_response(type, msg):
    try:
        sk = SendResponseSkManager.get_send_response_sk(type)
        if __send_response(sk, msg):
            return True
        else:
            # 再次发送
            print("再次发送")
            return __send_response(sk, msg)
    except ConnectionResetError as e:
        SendResponseSkManager.del_send_response_sk(type)
        sk = SendResponseSkManager.get_send_response_sk(type)
        return __send_response(sk, msg)
    except BrokenPipeError as e:
        SendResponseSkManager.del_send_response_sk(type)
        sk = SendResponseSkManager.get_send_response_sk(type)
        return __send_response(sk, msg)


# 上传数据
def upload_data(code, _type, datas):
    uid = random.randint(0, 100000)
    key = f"{_type}_{code}"
    fdata = json.dumps(
        {"type": _type, "data": {"code": code, "data": datas}})
    # print("数据长度：", len(datas), len(fdata), f"{fdata[:20]}...{fdata[-20:]}", )
    # print("请求开始", uid, len(datas), len(fdata), f"{fdata[:20]}...{fdata[-20:]}")
    result = None
    start_time = time.time()
    logger_l2_upload.info(f"{code} 上传数据开始-{_type}")
    try:
        result = send_response(key, fdata.encode('utf-8'))
    except Exception as e:
        logging.exception(e)
    finally:
        # print("请求结束", uid, result)
        logger_l2_upload.info(f"{code} 上传数据耗时-{_type}： {round((time.time() - start_time) * 1000, 1)} 数据量:{len(datas)}")
    # print("上传结果", result)


# 循环读取上传数据
def __run_upload_order(code):
    if code not in tmep_order_detail_queue_dict:
        tmep_order_detail_queue_dict[code] = queue.Queue()
    while True:
        # print("order task")
        try:
            if code not in target_codes:
                break
            order_detail_upload_active_time_dict[code] = time.time()
            udatas = []
            while not tmep_order_detail_queue_dict[code].empty():
                temp = tmep_order_detail_queue_dict[code].get()
                udatas.append(temp)
            if udatas:
                upload_data(code, "l2_order", udatas)

            time.sleep(0.01)

        except Exception as e:
            logger_l2_error.error(f"上传订单数据出错：{str(e)}")
            pass


def __run_upload_trans(code):
    if code not in tmep_transaction_queue_dict:
        tmep_transaction_queue_dict[code] = queue.Queue()
    while True:
        # print("trans task")
        try:
            if code not in target_codes:
                break
            transaction_upload_active_time_dict[code] = time.time()
            udatas = []
            while not tmep_transaction_queue_dict[code].empty():
                temp = tmep_transaction_queue_dict[code].get()
                udatas.append(temp)
            if udatas:
                upload_data(code, "l2_trans", udatas)
            time.sleep(0.01)
        except Exception as e:
            logger_l2_error.error(f"上传成交数据出错：{str(e)}")


def __run_upload_common():
    print("__run_upload_common")
    while True:
        try:
            while not common_queue.empty():
                temp = common_queue.get()
                upload_data(temp[0], temp[1], temp[2])
            time.sleep(0.01)
        except Exception as e:
            logger_l2_error.exception(e)
            logger_l2_error.error(f"上传普通数据出错：{str(e)}")


# 运行上传任务
def run_upload_task(code):
    # 如果代码没有在目标代码中就不需要运行
    if code not in target_codes:
        return
    # 如果最近的活动时间小于2s就不需要运行
    if code not in order_detail_upload_active_time_dict or time.time() - order_detail_upload_active_time_dict[code] > 2:
        t = threading.Thread(target=lambda: __run_upload_order(code), daemon=True)
        t.start()

    if code not in transaction_upload_active_time_dict or time.time() - transaction_upload_active_time_dict[code] > 2:
        t = threading.Thread(target=lambda: __run_upload_trans(code), daemon=True)
        t.start()


def run_upload_common():
    t = threading.Thread(target=lambda: __run_upload_common(), daemon=True)
    t.start()


if __name__ == "__main__":
    code = "603809"
    target_codes.add(code)
    run_upload_task(code)
    while True:
        for i in range(0, 5):
            add_l2_order_detail({"SecurityID": code, "Price": 11.28, "Volume": 500, "Side": "2", "OrderType": "\u0000",
                                 "OrderTime": 14591555, "MainSeq": 1, "SubSeq": 11050942, "OrderNO": 10692868,
                                 "OrderStatus": "A"}, False)
        time.sleep(0.001)

 huaxin/lev2mdapi.py

New file
@@ -0,0 +1,1166 @@
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _lev2mdapi
else:
    import _lev2mdapi

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref


def set_null(*args):
    return _lev2mdapi.set_null(*args)

def is_null(*args):
    return _lev2mdapi.is_null(*args)
class CTORATstpFensUserInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LogInAccount = property(_lev2mdapi.CTORATstpFensUserInfoField_LogInAccount_get, _lev2mdapi.CTORATstpFensUserInfoField_LogInAccount_set)
    LogInAccountType = property(_lev2mdapi.CTORATstpFensUserInfoField_LogInAccountType_get, _lev2mdapi.CTORATstpFensUserInfoField_LogInAccountType_set)

    def __init__(self):
        _lev2mdapi.CTORATstpFensUserInfoField_swiginit(self, _lev2mdapi.new_CTORATstpFensUserInfoField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpFensUserInfoField

# Register CTORATstpFensUserInfoField in _lev2mdapi:
_lev2mdapi.CTORATstpFensUserInfoField_swigregister(CTORATstpFensUserInfoField)
cvar = _lev2mdapi.cvar
INT_NULL_VAL = cvar.INT_NULL_VAL
FLOAT_NULL_VAL = cvar.FLOAT_NULL_VAL
CHAR_NULL_VAL = cvar.CHAR_NULL_VAL
WORD_NULL_VAL = cvar.WORD_NULL_VAL
LONG_NULL_VAL = cvar.LONG_NULL_VAL
TORA_TSTP_EXD_COMM = cvar.TORA_TSTP_EXD_COMM
TORA_TSTP_EXD_SSE = cvar.TORA_TSTP_EXD_SSE
TORA_TSTP_EXD_SZSE = cvar.TORA_TSTP_EXD_SZSE
TORA_TSTP_EXD_HK = cvar.TORA_TSTP_EXD_HK
TORA_TSTP_AM_Password = cvar.TORA_TSTP_AM_Password
TORA_TSTP_AM_FingerPrint = cvar.TORA_TSTP_AM_FingerPrint
TORA_TSTP_AM_CertInfo = cvar.TORA_TSTP_AM_CertInfo
TORA_TSTP_MST_TCP = cvar.TORA_TSTP_MST_TCP
TORA_TSTP_MST_UDP = cvar.TORA_TSTP_MST_UDP
TORA_TSTP_MST_MCAST = cvar.TORA_TSTP_MST_MCAST
TORA_TSTP_MST_DMA = cvar.TORA_TSTP_MST_DMA
TORA_TSTP_MST_PROXY = cvar.TORA_TSTP_MST_PROXY
TORA_TSTP_UTYPE_BrokerUser = cvar.TORA_TSTP_UTYPE_BrokerUser
TORA_TSTP_UTYPE_SuperUser = cvar.TORA_TSTP_UTYPE_SuperUser
TORA_TSTP_UTYPE_Investor = cvar.TORA_TSTP_UTYPE_Investor
TORA_TSTP_LACT_UserID = cvar.TORA_TSTP_LACT_UserID
TORA_TSTP_LACT_AccountID = cvar.TORA_TSTP_LACT_AccountID
TORA_TSTP_LACT_SHAStock = cvar.TORA_TSTP_LACT_SHAStock
TORA_TSTP_LACT_SZAStock = cvar.TORA_TSTP_LACT_SZAStock
TORA_TSTP_LACT_SHBStock = cvar.TORA_TSTP_LACT_SHBStock
TORA_TSTP_LACT_SZBStock = cvar.TORA_TSTP_LACT_SZBStock
TORA_TSTP_LACT_ThreeNewBoardA = cvar.TORA_TSTP_LACT_ThreeNewBoardA
TORA_TSTP_LACT_ThreeNewBoardB = cvar.TORA_TSTP_LACT_ThreeNewBoardB
TORA_TSTP_LACT_HKStock = cvar.TORA_TSTP_LACT_HKStock
TORA_TSTP_LACT_UnifiedUserID = cvar.TORA_TSTP_LACT_UnifiedUserID
TORA_TSTP_MKST_MarketData = cvar.TORA_TSTP_MKST_MarketData
TORA_TSTP_MKST_Index = cvar.TORA_TSTP_MKST_Index
TORA_TSTP_MKST_Transaction = cvar.TORA_TSTP_MKST_Transaction
TORA_TSTP_MKST_OrderDetail = cvar.TORA_TSTP_MKST_OrderDetail
TORA_TSTP_MKST_PHMarketData = cvar.TORA_TSTP_MKST_PHMarketData
TORA_TSTP_MKST_PHTransaction = cvar.TORA_TSTP_MKST_PHTransaction
TORA_TSTP_MKST_ResendTransaction = cvar.TORA_TSTP_MKST_ResendTransaction
TORA_TSTP_MKST_ResendOrderDetail = cvar.TORA_TSTP_MKST_ResendOrderDetail
TORA_TSTP_MKST_XTSMarketData = cvar.TORA_TSTP_MKST_XTSMarketData
TORA_TSTP_MKST_XTSTick = cvar.TORA_TSTP_MKST_XTSTick
TORA_TSTP_MKST_BondMarketData = cvar.TORA_TSTP_MKST_BondMarketData
TORA_TSTP_MKST_BondTransaction = cvar.TORA_TSTP_MKST_BondTransaction
TORA_TSTP_MKST_BondOrderDetail = cvar.TORA_TSTP_MKST_BondOrderDetail
TORA_TSTP_MKST_NGTSTick = cvar.TORA_TSTP_MKST_NGTSTick
TORA_TSTP_LOT_Market = cvar.TORA_TSTP_LOT_Market
TORA_TSTP_LOT_Limit = cvar.TORA_TSTP_LOT_Limit
TORA_TSTP_LOT_HomeBest = cvar.TORA_TSTP_LOT_HomeBest
TORA_TSTP_LSD_Buy = cvar.TORA_TSTP_LSD_Buy
TORA_TSTP_LSD_Sell = cvar.TORA_TSTP_LSD_Sell
TORA_TSTP_LSD_Borrow = cvar.TORA_TSTP_LSD_Borrow
TORA_TSTP_LSD_Lend = cvar.TORA_TSTP_LSD_Lend
TORA_TSTP_ECT_Fill = cvar.TORA_TSTP_ECT_Fill
TORA_TSTP_ECT_Cancel = cvar.TORA_TSTP_ECT_Cancel
TORA_TSTP_ECT_Unknown = cvar.TORA_TSTP_ECT_Unknown
TORA_TSTP_LOS_Add = cvar.TORA_TSTP_LOS_Add
TORA_TSTP_LOS_Delete = cvar.TORA_TSTP_LOS_Delete
TORA_TSTP_MSST_PreOpen = cvar.TORA_TSTP_MSST_PreOpen
TORA_TSTP_MSST_CallAuction = cvar.TORA_TSTP_MSST_CallAuction
TORA_TSTP_MSST_Continous = cvar.TORA_TSTP_MSST_Continous
TORA_TSTP_MSST_Pause = cvar.TORA_TSTP_MSST_Pause
TORA_TSTP_MSST_Suspend = cvar.TORA_TSTP_MSST_Suspend
TORA_TSTP_MSST_LongSuspend = cvar.TORA_TSTP_MSST_LongSuspend
TORA_TSTP_MSST_UndulationInt = cvar.TORA_TSTP_MSST_UndulationInt
TORA_TSTP_MSST_CircuitBreak = cvar.TORA_TSTP_MSST_CircuitBreak
TORA_TSTP_MSST_CircuitBreakU = cvar.TORA_TSTP_MSST_CircuitBreakU
TORA_TSTP_MSST_Close = cvar.TORA_TSTP_MSST_Close
TORA_TSTP_MSST_Other = cvar.TORA_TSTP_MSST_Other
TORA_TSTP_MSST_CloseCallAuction = cvar.TORA_TSTP_MSST_CloseCallAuction
TORA_TSTP_MSST_CallMatch = cvar.TORA_TSTP_MSST_CallMatch
TORA_TSTP_MSST_PostContinous = cvar.TORA_TSTP_MSST_PostContinous
TORA_TSTP_MSST_PostClose = cvar.TORA_TSTP_MSST_PostClose
TORA_TSTP_MSST_PrePostOpen = cvar.TORA_TSTP_MSST_PrePostOpen
TORA_TSTP_MSST_Unlisted = cvar.TORA_TSTP_MSST_Unlisted
TORA_TSTP_TBSF_Buy = cvar.TORA_TSTP_TBSF_Buy
TORA_TSTP_TBSF_Sell = cvar.TORA_TSTP_TBSF_Sell
TORA_TSTP_TBSF_Unknown = cvar.TORA_TSTP_TBSF_Unknown
TORA_TSTP_LTT_Add = cvar.TORA_TSTP_LTT_Add
TORA_TSTP_LTT_Delete = cvar.TORA_TSTP_LTT_Delete
TORA_TSTP_LTT_Status = cvar.TORA_TSTP_LTT_Status
TORA_TSTP_LTT_Trade = cvar.TORA_TSTP_LTT_Trade

class CTORATstpReqUserLoginField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LogInAccount = property(_lev2mdapi.CTORATstpReqUserLoginField_LogInAccount_get, _lev2mdapi.CTORATstpReqUserLoginField_LogInAccount_set)
    LogInAccountType = property(_lev2mdapi.CTORATstpReqUserLoginField_LogInAccountType_get, _lev2mdapi.CTORATstpReqUserLoginField_LogInAccountType_set)
    Password = property(_lev2mdapi.CTORATstpReqUserLoginField_Password_get, _lev2mdapi.CTORATstpReqUserLoginField_Password_set)
    UserProductInfo = property(_lev2mdapi.CTORATstpReqUserLoginField_UserProductInfo_get, _lev2mdapi.CTORATstpReqUserLoginField_UserProductInfo_set)
    InterfaceProductInfo = property(_lev2mdapi.CTORATstpReqUserLoginField_InterfaceProductInfo_get, _lev2mdapi.CTORATstpReqUserLoginField_InterfaceProductInfo_set)
    ProtocolInfo = property(_lev2mdapi.CTORATstpReqUserLoginField_ProtocolInfo_get, _lev2mdapi.CTORATstpReqUserLoginField_ProtocolInfo_set)
    MacAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_MacAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_MacAddress_set)
    Mobile = property(_lev2mdapi.CTORATstpReqUserLoginField_Mobile_get, _lev2mdapi.CTORATstpReqUserLoginField_Mobile_set)
    InnerIPAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_InnerIPAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_InnerIPAddress_set)
    Lang = property(_lev2mdapi.CTORATstpReqUserLoginField_Lang_get, _lev2mdapi.CTORATstpReqUserLoginField_Lang_set)
    TerminalInfo = property(_lev2mdapi.CTORATstpReqUserLoginField_TerminalInfo_get, _lev2mdapi.CTORATstpReqUserLoginField_TerminalInfo_set)
    GWMacAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_GWMacAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_GWMacAddress_set)
    GWInnerIPAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_GWInnerIPAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_GWInnerIPAddress_set)
    GWOuterIPAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_GWOuterIPAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_GWOuterIPAddress_set)
    DepartmentID = property(_lev2mdapi.CTORATstpReqUserLoginField_DepartmentID_get, _lev2mdapi.CTORATstpReqUserLoginField_DepartmentID_set)
    HDSerial = property(_lev2mdapi.CTORATstpReqUserLoginField_HDSerial_get, _lev2mdapi.CTORATstpReqUserLoginField_HDSerial_set)
    AuthMode = property(_lev2mdapi.CTORATstpReqUserLoginField_AuthMode_get, _lev2mdapi.CTORATstpReqUserLoginField_AuthMode_set)
    DeviceID = property(_lev2mdapi.CTORATstpReqUserLoginField_DeviceID_get, _lev2mdapi.CTORATstpReqUserLoginField_DeviceID_set)
    CertSerial = property(_lev2mdapi.CTORATstpReqUserLoginField_CertSerial_get, _lev2mdapi.CTORATstpReqUserLoginField_CertSerial_set)
    OuterIPAddress = property(_lev2mdapi.CTORATstpReqUserLoginField_OuterIPAddress_get, _lev2mdapi.CTORATstpReqUserLoginField_OuterIPAddress_set)
    DynamicPassword = property(_lev2mdapi.CTORATstpReqUserLoginField_DynamicPassword_get, _lev2mdapi.CTORATstpReqUserLoginField_DynamicPassword_set)
    OuterPort = property(_lev2mdapi.CTORATstpReqUserLoginField_OuterPort_get, _lev2mdapi.CTORATstpReqUserLoginField_OuterPort_set)

    def __init__(self):
        _lev2mdapi.CTORATstpReqUserLoginField_swiginit(self, _lev2mdapi.new_CTORATstpReqUserLoginField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpReqUserLoginField

# Register CTORATstpReqUserLoginField in _lev2mdapi:
_lev2mdapi.CTORATstpReqUserLoginField_swigregister(CTORATstpReqUserLoginField)

class CTORATstpRspUserLoginField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LoginTime = property(_lev2mdapi.CTORATstpRspUserLoginField_LoginTime_get, _lev2mdapi.CTORATstpRspUserLoginField_LoginTime_set)
    LogInAccount = property(_lev2mdapi.CTORATstpRspUserLoginField_LogInAccount_get, _lev2mdapi.CTORATstpRspUserLoginField_LogInAccount_set)
    LogInAccountType = property(_lev2mdapi.CTORATstpRspUserLoginField_LogInAccountType_get, _lev2mdapi.CTORATstpRspUserLoginField_LogInAccountType_set)
    SystemName = property(_lev2mdapi.CTORATstpRspUserLoginField_SystemName_get, _lev2mdapi.CTORATstpRspUserLoginField_SystemName_set)
    FrontID = property(_lev2mdapi.CTORATstpRspUserLoginField_FrontID_get, _lev2mdapi.CTORATstpRspUserLoginField_FrontID_set)
    SessionID = property(_lev2mdapi.CTORATstpRspUserLoginField_SessionID_get, _lev2mdapi.CTORATstpRspUserLoginField_SessionID_set)
    MaxOrderRef = property(_lev2mdapi.CTORATstpRspUserLoginField_MaxOrderRef_get, _lev2mdapi.CTORATstpRspUserLoginField_MaxOrderRef_set)
    PrivateFlowCount = property(_lev2mdapi.CTORATstpRspUserLoginField_PrivateFlowCount_get, _lev2mdapi.CTORATstpRspUserLoginField_PrivateFlowCount_set)
    PublicFlowCount = property(_lev2mdapi.CTORATstpRspUserLoginField_PublicFlowCount_get, _lev2mdapi.CTORATstpRspUserLoginField_PublicFlowCount_set)
    TradingDay = property(_lev2mdapi.CTORATstpRspUserLoginField_TradingDay_get, _lev2mdapi.CTORATstpRspUserLoginField_TradingDay_set)
    UserID = property(_lev2mdapi.CTORATstpRspUserLoginField_UserID_get, _lev2mdapi.CTORATstpRspUserLoginField_UserID_set)
    UserName = property(_lev2mdapi.CTORATstpRspUserLoginField_UserName_get, _lev2mdapi.CTORATstpRspUserLoginField_UserName_set)
    UserType = property(_lev2mdapi.CTORATstpRspUserLoginField_UserType_get, _lev2mdapi.CTORATstpRspUserLoginField_UserType_set)
    DepartmentID = property(_lev2mdapi.CTORATstpRspUserLoginField_DepartmentID_get, _lev2mdapi.CTORATstpRspUserLoginField_DepartmentID_set)
    InnerIPAddress = property(_lev2mdapi.CTORATstpRspUserLoginField_InnerIPAddress_get, _lev2mdapi.CTORATstpRspUserLoginField_InnerIPAddress_set)
    MacAddress = property(_lev2mdapi.CTORATstpRspUserLoginField_MacAddress_get, _lev2mdapi.CTORATstpRspUserLoginField_MacAddress_set)
    HDSerial = property(_lev2mdapi.CTORATstpRspUserLoginField_HDSerial_get, _lev2mdapi.CTORATstpRspUserLoginField_HDSerial_set)
    OrderInsertCommFlux = property(_lev2mdapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_get, _lev2mdapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_set)
    PasswordUpdatePeriod = property(_lev2mdapi.CTORATstpRspUserLoginField_PasswordUpdatePeriod_get, _lev2mdapi.CTORATstpRspUserLoginField_PasswordUpdatePeriod_set)
    PasswordRemainDays = property(_lev2mdapi.CTORATstpRspUserLoginField_PasswordRemainDays_get, _lev2mdapi.CTORATstpRspUserLoginField_PasswordRemainDays_set)
    NeedUpdatePassword = property(_lev2mdapi.CTORATstpRspUserLoginField_NeedUpdatePassword_get, _lev2mdapi.CTORATstpRspUserLoginField_NeedUpdatePassword_set)
    OrderActionCommFlux = property(_lev2mdapi.CTORATstpRspUserLoginField_OrderActionCommFlux_get, _lev2mdapi.CTORATstpRspUserLoginField_OrderActionCommFlux_set)
    Mobile = property(_lev2mdapi.CTORATstpRspUserLoginField_Mobile_get, _lev2mdapi.CTORATstpRspUserLoginField_Mobile_set)
    OuterIPAddress = property(_lev2mdapi.CTORATstpRspUserLoginField_OuterIPAddress_get, _lev2mdapi.CTORATstpRspUserLoginField_OuterIPAddress_set)
    CertSerial = property(_lev2mdapi.CTORATstpRspUserLoginField_CertSerial_get, _lev2mdapi.CTORATstpRspUserLoginField_CertSerial_set)
    OuterPort = property(_lev2mdapi.CTORATstpRspUserLoginField_OuterPort_get, _lev2mdapi.CTORATstpRspUserLoginField_OuterPort_set)

    def __init__(self):
        _lev2mdapi.CTORATstpRspUserLoginField_swiginit(self, _lev2mdapi.new_CTORATstpRspUserLoginField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpRspUserLoginField

# Register CTORATstpRspUserLoginField in _lev2mdapi:
_lev2mdapi.CTORATstpRspUserLoginField_swigregister(CTORATstpRspUserLoginField)

class CTORATstpRspInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ErrorID = property(_lev2mdapi.CTORATstpRspInfoField_ErrorID_get, _lev2mdapi.CTORATstpRspInfoField_ErrorID_set)
    ErrorMsg = property(_lev2mdapi.CTORATstpRspInfoField_ErrorMsg_get, _lev2mdapi.CTORATstpRspInfoField_ErrorMsg_set)

    def __init__(self):
        _lev2mdapi.CTORATstpRspInfoField_swiginit(self, _lev2mdapi.new_CTORATstpRspInfoField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpRspInfoField

# Register CTORATstpRspInfoField in _lev2mdapi:
_lev2mdapi.CTORATstpRspInfoField_swigregister(CTORATstpRspInfoField)

class CTORATstpUserLogoutField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UserID = property(_lev2mdapi.CTORATstpUserLogoutField_UserID_get, _lev2mdapi.CTORATstpUserLogoutField_UserID_set)

    def __init__(self):
        _lev2mdapi.CTORATstpUserLogoutField_swiginit(self, _lev2mdapi.new_CTORATstpUserLogoutField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpUserLogoutField

# Register CTORATstpUserLogoutField in _lev2mdapi:
_lev2mdapi.CTORATstpUserLogoutField_swigregister(CTORATstpUserLogoutField)

class CTORATstpSpecificSecurityField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpSpecificSecurityField_ExchangeID_get, _lev2mdapi.CTORATstpSpecificSecurityField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpSpecificSecurityField_SecurityID_get, _lev2mdapi.CTORATstpSpecificSecurityField_SecurityID_set)

    def __init__(self):
        _lev2mdapi.CTORATstpSpecificSecurityField_swiginit(self, _lev2mdapi.new_CTORATstpSpecificSecurityField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpSpecificSecurityField

# Register CTORATstpSpecificSecurityField in _lev2mdapi:
_lev2mdapi.CTORATstpSpecificSecurityField_swigregister(CTORATstpSpecificSecurityField)

class CTORATstpLev2MarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SecurityID = property(_lev2mdapi.CTORATstpLev2MarketDataField_SecurityID_get, _lev2mdapi.CTORATstpLev2MarketDataField_SecurityID_set)
    ExchangeID = property(_lev2mdapi.CTORATstpLev2MarketDataField_ExchangeID_get, _lev2mdapi.CTORATstpLev2MarketDataField_ExchangeID_set)
    DataTimeStamp = property(_lev2mdapi.CTORATstpLev2MarketDataField_DataTimeStamp_get, _lev2mdapi.CTORATstpLev2MarketDataField_DataTimeStamp_set)
    PreClosePrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_PreClosePrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_PreClosePrice_set)
    OpenPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_OpenPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_OpenPrice_set)
    NumTrades = property(_lev2mdapi.CTORATstpLev2MarketDataField_NumTrades_get, _lev2mdapi.CTORATstpLev2MarketDataField_NumTrades_set)
    TotalVolumeTrade = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalVolumeTrade_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalVolumeTrade_set)
    TotalValueTrade = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalValueTrade_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalValueTrade_set)
    TotalBidVolume = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalBidVolume_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalBidVolume_set)
    AvgBidPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_AvgBidPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_AvgBidPrice_set)
    TotalAskVolume = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalAskVolume_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalAskVolume_set)
    AvgAskPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_AvgAskPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_AvgAskPrice_set)
    HighestPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_HighestPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_HighestPrice_set)
    LowestPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_LowestPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_LowestPrice_set)
    LastPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_LastPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_LastPrice_set)
    BidPrice1 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice1_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice1_set)
    BidVolume1 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume1_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume1_set)
    AskPrice1 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice1_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice1_set)
    AskVolume1 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume1_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume1_set)
    AskPrice2 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice2_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice2_set)
    AskVolume2 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume2_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume2_set)
    AskPrice3 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice3_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice3_set)
    AskVolume3 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume3_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume3_set)
    BidPrice2 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice2_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice2_set)
    BidVolume2 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume2_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume2_set)
    BidPrice3 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice3_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice3_set)
    BidVolume3 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume3_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume3_set)
    AskPrice4 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice4_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice4_set)
    AskVolume4 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume4_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume4_set)
    AskPrice5 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice5_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice5_set)
    AskVolume5 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume5_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume5_set)
    BidPrice4 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice4_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice4_set)
    BidVolume4 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume4_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume4_set)
    BidPrice5 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice5_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice5_set)
    BidVolume5 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume5_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume5_set)
    AskPrice6 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice6_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice6_set)
    AskVolume6 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume6_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume6_set)
    AskPrice7 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice7_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice7_set)
    AskVolume7 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume7_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume7_set)
    BidPrice6 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice6_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice6_set)
    BidVolume6 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume6_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume6_set)
    BidPrice7 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice7_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice7_set)
    BidVolume7 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume7_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume7_set)
    AskPrice8 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice8_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice8_set)
    AskVolume8 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume8_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume8_set)
    AskPrice9 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice9_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice9_set)
    AskVolume9 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume9_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume9_set)
    BidPrice8 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice8_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice8_set)
    BidVolume8 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume8_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume8_set)
    BidPrice9 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice9_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice9_set)
    BidVolume9 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume9_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume9_set)
    BidPrice10 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidPrice10_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidPrice10_set)
    BidVolume10 = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidVolume10_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidVolume10_set)
    AskPrice10 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskPrice10_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskPrice10_set)
    AskVolume10 = property(_lev2mdapi.CTORATstpLev2MarketDataField_AskVolume10_get, _lev2mdapi.CTORATstpLev2MarketDataField_AskVolume10_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2MarketDataField_Info1_get, _lev2mdapi.CTORATstpLev2MarketDataField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2MarketDataField_Info2_get, _lev2mdapi.CTORATstpLev2MarketDataField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2MarketDataField_Info3_get, _lev2mdapi.CTORATstpLev2MarketDataField_Info3_set)
    UpperLimitPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_UpperLimitPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_UpperLimitPrice_set)
    LowerLimitPrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_LowerLimitPrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_LowerLimitPrice_set)
    ClosePrice = property(_lev2mdapi.CTORATstpLev2MarketDataField_ClosePrice_get, _lev2mdapi.CTORATstpLev2MarketDataField_ClosePrice_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2MarketDataField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2MarketDataField_MDSecurityStat_set)
    TotalBidNumber = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalBidNumber_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalBidNumber_set)
    TotalOfferNumber = property(_lev2mdapi.CTORATstpLev2MarketDataField_TotalOfferNumber_get, _lev2mdapi.CTORATstpLev2MarketDataField_TotalOfferNumber_set)
    BidTradeMaxDuration = property(_lev2mdapi.CTORATstpLev2MarketDataField_BidTradeMaxDuration_get, _lev2mdapi.CTORATstpLev2MarketDataField_BidTradeMaxDuration_set)
    OfferTradeMaxDuration = property(_lev2mdapi.CTORATstpLev2MarketDataField_OfferTradeMaxDuration_get, _lev2mdapi.CTORATstpLev2MarketDataField_OfferTradeMaxDuration_set)
    IOPV = property(_lev2mdapi.CTORATstpLev2MarketDataField_IOPV_get, _lev2mdapi.CTORATstpLev2MarketDataField_IOPV_set)
    Ask1NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask1NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask1NumOrders_set)
    Bid1NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid1NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid1NumOrders_set)
    Ask2NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask2NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask2NumOrders_set)
    Bid2NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid2NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid2NumOrders_set)
    Ask3NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask3NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask3NumOrders_set)
    Bid3NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid3NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid3NumOrders_set)
    Ask4NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask4NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask4NumOrders_set)
    Bid4NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid4NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid4NumOrders_set)
    Ask5NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask5NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask5NumOrders_set)
    Bid5NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid5NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid5NumOrders_set)
    Ask6NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask6NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask6NumOrders_set)
    Bid6NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid6NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid6NumOrders_set)
    Ask7NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask7NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask7NumOrders_set)
    Bid7NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid7NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid7NumOrders_set)
    Ask8NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask8NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask8NumOrders_set)
    Bid8NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid8NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid8NumOrders_set)
    Ask9NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask9NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask9NumOrders_set)
    Bid9NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid9NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid9NumOrders_set)
    Ask10NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Ask10NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Ask10NumOrders_set)
    Bid10NumOrders = property(_lev2mdapi.CTORATstpLev2MarketDataField_Bid10NumOrders_get, _lev2mdapi.CTORATstpLev2MarketDataField_Bid10NumOrders_set)
    WithdrawBuyNumber = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyNumber_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyNumber_set)
    WithdrawBuyAmount = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyAmount_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyAmount_set)
    WithdrawBuyMoney = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyMoney_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawBuyMoney_set)
    WithdrawSellNumber = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellNumber_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellNumber_set)
    WithdrawSellAmount = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellAmount_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellAmount_set)
    WithdrawSellMoney = property(_lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellMoney_get, _lev2mdapi.CTORATstpLev2MarketDataField_WithdrawSellMoney_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2MarketDataField_swiginit(self, _lev2mdapi.new_CTORATstpLev2MarketDataField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2MarketDataField

# Register CTORATstpLev2MarketDataField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2MarketDataField_swigregister(CTORATstpLev2MarketDataField)

class CTORATstpLev2IndexField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2IndexField_ExchangeID_get, _lev2mdapi.CTORATstpLev2IndexField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2IndexField_SecurityID_get, _lev2mdapi.CTORATstpLev2IndexField_SecurityID_set)
    DataTimeStamp = property(_lev2mdapi.CTORATstpLev2IndexField_DataTimeStamp_get, _lev2mdapi.CTORATstpLev2IndexField_DataTimeStamp_set)
    PreCloseIndex = property(_lev2mdapi.CTORATstpLev2IndexField_PreCloseIndex_get, _lev2mdapi.CTORATstpLev2IndexField_PreCloseIndex_set)
    OpenIndex = property(_lev2mdapi.CTORATstpLev2IndexField_OpenIndex_get, _lev2mdapi.CTORATstpLev2IndexField_OpenIndex_set)
    HighIndex = property(_lev2mdapi.CTORATstpLev2IndexField_HighIndex_get, _lev2mdapi.CTORATstpLev2IndexField_HighIndex_set)
    LowIndex = property(_lev2mdapi.CTORATstpLev2IndexField_LowIndex_get, _lev2mdapi.CTORATstpLev2IndexField_LowIndex_set)
    LastIndex = property(_lev2mdapi.CTORATstpLev2IndexField_LastIndex_get, _lev2mdapi.CTORATstpLev2IndexField_LastIndex_set)
    Turnover = property(_lev2mdapi.CTORATstpLev2IndexField_Turnover_get, _lev2mdapi.CTORATstpLev2IndexField_Turnover_set)
    TotalVolumeTraded = property(_lev2mdapi.CTORATstpLev2IndexField_TotalVolumeTraded_get, _lev2mdapi.CTORATstpLev2IndexField_TotalVolumeTraded_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2IndexField_Info1_get, _lev2mdapi.CTORATstpLev2IndexField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2IndexField_Info2_get, _lev2mdapi.CTORATstpLev2IndexField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2IndexField_Info3_get, _lev2mdapi.CTORATstpLev2IndexField_Info3_set)
    CloseIndex = property(_lev2mdapi.CTORATstpLev2IndexField_CloseIndex_get, _lev2mdapi.CTORATstpLev2IndexField_CloseIndex_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2IndexField_swiginit(self, _lev2mdapi.new_CTORATstpLev2IndexField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2IndexField

# Register CTORATstpLev2IndexField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2IndexField_swigregister(CTORATstpLev2IndexField)

class CTORATstpLev2TransactionField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2TransactionField_ExchangeID_get, _lev2mdapi.CTORATstpLev2TransactionField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2TransactionField_SecurityID_get, _lev2mdapi.CTORATstpLev2TransactionField_SecurityID_set)
    TradeTime = property(_lev2mdapi.CTORATstpLev2TransactionField_TradeTime_get, _lev2mdapi.CTORATstpLev2TransactionField_TradeTime_set)
    TradePrice = property(_lev2mdapi.CTORATstpLev2TransactionField_TradePrice_get, _lev2mdapi.CTORATstpLev2TransactionField_TradePrice_set)
    TradeVolume = property(_lev2mdapi.CTORATstpLev2TransactionField_TradeVolume_get, _lev2mdapi.CTORATstpLev2TransactionField_TradeVolume_set)
    ExecType = property(_lev2mdapi.CTORATstpLev2TransactionField_ExecType_get, _lev2mdapi.CTORATstpLev2TransactionField_ExecType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2TransactionField_MainSeq_get, _lev2mdapi.CTORATstpLev2TransactionField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2TransactionField_SubSeq_get, _lev2mdapi.CTORATstpLev2TransactionField_SubSeq_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2TransactionField_BuyNo_get, _lev2mdapi.CTORATstpLev2TransactionField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2TransactionField_SellNo_get, _lev2mdapi.CTORATstpLev2TransactionField_SellNo_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2TransactionField_Info1_get, _lev2mdapi.CTORATstpLev2TransactionField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2TransactionField_Info2_get, _lev2mdapi.CTORATstpLev2TransactionField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2TransactionField_Info3_get, _lev2mdapi.CTORATstpLev2TransactionField_Info3_set)
    TradeBSFlag = property(_lev2mdapi.CTORATstpLev2TransactionField_TradeBSFlag_get, _lev2mdapi.CTORATstpLev2TransactionField_TradeBSFlag_set)
    BizIndex = property(_lev2mdapi.CTORATstpLev2TransactionField_BizIndex_get, _lev2mdapi.CTORATstpLev2TransactionField_BizIndex_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2TransactionField_swiginit(self, _lev2mdapi.new_CTORATstpLev2TransactionField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2TransactionField

# Register CTORATstpLev2TransactionField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2TransactionField_swigregister(CTORATstpLev2TransactionField)

class CTORATstpLev2OrderDetailField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2OrderDetailField_ExchangeID_get, _lev2mdapi.CTORATstpLev2OrderDetailField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2OrderDetailField_SecurityID_get, _lev2mdapi.CTORATstpLev2OrderDetailField_SecurityID_set)
    OrderTime = property(_lev2mdapi.CTORATstpLev2OrderDetailField_OrderTime_get, _lev2mdapi.CTORATstpLev2OrderDetailField_OrderTime_set)
    Price = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Price_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Price_set)
    Volume = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Volume_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Volume_set)
    Side = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Side_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Side_set)
    OrderType = property(_lev2mdapi.CTORATstpLev2OrderDetailField_OrderType_get, _lev2mdapi.CTORATstpLev2OrderDetailField_OrderType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2OrderDetailField_MainSeq_get, _lev2mdapi.CTORATstpLev2OrderDetailField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2OrderDetailField_SubSeq_get, _lev2mdapi.CTORATstpLev2OrderDetailField_SubSeq_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Info1_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Info2_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2OrderDetailField_Info3_get, _lev2mdapi.CTORATstpLev2OrderDetailField_Info3_set)
    OrderNO = property(_lev2mdapi.CTORATstpLev2OrderDetailField_OrderNO_get, _lev2mdapi.CTORATstpLev2OrderDetailField_OrderNO_set)
    OrderStatus = property(_lev2mdapi.CTORATstpLev2OrderDetailField_OrderStatus_get, _lev2mdapi.CTORATstpLev2OrderDetailField_OrderStatus_set)
    BizIndex = property(_lev2mdapi.CTORATstpLev2OrderDetailField_BizIndex_get, _lev2mdapi.CTORATstpLev2OrderDetailField_BizIndex_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2OrderDetailField_swiginit(self, _lev2mdapi.new_CTORATstpLev2OrderDetailField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2OrderDetailField

# Register CTORATstpLev2OrderDetailField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2OrderDetailField_swigregister(CTORATstpLev2OrderDetailField)

class CTORATstpLev2PHMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SecurityID = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_SecurityID_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_SecurityID_set)
    ExchangeID = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_ExchangeID_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_ExchangeID_set)
    DataTimeStamp = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_DataTimeStamp_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_DataTimeStamp_set)
    ClosePrice = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_ClosePrice_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_ClosePrice_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_MDSecurityStat_set)
    NumTrades = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_NumTrades_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_NumTrades_set)
    TotalVolumeTrade = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_TotalVolumeTrade_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_TotalVolumeTrade_set)
    TotalValueTrade = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_TotalValueTrade_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_TotalValueTrade_set)
    TotalBidVolume = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_TotalBidVolume_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_TotalBidVolume_set)
    TotalAskVolume = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_TotalAskVolume_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_TotalAskVolume_set)
    WithdrawBuyNumber = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawBuyNumber_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawBuyNumber_set)
    WithdrawBuyAmount = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawBuyAmount_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawBuyAmount_set)
    WithdrawSellNumber = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawSellNumber_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawSellNumber_set)
    WithdrawSellAmount = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawSellAmount_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_WithdrawSellAmount_set)
    BidOrderQty = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_BidOrderQty_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_BidOrderQty_set)
    BidNumOrders = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_BidNumOrders_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_BidNumOrders_set)
    AskOrderQty = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_AskOrderQty_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_AskOrderQty_set)
    AskNumOrders = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_AskNumOrders_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_AskNumOrders_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_Info1_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_Info2_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2PHMarketDataField_Info3_get, _lev2mdapi.CTORATstpLev2PHMarketDataField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2PHMarketDataField_swiginit(self, _lev2mdapi.new_CTORATstpLev2PHMarketDataField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2PHMarketDataField

# Register CTORATstpLev2PHMarketDataField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2PHMarketDataField_swigregister(CTORATstpLev2PHMarketDataField)

class CTORATstpLev2PHTransactionField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2PHTransactionField_ExchangeID_get, _lev2mdapi.CTORATstpLev2PHTransactionField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2PHTransactionField_SecurityID_get, _lev2mdapi.CTORATstpLev2PHTransactionField_SecurityID_set)
    TradeTime = property(_lev2mdapi.CTORATstpLev2PHTransactionField_TradeTime_get, _lev2mdapi.CTORATstpLev2PHTransactionField_TradeTime_set)
    TradePrice = property(_lev2mdapi.CTORATstpLev2PHTransactionField_TradePrice_get, _lev2mdapi.CTORATstpLev2PHTransactionField_TradePrice_set)
    TradeVolume = property(_lev2mdapi.CTORATstpLev2PHTransactionField_TradeVolume_get, _lev2mdapi.CTORATstpLev2PHTransactionField_TradeVolume_set)
    TradeMoney = property(_lev2mdapi.CTORATstpLev2PHTransactionField_TradeMoney_get, _lev2mdapi.CTORATstpLev2PHTransactionField_TradeMoney_set)
    ExecType = property(_lev2mdapi.CTORATstpLev2PHTransactionField_ExecType_get, _lev2mdapi.CTORATstpLev2PHTransactionField_ExecType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2PHTransactionField_MainSeq_get, _lev2mdapi.CTORATstpLev2PHTransactionField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2PHTransactionField_SubSeq_get, _lev2mdapi.CTORATstpLev2PHTransactionField_SubSeq_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2PHTransactionField_BuyNo_get, _lev2mdapi.CTORATstpLev2PHTransactionField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2PHTransactionField_SellNo_get, _lev2mdapi.CTORATstpLev2PHTransactionField_SellNo_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2PHTransactionField_Info1_get, _lev2mdapi.CTORATstpLev2PHTransactionField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2PHTransactionField_Info2_get, _lev2mdapi.CTORATstpLev2PHTransactionField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2PHTransactionField_Info3_get, _lev2mdapi.CTORATstpLev2PHTransactionField_Info3_set)
    TradeBSFlag = property(_lev2mdapi.CTORATstpLev2PHTransactionField_TradeBSFlag_get, _lev2mdapi.CTORATstpLev2PHTransactionField_TradeBSFlag_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2PHTransactionField_swiginit(self, _lev2mdapi.new_CTORATstpLev2PHTransactionField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2PHTransactionField

# Register CTORATstpLev2PHTransactionField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2PHTransactionField_swigregister(CTORATstpLev2PHTransactionField)

class CTORATstpLev2ResendTransactionField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_ExchangeID_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_SecurityID_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_SecurityID_set)
    TradeTime = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_TradeTime_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_TradeTime_set)
    TradePrice = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_TradePrice_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_TradePrice_set)
    TradeVolume = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_TradeVolume_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_TradeVolume_set)
    ExecType = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_ExecType_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_ExecType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_MainSeq_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_SubSeq_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_SubSeq_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_BuyNo_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_SellNo_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_SellNo_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_Info1_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_Info2_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_Info3_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_Info3_set)
    TradeBSFlag = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_TradeBSFlag_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_TradeBSFlag_set)
    BizIndex = property(_lev2mdapi.CTORATstpLev2ResendTransactionField_BizIndex_get, _lev2mdapi.CTORATstpLev2ResendTransactionField_BizIndex_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2ResendTransactionField_swiginit(self, _lev2mdapi.new_CTORATstpLev2ResendTransactionField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2ResendTransactionField

# Register CTORATstpLev2ResendTransactionField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2ResendTransactionField_swigregister(CTORATstpLev2ResendTransactionField)

class CTORATstpLev2ResendOrderDetailField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_ExchangeID_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_SecurityID_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_SecurityID_set)
    OrderTime = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderTime_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderTime_set)
    Price = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Price_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Price_set)
    Volume = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Volume_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Volume_set)
    Side = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Side_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Side_set)
    OrderType = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderType_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_MainSeq_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_SubSeq_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_SubSeq_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info1_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info2_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info3_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_Info3_set)
    OrderNO = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderNO_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderNO_set)
    OrderStatus = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderStatus_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_OrderStatus_set)
    BizIndex = property(_lev2mdapi.CTORATstpLev2ResendOrderDetailField_BizIndex_get, _lev2mdapi.CTORATstpLev2ResendOrderDetailField_BizIndex_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2ResendOrderDetailField_swiginit(self, _lev2mdapi.new_CTORATstpLev2ResendOrderDetailField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2ResendOrderDetailField

# Register CTORATstpLev2ResendOrderDetailField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2ResendOrderDetailField_swigregister(CTORATstpLev2ResendOrderDetailField)

class CTORATstpLev2XTSMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SecurityID = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_SecurityID_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_SecurityID_set)
    ExchangeID = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_ExchangeID_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_ExchangeID_set)
    DataTimeStamp = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_DataTimeStamp_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_DataTimeStamp_set)
    PreClosePrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_PreClosePrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_PreClosePrice_set)
    OpenPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_OpenPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_OpenPrice_set)
    NumTrades = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_NumTrades_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_NumTrades_set)
    TotalVolumeTrade = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalVolumeTrade_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalVolumeTrade_set)
    TotalValueTrade = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalValueTrade_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalValueTrade_set)
    TotalBidVolume = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalBidVolume_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalBidVolume_set)
    AvgBidPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AvgBidPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AvgBidPrice_set)
    TotalAskVolume = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalAskVolume_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalAskVolume_set)
    AvgAskPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AvgAskPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AvgAskPrice_set)
    HighestPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_HighestPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_HighestPrice_set)
    LowestPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_LowestPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_LowestPrice_set)
    LastPrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_LastPrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_LastPrice_set)
    BidPrice1 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice1_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice1_set)
    BidVolume1 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume1_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume1_set)
    Bid1NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid1NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid1NumOrders_set)
    AskPrice1 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice1_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice1_set)
    AskVolume1 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume1_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume1_set)
    Ask1NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask1NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask1NumOrders_set)
    AskPrice2 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice2_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice2_set)
    AskVolume2 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume2_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume2_set)
    Ask2NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask2NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask2NumOrders_set)
    AskPrice3 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice3_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice3_set)
    AskVolume3 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume3_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume3_set)
    Ask3NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask3NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask3NumOrders_set)
    BidPrice2 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice2_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice2_set)
    BidVolume2 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume2_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume2_set)
    Bid2NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid2NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid2NumOrders_set)
    BidPrice3 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice3_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice3_set)
    BidVolume3 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume3_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume3_set)
    Bid3NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid3NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid3NumOrders_set)
    AskPrice4 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice4_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice4_set)
    AskVolume4 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume4_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume4_set)
    Ask4NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask4NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask4NumOrders_set)
    AskPrice5 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice5_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice5_set)
    AskVolume5 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume5_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume5_set)
    Ask5NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask5NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask5NumOrders_set)
    BidPrice4 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice4_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice4_set)
    BidVolume4 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume4_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume4_set)
    Bid4NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid4NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid4NumOrders_set)
    BidPrice5 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice5_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice5_set)
    BidVolume5 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume5_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume5_set)
    Bid5NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid5NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid5NumOrders_set)
    AskPrice6 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice6_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice6_set)
    AskVolume6 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume6_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume6_set)
    Ask6NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask6NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask6NumOrders_set)
    AskPrice7 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice7_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice7_set)
    AskVolume7 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume7_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume7_set)
    Ask7NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask7NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask7NumOrders_set)
    BidPrice6 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice6_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice6_set)
    BidVolume6 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume6_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume6_set)
    Bid6NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid6NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid6NumOrders_set)
    BidPrice7 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice7_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice7_set)
    BidVolume7 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume7_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume7_set)
    Bid7NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid7NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid7NumOrders_set)
    AskPrice8 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice8_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice8_set)
    AskVolume8 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume8_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume8_set)
    Ask8NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask8NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask8NumOrders_set)
    AskPrice9 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice9_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice9_set)
    AskVolume9 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume9_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume9_set)
    Ask9NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask9NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask9NumOrders_set)
    BidPrice8 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice8_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice8_set)
    BidVolume8 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume8_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume8_set)
    Bid8NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid8NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid8NumOrders_set)
    BidPrice9 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice9_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice9_set)
    BidVolume9 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume9_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume9_set)
    Bid9NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid9NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid9NumOrders_set)
    BidPrice10 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice10_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidPrice10_set)
    BidVolume10 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume10_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidVolume10_set)
    Bid10NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid10NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Bid10NumOrders_set)
    AskPrice10 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice10_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskPrice10_set)
    AskVolume10 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume10_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_AskVolume10_set)
    Ask10NumOrders = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask10NumOrders_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Ask10NumOrders_set)
    ClosePrice = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_ClosePrice_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_ClosePrice_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_MDSecurityStat_set)
    TotalBidNumber = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalBidNumber_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalBidNumber_set)
    TotalOfferNumber = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalOfferNumber_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_TotalOfferNumber_set)
    BidTradeMaxDuration = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_BidTradeMaxDuration_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_BidTradeMaxDuration_set)
    OfferTradeMaxDuration = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_OfferTradeMaxDuration_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_OfferTradeMaxDuration_set)
    WithdrawBuyNumber = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyNumber_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyNumber_set)
    WithdrawBuyAmount = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyAmount_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyAmount_set)
    WithdrawBuyMoney = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyMoney_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawBuyMoney_set)
    WithdrawSellNumber = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellNumber_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellNumber_set)
    WithdrawSellAmount = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellAmount_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellAmount_set)
    WithdrawSellMoney = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellMoney_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_WithdrawSellMoney_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Info1_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Info2_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2XTSMarketDataField_Info3_get, _lev2mdapi.CTORATstpLev2XTSMarketDataField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2XTSMarketDataField_swiginit(self, _lev2mdapi.new_CTORATstpLev2XTSMarketDataField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2XTSMarketDataField

# Register CTORATstpLev2XTSMarketDataField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2XTSMarketDataField_swigregister(CTORATstpLev2XTSMarketDataField)

class CTORATstpLev2XTSTickField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2XTSTickField_ExchangeID_get, _lev2mdapi.CTORATstpLev2XTSTickField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2XTSTickField_SecurityID_get, _lev2mdapi.CTORATstpLev2XTSTickField_SecurityID_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2XTSTickField_MainSeq_get, _lev2mdapi.CTORATstpLev2XTSTickField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2XTSTickField_SubSeq_get, _lev2mdapi.CTORATstpLev2XTSTickField_SubSeq_set)
    TickTime = property(_lev2mdapi.CTORATstpLev2XTSTickField_TickTime_get, _lev2mdapi.CTORATstpLev2XTSTickField_TickTime_set)
    TickType = property(_lev2mdapi.CTORATstpLev2XTSTickField_TickType_get, _lev2mdapi.CTORATstpLev2XTSTickField_TickType_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2XTSTickField_BuyNo_get, _lev2mdapi.CTORATstpLev2XTSTickField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2XTSTickField_SellNo_get, _lev2mdapi.CTORATstpLev2XTSTickField_SellNo_set)
    Price = property(_lev2mdapi.CTORATstpLev2XTSTickField_Price_get, _lev2mdapi.CTORATstpLev2XTSTickField_Price_set)
    Volume = property(_lev2mdapi.CTORATstpLev2XTSTickField_Volume_get, _lev2mdapi.CTORATstpLev2XTSTickField_Volume_set)
    TradeMoney = property(_lev2mdapi.CTORATstpLev2XTSTickField_TradeMoney_get, _lev2mdapi.CTORATstpLev2XTSTickField_TradeMoney_set)
    Side = property(_lev2mdapi.CTORATstpLev2XTSTickField_Side_get, _lev2mdapi.CTORATstpLev2XTSTickField_Side_set)
    TradeBSFlag = property(_lev2mdapi.CTORATstpLev2XTSTickField_TradeBSFlag_get, _lev2mdapi.CTORATstpLev2XTSTickField_TradeBSFlag_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2XTSTickField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2XTSTickField_MDSecurityStat_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2XTSTickField_Info1_get, _lev2mdapi.CTORATstpLev2XTSTickField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2XTSTickField_Info2_get, _lev2mdapi.CTORATstpLev2XTSTickField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2XTSTickField_Info3_get, _lev2mdapi.CTORATstpLev2XTSTickField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2XTSTickField_swiginit(self, _lev2mdapi.new_CTORATstpLev2XTSTickField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2XTSTickField

# Register CTORATstpLev2XTSTickField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2XTSTickField_swigregister(CTORATstpLev2XTSTickField)

class CTORATstpLev2NGTSTickField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2NGTSTickField_ExchangeID_get, _lev2mdapi.CTORATstpLev2NGTSTickField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2NGTSTickField_SecurityID_get, _lev2mdapi.CTORATstpLev2NGTSTickField_SecurityID_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2NGTSTickField_MainSeq_get, _lev2mdapi.CTORATstpLev2NGTSTickField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2NGTSTickField_SubSeq_get, _lev2mdapi.CTORATstpLev2NGTSTickField_SubSeq_set)
    TickTime = property(_lev2mdapi.CTORATstpLev2NGTSTickField_TickTime_get, _lev2mdapi.CTORATstpLev2NGTSTickField_TickTime_set)
    TickType = property(_lev2mdapi.CTORATstpLev2NGTSTickField_TickType_get, _lev2mdapi.CTORATstpLev2NGTSTickField_TickType_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2NGTSTickField_BuyNo_get, _lev2mdapi.CTORATstpLev2NGTSTickField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2NGTSTickField_SellNo_get, _lev2mdapi.CTORATstpLev2NGTSTickField_SellNo_set)
    Price = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Price_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Price_set)
    Volume = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Volume_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Volume_set)
    TradeMoney = property(_lev2mdapi.CTORATstpLev2NGTSTickField_TradeMoney_get, _lev2mdapi.CTORATstpLev2NGTSTickField_TradeMoney_set)
    Side = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Side_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Side_set)
    TradeBSFlag = property(_lev2mdapi.CTORATstpLev2NGTSTickField_TradeBSFlag_get, _lev2mdapi.CTORATstpLev2NGTSTickField_TradeBSFlag_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2NGTSTickField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2NGTSTickField_MDSecurityStat_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Info1_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Info2_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2NGTSTickField_Info3_get, _lev2mdapi.CTORATstpLev2NGTSTickField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2NGTSTickField_swiginit(self, _lev2mdapi.new_CTORATstpLev2NGTSTickField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2NGTSTickField

# Register CTORATstpLev2NGTSTickField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2NGTSTickField_swigregister(CTORATstpLev2NGTSTickField)

class CTORATstpLev2BondMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SecurityID = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_SecurityID_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_SecurityID_set)
    ExchangeID = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_ExchangeID_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_ExchangeID_set)
    DataTimeStamp = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_DataTimeStamp_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_DataTimeStamp_set)
    PreClosePrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_PreClosePrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_PreClosePrice_set)
    OpenPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_OpenPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_OpenPrice_set)
    AvgPreClosePrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AvgPreClosePrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AvgPreClosePrice_set)
    NumTrades = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_NumTrades_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_NumTrades_set)
    TotalVolumeTrade = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_TotalVolumeTrade_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_TotalVolumeTrade_set)
    TotalValueTrade = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_TotalValueTrade_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_TotalValueTrade_set)
    AuctionVolumeTrade = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionVolumeTrade_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionVolumeTrade_set)
    AuctionValueTrade = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionValueTrade_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionValueTrade_set)
    TotalBidVolume = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_TotalBidVolume_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_TotalBidVolume_set)
    AvgBidPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AvgBidPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AvgBidPrice_set)
    TotalAskVolume = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_TotalAskVolume_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_TotalAskVolume_set)
    AvgAskPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AvgAskPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AvgAskPrice_set)
    HighestPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_HighestPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_HighestPrice_set)
    LowestPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_LowestPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_LowestPrice_set)
    LastPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_LastPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_LastPrice_set)
    AuctionLastPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionLastPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AuctionLastPrice_set)
    AvgPrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AvgPrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AvgPrice_set)
    PriceUpDown1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_PriceUpDown1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_PriceUpDown1_set)
    PriceUpDown2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_PriceUpDown2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_PriceUpDown2_set)
    ClosePrice = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_ClosePrice_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_ClosePrice_set)
    MDSecurityStat = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_MDSecurityStat_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_MDSecurityStat_set)
    BidPrice1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice1_set)
    BidVolume1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume1_set)
    Bid1NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid1NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid1NumOrders_set)
    AskPrice1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice1_set)
    AskVolume1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume1_set)
    Ask1NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask1NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask1NumOrders_set)
    AskPrice2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice2_set)
    AskVolume2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume2_set)
    Ask2NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask2NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask2NumOrders_set)
    AskPrice3 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice3_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice3_set)
    AskVolume3 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume3_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume3_set)
    Ask3NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask3NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask3NumOrders_set)
    BidPrice2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice2_set)
    BidVolume2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume2_set)
    Bid2NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid2NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid2NumOrders_set)
    BidPrice3 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice3_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice3_set)
    BidVolume3 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume3_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume3_set)
    Bid3NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid3NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid3NumOrders_set)
    AskPrice4 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice4_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice4_set)
    AskVolume4 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume4_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume4_set)
    Ask4NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask4NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask4NumOrders_set)
    AskPrice5 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice5_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice5_set)
    AskVolume5 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume5_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume5_set)
    Ask5NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask5NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask5NumOrders_set)
    BidPrice4 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice4_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice4_set)
    BidVolume4 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume4_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume4_set)
    Bid4NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid4NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid4NumOrders_set)
    BidPrice5 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice5_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice5_set)
    BidVolume5 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume5_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume5_set)
    Bid5NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid5NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid5NumOrders_set)
    AskPrice6 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice6_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice6_set)
    AskVolume6 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume6_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume6_set)
    Ask6NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask6NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask6NumOrders_set)
    AskPrice7 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice7_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice7_set)
    AskVolume7 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume7_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume7_set)
    Ask7NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask7NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask7NumOrders_set)
    BidPrice6 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice6_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice6_set)
    BidVolume6 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume6_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume6_set)
    Bid6NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid6NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid6NumOrders_set)
    BidPrice7 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice7_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice7_set)
    BidVolume7 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume7_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume7_set)
    Bid7NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid7NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid7NumOrders_set)
    AskPrice8 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice8_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice8_set)
    AskVolume8 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume8_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume8_set)
    Ask8NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask8NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask8NumOrders_set)
    AskPrice9 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice9_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice9_set)
    AskVolume9 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume9_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume9_set)
    Ask9NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask9NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask9NumOrders_set)
    BidPrice8 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice8_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice8_set)
    BidVolume8 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume8_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume8_set)
    Bid8NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid8NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid8NumOrders_set)
    BidPrice9 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice9_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice9_set)
    BidVolume9 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume9_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume9_set)
    Bid9NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid9NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid9NumOrders_set)
    BidPrice10 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice10_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidPrice10_set)
    BidVolume10 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume10_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_BidVolume10_set)
    Bid10NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Bid10NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Bid10NumOrders_set)
    AskPrice10 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice10_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskPrice10_set)
    AskVolume10 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume10_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_AskVolume10_set)
    Ask10NumOrders = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Ask10NumOrders_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Ask10NumOrders_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Info1_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Info2_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2BondMarketDataField_Info3_get, _lev2mdapi.CTORATstpLev2BondMarketDataField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2BondMarketDataField_swiginit(self, _lev2mdapi.new_CTORATstpLev2BondMarketDataField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2BondMarketDataField

# Register CTORATstpLev2BondMarketDataField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2BondMarketDataField_swigregister(CTORATstpLev2BondMarketDataField)

class CTORATstpLev2BondOrderDetailField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_ExchangeID_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_SecurityID_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_SecurityID_set)
    OrderTime = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_OrderTime_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_OrderTime_set)
    Price = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Price_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Price_set)
    Volume = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Volume_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Volume_set)
    Side = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Side_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Side_set)
    OrderType = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_OrderType_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_OrderType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_MainSeq_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_SubSeq_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_SubSeq_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Info1_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Info2_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2BondOrderDetailField_Info3_get, _lev2mdapi.CTORATstpLev2BondOrderDetailField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2BondOrderDetailField_swiginit(self, _lev2mdapi.new_CTORATstpLev2BondOrderDetailField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2BondOrderDetailField

# Register CTORATstpLev2BondOrderDetailField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2BondOrderDetailField_swigregister(CTORATstpLev2BondOrderDetailField)

class CTORATstpLev2BondTransactionField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_lev2mdapi.CTORATstpLev2BondTransactionField_ExchangeID_get, _lev2mdapi.CTORATstpLev2BondTransactionField_ExchangeID_set)
    SecurityID = property(_lev2mdapi.CTORATstpLev2BondTransactionField_SecurityID_get, _lev2mdapi.CTORATstpLev2BondTransactionField_SecurityID_set)
    TradeTime = property(_lev2mdapi.CTORATstpLev2BondTransactionField_TradeTime_get, _lev2mdapi.CTORATstpLev2BondTransactionField_TradeTime_set)
    TradePrice = property(_lev2mdapi.CTORATstpLev2BondTransactionField_TradePrice_get, _lev2mdapi.CTORATstpLev2BondTransactionField_TradePrice_set)
    TradeVolume = property(_lev2mdapi.CTORATstpLev2BondTransactionField_TradeVolume_get, _lev2mdapi.CTORATstpLev2BondTransactionField_TradeVolume_set)
    ExecType = property(_lev2mdapi.CTORATstpLev2BondTransactionField_ExecType_get, _lev2mdapi.CTORATstpLev2BondTransactionField_ExecType_set)
    MainSeq = property(_lev2mdapi.CTORATstpLev2BondTransactionField_MainSeq_get, _lev2mdapi.CTORATstpLev2BondTransactionField_MainSeq_set)
    SubSeq = property(_lev2mdapi.CTORATstpLev2BondTransactionField_SubSeq_get, _lev2mdapi.CTORATstpLev2BondTransactionField_SubSeq_set)
    BuyNo = property(_lev2mdapi.CTORATstpLev2BondTransactionField_BuyNo_get, _lev2mdapi.CTORATstpLev2BondTransactionField_BuyNo_set)
    SellNo = property(_lev2mdapi.CTORATstpLev2BondTransactionField_SellNo_get, _lev2mdapi.CTORATstpLev2BondTransactionField_SellNo_set)
    Info1 = property(_lev2mdapi.CTORATstpLev2BondTransactionField_Info1_get, _lev2mdapi.CTORATstpLev2BondTransactionField_Info1_set)
    Info2 = property(_lev2mdapi.CTORATstpLev2BondTransactionField_Info2_get, _lev2mdapi.CTORATstpLev2BondTransactionField_Info2_set)
    Info3 = property(_lev2mdapi.CTORATstpLev2BondTransactionField_Info3_get, _lev2mdapi.CTORATstpLev2BondTransactionField_Info3_set)

    def __init__(self):
        _lev2mdapi.CTORATstpLev2BondTransactionField_swiginit(self, _lev2mdapi.new_CTORATstpLev2BondTransactionField())
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2BondTransactionField

# Register CTORATstpLev2BondTransactionField in _lev2mdapi:
_lev2mdapi.CTORATstpLev2BondTransactionField_swigregister(CTORATstpLev2BondTransactionField)

class CTORATstpLev2MdSpi(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def OnFrontConnected(self):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnFrontConnected(self)

    def OnFrontDisconnected(self, nReason):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnFrontDisconnected(self, nReason)

    def OnRspError(self, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspError(self, pRspInfo, nRequestID, bIsLast)

    def OnRspUserLogin(self, pRspUserLogin, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUserLogin(self, pRspUserLogin, pRspInfo, nRequestID, bIsLast)

    def OnRspUserLogout(self, pUserLogout, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUserLogout(self, pUserLogout, pRspInfo, nRequestID, bIsLast)

    def OnRspSubMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubPHMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubPHMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubPHMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubPHMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubPHTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubPHTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubPHTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubPHTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubResendTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubResendTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubResendTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubResendTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubResendOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubResendOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubResendOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubResendOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubXTSMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubXTSMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubXTSMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubXTSMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubXTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubXTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubXTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubXTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubNGTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubNGTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubNGTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubNGTSTick(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubBondMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubBondMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubBondMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubBondMarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubBondTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubBondTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubBondTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubBondTransaction(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspSubBondOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspSubBondOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRspUnSubBondOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRspUnSubBondOrderDetail(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast)

    def OnRtnMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes)

    def OnRtnIndex(self, pIndex):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnIndex(self, pIndex)

    def OnRtnTransaction(self, pTransaction):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnTransaction(self, pTransaction)

    def OnRtnOrderDetail(self, pOrderDetail):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnOrderDetail(self, pOrderDetail)

    def OnRtnPHMarketData(self, pPHMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnPHMarketData(self, pPHMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes)

    def OnRtnPHTransaction(self, pTransaction):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnPHTransaction(self, pTransaction)

    def OnRtnResendTransaction(self, pTransaction):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnResendTransaction(self, pTransaction)

    def OnRtnResendOrderDetail(self, pOrderDetail):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnResendOrderDetail(self, pOrderDetail)

    def OnRtnXTSMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnXTSMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes)

    def OnRtnXTSTick(self, pTick):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnXTSTick(self, pTick)

    def OnRtnNGTSTick(self, pTick):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnNGTSTick(self, pTick)

    def OnRtnBondMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnBondMarketData(self, pMarketData, FirstLevelBuyNum, FirstLevelBuyOrderVolumes, FirstLevelSellNum, FirstLevelSellOrderVolumes)

    def OnRtnBondTransaction(self, pTransaction):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnBondTransaction(self, pTransaction)

    def OnRtnBondOrderDetail(self, pOrderDetail):
        return _lev2mdapi.CTORATstpLev2MdSpi_OnRtnBondOrderDetail(self, pOrderDetail)

    def __init__(self):
        if self.__class__ == CTORATstpLev2MdSpi:
            _self = None
        else:
            _self = self
        _lev2mdapi.CTORATstpLev2MdSpi_swiginit(self, _lev2mdapi.new_CTORATstpLev2MdSpi(_self, ))
    __swig_destroy__ = _lev2mdapi.delete_CTORATstpLev2MdSpi
    def __disown__(self):
        self.this.disown()
        _lev2mdapi.disown_CTORATstpLev2MdSpi(self)
        return weakref.proxy(self)

# Register CTORATstpLev2MdSpi in _lev2mdapi:
_lev2mdapi.CTORATstpLev2MdSpi_swigregister(CTORATstpLev2MdSpi)

class CTORATstpLev2MdApi(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def CreateTstpLev2MdApi(*args):
        return _lev2mdapi.CTORATstpLev2MdApi_CreateTstpLev2MdApi(*args)

    @staticmethod
    def GetApiVersion():
        return _lev2mdapi.CTORATstpLev2MdApi_GetApiVersion()

    def Release(self):
        return _lev2mdapi.CTORATstpLev2MdApi_Release(self)

    def Init(self, *args):
        return _lev2mdapi.CTORATstpLev2MdApi_Init(self, *args)

    def Join(self):
        return _lev2mdapi.CTORATstpLev2MdApi_Join(self)

    def RegisterFront(self, pszFrontAddress):
        return _lev2mdapi.CTORATstpLev2MdApi_RegisterFront(self, pszFrontAddress)

    def RegisterNameServer(self, pszNsAddress):
        return _lev2mdapi.CTORATstpLev2MdApi_RegisterNameServer(self, pszNsAddress)

    def RegisterMulticast(self, *args):
        return _lev2mdapi.CTORATstpLev2MdApi_RegisterMulticast(self, *args)

    def RegisterSpi(self, pSpi):
        return _lev2mdapi.CTORATstpLev2MdApi_RegisterSpi(self, pSpi)

    def DeclareMKSubTypes(self, mkSubTypes):
        return _lev2mdapi.CTORATstpLev2MdApi_DeclareMKSubTypes(self, mkSubTypes)

    def SubscribeMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeMarketData(self, ppSecurityID, ExchageID)

    def UnSubscribeMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeMarketData(self, ppSecurityID, ExchageID)

    def SubscribeIndex(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeIndex(self, ppSecurityID, ExchageID)

    def UnSubscribeIndex(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeIndex(self, ppSecurityID, ExchageID)

    def SubscribeTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeTransaction(self, ppSecurityID, ExchageID)

    def UnSubscribeTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeTransaction(self, ppSecurityID, ExchageID)

    def SubscribeOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeOrderDetail(self, ppSecurityID, ExchageID)

    def UnSubscribeOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeOrderDetail(self, ppSecurityID, ExchageID)

    def SubscribePHMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribePHMarketData(self, ppSecurityID, ExchageID)

    def UnSubscribePHMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribePHMarketData(self, ppSecurityID, ExchageID)

    def SubscribePHTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribePHTransaction(self, ppSecurityID, ExchageID)

    def UnSubscribePHTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribePHTransaction(self, ppSecurityID, ExchageID)

    def SubscribeResendTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeResendTransaction(self, ppSecurityID, ExchageID)

    def UnSubscribeResendTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeResendTransaction(self, ppSecurityID, ExchageID)

    def SubscribeResendOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeResendOrderDetail(self, ppSecurityID, ExchageID)

    def UnSubscribeResendOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeResendOrderDetail(self, ppSecurityID, ExchageID)

    def SubscribeXTSMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeXTSMarketData(self, ppSecurityID, ExchageID)

    def UnSubscribeXTSMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeXTSMarketData(self, ppSecurityID, ExchageID)

    def SubscribeXTSTick(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeXTSTick(self, ppSecurityID, ExchageID)

    def UnSubscribeXTSTick(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeXTSTick(self, ppSecurityID, ExchageID)

    def SubscribeNGTSTick(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeNGTSTick(self, ppSecurityID, ExchageID)

    def UnSubscribeNGTSTick(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeNGTSTick(self, ppSecurityID, ExchageID)

    def SubscribeBondMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeBondMarketData(self, ppSecurityID, ExchageID)

    def UnSubscribeBondMarketData(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeBondMarketData(self, ppSecurityID, ExchageID)

    def SubscribeBondTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeBondTransaction(self, ppSecurityID, ExchageID)

    def UnSubscribeBondTransaction(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeBondTransaction(self, ppSecurityID, ExchageID)

    def SubscribeBondOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_SubscribeBondOrderDetail(self, ppSecurityID, ExchageID)

    def UnSubscribeBondOrderDetail(self, ppSecurityID, ExchageID):
        return _lev2mdapi.CTORATstpLev2MdApi_UnSubscribeBondOrderDetail(self, ppSecurityID, ExchageID)

    def ReqUserLogin(self, pReqUserLoginField, nRequestID):
        return _lev2mdapi.CTORATstpLev2MdApi_ReqUserLogin(self, pReqUserLoginField, nRequestID)

    def ReqUserLogout(self, pUserLogout, nRequestID):
        return _lev2mdapi.CTORATstpLev2MdApi_ReqUserLogout(self, pUserLogout, nRequestID)

# Register CTORATstpLev2MdApi in _lev2mdapi:
_lev2mdapi.CTORATstpLev2MdApi_swigregister(CTORATstpLev2MdApi)

def CTORATstpLev2MdApi_CreateTstpLev2MdApi(*args):
    return _lev2mdapi.CTORATstpLev2MdApi_CreateTstpLev2MdApi(*args)

def CTORATstpLev2MdApi_GetApiVersion():
    return _lev2mdapi.CTORATstpLev2MdApi_GetApiVersion()




 huaxin/log.py

New file
@@ -0,0 +1,44 @@
import logging
import sys
import time

log_records = []




class MyLogHandler(logging.Handler, object):
    """
    自定义日志handler
    """

    def __init__(self, name, other_attr=None, **kwargs):
        logging.Handler.__init__(self)

    def emit(self, record):
        """
        emit函数为自定义handler类时必重写的函数，这里可以根据需要对日志消息做一些处理，比如发送日志到服务器

        发出记录(Emit a record)
        """
        try:
            msg = self.format(record)
            log_records.append((round(time.time() * 1000), msg))
        except Exception:
            self.handleError(record)


logger = logging.getLogger('logger')
logger.setLevel(logging.DEBUG)

# 创建一个流处理器handler并设置其日志级别为DEBUG
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setLevel(logging.DEBUG)
# 创建一个格式器formatter并将其添加到处理器handler
formatter = logging.Formatter("%(asctime)s - %(message)s")
stdout_handler.setFormatter(formatter)

logger.addHandler(stdout_handler)
# 内存日志handler
my_log_handler = MyLogHandler('LoggerHandler')
logger.addHandler(my_log_handler)

 huaxin/mylog.py

New file
@@ -0,0 +1,51 @@
"""
日志
"""
import platform

from loguru import logger


class MyLogger:
    def __init__(self):
        logger.remove()
        #   每一天生成一个日志文件，历史日志文件采用zip压缩,异步写入日志
        logger.add(self.get_path("l2", "transaction"),
                   filter=lambda record: record["extra"].get("name") == "transaction",
                   rotation="00:00", compression="zip", enqueue=True)
        logger.add(self.get_path("l2", "orderdetail"),
                   filter=lambda record: record["extra"].get("name") == "orderdetail",
                   rotation="00:00", compression="zip", enqueue=True)
        logger.add(self.get_path("l2", "upload"),
                   filter=lambda record: record["extra"].get("name") == "upload",
                   rotation="00:00", compression="zip", enqueue=True)
        logger.add(self.get_path("l2", "subscript"),
                   filter=lambda record: record["extra"].get("name") == "subscript",
                   rotation="00:00", compression="zip", enqueue=True)
        logger.add(self.get_path("contact", "debug"),
                   filter=lambda record: record["extra"].get("name") == "debug",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("trade", "trade_debug"),
                   filter=lambda record: record["extra"].get("name") == "trade_debug",
                   rotation="00:00", compression="zip", enqueue=True)

    def get_path(self, dir_name, log_name):
        system = platform.system()
        base_dir = "/home/userzjj/logs"
        if system == 'Windows':
            base_dir = "D:/logs/huaxin"
        return "{}/{}/{}".format(base_dir, dir_name, log_name) + ".{time:YYYY-MM-DD}.log"

    def get_logger(self, log_name):
        return logger.bind(name=log_name)


__mylogger = MyLogger()
logger_l2_transaction = __mylogger.get_logger("transaction")
logger_l2_orderdetail = __mylogger.get_logger("orderdetail")
logger_l2_upload = __mylogger.get_logger("upload")
logger_l2_error = __mylogger.get_logger("error")
logger_l2_subscript = __mylogger.get_logger("subscript")
logger_contact_debug = __mylogger.get_logger("debug")
logger_trade_debug = __mylogger.get_logger("trade_debug")

 huaxin/socket_util.py

New file
@@ -0,0 +1,74 @@
"""
socket工具类
"""

# 添加数据头
import json

from huaxin import crypt


def load_header(data_bytes):
    slen = '##%08d' % len(data_bytes)
    return slen.encode("utf-8") + data_bytes


# 接收数据，去除头
def recv_data(sk):
    data = ""
    header_size = 10
    buf = sk.recv(1024)
    header_str = buf[:header_size]
    if buf:
        buf = buf.decode('utf-8')
        if buf.startswith("##"):
            content_length = int(buf[2:10])
            received_size = 0
            # 加上读取头的数据
            received_size += len(buf[header_size:])
            data += buf[header_size:]
            while not received_size == content_length:
                r_data = sk.recv(10240)
                received_size += len(r_data)
                data += r_data.decode('utf-8')
        else:
            data = sk.recv(1024 * 1024)
            data = buf + data.decode('utf-8')
    return data, header_str


# 客户端参数加密
def encryp_client_params_sign(dataJson):
    if type(dataJson) != dict:
        return dataJson
    str_list = []
    for k in dataJson:
        if type(dataJson[k]) == dict:
            str_list.append(f"{k}={json.dumps(dataJson[k], separators=(',', ':'))}")
        else:
            str_list.append(f"{k}={dataJson[k]}")
    str_list.sort()
    str_list.append("%Yeshi2014@#.")
    dataJson["sign"] = crypt.md5_encrypt("&".join(str_list))
    return dataJson


# 客户端密码加密验证
def is_client_params_sign_right(dataJson):
    if type(dataJson) != dict:
        return False
    sign = dataJson["sign"]
    dataJson.pop("sign")
    str_list = []
    for k in dataJson:
        if type(dataJson[k]) == dict:
            str_list.append(f"{k}={json.dumps(dataJson[k], separators=(',', ':'))}")
        else:
            str_list.append(f"{k}={dataJson[k]}")
    str_list.sort()
    str_list.append("%Yeshi2014@#.")
    new_sign = crypt.md5_encrypt("&".join(str_list))
    if sign == new_sign:
        return True
    else:
        return False

 huaxin/tool.py

New file
@@ -0,0 +1,13 @@
import time


def is_trade_time():
    relative_timestamp = time.time() % (24 * 60 * 60) + 8 * 60 * 60
    start1 = 60 * 60 * 9 + 24 * 60
    end1 = 60 * 60 * 11 + 31 * 60
    start2 = 60 * 60 * 12 + 58 * 60
    end2 = 60 * 60 * 15 + 1 * 60
    if start1 < relative_timestamp < end1 or start2 < relative_timestamp < end2:
        return True
    else:
        return False

 huaxin/trade_client.py

New file
@@ -0,0 +1,961 @@
import json
import logging
import threading
import time

from huaxin import command_manager
from huaxin import constant
from huaxin import socket_util
from huaxin import traderapi
from huaxin.client_network import SendResponseSkManager
from huaxin.log import logger

# 正式账号
from huaxin.mylog import logger_trade_debug

UserID = '388000013349'
# 登陆密码
Password = '110808'
# 投资者账户
InvestorID = '388000013349'
# 经济公司部门代码
DepartmentID = '0003'
# 资金账户
AccountID = '388000013349'
# 沪市股东账号
SSE_ShareHolderID = 'A641420991'
# 深市股东账号
SZSE_ShareHolderID = '0345104949'

# # 仿真
# from mylog import logger_trade_debug
#
# UserID = '00043201'
# # 登陆密码
# Password = '45249973'
# # 投资者账户
# InvestorID = '11160150'
# # 经济公司部门代码
# DepartmentID = '0003'
# # 资金账户
# AccountID = '00043201'
# # 沪市股东账号
# SSE_ShareHolderID = 'A00043201'
# # 深市股东账号
# SZSE_ShareHolderID = '700043201'

# # 登录用户
# UserID = '00572083'
# # 登陆密码
# Password = '16121950'
# # 投资者账户
# InvestorID = '11160150'
# # 经济公司部门代码
# DepartmentID = '0057'
# # 资金账户
# AccountID = '00572083'
# # 沪市股东账号
# SSE_ShareHolderID = 'A00572083'
# # 深市股东账号
# SZSE_ShareHolderID = '700572083'


TYPE_ORDER = 0
TYPE_CANCEL_ORDER = 1
TYPE_LIST_DELEGATE = 2
TYPE_LIST_TRADED = 3
TYPE_LIST_POSITION = 4
TYPE_LIST_MONEY = 5


class TradeSimpleApi:
    req_id = 0
    __buy_sinfo_set = set()
    __sell_sinfo_set = set()
    __cancel_buy_sinfo_set = set()
    __cancel_sell_sinfo_set = set()

    # sinfo char(32)
    def buy(self, code, count, price, sinfo):
        if sinfo in self.__buy_sinfo_set:
            raise Exception(f'下单请求已经提交：{sinfo}')
        self.__buy_sinfo_set.add(sinfo)
        self.req_id += 1
        # 请求报单
        req_field = traderapi.CTORATstpInputOrderField()
        # TORA_TSTP_EXD_COMM(0): 通用(内部使用)
        # TORA_TSTP_EXD_SSE(1): 上海交易所
        # TORA_TSTP_EXD_SZSE(2): 深圳交易所
        # TORA_TSTP_EXD_HK(3): 香港交易所
        # TORA_TSTP_EXD_BSE(4): 北京证券交易所
        if code.find('00') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
            req_field.ShareholderID = SZSE_ShareHolderID
        elif code.find('60') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE
            req_field.ShareholderID = SSE_ShareHolderID

        # 证券代码
        req_field.SecurityID = code
        req_field.Direction = traderapi.TORA_TSTP_D_Buy
        req_field.VolumeTotalOriginal = count
        req_field.SInfo = sinfo

        '''
        上交所支持限价指令和最优五档剩撤、最优五档剩转限两种市价指令，对于科创板额外支持本方最优和对手方最优两种市价指令和盘后固定价格申报指令
        深交所支持限价指令和立即成交剩余撤销、全额成交或撤销、本方最优、对手方最优和最优五档剩撤五种市价指令
        限价指令和上交所科创板盘后固定价格申报指令需填写报单价格，其它市价指令无需填写报单价格
        以下以上交所限价指令为例，其它指令参考开发指南相关说明填写OrderPriceType、TimeCondition和VolumeCondition三个字段:
        '''
        req_field.LimitPrice = price
        req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_LimitPrice
        req_field.TimeCondition = traderapi.TORA_TSTP_TC_GFD
        req_field.VolumeCondition = traderapi.TORA_TSTP_VC_AV

        '''
        OrderRef为报单引用，类型为整型，该字段报单时为选填
        若不填写，则系统会为每笔报单自动分配一个报单引用
        若填写，则需保证同一个TCP会话下报单引用严格单调递增，不要求连续递增，至少需从1开始编号
        '''
        # req_field.OrderRef = 1

        '''
        InvestorID为选填，若填写则需保证填写正确
        Operway为委托方式，根据券商要求填写，无特殊说明置空即可
        终端自定义字段，终端可根据需要填写如下字段的值，该字段值不会被柜台系统修改，在报单回报和查询报单时返回给终端
        '''
        # req_field.SInfo = 'sinfo'
        # req_field.IInfo = 123

        '''
        其它字段置空
        '''
        ret = api.ReqOrderInsert(req_field, self.req_id)
        if ret != 0:
            raise Exception('ReqOrderInsert fail, ret[%d]' % ret)
        # 给L2发送消息
        if l2pipe is not None:
            l2pipe.send(json.dumps({"type": "listen_volume", "data": {"code": code, "volume": count}}).encode('utf-8'))
        return

    # 撤买
    def cancel_buy(self, code, order_sys_id, sinfo):
        if sinfo in self.__cancel_buy_sinfo_set:
            raise Exception(f'撤单请求已经提交：{sinfo}')
        self.__cancel_buy_sinfo_set.add(sinfo)
        self.req_id += 1
        # 请求撤单
        req_field = traderapi.CTORATstpInputOrderActionField()
        if code.find('00') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
        elif code.find('60') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE

        req_field.ActionFlag = traderapi.TORA_TSTP_AF_Delete

        # 撤单支持以下两种方式定位原始报单：
        # （1）报单引用方式
        # req_field.FrontID = self.__front_id
        # req_field.SessionID = self.__session_id
        # req_field.OrderRef = 1
        # （2）系统报单编号方式
        req_field.OrderSysID = order_sys_id

        # OrderActionRef报单操作引用，用法同报单引用，可根据需要选填

        '''
        终端自定义字段，终端可根据需要填写如下字段的值，该字段值不会被柜台系统修改，在查询撤单时返回给终端
        '''
        req_field.SInfo = sinfo
        # req_field.IInfo = 123

        '''
        委托方式字段根据券商要求填写，无特殊说明置空即可
        其它字段置空
        '''
        ret = api.ReqOrderAction(req_field, self.req_id)
        if ret != 0:
            raise Exception('ReqOrderAction fail, ret[%d]' % ret)
        return

    # 卖
    def sell(self, code, count, price, price_type, sinfo):
        if sinfo in self.__sell_sinfo_set:
            raise Exception(f'下单请求已经提交：{sinfo}')
        self.__sell_sinfo_set.add(sinfo)
        self.req_id += 1
        # 请求报单
        req_field = traderapi.CTORATstpInputOrderField()
        # TORA_TSTP_EXD_COMM(0): 通用(内部使用)
        # TORA_TSTP_EXD_SSE(1): 上海交易所
        # TORA_TSTP_EXD_SZSE(2): 深圳交易所
        # TORA_TSTP_EXD_HK(3): 香港交易所
        # TORA_TSTP_EXD_BSE(4): 北京证券交易所
        if code.find('00') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
            req_field.ShareholderID = SZSE_ShareHolderID
        elif code.find('60') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE
            req_field.ShareholderID = SSE_ShareHolderID

        # 证券代码
        req_field.SecurityID = code
        req_field.Direction = traderapi.TORA_TSTP_D_Sell
        req_field.VolumeTotalOriginal = count
        req_field.SInfo = sinfo

        '''
        上交所支持限价指令和最优五档剩撤、最优五档剩转限两种市价指令，对于科创板额外支持本方最优和对手方最优两种市价指令和盘后固定价格申报指令
        深交所支持限价指令和立即成交剩余撤销、全额成交或撤销、本方最优、对手方最优和最优五档剩撤五种市价指令
        限价指令和上交所科创板盘后固定价格申报指令需填写报单价格，其它市价指令无需填写报单价格
        以下以上交所限价指令为例，其它指令参考开发指南相关说明填写OrderPriceType、TimeCondition和VolumeCondition三个字段:
        '''

        print('卖 price', price, price_type)
        if price and price > 0:
            req_field.LimitPrice = price
        if price_type == 1:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_AnyPrice
        elif price_type == 2:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_LimitPrice
        elif price_type == 3:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_BestPrice
        elif price_type == 4:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_FixPrice
        elif price_type == 5:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_FiveLevelPrice
        elif price_type == 6:
            req_field.OrderPriceType = traderapi.TORA_TSTP_OPT_HomeBestPrice

        req_field.TimeCondition = traderapi.TORA_TSTP_TC_GFD
        req_field.VolumeCondition = traderapi.TORA_TSTP_VC_AV

        '''
        OrderRef为报单引用，类型为整型，该字段报单时为选填
        若不填写，则系统会为每笔报单自动分配一个报单引用
        若填写，则需保证同一个TCP会话下报单引用严格单调递增，不要求连续递增，至少需从1开始编号
        '''
        # req_field.OrderRef = 1

        '''
        InvestorID为选填，若填写则需保证填写正确
        Operway为委托方式，根据券商要求填写，无特殊说明置空即可
        终端自定义字段，终端可根据需要填写如下字段的值，该字段值不会被柜台系统修改，在报单回报和查询报单时返回给终端
        '''
        # req_field.SInfo = 'sinfo'
        # req_field.IInfo = 123

        '''
        其它字段置空
        '''
        ret = api.ReqOrderInsert(req_field, self.req_id)
        if ret != 0:
            raise Exception('ReqOrderInsert fail, ret[%d]' % ret)
        return

    # 撤卖
    def cancel_sell(self, code, order_sys_id, sinfo):
        if sinfo in self.__cancel_sell_sinfo_set:
            raise Exception(f'撤单请求已经提交：{sinfo}')
        self.__cancel_sell_sinfo_set.add(sinfo)
        self.req_id += 1
        # 请求撤单
        req_field = traderapi.CTORATstpInputOrderActionField()
        if code.find('00') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
        elif code.find('60') == 0:
            req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE

        req_field.ActionFlag = traderapi.TORA_TSTP_AF_Delete

        # 撤单支持以下两种方式定位原始报单：
        # （1）报单引用方式
        # req_field.FrontID = self.__front_id
        # req_field.SessionID = self.__session_id
        # req_field.OrderRef = 1
        # （2）系统报单编号方式
        req_field.OrderSysID = order_sys_id

        # OrderActionRef报单操作引用，用法同报单引用，可根据需要选填

        '''
        终端自定义字段，终端可根据需要填写如下字段的值，该字段值不会被柜台系统修改，在查询撤单时返回给终端
        '''
        req_field.SInfo = sinfo
        # req_field.IInfo = 123

        '''
        委托方式字段根据券商要求填写，无特殊说明置空即可
        其它字段置空
        '''
        ret = api.ReqOrderAction(req_field, self.req_id)
        if ret != 0:
            raise Exception('ReqOrderAction fail, ret[%d]' % ret)
        return

    # 查询当日可撤销的委托
    def list_delegate_orders(self, is_cancel):
        self.req_id += 1
        req_id = self.req_id
        req_field = traderapi.CTORATstpQryOrderField()
        # 以下字段不填表示不设过滤条件，即查询所有报单
        # req_field.SecurityID = '600000'
        # req_field.InsertTimeStart = '09:35:00'
        # req_field.InsertTimeEnd = '10:00:00'
        # IsCancel字段填1表示只查询可撤报单
        if is_cancel:
            req_field.IsCancel = 1
        # req_field.SInfo = sinfo
        ret = api.ReqQryOrder(req_field, req_id)
        if ret != 0:
            raise Exception('ReqQryOrder fail, ret[%d]' % ret)
        return req_id

    # 查询当日成交的订单
    def list_traded_orders(self):
        self.req_id += 1
        req_id = self.req_id
        req_field = traderapi.CTORATstpQryTradeField()
        ret = api.ReqQryTrade(req_field, req_id)
        if ret != 0:
            raise Exception('ReqQryTrade fail, ret[%d]' % ret)
        return req_id

    # 查询持仓
    def list_positions(self):
        self.req_id += 1
        req_id = self.req_id
        req_field = traderapi.CTORATstpQryPositionField()
        ret = api.ReqQryPosition(req_field, req_id)
        if ret != 0:
            raise Exception('ReqQryPosition fail, ret[%d]' % ret)
        return req_id

    # 查询资金账户
    def get_money_account(self):
        self.req_id += 1
        req_id = self.req_id
        req_field = traderapi.CTORATstpQryTradingAccountField()
        req_field.CurrencyID = traderapi.TORA_TSTP_CID_CNY
        ret = api.ReqQryTradingAccount(req_field, req_id)
        if ret != 0:
            raise Exception('ReqQryTradingAccount fail, ret[%d]' % ret)
        return req_id

    def login(self):
        # 请求登录
        login_req = traderapi.CTORATstpReqUserLoginField()

        # 支持以用户代码、资金账号和股东账号方式登录
        # （1）以用户代码方式登录
        login_req.LogInAccount = UserID
        login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_UserID
        # （2）以资金账号方式登录
        # login_req.DepartmentID = DepartmentID
        # login_req.LogInAccount = AccountID
        # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_AccountID
        # （3）以上海股东账号方式登录
        # login_req.LogInAccount = SSE_ShareHolderID
        # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_SHAStock
        # （4）以深圳股东账号方式登录
        # login_req.LogInAccount = SZSE_ShareHolderID
        # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_SZAStock

        # 支持以密码和指纹(移动设备)方式认证
        # （1）密码认证
        # 密码认证时AuthMode可不填
        # login_req.AuthMode = traderapi.TORA_TSTP_AM_Password
        login_req.Password = Password
        # （2）指纹认证
        # 非密码认证时AuthMode必填
        # login_req.AuthMode = traderapi.TORA_TSTP_AM_FingerPrint
        # login_req.DeviceID = '03873902'
        # login_req.CertSerial = '9FAC09383D3920CAEFF039'

        # 终端信息采集
        # UserProductInfo填写终端名称
        login_req.UserProductInfo = 'jiabei'
        # 按照监管要求填写终端信息
        login_req.TerminalInfo = 'PC;IIP=123.112.154.118;IPORT=50361;LIP=192.168.118.107;MAC=54EE750B1713FCF8AE5CBD58;HD=TF655AY91GHRVL'
        # 以下内外网IP地址若不填则柜台系统自动采集，若填写则以终端填值为准报送
        # login_req.MacAddress = '5C-87-9C-96-F3-E3'
        # login_req.InnerIPAddress = '10.0.1.102'
        # login_req.OuterIPAddress = '58.246.43.50'

        TradeSimpleApi.req_id += 1
        ret = api.ReqUserLogin(login_req, TradeSimpleApi.req_id)
        if ret != 0:
            raise Exception('ReqUserLogin fail, ret[%d]' % ret)


class TraderSpi(traderapi.CTORATstpTraderSpi):
    def __init__(self, callback):
        traderapi.CTORATstpTraderSpi.__init__(self)
        self.__front_id = 0
        self.__session_id = 0
        self.__data_callback = callback
        self.__temp_order_list_dict = {}
        self.__temp_position_list_dict = {}
        self.__temp_money_account_list_dict = {}

    def OnFrontConnected(self) -> "void":
        logger.info('OnFrontConnected')

        # 获取终端信息
        TradeSimpleApi.req_id += 1

        ret = api.ReqGetConnectionInfo(TradeSimpleApi.req_id)
        if ret != 0:
            logger.info('ReqGetConnectionInfo fail, ret[%d]' % ret)

    def OnFrontDisconnected(self, nReason: "int") -> "void":
        logger.info('OnFrontDisconnected: [%d]' % nReason)

    def OnRspGetConnectionInfo(self, pConnectionInfoField: "CTORATstpConnectionInfoField",
                               pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('inner_ip_address[%s]' % pConnectionInfoField.InnerIPAddress)
            logger.info('inner_port[%d]' % pConnectionInfoField.InnerPort)
            logger.info('outer_ip_address[%s]' % pConnectionInfoField.OuterIPAddress)
            logger.info('outer_port[%d]' % pConnectionInfoField.OuterPort)
            logger.info('mac_address[%s]' % pConnectionInfoField.MacAddress)

            # 请求登录
            login_req = traderapi.CTORATstpReqUserLoginField()

            # 支持以用户代码、资金账号和股东账号方式登录
            # （1）以用户代码方式登录
            login_req.LogInAccount = UserID
            login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_UserID
            # （2）以资金账号方式登录
            # login_req.DepartmentID = DepartmentID
            # login_req.LogInAccount = AccountID
            # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_AccountID
            # （3）以上海股东账号方式登录
            # login_req.LogInAccount = SSE_ShareHolderID
            # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_SHAStock
            # （4）以深圳股东账号方式登录
            # login_req.LogInAccount = SZSE_ShareHolderID
            # login_req.LogInAccountType = traderapi.TORA_TSTP_LACT_SZAStock

            # 支持以密码和指纹(移动设备)方式认证
            # （1）密码认证
            # 密码认证时AuthMode可不填
            # login_req.AuthMode = traderapi.TORA_TSTP_AM_Password
            login_req.Password = Password
            # （2）指纹认证
            # 非密码认证时AuthMode必填
            # login_req.AuthMode = traderapi.TORA_TSTP_AM_FingerPrint
            # login_req.DeviceID = '03873902'
            # login_req.CertSerial = '9FAC09383D3920CAEFF039'

            # 终端信息采集
            # UserProductInfo填写终端名称
            login_req.UserProductInfo = 'jiabei'
            # 按照监管要求填写终端信息
            login_req.TerminalInfo = 'PC;IIP=NA;IPORT=NA;LIP=192.168.84.75;MAC=5C6F69CC2B40;HD=004bc76004aff0882b9052ba0eb00506;@jiabei'
            # 以下内外网IP地址若不填则柜台系统自动采集，若填写则以终端填值为准报送
            # login_req.MacAddress = '5C-87-9C-96-F3-E3'
            # login_req.InnerIPAddress = '10.0.1.102'
            # login_req.OuterIPAddress = '58.246.43.50'

            TradeSimpleApi.req_id += 1
            ret = api.ReqUserLogin(login_req, TradeSimpleApi.req_id)
            if ret != 0:
                logger.info('ReqUserLogin fail, ret[%d]' % ret)
        else:
            logger.info('GetConnectionInfo fail, [%d] [%d] [%s]!!!' % (
                nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspUserLogin(self, pRspUserLoginField: "CTORATstpRspUserLoginField", pRspInfoField: "CTORATstpRspInfoField",
                       nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('Login success! [%d]' % nRequestID)
            self.__front_id = pRspUserLoginField.FrontID
            self.__session_id = pRspUserLoginField.SessionID

            if 0:
                # 查询股东账号
                req_field = traderapi.CTORATstpQryShareholderAccountField()

                # 以下字段不填表示不设过滤条件，即查询所有股东账号
                # req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE

                TradeSimpleApi.req_id += 1
                ret = api.ReqQryShareholderAccount(req_field, TradeSimpleApi.req_id)
                if ret != 0:
                    logger.info('ReqQryShareholderAccount fail, ret[%d]' % ret)

            if 0:
                TradeSimpleApi().list_traded_orders()

            if 1:
                TradeSimpleApi().get_money_account()

        else:
            logger.info('Login fail!!! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspUserPasswordUpdate(self, pUserPasswordUpdateField: "CTORATstpUserPasswordUpdateField",
                                pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('OnRspUserPasswordUpdate: OK! [%d]' % nRequestID)
        else:
            logger.info('OnRspUserPasswordUpdate: Error! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspOrderInsert(self, pInputOrderField: "CTORATstpInputOrderField", pRspInfoField: "CTORATstpRspInfoField",
                         nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('[%d] OnRspOrderInsert: OK! [%d]' % (round(time.time() * 1000), nRequestID))
        else:
            logger.info('OnRspOrderInsert: Error! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
            self.__data_callback(TYPE_ORDER, nRequestID, {"sinfo": pInputOrderField.SInfo, "orderStatus": -1,
                                                          "orderStatusMsg": pRspInfoField.ErrorMsg})

    def OnRspOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField",
                         pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('OnRspOrderAction: OK! [%d]' % nRequestID)
            self.__data_callback(TYPE_CANCEL_ORDER, nRequestID, {"sinfo": pInputOrderActionField.SInfo,
                                                                 "orderSysID": pInputOrderActionField.OrderSysID,
                                                                 "cancel": 1})

        else:
            logger.info('OnRspOrderAction: Error! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
            self.__data_callback(TYPE_CANCEL_ORDER, nRequestID, {"sinfo": pInputOrderActionField.SInfo,
                                                                 "orderSysID": pInputOrderActionField.OrderSysID,
                                                                 "cancel": 0, "errorID": pRspInfoField.ErrorID,
                                                                 "errorMsg": pRspInfoField.ErrorMsg})

    def OnRspInquiryJZFund(self, pRspInquiryJZFundField: "CTORATstpRspInquiryJZFundField",
                           pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('OnRspInquiryJZFund: OK! [%d] [%.2f] [%.2f]'
                        % (nRequestID, pRspInquiryJZFundField.UsefulMoney, pRspInquiryJZFundField.FetchLimit))
        else:
            logger.info('OnRspInquiryJZFund: Error! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspTransferFund(self, pInputTransferFundField: "CTORATstpInputTransferFundField",
                          pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
        if pRspInfoField.ErrorID == 0:
            logger.info('OnRspTransferFund: OK! [%d]' % nRequestID)
        else:
            logger.info('OnRspTransferFund: Error! [%d] [%d] [%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRtnOrder(self, pOrderField: "CTORATstpOrderField") -> "void":
        logger_trade_debug.info(
            '[%d] OnRtnOrder: SInfo[%s] InvestorID[%s] SecurityID[%s] OrderRef[%d] OrderLocalID[%s] LimitPrice[%.2f] VolumeTotalOriginal[%d] OrderSysID[%s] OrderStatus[%s]'
            % (round(time.time() * 1000), pOrderField.SInfo, pOrderField.InvestorID, pOrderField.SecurityID,
               pOrderField.OrderRef, pOrderField.OrderLocalID,
               pOrderField.LimitPrice, pOrderField.VolumeTotalOriginal, pOrderField.OrderSysID,
               pOrderField.OrderStatus))
        if pOrderField.OrderStatus != traderapi.TORA_TSTP_OST_Unknown:
            self.__data_callback(TYPE_ORDER, 0, {"sinfo": pOrderField.SInfo, "securityId": pOrderField.SecurityID,
                                                 "orderLocalId": pOrderField.OrderLocalID,
                                                 "orderStatus": pOrderField.OrderStatus,
                                                 "statusMsg": pOrderField.StatusMsg,
                                                 "orderSysID": pOrderField.OrderSysID,
                                                 "accountID": pOrderField.AccountID})

    def OnRtnTrade(self, pTradeField: "CTORATstpTradeField") -> "void":
        logger_trade_debug.info(
            'OnRtnTrade: TradeID[%s] InvestorID[%s] SecurityID[%s] OrderRef[%d] OrderLocalID[%s] Price[%.2f] Volume[%d]'
            % (pTradeField.TradeID, pTradeField.InvestorID, pTradeField.SecurityID,
               pTradeField.OrderRef, pTradeField.OrderLocalID, pTradeField.Price, pTradeField.Volume))

    def OnRtnMarketStatus(self, pMarketStatusField: "CTORATstpMarketStatusField") -> "void":
        # TORA_TSTP_MKD_SHA(1): 上海A股
        # TORA_TSTP_MKD_SZA(2): 深圳A股
        # TORA_TSTP_MKD_BJMain(a):北京主板

        # TORA_TSTP_MST_UnKnown(  # ):未知
        # TORA_TSTP_MST_BeforeTrading(0): 开盘前
        # TORA_TSTP_MST_Continous(1): 连续交易
        # TORA_TSTP_MST_Closed(2): 收盘
        # TORA_TSTP_MST_OpenCallAuction(3): 开盘集合竞价
        logger.info('OnRtnMarketStatus: MarketID[%s] MarketStatus[%s]'
                    % (pMarketStatusField.MarketID, pMarketStatusField.MarketStatus))

    def OnRspQrySecurity(self, pSecurityField: "CTORATstpSecurityField", pRspInfoField: "CTORATstpRspInfoField",
                         nRequestID: "int", bIsLast: "bool") -> "void":
        if bIsLast != 1:
            logger.info(
                'OnRspQrySecurity[%d]: SecurityID[%s] SecurityName[%s] MarketID[%s] OrderUnit[%s] OpenDate[%s] UpperLimitPrice[%.2f] LowerLimitPrice[%.2f]'
                % (nRequestID, pSecurityField.SecurityID, pSecurityField.SecurityName, pSecurityField.MarketID,
                   pSecurityField.OrderUnit, pSecurityField.OpenDate, pSecurityField.UpperLimitPrice,
                   pSecurityField.LowerLimitPrice))
        else:
            logger.info('查询合约结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspQryInvestor(self, pInvestorField: "CTORATstpInvestorField", pRspInfoField: "CTORATstpRspInfoField",
                         nRequestID: "int", bIsLast: "bool") -> "void":
        if bIsLast != 1:
            logger.info('OnRspQryInvestor[%d]: InvestorID[%s] InvestorName[%s] Operways[%s]'
                        % (nRequestID, pInvestorField.InvestorID, pInvestorField.InvestorName,
                           pInvestorField.Operways))
        else:
            logger.info('查询投资者结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspQryShareholderAccount(self, pShareholderAccountField: "CTORATstpShareholderAccountField",
                                   pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int",
                                   bIsLast: "bool") -> "void":
        if bIsLast != 1:
            logger.info('OnRspQryShareholderAccount[%d]: InvestorID[%s] ExchangeID[%s] ShareholderID[%s]'
                        % (nRequestID, pShareholderAccountField.InvestorID, pShareholderAccountField.ExchangeID,
                           pShareholderAccountField.ShareholderID))
        else:
            logger.info('查询股东账户结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspQryTradingAccount(self, pTradingAccountField: "CTORATstpTradingAccountField",
                               pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
        if nRequestID not in self.__temp_money_account_list_dict:
            self.__temp_money_account_list_dict[nRequestID] = []
        if bIsLast != 1:
            self.__temp_money_account_list_dict[nRequestID].append(
                {"departmentID": pTradingAccountField.DepartmentID, "investorID": pTradingAccountField.InvestorID,
                 "accountID": pTradingAccountField.AccountID, "currencyID": pTradingAccountField.CurrencyID,
                 "usefulMoney": round(pTradingAccountField.UsefulMoney, 2),
                 "frozenCash": round(pTradingAccountField.FrozenCash, 2),
                 "fetchLimit": round(pTradingAccountField.FetchLimit, 2),
                 "preDeposit": round(pTradingAccountField.PreDeposit, 2)})
            logger.info(
                'OnRspQryTradingAccount[%d]: DepartmentID[%s] InvestorID[%s] AccountID[%s] CurrencyID[%s] UsefulMoney[%.2f] FetchLimit[%.2f]'
                % (nRequestID, pTradingAccountField.DepartmentID, pTradingAccountField.InvestorID,
                   pTradingAccountField.AccountID, pTradingAccountField.CurrencyID,
                   pTradingAccountField.UsefulMoney, pTradingAccountField.FetchLimit))
        else:
            results = self.__temp_money_account_list_dict.pop(nRequestID)
            self.__data_callback(TYPE_LIST_MONEY, nRequestID, results)
            logger.info('查询资金账号结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))

    def OnRspQryOrder(self, pOrderField: "CTORATstpOrderField", pRspInfoField: "CTORATstpRspInfoField",
                      nRequestID: "int", bIsLast: "bool") -> "void":
        print('查询报单回调', bIsLast)
        if nRequestID not in self.__temp_order_list_dict:
            self.__temp_order_list_dict[nRequestID] = []
        if not bIsLast:
            logger.info(
                'OnRspQryOrder[%d]: SecurityID[%s] OrderLocalID[%s] Direction[%s] OrderRef[%d] OrderSysID[%s] VolumeTraded[%d] OrderStatus[%s] OrderSubmitStatus[%s], StatusMsg[%s]'
                % (nRequestID, pOrderField.SecurityID, pOrderField.OrderLocalID, pOrderField.Direction,
                   pOrderField.OrderRef, pOrderField.OrderSysID,
                   pOrderField.VolumeTraded, pOrderField.OrderStatus, pOrderField.OrderSubmitStatus,
                   pOrderField.StatusMsg))
            self.__temp_order_list_dict[nRequestID].append(
                {"securityID": pOrderField.SecurityID, "orderLocalID": pOrderField.OrderLocalID,
                 "direction": pOrderField.Direction, "orderSysID": pOrderField.OrderSysID,
                 "insertTime": pOrderField.InsertTime, "insertDate": pOrderField.InsertDate,
                 "acceptTime": pOrderField.AcceptTime, "cancelTime": pOrderField.CancelTime,
                 "limitPrice": pOrderField.LimitPrice, "accountID": pOrderField.AccountID,
                 "turnover": pOrderField.Turnover,
                 "volume": pOrderField.VolumeTotalOriginal,
                 "volumeTraded": pOrderField.VolumeTraded, "orderStatus": pOrderField.OrderStatus,
                 "orderSubmitStatus": pOrderField.OrderSubmitStatus, "statusMsg": pOrderField.StatusMsg})

        else:
            logger.info('查询报单结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
            self.__data_callback(TYPE_LIST_DELEGATE, nRequestID, self.__temp_order_list_dict[nRequestID])
            self.__temp_order_list_dict.pop(nRequestID)

    def OnRspQryPosition(self, pPositionField: "CTORATstpPositionField", pRspInfoField: "CTORATstpRspInfoField",
                         nRequestID: "int", bIsLast: "bool") -> "void":
        if nRequestID not in self.__temp_position_list_dict:
            self.__temp_position_list_dict[nRequestID] = []
        if bIsLast != 1:
            self.__temp_position_list_dict[nRequestID].append(
                {"investorID": pPositionField.InvestorID, "tradingDay": pPositionField.TradingDay,
                 "securityName": pPositionField.SecurityName,
                 "securityID": pPositionField.SecurityID, "historyPos": pPositionField.HistoryPos,
                 "historyPosFrozen": pPositionField.HistoryPosFrozen,
                 "todayBSPos": pPositionField.TodayBSPos, "todayBSPosFrozen": pPositionField.TodayBSPosFrozen,
                 "historyPosPrice": pPositionField.HistoryPosPrice, "totalPosCost": pPositionField.TotalPosCost,
                 "prePosition": pPositionField.PrePosition, "availablePosition": pPositionField.AvailablePosition,
                 "currentPosition": pPositionField.CurrentPosition, "openPosCost": pPositionField.OpenPosCost,
                 "todayCommission": pPositionField.TodayCommission,
                 "todayTotalBuyAmount": pPositionField.TodayTotalBuyAmount,
                 "todayTotalSellAmount": pPositionField.TodayTotalSellAmount})
        else:
            logger.info('查询持仓结束[%d] ErrorID[%d] ErrorMsg[%s]'
                        % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
            self.__data_callback(TYPE_LIST_POSITION, nRequestID, self.__temp_position_list_dict[nRequestID])
            self.__temp_position_list_dict.pop(nRequestID)

    # 成交回报,参数pTradeField是一个CTORATstpTradeField类对象
    def OnRtnTrade(self, pTradeField: "CTORATstpTradeField") -> "void":
        logger.info("OnRtnTrade")

    # 查询成交响应,参数pTradeField是一个CTORATstpTradeField类对象
    def OnRspQryTrade(self, pTradeField: "CTORATstpTradeField", pRspInfoField: "CTORATstpRspInfoField",
                      nRequestID: "int", bIsLast: "bool") -> "void":
        logger.info("查询成交响应")
        if nRequestID not in self.__temp_order_list_dict:
            self.__temp_order_list_dict[nRequestID] = []
        if not bIsLast:
            self.__temp_order_list_dict[nRequestID].append(
                {"tradeID": pTradeField.TradeID, "securityID": pTradeField.SecurityID,
                 "orderLocalID": pTradeField.OrderLocalID,
                 "direction": pTradeField.Direction, "orderSysID": pTradeField.OrderSysID, "price": pTradeField.Price,
                 "tradeTime": pTradeField.TradeTime,
                 "volume": pTradeField.Volume, "tradeDate": pTradeField.TradeDate, "tradingDay": pTradeField.TradingDay,
                 "pbuID": pTradeField.PbuID, "accountID": pTradeField.AccountID})
        else:
            self.__data_callback(TYPE_LIST_TRADED, nRequestID, self.__temp_order_list_dict[nRequestID])
            self.__temp_order_list_dict.pop(nRequestID)


# 获取响应发送socket


global req_rid_dict
req_rid_dict = {}


class MyTradeActionCallback(command_manager.TradeActionCallback):
    __tradeSimpleApi = TradeSimpleApi()

    def OnTrade(self, client_id, request_id, type_, data):
        if type_ == 1:
            logger_trade_debug.info(f"---------------------\n请求下单：client_id-{client_id} request_id-{request_id}")
            # 下单
            # 1-买 2-卖
            direction = data["direction"]
            code = data["code"]
            volume = data["volume"]
            price = data["price"]
            sinfo = data["sinfo"]
            if direction == 1:
                # 买
                try:
                    req_rid_dict[sinfo] = (client_id, request_id)
                    self.__tradeSimpleApi.buy(code, volume, price, sinfo)
                except Exception as e:
                    send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_ORDER, client_id,
                                  request_id)

            elif direction == 2:
                try:
                    price_type = data["price_type"]
                    req_rid_dict[sinfo] = (client_id, request_id)
                    self.__tradeSimpleApi.sell(code, volume, price, price_type, sinfo)
                    print("sell", req_rid_dict)
                except Exception as e:
                    logging.exception(e)
                    send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_ORDER, client_id,
                                  request_id)

        elif type_ == 2:
            logger_trade_debug.info(
                f"---------------------\n请求撤单：client_id-{client_id} request_id-{request_id} data-{data}")
            # 撤单
            direction = data["direction"]
            code = data["code"]
            orderSysID = data["orderSysID"]
            sinfo = data["sinfo"]
            if direction == 1:
                # 撤买
                try:
                    req_rid_dict[sinfo] = (client_id, request_id)
                    self.__tradeSimpleApi.cancel_buy(code, orderSysID, sinfo)
                except Exception as e:
                    send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_CANCEL_ORDER, client_id,
                                  request_id)

            elif direction == 2:
                # 撤卖
                try:
                    req_rid_dict[sinfo] = (client_id, request_id)
                    self.__tradeSimpleApi.cancel_sell(code, orderSysID, sinfo)
                except Exception as e:
                    send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_CANCEL_ORDER, client_id,
                                  request_id)

    def OnDealList(self, client_id, request_id):
        logger_trade_debug.info(f"请求成交列表：client_id-{client_id} request_id-{request_id}")
        try:
            print("开始请求成交列表")
            req_id = self.__tradeSimpleApi.list_traded_orders()
            req_rid_dict[req_id] = (client_id, request_id)
        except Exception as e:
            logging.exception(e)
            SendResponseSkManager.send_error_response("common", request_id, client_id, str(e))

    def OnDelegateList(self, client_id, request_id, is_cancel):
        logger_trade_debug.info(f"请求委托列表：client_id-{client_id} request_id-{request_id}")
        try:
            req_id = self.__tradeSimpleApi.list_delegate_orders(is_cancel)
            req_rid_dict[req_id] = (client_id, request_id)
        except Exception as e:
            send_response(json.dumps({"code": 1, "msg": str(e)}), "common", client_id,
                          request_id)

    def OnMoney(self, client_id, request_id):
        logger_trade_debug.info(f"请求账户：client_id-{client_id} request_id-{request_id}")
        try:
            req_id = self.__tradeSimpleApi.get_money_account()
            req_rid_dict[req_id] = (client_id, request_id)
        except Exception as e:
            send_response(json.dumps({"code": 1, "msg": str(e)}), "common", client_id,
                          request_id)

    def OnPositionList(self, client_id, request_id):
        logger_trade_debug.info(f"请求持仓：client_id-{client_id} request_id-{request_id}")
        try:
            req_id = self.__tradeSimpleApi.list_positions()
            req_rid_dict[req_id] = (client_id, request_id)
        except Exception as e:
            send_response(json.dumps({"code": 1, "msg": str(e)}), "common", client_id,
                          request_id)


def __init_trade_data_server():
    logger.info("初始化交易服务器")
    global api
    api = traderapi.CTORATstpTraderApi.CreateTstpTraderApi('./flow', False)
    # 创建回调对象
    global spi
    spi = TraderSpi(traderapi_callback)
    # 注册回调接口
    api.RegisterSpi(spi)

    # 注册多个交易前置服务地址，用逗号隔开
    # api.RegisterFront('tcp://10.0.1.101:6500,tcp://10.0.1.101:26500')
    # 注册名字服务器地址，支持多服务地址逗号隔开
    # api.RegisterNameServer('tcp://10.0.1.101:52370')
    # api.RegisterNameServer('tcp://10.0.1.101:52370,tcp://10.0.1.101:62370')

    if 1:  # 模拟环境，TCP 直连Front方式
        # 注册单个交易前置服务地址

        api.RegisterFront("tcp://192.168.84.31:6500")  # 正式环境主地址
        api.RegisterFront("tcp://192.168.84.32:26500")  # 正式环境备用地址

        # TD_TCP_FrontAddress = "tcp://210.14.72.21:4400"  # 仿真交易环境
        # TD_TCP_FrontAddress = "tcp://210.14.72.15:4400"  # 24小时环境A套
        # TD_TCP_FrontAddress="tcp://210.14.72.16:9500" #24小时环境B套
        # api.RegisterFront(TD_TCP_FrontAddress)
        # 注册多个交易前置服务地址，用逗号隔开 形如: api.RegisterFront("tcp://10.0.1.101:6500,tcp://10.0.1.101:26500")
        # print("TD_TCP_FensAddress[sim or 24H]::%s\n" % TD_TCP_FrontAddress)

    else:  # 模拟环境，FENS名字服务器方式
        TD_TCP_FensAddress = "tcp://210.14.72.21:42370";  # 模拟环境通用fens地址
        '''********************************************************************************
            * 注册 fens 地址前还需注册 fens 用户信息，包括环境编号、节点编号、Fens 用户代码等信息
            * 使用名字服务器的好处是当券商系统部署方式发生调整时外围终端无需做任何前置地址修改
            * *****************************************************************************'''
        fens_user_info_field = traderapi.CTORATstpFensUserInfoField()
        fens_user_info_field.FensEnvID = "stock"  # 必填项，暂时固定为“stock”表示普通现货柜台
        fens_user_info_field.FensNodeID = "sim"  # 必填项，生产环境需按实际填写,仿真环境为sim
        fens_user_info_field.FensNodeID, = "24a"  # 必填项，生产环境需按实际填写,24小时A套环境为24a
        # fens_user_info_field.FensNodeID="24b" #必填项，生产环境需按实际填写,24小时B套环境为24b
        api.RegisterFensUserInfo(fens_user_info_field)
        api.RegisterNameServer(TD_TCP_FensAddress)
        # 注册名字服务器地址，支持多服务地址逗号隔开 形如:api.RegisterNameServer('tcp://10.0.1.101:52370,tcp://10.0.1.101:62370')
        print("TD_TCP_FensAddress[%s]::%s\n" % (fens_user_info_field.FensNodeID, TD_TCP_FensAddress))

    # 订阅私有流
    api.SubscribePrivateTopic(traderapi.TORA_TERT_QUICK)
    # 订阅公有流
    api.SubscribePublicTopic(traderapi.TORA_TERT_QUICK)
    # 启动接口
    api.Init()


def __send_response(type, data_bytes):
    sk = SendResponseSkManager.create_send_response_sk()
    try:
        data_bytes = socket_util.load_header(data_bytes)
        sk.sendall(data_bytes)
        result, header_str = socket_util.recv_data(sk)
        result = json.loads(result)
        if result["code"] != 0:
            raise Exception(result['msg'])
    finally:
        sk.close()


def send_response(data, type, _client_id, _request_id):
    strategy_pipe.send(data)


# 交易反馈回调
def __traderapi_callback(type, req_id, data):
    logger_trade_debug.info("回调:type-{} req_id-{}", type, req_id)
    key = req_id
    if type == TYPE_ORDER or type == TYPE_CANCEL_ORDER:
        key = data["sinfo"]
    try:
        print("traderapi_callback", req_rid_dict)
        if req_rid_dict and key in req_rid_dict:
            print("API回调")
            client_id, request_id = req_rid_dict.pop(key)
            logger_trade_debug.info("API回调 request_id-{}", request_id)
            # 测试
            send_response(
                json.dumps({"type": "response", "data": {"code": 0, "data": data}, "client_id": client_id,
                            "request_id": request_id}), type, client_id, request_id)
            logger_trade_debug.info("API回调结束 req_id-{} request_id-{}", req_id, request_id)
            print("API回调结束")
        else:
            logger_trade_debug.info("非API回调 req_id-{}", req_id)
            print("非API回调")
            # 非API回调
            send_response(
                json.dumps({"type": "trade_callback", "data": {"code": 0, "data": data, "type": type}}),
                type,
                None,
                req_id)
            print("非API结束")
    except Exception as e:
        logging.exception(e)


# 采用异步回调
def traderapi_callback(type, req_id, data):
    t1 = threading.Thread(target=lambda: __traderapi_callback(type, req_id, data), daemon=True)
    t1.start()


addr, port = constant.SERVER_IP, constant.SERVER_PORT


def run(pipe_l2=None, pipe_strategy=None):
    __init_trade_data_server()
    global l2pipe
    l2pipe = pipe_l2

    global strategy_pipe
    strategy_pipe = pipe_strategy


    global tradeCommandManager
    tradeCommandManager = command_manager.TradeCommandManager()
    tradeCommandManager.init(MyTradeActionCallback(), l2pipe, pipe_strategy)
    tradeCommandManager.run()
    print("trade_client启动成功")


if __name__ == "__main__":
    # 测试
    # try:
    #     ip_port = ("127.0.0.1", 10008)  # server地址和端口号（最好是10000以后）
    #     client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)  # 生成socket，连接server
    #     client.connect(ip_port)
    #     client.sendall("111111111111111111111111111111111111111".encode("utf-8"))
    # except Exception as e:
    #     logging.exception(e)
    #     print("远程服务器访问失败", str(e))
    #
    # while True:
    #     time.sleep(1)

    run()
    input()

 huaxin/traderapi.py

New file
Diff too large

 huaxin/xmdapi.py

New file
@@ -0,0 +1,924 @@
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _xmdapi
else:
    import _xmdapi

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref


def set_null(*args):
    return _xmdapi.set_null(*args)

def is_null(*args):
    return _xmdapi.is_null(*args)
TORA_TERT_RESTART = _xmdapi.TORA_TERT_RESTART
TORA_TERT_RESUME = _xmdapi.TORA_TERT_RESUME
TORA_TERT_QUICK = _xmdapi.TORA_TERT_QUICK
class CTORATstpReqUserLoginField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LogInAccount = property(_xmdapi.CTORATstpReqUserLoginField_LogInAccount_get, _xmdapi.CTORATstpReqUserLoginField_LogInAccount_set)
    LogInAccountType = property(_xmdapi.CTORATstpReqUserLoginField_LogInAccountType_get, _xmdapi.CTORATstpReqUserLoginField_LogInAccountType_set)
    DepartmentID = property(_xmdapi.CTORATstpReqUserLoginField_DepartmentID_get, _xmdapi.CTORATstpReqUserLoginField_DepartmentID_set)
    AuthMode = property(_xmdapi.CTORATstpReqUserLoginField_AuthMode_get, _xmdapi.CTORATstpReqUserLoginField_AuthMode_set)
    Password = property(_xmdapi.CTORATstpReqUserLoginField_Password_get, _xmdapi.CTORATstpReqUserLoginField_Password_set)
    UserProductInfo = property(_xmdapi.CTORATstpReqUserLoginField_UserProductInfo_get, _xmdapi.CTORATstpReqUserLoginField_UserProductInfo_set)
    InterfaceProductInfo = property(_xmdapi.CTORATstpReqUserLoginField_InterfaceProductInfo_get, _xmdapi.CTORATstpReqUserLoginField_InterfaceProductInfo_set)
    TerminalInfo = property(_xmdapi.CTORATstpReqUserLoginField_TerminalInfo_get, _xmdapi.CTORATstpReqUserLoginField_TerminalInfo_set)
    InnerIPAddress = property(_xmdapi.CTORATstpReqUserLoginField_InnerIPAddress_get, _xmdapi.CTORATstpReqUserLoginField_InnerIPAddress_set)
    OuterIPAddress = property(_xmdapi.CTORATstpReqUserLoginField_OuterIPAddress_get, _xmdapi.CTORATstpReqUserLoginField_OuterIPAddress_set)
    MacAddress = property(_xmdapi.CTORATstpReqUserLoginField_MacAddress_get, _xmdapi.CTORATstpReqUserLoginField_MacAddress_set)
    Lang = property(_xmdapi.CTORATstpReqUserLoginField_Lang_get, _xmdapi.CTORATstpReqUserLoginField_Lang_set)
    DynamicPassword = property(_xmdapi.CTORATstpReqUserLoginField_DynamicPassword_get, _xmdapi.CTORATstpReqUserLoginField_DynamicPassword_set)
    DeviceID = property(_xmdapi.CTORATstpReqUserLoginField_DeviceID_get, _xmdapi.CTORATstpReqUserLoginField_DeviceID_set)
    CertSerial = property(_xmdapi.CTORATstpReqUserLoginField_CertSerial_get, _xmdapi.CTORATstpReqUserLoginField_CertSerial_set)
    DeviceType = property(_xmdapi.CTORATstpReqUserLoginField_DeviceType_get, _xmdapi.CTORATstpReqUserLoginField_DeviceType_set)

    def __init__(self):
        _xmdapi.CTORATstpReqUserLoginField_swiginit(self, _xmdapi.new_CTORATstpReqUserLoginField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpReqUserLoginField

# Register CTORATstpReqUserLoginField in _xmdapi:
_xmdapi.CTORATstpReqUserLoginField_swigregister(CTORATstpReqUserLoginField)
cvar = _xmdapi.cvar
INT_NULL_VAL = cvar.INT_NULL_VAL
FLOAT_NULL_VAL = cvar.FLOAT_NULL_VAL
CHAR_NULL_VAL = cvar.CHAR_NULL_VAL
WORD_NULL_VAL = cvar.WORD_NULL_VAL
LONG_NULL_VAL = cvar.LONG_NULL_VAL
TORA_TSTP_LACT_UserID = cvar.TORA_TSTP_LACT_UserID
TORA_TSTP_LACT_AccountID = cvar.TORA_TSTP_LACT_AccountID
TORA_TSTP_LACT_SHAStock = cvar.TORA_TSTP_LACT_SHAStock
TORA_TSTP_LACT_SZAStock = cvar.TORA_TSTP_LACT_SZAStock
TORA_TSTP_LACT_SHBStock = cvar.TORA_TSTP_LACT_SHBStock
TORA_TSTP_LACT_SZBStock = cvar.TORA_TSTP_LACT_SZBStock
TORA_TSTP_LACT_ThreeNewBoardA = cvar.TORA_TSTP_LACT_ThreeNewBoardA
TORA_TSTP_LACT_ThreeNewBoardB = cvar.TORA_TSTP_LACT_ThreeNewBoardB
TORA_TSTP_LACT_HKStock = cvar.TORA_TSTP_LACT_HKStock
TORA_TSTP_LACT_UnifiedUserID = cvar.TORA_TSTP_LACT_UnifiedUserID
TORA_TSTP_AM_Password = cvar.TORA_TSTP_AM_Password
TORA_TSTP_AM_FingerPrint = cvar.TORA_TSTP_AM_FingerPrint
TORA_TSTP_AM_CertInfo = cvar.TORA_TSTP_AM_CertInfo
TORA_TSTP_LGT_ZHCN = cvar.TORA_TSTP_LGT_ZHCN
TORA_TSTP_LGT_ZHHK = cvar.TORA_TSTP_LGT_ZHHK
TORA_TSTP_LGT_ENUS = cvar.TORA_TSTP_LGT_ENUS
TORA_TSTP_DT_PC = cvar.TORA_TSTP_DT_PC
TORA_TSTP_DT_Mobile = cvar.TORA_TSTP_DT_Mobile
TORA_TSTP_UTYPE_BrokerUser = cvar.TORA_TSTP_UTYPE_BrokerUser
TORA_TSTP_UTYPE_SuperUser = cvar.TORA_TSTP_UTYPE_SuperUser
TORA_TSTP_UTYPE_Investor = cvar.TORA_TSTP_UTYPE_Investor
TORA_TSTP_EXD_SSE = cvar.TORA_TSTP_EXD_SSE
TORA_TSTP_EXD_SZSE = cvar.TORA_TSTP_EXD_SZSE
TORA_TSTP_EXD_HK = cvar.TORA_TSTP_EXD_HK
TORA_TSTP_EXD_BSE = cvar.TORA_TSTP_EXD_BSE
TORA_TSTP_MKD_SHA = cvar.TORA_TSTP_MKD_SHA
TORA_TSTP_MKD_SZA = cvar.TORA_TSTP_MKD_SZA
TORA_TSTP_MKD_SHB = cvar.TORA_TSTP_MKD_SHB
TORA_TSTP_MKD_SZB = cvar.TORA_TSTP_MKD_SZB
TORA_TSTP_MKD_SZThreeA = cvar.TORA_TSTP_MKD_SZThreeA
TORA_TSTP_MKD_SZThreeB = cvar.TORA_TSTP_MKD_SZThreeB
TORA_TSTP_MKD_Foreign = cvar.TORA_TSTP_MKD_Foreign
TORA_TSTP_MKD_SZHK = cvar.TORA_TSTP_MKD_SZHK
TORA_TSTP_MKD_SHHK = cvar.TORA_TSTP_MKD_SHHK
TORA_TSTP_MKD_BJMain = cvar.TORA_TSTP_MKD_BJMain
TORA_TSTP_MSST_PreOpen = cvar.TORA_TSTP_MSST_PreOpen
TORA_TSTP_MSST_CallAuction = cvar.TORA_TSTP_MSST_CallAuction
TORA_TSTP_MSST_Continous = cvar.TORA_TSTP_MSST_Continous
TORA_TSTP_MSST_Pause = cvar.TORA_TSTP_MSST_Pause
TORA_TSTP_MSST_Suspend = cvar.TORA_TSTP_MSST_Suspend
TORA_TSTP_MSST_LongSuspend = cvar.TORA_TSTP_MSST_LongSuspend
TORA_TSTP_MSST_UndulationInt = cvar.TORA_TSTP_MSST_UndulationInt
TORA_TSTP_MSST_CircuitBreak = cvar.TORA_TSTP_MSST_CircuitBreak
TORA_TSTP_MSST_CircuitBreakU = cvar.TORA_TSTP_MSST_CircuitBreakU
TORA_TSTP_MSST_Close = cvar.TORA_TSTP_MSST_Close
TORA_TSTP_MSST_Other = cvar.TORA_TSTP_MSST_Other
TORA_TSTP_MSST_CloseCallAuction = cvar.TORA_TSTP_MSST_CloseCallAuction
TORA_TSTP_MSST_CallMatch = cvar.TORA_TSTP_MSST_CallMatch
TORA_TSTP_MSST_PostContinous = cvar.TORA_TSTP_MSST_PostContinous
TORA_TSTP_MSST_PostClose = cvar.TORA_TSTP_MSST_PostClose
TORA_TSTP_MSST_PrePostOpen = cvar.TORA_TSTP_MSST_PrePostOpen
TORA_TSTP_EF_ToBeContinued = cvar.TORA_TSTP_EF_ToBeContinued
TORA_TSTP_EF_BatchEnd = cvar.TORA_TSTP_EF_BatchEnd
TORA_TSTP_EF_Completed = cvar.TORA_TSTP_EF_Completed
TORA_TSTP_EF_NOP = cvar.TORA_TSTP_EF_NOP
TORA_TSTP_MST_UnKnown = cvar.TORA_TSTP_MST_UnKnown
TORA_TSTP_MST_BeforeTrading = cvar.TORA_TSTP_MST_BeforeTrading
TORA_TSTP_MST_Continous = cvar.TORA_TSTP_MST_Continous
TORA_TSTP_MST_Closed = cvar.TORA_TSTP_MST_Closed
TORA_TSTP_MST_OpenCallAuction = cvar.TORA_TSTP_MST_OpenCallAuction
TORA_TSTP_MST_SZSEHKUnopened = cvar.TORA_TSTP_MST_SZSEHKUnopened
TORA_TSTP_MST_SZSEHKOpenCallAuctionInput = cvar.TORA_TSTP_MST_SZSEHKOpenCallAuctionInput
TORA_TSTP_MST_SZSEHKOpenCallAuctionBeforeMatch = cvar.TORA_TSTP_MST_SZSEHKOpenCallAuctionBeforeMatch
TORA_TSTP_MST_SZSEHKOpenCallAuctionMatch = cvar.TORA_TSTP_MST_SZSEHKOpenCallAuctionMatch
TORA_TSTP_MST_SZSEHKHalt = cvar.TORA_TSTP_MST_SZSEHKHalt
TORA_TSTP_MST_SZSEHKContinous = cvar.TORA_TSTP_MST_SZSEHKContinous
TORA_TSTP_MST_SZSEHKExchangeIntervention = cvar.TORA_TSTP_MST_SZSEHKExchangeIntervention
TORA_TSTP_MST_SZSEHKCloseCallAuctionReferencePrice = cvar.TORA_TSTP_MST_SZSEHKCloseCallAuctionReferencePrice
TORA_TSTP_MST_SZSEHKCloseCallAuctionInput = cvar.TORA_TSTP_MST_SZSEHKCloseCallAuctionInput
TORA_TSTP_MST_SZSEHKCloseCallAuctionCannotCancel = cvar.TORA_TSTP_MST_SZSEHKCloseCallAuctionCannotCancel
TORA_TSTP_MST_SZSEHKCloseCallAuctionMatch = cvar.TORA_TSTP_MST_SZSEHKCloseCallAuctionMatch
TORA_TSTP_MST_SZSEHKCloseCallAuctionRandomClosed = cvar.TORA_TSTP_MST_SZSEHKCloseCallAuctionRandomClosed
TORA_TSTP_MST_SZSEHKCancel = cvar.TORA_TSTP_MST_SZSEHKCancel
TORA_TSTP_MST_SZSEHKClosed = cvar.TORA_TSTP_MST_SZSEHKClosed
TORA_TSTP_MST_SZSEHKWholeClosed = cvar.TORA_TSTP_MST_SZSEHKWholeClosed
TORA_TSTP_MST_TCP = cvar.TORA_TSTP_MST_TCP
TORA_TSTP_MST_UDP = cvar.TORA_TSTP_MST_UDP
TORA_TSTP_MST_MCAST = cvar.TORA_TSTP_MST_MCAST

class CTORATstpRspUserLoginField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DepartmentID = property(_xmdapi.CTORATstpRspUserLoginField_DepartmentID_get, _xmdapi.CTORATstpRspUserLoginField_DepartmentID_set)
    LogInAccount = property(_xmdapi.CTORATstpRspUserLoginField_LogInAccount_get, _xmdapi.CTORATstpRspUserLoginField_LogInAccount_set)
    LogInAccountType = property(_xmdapi.CTORATstpRspUserLoginField_LogInAccountType_get, _xmdapi.CTORATstpRspUserLoginField_LogInAccountType_set)
    FrontID = property(_xmdapi.CTORATstpRspUserLoginField_FrontID_get, _xmdapi.CTORATstpRspUserLoginField_FrontID_set)
    SessionID = property(_xmdapi.CTORATstpRspUserLoginField_SessionID_get, _xmdapi.CTORATstpRspUserLoginField_SessionID_set)
    MaxOrderRef = property(_xmdapi.CTORATstpRspUserLoginField_MaxOrderRef_get, _xmdapi.CTORATstpRspUserLoginField_MaxOrderRef_set)
    PrivateFlowCount = property(_xmdapi.CTORATstpRspUserLoginField_PrivateFlowCount_get, _xmdapi.CTORATstpRspUserLoginField_PrivateFlowCount_set)
    PublicFlowCount = property(_xmdapi.CTORATstpRspUserLoginField_PublicFlowCount_get, _xmdapi.CTORATstpRspUserLoginField_PublicFlowCount_set)
    LoginTime = property(_xmdapi.CTORATstpRspUserLoginField_LoginTime_get, _xmdapi.CTORATstpRspUserLoginField_LoginTime_set)
    SystemName = property(_xmdapi.CTORATstpRspUserLoginField_SystemName_get, _xmdapi.CTORATstpRspUserLoginField_SystemName_set)
    TradingDay = property(_xmdapi.CTORATstpRspUserLoginField_TradingDay_get, _xmdapi.CTORATstpRspUserLoginField_TradingDay_set)
    UserID = property(_xmdapi.CTORATstpRspUserLoginField_UserID_get, _xmdapi.CTORATstpRspUserLoginField_UserID_set)
    UserName = property(_xmdapi.CTORATstpRspUserLoginField_UserName_get, _xmdapi.CTORATstpRspUserLoginField_UserName_set)
    UserType = property(_xmdapi.CTORATstpRspUserLoginField_UserType_get, _xmdapi.CTORATstpRspUserLoginField_UserType_set)
    OrderInsertCommFlux = property(_xmdapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_get, _xmdapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_set)
    OrderActionCommFlux = property(_xmdapi.CTORATstpRspUserLoginField_OrderActionCommFlux_get, _xmdapi.CTORATstpRspUserLoginField_OrderActionCommFlux_set)
    PasswordExpiryDate = property(_xmdapi.CTORATstpRspUserLoginField_PasswordExpiryDate_get, _xmdapi.CTORATstpRspUserLoginField_PasswordExpiryDate_set)
    NeedUpdatePassword = property(_xmdapi.CTORATstpRspUserLoginField_NeedUpdatePassword_get, _xmdapi.CTORATstpRspUserLoginField_NeedUpdatePassword_set)
    CertSerial = property(_xmdapi.CTORATstpRspUserLoginField_CertSerial_get, _xmdapi.CTORATstpRspUserLoginField_CertSerial_set)
    InnerIPAddress = property(_xmdapi.CTORATstpRspUserLoginField_InnerIPAddress_get, _xmdapi.CTORATstpRspUserLoginField_InnerIPAddress_set)
    OuterIPAddress = property(_xmdapi.CTORATstpRspUserLoginField_OuterIPAddress_get, _xmdapi.CTORATstpRspUserLoginField_OuterIPAddress_set)
    MacAddress = property(_xmdapi.CTORATstpRspUserLoginField_MacAddress_get, _xmdapi.CTORATstpRspUserLoginField_MacAddress_set)

    def __init__(self):
        _xmdapi.CTORATstpRspUserLoginField_swiginit(self, _xmdapi.new_CTORATstpRspUserLoginField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpRspUserLoginField

# Register CTORATstpRspUserLoginField in _xmdapi:
_xmdapi.CTORATstpRspUserLoginField_swigregister(CTORATstpRspUserLoginField)

class CTORATstpRspInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ErrorID = property(_xmdapi.CTORATstpRspInfoField_ErrorID_get, _xmdapi.CTORATstpRspInfoField_ErrorID_set)
    ErrorMsg = property(_xmdapi.CTORATstpRspInfoField_ErrorMsg_get, _xmdapi.CTORATstpRspInfoField_ErrorMsg_set)

    def __init__(self):
        _xmdapi.CTORATstpRspInfoField_swiginit(self, _xmdapi.new_CTORATstpRspInfoField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpRspInfoField

# Register CTORATstpRspInfoField in _xmdapi:
_xmdapi.CTORATstpRspInfoField_swigregister(CTORATstpRspInfoField)

class CTORATstpUserLogoutField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UserID = property(_xmdapi.CTORATstpUserLogoutField_UserID_get, _xmdapi.CTORATstpUserLogoutField_UserID_set)

    def __init__(self):
        _xmdapi.CTORATstpUserLogoutField_swiginit(self, _xmdapi.new_CTORATstpUserLogoutField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpUserLogoutField

# Register CTORATstpUserLogoutField in _xmdapi:
_xmdapi.CTORATstpUserLogoutField_swigregister(CTORATstpUserLogoutField)

class CTORATstpSpecificSecurityField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_xmdapi.CTORATstpSpecificSecurityField_ExchangeID_get, _xmdapi.CTORATstpSpecificSecurityField_ExchangeID_set)
    SecurityID = property(_xmdapi.CTORATstpSpecificSecurityField_SecurityID_get, _xmdapi.CTORATstpSpecificSecurityField_SecurityID_set)

    def __init__(self):
        _xmdapi.CTORATstpSpecificSecurityField_swiginit(self, _xmdapi.new_CTORATstpSpecificSecurityField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpSpecificSecurityField

# Register CTORATstpSpecificSecurityField in _xmdapi:
_xmdapi.CTORATstpSpecificSecurityField_swigregister(CTORATstpSpecificSecurityField)

class CTORATstpSpecificMarketField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MarketID = property(_xmdapi.CTORATstpSpecificMarketField_MarketID_get, _xmdapi.CTORATstpSpecificMarketField_MarketID_set)

    def __init__(self):
        _xmdapi.CTORATstpSpecificMarketField_swiginit(self, _xmdapi.new_CTORATstpSpecificMarketField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpSpecificMarketField

# Register CTORATstpSpecificMarketField in _xmdapi:
_xmdapi.CTORATstpSpecificMarketField_swigregister(CTORATstpSpecificMarketField)

class CTORATstpInquiryMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_xmdapi.CTORATstpInquiryMarketDataField_ExchangeID_get, _xmdapi.CTORATstpInquiryMarketDataField_ExchangeID_set)
    SecurityID = property(_xmdapi.CTORATstpInquiryMarketDataField_SecurityID_get, _xmdapi.CTORATstpInquiryMarketDataField_SecurityID_set)

    def __init__(self):
        _xmdapi.CTORATstpInquiryMarketDataField_swiginit(self, _xmdapi.new_CTORATstpInquiryMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpInquiryMarketDataField

# Register CTORATstpInquiryMarketDataField in _xmdapi:
_xmdapi.CTORATstpInquiryMarketDataField_swigregister(CTORATstpInquiryMarketDataField)

class CTORATstpMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TradingDay = property(_xmdapi.CTORATstpMarketDataField_TradingDay_get, _xmdapi.CTORATstpMarketDataField_TradingDay_set)
    SecurityID = property(_xmdapi.CTORATstpMarketDataField_SecurityID_get, _xmdapi.CTORATstpMarketDataField_SecurityID_set)
    ExchangeID = property(_xmdapi.CTORATstpMarketDataField_ExchangeID_get, _xmdapi.CTORATstpMarketDataField_ExchangeID_set)
    SecurityName = property(_xmdapi.CTORATstpMarketDataField_SecurityName_get, _xmdapi.CTORATstpMarketDataField_SecurityName_set)
    PreClosePrice = property(_xmdapi.CTORATstpMarketDataField_PreClosePrice_get, _xmdapi.CTORATstpMarketDataField_PreClosePrice_set)
    OpenPrice = property(_xmdapi.CTORATstpMarketDataField_OpenPrice_get, _xmdapi.CTORATstpMarketDataField_OpenPrice_set)
    Volume = property(_xmdapi.CTORATstpMarketDataField_Volume_get, _xmdapi.CTORATstpMarketDataField_Volume_set)
    Turnover = property(_xmdapi.CTORATstpMarketDataField_Turnover_get, _xmdapi.CTORATstpMarketDataField_Turnover_set)
    TradingCount = property(_xmdapi.CTORATstpMarketDataField_TradingCount_get, _xmdapi.CTORATstpMarketDataField_TradingCount_set)
    LastPrice = property(_xmdapi.CTORATstpMarketDataField_LastPrice_get, _xmdapi.CTORATstpMarketDataField_LastPrice_set)
    HighestPrice = property(_xmdapi.CTORATstpMarketDataField_HighestPrice_get, _xmdapi.CTORATstpMarketDataField_HighestPrice_set)
    LowestPrice = property(_xmdapi.CTORATstpMarketDataField_LowestPrice_get, _xmdapi.CTORATstpMarketDataField_LowestPrice_set)
    BidPrice1 = property(_xmdapi.CTORATstpMarketDataField_BidPrice1_get, _xmdapi.CTORATstpMarketDataField_BidPrice1_set)
    AskPrice1 = property(_xmdapi.CTORATstpMarketDataField_AskPrice1_get, _xmdapi.CTORATstpMarketDataField_AskPrice1_set)
    UpperLimitPrice = property(_xmdapi.CTORATstpMarketDataField_UpperLimitPrice_get, _xmdapi.CTORATstpMarketDataField_UpperLimitPrice_set)
    LowerLimitPrice = property(_xmdapi.CTORATstpMarketDataField_LowerLimitPrice_get, _xmdapi.CTORATstpMarketDataField_LowerLimitPrice_set)
    PERatio1 = property(_xmdapi.CTORATstpMarketDataField_PERatio1_get, _xmdapi.CTORATstpMarketDataField_PERatio1_set)
    PERatio2 = property(_xmdapi.CTORATstpMarketDataField_PERatio2_get, _xmdapi.CTORATstpMarketDataField_PERatio2_set)
    PriceUpDown1 = property(_xmdapi.CTORATstpMarketDataField_PriceUpDown1_get, _xmdapi.CTORATstpMarketDataField_PriceUpDown1_set)
    PriceUpDown2 = property(_xmdapi.CTORATstpMarketDataField_PriceUpDown2_get, _xmdapi.CTORATstpMarketDataField_PriceUpDown2_set)
    OpenInterest = property(_xmdapi.CTORATstpMarketDataField_OpenInterest_get, _xmdapi.CTORATstpMarketDataField_OpenInterest_set)
    BidVolume1 = property(_xmdapi.CTORATstpMarketDataField_BidVolume1_get, _xmdapi.CTORATstpMarketDataField_BidVolume1_set)
    AskVolume1 = property(_xmdapi.CTORATstpMarketDataField_AskVolume1_get, _xmdapi.CTORATstpMarketDataField_AskVolume1_set)
    BidPrice2 = property(_xmdapi.CTORATstpMarketDataField_BidPrice2_get, _xmdapi.CTORATstpMarketDataField_BidPrice2_set)
    BidVolume2 = property(_xmdapi.CTORATstpMarketDataField_BidVolume2_get, _xmdapi.CTORATstpMarketDataField_BidVolume2_set)
    AskPrice2 = property(_xmdapi.CTORATstpMarketDataField_AskPrice2_get, _xmdapi.CTORATstpMarketDataField_AskPrice2_set)
    AskVolume2 = property(_xmdapi.CTORATstpMarketDataField_AskVolume2_get, _xmdapi.CTORATstpMarketDataField_AskVolume2_set)
    BidPrice3 = property(_xmdapi.CTORATstpMarketDataField_BidPrice3_get, _xmdapi.CTORATstpMarketDataField_BidPrice3_set)
    BidVolume3 = property(_xmdapi.CTORATstpMarketDataField_BidVolume3_get, _xmdapi.CTORATstpMarketDataField_BidVolume3_set)
    AskPrice3 = property(_xmdapi.CTORATstpMarketDataField_AskPrice3_get, _xmdapi.CTORATstpMarketDataField_AskPrice3_set)
    AskVolume3 = property(_xmdapi.CTORATstpMarketDataField_AskVolume3_get, _xmdapi.CTORATstpMarketDataField_AskVolume3_set)
    BidPrice4 = property(_xmdapi.CTORATstpMarketDataField_BidPrice4_get, _xmdapi.CTORATstpMarketDataField_BidPrice4_set)
    BidVolume4 = property(_xmdapi.CTORATstpMarketDataField_BidVolume4_get, _xmdapi.CTORATstpMarketDataField_BidVolume4_set)
    AskPrice4 = property(_xmdapi.CTORATstpMarketDataField_AskPrice4_get, _xmdapi.CTORATstpMarketDataField_AskPrice4_set)
    AskVolume4 = property(_xmdapi.CTORATstpMarketDataField_AskVolume4_get, _xmdapi.CTORATstpMarketDataField_AskVolume4_set)
    BidPrice5 = property(_xmdapi.CTORATstpMarketDataField_BidPrice5_get, _xmdapi.CTORATstpMarketDataField_BidPrice5_set)
    BidVolume5 = property(_xmdapi.CTORATstpMarketDataField_BidVolume5_get, _xmdapi.CTORATstpMarketDataField_BidVolume5_set)
    AskPrice5 = property(_xmdapi.CTORATstpMarketDataField_AskPrice5_get, _xmdapi.CTORATstpMarketDataField_AskPrice5_set)
    AskVolume5 = property(_xmdapi.CTORATstpMarketDataField_AskVolume5_get, _xmdapi.CTORATstpMarketDataField_AskVolume5_set)
    UpdateTime = property(_xmdapi.CTORATstpMarketDataField_UpdateTime_get, _xmdapi.CTORATstpMarketDataField_UpdateTime_set)
    UpdateMillisec = property(_xmdapi.CTORATstpMarketDataField_UpdateMillisec_get, _xmdapi.CTORATstpMarketDataField_UpdateMillisec_set)
    ClosePrice = property(_xmdapi.CTORATstpMarketDataField_ClosePrice_get, _xmdapi.CTORATstpMarketDataField_ClosePrice_set)
    SettlementPrice = property(_xmdapi.CTORATstpMarketDataField_SettlementPrice_get, _xmdapi.CTORATstpMarketDataField_SettlementPrice_set)
    MDSecurityStat = property(_xmdapi.CTORATstpMarketDataField_MDSecurityStat_get, _xmdapi.CTORATstpMarketDataField_MDSecurityStat_set)
    HWLevel = property(_xmdapi.CTORATstpMarketDataField_HWLevel_get, _xmdapi.CTORATstpMarketDataField_HWLevel_set)
    PreCloseIOPV = property(_xmdapi.CTORATstpMarketDataField_PreCloseIOPV_get, _xmdapi.CTORATstpMarketDataField_PreCloseIOPV_set)
    IOPV = property(_xmdapi.CTORATstpMarketDataField_IOPV_get, _xmdapi.CTORATstpMarketDataField_IOPV_set)

    def __init__(self):
        _xmdapi.CTORATstpMarketDataField_swiginit(self, _xmdapi.new_CTORATstpMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpMarketDataField

# Register CTORATstpMarketDataField in _xmdapi:
_xmdapi.CTORATstpMarketDataField_swigregister(CTORATstpMarketDataField)

class CTORATstpQryRspInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    EndFlag = property(_xmdapi.CTORATstpQryRspInfoField_EndFlag_get, _xmdapi.CTORATstpQryRspInfoField_EndFlag_set)
    ErrorID = property(_xmdapi.CTORATstpQryRspInfoField_ErrorID_get, _xmdapi.CTORATstpQryRspInfoField_ErrorID_set)
    ErrorMsg = property(_xmdapi.CTORATstpQryRspInfoField_ErrorMsg_get, _xmdapi.CTORATstpQryRspInfoField_ErrorMsg_set)

    def __init__(self):
        _xmdapi.CTORATstpQryRspInfoField_swiginit(self, _xmdapi.new_CTORATstpQryRspInfoField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpQryRspInfoField

# Register CTORATstpQryRspInfoField in _xmdapi:
_xmdapi.CTORATstpQryRspInfoField_swigregister(CTORATstpQryRspInfoField)

class CTORATstpPHMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TradingDay = property(_xmdapi.CTORATstpPHMarketDataField_TradingDay_get, _xmdapi.CTORATstpPHMarketDataField_TradingDay_set)
    SecurityID = property(_xmdapi.CTORATstpPHMarketDataField_SecurityID_get, _xmdapi.CTORATstpPHMarketDataField_SecurityID_set)
    ExchangeID = property(_xmdapi.CTORATstpPHMarketDataField_ExchangeID_get, _xmdapi.CTORATstpPHMarketDataField_ExchangeID_set)
    SecurityName = property(_xmdapi.CTORATstpPHMarketDataField_SecurityName_get, _xmdapi.CTORATstpPHMarketDataField_SecurityName_set)
    Volume = property(_xmdapi.CTORATstpPHMarketDataField_Volume_get, _xmdapi.CTORATstpPHMarketDataField_Volume_set)
    Turnover = property(_xmdapi.CTORATstpPHMarketDataField_Turnover_get, _xmdapi.CTORATstpPHMarketDataField_Turnover_set)
    ClosePrice = property(_xmdapi.CTORATstpPHMarketDataField_ClosePrice_get, _xmdapi.CTORATstpPHMarketDataField_ClosePrice_set)
    UpperLimitPrice = property(_xmdapi.CTORATstpPHMarketDataField_UpperLimitPrice_get, _xmdapi.CTORATstpPHMarketDataField_UpperLimitPrice_set)
    LowerLimitPrice = property(_xmdapi.CTORATstpPHMarketDataField_LowerLimitPrice_get, _xmdapi.CTORATstpPHMarketDataField_LowerLimitPrice_set)
    BidVolume = property(_xmdapi.CTORATstpPHMarketDataField_BidVolume_get, _xmdapi.CTORATstpPHMarketDataField_BidVolume_set)
    AskVolume = property(_xmdapi.CTORATstpPHMarketDataField_AskVolume_get, _xmdapi.CTORATstpPHMarketDataField_AskVolume_set)
    UpdateTime = property(_xmdapi.CTORATstpPHMarketDataField_UpdateTime_get, _xmdapi.CTORATstpPHMarketDataField_UpdateTime_set)
    UpdateMillisec = property(_xmdapi.CTORATstpPHMarketDataField_UpdateMillisec_get, _xmdapi.CTORATstpPHMarketDataField_UpdateMillisec_set)
    MDSecurityStat = property(_xmdapi.CTORATstpPHMarketDataField_MDSecurityStat_get, _xmdapi.CTORATstpPHMarketDataField_MDSecurityStat_set)
    HWLevel = property(_xmdapi.CTORATstpPHMarketDataField_HWLevel_get, _xmdapi.CTORATstpPHMarketDataField_HWLevel_set)

    def __init__(self):
        _xmdapi.CTORATstpPHMarketDataField_swiginit(self, _xmdapi.new_CTORATstpPHMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpPHMarketDataField

# Register CTORATstpPHMarketDataField in _xmdapi:
_xmdapi.CTORATstpPHMarketDataField_swigregister(CTORATstpPHMarketDataField)

class CTORATstpInquirySpecialMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_xmdapi.CTORATstpInquirySpecialMarketDataField_ExchangeID_get, _xmdapi.CTORATstpInquirySpecialMarketDataField_ExchangeID_set)
    SecurityID = property(_xmdapi.CTORATstpInquirySpecialMarketDataField_SecurityID_get, _xmdapi.CTORATstpInquirySpecialMarketDataField_SecurityID_set)

    def __init__(self):
        _xmdapi.CTORATstpInquirySpecialMarketDataField_swiginit(self, _xmdapi.new_CTORATstpInquirySpecialMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpInquirySpecialMarketDataField

# Register CTORATstpInquirySpecialMarketDataField in _xmdapi:
_xmdapi.CTORATstpInquirySpecialMarketDataField_swigregister(CTORATstpInquirySpecialMarketDataField)

class CTORATstpSpecialMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TradingDay = property(_xmdapi.CTORATstpSpecialMarketDataField_TradingDay_get, _xmdapi.CTORATstpSpecialMarketDataField_TradingDay_set)
    SecurityID = property(_xmdapi.CTORATstpSpecialMarketDataField_SecurityID_get, _xmdapi.CTORATstpSpecialMarketDataField_SecurityID_set)
    ExchangeID = property(_xmdapi.CTORATstpSpecialMarketDataField_ExchangeID_get, _xmdapi.CTORATstpSpecialMarketDataField_ExchangeID_set)
    SecurityName = property(_xmdapi.CTORATstpSpecialMarketDataField_SecurityName_get, _xmdapi.CTORATstpSpecialMarketDataField_SecurityName_set)
    MovingAvgPrice = property(_xmdapi.CTORATstpSpecialMarketDataField_MovingAvgPrice_get, _xmdapi.CTORATstpSpecialMarketDataField_MovingAvgPrice_set)
    MovingAvgPriceSamplingNum = property(_xmdapi.CTORATstpSpecialMarketDataField_MovingAvgPriceSamplingNum_get, _xmdapi.CTORATstpSpecialMarketDataField_MovingAvgPriceSamplingNum_set)
    UpdateTime = property(_xmdapi.CTORATstpSpecialMarketDataField_UpdateTime_get, _xmdapi.CTORATstpSpecialMarketDataField_UpdateTime_set)
    UpdateMillisec = property(_xmdapi.CTORATstpSpecialMarketDataField_UpdateMillisec_get, _xmdapi.CTORATstpSpecialMarketDataField_UpdateMillisec_set)

    def __init__(self):
        _xmdapi.CTORATstpSpecialMarketDataField_swiginit(self, _xmdapi.new_CTORATstpSpecialMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpSpecialMarketDataField

# Register CTORATstpSpecialMarketDataField in _xmdapi:
_xmdapi.CTORATstpSpecialMarketDataField_swigregister(CTORATstpSpecialMarketDataField)

class CTORATstpSimplifyMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_xmdapi.CTORATstpSimplifyMarketDataField_ExchangeID_get, _xmdapi.CTORATstpSimplifyMarketDataField_ExchangeID_set)
    SecurityID = property(_xmdapi.CTORATstpSimplifyMarketDataField_SecurityID_get, _xmdapi.CTORATstpSimplifyMarketDataField_SecurityID_set)
    SecurityName = property(_xmdapi.CTORATstpSimplifyMarketDataField_SecurityName_get, _xmdapi.CTORATstpSimplifyMarketDataField_SecurityName_set)
    PreClosePrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_PreClosePrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_PreClosePrice_set)
    LastPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_LastPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_LastPrice_set)
    BidPrice1 = property(_xmdapi.CTORATstpSimplifyMarketDataField_BidPrice1_get, _xmdapi.CTORATstpSimplifyMarketDataField_BidPrice1_set)
    AskPrice1 = property(_xmdapi.CTORATstpSimplifyMarketDataField_AskPrice1_get, _xmdapi.CTORATstpSimplifyMarketDataField_AskPrice1_set)
    HighestPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_HighestPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_HighestPrice_set)
    LowestPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_LowestPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_LowestPrice_set)
    UpperLimitPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_UpperLimitPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_UpperLimitPrice_set)
    LowerLimitPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_LowerLimitPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_LowerLimitPrice_set)
    ClosePrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_ClosePrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_ClosePrice_set)
    SettlementPrice = property(_xmdapi.CTORATstpSimplifyMarketDataField_SettlementPrice_get, _xmdapi.CTORATstpSimplifyMarketDataField_SettlementPrice_set)
    UpdateTime = property(_xmdapi.CTORATstpSimplifyMarketDataField_UpdateTime_get, _xmdapi.CTORATstpSimplifyMarketDataField_UpdateTime_set)

    def __init__(self):
        _xmdapi.CTORATstpSimplifyMarketDataField_swiginit(self, _xmdapi.new_CTORATstpSimplifyMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpSimplifyMarketDataField

# Register CTORATstpSimplifyMarketDataField in _xmdapi:
_xmdapi.CTORATstpSimplifyMarketDataField_swigregister(CTORATstpSimplifyMarketDataField)

class CTORATstpSecurityStatusField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ExchangeID = property(_xmdapi.CTORATstpSecurityStatusField_ExchangeID_get, _xmdapi.CTORATstpSecurityStatusField_ExchangeID_set)
    SecurityID = property(_xmdapi.CTORATstpSecurityStatusField_SecurityID_get, _xmdapi.CTORATstpSecurityStatusField_SecurityID_set)
    IsSuspend = property(_xmdapi.CTORATstpSecurityStatusField_IsSuspend_get, _xmdapi.CTORATstpSecurityStatusField_IsSuspend_set)
    IsBreak = property(_xmdapi.CTORATstpSecurityStatusField_IsBreak_get, _xmdapi.CTORATstpSecurityStatusField_IsBreak_set)
    IsLongSuspend = property(_xmdapi.CTORATstpSecurityStatusField_IsLongSuspend_get, _xmdapi.CTORATstpSecurityStatusField_IsLongSuspend_set)
    IsCircuitBreak = property(_xmdapi.CTORATstpSecurityStatusField_IsCircuitBreak_get, _xmdapi.CTORATstpSecurityStatusField_IsCircuitBreak_set)
    IsSupportMarginBuy = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportMarginBuy_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportMarginBuy_set)
    IsSupportShortSell = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportShortSell_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportShortSell_set)
    IsSupportPur = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportPur_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportPur_set)
    IsSupportRed = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportRed_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportRed_set)
    IsSupportSplit = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportSplit_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportSplit_set)
    IsSupportMerge = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportMerge_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportMerge_set)
    IsSupportPleadgeIn = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportPleadgeIn_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportPleadgeIn_set)
    IsSupportPleadgeOut = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportPleadgeOut_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportPleadgeOut_set)
    IsSupportRoundLotBuy = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportRoundLotBuy_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportRoundLotBuy_set)
    IsSupportRoundLotSell = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportRoundLotSell_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportRoundLotSell_set)
    IsSupportOddLotBuy = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportOddLotBuy_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportOddLotBuy_set)
    IsSupportOddLotSell = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportOddLotSell_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportOddLotSell_set)
    IsSupportExercise = property(_xmdapi.CTORATstpSecurityStatusField_IsSupportExercise_get, _xmdapi.CTORATstpSecurityStatusField_IsSupportExercise_set)
    IsLimitBuy = property(_xmdapi.CTORATstpSecurityStatusField_IsLimitBuy_get, _xmdapi.CTORATstpSecurityStatusField_IsLimitBuy_set)
    IsLimitSell = property(_xmdapi.CTORATstpSecurityStatusField_IsLimitSell_get, _xmdapi.CTORATstpSecurityStatusField_IsLimitSell_set)
    IsLimitCover = property(_xmdapi.CTORATstpSecurityStatusField_IsLimitCover_get, _xmdapi.CTORATstpSecurityStatusField_IsLimitCover_set)
    IsLimitMarketMaker = property(_xmdapi.CTORATstpSecurityStatusField_IsLimitMarketMaker_get, _xmdapi.CTORATstpSecurityStatusField_IsLimitMarketMaker_set)

    def __init__(self):
        _xmdapi.CTORATstpSecurityStatusField_swiginit(self, _xmdapi.new_CTORATstpSecurityStatusField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpSecurityStatusField

# Register CTORATstpSecurityStatusField in _xmdapi:
_xmdapi.CTORATstpSecurityStatusField_swigregister(CTORATstpSecurityStatusField)

class CTORATstpMarketStatusField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MarketID = property(_xmdapi.CTORATstpMarketStatusField_MarketID_get, _xmdapi.CTORATstpMarketStatusField_MarketID_set)
    MarketStatus = property(_xmdapi.CTORATstpMarketStatusField_MarketStatus_get, _xmdapi.CTORATstpMarketStatusField_MarketStatus_set)

    def __init__(self):
        _xmdapi.CTORATstpMarketStatusField_swiginit(self, _xmdapi.new_CTORATstpMarketStatusField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpMarketStatusField

# Register CTORATstpMarketStatusField in _xmdapi:
_xmdapi.CTORATstpMarketStatusField_swigregister(CTORATstpMarketStatusField)

class CTORATstpImcParamsField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MarketID = property(_xmdapi.CTORATstpImcParamsField_MarketID_get, _xmdapi.CTORATstpImcParamsField_MarketID_set)
    OpenFlag = property(_xmdapi.CTORATstpImcParamsField_OpenFlag_get, _xmdapi.CTORATstpImcParamsField_OpenFlag_set)
    ThresholdAmount = property(_xmdapi.CTORATstpImcParamsField_ThresholdAmount_get, _xmdapi.CTORATstpImcParamsField_ThresholdAmount_set)
    PosAmt = property(_xmdapi.CTORATstpImcParamsField_PosAmt_get, _xmdapi.CTORATstpImcParamsField_PosAmt_set)
    AmountStatus = property(_xmdapi.CTORATstpImcParamsField_AmountStatus_get, _xmdapi.CTORATstpImcParamsField_AmountStatus_set)

    def __init__(self):
        _xmdapi.CTORATstpImcParamsField_swiginit(self, _xmdapi.new_CTORATstpImcParamsField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpImcParamsField

# Register CTORATstpImcParamsField in _xmdapi:
_xmdapi.CTORATstpImcParamsField_swigregister(CTORATstpImcParamsField)

class CTORATstpRapidMarketDataField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SecurityID = property(_xmdapi.CTORATstpRapidMarketDataField_SecurityID_get, _xmdapi.CTORATstpRapidMarketDataField_SecurityID_set)
    ExchangeID = property(_xmdapi.CTORATstpRapidMarketDataField_ExchangeID_get, _xmdapi.CTORATstpRapidMarketDataField_ExchangeID_set)
    DataTimeStamp = property(_xmdapi.CTORATstpRapidMarketDataField_DataTimeStamp_get, _xmdapi.CTORATstpRapidMarketDataField_DataTimeStamp_set)
    PreClosePrice = property(_xmdapi.CTORATstpRapidMarketDataField_PreClosePrice_get, _xmdapi.CTORATstpRapidMarketDataField_PreClosePrice_set)
    OpenPrice = property(_xmdapi.CTORATstpRapidMarketDataField_OpenPrice_get, _xmdapi.CTORATstpRapidMarketDataField_OpenPrice_set)
    NumTrades = property(_xmdapi.CTORATstpRapidMarketDataField_NumTrades_get, _xmdapi.CTORATstpRapidMarketDataField_NumTrades_set)
    TotalVolumeTrade = property(_xmdapi.CTORATstpRapidMarketDataField_TotalVolumeTrade_get, _xmdapi.CTORATstpRapidMarketDataField_TotalVolumeTrade_set)
    TotalValueTrade = property(_xmdapi.CTORATstpRapidMarketDataField_TotalValueTrade_get, _xmdapi.CTORATstpRapidMarketDataField_TotalValueTrade_set)
    HighestPrice = property(_xmdapi.CTORATstpRapidMarketDataField_HighestPrice_get, _xmdapi.CTORATstpRapidMarketDataField_HighestPrice_set)
    LowestPrice = property(_xmdapi.CTORATstpRapidMarketDataField_LowestPrice_get, _xmdapi.CTORATstpRapidMarketDataField_LowestPrice_set)
    LastPrice = property(_xmdapi.CTORATstpRapidMarketDataField_LastPrice_get, _xmdapi.CTORATstpRapidMarketDataField_LastPrice_set)
    BidPrice1 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice1_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice1_set)
    BidVolume1 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume1_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume1_set)
    AskPrice1 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice1_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice1_set)
    AskVolume1 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume1_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume1_set)
    AskPrice2 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice2_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice2_set)
    AskVolume2 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume2_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume2_set)
    AskPrice3 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice3_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice3_set)
    AskVolume3 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume3_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume3_set)
    BidPrice2 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice2_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice2_set)
    BidVolume2 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume2_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume2_set)
    BidPrice3 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice3_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice3_set)
    BidVolume3 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume3_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume3_set)
    AskPrice4 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice4_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice4_set)
    AskVolume4 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume4_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume4_set)
    AskPrice5 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice5_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice5_set)
    AskVolume5 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume5_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume5_set)
    BidPrice4 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice4_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice4_set)
    BidVolume4 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume4_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume4_set)
    BidPrice5 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice5_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice5_set)
    BidVolume5 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume5_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume5_set)
    AskPrice6 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice6_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice6_set)
    AskVolume6 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume6_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume6_set)
    AskPrice7 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice7_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice7_set)
    AskVolume7 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume7_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume7_set)
    BidPrice6 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice6_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice6_set)
    BidVolume6 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume6_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume6_set)
    BidPrice7 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice7_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice7_set)
    BidVolume7 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume7_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume7_set)
    AskPrice8 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice8_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice8_set)
    AskVolume8 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume8_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume8_set)
    AskPrice9 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice9_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice9_set)
    AskVolume9 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume9_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume9_set)
    BidPrice8 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice8_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice8_set)
    BidVolume8 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume8_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume8_set)
    BidPrice9 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice9_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice9_set)
    BidVolume9 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume9_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume9_set)
    BidPrice10 = property(_xmdapi.CTORATstpRapidMarketDataField_BidPrice10_get, _xmdapi.CTORATstpRapidMarketDataField_BidPrice10_set)
    BidVolume10 = property(_xmdapi.CTORATstpRapidMarketDataField_BidVolume10_get, _xmdapi.CTORATstpRapidMarketDataField_BidVolume10_set)
    AskPrice10 = property(_xmdapi.CTORATstpRapidMarketDataField_AskPrice10_get, _xmdapi.CTORATstpRapidMarketDataField_AskPrice10_set)
    AskVolume10 = property(_xmdapi.CTORATstpRapidMarketDataField_AskVolume10_get, _xmdapi.CTORATstpRapidMarketDataField_AskVolume10_set)
    UpperLimitPrice = property(_xmdapi.CTORATstpRapidMarketDataField_UpperLimitPrice_get, _xmdapi.CTORATstpRapidMarketDataField_UpperLimitPrice_set)
    LowerLimitPrice = property(_xmdapi.CTORATstpRapidMarketDataField_LowerLimitPrice_get, _xmdapi.CTORATstpRapidMarketDataField_LowerLimitPrice_set)
    ClosePrice = property(_xmdapi.CTORATstpRapidMarketDataField_ClosePrice_get, _xmdapi.CTORATstpRapidMarketDataField_ClosePrice_set)
    MDSecurityStat = property(_xmdapi.CTORATstpRapidMarketDataField_MDSecurityStat_get, _xmdapi.CTORATstpRapidMarketDataField_MDSecurityStat_set)
    IOPV = property(_xmdapi.CTORATstpRapidMarketDataField_IOPV_get, _xmdapi.CTORATstpRapidMarketDataField_IOPV_set)
    InnerSell = property(_xmdapi.CTORATstpRapidMarketDataField_InnerSell_get, _xmdapi.CTORATstpRapidMarketDataField_InnerSell_set)
    OuterBuy = property(_xmdapi.CTORATstpRapidMarketDataField_OuterBuy_get, _xmdapi.CTORATstpRapidMarketDataField_OuterBuy_set)
    BidCount1 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount1_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount1_set)
    AskCount1 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount1_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount1_set)
    AskCount2 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount2_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount2_set)
    AskCount3 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount3_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount3_set)
    BidCount2 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount2_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount2_set)
    BidCount3 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount3_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount3_set)
    AskCount4 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount4_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount4_set)
    AskCount5 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount5_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount5_set)
    BidCount4 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount4_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount4_set)
    BidCount5 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount5_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount5_set)
    AskCount6 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount6_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount6_set)
    AskCount7 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount7_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount7_set)
    BidCount6 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount6_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount6_set)
    BidCount7 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount7_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount7_set)
    AskCount8 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount8_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount8_set)
    AskCount9 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount9_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount9_set)
    BidCount8 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount8_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount8_set)
    BidCount9 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount9_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount9_set)
    BidCount10 = property(_xmdapi.CTORATstpRapidMarketDataField_BidCount10_get, _xmdapi.CTORATstpRapidMarketDataField_BidCount10_set)
    AskCount10 = property(_xmdapi.CTORATstpRapidMarketDataField_AskCount10_get, _xmdapi.CTORATstpRapidMarketDataField_AskCount10_set)

    def __init__(self):
        _xmdapi.CTORATstpRapidMarketDataField_swiginit(self, _xmdapi.new_CTORATstpRapidMarketDataField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpRapidMarketDataField

# Register CTORATstpRapidMarketDataField in _xmdapi:
_xmdapi.CTORATstpRapidMarketDataField_swigregister(CTORATstpRapidMarketDataField)

class CTORATstpFensUserInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FensVer = property(_xmdapi.CTORATstpFensUserInfoField_FensVer_get, _xmdapi.CTORATstpFensUserInfoField_FensVer_set)
    FensEnvID = property(_xmdapi.CTORATstpFensUserInfoField_FensEnvID_get, _xmdapi.CTORATstpFensUserInfoField_FensEnvID_set)
    FensNodeID = property(_xmdapi.CTORATstpFensUserInfoField_FensNodeID_get, _xmdapi.CTORATstpFensUserInfoField_FensNodeID_set)
    FensUserID = property(_xmdapi.CTORATstpFensUserInfoField_FensUserID_get, _xmdapi.CTORATstpFensUserInfoField_FensUserID_set)
    UserID = property(_xmdapi.CTORATstpFensUserInfoField_UserID_get, _xmdapi.CTORATstpFensUserInfoField_UserID_set)
    ClientInfo = property(_xmdapi.CTORATstpFensUserInfoField_ClientInfo_get, _xmdapi.CTORATstpFensUserInfoField_ClientInfo_set)

    def __init__(self):
        _xmdapi.CTORATstpFensUserInfoField_swiginit(self, _xmdapi.new_CTORATstpFensUserInfoField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpFensUserInfoField

# Register CTORATstpFensUserInfoField in _xmdapi:
_xmdapi.CTORATstpFensUserInfoField_swigregister(CTORATstpFensUserInfoField)

class CTORATstpConnectionInfoField(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    InnerIPAddress = property(_xmdapi.CTORATstpConnectionInfoField_InnerIPAddress_get, _xmdapi.CTORATstpConnectionInfoField_InnerIPAddress_set)
    InnerPort = property(_xmdapi.CTORATstpConnectionInfoField_InnerPort_get, _xmdapi.CTORATstpConnectionInfoField_InnerPort_set)
    OuterIPAddress = property(_xmdapi.CTORATstpConnectionInfoField_OuterIPAddress_get, _xmdapi.CTORATstpConnectionInfoField_OuterIPAddress_set)
    OuterPort = property(_xmdapi.CTORATstpConnectionInfoField_OuterPort_get, _xmdapi.CTORATstpConnectionInfoField_OuterPort_set)
    MacAddress = property(_xmdapi.CTORATstpConnectionInfoField_MacAddress_get, _xmdapi.CTORATstpConnectionInfoField_MacAddress_set)

    def __init__(self):
        _xmdapi.CTORATstpConnectionInfoField_swiginit(self, _xmdapi.new_CTORATstpConnectionInfoField())
    __swig_destroy__ = _xmdapi.delete_CTORATstpConnectionInfoField

# Register CTORATstpConnectionInfoField in _xmdapi:
_xmdapi.CTORATstpConnectionInfoField_swigregister(CTORATstpConnectionInfoField)

class CTORATstpXMdSpi(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def OnFrontConnected(self):
        return _xmdapi.CTORATstpXMdSpi_OnFrontConnected(self)

    def OnFrontDisconnected(self, nReason):
        return _xmdapi.CTORATstpXMdSpi_OnFrontDisconnected(self, nReason)

    def OnRspGetConnectionInfo(self, pConnectionInfoField, pRspInfoField, nRequestID):
        return _xmdapi.CTORATstpXMdSpi_OnRspGetConnectionInfo(self, pConnectionInfoField, pRspInfoField, nRequestID)

    def OnRspUserLogin(self, pRspUserLoginField, pRspInfoField, nRequestID):
        return _xmdapi.CTORATstpXMdSpi_OnRspUserLogin(self, pRspUserLoginField, pRspInfoField, nRequestID)

    def OnRspUserLogout(self, pUserLogoutField, pRspInfoField, nRequestID):
        return _xmdapi.CTORATstpXMdSpi_OnRspUserLogout(self, pUserLogoutField, pRspInfoField, nRequestID)

    def OnRspSubMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubPHMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubPHMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubPHMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubPHMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSpecialMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSpecialMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSpecialMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSpecialMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSecurityStatus(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSecurityStatus(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSecurityStatus(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSecurityStatus(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubMarketStatus(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubMarketStatus(self, pSpecificMarketField, pRspInfoField)

    def OnRspUnSubMarketStatus(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubMarketStatus(self, pSpecificMarketField, pRspInfoField)

    def OnRspSubImcParams(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubImcParams(self, pSpecificMarketField, pRspInfoField)

    def OnRspUnSubImcParams(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubImcParams(self, pSpecificMarketField, pRspInfoField)

    def OnRspInquiryMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast):
        return _xmdapi.CTORATstpXMdSpi_OnRspInquiryMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast)

    def OnRspInquiryPHMarketDataMirror(self, pPHMarketDataField, pRspInfoField, nRequestID, bIsLast):
        return _xmdapi.CTORATstpXMdSpi_OnRspInquiryPHMarketDataMirror(self, pPHMarketDataField, pRspInfoField, nRequestID, bIsLast)

    def OnRspInquirySpecialMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast):
        return _xmdapi.CTORATstpXMdSpi_OnRspInquirySpecialMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast)

    def OnRspSubSPMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSPMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSPMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSPMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSPSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSPSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSPSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSPSimplifyMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSPSecurityStatus(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSPSecurityStatus(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubSPSecurityStatus(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSPSecurityStatus(self, pSpecificSecurityField, pRspInfoField)

    def OnRspSubSPMarketStatus(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubSPMarketStatus(self, pSpecificMarketField, pRspInfoField)

    def OnRspUnSubSPMarketStatus(self, pSpecificMarketField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubSPMarketStatus(self, pSpecificMarketField, pRspInfoField)

    def OnRspInquirySPMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast):
        return _xmdapi.CTORATstpXMdSpi_OnRspInquirySPMarketDataMirror(self, pMarketDataField, pRspInfoField, nRequestID, bIsLast)

    def OnRtnMarketData(self, pMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnMarketData(self, pMarketDataField)

    def OnRtnPHMarketData(self, pPHMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnPHMarketData(self, pPHMarketDataField)

    def OnRtnSpecialMarketData(self, pSpecialMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSpecialMarketData(self, pSpecialMarketDataField)

    def OnRtnSimplifyMarketData(self, pSimplifyMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSimplifyMarketData(self, pSimplifyMarketDataField)

    def OnRtnSecurityStatus(self, pSecurityStatusField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSecurityStatus(self, pSecurityStatusField)

    def OnRtnMarketStatus(self, pMarketStatusField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnMarketStatus(self, pMarketStatusField)

    def OnRtnImcParams(self, pImcParamsField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnImcParams(self, pImcParamsField)

    def OnRtnSPMarketData(self, pMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSPMarketData(self, pMarketDataField)

    def OnRtnSPSimplifyMarketData(self, pSimplifyMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSPSimplifyMarketData(self, pSimplifyMarketDataField)

    def OnRtnSPSecurityStatus(self, pSecurityStatusField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSPSecurityStatus(self, pSecurityStatusField)

    def OnRtnSPMarketStatus(self, pMarketStatusField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnSPMarketStatus(self, pMarketStatusField)

    def OnRspSubRapidMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspSubRapidMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRspUnSubRapidMarketData(self, pSpecificSecurityField, pRspInfoField):
        return _xmdapi.CTORATstpXMdSpi_OnRspUnSubRapidMarketData(self, pSpecificSecurityField, pRspInfoField)

    def OnRtnRapidMarketData(self, pRapidMarketDataField):
        return _xmdapi.CTORATstpXMdSpi_OnRtnRapidMarketData(self, pRapidMarketDataField)

    def __init__(self):
        if self.__class__ == CTORATstpXMdSpi:
            _self = None
        else:
            _self = self
        _xmdapi.CTORATstpXMdSpi_swiginit(self, _xmdapi.new_CTORATstpXMdSpi(_self, ))
    __swig_destroy__ = _xmdapi.delete_CTORATstpXMdSpi
    def __disown__(self):
        self.this.disown()
        _xmdapi.disown_CTORATstpXMdSpi(self)
        return weakref.proxy(self)

# Register CTORATstpXMdSpi in _xmdapi:
_xmdapi.CTORATstpXMdSpi_swigregister(CTORATstpXMdSpi)

class CTORATstpXMdApi(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def CreateTstpXMdApi(*args):
        return _xmdapi.CTORATstpXMdApi_CreateTstpXMdApi(*args)

    @staticmethod
    def GetApiVersion():
        return _xmdapi.CTORATstpXMdApi_GetApiVersion()

    def Release(self):
        return _xmdapi.CTORATstpXMdApi_Release(self)

    def Init(self, *args):
        return _xmdapi.CTORATstpXMdApi_Init(self, *args)

    def Join(self):
        return _xmdapi.CTORATstpXMdApi_Join(self)

    def RegisterFront(self, pszFrontAddress):
        return _xmdapi.CTORATstpXMdApi_RegisterFront(self, pszFrontAddress)

    def RegisterNameServer(self, pszNsAddress):
        return _xmdapi.CTORATstpXMdApi_RegisterNameServer(self, pszNsAddress)

    def RegisterFensUserInfo(self, pFensUserInfoField):
        return _xmdapi.CTORATstpXMdApi_RegisterFensUserInfo(self, pFensUserInfoField)

    def RegisterMulticast(self, pszMulticastAddress, pszInterfaceIP, pszSourceIp):
        return _xmdapi.CTORATstpXMdApi_RegisterMulticast(self, pszMulticastAddress, pszInterfaceIP, pszSourceIp)

    def RegisterDeriveServer(self, pszDeriveAddress):
        return _xmdapi.CTORATstpXMdApi_RegisterDeriveServer(self, pszDeriveAddress)

    def RegisterDeriveMulticast(self, pszMulticastAddress, pszInterfaceIP, pszSourceIp):
        return _xmdapi.CTORATstpXMdApi_RegisterDeriveMulticast(self, pszMulticastAddress, pszInterfaceIP, pszSourceIp)

    def RegisterSpi(self, pSpi):
        return _xmdapi.CTORATstpXMdApi_RegisterSpi(self, pSpi)

    def ReqGetConnectionInfo(self, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqGetConnectionInfo(self, nRequestID)

    def ReqUserLogin(self, pReqUserLoginField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqUserLogin(self, pReqUserLoginField, nRequestID)

    def ReqUserLogout(self, pUserLogoutField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqUserLogout(self, pUserLogoutField, nRequestID)

    def SubscribeMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeMarketData(self, ppSecurityID, ExchangeID)

    def SubscribePHMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribePHMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribePHMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribePHMarketData(self, ppSecurityID, ExchangeID)

    def SubscribeSpecialMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSpecialMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeSpecialMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSpecialMarketData(self, ppSecurityID, ExchangeID)

    def SubscribeSimplifyMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSimplifyMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeSimplifyMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSimplifyMarketData(self, ppSecurityID, ExchangeID)

    def SubscribeSecurityStatus(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSecurityStatus(self, ppSecurityID, ExchangeID)

    def UnSubscribeSecurityStatus(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSecurityStatus(self, ppSecurityID, ExchangeID)

    def SubscribeMarketStatus(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_SubscribeMarketStatus(self, MarketID)

    def UnSubscribeMarketStatus(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeMarketStatus(self, MarketID)

    def SubscribeImcParams(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_SubscribeImcParams(self, MarketID)

    def UnSubscribeImcParams(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeImcParams(self, MarketID)

    def ReqInquiryMarketDataMirror(self, pInquiryMarketDataField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqInquiryMarketDataMirror(self, pInquiryMarketDataField, nRequestID)

    def ReqInquiryPHMarketDataMirror(self, pInquiryMarketDataField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqInquiryPHMarketDataMirror(self, pInquiryMarketDataField, nRequestID)

    def ReqInquirySpecialMarketDataMirror(self, pInquirySpecialMarketDataField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqInquirySpecialMarketDataMirror(self, pInquirySpecialMarketDataField, nRequestID)

    def SubscribeSPMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSPMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeSPMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSPMarketData(self, ppSecurityID, ExchangeID)

    def SubscribeSPSimplifyMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSPSimplifyMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeSPSimplifyMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSPSimplifyMarketData(self, ppSecurityID, ExchangeID)

    def SubscribeSPSecurityStatus(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSPSecurityStatus(self, ppSecurityID, ExchangeID)

    def UnSubscribeSPSecurityStatus(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSPSecurityStatus(self, ppSecurityID, ExchangeID)

    def SubscribeSPMarketStatus(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_SubscribeSPMarketStatus(self, MarketID)

    def UnSubscribeSPMarketStatus(self, MarketID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeSPMarketStatus(self, MarketID)

    def ReqInquirySPMarketDataMirror(self, pInquiryMarketDataField, nRequestID):
        return _xmdapi.CTORATstpXMdApi_ReqInquirySPMarketDataMirror(self, pInquiryMarketDataField, nRequestID)

    def SubscribeRapidMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_SubscribeRapidMarketData(self, ppSecurityID, ExchangeID)

    def UnSubscribeRapidMarketData(self, ppSecurityID, ExchangeID):
        return _xmdapi.CTORATstpXMdApi_UnSubscribeRapidMarketData(self, ppSecurityID, ExchangeID)

# Register CTORATstpXMdApi in _xmdapi:
_xmdapi.CTORATstpXMdApi_swigregister(CTORATstpXMdApi)

def CTORATstpXMdApi_CreateTstpXMdApi(*args):
    return _xmdapi.CTORATstpXMdApi_CreateTstpXMdApi(*args)

def CTORATstpXMdApi_GetApiVersion():
    return _xmdapi.CTORATstpXMdApi_GetApiVersion()




 l2/l2_data_manager_new.py

@@ -620,12 +620,11 @@
                lp.enable()
                lp_wrap = lp(cls.__buy)
                lp_wrap(code, unreal_buy_info[1], local_today_datas[code][unreal_buy_info[0]],
                          unreal_buy_info[0], is_first_code)
                        unreal_buy_info[0], is_first_code)
                output = io.StringIO()
                lp.print_stats(stream=output)
                lp.disable()
                logger_profile.info(output.getvalue())


                _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time,
                                                  "已虚拟下单-执行真实下单 外部耗时")

 main.py

@@ -12,9 +12,10 @@
# 交易服务
from third_data import data_server
from trade.huaxin import trade_server, trade_api_server
import huaxin


def createTradeServer(pipe):
def createTradeServer(pipe_server, pipe_trade, pipe_l1):
    # 初始化参数
    global_data_loader.init()

@@ -23,15 +24,15 @@
    t1.start()

    # 交易接口服务
    t1 = threading.Thread(target=trade_api_server.run, args=(pipe,), daemon=True)
    t1 = threading.Thread(target=trade_api_server.run, args=(pipe_server,), daemon=True)
    t1.start()

    # redis后台服务
    t1 = threading.Thread(target=redis_manager.RedisUtils.run_loop,  daemon=True)
    t1 = threading.Thread(target=redis_manager.RedisUtils.run_loop, daemon=True)
    t1.start()

    # 交易服务
    trade_server.run()
    trade_server.run(pipe_trade, pipe_l1)


# 主服务
@@ -50,9 +51,23 @@


if __name__ == '__main__':
    pipe_server, pipe_trade = multiprocessing.Pipe()
    # 策略与server间的通信
    pss_server, pss_strategy = multiprocessing.Pipe()
    # 策略与交易间的通信
    pst_trade, pst_strategy = multiprocessing.Pipe()
    # 交易与l2之间的通信
    ptl2_trade, ptl2_l2 = multiprocessing.Pipe()
    # l1与trade间的通信
    pl1t_l1, pl1t_trade = multiprocessing.Pipe()

    logger_l2_process_time.info("测试123")
    serverProcess = multiprocessing.Process(target=createServer, args=(pipe_server,))
    serverProcess = multiprocessing.Process(target=createServer, args=(pss_server,))
    serverProcess.start()
    # 将tradeServer作为主进程
    createTradeServer(pipe_trade)
    createTradeServer(pss_strategy, pst_strategy, pl1t_trade)

    tradeProcess = multiprocessing.Process(target=huaxin.trade_client.run, args=(ptl2_trade, pst_trade))
    l2Process = multiprocessing.Process(target=huaxin.l2_client.run, args=(ptl2_l2,))
    tradeProcess.start()
    l2Process.start()
    huaxin.l1_client.run_async(pl1t_l1)

 trade/huaxin/huaxin_trade_api.py

@@ -7,9 +7,41 @@
import threading
import time

from log_module.log import hx_logger_trade_debug, hx_logger_trade_loop
from log_module.log import hx_logger_trade_debug, hx_logger_trade_loop, hx_logger_trade_callback
from trade.huaxin import huaxin_trade_data_update
from utils import socket_util

# 外部传入的交易队列
pipe_trade = None


def __run_recv_pipe_trade():
    # 设置结果
    def __set_response(data_json):
        # 处理数据
        hx_logger_trade_callback.info(f"response：request_id-{data_json['request_id']}")
        # 设置响应内容
        set_response(data_json["request_id"], data_json['data'])

    if pipe_trade is not None:
        while True:
            try:
                val = pipe_trade.recv()
                if val:
                    print("收到来自交易服务器的数据：", val)
                    data_json = json.loads(val)
                    t1 = threading.Thread(target=lambda: __set_response(data_json), daemon=True)
                    t1.start()
            except:
                pass


# 设置交易通信队列
def set_pipe_trade(pipe_trade_):
    global pipe_trade
    pipe_trade = pipe_trade_
    t1 = threading.Thread(target=lambda: __run_recv_pipe_trade(), daemon=True)
    t1.start()


class ClientSocketManager:
@@ -156,34 +188,26 @@

# 网络请求
def __request(_type, data):
    client = ClientSocketManager.acquire_client(_type)
    if not client:
        raise Exception("无可用的交易client")
    request_id = __get_request_id(_type)
    try:
        hx_logger_trade_loop.info("请求发送开始：client_id-{} request_id-{}", client[0], request_id)
        hx_logger_trade_loop.info("请求发送开始：client_id-{} request_id-{}", 0, request_id)
        root_data = {"type": "cmd",
                     "data": data,
                     "request_id": request_id}
        root_data = socket_util.encryp_client_params_sign(root_data)
        # print("请求前对象", root_data)
        # 添加请求头
        client[1].sendall(socket_util.load_header(json.dumps(root_data).encode(encoding='utf-8')))
        result = client[1].recv(1024)
        # print("请求发送成功", result.decode(encoding='utf-8'))
        hx_logger_trade_loop.info("请求发送成功：client_id-{} request_id-{}", client[0], request_id)
        pipe_trade.send(json.dumps(root_data).encode(encoding='utf-8'))
        hx_logger_trade_loop.info("请求发送成功：request_id-{}", request_id)
    except BrokenPipeError as e:
        hx_logger_trade_loop.info("请求发送异常：client_id-{} request_id-{} error-{}", client[0], request_id, str(e))
        ClientSocketManager.del_client(client[0])
        hx_logger_trade_loop.info("请求发送异常：request_id-{} error-{}", request_id, str(e))
        raise e
    except Exception as e:
        hx_logger_trade_loop.info("请求发送异常：client_id-{} request_id-{} error-{}", client[0], request_id, str(e))
        hx_logger_trade_loop.info("请求发送异常： request_id-{} error-{}", request_id, str(e))
        logging.exception(e)
        raise e
    return request_id, client
    return request_id


def __read_response(client, request_id, blocking, timeout=TIMEOUT):
def __read_response(request_id, blocking, timeout=TIMEOUT):
    if blocking:
        start_time = time.time()
        try:
@@ -192,12 +216,11 @@
                if request_id in __request_response_dict:
                    # 获取到了响应内容
                    result = __request_response_dict.pop(request_id)
                    hx_logger_trade_loop.info("请求读取成功：client_id-{} request_id-{}", client[0], request_id)
                    hx_logger_trade_loop.info("请求读取成功： request_id-{}", request_id)
                    return result
                if time.time() - start_time > timeout:
                    hx_logger_trade_loop.info("请求读取超时：client_id-{} request_id-{}", client[0], request_id)
                    hx_logger_trade_loop.info("请求读取超时： request_id-{}", request_id)
                    # 读取内容超时才会释放
                    ClientSocketManager.release_client(client[0])
                    raise Exception(f"读取内容超时: request_id={request_id}")
        finally:
            pass
@@ -205,12 +228,11 @@
    return None


def set_response(client_id, request_id, response):
    if client_id and request_id:
        hx_logger_trade_loop.info("请求响应：client_id-{} request_id-{}", client_id, request_id)
def set_response(request_id, response):
    if request_id:
        hx_logger_trade_loop.info("请求响应：client_id-{} request_id-{}", request_id)
        # 主动触发
        __request_response_dict[request_id] = response
        ClientSocketManager.release_client(client_id)
    else:
        # 被动触发
        pass
@@ -224,29 +246,29 @@
# blocking是否阻塞进程
def order(direction, code, volume, price, price_type=2, blocking=True):
    print("客户端", ClientSocketManager.socket_client_dict)
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                                   {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 1,
                                    "direction": direction,
                                    "code": code,
                                    "volume": volume,
                                    "price_type": price_type,
                                    "price": price, "sinfo": f"b_{code}_{round(time.time() * 1000)}"})
    request_id = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                           {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 1,
                            "direction": direction,
                            "code": code,
                            "volume": volume,
                            "price_type": price_type,
                            "price": price, "sinfo": f"b_{code}_{round(time.time() * 1000)}"})

    try:
        return __read_response(client, request_id, blocking)
        return __read_response(request_id, blocking)
    finally:
        huaxin_trade_data_update.add_delegate_list()
        huaxin_trade_data_update.add_money_list()


def cancel_order(direction, code, orderSysID, blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                                   {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 2,
                                    "direction": direction,
                                    "code": code,
                                    "orderSysID": orderSysID, "sinfo": f"cb_{code}_{round(time.time() * 1000)}"})
    request_id = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                           {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 2,
                            "direction": direction,
                            "code": code,
                            "orderSysID": orderSysID, "sinfo": f"cb_{code}_{round(time.time() * 1000)}"})
    try:
        return __read_response(client, request_id, blocking)
        return __read_response(request_id, blocking)
    finally:
        huaxin_trade_data_update.add_delegate_list()
        huaxin_trade_data_update.add_money_list()
@@ -261,39 +283,39 @@
# 获取委托列表
# can_cancel:是否可以撤
def get_delegate_list(can_cancel=True, blocking=True, timeout=TIMEOUT):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                                    "can_cancel": 1 if can_cancel else 0})
    request_id = __request(ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                           {"type": ClientSocketManager.CLIENT_TYPE_DELEGATE_LIST,
                            "can_cancel": 1 if can_cancel else 0})

    return __read_response(client, request_id, blocking, timeout=timeout)
    return __read_response(request_id, blocking, timeout=timeout)


# 获取成交列表
def get_deal_list(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_DEAL_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_DEAL_LIST})
    return __read_response(client, request_id, blocking)
    request_id = __request(ClientSocketManager.CLIENT_TYPE_DEAL_LIST,
                           {"type": ClientSocketManager.CLIENT_TYPE_DEAL_LIST})
    return __read_response(request_id, blocking)


# 获取持仓列表
def get_position_list(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_POSITION_LIST,
                                   {"type": ClientSocketManager.CLIENT_TYPE_POSITION_LIST})
    return __read_response(client, request_id, blocking)
    request_id = __request(ClientSocketManager.CLIENT_TYPE_POSITION_LIST,
                           {"type": ClientSocketManager.CLIENT_TYPE_POSITION_LIST})
    return __read_response(request_id, blocking)


# 获取账户资金状况
def get_money(blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_MONEY,
                                   {"type": ClientSocketManager.CLIENT_TYPE_MONEY})
    return __read_response(client, request_id, blocking)
    request_id = __request(ClientSocketManager.CLIENT_TYPE_MONEY,
                           {"type": ClientSocketManager.CLIENT_TYPE_MONEY})
    return __read_response(request_id, blocking)


# 设置L2订阅数据
def set_l2_codes_data(codes_data, blocking=True):
    request_id, client = __request(ClientSocketManager.CLIENT_TYPE_CMD_L2,
                                   {"type": ClientSocketManager.CLIENT_TYPE_CMD_L2, "data": codes_data})
    return __read_response(client, request_id, blocking)
    request_id = __request(ClientSocketManager.CLIENT_TYPE_CMD_L2,
                           {"type": ClientSocketManager.CLIENT_TYPE_CMD_L2, "data": codes_data})
    return __read_response(request_id, blocking)


def parseResponse(data_str):

 trade/huaxin/trade_server.py

@@ -343,9 +343,27 @@
            time.sleep(2)


def run():
def __recv_pipe_l1(pipe_trade, pipe_l1):
    if pipe_trade is not None and pipe_l1 is not None:
        while True:
            try:
                val = pipe_l1.recv()
                if val:
                    val = json.loads(val)
                    print("收到来自L1的数据：", val)
                    # 处理数据
            except:
                pass


def run(pipe_trade, pipe_l1):
    # 执行一些初始化数据
    block_info.init()
    huaxin_trade_api.set_pipe_trade(pipe_trade)

    # 监听l1那边传过来的代码
    t1 = threading.Thread(target=lambda: __recv_pipe_l1(pipe_trade, pipe_l1), daemon=True)
    t1.start()

    print("create TradeServer")
    t1 = threading.Thread(target=lambda: clear_invalid_client(), daemon=True)

 trade/trade_result_manager.py

@@ -83,23 +83,15 @@
# 真实撤成功
def real_cancel_success(code, buy_single_index, buy_exec_index, total_datas):
    # 安全笔数计算
    f1 = dask.delayed(__buyL2SafeCountManager.save_place_order_info)(code, buy_single_index, buy_exec_index,
                                                                     total_datas[-1]["index"])
    __buyL2SafeCountManager.save_place_order_info(code, buy_single_index, buy_exec_index,
                                                  total_datas[-1]["index"])
    # 取消买入标识
    f2 = dask.delayed(l2_data_manager.TradePointManager().delete_buy_point)(code)
    f3 = dask.delayed(l2_data_manager.TradePointManager().delete_buy_cancel_point)(code)
    f6 = dask.delayed(SecondCancelBigNumComputer().cancel_success)(code)
    f7 = dask.delayed(DCancelBigNumComputer().cancel_success)(code)
    f8 = dask.delayed(LCancelBigNumComputer().cancel_success)(code)

    dask.compute(f1, f2, f3, f6, f7, f8)
    l2_data_manager.TradePointManager().delete_buy_point(code)
    l2_data_manager.TradePointManager().delete_buy_cancel_point(code)
    SecondCancelBigNumComputer().cancel_success(code)
    DCancelBigNumComputer().cancel_success(code)
    LCancelBigNumComputer().cancel_success(code)


if __name__ == "__main__":
    code = "600246"
    f2 = dask.delayed(l2_data_manager.TradePointManager().delete_buy_point)(code)
    f3 = dask.delayed(l2_data_manager.TradePointManager().delete_buy_cancel_point)(code)
    f6 = dask.delayed(SecondCancelBigNumComputer().cancel_success)(code)
    f7 = dask.delayed(DCancelBigNumComputer().cancel_success)(code)
    f8 = dask.delayed(LCancelBigNumComputer().cancel_success)(code)
    dask.compute(f2, f3, f6, f7, f8)
    pass