From 4ee1bd5de9ca76a69adac6e17a11bd686c742ef3 Mon Sep 17 00:00:00 2001
From: admin <weikou2014>
Date: 星期三, 22 五月 2024 18:57:54 +0800
Subject: [PATCH] 融入交易
---
middle_l1_data_server.py | 14
_traderapi.cpython-37m-x86_64-linux-gnu.so | 0
log_module/request_log_util.py | 10
trade/huaxin_trade_api.py | 323 +
traderapi.py | 8064 +++++++++++++++++++++++++++++++++++++++++++++
huaxin_client/command_manager.py | 164
huaxin_client/huaxin_trade_client.py | 524 ++
db/mysql_data.py | 9
socket_manager.py | 4
data_server.py | 12
main.py | 20
utils/kp_client_msg_manager.py | 2
huaxin_client/client_network.py | 83
huaxin_client/trade_manager.py | 616 +++
third_data/kpl_data_manager.py | 2
_traderapi.cp37-win_amd64.pyd | 0
constant.py | 2
/dev/null | 139
middle_api_server.py | 8
log_module/async_log_util.py | 101
output/push_msg_manager.py | 2
utils/hosting_api_util.py | 14
middle_server.py | 41
log_module/log.py | 464 ++
middle_cb_api_server.py | 9
_traderapi.cp37-win32.pyd | 0
db/redis_manager.py | 2
27 files changed, 10,446 insertions(+), 183 deletions(-)
diff --git a/_traderapi.cp37-win32.pyd b/_traderapi.cp37-win32.pyd
new file mode 100644
index 0000000..3508a03
--- /dev/null
+++ b/_traderapi.cp37-win32.pyd
Binary files differ
diff --git a/_traderapi.cp37-win_amd64.pyd b/_traderapi.cp37-win_amd64.pyd
new file mode 100644
index 0000000..b4cc581
--- /dev/null
+++ b/_traderapi.cp37-win_amd64.pyd
Binary files differ
diff --git a/_traderapi.cpython-37m-x86_64-linux-gnu.so b/_traderapi.cpython-37m-x86_64-linux-gnu.so
new file mode 100644
index 0000000..b2b50db
--- /dev/null
+++ b/_traderapi.cpython-37m-x86_64-linux-gnu.so
Binary files differ
diff --git a/constant.py b/constant.py
index 5095771..e71aeb6 100644
--- a/constant.py
+++ b/constant.py
@@ -95,6 +95,8 @@
"passwd": "Yeshi2016@"
}
+LOG_DIR = "logs"
+
# 鑾峰彇鏍硅矾寰�
def get_path_prefix():
return 'D:' if is_windows() else '/home'
diff --git a/data_server.py b/data_server.py
index 1308eec..e16b735 100644
--- a/data_server.py
+++ b/data_server.py
@@ -6,10 +6,8 @@
import dask
-import log
from code_attribute import gpcode_manager
-from log import logger_request_debug
-from log_module import log_analyse, log_export
+from log_module import log_analyse, log_export, log, request_log_util
from output import limit_up_data_filter, output_util
from output.limit_up_data_filter import IgnoreCodeManager
from third_data import kpl_util, kpl_data_manager, kpl_api
@@ -273,7 +271,7 @@
def do_GET(self):
path = self.path
url = urlparse.urlparse(path)
- log.request_info("DATA_SERVER_GET", f"GET 璇锋眰寮�濮嬶細{url.path}")
+ request_log_util.request_info("DATA_SERVER_GET", f"GET 璇锋眰寮�濮嬶細{url.path}")
try:
if url.path == "/kpl/get_limit_up_list":
response_data = self.__get_limit_up_list()
@@ -287,12 +285,12 @@
result = hosting_api_util.get_from_data_server(url.path, ps_dict)
self.__send_response(result)
finally:
- log.request_info("DATA_SERVER_GET", f"GET 璇锋眰缁撴潫")
+ request_log_util.request_info("DATA_SERVER_GET", f"GET 璇锋眰缁撴潫")
def do_POST(self):
path = self.path
url = urlparse.urlparse(path)
- log.request_info("DATA_SERVER_POST", f"POST 璇锋眰寮�濮嬶細{url.path}")
+ request_log_util.request_info("DATA_SERVER_POST", f"POST 璇锋眰寮�濮嬶細{url.path}")
try:
if url.path == "/upload_kpl_data":
# 鎺ュ彈寮�鐩樺暒鏁版嵁
@@ -300,7 +298,7 @@
result_str = self.__process_kpl_data(params)
self.__send_response(result_str)
finally:
- log.request_info("DATA_SERVER_POST", f"POST 璇锋眰缁撴潫")
+ request_log_util.request_info("DATA_SERVER_POST", f"POST 璇锋眰缁撴潫")
def __process_kpl_data(self, data):
data = json.loads(json.dumps(data).replace("姒傚康", ""))
diff --git a/db/mysql_data.py b/db/mysql_data.py
index f614cb0..142917a 100644
--- a/db/mysql_data.py
+++ b/db/mysql_data.py
@@ -6,11 +6,11 @@
# 鎶婅繛鎺ュ弬鏁板畾涔夋垚瀛楀吀
import constant
-config = constant.MYSQL_CONFIG
class Mysqldb:
# 鍒濆鍖栨柟娉�
- def __init__(self):
+ def __init__(self, config=constant.MYSQL_CONFIG):
+ self.config = config
# 鍒濆鍖栨柟娉曚腑璋冪敤杩炴帴鏁版嵁搴撶殑鏂规硶
self.conn = self.get_conn()
# 璋冪敤鑾峰彇娓告爣鐨勬柟娉�
@@ -22,7 +22,7 @@
# 杩炴帴鏁版嵁搴撶殑鏂规硶
def get_conn(self):
# **config浠ｈ〃涓嶅畾闀垮弬鏁�
- conn = pymysql.connect(**config)
+ conn = pymysql.connect(**self.config)
return conn
# 鑾峰彇娓告爣
@@ -82,4 +82,5 @@
# 鎻掑叆鍗曟潯鏁版嵁
mysqldb.execute("insert into clients(account,pwd,rule) values(%s,%s,%s)", ("test", 123456, "\"123"))
# 鎻掑叆澶氭潯鏁版嵁
- mysqldb.execute_many("insert into clients(account,pwd,rule) values(%s,%s,%s)", [("test", 123456, "\"123"),("test", 123456, "\"123")])
+ mysqldb.execute_many("insert into clients(account,pwd,rule) values(%s,%s,%s)",
+ [("test", 123456, "\"123"), ("test", 123456, "\"123")])
diff --git a/db/redis_manager.py b/db/redis_manager.py
index 83e36df..edcbc5a 100644
--- a/db/redis_manager.py
+++ b/db/redis_manager.py
@@ -6,7 +6,7 @@
import redis
import constant
-from log import logger_redis_debug
+from log_module.log import logger_redis_debug
config = constant.REDIS_CONFIG
diff --git a/huaxin_client/client_network.py b/huaxin_client/client_network.py
new file mode 100644
index 0000000..6dfc41f
--- /dev/null
+++ b/huaxin_client/client_network.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+import json
+import socket
+
+from utils import socket_util
+
+SERVER_IP = "127.0.0.1"
+SERVER_PORT = 10008
+
+
+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=SERVER_IP, port=SERVER_PORT):
+ client = socket.socket() # 鐢熸垚socket锛岃繛鎺erver
+ 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)
+ # printlog("鍝嶅簲", 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
diff --git a/huaxin_client/command_manager.py b/huaxin_client/command_manager.py
new file mode 100644
index 0000000..98ba099
--- /dev/null
+++ b/huaxin_client/command_manager.py
@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+"""
+鍛戒护绠＄悊鍣�
+"""
+import concurrent.futures
+import logging
+import multiprocessing
+import threading
+
+from log_module import async_log_util
+from log_module.log import logger_local_huaxin_trade_debug, logger_trade, logger_local_huaxin_contact_debug, logger_info
+
+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, sk, type_, data):
+ pass
+
+ # 濮旀墭鍒楄〃
+ def OnDelegateList(self, client_id, request_id, sk, can_cancel):
+ pass
+
+ # 鎴愪氦鍒楄〃
+ def OnDealList(self, client_id, request_id, sk):
+ pass
+
+ # 鎴愪氦鍒楄〃
+ def OnPositionList(self, client_id, request_id, sk):
+ pass
+
+ # 鑾峰彇璧勯噾淇℃伅
+ def OnMoney(self, client_id, request_id, sk):
+ pass
+
+ # 娴嬭瘯
+ def OnTest(self, client_id, request_id, data, sk):
+ pass
+
+
+class L2ActionCallback(object):
+ # 鐩戝惉L2鏁版嵁
+ def OnSetL2Position(self, codes_data):
+ pass
+
+
+# 浜ゆ槗鎸囦护绠＄悊
+class TradeCommandManager:
+ trade_client_dict = {}
+ _instance = None
+ process_command_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=30)
+
+ 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: TradeActionCallback,
+ queue_strategy_trade_read_for_trade: multiprocessing.Queue,
+ queue_strategy_w_trade_r_for_query: multiprocessing.Queue):
+ cls.action_callback = trade_action_callback
+ cls.queue_strategy_w_trade_r = queue_strategy_trade_read_for_trade
+ cls.queue_strategy_w_trade_r_for_query = queue_strategy_w_trade_r_for_query
+
+ @classmethod
+ def process_command(cls, _type, client_id, result_json, sk=None):
+ async_log_util.info(logger_local_huaxin_contact_debug, f"process_command锛� {result_json}")
+ # 鏌ョ湅鏄惁鏄缃甃2鐨勪唬鐮�
+ try:
+ data = result_json["data"]
+ request_id = result_json.get('request_id')
+
+ if _type == CLIENT_TYPE_TRADE:
+ # 浜ゆ槗
+ ctype = data["trade_type"]
+ async_log_util.info(logger_trade, f"浜ゆ槗寮�濮�:{request_id}")
+ cls.action_callback.OnTrade(client_id, request_id, sk, ctype, data)
+ async_log_util.info(logger_trade, f"浜ゆ槗缁撴潫:{request_id}")
+ elif _type == CLIENT_TYPE_MONEY:
+ cls.action_callback.OnMoney(client_id, request_id, sk)
+ elif _type == CLIENT_TYPE_DEAL_LIST:
+ cls.action_callback.OnDealList(client_id, request_id, sk)
+ elif _type == CLIENT_TYPE_DELEGATE_LIST:
+ can_cancel = data["can_cancel"]
+ cls.action_callback.OnDelegateList(client_id, request_id, sk, can_cancel)
+ elif _type == CLIENT_TYPE_POSITION_LIST:
+ cls.action_callback.OnPositionList(client_id, request_id, sk)
+ elif _type == "test":
+ cls.action_callback.OnTest(client_id, request_id, data, sk)
+ except Exception as e:
+ async_log_util.error(logger_local_huaxin_contact_debug, f"process_command鍑洪敊锛� {result_json}")
+ # logging.exception(e)
+ # logging.error(result_json)
+
+ @classmethod
+ def run_process_command(cls, queue_strategy_trade: multiprocessing.Queue):
+ if queue_strategy_trade is None:
+ return
+ # 鏈湴鍛戒护鎺ユ敹
+ try:
+ while True:
+ try:
+ val = queue_strategy_trade.get()
+ if val:
+ _type = val["type"]
+ if _type != "test":
+ async_log_util.info(logger_local_huaxin_contact_debug, f"鎺ュ彈鍒颁俊鎭細 {val}")
+ # TODO 娴嬭瘯
+ logger_info.info(f"鎺ュ彈鍒颁俊鎭細 {val}")
+ cls.process_command(_type, None, val)
+ except Exception as e:
+ async_log_util.exception(logger_local_huaxin_trade_debug, e)
+ logging.exception(e)
+ except Exception as e:
+ async_log_util.exception(logger_local_huaxin_trade_debug, e)
+
+ # 缁存姢杩炴帴鏁扮殑绋冲畾
+ def run(self, blocking=True):
+ if blocking:
+ threading.Thread(target=lambda: self.run_process_command(self.queue_strategy_w_trade_r_for_query),
+ daemon=True).start()
+ self.run_process_command(self.queue_strategy_w_trade_r)
+ else:
+ # 鎺ュ彈鍛戒护
+ threading.Thread(target=lambda: self.run_process_command(self.queue_strategy_w_trade_r), daemon=True).start()
+ threading.Thread(target=lambda: self.run_process_command(self.queue_strategy_w_trade_r_for_query),
+ daemon=True).start()
+
+# L2鎸囦护绠＄悊
+class L2CommandManager:
+ action_callback = None
+
+ @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"]
+ ctype = result_json["type"]
+ if ctype == CLIENT_TYPE_CMD_L2:
+ cls.action_callback.OnSetL2Position(data)
+
+
+if __name__ == "__main__":
+ manager = TradeCommandManager("127.0.0.1", 10008, None)
+ manager.run()
+ input()
diff --git a/huaxin_client/huaxin_trade_client.py b/huaxin_client/huaxin_trade_client.py
new file mode 100644
index 0000000..2ee8361
--- /dev/null
+++ b/huaxin_client/huaxin_trade_client.py
@@ -0,0 +1,524 @@
+# -*- coding: utf-8 -*-
+import concurrent.futures
+import threading
+import time
+
+from loguru import logger
+
+import traderapi
+from huaxin_client import trade_manager
+from huaxin_client.command_manager import TradeCommandManager
+from huaxin_client.trade_manager import TradeSimpleApi
+from log_module import async_log_util
+from log_module.log import logger_system, printlog, logger_local_huaxin_trade_debug, logger_info
+
+TEST_TRADE = True
+
+########B绫�########
+UserID = '388000013349'
+# 鐧婚檰瀵嗙爜
+Password = '110808'
+# 鎶曡祫鑰呰处鎴�
+InvestorID = '388000013349'
+# 缁忔祹鍏徃閮ㄩ棬浠ｇ爜
+DepartmentID = '0003'
+# 璧勯噾璐︽埛
+AccountID = '388000013349'
+# 娌競鑲′笢璐﹀彿
+SSE_ShareHolderID = 'A641420991'
+# 娣卞競鑲′笢璐﹀彿
+SZSE_ShareHolderID = '0345104949'
+
+LOCAL_IP = "192.168.84.75"
+FRONT_ADDRESS = "tcp://192.168.84.31:6500"
+FRONT_ADDRESS1 = "tcp://192.168.84.32:26500"
+
+if TEST_TRADE:
+ # # 浠跨湡
+ # from mylog import logger_trade_debug
+ #
+ UserID = '00032047'
+ # 鐧婚檰瀵嗙爜
+ Password = '59009218'
+ # 鎶曡祫鑰呰处鎴�
+ InvestorID = '00032047'
+ # 缁忔祹鍏徃閮ㄩ棬浠ｇ爜
+ DepartmentID = '0003'
+ # 璧勯噾璐︽埛
+ AccountID = '00032047'
+ # 娌競鑲′笢璐﹀彿
+ SSE_ShareHolderID = 'A00032047'
+ # 娣卞競鑲′笢璐﹀彿
+ SZSE_ShareHolderID = '700032047'
+
+
+class TraderSpi(traderapi.CTORATstpTraderSpi):
+ def __init__(self, api, callback):
+ traderapi.CTORATstpTraderSpi.__init__(self)
+ self.__api = api
+ 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 = {}
+ self.call_back_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
+
+ def OnFrontConnected(self) -> "void":
+
+ # 鑾峰彇缁堢淇℃伅
+ TradeSimpleApi.req_id += 1
+
+ ret = self.__api.ReqGetConnectionInfo(TradeSimpleApi.req_id)
+ if ret != 0:
+ logger_system.info('ReqGetConnectionInfo fail, ret[%d]' % ret)
+
+ def OnFrontDisconnected(self, nReason: "int") -> "void":
+ printlog('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锛夊瘑鐮佽璇�
+ # 瀵嗙爜璁よ瘉鏃禔uthMode鍙笉濉�
+ # 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 = f'PC;IIP=NA;IPORT=NA;LIP={LOCAL_IP};MAC=5C6F69CC2B40;HD=004bc76004aff0882b9052ba0eb00506;@jiabei'
+ # 浠ヤ笅鍐呭缃慖P鍦板潃鑻ヤ笉濉垯鏌滃彴绯荤粺鑷姩閲囬泦锛岃嫢濉啓鍒欎互缁堢濉�间负鍑嗘姤閫�
+ # 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 = self.__api.ReqUserLogin(login_req, TradeSimpleApi.req_id)
+ if ret != 0:
+ printlog('ReqUserLogin fail, ret[%d]' % ret)
+ else:
+ printlog('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_system.info('Login success! [%d]' % nRequestID)
+ self.__front_id = pRspUserLoginField.FrontID
+ self.__session_id = pRspUserLoginField.SessionID
+ # TradeSimpleApi.set_login_info(self.__session_id, self.__front_id)
+
+ # if 1:
+ # # 鏌ヨ鑲′笢璐﹀彿
+ # 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.info('ReqQryShareholderAccount fail, ret[%d]' % ret)
+
+ else:
+ logger_system.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:
+ printlog('OnRspUserPasswordUpdate: OK! [%d]' % nRequestID)
+ else:
+ printlog('OnRspUserPasswordUpdate: Error! [%d] [%d] [%s]'
+ % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
+
+ def OnRspOrderInsert(self, pInputOrderField: "CTORATstpInputOrderField", pRspInfoField: "CTORATstpRspInfoField",
+ nRequestID: "int") -> "void":
+ try:
+ if pRspInfoField.ErrorID == 0:
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ '[%d] OnRspOrderInsert: OK! [%d]' % (round(time.time() * 1000), nRequestID))
+ else:
+ async_log_util.error(logger_local_huaxin_trade_debug,
+ f"OnRspOrderInsert 鎶ュ崟鍑洪敊锛歿pRspInfoField.ErrorID}-{pRspInfoField.ErrorMsg}")
+ self.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_ORDER, nRequestID,
+ {"sinfo": pInputOrderField.SInfo,
+ "orderStatus": -1,
+ "orderStatusMsg": pRspInfoField.ErrorMsg})
+ except:
+ pass
+
+ # 鎾ゅ崟鍝嶅簲
+ def OnRspOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField",
+ pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ try:
+ if pRspInfoField.ErrorID == 0:
+ async_log_util.info(logger_local_huaxin_trade_debug, 'OnRspOrderAction: OK! [%d]' % nRequestID)
+ self.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_CANCEL_ORDER, nRequestID,
+ {"sinfo": pInputOrderActionField.SInfo,
+ "orderSysID": pInputOrderActionField.OrderSysID,
+ "cancel": 1})
+
+ else:
+ async_log_util.info(logger_local_huaxin_trade_debug, 'OnRspOrderAction: Error! [%d] [%d] [%s]'
+ % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
+ self.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_CANCEL_ORDER, nRequestID,
+ {"sinfo": pInputOrderActionField.SInfo,
+ "orderSysID": pInputOrderActionField.OrderSysID,
+ "cancel": 0, "errorID": pRspInfoField.ErrorID,
+ "errorMsg": pRspInfoField.ErrorMsg})
+ except:
+ pass
+
+ # 鎾ゅ崟閿欒鍥炴姤
+ def OnErrRtnOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField",
+ pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ try:
+ if pInputOrderActionField and pRspInfoField:
+ async_log_util.info(logger_local_huaxin_trade_debug, 'OnErrRtnOrderAction: Error! [%d] [%d] [%d] [%s]'
+ % (nRequestID, pInputOrderActionField.OrderSysID,
+ pRspInfoField.ErrorID,
+ pRspInfoField.ErrorMsg))
+ except:
+ async_log_util.info(logger_local_huaxin_trade_debug, "OnErrRtnOrderAction: 鎾ゅ崟鍑洪敊")
+
+ def OnRspInquiryJZFund(self, pRspInquiryJZFundField: "CTORATstpRspInquiryJZFundField",
+ pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ # try:
+ # 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))
+ # except:
+ # pass
+ pass
+
+ def OnRspTransferFund(self, pInputTransferFundField: "CTORATstpInputTransferFundField",
+ pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ # try:
+ # if pRspInfoField.ErrorID == 0:
+ # logger.info('OnRspTransferFund: OK! [%d]' % nRequestID)
+ # else:
+ # logger.info('OnRspTransferFund: Error! [%d] [%d] [%s]'
+ # % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
+ # except:
+ # pass
+ pass
+
+ def OnRtnOrder(self, pOrderField: "CTORATstpOrderField") -> "void":
+ try:
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ '[%d] OnRtnOrder: SInfo[%s] InvestorID[%s] SecurityID[%s] OrderRef[%d] OrderLocalID[%s] LimitPrice[%.2f] VolumeTotalOriginal[%d] OrderSysID[%s] OrderStatus[%s] InsertTime[%s]'
+ % (round(time.time() * 1000), pOrderField.SInfo, pOrderField.InvestorID,
+ pOrderField.SecurityID,
+ pOrderField.OrderRef, pOrderField.OrderLocalID,
+ pOrderField.LimitPrice, pOrderField.VolumeTotalOriginal, pOrderField.OrderSysID,
+ pOrderField.OrderStatus, pOrderField.InsertTime))
+ if pOrderField.OrderStatus == traderapi.TORA_TSTP_OST_Unknown:
+ pass
+ # if queue_trade_w_l2_r is not None:
+ # queue_trade_w_l2_r.put_nowait(
+ # json.dumps({"type": "listen_volume", "data": {"code": pOrderField.SecurityID,
+ # "volume": pOrderField.VolumeTotalOriginal}}).encode(
+ # 'utf-8'))
+ else:
+ order_data = {"sinfo": pOrderField.SInfo, "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,
+ "orderRef": pOrderField.OrderRef, "turnover": pOrderField.Turnover,
+ "volume": pOrderField.VolumeTotalOriginal, "volumeTraded": pOrderField.VolumeTraded,
+ "orderStatus": pOrderField.OrderStatus,
+ "orderSubmitStatus": pOrderField.OrderSubmitStatus,
+ "statusMsg": pOrderField.StatusMsg}
+ self.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_ORDER, 0, order_data)
+ except Exception as e:
+ async_log_util.error(logger_local_huaxin_trade_debug, "OnRtnOrder 鍑洪敊")
+ except:
+ async_log_util.error(logger_local_huaxin_trade_debug, "OnRtnOrder 鍑洪敊")
+
+ def OnRtnTrade(self, pTradeField: "CTORATstpTradeField") -> "void":
+ try:
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ '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))
+ except:
+ pass
+
+ 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): 寮�鐩橀泦鍚堢珵浠�
+ try:
+ logger.info('OnRtnMarketStatus: MarketID[%s] MarketStatus[%s]'
+ % (pMarketStatusField.MarketID, pMarketStatusField.MarketStatus))
+ except:
+ pass
+
+ 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_local_huaxin_trade_debug.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":
+ try:
+ 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.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_LIST_MONEY, nRequestID,
+ results)
+ # logger.info('鏌ヨ璧勯噾璐﹀彿缁撴潫[%d] ErrorID[%d] ErrorMsg[%s]'
+ # % (nRequestID, pRspInfoField.ErrorID, pRspInfoField.ErrorMsg))
+ except:
+ pass
+
+ def OnRspQryOrder(self, pOrderField: "CTORATstpOrderField", pRspInfoField: "CTORATstpRspInfoField",
+ nRequestID: "int", bIsLast: "bool") -> "void":
+ try:
+ 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, "orderRef": pOrderField.OrderRef,
+ "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.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_LIST_DELEGATE, nRequestID,
+ self.__temp_order_list_dict[nRequestID])
+
+ self.__temp_order_list_dict.pop(nRequestID)
+ except:
+ pass
+
+ def OnRspQryPosition(self, pPositionField: "CTORATstpPositionField", pRspInfoField: "CTORATstpRspInfoField",
+ nRequestID: "int", bIsLast: "bool") -> "void":
+ try:
+ 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.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_LIST_POSITION, nRequestID,
+ self.__temp_position_list_dict[nRequestID])
+
+ self.__temp_position_list_dict.pop(nRequestID)
+ except:
+ pass
+
+ # 鎴愪氦鍥炴姤,鍙傛暟pTradeField鏄竴涓狢TORATstpTradeField绫诲璞�
+ def OnRtnTrade(self, pTradeField: "CTORATstpTradeField") -> "void":
+ pass
+ # logger.info("OnRtnTrade")
+
+ # 鏌ヨ鎴愪氦鍝嶅簲,鍙傛暟pTradeField鏄竴涓狢TORATstpTradeField绫诲璞�
+ def OnRspQryTrade(self, pTradeField: "CTORATstpTradeField", pRspInfoField: "CTORATstpRspInfoField",
+ nRequestID: "int", bIsLast: "bool") -> "void":
+ try:
+ # logger.info("鏌ヨ鎴愪氦鍝嶅簲")
+ pass
+ 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.call_back_thread_pool.submit(self.__data_callback, trade_manager.TYPE_LIST_TRADED, nRequestID,
+ self.__temp_order_list_dict[nRequestID])
+ self.__temp_order_list_dict.pop(nRequestID)
+ except:
+ pass
+
+
+def run(queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query, queue_result):
+ """
+ 浜ゆ槗杩愯
+ :param queue_strategy_w_trade_r:
+ :return:
+ """
+ logger_system.info("浜ゆ槗鍒濆鍖�")
+ # -----------鍒濆鍖栦氦鏄撶幆澧�---------------------
+ trade_manager.set_result_read_queue(queue_result)
+ api = traderapi.CTORATstpTraderApi.CreateTstpTraderApi('./flow', False)
+ # 鍒涘缓鍥炶皟瀵硅薄
+ spi = TraderSpi(api, trade_manager.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 not TEST_TRADE: # 妯℃嫙鐜锛孴CP 鐩磋繛Front鏂瑰紡
+ # 娉ㄥ唽鍗曚釜浜ゆ槗鍓嶇疆鏈嶅姟鍦板潃
+ ##B绫绘湇鍔″櫒##
+ logger.info(f"娉ㄥ唽浜ゆ槗鍦板潃锛歿FRONT_ADDRESS}/{FRONT_ADDRESS1}")
+ api.RegisterFront(FRONT_ADDRESS) # 姝ｅ紡鐜涓诲湴鍧�
+ api.RegisterFront(FRONT_ADDRESS1) # 姝ｅ紡鐜澶囩敤鍦板潃
+
+ ##A绫绘湇鍔″櫒##
+ # api.RegisterFront("tcp://10.224.123.143:6500") # 姝ｅ紡鐜涓诲湴鍧�
+ # api.RegisterFront("tcp://10.224.123.147: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")
+ # printlog("TD_TCP_FensAddress[sim or 24H]::%s\n" % TD_TCP_FrontAddress)
+
+ else: # 妯℃嫙鐜锛孎ENS鍚嶅瓧鏈嶅姟鍣ㄦ柟寮�
+ 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")
+ printlog("TD_TCP_FensAddress[sim or 24H]::%s\n" % TD_TCP_FrontAddress)
+
+ # 璁㈤槄绉佹湁娴�
+ api.SubscribePrivateTopic(traderapi.TORA_TERT_QUICK)
+ # 璁㈤槄鍏湁娴�
+ api.SubscribePublicTopic(traderapi.TORA_TERT_QUICK)
+ # 鍚姩鎺ュ彛
+ api.Init()
+
+ threading.Thread(target=async_log_util.run_sync, daemon=True).start()
+
+ data_callback = trade_manager.MyTradeActionCallback(UserID, Password, SZSE_ShareHolderID, SSE_ShareHolderID, api)
+ # 涓嶉渶瑕佽繍琛屽懡浠よВ鏋�
+ tradeCommandManager = TradeCommandManager()
+ tradeCommandManager.init(
+ data_callback,
+ queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query)
+ logger_info.debug("鍏ㄩ儴鍒濆鍖栧畬鎴�")
+ tradeCommandManager.run(True)
+ while True:
+ time.sleep(2)
+
+
+if __name__ == "__main__":
+ pass
diff --git a/huaxin_client/trade_manager.py b/huaxin_client/trade_manager.py
new file mode 100644
index 0000000..187f41b
--- /dev/null
+++ b/huaxin_client/trade_manager.py
@@ -0,0 +1,616 @@
+"""
+鍗庨懌浜ゆ槗绠＄悊
+"""
+import concurrent.futures
+import json
+import logging
+import time
+import multiprocessing
+
+import traderapi
+from huaxin_client.client_network import SendResponseSkManager
+from huaxin_client.command_manager import TradeActionCallback
+from log_module import async_log_util
+from log_module.log import logger_trade, logger_local_huaxin_trade_debug, printlog
+from utils import tool, socket_util
+
+ENABLE_ORDER = True
+
+TYPE_ORDER = 0
+TYPE_CANCEL_ORDER = 1
+TYPE_LIST_DELEGATE = 2
+TYPE_LIST_TRADED = 3
+TYPE_LIST_POSITION = 4
+TYPE_LIST_MONEY = 5
+# 鎴愪氦
+TYPE_DEAL = 6
+
+__queue_result: multiprocessing.Queue = None
+
+
+def set_result_read_queue(queue_result):
+ """
+ 璁剧疆缁撴灉璇诲彇闃熷垪
+ :param queue_result:
+ :return:
+ """
+ global __queue_result
+ __queue_result = queue_result
+
+
+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, show_log=True):
+ if show_log:
+ async_log_util.debug(logger_local_huaxin_trade_debug, f"鍥炶皟杩斿洖鍐呭锛歿data}")
+ __queue_result.put_nowait(data)
+
+
+# 浜ゆ槗鍙嶉鍥炶皟
+def __traderapi_callback(type, req_id, data):
+ async_log_util.info(logger_local_huaxin_trade_debug, "鍥炶皟:type-{} req_id-{}", type, req_id)
+ key = req_id
+ if type == TYPE_ORDER or type == TYPE_CANCEL_ORDER:
+ key = data["sinfo"]
+ try:
+ if req_rid_dict and key in req_rid_dict:
+ temp_params = req_rid_dict.pop(key)
+ client_id, request_id = temp_params[0], temp_params[1]
+ # 鏈湴璁㈠崟鍙�-绯荤粺璁㈠崟鍙锋槧灏�
+ if len(temp_params) >= 4 and type == TYPE_ORDER:
+ order_ref = temp_params[3]
+ data["orderRef"] = order_ref
+
+ async_log_util.info(logger_local_huaxin_trade_debug, "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, temp_params[2])
+ send_response(
+ json.dumps({"type": "response", "data": {"code": 0, "data": data}, "client_id": client_id,
+ "request_id": request_id}), type, client_id, request_id)
+
+ async_log_util.info(logger_local_huaxin_trade_debug, "API鍥炶皟缁撴潫 req_id-{} request_id-{}", req_id, request_id)
+ else:
+ async_log_util.info(logger_local_huaxin_trade_debug, "闈濧PI鍥炶皟 req_id-{}", req_id)
+ send_response(
+ json.dumps({"type": "trade_callback", "data": {"code": 0, "data": data, "type": type}}),
+ type,
+ None,
+ req_id)
+ except Exception as e:
+ logging.exception(e)
+
+
+# 閲囩敤寮傛鍥炶皟
+def traderapi_callback(type, req_id, data):
+ __traderapi_callback(type, req_id, data)
+
+
+req_rid_dict = {}
+
+
+class TradeSimpleApi:
+ req_id = 0
+ __buy_sinfo_set = set()
+ __sell_sinfo_set = set()
+ __cancel_buy_sinfo_set = set()
+ __cancel_sell_sinfo_set = set()
+
+ def __init__(self, UserID, Password, SZSE_ShareHolderID, SSE_ShareHolderID, api: traderapi.CTORATstpTraderApi):
+ """
+
+ :param SZSE_ShareHolderID: 娣辫瘉鎶曡祫鑰呬唬鐮�
+ :param SSE_ShareHolderID: 涓婅瘉鎶曡祫鑰呬唬鐮�
+ :param api: 浜ゆ槗鎺ュ彛
+ """
+ self.UserID = UserID
+ self.Password = Password
+ self.SZSE_ShareHolderID = SZSE_ShareHolderID
+ self.SSE_ShareHolderID = SSE_ShareHolderID
+ self.api = api
+
+
+ @classmethod
+ def set_login_info(cls, session_id, front_id):
+ cls.__session_id = session_id
+ cls.__front_id = front_id
+
+ # sinfo char(32)
+ def buy(self, code, count, price, sinfo, order_ref, shadow_price=None):
+ if not ENABLE_ORDER:
+ return
+ if sinfo in self.__buy_sinfo_set:
+ raise Exception(f'涓嬪崟璇锋眰宸茬粡鎻愪氦锛歿sinfo}')
+ async_log_util.info(logger_trade, f"{code}鍗庨懌鏈湴鐪熷疄涓嬪崟寮�濮�")
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"杩涘叆涔板叆鏂规硶锛歝ode-{code} sinfo-{sinfo} order_ref-{order_ref}")
+ 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 tool.get_market_type(code) == tool.MARKET_TYPE_SZSE:
+ req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
+ req_field.ShareholderID = self.SZSE_ShareHolderID
+ elif tool.get_market_type(code) == tool.MARKET_TYPE_SSE:
+ req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE
+ req_field.ShareholderID = self.SSE_ShareHolderID
+
+ # 璇佸埜浠ｇ爜
+ req_field.SecurityID = code
+ req_field.Direction = traderapi.TORA_TSTP_D_Buy
+ req_field.VolumeTotalOriginal = count
+ req_field.SInfo = sinfo
+ req_field.OrderRef = order_ref
+
+ '''
+ 涓婁氦鎵�鏀寔闄愪环鎸囦护鍜屾渶浼樹簲妗ｅ墿鎾ゃ�佹渶浼樹簲妗ｅ墿杞檺涓ょ甯備环鎸囦护锛屽浜庣鍒涙澘棰濆鏀寔鏈柟鏈�浼樺拰瀵规墜鏂规渶浼樹袱绉嶅競浠锋寚浠ゅ拰鐩樺悗鍥哄畾浠锋牸鐢虫姤鎸囦护
+ 娣变氦鎵�鏀寔闄愪环鎸囦护鍜岀珛鍗虫垚浜ゅ墿浣欐挙閿�銆佸叏棰濇垚浜ゆ垨鎾ら攢銆佹湰鏂规渶浼樸�佸鎵嬫柟鏈�浼樺拰鏈�浼樹簲妗ｅ墿鎾や簲绉嶅競浠锋寚浠�
+ 闄愪环鎸囦护鍜屼笂浜ゆ墍绉戝垱鏉跨洏鍚庡浐瀹氫环鏍肩敵鎶ユ寚浠ら渶濉啓鎶ュ崟浠锋牸锛屽叾瀹冨競浠锋寚浠ゆ棤闇�濉啓鎶ュ崟浠锋牸
+ 浠ヤ笅浠ヤ笂浜ゆ墍闄愪环鎸囦护涓轰緥锛屽叾瀹冩寚浠ゅ弬鑰冨紑鍙戞寚鍗楃浉鍏宠鏄庡～鍐橭rderPriceType銆乀imeCondition鍜孷olumeCondition涓変釜瀛楁:
+ '''
+ 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涓烘姤鍗曞紩鐢紝绫诲瀷涓烘暣鍨嬶紝璇ュ瓧娈垫姤鍗曟椂涓洪�夊～
+ 鑻ヤ笉濉啓锛屽垯绯荤粺浼氫负姣忕瑪鎶ュ崟鑷姩鍒嗛厤涓�涓姤鍗曞紩鐢�
+ 鑻ュ～鍐欙紝鍒欓渶淇濊瘉鍚屼竴涓猅CP浼氳瘽涓嬫姤鍗曞紩鐢ㄤ弗鏍煎崟璋冮�掑锛屼笉瑕佹眰杩炵画閫掑锛岃嚦灏戦渶浠�1寮�濮嬬紪鍙�
+ '''
+ # req_field.OrderRef = 1
+
+ '''
+ InvestorID涓洪�夊～锛岃嫢濉啓鍒欓渶淇濊瘉濉啓姝ｇ‘
+ Operway涓哄鎵樻柟寮忥紝鏍规嵁鍒稿晢瑕佹眰濉啓锛屾棤鐗规畩璇存槑缃┖鍗冲彲
+ 缁堢鑷畾涔夊瓧娈碉紝缁堢鍙牴鎹渶瑕佸～鍐欏涓嬪瓧娈电殑鍊硷紝璇ュ瓧娈靛�间笉浼氳鏌滃彴绯荤粺淇敼锛屽湪鎶ュ崟鍥炴姤鍜屾煡璇㈡姤鍗曟椂杩斿洖缁欑粓绔�
+ '''
+ # req_field.SInfo = 'sinfo'
+ # req_field.IInfo = 123
+
+ '''
+ 鍏跺畠瀛楁缃┖
+ '''
+ # 缁橪2鍙戦�佹秷鎭�
+
+ ret = self.api.ReqOrderInsert(req_field, self.req_id)
+ if ret != 0:
+ raise Exception('ReqOrderInsert fail, ret[%d]' % ret)
+ # 甯告�佸寲鐩戝惉涓嶉渶瑕佸崟鐙缃�
+ # if queue_other_w_l2_r is not None:
+ # queue_other_w_l2_r.put_nowait(
+ # json.dumps({"type": "listen_volume", "data": {"code": code,
+ # "volume": count}}).encode(
+ # 'utf-8'))
+ async_log_util.info(logger_trade, f"{code}鍗庨懌鏈湴鐪熷疄涓嬪崟缁撴潫")
+ # --------------------------------褰卞瓙璁㈠崟--------------------------------
+ if shadow_price:
+ if order_ref:
+ # 涓嬩竴涓奖瀛愯鍗�
+ shadow_order_ref = order_ref + 1
+ shadow_sinfo = f"s_b_{order_ref}"
+ req_field.LimitPrice = shadow_price
+ req_field.SInfo = shadow_sinfo
+ req_field.OrderRef = shadow_order_ref
+ req_field.VolumeTotalOriginal = 100
+ self.req_id += 1
+ ret = self.api.ReqOrderInsert(req_field, self.req_id)
+ if ret != 0:
+ raise Exception('ReqOrderInsert fail, ret[%d]' % ret)
+ # 褰卞瓙璁㈠崟鎾ゅ崟
+ # 鎾ゆ帀褰卞瓙鍗�
+ shadow_cancel_order_ref = shadow_order_ref + 1
+ # 娣辫瘉鍋滅暀50ms涓婅瘉鍋滅暀200ms
+ delay_s = 0.05 if code.find("00") == 0 else 0.2
+ self.cancel_buy(code, f"s_c_{shadow_order_ref}", order_sys_id=None,
+ order_ref=shadow_order_ref,
+ order_action_ref=None, delay_s=delay_s)
+
+ return ret
+
+ # 鎾や拱
+ def cancel_buy(self, code, sinfo, order_sys_id=None, order_ref=None, order_action_ref=None, delay_s=0.0):
+ if delay_s > 0:
+ time.sleep(delay_s)
+ if sinfo in self.__cancel_buy_sinfo_set:
+ raise Exception(f'鎾ゅ崟璇锋眰宸茬粡鎻愪氦锛歿sinfo}')
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"杩涘叆鎾ゅ崟鏂规硶锛歝ode-{code} order_sys_id-{order_sys_id} order_ref-{order_ref} sinfo-{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锛夌郴缁熸姤鍗曠紪鍙锋柟寮�
+ if order_sys_id:
+ req_field.OrderSysID = order_sys_id
+ elif order_ref is not None:
+ req_field.OrderRef = order_ref
+ req_field.SessionID = self.__session_id
+ req_field.FrontID = self.__front_id
+ if order_action_ref:
+ req_field.OrderActionRef = order_action_ref
+
+ # OrderActionRef鎶ュ崟鎿嶄綔寮曠敤锛岀敤娉曞悓鎶ュ崟寮曠敤锛屽彲鏍规嵁闇�瑕侀�夊～
+
+ '''
+ 缁堢鑷畾涔夊瓧娈碉紝缁堢鍙牴鎹渶瑕佸～鍐欏涓嬪瓧娈电殑鍊硷紝璇ュ瓧娈靛�间笉浼氳鏌滃彴绯荤粺淇敼锛屽湪鏌ヨ鎾ゅ崟鏃惰繑鍥炵粰缁堢
+ '''
+ req_field.SInfo = sinfo
+ # req_field.IInfo = 123
+
+ '''
+ 濮旀墭鏂瑰紡瀛楁鏍规嵁鍒稿晢瑕佹眰濉啓锛屾棤鐗规畩璇存槑缃┖鍗冲彲
+ 鍏跺畠瀛楁缃┖
+ '''
+ ret = self.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, order_ref=None):
+ 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 tool.get_market_type(code) == tool.MARKET_TYPE_SZSE:
+ req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SZSE
+ req_field.ShareholderID = self.SZSE_ShareHolderID
+ elif tool.get_market_type(code) == tool.MARKET_TYPE_SSE:
+ req_field.ExchangeID = traderapi.TORA_TSTP_EXD_SSE
+ req_field.ShareholderID = self.SSE_ShareHolderID
+
+ # 璇佸埜浠ｇ爜
+ req_field.SecurityID = code
+ req_field.Direction = traderapi.TORA_TSTP_D_Sell
+ req_field.VolumeTotalOriginal = count
+ req_field.SInfo = sinfo
+
+ '''
+ 涓婁氦鎵�鏀寔闄愪环鎸囦护鍜屾渶浼樹簲妗ｅ墿鎾ゃ�佹渶浼樹簲妗ｅ墿杞檺涓ょ甯備环鎸囦护锛屽浜庣鍒涙澘棰濆鏀寔鏈柟鏈�浼樺拰瀵规墜鏂规渶浼樹袱绉嶅競浠锋寚浠ゅ拰鐩樺悗鍥哄畾浠锋牸鐢虫姤鎸囦护
+ 娣变氦鎵�鏀寔闄愪环鎸囦护鍜岀珛鍗虫垚浜ゅ墿浣欐挙閿�銆佸叏棰濇垚浜ゆ垨鎾ら攢銆佹湰鏂规渶浼樸�佸鎵嬫柟鏈�浼樺拰鏈�浼樹簲妗ｅ墿鎾や簲绉嶅競浠锋寚浠�
+ 闄愪环鎸囦护鍜屼笂浜ゆ墍绉戝垱鏉跨洏鍚庡浐瀹氫环鏍肩敵鎶ユ寚浠ら渶濉啓鎶ュ崟浠锋牸锛屽叾瀹冨競浠锋寚浠ゆ棤闇�濉啓鎶ュ崟浠锋牸
+ 浠ヤ笅浠ヤ笂浜ゆ墍闄愪环鎸囦护涓轰緥锛屽叾瀹冩寚浠ゅ弬鑰冨紑鍙戞寚鍗楃浉鍏宠鏄庡～鍐橭rderPriceType銆乀imeCondition鍜孷olumeCondition涓変釜瀛楁:
+ '''
+
+ printlog('鍗� 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
+ if order_ref:
+ req_field.OrderRef = order_ref
+
+ '''
+ OrderRef涓烘姤鍗曞紩鐢紝绫诲瀷涓烘暣鍨嬶紝璇ュ瓧娈垫姤鍗曟椂涓洪�夊～
+ 鑻ヤ笉濉啓锛屽垯绯荤粺浼氫负姣忕瑪鎶ュ崟鑷姩鍒嗛厤涓�涓姤鍗曞紩鐢�
+ 鑻ュ～鍐欙紝鍒欓渶淇濊瘉鍚屼竴涓猅CP浼氳瘽涓嬫姤鍗曞紩鐢ㄤ弗鏍煎崟璋冮�掑锛屼笉瑕佹眰杩炵画閫掑锛岃嚦灏戦渶浠�1寮�濮嬬紪鍙�
+ '''
+ # req_field.OrderRef = 1
+
+ '''
+ InvestorID涓洪�夊～锛岃嫢濉啓鍒欓渶淇濊瘉濉啓姝ｇ‘
+ Operway涓哄鎵樻柟寮忥紝鏍规嵁鍒稿晢瑕佹眰濉啓锛屾棤鐗规畩璇存槑缃┖鍗冲彲
+ 缁堢鑷畾涔夊瓧娈碉紝缁堢鍙牴鎹渶瑕佸～鍐欏涓嬪瓧娈电殑鍊硷紝璇ュ瓧娈靛�间笉浼氳鏌滃彴绯荤粺淇敼锛屽湪鎶ュ崟鍥炴姤鍜屾煡璇㈡姤鍗曟椂杩斿洖缁欑粓绔�
+ '''
+ # req_field.SInfo = 'sinfo'
+ # req_field.IInfo = 123
+
+ '''
+ 鍏跺畠瀛楁缃┖
+ '''
+ ret = self.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 = self.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:15:00'
+ req_field.InsertTimeEnd = '15:00:00'
+ # IsCancel瀛楁濉�1琛ㄧず鍙煡璇㈠彲鎾ゆ姤鍗�
+ if is_cancel:
+ req_field.IsCancel = 1
+ # req_field.SInfo = sinfo
+ ret = self.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 = self.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 = self.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 = self.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 = self.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锛夊瘑鐮佽璇�
+ # 瀵嗙爜璁よ瘉鏃禔uthMode鍙笉濉�
+ # login_req.AuthMode = traderapi.TORA_TSTP_AM_Password
+ login_req.Password = self.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'
+ # 浠ヤ笅鍐呭缃慖P鍦板潃鑻ヤ笉濉垯鏌滃彴绯荤粺鑷姩閲囬泦锛岃嫢濉啓鍒欎互缁堢濉�间负鍑嗘姤閫�
+ # 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 = self.api.ReqUserLogin(login_req, TradeSimpleApi.req_id)
+ if ret != 0:
+ raise Exception('ReqUserLogin fail, ret[%d]' % ret)
+
+
+class MyTradeActionCallback(TradeActionCallback):
+ trade_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=30)
+
+ def __init__(self, UserID, Password, SZSE_ShareHolderID, SSE_ShareHolderID, api: traderapi.CTORATstpTraderApi):
+ self.__tradeSimpleApi = TradeSimpleApi(UserID, Password, SZSE_ShareHolderID, SSE_ShareHolderID, api)
+
+
+ def OnTrade(self, client_id, request_id, sk, type_, data):
+ if type_ == 1:
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"\n---------------------\n璇锋眰涓嬪崟锛歝lient_id-{client_id} request_id-{request_id} data:{data}")
+ # 涓嬪崟
+ # 1-涔� 2-鍗�
+ direction = data["direction"]
+ code = data["code"]
+ volume = data["volume"]
+ price = data["price"]
+ sinfo = data["sinfo"]
+ order_ref = data.get("order_ref")
+ shadow_price = data.get("shadow_price")
+ blocking = data.get("blocking")
+
+ if direction == 1:
+ async_log_util.info(logger_trade, f"{code}鍗庨懌鏈湴寮�濮嬩笅鍗�")
+ # 涔�
+ try:
+ if blocking:
+ req_rid_dict[sinfo] = (client_id, request_id, sk, order_ref)
+ # threading.Thread(target=lambda: self.__tradeSimpleApi.buy(code, volume, price, sinfo, order_ref),
+ # daemon=True).start()
+ self.trade_thread_pool.submit(self.__tradeSimpleApi.buy, code, volume, price, sinfo, order_ref,
+ shadow_price)
+
+ async_log_util.info(logger_trade, f"{code}鍗庨懌鏈湴涓嬪崟绾跨▼缁撴潫")
+ except Exception as e:
+ send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_ORDER, client_id,
+ request_id)
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"涔板叆缁撴潫锛歝ode-{code} sinfo-{sinfo}")
+ elif direction == 2:
+ try:
+ price_type = data["price_type"]
+ if blocking:
+ req_rid_dict[sinfo] = (client_id, request_id, sk)
+ self.__tradeSimpleApi.sell(code, volume, price, price_type, sinfo, order_ref)
+ printlog("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:
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"\n---------------------\n璇锋眰鎾ゅ崟锛歝lient_id-{client_id} request_id-{request_id} data-{data}")
+ # 鎾ゅ崟
+ direction = data["direction"]
+ code = data["code"]
+ orderSysID = data.get("orderSysID")
+ orderRef = data.get("orderRef")
+ orderActionRef = data.get("orderActionRef")
+ sinfo = data["sinfo"]
+ if direction == 1:
+ # 鎾や拱
+ try:
+ if not orderSysID and orderRef is None:
+ raise Exception("娌℃湁鎵惧埌绯荤粺璁㈠崟鍙锋垨鑰呮姤鍗曞紩鐢�")
+ req_rid_dict[sinfo] = (client_id, request_id, sk)
+ self.trade_thread_pool.submit(
+ lambda: self.__tradeSimpleApi.cancel_buy(code, sinfo, order_sys_id=orderSysID,
+ order_ref=orderRef, order_action_ref=orderActionRef))
+ async_log_util.info(logger_local_huaxin_trade_debug,
+ f"鎾ゅ崟缁撴潫锛歝ode-{code} order_sys_id-{orderSysID} sinfo-{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, sk)
+ 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, sk):
+ async_log_util.info(logger_local_huaxin_trade_debug, f"璇锋眰鎴愪氦鍒楄〃锛歝lient_id-{client_id} request_id-{request_id}")
+ try:
+ # printlog("寮�濮嬭姹傛垚浜ゅ垪琛�")
+ req_id = self.__tradeSimpleApi.list_traded_orders()
+ req_rid_dict[req_id] = (client_id, request_id, sk)
+ 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, sk, is_cancel):
+ async_log_util.info(logger_local_huaxin_trade_debug, f"璇锋眰濮旀墭鍒楄〃锛歝lient_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, sk)
+ 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, sk):
+ async_log_util.info(logger_local_huaxin_trade_debug, f"璇锋眰璐︽埛锛歝lient_id-{client_id} request_id-{request_id}")
+ try:
+ req_id = self.__tradeSimpleApi.get_money_account()
+ req_rid_dict[req_id] = (client_id, request_id, sk)
+ 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, sk):
+ async_log_util.info(logger_local_huaxin_trade_debug, f"璇锋眰鎸佷粨锛歝lient_id-{client_id} request_id-{request_id}")
+ try:
+ req_id = self.__tradeSimpleApi.list_positions()
+ req_rid_dict[req_id] = (client_id, request_id, sk)
+ except Exception as e:
+ send_response(json.dumps({"code": 1, "msg": str(e)}), "common", client_id,
+ request_id)
+
+ def OnTest(self, client_id, request_id, data, sk):
+ send_response(
+ json.dumps({"type": "response", "data": {"code": 0, "data": data}, "client_id": client_id,
+ "request_id": request_id}), type, client_id, request_id, show_log=False, sk=sk)
diff --git a/log.py b/log.py
deleted file mode 100644
index c1cc75f..0000000
--- a/log.py
+++ /dev/null
@@ -1,139 +0,0 @@
-"""
-鏃ュ織
-"""
-import queue
-import sys
-import time
-
-from loguru import logger
-import constant
-from utils import tool
-
-
-class MyLogger:
- def __init__(self):
- logger.remove()
-
- # 鏄剧ず鍦ㄦ帶鍒跺彴
- # logger.add(sys.stdout,
- # filter=lambda record: record["extra"].get("name") == "l2_trade", enqueue=True)
-
- logger.add(self.get_path("first_code", "first_code_record"),
- filter=lambda record: record["extra"].get("name") == "first_code_record",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("debug", "debug"),
- filter=lambda record: record["extra"].get("name") == "debug",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("kpl", "kpl_limit_up_reason_change"),
- filter=lambda record: record["extra"].get("name") == "kpl_limit_up_reason_change",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("kpl", "kpl_limit_up"),
- filter=lambda record: record["extra"].get("name") == "kpl_limit_up",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("kpl", "kpl_debug"),
- filter=lambda record: record["extra"].get("name") == "kpl_debug",
- rotation="00:00", compression="zip", enqueue=True)
-
- # 鐪嬬洏鏃ュ織
- logger.add(self.get_path("kp", "kp_msg"),
- filter=lambda record: record["extra"].get("name") == "kp_msg",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("redis", "redis_debug"),
- filter=lambda record: record["extra"].get("name") == "redis_debug",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("profile", "profile"),
- filter=lambda record: record["extra"].get("name") == "profile",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("request", "request_debug"),
- filter=lambda record: record["extra"].get("name") == "request_debug",
- rotation="00:00", compression="zip", enqueue=True)
-
- logger.add(self.get_path("request", "tuoguan_request_debug"),
- filter=lambda record: record["extra"].get("name") == "tuoguan_request_debug",
- rotation="00:00", compression="zip", enqueue=True)
-
- def get_path(self, dir_name, log_name):
- path_str = "{}/logs/gp/{}/{}".format(constant.get_path_prefix(), dir_name, log_name) + ".{time:YYYY-MM-DD}.log"
- # print(path_str)
- return path_str
-
- def get_logger(self, log_name):
- return logger.bind(name=log_name)
-
-
-__mylogger = MyLogger()
-
-logger_first_code_record = __mylogger.get_logger("first_code_record")
-
-logger_debug = __mylogger.get_logger("debug")
-
-logger_kpl_limit_up_reason_change = __mylogger.get_logger("kpl_limit_up_reason_change")
-
-logger_kpl_limit_up = __mylogger.get_logger("kpl_limit_up")
-
-logger_kpl_debug = __mylogger.get_logger("kpl_debug")
-
-logger_kp_msg = __mylogger.get_logger("kp_msg")
-
-logger_redis_debug = __mylogger.get_logger("redis_debug")
-
-logger_profile = __mylogger.get_logger("profile")
-
-logger_request_debug = __mylogger.get_logger("request_debug")
-
-logger_tuoguan_request_debug = __mylogger.get_logger("tuoguan_request_debug")
-
-
-
-
-class AsyncLogManager:
- __log_queue = queue.Queue()
-
- def __add_log(self, logger, method, *args):
- self.__log_queue.put_nowait((logger, time.time(), method, args))
-
- def debug(self, logger, *args):
- self.__add_log(logger, "debug", *args)
-
- def info(self, logger, *args):
- self.__add_log(logger, "info", *args)
-
- def warning(self, logger, *args):
- self.__add_log(logger, "warning", *args)
-
- def error(self, logger, *args):
- self.__add_log(logger, "error", *args)
-
- def exception(self, logger, *args):
- self.__add_log(logger, "exception", *args)
-
- # 杩愯鍚屾鏃ュ織
- def run_sync(self):
- while True:
- try:
- val = self.__log_queue.get()
- time_s = val[1]
- cmd = val[2]
- method = getattr(val[0], cmd)
- d = list(val[3])
- d[0] = f"[{tool.to_time_str(int(time_s))}.{str(time_s).split('.')[1][:3]}] " + d[0]
- d = tuple(d)
- method(*d)
- except:
- pass
-
-
-async_log_util = AsyncLogManager()
-
-
-def request_info(type_name, content, thread_id=None):
- if not thread_id:
- thread_id = tool.get_thread_id()
- async_log_util.info(logger_request_debug, f"銆恵thread_id}銆戙�恵type_name}銆� {content}")
diff --git a/log_module/async_log_util.py b/log_module/async_log_util.py
new file mode 100644
index 0000000..1cc5d3d
--- /dev/null
+++ b/log_module/async_log_util.py
@@ -0,0 +1,101 @@
+"""
+寮傛鏃ュ織绠＄悊鍣�
+"""
+import logging
+import queue
+import threading
+import time
+
+from log_module.log import printlog, logger_system, logger_debug
+from utils import tool
+
+
+class AsyncLogManager:
+
+ def __init__(self):
+ self.__log_queue = queue.Queue()
+
+ def __add_log(self, logger, method, *args):
+ self.__log_queue.put_nowait((logger, time.time(), method, args))
+
+ def add_log(self, data):
+ self.__log_queue.put_nowait(data)
+
+ def debug(self, logger, *args):
+ self.__add_log(logger, "debug", *args)
+
+ def info(self, logger, *args):
+ self.__add_log(logger, "info", *args)
+
+ def warning(self, logger, *args):
+ self.__add_log(logger, "warning", *args)
+
+ def error(self, logger, *args):
+ self.__add_log(logger, "error", *args)
+
+ def exception(self, logger, *args):
+ self.__add_log(logger, "exception", *args)
+
+ # 杩愯鍚屾鏃ュ織
+ def run_sync(self, add_to_common_log=False):
+ printlog("run_sync", add_to_common_log)
+ logger_system.info(f"run_sync 绾跨▼ID:{tool.get_thread_id()}")
+ while True:
+ # val = self.__log_queue.get()
+ try:
+ val = self.__log_queue.get()
+ if not add_to_common_log:
+ time_s = val[1]
+ cmd = val[2]
+ method = getattr(val[0], cmd)
+ d = list(val[3])
+ d[0] = f"[{tool.to_time_str(int(time_s))}.{str(time_s).split('.')[1][:6]}] " + d[0]
+ d = tuple(d)
+ method(*d)
+ else:
+ _common_log.add_log(val)
+ except Exception as e:
+ logging.exception(e)
+
+
+l2_data_log = AsyncLogManager()
+
+huaxin_l2_log = AsyncLogManager()
+
+_common_log = AsyncLogManager()
+
+
+def debug(logger, *args):
+ _common_log.debug(logger, *args)
+
+
+def info(logger, *args):
+ _common_log.info(logger, *args)
+
+
+def warning(logger, *args):
+ _common_log.warning(logger, *args)
+
+
+def error(logger, *args):
+ _common_log.error(logger, *args)
+
+
+def exception(logger, *args):
+ _common_log.exception(logger, *args)
+
+
+# 杩愯鍚屾鏃ュ織
+def run_sync():
+ logger_system.info(f"async_log 绾跨▼ID:{tool.get_thread_id()}")
+ _common_log.run_sync()
+
+
+if __name__ == "__main__":
+ # info(logger_debug, "*-{}", "test")
+ asyncLogManager = AsyncLogManager()
+ asyncLogManager.info(logger_debug, "娴嬭瘯123")
+ threading.Thread(target=lambda: asyncLogManager.run_sync(), daemon=True).start()
+ time.sleep(1)
+ # info(logger_debug, "002375")
+ run_sync()
diff --git a/log_module/log.py b/log_module/log.py
new file mode 100644
index 0000000..63c5d7f
--- /dev/null
+++ b/log_module/log.py
@@ -0,0 +1,464 @@
+"""
+鏃ュ織
+"""
+import logging
+import os
+import sys
+from loguru import logger
+
+import constant
+
+
+class MyLogger:
+ def __init__(self):
+ logger.remove()
+ # 姣忎竴澶╃敓鎴愪竴涓棩蹇楁枃浠讹紝鍘嗗彶鏃ュ織鏂囦欢閲囩敤zip鍘嬬缉,寮傛鍐欏叆鏃ュ織
+ logger.add(self.get_path("trade", "trade_gui"),
+ filter=lambda record: record["extra"].get("name") == "trade_gui",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_path("trade", "trade"), filter=lambda record: record["extra"].get("name") == "trade",
+ rotation="00:00",
+ compression="zip", enqueue=True)
+ logger.add(self.get_path("trade", "delegate"), filter=lambda record: record["extra"].get("name") == "delegate",
+ rotation="00:00",
+ compression="zip", enqueue=True)
+ logger.add(self.get_path("l2", "l2_error"), filter=lambda record: record["extra"].get("name") == "l2_error",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_process"), filter=lambda record: record["extra"].get("name") == "l2_process",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_path("l2", "l2_process_time"),
+ filter=lambda record: record["extra"].get("name") == "l2_process_time",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade"), filter=lambda record: record["extra"].get("name") == "l2_trade",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_data"), filter=lambda record: record["extra"].get("name") == "l2_data",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_latest_data"),
+ filter=lambda record: record["extra"].get("name") == "l2_latest_data",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("mysql", "mysql_debug"),
+ filter=lambda record: record["extra"].get("name") == "mysql_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ # 鏄剧ず鍦ㄦ帶鍒跺彴
+ logger.add(sys.stdout,
+ filter=lambda record: record["extra"].get("name") == "info", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade_cancel"),
+ filter=lambda record: record["extra"].get("name") == "l2_trade_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/s_cancel"),
+ filter=lambda record: record["extra"].get("name") == "s_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/h_cancel"),
+ filter=lambda record: record["extra"].get("name") == "h_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/l_cancel"),
+ filter=lambda record: record["extra"].get("name") == "l_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/g_cancel"),
+ filter=lambda record: record["extra"].get("name") == "g_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/d_cancel"),
+ filter=lambda record: record["extra"].get("name") == "d_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "cancel/f_cancel"),
+ filter=lambda record: record["extra"].get("name") == "f_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade_buy"),
+ filter=lambda record: record["extra"].get("name") == "l2_trade_buy",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_big_data"),
+ filter=lambda record: record["extra"].get("name") == "l2_big_data",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade_queue"),
+ filter=lambda record: record["extra"].get("name") == "l2_trade_queue",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade_buy_queue"),
+ filter=lambda record: record["extra"].get("name") == "l2_trade_buy_queue",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_trade_buy_progress"),
+ filter=lambda record: record["extra"].get("name") == "l2_trade_buy_progress",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_real_place_order_position"),
+ filter=lambda record: record["extra"].get("name") == "l2_real_place_order_position",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_subscript"),
+ filter=lambda record: record["extra"].get("name") == "l2_codes_subscript",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_market_sell"),
+ filter=lambda record: record["extra"].get("name") == "l2_market_sell",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("l2", "l2_not_buy_reasons"),
+ filter=lambda record: record["extra"].get("name") == "l2_not_buy_reasons",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("juejin", "juejin_tick"),
+ filter=lambda record: record["extra"].get("name") == "juejin_tick",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("juejin", "juejin_trade"),
+ filter=lambda record: record["extra"].get("name") == "juejin_trade",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("juejin", "huaxin_trade"),
+ filter=lambda record: record["extra"].get("name") == "huaxin_trade",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "code_operate"),
+ filter=lambda record: record["extra"].get("name") == "code_operate",
+ rotation="00:00", compression="zip", enqueue=True)
+ # 鏄剧ず鍦ㄦ帶鍒跺彴
+ logger.add(sys.stdout,
+ filter=lambda record: record["extra"].get("name") == "print", enqueue=True)
+
+ logger.add(self.get_path("device", "device"), filter=lambda record: record["extra"].get("name") == "device",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("system", "system"), filter=lambda record: record["extra"].get("name") == "system",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "buy_1_volumn"),
+ filter=lambda record: record["extra"].get("name") == "buy_1_volumn",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "buy_1_volumn_record"),
+ filter=lambda record: record["extra"].get("name") == "buy_1_volumn_record",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "trade_queue_price_info"),
+ filter=lambda record: record["extra"].get("name") == "trade_queue_price_info",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "day_volumn"),
+ filter=lambda record: record["extra"].get("name") == "day_volumn",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("ths", "buy_win_distibute"),
+ filter=lambda record: record["extra"].get("name") == "buy_win_distibute",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("first_code", "first_code_record"),
+ filter=lambda record: record["extra"].get("name") == "first_code_record",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("debug", "debug"),
+ filter=lambda record: record["extra"].get("name") == "debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("debug", "request_api"),
+ filter=lambda record: record["extra"].get("name") == "request_api",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("trade", "trade_record"),
+ filter=lambda record: record["extra"].get("name") == "trade_record",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("trade", "position_api_request"),
+ filter=lambda record: record["extra"].get("name") == "position_api_request",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("score", "place_order_score"),
+ filter=lambda record: record["extra"].get("name") == "place_order_score",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("kpl", "kpl_limit_up_reason_change"),
+ filter=lambda record: record["extra"].get("name") == "kpl_limit_up_reason_change",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("kpl", "kpl_limit_up"),
+ filter=lambda record: record["extra"].get("name") == "kpl_limit_up",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("kpl", "kpl_debug"),
+ filter=lambda record: record["extra"].get("name") == "kpl_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("kpl", "kpl_block_can_buy"),
+ filter=lambda record: record["extra"].get("name") == "kpl_block_can_buy",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("kpl", "kpl_open_limit_up"),
+ filter=lambda record: record["extra"].get("name") == "kpl_open_limit_up",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ # 鐪嬬洏鏃ュ織
+ logger.add(self.get_path("kp", "kp_msg"),
+ filter=lambda record: record["extra"].get("name") == "kp_msg",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("redis", "redis_debug"),
+ filter=lambda record: record["extra"].get("name") == "redis_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("profile", "profile"),
+ filter=lambda record: record["extra"].get("name") == "profile",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ ################################鍗庨懌鏃ュ織################################
+ logger.add(self.get_hx_path("l2", "transaction"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_transaction",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_hx_path("l2", "transaction_sell_order"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_transaction_sell_order",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_hx_path("l2", "transaction_desc"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_transaction_desc",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("l2", "orderdetail"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_orderdetail",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("l2", "marketdata"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_market_data",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("l2", "upload"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_upload",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("l2", "debug"),
+ filter=lambda record: record["extra"].get("name") == "hx_l2_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_hx_path("contact", "debug"),
+ filter=lambda record: record["extra"].get("name") == "hx_contact_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("trade", "trade_callback"),
+ filter=lambda record: record["extra"].get("name") == "hx_trade_callback",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("trade", "debug"),
+ filter=lambda record: record["extra"].get("name") == "hx_trade_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_hx_path("trade", "trade_loop"),
+ filter=lambda record: record["extra"].get("name") == "hx_trade_loop",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "transaction"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_transaction",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_local_huaxin_path("l2", "orderdetail"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_orderdetail",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(self.get_local_huaxin_path("l2", "upload"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_upload",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "error"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_error",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "subscript"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_subscript",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "market"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l2_market",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("contact", "debug"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("trade", "trade_debug"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_trade_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+ logger.add(sys.stdout,
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l1_show_info")
+ logger.add(self.get_local_huaxin_path("l1", "show_info"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l1_show_info",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l1", "l1_for_trade"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l1_trade_info",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "g_cancel"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_g_cancel",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "special_volume"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l2_special_volume",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_local_huaxin_path("l2", "l2_buy_no"),
+ filter=lambda record: record["extra"].get("name") == "local_huaxin_l2_buy_no",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("request", "request_debug"),
+ filter=lambda record: record["extra"].get("name") == "request_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ logger.add(self.get_path("request", "tuoguan_request_debug"),
+ filter=lambda record: record["extra"].get("name") == "tuoguan_request_debug",
+ rotation="00:00", compression="zip", enqueue=True)
+
+ def get_path(self, dir_name, log_name):
+ path_str = "{}/{}/gp/{}/{}".format(constant.get_path_prefix(), constant.LOG_DIR, dir_name,
+ log_name) + ".{time:YYYY-MM-DD}.log"
+ # print(path_str)
+ return path_str
+
+ def get_hx_path(self, dir_name, log_name):
+ path_str = "{}/{}/huaxin/{}/{}".format(constant.get_path_prefix(), constant.LOG_DIR, dir_name,
+ log_name) + ".{time:YYYY-MM-DD}.log"
+ # print(path_str)
+ return path_str
+
+ def get_local_huaxin_path(self, dir_name, log_name):
+ path_str = "{}/{}/huaxin_local/{}/{}".format(constant.get_path_prefix(), constant.LOG_DIR, dir_name,
+ log_name) + ".{time:YYYY-MM-DD}.log"
+ # print(path_str)
+ return path_str
+
+ def get_logger(self, log_name):
+ return logger.bind(name=log_name)
+
+
+__mylogger = MyLogger()
+
+logger_print = __mylogger.get_logger("print")
+
+logger_info = __mylogger.get_logger("info")
+
+logger_trade_gui = __mylogger.get_logger("trade_gui")
+logger_trade = __mylogger.get_logger("trade")
+logger_trade_delegate = __mylogger.get_logger("delegate")
+logger_l2_error = __mylogger.get_logger("l2_error")
+logger_l2_process = __mylogger.get_logger("l2_process")
+logger_l2_process_time = __mylogger.get_logger("l2_process_time")
+logger_l2_data = __mylogger.get_logger("l2_data")
+logger_l2_latest_data = __mylogger.get_logger("l2_latest_data")
+logger_l2_market_sell = __mylogger.get_logger("l2_market_sell")
+logger_l2_not_buy_reasons = __mylogger.get_logger("l2_not_buy_reasons")
+
+logger_l2_trade = __mylogger.get_logger("l2_trade")
+logger_l2_trade_cancel = __mylogger.get_logger("l2_trade_cancel")
+logger_l2_s_cancel = __mylogger.get_logger("s_cancel")
+logger_l2_h_cancel = __mylogger.get_logger("h_cancel")
+logger_l2_d_cancel = __mylogger.get_logger("d_cancel")
+logger_l2_f_cancel = __mylogger.get_logger("f_cancel")
+logger_l2_l_cancel = __mylogger.get_logger("l_cancel")
+logger_l2_g_cancel = __mylogger.get_logger("g_cancel")
+logger_l2_trade_buy = __mylogger.get_logger("l2_trade_buy")
+logger_l2_trade_queue = __mylogger.get_logger("l2_trade_queue")
+logger_l2_trade_buy_queue = __mylogger.get_logger("l2_trade_buy_queue")
+logger_l2_trade_buy_progress = __mylogger.get_logger("l2_trade_buy_progress")
+logger_real_place_order_position = __mylogger.get_logger("l2_real_place_order_position")
+# 浠ｇ爜璁㈤槄鏃ュ織
+logger_l2_codes_subscript = __mylogger.get_logger("l2_codes_subscript")
+
+logger_l2_big_data = __mylogger.get_logger("l2_big_data")
+logger_juejin_tick = __mylogger.get_logger("juejin_tick")
+logger_juejin_trade = __mylogger.get_logger("juejin_trade")
+logger_huaxin_trade = __mylogger.get_logger("huaxin_trade")
+logger_code_operate = __mylogger.get_logger("code_operate")
+logger_device = __mylogger.get_logger("device")
+logger_system = __mylogger.get_logger("system")
+
+logger_buy_1_volumn = __mylogger.get_logger("buy_1_volumn")
+
+logger_buy_1_volumn_record = __mylogger.get_logger("buy_1_volumn_record")
+
+logger_trade_queue_price_info = __mylogger.get_logger("trade_queue_price_info")
+
+logger_day_volumn = __mylogger.get_logger("day_volumn")
+
+logger_buy_win_distibute = __mylogger.get_logger("buy_win_distibute")
+
+logger_first_code_record = __mylogger.get_logger("first_code_record")
+
+logger_debug = __mylogger.get_logger("debug")
+
+logger_request_api = __mylogger.get_logger("request_api")
+
+logger_trade_record = __mylogger.get_logger("trade_record")
+
+logger_trade_position_api_request = __mylogger.get_logger("position_api_request")
+
+logger_place_order_score = __mylogger.get_logger("place_order_score")
+
+logger_kpl_limit_up_reason_change = __mylogger.get_logger("kpl_limit_up_reason_change")
+
+logger_kpl_limit_up = __mylogger.get_logger("kpl_limit_up")
+
+logger_kpl_debug = __mylogger.get_logger("kpl_debug")
+
+logger_kpl_block_can_buy = __mylogger.get_logger("kpl_block_can_buy")
+
+logger_kpl_open_limit_up = __mylogger.get_logger("kpl_open_limit_up")
+
+logger_kp_msg = __mylogger.get_logger("kp_msg")
+
+logger_redis_debug = __mylogger.get_logger("redis_debug")
+
+logger_profile = __mylogger.get_logger("profile")
+
+logger_mysql_debug = __mylogger.get_logger("mysql_debug")
+
+# -------------------------------鍗庨懌鏃ュ織---------------------------------
+hx_logger_l2_orderdetail = __mylogger.get_logger("hx_l2_orderdetail")
+hx_logger_l2_transaction = __mylogger.get_logger("hx_l2_transaction")
+hx_logger_l2_transaction_sell_order = __mylogger.get_logger("hx_l2_transaction_sell_order")
+hx_logger_l2_transaction_desc = __mylogger.get_logger("hx_l2_transaction_desc")
+hx_logger_l2_market_data = __mylogger.get_logger("hx_l2_market_data")
+hx_logger_l2_upload = __mylogger.get_logger("hx_l2_upload")
+hx_logger_l2_debug = __mylogger.get_logger("hx_l2_debug")
+hx_logger_contact_debug = __mylogger.get_logger("hx_contact_debug")
+hx_logger_trade_callback = __mylogger.get_logger("hx_trade_callback")
+hx_logger_trade_debug = __mylogger.get_logger("hx_trade_debug")
+hx_logger_trade_loop = __mylogger.get_logger("hx_trade_loop")
+
+# -------------------------------鍗庨懌鏈湴鏃ュ織---------------------------------
+logger_local_huaxin_l2_transaction = __mylogger.get_logger("local_huaxin_transaction")
+logger_local_huaxin_l2_orderdetail = __mylogger.get_logger("local_huaxin_orderdetail")
+logger_local_huaxin_l2_upload = __mylogger.get_logger("local_huaxin_upload")
+logger_local_huaxin_l2_error = __mylogger.get_logger("local_huaxin_error")
+logger_local_huaxin_l2_subscript = __mylogger.get_logger("local_huaxin_subscript")
+logger_local_huaxin_l2_market = __mylogger.get_logger("local_huaxin_l2_market")
+logger_local_huaxin_contact_debug = __mylogger.get_logger("local_huaxin_debug")
+logger_local_huaxin_trade_debug = __mylogger.get_logger("local_huaxin_trade_debug")
+logger_local_huaxin_l1 = __mylogger.get_logger("local_huaxin_l1_show_info")
+logger_local_huaxin_g_cancel = __mylogger.get_logger("local_huaxin_g_cancel")
+logger_local_huaxin_l2_buy_no = __mylogger.get_logger("local_huaxin_l2_buy_no")
+logger_local_huaxin_l1_trade_info = __mylogger.get_logger("local_huaxin_l1_trade_info")
+logger_local_huaxin_l2_special_volume = __mylogger.get_logger("local_huaxin_l2_special_volume")
+
+logger_request_debug = __mylogger.get_logger("request_debug")
+
+logger_tuoguan_request_debug = __mylogger.get_logger("tuoguan_request_debug")
+
+
+def close_print():
+ logging.basicConfig(level=logging.ERROR)
+ if not constant.is_windows():
+ os.close(1)
+ os.open('/dev/null', os.O_WRONLY)
+
+
+def printlog(*args):
+ logger_print.info(args)
+
+
+if __name__ == "__main__":
+ open_limit_up_codes = set({"000333", "000222"})
+ logger_kpl_open_limit_up.info(f"鐐告澘浠ｇ爜锛歿open_limit_up_codes}")
diff --git a/log_module/request_log_util.py b/log_module/request_log_util.py
new file mode 100644
index 0000000..17ff407
--- /dev/null
+++ b/log_module/request_log_util.py
@@ -0,0 +1,10 @@
+from log_module import async_log_util
+from log_module.log import logger_request_debug
+from utils import tool
+
+
+def request_info(type_name, content, thread_id=None):
+ if not thread_id:
+ thread_id = tool.get_thread_id()
+ async_log_util.info(logger_request_debug, f"銆恵thread_id}銆戙�恵type_name}銆� {content}")
+
diff --git a/main.py b/main.py
index bc90c4b..b98d5a8 100644
--- a/main.py
+++ b/main.py
@@ -1,18 +1,23 @@
+import multiprocessing
import threading
import constant
import data_server
-import log
import middle_api_server
import middle_cb_api_server
import middle_server
+# from huaxin_client import huaxin_trade_client
+# from trade import huaxin_trade_api
+# from huaxin_client import huaxin_trade_client
+from log_module import async_log_util
+# from trade import huaxin_trade_api
if __name__ == "__main__":
t1 = threading.Thread(target=lambda: middle_api_server.run(), daemon=True)
t1.start()
t1 = threading.Thread(target=lambda: data_server.run("0.0.0.0", constant.DATA_SERVER_PORT), daemon=True)
t1.start()
- t1 = threading.Thread(target=lambda: log.async_log_util.run_sync(), daemon=True)
+ t1 = threading.Thread(target=lambda: async_log_util.run_sync(), daemon=True)
t1.start()
t1 = threading.Thread(target=lambda: middle_server.run(12880), daemon=True)
t1.start()
@@ -21,4 +26,15 @@
t1.start()
# t1 = threading.Thread(target=lambda: middle_l1_data_server.run(12881), daemon=True)
# t1.start()
+
+ # 杩愯浠跨湡浜ゆ槗
+ # queue_strategy_r_trade_w, queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query = multiprocessing.Queue(), multiprocessing.Queue(), multiprocessing.Queue()
+ # huaxin_trade_api.run_trade(queue_strategy_r_trade_w, queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query)
+
+ # ===========杩愯浜ゆ槗绔�==========
+ # tradeProcess = multiprocessing.Process(
+ # target=huaxin_trade_client.run,
+ # args=(queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query, queue_strategy_r_trade_w,))
+ # tradeProcess.start()
+
middle_server.run()
diff --git a/middle_api_server.py b/middle_api_server.py
index 3e6c927..09c6fa9 100644
--- a/middle_api_server.py
+++ b/middle_api_server.py
@@ -8,12 +8,12 @@
import time
import constant
-import log
import socket_manager
import trade_manager
from db import mysql_data, redis_manager
from db.redis_manager import RedisUtils
-from log import logger_request_debug
+from log_module import log, request_log_util
+from log_module.log import logger_request_debug
from middle_l1_data_server import L1DataManager
from output import push_msg_manager
from utils import socket_util, hosting_api_util, huaxin_trade_record_manager, huaxin_util, tool, global_data_cache_util
@@ -69,7 +69,7 @@
data_json = json.loads(data_str)
type_ = data_json['type']
try:
- log.request_info("middle_api_server", f"璇锋眰寮�濮嬶細{type_}")
+ request_log_util.request_info("middle_api_server", f"璇锋眰寮�濮嬶細{type_}")
if type(type_) == int:
# 澶勭悊鏁板瓧鍨婽YPE
return_str = self.process_num_type(sk, type_, data_str)
@@ -397,7 +397,7 @@
results = L1DataManager.get_current_l1_data()
return_str = json.dumps({"code": 0, "data": results})
finally:
- log.request_info("middle_api_server", f"璇锋眰缁撴潫锛歿type_}")
+ request_log_util.request_info("middle_api_server", f"璇锋眰缁撴潫锛歿type_}")
break
# sk.close()
except Exception as e:
diff --git a/middle_cb_api_server.py b/middle_cb_api_server.py
index 5d63c54..dadcb75 100644
--- a/middle_cb_api_server.py
+++ b/middle_cb_api_server.py
@@ -3,8 +3,9 @@
import logging
import socket
import socketserver
-import log
-from log import logger_request_debug
+
+from log_module import log, request_log_util
+from log_module.log import logger_request_debug
from utils import socket_util, hosting_api_util
"""
@@ -60,7 +61,7 @@
data_json = json.loads(data_str)
type_ = data_json['type']
try:
- log.request_info("middle_cb_api_server", f"璇锋眰寮�濮嬶細{type_}")
+ request_log_util.request_info("middle_cb_api_server", f"璇锋眰寮�濮嬶細{type_}")
is_sign_right = socket_util.is_client_params_sign_right(data_json)
# ------瀹㈡埛绔姹傛帴鍙�-------
if type_ == 'buy':
@@ -152,7 +153,7 @@
return_str = json.dumps(result)
break
finally:
- log.request_info("middle_cb_api_server", f"璇锋眰缁撴潫锛歿type_}")
+ request_log_util.request_info("middle_cb_api_server", f"璇锋眰缁撴潫锛歿type_}")
break
# sk.close()
except Exception as e:
diff --git a/middle_l1_data_server.py b/middle_l1_data_server.py
index 62b9cd8..6af0133 100644
--- a/middle_l1_data_server.py
+++ b/middle_l1_data_server.py
@@ -3,21 +3,13 @@
import json
import logging
import queue
-import random
import socket
import socketserver
-import threading
import time
-import constant
-import log
-import socket_manager
-from db import mysql_data
-from db.redis_manager import RedisUtils, RedisManager
-from log import logger_debug, logger_request_debug
-from output import push_msg_manager
-from utils import socket_util, kpl_api_util, hosting_api_util, kp_client_msg_manager, global_data_cache_util, tool
-from utils.juejin_util import JueJinHttpApi
+
+from log_module import log
+from utils import socket_util
trade_data_request_queue = queue.Queue()
diff --git a/middle_server.py b/middle_server.py
index 4e39e59..a81c36e 100644
--- a/middle_server.py
+++ b/middle_server.py
@@ -1,4 +1,5 @@
import builtins
+import copy
import hashlib
import json
import logging
@@ -10,17 +11,34 @@
import time
import constant
-import log
import socket_manager
from db import mysql_data
from db.redis_manager import RedisUtils, RedisManager
-from log import logger_debug, logger_request_debug
+from log_module import log
+from log_module.log import logger_debug
from middle_l1_data_server import L1DataManager
from output import push_msg_manager
+from trade import huaxin_trade_api
from utils import socket_util, kpl_api_util, hosting_api_util, kp_client_msg_manager, global_data_cache_util, tool
from utils.juejin_util import JueJinHttpApi
trade_data_request_queue = queue.Queue()
+
+__mysql_config_dict = {}
+
+
+def get_mysql_config(db_name):
+ """
+ 鑾峰彇mysql鐨勯厤缃�
+ :param db_name:
+ :return:
+ """
+ if db_name in __mysql_config_dict:
+ return __mysql_config_dict.get(db_name)
+ config = copy.deepcopy(constant.MYSQL_CONFIG)
+ config["database"] = db_name
+ __mysql_config_dict[db_name] = config
+ return config
class MyTCPServer(socketserver.TCPServer):
@@ -235,7 +253,8 @@
db = data["db"]
cmd = data["cmd"]
args = data.get("args")
- mysql = mysql_data.Mysqldb()
+ mysql_config = get_mysql_config(db)
+ mysql = mysql_data.Mysqldb(mysql_config)
method = getattr(mysql, cmd)
args_ = []
if args:
@@ -300,11 +319,21 @@
datas = data_json["data"]
L1DataManager.add_datas(datas)
break
+ elif data_json["type"] == "simulation_trade":
+ datas = data_json["data"]
+ ctype = datas["ctype"]
+ data = datas["data"]
+ result = huaxin_trade_api.request(ctype,data)
+ result_str = json.dumps({"code": 0, "data": result}, default=str)
+ sk.sendall(socket_util.load_header(result_str.encode(encoding='utf-8')))
+
+
except Exception as e:
log.logger_tuoguan_request_debug.exception(e)
finally:
if time.time() - __start_time > 2:
- log.logger_tuoguan_request_debug.info(f"鑰楁椂锛歿int(time.time() - __start_time)}s 鏁版嵁锛歿data_json}")
+ log.logger_tuoguan_request_debug.info(
+ f"鑰楁椂锛歿int(time.time() - __start_time)}s 鏁版嵁锛歿data_json}")
else:
# 鏂紑杩炴帴
break
@@ -341,7 +370,7 @@
pass
-def run(port = constant.MIDDLE_SERVER_PORT):
+def run(port=constant.MIDDLE_SERVER_PORT):
print("create MiddleServer")
t1 = threading.Thread(target=lambda: clear_invalid_client(), daemon=True)
t1.start()
@@ -353,4 +382,4 @@
if __name__ == "__main__":
- print(builtins.type("")==str)
+ pass
diff --git a/output/push_msg_manager.py b/output/push_msg_manager.py
index 30ae330..7d396ee 100644
--- a/output/push_msg_manager.py
+++ b/output/push_msg_manager.py
@@ -3,7 +3,7 @@
"""
import json
-from log import logger_debug
+from log_module.log import logger_debug
from utils import socket_util
TYPE_ORDER_ALMOST_DEAL = "order_almost_deal" # 璁㈠崟鍗冲皢鎴愪氦
diff --git a/socket_manager.py b/socket_manager.py
index f92cebe..0c492d3 100644
--- a/socket_manager.py
+++ b/socket_manager.py
@@ -18,7 +18,7 @@
@classmethod
def add_client(cls, _type, rid, sk):
- if _type == cls.CLIENT_TYPE_COMMON or _type == cls.CLIENT_TYPE_TRADE or _type == cls.CLIENT_TYPE_TRADE_SELL:
+ if _type == cls.CLIENT_TYPE_COMMON or _type == cls.CLIENT_TYPE_TRADE or _type == cls.CLIENT_TYPE_TRADE_SELL or _type == cls.CLIENT_TYPE_TRADE_CB:
# 浜ゆ槗鍒楄〃
if _type not in cls.socket_client_dict:
cls.socket_client_dict[_type] = []
@@ -30,7 +30,7 @@
@classmethod
def acquire_client(cls, _type):
- if _type == cls.CLIENT_TYPE_COMMON or _type == cls.CLIENT_TYPE_TRADE or _type == cls.CLIENT_TYPE_TRADE_SELL:
+ if _type == cls.CLIENT_TYPE_COMMON or _type == cls.CLIENT_TYPE_TRADE or _type == cls.CLIENT_TYPE_TRADE_SELL or _type == cls.CLIENT_TYPE_TRADE_CB:
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[
diff --git a/third_data/kpl_data_manager.py b/third_data/kpl_data_manager.py
index 78fda50..29cda95 100644
--- a/third_data/kpl_data_manager.py
+++ b/third_data/kpl_data_manager.py
@@ -7,7 +7,7 @@
import constant
from db.redis_manager import RedisUtils
-from log import logger_kpl_limit_up_reason_change
+from log_module.log import logger_kpl_limit_up_reason_change
from utils import tool
# 寮�鐩樺暒鍘嗗彶娑ㄥ仠鏁版嵁绠＄悊
diff --git a/trade/huaxin_trade_api.py b/trade/huaxin_trade_api.py
new file mode 100644
index 0000000..7d31442
--- /dev/null
+++ b/trade/huaxin_trade_api.py
@@ -0,0 +1,323 @@
+"""
+浜ゆ槗API
+"""
+import json
+import logging
+import multiprocessing
+import queue
+import random
+import threading
+import time
+import concurrent.futures
+
+from utils import socket_util, tool
+
+__response_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=15)
+__save_data_queue = queue.Queue()
+
+
+def __run_recv_queue_trade(queue: multiprocessing.Queue):
+ # 璁剧疆缁撴灉
+ def __set_response(data_json):
+ if 'request_id' not in data_json:
+ return
+ # 璁剧疆鍝嶅簲鍐呭
+ set_response(data_json["request_id"], data_json['data'])
+
+ if queue is not None:
+ while True:
+ try:
+ val = queue.get()
+ if val:
+ data_json = json.loads(val)
+ # 澶勭悊鏁版嵁
+ type_ = data_json["type"]
+ if type_ == "response":
+ # 涓诲姩瑙﹀彂鐨勫搷搴�
+ request_id = data_json['request_id']
+
+ __response_thread_pool.submit(__set_response, data_json)
+ elif type_ == "trade_callback":
+ try:
+ # 浜ゆ槗鍥炶皟
+ data_json = data_json["data"]
+ ctype = data_json["type"]
+ # 璁板綍浜ゆ槗鍙嶉鏃ュ織
+ finally:
+ pass
+ except:
+ pass
+
+
+# 璁剧疆浜ゆ槗閫氫俊闃熷垪
+# 鏆傛椂涓嶄細浣跨敤璇ユ柟娉�
+def run_trade(queue_strategy_r_trade_w_, queue_strategy_w_trade_r_, queue_strategy_w_trade_r_for_query_):
+ """
+
+ :param queue_strategy_r_trade_w_: 鎺ユ敹浜ゆ槗缁撴灉鏁版嵁闃熷垪
+ :param queue_strategy_w_trade_r_: 鍙戦�佷氦鏄撴寚浠ら槦鍒�
+ :param queue_strategy_w_trade_r_for_query_:鍙戦�佹煡璇㈢殑浜ゆ槗鎸囦护闃熷垪
+ :param trade_ipc_addr:
+ :return:
+ """
+ global queue_strategy_w_trade_r, queue_strategy_w_trade_r_for_query
+ queue_strategy_w_trade_r = queue_strategy_w_trade_r_
+ queue_strategy_w_trade_r_for_query = queue_strategy_w_trade_r_for_query_
+
+ # 璇诲彇浜ゆ槗缁撴灉
+ threading.Thread(target=lambda: __run_recv_queue_trade(queue_strategy_r_trade_w_), daemon=True).start()
+
+
+# 浜ゆ槗閫氶亾鐨勯敊璇鏁�
+trade_pipe_channel_error_count = 0
+
+
+# pipe鐨勪氦鏄撻�氶亾鏄惁姝ｅ父
+def is_pipe_channel_normal():
+ return True
+
+
+# 娴嬭瘯浜ゆ槗閫氶亾
+def test_trade_channel():
+ global trade_pipe_channel_error_count
+ sid = random.randint(0, 1000000)
+ result = __test_trade_channel(sid)
+ if result["code"] == 0 and result["data"]["data"]["sid"] == sid:
+ trade_pipe_channel_error_count = 0
+ return True
+ trade_pipe_channel_error_count += 1
+ if trade_pipe_channel_error_count > 100:
+ trade_pipe_channel_error_count = 100
+ return False
+
+
+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 list_client(cls, _type):
+ if _type == cls.CLIENT_TYPE_TRADE:
+ if _type in cls.socket_client_dict:
+ return cls.socket_client_dict.get(_type)
+ else:
+ if _type in cls.socket_client_dict:
+ return [cls.socket_client_dict.get(_type)]
+ return []
+
+ @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 is_client_locked(cls, rid):
+ if rid in cls.socket_client_lock_dict:
+ return cls.socket_client_lock_dict[rid].locked()
+ return None
+
+ @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, client_id):
+ sucess = False
+ if client_id in cls.socket_client_lock_dict:
+ sucess = True
+ # 閲婃斁閿�
+ if cls.socket_client_lock_dict[client_id].locked():
+ cls.socket_client_lock_dict[client_id].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:
+ try:
+ # 鍏抽棴socket
+ d[1].close()
+ except:
+ pass
+ cls.socket_client_dict[t].remove(d)
+ break
+
+ elif type(cls.socket_client_dict[t]) == tuple:
+ if cls.socket_client_dict[t][0] == rid:
+ try:
+ # 鍏抽棴socket
+ cls.socket_client_dict[t][1].close()
+ except:
+ pass
+ cls.socket_client_dict.pop(t)
+ break
+
+ # 蹇冭烦淇℃伅
+ @classmethod
+ def heart(cls, rid):
+ cls.active_client_dict[rid] = time.time()
+
+ @classmethod
+ def del_invalid_clients(cls):
+ # 娓呴櫎闀挎椂闂存棤蹇冭烦鐨勫鎴风閫氶亾
+ for k in cls.active_client_dict.keys():
+ if time.time() - cls.active_client_dict[k] > 20:
+ # 蹇冭烦鏃堕棿闂撮殧20s浠ヤ笂瑙嗕负鏃犳晥
+ cls.del_client(k)
+
+
+TRADE_DIRECTION_BUY = 1
+TRADE_DIRECTION_SELL = 2
+
+# 瓒呮椂鏃堕棿2s
+TIMEOUT = 2.0
+# 浜ゆ槗浠ｇ悊
+TRADE_DELEGATED = True
+
+# 绛夊緟鍝嶅簲鐨剅equest_id
+__request_response_dict = {}
+
+
+def __get_request_id(type):
+ return f"r_{type}_{round(time.time() * 10000)}_{random.randint(0, 100000)}"
+
+
+# 缃戠粶璇锋眰
+def __request(_type, data, request_id=None, log_enable=True, is_trade=False):
+ """
+ 璇锋眰锛屽皢浜ゆ槗锛堝寘鍚笅鍗�/鎾ゅ崟锛変笌鏌ヨ锛堝寘鍚煡鎸佷粨/璐︽埛鍙敤閲戦/濮旀墭鍒楄〃/鎴愪氦鍒楄〃锛夐槦鍒楀垎绂�
+ @param _type:
+ @param data:
+ @param request_id:
+ @param log_enable:
+ @param is_trade:
+ @return:
+ """
+ if not request_id:
+ request_id = __get_request_id(_type)
+ try:
+ root_data = {"type": _type,
+ "data": data,
+ "request_id": request_id,
+ "time": time.time()
+ }
+ root_data = socket_util.encryp_client_params_sign(root_data)
+ start_time = time.time()
+ if is_trade:
+ queue_strategy_w_trade_r.put_nowait(root_data)
+ else:
+ queue_strategy_w_trade_r_for_query.put_nowait(root_data)
+
+ use_time = int((time.time() - start_time) * 1000)
+ except BrokenPipeError as e:
+
+ raise e
+ except Exception as e:
+
+ logging.exception(e)
+ raise e
+ return request_id
+
+
+def __read_response(request_id, blocking, timeout=TIMEOUT, log_enable=True):
+ if blocking:
+ start_time = time.time()
+ try:
+ while True:
+ time.sleep(0.005)
+ if request_id in __request_response_dict:
+ # 鑾峰彇鍒颁簡鍝嶅簲鍐呭
+ result = __request_response_dict.pop(request_id)
+ return result
+ if time.time() - start_time > timeout:
+ # 璇诲彇鍐呭瓒呮椂鎵嶄細閲婃斁
+ raise Exception(f"璇诲彇鍐呭瓒呮椂: request_id={request_id}")
+ finally:
+ pass
+
+ return None
+
+
+
+def set_response(request_id, response):
+ if request_id:
+ # 涓诲姩瑙﹀彂
+ __request_response_dict[request_id] = response
+ else:
+ # 琚姩瑙﹀彂
+ pass
+
+
+def request(type_, data):
+ request_id = __request(type_,
+ data)
+ return __read_response(request_id, blocking=True)
+
+
+# 璁剧疆L2璁㈤槄鏁版嵁
+def __test_trade_channel(sid):
+ request_id = __request("test",
+ {"type": "test", "data": {"sid": sid}}, log_enable=False)
+ return __read_response(request_id, True, log_enable=False)
+
+
+def parseResponse(data_str):
+ if not data_str:
+ raise Exception("鍙嶉鍐呭涓虹┖")
+ res = data_str
+ if type(res) == str:
+ res = json.loads(data_str)
+ res = res['data']
+ if res['code'] != 0:
+ raise Exception(res['msg'])
+ return res['data']
+
+
+if __name__ == "__main__":
+ pass
diff --git a/traderapi.py b/traderapi.py
new file mode 100644
index 0000000..03dcdc1
--- /dev/null
+++ b/traderapi.py
@@ -0,0 +1,8064 @@
+# -*- coding: utf-8 -*-
+# 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 _traderapi
+else:
+ import _traderapi
+
+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) -> "void":
+ return _traderapi.set_null(*args)
+
+def is_null(*args) -> "bool":
+ return _traderapi.is_null(*args)
+TORA_TERT_RESTART = _traderapi.TORA_TERT_RESTART
+TORA_TERT_RESUME = _traderapi.TORA_TERT_RESUME
+TORA_TERT_QUICK = _traderapi.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
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqUserLoginField_UserRequestID_get, _traderapi.CTORATstpReqUserLoginField_UserRequestID_set)
+
+ # 锟斤拷录锟剿伙拷
+ LogInAccount = property(_traderapi.CTORATstpReqUserLoginField_LogInAccount_get, _traderapi.CTORATstpReqUserLoginField_LogInAccount_set)
+
+ # 锟斤拷录锟剿伙拷锟斤拷锟斤拷
+ LogInAccountType = property(_traderapi.CTORATstpReqUserLoginField_LogInAccountType_get, _traderapi.CTORATstpReqUserLoginField_LogInAccountType_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟诫（锟斤拷锟绞斤拷锟剿号凤拷式锟斤拷录时锟斤拷锟筋）
+ DepartmentID = property(_traderapi.CTORATstpReqUserLoginField_DepartmentID_get, _traderapi.CTORATstpReqUserLoginField_DepartmentID_set)
+
+ # 锟斤拷证锟斤拷式(指锟狡伙拷钥锟阶达拷锟斤拷证时锟斤拷锟斤拷)
+ AuthMode = property(_traderapi.CTORATstpReqUserLoginField_AuthMode_get, _traderapi.CTORATstpReqUserLoginField_AuthMode_set)
+
+ # 锟斤拷锟斤拷(锟斤拷锟斤拷锟斤拷证时锟斤拷锟斤拷)
+ Password = property(_traderapi.CTORATstpReqUserLoginField_Password_get, _traderapi.CTORATstpReqUserLoginField_Password_set)
+
+ # 锟矫伙拷锟剿诧拷品锟斤拷息
+ UserProductInfo = property(_traderapi.CTORATstpReqUserLoginField_UserProductInfo_get, _traderapi.CTORATstpReqUserLoginField_UserProductInfo_set)
+
+ # 锟接口端诧拷品锟斤拷息
+ InterfaceProductInfo = property(_traderapi.CTORATstpReqUserLoginField_InterfaceProductInfo_get, _traderapi.CTORATstpReqUserLoginField_InterfaceProductInfo_set)
+
+ # 锟秸端采硷拷锟斤拷息
+ TerminalInfo = property(_traderapi.CTORATstpReqUserLoginField_TerminalInfo_get, _traderapi.CTORATstpReqUserLoginField_TerminalInfo_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ InnerIPAddress = property(_traderapi.CTORATstpReqUserLoginField_InnerIPAddress_get, _traderapi.CTORATstpReqUserLoginField_InnerIPAddress_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ OuterIPAddress = property(_traderapi.CTORATstpReqUserLoginField_OuterIPAddress_get, _traderapi.CTORATstpReqUserLoginField_OuterIPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpReqUserLoginField_MacAddress_get, _traderapi.CTORATstpReqUserLoginField_MacAddress_set)
+
+ # 锟接匡拷锟斤拷锟斤拷
+ Lang = property(_traderapi.CTORATstpReqUserLoginField_Lang_get, _traderapi.CTORATstpReqUserLoginField_Lang_set)
+
+ # 锟秸端讹拷态锟斤拷钥
+ DynamicPassword = property(_traderapi.CTORATstpReqUserLoginField_DynamicPassword_get, _traderapi.CTORATstpReqUserLoginField_DynamicPassword_set)
+
+ # 锟借备锟斤拷识(指锟斤拷锟斤拷证时锟斤拷锟斤拷)
+ DeviceID = property(_traderapi.CTORATstpReqUserLoginField_DeviceID_get, _traderapi.CTORATstpReqUserLoginField_DeviceID_set)
+
+ # 锟斤拷证锟斤拷锟叫猴拷(指锟狡伙拷钥锟阶达拷锟斤拷证时锟斤拷锟斤拷)
+ CertSerial = property(_traderapi.CTORATstpReqUserLoginField_CertSerial_get, _traderapi.CTORATstpReqUserLoginField_CertSerial_set)
+
+ # 锟借备锟斤拷锟�(指锟狡伙拷钥锟阶达拷锟斤拷证时锟斤拷锟斤拷)
+ DeviceType = property(_traderapi.CTORATstpReqUserLoginField_DeviceType_get, _traderapi.CTORATstpReqUserLoginField_DeviceType_set)
+
+ # 锟斤拷锟斤拷锟节碉拷锟斤拷(锟节诧拷使锟斤拷)
+ NodeRef = property(_traderapi.CTORATstpReqUserLoginField_NodeRef_get, _traderapi.CTORATstpReqUserLoginField_NodeRef_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqUserLoginField_swiginit(self, _traderapi.new_CTORATstpReqUserLoginField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqUserLoginField
+
+# Register CTORATstpReqUserLoginField in _traderapi:
+_traderapi.CTORATstpReqUserLoginField_swigregister(CTORATstpReqUserLoginField)
+cvar = _traderapi.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
+# 锟较猴拷A锟斤拷
+TORA_TSTP_LACT_SHAStock = cvar.TORA_TSTP_LACT_SHAStock
+# 锟斤拷锟斤拷A锟斤拷
+TORA_TSTP_LACT_SZAStock = cvar.TORA_TSTP_LACT_SZAStock
+# 锟较猴拷B锟斤拷
+TORA_TSTP_LACT_SHBStock = cvar.TORA_TSTP_LACT_SHBStock
+# 锟斤拷锟斤拷B锟斤拷
+TORA_TSTP_LACT_SZBStock = cvar.TORA_TSTP_LACT_SZBStock
+# 锟斤拷锟斤拷A
+TORA_TSTP_LACT_ThreeNewBoardA = cvar.TORA_TSTP_LACT_ThreeNewBoardA
+# 锟斤拷锟斤拷B
+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
+# 锟斤拷锟斤拷A锟斤拷
+TORA_TSTP_LACT_BJAStock = cvar.TORA_TSTP_LACT_BJAStock
+# 锟斤拷锟斤拷
+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
+# PC锟斤拷
+TORA_TSTP_DVT_PC = cvar.TORA_TSTP_DVT_PC
+# 锟狡讹拷锟斤拷
+TORA_TSTP_DVT_Mobile = cvar.TORA_TSTP_DVT_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_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_EXD_BSE = cvar.TORA_TSTP_EXD_BSE
+# 锟斤拷锟斤拷
+TORA_TSTP_D_Buy = cvar.TORA_TSTP_D_Buy
+# 锟斤拷锟斤拷
+TORA_TSTP_D_Sell = cvar.TORA_TSTP_D_Sell
+# ETF锟疥购
+TORA_TSTP_D_ETFPur = cvar.TORA_TSTP_D_ETFPur
+# ETF锟斤拷锟�
+TORA_TSTP_D_ETFRed = cvar.TORA_TSTP_D_ETFRed
+# 锟铰癸拷锟疥购
+TORA_TSTP_D_IPO = cvar.TORA_TSTP_D_IPO
+# 锟斤拷锟截癸拷
+TORA_TSTP_D_Repurchase = cvar.TORA_TSTP_D_Repurchase
+# 锟斤拷毓锟�
+TORA_TSTP_D_ReverseRepur = cvar.TORA_TSTP_D_ReverseRepur
+# 锟斤拷锟斤拷式锟斤拷锟斤拷锟疥购
+TORA_TSTP_D_OeFundPur = cvar.TORA_TSTP_D_OeFundPur
+# 锟斤拷锟斤拷式锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_D_OeFundRed = cvar.TORA_TSTP_D_OeFundRed
+# 锟斤拷锟斤拷品锟斤拷锟斤拷
+TORA_TSTP_D_CollateralIn = cvar.TORA_TSTP_D_CollateralIn
+# 锟斤拷锟斤拷品锟斤拷锟斤拷
+TORA_TSTP_D_CollateralOut = cvar.TORA_TSTP_D_CollateralOut
+# 锟斤拷押锟斤拷锟�
+TORA_TSTP_D_PledgeIn = cvar.TORA_TSTP_D_PledgeIn
+# 锟斤拷押锟斤拷锟斤拷
+TORA_TSTP_D_PledgeOut = cvar.TORA_TSTP_D_PledgeOut
+# 锟斤拷锟斤拷锟秸�
+TORA_TSTP_D_Rationed = cvar.TORA_TSTP_D_Rationed
+# 锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_Split = cvar.TORA_TSTP_D_Split
+# 锟斤拷锟斤拷喜锟�
+TORA_TSTP_D_Merge = cvar.TORA_TSTP_D_Merge
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_CreditBuy = cvar.TORA_TSTP_D_CreditBuy
+# 锟斤拷券锟斤拷锟斤拷
+TORA_TSTP_D_CreditSell = cvar.TORA_TSTP_D_CreditSell
+# 锟斤拷券锟斤拷锟斤拷
+TORA_TSTP_D_SellRepay = cvar.TORA_TSTP_D_SellRepay
+# 锟斤拷券锟斤拷券
+TORA_TSTP_D_BuyRepay = cvar.TORA_TSTP_D_BuyRepay
+# 锟斤拷券锟斤拷转
+TORA_TSTP_D_RepayTransfer = cvar.TORA_TSTP_D_RepayTransfer
+# 锟斤拷券锟斤拷转
+TORA_TSTP_D_SurplusTransfer = cvar.TORA_TSTP_D_SurplusTransfer
+# 源券锟斤拷转
+TORA_TSTP_D_SourceTransfer = cvar.TORA_TSTP_D_SourceTransfer
+# 债券转锟斤拷
+TORA_TSTP_D_BondConvertStock = cvar.TORA_TSTP_D_BondConvertStock
+# 债券锟斤拷锟斤拷
+TORA_TSTP_D_BondPutback = cvar.TORA_TSTP_D_BondPutback
+# ETF实锟斤拷锟疥购
+TORA_TSTP_D_ETFOtPur = cvar.TORA_TSTP_D_ETFOtPur
+# ETF实锟斤拷锟斤拷锟�
+TORA_TSTP_D_ETFOtRed = cvar.TORA_TSTP_D_ETFOtRed
+# 锟斤拷锟桔筹拷锟斤拷
+TORA_TSTP_D_PutbackRelieve = cvar.TORA_TSTP_D_PutbackRelieve
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_IOIBuy = cvar.TORA_TSTP_D_IOIBuy
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_IOISell = cvar.TORA_TSTP_D_IOISell
+# 锟缴斤拷确锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_TCRBuy = cvar.TORA_TSTP_D_TCRBuy
+# 锟缴斤拷确锟斤拷锟斤拷锟斤拷
+TORA_TSTP_D_TCRSell = cvar.TORA_TSTP_D_TCRSell
+# 锟斤拷锟斤拷锟�
+TORA_TSTP_OPT_AnyPrice = cvar.TORA_TSTP_OPT_AnyPrice
+# 锟睫硷拷
+TORA_TSTP_OPT_LimitPrice = cvar.TORA_TSTP_OPT_LimitPrice
+# 锟斤拷锟脚硷拷
+TORA_TSTP_OPT_BestPrice = cvar.TORA_TSTP_OPT_BestPrice
+# 锟教后定硷拷
+TORA_TSTP_OPT_FixPrice = cvar.TORA_TSTP_OPT_FixPrice
+# 锟藉档锟斤拷
+TORA_TSTP_OPT_FiveLevelPrice = cvar.TORA_TSTP_OPT_FiveLevelPrice
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_OPT_HomeBestPrice = cvar.TORA_TSTP_OPT_HomeBestPrice
+# 锟斤拷锟斤拷锟斤拷桑锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_TC_IOC = cvar.TORA_TSTP_TC_IOC
+# 锟斤拷锟斤拷锟斤拷效
+TORA_TSTP_TC_GFS = cvar.TORA_TSTP_TC_GFS
+# 锟斤拷锟斤拷锟斤拷效
+TORA_TSTP_TC_GFD = cvar.TORA_TSTP_TC_GFD
+# 指锟斤拷锟斤拷锟斤拷前锟斤拷效
+TORA_TSTP_TC_GTD = cvar.TORA_TSTP_TC_GTD
+# 锟斤拷锟斤拷前锟斤拷效
+TORA_TSTP_TC_GTC = cvar.TORA_TSTP_TC_GTC
+# 锟斤拷锟较撅拷锟斤拷锟斤拷效
+TORA_TSTP_TC_GFA = cvar.TORA_TSTP_TC_GFA
+# 锟轿猴拷锟斤拷锟斤拷
+TORA_TSTP_VC_AV = cvar.TORA_TSTP_VC_AV
+# 锟斤拷小锟斤拷锟斤拷
+TORA_TSTP_VC_MV = cvar.TORA_TSTP_VC_MV
+# 全锟斤拷锟斤拷锟斤拷
+TORA_TSTP_VC_CV = cvar.TORA_TSTP_VC_CV
+# 锟斤拷
+TORA_TSTP_OPERW_Non = cvar.TORA_TSTP_OPERW_Non
+# 锟界话委锟斤拷
+TORA_TSTP_OPERW_Telephone = cvar.TORA_TSTP_OPERW_Telephone
+# 锟斤拷台委锟斤拷
+TORA_TSTP_OPERW_OTC = cvar.TORA_TSTP_OPERW_OTC
+# 锟狡讹拷锟酵伙拷锟斤拷委锟斤拷
+TORA_TSTP_OPERW_MobileClient = cvar.TORA_TSTP_OPERW_MobileClient
+# PC锟酵伙拷锟斤拷委锟斤拷
+TORA_TSTP_OPERW_PCClient = cvar.TORA_TSTP_OPERW_PCClient
+# TY委锟斤拷
+TORA_TSTP_OPERW_TY = cvar.TORA_TSTP_OPERW_TY
+# 通锟斤拷委锟斤拷
+TORA_TSTP_OPERW_Channel = cvar.TORA_TSTP_OPERW_Channel
+# 锟斤拷啥锟斤拷锟�
+TORA_TSTP_LT_OddLot = cvar.TORA_TSTP_LT_OddLot
+# 锟斤拷锟街讹拷锟斤拷
+TORA_TSTP_LT_RoundLot = cvar.TORA_TSTP_LT_RoundLot
+# 锟斤拷锟斤拷锟轿何硷拷锟�
+TORA_TSTP_CCT_None = cvar.TORA_TSTP_CCT_None
+# 锟皆成斤拷锟斤拷锟�
+TORA_TSTP_CCT_SelfDeal = cvar.TORA_TSTP_CCT_SelfDeal
+# 锟斤拷强平
+TORA_TSTP_FCC_NotForceClose = cvar.TORA_TSTP_FCC_NotForceClose
+# 锟绞斤拷锟斤拷
+TORA_TSTP_FCC_MoneyNotEnough = cvar.TORA_TSTP_FCC_MoneyNotEnough
+# 锟斤拷位锟斤拷锟斤拷
+TORA_TSTP_FCC_PositionOverFull = cvar.TORA_TSTP_FCC_PositionOverFull
+# 锟斤拷锟斤拷
+TORA_TSTP_FCC_Other = cvar.TORA_TSTP_FCC_Other
+# 锟斤拷通
+TORA_TSTP_CQT_Normal = cvar.TORA_TSTP_CQT_Normal
+# 专锟斤拷
+TORA_TSTP_CQT_Special = cvar.TORA_TSTP_CQT_Special
+# 预锟斤拷
+TORA_TSTP_OST_Cached = cvar.TORA_TSTP_OST_Cached
+# 未知
+TORA_TSTP_OST_Unknown = cvar.TORA_TSTP_OST_Unknown
+# 锟斤拷锟斤拷锟斤拷锟窖斤拷锟斤拷
+TORA_TSTP_OST_Accepted = cvar.TORA_TSTP_OST_Accepted
+# 锟斤拷锟街成斤拷
+TORA_TSTP_OST_PartTraded = cvar.TORA_TSTP_OST_PartTraded
+# 全锟斤拷锟缴斤拷
+TORA_TSTP_OST_AllTraded = cvar.TORA_TSTP_OST_AllTraded
+# 锟斤拷锟缴诧拷锟斤拷
+TORA_TSTP_OST_PartTradeCanceled = cvar.TORA_TSTP_OST_PartTradeCanceled
+# 全锟斤拷锟斤拷锟斤拷
+TORA_TSTP_OST_AllCanceled = cvar.TORA_TSTP_OST_AllCanceled
+# 锟斤拷锟斤拷锟斤拷锟窖拒撅拷
+TORA_TSTP_OST_Rejected = cvar.TORA_TSTP_OST_Rejected
+# 锟斤拷锟斤拷锟斤拷锟阶猴拷锟斤拷
+TORA_TSTP_OST_SendTradeEngine = cvar.TORA_TSTP_OST_SendTradeEngine
+# 未锟结交
+TORA_TSTP_OSS_InsertUnSubmit = cvar.TORA_TSTP_OSS_InsertUnSubmit
+# 锟斤拷锟结交
+TORA_TSTP_OSS_InsertSubmitted = cvar.TORA_TSTP_OSS_InsertSubmitted
+# 锟斤拷锟斤拷未锟结交
+TORA_TSTP_OSS_CancelUnSubmit = cvar.TORA_TSTP_OSS_CancelUnSubmit
+# 锟斤拷锟斤拷锟斤拷锟结交
+TORA_TSTP_OSS_CancelSubmitted = cvar.TORA_TSTP_OSS_CancelSubmitted
+# 锟斤拷锟斤拷锟窖憋拷锟杰撅拷
+TORA_TSTP_OSS_CancelRejected = cvar.TORA_TSTP_OSS_CancelRejected
+# 锟斤拷锟斤拷锟斤拷删锟斤拷
+TORA_TSTP_OSS_CancelDeleted = cvar.TORA_TSTP_OSS_CancelDeleted
+# 锟斤拷锟斤拷锟�
+TORA_TSTP_CID_CNY = cvar.TORA_TSTP_CID_CNY
+# 锟桔憋拷
+TORA_TSTP_CID_HKD = cvar.TORA_TSTP_CID_HKD
+# 锟斤拷元
+TORA_TSTP_CID_USD = cvar.TORA_TSTP_CID_USD
+# 锟斤拷锟斤拷
+TORA_TSTP_ORDT_Normal = cvar.TORA_TSTP_ORDT_Normal
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_ORDT_DeriveFromQuote = cvar.TORA_TSTP_ORDT_DeriveFromQuote
+# 锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_ORDT_DeriveFromCombination = cvar.TORA_TSTP_ORDT_DeriveFromCombination
+# 锟斤拷媳锟斤拷锟�
+TORA_TSTP_ORDT_Combination = cvar.TORA_TSTP_ORDT_Combination
+# 锟斤拷锟斤拷锟斤拷
+TORA_TSTP_ORDT_ConditionalOrder = cvar.TORA_TSTP_ORDT_ConditionalOrder
+# 锟斤拷锟斤拷锟斤拷
+TORA_TSTP_ORDT_Swap = cvar.TORA_TSTP_ORDT_Swap
+# 预锟斤拷
+TORA_TSTP_ORDT_Cache = cvar.TORA_TSTP_ORDT_Cache
+# 夜锟斤拷委锟斤拷
+TORA_TSTP_ORDT_Night = cvar.TORA_TSTP_ORDT_Night
+# 通锟斤拷委锟斤拷
+TORA_TSTP_ORDT_Board = cvar.TORA_TSTP_ORDT_Board
+# 删锟斤拷
+TORA_TSTP_AF_Delete = cvar.TORA_TSTP_AF_Delete
+# 锟睫革拷
+TORA_TSTP_AF_Modify = cvar.TORA_TSTP_AF_Modify
+# 强锟斤拷删锟斤拷
+TORA_TSTP_AF_ForceDelete = cvar.TORA_TSTP_AF_ForceDelete
+# 锟皆讹拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_TOVT_CustomVol = cvar.TORA_TSTP_TOVT_CustomVol
+# 锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_TOVT_RelativeVol = cvar.TORA_TSTP_TOVT_RelativeVol
+# 锟皆讹拷锟斤拷鄹锟�
+TORA_TSTP_TOPT_CustomPrice = cvar.TORA_TSTP_TOPT_CustomPrice
+# 锟斤拷锟铰硷拷
+TORA_TSTP_TOPT_LastPrice = cvar.TORA_TSTP_TOPT_LastPrice
+# 锟斤拷一锟斤拷
+TORA_TSTP_TOPT_AskPrice1 = cvar.TORA_TSTP_TOPT_AskPrice1
+# 锟斤拷一锟斤拷
+TORA_TSTP_TOPT_BidPrice1 = cvar.TORA_TSTP_TOPT_BidPrice1
+# 锟斤拷丶锟�
+TORA_TSTP_TOPT_Relative = cvar.TORA_TSTP_TOPT_Relative
+# 锟缴斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_TradeTouch = cvar.TORA_TSTP_CC_TradeTouch
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_CancelTouch = cvar.TORA_TSTP_CC_CancelTouch
+# 时锟戒触锟斤拷
+TORA_TSTP_CC_TimeTouch = cvar.TORA_TSTP_CC_TimeTouch
+# 锟斤拷锟斤拷时锟轿达拷锟斤拷
+TORA_TSTP_CC_SegmentTouch = cvar.TORA_TSTP_CC_SegmentTouch
+# 锟斤拷锟铰价达拷锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_LastPriceGreaterThanStopPrice = cvar.TORA_TSTP_CC_LastPriceGreaterThanStopPrice
+# 锟斤拷锟铰硷拷小锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_LastPriceLesserThanStopPrice = cvar.TORA_TSTP_CC_LastPriceLesserThanStopPrice
+# 锟斤拷一锟桔达拷锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_AskPriceGreaterEqualStopPrice = cvar.TORA_TSTP_CC_AskPriceGreaterEqualStopPrice
+# 锟斤拷一锟斤拷小锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_AskPriceLesserEqualStopPrice = cvar.TORA_TSTP_CC_AskPriceLesserEqualStopPrice
+# 锟斤拷一锟桔达拷锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_BidPriceGreaterEqualStopPrice = cvar.TORA_TSTP_CC_BidPriceGreaterEqualStopPrice
+# 锟斤拷一锟斤拷小锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CC_BidPriceLesserEqualStopPrice = cvar.TORA_TSTP_CC_BidPriceLesserEqualStopPrice
+# 锟斤拷始
+TORA_TSTP_COST_Initial = cvar.TORA_TSTP_COST_Initial
+# 未锟斤拷锟斤拷
+TORA_TSTP_COST_NotTouched = cvar.TORA_TSTP_COST_NotTouched
+# 锟窖达拷锟斤拷
+TORA_TSTP_COST_Touched = cvar.TORA_TSTP_COST_Touched
+# 锟窖斤拷锟斤拷
+TORA_TSTP_COST_Finished = cvar.TORA_TSTP_COST_Finished
+# 锟窖筹拷锟斤拷
+TORA_TSTP_COST_Cancel = cvar.TORA_TSTP_COST_Cancel
+# 锟斤拷锟斤拷失锟斤拷
+TORA_TSTP_COST_Failed = cvar.TORA_TSTP_COST_Failed
+# 通锟斤拷(锟节诧拷使锟斤拷)
+TORA_TSTP_MKD_COMMON = cvar.TORA_TSTP_MKD_COMMON
+# 锟较猴拷A锟斤拷
+TORA_TSTP_MKD_SHA = cvar.TORA_TSTP_MKD_SHA
+# 锟斤拷锟斤拷A锟斤拷
+TORA_TSTP_MKD_SZA = cvar.TORA_TSTP_MKD_SZA
+# 锟较猴拷B锟斤拷
+TORA_TSTP_MKD_SHB = cvar.TORA_TSTP_MKD_SHB
+# 锟斤拷锟斤拷B锟斤拷
+TORA_TSTP_MKD_SZB = cvar.TORA_TSTP_MKD_SZB
+# 锟斤拷锟斤拷锟斤拷锟斤拷A锟斤拷
+TORA_TSTP_MKD_SZThreeA = cvar.TORA_TSTP_MKD_SZThreeA
+# 锟斤拷锟斤拷锟斤拷锟斤拷B锟斤拷
+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_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
+# (锟桔癸拷通)Exchange Intervention
+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_TRNSD_In = cvar.TORA_TSTP_TRNSD_In
+# 锟斤拷锟�
+TORA_TSTP_TRNSD_Out = cvar.TORA_TSTP_TRNSD_Out
+# 锟斤拷锟叫斤拷锟阶碉拷锟斤拷
+TORA_TSTP_TRNSD_MoveIn = cvar.TORA_TSTP_TRNSD_MoveIn
+# 锟斤拷锟叫斤拷锟阶碉拷锟斤拷
+TORA_TSTP_TRNSD_MoveOut = cvar.TORA_TSTP_TRNSD_MoveOut
+# 锟斤拷锟斤拷
+TORA_TSTP_TRNSD_Freeze = cvar.TORA_TSTP_TRNSD_Freeze
+# 锟解冻
+TORA_TSTP_TRNSD_UnFreeze = cvar.TORA_TSTP_TRNSD_UnFreeze
+# 证券转锟斤拷锟斤拷
+TORA_TSTP_TRNSD_StockToBank = cvar.TORA_TSTP_TRNSD_StockToBank
+# 锟斤拷锟斤拷转证券
+TORA_TSTP_TRNSD_BankToStock = cvar.TORA_TSTP_TRNSD_BankToStock
+# 锟解部锟节碉拷转锟斤拷
+TORA_TSTP_TRNSD_NodeMoveIn = cvar.TORA_TSTP_TRNSD_NodeMoveIn
+# 锟解部锟节碉拷转锟斤拷
+TORA_TSTP_TRNSD_NodeMoveOut = cvar.TORA_TSTP_TRNSD_NodeMoveOut
+# 直锟接伙拷锟斤拷
+TORA_TSTP_TRNSD_CashRepay = cvar.TORA_TSTP_TRNSD_CashRepay
+# 直锟接伙拷息(锟节诧拷使锟斤拷)
+TORA_TSTP_TRNSD_CashRepayInterestFee = cvar.TORA_TSTP_TRNSD_CashRepayInterestFee
+# 锟叫癸拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_CCB = cvar.TORA_TSTP_BKID_CCB
+# 锟叫癸拷农业锟斤拷锟斤拷
+TORA_TSTP_BKID_ABC = cvar.TORA_TSTP_BKID_ABC
+# 锟叫癸拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_ICBC = cvar.TORA_TSTP_BKID_ICBC
+# 锟叫癸拷锟斤拷锟斤拷
+TORA_TSTP_BKID_BOC = cvar.TORA_TSTP_BKID_BOC
+# 锟叫癸拷锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_CMB = cvar.TORA_TSTP_BKID_CMB
+# 锟叫癸拷锟斤拷通锟斤拷锟斤拷
+TORA_TSTP_BKID_BC = cvar.TORA_TSTP_BKID_BC
+# 锟街讹拷锟斤拷展锟斤拷锟斤拷
+TORA_TSTP_BKID_SPDB = cvar.TORA_TSTP_BKID_SPDB
+# 锟斤拷业锟斤拷锟斤拷
+TORA_TSTP_BKID_CIB = cvar.TORA_TSTP_BKID_CIB
+# 锟叫癸拷锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_BKID_CEB = cvar.TORA_TSTP_BKID_CEB
+# 锟姐东锟斤拷展锟斤拷锟斤拷
+TORA_TSTP_BKID_GDB = cvar.TORA_TSTP_BKID_GDB
+# 锟较撅拷锟斤拷锟斤拷
+TORA_TSTP_BKID_NJCB = cvar.TORA_TSTP_BKID_NJCB
+# 锟较猴拷锟斤拷锟斤拷
+TORA_TSTP_BKID_SHCB = cvar.TORA_TSTP_BKID_SHCB
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_CITICB = cvar.TORA_TSTP_BKID_CITICB
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_HXB = cvar.TORA_TSTP_BKID_HXB
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_CMBC = cvar.TORA_TSTP_BKID_CMBC
+# 平锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_PACB = cvar.TORA_TSTP_BKID_PACB
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_NBCB = cvar.TORA_TSTP_BKID_NBCB
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BKID_BOB = cvar.TORA_TSTP_BKID_BOB
+# 锟绞达拷锟斤拷锟斤拷
+TORA_TSTP_BKID_PSBC = cvar.TORA_TSTP_BKID_PSBC
+# 转锟斤拷锟斤拷锟节达拷锟斤拷
+TORA_TSTP_TRANST_TranferHandling = cvar.TORA_TSTP_TRANST_TranferHandling
+# 转锟狡成癸拷
+TORA_TSTP_TRANST_TransferSuccess = cvar.TORA_TSTP_TRANST_TransferSuccess
+# 转锟斤拷失锟斤拷
+TORA_TSTP_TRANST_TransferFail = cvar.TORA_TSTP_TRANST_TransferFail
+# 锟斤拷锟斤拷锟斤拷锟节达拷锟斤拷
+TORA_TSTP_TRANST_RepealHandling = cvar.TORA_TSTP_TRANST_RepealHandling
+# 锟斤拷锟斤拷锟缴癸拷
+TORA_TSTP_TRANST_RepealSuccess = cvar.TORA_TSTP_TRANST_RepealSuccess
+# 锟斤拷锟斤拷失锟斤拷
+TORA_TSTP_TRANST_RepealFail = cvar.TORA_TSTP_TRANST_RepealFail
+# 锟解部系统锟窖斤拷锟斤拷
+TORA_TSTP_TRANST_ExternalAccepted = cvar.TORA_TSTP_TRANST_ExternalAccepted
+# 锟斤拷锟斤拷锟斤拷锟阶猴拷锟斤拷
+TORA_TSTP_TRANST_SendTradeEngine = cvar.TORA_TSTP_TRANST_SendTradeEngine
+# 锟斤拷锟斤拷锟�
+TORA_TSTP_TPT_ALL = cvar.TORA_TSTP_TPT_ALL
+# 锟斤拷锟�
+TORA_TSTP_TPT_History = cvar.TORA_TSTP_TPT_History
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_TPT_TodayBS = cvar.TORA_TSTP_TPT_TodayBS
+# 锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_TPT_TodayPR = cvar.TORA_TSTP_TPT_TodayPR
+# 锟斤拷锟街合诧拷锟斤拷
+TORA_TSTP_TPT_TodaySM = cvar.TORA_TSTP_TPT_TodaySM
+# 未同锟斤拷
+TORA_TSTP_DS_Asynchronous = cvar.TORA_TSTP_DS_Asynchronous
+# 同锟斤拷锟斤拷
+TORA_TSTP_DS_Synchronizing = cvar.TORA_TSTP_DS_Synchronizing
+# 锟斤拷同锟斤拷
+TORA_TSTP_DS_Synchronized = cvar.TORA_TSTP_DS_Synchronized
+# 全锟斤拷同锟斤拷锟斤拷锟�
+TORA_TSTP_DS_AllSynchronized = cvar.TORA_TSTP_DS_AllSynchronized
+# 预同锟斤拷锟斤拷锟�
+TORA_TSTP_DS_PreSync = cvar.TORA_TSTP_DS_PreSync
+# 通锟斤拷(锟节诧拷使锟斤拷)
+TORA_TSTP_PID_COMMON = cvar.TORA_TSTP_PID_COMMON
+# 锟较猴拷锟斤拷票
+TORA_TSTP_PID_SHStock = cvar.TORA_TSTP_PID_SHStock
+# 锟较猴拷锟斤拷锟斤拷
+TORA_TSTP_PID_SHFund = cvar.TORA_TSTP_PID_SHFund
+# 锟较猴拷债券
+TORA_TSTP_PID_SHBond = cvar.TORA_TSTP_PID_SHBond
+# 锟较猴拷锟斤拷准券
+TORA_TSTP_PID_SHStandard = cvar.TORA_TSTP_PID_SHStandard
+# 锟较猴拷锟斤拷押式锟截癸拷
+TORA_TSTP_PID_SHRepurchase = cvar.TORA_TSTP_PID_SHRepurchase
+# 锟斤拷锟节癸拷票
+TORA_TSTP_PID_SZStock = cvar.TORA_TSTP_PID_SZStock
+# 锟斤拷锟节伙拷锟斤拷
+TORA_TSTP_PID_SZFund = cvar.TORA_TSTP_PID_SZFund
+# 锟斤拷锟斤拷债券
+TORA_TSTP_PID_SZBond = cvar.TORA_TSTP_PID_SZBond
+# 锟斤拷锟节憋拷准券
+TORA_TSTP_PID_SZStandard = cvar.TORA_TSTP_PID_SZStandard
+# 锟斤拷锟斤拷锟斤拷押式锟截癸拷
+TORA_TSTP_PID_SZRepurchase = cvar.TORA_TSTP_PID_SZRepurchase
+# 锟斤拷锟酵拷酃锟斤拷锟斤拷锟�
+TORA_TSTP_PID_SZSEHKMain = cvar.TORA_TSTP_PID_SZSEHKMain
+# 锟斤拷锟酵拷酃纱锟揭碉拷锟�
+TORA_TSTP_PID_SZSEHKGEM = cvar.TORA_TSTP_PID_SZSEHKGEM
+# 锟斤拷锟酵拷酃锟斤拷锟斤拷浣伙拷锟街と�
+TORA_TSTP_PID_SZSEHKETS = cvar.TORA_TSTP_PID_SZSEHKETS
+# 锟斤拷锟酵拷酃锟絅asdaqAMX锟叫筹拷
+TORA_TSTP_PID_SZSEHKNasdaqAMX = cvar.TORA_TSTP_PID_SZSEHKNasdaqAMX
+# 锟较猴拷锟狡达拷锟斤拷
+TORA_TSTP_PID_SHKC = cvar.TORA_TSTP_PID_SHKC
+# 锟斤拷锟斤拷锟斤拷票
+TORA_TSTP_PID_BJStock = cvar.TORA_TSTP_PID_BJStock
+# 通锟斤拷(锟节诧拷使锟斤拷)
+TORA_TSTP_STP_COMMON = cvar.TORA_TSTP_STP_COMMON
+# 锟较猴拷A锟斤拷
+TORA_TSTP_STP_SHAShares = cvar.TORA_TSTP_STP_SHAShares
+# 锟较猴拷锟斤拷锟叫筹拷锟斤拷票ETF
+TORA_TSTP_STP_SHSingleMarketStockETF = cvar.TORA_TSTP_STP_SHSingleMarketStockETF
+# 锟较猴拷锟斤拷锟叫筹拷实锟斤拷债券ETF
+TORA_TSTP_STP_SHSingleMarketBondETF = cvar.TORA_TSTP_STP_SHSingleMarketBondETF
+# 锟较猴拷锟狡斤拷ETF
+TORA_TSTP_STP_SHGoldETF = cvar.TORA_TSTP_STP_SHGoldETF
+# 锟较猴拷锟斤拷锟斤拷ETF
+TORA_TSTP_STP_SHTradableMonetaryFund = cvar.TORA_TSTP_STP_SHTradableMonetaryFund
+# 锟较猴拷锟斤拷债锟截凤拷债
+TORA_TSTP_STP_SHBondNation = cvar.TORA_TSTP_STP_SHBondNation
+# 锟较猴拷锟斤拷业债
+TORA_TSTP_STP_SHBondCorporation = cvar.TORA_TSTP_STP_SHBondCorporation
+# 锟较猴拷锟斤拷司债
+TORA_TSTP_STP_SHBondCompany = cvar.TORA_TSTP_STP_SHBondCompany
+# 锟较猴拷锟斤拷转债
+TORA_TSTP_STP_SHBondConversion = cvar.TORA_TSTP_STP_SHBondConversion
+# 锟较猴拷锟斤拷锟斤拷债
+TORA_TSTP_STP_SHBondSeparation = cvar.TORA_TSTP_STP_SHBondSeparation
+# 锟较猴拷锟斤拷准券
+TORA_TSTP_STP_SHStandard = cvar.TORA_TSTP_STP_SHStandard
+# 锟较猴拷锟斤拷押式锟截癸拷
+TORA_TSTP_STP_SHRepo = cvar.TORA_TSTP_STP_SHRepo
+# 锟较猴拷锟斤拷锟绞斤拷锟斤拷锟�
+TORA_TSTP_STP_SHCEFund = cvar.TORA_TSTP_STP_SHCEFund
+# 锟较猴拷锟斤拷锟斤拷式锟斤拷锟斤拷
+TORA_TSTP_STP_SHOEFund = cvar.TORA_TSTP_STP_SHOEFund
+# 锟较猴拷锟斤拷锟叫筹拷ETF
+TORA_TSTP_STP_SHCrossMarketStockETF = cvar.TORA_TSTP_STP_SHCrossMarketStockETF
+# 锟较猴拷锟界境ETF
+TORA_TSTP_STP_SHCrossBorderETF = cvar.TORA_TSTP_STP_SHCrossBorderETF
+# 锟较猴拷锟街硷拷母锟斤拷锟斤拷
+TORA_TSTP_STP_SHMontherStructFund = cvar.TORA_TSTP_STP_SHMontherStructFund
+# 锟较猴拷锟街硷拷锟接伙拷锟斤拷
+TORA_TSTP_STP_SHSubStructFund = cvar.TORA_TSTP_STP_SHSubStructFund
+# 锟较猴拷实时锟斤拷锟斤拷锟斤拷一锟斤拷锟�
+TORA_TSTP_STP_SHRealTimeMonetaryFund = cvar.TORA_TSTP_STP_SHRealTimeMonetaryFund
+# 锟较猴拷锟缴斤拷锟斤拷债
+TORA_TSTP_STP_SHExchangeableBond = cvar.TORA_TSTP_STP_SHExchangeableBond
+# 锟较猴拷锟斤拷准LOF锟斤拷锟斤拷
+TORA_TSTP_STP_SHLOF = cvar.TORA_TSTP_STP_SHLOF
+# 锟斤拷锟斤拷锟斤拷锟斤拷A锟斤拷
+TORA_TSTP_STP_SZMainAShares = cvar.TORA_TSTP_STP_SZMainAShares
+# 锟斤拷锟斤拷锟斤拷小锟斤拷业锟斤拷
+TORA_TSTP_STP_SZSME = cvar.TORA_TSTP_STP_SZSME
+# 锟斤拷锟节癸拷债锟斤拷锟截凤拷债
+TORA_TSTP_STP_SZBondNation = cvar.TORA_TSTP_STP_SZBondNation
+# 锟斤拷锟斤拷锟斤拷业债
+TORA_TSTP_STP_SZBondCorporation = cvar.TORA_TSTP_STP_SZBondCorporation
+# 锟斤拷锟节癸拷司债
+TORA_TSTP_STP_SZBondCompany = cvar.TORA_TSTP_STP_SZBondCompany
+# 锟斤拷锟节匡拷转债
+TORA_TSTP_STP_SZBondConversion = cvar.TORA_TSTP_STP_SZBondConversion
+# 锟斤拷锟节凤拷锟斤拷债
+TORA_TSTP_STP_SZBondSeparation = cvar.TORA_TSTP_STP_SZBondSeparation
+# 锟斤拷锟节达拷业锟斤拷(注锟斤拷锟斤拷)
+TORA_TSTP_STP_SZGEMReg = cvar.TORA_TSTP_STP_SZGEMReg
+# 锟斤拷锟节达拷业锟斤拷锟阶�(注锟斤拷锟斤拷)
+TORA_TSTP_STP_SZGEMBondConversionReg = cvar.TORA_TSTP_STP_SZGEMBondConversionReg
+# 锟斤拷锟节跨境ETF
+TORA_TSTP_STP_SZCrossBorderETF = cvar.TORA_TSTP_STP_SZCrossBorderETF
+# 锟斤拷锟节黄斤拷ETF
+TORA_TSTP_STP_SZGoldETF = cvar.TORA_TSTP_STP_SZGoldETF
+# 锟斤拷锟斤拷锟街斤拷债券ETF
+TORA_TSTP_STP_SZCashBondETF = cvar.TORA_TSTP_STP_SZCashBondETF
+# 锟斤拷锟节碉拷锟叫筹拷锟斤拷票ETF
+TORA_TSTP_STP_SZSingleMarketStockETF = cvar.TORA_TSTP_STP_SZSingleMarketStockETF
+# 锟斤拷锟节碉拷锟叫筹拷实锟斤拷债券ETF
+TORA_TSTP_STP_SZSingleMarketBondETF = cvar.TORA_TSTP_STP_SZSingleMarketBondETF
+# 锟斤拷锟节伙拷锟斤拷ETF
+TORA_TSTP_STP_SZMonetaryFundETF = cvar.TORA_TSTP_STP_SZMonetaryFundETF
+# 锟斤拷锟节达拷业锟斤拷
+TORA_TSTP_STP_SZGEM = cvar.TORA_TSTP_STP_SZGEM
+# 锟斤拷锟节达拷业锟斤拷山锟斤拷锟秸�
+TORA_TSTP_STP_SZGEMExchangeableBond = cvar.TORA_TSTP_STP_SZGEMExchangeableBond
+# 锟斤拷锟节达拷业锟斤拷山锟斤拷锟秸�(注锟斤拷锟斤拷)
+TORA_TSTP_STP_SZGEMExchangeableBondReg = cvar.TORA_TSTP_STP_SZGEMExchangeableBondReg
+# 锟斤拷锟节憋拷准券
+TORA_TSTP_STP_SZStandard = cvar.TORA_TSTP_STP_SZStandard
+# 锟斤拷锟斤拷锟斤拷押式锟截癸拷
+TORA_TSTP_STP_SZRepo = cvar.TORA_TSTP_STP_SZRepo
+# 锟斤拷锟节凤拷锟绞斤拷锟斤拷锟�
+TORA_TSTP_STP_SZCEFund = cvar.TORA_TSTP_STP_SZCEFund
+# 锟斤拷锟节匡拷锟斤拷式锟斤拷锟斤拷
+TORA_TSTP_STP_SZOEFund = cvar.TORA_TSTP_STP_SZOEFund
+# 锟斤拷锟节跨境锟斤拷锟斤拷式锟斤拷锟斤拷
+TORA_TSTP_STP_SZCrossBorderOEFund = cvar.TORA_TSTP_STP_SZCrossBorderOEFund
+# 锟斤拷锟节匡拷锟叫筹拷锟斤拷票ETF
+TORA_TSTP_STP_SZCrossMarketStockETF = cvar.TORA_TSTP_STP_SZCrossMarketStockETF
+# 锟斤拷锟节憋拷准LOF锟斤拷锟斤拷
+TORA_TSTP_STP_SZLOF = cvar.TORA_TSTP_STP_SZLOF
+# 锟斤拷锟节跨境LOF锟斤拷锟斤拷
+TORA_TSTP_STP_SZCrossBorderLOF = cvar.TORA_TSTP_STP_SZCrossBorderLOF
+# 锟斤拷锟节达拷统锟街硷拷母锟斤拷锟斤拷
+TORA_TSTP_STP_SZMontherStructFund = cvar.TORA_TSTP_STP_SZMontherStructFund
+# 锟斤拷锟节达拷统锟街硷拷锟接伙拷锟斤拷
+TORA_TSTP_STP_SZSubStructFund = cvar.TORA_TSTP_STP_SZSubStructFund
+# 锟斤拷锟节跨境锟街硷拷母锟斤拷锟斤拷
+TORA_TSTP_STP_SZMontherCrossBorderStructFund = cvar.TORA_TSTP_STP_SZMontherCrossBorderStructFund
+# 锟斤拷锟节跨境锟街硷拷锟接伙拷锟斤拷
+TORA_TSTP_STP_SZSubCrossBorderStructFund = cvar.TORA_TSTP_STP_SZSubCrossBorderStructFund
+# 锟斤拷锟节可斤拷锟斤拷债
+TORA_TSTP_STP_SZExchangeableBond = cvar.TORA_TSTP_STP_SZExchangeableBond
+# 锟斤拷锟节达拷业锟斤拷锟阶�
+TORA_TSTP_STP_SZGEMBondConversion = cvar.TORA_TSTP_STP_SZGEMBondConversion
+# 锟斤拷锟酵拷酃锟秸�
+TORA_TSTP_STP_SZSEHKBond = cvar.TORA_TSTP_STP_SZSEHKBond
+# 锟斤拷锟酵拷酃锟揭伙拷锟斤拷锟饺ㄖ�
+TORA_TSTP_STP_SZSEHKBasketWarrant = cvar.TORA_TSTP_STP_SZSEHKBasketWarrant
+# 锟斤拷锟酵拷酃晒杀锟�
+TORA_TSTP_STP_SZSEHKEquity = cvar.TORA_TSTP_STP_SZSEHKEquity
+# 锟斤拷锟酵拷酃锟斤拷锟斤拷锟�
+TORA_TSTP_STP_SZSEHKTrust = cvar.TORA_TSTP_STP_SZSEHKTrust
+# 锟斤拷锟酵拷酃锟饺ㄖ�
+TORA_TSTP_STP_SZSEHKWarrant = cvar.TORA_TSTP_STP_SZSEHKWarrant
+# 锟较猴拷锟斤拷锟斤拷凭证
+TORA_TSTP_STP_SHCDR = cvar.TORA_TSTP_STP_SHCDR
+# 锟较猴拷锟狡达拷锟斤拷锟狡�
+TORA_TSTP_STP_SHKC = cvar.TORA_TSTP_STP_SHKC
+# 锟狡达拷锟斤拷锟狡凤拷锟斤拷锟斤拷泻锟角�5锟斤拷锟斤拷锟斤拷锟秸ｏ拷
+TORA_TSTP_STP_SHKC1 = cvar.TORA_TSTP_STP_SHKC1
+# 锟较猴拷锟狡达拷锟斤拷锟斤拷锟狡局�
+TORA_TSTP_STP_SHKCCDR = cvar.TORA_TSTP_STP_SHKCCDR
+# 锟斤拷锟斤拷锟斤拷锟藉、锟斤拷小锟藉创锟斤拷锟斤拷业锟斤拷票锟斤拷锟斤拷锟狡局�
+TORA_TSTP_STP_SZCDR = cvar.TORA_TSTP_STP_SZCDR
+# 锟斤拷锟节达拷业锟藉创锟斤拷锟斤拷业锟斤拷票锟斤拷锟斤拷锟狡局�
+TORA_TSTP_STP_SZGEMCDR = cvar.TORA_TSTP_STP_SZGEMCDR
+# 锟斤拷锟节达拷业锟藉创锟斤拷锟斤拷业锟斤拷票锟斤拷锟斤拷锟狡局�(注锟斤拷锟斤拷)
+TORA_TSTP_STP_SZGEMCDRReg = cvar.TORA_TSTP_STP_SZGEMCDRReg
+# 锟斤拷锟斤拷锟斤拷品锟节伙拷ETF
+TORA_TSTP_STP_SZCommFuturesETF = cvar.TORA_TSTP_STP_SZCommFuturesETF
+# 锟斤拷锟节伙拷锟斤拷锟斤拷施锟斤拷锟斤拷
+TORA_TSTP_STP_SZInfrastructureFund = cvar.TORA_TSTP_STP_SZInfrastructureFund
+# 锟较猴拷锟狡达拷锟斤拷ETF
+TORA_TSTP_STP_SHKCETF = cvar.TORA_TSTP_STP_SHKCETF
+# 锟较猴拷锟狡达拷锟斤拷LOF
+TORA_TSTP_STP_SHKCLOF = cvar.TORA_TSTP_STP_SHKCLOF
+# 锟较猴拷锟狡达拷锟斤拷锟阶�
+TORA_TSTP_STP_SHKCBondConversion = cvar.TORA_TSTP_STP_SHKCBondConversion
+# 锟较猴拷锟斤拷锟斤拷锟阶�
+TORA_TSTP_STP_SHOrientedConversionBond = cvar.TORA_TSTP_STP_SHOrientedConversionBond
+# 锟斤拷锟节讹拷锟斤拷锟阶�
+TORA_TSTP_STP_SZOrientedConversionBond = cvar.TORA_TSTP_STP_SZOrientedConversionBond
+# 锟较猴拷锟斤拷锟斤拷锟斤拷施锟斤拷锟斤拷
+TORA_TSTP_STP_SHInfrastructureFund = cvar.TORA_TSTP_STP_SHInfrastructureFund
+# 锟斤拷锟斤拷锟斤拷票
+TORA_TSTP_STP_BJStock = cvar.TORA_TSTP_STP_BJStock
+# 锟斤拷
+TORA_TSTP_OUT_Shou = cvar.TORA_TSTP_OUT_Shou
+# 锟斤拷
+TORA_TSTP_OUT_Gu = cvar.TORA_TSTP_OUT_Gu
+# 锟斤拷
+TORA_TSTP_OUT_Fen = cvar.TORA_TSTP_OUT_Fen
+# 锟斤拷
+TORA_TSTP_OUT_Zhang = cvar.TORA_TSTP_OUT_Zhang
+# 锟斤拷值锟斤拷锟桔凤拷式
+TORA_TSTP_IMO_ValueLimit = cvar.TORA_TSTP_IMO_ValueLimit
+# 锟斤拷锟斤拷锟斤拷锟桔凤拷式
+TORA_TSTP_IMO_AddIssue = cvar.TORA_TSTP_IMO_AddIssue
+# 锟斤拷锟斤拷锟疥购锟斤拷式
+TORA_TSTP_IMO_Credit = cvar.TORA_TSTP_IMO_Credit
+# 锟斤拷锟桔凤拷锟斤拷(锟斤拷锟斤拷锟斤拷)
+TORA_TSTP_IMO_Fixed = cvar.TORA_TSTP_IMO_Fixed
+# 锟斤拷锟桔凤拷锟斤拷(锟斤拷锟斤拷锟斤拷)
+TORA_TSTP_IMO_Auction = cvar.TORA_TSTP_IMO_Auction
+# 锟斤拷锟斤拷
+TORA_TSTP_USTS_Enabled = cvar.TORA_TSTP_USTS_Enabled
+# 锟斤拷锟斤拷
+TORA_TSTP_USTS_Disabled = cvar.TORA_TSTP_USTS_Disabled
+# 锟斤拷锟斤拷
+TORA_TSTP_USTS_Locked = cvar.TORA_TSTP_USTS_Locked
+# 锟斤拷锟斤拷
+TORA_TSTP_CT_Person = cvar.TORA_TSTP_CT_Person
+# 锟斤拷锟斤拷
+TORA_TSTP_CT_Company = cvar.TORA_TSTP_CT_Company
+# 锟斤拷营
+TORA_TSTP_CT_SelfOperate = cvar.TORA_TSTP_CT_SelfOperate
+# 锟斤拷锟斤拷
+TORA_TSTP_CT_Test = cvar.TORA_TSTP_CT_Test
+# 锟斤拷织锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_ICT_EID = cvar.TORA_TSTP_ICT_EID
+# 锟叫癸拷锟斤拷锟斤拷锟斤拷锟街�
+TORA_TSTP_ICT_IDCard = cvar.TORA_TSTP_ICT_IDCard
+# 锟斤拷锟斤拷证
+TORA_TSTP_ICT_OfficerIDCard = cvar.TORA_TSTP_ICT_OfficerIDCard
+# 锟斤拷锟斤拷证
+TORA_TSTP_ICT_PoliceIDCard = cvar.TORA_TSTP_ICT_PoliceIDCard
+# 士锟斤拷证
+TORA_TSTP_ICT_SoldierIDCard = cvar.TORA_TSTP_ICT_SoldierIDCard
+# 锟斤拷锟节诧拷
+TORA_TSTP_ICT_HouseholdRegister = cvar.TORA_TSTP_ICT_HouseholdRegister
+# 锟斤拷锟斤拷
+TORA_TSTP_ICT_Passport = cvar.TORA_TSTP_ICT_Passport
+# 台锟斤拷证
+TORA_TSTP_ICT_TaiwanCompatriotIDCard = cvar.TORA_TSTP_ICT_TaiwanCompatriotIDCard
+# 锟斤拷锟斤拷证
+TORA_TSTP_ICT_HomeComingCard = cvar.TORA_TSTP_ICT_HomeComingCard
+# 营业执锟秸猴拷
+TORA_TSTP_ICT_LicenseNo = cvar.TORA_TSTP_ICT_LicenseNo
+# 税锟斤拷羌呛锟�/锟斤拷锟斤拷锟斤拷税ID
+TORA_TSTP_ICT_TaxNo = cvar.TORA_TSTP_ICT_TaxNo
+# 锟桔澳撅拷锟斤拷锟斤拷锟斤拷锟节碉拷通锟斤拷证
+TORA_TSTP_ICT_HMMainlandTravelPermit = cvar.TORA_TSTP_ICT_HMMainlandTravelPermit
+# 台锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟铰酵拷锟街�
+TORA_TSTP_ICT_TwMainlandTravelPermit = cvar.TORA_TSTP_ICT_TwMainlandTravelPermit
+# 锟斤拷锟斤拷
+TORA_TSTP_ICT_DrivingLicense = cvar.TORA_TSTP_ICT_DrivingLicense
+# 锟斤拷锟斤拷锟界保ID
+TORA_TSTP_ICT_SocialID = cvar.TORA_TSTP_ICT_SocialID
+# 锟斤拷锟斤拷锟斤拷锟街�
+TORA_TSTP_ICT_LocalID = cvar.TORA_TSTP_ICT_LocalID
+# 锟斤拷业锟角硷拷证
+TORA_TSTP_ICT_BusinessRegistration = cvar.TORA_TSTP_ICT_BusinessRegistration
+# 锟桔帮拷锟斤拷锟斤拷锟皆撅拷锟斤拷锟斤拷锟街�
+TORA_TSTP_ICT_HKMCIDCard = cvar.TORA_TSTP_ICT_HKMCIDCard
+# 锟斤拷锟叫匡拷锟斤拷锟斤拷锟街�
+TORA_TSTP_ICT_AccountsPermits = cvar.TORA_TSTP_ICT_AccountsPermits
+# 锟斤拷锟斤拷证锟斤拷
+TORA_TSTP_ICT_OtherCard = cvar.TORA_TSTP_ICT_OtherCard
+# 锟斤拷锟斤拷
+TORA_TSTP_TS_Normal = cvar.TORA_TSTP_TS_Normal
+# 锟斤拷锟斤拷强平
+TORA_TSTP_TS_ForceClosing = cvar.TORA_TSTP_TS_ForceClosing
+# 锟届常
+TORA_TSTP_TS_Exception = cvar.TORA_TSTP_TS_Exception
+# 锟斤拷专业投锟斤拷锟斤拷
+TORA_TSTP_PIT_Normal = cvar.TORA_TSTP_PIT_Normal
+# 专业投锟斤拷锟斤拷
+TORA_TSTP_PIT_Professional = cvar.TORA_TSTP_PIT_Professional
+# 锟斤拷准锟阶诧拷
+TORA_TSTP_PLTP_Standard = cvar.TORA_TSTP_PLTP_Standard
+# 锟斤拷锟斤拷锟阶诧拷
+TORA_TSTP_PLTP_Smart = cvar.TORA_TSTP_PLTP_Smart
+# 预锟斤拷1
+TORA_TSTP_PLTP_Reserve1 = cvar.TORA_TSTP_PLTP_Reserve1
+# 预锟斤拷2
+TORA_TSTP_PLTP_Reserve2 = cvar.TORA_TSTP_PLTP_Reserve2
+# 未锟斤拷锟斤拷锟斤拷锟酵ｏ拷锟节诧拷使锟矫ｏ拷
+TORA_TSTP_PLTP_Undefined = cvar.TORA_TSTP_PLTP_Undefined
+# 投锟斤拷
+TORA_TSTP_SIDT_Speculation = cvar.TORA_TSTP_SIDT_Speculation
+# 锟斤拷锟斤拷
+TORA_TSTP_SIDT_Arbitrage = cvar.TORA_TSTP_SIDT_Arbitrage
+# 锟阶憋拷
+TORA_TSTP_SIDT_Hedge = cvar.TORA_TSTP_SIDT_Hedge
+# 锟斤拷通
+TORA_TSTP_SIDT_Normal = cvar.TORA_TSTP_SIDT_Normal
+# 锟斤拷锟斤拷
+TORA_TSTP_SIDT_Credit = cvar.TORA_TSTP_SIDT_Credit
+# 锟斤拷锟斤拷品
+TORA_TSTP_SIDT_Derivatives = cvar.TORA_TSTP_SIDT_Derivatives
+# 预锟斤拷
+TORA_TSTP_CORDS_Cached = cvar.TORA_TSTP_CORDS_Cached
+# 锟斤拷锟结交
+TORA_TSTP_CORDS_Submitted = cvar.TORA_TSTP_CORDS_Submitted
+# 锟缴癸拷
+TORA_TSTP_CORDS_Success = cvar.TORA_TSTP_CORDS_Success
+# 锟杰撅拷
+TORA_TSTP_CORDS_Rejected = cvar.TORA_TSTP_CORDS_Rejected
+# 锟斤拷通锟斤拷锟斤拷
+TORA_TSTP_CORDT_Normal = cvar.TORA_TSTP_CORDT_Normal
+# 强锟狡筹拷锟斤拷
+TORA_TSTP_CORDT_Force = cvar.TORA_TSTP_CORDT_Force
+# 预锟今撤碉拷
+TORA_TSTP_CORDT_Cache = cvar.TORA_TSTP_CORDT_Cache
+# 通锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CORDT_Board = cvar.TORA_TSTP_CORDT_Board
+# 锟斤拷通
+TORA_TSTP_FAT_Normal = cvar.TORA_TSTP_FAT_Normal
+# 锟斤拷锟斤拷
+TORA_TSTP_FAT_Credit = cvar.TORA_TSTP_FAT_Credit
+# 锟斤拷锟斤拷品
+TORA_TSTP_FAT_Derivatives = cvar.TORA_TSTP_FAT_Derivatives
+# 锟斤拷锟斤拷
+TORA_TSTP_BC_Buy = cvar.TORA_TSTP_BC_Buy
+# 锟斤拷锟斤拷
+TORA_TSTP_BC_Sell = cvar.TORA_TSTP_BC_Sell
+# ETF锟疥购
+TORA_TSTP_BC_ETFPur = cvar.TORA_TSTP_BC_ETFPur
+# ETF锟斤拷锟�
+TORA_TSTP_BC_ETFRed = cvar.TORA_TSTP_BC_ETFRed
+# 锟铰癸拷锟疥购
+TORA_TSTP_BC_SubscribingShares = cvar.TORA_TSTP_BC_SubscribingShares
+# 锟斤拷锟截癸拷
+TORA_TSTP_BC_Repurchase = cvar.TORA_TSTP_BC_Repurchase
+# 锟斤拷毓锟�
+TORA_TSTP_BC_ReverseRepur = cvar.TORA_TSTP_BC_ReverseRepur
+# 锟斤拷锟斤拷式锟斤拷锟斤拷锟疥购
+TORA_TSTP_BC_OeFundPur = cvar.TORA_TSTP_BC_OeFundPur
+# 锟斤拷锟斤拷式锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_BC_OeFundRed = cvar.TORA_TSTP_BC_OeFundRed
+# 锟斤拷锟斤拷品锟斤拷锟斤拷
+TORA_TSTP_BC_CollateralIn = cvar.TORA_TSTP_BC_CollateralIn
+# 锟斤拷锟斤拷品锟斤拷锟斤拷
+TORA_TSTP_BC_CollateralOut = cvar.TORA_TSTP_BC_CollateralOut
+# 锟斤拷押锟斤拷锟�
+TORA_TSTP_BC_PledgeIn = cvar.TORA_TSTP_BC_PledgeIn
+# 锟斤拷押锟斤拷锟斤拷
+TORA_TSTP_BC_PledgeOut = cvar.TORA_TSTP_BC_PledgeOut
+# 锟斤拷锟斤拷锟秸�
+TORA_TSTP_BC_Rationed = cvar.TORA_TSTP_BC_Rationed
+# 锟斤拷锟斤拷式锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BC_Split = cvar.TORA_TSTP_BC_Split
+# 锟斤拷锟斤拷式锟斤拷锟斤拷喜锟�
+TORA_TSTP_BC_Merge = cvar.TORA_TSTP_BC_Merge
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_BC_CreditBuy = cvar.TORA_TSTP_BC_CreditBuy
+# 锟斤拷券锟斤拷锟斤拷
+TORA_TSTP_BC_CreditSell = cvar.TORA_TSTP_BC_CreditSell
+# 锟斤拷券锟斤拷锟斤拷
+TORA_TSTP_BC_SellRepay = cvar.TORA_TSTP_BC_SellRepay
+# 锟斤拷券锟斤拷券
+TORA_TSTP_BC_BuyRepay = cvar.TORA_TSTP_BC_BuyRepay
+# 锟斤拷券锟斤拷转
+TORA_TSTP_BC_RepayTransfer = cvar.TORA_TSTP_BC_RepayTransfer
+# 锟斤拷券锟斤拷转
+TORA_TSTP_BC_SurplusTransfer = cvar.TORA_TSTP_BC_SurplusTransfer
+# 源券锟斤拷转
+TORA_TSTP_BC_SourceTransfer = cvar.TORA_TSTP_BC_SourceTransfer
+# 锟斤拷券强平锟斤拷锟斤拷(锟节诧拷使锟斤拷)
+TORA_TSTP_BC_ForceSellRepay = cvar.TORA_TSTP_BC_ForceSellRepay
+# 锟斤拷券强平锟斤拷券(锟节诧拷使锟斤拷)
+TORA_TSTP_BC_ForceBuyRepay = cvar.TORA_TSTP_BC_ForceBuyRepay
+# 锟斤拷债展锟斤拷(锟节诧拷使锟斤拷)
+TORA_TSTP_BC_DebtExtend = cvar.TORA_TSTP_BC_DebtExtend
+# 转锟叫癸拷
+TORA_TSTP_BC_CustodyTransfer = cvar.TORA_TSTP_BC_CustodyTransfer
+# 债券转锟斤拷
+TORA_TSTP_BC_BondConvertStock = cvar.TORA_TSTP_BC_BondConvertStock
+# 债券锟斤拷锟斤拷
+TORA_TSTP_BC_BondPutback = cvar.TORA_TSTP_BC_BondPutback
+# ETF实锟斤拷锟疥购
+TORA_TSTP_BC_ETFOtPur = cvar.TORA_TSTP_BC_ETFOtPur
+# ETF实锟斤拷锟斤拷锟�
+TORA_TSTP_BC_ETFOtRed = cvar.TORA_TSTP_BC_ETFOtRed
+# 锟斤拷锟桔筹拷锟斤拷
+TORA_TSTP_BC_PutbackRelieve = cvar.TORA_TSTP_BC_PutbackRelieve
+# 毛佣锟斤拷
+TORA_TSTP_BT_Gross = cvar.TORA_TSTP_BT_Gross
+# 锟斤拷佣锟斤拷
+TORA_TSTP_BT_Net = cvar.TORA_TSTP_BT_Net
+# 实时锟较筹拷
+TORA_TSTP_OPRTSRC_DBCommand = cvar.TORA_TSTP_OPRTSRC_DBCommand
+# API锟斤拷锟斤拷
+TORA_TSTP_OPRTSRC_SyncAPI = cvar.TORA_TSTP_OPRTSRC_SyncAPI
+# 锟皆讹拷锟斤拷锟斤拷
+TORA_TSTP_OPRTSRC_AutoTrigger = cvar.TORA_TSTP_OPRTSRC_AutoTrigger
+# API锟斤拷锟斤拷锟较筹拷
+TORA_TSTP_OPRTSRC_EmergencyAPI = cvar.TORA_TSTP_OPRTSRC_EmergencyAPI
+# 锟斤拷业锟斤拷
+TORA_TSTP_SPLT_GEM = cvar.TORA_TSTP_SPLT_GEM
+# 锟斤拷锟秸撅拷示锟斤拷
+TORA_TSTP_SPLT_RiskWarning = cvar.TORA_TSTP_SPLT_RiskWarning
+# 锟斤拷锟斤拷锟斤拷锟斤拷锟�
+TORA_TSTP_SPLT_Delisting = cvar.TORA_TSTP_SPLT_Delisting
+# 锟桔癸拷通
+TORA_TSTP_SPLT_SZSEHK = cvar.TORA_TSTP_SPLT_SZSEHK
+# 锟狡达拷锟斤拷
+TORA_TSTP_SPLT_SHKC = cvar.TORA_TSTP_SPLT_SHKC
+# 锟斤拷业锟斤拷注锟斤拷锟斤拷
+TORA_TSTP_SPLT_GEMRegistration = cvar.TORA_TSTP_SPLT_GEMRegistration
+# 锟街硷拷锟斤拷锟斤拷
+TORA_TSTP_SPLT_StructFund = cvar.TORA_TSTP_SPLT_StructFund
+# 锟斤拷转债
+TORA_TSTP_SPLT_ConvertBond = cvar.TORA_TSTP_SPLT_ConvertBond
+# 锟斤拷锟斤拷锟斤拷施锟斤拷锟斤拷
+TORA_TSTP_SPLT_InfrastructureFund = cvar.TORA_TSTP_SPLT_InfrastructureFund
+# 锟斤拷锟斤拷锟阶�
+TORA_TSTP_SPLT_OrientedConvertBond = cvar.TORA_TSTP_SPLT_OrientedConvertBond
+# 锟斤拷锟斤拷锟斤拷锟斤拷票
+TORA_TSTP_SPLT_BJStock = cvar.TORA_TSTP_SPLT_BJStock
+# 锟斤拷通锟斤拷锟斤拷
+TORA_TSTP_CRT_IS = cvar.TORA_TSTP_CRT_IS
+# 实锟斤拷锟斤拷锟斤拷
+TORA_TSTP_CRT_OS = cvar.TORA_TSTP_CRT_OS
+# 锟斤拷止锟街斤拷锟斤拷锟�
+TORA_TSTP_ETFCTSTAT_Forbidden = cvar.TORA_TSTP_ETFCTSTAT_Forbidden
+# 锟斤拷锟斤拷锟街斤拷锟斤拷锟�
+TORA_TSTP_ETFCTSTAT_Allow = cvar.TORA_TSTP_ETFCTSTAT_Allow
+# 锟斤拷锟斤拷锟街斤拷锟斤拷锟�
+TORA_TSTP_ETFCTSTAT_Force = cvar.TORA_TSTP_ETFCTSTAT_Force
+# 锟斤拷锟斤拷锟剿诧拷锟街斤拷锟斤拷锟�
+TORA_TSTP_ETFCTSTAT_CBAllow = cvar.TORA_TSTP_ETFCTSTAT_CBAllow
+# 锟斤拷锟叫憋拷锟斤拷锟街斤拷锟斤拷锟�
+TORA_TSTP_ETFCTSTAT_CBForce = cvar.TORA_TSTP_ETFCTSTAT_CBForce
+# 锟缴憋拷证券
+TORA_TSTP_PTID_Stock = cvar.TORA_TSTP_PTID_Stock
+# 债锟斤拷证券
+TORA_TSTP_PTID_Bond = cvar.TORA_TSTP_PTID_Bond
+# 锟斤拷票锟斤拷权
+TORA_TSTP_PTID_Option = cvar.TORA_TSTP_PTID_Option
+# 锟斤拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_PTID_Fund = cvar.TORA_TSTP_PTID_Fund
+# 锟桔革拷锟斤拷锟斤拷锟斤拷
+TORA_TSTP_PPT_LimitPrice = cvar.TORA_TSTP_PPT_LimitPrice
+# 锟桔诧拷锟斤拷
+TORA_TSTP_PPT_PriceTick = cvar.TORA_TSTP_PPT_PriceTick
+# 锟斤拷准LOF
+TORA_TSTP_FUT_Normal = cvar.TORA_TSTP_FUT_Normal
+# 锟街硷拷母锟斤拷锟斤拷
+TORA_TSTP_FUT_Mother = cvar.TORA_TSTP_FUT_Mother
+# 锟街硷拷锟接伙拷锟斤拷
+TORA_TSTP_FUT_Sub = cvar.TORA_TSTP_FUT_Sub
+# TCP模式
+TORA_TSTP_TCM_TCP = cvar.TORA_TSTP_TCM_TCP
+# UDP模式
+TORA_TSTP_TCM_UDP = cvar.TORA_TSTP_TCM_UDP
+# PROXY模式
+TORA_TSTP_TCM_PROXY = cvar.TORA_TSTP_TCM_PROXY
+
+
+
+
+#########################################锟斤拷录锟斤拷应############################################
+class CTORATstpRspUserLoginField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspUserLoginField_UserRequestID_get, _traderapi.CTORATstpRspUserLoginField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpRspUserLoginField_DepartmentID_get, _traderapi.CTORATstpRspUserLoginField_DepartmentID_set)
+
+ # 锟斤拷录锟剿伙拷
+ LogInAccount = property(_traderapi.CTORATstpRspUserLoginField_LogInAccount_get, _traderapi.CTORATstpRspUserLoginField_LogInAccount_set)
+
+ # 锟斤拷录锟剿伙拷锟斤拷锟斤拷
+ LogInAccountType = property(_traderapi.CTORATstpRspUserLoginField_LogInAccountType_get, _traderapi.CTORATstpRspUserLoginField_LogInAccountType_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpRspUserLoginField_FrontID_get, _traderapi.CTORATstpRspUserLoginField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpRspUserLoginField_SessionID_get, _traderapi.CTORATstpRspUserLoginField_SessionID_set)
+
+ # 锟斤拷蟊ǖ锟斤拷锟斤拷锟�
+ MaxOrderRef = property(_traderapi.CTORATstpRspUserLoginField_MaxOrderRef_get, _traderapi.CTORATstpRspUserLoginField_MaxOrderRef_set)
+
+ # 私锟斤拷锟斤拷锟斤拷锟斤拷
+ PrivateFlowCount = property(_traderapi.CTORATstpRspUserLoginField_PrivateFlowCount_get, _traderapi.CTORATstpRspUserLoginField_PrivateFlowCount_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ PublicFlowCount = property(_traderapi.CTORATstpRspUserLoginField_PublicFlowCount_get, _traderapi.CTORATstpRspUserLoginField_PublicFlowCount_set)
+
+ # 锟斤拷录时锟斤拷
+ LoginTime = property(_traderapi.CTORATstpRspUserLoginField_LoginTime_get, _traderapi.CTORATstpRspUserLoginField_LoginTime_set)
+
+ # 锟斤拷锟斤拷系统锟斤拷锟斤拷
+ SystemName = property(_traderapi.CTORATstpRspUserLoginField_SystemName_get, _traderapi.CTORATstpRspUserLoginField_SystemName_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpRspUserLoginField_TradingDay_get, _traderapi.CTORATstpRspUserLoginField_TradingDay_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpRspUserLoginField_UserID_get, _traderapi.CTORATstpRspUserLoginField_UserID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserName = property(_traderapi.CTORATstpRspUserLoginField_UserName_get, _traderapi.CTORATstpRspUserLoginField_UserName_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserType = property(_traderapi.CTORATstpRspUserLoginField_UserType_get, _traderapi.CTORATstpRspUserLoginField_UserType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderInsertCommFlux = property(_traderapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_get, _traderapi.CTORATstpRspUserLoginField_OrderInsertCommFlux_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderActionCommFlux = property(_traderapi.CTORATstpRspUserLoginField_OrderActionCommFlux_get, _traderapi.CTORATstpRspUserLoginField_OrderActionCommFlux_set)
+
+ # 锟斤拷锟诫到锟斤拷锟斤拷锟斤拷
+ PasswordExpiryDate = property(_traderapi.CTORATstpRspUserLoginField_PasswordExpiryDate_get, _traderapi.CTORATstpRspUserLoginField_PasswordExpiryDate_set)
+
+ # 锟角凤拷锟斤拷要锟斤拷锟斤拷
+ NeedUpdatePassword = property(_traderapi.CTORATstpRspUserLoginField_NeedUpdatePassword_get, _traderapi.CTORATstpRspUserLoginField_NeedUpdatePassword_set)
+
+ # 锟斤拷证锟斤拷锟叫猴拷
+ CertSerial = property(_traderapi.CTORATstpRspUserLoginField_CertSerial_get, _traderapi.CTORATstpRspUserLoginField_CertSerial_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ InnerIPAddress = property(_traderapi.CTORATstpRspUserLoginField_InnerIPAddress_get, _traderapi.CTORATstpRspUserLoginField_InnerIPAddress_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ OuterIPAddress = property(_traderapi.CTORATstpRspUserLoginField_OuterIPAddress_get, _traderapi.CTORATstpRspUserLoginField_OuterIPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpRspUserLoginField_MacAddress_get, _traderapi.CTORATstpRspUserLoginField_MacAddress_set)
+
+ # 锟斤拷锟斤拷锟节碉拷锟斤拷(锟节诧拷使锟斤拷)
+ NodeRef = property(_traderapi.CTORATstpRspUserLoginField_NodeRef_get, _traderapi.CTORATstpRspUserLoginField_NodeRef_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspUserLoginField_swiginit(self, _traderapi.new_CTORATstpRspUserLoginField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspUserLoginField
+
+# Register CTORATstpRspUserLoginField in _traderapi:
+_traderapi.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(_traderapi.CTORATstpRspInfoField_ErrorID_get, _traderapi.CTORATstpRspInfoField_ErrorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷息
+ ErrorMsg = property(_traderapi.CTORATstpRspInfoField_ErrorMsg_get, _traderapi.CTORATstpRspInfoField_ErrorMsg_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInfoField_swiginit(self, _traderapi.new_CTORATstpRspInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInfoField
+
+# Register CTORATstpRspInfoField in _traderapi:
+_traderapi.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
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpUserLogoutField_UserRequestID_get, _traderapi.CTORATstpUserLogoutField_UserRequestID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpUserLogoutField_UserID_get, _traderapi.CTORATstpUserLogoutField_UserID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpUserLogoutField_swiginit(self, _traderapi.new_CTORATstpUserLogoutField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpUserLogoutField
+
+# Register CTORATstpUserLogoutField in _traderapi:
+_traderapi.CTORATstpUserLogoutField_swigregister(CTORATstpUserLogoutField)
+
+
+
+
+#########################################锟睫革拷锟矫伙拷锟斤拷锟斤拷############################################
+class CTORATstpUserPasswordUpdateField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpUserPasswordUpdateField_UserID_get, _traderapi.CTORATstpUserPasswordUpdateField_UserID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ OldPassword = property(_traderapi.CTORATstpUserPasswordUpdateField_OldPassword_get, _traderapi.CTORATstpUserPasswordUpdateField_OldPassword_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ NewPassword = property(_traderapi.CTORATstpUserPasswordUpdateField_NewPassword_get, _traderapi.CTORATstpUserPasswordUpdateField_NewPassword_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpUserPasswordUpdateField_UserRequestID_get, _traderapi.CTORATstpUserPasswordUpdateField_UserRequestID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpUserPasswordUpdateField_swiginit(self, _traderapi.new_CTORATstpUserPasswordUpdateField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpUserPasswordUpdateField
+
+# Register CTORATstpUserPasswordUpdateField in _traderapi:
+_traderapi.CTORATstpUserPasswordUpdateField_swigregister(CTORATstpUserPasswordUpdateField)
+
+
+
+
+#########################################锟斤拷锟斤拷录锟斤拷锟借备锟斤拷锟斤拷############################################
+class CTORATstpReqInputDeviceSerialField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqInputDeviceSerialField_UserRequestID_get, _traderapi.CTORATstpReqInputDeviceSerialField_UserRequestID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpReqInputDeviceSerialField_UserID_get, _traderapi.CTORATstpReqInputDeviceSerialField_UserID_set)
+
+ # 锟借备锟斤拷识
+ DeviceID = property(_traderapi.CTORATstpReqInputDeviceSerialField_DeviceID_get, _traderapi.CTORATstpReqInputDeviceSerialField_DeviceID_set)
+
+ # 锟借备锟斤拷锟叫猴拷
+ CertSerial = property(_traderapi.CTORATstpReqInputDeviceSerialField_CertSerial_get, _traderapi.CTORATstpReqInputDeviceSerialField_CertSerial_set)
+
+ # 锟借备锟斤拷锟�
+ DeviceType = property(_traderapi.CTORATstpReqInputDeviceSerialField_DeviceType_get, _traderapi.CTORATstpReqInputDeviceSerialField_DeviceType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqInputDeviceSerialField_swiginit(self, _traderapi.new_CTORATstpReqInputDeviceSerialField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqInputDeviceSerialField
+
+# Register CTORATstpReqInputDeviceSerialField in _traderapi:
+_traderapi.CTORATstpReqInputDeviceSerialField_swigregister(CTORATstpReqInputDeviceSerialField)
+
+
+
+
+#########################################录锟斤拷锟借备锟斤拷锟斤拷锟斤拷应############################################
+class CTORATstpRspInputDeviceSerialField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspInputDeviceSerialField_UserRequestID_get, _traderapi.CTORATstpRspInputDeviceSerialField_UserRequestID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpRspInputDeviceSerialField_UserID_get, _traderapi.CTORATstpRspInputDeviceSerialField_UserID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInputDeviceSerialField_swiginit(self, _traderapi.new_CTORATstpRspInputDeviceSerialField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInputDeviceSerialField
+
+# Register CTORATstpRspInputDeviceSerialField in _traderapi:
+_traderapi.CTORATstpRspInputDeviceSerialField_swigregister(CTORATstpRspInputDeviceSerialField)
+
+
+
+
+#########################################锟斤拷锟诫报锟斤拷############################################
+class CTORATstpInputOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputOrderField_UserRequestID_get, _traderapi.CTORATstpInputOrderField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputOrderField_ExchangeID_get, _traderapi.CTORATstpInputOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputOrderField_InvestorID_get, _traderapi.CTORATstpInputOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInputOrderField_BusinessUnitID_get, _traderapi.CTORATstpInputOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInputOrderField_ShareholderID_get, _traderapi.CTORATstpInputOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputOrderField_SecurityID_get, _traderapi.CTORATstpInputOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpInputOrderField_Direction_get, _traderapi.CTORATstpInputOrderField_Direction_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpInputOrderField_LimitPrice_get, _traderapi.CTORATstpInputOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpInputOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpInputOrderField_VolumeTotalOriginal_set)
+
+ # 锟斤拷锟斤拷锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpInputOrderField_OrderPriceType_get, _traderapi.CTORATstpInputOrderField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpInputOrderField_TimeCondition_get, _traderapi.CTORATstpInputOrderField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpInputOrderField_VolumeCondition_get, _traderapi.CTORATstpInputOrderField_VolumeCondition_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputOrderField_Operway_get, _traderapi.CTORATstpInputOrderField_Operway_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpInputOrderField_OrderRef_get, _traderapi.CTORATstpInputOrderField_OrderRef_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpInputOrderField_LotType_get, _traderapi.CTORATstpInputOrderField_LotType_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputOrderField_OrderSysID_get, _traderapi.CTORATstpInputOrderField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondCheck = property(_traderapi.CTORATstpInputOrderField_CondCheck_get, _traderapi.CTORATstpInputOrderField_CondCheck_set)
+
+ # 锟斤拷效锟斤拷锟斤拷
+ GTDate = property(_traderapi.CTORATstpInputOrderField_GTDate_get, _traderapi.CTORATstpInputOrderField_GTDate_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpInputOrderField_ForceCloseReason_get, _traderapi.CTORATstpInputOrderField_ForceCloseReason_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpInputOrderField_CreditDebtID_get, _traderapi.CTORATstpInputOrderField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaType = property(_traderapi.CTORATstpInputOrderField_CreditQuotaType_get, _traderapi.CTORATstpInputOrderField_CreditQuotaType_set)
+
+ # 锟斤拷息锟桔匡拷券锟斤拷牛锟�0锟斤拷示锟斤拷使锟斤拷锟桔匡拷券锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ DiscountCouponID = property(_traderapi.CTORATstpInputOrderField_DiscountCouponID_get, _traderapi.CTORATstpInputOrderField_DiscountCouponID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputOrderField_SInfo_get, _traderapi.CTORATstpInputOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputOrderField_IInfo_get, _traderapi.CTORATstpInputOrderField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputOrderField_swiginit(self, _traderapi.new_CTORATstpInputOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputOrderField
+
+# Register CTORATstpInputOrderField in _traderapi:
+_traderapi.CTORATstpInputOrderField_swigregister(CTORATstpInputOrderField)
+
+
+
+
+#########################################锟斤拷锟斤拷############################################
+class CTORATstpOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpOrderField_ExchangeID_get, _traderapi.CTORATstpOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpOrderField_InvestorID_get, _traderapi.CTORATstpOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpOrderField_BusinessUnitID_get, _traderapi.CTORATstpOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpOrderField_ShareholderID_get, _traderapi.CTORATstpOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpOrderField_SecurityID_get, _traderapi.CTORATstpOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpOrderField_Direction_get, _traderapi.CTORATstpOrderField_Direction_set)
+
+ # 锟斤拷锟斤拷锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpOrderField_OrderPriceType_get, _traderapi.CTORATstpOrderField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpOrderField_TimeCondition_get, _traderapi.CTORATstpOrderField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpOrderField_VolumeCondition_get, _traderapi.CTORATstpOrderField_VolumeCondition_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpOrderField_LimitPrice_get, _traderapi.CTORATstpOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpOrderField_VolumeTotalOriginal_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpOrderField_LotType_get, _traderapi.CTORATstpOrderField_LotType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷
+ GTDate = property(_traderapi.CTORATstpOrderField_GTDate_get, _traderapi.CTORATstpOrderField_GTDate_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpOrderField_Operway_get, _traderapi.CTORATstpOrderField_Operway_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondCheck = property(_traderapi.CTORATstpOrderField_CondCheck_get, _traderapi.CTORATstpOrderField_CondCheck_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpOrderField_SInfo_get, _traderapi.CTORATstpOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpOrderField_IInfo_get, _traderapi.CTORATstpOrderField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpOrderField_RequestID_get, _traderapi.CTORATstpOrderField_RequestID_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpOrderField_FrontID_get, _traderapi.CTORATstpOrderField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpOrderField_SessionID_get, _traderapi.CTORATstpOrderField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpOrderField_OrderRef_get, _traderapi.CTORATstpOrderField_OrderRef_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpOrderField_OrderLocalID_get, _traderapi.CTORATstpOrderField_OrderLocalID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpOrderField_OrderSysID_get, _traderapi.CTORATstpOrderField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷状态
+ OrderStatus = property(_traderapi.CTORATstpOrderField_OrderStatus_get, _traderapi.CTORATstpOrderField_OrderStatus_set)
+
+ # 锟斤拷锟斤拷锟结交状态
+ OrderSubmitStatus = property(_traderapi.CTORATstpOrderField_OrderSubmitStatus_get, _traderapi.CTORATstpOrderField_OrderSubmitStatus_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpOrderField_StatusMsg_get, _traderapi.CTORATstpOrderField_StatusMsg_set)
+
+ # 锟窖成斤拷锟斤拷锟斤拷
+ VolumeTraded = property(_traderapi.CTORATstpOrderField_VolumeTraded_get, _traderapi.CTORATstpOrderField_VolumeTraded_set)
+
+ # 锟窖筹拷锟斤拷锟斤拷锟斤拷
+ VolumeCanceled = property(_traderapi.CTORATstpOrderField_VolumeCanceled_get, _traderapi.CTORATstpOrderField_VolumeCanceled_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpOrderField_TradingDay_get, _traderapi.CTORATstpOrderField_TradingDay_set)
+
+ # 锟疥报锟矫伙拷
+ InsertUser = property(_traderapi.CTORATstpOrderField_InsertUser_get, _traderapi.CTORATstpOrderField_InsertUser_set)
+
+ # 锟疥报锟斤拷锟斤拷
+ InsertDate = property(_traderapi.CTORATstpOrderField_InsertDate_get, _traderapi.CTORATstpOrderField_InsertDate_set)
+
+ # 锟疥报时锟斤拷
+ InsertTime = property(_traderapi.CTORATstpOrderField_InsertTime_get, _traderapi.CTORATstpOrderField_InsertTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷
+ AcceptTime = property(_traderapi.CTORATstpOrderField_AcceptTime_get, _traderapi.CTORATstpOrderField_AcceptTime_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ CancelUser = property(_traderapi.CTORATstpOrderField_CancelUser_get, _traderapi.CTORATstpOrderField_CancelUser_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ CancelTime = property(_traderapi.CTORATstpOrderField_CancelTime_get, _traderapi.CTORATstpOrderField_CancelTime_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpOrderField_DepartmentID_get, _traderapi.CTORATstpOrderField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpOrderField_AccountID_get, _traderapi.CTORATstpOrderField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpOrderField_CurrencyID_get, _traderapi.CTORATstpOrderField_CurrencyID_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpOrderField_PbuID_get, _traderapi.CTORATstpOrderField_PbuID_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ Turnover = property(_traderapi.CTORATstpOrderField_Turnover_get, _traderapi.CTORATstpOrderField_Turnover_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderType = property(_traderapi.CTORATstpOrderField_OrderType_get, _traderapi.CTORATstpOrderField_OrderType_set)
+
+ # 锟矫伙拷锟剿诧拷品锟斤拷息
+ UserProductInfo = property(_traderapi.CTORATstpOrderField_UserProductInfo_get, _traderapi.CTORATstpOrderField_UserProductInfo_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpOrderField_ForceCloseReason_get, _traderapi.CTORATstpOrderField_ForceCloseReason_set)
+
+ # 锟斤拷锟斤拷头锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaID = property(_traderapi.CTORATstpOrderField_CreditQuotaID_get, _traderapi.CTORATstpOrderField_CreditQuotaID_set)
+
+ # 头锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaType = property(_traderapi.CTORATstpOrderField_CreditQuotaType_get, _traderapi.CTORATstpOrderField_CreditQuotaType_set)
+
+ # 锟斤拷锟矫革拷债锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpOrderField_CreditDebtID_get, _traderapi.CTORATstpOrderField_CreditDebtID_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpOrderField_IPAddress_get, _traderapi.CTORATstpOrderField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpOrderField_MacAddress_get, _traderapi.CTORATstpOrderField_MacAddress_set)
+
+ # 锟截憋拷锟斤拷锟接革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ RtnFloatInfo = property(_traderapi.CTORATstpOrderField_RtnFloatInfo_get, _traderapi.CTORATstpOrderField_RtnFloatInfo_set)
+
+ # 锟截憋拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ RtnIntInfo = property(_traderapi.CTORATstpOrderField_RtnIntInfo_get, _traderapi.CTORATstpOrderField_RtnIntInfo_set)
+
+ # 锟截憋拷锟斤拷锟接革拷锟斤拷锟斤拷锟斤拷锟斤拷1
+ RtnFloatInfo1 = property(_traderapi.CTORATstpOrderField_RtnFloatInfo1_get, _traderapi.CTORATstpOrderField_RtnFloatInfo1_set)
+
+ # 锟截憋拷锟斤拷锟接革拷锟斤拷锟斤拷锟斤拷锟斤拷2
+ RtnFloatInfo2 = property(_traderapi.CTORATstpOrderField_RtnFloatInfo2_get, _traderapi.CTORATstpOrderField_RtnFloatInfo2_set)
+
+ # 锟截憋拷锟斤拷锟接革拷锟斤拷锟斤拷锟斤拷锟斤拷3
+ RtnFloatInfo3 = property(_traderapi.CTORATstpOrderField_RtnFloatInfo3_get, _traderapi.CTORATstpOrderField_RtnFloatInfo3_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpOrderField_swiginit(self, _traderapi.new_CTORATstpOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpOrderField
+
+# Register CTORATstpOrderField in _traderapi:
+_traderapi.CTORATstpOrderField_swigregister(CTORATstpOrderField)
+
+
+
+
+#########################################锟矫伙拷锟斤拷识############################################
+class CTORATstpUserRefField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpUserRefField_UserID_get, _traderapi.CTORATstpUserRefField_UserID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpUserRefField_swiginit(self, _traderapi.new_CTORATstpUserRefField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpUserRefField
+
+# Register CTORATstpUserRefField in _traderapi:
+_traderapi.CTORATstpUserRefField_swigregister(CTORATstpUserRefField)
+
+
+
+
+#########################################锟缴斤拷############################################
+class CTORATstpTradeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpTradeField_ExchangeID_get, _traderapi.CTORATstpTradeField_ExchangeID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpTradeField_DepartmentID_get, _traderapi.CTORATstpTradeField_DepartmentID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpTradeField_InvestorID_get, _traderapi.CTORATstpTradeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpTradeField_BusinessUnitID_get, _traderapi.CTORATstpTradeField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpTradeField_ShareholderID_get, _traderapi.CTORATstpTradeField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpTradeField_SecurityID_get, _traderapi.CTORATstpTradeField_SecurityID_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpTradeField_TradeID_get, _traderapi.CTORATstpTradeField_TradeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpTradeField_Direction_get, _traderapi.CTORATstpTradeField_Direction_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpTradeField_OrderSysID_get, _traderapi.CTORATstpTradeField_OrderSysID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpTradeField_OrderLocalID_get, _traderapi.CTORATstpTradeField_OrderLocalID_set)
+
+ # 锟缴斤拷锟桔革拷
+ Price = property(_traderapi.CTORATstpTradeField_Price_get, _traderapi.CTORATstpTradeField_Price_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ Volume = property(_traderapi.CTORATstpTradeField_Volume_get, _traderapi.CTORATstpTradeField_Volume_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ TradeDate = property(_traderapi.CTORATstpTradeField_TradeDate_get, _traderapi.CTORATstpTradeField_TradeDate_set)
+
+ # 锟缴斤拷时锟斤拷
+ TradeTime = property(_traderapi.CTORATstpTradeField_TradeTime_get, _traderapi.CTORATstpTradeField_TradeTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpTradeField_TradingDay_get, _traderapi.CTORATstpTradeField_TradingDay_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpTradeField_PbuID_get, _traderapi.CTORATstpTradeField_PbuID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpTradeField_OrderRef_get, _traderapi.CTORATstpTradeField_OrderRef_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpTradeField_AccountID_get, _traderapi.CTORATstpTradeField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpTradeField_CurrencyID_get, _traderapi.CTORATstpTradeField_CurrencyID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTradeField_swiginit(self, _traderapi.new_CTORATstpTradeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTradeField
+
+# Register CTORATstpTradeField in _traderapi:
+_traderapi.CTORATstpTradeField_swigregister(CTORATstpTradeField)
+
+
+
+
+#########################################锟斤拷锟诫撤锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpInputOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputOrderActionField_UserRequestID_get, _traderapi.CTORATstpInputOrderActionField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputOrderActionField_ExchangeID_get, _traderapi.CTORATstpInputOrderActionField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpInputOrderActionField_FrontID_get, _traderapi.CTORATstpInputOrderActionField_FrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpInputOrderActionField_SessionID_get, _traderapi.CTORATstpInputOrderActionField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpInputOrderActionField_OrderRef_get, _traderapi.CTORATstpInputOrderActionField_OrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷系统锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputOrderActionField_OrderSysID_get, _traderapi.CTORATstpInputOrderActionField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpInputOrderActionField_ActionFlag_get, _traderapi.CTORATstpInputOrderActionField_ActionFlag_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderActionRef = property(_traderapi.CTORATstpInputOrderActionField_OrderActionRef_get, _traderapi.CTORATstpInputOrderActionField_OrderActionRef_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ CancelOrderSysID = property(_traderapi.CTORATstpInputOrderActionField_CancelOrderSysID_get, _traderapi.CTORATstpInputOrderActionField_CancelOrderSysID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputOrderActionField_Operway_get, _traderapi.CTORATstpInputOrderActionField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputOrderActionField_SInfo_get, _traderapi.CTORATstpInputOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputOrderActionField_IInfo_get, _traderapi.CTORATstpInputOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputOrderActionField_swiginit(self, _traderapi.new_CTORATstpInputOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputOrderActionField
+
+# Register CTORATstpInputOrderActionField in _traderapi:
+_traderapi.CTORATstpInputOrderActionField_swigregister(CTORATstpInputOrderActionField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷############################################
+class CTORATstpInputCondOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputCondOrderField_UserRequestID_get, _traderapi.CTORATstpInputCondOrderField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputCondOrderField_ExchangeID_get, _traderapi.CTORATstpInputCondOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputCondOrderField_InvestorID_get, _traderapi.CTORATstpInputCondOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInputCondOrderField_BusinessUnitID_get, _traderapi.CTORATstpInputCondOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInputCondOrderField_ShareholderID_get, _traderapi.CTORATstpInputCondOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputCondOrderField_SecurityID_get, _traderapi.CTORATstpInputCondOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpInputCondOrderField_Direction_get, _traderapi.CTORATstpInputCondOrderField_Direction_set)
+
+ # 锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpInputCondOrderField_OrderPriceType_get, _traderapi.CTORATstpInputCondOrderField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpInputCondOrderField_TimeCondition_get, _traderapi.CTORATstpInputCondOrderField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpInputCondOrderField_VolumeCondition_get, _traderapi.CTORATstpInputCondOrderField_VolumeCondition_set)
+
+ # 锟斤拷锟斤拷锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpInputCondOrderField_LimitPrice_get, _traderapi.CTORATstpInputCondOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpInputCondOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpInputCondOrderField_VolumeTotalOriginal_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputCondOrderField_Operway_get, _traderapi.CTORATstpInputCondOrderField_Operway_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpInputCondOrderField_LotType_get, _traderapi.CTORATstpInputCondOrderField_LotType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondCheck = property(_traderapi.CTORATstpInputCondOrderField_CondCheck_get, _traderapi.CTORATstpInputCondOrderField_CondCheck_set)
+
+ # 锟斤拷效锟斤拷锟斤拷
+ GTDate = property(_traderapi.CTORATstpInputCondOrderField_GTDate_get, _traderapi.CTORATstpInputCondOrderField_GTDate_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpInputCondOrderField_ForceCloseReason_get, _traderapi.CTORATstpInputCondOrderField_ForceCloseReason_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpInputCondOrderField_CreditDebtID_get, _traderapi.CTORATstpInputCondOrderField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaType = property(_traderapi.CTORATstpInputCondOrderField_CreditQuotaType_get, _traderapi.CTORATstpInputCondOrderField_CreditQuotaType_set)
+
+ # 锟斤拷息锟桔匡拷券锟斤拷牛锟�0锟斤拷示锟斤拷使锟斤拷锟桔匡拷券锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ DiscountCouponID = property(_traderapi.CTORATstpInputCondOrderField_DiscountCouponID_get, _traderapi.CTORATstpInputCondOrderField_DiscountCouponID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderRef = property(_traderapi.CTORATstpInputCondOrderField_CondOrderRef_get, _traderapi.CTORATstpInputCondOrderField_CondOrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpInputCondOrderField_CondOrderID_get, _traderapi.CTORATstpInputCondOrderField_CondOrderID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputCondOrderField_SInfo_get, _traderapi.CTORATstpInputCondOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputCondOrderField_IInfo_get, _traderapi.CTORATstpInputCondOrderField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟斤拷准锟斤拷锟斤拷锟斤拷锟斤拷
+ TriggerOrderVolumeType = property(_traderapi.CTORATstpInputCondOrderField_TriggerOrderVolumeType_get, _traderapi.CTORATstpInputCondOrderField_TriggerOrderVolumeType_set)
+
+ # 锟斤拷锟斤拷锟斤拷准锟斤拷锟斤拷锟斤拷
+ TriggerOrderPriceType = property(_traderapi.CTORATstpInputCondOrderField_TriggerOrderPriceType_get, _traderapi.CTORATstpInputCondOrderField_TriggerOrderPriceType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ContingentCondition = property(_traderapi.CTORATstpInputCondOrderField_ContingentCondition_get, _traderapi.CTORATstpInputCondOrderField_ContingentCondition_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ ConditionPrice = property(_traderapi.CTORATstpInputCondOrderField_ConditionPrice_get, _traderapi.CTORATstpInputCondOrderField_ConditionPrice_set)
+
+ # 锟桔格浮讹拷tick锟斤拷
+ PriceTicks = property(_traderapi.CTORATstpInputCondOrderField_PriceTicks_get, _traderapi.CTORATstpInputCondOrderField_PriceTicks_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ VolumeMultiple = property(_traderapi.CTORATstpInputCondOrderField_VolumeMultiple_get, _traderapi.CTORATstpInputCondOrderField_VolumeMultiple_set)
+
+ # 锟斤拷锟角帮拷帽锟斤拷
+ RelativeFrontID = property(_traderapi.CTORATstpInputCondOrderField_RelativeFrontID_get, _traderapi.CTORATstpInputCondOrderField_RelativeFrontID_set)
+
+ # 锟斤拷鼗峄帮拷锟斤拷
+ RelativeSessionID = property(_traderapi.CTORATstpInputCondOrderField_RelativeSessionID_get, _traderapi.CTORATstpInputCondOrderField_RelativeSessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ RelativeParam = property(_traderapi.CTORATstpInputCondOrderField_RelativeParam_get, _traderapi.CTORATstpInputCondOrderField_RelativeParam_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ AppendContingentCondition = property(_traderapi.CTORATstpInputCondOrderField_AppendContingentCondition_get, _traderapi.CTORATstpInputCondOrderField_AppendContingentCondition_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ AppendConditionPrice = property(_traderapi.CTORATstpInputCondOrderField_AppendConditionPrice_get, _traderapi.CTORATstpInputCondOrderField_AppendConditionPrice_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟角帮拷帽锟斤拷
+ AppendRelativeFrontID = property(_traderapi.CTORATstpInputCondOrderField_AppendRelativeFrontID_get, _traderapi.CTORATstpInputCondOrderField_AppendRelativeFrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷鼗峄帮拷锟斤拷
+ AppendRelativeSessionID = property(_traderapi.CTORATstpInputCondOrderField_AppendRelativeSessionID_get, _traderapi.CTORATstpInputCondOrderField_AppendRelativeSessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ AppendRelativeParam = property(_traderapi.CTORATstpInputCondOrderField_AppendRelativeParam_get, _traderapi.CTORATstpInputCondOrderField_AppendRelativeParam_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputCondOrderField_swiginit(self, _traderapi.new_CTORATstpInputCondOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputCondOrderField
+
+# Register CTORATstpInputCondOrderField in _traderapi:
+_traderapi.CTORATstpInputCondOrderField_swigregister(CTORATstpInputCondOrderField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpConditionOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpConditionOrderField_ExchangeID_get, _traderapi.CTORATstpConditionOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpConditionOrderField_InvestorID_get, _traderapi.CTORATstpConditionOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpConditionOrderField_BusinessUnitID_get, _traderapi.CTORATstpConditionOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpConditionOrderField_ShareholderID_get, _traderapi.CTORATstpConditionOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpConditionOrderField_SecurityID_get, _traderapi.CTORATstpConditionOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpConditionOrderField_Direction_get, _traderapi.CTORATstpConditionOrderField_Direction_set)
+
+ # 锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpConditionOrderField_OrderPriceType_get, _traderapi.CTORATstpConditionOrderField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpConditionOrderField_TimeCondition_get, _traderapi.CTORATstpConditionOrderField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpConditionOrderField_VolumeCondition_get, _traderapi.CTORATstpConditionOrderField_VolumeCondition_set)
+
+ # 锟斤拷锟斤拷锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpConditionOrderField_LimitPrice_get, _traderapi.CTORATstpConditionOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpConditionOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpConditionOrderField_VolumeTotalOriginal_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpConditionOrderField_Operway_get, _traderapi.CTORATstpConditionOrderField_Operway_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpConditionOrderField_LotType_get, _traderapi.CTORATstpConditionOrderField_LotType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondCheck = property(_traderapi.CTORATstpConditionOrderField_CondCheck_get, _traderapi.CTORATstpConditionOrderField_CondCheck_set)
+
+ # 锟斤拷效锟斤拷锟斤拷
+ GTDate = property(_traderapi.CTORATstpConditionOrderField_GTDate_get, _traderapi.CTORATstpConditionOrderField_GTDate_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpConditionOrderField_ForceCloseReason_get, _traderapi.CTORATstpConditionOrderField_ForceCloseReason_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpConditionOrderField_CreditDebtID_get, _traderapi.CTORATstpConditionOrderField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaType = property(_traderapi.CTORATstpConditionOrderField_CreditQuotaType_get, _traderapi.CTORATstpConditionOrderField_CreditQuotaType_set)
+
+ # 锟斤拷息锟桔匡拷券锟斤拷牛锟�0锟斤拷示锟斤拷使锟斤拷锟桔匡拷券锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ DiscountCouponID = property(_traderapi.CTORATstpConditionOrderField_DiscountCouponID_get, _traderapi.CTORATstpConditionOrderField_DiscountCouponID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderRef = property(_traderapi.CTORATstpConditionOrderField_CondOrderRef_get, _traderapi.CTORATstpConditionOrderField_CondOrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpConditionOrderField_CondOrderID_get, _traderapi.CTORATstpConditionOrderField_CondOrderID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpConditionOrderField_SInfo_get, _traderapi.CTORATstpConditionOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpConditionOrderField_IInfo_get, _traderapi.CTORATstpConditionOrderField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟斤拷准锟斤拷锟斤拷锟斤拷锟斤拷
+ TriggerOrderVolumeType = property(_traderapi.CTORATstpConditionOrderField_TriggerOrderVolumeType_get, _traderapi.CTORATstpConditionOrderField_TriggerOrderVolumeType_set)
+
+ # 锟斤拷锟斤拷锟斤拷准锟斤拷锟斤拷锟斤拷
+ TriggerOrderPriceType = property(_traderapi.CTORATstpConditionOrderField_TriggerOrderPriceType_get, _traderapi.CTORATstpConditionOrderField_TriggerOrderPriceType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ContingentCondition = property(_traderapi.CTORATstpConditionOrderField_ContingentCondition_get, _traderapi.CTORATstpConditionOrderField_ContingentCondition_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ ConditionPrice = property(_traderapi.CTORATstpConditionOrderField_ConditionPrice_get, _traderapi.CTORATstpConditionOrderField_ConditionPrice_set)
+
+ # 锟桔格浮讹拷tick锟斤拷
+ PriceTicks = property(_traderapi.CTORATstpConditionOrderField_PriceTicks_get, _traderapi.CTORATstpConditionOrderField_PriceTicks_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ VolumeMultiple = property(_traderapi.CTORATstpConditionOrderField_VolumeMultiple_get, _traderapi.CTORATstpConditionOrderField_VolumeMultiple_set)
+
+ # 锟斤拷锟角帮拷帽锟斤拷
+ RelativeFrontID = property(_traderapi.CTORATstpConditionOrderField_RelativeFrontID_get, _traderapi.CTORATstpConditionOrderField_RelativeFrontID_set)
+
+ # 锟斤拷鼗峄帮拷锟斤拷
+ RelativeSessionID = property(_traderapi.CTORATstpConditionOrderField_RelativeSessionID_get, _traderapi.CTORATstpConditionOrderField_RelativeSessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ RelativeParam = property(_traderapi.CTORATstpConditionOrderField_RelativeParam_get, _traderapi.CTORATstpConditionOrderField_RelativeParam_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ AppendContingentCondition = property(_traderapi.CTORATstpConditionOrderField_AppendContingentCondition_get, _traderapi.CTORATstpConditionOrderField_AppendContingentCondition_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ AppendConditionPrice = property(_traderapi.CTORATstpConditionOrderField_AppendConditionPrice_get, _traderapi.CTORATstpConditionOrderField_AppendConditionPrice_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟角帮拷帽锟斤拷
+ AppendRelativeFrontID = property(_traderapi.CTORATstpConditionOrderField_AppendRelativeFrontID_get, _traderapi.CTORATstpConditionOrderField_AppendRelativeFrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷鼗峄帮拷锟斤拷
+ AppendRelativeSessionID = property(_traderapi.CTORATstpConditionOrderField_AppendRelativeSessionID_get, _traderapi.CTORATstpConditionOrderField_AppendRelativeSessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ AppendRelativeParam = property(_traderapi.CTORATstpConditionOrderField_AppendRelativeParam_get, _traderapi.CTORATstpConditionOrderField_AppendRelativeParam_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpConditionOrderField_RequestID_get, _traderapi.CTORATstpConditionOrderField_RequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpConditionOrderField_TradingDay_get, _traderapi.CTORATstpConditionOrderField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷状态
+ CondOrderStatus = property(_traderapi.CTORATstpConditionOrderField_CondOrderStatus_get, _traderapi.CTORATstpConditionOrderField_CondOrderStatus_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpConditionOrderField_StatusMsg_get, _traderapi.CTORATstpConditionOrderField_StatusMsg_set)
+
+ # 锟疥报锟矫伙拷
+ InsertUser = property(_traderapi.CTORATstpConditionOrderField_InsertUser_get, _traderapi.CTORATstpConditionOrderField_InsertUser_set)
+
+ # 锟疥报锟斤拷锟斤拷
+ InsertDate = property(_traderapi.CTORATstpConditionOrderField_InsertDate_get, _traderapi.CTORATstpConditionOrderField_InsertDate_set)
+
+ # 锟疥报时锟斤拷
+ InsertTime = property(_traderapi.CTORATstpConditionOrderField_InsertTime_get, _traderapi.CTORATstpConditionOrderField_InsertTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ActiveDate = property(_traderapi.CTORATstpConditionOrderField_ActiveDate_get, _traderapi.CTORATstpConditionOrderField_ActiveDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ ActiveTime = property(_traderapi.CTORATstpConditionOrderField_ActiveTime_get, _traderapi.CTORATstpConditionOrderField_ActiveTime_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ CancelUser = property(_traderapi.CTORATstpConditionOrderField_CancelUser_get, _traderapi.CTORATstpConditionOrderField_CancelUser_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ CancelTime = property(_traderapi.CTORATstpConditionOrderField_CancelTime_get, _traderapi.CTORATstpConditionOrderField_CancelTime_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpConditionOrderField_FrontID_get, _traderapi.CTORATstpConditionOrderField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpConditionOrderField_SessionID_get, _traderapi.CTORATstpConditionOrderField_SessionID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpConditionOrderField_DepartmentID_get, _traderapi.CTORATstpConditionOrderField_DepartmentID_set)
+
+ # 锟矫伙拷锟剿诧拷品锟斤拷息
+ UserProductInfo = property(_traderapi.CTORATstpConditionOrderField_UserProductInfo_get, _traderapi.CTORATstpConditionOrderField_UserProductInfo_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpConditionOrderField_IPAddress_get, _traderapi.CTORATstpConditionOrderField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpConditionOrderField_MacAddress_get, _traderapi.CTORATstpConditionOrderField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpConditionOrderField_swiginit(self, _traderapi.new_CTORATstpConditionOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpConditionOrderField
+
+# Register CTORATstpConditionOrderField in _traderapi:
+_traderapi.CTORATstpConditionOrderField_swigregister(CTORATstpConditionOrderField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷录锟斤拷############################################
+class CTORATstpInputCondOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputCondOrderActionField_UserRequestID_get, _traderapi.CTORATstpInputCondOrderActionField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputCondOrderActionField_ExchangeID_get, _traderapi.CTORATstpInputCondOrderActionField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpInputCondOrderActionField_FrontID_get, _traderapi.CTORATstpInputCondOrderActionField_FrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpInputCondOrderActionField_SessionID_get, _traderapi.CTORATstpInputCondOrderActionField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderRef = property(_traderapi.CTORATstpInputCondOrderActionField_CondOrderRef_get, _traderapi.CTORATstpInputCondOrderActionField_CondOrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpInputCondOrderActionField_CondOrderID_get, _traderapi.CTORATstpInputCondOrderActionField_CondOrderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpInputCondOrderActionField_ActionFlag_get, _traderapi.CTORATstpInputCondOrderActionField_ActionFlag_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputCondOrderActionField_Operway_get, _traderapi.CTORATstpInputCondOrderActionField_Operway_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderActionRef = property(_traderapi.CTORATstpInputCondOrderActionField_CondOrderActionRef_get, _traderapi.CTORATstpInputCondOrderActionField_CondOrderActionRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CancelCondOrderID = property(_traderapi.CTORATstpInputCondOrderActionField_CancelCondOrderID_get, _traderapi.CTORATstpInputCondOrderActionField_CancelCondOrderID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputCondOrderActionField_SInfo_get, _traderapi.CTORATstpInputCondOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputCondOrderActionField_IInfo_get, _traderapi.CTORATstpInputCondOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputCondOrderActionField_swiginit(self, _traderapi.new_CTORATstpInputCondOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputCondOrderActionField
+
+# Register CTORATstpInputCondOrderActionField in _traderapi:
+_traderapi.CTORATstpInputCondOrderActionField_swigregister(CTORATstpInputCondOrderActionField)
+
+
+
+
+#########################################锟斤拷锟诫报锟斤拷############################################
+class CTORATstpInputNegoOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputNegoOrderField_UserRequestID_get, _traderapi.CTORATstpInputNegoOrderField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputNegoOrderField_ExchangeID_get, _traderapi.CTORATstpInputNegoOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputNegoOrderField_InvestorID_get, _traderapi.CTORATstpInputNegoOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInputNegoOrderField_BusinessUnitID_get, _traderapi.CTORATstpInputNegoOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInputNegoOrderField_ShareholderID_get, _traderapi.CTORATstpInputNegoOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputNegoOrderField_SecurityID_get, _traderapi.CTORATstpInputNegoOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpInputNegoOrderField_Direction_get, _traderapi.CTORATstpInputNegoOrderField_Direction_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpInputNegoOrderField_LimitPrice_get, _traderapi.CTORATstpInputNegoOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpInputNegoOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpInputNegoOrderField_VolumeTotalOriginal_set)
+
+ # 锟斤拷系锟斤拷(锟斤拷锟斤拷锟疥报时锟斤拷锟斤拷)
+ Contractor = property(_traderapi.CTORATstpInputNegoOrderField_Contractor_get, _traderapi.CTORATstpInputNegoOrderField_Contractor_set)
+
+ # 锟斤拷系锟斤拷式(锟斤拷锟斤拷锟疥报时锟斤拷锟斤拷)
+ ContractorInfo = property(_traderapi.CTORATstpInputNegoOrderField_ContractorInfo_get, _traderapi.CTORATstpInputNegoOrderField_ContractorInfo_set)
+
+ # 约锟斤拷锟斤拷(锟缴斤拷锟疥报时锟斤拷锟斤拷)
+ ConfirmID = property(_traderapi.CTORATstpInputNegoOrderField_ConfirmID_get, _traderapi.CTORATstpInputNegoOrderField_ConfirmID_set)
+
+ # 锟斤拷锟街凤拷席位锟斤拷(锟缴斤拷锟疥报时锟斤拷锟斤拷)
+ CounterpartyPbuID = property(_traderapi.CTORATstpInputNegoOrderField_CounterpartyPbuID_get, _traderapi.CTORATstpInputNegoOrderField_CounterpartyPbuID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputNegoOrderField_OrderSysID_get, _traderapi.CTORATstpInputNegoOrderField_OrderSysID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputNegoOrderField_Operway_get, _traderapi.CTORATstpInputNegoOrderField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputNegoOrderField_SInfo_get, _traderapi.CTORATstpInputNegoOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputNegoOrderField_IInfo_get, _traderapi.CTORATstpInputNegoOrderField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputNegoOrderField_swiginit(self, _traderapi.new_CTORATstpInputNegoOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputNegoOrderField
+
+# Register CTORATstpInputNegoOrderField in _traderapi:
+_traderapi.CTORATstpInputNegoOrderField_swigregister(CTORATstpInputNegoOrderField)
+
+
+
+
+#########################################协锟介交锟阶憋拷锟斤拷############################################
+class CTORATstpNegoOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpNegoOrderField_ExchangeID_get, _traderapi.CTORATstpNegoOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpNegoOrderField_InvestorID_get, _traderapi.CTORATstpNegoOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpNegoOrderField_BusinessUnitID_get, _traderapi.CTORATstpNegoOrderField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpNegoOrderField_ShareholderID_get, _traderapi.CTORATstpNegoOrderField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpNegoOrderField_SecurityID_get, _traderapi.CTORATstpNegoOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpNegoOrderField_Direction_get, _traderapi.CTORATstpNegoOrderField_Direction_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpNegoOrderField_LimitPrice_get, _traderapi.CTORATstpNegoOrderField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpNegoOrderField_VolumeTotalOriginal_get, _traderapi.CTORATstpNegoOrderField_VolumeTotalOriginal_set)
+
+ # 锟斤拷系锟斤拷
+ Contractor = property(_traderapi.CTORATstpNegoOrderField_Contractor_get, _traderapi.CTORATstpNegoOrderField_Contractor_set)
+
+ # 锟斤拷系锟斤拷式
+ ContractorInfo = property(_traderapi.CTORATstpNegoOrderField_ContractorInfo_get, _traderapi.CTORATstpNegoOrderField_ContractorInfo_set)
+
+ # 约锟斤拷锟斤拷
+ ConfirmID = property(_traderapi.CTORATstpNegoOrderField_ConfirmID_get, _traderapi.CTORATstpNegoOrderField_ConfirmID_set)
+
+ # 锟斤拷锟街凤拷席位锟斤拷
+ CounterpartyPbuID = property(_traderapi.CTORATstpNegoOrderField_CounterpartyPbuID_get, _traderapi.CTORATstpNegoOrderField_CounterpartyPbuID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpNegoOrderField_Operway_get, _traderapi.CTORATstpNegoOrderField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpNegoOrderField_SInfo_get, _traderapi.CTORATstpNegoOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpNegoOrderField_IInfo_get, _traderapi.CTORATstpNegoOrderField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpNegoOrderField_RequestID_get, _traderapi.CTORATstpNegoOrderField_RequestID_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpNegoOrderField_FrontID_get, _traderapi.CTORATstpNegoOrderField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpNegoOrderField_SessionID_get, _traderapi.CTORATstpNegoOrderField_SessionID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpNegoOrderField_OrderLocalID_get, _traderapi.CTORATstpNegoOrderField_OrderLocalID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpNegoOrderField_OrderSysID_get, _traderapi.CTORATstpNegoOrderField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷状态
+ OrderStatus = property(_traderapi.CTORATstpNegoOrderField_OrderStatus_get, _traderapi.CTORATstpNegoOrderField_OrderStatus_set)
+
+ # 锟斤拷锟斤拷锟结交状态
+ OrderSubmitStatus = property(_traderapi.CTORATstpNegoOrderField_OrderSubmitStatus_get, _traderapi.CTORATstpNegoOrderField_OrderSubmitStatus_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpNegoOrderField_StatusMsg_get, _traderapi.CTORATstpNegoOrderField_StatusMsg_set)
+
+ # 锟窖成斤拷锟斤拷锟斤拷
+ VolumeTraded = property(_traderapi.CTORATstpNegoOrderField_VolumeTraded_get, _traderapi.CTORATstpNegoOrderField_VolumeTraded_set)
+
+ # 锟窖筹拷锟斤拷锟斤拷锟斤拷
+ VolumeCanceled = property(_traderapi.CTORATstpNegoOrderField_VolumeCanceled_get, _traderapi.CTORATstpNegoOrderField_VolumeCanceled_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpNegoOrderField_TradingDay_get, _traderapi.CTORATstpNegoOrderField_TradingDay_set)
+
+ # 锟疥报锟矫伙拷
+ InsertUser = property(_traderapi.CTORATstpNegoOrderField_InsertUser_get, _traderapi.CTORATstpNegoOrderField_InsertUser_set)
+
+ # 锟疥报锟斤拷锟斤拷
+ InsertDate = property(_traderapi.CTORATstpNegoOrderField_InsertDate_get, _traderapi.CTORATstpNegoOrderField_InsertDate_set)
+
+ # 锟疥报时锟斤拷
+ InsertTime = property(_traderapi.CTORATstpNegoOrderField_InsertTime_get, _traderapi.CTORATstpNegoOrderField_InsertTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷
+ AcceptTime = property(_traderapi.CTORATstpNegoOrderField_AcceptTime_get, _traderapi.CTORATstpNegoOrderField_AcceptTime_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ CancelUser = property(_traderapi.CTORATstpNegoOrderField_CancelUser_get, _traderapi.CTORATstpNegoOrderField_CancelUser_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ CancelTime = property(_traderapi.CTORATstpNegoOrderField_CancelTime_get, _traderapi.CTORATstpNegoOrderField_CancelTime_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpNegoOrderField_DepartmentID_get, _traderapi.CTORATstpNegoOrderField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpNegoOrderField_AccountID_get, _traderapi.CTORATstpNegoOrderField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpNegoOrderField_CurrencyID_get, _traderapi.CTORATstpNegoOrderField_CurrencyID_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpNegoOrderField_PbuID_get, _traderapi.CTORATstpNegoOrderField_PbuID_set)
+
+ # 锟矫伙拷锟剿诧拷品锟斤拷息
+ UserProductInfo = property(_traderapi.CTORATstpNegoOrderField_UserProductInfo_get, _traderapi.CTORATstpNegoOrderField_UserProductInfo_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpNegoOrderField_IPAddress_get, _traderapi.CTORATstpNegoOrderField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpNegoOrderField_MacAddress_get, _traderapi.CTORATstpNegoOrderField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpNegoOrderField_swiginit(self, _traderapi.new_CTORATstpNegoOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpNegoOrderField
+
+# Register CTORATstpNegoOrderField in _traderapi:
+_traderapi.CTORATstpNegoOrderField_swigregister(CTORATstpNegoOrderField)
+
+
+
+
+#########################################协锟介交锟阶成斤拷############################################
+class CTORATstpNegoTradeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpNegoTradeField_ExchangeID_get, _traderapi.CTORATstpNegoTradeField_ExchangeID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpNegoTradeField_DepartmentID_get, _traderapi.CTORATstpNegoTradeField_DepartmentID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpNegoTradeField_InvestorID_get, _traderapi.CTORATstpNegoTradeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpNegoTradeField_BusinessUnitID_get, _traderapi.CTORATstpNegoTradeField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpNegoTradeField_ShareholderID_get, _traderapi.CTORATstpNegoTradeField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpNegoTradeField_SecurityID_get, _traderapi.CTORATstpNegoTradeField_SecurityID_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpNegoTradeField_TradeID_get, _traderapi.CTORATstpNegoTradeField_TradeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpNegoTradeField_Direction_get, _traderapi.CTORATstpNegoTradeField_Direction_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpNegoTradeField_OrderSysID_get, _traderapi.CTORATstpNegoTradeField_OrderSysID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpNegoTradeField_OrderLocalID_get, _traderapi.CTORATstpNegoTradeField_OrderLocalID_set)
+
+ # 锟缴斤拷锟桔革拷
+ Price = property(_traderapi.CTORATstpNegoTradeField_Price_get, _traderapi.CTORATstpNegoTradeField_Price_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ Volume = property(_traderapi.CTORATstpNegoTradeField_Volume_get, _traderapi.CTORATstpNegoTradeField_Volume_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ TradeDate = property(_traderapi.CTORATstpNegoTradeField_TradeDate_get, _traderapi.CTORATstpNegoTradeField_TradeDate_set)
+
+ # 锟缴斤拷时锟斤拷
+ TradeTime = property(_traderapi.CTORATstpNegoTradeField_TradeTime_get, _traderapi.CTORATstpNegoTradeField_TradeTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpNegoTradeField_TradingDay_get, _traderapi.CTORATstpNegoTradeField_TradingDay_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpNegoTradeField_PbuID_get, _traderapi.CTORATstpNegoTradeField_PbuID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpNegoTradeField_AccountID_get, _traderapi.CTORATstpNegoTradeField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpNegoTradeField_CurrencyID_get, _traderapi.CTORATstpNegoTradeField_CurrencyID_set)
+
+ # 锟斤拷锟街凤拷锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ CounterpartyPbuID = property(_traderapi.CTORATstpNegoTradeField_CounterpartyPbuID_get, _traderapi.CTORATstpNegoTradeField_CounterpartyPbuID_set)
+
+ # 锟斤拷锟街凤拷锟缴讹拷锟剿猴拷
+ CounterpartyShareholderID = property(_traderapi.CTORATstpNegoTradeField_CounterpartyShareholderID_get, _traderapi.CTORATstpNegoTradeField_CounterpartyShareholderID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpNegoTradeField_swiginit(self, _traderapi.new_CTORATstpNegoTradeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpNegoTradeField
+
+# Register CTORATstpNegoTradeField in _traderapi:
+_traderapi.CTORATstpNegoTradeField_swigregister(CTORATstpNegoTradeField)
+
+
+
+
+#########################################锟斤拷锟斤拷协锟介交锟阶筹拷锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpInputNegoOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputNegoOrderActionField_UserRequestID_get, _traderapi.CTORATstpInputNegoOrderActionField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputNegoOrderActionField_ExchangeID_get, _traderapi.CTORATstpInputNegoOrderActionField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷系统锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputNegoOrderActionField_OrderSysID_get, _traderapi.CTORATstpInputNegoOrderActionField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpInputNegoOrderActionField_ActionFlag_get, _traderapi.CTORATstpInputNegoOrderActionField_ActionFlag_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ CancelOrderSysID = property(_traderapi.CTORATstpInputNegoOrderActionField_CancelOrderSysID_get, _traderapi.CTORATstpInputNegoOrderActionField_CancelOrderSysID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputNegoOrderActionField_Operway_get, _traderapi.CTORATstpInputNegoOrderActionField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputNegoOrderActionField_SInfo_get, _traderapi.CTORATstpInputNegoOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputNegoOrderActionField_IInfo_get, _traderapi.CTORATstpInputNegoOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputNegoOrderActionField_swiginit(self, _traderapi.new_CTORATstpInputNegoOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputNegoOrderActionField
+
+# Register CTORATstpInputNegoOrderActionField in _traderapi:
+_traderapi.CTORATstpInputNegoOrderActionField_swigregister(CTORATstpInputNegoOrderActionField)
+
+
+
+
+#########################################锟斤拷锟诫报锟斤拷############################################
+class CTORATstpInputOrderExField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputOrderExField_UserRequestID_get, _traderapi.CTORATstpInputOrderExField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputOrderExField_ExchangeID_get, _traderapi.CTORATstpInputOrderExField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputOrderExField_InvestorID_get, _traderapi.CTORATstpInputOrderExField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInputOrderExField_BusinessUnitID_get, _traderapi.CTORATstpInputOrderExField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInputOrderExField_ShareholderID_get, _traderapi.CTORATstpInputOrderExField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputOrderExField_SecurityID_get, _traderapi.CTORATstpInputOrderExField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpInputOrderExField_Direction_get, _traderapi.CTORATstpInputOrderExField_Direction_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpInputOrderExField_LimitPrice_get, _traderapi.CTORATstpInputOrderExField_LimitPrice_set)
+
+ # 锟斤拷锟斤拷
+ VolumeTotalOriginal = property(_traderapi.CTORATstpInputOrderExField_VolumeTotalOriginal_get, _traderapi.CTORATstpInputOrderExField_VolumeTotalOriginal_set)
+
+ # 锟斤拷锟斤拷锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpInputOrderExField_OrderPriceType_get, _traderapi.CTORATstpInputOrderExField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpInputOrderExField_TimeCondition_get, _traderapi.CTORATstpInputOrderExField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpInputOrderExField_VolumeCondition_get, _traderapi.CTORATstpInputOrderExField_VolumeCondition_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputOrderExField_Operway_get, _traderapi.CTORATstpInputOrderExField_Operway_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpInputOrderExField_OrderRef_get, _traderapi.CTORATstpInputOrderExField_OrderRef_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpInputOrderExField_LotType_get, _traderapi.CTORATstpInputOrderExField_LotType_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputOrderExField_OrderSysID_get, _traderapi.CTORATstpInputOrderExField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondCheck = property(_traderapi.CTORATstpInputOrderExField_CondCheck_get, _traderapi.CTORATstpInputOrderExField_CondCheck_set)
+
+ # 锟斤拷效锟斤拷锟斤拷
+ GTDate = property(_traderapi.CTORATstpInputOrderExField_GTDate_get, _traderapi.CTORATstpInputOrderExField_GTDate_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpInputOrderExField_ForceCloseReason_get, _traderapi.CTORATstpInputOrderExField_ForceCloseReason_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpInputOrderExField_CreditDebtID_get, _traderapi.CTORATstpInputOrderExField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditQuotaType = property(_traderapi.CTORATstpInputOrderExField_CreditQuotaType_get, _traderapi.CTORATstpInputOrderExField_CreditQuotaType_set)
+
+ # 锟斤拷息锟桔匡拷券锟斤拷牛锟�0锟斤拷示锟斤拷使锟斤拷锟桔匡拷券锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ DiscountCouponID = property(_traderapi.CTORATstpInputOrderExField_DiscountCouponID_get, _traderapi.CTORATstpInputOrderExField_DiscountCouponID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputOrderExField_SInfo_get, _traderapi.CTORATstpInputOrderExField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputOrderExField_IInfo_get, _traderapi.CTORATstpInputOrderExField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟节碉拷锟斤拷
+ NodeRef = property(_traderapi.CTORATstpInputOrderExField_NodeRef_get, _traderapi.CTORATstpInputOrderExField_NodeRef_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputOrderExField_swiginit(self, _traderapi.new_CTORATstpInputOrderExField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputOrderExField
+
+# Register CTORATstpInputOrderExField in _traderapi:
+_traderapi.CTORATstpInputOrderExField_swigregister(CTORATstpInputOrderExField)
+
+
+
+
+#########################################锟斤拷锟诫撤锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpInputOrderActionExField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputOrderActionExField_UserRequestID_get, _traderapi.CTORATstpInputOrderActionExField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputOrderActionExField_ExchangeID_get, _traderapi.CTORATstpInputOrderActionExField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpInputOrderActionExField_FrontID_get, _traderapi.CTORATstpInputOrderActionExField_FrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpInputOrderActionExField_SessionID_get, _traderapi.CTORATstpInputOrderActionExField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpInputOrderActionExField_OrderRef_get, _traderapi.CTORATstpInputOrderActionExField_OrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷系统锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpInputOrderActionExField_OrderSysID_get, _traderapi.CTORATstpInputOrderActionExField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpInputOrderActionExField_ActionFlag_get, _traderapi.CTORATstpInputOrderActionExField_ActionFlag_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderActionRef = property(_traderapi.CTORATstpInputOrderActionExField_OrderActionRef_get, _traderapi.CTORATstpInputOrderActionExField_OrderActionRef_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ CancelOrderSysID = property(_traderapi.CTORATstpInputOrderActionExField_CancelOrderSysID_get, _traderapi.CTORATstpInputOrderActionExField_CancelOrderSysID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpInputOrderActionExField_Operway_get, _traderapi.CTORATstpInputOrderActionExField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpInputOrderActionExField_SInfo_get, _traderapi.CTORATstpInputOrderActionExField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpInputOrderActionExField_IInfo_get, _traderapi.CTORATstpInputOrderActionExField_IInfo_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputOrderActionExField_SecurityID_get, _traderapi.CTORATstpInputOrderActionExField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputOrderActionExField_swiginit(self, _traderapi.new_CTORATstpInputOrderActionExField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputOrderActionExField
+
+# Register CTORATstpInputOrderActionExField in _traderapi:
+_traderapi.CTORATstpInputOrderActionExField_swigregister(CTORATstpInputOrderActionExField)
+
+
+
+
+#########################################锟叫筹拷状态############################################
+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(_traderapi.CTORATstpMarketStatusField_MarketID_get, _traderapi.CTORATstpMarketStatusField_MarketID_set)
+
+ # 锟叫筹拷状态
+ MarketStatus = property(_traderapi.CTORATstpMarketStatusField_MarketStatus_get, _traderapi.CTORATstpMarketStatusField_MarketStatus_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpMarketStatusField_swiginit(self, _traderapi.new_CTORATstpMarketStatusField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpMarketStatusField
+
+# Register CTORATstpMarketStatusField in _traderapi:
+_traderapi.CTORATstpMarketStatusField_swigregister(CTORATstpMarketStatusField)
+
+
+
+
+#########################################锟绞斤拷转锟斤拷############################################
+class CTORATstpInputTransferFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputTransferFundField_UserRequestID_get, _traderapi.CTORATstpInputTransferFundField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpInputTransferFundField_DepartmentID_get, _traderapi.CTORATstpInputTransferFundField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpInputTransferFundField_AccountID_get, _traderapi.CTORATstpInputTransferFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpInputTransferFundField_CurrencyID_get, _traderapi.CTORATstpInputTransferFundField_CurrencyID_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpInputTransferFundField_ApplySerial_get, _traderapi.CTORATstpInputTransferFundField_ApplySerial_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpInputTransferFundField_TransferDirection_get, _traderapi.CTORATstpInputTransferFundField_TransferDirection_set)
+
+ # 转锟狡斤拷锟�
+ Amount = property(_traderapi.CTORATstpInputTransferFundField_Amount_get, _traderapi.CTORATstpInputTransferFundField_Amount_set)
+
+ # 锟斤拷锟叫达拷锟斤拷(锟斤拷证转锟斤拷时锟斤拷锟斤拷)
+ BankID = property(_traderapi.CTORATstpInputTransferFundField_BankID_get, _traderapi.CTORATstpInputTransferFundField_BankID_set)
+
+ # 锟绞斤拷锟斤拷锟斤拷(证券转锟斤拷锟斤拷时锟斤拷锟斤拷)
+ AccountPassword = property(_traderapi.CTORATstpInputTransferFundField_AccountPassword_get, _traderapi.CTORATstpInputTransferFundField_AccountPassword_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷转证券时锟斤拷锟斤拷)
+ BankPassword = property(_traderapi.CTORATstpInputTransferFundField_BankPassword_get, _traderapi.CTORATstpInputTransferFundField_BankPassword_set)
+
+ # 锟解部锟节碉拷锟�(锟节碉拷锟斤拷式锟斤拷锟斤拷时锟斤拷锟斤拷)
+ ExternalNodeID = property(_traderapi.CTORATstpInputTransferFundField_ExternalNodeID_get, _traderapi.CTORATstpInputTransferFundField_ExternalNodeID_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpInputTransferFundField_CreditDebtID_get, _traderapi.CTORATstpInputTransferFundField_CreditDebtID_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpInputTransferFundField_ForceCloseReason_get, _traderapi.CTORATstpInputTransferFundField_ForceCloseReason_set)
+
+ # 实锟绞筹拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷)(锟斤拷锟斤拷专锟斤拷)
+ RealAmount = property(_traderapi.CTORATstpInputTransferFundField_RealAmount_get, _traderapi.CTORATstpInputTransferFundField_RealAmount_set)
+
+ # 强锟狡憋拷识(证券转锟斤拷锟斤拷时锟斤拷效)
+ ForceFlag = property(_traderapi.CTORATstpInputTransferFundField_ForceFlag_get, _traderapi.CTORATstpInputTransferFundField_ForceFlag_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputTransferFundField_swiginit(self, _traderapi.new_CTORATstpInputTransferFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputTransferFundField
+
+# Register CTORATstpInputTransferFundField in _traderapi:
+_traderapi.CTORATstpInputTransferFundField_swigregister(CTORATstpInputTransferFundField)
+
+
+
+
+#########################################锟绞斤拷转锟狡回憋拷############################################
+class CTORATstpTransferFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 转锟斤拷锟斤拷水锟斤拷
+ FundSerial = property(_traderapi.CTORATstpTransferFundField_FundSerial_get, _traderapi.CTORATstpTransferFundField_FundSerial_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpTransferFundField_ApplySerial_get, _traderapi.CTORATstpTransferFundField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpTransferFundField_FrontID_get, _traderapi.CTORATstpTransferFundField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpTransferFundField_SessionID_get, _traderapi.CTORATstpTransferFundField_SessionID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpTransferFundField_DepartmentID_get, _traderapi.CTORATstpTransferFundField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpTransferFundField_AccountID_get, _traderapi.CTORATstpTransferFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpTransferFundField_CurrencyID_get, _traderapi.CTORATstpTransferFundField_CurrencyID_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpTransferFundField_TransferDirection_get, _traderapi.CTORATstpTransferFundField_TransferDirection_set)
+
+ # 转锟狡斤拷锟�
+ Amount = property(_traderapi.CTORATstpTransferFundField_Amount_get, _traderapi.CTORATstpTransferFundField_Amount_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpTransferFundField_TransferStatus_get, _traderapi.CTORATstpTransferFundField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷员
+ OperatorID = property(_traderapi.CTORATstpTransferFundField_OperatorID_get, _traderapi.CTORATstpTransferFundField_OperatorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpTransferFundField_OperateDate_get, _traderapi.CTORATstpTransferFundField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpTransferFundField_OperateTime_get, _traderapi.CTORATstpTransferFundField_OperateTime_set)
+
+ # 签约锟斤拷锟斤拷锟剿伙拷
+ BankAccountID = property(_traderapi.CTORATstpTransferFundField_BankAccountID_get, _traderapi.CTORATstpTransferFundField_BankAccountID_set)
+
+ # 锟斤拷锟叫达拷锟斤拷
+ BankID = property(_traderapi.CTORATstpTransferFundField_BankID_get, _traderapi.CTORATstpTransferFundField_BankID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpTransferFundField_InvestorID_get, _traderapi.CTORATstpTransferFundField_InvestorID_set)
+
+ # 锟解部锟节碉拷锟�
+ ExternalNodeID = property(_traderapi.CTORATstpTransferFundField_ExternalNodeID_get, _traderapi.CTORATstpTransferFundField_ExternalNodeID_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpTransferFundField_ForceCloseReason_get, _traderapi.CTORATstpTransferFundField_ForceCloseReason_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpTransferFundField_IPAddress_get, _traderapi.CTORATstpTransferFundField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpTransferFundField_MacAddress_get, _traderapi.CTORATstpTransferFundField_MacAddress_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpTransferFundField_BusinessUnitID_get, _traderapi.CTORATstpTransferFundField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTransferFundField_swiginit(self, _traderapi.new_CTORATstpTransferFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTransferFundField
+
+# Register CTORATstpTransferFundField in _traderapi:
+_traderapi.CTORATstpTransferFundField_swigregister(CTORATstpTransferFundField)
+
+
+
+
+#########################################锟斤拷位转锟斤拷############################################
+class CTORATstpInputTransferPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputTransferPositionField_InvestorID_get, _traderapi.CTORATstpInputTransferPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInputTransferPositionField_BusinessUnitID_get, _traderapi.CTORATstpInputTransferPositionField_BusinessUnitID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInputTransferPositionField_ExchangeID_get, _traderapi.CTORATstpInputTransferPositionField_ExchangeID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInputTransferPositionField_ShareholderID_get, _traderapi.CTORATstpInputTransferPositionField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInputTransferPositionField_SecurityID_get, _traderapi.CTORATstpInputTransferPositionField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpInputTransferPositionField_ApplySerial_get, _traderapi.CTORATstpInputTransferPositionField_ApplySerial_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpInputTransferPositionField_TransferDirection_get, _traderapi.CTORATstpInputTransferPositionField_TransferDirection_set)
+
+ # 锟斤拷锟斤拷
+ Volume = property(_traderapi.CTORATstpInputTransferPositionField_Volume_get, _traderapi.CTORATstpInputTransferPositionField_Volume_set)
+
+ # 转锟狡持诧拷锟斤拷锟斤拷
+ TransferPositionType = property(_traderapi.CTORATstpInputTransferPositionField_TransferPositionType_get, _traderapi.CTORATstpInputTransferPositionField_TransferPositionType_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputTransferPositionField_UserRequestID_get, _traderapi.CTORATstpInputTransferPositionField_UserRequestID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpInputTransferPositionField_MarketID_get, _traderapi.CTORATstpInputTransferPositionField_MarketID_set)
+
+ # 锟解部锟节碉拷锟斤拷(锟解部系统转锟斤拷时锟斤拷锟斤拷)
+ ExternalNodeID = property(_traderapi.CTORATstpInputTransferPositionField_ExternalNodeID_get, _traderapi.CTORATstpInputTransferPositionField_ExternalNodeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputTransferPositionField_swiginit(self, _traderapi.new_CTORATstpInputTransferPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputTransferPositionField
+
+# Register CTORATstpInputTransferPositionField in _traderapi:
+_traderapi.CTORATstpInputTransferPositionField_swigregister(CTORATstpInputTransferPositionField)
+
+
+
+
+#########################################锟斤拷位转锟狡回憋拷############################################
+class CTORATstpTransferPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷位转锟斤拷锟斤拷水锟斤拷
+ PositionSerial = property(_traderapi.CTORATstpTransferPositionField_PositionSerial_get, _traderapi.CTORATstpTransferPositionField_PositionSerial_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpTransferPositionField_ApplySerial_get, _traderapi.CTORATstpTransferPositionField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpTransferPositionField_FrontID_get, _traderapi.CTORATstpTransferPositionField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpTransferPositionField_SessionID_get, _traderapi.CTORATstpTransferPositionField_SessionID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpTransferPositionField_InvestorID_get, _traderapi.CTORATstpTransferPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpTransferPositionField_BusinessUnitID_get, _traderapi.CTORATstpTransferPositionField_BusinessUnitID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpTransferPositionField_ExchangeID_get, _traderapi.CTORATstpTransferPositionField_ExchangeID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpTransferPositionField_ShareholderID_get, _traderapi.CTORATstpTransferPositionField_ShareholderID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpTransferPositionField_MarketID_get, _traderapi.CTORATstpTransferPositionField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpTransferPositionField_SecurityID_get, _traderapi.CTORATstpTransferPositionField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpTransferPositionField_TradingDay_get, _traderapi.CTORATstpTransferPositionField_TradingDay_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpTransferPositionField_TransferDirection_get, _traderapi.CTORATstpTransferPositionField_TransferDirection_set)
+
+ # 转锟狡持诧拷锟斤拷锟斤拷
+ TransferPositionType = property(_traderapi.CTORATstpTransferPositionField_TransferPositionType_get, _traderapi.CTORATstpTransferPositionField_TransferPositionType_set)
+
+ # 锟斤拷锟秸持诧拷锟斤拷锟斤拷
+ HistoryVolume = property(_traderapi.CTORATstpTransferPositionField_HistoryVolume_get, _traderapi.CTORATstpTransferPositionField_HistoryVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟街诧拷锟斤拷锟斤拷
+ TodayBSVolume = property(_traderapi.CTORATstpTransferPositionField_TodayBSVolume_get, _traderapi.CTORATstpTransferPositionField_TodayBSVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷植锟斤拷锟斤拷锟�
+ TodayPRVolume = property(_traderapi.CTORATstpTransferPositionField_TodayPRVolume_get, _traderapi.CTORATstpTransferPositionField_TodayPRVolume_set)
+
+ # 锟斤拷锟秸诧拷趾喜锟斤拷植锟斤拷锟斤拷锟�
+ TodaySMVolume = property(_traderapi.CTORATstpTransferPositionField_TodaySMVolume_get, _traderapi.CTORATstpTransferPositionField_TodaySMVolume_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpTransferPositionField_TransferStatus_get, _traderapi.CTORATstpTransferPositionField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷员
+ OperatorID = property(_traderapi.CTORATstpTransferPositionField_OperatorID_get, _traderapi.CTORATstpTransferPositionField_OperatorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpTransferPositionField_OperateDate_get, _traderapi.CTORATstpTransferPositionField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpTransferPositionField_OperateTime_get, _traderapi.CTORATstpTransferPositionField_OperateTime_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpTransferPositionField_IPAddress_get, _traderapi.CTORATstpTransferPositionField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpTransferPositionField_MacAddress_get, _traderapi.CTORATstpTransferPositionField_MacAddress_set)
+
+ # 锟解部锟节碉拷锟斤拷
+ ExternalNodeID = property(_traderapi.CTORATstpTransferPositionField_ExternalNodeID_get, _traderapi.CTORATstpTransferPositionField_ExternalNodeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTransferPositionField_swiginit(self, _traderapi.new_CTORATstpTransferPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTransferPositionField
+
+# Register CTORATstpTransferPositionField in _traderapi:
+_traderapi.CTORATstpTransferPositionField_swigregister(CTORATstpTransferPositionField)
+
+
+
+
+#########################################锟斤拷围系统锟斤拷位转锟狡回憋拷############################################
+class CTORATstpPeripheryTransferPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷水锟斤拷
+ PositionSerial = property(_traderapi.CTORATstpPeripheryTransferPositionField_PositionSerial_get, _traderapi.CTORATstpPeripheryTransferPositionField_PositionSerial_set)
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpPeripheryTransferPositionField_ApplySerial_get, _traderapi.CTORATstpPeripheryTransferPositionField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpPeripheryTransferPositionField_FrontID_get, _traderapi.CTORATstpPeripheryTransferPositionField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpPeripheryTransferPositionField_SessionID_get, _traderapi.CTORATstpPeripheryTransferPositionField_SessionID_set)
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpPeripheryTransferPositionField_TransferDirection_get, _traderapi.CTORATstpPeripheryTransferPositionField_TransferDirection_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPeripheryTransferPositionField_ExchangeID_get, _traderapi.CTORATstpPeripheryTransferPositionField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPeripheryTransferPositionField_MarketID_get, _traderapi.CTORATstpPeripheryTransferPositionField_MarketID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPeripheryTransferPositionField_InvestorID_get, _traderapi.CTORATstpPeripheryTransferPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPeripheryTransferPositionField_BusinessUnitID_get, _traderapi.CTORATstpPeripheryTransferPositionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPeripheryTransferPositionField_ShareholderID_get, _traderapi.CTORATstpPeripheryTransferPositionField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPeripheryTransferPositionField_SecurityID_get, _traderapi.CTORATstpPeripheryTransferPositionField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷位转锟斤拷转锟斤拷锟斤拷锟斤拷
+ TodayBSPos = property(_traderapi.CTORATstpPeripheryTransferPositionField_TodayBSPos_get, _traderapi.CTORATstpPeripheryTransferPositionField_TodayBSPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟轿蛔拷锟斤拷锟斤拷锟�
+ TodayPRPos = property(_traderapi.CTORATstpPeripheryTransferPositionField_TodayPRPos_get, _traderapi.CTORATstpPeripheryTransferPositionField_TodayPRPos_set)
+
+ # 锟斤拷锟秸诧拷位转锟斤拷锟斤拷锟斤拷
+ HistoryPos = property(_traderapi.CTORATstpPeripheryTransferPositionField_HistoryPos_get, _traderapi.CTORATstpPeripheryTransferPositionField_HistoryPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpPeripheryTransferPositionField_TradingDay_get, _traderapi.CTORATstpPeripheryTransferPositionField_TradingDay_set)
+
+ # 锟斤拷位锟斤拷锟斤拷原锟斤拷
+ TransferReason = property(_traderapi.CTORATstpPeripheryTransferPositionField_TransferReason_get, _traderapi.CTORATstpPeripheryTransferPositionField_TransferReason_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpPeripheryTransferPositionField_TransferStatus_get, _traderapi.CTORATstpPeripheryTransferPositionField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpPeripheryTransferPositionField_OperateDate_get, _traderapi.CTORATstpPeripheryTransferPositionField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpPeripheryTransferPositionField_OperateTime_get, _traderapi.CTORATstpPeripheryTransferPositionField_OperateTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ RepealDate = property(_traderapi.CTORATstpPeripheryTransferPositionField_RepealDate_get, _traderapi.CTORATstpPeripheryTransferPositionField_RepealDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ RepealTime = property(_traderapi.CTORATstpPeripheryTransferPositionField_RepealTime_get, _traderapi.CTORATstpPeripheryTransferPositionField_RepealTime_set)
+
+ # 锟斤拷锟斤拷原锟斤拷
+ RepealReason = property(_traderapi.CTORATstpPeripheryTransferPositionField_RepealReason_get, _traderapi.CTORATstpPeripheryTransferPositionField_RepealReason_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpPeripheryTransferPositionField_StatusMsg_get, _traderapi.CTORATstpPeripheryTransferPositionField_StatusMsg_set)
+
+ # 锟斤拷锟秸诧拷趾喜锟斤拷锟轿蛔拷锟斤拷锟斤拷锟�
+ TodaySMPos = property(_traderapi.CTORATstpPeripheryTransferPositionField_TodaySMPos_get, _traderapi.CTORATstpPeripheryTransferPositionField_TodaySMPos_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPeripheryTransferPositionField_swiginit(self, _traderapi.new_CTORATstpPeripheryTransferPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPeripheryTransferPositionField
+
+# Register CTORATstpPeripheryTransferPositionField in _traderapi:
+_traderapi.CTORATstpPeripheryTransferPositionField_swigregister(CTORATstpPeripheryTransferPositionField)
+
+
+
+
+#########################################锟斤拷围系统锟绞斤拷转锟狡回憋拷############################################
+class CTORATstpPeripheryTransferFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟绞斤拷锟斤拷锟斤拷锟剿拷锟�
+ FundSerial = property(_traderapi.CTORATstpPeripheryTransferFundField_FundSerial_get, _traderapi.CTORATstpPeripheryTransferFundField_FundSerial_set)
+
+ # 锟绞斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟剿拷锟�
+ ApplySerial = property(_traderapi.CTORATstpPeripheryTransferFundField_ApplySerial_get, _traderapi.CTORATstpPeripheryTransferFundField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpPeripheryTransferFundField_FrontID_get, _traderapi.CTORATstpPeripheryTransferFundField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpPeripheryTransferFundField_SessionID_get, _traderapi.CTORATstpPeripheryTransferFundField_SessionID_set)
+
+ # 锟绞斤拷锟斤拷锟斤拷锟斤拷锟�
+ TransferDirection = property(_traderapi.CTORATstpPeripheryTransferFundField_TransferDirection_get, _traderapi.CTORATstpPeripheryTransferFundField_TransferDirection_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpPeripheryTransferFundField_DepartmentID_get, _traderapi.CTORATstpPeripheryTransferFundField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpPeripheryTransferFundField_AccountID_get, _traderapi.CTORATstpPeripheryTransferFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpPeripheryTransferFundField_CurrencyID_get, _traderapi.CTORATstpPeripheryTransferFundField_CurrencyID_set)
+
+ # 转锟狡斤拷锟�
+ Amount = property(_traderapi.CTORATstpPeripheryTransferFundField_Amount_get, _traderapi.CTORATstpPeripheryTransferFundField_Amount_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPeripheryTransferFundField_InvestorID_get, _traderapi.CTORATstpPeripheryTransferFundField_InvestorID_set)
+
+ # 锟绞斤拷锟斤拷锟皆拷锟�
+ TransferReason = property(_traderapi.CTORATstpPeripheryTransferFundField_TransferReason_get, _traderapi.CTORATstpPeripheryTransferFundField_TransferReason_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpPeripheryTransferFundField_TransferStatus_get, _traderapi.CTORATstpPeripheryTransferFundField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpPeripheryTransferFundField_OperateDate_get, _traderapi.CTORATstpPeripheryTransferFundField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpPeripheryTransferFundField_OperateTime_get, _traderapi.CTORATstpPeripheryTransferFundField_OperateTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ RepealDate = property(_traderapi.CTORATstpPeripheryTransferFundField_RepealDate_get, _traderapi.CTORATstpPeripheryTransferFundField_RepealDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ RepealTime = property(_traderapi.CTORATstpPeripheryTransferFundField_RepealTime_get, _traderapi.CTORATstpPeripheryTransferFundField_RepealTime_set)
+
+ # 锟斤拷锟斤拷原锟斤拷
+ RepealReason = property(_traderapi.CTORATstpPeripheryTransferFundField_RepealReason_get, _traderapi.CTORATstpPeripheryTransferFundField_RepealReason_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpPeripheryTransferFundField_StatusMsg_get, _traderapi.CTORATstpPeripheryTransferFundField_StatusMsg_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPeripheryTransferFundField_BusinessUnitID_get, _traderapi.CTORATstpPeripheryTransferFundField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPeripheryTransferFundField_swiginit(self, _traderapi.new_CTORATstpPeripheryTransferFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPeripheryTransferFundField
+
+# Register CTORATstpPeripheryTransferFundField in _traderapi:
+_traderapi.CTORATstpPeripheryTransferFundField_swigregister(CTORATstpPeripheryTransferFundField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟叫斤拷锟斤拷系统锟绞斤拷锟斤拷锟斤拷############################################
+class CTORATstpReqInquiryJZFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpReqInquiryJZFundField_AccountID_get, _traderapi.CTORATstpReqInquiryJZFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpReqInquiryJZFundField_CurrencyID_get, _traderapi.CTORATstpReqInquiryJZFundField_CurrencyID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqInquiryJZFundField_UserRequestID_get, _traderapi.CTORATstpReqInquiryJZFundField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpReqInquiryJZFundField_DepartmentID_get, _traderapi.CTORATstpReqInquiryJZFundField_DepartmentID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqInquiryJZFundField_swiginit(self, _traderapi.new_CTORATstpReqInquiryJZFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqInquiryJZFundField
+
+# Register CTORATstpReqInquiryJZFundField in _traderapi:
+_traderapi.CTORATstpReqInquiryJZFundField_swigregister(CTORATstpReqInquiryJZFundField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟叫斤拷锟斤拷系统锟绞斤拷锟斤拷应############################################
+class CTORATstpRspInquiryJZFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpRspInquiryJZFundField_AccountID_get, _traderapi.CTORATstpRspInquiryJZFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpRspInquiryJZFundField_CurrencyID_get, _traderapi.CTORATstpRspInquiryJZFundField_CurrencyID_set)
+
+ # 锟斤拷锟矫斤拷锟�
+ UsefulMoney = property(_traderapi.CTORATstpRspInquiryJZFundField_UsefulMoney_get, _traderapi.CTORATstpRspInquiryJZFundField_UsefulMoney_set)
+
+ # 锟斤拷取锟斤拷锟�
+ FetchLimit = property(_traderapi.CTORATstpRspInquiryJZFundField_FetchLimit_get, _traderapi.CTORATstpRspInquiryJZFundField_FetchLimit_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspInquiryJZFundField_UserRequestID_get, _traderapi.CTORATstpRspInquiryJZFundField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpRspInquiryJZFundField_DepartmentID_get, _traderapi.CTORATstpRspInquiryJZFundField_DepartmentID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInquiryJZFundField_swiginit(self, _traderapi.new_CTORATstpRspInquiryJZFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInquiryJZFundField
+
+# Register CTORATstpRspInquiryJZFundField in _traderapi:
+_traderapi.CTORATstpRspInquiryJZFundField_swigregister(CTORATstpRspInquiryJZFundField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷锟斤拷锟�############################################
+class CTORATstpReqInquiryBankAccountFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_UserRequestID_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_DepartmentID_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_AccountID_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_CurrencyID_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_CurrencyID_set)
+
+ # 锟斤拷锟叫达拷锟斤拷
+ BankID = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_BankID_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_BankID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ BankPassword = property(_traderapi.CTORATstpReqInquiryBankAccountFundField_BankPassword_get, _traderapi.CTORATstpReqInquiryBankAccountFundField_BankPassword_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqInquiryBankAccountFundField_swiginit(self, _traderapi.new_CTORATstpReqInquiryBankAccountFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqInquiryBankAccountFundField
+
+# Register CTORATstpReqInquiryBankAccountFundField in _traderapi:
+_traderapi.CTORATstpReqInquiryBankAccountFundField_swigregister(CTORATstpReqInquiryBankAccountFundField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷锟接�############################################
+class CTORATstpRspInquiryBankAccountFundField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_UserRequestID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_DepartmentID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_AccountID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_CurrencyID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_CurrencyID_set)
+
+ # 锟斤拷锟叫达拷锟斤拷
+ BankID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_BankID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_BankID_set)
+
+ # 签约锟斤拷锟斤拷锟剿伙拷
+ BankAccountID = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_BankAccountID_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_BankAccountID_set)
+
+ # 锟剿伙拷锟斤拷锟�
+ Balance = property(_traderapi.CTORATstpRspInquiryBankAccountFundField_Balance_get, _traderapi.CTORATstpRspInquiryBankAccountFundField_Balance_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInquiryBankAccountFundField_swiginit(self, _traderapi.new_CTORATstpRspInquiryBankAccountFundField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInquiryBankAccountFundField
+
+# Register CTORATstpRspInquiryBankAccountFundField in _traderapi:
+_traderapi.CTORATstpRspInquiryBankAccountFundField_swigregister(CTORATstpRspInquiryBankAccountFundField)
+
+
+
+
+#########################################锟斤拷锟斤拷通知############################################
+class CTORATstpTradingNoticeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 通知锟斤拷水锟斤拷
+ NoticeSerial = property(_traderapi.CTORATstpTradingNoticeField_NoticeSerial_get, _traderapi.CTORATstpTradingNoticeField_NoticeSerial_set)
+
+ # 通知锟斤拷锟斤拷
+ InsertDate = property(_traderapi.CTORATstpTradingNoticeField_InsertDate_get, _traderapi.CTORATstpTradingNoticeField_InsertDate_set)
+
+ # 通知时锟斤拷
+ InsertTime = property(_traderapi.CTORATstpTradingNoticeField_InsertTime_get, _traderapi.CTORATstpTradingNoticeField_InsertTime_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpTradingNoticeField_InvestorID_get, _traderapi.CTORATstpTradingNoticeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpTradingNoticeField_BusinessUnitID_get, _traderapi.CTORATstpTradingNoticeField_BusinessUnitID_set)
+
+ # 通知锟斤拷息锟斤拷锟斤拷
+ Content = property(_traderapi.CTORATstpTradingNoticeField_Content_get, _traderapi.CTORATstpTradingNoticeField_Content_set)
+
+ # 锟斤拷锟斤拷员
+ OperatorID = property(_traderapi.CTORATstpTradingNoticeField_OperatorID_get, _traderapi.CTORATstpTradingNoticeField_OperatorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTradingNoticeField_swiginit(self, _traderapi.new_CTORATstpTradingNoticeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTradingNoticeField
+
+# Register CTORATstpTradingNoticeField in _traderapi:
+_traderapi.CTORATstpTradingNoticeField_swigregister(CTORATstpTradingNoticeField)
+
+
+
+
+#########################################锟斤拷询锟斤拷蟊ǖ锟斤拷锟斤拷锟斤拷锟�############################################
+class CTORATstpReqInquiryMaxOrderVolumeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_UserRequestID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_ExchangeID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_SecurityID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_SecurityID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_InvestorID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_BusinessUnitID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_ShareholderID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_Direction_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_Direction_set)
+
+ # 锟斤拷锟斤拷锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_OrderPriceType_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_TimeCondition_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_VolumeCondition_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_VolumeCondition_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_LimitPrice_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_LimitPrice_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_LotType_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_LotType_set)
+
+ # 锟斤拷锟轿拷锟斤拷锟斤拷锟�
+ MaxVolume = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_MaxVolume_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_MaxVolume_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟阶拷茫锟�
+ CreditDebtID = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_CreditDebtID_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟酵ｏ拷锟斤拷锟斤拷专锟矫ｏ拷
+ CreditQuotaType = property(_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_CreditQuotaType_get, _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_CreditQuotaType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqInquiryMaxOrderVolumeField_swiginit(self, _traderapi.new_CTORATstpReqInquiryMaxOrderVolumeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqInquiryMaxOrderVolumeField
+
+# Register CTORATstpReqInquiryMaxOrderVolumeField in _traderapi:
+_traderapi.CTORATstpReqInquiryMaxOrderVolumeField_swigregister(CTORATstpReqInquiryMaxOrderVolumeField)
+
+
+
+
+#########################################锟斤拷询锟斤拷蟊ǖ锟斤拷锟斤拷锟接�############################################
+class CTORATstpRspInquiryMaxOrderVolumeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_UserRequestID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_ExchangeID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_SecurityID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_SecurityID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_InvestorID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_BusinessUnitID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_ShareholderID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_Direction_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_Direction_set)
+
+ # 锟斤拷锟斤拷锟桔革拷锟斤拷锟斤拷
+ OrderPriceType = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_OrderPriceType_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_OrderPriceType_set)
+
+ # 锟斤拷效锟斤拷锟斤拷锟斤拷
+ TimeCondition = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_TimeCondition_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_TimeCondition_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷锟斤拷
+ VolumeCondition = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_VolumeCondition_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_VolumeCondition_set)
+
+ # 锟桔革拷
+ LimitPrice = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_LimitPrice_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_LimitPrice_set)
+
+ # 锟桔癸拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ LotType = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_LotType_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_LotType_set)
+
+ # 锟斤拷锟轿拷锟斤拷锟斤拷锟�
+ MaxVolume = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_MaxVolume_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_MaxVolume_set)
+
+ # 指锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫革拷债锟斤拷牛锟斤拷锟斤拷侄锟斤拷每毡锟绞撅拷锟街革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟阶拷茫锟�
+ CreditDebtID = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_CreditDebtID_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_CreditDebtID_set)
+
+ # 头锟斤拷锟斤拷锟酵ｏ拷锟斤拷锟斤拷专锟矫ｏ拷
+ CreditQuotaType = property(_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_CreditQuotaType_get, _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_CreditQuotaType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInquiryMaxOrderVolumeField_swiginit(self, _traderapi.new_CTORATstpRspInquiryMaxOrderVolumeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInquiryMaxOrderVolumeField
+
+# Register CTORATstpRspInquiryMaxOrderVolumeField in _traderapi:
+_traderapi.CTORATstpRspInquiryMaxOrderVolumeField_swigregister(CTORATstpRspInquiryMaxOrderVolumeField)
+
+
+
+
+#########################################锟斤拷锟阶成斤拷锟斤拷锟叫讹拷############################################
+class CTORATstpInquiryTradeConcentrationField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_UserRequestID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_ExchangeID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_MarketID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_SecurityID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_SecurityID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_InvestorID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_BusinessUnitID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_BusinessUnitID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_AccountID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_AccountID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpInquiryTradeConcentrationField_ShareholderID_get, _traderapi.CTORATstpInquiryTradeConcentrationField_ShareholderID_set)
+
+ # 投锟斤拷锟竭成斤拷锟斤拷/锟缴斤拷锟斤拷锟斤拷
+ ConcentrationRatio1 = property(_traderapi.CTORATstpInquiryTradeConcentrationField_ConcentrationRatio1_get, _traderapi.CTORATstpInquiryTradeConcentrationField_ConcentrationRatio1_set)
+
+ # 投锟斤拷锟竭成斤拷锟斤拷锟�/锟缴斤拷锟杰斤拷锟�
+ ConcentrationRatio2 = property(_traderapi.CTORATstpInquiryTradeConcentrationField_ConcentrationRatio2_get, _traderapi.CTORATstpInquiryTradeConcentrationField_ConcentrationRatio2_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInquiryTradeConcentrationField_swiginit(self, _traderapi.new_CTORATstpInquiryTradeConcentrationField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInquiryTradeConcentrationField
+
+# Register CTORATstpInquiryTradeConcentrationField in _traderapi:
+_traderapi.CTORATstpInquiryTradeConcentrationField_swigregister(CTORATstpInquiryTradeConcentrationField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟睫改匡拷锟街成憋拷############################################
+class CTORATstpReqModifyOpenPosCostField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_UserRequestID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_ExchangeID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_InvestorID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_BusinessUnitID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_ShareholderID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpReqModifyOpenPosCostField_SecurityID_get, _traderapi.CTORATstpReqModifyOpenPosCostField_SecurityID_set)
+
+ # 锟斤拷锟街成憋拷
+ OpenPosCost = property(_traderapi.CTORATstpReqModifyOpenPosCostField_OpenPosCost_get, _traderapi.CTORATstpReqModifyOpenPosCostField_OpenPosCost_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqModifyOpenPosCostField_swiginit(self, _traderapi.new_CTORATstpReqModifyOpenPosCostField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqModifyOpenPosCostField
+
+# Register CTORATstpReqModifyOpenPosCostField in _traderapi:
+_traderapi.CTORATstpReqModifyOpenPosCostField_swigregister(CTORATstpReqModifyOpenPosCostField)
+
+
+
+
+#########################################录锟斤拷诘锟斤拷式锟斤拷锟斤拷锟斤拷息############################################
+class CTORATstpInputNodeFundAssignmentField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpInputNodeFundAssignmentField_UserRequestID_get, _traderapi.CTORATstpInputNodeFundAssignmentField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpInputNodeFundAssignmentField_DepartmentID_get, _traderapi.CTORATstpInputNodeFundAssignmentField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿猴拷
+ AccountID = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AccountID_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpInputNodeFundAssignmentField_CurrencyID_get, _traderapi.CTORATstpInputNodeFundAssignmentField_CurrencyID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInputNodeFundAssignmentField_InvestorID_get, _traderapi.CTORATstpInputNodeFundAssignmentField_InvestorID_set)
+
+ # 锟节碉拷锟斤拷1
+ NodeID1 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_NodeID1_get, _traderapi.CTORATstpInputNodeFundAssignmentField_NodeID1_set)
+
+ # 锟绞斤拷锟斤拷锟�1
+ AmtRatio1 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio1_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio1_set)
+
+ # 锟节碉拷锟斤拷2
+ NodeID2 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_NodeID2_get, _traderapi.CTORATstpInputNodeFundAssignmentField_NodeID2_set)
+
+ # 锟绞斤拷锟斤拷锟�2
+ AmtRatio2 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio2_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio2_set)
+
+ # 锟节碉拷锟斤拷3
+ NodeID3 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_NodeID3_get, _traderapi.CTORATstpInputNodeFundAssignmentField_NodeID3_set)
+
+ # 锟绞斤拷锟斤拷锟�3
+ AmtRatio3 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio3_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio3_set)
+
+ # 锟节碉拷锟斤拷4
+ NodeID4 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_NodeID4_get, _traderapi.CTORATstpInputNodeFundAssignmentField_NodeID4_set)
+
+ # 锟绞斤拷锟斤拷锟�4
+ AmtRatio4 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio4_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio4_set)
+
+ # 锟节碉拷锟斤拷5
+ NodeID5 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_NodeID5_get, _traderapi.CTORATstpInputNodeFundAssignmentField_NodeID5_set)
+
+ # 锟绞斤拷锟斤拷锟�5
+ AmtRatio5 = property(_traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio5_get, _traderapi.CTORATstpInputNodeFundAssignmentField_AmtRatio5_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInputNodeFundAssignmentField_swiginit(self, _traderapi.new_CTORATstpInputNodeFundAssignmentField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInputNodeFundAssignmentField
+
+# Register CTORATstpInputNodeFundAssignmentField in _traderapi:
+_traderapi.CTORATstpInputNodeFundAssignmentField_swigregister(CTORATstpInputNodeFundAssignmentField)
+
+
+
+
+#########################################锟斤拷询锟节碉拷锟绞斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpReqInquiryNodeFundAssignmentField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_DepartmentID_get, _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿猴拷
+ AccountID = property(_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_AccountID_get, _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_CurrencyID_get, _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_CurrencyID_set)
+
+ # 锟节碉拷锟斤拷
+ NodeID = property(_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_NodeID_get, _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_NodeID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_UserRequestID_get, _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_UserRequestID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpReqInquiryNodeFundAssignmentField_swiginit(self, _traderapi.new_CTORATstpReqInquiryNodeFundAssignmentField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpReqInquiryNodeFundAssignmentField
+
+# Register CTORATstpReqInquiryNodeFundAssignmentField in _traderapi:
+_traderapi.CTORATstpReqInquiryNodeFundAssignmentField_swigregister(CTORATstpReqInquiryNodeFundAssignmentField)
+
+
+
+
+#########################################锟斤拷询锟节碉拷锟绞斤拷锟斤拷锟斤拷锟斤拷锟斤拷应############################################
+class CTORATstpRspInquiryNodeFundAssignmentField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_UserRequestID_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_UserRequestID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_DepartmentID_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿猴拷
+ AccountID = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AccountID_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_CurrencyID_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_CurrencyID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_InvestorID_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_InvestorID_set)
+
+ # 锟节碉拷锟斤拷1
+ NodeID1 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID1_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID1_set)
+
+ # 锟绞斤拷锟斤拷锟�1
+ AmtRatio1 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio1_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio1_set)
+
+ # 锟节碉拷锟斤拷2
+ NodeID2 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID2_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID2_set)
+
+ # 锟绞斤拷锟斤拷锟�2
+ AmtRatio2 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio2_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio2_set)
+
+ # 锟节碉拷锟斤拷3
+ NodeID3 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID3_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID3_set)
+
+ # 锟绞斤拷锟斤拷锟�3
+ AmtRatio3 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio3_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio3_set)
+
+ # 锟节碉拷锟斤拷4
+ NodeID4 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID4_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID4_set)
+
+ # 锟绞斤拷锟斤拷锟�4
+ AmtRatio4 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio4_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio4_set)
+
+ # 锟节碉拷锟斤拷5
+ NodeID5 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID5_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_NodeID5_set)
+
+ # 锟绞斤拷锟斤拷锟�5
+ AmtRatio5 = property(_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio5_get, _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_AmtRatio5_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRspInquiryNodeFundAssignmentField_swiginit(self, _traderapi.new_CTORATstpRspInquiryNodeFundAssignmentField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRspInquiryNodeFundAssignmentField
+
+# Register CTORATstpRspInquiryNodeFundAssignmentField in _traderapi:
+_traderapi.CTORATstpRspInquiryNodeFundAssignmentField_swigregister(CTORATstpRspInquiryNodeFundAssignmentField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpQryExchangeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryExchangeField_ExchangeID_get, _traderapi.CTORATstpQryExchangeField_ExchangeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryExchangeField_swiginit(self, _traderapi.new_CTORATstpQryExchangeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryExchangeField
+
+# Register CTORATstpQryExchangeField in _traderapi:
+_traderapi.CTORATstpQryExchangeField_swigregister(CTORATstpQryExchangeField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpExchangeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpExchangeField_ExchangeID_get, _traderapi.CTORATstpExchangeField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeName = property(_traderapi.CTORATstpExchangeField_ExchangeName_get, _traderapi.CTORATstpExchangeField_ExchangeName_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpExchangeField_TradingDay_get, _traderapi.CTORATstpExchangeField_TradingDay_set)
+
+ # 锟斤拷锟斤拷同锟斤拷状态
+ DataSyncStatus = property(_traderapi.CTORATstpExchangeField_DataSyncStatus_get, _traderapi.CTORATstpExchangeField_DataSyncStatus_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpExchangeField_swiginit(self, _traderapi.new_CTORATstpExchangeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpExchangeField
+
+# Register CTORATstpExchangeField in _traderapi:
+_traderapi.CTORATstpExchangeField_swigregister(CTORATstpExchangeField)
+
+
+
+
+#########################################锟斤拷询证券锟斤拷息############################################
+class CTORATstpQrySecurityField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQrySecurityField_ExchangeID_get, _traderapi.CTORATstpQrySecurityField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQrySecurityField_SecurityID_get, _traderapi.CTORATstpQrySecurityField_SecurityID_set)
+
+ # 锟斤拷品锟斤拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpQrySecurityField_ProductID_get, _traderapi.CTORATstpQrySecurityField_ProductID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQrySecurityField_swiginit(self, _traderapi.new_CTORATstpQrySecurityField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQrySecurityField
+
+# Register CTORATstpQrySecurityField in _traderapi:
+_traderapi.CTORATstpQrySecurityField_swigregister(CTORATstpQrySecurityField)
+
+
+
+
+#########################################证券锟斤拷息############################################
+class CTORATstpSecurityField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpSecurityField_TradingDay_get, _traderapi.CTORATstpSecurityField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpSecurityField_ExchangeID_get, _traderapi.CTORATstpSecurityField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpSecurityField_SecurityID_get, _traderapi.CTORATstpSecurityField_SecurityID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpSecurityField_SecurityName_get, _traderapi.CTORATstpSecurityField_SecurityName_set)
+
+ # 证券锟斤拷锟斤拷(锟斤拷)
+ ShortSecurityName = property(_traderapi.CTORATstpSecurityField_ShortSecurityName_get, _traderapi.CTORATstpSecurityField_ShortSecurityName_set)
+
+ # 锟斤拷锟斤拷证券锟斤拷锟斤拷
+ UnderlyingSecurityID = property(_traderapi.CTORATstpSecurityField_UnderlyingSecurityID_get, _traderapi.CTORATstpSecurityField_UnderlyingSecurityID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpSecurityField_MarketID_get, _traderapi.CTORATstpSecurityField_MarketID_set)
+
+ # 锟斤拷品锟斤拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpSecurityField_ProductID_get, _traderapi.CTORATstpSecurityField_ProductID_set)
+
+ # 证券锟斤拷锟�
+ SecurityType = property(_traderapi.CTORATstpSecurityField_SecurityType_get, _traderapi.CTORATstpSecurityField_SecurityType_set)
+
+ # 锟疥报锟斤拷位
+ OrderUnit = property(_traderapi.CTORATstpSecurityField_OrderUnit_get, _traderapi.CTORATstpSecurityField_OrderUnit_set)
+
+ # 锟睫硷拷锟斤拷锟诫交锟阶碉拷位
+ LimitBuyTradingUnit = property(_traderapi.CTORATstpSecurityField_LimitBuyTradingUnit_get, _traderapi.CTORATstpSecurityField_LimitBuyTradingUnit_set)
+
+ # 锟睫价碉拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxLimitOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MaxLimitOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MaxLimitOrderBuyVolume_set)
+
+ # 锟睫价碉拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinLimitOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MinLimitOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MinLimitOrderBuyVolume_set)
+
+ # 锟睫硷拷锟斤拷锟斤拷锟斤拷锟阶碉拷位
+ LimitSellTradingUnit = property(_traderapi.CTORATstpSecurityField_LimitSellTradingUnit_get, _traderapi.CTORATstpSecurityField_LimitSellTradingUnit_set)
+
+ # 锟睫价碉拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxLimitOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MaxLimitOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MaxLimitOrderSellVolume_set)
+
+ # 锟睫价碉拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinLimitOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MinLimitOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MinLimitOrderSellVolume_set)
+
+ # 锟叫硷拷锟斤拷锟诫交锟阶碉拷位
+ MarketBuyTradingUnit = property(_traderapi.CTORATstpSecurityField_MarketBuyTradingUnit_get, _traderapi.CTORATstpSecurityField_MarketBuyTradingUnit_set)
+
+ # 锟叫价碉拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxMarketOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MaxMarketOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MaxMarketOrderBuyVolume_set)
+
+ # 锟叫价碉拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinMarketOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MinMarketOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MinMarketOrderBuyVolume_set)
+
+ # 锟叫硷拷锟斤拷锟斤拷锟斤拷锟阶碉拷位
+ MarketSellTradingUnit = property(_traderapi.CTORATstpSecurityField_MarketSellTradingUnit_get, _traderapi.CTORATstpSecurityField_MarketSellTradingUnit_set)
+
+ # 锟叫价碉拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxMarketOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MaxMarketOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MaxMarketOrderSellVolume_set)
+
+ # 锟叫价碉拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinMarketOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MinMarketOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MinMarketOrderSellVolume_set)
+
+ # 锟教后定硷拷锟斤拷锟诫交锟阶碉拷位
+ FixPriceBuyTradingUnit = property(_traderapi.CTORATstpSecurityField_FixPriceBuyTradingUnit_get, _traderapi.CTORATstpSecurityField_FixPriceBuyTradingUnit_set)
+
+ # 锟教后定硷拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxFixPriceOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MaxFixPriceOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MaxFixPriceOrderBuyVolume_set)
+
+ # 锟教后定硷拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinFixPriceOrderBuyVolume = property(_traderapi.CTORATstpSecurityField_MinFixPriceOrderBuyVolume_get, _traderapi.CTORATstpSecurityField_MinFixPriceOrderBuyVolume_set)
+
+ # 锟教后定硷拷锟斤拷锟斤拷锟斤拷锟阶碉拷位
+ FixPriceSellTradingUnit = property(_traderapi.CTORATstpSecurityField_FixPriceSellTradingUnit_get, _traderapi.CTORATstpSecurityField_FixPriceSellTradingUnit_set)
+
+ # 锟教后定硷拷锟斤拷锟斤拷锟斤拷碌锟斤拷锟�
+ MaxFixPriceOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MaxFixPriceOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MaxFixPriceOrderSellVolume_set)
+
+ # 锟教后定硷拷锟斤拷锟斤拷小锟铰碉拷锟斤拷
+ MinFixPriceOrderSellVolume = property(_traderapi.CTORATstpSecurityField_MinFixPriceOrderSellVolume_get, _traderapi.CTORATstpSecurityField_MinFixPriceOrderSellVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ VolumeMultiple = property(_traderapi.CTORATstpSecurityField_VolumeMultiple_get, _traderapi.CTORATstpSecurityField_VolumeMultiple_set)
+
+ # 锟斤拷小锟戒动锟斤拷位
+ PriceTick = property(_traderapi.CTORATstpSecurityField_PriceTick_get, _traderapi.CTORATstpSecurityField_PriceTick_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ OpenDate = property(_traderapi.CTORATstpSecurityField_OpenDate_get, _traderapi.CTORATstpSecurityField_OpenDate_set)
+
+ # 锟斤拷值
+ ParValue = property(_traderapi.CTORATstpSecurityField_ParValue_get, _traderapi.CTORATstpSecurityField_ParValue_set)
+
+ # 证券状态
+ SecurityStatus = property(_traderapi.CTORATstpSecurityField_SecurityStatus_get, _traderapi.CTORATstpSecurityField_SecurityStatus_set)
+
+ # 债券应锟斤拷锟斤拷息
+ BondInterest = property(_traderapi.CTORATstpSecurityField_BondInterest_get, _traderapi.CTORATstpSecurityField_BondInterest_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ ConversionRate = property(_traderapi.CTORATstpSecurityField_ConversionRate_get, _traderapi.CTORATstpSecurityField_ConversionRate_set)
+
+ # 锟杰股憋拷
+ TotalEquity = property(_traderapi.CTORATstpSecurityField_TotalEquity_get, _traderapi.CTORATstpSecurityField_TotalEquity_set)
+
+ # 锟斤拷通锟缴憋拷
+ CirculationEquity = property(_traderapi.CTORATstpSecurityField_CirculationEquity_get, _traderapi.CTORATstpSecurityField_CirculationEquity_set)
+
+ # 锟角凤拷锟斤拷锟斤拷锟角碉拷停锟斤拷锟�
+ bPriceLimit = property(_traderapi.CTORATstpSecurityField_bPriceLimit_get, _traderapi.CTORATstpSecurityField_bPriceLimit_set)
+
+ # 锟斤拷锟斤拷锟教硷拷
+ PreClosePrice = property(_traderapi.CTORATstpSecurityField_PreClosePrice_get, _traderapi.CTORATstpSecurityField_PreClosePrice_set)
+
+ # 锟斤拷停锟斤拷锟�
+ UpperLimitPrice = property(_traderapi.CTORATstpSecurityField_UpperLimitPrice_get, _traderapi.CTORATstpSecurityField_UpperLimitPrice_set)
+
+ # 锟斤拷停锟斤拷锟�
+ LowerLimitPrice = property(_traderapi.CTORATstpSecurityField_LowerLimitPrice_get, _traderapi.CTORATstpSecurityField_LowerLimitPrice_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpSecurityField_swiginit(self, _traderapi.new_CTORATstpSecurityField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpSecurityField
+
+# Register CTORATstpSecurityField in _traderapi:
+_traderapi.CTORATstpSecurityField_swigregister(CTORATstpSecurityField)
+
+
+
+
+#########################################锟斤拷询锟铰癸拷锟斤拷息############################################
+class CTORATstpQryIPOInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryIPOInfoField_ExchangeID_get, _traderapi.CTORATstpQryIPOInfoField_ExchangeID_set)
+
+ # 锟疥购锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryIPOInfoField_SecurityID_get, _traderapi.CTORATstpQryIPOInfoField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryIPOInfoField_swiginit(self, _traderapi.new_CTORATstpQryIPOInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryIPOInfoField
+
+# Register CTORATstpQryIPOInfoField in _traderapi:
+_traderapi.CTORATstpQryIPOInfoField_swigregister(CTORATstpQryIPOInfoField)
+
+
+
+
+#########################################锟铰癸拷锟斤拷息############################################
+class CTORATstpIPOInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpIPOInfoField_ExchangeID_get, _traderapi.CTORATstpIPOInfoField_ExchangeID_set)
+
+ # 锟疥购锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpIPOInfoField_SecurityID_get, _traderapi.CTORATstpIPOInfoField_SecurityID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpIPOInfoField_MarketID_get, _traderapi.CTORATstpIPOInfoField_MarketID_set)
+
+ # 锟斤拷品锟斤拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpIPOInfoField_ProductID_get, _traderapi.CTORATstpIPOInfoField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpIPOInfoField_SecurityType_get, _traderapi.CTORATstpIPOInfoField_SecurityType_set)
+
+ # 锟斤拷小锟疥购锟桔革拷
+ MinPrice = property(_traderapi.CTORATstpIPOInfoField_MinPrice_get, _traderapi.CTORATstpIPOInfoField_MinPrice_set)
+
+ # 锟斤拷锟街达拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpIPOInfoField_CurrencyID_get, _traderapi.CTORATstpIPOInfoField_CurrencyID_set)
+
+ # 锟疥购证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpIPOInfoField_SecurityName_get, _traderapi.CTORATstpIPOInfoField_SecurityName_set)
+
+ # 锟铰癸拷证券锟斤拷锟斤拷
+ UnderlyingSecurityID = property(_traderapi.CTORATstpIPOInfoField_UnderlyingSecurityID_get, _traderapi.CTORATstpIPOInfoField_UnderlyingSecurityID_set)
+
+ # 锟铰癸拷证券锟斤拷锟斤拷
+ UnderlyingSecurityName = property(_traderapi.CTORATstpIPOInfoField_UnderlyingSecurityName_get, _traderapi.CTORATstpIPOInfoField_UnderlyingSecurityName_set)
+
+ # 锟斤拷锟斤拷锟疥购锟斤拷小锟斤拷锟斤拷
+ MinVolume = property(_traderapi.CTORATstpIPOInfoField_MinVolume_get, _traderapi.CTORATstpIPOInfoField_MinVolume_set)
+
+ # 锟斤拷锟斤拷锟疥购锟斤拷锟斤拷锟斤拷锟�
+ MaxVolume = property(_traderapi.CTORATstpIPOInfoField_MaxVolume_get, _traderapi.CTORATstpIPOInfoField_MaxVolume_set)
+
+ # 锟斤拷锟斤拷锟疥购锟斤拷位锟斤拷锟斤拷
+ VolumeUnit = property(_traderapi.CTORATstpIPOInfoField_VolumeUnit_get, _traderapi.CTORATstpIPOInfoField_VolumeUnit_set)
+
+ # 锟斤拷锟叫凤拷式
+ IssueMode = property(_traderapi.CTORATstpIPOInfoField_IssueMode_get, _traderapi.CTORATstpIPOInfoField_IssueMode_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpIPOInfoField_TradingDay_get, _traderapi.CTORATstpIPOInfoField_TradingDay_set)
+
+ # 锟斤拷锟斤拷旯猴拷鄹锟�
+ MaxPrice = property(_traderapi.CTORATstpIPOInfoField_MaxPrice_get, _traderapi.CTORATstpIPOInfoField_MaxPrice_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpIPOInfoField_swiginit(self, _traderapi.new_CTORATstpIPOInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpIPOInfoField
+
+# Register CTORATstpIPOInfoField in _traderapi:
+_traderapi.CTORATstpIPOInfoField_swigregister(CTORATstpIPOInfoField)
+
+
+
+
+#########################################锟斤拷询锟矫伙拷############################################
+class CTORATstpQryUserField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpQryUserField_UserID_get, _traderapi.CTORATstpQryUserField_UserID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserType = property(_traderapi.CTORATstpQryUserField_UserType_get, _traderapi.CTORATstpQryUserField_UserType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryUserField_swiginit(self, _traderapi.new_CTORATstpQryUserField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryUserField
+
+# Register CTORATstpQryUserField in _traderapi:
+_traderapi.CTORATstpQryUserField_swigregister(CTORATstpQryUserField)
+
+
+
+
+#########################################锟矫伙拷############################################
+class CTORATstpUserField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpUserField_UserID_get, _traderapi.CTORATstpUserField_UserID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserName = property(_traderapi.CTORATstpUserField_UserName_get, _traderapi.CTORATstpUserField_UserName_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserType = property(_traderapi.CTORATstpUserField_UserType_get, _traderapi.CTORATstpUserField_UserType_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpUserField_DepartmentID_get, _traderapi.CTORATstpUserField_DepartmentID_set)
+
+ # 锟斤拷录锟斤拷锟斤拷锟斤拷
+ LoginLimit = property(_traderapi.CTORATstpUserField_LoginLimit_get, _traderapi.CTORATstpUserField_LoginLimit_set)
+
+ # 锟斤拷录状态
+ LoginStatus = property(_traderapi.CTORATstpUserField_LoginStatus_get, _traderapi.CTORATstpUserField_LoginStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OpenDate = property(_traderapi.CTORATstpUserField_OpenDate_get, _traderapi.CTORATstpUserField_OpenDate_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ CloseDate = property(_traderapi.CTORATstpUserField_CloseDate_get, _traderapi.CTORATstpUserField_CloseDate_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderInsertCommFlux = property(_traderapi.CTORATstpUserField_OrderInsertCommFlux_get, _traderapi.CTORATstpUserField_OrderInsertCommFlux_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderActionCommFlux = property(_traderapi.CTORATstpUserField_OrderActionCommFlux_get, _traderapi.CTORATstpUserField_OrderActionCommFlux_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpUserField_swiginit(self, _traderapi.new_CTORATstpUserField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpUserField
+
+# Register CTORATstpUserField in _traderapi:
+_traderapi.CTORATstpUserField_swigregister(CTORATstpUserField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟斤拷############################################
+class CTORATstpQryInvestorField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryInvestorField_InvestorID_get, _traderapi.CTORATstpQryInvestorField_InvestorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryInvestorField_swiginit(self, _traderapi.new_CTORATstpQryInvestorField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryInvestorField
+
+# Register CTORATstpQryInvestorField in _traderapi:
+_traderapi.CTORATstpQryInvestorField_swigregister(CTORATstpQryInvestorField)
+
+
+
+
+#########################################投锟斤拷锟斤拷############################################
+class CTORATstpInvestorField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInvestorField_InvestorID_get, _traderapi.CTORATstpInvestorField_InvestorID_set)
+
+ # 投锟斤拷锟斤拷锟斤拷锟斤拷
+ InvestorType = property(_traderapi.CTORATstpInvestorField_InvestorType_get, _traderapi.CTORATstpInvestorField_InvestorType_set)
+
+ # 投锟斤拷锟斤拷锟斤拷锟斤拷
+ InvestorName = property(_traderapi.CTORATstpInvestorField_InvestorName_get, _traderapi.CTORATstpInvestorField_InvestorName_set)
+
+ # 证锟斤拷锟斤拷锟斤拷
+ IdCardType = property(_traderapi.CTORATstpInvestorField_IdCardType_get, _traderapi.CTORATstpInvestorField_IdCardType_set)
+
+ # 证锟斤拷锟斤拷锟斤拷
+ IdCardNo = property(_traderapi.CTORATstpInvestorField_IdCardNo_get, _traderapi.CTORATstpInvestorField_IdCardNo_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OpenDate = property(_traderapi.CTORATstpInvestorField_OpenDate_get, _traderapi.CTORATstpInvestorField_OpenDate_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ CloseDate = property(_traderapi.CTORATstpInvestorField_CloseDate_get, _traderapi.CTORATstpInvestorField_CloseDate_set)
+
+ # 锟斤拷锟斤拷状态
+ TradingStatus = property(_traderapi.CTORATstpInvestorField_TradingStatus_get, _traderapi.CTORATstpInvestorField_TradingStatus_set)
+
+ # 委锟叫凤拷式
+ Operways = property(_traderapi.CTORATstpInvestorField_Operways_get, _traderapi.CTORATstpInvestorField_Operways_set)
+
+ # 锟街伙拷
+ Mobile = property(_traderapi.CTORATstpInvestorField_Mobile_get, _traderapi.CTORATstpInvestorField_Mobile_set)
+
+ # 锟斤拷系锟界话
+ Telephone = property(_traderapi.CTORATstpInvestorField_Telephone_get, _traderapi.CTORATstpInvestorField_Telephone_set)
+
+ # 锟斤拷锟斤拷锟绞硷拷
+ Email = property(_traderapi.CTORATstpInvestorField_Email_get, _traderapi.CTORATstpInvestorField_Email_set)
+
+ # 锟斤拷锟斤拷
+ Fax = property(_traderapi.CTORATstpInvestorField_Fax_get, _traderapi.CTORATstpInvestorField_Fax_set)
+
+ # 通讯锟斤拷址
+ Address = property(_traderapi.CTORATstpInvestorField_Address_get, _traderapi.CTORATstpInvestorField_Address_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ZipCode = property(_traderapi.CTORATstpInvestorField_ZipCode_get, _traderapi.CTORATstpInvestorField_ZipCode_set)
+
+ # 专业投锟斤拷锟斤拷锟斤拷锟�
+ ProfInvestorType = property(_traderapi.CTORATstpInvestorField_ProfInvestorType_get, _traderapi.CTORATstpInvestorField_ProfInvestorType_set)
+
+ # 锟阶诧拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ PlanType = property(_traderapi.CTORATstpInvestorField_PlanType_get, _traderapi.CTORATstpInvestorField_PlanType_set)
+
+ # 锟角凤拷锟斤拷锟斤拷投锟斤拷锟斤拷锟斤拷锟斤拷锟阶诧拷(锟斤拷锟斤拷专锟斤拷)
+ AllowSelfSwitchPlan = property(_traderapi.CTORATstpInvestorField_AllowSelfSwitchPlan_get, _traderapi.CTORATstpInvestorField_AllowSelfSwitchPlan_set)
+
+ # 锟斤拷注
+ Remark = property(_traderapi.CTORATstpInvestorField_Remark_get, _traderapi.CTORATstpInvestorField_Remark_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInvestorField_swiginit(self, _traderapi.new_CTORATstpInvestorField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInvestorField
+
+# Register CTORATstpInvestorField in _traderapi:
+_traderapi.CTORATstpInvestorField_swigregister(CTORATstpInvestorField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟阶股讹拷锟剿伙拷############################################
+class CTORATstpQryShareholderAccountField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryShareholderAccountField_InvestorID_get, _traderapi.CTORATstpQryShareholderAccountField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryShareholderAccountField_ExchangeID_get, _traderapi.CTORATstpQryShareholderAccountField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryShareholderAccountField_MarketID_get, _traderapi.CTORATstpQryShareholderAccountField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryShareholderAccountField_ShareholderID_get, _traderapi.CTORATstpQryShareholderAccountField_ShareholderID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderIDType = property(_traderapi.CTORATstpQryShareholderAccountField_ShareholderIDType_get, _traderapi.CTORATstpQryShareholderAccountField_ShareholderIDType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryShareholderAccountField_swiginit(self, _traderapi.new_CTORATstpQryShareholderAccountField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryShareholderAccountField
+
+# Register CTORATstpQryShareholderAccountField in _traderapi:
+_traderapi.CTORATstpQryShareholderAccountField_swigregister(CTORATstpQryShareholderAccountField)
+
+
+
+
+#########################################锟斤拷锟阶股讹拷锟剿伙拷############################################
+class CTORATstpShareholderAccountField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpShareholderAccountField_InvestorID_get, _traderapi.CTORATstpShareholderAccountField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpShareholderAccountField_ExchangeID_get, _traderapi.CTORATstpShareholderAccountField_ExchangeID_set)
+
+ # 锟酵伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpShareholderAccountField_ShareholderID_get, _traderapi.CTORATstpShareholderAccountField_ShareholderID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderIDType = property(_traderapi.CTORATstpShareholderAccountField_ShareholderIDType_get, _traderapi.CTORATstpShareholderAccountField_ShareholderIDType_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpShareholderAccountField_MarketID_get, _traderapi.CTORATstpShareholderAccountField_MarketID_set)
+
+ # 锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡憋拷志(锟斤拷锟斤拷专锟斤拷)
+ BSWhiteListCtl = property(_traderapi.CTORATstpShareholderAccountField_BSWhiteListCtl_get, _traderapi.CTORATstpShareholderAccountField_BSWhiteListCtl_set)
+
+ # 锟斤拷锟剿伙拷锟斤拷识
+ MainFlag = property(_traderapi.CTORATstpShareholderAccountField_MainFlag_get, _traderapi.CTORATstpShareholderAccountField_MainFlag_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpShareholderAccountField_swiginit(self, _traderapi.new_CTORATstpShareholderAccountField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpShareholderAccountField
+
+# Register CTORATstpShareholderAccountField in _traderapi:
+_traderapi.CTORATstpShareholderAccountField_swigregister(CTORATstpShareholderAccountField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟秸拷锟较�############################################
+class CTORATstpQryRationalInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryRationalInfoField_ExchangeID_get, _traderapi.CTORATstpQryRationalInfoField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟秸拷锟斤拷锟�
+ SecurityID = property(_traderapi.CTORATstpQryRationalInfoField_SecurityID_get, _traderapi.CTORATstpQryRationalInfoField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryRationalInfoField_swiginit(self, _traderapi.new_CTORATstpQryRationalInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryRationalInfoField
+
+# Register CTORATstpQryRationalInfoField in _traderapi:
+_traderapi.CTORATstpQryRationalInfoField_swigregister(CTORATstpQryRationalInfoField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟秸拷锟较�############################################
+class CTORATstpRationalInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpRationalInfoField_TradingDay_get, _traderapi.CTORATstpRationalInfoField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpRationalInfoField_ExchangeID_get, _traderapi.CTORATstpRationalInfoField_ExchangeID_set)
+
+ # 锟疥购锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpRationalInfoField_SecurityID_get, _traderapi.CTORATstpRationalInfoField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟秸拷鄹锟�
+ Price = property(_traderapi.CTORATstpRationalInfoField_Price_get, _traderapi.CTORATstpRationalInfoField_Price_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpRationalInfoField_MarketID_get, _traderapi.CTORATstpRationalInfoField_MarketID_set)
+
+ # 证券品锟街达拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpRationalInfoField_ProductID_get, _traderapi.CTORATstpRationalInfoField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpRationalInfoField_SecurityType_get, _traderapi.CTORATstpRationalInfoField_SecurityType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ SecurityName = property(_traderapi.CTORATstpRationalInfoField_SecurityName_get, _traderapi.CTORATstpRationalInfoField_SecurityName_set)
+
+ # 锟斤拷锟斤拷证券锟斤拷锟斤拷
+ UnderlyingSecurityID = property(_traderapi.CTORATstpRationalInfoField_UnderlyingSecurityID_get, _traderapi.CTORATstpRationalInfoField_UnderlyingSecurityID_set)
+
+ # 锟斤拷锟斤拷证券锟斤拷锟斤拷
+ UnderlyingSecurityName = property(_traderapi.CTORATstpRationalInfoField_UnderlyingSecurityName_get, _traderapi.CTORATstpRationalInfoField_UnderlyingSecurityName_set)
+
+ # 锟斤拷锟斤拷锟秸拷锟叫★拷锟斤拷锟�
+ MinVolume = property(_traderapi.CTORATstpRationalInfoField_MinVolume_get, _traderapi.CTORATstpRationalInfoField_MinVolume_set)
+
+ # 锟斤拷锟斤拷锟秸拷锟斤拷锟斤拷锟斤拷
+ MaxVolume = property(_traderapi.CTORATstpRationalInfoField_MaxVolume_get, _traderapi.CTORATstpRationalInfoField_MaxVolume_set)
+
+ # 锟斤拷锟斤拷锟秸拷锟轿伙拷锟斤拷锟�
+ VolumeUnit = property(_traderapi.CTORATstpRationalInfoField_VolumeUnit_get, _traderapi.CTORATstpRationalInfoField_VolumeUnit_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpRationalInfoField_swiginit(self, _traderapi.new_CTORATstpRationalInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpRationalInfoField
+
+# Register CTORATstpRationalInfoField in _traderapi:
+_traderapi.CTORATstpRationalInfoField_swigregister(CTORATstpRationalInfoField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷############################################
+class CTORATstpQryOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryOrderField_ExchangeID_get, _traderapi.CTORATstpQryOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryOrderField_InvestorID_get, _traderapi.CTORATstpQryOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryOrderField_BusinessUnitID_get, _traderapi.CTORATstpQryOrderField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryOrderField_SecurityID_get, _traderapi.CTORATstpQryOrderField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryOrderField_ShareholderID_get, _traderapi.CTORATstpQryOrderField_ShareholderID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpQryOrderField_OrderSysID_get, _traderapi.CTORATstpQryOrderField_OrderSysID_set)
+
+ # Insert Time
+ InsertTimeStart = property(_traderapi.CTORATstpQryOrderField_InsertTimeStart_get, _traderapi.CTORATstpQryOrderField_InsertTimeStart_set)
+
+ # Insert Time
+ InsertTimeEnd = property(_traderapi.CTORATstpQryOrderField_InsertTimeEnd_get, _traderapi.CTORATstpQryOrderField_InsertTimeEnd_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryOrderField_SInfo_get, _traderapi.CTORATstpQryOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryOrderField_IInfo_get, _traderapi.CTORATstpQryOrderField_IInfo_set)
+
+ # 锟角凤拷沙锟�
+ IsCancel = property(_traderapi.CTORATstpQryOrderField_IsCancel_get, _traderapi.CTORATstpQryOrderField_IsCancel_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryOrderField_swiginit(self, _traderapi.new_CTORATstpQryOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryOrderField
+
+# Register CTORATstpQryOrderField in _traderapi:
+_traderapi.CTORATstpQryOrderField_swigregister(CTORATstpQryOrderField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷############################################
+class CTORATstpQryOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryOrderActionField_ExchangeID_get, _traderapi.CTORATstpQryOrderActionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryOrderActionField_InvestorID_get, _traderapi.CTORATstpQryOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpQryOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryOrderActionField_ShareholderID_get, _traderapi.CTORATstpQryOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpQryOrderActionField_OrderLocalID_get, _traderapi.CTORATstpQryOrderActionField_OrderLocalID_set)
+
+ # 锟斤拷锟截筹拷锟斤拷锟斤拷锟�
+ CancelOrderLocalID = property(_traderapi.CTORATstpQryOrderActionField_CancelOrderLocalID_get, _traderapi.CTORATstpQryOrderActionField_CancelOrderLocalID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryOrderActionField_SInfo_get, _traderapi.CTORATstpQryOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryOrderActionField_IInfo_get, _traderapi.CTORATstpQryOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryOrderActionField_swiginit(self, _traderapi.new_CTORATstpQryOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryOrderActionField
+
+# Register CTORATstpQryOrderActionField in _traderapi:
+_traderapi.CTORATstpQryOrderActionField_swigregister(CTORATstpQryOrderActionField)
+
+
+
+
+#########################################锟斤拷锟斤拷############################################
+class CTORATstpOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpOrderActionField_ExchangeID_get, _traderapi.CTORATstpOrderActionField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpOrderActionField_FrontID_get, _traderapi.CTORATstpOrderActionField_FrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpOrderActionField_SessionID_get, _traderapi.CTORATstpOrderActionField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderRef = property(_traderapi.CTORATstpOrderActionField_OrderRef_get, _traderapi.CTORATstpOrderActionField_OrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷系统锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpOrderActionField_OrderSysID_get, _traderapi.CTORATstpOrderActionField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpOrderActionField_ActionFlag_get, _traderapi.CTORATstpOrderActionField_ActionFlag_set)
+
+ # 锟斤拷锟截筹拷锟斤拷锟斤拷锟�
+ CancelOrderLocalID = property(_traderapi.CTORATstpOrderActionField_CancelOrderLocalID_get, _traderapi.CTORATstpOrderActionField_CancelOrderLocalID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpOrderActionField_Operway_get, _traderapi.CTORATstpOrderActionField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpOrderActionField_SInfo_get, _traderapi.CTORATstpOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpOrderActionField_IInfo_get, _traderapi.CTORATstpOrderActionField_IInfo_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpOrderActionField_DepartmentID_get, _traderapi.CTORATstpOrderActionField_DepartmentID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpOrderActionField_InvestorID_get, _traderapi.CTORATstpOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpOrderActionField_ShareholderID_get, _traderapi.CTORATstpOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟截憋拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpOrderActionField_OrderLocalID_get, _traderapi.CTORATstpOrderActionField_OrderLocalID_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ ActionUser = property(_traderapi.CTORATstpOrderActionField_ActionUser_get, _traderapi.CTORATstpOrderActionField_ActionUser_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpOrderActionField_TradingDay_get, _traderapi.CTORATstpOrderActionField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ActionDate = property(_traderapi.CTORATstpOrderActionField_ActionDate_get, _traderapi.CTORATstpOrderActionField_ActionDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ ActionTime = property(_traderapi.CTORATstpOrderActionField_ActionTime_get, _traderapi.CTORATstpOrderActionField_ActionTime_set)
+
+ # 锟斤拷锟斤拷状态
+ CancelOrderStatus = property(_traderapi.CTORATstpOrderActionField_CancelOrderStatus_get, _traderapi.CTORATstpOrderActionField_CancelOrderStatus_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpOrderActionField_StatusMsg_get, _traderapi.CTORATstpOrderActionField_StatusMsg_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpOrderActionField_RequestID_get, _traderapi.CTORATstpOrderActionField_RequestID_set)
+
+ # 锟斤拷锟斤拷前锟矫憋拷锟�
+ ActionFrontID = property(_traderapi.CTORATstpOrderActionField_ActionFrontID_get, _traderapi.CTORATstpOrderActionField_ActionFrontID_set)
+
+ # 锟斤拷锟斤拷锟结话锟斤拷锟�
+ ActionSessionID = property(_traderapi.CTORATstpOrderActionField_ActionSessionID_get, _traderapi.CTORATstpOrderActionField_ActionSessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderActionRef = property(_traderapi.CTORATstpOrderActionField_OrderActionRef_get, _traderapi.CTORATstpOrderActionField_OrderActionRef_set)
+
+ # 锟斤拷锟截筹拷锟斤拷系统锟斤拷锟�
+ CancelOrderSysID = property(_traderapi.CTORATstpOrderActionField_CancelOrderSysID_get, _traderapi.CTORATstpOrderActionField_CancelOrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ CancelOrderType = property(_traderapi.CTORATstpOrderActionField_CancelOrderType_get, _traderapi.CTORATstpOrderActionField_CancelOrderType_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpOrderActionField_PbuID_get, _traderapi.CTORATstpOrderActionField_PbuID_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpOrderActionField_IPAddress_get, _traderapi.CTORATstpOrderActionField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpOrderActionField_MacAddress_get, _traderapi.CTORATstpOrderActionField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpOrderActionField_swiginit(self, _traderapi.new_CTORATstpOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpOrderActionField
+
+# Register CTORATstpOrderActionField in _traderapi:
+_traderapi.CTORATstpOrderActionField_swigregister(CTORATstpOrderActionField)
+
+
+
+
+#########################################锟斤拷询锟缴斤拷############################################
+class CTORATstpQryTradeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryTradeField_ExchangeID_get, _traderapi.CTORATstpQryTradeField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryTradeField_InvestorID_get, _traderapi.CTORATstpQryTradeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryTradeField_BusinessUnitID_get, _traderapi.CTORATstpQryTradeField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryTradeField_SecurityID_get, _traderapi.CTORATstpQryTradeField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryTradeField_ShareholderID_get, _traderapi.CTORATstpQryTradeField_ShareholderID_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpQryTradeField_TradeID_get, _traderapi.CTORATstpQryTradeField_TradeID_set)
+
+ # Insert Time
+ TradeTimeStart = property(_traderapi.CTORATstpQryTradeField_TradeTimeStart_get, _traderapi.CTORATstpQryTradeField_TradeTimeStart_set)
+
+ # Insert Time
+ TradeTimeEnd = property(_traderapi.CTORATstpQryTradeField_TradeTimeEnd_get, _traderapi.CTORATstpQryTradeField_TradeTimeEnd_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryTradeField_swiginit(self, _traderapi.new_CTORATstpQryTradeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryTradeField
+
+# Register CTORATstpQryTradeField in _traderapi:
+_traderapi.CTORATstpQryTradeField_swigregister(CTORATstpQryTradeField)
+
+
+
+
+#########################################锟斤拷询锟绞斤拷锟剿伙拷############################################
+class CTORATstpQryTradingAccountField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryTradingAccountField_InvestorID_get, _traderapi.CTORATstpQryTradingAccountField_InvestorID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpQryTradingAccountField_CurrencyID_get, _traderapi.CTORATstpQryTradingAccountField_CurrencyID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpQryTradingAccountField_AccountID_get, _traderapi.CTORATstpQryTradingAccountField_AccountID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountType = property(_traderapi.CTORATstpQryTradingAccountField_AccountType_get, _traderapi.CTORATstpQryTradingAccountField_AccountType_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpQryTradingAccountField_DepartmentID_get, _traderapi.CTORATstpQryTradingAccountField_DepartmentID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryTradingAccountField_swiginit(self, _traderapi.new_CTORATstpQryTradingAccountField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryTradingAccountField
+
+# Register CTORATstpQryTradingAccountField in _traderapi:
+_traderapi.CTORATstpQryTradingAccountField_swigregister(CTORATstpQryTradingAccountField)
+
+
+
+
+#########################################锟绞斤拷锟剿伙拷############################################
+class CTORATstpTradingAccountField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpTradingAccountField_DepartmentID_get, _traderapi.CTORATstpTradingAccountField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpTradingAccountField_AccountID_get, _traderapi.CTORATstpTradingAccountField_AccountID_set)
+
+ # 锟斤拷锟街达拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpTradingAccountField_CurrencyID_get, _traderapi.CTORATstpTradingAccountField_CurrencyID_set)
+
+ # 锟斤拷锟秸斤拷锟�
+ PreDeposit = property(_traderapi.CTORATstpTradingAccountField_PreDeposit_get, _traderapi.CTORATstpTradingAccountField_PreDeposit_set)
+
+ # 锟斤拷锟斤拷锟绞斤拷
+ UsefulMoney = property(_traderapi.CTORATstpTradingAccountField_UsefulMoney_get, _traderapi.CTORATstpTradingAccountField_UsefulMoney_set)
+
+ # 锟斤拷取锟绞斤拷
+ FetchLimit = property(_traderapi.CTORATstpTradingAccountField_FetchLimit_get, _traderapi.CTORATstpTradingAccountField_FetchLimit_set)
+
+ # 锟斤拷锟斤拷未锟斤拷锟秸斤拷锟�(锟桔癸拷通专锟斤拷锟街讹拷)
+ PreUnDeliveredMoney = property(_traderapi.CTORATstpTradingAccountField_PreUnDeliveredMoney_get, _traderapi.CTORATstpTradingAccountField_PreUnDeliveredMoney_set)
+
+ # 锟斤拷锟斤拷未锟斤拷锟秸斤拷锟�(锟桔癸拷通专锟斤拷锟街讹拷)
+ UnDeliveredMoney = property(_traderapi.CTORATstpTradingAccountField_UnDeliveredMoney_get, _traderapi.CTORATstpTradingAccountField_UnDeliveredMoney_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ Deposit = property(_traderapi.CTORATstpTradingAccountField_Deposit_get, _traderapi.CTORATstpTradingAccountField_Deposit_set)
+
+ # 锟斤拷锟秸筹拷锟斤拷锟斤拷
+ Withdraw = property(_traderapi.CTORATstpTradingAccountField_Withdraw_get, _traderapi.CTORATstpTradingAccountField_Withdraw_set)
+
+ # 锟斤拷锟斤拷锟斤拷式锟�(锟桔癸拷通锟斤拷锟街段诧拷锟斤拷锟斤拷未锟斤拷锟秸诧拷锟街讹拷锟斤拷锟绞斤拷)
+ FrozenCash = property(_traderapi.CTORATstpTradingAccountField_FrozenCash_get, _traderapi.CTORATstpTradingAccountField_FrozenCash_set)
+
+ # 锟斤拷锟斤拷未锟斤拷锟秸斤拷锟�(锟桔癸拷通专锟斤拷)
+ UnDeliveredFrozenCash = property(_traderapi.CTORATstpTradingAccountField_UnDeliveredFrozenCash_get, _traderapi.CTORATstpTradingAccountField_UnDeliveredFrozenCash_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�(锟桔癸拷通锟斤拷锟街段诧拷锟斤拷锟斤拷未锟斤拷锟秸诧拷锟街讹拷锟斤拷锟斤拷锟斤拷锟斤拷)
+ FrozenCommission = property(_traderapi.CTORATstpTradingAccountField_FrozenCommission_get, _traderapi.CTORATstpTradingAccountField_FrozenCommission_set)
+
+ # 锟斤拷锟斤拷未锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷(锟桔癸拷通专锟斤拷)
+ UnDeliveredFrozenCommission = property(_traderapi.CTORATstpTradingAccountField_UnDeliveredFrozenCommission_get, _traderapi.CTORATstpTradingAccountField_UnDeliveredFrozenCommission_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷通锟斤拷锟街段诧拷锟斤拷锟斤拷未锟斤拷锟秸诧拷锟斤拷锟斤拷锟斤拷锟斤拷)
+ Commission = property(_traderapi.CTORATstpTradingAccountField_Commission_get, _traderapi.CTORATstpTradingAccountField_Commission_set)
+
+ # 占锟斤拷未锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷(锟桔癸拷通专锟斤拷)
+ UnDeliveredCommission = property(_traderapi.CTORATstpTradingAccountField_UnDeliveredCommission_get, _traderapi.CTORATstpTradingAccountField_UnDeliveredCommission_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountType = property(_traderapi.CTORATstpTradingAccountField_AccountType_get, _traderapi.CTORATstpTradingAccountField_AccountType_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpTradingAccountField_InvestorID_get, _traderapi.CTORATstpTradingAccountField_InvestorID_set)
+
+ # 锟斤拷锟叫达拷锟斤拷
+ BankID = property(_traderapi.CTORATstpTradingAccountField_BankID_get, _traderapi.CTORATstpTradingAccountField_BankID_set)
+
+ # 锟斤拷锟斤拷锟剿伙拷
+ BankAccountID = property(_traderapi.CTORATstpTradingAccountField_BankAccountID_get, _traderapi.CTORATstpTradingAccountField_BankAccountID_set)
+
+ # 权锟斤拷锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ RoyaltyIn = property(_traderapi.CTORATstpTradingAccountField_RoyaltyIn_get, _traderapi.CTORATstpTradingAccountField_RoyaltyIn_set)
+
+ # 权锟斤拷锟斤拷支锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ RoyaltyOut = property(_traderapi.CTORATstpTradingAccountField_RoyaltyOut_get, _traderapi.CTORATstpTradingAccountField_RoyaltyOut_set)
+
+ # 锟斤拷券锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditSellAmount = property(_traderapi.CTORATstpTradingAccountField_CreditSellAmount_get, _traderapi.CTORATstpTradingAccountField_CreditSellAmount_set)
+
+ # 锟斤拷券锟斤拷锟斤拷使锟矫斤拷锟�(锟斤拷锟节筹拷锟斤拷锟斤拷锟绞革拷债锟斤拷锟斤拷锟斤拷锟斤拷品锟街的斤拷锟�)(锟斤拷锟斤拷专锟斤拷)
+ CreditSellUseAmount = property(_traderapi.CTORATstpTradingAccountField_CreditSellUseAmount_get, _traderapi.CTORATstpTradingAccountField_CreditSellUseAmount_set)
+
+ # 锟斤拷锟斤拷锟绞诧拷(锟斤拷锟斤拷专锟斤拷)
+ VirtualAssets = property(_traderapi.CTORATstpTradingAccountField_VirtualAssets_get, _traderapi.CTORATstpTradingAccountField_VirtualAssets_set)
+
+ # 锟斤拷券锟斤拷锟斤拷锟斤拷疃筹拷锟�(锟斤拷锟节筹拷锟斤拷锟斤拷锟绞革拷债锟斤拷锟斤拷锟斤拷锟斤拷品锟街碉拷未锟缴斤拷锟斤拷锟斤拷锟斤拷)(锟斤拷锟斤拷专锟斤拷)
+ CreditSellFrozenAmount = property(_traderapi.CTORATstpTradingAccountField_CreditSellFrozenAmount_get, _traderapi.CTORATstpTradingAccountField_CreditSellFrozenAmount_set)
+
+ # 锟斤拷锟斤拷锟斤拷元
+ OwnerUnit = property(_traderapi.CTORATstpTradingAccountField_OwnerUnit_get, _traderapi.CTORATstpTradingAccountField_OwnerUnit_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTradingAccountField_swiginit(self, _traderapi.new_CTORATstpTradingAccountField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTradingAccountField
+
+# Register CTORATstpTradingAccountField in _traderapi:
+_traderapi.CTORATstpTradingAccountField_swigregister(CTORATstpTradingAccountField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟竭持诧拷############################################
+class CTORATstpQryPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPositionField_ExchangeID_get, _traderapi.CTORATstpQryPositionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPositionField_InvestorID_get, _traderapi.CTORATstpQryPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryPositionField_BusinessUnitID_get, _traderapi.CTORATstpQryPositionField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPositionField_SecurityID_get, _traderapi.CTORATstpQryPositionField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryPositionField_ShareholderID_get, _traderapi.CTORATstpQryPositionField_ShareholderID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPositionField_swiginit(self, _traderapi.new_CTORATstpQryPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPositionField
+
+# Register CTORATstpQryPositionField in _traderapi:
+_traderapi.CTORATstpQryPositionField_swigregister(CTORATstpQryPositionField)
+
+
+
+
+#########################################投锟斤拷锟竭持诧拷############################################
+class CTORATstpPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPositionField_ExchangeID_get, _traderapi.CTORATstpPositionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPositionField_InvestorID_get, _traderapi.CTORATstpPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPositionField_BusinessUnitID_get, _traderapi.CTORATstpPositionField_BusinessUnitID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPositionField_MarketID_get, _traderapi.CTORATstpPositionField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPositionField_ShareholderID_get, _traderapi.CTORATstpPositionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpPositionField_TradingDay_get, _traderapi.CTORATstpPositionField_TradingDay_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPositionField_SecurityID_get, _traderapi.CTORATstpPositionField_SecurityID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpPositionField_SecurityName_get, _traderapi.CTORATstpPositionField_SecurityName_set)
+
+ # 锟斤拷锟�
+ HistoryPos = property(_traderapi.CTORATstpPositionField_HistoryPos_get, _traderapi.CTORATstpPositionField_HistoryPos_set)
+
+ # 锟斤拷侄锟斤拷锟�
+ HistoryPosFrozen = property(_traderapi.CTORATstpPositionField_HistoryPosFrozen_get, _traderapi.CTORATstpPositionField_HistoryPosFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ TodayBSPos = property(_traderapi.CTORATstpPositionField_TodayBSPos_get, _traderapi.CTORATstpPositionField_TodayBSPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟街讹拷锟斤拷
+ TodayBSPosFrozen = property(_traderapi.CTORATstpPositionField_TodayBSPosFrozen_get, _traderapi.CTORATstpPositionField_TodayBSPosFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷植锟�
+ TodayPRPos = property(_traderapi.CTORATstpPositionField_TodayPRPos_get, _traderapi.CTORATstpPositionField_TodayPRPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷植侄锟斤拷锟�
+ TodayPRPosFrozen = property(_traderapi.CTORATstpPositionField_TodayPRPosFrozen_get, _traderapi.CTORATstpPositionField_TodayPRPosFrozen_set)
+
+ # 锟斤拷锟街合诧拷锟街诧拷
+ TodaySMPos = property(_traderapi.CTORATstpPositionField_TodaySMPos_get, _traderapi.CTORATstpPositionField_TodaySMPos_set)
+
+ # 锟斤拷锟街合诧拷锟街仓讹拷锟斤拷
+ TodaySMPosFrozen = property(_traderapi.CTORATstpPositionField_TodaySMPosFrozen_get, _traderapi.CTORATstpPositionField_TodaySMPosFrozen_set)
+
+ # 锟斤拷殖杀锟斤拷锟�
+ HistoryPosPrice = property(_traderapi.CTORATstpPositionField_HistoryPosPrice_get, _traderapi.CTORATstpPositionField_HistoryPosPrice_set)
+
+ # 锟街仓成憋拷
+ TotalPosCost = property(_traderapi.CTORATstpPositionField_TotalPosCost_get, _traderapi.CTORATstpPositionField_TotalPosCost_set)
+
+ # 锟较达拷锟斤拷锟�(锟斤拷锟叫诧拷锟斤拷)
+ PrePosition = property(_traderapi.CTORATstpPositionField_PrePosition_get, _traderapi.CTORATstpPositionField_PrePosition_set)
+
+ # 锟缴份匡拷锟斤拷
+ AvailablePosition = property(_traderapi.CTORATstpPositionField_AvailablePosition_get, _traderapi.CTORATstpPositionField_AvailablePosition_set)
+
+ # 锟缴凤拷锟斤拷锟�
+ CurrentPosition = property(_traderapi.CTORATstpPositionField_CurrentPosition_get, _traderapi.CTORATstpPositionField_CurrentPosition_set)
+
+ # 锟斤拷锟街成憋拷
+ OpenPosCost = property(_traderapi.CTORATstpPositionField_OpenPosCost_get, _traderapi.CTORATstpPositionField_OpenPosCost_set)
+
+ # 锟斤拷锟绞诧拷位(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyPos = property(_traderapi.CTORATstpPositionField_CreditBuyPos_get, _traderapi.CTORATstpPositionField_CreditBuyPos_set)
+
+ # 锟斤拷券锟斤拷位(锟斤拷锟斤拷专锟斤拷)
+ CreditSellPos = property(_traderapi.CTORATstpPositionField_CreditSellPos_get, _traderapi.CTORATstpPositionField_CreditSellPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷券锟斤拷位(锟斤拷锟斤拷专锟斤拷)
+ TodayCreditSellPos = property(_traderapi.CTORATstpPositionField_TodayCreditSellPos_get, _traderapi.CTORATstpPositionField_TodayCreditSellPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷位(锟斤拷锟斤拷专锟斤拷)
+ CollateralOutPos = property(_traderapi.CTORATstpPositionField_CollateralOutPos_get, _traderapi.CTORATstpPositionField_CollateralOutPos_set)
+
+ # 锟斤拷券未锟缴斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ RepayUntradeVolume = property(_traderapi.CTORATstpPositionField_RepayUntradeVolume_get, _traderapi.CTORATstpPositionField_RepayUntradeVolume_set)
+
+ # 直锟接伙拷券未锟缴斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ RepayTransferUntradeVolume = property(_traderapi.CTORATstpPositionField_RepayTransferUntradeVolume_get, _traderapi.CTORATstpPositionField_RepayTransferUntradeVolume_set)
+
+ # 锟斤拷锟斤拷品锟斤拷锟斤拷未锟缴斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CollateralBuyUntradeAmount = property(_traderapi.CTORATstpPositionField_CollateralBuyUntradeAmount_get, _traderapi.CTORATstpPositionField_CollateralBuyUntradeAmount_set)
+
+ # 锟斤拷锟斤拷品锟斤拷锟斤拷未锟缴斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CollateralBuyUntradeVolume = property(_traderapi.CTORATstpPositionField_CollateralBuyUntradeVolume_get, _traderapi.CTORATstpPositionField_CollateralBuyUntradeVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷)(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyAmount = property(_traderapi.CTORATstpPositionField_CreditBuyAmount_get, _traderapi.CTORATstpPositionField_CreditBuyAmount_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷未锟缴斤拷锟斤拷锟�(锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷)(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyUntradeAmount = property(_traderapi.CTORATstpPositionField_CreditBuyUntradeAmount_get, _traderapi.CTORATstpPositionField_CreditBuyUntradeAmount_set)
+
+ # 锟斤拷锟绞讹拷锟结保证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyFrozenMargin = property(_traderapi.CTORATstpPositionField_CreditBuyFrozenMargin_get, _traderapi.CTORATstpPositionField_CreditBuyFrozenMargin_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷息(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyInterestFee = property(_traderapi.CTORATstpPositionField_CreditBuyInterestFee_get, _traderapi.CTORATstpPositionField_CreditBuyInterestFee_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷未锟缴斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyUntradeVolume = property(_traderapi.CTORATstpPositionField_CreditBuyUntradeVolume_get, _traderapi.CTORATstpPositionField_CreditBuyUntradeVolume_set)
+
+ # 锟斤拷券锟斤拷锟斤拷锟斤拷锟�(锟皆成斤拷锟桔硷拷锟斤拷)(锟斤拷锟斤拷专锟斤拷)
+ CreditSellAmount = property(_traderapi.CTORATstpPositionField_CreditSellAmount_get, _traderapi.CTORATstpPositionField_CreditSellAmount_set)
+
+ # 锟斤拷券锟斤拷锟斤拷未锟缴斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditSellUntradeAmount = property(_traderapi.CTORATstpPositionField_CreditSellUntradeAmount_get, _traderapi.CTORATstpPositionField_CreditSellUntradeAmount_set)
+
+ # 锟斤拷券锟斤拷锟结保证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditSellFrozenMargin = property(_traderapi.CTORATstpPositionField_CreditSellFrozenMargin_get, _traderapi.CTORATstpPositionField_CreditSellFrozenMargin_set)
+
+ # 锟斤拷券锟斤拷锟斤拷息锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditSellInterestFee = property(_traderapi.CTORATstpPositionField_CreditSellInterestFee_get, _traderapi.CTORATstpPositionField_CreditSellInterestFee_set)
+
+ # 锟斤拷券锟斤拷锟斤拷未锟缴斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditSellUntradeVolume = property(_traderapi.CTORATstpPositionField_CreditSellUntradeVolume_get, _traderapi.CTORATstpPositionField_CreditSellUntradeVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷詹锟�(锟斤拷锟斤拷专锟斤拷)
+ CollateralInPos = property(_traderapi.CTORATstpPositionField_CollateralInPos_get, _traderapi.CTORATstpPositionField_CollateralInPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟结保证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditBuyFrozenCirculateMargin = property(_traderapi.CTORATstpPositionField_CreditBuyFrozenCirculateMargin_get, _traderapi.CTORATstpPositionField_CreditBuyFrozenCirculateMargin_set)
+
+ # 锟斤拷券锟斤拷锟斤拷锟斤拷锟结保证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CreditSellFrozenCirculateMargin = property(_traderapi.CTORATstpPositionField_CreditSellFrozenCirculateMargin_get, _traderapi.CTORATstpPositionField_CreditSellFrozenCirculateMargin_set)
+
+ # 锟桔硷拷平锟斤拷盈锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CloseProfit = property(_traderapi.CTORATstpPositionField_CloseProfit_get, _traderapi.CTORATstpPositionField_CloseProfit_set)
+
+ # 锟斤拷锟斤拷锟桔计匡拷锟斤拷锟斤拷锟斤拷
+ TodayTotalOpenVolume = property(_traderapi.CTORATstpPositionField_TodayTotalOpenVolume_get, _traderapi.CTORATstpPositionField_TodayTotalOpenVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ TodayCommission = property(_traderapi.CTORATstpPositionField_TodayCommission_get, _traderapi.CTORATstpPositionField_TodayCommission_set)
+
+ # 锟斤拷锟斤拷锟桔硷拷锟斤拷锟斤拷锟斤拷
+ TodayTotalBuyAmount = property(_traderapi.CTORATstpPositionField_TodayTotalBuyAmount_get, _traderapi.CTORATstpPositionField_TodayTotalBuyAmount_set)
+
+ # 锟斤拷锟斤拷锟桔硷拷锟斤拷锟斤拷锟斤拷锟�
+ TodayTotalSellAmount = property(_traderapi.CTORATstpPositionField_TodayTotalSellAmount_get, _traderapi.CTORATstpPositionField_TodayTotalSellAmount_set)
+
+ # 锟斤拷锟秸讹拷锟斤拷(锟斤拷锟叫诧拷锟斤拷)
+ PreFrozen = property(_traderapi.CTORATstpPositionField_PreFrozen_get, _traderapi.CTORATstpPositionField_PreFrozen_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPositionField_swiginit(self, _traderapi.new_CTORATstpPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPositionField
+
+# Register CTORATstpPositionField in _traderapi:
+_traderapi.CTORATstpPositionField_swigregister(CTORATstpPositionField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷############################################
+class CTORATstpQryTradingFeeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryTradingFeeField_ExchangeID_get, _traderapi.CTORATstpQryTradingFeeField_ExchangeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryTradingFeeField_swiginit(self, _traderapi.new_CTORATstpQryTradingFeeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryTradingFeeField
+
+# Register CTORATstpQryTradingFeeField in _traderapi:
+_traderapi.CTORATstpQryTradingFeeField_swigregister(CTORATstpQryTradingFeeField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷############################################
+class CTORATstpTradingFeeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpTradingFeeField_ExchangeID_get, _traderapi.CTORATstpTradingFeeField_ExchangeID_set)
+
+ # 锟斤拷品锟斤拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpTradingFeeField_ProductID_get, _traderapi.CTORATstpTradingFeeField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpTradingFeeField_SecurityType_get, _traderapi.CTORATstpTradingFeeField_SecurityType_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpTradingFeeField_SecurityID_get, _traderapi.CTORATstpTradingFeeField_SecurityID_set)
+
+ # 业锟斤拷锟斤拷锟�
+ BizClass = property(_traderapi.CTORATstpTradingFeeField_BizClass_get, _traderapi.CTORATstpTradingFeeField_BizClass_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税)锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷锟�
+ StampTaxRatioByAmt = property(_traderapi.CTORATstpTradingFeeField_StampTaxRatioByAmt_get, _traderapi.CTORATstpTradingFeeField_StampTaxRatioByAmt_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税)锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ StampTaxRatioByPar = property(_traderapi.CTORATstpTradingFeeField_StampTaxRatioByPar_get, _traderapi.CTORATstpTradingFeeField_StampTaxRatioByPar_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ StampTaxFeePerOrder = property(_traderapi.CTORATstpTradingFeeField_StampTaxFeePerOrder_get, _traderapi.CTORATstpTradingFeeField_StampTaxFeePerOrder_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ StampTaxFeeByVolume = property(_traderapi.CTORATstpTradingFeeField_StampTaxFeeByVolume_get, _traderapi.CTORATstpTradingFeeField_StampTaxFeeByVolume_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ StampTaxFeeMin = property(_traderapi.CTORATstpTradingFeeField_StampTaxFeeMin_get, _traderapi.CTORATstpTradingFeeField_StampTaxFeeMin_set)
+
+ # 印锟斤拷税(锟桔癸拷印锟斤拷税,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ StampTaxFeeMax = property(_traderapi.CTORATstpTradingFeeField_StampTaxFeeMax_get, _traderapi.CTORATstpTradingFeeField_StampTaxFeeMax_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�)锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷锟�
+ TransferRatioByAmt = property(_traderapi.CTORATstpTradingFeeField_TransferRatioByAmt_get, _traderapi.CTORATstpTradingFeeField_TransferRatioByAmt_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�)锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ TransferRatioByPar = property(_traderapi.CTORATstpTradingFeeField_TransferRatioByPar_get, _traderapi.CTORATstpTradingFeeField_TransferRatioByPar_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ TransferFeePerOrder = property(_traderapi.CTORATstpTradingFeeField_TransferFeePerOrder_get, _traderapi.CTORATstpTradingFeeField_TransferFeePerOrder_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ TransferFeeByVolume = property(_traderapi.CTORATstpTradingFeeField_TransferFeeByVolume_get, _traderapi.CTORATstpTradingFeeField_TransferFeeByVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ TransferFeeMin = property(_traderapi.CTORATstpTradingFeeField_TransferFeeMin_get, _traderapi.CTORATstpTradingFeeField_TransferFeeMin_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷证券锟斤拷戏锟�,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ TransferFeeMax = property(_traderapi.CTORATstpTradingFeeField_TransferFeeMax_get, _traderapi.CTORATstpTradingFeeField_TransferFeeMax_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷)锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷锟�
+ HandlingRatioByAmt = property(_traderapi.CTORATstpTradingFeeField_HandlingRatioByAmt_get, _traderapi.CTORATstpTradingFeeField_HandlingRatioByAmt_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷)锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ HandlingRatioByPar = property(_traderapi.CTORATstpTradingFeeField_HandlingRatioByPar_get, _traderapi.CTORATstpTradingFeeField_HandlingRatioByPar_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ HandlingFeePerOrder = property(_traderapi.CTORATstpTradingFeeField_HandlingFeePerOrder_get, _traderapi.CTORATstpTradingFeeField_HandlingFeePerOrder_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ HandlingFeeByVolume = property(_traderapi.CTORATstpTradingFeeField_HandlingFeeByVolume_get, _traderapi.CTORATstpTradingFeeField_HandlingFeeByVolume_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ HandlingFeeMin = property(_traderapi.CTORATstpTradingFeeField_HandlingFeeMin_get, _traderapi.CTORATstpTradingFeeField_HandlingFeeMin_set)
+
+ # 锟斤拷锟街凤拷(锟桔股斤拷锟阶凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ HandlingFeeMax = property(_traderapi.CTORATstpTradingFeeField_HandlingFeeMax_get, _traderapi.CTORATstpTradingFeeField_HandlingFeeMax_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷)锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷锟�
+ RegulateRatioByAmt = property(_traderapi.CTORATstpTradingFeeField_RegulateRatioByAmt_get, _traderapi.CTORATstpTradingFeeField_RegulateRatioByAmt_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷)锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ RegulateRatioByPar = property(_traderapi.CTORATstpTradingFeeField_RegulateRatioByPar_get, _traderapi.CTORATstpTradingFeeField_RegulateRatioByPar_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ RegulateFeePerOrder = property(_traderapi.CTORATstpTradingFeeField_RegulateFeePerOrder_get, _traderapi.CTORATstpTradingFeeField_RegulateFeePerOrder_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ RegulateFeeByVolume = property(_traderapi.CTORATstpTradingFeeField_RegulateFeeByVolume_get, _traderapi.CTORATstpTradingFeeField_RegulateFeeByVolume_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ RegulateFeeMin = property(_traderapi.CTORATstpTradingFeeField_RegulateFeeMin_get, _traderapi.CTORATstpTradingFeeField_RegulateFeeMin_set)
+
+ # 证锟杰凤拷(锟桔股斤拷锟斤拷锟斤拷锟斤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ RegulateFeeMax = property(_traderapi.CTORATstpTradingFeeField_RegulateFeeMax_get, _traderapi.CTORATstpTradingFeeField_RegulateFeeMax_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷)锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷锟�
+ SettlementRatioByAmt = property(_traderapi.CTORATstpTradingFeeField_SettlementRatioByAmt_get, _traderapi.CTORATstpTradingFeeField_SettlementRatioByAmt_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷)锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ SettlementRatioByPar = property(_traderapi.CTORATstpTradingFeeField_SettlementRatioByPar_get, _traderapi.CTORATstpTradingFeeField_SettlementRatioByPar_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ SettlementFeePerOrder = property(_traderapi.CTORATstpTradingFeeField_SettlementFeePerOrder_get, _traderapi.CTORATstpTradingFeeField_SettlementFeePerOrder_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ SettlementFeeByVolume = property(_traderapi.CTORATstpTradingFeeField_SettlementFeeByVolume_get, _traderapi.CTORATstpTradingFeeField_SettlementFeeByVolume_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ SettlementFeeMin = property(_traderapi.CTORATstpTradingFeeField_SettlementFeeMin_get, _traderapi.CTORATstpTradingFeeField_SettlementFeeMin_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔股股份斤拷锟秸凤拷,锟斤拷位锟桔憋拷)锟斤拷锟斤拷锟饺★拷锟斤拷
+ SettlementFeeMax = property(_traderapi.CTORATstpTradingFeeField_SettlementFeeMax_get, _traderapi.CTORATstpTradingFeeField_SettlementFeeMax_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpTradingFeeField_swiginit(self, _traderapi.new_CTORATstpTradingFeeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpTradingFeeField
+
+# Register CTORATstpTradingFeeField in _traderapi:
+_traderapi.CTORATstpTradingFeeField_swigregister(CTORATstpTradingFeeField)
+
+
+
+
+#########################################锟斤拷询佣锟斤拷锟斤拷锟�############################################
+class CTORATstpQryInvestorTradingFeeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryInvestorTradingFeeField_InvestorID_get, _traderapi.CTORATstpQryInvestorTradingFeeField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryInvestorTradingFeeField_ExchangeID_get, _traderapi.CTORATstpQryInvestorTradingFeeField_ExchangeID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpQryInvestorTradingFeeField_DepartmentID_get, _traderapi.CTORATstpQryInvestorTradingFeeField_DepartmentID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryInvestorTradingFeeField_swiginit(self, _traderapi.new_CTORATstpQryInvestorTradingFeeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryInvestorTradingFeeField
+
+# Register CTORATstpQryInvestorTradingFeeField in _traderapi:
+_traderapi.CTORATstpQryInvestorTradingFeeField_swigregister(CTORATstpQryInvestorTradingFeeField)
+
+
+
+
+#########################################佣锟斤拷锟斤拷锟�############################################
+class CTORATstpInvestorTradingFeeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInvestorTradingFeeField_InvestorID_get, _traderapi.CTORATstpInvestorTradingFeeField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInvestorTradingFeeField_ExchangeID_get, _traderapi.CTORATstpInvestorTradingFeeField_ExchangeID_set)
+
+ # 锟斤拷品锟斤拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpInvestorTradingFeeField_ProductID_get, _traderapi.CTORATstpInvestorTradingFeeField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpInvestorTradingFeeField_SecurityType_get, _traderapi.CTORATstpInvestorTradingFeeField_SecurityType_set)
+
+ # 锟斤拷约锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInvestorTradingFeeField_SecurityID_get, _traderapi.CTORATstpInvestorTradingFeeField_SecurityID_set)
+
+ # 业锟斤拷锟斤拷锟�
+ BizClass = property(_traderapi.CTORATstpInvestorTradingFeeField_BizClass_get, _traderapi.CTORATstpInvestorTradingFeeField_BizClass_set)
+
+ # 佣锟斤拷锟斤拷锟斤拷
+ BrokerageType = property(_traderapi.CTORATstpInvestorTradingFeeField_BrokerageType_get, _traderapi.CTORATstpInvestorTradingFeeField_BrokerageType_set)
+
+ # 佣锟金按斤拷锟斤拷锟饺★拷锟斤拷锟�
+ RatioByAmt = property(_traderapi.CTORATstpInvestorTradingFeeField_RatioByAmt_get, _traderapi.CTORATstpInvestorTradingFeeField_RatioByAmt_set)
+
+ # 佣锟斤拷锟斤拷值锟斤拷取锟斤拷锟斤拷
+ RatioByPar = property(_traderapi.CTORATstpInvestorTradingFeeField_RatioByPar_get, _traderapi.CTORATstpInvestorTradingFeeField_RatioByPar_set)
+
+ # 佣锟金按憋拷锟斤拷取锟斤拷锟�
+ FeePerOrder = property(_traderapi.CTORATstpInvestorTradingFeeField_FeePerOrder_get, _traderapi.CTORATstpInvestorTradingFeeField_FeePerOrder_set)
+
+ # 佣锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷
+ FeeMin = property(_traderapi.CTORATstpInvestorTradingFeeField_FeeMin_get, _traderapi.CTORATstpInvestorTradingFeeField_FeeMin_set)
+
+ # 佣锟斤拷锟斤拷锟斤拷锟饺★拷锟斤拷
+ FeeMax = property(_traderapi.CTORATstpInvestorTradingFeeField_FeeMax_get, _traderapi.CTORATstpInvestorTradingFeeField_FeeMax_set)
+
+ # 佣锟斤拷锟斤拷锟斤拷锟斤拷取锟斤拷锟�
+ FeeByVolume = property(_traderapi.CTORATstpInvestorTradingFeeField_FeeByVolume_get, _traderapi.CTORATstpInvestorTradingFeeField_FeeByVolume_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpInvestorTradingFeeField_DepartmentID_get, _traderapi.CTORATstpInvestorTradingFeeField_DepartmentID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OrderType = property(_traderapi.CTORATstpInvestorTradingFeeField_OrderType_get, _traderapi.CTORATstpInvestorTradingFeeField_OrderType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInvestorTradingFeeField_swiginit(self, _traderapi.new_CTORATstpInvestorTradingFeeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInvestorTradingFeeField
+
+# Register CTORATstpInvestorTradingFeeField in _traderapi:
+_traderapi.CTORATstpInvestorTradingFeeField_swigregister(CTORATstpInvestorTradingFeeField)
+
+
+
+
+#########################################锟斤拷询锟铰癸拷锟疥购锟斤拷锟�############################################
+class CTORATstpQryIPOQuotaField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryIPOQuotaField_InvestorID_get, _traderapi.CTORATstpQryIPOQuotaField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryIPOQuotaField_ExchangeID_get, _traderapi.CTORATstpQryIPOQuotaField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryIPOQuotaField_MarketID_get, _traderapi.CTORATstpQryIPOQuotaField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryIPOQuotaField_ShareholderID_get, _traderapi.CTORATstpQryIPOQuotaField_ShareholderID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryIPOQuotaField_swiginit(self, _traderapi.new_CTORATstpQryIPOQuotaField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryIPOQuotaField
+
+# Register CTORATstpQryIPOQuotaField in _traderapi:
+_traderapi.CTORATstpQryIPOQuotaField_swigregister(CTORATstpQryIPOQuotaField)
+
+
+
+
+#########################################锟铰癸拷锟疥购锟斤拷锟�############################################
+class CTORATstpIPOQuotaField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpIPOQuotaField_InvestorID_get, _traderapi.CTORATstpIPOQuotaField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpIPOQuotaField_ExchangeID_get, _traderapi.CTORATstpIPOQuotaField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpIPOQuotaField_MarketID_get, _traderapi.CTORATstpIPOQuotaField_MarketID_set)
+
+ # 锟酵伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpIPOQuotaField_ShareholderID_get, _traderapi.CTORATstpIPOQuotaField_ShareholderID_set)
+
+ # 锟斤拷锟疥购锟斤拷锟�
+ MaxVolume = property(_traderapi.CTORATstpIPOQuotaField_MaxVolume_get, _traderapi.CTORATstpIPOQuotaField_MaxVolume_set)
+
+ # 锟狡达拷锟斤拷锟斤拷旯猴拷锟斤拷
+ KCMaxVolume = property(_traderapi.CTORATstpIPOQuotaField_KCMaxVolume_get, _traderapi.CTORATstpIPOQuotaField_KCMaxVolume_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpIPOQuotaField_swiginit(self, _traderapi.new_CTORATstpIPOQuotaField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpIPOQuotaField
+
+# Register CTORATstpIPOQuotaField in _traderapi:
+_traderapi.CTORATstpIPOQuotaField_swigregister(CTORATstpIPOQuotaField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟斤拷细锟绞斤拷############################################
+class CTORATstpQryOrderFundDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryOrderFundDetailField_ExchangeID_get, _traderapi.CTORATstpQryOrderFundDetailField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryOrderFundDetailField_InvestorID_get, _traderapi.CTORATstpQryOrderFundDetailField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryOrderFundDetailField_BusinessUnitID_get, _traderapi.CTORATstpQryOrderFundDetailField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryOrderFundDetailField_SecurityID_get, _traderapi.CTORATstpQryOrderFundDetailField_SecurityID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpQryOrderFundDetailField_OrderSysID_get, _traderapi.CTORATstpQryOrderFundDetailField_OrderSysID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryOrderFundDetailField_swiginit(self, _traderapi.new_CTORATstpQryOrderFundDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryOrderFundDetailField
+
+# Register CTORATstpQryOrderFundDetailField in _traderapi:
+_traderapi.CTORATstpQryOrderFundDetailField_swigregister(CTORATstpQryOrderFundDetailField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷细锟绞斤拷############################################
+class CTORATstpOrderFundDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpOrderFundDetailField_InvestorID_get, _traderapi.CTORATstpOrderFundDetailField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpOrderFundDetailField_SecurityID_get, _traderapi.CTORATstpOrderFundDetailField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpOrderFundDetailField_ExchangeID_get, _traderapi.CTORATstpOrderFundDetailField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpOrderFundDetailField_TradingDay_get, _traderapi.CTORATstpOrderFundDetailField_TradingDay_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpOrderFundDetailField_OrderSysID_get, _traderapi.CTORATstpOrderFundDetailField_OrderSysID_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpOrderFundDetailField_PbuID_get, _traderapi.CTORATstpOrderFundDetailField_PbuID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpOrderFundDetailField_OrderLocalID_get, _traderapi.CTORATstpOrderFundDetailField_OrderLocalID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpOrderFundDetailField_BusinessUnitID_get, _traderapi.CTORATstpOrderFundDetailField_BusinessUnitID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpOrderFundDetailField_AccountID_get, _traderapi.CTORATstpOrderFundDetailField_AccountID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ OrderAmount = property(_traderapi.CTORATstpOrderFundDetailField_OrderAmount_get, _traderapi.CTORATstpOrderFundDetailField_OrderAmount_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ Turnover = property(_traderapi.CTORATstpOrderFundDetailField_Turnover_get, _traderapi.CTORATstpOrderFundDetailField_Turnover_set)
+
+ # 印锟斤拷税(锟桔癸拷为印锟斤拷税)
+ StampTaxFee = property(_traderapi.CTORATstpOrderFundDetailField_StampTaxFee_get, _traderapi.CTORATstpOrderFundDetailField_StampTaxFee_set)
+
+ # 锟斤拷锟街凤拷(锟桔癸拷为锟斤拷锟阶凤拷)
+ HandlingFee = property(_traderapi.CTORATstpOrderFundDetailField_HandlingFee_get, _traderapi.CTORATstpOrderFundDetailField_HandlingFee_set)
+
+ # 锟斤拷锟斤拷锟斤拷(锟桔癸拷为证券锟斤拷戏锟�)
+ TransferFee = property(_traderapi.CTORATstpOrderFundDetailField_TransferFee_get, _traderapi.CTORATstpOrderFundDetailField_TransferFee_set)
+
+ # 证锟杰凤拷(锟桔癸拷为锟斤拷锟斤拷锟斤拷锟斤拷)
+ RegulateFee = property(_traderapi.CTORATstpOrderFundDetailField_RegulateFee_get, _traderapi.CTORATstpOrderFundDetailField_RegulateFee_set)
+
+ # 锟斤拷锟斤拷锟�(锟桔癸拷为锟缴份斤拷锟秸凤拷)
+ SettlementFee = property(_traderapi.CTORATstpOrderFundDetailField_SettlementFee_get, _traderapi.CTORATstpOrderFundDetailField_SettlementFee_set)
+
+ # 佣锟斤拷
+ BrokerageFee = property(_traderapi.CTORATstpOrderFundDetailField_BrokerageFee_get, _traderapi.CTORATstpOrderFundDetailField_BrokerageFee_set)
+
+ # 锟杰凤拷锟斤拷
+ TotalFee = property(_traderapi.CTORATstpOrderFundDetailField_TotalFee_get, _traderapi.CTORATstpOrderFundDetailField_TotalFee_set)
+
+ # 锟斤拷锟斤拷锟斤拷始锟斤拷锟斤拷锟斤拷
+ OrderCashFrozen = property(_traderapi.CTORATstpOrderFundDetailField_OrderCashFrozen_get, _traderapi.CTORATstpOrderFundDetailField_OrderCashFrozen_set)
+
+ # 预锟斤拷锟斤拷锟斤拷锟街斤拷
+ EstimateCashFrozen = property(_traderapi.CTORATstpOrderFundDetailField_EstimateCashFrozen_get, _traderapi.CTORATstpOrderFundDetailField_EstimateCashFrozen_set)
+
+ # 锟斤拷始锟斤拷锟斤拷锟杰凤拷锟斤拷
+ TotalFeeFrozen = property(_traderapi.CTORATstpOrderFundDetailField_TotalFeeFrozen_get, _traderapi.CTORATstpOrderFundDetailField_TotalFeeFrozen_set)
+
+ # 锟斤拷始锟斤拷锟斤拷锟斤拷霞锟�
+ TotalFrozen = property(_traderapi.CTORATstpOrderFundDetailField_TotalFrozen_get, _traderapi.CTORATstpOrderFundDetailField_TotalFrozen_set)
+
+ # 锟斤拷证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ Margin = property(_traderapi.CTORATstpOrderFundDetailField_Margin_get, _traderapi.CTORATstpOrderFundDetailField_Margin_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ RepayAmount = property(_traderapi.CTORATstpOrderFundDetailField_RepayAmount_get, _traderapi.CTORATstpOrderFundDetailField_RepayAmount_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ RepayVolume = property(_traderapi.CTORATstpOrderFundDetailField_RepayVolume_get, _traderapi.CTORATstpOrderFundDetailField_RepayVolume_set)
+
+ # 锟斤拷始锟斤拷锟结保证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ MarginFrozen = property(_traderapi.CTORATstpOrderFundDetailField_MarginFrozen_get, _traderapi.CTORATstpOrderFundDetailField_MarginFrozen_set)
+
+ # 锟斤拷始锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷证锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ CirculateMarginFrozen = property(_traderapi.CTORATstpOrderFundDetailField_CirculateMarginFrozen_get, _traderapi.CTORATstpOrderFundDetailField_CirculateMarginFrozen_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpOrderFundDetailField_swiginit(self, _traderapi.new_CTORATstpOrderFundDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpOrderFundDetailField
+
+# Register CTORATstpOrderFundDetailField in _traderapi:
+_traderapi.CTORATstpOrderFundDetailField_swigregister(CTORATstpOrderFundDetailField)
+
+
+
+
+#########################################锟斤拷询锟绞斤拷转锟斤拷锟斤拷水############################################
+class CTORATstpQryFundTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpQryFundTransferDetailField_DepartmentID_get, _traderapi.CTORATstpQryFundTransferDetailField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpQryFundTransferDetailField_AccountID_get, _traderapi.CTORATstpQryFundTransferDetailField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpQryFundTransferDetailField_CurrencyID_get, _traderapi.CTORATstpQryFundTransferDetailField_CurrencyID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryFundTransferDetailField_InvestorID_get, _traderapi.CTORATstpQryFundTransferDetailField_InvestorID_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpQryFundTransferDetailField_TransferDirection_get, _traderapi.CTORATstpQryFundTransferDetailField_TransferDirection_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryFundTransferDetailField_swiginit(self, _traderapi.new_CTORATstpQryFundTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryFundTransferDetailField
+
+# Register CTORATstpQryFundTransferDetailField in _traderapi:
+_traderapi.CTORATstpQryFundTransferDetailField_swigregister(CTORATstpQryFundTransferDetailField)
+
+
+
+
+#########################################锟绞斤拷转锟斤拷锟斤拷水############################################
+class CTORATstpFundTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 转锟斤拷锟斤拷水锟斤拷
+ FundSerial = property(_traderapi.CTORATstpFundTransferDetailField_FundSerial_get, _traderapi.CTORATstpFundTransferDetailField_FundSerial_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpFundTransferDetailField_ApplySerial_get, _traderapi.CTORATstpFundTransferDetailField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpFundTransferDetailField_FrontID_get, _traderapi.CTORATstpFundTransferDetailField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpFundTransferDetailField_SessionID_get, _traderapi.CTORATstpFundTransferDetailField_SessionID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpFundTransferDetailField_AccountID_get, _traderapi.CTORATstpFundTransferDetailField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpFundTransferDetailField_CurrencyID_get, _traderapi.CTORATstpFundTransferDetailField_CurrencyID_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpFundTransferDetailField_TransferDirection_get, _traderapi.CTORATstpFundTransferDetailField_TransferDirection_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ Amount = property(_traderapi.CTORATstpFundTransferDetailField_Amount_get, _traderapi.CTORATstpFundTransferDetailField_Amount_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpFundTransferDetailField_TransferStatus_get, _traderapi.CTORATstpFundTransferDetailField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷源
+ OperateSource = property(_traderapi.CTORATstpFundTransferDetailField_OperateSource_get, _traderapi.CTORATstpFundTransferDetailField_OperateSource_set)
+
+ # 锟斤拷锟斤拷锟斤拷员
+ OperatorID = property(_traderapi.CTORATstpFundTransferDetailField_OperatorID_get, _traderapi.CTORATstpFundTransferDetailField_OperatorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpFundTransferDetailField_OperateDate_get, _traderapi.CTORATstpFundTransferDetailField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpFundTransferDetailField_OperateTime_get, _traderapi.CTORATstpFundTransferDetailField_OperateTime_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpFundTransferDetailField_StatusMsg_get, _traderapi.CTORATstpFundTransferDetailField_StatusMsg_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpFundTransferDetailField_DepartmentID_get, _traderapi.CTORATstpFundTransferDetailField_DepartmentID_set)
+
+ # 锟斤拷锟叫达拷锟斤拷
+ BankID = property(_traderapi.CTORATstpFundTransferDetailField_BankID_get, _traderapi.CTORATstpFundTransferDetailField_BankID_set)
+
+ # 签约锟斤拷锟斤拷锟剿伙拷
+ BankAccountID = property(_traderapi.CTORATstpFundTransferDetailField_BankAccountID_get, _traderapi.CTORATstpFundTransferDetailField_BankAccountID_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpFundTransferDetailField_IPAddress_get, _traderapi.CTORATstpFundTransferDetailField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpFundTransferDetailField_MacAddress_get, _traderapi.CTORATstpFundTransferDetailField_MacAddress_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpFundTransferDetailField_InvestorID_get, _traderapi.CTORATstpFundTransferDetailField_InvestorID_set)
+
+ # 锟解部锟斤拷水锟斤拷
+ ExternalSerial = property(_traderapi.CTORATstpFundTransferDetailField_ExternalSerial_get, _traderapi.CTORATstpFundTransferDetailField_ExternalSerial_set)
+
+ # 锟解部系统锟节碉拷锟�
+ ExternalNodeID = property(_traderapi.CTORATstpFundTransferDetailField_ExternalNodeID_get, _traderapi.CTORATstpFundTransferDetailField_ExternalNodeID_set)
+
+ # 强平原锟斤拷(锟斤拷锟斤拷专锟斤拷)
+ ForceCloseReason = property(_traderapi.CTORATstpFundTransferDetailField_ForceCloseReason_get, _traderapi.CTORATstpFundTransferDetailField_ForceCloseReason_set)
+
+ # (直锟接伙拷锟斤拷锟斤拷)指锟斤拷锟斤拷锟斤拷时锟侥革拷债锟斤拷锟�(锟斤拷锟斤拷专锟斤拷)
+ CreditDebtID = property(_traderapi.CTORATstpFundTransferDetailField_CreditDebtID_get, _traderapi.CTORATstpFundTransferDetailField_CreditDebtID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpFundTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpFundTransferDetailField_BusinessUnitID_set)
+
+ # 业锟斤拷锟斤拷
+ BizRef = property(_traderapi.CTORATstpFundTransferDetailField_BizRef_get, _traderapi.CTORATstpFundTransferDetailField_BizRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeRef = property(_traderapi.CTORATstpFundTransferDetailField_ExchangeRef_get, _traderapi.CTORATstpFundTransferDetailField_ExchangeRef_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpFundTransferDetailField_swiginit(self, _traderapi.new_CTORATstpFundTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpFundTransferDetailField
+
+# Register CTORATstpFundTransferDetailField in _traderapi:
+_traderapi.CTORATstpFundTransferDetailField_swigregister(CTORATstpFundTransferDetailField)
+
+
+
+
+#########################################锟斤拷询锟街诧拷转锟斤拷锟斤拷水############################################
+class CTORATstpQryPositionTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPositionTransferDetailField_ExchangeID_get, _traderapi.CTORATstpQryPositionTransferDetailField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPositionTransferDetailField_InvestorID_get, _traderapi.CTORATstpQryPositionTransferDetailField_InvestorID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryPositionTransferDetailField_ShareholderID_get, _traderapi.CTORATstpQryPositionTransferDetailField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPositionTransferDetailField_SecurityID_get, _traderapi.CTORATstpQryPositionTransferDetailField_SecurityID_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpQryPositionTransferDetailField_TransferDirection_get, _traderapi.CTORATstpQryPositionTransferDetailField_TransferDirection_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryPositionTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpQryPositionTransferDetailField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPositionTransferDetailField_swiginit(self, _traderapi.new_CTORATstpQryPositionTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPositionTransferDetailField
+
+# Register CTORATstpQryPositionTransferDetailField in _traderapi:
+_traderapi.CTORATstpQryPositionTransferDetailField_swigregister(CTORATstpQryPositionTransferDetailField)
+
+
+
+
+#########################################锟街诧拷转锟斤拷锟斤拷水############################################
+class CTORATstpPositionTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷水锟斤拷
+ PositionSerial = property(_traderapi.CTORATstpPositionTransferDetailField_PositionSerial_get, _traderapi.CTORATstpPositionTransferDetailField_PositionSerial_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpPositionTransferDetailField_ApplySerial_get, _traderapi.CTORATstpPositionTransferDetailField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpPositionTransferDetailField_FrontID_get, _traderapi.CTORATstpPositionTransferDetailField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpPositionTransferDetailField_SessionID_get, _traderapi.CTORATstpPositionTransferDetailField_SessionID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPositionTransferDetailField_InvestorID_get, _traderapi.CTORATstpPositionTransferDetailField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPositionTransferDetailField_ExchangeID_get, _traderapi.CTORATstpPositionTransferDetailField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPositionTransferDetailField_ShareholderID_get, _traderapi.CTORATstpPositionTransferDetailField_ShareholderID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPositionTransferDetailField_MarketID_get, _traderapi.CTORATstpPositionTransferDetailField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPositionTransferDetailField_SecurityID_get, _traderapi.CTORATstpPositionTransferDetailField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpPositionTransferDetailField_TradingDay_get, _traderapi.CTORATstpPositionTransferDetailField_TradingDay_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpPositionTransferDetailField_TransferDirection_get, _traderapi.CTORATstpPositionTransferDetailField_TransferDirection_set)
+
+ # 转锟狡持诧拷锟斤拷锟斤拷
+ TransferPositionType = property(_traderapi.CTORATstpPositionTransferDetailField_TransferPositionType_get, _traderapi.CTORATstpPositionTransferDetailField_TransferPositionType_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpPositionTransferDetailField_TransferStatus_get, _traderapi.CTORATstpPositionTransferDetailField_TransferStatus_set)
+
+ # 锟斤拷锟秸诧拷位锟斤拷锟斤拷
+ HistoryVolume = property(_traderapi.CTORATstpPositionTransferDetailField_HistoryVolume_get, _traderapi.CTORATstpPositionTransferDetailField_HistoryVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷位锟斤拷锟斤拷
+ TodayBSVolume = property(_traderapi.CTORATstpPositionTransferDetailField_TodayBSVolume_get, _traderapi.CTORATstpPositionTransferDetailField_TodayBSVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟轿伙拷锟斤拷锟�
+ TodayPRVolume = property(_traderapi.CTORATstpPositionTransferDetailField_TodayPRVolume_get, _traderapi.CTORATstpPositionTransferDetailField_TodayPRVolume_set)
+
+ # 锟斤拷锟秸诧拷趾喜锟斤拷锟轿伙拷锟斤拷锟�
+ TodaySMVolume = property(_traderapi.CTORATstpPositionTransferDetailField_TodaySMVolume_get, _traderapi.CTORATstpPositionTransferDetailField_TodaySMVolume_set)
+
+ # 锟斤拷锟斤拷锟斤拷员
+ OperatorID = property(_traderapi.CTORATstpPositionTransferDetailField_OperatorID_get, _traderapi.CTORATstpPositionTransferDetailField_OperatorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpPositionTransferDetailField_OperateDate_get, _traderapi.CTORATstpPositionTransferDetailField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpPositionTransferDetailField_OperateTime_get, _traderapi.CTORATstpPositionTransferDetailField_OperateTime_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPositionTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpPositionTransferDetailField_BusinessUnitID_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpPositionTransferDetailField_StatusMsg_get, _traderapi.CTORATstpPositionTransferDetailField_StatusMsg_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpPositionTransferDetailField_IPAddress_get, _traderapi.CTORATstpPositionTransferDetailField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpPositionTransferDetailField_MacAddress_get, _traderapi.CTORATstpPositionTransferDetailField_MacAddress_set)
+
+ # 锟解部锟节碉拷锟斤拷
+ ExternalNodeID = property(_traderapi.CTORATstpPositionTransferDetailField_ExternalNodeID_get, _traderapi.CTORATstpPositionTransferDetailField_ExternalNodeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPositionTransferDetailField_swiginit(self, _traderapi.new_CTORATstpPositionTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPositionTransferDetailField
+
+# Register CTORATstpPositionTransferDetailField in _traderapi:
+_traderapi.CTORATstpPositionTransferDetailField_swigregister(CTORATstpPositionTransferDetailField)
+
+
+
+
+#########################################锟斤拷询锟斤拷围系统锟斤拷位锟斤拷锟斤拷锟斤拷水############################################
+class CTORATstpQryPeripheryPositionTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_ExchangeID_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_InvestorID_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_InvestorID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_ShareholderID_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_SecurityID_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_SecurityID_set)
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_TransferDirection_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_TransferDirection_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPeripheryPositionTransferDetailField_swiginit(self, _traderapi.new_CTORATstpQryPeripheryPositionTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPeripheryPositionTransferDetailField
+
+# Register CTORATstpQryPeripheryPositionTransferDetailField in _traderapi:
+_traderapi.CTORATstpQryPeripheryPositionTransferDetailField_swigregister(CTORATstpQryPeripheryPositionTransferDetailField)
+
+
+
+
+#########################################锟斤拷围系统锟斤拷位锟斤拷锟斤拷锟斤拷水############################################
+class CTORATstpPeripheryPositionTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷位锟斤拷锟斤拷系统锟斤拷水锟斤拷
+ PositionSerial = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_PositionSerial_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_PositionSerial_set)
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_ApplySerial_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_FrontID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_SessionID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_SessionID_set)
+
+ # 锟斤拷位锟斤拷锟斤拷锟斤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferDirection_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferDirection_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_ExchangeID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_MarketID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_MarketID_set)
+
+ # 锟街伙拷系统投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_InvestorID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_InvestorID_set)
+
+ # 锟街伙拷系统投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_BusinessUnitID_set)
+
+ # 锟街伙拷系统锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_ShareholderID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_ShareholderID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_SecurityID_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷位转锟斤拷转锟斤拷锟斤拷锟斤拷
+ TodayBSPos = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TodayBSPos_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TodayBSPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟轿蛔拷锟斤拷锟斤拷锟�
+ TodayPRPos = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TodayPRPos_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TodayPRPos_set)
+
+ # 锟斤拷锟秸诧拷趾喜锟斤拷锟轿蛔拷锟斤拷锟斤拷锟�
+ TodaySMPos = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TodaySMPos_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TodaySMPos_set)
+
+ # 锟斤拷锟秸诧拷位转锟斤拷锟斤拷锟斤拷
+ HistoryPos = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_HistoryPos_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_HistoryPos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TradingDay_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TradingDay_set)
+
+ # 锟斤拷位锟斤拷锟斤拷原锟斤拷
+ TransferReason = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferReason_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferReason_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferStatus_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_TransferStatus_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_OperateDate_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_OperateTime_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_OperateTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ RepealDate = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealDate_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ RepealTime = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealTime_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealTime_set)
+
+ # 锟斤拷锟斤拷原锟斤拷
+ RepealReason = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealReason_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_RepealReason_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpPeripheryPositionTransferDetailField_StatusMsg_get, _traderapi.CTORATstpPeripheryPositionTransferDetailField_StatusMsg_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPeripheryPositionTransferDetailField_swiginit(self, _traderapi.new_CTORATstpPeripheryPositionTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPeripheryPositionTransferDetailField
+
+# Register CTORATstpPeripheryPositionTransferDetailField in _traderapi:
+_traderapi.CTORATstpPeripheryPositionTransferDetailField_swigregister(CTORATstpPeripheryPositionTransferDetailField)
+
+
+
+
+#########################################锟斤拷询锟斤拷围系统锟绞斤拷转锟斤拷锟斤拷水############################################
+class CTORATstpQryPeripheryFundTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPeripheryFundTransferDetailField_InvestorID_get, _traderapi.CTORATstpQryPeripheryFundTransferDetailField_InvestorID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpQryPeripheryFundTransferDetailField_DepartmentID_get, _traderapi.CTORATstpQryPeripheryFundTransferDetailField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpQryPeripheryFundTransferDetailField_AccountID_get, _traderapi.CTORATstpQryPeripheryFundTransferDetailField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpQryPeripheryFundTransferDetailField_CurrencyID_get, _traderapi.CTORATstpQryPeripheryFundTransferDetailField_CurrencyID_set)
+
+ # 锟绞斤拷锟斤拷锟斤拷锟斤拷锟�
+ TransferDirection = property(_traderapi.CTORATstpQryPeripheryFundTransferDetailField_TransferDirection_get, _traderapi.CTORATstpQryPeripheryFundTransferDetailField_TransferDirection_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPeripheryFundTransferDetailField_swiginit(self, _traderapi.new_CTORATstpQryPeripheryFundTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPeripheryFundTransferDetailField
+
+# Register CTORATstpQryPeripheryFundTransferDetailField in _traderapi:
+_traderapi.CTORATstpQryPeripheryFundTransferDetailField_swigregister(CTORATstpQryPeripheryFundTransferDetailField)
+
+
+
+
+#########################################锟斤拷围系统锟绞斤拷转锟斤拷锟斤拷水############################################
+class CTORATstpPeripheryFundTransferDetailField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 转锟斤拷锟斤拷水锟斤拷
+ FundSerial = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_FundSerial_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_FundSerial_set)
+
+ # 锟斤拷锟斤拷锟斤拷水锟斤拷
+ ApplySerial = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_ApplySerial_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_ApplySerial_set)
+
+ # 前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_FrontID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_FrontID_set)
+
+ # 锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_SessionID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_SessionID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_DepartmentID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_DepartmentID_set)
+
+ # 锟绞斤拷锟剿伙拷锟斤拷锟斤拷
+ AccountID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_AccountID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_AccountID_set)
+
+ # 锟斤拷锟斤拷
+ CurrencyID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_CurrencyID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_CurrencyID_set)
+
+ # 转锟狡凤拷锟斤拷
+ TransferDirection = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_TransferDirection_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_TransferDirection_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ Amount = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_Amount_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_Amount_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_InvestorID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_InvestorID_set)
+
+ # 转锟斤拷状态
+ TransferStatus = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_TransferStatus_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_TransferStatus_set)
+
+ # 锟绞斤拷锟斤拷锟皆拷锟�
+ TransferReason = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_TransferReason_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_TransferReason_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ OperateDate = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_OperateDate_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_OperateDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ OperateTime = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_OperateTime_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_OperateTime_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ RepealDate = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_RepealDate_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_RepealDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ RepealTime = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_RepealTime_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_RepealTime_set)
+
+ # 锟斤拷锟斤拷原锟斤拷
+ RepealReason = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_RepealReason_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_RepealReason_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_StatusMsg_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_StatusMsg_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPeripheryFundTransferDetailField_BusinessUnitID_get, _traderapi.CTORATstpPeripheryFundTransferDetailField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPeripheryFundTransferDetailField_swiginit(self, _traderapi.new_CTORATstpPeripheryFundTransferDetailField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPeripheryFundTransferDetailField
+
+# Register CTORATstpPeripheryFundTransferDetailField in _traderapi:
+_traderapi.CTORATstpPeripheryFundTransferDetailField_swigregister(CTORATstpPeripheryFundTransferDetailField)
+
+
+
+
+#########################################锟斤拷询债券转锟斤拷锟斤拷息############################################
+class CTORATstpQryBondConversionInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryBondConversionInfoField_ExchangeID_get, _traderapi.CTORATstpQryBondConversionInfoField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryBondConversionInfoField_SecurityID_get, _traderapi.CTORATstpQryBondConversionInfoField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryBondConversionInfoField_swiginit(self, _traderapi.new_CTORATstpQryBondConversionInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryBondConversionInfoField
+
+# Register CTORATstpQryBondConversionInfoField in _traderapi:
+_traderapi.CTORATstpQryBondConversionInfoField_swigregister(CTORATstpQryBondConversionInfoField)
+
+
+
+
+#########################################债券转锟斤拷锟斤拷息############################################
+class CTORATstpBondConversionInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpBondConversionInfoField_ExchangeID_get, _traderapi.CTORATstpBondConversionInfoField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpBondConversionInfoField_MarketID_get, _traderapi.CTORATstpBondConversionInfoField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpBondConversionInfoField_SecurityID_get, _traderapi.CTORATstpBondConversionInfoField_SecurityID_set)
+
+ # 转锟斤拷锟疥报锟斤拷锟斤拷
+ ConvertOrderID = property(_traderapi.CTORATstpBondConversionInfoField_ConvertOrderID_get, _traderapi.CTORATstpBondConversionInfoField_ConvertOrderID_set)
+
+ # 转锟缴价革拷
+ ConvertPrice = property(_traderapi.CTORATstpBondConversionInfoField_ConvertPrice_get, _traderapi.CTORATstpBondConversionInfoField_ConvertPrice_set)
+
+ # 每锟轿匡拷锟斤拷转锟斤拷锟斤拷小锟斤拷锟阶碉拷位
+ ConvertVolUnit = property(_traderapi.CTORATstpBondConversionInfoField_ConvertVolUnit_get, _traderapi.CTORATstpBondConversionInfoField_ConvertVolUnit_set)
+
+ # 证券锟斤拷锟斤拷转锟缴碉拷锟斤拷锟斤拷锟斤拷锟�
+ ConvertVolMax = property(_traderapi.CTORATstpBondConversionInfoField_ConvertVolMax_get, _traderapi.CTORATstpBondConversionInfoField_ConvertVolMax_set)
+
+ # 证券锟斤拷锟斤拷转锟缴碉拷锟斤拷小锟斤拷锟斤拷
+ ConvertVolMin = property(_traderapi.CTORATstpBondConversionInfoField_ConvertVolMin_get, _traderapi.CTORATstpBondConversionInfoField_ConvertVolMin_set)
+
+ # 转锟缴匡拷始锟斤拷锟斤拷
+ BeginDate = property(_traderapi.CTORATstpBondConversionInfoField_BeginDate_get, _traderapi.CTORATstpBondConversionInfoField_BeginDate_set)
+
+ # 转锟缴斤拷锟斤拷锟斤拷锟斤拷
+ EndDate = property(_traderapi.CTORATstpBondConversionInfoField_EndDate_get, _traderapi.CTORATstpBondConversionInfoField_EndDate_set)
+
+ # 转锟斤拷锟斤拷锟斤拷
+ ConvertName = property(_traderapi.CTORATstpBondConversionInfoField_ConvertName_get, _traderapi.CTORATstpBondConversionInfoField_ConvertName_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpBondConversionInfoField_swiginit(self, _traderapi.new_CTORATstpBondConversionInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpBondConversionInfoField
+
+# Register CTORATstpBondConversionInfoField in _traderapi:
+_traderapi.CTORATstpBondConversionInfoField_swigregister(CTORATstpBondConversionInfoField)
+
+
+
+
+#########################################锟斤拷询债券锟斤拷锟斤拷锟斤拷息############################################
+class CTORATstpQryBondPutbackInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryBondPutbackInfoField_ExchangeID_get, _traderapi.CTORATstpQryBondPutbackInfoField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryBondPutbackInfoField_SecurityID_get, _traderapi.CTORATstpQryBondPutbackInfoField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryBondPutbackInfoField_swiginit(self, _traderapi.new_CTORATstpQryBondPutbackInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryBondPutbackInfoField
+
+# Register CTORATstpQryBondPutbackInfoField in _traderapi:
+_traderapi.CTORATstpQryBondPutbackInfoField_swigregister(CTORATstpQryBondPutbackInfoField)
+
+
+
+
+#########################################债券锟斤拷锟斤拷锟斤拷息############################################
+class CTORATstpBondPutbackInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpBondPutbackInfoField_ExchangeID_get, _traderapi.CTORATstpBondPutbackInfoField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpBondPutbackInfoField_MarketID_get, _traderapi.CTORATstpBondPutbackInfoField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpBondPutbackInfoField_SecurityID_get, _traderapi.CTORATstpBondPutbackInfoField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟疥报锟斤拷锟斤拷
+ PutbackOrderID = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackOrderID_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackOrderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ PutbackName = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackName_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackName_set)
+
+ # 锟斤拷锟桔价革拷
+ PutbackPrice = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackPrice_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackPrice_set)
+
+ # 每锟轿匡拷锟皆伙拷锟斤拷锟斤拷小锟斤拷锟阶碉拷位
+ PutbackVolUnit = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackVolUnit_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackVolUnit_set)
+
+ # 债券锟斤拷锟皆伙拷锟桔碉拷锟斤拷锟斤拷锟斤拷锟�
+ PutbackVolMax = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackVolMax_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackVolMax_set)
+
+ # 债券锟斤拷锟皆伙拷锟桔碉拷锟斤拷小锟斤拷锟斤拷
+ PutbackVolMin = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackVolMin_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackVolMin_set)
+
+ # 锟斤拷锟桔匡拷始锟斤拷锟斤拷
+ PutbackBeginDate = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackBeginDate_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackBeginDate_set)
+
+ # 锟斤拷锟桔斤拷锟斤拷锟斤拷锟斤拷
+ PutbackEndDate = property(_traderapi.CTORATstpBondPutbackInfoField_PutbackEndDate_get, _traderapi.CTORATstpBondPutbackInfoField_PutbackEndDate_set)
+
+ # 锟斤拷锟桔筹拷锟斤拷锟斤拷始锟斤拷锟斤拷
+ RelieveBeginDate = property(_traderapi.CTORATstpBondPutbackInfoField_RelieveBeginDate_get, _traderapi.CTORATstpBondPutbackInfoField_RelieveBeginDate_set)
+
+ # 锟斤拷锟桔筹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ RelieveEndDate = property(_traderapi.CTORATstpBondPutbackInfoField_RelieveEndDate_get, _traderapi.CTORATstpBondPutbackInfoField_RelieveEndDate_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpBondPutbackInfoField_swiginit(self, _traderapi.new_CTORATstpBondPutbackInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpBondPutbackInfoField
+
+# Register CTORATstpBondPutbackInfoField in _traderapi:
+_traderapi.CTORATstpBondPutbackInfoField_swigregister(CTORATstpBondPutbackInfoField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡诧拷锟斤拷############################################
+class CTORATstpQryInvestorCondOrderLimitParamField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryInvestorCondOrderLimitParamField_InvestorID_get, _traderapi.CTORATstpQryInvestorCondOrderLimitParamField_InvestorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryInvestorCondOrderLimitParamField_swiginit(self, _traderapi.new_CTORATstpQryInvestorCondOrderLimitParamField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryInvestorCondOrderLimitParamField
+
+# Register CTORATstpQryInvestorCondOrderLimitParamField in _traderapi:
+_traderapi.CTORATstpQryInvestorCondOrderLimitParamField_swigregister(CTORATstpQryInvestorCondOrderLimitParamField)
+
+
+
+
+#########################################投锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡诧拷锟斤拷############################################
+class CTORATstpInvestorCondOrderLimitParamField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInvestorCondOrderLimitParamField_InvestorID_get, _traderapi.CTORATstpInvestorCondOrderLimitParamField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ MaxCondOrderLimitCnt = property(_traderapi.CTORATstpInvestorCondOrderLimitParamField_MaxCondOrderLimitCnt_get, _traderapi.CTORATstpInvestorCondOrderLimitParamField_MaxCondOrderLimitCnt_set)
+
+ # 锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷
+ CurrCondOrderCnt = property(_traderapi.CTORATstpInvestorCondOrderLimitParamField_CurrCondOrderCnt_get, _traderapi.CTORATstpInvestorCondOrderLimitParamField_CurrCondOrderCnt_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInvestorCondOrderLimitParamField_swiginit(self, _traderapi.new_CTORATstpInvestorCondOrderLimitParamField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInvestorCondOrderLimitParamField
+
+# Register CTORATstpInvestorCondOrderLimitParamField in _traderapi:
+_traderapi.CTORATstpInvestorCondOrderLimitParamField_swigregister(CTORATstpInvestorCondOrderLimitParamField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpQryConditionOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryConditionOrderField_ExchangeID_get, _traderapi.CTORATstpQryConditionOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryConditionOrderField_InvestorID_get, _traderapi.CTORATstpQryConditionOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryConditionOrderField_BusinessUnitID_get, _traderapi.CTORATstpQryConditionOrderField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryConditionOrderField_SecurityID_get, _traderapi.CTORATstpQryConditionOrderField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryConditionOrderField_ShareholderID_get, _traderapi.CTORATstpQryConditionOrderField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpQryConditionOrderField_CondOrderID_get, _traderapi.CTORATstpQryConditionOrderField_CondOrderID_set)
+
+ # Insert Time
+ InsertTimeStart = property(_traderapi.CTORATstpQryConditionOrderField_InsertTimeStart_get, _traderapi.CTORATstpQryConditionOrderField_InsertTimeStart_set)
+
+ # Insert Time
+ InsertTimeEnd = property(_traderapi.CTORATstpQryConditionOrderField_InsertTimeEnd_get, _traderapi.CTORATstpQryConditionOrderField_InsertTimeEnd_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryConditionOrderField_SInfo_get, _traderapi.CTORATstpQryConditionOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryConditionOrderField_IInfo_get, _traderapi.CTORATstpQryConditionOrderField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryConditionOrderField_swiginit(self, _traderapi.new_CTORATstpQryConditionOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryConditionOrderField
+
+# Register CTORATstpQryConditionOrderField in _traderapi:
+_traderapi.CTORATstpQryConditionOrderField_swigregister(CTORATstpQryConditionOrderField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpQryCondOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryCondOrderActionField_ExchangeID_get, _traderapi.CTORATstpQryCondOrderActionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryCondOrderActionField_InvestorID_get, _traderapi.CTORATstpQryCondOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryCondOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpQryCondOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryCondOrderActionField_ShareholderID_get, _traderapi.CTORATstpQryCondOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpQryCondOrderActionField_CondOrderID_get, _traderapi.CTORATstpQryCondOrderActionField_CondOrderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CancelCondOrderID = property(_traderapi.CTORATstpQryCondOrderActionField_CancelCondOrderID_get, _traderapi.CTORATstpQryCondOrderActionField_CancelCondOrderID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryCondOrderActionField_SInfo_get, _traderapi.CTORATstpQryCondOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryCondOrderActionField_IInfo_get, _traderapi.CTORATstpQryCondOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryCondOrderActionField_swiginit(self, _traderapi.new_CTORATstpQryCondOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryCondOrderActionField
+
+# Register CTORATstpQryCondOrderActionField in _traderapi:
+_traderapi.CTORATstpQryCondOrderActionField_swigregister(CTORATstpQryCondOrderActionField)
+
+
+
+
+#########################################锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷############################################
+class CTORATstpCondOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpCondOrderActionField_ExchangeID_get, _traderapi.CTORATstpCondOrderActionField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷前锟矫憋拷锟�
+ FrontID = property(_traderapi.CTORATstpCondOrderActionField_FrontID_get, _traderapi.CTORATstpCondOrderActionField_FrontID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟结话锟斤拷锟�
+ SessionID = property(_traderapi.CTORATstpCondOrderActionField_SessionID_get, _traderapi.CTORATstpCondOrderActionField_SessionID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderRef = property(_traderapi.CTORATstpCondOrderActionField_CondOrderRef_get, _traderapi.CTORATstpCondOrderActionField_CondOrderRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CondOrderID = property(_traderapi.CTORATstpCondOrderActionField_CondOrderID_get, _traderapi.CTORATstpCondOrderActionField_CondOrderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpCondOrderActionField_ActionFlag_get, _traderapi.CTORATstpCondOrderActionField_ActionFlag_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpCondOrderActionField_Operway_get, _traderapi.CTORATstpCondOrderActionField_Operway_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ CondOrderActionRef = property(_traderapi.CTORATstpCondOrderActionField_CondOrderActionRef_get, _traderapi.CTORATstpCondOrderActionField_CondOrderActionRef_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ CancelCondOrderID = property(_traderapi.CTORATstpCondOrderActionField_CancelCondOrderID_get, _traderapi.CTORATstpCondOrderActionField_CancelCondOrderID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpCondOrderActionField_SInfo_get, _traderapi.CTORATstpCondOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpCondOrderActionField_IInfo_get, _traderapi.CTORATstpCondOrderActionField_IInfo_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpCondOrderActionField_RequestID_get, _traderapi.CTORATstpCondOrderActionField_RequestID_set)
+
+ # 锟斤拷锟斤拷前锟矫憋拷锟�
+ ActionFrontID = property(_traderapi.CTORATstpCondOrderActionField_ActionFrontID_get, _traderapi.CTORATstpCondOrderActionField_ActionFrontID_set)
+
+ # 锟斤拷锟斤拷锟结话锟斤拷锟�
+ ActionSessionID = property(_traderapi.CTORATstpCondOrderActionField_ActionSessionID_get, _traderapi.CTORATstpCondOrderActionField_ActionSessionID_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpCondOrderActionField_DepartmentID_get, _traderapi.CTORATstpCondOrderActionField_DepartmentID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpCondOrderActionField_InvestorID_get, _traderapi.CTORATstpCondOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpCondOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpCondOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpCondOrderActionField_ShareholderID_get, _traderapi.CTORATstpCondOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ ActionUser = property(_traderapi.CTORATstpCondOrderActionField_ActionUser_get, _traderapi.CTORATstpCondOrderActionField_ActionUser_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ActionDate = property(_traderapi.CTORATstpCondOrderActionField_ActionDate_get, _traderapi.CTORATstpCondOrderActionField_ActionDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ ActionTime = property(_traderapi.CTORATstpCondOrderActionField_ActionTime_get, _traderapi.CTORATstpCondOrderActionField_ActionTime_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpCondOrderActionField_IPAddress_get, _traderapi.CTORATstpCondOrderActionField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpCondOrderActionField_MacAddress_get, _traderapi.CTORATstpCondOrderActionField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpCondOrderActionField_swiginit(self, _traderapi.new_CTORATstpCondOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpCondOrderActionField
+
+# Register CTORATstpCondOrderActionField in _traderapi:
+_traderapi.CTORATstpCondOrderActionField_swigregister(CTORATstpCondOrderActionField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷通知############################################
+class CTORATstpQryTradingNoticeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryTradingNoticeField_InvestorID_get, _traderapi.CTORATstpQryTradingNoticeField_InvestorID_set)
+
+ # Insert Date
+ InsertDateStart = property(_traderapi.CTORATstpQryTradingNoticeField_InsertDateStart_get, _traderapi.CTORATstpQryTradingNoticeField_InsertDateStart_set)
+
+ # Insert Date
+ InsertDateEnd = property(_traderapi.CTORATstpQryTradingNoticeField_InsertDateEnd_get, _traderapi.CTORATstpQryTradingNoticeField_InsertDateEnd_set)
+
+ # Insert Time
+ InsertTimeStart = property(_traderapi.CTORATstpQryTradingNoticeField_InsertTimeStart_get, _traderapi.CTORATstpQryTradingNoticeField_InsertTimeStart_set)
+
+ # Insert Time
+ InsertTimeEnd = property(_traderapi.CTORATstpQryTradingNoticeField_InsertTimeEnd_get, _traderapi.CTORATstpQryTradingNoticeField_InsertTimeEnd_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryTradingNoticeField_swiginit(self, _traderapi.new_CTORATstpQryTradingNoticeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryTradingNoticeField
+
+# Register CTORATstpQryTradingNoticeField in _traderapi:
+_traderapi.CTORATstpQryTradingNoticeField_swigregister(CTORATstpQryTradingNoticeField)
+
+
+
+
+#########################################锟斤拷询锟铰癸拷锟疥购锟斤拷沤锟斤拷############################################
+class CTORATstpQryIPONumberResultField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryIPONumberResultField_InvestorID_get, _traderapi.CTORATstpQryIPONumberResultField_InvestorID_set)
+
+ # 锟疥购锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryIPONumberResultField_SecurityID_get, _traderapi.CTORATstpQryIPONumberResultField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryIPONumberResultField_ExchangeID_get, _traderapi.CTORATstpQryIPONumberResultField_ExchangeID_set)
+
+ # 锟缴讹拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryIPONumberResultField_ShareholderID_get, _traderapi.CTORATstpQryIPONumberResultField_ShareholderID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryIPONumberResultField_swiginit(self, _traderapi.new_CTORATstpQryIPONumberResultField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryIPONumberResultField
+
+# Register CTORATstpQryIPONumberResultField in _traderapi:
+_traderapi.CTORATstpQryIPONumberResultField_swigregister(CTORATstpQryIPONumberResultField)
+
+
+
+
+#########################################锟铰癸拷锟疥购锟斤拷沤锟斤拷############################################
+class CTORATstpIPONumberResultField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpIPONumberResultField_SecurityID_get, _traderapi.CTORATstpIPONumberResultField_SecurityID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpIPONumberResultField_MarketID_get, _traderapi.CTORATstpIPONumberResultField_MarketID_set)
+
+ # 锟缴讹拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpIPONumberResultField_ShareholderID_get, _traderapi.CTORATstpIPONumberResultField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpIPONumberResultField_ExchangeID_get, _traderapi.CTORATstpIPONumberResultField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷
+ Day = property(_traderapi.CTORATstpIPONumberResultField_Day_get, _traderapi.CTORATstpIPONumberResultField_Day_set)
+
+ # 锟疥购证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpIPONumberResultField_SecurityName_get, _traderapi.CTORATstpIPONumberResultField_SecurityName_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpIPONumberResultField_SecurityType_get, _traderapi.CTORATstpIPONumberResultField_SecurityType_set)
+
+ # 锟斤拷始锟斤拷锟�
+ BeginNumberID = property(_traderapi.CTORATstpIPONumberResultField_BeginNumberID_get, _traderapi.CTORATstpIPONumberResultField_BeginNumberID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ Volume = property(_traderapi.CTORATstpIPONumberResultField_Volume_get, _traderapi.CTORATstpIPONumberResultField_Volume_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpIPONumberResultField_InvestorID_get, _traderapi.CTORATstpIPONumberResultField_InvestorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpIPONumberResultField_swiginit(self, _traderapi.new_CTORATstpIPONumberResultField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpIPONumberResultField
+
+# Register CTORATstpIPONumberResultField in _traderapi:
+_traderapi.CTORATstpIPONumberResultField_swigregister(CTORATstpIPONumberResultField)
+
+
+
+
+#########################################锟斤拷询锟铰癸拷锟疥购锟斤拷签锟斤拷锟�############################################
+class CTORATstpQryIPOMatchNumberResultField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryIPOMatchNumberResultField_InvestorID_get, _traderapi.CTORATstpQryIPOMatchNumberResultField_InvestorID_set)
+
+ # 锟疥购锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryIPOMatchNumberResultField_SecurityID_get, _traderapi.CTORATstpQryIPOMatchNumberResultField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryIPOMatchNumberResultField_ExchangeID_get, _traderapi.CTORATstpQryIPOMatchNumberResultField_ExchangeID_set)
+
+ # 锟缴讹拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryIPOMatchNumberResultField_ShareholderID_get, _traderapi.CTORATstpQryIPOMatchNumberResultField_ShareholderID_set)
+
+ # 锟斤拷签锟斤拷锟�
+ MatchNumberID = property(_traderapi.CTORATstpQryIPOMatchNumberResultField_MatchNumberID_get, _traderapi.CTORATstpQryIPOMatchNumberResultField_MatchNumberID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryIPOMatchNumberResultField_swiginit(self, _traderapi.new_CTORATstpQryIPOMatchNumberResultField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryIPOMatchNumberResultField
+
+# Register CTORATstpQryIPOMatchNumberResultField in _traderapi:
+_traderapi.CTORATstpQryIPOMatchNumberResultField_swigregister(CTORATstpQryIPOMatchNumberResultField)
+
+
+
+
+#########################################锟铰癸拷锟疥购锟斤拷签锟斤拷锟�############################################
+class CTORATstpIPOMatchNumberResultField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpIPOMatchNumberResultField_SecurityID_get, _traderapi.CTORATstpIPOMatchNumberResultField_SecurityID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpIPOMatchNumberResultField_MarketID_get, _traderapi.CTORATstpIPOMatchNumberResultField_MarketID_set)
+
+ # 锟缴讹拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpIPOMatchNumberResultField_ShareholderID_get, _traderapi.CTORATstpIPOMatchNumberResultField_ShareholderID_set)
+
+ # 锟斤拷签锟斤拷锟�
+ MatchNumberID = property(_traderapi.CTORATstpIPOMatchNumberResultField_MatchNumberID_get, _traderapi.CTORATstpIPOMatchNumberResultField_MatchNumberID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpIPOMatchNumberResultField_ExchangeID_get, _traderapi.CTORATstpIPOMatchNumberResultField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷
+ Day = property(_traderapi.CTORATstpIPOMatchNumberResultField_Day_get, _traderapi.CTORATstpIPOMatchNumberResultField_Day_set)
+
+ # 锟疥购证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpIPOMatchNumberResultField_SecurityName_get, _traderapi.CTORATstpIPOMatchNumberResultField_SecurityName_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpIPOMatchNumberResultField_SecurityType_get, _traderapi.CTORATstpIPOMatchNumberResultField_SecurityType_set)
+
+ # 锟斤拷锟斤拷签锟斤拷拥锟叫碉拷证券锟斤拷锟斤拷
+ Volume = property(_traderapi.CTORATstpIPOMatchNumberResultField_Volume_get, _traderapi.CTORATstpIPOMatchNumberResultField_Volume_set)
+
+ # 锟疥购锟桔革拷
+ Price = property(_traderapi.CTORATstpIPOMatchNumberResultField_Price_get, _traderapi.CTORATstpIPOMatchNumberResultField_Price_set)
+
+ # 锟疥购锟斤拷锟�
+ Amout = property(_traderapi.CTORATstpIPOMatchNumberResultField_Amout_get, _traderapi.CTORATstpIPOMatchNumberResultField_Amout_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpIPOMatchNumberResultField_InvestorID_get, _traderapi.CTORATstpIPOMatchNumberResultField_InvestorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpIPOMatchNumberResultField_swiginit(self, _traderapi.new_CTORATstpIPOMatchNumberResultField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpIPOMatchNumberResultField
+
+# Register CTORATstpIPOMatchNumberResultField in _traderapi:
+_traderapi.CTORATstpIPOMatchNumberResultField_swigregister(CTORATstpIPOMatchNumberResultField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟斤拷协锟斤拷############################################
+class CTORATstpQryShareholderSpecPrivilegeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_InvestorID_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_ExchangeID_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_ExchangeID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_ShareholderID_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷权锟斤拷锟斤拷锟�
+ SpecPrivilegeType = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_SpecPrivilegeType_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_SpecPrivilegeType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_Direction_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_Direction_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryShareholderSpecPrivilegeField_MarketID_get, _traderapi.CTORATstpQryShareholderSpecPrivilegeField_MarketID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryShareholderSpecPrivilegeField_swiginit(self, _traderapi.new_CTORATstpQryShareholderSpecPrivilegeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryShareholderSpecPrivilegeField
+
+# Register CTORATstpQryShareholderSpecPrivilegeField in _traderapi:
+_traderapi.CTORATstpQryShareholderSpecPrivilegeField_swigregister(CTORATstpQryShareholderSpecPrivilegeField)
+
+
+
+
+#########################################锟斤拷锟斤拷协锟斤拷############################################
+class CTORATstpShareholderSpecPrivilegeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_ExchangeID_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_ShareholderID_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_ShareholderID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_MarketID_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_MarketID_set)
+
+ # 锟斤拷锟斤拷权锟斤拷锟斤拷锟�
+ SpecPrivilegeType = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_SpecPrivilegeType_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_SpecPrivilegeType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ Direction = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_Direction_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_Direction_set)
+
+ # 锟角凤拷锟街�
+ bForbidden = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_bForbidden_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_bForbidden_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpShareholderSpecPrivilegeField_InvestorID_get, _traderapi.CTORATstpShareholderSpecPrivilegeField_InvestorID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpShareholderSpecPrivilegeField_swiginit(self, _traderapi.new_CTORATstpShareholderSpecPrivilegeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpShareholderSpecPrivilegeField
+
+# Register CTORATstpShareholderSpecPrivilegeField in _traderapi:
+_traderapi.CTORATstpShareholderSpecPrivilegeField_swigregister(CTORATstpShareholderSpecPrivilegeField)
+
+
+
+
+#########################################锟斤拷询锟叫筹拷############################################
+class CTORATstpQryMarketField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryMarketField_ExchangeID_get, _traderapi.CTORATstpQryMarketField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryMarketField_MarketID_get, _traderapi.CTORATstpQryMarketField_MarketID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryMarketField_swiginit(self, _traderapi.new_CTORATstpQryMarketField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryMarketField
+
+# Register CTORATstpQryMarketField in _traderapi:
+_traderapi.CTORATstpQryMarketField_swigregister(CTORATstpQryMarketField)
+
+
+
+
+#########################################锟叫筹拷############################################
+class CTORATstpMarketField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpMarketField_MarketID_get, _traderapi.CTORATstpMarketField_MarketID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketName = property(_traderapi.CTORATstpMarketField_MarketName_get, _traderapi.CTORATstpMarketField_MarketName_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpMarketField_ExchangeID_get, _traderapi.CTORATstpMarketField_ExchangeID_set)
+
+ # 锟叫筹拷状态
+ MarketStatus = property(_traderapi.CTORATstpMarketField_MarketStatus_get, _traderapi.CTORATstpMarketField_MarketStatus_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpMarketField_swiginit(self, _traderapi.new_CTORATstpMarketField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpMarketField
+
+# Register CTORATstpMarketField in _traderapi:
+_traderapi.CTORATstpMarketField_swigregister(CTORATstpMarketField)
+
+
+
+
+#########################################锟斤拷询ETF锟藉单锟斤拷息############################################
+class CTORATstpQryETFFileField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryETFFileField_ExchangeID_get, _traderapi.CTORATstpQryETFFileField_ExchangeID_set)
+
+ # ETF锟斤拷锟斤拷锟叫筹拷锟斤拷锟阶达拷锟斤拷
+ ETFSecurityID = property(_traderapi.CTORATstpQryETFFileField_ETFSecurityID_get, _traderapi.CTORATstpQryETFFileField_ETFSecurityID_set)
+
+ # ETF一锟斤拷锟叫筹拷锟斤拷锟斤拷锟斤拷锟�
+ ETFCreRedSecurityID = property(_traderapi.CTORATstpQryETFFileField_ETFCreRedSecurityID_get, _traderapi.CTORATstpQryETFFileField_ETFCreRedSecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryETFFileField_swiginit(self, _traderapi.new_CTORATstpQryETFFileField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryETFFileField
+
+# Register CTORATstpQryETFFileField in _traderapi:
+_traderapi.CTORATstpQryETFFileField_swigregister(CTORATstpQryETFFileField)
+
+
+
+
+#########################################ETF锟藉单锟斤拷息############################################
+class CTORATstpETFFileField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpETFFileField_TradingDay_get, _traderapi.CTORATstpETFFileField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpETFFileField_ExchangeID_get, _traderapi.CTORATstpETFFileField_ExchangeID_set)
+
+ # ETF锟斤拷锟阶达拷锟斤拷
+ ETFSecurityID = property(_traderapi.CTORATstpETFFileField_ETFSecurityID_get, _traderapi.CTORATstpETFFileField_ETFSecurityID_set)
+
+ # ETF锟斤拷锟斤拷锟斤拷锟�
+ ETFCreRedSecurityID = property(_traderapi.CTORATstpETFFileField_ETFCreRedSecurityID_get, _traderapi.CTORATstpETFFileField_ETFCreRedSecurityID_set)
+
+ # 锟斤拷小锟疥购锟斤拷氐锟轿伙拷锟斤拷锟�
+ CreationRedemptionUnit = property(_traderapi.CTORATstpETFFileField_CreationRedemptionUnit_get, _traderapi.CTORATstpETFFileField_CreationRedemptionUnit_set)
+
+ # 锟斤拷锟斤拷纸锟斤拷锟斤拷锟斤拷锟斤拷
+ Maxcashratio = property(_traderapi.CTORATstpETFFileField_Maxcashratio_get, _traderapi.CTORATstpETFFileField_Maxcashratio_set)
+
+ # 预锟斤拷锟街斤拷锟斤拷
+ EstimateCashComponent = property(_traderapi.CTORATstpETFFileField_EstimateCashComponent_get, _traderapi.CTORATstpETFFileField_EstimateCashComponent_set)
+
+ # 前一锟斤拷锟斤拷锟斤拷锟街斤拷锟斤拷
+ CashComponent = property(_traderapi.CTORATstpETFFileField_CashComponent_get, _traderapi.CTORATstpETFFileField_CashComponent_set)
+
+ # 前一锟斤拷锟斤拷锟秸伙拷锟斤拷位锟斤拷值
+ NAV = property(_traderapi.CTORATstpETFFileField_NAV_get, _traderapi.CTORATstpETFFileField_NAV_set)
+
+ # 前一锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟阶硷拷锟轿伙拷锟街�
+ NAVperCU = property(_traderapi.CTORATstpETFFileField_NAVperCU_get, _traderapi.CTORATstpETFFileField_NAVperCU_set)
+
+ # 锟斤拷锟斤拷锟疥购锟斤拷鼗锟阶硷拷锟轿伙拷暮锟斤拷锟斤拷锟斤拷
+ DividendPerCU = property(_traderapi.CTORATstpETFFileField_DividendPerCU_get, _traderapi.CTORATstpETFFileField_DividendPerCU_set)
+
+ # ETF锟斤拷锟斤拷锟斤拷锟斤拷
+ ETFCreRedType = property(_traderapi.CTORATstpETFFileField_ETFCreRedType_get, _traderapi.CTORATstpETFFileField_ETFCreRedType_set)
+
+ # ETF证券锟斤拷锟斤拷
+ ETFSecurityName = property(_traderapi.CTORATstpETFFileField_ETFSecurityName_get, _traderapi.CTORATstpETFFileField_ETFSecurityName_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpETFFileField_swiginit(self, _traderapi.new_CTORATstpETFFileField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpETFFileField
+
+# Register CTORATstpETFFileField in _traderapi:
+_traderapi.CTORATstpETFFileField_swigregister(CTORATstpETFFileField)
+
+
+
+
+#########################################锟斤拷询ETF锟缴凤拷证券锟斤拷息############################################
+class CTORATstpQryETFBasketField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryETFBasketField_ExchangeID_get, _traderapi.CTORATstpQryETFBasketField_ExchangeID_set)
+
+ # ETF锟斤拷锟斤拷锟叫筹拷锟斤拷锟阶达拷锟斤拷
+ ETFSecurityID = property(_traderapi.CTORATstpQryETFBasketField_ETFSecurityID_get, _traderapi.CTORATstpQryETFBasketField_ETFSecurityID_set)
+
+ # ETF锟缴凤拷证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryETFBasketField_SecurityID_get, _traderapi.CTORATstpQryETFBasketField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryETFBasketField_swiginit(self, _traderapi.new_CTORATstpQryETFBasketField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryETFBasketField
+
+# Register CTORATstpQryETFBasketField in _traderapi:
+_traderapi.CTORATstpQryETFBasketField_swigregister(CTORATstpQryETFBasketField)
+
+
+
+
+#########################################ETF锟缴凤拷证券锟斤拷息############################################
+class CTORATstpETFBasketField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpETFBasketField_TradingDay_get, _traderapi.CTORATstpETFBasketField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpETFBasketField_ExchangeID_get, _traderapi.CTORATstpETFBasketField_ExchangeID_set)
+
+ # ETF锟斤拷锟阶达拷锟斤拷
+ ETFSecurityID = property(_traderapi.CTORATstpETFBasketField_ETFSecurityID_get, _traderapi.CTORATstpETFBasketField_ETFSecurityID_set)
+
+ # ETF锟缴凤拷证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpETFBasketField_SecurityID_get, _traderapi.CTORATstpETFBasketField_SecurityID_set)
+
+ # 锟缴凤拷证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpETFBasketField_SecurityName_get, _traderapi.CTORATstpETFBasketField_SecurityName_set)
+
+ # 锟缴凤拷证券锟斤拷锟斤拷
+ Volume = property(_traderapi.CTORATstpETFBasketField_Volume_get, _traderapi.CTORATstpETFBasketField_Volume_set)
+
+ # 锟街斤拷锟斤拷锟斤拷锟街�
+ ETFCurrenceReplaceStatus = property(_traderapi.CTORATstpETFBasketField_ETFCurrenceReplaceStatus_get, _traderapi.CTORATstpETFBasketField_ETFCurrenceReplaceStatus_set)
+
+ # 锟斤拷郾锟斤拷锟�
+ Premium = property(_traderapi.CTORATstpETFBasketField_Premium_get, _traderapi.CTORATstpETFBasketField_Premium_set)
+
+ # 锟疥购锟斤拷锟斤拷锟斤拷
+ CreationReplaceAmount = property(_traderapi.CTORATstpETFBasketField_CreationReplaceAmount_get, _traderapi.CTORATstpETFBasketField_CreationReplaceAmount_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ RedemptionReplaceAmount = property(_traderapi.CTORATstpETFBasketField_RedemptionReplaceAmount_get, _traderapi.CTORATstpETFBasketField_RedemptionReplaceAmount_set)
+
+ # 锟斤拷锟斤拷锟叫筹拷
+ MarketID = property(_traderapi.CTORATstpETFBasketField_MarketID_get, _traderapi.CTORATstpETFBasketField_MarketID_set)
+
+ # ETF锟斤拷锟斤拷锟斤拷锟斤拷
+ ETFCreRedType = property(_traderapi.CTORATstpETFBasketField_ETFCreRedType_get, _traderapi.CTORATstpETFBasketField_ETFCreRedType_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpETFBasketField_swiginit(self, _traderapi.new_CTORATstpETFBasketField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpETFBasketField
+
+# Register CTORATstpETFBasketField in _traderapi:
+_traderapi.CTORATstpETFBasketField_swigregister(CTORATstpETFBasketField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟斤拷锟睫诧拷锟斤拷息############################################
+class CTORATstpQryInvestorPositionLimitField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryInvestorPositionLimitField_ExchangeID_get, _traderapi.CTORATstpQryInvestorPositionLimitField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryInvestorPositionLimitField_InvestorID_get, _traderapi.CTORATstpQryInvestorPositionLimitField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryInvestorPositionLimitField_SecurityID_get, _traderapi.CTORATstpQryInvestorPositionLimitField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryInvestorPositionLimitField_swiginit(self, _traderapi.new_CTORATstpQryInvestorPositionLimitField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryInvestorPositionLimitField
+
+# Register CTORATstpQryInvestorPositionLimitField in _traderapi:
+_traderapi.CTORATstpQryInvestorPositionLimitField_swigregister(CTORATstpQryInvestorPositionLimitField)
+
+
+
+
+#########################################投锟斤拷锟斤拷锟睫诧拷锟斤拷息############################################
+class CTORATstpInvestorPositionLimitField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpInvestorPositionLimitField_ExchangeID_get, _traderapi.CTORATstpInvestorPositionLimitField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpInvestorPositionLimitField_InvestorID_get, _traderapi.CTORATstpInvestorPositionLimitField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpInvestorPositionLimitField_SecurityID_get, _traderapi.CTORATstpInvestorPositionLimitField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ BuyLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_BuyLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_BuyLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷锟斤拷锟斤拷
+ BuyFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_BuyFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_BuyFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ SellLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_SellLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_SellLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ SellFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_SellFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_SellFrozen_set)
+
+ # 锟斤拷锟斤拷锟疥购锟斤拷锟�
+ PurchaseLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_PurchaseLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_PurchaseLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟疥购锟斤拷锟�
+ PurchaseFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_PurchaseFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_PurchaseFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷囟锟斤拷
+ RedeemLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_RedeemLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_RedeemLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷囟锟斤拷
+ RedeemFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_RedeemFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_RedeemFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟斤拷锟斤拷锟�
+ PledgeInLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_PledgeInLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_PledgeInLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷押锟斤拷锟斤拷锟�
+ PledgeInFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_PledgeInFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_PledgeInFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟斤拷锟斤拷锟斤拷
+ PledgeOutLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_PledgeOutLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_PledgeOutLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷押锟斤拷锟斤拷锟斤拷
+ PledgeOutFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_PledgeOutFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_PledgeOutFrozen_set)
+
+ # 锟斤拷锟斤拷债转锟缴讹拷锟�
+ ConvertLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_ConvertLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_ConvertLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷债转锟缴讹拷锟�
+ ConvertFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_ConvertFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_ConvertFrozen_set)
+
+ # 锟斤拷锟斤拷债券锟斤拷锟桔讹拷锟�
+ PutbackLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_PutbackLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_PutbackLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷债券锟斤拷锟桔讹拷锟�
+ PutbackFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_PutbackFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_PutbackFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟秸拷锟斤拷
+ RationalLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_RationalLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_RationalLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟斤拷锟斤拷锟斤拷锟秸拷锟斤拷
+ RationalFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_RationalFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_RationalFrozen_set)
+
+ # 锟杰持仓讹拷锟�
+ TotalPositionLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_TotalPositionLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_TotalPositionLimit_set)
+
+ # 锟斤拷使锟斤拷锟杰持仓讹拷锟�
+ TotalPositionFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_TotalPositionFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_TotalPositionFrozen_set)
+
+ # 锟斤拷锟秸诧拷侄锟斤拷
+ SplitLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_SplitLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_SplitLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟秸诧拷侄锟斤拷
+ SplitFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_SplitFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_SplitFrozen_set)
+
+ # 锟斤拷锟秸合诧拷锟斤拷锟�
+ MergeLimit = property(_traderapi.CTORATstpInvestorPositionLimitField_MergeLimit_get, _traderapi.CTORATstpInvestorPositionLimitField_MergeLimit_set)
+
+ # 锟斤拷使锟矫碉拷锟秸合诧拷锟斤拷锟�
+ MergeFrozen = property(_traderapi.CTORATstpInvestorPositionLimitField_MergeFrozen_get, _traderapi.CTORATstpInvestorPositionLimitField_MergeFrozen_set)
+
+ # 通锟斤拷统一锟斤拷锟斤拷识锟斤拷锟斤拷
+ UUPIC = property(_traderapi.CTORATstpInvestorPositionLimitField_UUPIC_get, _traderapi.CTORATstpInvestorPositionLimitField_UUPIC_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpInvestorPositionLimitField_swiginit(self, _traderapi.new_CTORATstpInvestorPositionLimitField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpInvestorPositionLimitField
+
+# Register CTORATstpInvestorPositionLimitField in _traderapi:
+_traderapi.CTORATstpInvestorPositionLimitField_swigregister(CTORATstpInvestorPositionLimitField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟阶刺拷锟较�############################################
+class CTORATstpQrySZSEImcParamsField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQrySZSEImcParamsField_MarketID_get, _traderapi.CTORATstpQrySZSEImcParamsField_MarketID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQrySZSEImcParamsField_swiginit(self, _traderapi.new_CTORATstpQrySZSEImcParamsField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQrySZSEImcParamsField
+
+# Register CTORATstpQrySZSEImcParamsField in _traderapi:
+_traderapi.CTORATstpQrySZSEImcParamsField_swigregister(CTORATstpQrySZSEImcParamsField)
+
+
+
+
+#########################################锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟阶刺拷锟较�############################################
+class CTORATstpSZSEImcParamsField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpSZSEImcParamsField_MarketID_get, _traderapi.CTORATstpSZSEImcParamsField_MarketID_set)
+
+ # 锟角否开凤拷
+ OpenFlag = property(_traderapi.CTORATstpSZSEImcParamsField_OpenFlag_get, _traderapi.CTORATstpSZSEImcParamsField_OpenFlag_set)
+
+ # 锟斤拷始锟斤拷锟�
+ ThresholdAmount = property(_traderapi.CTORATstpSZSEImcParamsField_ThresholdAmount_get, _traderapi.CTORATstpSZSEImcParamsField_ThresholdAmount_set)
+
+ # 锟斤拷锟斤拷剩锟斤拷锟斤拷
+ PosAmt = property(_traderapi.CTORATstpSZSEImcParamsField_PosAmt_get, _traderapi.CTORATstpSZSEImcParamsField_PosAmt_set)
+
+ # 锟斤拷锟斤拷欠锟斤拷锟斤拷
+ AmountStatus = property(_traderapi.CTORATstpSZSEImcParamsField_AmountStatus_get, _traderapi.CTORATstpSZSEImcParamsField_AmountStatus_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpSZSEImcParamsField_swiginit(self, _traderapi.new_CTORATstpSZSEImcParamsField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpSZSEImcParamsField
+
+# Register CTORATstpSZSEImcParamsField in _traderapi:
+_traderapi.CTORATstpSZSEImcParamsField_swigregister(CTORATstpSZSEImcParamsField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�############################################
+class CTORATstpQrySZSEImcExchangeRateField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 源锟斤拷锟揭憋拷锟斤拷
+ FromCurrency = property(_traderapi.CTORATstpQrySZSEImcExchangeRateField_FromCurrency_get, _traderapi.CTORATstpQrySZSEImcExchangeRateField_FromCurrency_set)
+
+ # 目锟斤拷锟斤拷冶锟斤拷锟�
+ ToCurrency = property(_traderapi.CTORATstpQrySZSEImcExchangeRateField_ToCurrency_get, _traderapi.CTORATstpQrySZSEImcExchangeRateField_ToCurrency_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQrySZSEImcExchangeRateField_swiginit(self, _traderapi.new_CTORATstpQrySZSEImcExchangeRateField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQrySZSEImcExchangeRateField
+
+# Register CTORATstpQrySZSEImcExchangeRateField in _traderapi:
+_traderapi.CTORATstpQrySZSEImcExchangeRateField_swigregister(CTORATstpQrySZSEImcExchangeRateField)
+
+
+
+
+#########################################锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�############################################
+class CTORATstpSZSEImcExchangeRateField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 源锟斤拷锟揭憋拷锟斤拷
+ FromCurrency = property(_traderapi.CTORATstpSZSEImcExchangeRateField_FromCurrency_get, _traderapi.CTORATstpSZSEImcExchangeRateField_FromCurrency_set)
+
+ # 目锟斤拷锟斤拷冶锟斤拷锟�
+ ToCurrency = property(_traderapi.CTORATstpSZSEImcExchangeRateField_ToCurrency_get, _traderapi.CTORATstpSZSEImcExchangeRateField_ToCurrency_set)
+
+ # 锟轿匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ BidRate = property(_traderapi.CTORATstpSZSEImcExchangeRateField_BidRate_get, _traderapi.CTORATstpSZSEImcExchangeRateField_BidRate_set)
+
+ # 锟轿匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ OfferRate = property(_traderapi.CTORATstpSZSEImcExchangeRateField_OfferRate_get, _traderapi.CTORATstpSZSEImcExchangeRateField_OfferRate_set)
+
+ # 锟轿匡拷锟斤拷锟斤拷锟叫硷拷锟�
+ MidPointRate = property(_traderapi.CTORATstpSZSEImcExchangeRateField_MidPointRate_get, _traderapi.CTORATstpSZSEImcExchangeRateField_MidPointRate_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpSZSEImcExchangeRateField_swiginit(self, _traderapi.new_CTORATstpSZSEImcExchangeRateField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpSZSEImcExchangeRateField
+
+# Register CTORATstpSZSEImcExchangeRateField in _traderapi:
+_traderapi.CTORATstpSZSEImcExchangeRateField_swigregister(CTORATstpSZSEImcExchangeRateField)
+
+
+
+
+#########################################锟斤拷询锟斤拷锟酵拷锟叫★拷鄄锟斤拷锟较�############################################
+class CTORATstpQrySZSEHKPriceTickInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟桔诧拷品锟斤拷
+ PriceTickID = property(_traderapi.CTORATstpQrySZSEHKPriceTickInfoField_PriceTickID_get, _traderapi.CTORATstpQrySZSEHKPriceTickInfoField_PriceTickID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQrySZSEHKPriceTickInfoField_swiginit(self, _traderapi.new_CTORATstpQrySZSEHKPriceTickInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQrySZSEHKPriceTickInfoField
+
+# Register CTORATstpQrySZSEHKPriceTickInfoField in _traderapi:
+_traderapi.CTORATstpQrySZSEHKPriceTickInfoField_swigregister(CTORATstpQrySZSEHKPriceTickInfoField)
+
+
+
+
+#########################################锟斤拷锟酵拷锟叫★拷鄄锟斤拷锟较�############################################
+class CTORATstpSZSEHKPriceTickInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟桔诧拷品锟斤拷
+ PriceTickID = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickID_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickID_set)
+
+ # 锟桔诧拷锟斤拷锟�
+ PriceTickGroupID = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickGroupID_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickGroupID_set)
+
+ # 锟桔诧拷锟斤拷锟�
+ PriceTickType = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickType_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTickType_set)
+
+ # 锟桔诧拷锟斤拷锟斤拷始锟桔革拷
+ BeginPrice = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_BeginPrice_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_BeginPrice_set)
+
+ # 锟桔诧拷锟斤拷锟斤拷锟斤拷鄹锟�
+ EndPrice = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_EndPrice_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_EndPrice_set)
+
+ # 锟桔诧拷值
+ PriceTick = property(_traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTick_get, _traderapi.CTORATstpSZSEHKPriceTickInfoField_PriceTick_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpSZSEHKPriceTickInfoField_swiginit(self, _traderapi.new_CTORATstpSZSEHKPriceTickInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpSZSEHKPriceTickInfoField
+
+# Register CTORATstpSZSEHKPriceTickInfoField in _traderapi:
+_traderapi.CTORATstpSZSEHKPriceTickInfoField_swigregister(CTORATstpSZSEHKPriceTickInfoField)
+
+
+
+
+#########################################锟斤拷询LOF锟斤拷锟斤拷锟斤拷息############################################
+class CTORATstpQryLofFundInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryLofFundInfoField_ExchangeID_get, _traderapi.CTORATstpQryLofFundInfoField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ FundID = property(_traderapi.CTORATstpQryLofFundInfoField_FundID_get, _traderapi.CTORATstpQryLofFundInfoField_FundID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ MainFundID = property(_traderapi.CTORATstpQryLofFundInfoField_MainFundID_get, _traderapi.CTORATstpQryLofFundInfoField_MainFundID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryLofFundInfoField_swiginit(self, _traderapi.new_CTORATstpQryLofFundInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryLofFundInfoField
+
+# Register CTORATstpQryLofFundInfoField in _traderapi:
+_traderapi.CTORATstpQryLofFundInfoField_swigregister(CTORATstpQryLofFundInfoField)
+
+
+
+
+#########################################LOF锟斤拷锟斤拷锟斤拷息############################################
+class CTORATstpLofFundInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpLofFundInfoField_ExchangeID_get, _traderapi.CTORATstpLofFundInfoField_ExchangeID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ FundID = property(_traderapi.CTORATstpLofFundInfoField_FundID_get, _traderapi.CTORATstpLofFundInfoField_FundID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ MainFundID = property(_traderapi.CTORATstpLofFundInfoField_MainFundID_get, _traderapi.CTORATstpLofFundInfoField_MainFundID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ FundType = property(_traderapi.CTORATstpLofFundInfoField_FundType_get, _traderapi.CTORATstpLofFundInfoField_FundType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟轿�
+ SplitUnit = property(_traderapi.CTORATstpLofFundInfoField_SplitUnit_get, _traderapi.CTORATstpLofFundInfoField_SplitUnit_set)
+
+ # 锟斤拷小锟斤拷锟斤拷锟斤拷锟�
+ SplitMinVol = property(_traderapi.CTORATstpLofFundInfoField_SplitMinVol_get, _traderapi.CTORATstpLofFundInfoField_SplitMinVol_set)
+
+ # 锟较诧拷锟斤拷锟斤拷锟斤拷位
+ MergeUnit = property(_traderapi.CTORATstpLofFundInfoField_MergeUnit_get, _traderapi.CTORATstpLofFundInfoField_MergeUnit_set)
+
+ # 锟斤拷小锟较诧拷锟斤拷锟斤拷
+ MergeMinVol = property(_traderapi.CTORATstpLofFundInfoField_MergeMinVol_get, _traderapi.CTORATstpLofFundInfoField_MergeMinVol_set)
+
+ # 锟斤拷锟斤拷转锟斤拷系锟斤拷
+ FundRatio = property(_traderapi.CTORATstpLofFundInfoField_FundRatio_get, _traderapi.CTORATstpLofFundInfoField_FundRatio_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpLofFundInfoField_swiginit(self, _traderapi.new_CTORATstpLofFundInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpLofFundInfoField
+
+# Register CTORATstpLofFundInfoField in _traderapi:
+_traderapi.CTORATstpLofFundInfoField_swigregister(CTORATstpLofFundInfoField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟斤拷锟斤拷押锟街诧拷############################################
+class CTORATstpQryPledgePositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPledgePositionField_InvestorID_get, _traderapi.CTORATstpQryPledgePositionField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPledgePositionField_SecurityID_get, _traderapi.CTORATstpQryPledgePositionField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPledgePositionField_ExchangeID_get, _traderapi.CTORATstpQryPledgePositionField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryPledgePositionField_MarketID_get, _traderapi.CTORATstpQryPledgePositionField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryPledgePositionField_ShareholderID_get, _traderapi.CTORATstpQryPledgePositionField_ShareholderID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryPledgePositionField_BusinessUnitID_get, _traderapi.CTORATstpQryPledgePositionField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPledgePositionField_swiginit(self, _traderapi.new_CTORATstpQryPledgePositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPledgePositionField
+
+# Register CTORATstpQryPledgePositionField in _traderapi:
+_traderapi.CTORATstpQryPledgePositionField_swigregister(CTORATstpQryPledgePositionField)
+
+
+
+
+#########################################投锟斤拷锟斤拷锟斤拷押锟街诧拷############################################
+class CTORATstpPledgePositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPledgePositionField_SecurityID_get, _traderapi.CTORATstpPledgePositionField_SecurityID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPledgePositionField_InvestorID_get, _traderapi.CTORATstpPledgePositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPledgePositionField_BusinessUnitID_get, _traderapi.CTORATstpPledgePositionField_BusinessUnitID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPledgePositionField_ExchangeID_get, _traderapi.CTORATstpPledgePositionField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPledgePositionField_MarketID_get, _traderapi.CTORATstpPledgePositionField_MarketID_set)
+
+ # 锟酵伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPledgePositionField_ShareholderID_get, _traderapi.CTORATstpPledgePositionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpPledgePositionField_TradingDay_get, _traderapi.CTORATstpPledgePositionField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟街诧拷
+ HisPledgePos = property(_traderapi.CTORATstpPledgePositionField_HisPledgePos_get, _traderapi.CTORATstpPledgePositionField_HisPledgePos_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟街仓讹拷锟斤拷
+ HisPledgePosFrozen = property(_traderapi.CTORATstpPledgePositionField_HisPledgePosFrozen_get, _traderapi.CTORATstpPledgePositionField_HisPledgePosFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷押锟街诧拷
+ TodayPledgePos = property(_traderapi.CTORATstpPledgePositionField_TodayPledgePos_get, _traderapi.CTORATstpPledgePositionField_TodayPledgePos_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷押锟街仓讹拷锟斤拷
+ TodayPledgePosFrozen = property(_traderapi.CTORATstpPledgePositionField_TodayPledgePosFrozen_get, _traderapi.CTORATstpPledgePositionField_TodayPledgePosFrozen_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟斤拷锟斤拷锟斤拷券锟斤拷锟斤拷
+ PreTotalPledgePos = property(_traderapi.CTORATstpPledgePositionField_PreTotalPledgePos_get, _traderapi.CTORATstpPledgePositionField_PreTotalPledgePos_set)
+
+ # 锟斤拷锟斤拷锟斤拷押锟斤拷锟斤拷锟斤拷券锟斤拷锟斤拷锟斤拷锟斤拷
+ PreAvailablePledgePos = property(_traderapi.CTORATstpPledgePositionField_PreAvailablePledgePos_get, _traderapi.CTORATstpPledgePositionField_PreAvailablePledgePos_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPledgePositionField_swiginit(self, _traderapi.new_CTORATstpPledgePositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPledgePositionField
+
+# Register CTORATstpPledgePositionField in _traderapi:
+_traderapi.CTORATstpPledgePositionField_swigregister(CTORATstpPledgePositionField)
+
+
+
+
+#########################################锟斤拷询证券锟斤拷押锟斤拷息############################################
+class CTORATstpQryPledgeInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPledgeInfoField_ExchangeID_get, _traderapi.CTORATstpQryPledgeInfoField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPledgeInfoField_SecurityID_get, _traderapi.CTORATstpQryPledgeInfoField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPledgeInfoField_swiginit(self, _traderapi.new_CTORATstpQryPledgeInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPledgeInfoField
+
+# Register CTORATstpQryPledgeInfoField in _traderapi:
+_traderapi.CTORATstpQryPledgeInfoField_swigregister(CTORATstpQryPledgeInfoField)
+
+
+
+
+#########################################证券锟斤拷押锟斤拷息############################################
+class CTORATstpPledgeInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPledgeInfoField_ExchangeID_get, _traderapi.CTORATstpPledgeInfoField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPledgeInfoField_MarketID_get, _traderapi.CTORATstpPledgeInfoField_MarketID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPledgeInfoField_SecurityID_get, _traderapi.CTORATstpPledgeInfoField_SecurityID_set)
+
+ # 锟斤拷押锟疥报锟斤拷锟斤拷
+ PledgeOrderID = property(_traderapi.CTORATstpPledgeInfoField_PledgeOrderID_get, _traderapi.CTORATstpPledgeInfoField_PledgeOrderID_set)
+
+ # 锟斤拷押锟斤拷锟斤拷
+ PledgeName = property(_traderapi.CTORATstpPledgeInfoField_PledgeName_get, _traderapi.CTORATstpPledgeInfoField_PledgeName_set)
+
+ # 锟斤拷准券锟斤拷锟斤拷
+ StandardBondID = property(_traderapi.CTORATstpPledgeInfoField_StandardBondID_get, _traderapi.CTORATstpPledgeInfoField_StandardBondID_set)
+
+ # 锟斤拷准券锟斤拷锟斤拷锟斤拷/锟斤拷锟斤拷值
+ ConversionRate = property(_traderapi.CTORATstpPledgeInfoField_ConversionRate_get, _traderapi.CTORATstpPledgeInfoField_ConversionRate_set)
+
+ # 每锟轿匡拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟阶碉拷位
+ PledgeInTradingUnit = property(_traderapi.CTORATstpPledgeInfoField_PledgeInTradingUnit_get, _traderapi.CTORATstpPledgeInfoField_PledgeInTradingUnit_set)
+
+ # 每锟轿匡拷锟皆筹拷锟斤拷锟斤拷锟叫★拷锟斤拷椎锟轿�
+ PledgeOutTradingUnit = property(_traderapi.CTORATstpPledgeInfoField_PledgeOutTradingUnit_get, _traderapi.CTORATstpPledgeInfoField_PledgeOutTradingUnit_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+ PledgeInVolMax = property(_traderapi.CTORATstpPledgeInfoField_PledgeInVolMax_get, _traderapi.CTORATstpPledgeInfoField_PledgeInVolMax_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟斤拷
+ PledgeInVolMin = property(_traderapi.CTORATstpPledgeInfoField_PledgeInVolMin_get, _traderapi.CTORATstpPledgeInfoField_PledgeInVolMin_set)
+
+ # 证券锟斤拷锟皆筹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ PledgeOutVolMax = property(_traderapi.CTORATstpPledgeInfoField_PledgeOutVolMax_get, _traderapi.CTORATstpPledgeInfoField_PledgeOutVolMax_set)
+
+ # 证券锟斤拷锟皆筹拷锟斤拷锟斤拷锟叫★拷锟斤拷锟�
+ PledgeOutVolMin = property(_traderapi.CTORATstpPledgeInfoField_PledgeOutVolMin_get, _traderapi.CTORATstpPledgeInfoField_PledgeOutVolMin_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPledgeInfoField_swiginit(self, _traderapi.new_CTORATstpPledgeInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPledgeInfoField
+
+# Register CTORATstpPledgeInfoField in _traderapi:
+_traderapi.CTORATstpPledgeInfoField_swigregister(CTORATstpPledgeInfoField)
+
+
+
+
+#########################################锟斤拷询系统锟节碉拷锟斤拷息############################################
+class CTORATstpQrySystemNodeInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟节碉拷锟斤拷
+ NodeID = property(_traderapi.CTORATstpQrySystemNodeInfoField_NodeID_get, _traderapi.CTORATstpQrySystemNodeInfoField_NodeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQrySystemNodeInfoField_swiginit(self, _traderapi.new_CTORATstpQrySystemNodeInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQrySystemNodeInfoField
+
+# Register CTORATstpQrySystemNodeInfoField in _traderapi:
+_traderapi.CTORATstpQrySystemNodeInfoField_swigregister(CTORATstpQrySystemNodeInfoField)
+
+
+
+
+#########################################系统锟节碉拷锟斤拷息############################################
+class CTORATstpSystemNodeInfoField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟节碉拷锟斤拷
+ NodeID = property(_traderapi.CTORATstpSystemNodeInfoField_NodeID_get, _traderapi.CTORATstpSystemNodeInfoField_NodeID_set)
+
+ # 锟节碉拷锟斤拷息
+ NodeInfo = property(_traderapi.CTORATstpSystemNodeInfoField_NodeInfo_get, _traderapi.CTORATstpSystemNodeInfoField_NodeInfo_set)
+
+ # 锟角凤拷前锟节碉拷
+ bCurrent = property(_traderapi.CTORATstpSystemNodeInfoField_bCurrent_get, _traderapi.CTORATstpSystemNodeInfoField_bCurrent_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpSystemNodeInfoField_swiginit(self, _traderapi.new_CTORATstpSystemNodeInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpSystemNodeInfoField
+
+# Register CTORATstpSystemNodeInfoField in _traderapi:
+_traderapi.CTORATstpSystemNodeInfoField_swigregister(CTORATstpSystemNodeInfoField)
+
+
+
+
+#########################################锟斤拷询投锟斤拷锟竭憋拷准券锟斤拷锟�############################################
+class CTORATstpQryStandardBondPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryStandardBondPositionField_InvestorID_get, _traderapi.CTORATstpQryStandardBondPositionField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryStandardBondPositionField_SecurityID_get, _traderapi.CTORATstpQryStandardBondPositionField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryStandardBondPositionField_ExchangeID_get, _traderapi.CTORATstpQryStandardBondPositionField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryStandardBondPositionField_MarketID_get, _traderapi.CTORATstpQryStandardBondPositionField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryStandardBondPositionField_ShareholderID_get, _traderapi.CTORATstpQryStandardBondPositionField_ShareholderID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryStandardBondPositionField_BusinessUnitID_get, _traderapi.CTORATstpQryStandardBondPositionField_BusinessUnitID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryStandardBondPositionField_swiginit(self, _traderapi.new_CTORATstpQryStandardBondPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryStandardBondPositionField
+
+# Register CTORATstpQryStandardBondPositionField in _traderapi:
+_traderapi.CTORATstpQryStandardBondPositionField_swigregister(CTORATstpQryStandardBondPositionField)
+
+
+
+
+#########################################投锟斤拷锟竭憋拷准券锟斤拷锟�############################################
+class CTORATstpStandardBondPositionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpStandardBondPositionField_SecurityID_get, _traderapi.CTORATstpStandardBondPositionField_SecurityID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpStandardBondPositionField_InvestorID_get, _traderapi.CTORATstpStandardBondPositionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpStandardBondPositionField_BusinessUnitID_get, _traderapi.CTORATstpStandardBondPositionField_BusinessUnitID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpStandardBondPositionField_ExchangeID_get, _traderapi.CTORATstpStandardBondPositionField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpStandardBondPositionField_MarketID_get, _traderapi.CTORATstpStandardBondPositionField_MarketID_set)
+
+ # 锟酵伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpStandardBondPositionField_ShareholderID_get, _traderapi.CTORATstpStandardBondPositionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpStandardBondPositionField_TradingDay_get, _traderapi.CTORATstpStandardBondPositionField_TradingDay_set)
+
+ # 锟斤拷准券锟斤拷锟矫讹拷锟�
+ AvailablePosition = property(_traderapi.CTORATstpStandardBondPositionField_AvailablePosition_get, _traderapi.CTORATstpStandardBondPositionField_AvailablePosition_set)
+
+ # 锟斤拷准券锟斤拷锟矫讹拷榷锟斤拷锟�
+ AvailablePosFrozen = property(_traderapi.CTORATstpStandardBondPositionField_AvailablePosFrozen_get, _traderapi.CTORATstpStandardBondPositionField_AvailablePosFrozen_set)
+
+ # 锟斤拷准券锟斤拷锟斤拷锟斤拷锟�
+ TotalPosition = property(_traderapi.CTORATstpStandardBondPositionField_TotalPosition_get, _traderapi.CTORATstpStandardBondPositionField_TotalPosition_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpStandardBondPositionField_swiginit(self, _traderapi.new_CTORATstpStandardBondPositionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpStandardBondPositionField
+
+# Register CTORATstpStandardBondPositionField in _traderapi:
+_traderapi.CTORATstpStandardBondPositionField_swigregister(CTORATstpStandardBondPositionField)
+
+
+
+
+#########################################锟斤拷询未锟斤拷锟斤拷债券锟斤拷押锟截癸拷委锟斤拷############################################
+class CTORATstpQryPrematurityRepoOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_InvestorID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_InvestorID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_SecurityID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_SecurityID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_ExchangeID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_MarketID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_MarketID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_ShareholderID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_ShareholderID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_BusinessUnitID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_BusinessUnitID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_OrderLocalID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_OrderLocalID_set)
+
+ # 证券品锟街达拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_ProductID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_SecurityType_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_SecurityType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ Direction = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_Direction_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_Direction_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpQryPrematurityRepoOrderField_TradeID_get, _traderapi.CTORATstpQryPrematurityRepoOrderField_TradeID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryPrematurityRepoOrderField_swiginit(self, _traderapi.new_CTORATstpQryPrematurityRepoOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryPrematurityRepoOrderField
+
+# Register CTORATstpQryPrematurityRepoOrderField in _traderapi:
+_traderapi.CTORATstpQryPrematurityRepoOrderField_swigregister(CTORATstpQryPrematurityRepoOrderField)
+
+
+
+
+#########################################未锟斤拷锟斤拷债券锟斤拷押锟截癸拷委锟斤拷############################################
+class CTORATstpPrematurityRepoOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpPrematurityRepoOrderField_ExchangeID_get, _traderapi.CTORATstpPrematurityRepoOrderField_ExchangeID_set)
+
+ # 锟叫筹拷锟斤拷锟斤拷
+ MarketID = property(_traderapi.CTORATstpPrematurityRepoOrderField_MarketID_get, _traderapi.CTORATstpPrematurityRepoOrderField_MarketID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpPrematurityRepoOrderField_InvestorID_get, _traderapi.CTORATstpPrematurityRepoOrderField_InvestorID_set)
+
+ # 锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpPrematurityRepoOrderField_ShareholderID_get, _traderapi.CTORATstpPrematurityRepoOrderField_ShareholderID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpPrematurityRepoOrderField_BusinessUnitID_get, _traderapi.CTORATstpPrematurityRepoOrderField_BusinessUnitID_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ TradeDay = property(_traderapi.CTORATstpPrematurityRepoOrderField_TradeDay_get, _traderapi.CTORATstpPrematurityRepoOrderField_TradeDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ExpireDay = property(_traderapi.CTORATstpPrematurityRepoOrderField_ExpireDay_get, _traderapi.CTORATstpPrematurityRepoOrderField_ExpireDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpPrematurityRepoOrderField_OrderLocalID_get, _traderapi.CTORATstpPrematurityRepoOrderField_OrderLocalID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpPrematurityRepoOrderField_SecurityID_get, _traderapi.CTORATstpPrematurityRepoOrderField_SecurityID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityName = property(_traderapi.CTORATstpPrematurityRepoOrderField_SecurityName_get, _traderapi.CTORATstpPrematurityRepoOrderField_SecurityName_set)
+
+ # 证券品锟街达拷锟斤拷
+ ProductID = property(_traderapi.CTORATstpPrematurityRepoOrderField_ProductID_get, _traderapi.CTORATstpPrematurityRepoOrderField_ProductID_set)
+
+ # 证券锟斤拷锟斤拷锟斤拷
+ SecurityType = property(_traderapi.CTORATstpPrematurityRepoOrderField_SecurityType_get, _traderapi.CTORATstpPrematurityRepoOrderField_SecurityType_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ Direction = property(_traderapi.CTORATstpPrematurityRepoOrderField_Direction_get, _traderapi.CTORATstpPrematurityRepoOrderField_Direction_set)
+
+ # 锟缴斤拷锟斤拷锟斤拷
+ VolumeTraded = property(_traderapi.CTORATstpPrematurityRepoOrderField_VolumeTraded_get, _traderapi.CTORATstpPrematurityRepoOrderField_VolumeTraded_set)
+
+ # 锟缴斤拷锟桔革拷
+ Price = property(_traderapi.CTORATstpPrematurityRepoOrderField_Price_get, _traderapi.CTORATstpPrematurityRepoOrderField_Price_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ Turnover = property(_traderapi.CTORATstpPrematurityRepoOrderField_Turnover_get, _traderapi.CTORATstpPrematurityRepoOrderField_Turnover_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpPrematurityRepoOrderField_TradeID_get, _traderapi.CTORATstpPrematurityRepoOrderField_TradeID_set)
+
+ # 锟斤拷锟斤拷应锟秸斤拷锟�
+ RepoTotalMoney = property(_traderapi.CTORATstpPrematurityRepoOrderField_RepoTotalMoney_get, _traderapi.CTORATstpPrematurityRepoOrderField_RepoTotalMoney_set)
+
+ # 锟斤拷息锟斤拷锟�
+ InterestAmount = property(_traderapi.CTORATstpPrematurityRepoOrderField_InterestAmount_get, _traderapi.CTORATstpPrematurityRepoOrderField_InterestAmount_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpPrematurityRepoOrderField_swiginit(self, _traderapi.new_CTORATstpPrematurityRepoOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpPrematurityRepoOrderField
+
+# Register CTORATstpPrematurityRepoOrderField in _traderapi:
+_traderapi.CTORATstpPrematurityRepoOrderField_swigregister(CTORATstpPrematurityRepoOrderField)
+
+
+
+
+#########################################锟斤拷询协锟介交锟阶憋拷锟斤拷############################################
+class CTORATstpQryNegoOrderField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryNegoOrderField_ExchangeID_get, _traderapi.CTORATstpQryNegoOrderField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryNegoOrderField_InvestorID_get, _traderapi.CTORATstpQryNegoOrderField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryNegoOrderField_BusinessUnitID_get, _traderapi.CTORATstpQryNegoOrderField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryNegoOrderField_SecurityID_get, _traderapi.CTORATstpQryNegoOrderField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryNegoOrderField_ShareholderID_get, _traderapi.CTORATstpQryNegoOrderField_ShareholderID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpQryNegoOrderField_OrderSysID_get, _traderapi.CTORATstpQryNegoOrderField_OrderSysID_set)
+
+ # Insert Time
+ InsertTimeStart = property(_traderapi.CTORATstpQryNegoOrderField_InsertTimeStart_get, _traderapi.CTORATstpQryNegoOrderField_InsertTimeStart_set)
+
+ # Insert Time
+ InsertTimeEnd = property(_traderapi.CTORATstpQryNegoOrderField_InsertTimeEnd_get, _traderapi.CTORATstpQryNegoOrderField_InsertTimeEnd_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryNegoOrderField_SInfo_get, _traderapi.CTORATstpQryNegoOrderField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryNegoOrderField_IInfo_get, _traderapi.CTORATstpQryNegoOrderField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryNegoOrderField_swiginit(self, _traderapi.new_CTORATstpQryNegoOrderField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryNegoOrderField
+
+# Register CTORATstpQryNegoOrderField in _traderapi:
+_traderapi.CTORATstpQryNegoOrderField_swigregister(CTORATstpQryNegoOrderField)
+
+
+
+
+#########################################锟斤拷询协锟介交锟阶筹拷锟斤拷############################################
+class CTORATstpQryNegoOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryNegoOrderActionField_ExchangeID_get, _traderapi.CTORATstpQryNegoOrderActionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryNegoOrderActionField_InvestorID_get, _traderapi.CTORATstpQryNegoOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryNegoOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpQryNegoOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryNegoOrderActionField_ShareholderID_get, _traderapi.CTORATstpQryNegoOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpQryNegoOrderActionField_OrderLocalID_get, _traderapi.CTORATstpQryNegoOrderActionField_OrderLocalID_set)
+
+ # 锟斤拷锟截筹拷锟斤拷锟斤拷锟�
+ CancelOrderLocalID = property(_traderapi.CTORATstpQryNegoOrderActionField_CancelOrderLocalID_get, _traderapi.CTORATstpQryNegoOrderActionField_CancelOrderLocalID_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpQryNegoOrderActionField_SInfo_get, _traderapi.CTORATstpQryNegoOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpQryNegoOrderActionField_IInfo_get, _traderapi.CTORATstpQryNegoOrderActionField_IInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryNegoOrderActionField_swiginit(self, _traderapi.new_CTORATstpQryNegoOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryNegoOrderActionField
+
+# Register CTORATstpQryNegoOrderActionField in _traderapi:
+_traderapi.CTORATstpQryNegoOrderActionField_swigregister(CTORATstpQryNegoOrderActionField)
+
+
+
+
+#########################################协锟介交锟阶筹拷锟斤拷############################################
+class CTORATstpNegoOrderActionField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpNegoOrderActionField_ExchangeID_get, _traderapi.CTORATstpNegoOrderActionField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpNegoOrderActionField_InvestorID_get, _traderapi.CTORATstpNegoOrderActionField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpNegoOrderActionField_BusinessUnitID_get, _traderapi.CTORATstpNegoOrderActionField_BusinessUnitID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpNegoOrderActionField_ShareholderID_get, _traderapi.CTORATstpNegoOrderActionField_ShareholderID_set)
+
+ # 锟斤拷锟斤拷锟斤拷志
+ ActionFlag = property(_traderapi.CTORATstpNegoOrderActionField_ActionFlag_get, _traderapi.CTORATstpNegoOrderActionField_ActionFlag_set)
+
+ # 锟斤拷锟截筹拷锟斤拷锟斤拷锟�
+ CancelOrderLocalID = property(_traderapi.CTORATstpNegoOrderActionField_CancelOrderLocalID_get, _traderapi.CTORATstpNegoOrderActionField_CancelOrderLocalID_set)
+
+ # 系统锟斤拷锟斤拷锟斤拷锟�
+ CancelOrderSysID = property(_traderapi.CTORATstpNegoOrderActionField_CancelOrderSysID_get, _traderapi.CTORATstpNegoOrderActionField_CancelOrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷系统锟斤拷锟斤拷锟斤拷锟�
+ OrderSysID = property(_traderapi.CTORATstpNegoOrderActionField_OrderSysID_get, _traderapi.CTORATstpNegoOrderActionField_OrderSysID_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟截憋拷锟斤拷锟斤拷锟�
+ OrderLocalID = property(_traderapi.CTORATstpNegoOrderActionField_OrderLocalID_get, _traderapi.CTORATstpNegoOrderActionField_OrderLocalID_set)
+
+ # 委锟叫凤拷式
+ Operway = property(_traderapi.CTORATstpNegoOrderActionField_Operway_get, _traderapi.CTORATstpNegoOrderActionField_Operway_set)
+
+ # 锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷息
+ SInfo = property(_traderapi.CTORATstpNegoOrderActionField_SInfo_get, _traderapi.CTORATstpNegoOrderActionField_SInfo_set)
+
+ # 锟斤拷锟轿革拷锟斤拷锟斤拷息
+ IInfo = property(_traderapi.CTORATstpNegoOrderActionField_IInfo_get, _traderapi.CTORATstpNegoOrderActionField_IInfo_set)
+
+ # 锟斤拷锟酵癸拷司锟斤拷锟脚达拷锟斤拷
+ DepartmentID = property(_traderapi.CTORATstpNegoOrderActionField_DepartmentID_get, _traderapi.CTORATstpNegoOrderActionField_DepartmentID_set)
+
+ # 锟斤拷锟斤拷锟矫伙拷
+ ActionUser = property(_traderapi.CTORATstpNegoOrderActionField_ActionUser_get, _traderapi.CTORATstpNegoOrderActionField_ActionUser_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ TradingDay = property(_traderapi.CTORATstpNegoOrderActionField_TradingDay_get, _traderapi.CTORATstpNegoOrderActionField_TradingDay_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷
+ ActionDate = property(_traderapi.CTORATstpNegoOrderActionField_ActionDate_get, _traderapi.CTORATstpNegoOrderActionField_ActionDate_set)
+
+ # 锟斤拷锟斤拷时锟斤拷
+ ActionTime = property(_traderapi.CTORATstpNegoOrderActionField_ActionTime_get, _traderapi.CTORATstpNegoOrderActionField_ActionTime_set)
+
+ # 锟斤拷锟斤拷状态
+ CancelOrderStatus = property(_traderapi.CTORATstpNegoOrderActionField_CancelOrderStatus_get, _traderapi.CTORATstpNegoOrderActionField_CancelOrderStatus_set)
+
+ # 状态锟斤拷息
+ StatusMsg = property(_traderapi.CTORATstpNegoOrderActionField_StatusMsg_get, _traderapi.CTORATstpNegoOrderActionField_StatusMsg_set)
+
+ # 锟斤拷锟斤拷锟斤拷
+ RequestID = property(_traderapi.CTORATstpNegoOrderActionField_RequestID_get, _traderapi.CTORATstpNegoOrderActionField_RequestID_set)
+
+ # 前锟矫憋拷锟�
+ ActionFrontID = property(_traderapi.CTORATstpNegoOrderActionField_ActionFrontID_get, _traderapi.CTORATstpNegoOrderActionField_ActionFrontID_set)
+
+ # 锟结话锟斤拷锟�
+ ActionSessionID = property(_traderapi.CTORATstpNegoOrderActionField_ActionSessionID_get, _traderapi.CTORATstpNegoOrderActionField_ActionSessionID_set)
+
+ # 锟斤拷锟阶碉拷元锟斤拷锟斤拷
+ PbuID = property(_traderapi.CTORATstpNegoOrderActionField_PbuID_get, _traderapi.CTORATstpNegoOrderActionField_PbuID_set)
+
+ # IP锟斤拷址
+ IPAddress = property(_traderapi.CTORATstpNegoOrderActionField_IPAddress_get, _traderapi.CTORATstpNegoOrderActionField_IPAddress_set)
+
+ # Mac锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpNegoOrderActionField_MacAddress_get, _traderapi.CTORATstpNegoOrderActionField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpNegoOrderActionField_swiginit(self, _traderapi.new_CTORATstpNegoOrderActionField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpNegoOrderActionField
+
+# Register CTORATstpNegoOrderActionField in _traderapi:
+_traderapi.CTORATstpNegoOrderActionField_swigregister(CTORATstpNegoOrderActionField)
+
+
+
+
+#########################################锟斤拷询协锟介交锟阶成斤拷############################################
+class CTORATstpQryNegoTradeField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryNegoTradeField_ExchangeID_get, _traderapi.CTORATstpQryNegoTradeField_ExchangeID_set)
+
+ # 投锟斤拷锟竭达拷锟斤拷
+ InvestorID = property(_traderapi.CTORATstpQryNegoTradeField_InvestorID_get, _traderapi.CTORATstpQryNegoTradeField_InvestorID_set)
+
+ # 投锟绞碉拷元锟斤拷锟斤拷
+ BusinessUnitID = property(_traderapi.CTORATstpQryNegoTradeField_BusinessUnitID_get, _traderapi.CTORATstpQryNegoTradeField_BusinessUnitID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryNegoTradeField_SecurityID_get, _traderapi.CTORATstpQryNegoTradeField_SecurityID_set)
+
+ # 锟缴讹拷锟剿伙拷锟斤拷锟斤拷
+ ShareholderID = property(_traderapi.CTORATstpQryNegoTradeField_ShareholderID_get, _traderapi.CTORATstpQryNegoTradeField_ShareholderID_set)
+
+ # 锟缴斤拷锟斤拷锟�
+ TradeID = property(_traderapi.CTORATstpQryNegoTradeField_TradeID_get, _traderapi.CTORATstpQryNegoTradeField_TradeID_set)
+
+ # Insert Time
+ TradeTimeStart = property(_traderapi.CTORATstpQryNegoTradeField_TradeTimeStart_get, _traderapi.CTORATstpQryNegoTradeField_TradeTimeStart_set)
+
+ # Insert Time
+ TradeTimeEnd = property(_traderapi.CTORATstpQryNegoTradeField_TradeTimeEnd_get, _traderapi.CTORATstpQryNegoTradeField_TradeTimeEnd_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryNegoTradeField_swiginit(self, _traderapi.new_CTORATstpQryNegoTradeField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryNegoTradeField
+
+# Register CTORATstpQryNegoTradeField in _traderapi:
+_traderapi.CTORATstpQryNegoTradeField_swigregister(CTORATstpQryNegoTradeField)
+
+
+
+
+#########################################锟斤拷询协锟介交锟阶诧拷锟斤拷############################################
+class CTORATstpQryNegotiationParamField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpQryNegotiationParamField_ExchangeID_get, _traderapi.CTORATstpQryNegotiationParamField_ExchangeID_set)
+
+ # 证券锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpQryNegotiationParamField_SecurityID_get, _traderapi.CTORATstpQryNegotiationParamField_SecurityID_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpQryNegotiationParamField_swiginit(self, _traderapi.new_CTORATstpQryNegotiationParamField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpQryNegotiationParamField
+
+# Register CTORATstpQryNegotiationParamField in _traderapi:
+_traderapi.CTORATstpQryNegotiationParamField_swigregister(CTORATstpQryNegotiationParamField)
+
+
+
+
+#########################################协锟介交锟阶诧拷锟斤拷############################################
+class CTORATstpNegotiationParamField(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+ __repr__ = _swig_repr
+
+ # 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ ExchangeID = property(_traderapi.CTORATstpNegotiationParamField_ExchangeID_get, _traderapi.CTORATstpNegotiationParamField_ExchangeID_set)
+
+ # 锟斤拷约锟斤拷锟斤拷
+ SecurityID = property(_traderapi.CTORATstpNegotiationParamField_SecurityID_get, _traderapi.CTORATstpNegotiationParamField_SecurityID_set)
+
+ # 锟斤拷锟诫交锟阶碉拷位
+ BuyTradingUnit = property(_traderapi.CTORATstpNegotiationParamField_BuyTradingUnit_get, _traderapi.CTORATstpNegotiationParamField_BuyTradingUnit_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟阶碉拷位
+ SellTradingUnit = property(_traderapi.CTORATstpNegotiationParamField_SellTradingUnit_get, _traderapi.CTORATstpNegotiationParamField_SellTradingUnit_set)
+
+ # 锟斤拷锟斤拷锟脚硷拷
+ MinOrderVolume = property(_traderapi.CTORATstpNegotiationParamField_MinOrderVolume_get, _traderapi.CTORATstpNegotiationParamField_MinOrderVolume_set)
+
+ # 锟斤拷锟斤拷偶锟�
+ MinOrderAmt = property(_traderapi.CTORATstpNegotiationParamField_MinOrderAmt_get, _traderapi.CTORATstpNegotiationParamField_MinOrderAmt_set)
+
+ # 锟斤拷小锟戒动锟斤拷位
+ PriceTick = property(_traderapi.CTORATstpNegotiationParamField_PriceTick_get, _traderapi.CTORATstpNegotiationParamField_PriceTick_set)
+
+ # 锟斤拷停锟斤拷锟�
+ UpperLimitPrice = property(_traderapi.CTORATstpNegotiationParamField_UpperLimitPrice_get, _traderapi.CTORATstpNegotiationParamField_UpperLimitPrice_set)
+
+ # 锟斤拷停锟斤拷锟�
+ LowerLimitPrice = property(_traderapi.CTORATstpNegotiationParamField_LowerLimitPrice_get, _traderapi.CTORATstpNegotiationParamField_LowerLimitPrice_set)
+
+ # 锟角凤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ bMarketMaker = property(_traderapi.CTORATstpNegotiationParamField_bMarketMaker_get, _traderapi.CTORATstpNegotiationParamField_bMarketMaker_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpNegotiationParamField_swiginit(self, _traderapi.new_CTORATstpNegotiationParamField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpNegotiationParamField
+
+# Register CTORATstpNegotiationParamField in _traderapi:
+_traderapi.CTORATstpNegotiationParamField_swigregister(CTORATstpNegotiationParamField)
+
+
+
+
+#########################################fens锟矫伙拷锟斤拷息############################################
+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(_traderapi.CTORATstpFensUserInfoField_FensVer_get, _traderapi.CTORATstpFensUserInfoField_FensVer_set)
+
+ # 锟斤拷锟斤拷锟斤拷锟�
+ FensEnvID = property(_traderapi.CTORATstpFensUserInfoField_FensEnvID_get, _traderapi.CTORATstpFensUserInfoField_FensEnvID_set)
+
+ # 锟节碉拷锟斤拷
+ FensNodeID = property(_traderapi.CTORATstpFensUserInfoField_FensNodeID_get, _traderapi.CTORATstpFensUserInfoField_FensNodeID_set)
+
+ # Fens锟矫伙拷锟斤拷锟斤拷
+ FensUserID = property(_traderapi.CTORATstpFensUserInfoField_FensUserID_get, _traderapi.CTORATstpFensUserInfoField_FensUserID_set)
+
+ # 锟矫伙拷锟斤拷锟斤拷
+ UserID = property(_traderapi.CTORATstpFensUserInfoField_UserID_get, _traderapi.CTORATstpFensUserInfoField_UserID_set)
+
+ # 锟秸讹拷锟斤拷息
+ ClientInfo = property(_traderapi.CTORATstpFensUserInfoField_ClientInfo_get, _traderapi.CTORATstpFensUserInfoField_ClientInfo_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpFensUserInfoField_swiginit(self, _traderapi.new_CTORATstpFensUserInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpFensUserInfoField
+
+# Register CTORATstpFensUserInfoField in _traderapi:
+_traderapi.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
+
+ # 锟矫伙拷锟斤拷锟斤拷锟斤拷
+ UserRequestID = property(_traderapi.CTORATstpConnectionInfoField_UserRequestID_get, _traderapi.CTORATstpConnectionInfoField_UserRequestID_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ InnerIPAddress = property(_traderapi.CTORATstpConnectionInfoField_InnerIPAddress_get, _traderapi.CTORATstpConnectionInfoField_InnerIPAddress_set)
+
+ # 锟斤拷锟斤拷锟剿口猴拷
+ InnerPort = property(_traderapi.CTORATstpConnectionInfoField_InnerPort_get, _traderapi.CTORATstpConnectionInfoField_InnerPort_set)
+
+ # 锟斤拷锟斤拷IP锟斤拷址
+ OuterIPAddress = property(_traderapi.CTORATstpConnectionInfoField_OuterIPAddress_get, _traderapi.CTORATstpConnectionInfoField_OuterIPAddress_set)
+
+ # 锟斤拷锟斤拷锟剿口猴拷
+ OuterPort = property(_traderapi.CTORATstpConnectionInfoField_OuterPort_get, _traderapi.CTORATstpConnectionInfoField_OuterPort_set)
+
+ # MAC锟斤拷址
+ MacAddress = property(_traderapi.CTORATstpConnectionInfoField_MacAddress_get, _traderapi.CTORATstpConnectionInfoField_MacAddress_set)
+
+ def __init__(self):
+ _traderapi.CTORATstpConnectionInfoField_swiginit(self, _traderapi.new_CTORATstpConnectionInfoField())
+ __swig_destroy__ = _traderapi.delete_CTORATstpConnectionInfoField
+
+# Register CTORATstpConnectionInfoField in _traderapi:
+_traderapi.CTORATstpConnectionInfoField_swigregister(CTORATstpConnectionInfoField)
+
+class CTORATstpTraderSpi(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) -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnFrontConnected(self)
+
+ #锟斤拷锟酵伙拷锟斤拷锟诫交锟阶猴拷台通锟斤拷锟斤拷锟接断匡拷时,锟矫凤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,API锟斤拷锟皆讹拷锟斤拷锟斤拷锟斤拷锟斤拷,锟酵伙拷锟剿可诧拷锟斤拷锟斤拷锟斤拷nReason为锟较匡拷原锟斤拷,-3 锟斤拷锟斤拷锟窖断匡拷,-4 锟斤拷锟斤拷锟绞э拷锟�,-5 锟斤拷锟斤拷写失锟斤拷,-6 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,-7 锟斤拷锟斤拷糯锟斤拷锟�,-8 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�,-9 锟斤拷锟斤拷谋锟斤拷锟�,-15锟斤拷锟斤拷锟绞э拷锟�,-16锟斤拷锟斤拷写失锟斤拷
+ def OnFrontDisconnected(self, nReason: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnFrontDisconnected(self, nReason)
+
+ #锟斤拷锟斤拷应锟斤拷
+ def OnRspError(self, pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspError(self, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷取锟斤拷锟斤拷锟斤拷息应锟斤拷,锟斤拷锟斤拷pConnectionInfoField锟斤拷一锟斤拷CTORATstpConnectionInfoField锟斤拷锟斤拷锟�
+ def OnRspGetConnectionInfo(self, pConnectionInfoField: "CTORATstpConnectionInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspGetConnectionInfo(self, pConnectionInfoField, pRspInfoField, nRequestID)
+
+ #锟斤拷录锟斤拷应,锟斤拷锟斤拷pRspUserLoginField锟斤拷一锟斤拷CTORATstpRspUserLoginField锟斤拷锟斤拷锟�
+ def OnRspUserLogin(self, pRspUserLoginField: "CTORATstpRspUserLoginField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspUserLogin(self, pRspUserLoginField, pRspInfoField, nRequestID)
+
+ #锟角筹拷锟斤拷应,锟斤拷锟斤拷pUserLogoutField锟斤拷一锟斤拷CTORATstpUserLogoutField锟斤拷锟斤拷锟�
+ def OnRspUserLogout(self, pUserLogoutField: "CTORATstpUserLogoutField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspUserLogout(self, pUserLogoutField, pRspInfoField, nRequestID)
+
+ #锟睫革拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pUserPasswordUpdateField锟斤拷一锟斤拷CTORATstpUserPasswordUpdateField锟斤拷锟斤拷锟�
+ def OnRspUserPasswordUpdate(self, pUserPasswordUpdateField: "CTORATstpUserPasswordUpdateField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspUserPasswordUpdate(self, pUserPasswordUpdateField, pRspInfoField, nRequestID)
+
+ #录锟斤拷锟借备锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pRspInputDeviceSerialField锟斤拷一锟斤拷CTORATstpRspInputDeviceSerialField锟斤拷锟斤拷锟�
+ def OnRspInputDeviceSerial(self, pRspInputDeviceSerialField: "CTORATstpRspInputDeviceSerialField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInputDeviceSerial(self, pRspInputDeviceSerialField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷录锟斤拷锟斤拷应,锟斤拷锟斤拷pInputOrderField锟斤拷一锟斤拷CTORATstpInputOrderField锟斤拷锟斤拷锟�
+ def OnRspOrderInsert(self, pInputOrderField: "CTORATstpInputOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspOrderInsert(self, pInputOrderField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟截憋拷,锟斤拷锟斤拷pOrderField锟斤拷一锟斤拷CTORATstpOrderField锟斤拷锟斤拷锟�
+ def OnRtnOrder(self, pOrderField: "CTORATstpOrderField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnOrder(self, pOrderField)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷乇锟�,锟斤拷锟斤拷pInputOrderField锟斤拷一锟斤拷CTORATstpInputOrderField锟斤拷锟斤拷锟�
+ def OnErrRtnOrderInsert(self, pInputOrderField: "CTORATstpInputOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnOrderInsert(self, pInputOrderField, pRspInfoField, nRequestID)
+
+ #锟缴斤拷锟截憋拷,锟斤拷锟斤拷pTradeField锟斤拷一锟斤拷CTORATstpTradeField锟斤拷锟斤拷锟�
+ def OnRtnTrade(self, pTradeField: "CTORATstpTradeField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnTrade(self, pTradeField)
+
+ #锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pInputOrderActionField锟斤拷一锟斤拷CTORATstpInputOrderActionField锟斤拷锟斤拷锟�
+ def OnRspOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspOrderAction(self, pInputOrderActionField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷乇锟�,锟斤拷锟斤拷pInputOrderActionField锟斤拷一锟斤拷CTORATstpInputOrderActionField锟斤拷锟斤拷锟�
+ def OnErrRtnOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnOrderAction(self, pInputOrderActionField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷应,锟斤拷锟斤拷pInputCondOrderField锟斤拷一锟斤拷CTORATstpInputCondOrderField锟斤拷锟斤拷锟�
+ def OnRspCondOrderInsert(self, pInputCondOrderField: "CTORATstpInputCondOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspCondOrderInsert(self, pInputCondOrderField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟截憋拷,锟斤拷锟斤拷pConditionOrderField锟斤拷一锟斤拷CTORATstpConditionOrderField锟斤拷锟斤拷锟�
+ def OnRtnCondOrder(self, pConditionOrderField: "CTORATstpConditionOrderField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnCondOrder(self, pConditionOrderField)
+
+ #锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷锟截憋拷,锟斤拷锟斤拷pInputCondOrderField锟斤拷一锟斤拷CTORATstpInputCondOrderField锟斤拷锟斤拷锟�
+ def OnErrRtnCondOrderInsert(self, pInputCondOrderField: "CTORATstpInputCondOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnCondOrderInsert(self, pInputCondOrderField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pInputCondOrderActionField锟斤拷一锟斤拷CTORATstpInputCondOrderActionField锟斤拷锟斤拷锟�
+ def OnRspCondOrderAction(self, pInputCondOrderActionField: "CTORATstpInputCondOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspCondOrderAction(self, pInputCondOrderActionField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷乇锟�,锟斤拷锟斤拷pInputCondOrderActionField锟斤拷一锟斤拷CTORATstpInputCondOrderActionField锟斤拷锟斤拷锟�
+ def OnErrRtnCondOrderAction(self, pInputCondOrderActionField: "CTORATstpInputCondOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnCondOrderAction(self, pInputCondOrderActionField, pRspInfoField, nRequestID)
+
+ #协锟介交锟阶憋拷锟斤拷录锟斤拷锟斤拷应,锟斤拷锟斤拷pInputNegoOrderField锟斤拷一锟斤拷CTORATstpInputNegoOrderField锟斤拷锟斤拷锟�
+ def OnRspNegoOrderInsert(self, pInputNegoOrderField: "CTORATstpInputNegoOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspNegoOrderInsert(self, pInputNegoOrderField, pRspInfoField, nRequestID)
+
+ #协锟介交锟阶憋拷锟斤拷锟截憋拷,锟斤拷锟斤拷pNegoOrderField锟斤拷一锟斤拷CTORATstpNegoOrderField锟斤拷锟斤拷锟�
+ def OnRtnNegoOrder(self, pNegoOrderField: "CTORATstpNegoOrderField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnNegoOrder(self, pNegoOrderField)
+
+ #协锟介交锟阶憋拷锟斤拷锟斤拷锟斤拷乇锟�,锟斤拷锟斤拷pInputNegoOrderField锟斤拷一锟斤拷CTORATstpInputNegoOrderField锟斤拷锟斤拷锟�
+ def OnErrRtnNegoOrderInsert(self, pInputNegoOrderField: "CTORATstpInputNegoOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnNegoOrderInsert(self, pInputNegoOrderField, pRspInfoField, nRequestID)
+
+ #协锟介交锟阶成斤拷锟截憋拷,锟斤拷锟斤拷pNegoTradeField锟斤拷一锟斤拷CTORATstpNegoTradeField锟斤拷锟斤拷锟�
+ def OnRtnNegoTrade(self, pNegoTradeField: "CTORATstpNegoTradeField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnNegoTrade(self, pNegoTradeField)
+
+ #协锟介交锟阶憋拷锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷应,锟斤拷锟斤拷pInputNegoOrderActionField锟斤拷一锟斤拷CTORATstpInputNegoOrderActionField锟斤拷锟斤拷锟�
+ def OnRspNegoOrderAction(self, pInputNegoOrderActionField: "CTORATstpInputNegoOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspNegoOrderAction(self, pInputNegoOrderActionField, pRspInfoField, nRequestID)
+
+ #协锟介交锟阶憋拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷乇锟�,锟斤拷锟斤拷pInputNegoOrderActionField锟斤拷一锟斤拷CTORATstpInputNegoOrderActionField锟斤拷锟斤拷锟�
+ def OnErrRtnNegoOrderAction(self, pInputNegoOrderActionField: "CTORATstpInputNegoOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnNegoOrderAction(self, pInputNegoOrderActionField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷录锟斤拷锟斤拷应锟斤拷锟斤拷展锟斤拷,锟斤拷锟斤拷pInputOrderExField锟斤拷一锟斤拷CTORATstpInputOrderExField锟斤拷锟斤拷锟�
+ def OnRspOrderInsertEx(self, pInputOrderExField: "CTORATstpInputOrderExField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspOrderInsertEx(self, pInputOrderExField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应锟斤拷锟斤拷展锟斤拷,锟斤拷锟斤拷pInputOrderActionExField锟斤拷一锟斤拷CTORATstpInputOrderActionExField锟斤拷锟斤拷锟�
+ def OnRspOrderActionEx(self, pInputOrderActionExField: "CTORATstpInputOrderActionExField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspOrderActionEx(self, pInputOrderActionExField, pRspInfoField, nRequestID)
+
+ #锟叫筹拷状态锟截憋拷,锟斤拷锟斤拷pMarketStatusField锟斤拷一锟斤拷CTORATstpMarketStatusField锟斤拷锟斤拷锟�
+ def OnRtnMarketStatus(self, pMarketStatusField: "CTORATstpMarketStatusField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnMarketStatus(self, pMarketStatusField)
+
+ #锟绞斤拷转锟斤拷锟斤拷应,锟斤拷锟斤拷pInputTransferFundField锟斤拷一锟斤拷CTORATstpInputTransferFundField锟斤拷锟斤拷锟�
+ def OnRspTransferFund(self, pInputTransferFundField: "CTORATstpInputTransferFundField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspTransferFund(self, pInputTransferFundField, pRspInfoField, nRequestID)
+
+ #锟绞斤拷转锟狡达拷锟斤拷乇锟�,锟斤拷锟斤拷pInputTransferFundField锟斤拷一锟斤拷CTORATstpInputTransferFundField锟斤拷锟斤拷锟�
+ def OnErrRtnTransferFund(self, pInputTransferFundField: "CTORATstpInputTransferFundField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnTransferFund(self, pInputTransferFundField, pRspInfoField, nRequestID)
+
+ #锟绞斤拷转锟狡回憋拷,锟斤拷锟斤拷pTransferFundField锟斤拷一锟斤拷CTORATstpTransferFundField锟斤拷锟斤拷锟�
+ def OnRtnTransferFund(self, pTransferFundField: "CTORATstpTransferFundField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnTransferFund(self, pTransferFundField)
+
+ #锟斤拷位转锟斤拷锟斤拷应,锟斤拷锟斤拷pInputTransferPositionField锟斤拷一锟斤拷CTORATstpInputTransferPositionField锟斤拷锟斤拷锟�
+ def OnRspTransferPosition(self, pInputTransferPositionField: "CTORATstpInputTransferPositionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspTransferPosition(self, pInputTransferPositionField, pRspInfoField, nRequestID)
+
+ #锟斤拷位转锟狡达拷锟斤拷乇锟�,锟斤拷锟斤拷pInputTransferPositionField锟斤拷一锟斤拷CTORATstpInputTransferPositionField锟斤拷锟斤拷锟�
+ def OnErrRtnTransferPosition(self, pInputTransferPositionField: "CTORATstpInputTransferPositionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnErrRtnTransferPosition(self, pInputTransferPositionField, pRspInfoField, nRequestID)
+
+ #锟斤拷位转锟狡回憋拷,锟斤拷锟斤拷pTransferPositionField锟斤拷一锟斤拷CTORATstpTransferPositionField锟斤拷锟斤拷锟�
+ def OnRtnTransferPosition(self, pTransferPositionField: "CTORATstpTransferPositionField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnTransferPosition(self, pTransferPositionField)
+
+ #锟斤拷围系统锟斤拷位转锟狡回憋拷,锟斤拷锟斤拷pPeripheryTransferPositionField锟斤拷一锟斤拷CTORATstpPeripheryTransferPositionField锟斤拷锟斤拷锟�
+ def OnRtnPeripheryTransferPosition(self, pPeripheryTransferPositionField: "CTORATstpPeripheryTransferPositionField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnPeripheryTransferPosition(self, pPeripheryTransferPositionField)
+
+ #锟斤拷围系统锟绞斤拷转锟狡回憋拷,锟斤拷锟斤拷pPeripheryTransferFundField锟斤拷一锟斤拷CTORATstpPeripheryTransferFundField锟斤拷锟斤拷锟�
+ def OnRtnPeripheryTransferFund(self, pPeripheryTransferFundField: "CTORATstpPeripheryTransferFundField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnPeripheryTransferFund(self, pPeripheryTransferFundField)
+
+ #锟斤拷询锟斤拷锟叫斤拷锟斤拷系统锟绞斤拷锟斤拷应,锟斤拷锟斤拷pRspInquiryJZFundField锟斤拷一锟斤拷CTORATstpRspInquiryJZFundField锟斤拷锟斤拷锟�
+ def OnRspInquiryJZFund(self, pRspInquiryJZFundField: "CTORATstpRspInquiryJZFundField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInquiryJZFund(self, pRspInquiryJZFundField, pRspInfoField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pRspInquiryBankAccountFundField锟斤拷一锟斤拷CTORATstpRspInquiryBankAccountFundField锟斤拷锟斤拷锟�
+ def OnRspInquiryBankAccountFund(self, pRspInquiryBankAccountFundField: "CTORATstpRspInquiryBankAccountFundField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInquiryBankAccountFund(self, pRspInquiryBankAccountFundField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷通知锟截憋拷,锟斤拷锟斤拷pTradingNoticeField锟斤拷一锟斤拷CTORATstpTradingNoticeField锟斤拷锟斤拷锟�
+ def OnRtnTradingNotice(self, pTradingNoticeField: "CTORATstpTradingNoticeField") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRtnTradingNotice(self, pTradingNoticeField)
+
+ #锟斤拷询锟斤拷蟊ǖ锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pRspInquiryMaxOrderVolumeField锟斤拷一锟斤拷CTORATstpRspInquiryMaxOrderVolumeField锟斤拷锟斤拷锟�
+ def OnRspInquiryMaxOrderVolume(self, pRspInquiryMaxOrderVolumeField: "CTORATstpRspInquiryMaxOrderVolumeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInquiryMaxOrderVolume(self, pRspInquiryMaxOrderVolumeField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟阶成斤拷锟斤拷锟叫度诧拷询锟斤拷应,锟斤拷锟斤拷pInquiryTradeConcentrationField锟斤拷一锟斤拷CTORATstpInquiryTradeConcentrationField锟斤拷锟斤拷锟�
+ def OnRspInquiryTradeConcentration(self, pInquiryTradeConcentrationField: "CTORATstpInquiryTradeConcentrationField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInquiryTradeConcentration(self, pInquiryTradeConcentrationField, pRspInfoField, nRequestID)
+
+ #锟斤拷锟斤拷锟睫改匡拷锟街成憋拷锟斤拷应,锟斤拷锟斤拷pReqModifyOpenPosCostField锟斤拷一锟斤拷CTORATstpReqModifyOpenPosCostField锟斤拷锟斤拷锟�
+ def OnRspModifyOpenPosCost(self, pReqModifyOpenPosCostField: "CTORATstpReqModifyOpenPosCostField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspModifyOpenPosCost(self, pReqModifyOpenPosCostField, pRspInfoField, nRequestID)
+
+ #录锟斤拷诘锟斤拷式锟斤拷锟斤拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pInputNodeFundAssignmentField锟斤拷一锟斤拷CTORATstpInputNodeFundAssignmentField锟斤拷锟斤拷锟�
+ def OnRspInputNodeFundAssignment(self, pInputNodeFundAssignmentField: "CTORATstpInputNodeFundAssignmentField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInputNodeFundAssignment(self, pInputNodeFundAssignmentField, pRspInfoField, nRequestID)
+
+ #锟斤拷询锟节碉拷锟绞斤拷锟斤拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pRspInquiryNodeFundAssignmentField锟斤拷一锟斤拷CTORATstpRspInquiryNodeFundAssignmentField锟斤拷锟斤拷锟�
+ def OnRspInquiryNodeFundAssignment(self, pRspInquiryNodeFundAssignmentField: "CTORATstpRspInquiryNodeFundAssignmentField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspInquiryNodeFundAssignment(self, pRspInquiryNodeFundAssignmentField, pRspInfoField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pExchangeField锟斤拷一锟斤拷CTORATstpExchangeField锟斤拷锟斤拷锟�
+ def OnRspQryExchange(self, pExchangeField: "CTORATstpExchangeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryExchange(self, pExchangeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询证券锟斤拷息锟斤拷应,锟斤拷锟斤拷pSecurityField锟斤拷一锟斤拷CTORATstpSecurityField锟斤拷锟斤拷锟�
+ def OnRspQrySecurity(self, pSecurityField: "CTORATstpSecurityField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQrySecurity(self, pSecurityField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟铰癸拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pIPOInfoField锟斤拷一锟斤拷CTORATstpIPOInfoField锟斤拷锟斤拷锟�
+ def OnRspQryIPOInfo(self, pIPOInfoField: "CTORATstpIPOInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryIPOInfo(self, pIPOInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟矫伙拷锟斤拷应,锟斤拷锟斤拷pUserField锟斤拷一锟斤拷CTORATstpUserField锟斤拷锟斤拷锟�
+ def OnRspQryUser(self, pUserField: "CTORATstpUserField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryUser(self, pUserField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pInvestorField锟斤拷一锟斤拷CTORATstpInvestorField锟斤拷锟斤拷锟�
+ def OnRspQryInvestor(self, pInvestorField: "CTORATstpInvestorField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryInvestor(self, pInvestorField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟缴讹拷锟剿伙拷锟斤拷应,锟斤拷锟斤拷pShareholderAccountField锟斤拷一锟斤拷CTORATstpShareholderAccountField锟斤拷锟斤拷锟�
+ def OnRspQryShareholderAccount(self, pShareholderAccountField: "CTORATstpShareholderAccountField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryShareholderAccount(self, pShareholderAccountField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟秸拷锟较拷锟接�,锟斤拷锟斤拷pRationalInfoField锟斤拷一锟斤拷CTORATstpRationalInfoField锟斤拷锟斤拷锟�
+ def OnRspQryRationalInfo(self, pRationalInfoField: "CTORATstpRationalInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryRationalInfo(self, pRationalInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pOrderField锟斤拷一锟斤拷CTORATstpOrderField锟斤拷锟斤拷锟�
+ def OnRspQryOrder(self, pOrderField: "CTORATstpOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryOrder(self, pOrderField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pOrderActionField锟斤拷一锟斤拷CTORATstpOrderActionField锟斤拷锟斤拷锟�
+ def OnRspQryOrderAction(self, pOrderActionField: "CTORATstpOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryOrderAction(self, pOrderActionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟缴斤拷锟斤拷应,锟斤拷锟斤拷pTradeField锟斤拷一锟斤拷CTORATstpTradeField锟斤拷锟斤拷锟�
+ def OnRspQryTrade(self, pTradeField: "CTORATstpTradeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryTrade(self, pTradeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟绞斤拷锟剿伙拷锟斤拷应,锟斤拷锟斤拷pTradingAccountField锟斤拷一锟斤拷CTORATstpTradingAccountField锟斤拷锟斤拷锟�
+ def OnRspQryTradingAccount(self, pTradingAccountField: "CTORATstpTradingAccountField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryTradingAccount(self, pTradingAccountField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询投锟斤拷锟竭持诧拷锟斤拷应,锟斤拷锟斤拷pPositionField锟斤拷一锟斤拷CTORATstpPositionField锟斤拷锟斤拷锟�
+ def OnRspQryPosition(self, pPositionField: "CTORATstpPositionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPosition(self, pPositionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pTradingFeeField锟斤拷一锟斤拷CTORATstpTradingFeeField锟斤拷锟斤拷锟�
+ def OnRspQryTradingFee(self, pTradingFeeField: "CTORATstpTradingFeeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryTradingFee(self, pTradingFeeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询佣锟斤拷锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pInvestorTradingFeeField锟斤拷一锟斤拷CTORATstpInvestorTradingFeeField锟斤拷锟斤拷锟�
+ def OnRspQryInvestorTradingFee(self, pInvestorTradingFeeField: "CTORATstpInvestorTradingFeeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryInvestorTradingFee(self, pInvestorTradingFeeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pIPOQuotaField锟斤拷一锟斤拷CTORATstpIPOQuotaField锟斤拷锟斤拷锟�
+ def OnRspQryIPOQuota(self, pIPOQuotaField: "CTORATstpIPOQuotaField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryIPOQuota(self, pIPOQuotaField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷细锟绞斤拷锟斤拷应,锟斤拷锟斤拷pOrderFundDetailField锟斤拷一锟斤拷CTORATstpOrderFundDetailField锟斤拷锟斤拷锟�
+ def OnRspQryOrderFundDetail(self, pOrderFundDetailField: "CTORATstpOrderFundDetailField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryOrderFundDetail(self, pOrderFundDetailField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟绞斤拷转锟斤拷锟斤拷水锟斤拷应,锟斤拷锟斤拷pFundTransferDetailField锟斤拷一锟斤拷CTORATstpFundTransferDetailField锟斤拷锟斤拷锟�
+ def OnRspQryFundTransferDetail(self, pFundTransferDetailField: "CTORATstpFundTransferDetailField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryFundTransferDetail(self, pFundTransferDetailField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟街诧拷转锟斤拷锟斤拷水锟斤拷应,锟斤拷锟斤拷pPositionTransferDetailField锟斤拷一锟斤拷CTORATstpPositionTransferDetailField锟斤拷锟斤拷锟�
+ def OnRspQryPositionTransferDetail(self, pPositionTransferDetailField: "CTORATstpPositionTransferDetailField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPositionTransferDetail(self, pPositionTransferDetailField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷围系统锟斤拷位锟斤拷锟斤拷锟斤拷水锟斤拷应,锟斤拷锟斤拷pPeripheryPositionTransferDetailField锟斤拷一锟斤拷CTORATstpPeripheryPositionTransferDetailField锟斤拷锟斤拷锟�
+ def OnRspQryPeripheryPositionTransferDetail(self, pPeripheryPositionTransferDetailField: "CTORATstpPeripheryPositionTransferDetailField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPeripheryPositionTransferDetail(self, pPeripheryPositionTransferDetailField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷围系统锟绞斤拷锟斤拷锟斤拷锟剿拷锟接�,锟斤拷锟斤拷pPeripheryFundTransferDetailField锟斤拷一锟斤拷CTORATstpPeripheryFundTransferDetailField锟斤拷锟斤拷锟�
+ def OnRspQryPeripheryFundTransferDetail(self, pPeripheryFundTransferDetailField: "CTORATstpPeripheryFundTransferDetailField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPeripheryFundTransferDetail(self, pPeripheryFundTransferDetailField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询债券转锟斤拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pBondConversionInfoField锟斤拷一锟斤拷CTORATstpBondConversionInfoField锟斤拷锟斤拷锟�
+ def OnRspQryBondConversionInfo(self, pBondConversionInfoField: "CTORATstpBondConversionInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryBondConversionInfo(self, pBondConversionInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询债券锟斤拷锟斤拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pBondPutbackInfoField锟斤拷一锟斤拷CTORATstpBondPutbackInfoField锟斤拷锟斤拷锟�
+ def OnRspQryBondPutbackInfo(self, pBondPutbackInfoField: "CTORATstpBondPutbackInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryBondPutbackInfo(self, pBondPutbackInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡诧拷锟斤拷锟斤拷应,锟斤拷锟斤拷pInvestorCondOrderLimitParamField锟斤拷一锟斤拷CTORATstpInvestorCondOrderLimitParamField锟斤拷锟斤拷锟�
+ def OnRspQryInvestorCondOrderLimitParam(self, pInvestorCondOrderLimitParamField: "CTORATstpInvestorCondOrderLimitParamField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryInvestorCondOrderLimitParam(self, pInvestorCondOrderLimitParamField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pConditionOrderField锟斤拷一锟斤拷CTORATstpConditionOrderField锟斤拷锟斤拷锟�
+ def OnRspQryConditionOrder(self, pConditionOrderField: "CTORATstpConditionOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryConditionOrder(self, pConditionOrderField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应,锟斤拷锟斤拷pCondOrderActionField锟斤拷一锟斤拷CTORATstpCondOrderActionField锟斤拷锟斤拷锟�
+ def OnRspQryCondOrderAction(self, pCondOrderActionField: "CTORATstpCondOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryCondOrderAction(self, pCondOrderActionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷通知锟斤拷应,锟斤拷锟斤拷pTradingNoticeField锟斤拷一锟斤拷CTORATstpTradingNoticeField锟斤拷锟斤拷锟�
+ def OnRspQryTradingNotice(self, pTradingNoticeField: "CTORATstpTradingNoticeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryTradingNotice(self, pTradingNoticeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷沤锟斤拷锟斤拷应,锟斤拷锟斤拷pIPONumberResultField锟斤拷一锟斤拷CTORATstpIPONumberResultField锟斤拷锟斤拷锟�
+ def OnRspQryIPONumberResult(self, pIPONumberResultField: "CTORATstpIPONumberResultField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryIPONumberResult(self, pIPONumberResultField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷签锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pIPOMatchNumberResultField锟斤拷一锟斤拷CTORATstpIPOMatchNumberResultField锟斤拷锟斤拷锟�
+ def OnRspQryIPOMatchNumberResult(self, pIPOMatchNumberResultField: "CTORATstpIPOMatchNumberResultField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryIPOMatchNumberResult(self, pIPOMatchNumberResultField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟斤拷协锟斤拷锟斤拷应,锟斤拷锟斤拷pShareholderSpecPrivilegeField锟斤拷一锟斤拷CTORATstpShareholderSpecPrivilegeField锟斤拷锟斤拷锟�
+ def OnRspQryShareholderSpecPrivilege(self, pShareholderSpecPrivilegeField: "CTORATstpShareholderSpecPrivilegeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryShareholderSpecPrivilege(self, pShareholderSpecPrivilegeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟叫筹拷锟斤拷应,锟斤拷锟斤拷pMarketField锟斤拷一锟斤拷CTORATstpMarketField锟斤拷锟斤拷锟�
+ def OnRspQryMarket(self, pMarketField: "CTORATstpMarketField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryMarket(self, pMarketField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询ETF锟藉单锟斤拷息锟斤拷应,锟斤拷锟斤拷pETFFileField锟斤拷一锟斤拷CTORATstpETFFileField锟斤拷锟斤拷锟�
+ def OnRspQryETFFile(self, pETFFileField: "CTORATstpETFFileField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryETFFile(self, pETFFileField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询ETF锟缴凤拷证券锟斤拷息锟斤拷应,锟斤拷锟斤拷pETFBasketField锟斤拷一锟斤拷CTORATstpETFBasketField锟斤拷锟斤拷锟�
+ def OnRspQryETFBasket(self, pETFBasketField: "CTORATstpETFBasketField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryETFBasket(self, pETFBasketField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询投锟斤拷锟斤拷锟睫诧拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pInvestorPositionLimitField锟斤拷一锟斤拷CTORATstpInvestorPositionLimitField锟斤拷锟斤拷锟�
+ def OnRspQryInvestorPositionLimit(self, pInvestorPositionLimitField: "CTORATstpInvestorPositionLimitField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryInvestorPositionLimit(self, pInvestorPositionLimitField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟阶刺拷锟较拷锟接�,锟斤拷锟斤拷pSZSEImcParamsField锟斤拷一锟斤拷CTORATstpSZSEImcParamsField锟斤拷锟斤拷锟�
+ def OnRspQrySZSEImcParams(self, pSZSEImcParamsField: "CTORATstpSZSEImcParamsField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQrySZSEImcParams(self, pSZSEImcParamsField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较拷锟接�,锟斤拷锟斤拷pSZSEImcExchangeRateField锟斤拷一锟斤拷CTORATstpSZSEImcExchangeRateField锟斤拷锟斤拷锟�
+ def OnRspQrySZSEImcExchangeRate(self, pSZSEImcExchangeRateField: "CTORATstpSZSEImcExchangeRateField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQrySZSEImcExchangeRate(self, pSZSEImcExchangeRateField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷锟酵拷锟叫★拷鄄锟斤拷锟较拷锟接�,锟斤拷锟斤拷pSZSEHKPriceTickInfoField锟斤拷一锟斤拷CTORATstpSZSEHKPriceTickInfoField锟斤拷锟斤拷锟�
+ def OnRspQrySZSEHKPriceTickInfo(self, pSZSEHKPriceTickInfoField: "CTORATstpSZSEHKPriceTickInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQrySZSEHKPriceTickInfo(self, pSZSEHKPriceTickInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询LOF锟斤拷锟斤拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pLofFundInfoField锟斤拷一锟斤拷CTORATstpLofFundInfoField锟斤拷锟斤拷锟�
+ def OnRspQryLofFundInfo(self, pLofFundInfoField: "CTORATstpLofFundInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryLofFundInfo(self, pLofFundInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷押锟街诧拷锟斤拷应,锟斤拷锟斤拷pPledgePositionField锟斤拷一锟斤拷CTORATstpPledgePositionField锟斤拷锟斤拷锟�
+ def OnRspQryPledgePosition(self, pPledgePositionField: "CTORATstpPledgePositionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPledgePosition(self, pPledgePositionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询证券锟斤拷押锟斤拷息锟斤拷应,锟斤拷锟斤拷pPledgeInfoField锟斤拷一锟斤拷CTORATstpPledgeInfoField锟斤拷锟斤拷锟�
+ def OnRspQryPledgeInfo(self, pPledgeInfoField: "CTORATstpPledgeInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPledgeInfo(self, pPledgeInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询系统锟节碉拷锟斤拷息锟斤拷应,锟斤拷锟斤拷pSystemNodeInfoField锟斤拷一锟斤拷CTORATstpSystemNodeInfoField锟斤拷锟斤拷锟�
+ def OnRspQrySystemNodeInfo(self, pSystemNodeInfoField: "CTORATstpSystemNodeInfoField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQrySystemNodeInfo(self, pSystemNodeInfoField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询锟斤拷准券锟斤拷锟斤拷锟接�,锟斤拷锟斤拷pStandardBondPositionField锟斤拷一锟斤拷CTORATstpStandardBondPositionField锟斤拷锟斤拷锟�
+ def OnRspQryStandardBondPosition(self, pStandardBondPositionField: "CTORATstpStandardBondPositionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryStandardBondPosition(self, pStandardBondPositionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询未锟斤拷锟斤拷债券锟斤拷押锟截癸拷委锟斤拷锟斤拷应,锟斤拷锟斤拷pPrematurityRepoOrderField锟斤拷一锟斤拷CTORATstpPrematurityRepoOrderField锟斤拷锟斤拷锟�
+ def OnRspQryPrematurityRepoOrder(self, pPrematurityRepoOrderField: "CTORATstpPrematurityRepoOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryPrematurityRepoOrder(self, pPrematurityRepoOrderField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询协锟介交锟阶憋拷锟斤拷锟斤拷应,锟斤拷锟斤拷pNegoOrderField锟斤拷一锟斤拷CTORATstpNegoOrderField锟斤拷锟斤拷锟�
+ def OnRspQryNegoOrder(self, pNegoOrderField: "CTORATstpNegoOrderField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryNegoOrder(self, pNegoOrderField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询协锟介交锟阶筹拷锟斤拷锟斤拷应,锟斤拷锟斤拷pNegoOrderActionField锟斤拷一锟斤拷CTORATstpNegoOrderActionField锟斤拷锟斤拷锟�
+ def OnRspQryNegoOrderAction(self, pNegoOrderActionField: "CTORATstpNegoOrderActionField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryNegoOrderAction(self, pNegoOrderActionField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询协锟介交锟阶成斤拷锟斤拷应,锟斤拷锟斤拷pNegoTradeField锟斤拷一锟斤拷CTORATstpNegoTradeField锟斤拷锟斤拷锟�
+ def OnRspQryNegoTrade(self, pNegoTradeField: "CTORATstpNegoTradeField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryNegoTrade(self, pNegoTradeField, pRspInfoField, nRequestID, bIsLast)
+
+ #锟斤拷询协锟介交锟阶诧拷锟斤拷锟斤拷应,锟斤拷锟斤拷pNegotiationParamField锟斤拷一锟斤拷CTORATstpNegotiationParamField锟斤拷锟斤拷锟�
+ def OnRspQryNegotiationParam(self, pNegotiationParamField: "CTORATstpNegotiationParamField", pRspInfoField: "CTORATstpRspInfoField", nRequestID: "int", bIsLast: "bool") -> "void":
+ return _traderapi.CTORATstpTraderSpi_OnRspQryNegotiationParam(self, pNegotiationParamField, pRspInfoField, nRequestID, bIsLast)
+
+ def __init__(self):
+ if self.__class__ == CTORATstpTraderSpi:
+ _self = None
+ else:
+ _self = self
+ _traderapi.CTORATstpTraderSpi_swiginit(self, _traderapi.new_CTORATstpTraderSpi(_self, ))
+ __swig_destroy__ = _traderapi.delete_CTORATstpTraderSpi
+ def __disown__(self):
+ self.this.disown()
+ _traderapi.disown_CTORATstpTraderSpi(self)
+ return weakref.proxy(self)
+
+# Register CTORATstpTraderSpi in _traderapi:
+_traderapi.CTORATstpTraderSpi_swigregister(CTORATstpTraderSpi)
+
+class CTORATstpTraderApi(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
+ #锟斤拷锟斤拷锟接口讹拷锟斤拷,锟斤拷锟斤拷1为锟斤拷锟侥硷拷锟斤拷锟侥柯�,锟斤拷锟斤拷2为锟斤拷锟斤拷锟斤拷锟斤拷锟角凤拷锟斤拷艽锟斤拷锟�
+ def CreateTstpTraderApi(*args) -> "TORASTOCKAPI::CTORATstpTraderApi *":
+ return _traderapi.CTORATstpTraderApi_CreateTstpTraderApi(*args)
+
+ @staticmethod
+ #锟斤拷取锟接口版本锟斤拷
+ def GetApiVersion() -> "char const *":
+ return _traderapi.CTORATstpTraderApi_GetApiVersion()
+
+ #删锟斤拷锟接口讹拷锟斤拷,锟斤拷锟斤拷使锟矫憋拷锟接口讹拷锟斤拷时,锟斤拷锟矫该猴拷锟斤拷删锟斤拷锟接口讹拷锟斤拷
+ def Release(self) -> "void":
+ return _traderapi.CTORATstpTraderApi_Release(self)
+
+ #锟斤拷始锟斤拷锟接口讹拷锟斤拷,锟斤拷始锟斤拷锟斤拷锟叫伙拷锟斤拷,只锟叫碉拷锟矫猴拷,锟接口才匡拷始锟斤拷锟斤拷
+ def Init(self) -> "void":
+ return _traderapi.CTORATstpTraderApi_Init(self)
+
+ #锟饺达拷锟接匡拷锟竭程斤拷锟斤拷锟斤拷锟斤拷
+ def Join(self) -> "int":
+ return _traderapi.CTORATstpTraderApi_Join(self)
+
+ #注锟斤拷前锟矫伙拷锟斤拷锟斤拷锟街�,pszFrontAddress为前锟矫伙拷锟斤拷锟斤拷锟街�,锟斤拷式tcp://127.0.0.1:17001
+ def RegisterFront(self, pszFrontAddress: "char *") -> "void":
+ return _traderapi.CTORATstpTraderApi_RegisterFront(self, pszFrontAddress)
+
+ #注锟斤拷锟斤拷锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街�,pszNsAddress为锟斤拷锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街�,锟斤拷式tcp://127.0.0.1:12001
+ def RegisterNameServer(self, pszNsAddress: "char *") -> "void":
+ return _traderapi.CTORATstpTraderApi_RegisterNameServer(self, pszNsAddress)
+
+ #@param pFensUserInfoField锟斤拷锟矫伙拷锟斤拷息锟斤拷,锟斤拷锟斤拷pFensUserInfoField锟斤拷一锟斤拷CTORATstpFensUserInfoField锟斤拷锟斤拷锟�
+ def RegisterFensUserInfo(self, pFensUserInfoField: "CTORATstpFensUserInfoField") -> "void":
+ return _traderapi.CTORATstpTraderApi_RegisterFensUserInfo(self, pFensUserInfoField)
+
+ #注锟斤拷氐锟斤拷涌锟�,pSpi为锟斤拷锟斤拷锟皆回碉拷锟接匡拷锟斤拷锟绞碉拷锟�
+ def RegisterSpi(self, pSpi: "CTORATstpTraderSpi") -> "void":
+ return _traderapi.CTORATstpTraderApi_RegisterSpi(self, pSpi)
+
+ #锟斤拷锟斤拷私锟斤拷锟斤拷,nResumeType为私锟斤拷锟斤拷锟截达拷锟斤拷式,TORA_TERT_RESTART锟斤拷示锟接憋拷锟斤拷锟斤拷锟秸匡拷始锟截达拷,TORA_TERT_RESUME锟斤拷示锟斤拷锟较达拷锟秸碉拷锟斤拷锟斤拷锟斤拷,TORA_TERT_QUICK锟斤拷示只锟斤拷锟酵碉拷录锟斤拷私锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+ def SubscribePrivateTopic(self, nResumeType: "TORASTOCKAPI::TORA_TE_RESUME_TYPE") -> "void":
+ return _traderapi.CTORATstpTraderApi_SubscribePrivateTopic(self, nResumeType)
+
+ #锟斤拷锟侥癸拷锟斤拷锟斤拷,nResumeType为锟斤拷锟斤拷锟斤拷锟截达拷锟斤拷式,TORA_TERT_RESTART锟斤拷示锟接憋拷锟斤拷锟斤拷锟秸匡拷始锟截达拷,TORA_TERT_RESUME锟斤拷示锟斤拷锟较达拷锟秸碉拷锟斤拷锟斤拷锟斤拷,TORA_TERT_QUICK锟斤拷示只锟斤拷锟酵碉拷录锟襟公癸拷锟斤拷锟斤拷锟斤拷锟斤拷
+ def SubscribePublicTopic(self, nResumeType: "TORASTOCKAPI::TORA_TE_RESUME_TYPE") -> "void":
+ return _traderapi.CTORATstpTraderApi_SubscribePublicTopic(self, nResumeType)
+
+ #锟斤拷取锟斤拷锟斤拷锟斤拷息
+ def ReqGetConnectionInfo(self, nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqGetConnectionInfo(self, nRequestID)
+
+ #锟斤拷录锟斤拷锟斤拷,锟斤拷锟斤拷pReqUserLoginField锟斤拷一锟斤拷CTORATstpReqUserLoginField锟斤拷锟斤拷锟�
+ def ReqUserLogin(self, pReqUserLoginField: "CTORATstpReqUserLoginField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqUserLogin(self, pReqUserLoginField, nRequestID)
+
+ #锟角筹拷锟斤拷锟斤拷,锟斤拷锟斤拷pUserLogoutField锟斤拷一锟斤拷CTORATstpUserLogoutField锟斤拷锟斤拷锟�
+ def ReqUserLogout(self, pUserLogoutField: "CTORATstpUserLogoutField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqUserLogout(self, pUserLogoutField, nRequestID)
+
+ #锟睫革拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pUserPasswordUpdateField锟斤拷一锟斤拷CTORATstpUserPasswordUpdateField锟斤拷锟斤拷锟�
+ def ReqUserPasswordUpdate(self, pUserPasswordUpdateField: "CTORATstpUserPasswordUpdateField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqUserPasswordUpdate(self, pUserPasswordUpdateField, nRequestID)
+
+ #录锟斤拷锟借备锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pReqInputDeviceSerialField锟斤拷一锟斤拷CTORATstpReqInputDeviceSerialField锟斤拷锟斤拷锟�
+ def ReqInputDeviceSerial(self, pReqInputDeviceSerialField: "CTORATstpReqInputDeviceSerialField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInputDeviceSerial(self, pReqInputDeviceSerialField, nRequestID)
+
+ #锟斤拷锟斤拷录锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputOrderField锟斤拷一锟斤拷CTORATstpInputOrderField锟斤拷锟斤拷锟�
+ def ReqOrderInsert(self, pInputOrderField: "CTORATstpInputOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqOrderInsert(self, pInputOrderField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputOrderActionField锟斤拷一锟斤拷CTORATstpInputOrderActionField锟斤拷锟斤拷锟�
+ def ReqOrderAction(self, pInputOrderActionField: "CTORATstpInputOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqOrderAction(self, pInputOrderActionField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputCondOrderField锟斤拷一锟斤拷CTORATstpInputCondOrderField锟斤拷锟斤拷锟�
+ def ReqCondOrderInsert(self, pInputCondOrderField: "CTORATstpInputCondOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqCondOrderInsert(self, pInputCondOrderField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputCondOrderActionField锟斤拷一锟斤拷CTORATstpInputCondOrderActionField锟斤拷锟斤拷锟�
+ def ReqCondOrderAction(self, pInputCondOrderActionField: "CTORATstpInputCondOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqCondOrderAction(self, pInputCondOrderActionField, nRequestID)
+
+ #协锟介交锟阶憋拷锟斤拷录锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputNegoOrderField锟斤拷一锟斤拷CTORATstpInputNegoOrderField锟斤拷锟斤拷锟�
+ def ReqNegoOrderInsert(self, pInputNegoOrderField: "CTORATstpInputNegoOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqNegoOrderInsert(self, pInputNegoOrderField, nRequestID)
+
+ #协锟介交锟阶憋拷锟斤拷锟斤拷锟斤拷录锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputNegoOrderActionField锟斤拷一锟斤拷CTORATstpInputNegoOrderActionField锟斤拷锟斤拷锟�
+ def ReqNegoOrderAction(self, pInputNegoOrderActionField: "CTORATstpInputNegoOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqNegoOrderAction(self, pInputNegoOrderActionField, nRequestID)
+
+ #锟斤拷锟斤拷录锟斤拷锟斤拷锟斤拷锟斤拷展锟斤拷,锟斤拷锟斤拷pInputOrderExField锟斤拷一锟斤拷CTORATstpInputOrderExField锟斤拷锟斤拷锟�
+ def ReqOrderInsertEx(self, pInputOrderExField: "CTORATstpInputOrderExField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqOrderInsertEx(self, pInputOrderExField, nRequestID)
+
+ #锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷展锟斤拷,锟斤拷锟斤拷pInputOrderActionExField锟斤拷一锟斤拷CTORATstpInputOrderActionExField锟斤拷锟斤拷锟�
+ def ReqOrderActionEx(self, pInputOrderActionExField: "CTORATstpInputOrderActionExField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqOrderActionEx(self, pInputOrderActionExField, nRequestID)
+
+ #锟绞斤拷转锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputTransferFundField锟斤拷一锟斤拷CTORATstpInputTransferFundField锟斤拷锟斤拷锟�
+ def ReqTransferFund(self, pInputTransferFundField: "CTORATstpInputTransferFundField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqTransferFund(self, pInputTransferFundField, nRequestID)
+
+ #锟斤拷位转锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pInputTransferPositionField锟斤拷一锟斤拷CTORATstpInputTransferPositionField锟斤拷锟斤拷锟�
+ def ReqTransferPosition(self, pInputTransferPositionField: "CTORATstpInputTransferPositionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqTransferPosition(self, pInputTransferPositionField, nRequestID)
+
+ #锟斤拷询锟斤拷锟叫斤拷锟斤拷系统锟绞斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pReqInquiryJZFundField锟斤拷一锟斤拷CTORATstpReqInquiryJZFundField锟斤拷锟斤拷锟�
+ def ReqInquiryJZFund(self, pReqInquiryJZFundField: "CTORATstpReqInquiryJZFundField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInquiryJZFund(self, pReqInquiryJZFundField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟剿伙拷锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pReqInquiryBankAccountFundField锟斤拷一锟斤拷CTORATstpReqInquiryBankAccountFundField锟斤拷锟斤拷锟�
+ def ReqInquiryBankAccountFund(self, pReqInquiryBankAccountFundField: "CTORATstpReqInquiryBankAccountFundField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInquiryBankAccountFund(self, pReqInquiryBankAccountFundField, nRequestID)
+
+ #锟斤拷询锟斤拷蟊ǖ锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pReqInquiryMaxOrderVolumeField锟斤拷一锟斤拷CTORATstpReqInquiryMaxOrderVolumeField锟斤拷锟斤拷锟�
+ def ReqInquiryMaxOrderVolume(self, pReqInquiryMaxOrderVolumeField: "CTORATstpReqInquiryMaxOrderVolumeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInquiryMaxOrderVolume(self, pReqInquiryMaxOrderVolumeField, nRequestID)
+
+ #锟斤拷询锟斤拷锟阶成斤拷锟斤拷锟叫讹拷锟斤拷锟斤拷,锟斤拷锟斤拷pInquiryTradeConcentrationField锟斤拷一锟斤拷CTORATstpInquiryTradeConcentrationField锟斤拷锟斤拷锟�
+ def ReqInquiryTradeConcentration(self, pInquiryTradeConcentrationField: "CTORATstpInquiryTradeConcentrationField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInquiryTradeConcentration(self, pInquiryTradeConcentrationField, nRequestID)
+
+ #锟斤拷锟斤拷锟睫改匡拷锟街成憋拷锟斤拷锟斤拷,锟斤拷锟斤拷pReqModifyOpenPosCostField锟斤拷一锟斤拷CTORATstpReqModifyOpenPosCostField锟斤拷锟斤拷锟�
+ def ReqModifyOpenPosCost(self, pReqModifyOpenPosCostField: "CTORATstpReqModifyOpenPosCostField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqModifyOpenPosCost(self, pReqModifyOpenPosCostField, nRequestID)
+
+ #录锟斤拷诘锟斤拷式锟斤拷锟斤拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pInputNodeFundAssignmentField锟斤拷一锟斤拷CTORATstpInputNodeFundAssignmentField锟斤拷锟斤拷锟�
+ def ReqInputNodeFundAssignment(self, pInputNodeFundAssignmentField: "CTORATstpInputNodeFundAssignmentField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInputNodeFundAssignment(self, pInputNodeFundAssignmentField, nRequestID)
+
+ #锟斤拷询锟节碉拷锟绞斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pReqInquiryNodeFundAssignmentField锟斤拷一锟斤拷CTORATstpReqInquiryNodeFundAssignmentField锟斤拷锟斤拷锟�
+ def ReqInquiryNodeFundAssignment(self, pReqInquiryNodeFundAssignmentField: "CTORATstpReqInquiryNodeFundAssignmentField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqInquiryNodeFundAssignment(self, pReqInquiryNodeFundAssignmentField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryExchangeField锟斤拷一锟斤拷CTORATstpQryExchangeField锟斤拷锟斤拷锟�
+ def ReqQryExchange(self, pQryExchangeField: "CTORATstpQryExchangeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryExchange(self, pQryExchangeField, nRequestID)
+
+ #锟斤拷询证券锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQrySecurityField锟斤拷一锟斤拷CTORATstpQrySecurityField锟斤拷锟斤拷锟�
+ def ReqQrySecurity(self, pQrySecurityField: "CTORATstpQrySecurityField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQrySecurity(self, pQrySecurityField, nRequestID)
+
+ #锟斤拷询锟铰癸拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryIPOInfoField锟斤拷一锟斤拷CTORATstpQryIPOInfoField锟斤拷锟斤拷锟�
+ def ReqQryIPOInfo(self, pQryIPOInfoField: "CTORATstpQryIPOInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryIPOInfo(self, pQryIPOInfoField, nRequestID)
+
+ #锟斤拷询锟矫伙拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryUserField锟斤拷一锟斤拷CTORATstpQryUserField锟斤拷锟斤拷锟�
+ def ReqQryUser(self, pQryUserField: "CTORATstpQryUserField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryUser(self, pQryUserField, nRequestID)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryInvestorField锟斤拷一锟斤拷CTORATstpQryInvestorField锟斤拷锟斤拷锟�
+ def ReqQryInvestor(self, pQryInvestorField: "CTORATstpQryInvestorField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryInvestor(self, pQryInvestorField, nRequestID)
+
+ #锟斤拷询锟缴讹拷锟剿伙拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryShareholderAccountField锟斤拷一锟斤拷CTORATstpQryShareholderAccountField锟斤拷锟斤拷锟�
+ def ReqQryShareholderAccount(self, pQryShareholderAccountField: "CTORATstpQryShareholderAccountField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryShareholderAccount(self, pQryShareholderAccountField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟秸拷锟较拷锟斤拷锟�,锟斤拷锟斤拷pQryRationalInfoField锟斤拷一锟斤拷CTORATstpQryRationalInfoField锟斤拷锟斤拷锟�
+ def ReqQryRationalInfo(self, pQryRationalInfoField: "CTORATstpQryRationalInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryRationalInfo(self, pQryRationalInfoField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryOrderField锟斤拷一锟斤拷CTORATstpQryOrderField锟斤拷锟斤拷锟�
+ def ReqQryOrder(self, pQryOrderField: "CTORATstpQryOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryOrder(self, pQryOrderField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryOrderActionField锟斤拷一锟斤拷CTORATstpQryOrderActionField锟斤拷锟斤拷锟�
+ def ReqQryOrderAction(self, pQryOrderActionField: "CTORATstpQryOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryOrderAction(self, pQryOrderActionField, nRequestID)
+
+ #锟斤拷询锟缴斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryTradeField锟斤拷一锟斤拷CTORATstpQryTradeField锟斤拷锟斤拷锟�
+ def ReqQryTrade(self, pQryTradeField: "CTORATstpQryTradeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryTrade(self, pQryTradeField, nRequestID)
+
+ #锟斤拷询锟绞斤拷锟剿伙拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryTradingAccountField锟斤拷一锟斤拷CTORATstpQryTradingAccountField锟斤拷锟斤拷锟�
+ def ReqQryTradingAccount(self, pQryTradingAccountField: "CTORATstpQryTradingAccountField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryTradingAccount(self, pQryTradingAccountField, nRequestID)
+
+ #锟斤拷询投锟斤拷锟竭持诧拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryPositionField锟斤拷一锟斤拷CTORATstpQryPositionField锟斤拷锟斤拷锟�
+ def ReqQryPosition(self, pQryPositionField: "CTORATstpQryPositionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPosition(self, pQryPositionField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟阶凤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryTradingFeeField锟斤拷一锟斤拷CTORATstpQryTradingFeeField锟斤拷锟斤拷锟�
+ def ReqQryTradingFee(self, pQryTradingFeeField: "CTORATstpQryTradingFeeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryTradingFee(self, pQryTradingFeeField, nRequestID)
+
+ #锟斤拷询佣锟斤拷锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pQryInvestorTradingFeeField锟斤拷一锟斤拷CTORATstpQryInvestorTradingFeeField锟斤拷锟斤拷锟�
+ def ReqQryInvestorTradingFee(self, pQryInvestorTradingFeeField: "CTORATstpQryInvestorTradingFeeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryInvestorTradingFee(self, pQryInvestorTradingFeeField, nRequestID)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pQryIPOQuotaField锟斤拷一锟斤拷CTORATstpQryIPOQuotaField锟斤拷锟斤拷锟�
+ def ReqQryIPOQuota(self, pQryIPOQuotaField: "CTORATstpQryIPOQuotaField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryIPOQuota(self, pQryIPOQuotaField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷细锟绞斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryOrderFundDetailField锟斤拷一锟斤拷CTORATstpQryOrderFundDetailField锟斤拷锟斤拷锟�
+ def ReqQryOrderFundDetail(self, pQryOrderFundDetailField: "CTORATstpQryOrderFundDetailField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryOrderFundDetail(self, pQryOrderFundDetailField, nRequestID)
+
+ #锟斤拷询锟绞斤拷转锟斤拷锟斤拷水锟斤拷锟斤拷,锟斤拷锟斤拷pQryFundTransferDetailField锟斤拷一锟斤拷CTORATstpQryFundTransferDetailField锟斤拷锟斤拷锟�
+ def ReqQryFundTransferDetail(self, pQryFundTransferDetailField: "CTORATstpQryFundTransferDetailField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryFundTransferDetail(self, pQryFundTransferDetailField, nRequestID)
+
+ #锟斤拷询锟街诧拷转锟斤拷锟斤拷水锟斤拷锟斤拷,锟斤拷锟斤拷pQryPositionTransferDetailField锟斤拷一锟斤拷CTORATstpQryPositionTransferDetailField锟斤拷锟斤拷锟�
+ def ReqQryPositionTransferDetail(self, pQryPositionTransferDetailField: "CTORATstpQryPositionTransferDetailField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPositionTransferDetail(self, pQryPositionTransferDetailField, nRequestID)
+
+ #锟斤拷询锟斤拷围系统锟斤拷位锟斤拷锟斤拷锟斤拷水锟斤拷锟斤拷,锟斤拷锟斤拷pQryPeripheryPositionTransferDetailField锟斤拷一锟斤拷CTORATstpQryPeripheryPositionTransferDetailField锟斤拷锟斤拷锟�
+ def ReqQryPeripheryPositionTransferDetail(self, pQryPeripheryPositionTransferDetailField: "CTORATstpQryPeripheryPositionTransferDetailField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPeripheryPositionTransferDetail(self, pQryPeripheryPositionTransferDetailField, nRequestID)
+
+ #锟斤拷询锟斤拷围系统锟绞斤拷锟斤拷锟斤拷锟剿拷锟斤拷锟�,锟斤拷锟斤拷pQryPeripheryFundTransferDetailField锟斤拷一锟斤拷CTORATstpQryPeripheryFundTransferDetailField锟斤拷锟斤拷锟�
+ def ReqQryPeripheryFundTransferDetail(self, pQryPeripheryFundTransferDetailField: "CTORATstpQryPeripheryFundTransferDetailField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPeripheryFundTransferDetail(self, pQryPeripheryFundTransferDetailField, nRequestID)
+
+ #锟斤拷询债券转锟斤拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryBondConversionInfoField锟斤拷一锟斤拷CTORATstpQryBondConversionInfoField锟斤拷锟斤拷锟�
+ def ReqQryBondConversionInfo(self, pQryBondConversionInfoField: "CTORATstpQryBondConversionInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryBondConversionInfo(self, pQryBondConversionInfoField, nRequestID)
+
+ #锟斤拷询债券锟斤拷锟斤拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryBondPutbackInfoField锟斤拷一锟斤拷CTORATstpQryBondPutbackInfoField锟斤拷锟斤拷锟�
+ def ReqQryBondPutbackInfo(self, pQryBondPutbackInfoField: "CTORATstpQryBondPutbackInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryBondPutbackInfo(self, pQryBondPutbackInfoField, nRequestID)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡诧拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryInvestorCondOrderLimitParamField锟斤拷一锟斤拷CTORATstpQryInvestorCondOrderLimitParamField锟斤拷锟斤拷锟�
+ def ReqQryInvestorCondOrderLimitParam(self, pQryInvestorCondOrderLimitParamField: "CTORATstpQryInvestorCondOrderLimitParamField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryInvestorCondOrderLimitParam(self, pQryInvestorCondOrderLimitParamField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryConditionOrderField锟斤拷一锟斤拷CTORATstpQryConditionOrderField锟斤拷锟斤拷锟�
+ def ReqQryConditionOrder(self, pQryConditionOrderField: "CTORATstpQryConditionOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryConditionOrder(self, pQryConditionOrderField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryCondOrderActionField锟斤拷一锟斤拷CTORATstpQryCondOrderActionField锟斤拷锟斤拷锟�
+ def ReqQryCondOrderAction(self, pQryCondOrderActionField: "CTORATstpQryCondOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryCondOrderAction(self, pQryCondOrderActionField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷通知锟斤拷锟斤拷,锟斤拷锟斤拷pQryTradingNoticeField锟斤拷一锟斤拷CTORATstpQryTradingNoticeField锟斤拷锟斤拷锟�
+ def ReqQryTradingNotice(self, pQryTradingNoticeField: "CTORATstpQryTradingNoticeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryTradingNotice(self, pQryTradingNoticeField, nRequestID)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷沤锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryIPONumberResultField锟斤拷一锟斤拷CTORATstpQryIPONumberResultField锟斤拷锟斤拷锟�
+ def ReqQryIPONumberResult(self, pQryIPONumberResultField: "CTORATstpQryIPONumberResultField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryIPONumberResult(self, pQryIPONumberResultField, nRequestID)
+
+ #锟斤拷询锟铰癸拷锟疥购锟斤拷签锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pQryIPOMatchNumberResultField锟斤拷一锟斤拷CTORATstpQryIPOMatchNumberResultField锟斤拷锟斤拷锟�
+ def ReqQryIPOMatchNumberResult(self, pQryIPOMatchNumberResultField: "CTORATstpQryIPOMatchNumberResultField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryIPOMatchNumberResult(self, pQryIPOMatchNumberResultField, nRequestID)
+
+ #锟斤拷询锟斤拷锟斤拷协锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryShareholderSpecPrivilegeField锟斤拷一锟斤拷CTORATstpQryShareholderSpecPrivilegeField锟斤拷锟斤拷锟�
+ def ReqQryShareholderSpecPrivilege(self, pQryShareholderSpecPrivilegeField: "CTORATstpQryShareholderSpecPrivilegeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryShareholderSpecPrivilege(self, pQryShareholderSpecPrivilegeField, nRequestID)
+
+ #锟斤拷询锟叫筹拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryMarketField锟斤拷一锟斤拷CTORATstpQryMarketField锟斤拷锟斤拷锟�
+ def ReqQryMarket(self, pQryMarketField: "CTORATstpQryMarketField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryMarket(self, pQryMarketField, nRequestID)
+
+ #锟斤拷询ETF锟藉单锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryETFFileField锟斤拷一锟斤拷CTORATstpQryETFFileField锟斤拷锟斤拷锟�
+ def ReqQryETFFile(self, pQryETFFileField: "CTORATstpQryETFFileField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryETFFile(self, pQryETFFileField, nRequestID)
+
+ #锟斤拷询ETF锟缴凤拷证券锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryETFBasketField锟斤拷一锟斤拷CTORATstpQryETFBasketField锟斤拷锟斤拷锟�
+ def ReqQryETFBasket(self, pQryETFBasketField: "CTORATstpQryETFBasketField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryETFBasket(self, pQryETFBasketField, nRequestID)
+
+ #锟斤拷询投锟斤拷锟斤拷锟睫诧拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryInvestorPositionLimitField锟斤拷一锟斤拷CTORATstpQryInvestorPositionLimitField锟斤拷锟斤拷锟�
+ def ReqQryInvestorPositionLimit(self, pQryInvestorPositionLimitField: "CTORATstpQryInvestorPositionLimitField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryInvestorPositionLimit(self, pQryInvestorPositionLimitField, nRequestID)
+
+ #锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟阶刺拷锟较拷锟斤拷锟�,锟斤拷锟斤拷pQrySZSEImcParamsField锟斤拷一锟斤拷CTORATstpQrySZSEImcParamsField锟斤拷锟斤拷锟�
+ def ReqQrySZSEImcParams(self, pQrySZSEImcParamsField: "CTORATstpQrySZSEImcParamsField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQrySZSEImcParams(self, pQrySZSEImcParamsField, nRequestID)
+
+ #锟斤拷询锟斤拷锟酵拷锟斤拷锟斤拷谐锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较拷锟斤拷锟�,锟斤拷锟斤拷pQrySZSEImcExchangeRateField锟斤拷一锟斤拷CTORATstpQrySZSEImcExchangeRateField锟斤拷锟斤拷锟�
+ def ReqQrySZSEImcExchangeRate(self, pQrySZSEImcExchangeRateField: "CTORATstpQrySZSEImcExchangeRateField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQrySZSEImcExchangeRate(self, pQrySZSEImcExchangeRateField, nRequestID)
+
+ #锟斤拷询锟斤拷锟酵拷锟叫★拷鄄锟斤拷锟较拷锟斤拷锟�,锟斤拷锟斤拷pQrySZSEHKPriceTickInfoField锟斤拷一锟斤拷CTORATstpQrySZSEHKPriceTickInfoField锟斤拷锟斤拷锟�
+ def ReqQrySZSEHKPriceTickInfo(self, pQrySZSEHKPriceTickInfoField: "CTORATstpQrySZSEHKPriceTickInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQrySZSEHKPriceTickInfo(self, pQrySZSEHKPriceTickInfoField, nRequestID)
+
+ #锟斤拷询LOF锟斤拷锟斤拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryLofFundInfoField锟斤拷一锟斤拷CTORATstpQryLofFundInfoField锟斤拷锟斤拷锟�
+ def ReqQryLofFundInfo(self, pQryLofFundInfoField: "CTORATstpQryLofFundInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryLofFundInfo(self, pQryLofFundInfoField, nRequestID)
+
+ #锟斤拷询投锟斤拷锟斤拷锟斤拷押锟街诧拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryPledgePositionField锟斤拷一锟斤拷CTORATstpQryPledgePositionField锟斤拷锟斤拷锟�
+ def ReqQryPledgePosition(self, pQryPledgePositionField: "CTORATstpQryPledgePositionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPledgePosition(self, pQryPledgePositionField, nRequestID)
+
+ #锟斤拷询证券锟斤拷押锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQryPledgeInfoField锟斤拷一锟斤拷CTORATstpQryPledgeInfoField锟斤拷锟斤拷锟�
+ def ReqQryPledgeInfo(self, pQryPledgeInfoField: "CTORATstpQryPledgeInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPledgeInfo(self, pQryPledgeInfoField, nRequestID)
+
+ #锟斤拷询系统锟节碉拷锟斤拷息锟斤拷锟斤拷,锟斤拷锟斤拷pQrySystemNodeInfoField锟斤拷一锟斤拷CTORATstpQrySystemNodeInfoField锟斤拷锟斤拷锟�
+ def ReqQrySystemNodeInfo(self, pQrySystemNodeInfoField: "CTORATstpQrySystemNodeInfoField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQrySystemNodeInfo(self, pQrySystemNodeInfoField, nRequestID)
+
+ #锟斤拷询锟斤拷准券锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟斤拷pQryStandardBondPositionField锟斤拷一锟斤拷CTORATstpQryStandardBondPositionField锟斤拷锟斤拷锟�
+ def ReqQryStandardBondPosition(self, pQryStandardBondPositionField: "CTORATstpQryStandardBondPositionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryStandardBondPosition(self, pQryStandardBondPositionField, nRequestID)
+
+ #锟斤拷询未锟斤拷锟斤拷债券锟斤拷押锟截癸拷委锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryPrematurityRepoOrderField锟斤拷一锟斤拷CTORATstpQryPrematurityRepoOrderField锟斤拷锟斤拷锟�
+ def ReqQryPrematurityRepoOrder(self, pQryPrematurityRepoOrderField: "CTORATstpQryPrematurityRepoOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryPrematurityRepoOrder(self, pQryPrematurityRepoOrderField, nRequestID)
+
+ #锟斤拷询协锟介交锟阶憋拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryNegoOrderField锟斤拷一锟斤拷CTORATstpQryNegoOrderField锟斤拷锟斤拷锟�
+ def ReqQryNegoOrder(self, pQryNegoOrderField: "CTORATstpQryNegoOrderField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryNegoOrder(self, pQryNegoOrderField, nRequestID)
+
+ #锟斤拷询协锟介交锟阶筹拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryNegoOrderActionField锟斤拷一锟斤拷CTORATstpQryNegoOrderActionField锟斤拷锟斤拷锟�
+ def ReqQryNegoOrderAction(self, pQryNegoOrderActionField: "CTORATstpQryNegoOrderActionField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryNegoOrderAction(self, pQryNegoOrderActionField, nRequestID)
+
+ #锟斤拷询协锟介交锟阶成斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryNegoTradeField锟斤拷一锟斤拷CTORATstpQryNegoTradeField锟斤拷锟斤拷锟�
+ def ReqQryNegoTrade(self, pQryNegoTradeField: "CTORATstpQryNegoTradeField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryNegoTrade(self, pQryNegoTradeField, nRequestID)
+
+ #锟斤拷询协锟介交锟阶诧拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷pQryNegotiationParamField锟斤拷一锟斤拷CTORATstpQryNegotiationParamField锟斤拷锟斤拷锟�
+ def ReqQryNegotiationParam(self, pQryNegotiationParamField: "CTORATstpQryNegotiationParamField", nRequestID: "int") -> "int":
+ return _traderapi.CTORATstpTraderApi_ReqQryNegotiationParam(self, pQryNegotiationParamField, nRequestID)
+
+# Register CTORATstpTraderApi in _traderapi:
+_traderapi.CTORATstpTraderApi_swigregister(CTORATstpTraderApi)
+
+ #锟斤拷锟斤拷锟接口讹拷锟斤拷,锟斤拷锟斤拷1为锟斤拷锟侥硷拷锟斤拷锟侥柯�,锟斤拷锟斤拷2为锟斤拷锟斤拷锟斤拷锟斤拷锟角凤拷锟斤拷艽锟斤拷锟�
+def CTORATstpTraderApi_CreateTstpTraderApi(*args) -> "TORASTOCKAPI::CTORATstpTraderApi *":
+ return _traderapi.CTORATstpTraderApi_CreateTstpTraderApi(*args)
+
+ #锟斤拷取锟接口版本锟斤拷
+def CTORATstpTraderApi_GetApiVersion() -> "char const *":
+ return _traderapi.CTORATstpTraderApi_GetApiVersion()
+
+
+
diff --git a/utils/hosting_api_util.py b/utils/hosting_api_util.py
index 8bd4aef..3e06172 100644
--- a/utils/hosting_api_util.py
+++ b/utils/hosting_api_util.py
@@ -388,6 +388,20 @@
return common_request_for_cb({"ctype": "get_account_money"}, blocking)
+def refresh_trade_data_for_cb(type_, blocking=True):
+ """
+ 鍒锋柊鍙浆鍊轰氦鏄撴暟鎹�
+ :param code:
+ :param blocking:
+ :return:
+ """
+ request_id, client = __request(ClientSocketManager.CLIENT_TYPE_TRADE_CB,
+ {"type": API_TYPE_REFRESH_TRADE_DATA, "ctype": type_,
+ "sinfo": f"cb_{API_TYPE_REFRESH_TRADE_DATA}_{round(time.time() * 1000)}"})
+ return __read_response(client, request_id, blocking)
+
+
+
def common_request_for_cb(params, blocking=True):
"""
閫氱敤璇锋眰
diff --git a/utils/kp_client_msg_manager.py b/utils/kp_client_msg_manager.py
index 183421c..099626a 100644
--- a/utils/kp_client_msg_manager.py
+++ b/utils/kp_client_msg_manager.py
@@ -6,7 +6,7 @@
import threading
import time
-from log import logger_kp_msg
+from log_module.log import logger_kp_msg
from utils import log_export
CLIENT_IDS = ["zjb", "hxh"]
--
Gitblit v1.8.0