xtquant.xttrader

   1#coding=utf-8
   2import asyncio
   3import os
   4from threading import Thread
   5from concurrent.futures import ThreadPoolExecutor, Future
   6from . import xtpythonclient as XTQC
   7from . import xttype
   8
   9def title(s = None):
  10    import inspect
  11    if not s:
  12        s = inspect.stack()[1].function
  13    print('-' * 33 + s + '-' * 33)
  14    return
  15
  16def cp(s = None):
  17    import inspect
  18    st = inspect.stack()
  19    pos = {'title':st[1].function, 'line':st[1].lineno}
  20    print('-' * 33 + f'{pos}, {s}' + '-' * 33)
  21    return
  22
  23# 交易回调类
  24class XtQuantTraderCallback(object):
  25    def on_connected(self):
  26        """
  27        连接成功推送
  28        """
  29        pass
  30        
  31    def on_disconnected(self):
  32        """
  33        连接断开推送
  34        """
  35        pass
  36
  37    def on_account_status(self, status):
  38        """
  39        :param status: XtAccountStatus对象
  40        :return:
  41        """
  42        pass
  43
  44    def on_stock_asset(self, asset):
  45        """
  46        :param asset: XtAsset对象
  47        :return:
  48        """
  49        pass
  50
  51    def on_stock_order(self, order):
  52        """
  53        :param order: XtOrder对象
  54        :return:
  55        """
  56        pass
  57
  58    def on_stock_trade(self, trade):
  59        """
  60        :param trade: XtTrade对象
  61        :return:
  62        """
  63        pass
  64
  65    def on_stock_position(self, position):
  66        """
  67        :param position: XtPosition对象
  68        :return:
  69        """
  70        pass
  71
  72    def on_order_error(self, order_error):
  73        """
  74        :param order_error: XtOrderError 对象
  75        :return:
  76        """
  77        pass
  78
  79    def on_cancel_error(self, cancel_error):
  80        """
  81        :param cancel_error:XtCancelError 对象
  82        :return:
  83        """
  84        pass
  85
  86    def on_order_stock_async_response(self, response):
  87        """
  88        :param response: XtOrderResponse 对象
  89        :return:
  90        """
  91        pass
  92    
  93    def on_smt_appointment_async_response(self, response):
  94        """
  95        :param response: XtAppointmentResponse 对象
  96        :return:
  97        """
  98        pass
  99    
 100    def on_cancel_order_stock_async_response(self, response):
 101        """
 102        :param response: XtCancelOrderResponse 对象
 103        :return:
 104        """
 105        pass
 106
 107class XtQuantTrader(object):
 108    def __init__(self, path, session, callback=None):
 109        """
 110        :param path: mini版迅投极速交易客户端安装路径下，userdata文件夹具体路径
 111        :param session: 当前任务执行所属的会话id
 112        :param callback: 回调方法
 113        """
 114        self.async_client = XTQC.XtQuantAsyncClient(path.encode('gb18030'), 'xtquant', session)
 115        self.callback = callback
 116
 117        self.connected = False
 118
 119        self.oldloop = asyncio.get_event_loop()
 120        self.loop = asyncio.new_event_loop()
 121        asyncio.set_event_loop(self.loop)
 122        self.cbs = {}
 123
 124        self.executor = None
 125        self.resp_executor = None
 126
 127        self.relaxed_resp_order_enabled = False
 128        self.relaxed_resp_executor = None
 129
 130        self.handled_async_order_stock_order_id = set()
 131        self.sync_order_stock_order_id = set()
 132        self.queuing_order_errors = {}
 133
 134        self.handled_async_smt_appointment_order_id = set()
 135        self.sync_smt_appointment_order_id = set()
 136         
 137        self.handled_async_cancel_order_stock_order_id = set()
 138        self.handled_async_cancel_order_stock_order_sys_id = set()
 139        self.handled_sync_cancel_order_stock_order_id = set()
 140        self.handled_sync_cancel_order_stock_order_sys_id = set()
 141        self.queuing_cancel_errors_by_order_id = {}
 142        self.queuing_cancel_errors_by_order_sys_id = {}
 143        
 144        
 145    #########################
 146        #push
 147        def on_common_push_callback_wrapper(argc, callback):
 148            if argc == 0:
 149                def on_push_data():
 150                    self.executor.submit(callback)
 151                return on_push_data
 152            elif argc == 1:
 153                def on_push_data(data):
 154                    self.executor.submit(callback, data)
 155                return on_push_data
 156            elif argc == 2:
 157                def on_push_data(data1, data2):
 158                    self.executor.submit(callback, data1, data2)
 159                return on_push_data
 160            else:
 161                return None
 162        
 163        #response
 164        def on_common_resp_callback(seq, resp):
 165            callback = self.cbs.pop(seq, None)
 166            if callback:
 167                self.resp_executor.submit(callback, resp)
 168            return
 169        
 170        self.async_client.bindOnSubscribeRespCallback(on_common_resp_callback)
 171        self.async_client.bindOnUnsubscribeRespCallback(on_common_resp_callback)
 172        self.async_client.bindOnQueryStockAssetCallback(on_common_resp_callback)
 173        self.async_client.bindOnQueryStockOrdersCallback(on_common_resp_callback)
 174        self.async_client.bindOnQueryStockTradesCallback(on_common_resp_callback)
 175        self.async_client.bindOnQueryStockPositionsCallback(on_common_resp_callback)
 176        self.async_client.bindOnQueryCreditDetailRespCallback(on_common_resp_callback)
 177        self.async_client.bindOnQueryStkCompactsRespCallback(on_common_resp_callback)
 178        self.async_client.bindOnQueryCreditSubjectsRespCallback(on_common_resp_callback)
 179        self.async_client.bindOnQueryCreditSloCodeRespCallback(on_common_resp_callback)
 180        self.async_client.bindOnQueryCreditAssureRespCallback(on_common_resp_callback)
 181        self.async_client.bindOnQueryNewPurchaseLimitCallback(on_common_resp_callback)
 182        self.async_client.bindOnQueryIPODataCallback(on_common_resp_callback)
 183        self.async_client.bindOnQueryAppointmentInfoRespCallback(on_common_resp_callback)
 184        self.async_client.bindOnQuerySMTSecuInfoRespCallback(on_common_resp_callback)
 185        self.async_client.bindOnQuerySMTSecuRateRespCallback(on_common_resp_callback)
 186        
 187        self.async_client.bindOnQueryAccountInfosCallback(on_common_resp_callback)
 188        self.async_client.bindOnQueryAccountStatusCallback(on_common_resp_callback)
 189    #########################
 190        
 191        enable_push = 1
 192        
 193        #order push
 194        
 195        def on_push_SmtAppointmentAsyncResponse(seq, resp):
 196            callback = self.cbs.pop(seq, None)
 197            if callback:
 198                resp = xttype.XtAppointmentResponse(resp.m_strAccountID, resp.m_nOrderID, resp.m_nErrorID, resp.m_strErrorMsg, seq)
 199                callback(resp)
 200                self.handled_async_smt_appointment_order_id.add(resp.order_id)
 201            return
 202        
 203        if enable_push:
 204            self.async_client.bindOnSmtAppointmentRespCallback(on_common_push_callback_wrapper(2, on_push_SmtAppointmentAsyncResponse))
 205        
 206        def on_push_OrderStockAsyncResponse(seq, resp):
 207            callback = self.cbs.pop(seq, None)
 208            if callback:
 209                resp = xttype.XtOrderResponse(resp.m_strAccountID, resp.m_nOrderID, resp.m_strStrategyName, resp.m_strOrderRemark, resp.m_strErrorMsg, seq)
 210                callback(resp)
 211                self.handled_async_order_stock_order_id.add(resp.order_id)
 212                e = self.queuing_order_errors.pop(resp.order_id, None)
 213                if e is not None:
 214                    self.callback.on_order_error(e)
 215                    self.handled_async_order_stock_order_id.discard(resp.order_id)
 216            return
 217        
 218        if enable_push:
 219            self.async_client.bindOnOrderStockRespCallback(on_common_push_callback_wrapper(2, on_push_OrderStockAsyncResponse))
 220        
 221        def on_push_CancelOrderStockAsyncResponse(seq, resp):
 222            callback = self.cbs.pop(seq, None)
 223            if callback:
 224                resp = xttype.XtCancelOrderResponse(resp.m_strAccountID, resp.m_nCancelResult, resp.m_nOrderID, resp.m_strOrderSysID, seq)
 225                callback(resp)
 226                
 227                if not resp.order_sysid:
 228                    self.handled_async_cancel_order_stock_order_id.add(resp.order_id)
 229                    e = self.queuing_cancel_errors_by_order_id.pop(resp.order_id, None)
 230                    if e is not None:
 231                        self.handled_async_cancel_order_stock_order_id.discard(resp.order_id)
 232                        self.callback.on_cancel_error(e)
 233                else:
 234                    self.handled_async_cancel_order_stock_order_sys_id.add(resp.order_sysid)
 235                    e = self.queuing_cancel_errors_by_order_sys_id.pop(resp.order_sysid, None)
 236                    if e is not None:
 237                        self.handled_async_cancel_order_stock_order_sys_id.discard(resp.order_sysid)
 238                        self.callback.on_cancel_error(e)
 239            return
 240        
 241        if enable_push:
 242            self.async_client.bindOnCancelOrderStockRespCallback(on_common_push_callback_wrapper(2, on_push_CancelOrderStockAsyncResponse))
 243            
 244        def on_push_disconnected():
 245            if self.callback:
 246                self.callback.on_disconnected()
 247
 248        if enable_push:
 249            self.async_client.bindOnDisconnectedCallback(on_common_push_callback_wrapper(0, on_push_disconnected))
 250
 251        def on_push_AccountStatus(data):
 252            data = xttype.XtAccountStatus(data.m_strAccountID, data.m_nAccountType, data.m_nStatus)
 253            self.callback.on_account_status(data)
 254
 255        if enable_push:
 256            self.async_client.bindOnUpdateAccountStatusCallback(on_common_push_callback_wrapper(1, on_push_AccountStatus))
 257
 258        def on_push_StockAsset(data):
 259            self.callback.on_stock_asset(data)
 260
 261        if enable_push:
 262            self.async_client.bindOnStockAssetCallback(on_common_push_callback_wrapper(1, on_push_StockAsset))
 263
 264        def on_push_OrderStock(data):
 265            self.callback.on_stock_order(data)
 266
 267        if enable_push:
 268            self.async_client.bindOnStockOrderCallback(on_common_push_callback_wrapper(1, on_push_OrderStock))
 269
 270        def on_push_StockTrade(data):
 271            self.callback.on_stock_trade(data)
 272
 273        if enable_push:
 274            self.async_client.bindOnStockTradeCallback(on_common_push_callback_wrapper(1, on_push_StockTrade))
 275
 276        def on_push_StockPosition(data):
 277            self.callback.on_stock_position(data)
 278
 279        if enable_push:
 280            self.async_client.bindOnStockPositionCallback(on_common_push_callback_wrapper(1, on_push_StockPosition))
 281
 282        def on_push_OrderError(data):
 283            if data.order_id in self.handled_async_order_stock_order_id or data.order_id in self.sync_order_stock_order_id:
 284                self.handled_async_order_stock_order_id.discard(data.order_id)
 285                self.sync_order_stock_order_id.discard(data.order_id)
 286                self.callback.on_order_error(data)
 287            else:
 288                self.queuing_order_errors[data.order_id] = data
 289
 290        if enable_push:
 291            self.async_client.bindOnOrderErrorCallback(on_common_push_callback_wrapper(1, on_push_OrderError))
 292
 293        def on_push_CancelError(data):
 294            if not data.order_sysid:
 295                if data.order_id in self.handled_async_cancel_order_stock_order_id or data.order_id in self.handled_sync_cancel_order_stock_order_id:
 296                    self.handled_async_cancel_order_stock_order_id.discard(data.order_id)
 297                    self.handled_sync_cancel_order_stock_order_id.discard(data.order_id)
 298                    self.callback.on_cancel_error(data)
 299                else:
 300                    self.queuing_cancel_errors_by_order_id[data.order_id] = data
 301            else:
 302                if data.order_sysid in self.handled_async_cancel_order_stock_order_sys_id or data.order_sysid in self.handled_sync_cancel_order_stock_order_sys_id:
 303                    self.handled_async_cancel_order_stock_order_sys_id.discard(data.order_sysid)
 304                    self.handled_sync_cancel_order_stock_order_sys_id.discard(data.order_sysid)
 305                    self.callback.on_cancel_error(data)
 306                else:
 307                    self.queuing_cancel_errors_by_order_sys_id[data.order_sysid] = data
 308
 309        if enable_push:
 310            self.async_client.bindOnCancelErrorCallback(on_common_push_callback_wrapper(1, on_push_CancelError))
 311        
 312    ########################
 313
 314    def common_op_async_with_seq(self, seq, callable, callback):
 315        self.cbs[seq] = callback
 316
 317        def apply(func, *args):
 318            return func(*args)
 319        apply(*callable)
 320
 321        return seq
 322
 323    def common_op_sync_with_seq(self, seq, callable):
 324        future = Future()
 325        self.cbs[seq] = lambda resp:future.set_result(resp)
 326
 327        def apply(func, *args):
 328            return func(*args)
 329        apply(*callable)
 330
 331        return future.result()
 332
 333    #########################
 334    
 335    
 336    def __del__(self):
 337        if hasattr(self, 'oldloop'):
 338            asyncio.set_event_loop(self.oldloop)
 339
 340    def register_callback(self, callback):
 341        self.callback = callback
 342
 343    def start(self):
 344        self.async_client.init()
 345        self.async_client.start()
 346        self.executor = ThreadPoolExecutor(max_workers = 1)
 347        self.relaxed_resp_executor = ThreadPoolExecutor(max_workers = 1)
 348        self.resp_executor = self.relaxed_resp_executor if self.relaxed_resp_order_enabled else self.executor
 349        return
 350
 351    def stop(self):
 352        self.async_client.stop()
 353        self.loop.call_soon_threadsafe(self.loop.stop)
 354        self.executor.shutdown(wait = True)
 355        self.relaxed_resp_executor.shutdown(wait = True)
 356        return
 357
 358    def connect(self):
 359        result = self.async_client.connect()
 360        self.connected = result == 0
 361        return result
 362
 363    def sleep(self, time):
 364        async def sleep_coroutine(time):
 365            await asyncio.sleep(time)
 366        asyncio.run_coroutine_threadsafe(sleep_coroutine(time), self.loop).result()
 367
 368    def run_forever(self):
 369        import time
 370        while True:
 371            time.sleep(0.2)
 372        return
 373
 374    def set_relaxed_response_order_enabled(self, enabled):
 375        self.relaxed_resp_order_enabled = enabled
 376        self.resp_executor = self.relaxed_resp_executor if self.relaxed_resp_order_enabled else self.executor
 377        return
 378
 379    def subscribe(self, account):
 380        req = XTQC.SubscribeReq()
 381        req.m_nAccountType = account.account_type
 382        req.m_strAccountID = account.account_id
 383        seq = self.async_client.nextSeq()
 384        return self.common_op_sync_with_seq(
 385            seq,
 386            (self.async_client.subscribeWithSeq, seq, req)
 387        )
 388
 389    def unsubscribe(self, account):
 390        req = XTQC.UnsubscribeReq()
 391        req.m_nAccountType = account.account_type
 392        req.m_strAccountID = account.account_id
 393        seq = self.async_client.nextSeq()
 394        return self.common_op_sync_with_seq(
 395            seq,
 396            (self.async_client.unsubscribeWithSeq, seq, req)
 397        )
 398
 399    def order_stock_async(self, account, stock_code, order_type, order_volume, price_type, price, strategy_name='',
 400                          order_remark=''):
 401        """
 402        :param account: 证券账号
 403        :param stock_code: 证券代码, 例如"600000.SH"
 404        :param order_type: 委托类型, 23:买, 24:卖
 405        :param order_volume: 委托数量, 股票以'股'为单位, 债券以'张'为单位
 406        :param price_type: 报价类型, 详见帮助手册
 407        :param price: 报价价格, 如果price_type为指定价, 那price为指定的价格, 否则填0
 408        :param strategy_name: 策略名称
 409        :param order_remark: 委托备注
 410        :return: 返回下单请求序号, 成功委托后的下单请求序号为大于0的正整数, 如果为-1表示委托失败
 411        """
 412        req = XTQC.OrderStockReq()
 413        req.m_nAccountType = account.account_type
 414        req.m_strAccountID = account.account_id
 415        req.m_strStockCode = stock_code
 416        req.m_nOrderType = order_type
 417        req.m_nOrderVolume = order_volume
 418        req.m_nPriceType = price_type
 419        req.m_dPrice = price
 420        req.m_strStrategyName = strategy_name
 421        req.m_strOrderRemark = order_remark
 422
 423        seq = self.async_client.nextSeq()
 424        self.cbs[seq] = self.callback.on_order_stock_async_response
 425        self.async_client.orderStockWithSeq(seq, req)
 426        return seq
 427
 428    def order_stock(self, account, stock_code, order_type, order_volume, price_type, price, strategy_name='',
 429                          order_remark=''):
 430        """
 431        :param account: 证券账号
 432        :param stock_code: 证券代码, 例如"600000.SH"
 433        :param order_type: 委托类型, 23:买, 24:卖
 434        :param order_volume: 委托数量, 股票以'股'为单位, 债券以'张'为单位
 435        :param price_type: 报价类型, 详见帮助手册
 436        :param price: 报价价格, 如果price_type为指定价, 那price为指定的价格, 否则填0
 437        :param strategy_name: 策略名称
 438        :param order_remark: 委托备注
 439        :return: 返回下单请求序号, 成功委托后的下单请求序号为大于0的正整数, 如果为-1表示委托失败
 440        """
 441        req = XTQC.OrderStockReq()
 442        req.m_nAccountType = account.account_type
 443        req.m_strAccountID = account.account_id
 444        req.m_strStockCode = stock_code
 445        req.m_nOrderType = order_type
 446        req.m_nOrderVolume = order_volume
 447        req.m_nPriceType = price_type
 448        req.m_dPrice = price
 449        req.m_strStrategyName = strategy_name
 450        req.m_strOrderRemark = order_remark
 451        
 452        seq = self.async_client.nextSeq()
 453        resp = self.common_op_sync_with_seq(
 454            seq,
 455            (self.async_client.orderStockWithSeq, seq, req)
 456        )
 457        self.sync_order_stock_order_id.add(resp.order_id)
 458        return resp.order_id
 459
 460    def cancel_order_stock(self, account, order_id):
 461        """
 462        :param account: 证券账号
 463        :param order_id: 委托编号, 报单时返回的编号
 464        :return: 返回撤单成功或者失败, 0:成功,  -1:委托已完成撤单失败, -2:未找到对应委托编号撤单失败, -3:账号未登陆撤单失败
 465        """
 466        req = XTQC.CancelOrderStockReq()
 467        req.m_nAccountType = account.account_type
 468        req.m_strAccountID = account.account_id
 469        req.m_nOrderID = order_id
 470        
 471        seq = self.async_client.nextSeq()
 472        resp = self.common_op_sync_with_seq(
 473            seq,
 474            (self.async_client.cancelOrderStockWithSeq, seq, req)
 475        )
 476        self.handled_sync_cancel_order_stock_order_id.add(resp.order_id)
 477        return resp.cancel_result
 478
 479    def cancel_order_stock_async(self, account, order_id):
 480        """
 481        :param account: 证券账号
 482        :param order_id: 委托编号, 报单时返回的编号
 483        :return: 返回撤单请求序号, 成功委托后的撤单请求序号为大于0的正整数, 如果为-1表示委托失败
 484        """
 485        req = XTQC.CancelOrderStockReq()
 486        req.m_nAccountType = account.account_type
 487        req.m_strAccountID = account.account_id
 488        req.m_nOrderID = order_id
 489        
 490        seq = self.async_client.nextSeq()
 491        self.cbs[seq] = self.callback.on_cancel_order_stock_async_response
 492        self.async_client.cancelOrderStockWithSeq(seq, req)
 493        return seq
 494
 495    def cancel_order_stock_sysid(self, account, market, sysid):
 496        """
 497        :param account:证券账号
 498        :param market: 交易市场 0:上海 1:深圳
 499        :param sysid: 柜台合同编号
 500        :return:返回撤单成功或者失败, 0:成功,  -1:撤单失败
 501        """
 502        req = XTQC.CancelOrderStockReq()
 503        req.m_nAccountType = account.account_type
 504        req.m_strAccountID = account.account_id
 505        req.m_nMarket = market
 506        req.m_strOrderSysID = sysid
 507        
 508        seq = self.async_client.nextSeq()
 509        resp = self.common_op_sync_with_seq(
 510            seq,
 511            (self.async_client.cancelOrderStockWithSeq, seq, req)
 512        )
 513        self.handled_sync_cancel_order_stock_order_sys_id.add(resp.order_sysid)
 514        return resp.cancel_result
 515
 516    def cancel_order_stock_sysid_async(self, account, market, sysid):
 517        """
 518        :param account:证券账号
 519        :param market: 交易市场 0:上海 1:深圳
 520        :param sysid: 柜台编号
 521        :return:返回撤单请求序号, 成功委托后的撤单请求序号为大于0的正整数, 如果为-1表示委托失败
 522        """
 523        req = XTQC.CancelOrderStockReq()
 524        req.m_nAccountType = account.account_type
 525        req.m_strAccountID = account.account_id
 526        req.m_nMarket = market
 527        req.m_strOrderSysID = sysid
 528        
 529        seq = self.async_client.nextSeq()
 530        self.cbs[seq] = self.callback.on_cancel_order_stock_async_response
 531        self.async_client.cancelOrderStockWithSeq(seq, req)
 532        return seq
 533
 534    def query_account_infos(self):
 535        """
 536        :return: 返回账号列表
 537        """
 538        req = XTQC.QueryAccountInfosReq()
 539        
 540        seq = self.async_client.nextSeq()
 541        return self.common_op_sync_with_seq(
 542            seq,
 543            (self.async_client.queryAccountInfosWithSeq, seq, req)
 544        )
 545        
 546    query_account_info = query_account_infos
 547    
 548    def query_account_infos_async(self, callback):
 549        """
 550        :return: 返回账号列表
 551        """
 552        req = XTQC.QueryAccountInfosReq()
 553        
 554        seq = self.async_client.nextSeq()
 555        return self.common_op_async_with_seq(
 556            seq,
 557            (self.async_client.queryAccountInfosWithSeq, seq, req)
 558            , callback
 559        )
 560        
 561    def query_account_status(self):
 562        """
 563        :return: 返回账号状态
 564        """
 565        req = XTQC.QueryAccountStatusReq()
 566        
 567        seq = self.async_client.nextSeq()
 568        return self.common_op_sync_with_seq(
 569            seq,
 570            (self.async_client.queryAccountStatusWithSeq, seq, req)
 571        )
 572    
 573    def query_account_status_async(self, callback):
 574        """
 575        :return: 返回账号状态
 576        """
 577        req = XTQC.QueryAccountStatusReq()
 578        
 579        seq = self.async_client.nextSeq()
 580        return self.common_op_async_with_seq(
 581            seq,
 582            (self.async_client.queryAccountStatusWithSeq, seq, req)
 583            , callback
 584        )
 585
 586    def query_stock_asset(self, account):
 587        """
 588        :param account: 证券账号
 589        :return: 返回当前证券账号的资产数据
 590        """
 591        req = XTQC.QueryStockAssetReq()
 592        req.m_nAccountType = account.account_type
 593        req.m_strAccountID = account.account_id
 594        
 595        seq = self.async_client.nextSeq()
 596        resp = self.common_op_sync_with_seq(
 597            seq,
 598            (self.async_client.queryStockAssetWithSeq, seq, req)
 599        )
 600
 601        if resp and len(resp):
 602            return resp[0]
 603        return None
 604    
 605    def query_stock_asset_async(self, account, callback):
 606        """
 607        :param account: 证券账号
 608        :return: 返回当前证券账号的资产数据
 609        """
 610        req = XTQC.QueryStockAssetReq()
 611        req.m_nAccountType = account.account_type
 612        req.m_strAccountID = account.account_id
 613        
 614        seq = self.async_client.nextSeq()
 615        def _cb(resp):
 616            callback(resp[0] if resp else None)
 617        resp = self.common_op_async_with_seq(
 618            seq,
 619            (self.async_client.queryStockAssetWithSeq, seq, req)
 620            , _cb
 621        )
 622        return
 623
 624    def query_stock_order(self, account, order_id):
 625        """
 626        :param account: 证券账号
 627        :param order_id:  订单编号，同步报单接口返回的编号
 628        :return: 返回订单编号对应的委托对象
 629        """
 630        req = XTQC.QueryStockOrdersReq()
 631        req.m_nAccountType = account.account_type
 632        req.m_strAccountID = account.account_id
 633        req.m_nOrderID = order_id
 634        
 635        seq = self.async_client.nextSeq()
 636        resp = self.common_op_sync_with_seq(
 637            seq,
 638            (self.async_client.queryStockOrdersWithSeq, seq, req)
 639        )
 640        if resp and len(resp):
 641            return resp[0]
 642        return None
 643
 644    def query_stock_orders(self, account, cancelable_only = False):
 645        """
 646        :param account: 证券账号
 647        :param cancelable_only: 仅查询可撤委托
 648        :return: 返回当日所有委托的委托对象组成的list
 649        """
 650        req = XTQC.QueryStockOrdersReq()
 651        req.m_nAccountType = account.account_type
 652        req.m_strAccountID = account.account_id
 653        req.m_bCanCancel = cancelable_only
 654        
 655        seq = self.async_client.nextSeq()
 656        return self.common_op_sync_with_seq(
 657            seq,
 658            (self.async_client.queryStockOrdersWithSeq, seq, req)
 659        )
 660    
 661    def query_stock_orders_async(self, account, callback, cancelable_only = False):
 662        """
 663        :param account: 证券账号
 664        :param cancelable_only: 仅查询可撤委托
 665        :return: 返回当日所有委托的委托对象组成的list
 666        """
 667        req = XTQC.QueryStockOrdersReq()
 668        req.m_nAccountType = account.account_type
 669        req.m_strAccountID = account.account_id
 670        req.m_bCanCancel = cancelable_only
 671        
 672        seq = self.async_client.nextSeq()
 673        return self.common_op_async_with_seq(
 674            seq,
 675            (self.async_client.queryStockOrdersWithSeq, seq, req)
 676            , callback
 677        )
 678    
 679    def query_stock_trades(self, account):
 680        """
 681        :param account:  证券账号
 682        :return:  返回当日所有成交的成交对象组成的list
 683        """
 684        req = XTQC.QueryStockTradesReq()
 685        req.m_nAccountType = account.account_type
 686        req.m_strAccountID = account.account_id
 687        
 688        seq = self.async_client.nextSeq()
 689        return self.common_op_sync_with_seq(
 690            seq,
 691            (self.async_client.queryStockTradesWithSeq, seq, req)
 692        )
 693    
 694    def query_stock_trades_async(self, account, callback):
 695        """
 696        :param account:  证券账号
 697        :return:  返回当日所有成交的成交对象组成的list
 698        """
 699        req = XTQC.QueryStockTradesReq()
 700        req.m_nAccountType = account.account_type
 701        req.m_strAccountID = account.account_id
 702        
 703        seq = self.async_client.nextSeq()
 704        return self.common_op_async_with_seq(
 705            seq,
 706            (self.async_client.queryStockTradesWithSeq, seq, req)
 707            , callback
 708        )
 709
 710    def query_stock_position(self, account, stock_code):
 711        """
 712        :param account: 证券账号
 713        :param stock_code: 证券代码, 例如"600000.SH"
 714        :return: 返回证券代码对应的持仓对象
 715        """
 716        req = XTQC.QueryStockPositionsReq()
 717        req.m_nAccountType = account.account_type
 718        req.m_strAccountID = account.account_id
 719        req.m_strStockCode = stock_code
 720        
 721        seq = self.async_client.nextSeq()
 722        resp = self.common_op_sync_with_seq(
 723            seq,
 724            (self.async_client.queryStockPositionsWithSeq, seq, req)
 725        )
 726        if resp and len(resp):
 727            return resp[0]
 728        return None
 729
 730    def query_stock_positions(self, account):
 731        """
 732        :param account: 证券账号
 733        :return: 返回当日所有持仓的持仓对象组成的list
 734        """
 735        req = XTQC.QueryStockPositionsReq()
 736        req.m_nAccountType = account.account_type
 737        req.m_strAccountID = account.account_id
 738        
 739        seq = self.async_client.nextSeq()
 740        return self.common_op_sync_with_seq(
 741            seq,
 742            (self.async_client.queryStockPositionsWithSeq, seq, req)
 743        )
 744    
 745    def query_stock_positions_async(self, account, callback):
 746        """
 747        :param account: 证券账号
 748        :return: 返回当日所有持仓的持仓对象组成的list
 749        """
 750        req = XTQC.QueryStockPositionsReq()
 751        req.m_nAccountType = account.account_type
 752        req.m_strAccountID = account.account_id
 753        
 754        seq = self.async_client.nextSeq()
 755        return self.common_op_async_with_seq(
 756            seq
 757            , (self.async_client.queryStockPositionsWithSeq, seq, req)
 758            , callback
 759        )
 760
 761    def query_credit_detail(self, account):
 762        """
 763        :param account: 证券账号
 764        :return: 返回当前证券账号的资产数据
 765        """
 766        req = XTQC.QueryCreditDetailReq()
 767        req.m_nAccountType = account.account_type
 768        req.m_strAccountID = account.account_id
 769        
 770        seq = self.async_client.nextSeq()
 771        return self.common_op_sync_with_seq(
 772            seq,
 773            (self.async_client.queryCreditDetailWithSeq, seq, req)
 774        )
 775    
 776    def query_credit_detail_async(self, account, callback):
 777        """
 778        :param account: 证券账号
 779        :return: 返回当前证券账号的资产数据
 780        """
 781        req = XTQC.QueryCreditDetailReq()
 782        req.m_nAccountType = account.account_type
 783        req.m_strAccountID = account.account_id
 784        
 785        seq = self.async_client.nextSeq()
 786        return self.common_op_async_with_seq(
 787            seq,
 788            (self.async_client.queryCreditDetailWithSeq, seq, req)
 789            , callback
 790        )
 791
 792    def query_stk_compacts(self, account):
 793        """
 794        :param account: 证券账号
 795        :return: 返回负债合约
 796        """
 797        req = XTQC.QueryStkCompactsReq()
 798        req.m_nAccountType = account.account_type
 799        req.m_strAccountID = account.account_id
 800        
 801        seq = self.async_client.nextSeq()
 802        return self.common_op_sync_with_seq(
 803            seq,
 804            (self.async_client.queryStkCompactsWithSeq, seq, req)
 805        )
 806    
 807    def query_stk_compacts_async(self, account, callback):
 808        """
 809        :param account: 证券账号
 810        :return: 返回负债合约
 811        """
 812        req = XTQC.QueryStkCompactsReq()
 813        req.m_nAccountType = account.account_type
 814        req.m_strAccountID = account.account_id
 815        
 816        seq = self.async_client.nextSeq()
 817        return self.common_op_async_with_seq(
 818            seq,
 819            (self.async_client.queryStkCompactsWithSeq, seq, req)
 820            , callback
 821        )
 822    
 823    def query_credit_subjects(self, account):
 824        """
 825        :param account: 证券账号
 826        :return: 返回融资融券标的
 827        """
 828        req = XTQC.QueryCreditSubjectsReq()
 829        req.m_nAccountType = account.account_type
 830        req.m_strAccountID = account.account_id
 831        
 832        seq = self.async_client.nextSeq()
 833        return self.common_op_sync_with_seq(
 834            seq,
 835            (self.async_client.queryCreditSubjectsWithSeq, seq, req)
 836        )
 837    
 838    def query_credit_subjects_async(self, account, callback):
 839        """
 840        :param account: 证券账号
 841        :return: 返回融资融券标的
 842        """
 843        req = XTQC.QueryCreditSubjectsReq()
 844        req.m_nAccountType = account.account_type
 845        req.m_strAccountID = account.account_id
 846        
 847        seq = self.async_client.nextSeq()
 848        return self.common_op_async_with_seq(
 849            seq,
 850            (self.async_client.queryCreditSubjectsWithSeq, seq, req)
 851            , callback
 852        )
 853    
 854    def query_credit_slo_code(self, account):
 855        """
 856        :param account: 证券账号
 857        :return: 返回可融券数据
 858        """
 859        req = XTQC.QueryCreditSloCodeReq()
 860        req.m_nAccountType = account.account_type
 861        req.m_strAccountID = account.account_id
 862        
 863        seq = self.async_client.nextSeq()
 864        return self.common_op_sync_with_seq(
 865            seq,
 866            (self.async_client.queryCreditSloCodeWithSeq, seq, req)
 867        )
 868    
 869    def query_credit_slo_code_async(self, account, callback):
 870        """
 871        :param account: 证券账号
 872        :return: 返回可融券数据
 873        """
 874        req = XTQC.QueryCreditSloCodeReq()
 875        req.m_nAccountType = account.account_type
 876        req.m_strAccountID = account.account_id
 877        
 878        seq = self.async_client.nextSeq()
 879        return self.common_op_async_with_seq(
 880            seq,
 881            (self.async_client.queryCreditSloCodeWithSeq, seq, req)
 882            , callback
 883        )
 884    
 885    def query_credit_assure(self, account):
 886        """
 887        :param account: 证券账号
 888        :return: 返回标的担保品
 889        """
 890        req = XTQC.QueryCreditAssureReq()
 891        req.m_nAccountType = account.account_type
 892        req.m_strAccountID = account.account_id
 893        
 894        seq = self.async_client.nextSeq()
 895        return self.common_op_sync_with_seq(
 896            seq,
 897            (self.async_client.queryCreditAssureWithSeq, seq, req)
 898        )
 899    
 900    def query_credit_assure_async(self, account, callback):
 901        """
 902        :param account: 证券账号
 903        :return: 返回标的担保品
 904        """
 905        req = XTQC.QueryCreditAssureReq()
 906        req.m_nAccountType = account.account_type
 907        req.m_strAccountID = account.account_id
 908        
 909        seq = self.async_client.nextSeq()
 910        return self.common_op_async_with_seq(
 911            seq,
 912            (self.async_client.queryCreditAssureWithSeq, seq, req)
 913            , callback
 914        )
 915    
 916    def query_new_purchase_limit(self, account):
 917        """
 918        :param account: 证券账号
 919        :return: 返回账户新股申购额度数据
 920        """
 921        req = XTQC.QueryNewPurchaseLimitReq()
 922        req.m_nAccountType = account.account_type
 923        req.m_strAccountID = account.account_id
 924        
 925        seq = self.async_client.nextSeq()
 926        new_purchase_limit_list = self.common_op_sync_with_seq(
 927            seq,
 928            (self.async_client.queryNewPurchaseLimitWithSeq, seq, req)
 929        )
 930        new_purchase_limit_result = dict()
 931        for item in new_purchase_limit_list:
 932            new_purchase_limit_result[item.m_strNewPurchaseLimitKey] = item.m_nNewPurchaseLimitValue
 933        return new_purchase_limit_result
 934        
 935    def query_new_purchase_limit_async(self, account, callback):
 936        """
 937        :param account: 证券账号
 938        :return: 返回账户新股申购额度数据
 939        """
 940        req = XTQC.QueryNewPurchaseLimitReq()
 941        req.m_nAccountType = account.account_type
 942        req.m_strAccountID = account.account_id
 943        
 944        seq = self.async_client.nextSeq()
 945        return self.common_op_async_with_seq(
 946            seq,
 947            (self.async_client.queryNewPurchaseLimitWithSeq, seq, req)
 948            , callback
 949        )
 950    
 951    def query_ipo_data(self):
 952        """
 953        :return: 返回新股新债信息
 954        """
 955        req = XTQC.QueryIPODataReq()
 956        req.m_strIPOType = ''
 957        
 958        seq = self.async_client.nextSeq()
 959        ipo_data_list = self.common_op_sync_with_seq(
 960            seq,
 961            (self.async_client.queryIPODataWithSeq, seq, req)
 962        )
 963        ipo_data_result = dict()
 964        for item in ipo_data_list:
 965            ipo_data_result[item.m_strIPOCode] = {
 966                'name': item.m_strIPOName, 
 967                'type':  item.m_strIPOType, 
 968                'maxPurchaseNum':  item.m_nMaxPurchaseNum, 
 969                'minPurchaseNum':  item.m_nMinPurchaseNum, 
 970                'purchaseDate':  item.m_strPurchaseDate, 
 971                'issuePrice': item.m_dIssuePrice,
 972            }
 973        return ipo_data_result
 974        
 975    def query_ipo_data_async(self, callback):
 976        """
 977        :return: 返回新股新债信息
 978        """
 979        req = XTQC.QueryIPODataReq()
 980        req.m_strIPOType = ''
 981        
 982        seq = self.async_client.nextSeq()
 983        return self.common_op_async_with_seq(
 984            seq,
 985            (self.async_client.queryIPODataWithSeq, seq, req)
 986            , callback
 987        )
 988    
 989    def query_appointment_info(self, account):
 990        """
 991        :param account: 证券账号
 992        :return: 返回约券合约信息
 993        """
 994        req = XTQC.QueryAppointmentInfoReq()
 995        req.m_nAccountType = 3
 996        req.m_strAccountID = account.account_id
 997        
 998        seq = self.async_client.nextSeq()
 999        appointment_info_list = self.common_op_sync_with_seq(
1000            seq,
1001            (self.async_client.queryAppointmentInfoWithSeq, seq, req)
1002        )      
1003        appointment_info_result = dict()
1004        for item in appointment_info_list:
1005            appointment_info_result[item.m_strCompactId] = {
1006                'success': item.m_bSuccess,
1007                'error': item.m_strError,
1008                'fundAccount': item.m_strFundAccount,
1009                'origCompactId': item.m_strOrigCompactId,
1010                'exchangeType': item.m_strExchangeType,
1011                'stockCode': item.m_strStockCode,
1012                'stockName': item.m_strStockName,
1013                'contractEndDate': item.m_nContractEndDate,
1014                'feeRatio': item.m_dFeeRatio,
1015                'compactTerm': item.m_nCompactTerm,
1016                'compactAmount': item.m_nCompactAmount,
1017                'compactRepayDate': item.m_nCompactRepayDate,
1018                'compactStatus': item.m_strCompactStatus,
1019                'positionStr': item.m_strPositionStr,
1020            }
1021        return appointment_info_result
1022    
1023    def query_appointment_info_async(self, account, callback):
1024        """
1025        :param account: 证券账号
1026        :return: 返回约券合约信息
1027        """
1028        req = XTQC.QueryAppointmentInfoReq()
1029        req.m_nAccountType = account.account_type
1030        req.m_strAccountID = account.account_id
1031        
1032        seq = self.async_client.nextSeq()
1033        return self.common_op_async_with_seq(
1034            seq,
1035            (self.async_client.queryAppointmentInfoWithSeq, seq, req)
1036            , callback
1037        )
1038
1039    def smt_appointment_async(self, account, stock_code, apt_days, apt_volume, fare_ratio, sub_rare_ratio, fine_ratio,
1040                          begin_date):
1041        """
1042        :param account: 证券账号
1043        :param stock_code: 证券代码, 例如"600000.SH"
1044        :param apt_days: 约定期限
1045        :param apt_volume: 约定数量
1046        :param fare_ratio: 约券费率
1047        :param sub_rare_ratio: 提前归还费率
1048        :param fine_ratio: 违约金率
1049        :param begin_date: 约定日期
1050        :return: 返回下单请求序号
1051        """
1052        req = XTQC.SmtAppointmentReq()
1053        req.m_strAccountID = account.account_id
1054        req.m_strStockCode = stock_code
1055        req.m_nAptDays = apt_days
1056        req.m_nVolume = apt_volume
1057        req.m_dFareRatio = fare_ratio
1058        req.m_dSubRareRatio = sub_rare_ratio
1059        req.m_dFineRatio = fine_ratio
1060        req.m_strBeginDate = begin_date
1061        
1062        
1063        seq = self.async_client.nextSeq()
1064        self.cbs[seq] = self.callback.on_smt_appointment_async_response
1065        self.async_client.smtAppointmentWithSeq(seq, req)
1066        return seq
1067       
1068    def query_smt_secu_info(self, account):
1069        """
1070        :param account: 证券账号
1071        :return: 返回券源券单信息
1072        """
1073        req = XTQC.QuerySMTSecuInfoReq()
1074        req.m_nAccountType = 3
1075        req.m_strAccountID = account.account_id
1076
1077        seq = self.async_client.nextSeq()
1078        smt_secu_info_list = self.common_op_sync_with_seq(
1079            seq,
1080            (self.async_client.querySMTSecuInfoWithSeq, seq, req)
1081        )
1082        smt_secu_info_result = dict()
1083        for item in smt_secu_info_list:
1084            stock = item.m_strStockCode + '.' +item.m_strExchangeType
1085            smt_secu_info_result[stock] = {
1086                'success': item.m_bSuccess, 
1087                'error':  item.m_strError, 
1088                'stockName': item.m_strStockName,
1089                'creditType':  item.m_strCreditType, 
1090                'tradeType': item.m_strTradeType,
1091                'compactTerm': item.m_nCompactTerm,
1092                'maxTerm': item.m_nMaxTerm,
1093                'lendAmount': item.m_nLendAmount,
1094                'remark': item.m_strRemark,
1095                'fareWay': item.m_strFareWay,
1096                'fareRateNew': item.m_dFareRateNew,
1097            }
1098        return smt_secu_info_result
1099    
1100    def query_smt_secu_rate(self, account, stock_code, max_term, fare_way, credit_type, trade_type):
1101        """
1102        :param account: 证券账号
1103        :param stock_code: 证券代码, 例如"600000.SH"
1104        :param max_term: 最大约定期限
1105        :param fare_way: 折扣标志
1106        :param credit_type: 资券类型
1107        :param trade_type: 业务类型
1108        :return: 返回券源费率信息
1109        """
1110        req = XTQC.QuerySMTSecuRateReq()
1111        req.m_nAccountType = 3
1112        req.m_strAccountID = account.account_id
1113        req.m_strStockCode = stock_code
1114        req.m_nMaxTerm = max_term
1115        req.m_strFareWay = fare_way
1116        req.m_strCreditType = credit_type
1117        req.m_strTradeType = trade_type
1118        
1119        seq = self.async_client.nextSeq()
1120        smt_secu_rate_list = self.common_op_sync_with_seq(
1121            seq,
1122            (self.async_client.querySMTSecuRateWithSeq, seq, req)
1123        )
1124        smt_secu_rate_result = dict()
1125        if smt_secu_rate_list:
1126            item = smt_secu_rate_list[0]
1127            smt_secu_rate_result = {
1128                'success': item.m_bSuccess, 
1129                'error':  item.m_strError, 
1130                'fareRatio': item.m_dFareRatio,
1131                'subRareRatio': item.m_dSubRareRatio,
1132                'fineRatio': item.m_dFineRatio,
1133        }
1134        return smt_secu_rate_result