okxv5 1.8.11__py3-none-any.whl → 1.8.13__py3-none-any.whl

okxv5/Rfq_api.py

@@ -3,113 +3,91 @@ from .consts import *
 
 
 class RfqAPI(Client):
-    # RfqAPI 类继承自 Client 类
     def __init__(self, api_key, api_secret_key, passphrase, use_server_time=False, flag='1'):
-        # 构造函数，初始化 Client 父类
         Client.__init__(self, api_key, api_secret_key, passphrase, use_server_time, flag)
 
     def counterparties(self):
-        # 获取对手方信息
         params = {}
         return self._request_with_params(GET, COUNTERPARTIES, params)
 
     def create_rfq(self, counterparties='', anonymous='', clRfqId='', allowPartialExecution = '', tag='', legs = []):
-        # 创建一个 RFQ (Request for Quote) 请求
         params = {'counterparties': counterparties, 'anonymous': anonymous, 'clRfqId': clRfqId, 'tag':tag, 'legs': legs}
         return self._request_with_params(POST, CREATE_RFQ, params)
 
     def cancel_rfq(self, rfqId = '', clRfqId = ''):
-        # 取消一个 RFQ 请求
         params = {'rfqId': rfqId, 'clRfqId': clRfqId}
         return self._request_with_params(POST, CANCEL_RFQ, params)
 
     def cancel_batch_rfqs(self, rfqIds='', clRfqIds=''):
-        # 批量取消 RFQ 请求
         params = {'rfqIds': rfqIds, 'clRfqIds': clRfqIds}
         return self._request_with_params(POST, CANCEL_BATCH_RFQS, params)
 
     def cancel_all_rfqs(self):
-        # 取消所有 RFQ 请求
         params = {}
         return self._request_with_params(POST, CANCEL_ALL_RSQS, params)
 
     def execute_quote(self, rfqId='', quoteId=''):
-        # 执行一个报价 (Quote)
         params = {'rfqId': rfqId, 'quoteId': quoteId}
         return self._request_with_params(POST, EXECUTE_QUOTE, params)
 
     def create_quote(self, rfqId='', clQuoteId='', tag = '', quoteSide = '', legs = [], expiresIn = '',anonymous = ''):
-        # 创建一个报价 (Quote)
         params = {'rfqId': rfqId, 'clQuoteId': clQuoteId, 'tag':tag, 'quoteSide': quoteSide, 'legs': legs, 'expiresIn':expiresIn, 'anonymous':anonymous}
         return self._request_with_params(POST, CREATE_QUOTE, params)
 
     def cancel_quote(self, quoteId  = '', clQuoteId = '', rfqId = ''):
-        # 取消一个报价 (Quote)
         params = {'quoteId': quoteId, 'clQuoteId': clQuoteId, 'rfqId':rfqId}
         return self._request_with_params(POST, CANCEL_QUOTE, params)
 
     def cancel_batch_quotes(self, quoteIds='', clQuoteIds=''):
-        # 批量取消报价
         params = {'quoteIds': quoteIds, 'clQuoteIds': clQuoteIds}
         return self._request_with_params(POST, CANCEL_BATCH_QUOTES, params)
 
     def cancel_all_quotes(self):
-        # 取消所有报价
         params = {}
         return self._request_with_params(POST, CANCEL_ALL_QUOTES, params)
 
     def get_rfqs(self, rfqId = '', clRfqId = '',  state = '', beginId = '', endId = '', limit = ''):
-        # 获取 RFQ 请求列表
         params = {'rfqId': rfqId, 'clRfqId': clRfqId, 'state': state, 'beginId': beginId, 'endId': endId, 'limit':limit}
         return self._request_with_params(GET, GET_RFQS, params)
 
     def get_quotes(self, rfqId = '', clRfqId = '', quoteId = '', clQuoteId = '', state = '', beginId = '', endId = '', limit = ''):
-        # 获取报价列表
         params = {'rfqId': rfqId, 'clRfqId': clRfqId, 'quoteId':quoteId,'clQuoteId':clQuoteId, 'state': state, 'beginId': beginId, 'endId': endId, 'limit':limit}
         return self._request_with_params(GET, GET_QUOTES, params)
 
     def get_rfq_trades(self, rfqId = '', clRfqId = '', quoteId = '', blockTdId = '', clQuoteId = '', isSuccessful = '', beginId = '', endId = '', limit = '', beginTs ='', endTs = ''):
-        # 获取 RFQ 相关的交易
         params = {'rfqId': rfqId, 'clRfqId': clRfqId, 'quoteId':quoteId,'clQuoteId':clQuoteId, 'isSuccessful': isSuccessful, 'beginId': beginId, 'endId': endId, 'limit':limit,'blockTdId':blockTdId,'beginTs':beginTs,'endTs':endTs}
         return self._request_with_params(GET, GET_RFQ_TRADES, params)
 
     def get_public_trades(self, beginId = '', endId = '', limit = ''):
-        # 获取公开交易列表
         params = {'beginId': beginId, 'endId': endId, 'limit': limit}
         return self._request_with_params(GET, GET_PUBLIC_TRADES, params)
 
 
     def rfq_cancel_all_after(self, timeOut = ''):
-        # 在指定时间后取消所有 RFQ 请求
         params = {'timeOut': timeOut}
         return self._request_with_params(POST, RFQ_CANCEL_ALL_AFTER, params)
 
     def maker_instrument_settings(self, instType='', data=[]):
-        # 设置做市商交易对参数
         params = [{'instType': instType, 'data': data}]
         return self._request_with_params(POST, MARKET_INSTRUMENT_SETTINGS, params)
 
     def mmp_reset(self):
-        # 重置 MMP (Market Making Protection)
         params = {}
         return self._request_with_params(POST, MMP_RESET, params)
 
     # POST /api/v5/rfq/mmp-config
     def mmp_config(self,timeInterval='',frozenInterval='',countLimit=''):
-        # 配置 MMP (Market Making Protection)
         params = {'timeInterval':timeInterval,'frozenInterval':frozenInterval,'countLimit':countLimit,}
         return self._request_with_params(POST, MMP_CONFIG, params)
 
     # GET /api/v5/rfq/maker-instrument-settings
     def get_maker_instrument_settings(self):
-        # 获取做市商交易对设置
         params = {}
         return self._request_with_params(GET, GET_MAKER_INSTRUMENT_SETTINGS, params)
 
 
     # GET /api/v5/rfq/maker-instrument-settings
     def mmp_configs(self,timeInterval='', frozenInterval='', countLimit='',mmpFrozen='',mmpFrozenUntil='',):
-        # 获取 MMP (Market Making Protection) 配置信息
         params = {'timeInterval':timeInterval,'frozenInterval':frozenInterval,'countLimit':countLimit,
                   'mmpFrozen':mmpFrozen,'mmpFrozenUntil':mmpFrozenUntil,}
         return self._request_with_params(GET, MMP_CONF, params)

okxv5/Singal_api.py

@@ -1,146 +1,91 @@
-# 从 .client 模块导入 Client 类
 from .client import Client
-# 从 .consts 模块导入所有常量
 from .consts import *
 
 
-# SignalApi 类继承自 Client 类
 class SignalApi(Client):
-    # 构造函数
     def __init__(self, api_key, api_secret_key, passphrase, use_server_time=False, flag='1'):
-        # 调用父类 Client 的构造函数
         Client.__init__(self, api_key, api_secret_key, passphrase, use_server_time, flag)
 
-    # 创建信号通道
-    def create_signal(self, signalChanName='', signalChanDesc=''):
-        # 构建请求参数
-        params = {'signalChanName': signalChanName, 'signalChanDesc': signalChanDesc}
-        # 发送 POST 请求创建信号
+
+    def create_signal(self,signalChanName='',signalChanDesc=''):
+        params = {'signalChanName':signalChanName,'signalChanDesc':signalChanDesc}
         return self._request_with_params(POST, CREAT_SIGNAL, params)
 
-    # 获取信号列表
-    def signals(self, signalSourceType='', signalChanId='', after='', before='',
+    def signals(self, signalSourceType='', signalChanId='',after='', before='',
                 limit='', ):
-        # 构建请求参数
-        params = {'signalSourceType': signalSourceType, 'signalChanId': signalChanId, 'after': after,
-                  'before': before, 'limit': limit, }
-        # 发送 GET 请求获取信号列表
+        params = {'signalSourceType': signalSourceType, 'signalChanId': signalChanId,'after': after,
+                  'before': before,'limit': limit,}
         return self._request_with_params(GET, SIGNALS, params)
 
-    # 策略下单
-    def order_algo(self, includeAll='', signalChanId='', instIds='', lever='',
-                   investAmt='', subOrdType='', ratio='', entrySettingParam='', exitSettingParam='', ):
-        # 构建请求参数
-        params = {'includeAll': includeAll, 'signalChanId': signalChanId, 'instIds': instIds,
-                  'lever': lever, 'investAmt': investAmt, 'subOrdType': subOrdType, 'ratio': ratio,
-                  'entrySettingParam': entrySettingParam,
-                  'exitSettingParam': exitSettingParam}
-        # 发送 POST 请求进行策略下单
+    def order_algo(self, includeAll='', signalChanId='',instIds='', lever='',
+                investAmt='',subOrdType='',ratio='',entrySettingParam='',exitSettingParam='', ):
+        params = {'includeAll': includeAll, 'signalChanId': signalChanId,'instIds': instIds,
+                  'lever': lever,'investAmt': investAmt,'subOrdType': subOrdType,'ratio': ratio,'entrySettingParam': entrySettingParam,
+                  'exitSettingParam':exitSettingParam}
         return self._request_with_params(POST, ORDER_ALGO_SIGNAL, params)
 
-    # 停止策略订单
     def signal_stop_order_algo(self, algoId='', ):
-        # 构建请求参数
         params = {'algoId': algoId, }
-        # 发送 POST 请求停止策略订单
         return self._request_with_params(POST, SIGNAL_STOP_ORDER_ALGO, params)
 
-    # 策略保证金余额操作
-    def signal_margin_balance(self, algoId='', type='', amt='', allowReinvest='', ):
-        # 构建请求参数
+    def signal_margin_balance(self, algoId='',type='',amt='',allowReinvest='', ):
         params = {'algoId': algoId, 'type': type, 'amt': amt, 'allowReinvest': allowReinvest, }
-        # 发送 POST 请求进行保证金余额操作
         return self._request_with_params(POST, SIGNAL_MARGIN_BALANCE, params)
 
-    # 修改止盈止损参数
-    def amendTPSL(self, algoId='', exitSettingParam='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'exitSettingParam': exitSettingParam, }
-        # 发送 POST 请求修改止盈止损参数
+    def amendTPSL(self, algoId='',exitSettingParam='', ):
+        params = {'algoId': algoId, 'exitSettingParam': exitSettingParam,  }
         return self._request_with_params(POST, AMENDTPSL, params)
 
-    # 设置策略交易对
-    def signal_set_instruments(self, algoId='', instIds='', includeAll=''):
-        # 构建请求参数
-        params = {'algoId': algoId, 'instIds': instIds, 'includeAll': includeAll}
-        # 发送 POST 请求设置策略交易对
+    def signal_set_instruments(self, algoId='',instIds='', includeAll=''):
+        params = {'algoId': algoId, 'instIds': instIds,'includeAll':includeAll}
         return self._request_with_params(POST, SIGNAL_SET_INSTRUMENTS, params)
 
-    # 获取策略订单详情
-    def orders_algo_details(self, algoId='', algoOrdType='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, }
-        # 发送 GET 请求获取策略订单详情
+    def orders_algo_details(self, algoId='',algoOrdType='', ):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType,}
         return self._request_with_params(GET, ORDERS_ALGO_DETAILS, params)
 
-    # 获取策略待处理订单
-    def orders_algo_pending(self, algoId='', algoOrdType='', after='', before='', limit='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, 'after': after,
-                  'before': before, 'limit': limit, }
-        # 发送 GET 请求获取策略待处理订单
+    def orders_algo_pending(self, algoId='',algoOrdType='',after='',before='',limit='', ):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType,'after': after,
+                  'before': before,'limit': limit,}
         return self._request_with_params(GET, ORDERS_ALGO_PENDING, params)
 
-    # 获取策略历史订单
-    def orders_algo_history(self, algoId='', algoOrdType='', after='', before='', limit='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, 'after': after,
-                  'before': before, 'limit': limit, }
-        # 发送 GET 请求获取策略历史订单
+    def orders_algo_history(self, algoId='',algoOrdType='',after='',before='',limit='', ):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType,'after': after,
+                  'before': before,'limit': limit,}
         return self._request_with_params(GET, ORDERS_ALGO_HISTORY, params)
 
-    # 获取策略持仓
-    def signal_positions(self, algoId='', algoOrdType='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, }
-        # 发送 GET 请求获取策略持仓
+    def signal_positions(self, algoId='',algoOrdType='', ):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType,}
         return self._request_with_params(GET, SIGNAL_POSITIONS, params)
 
-    # 获取策略历史持仓
-    def signal_positions_history(self, algoId='', instId='', after='', before='', limit='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'instId': instId, 'after': after,
-                  'before': before, 'limit': limit, }
-        # 发送 GET 请求获取策略历史持仓
+    def signal_positions_history(self, algoId='',instId='',after='',before='',limit='',  ):
+        params = {'algoId': algoId, 'instId': instId,'after': after,
+                  'before': before,'limit': limit,}
         return self._request_with_params(GET, SIGNAL_POSITIONS_HISTORY, params)
 
-    # 策略平仓
-    def signal_close_position(self, algoId='', instId='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'instId': instId, }
-        # 发送 POST 请求进行策略平仓
+    def signal_close_position(self, algoId='',instId='',):
+        params = {'algoId': algoId, 'instId': instId,}
         return self._request_with_params(POST, SIGNAL_CLOSE_POSITION, params)
 
-    # 下子订单
-    def sub_order(self, algoId='', instId='', side='', ordType='', sz='', px='', reduceOnly=''):
-        # 构建请求参数
-        params = {'algoId': algoId, 'instId': instId, 'side': side, 'ordType': ordType, 'sz': sz, 'px': px,
+    def sub_order(self, algoId='',instId='',side='',ordType='',sz='',px='',reduceOnly=''):
+        params = {'algoId': algoId, 'instId': instId,'side': side, 'ordType': ordType,'sz': sz, 'px': px,
                   'reduceOnly': reduceOnly, }
-        # 发送 POST 请求下子订单
         return self._request_with_params(POST, SUB_ORDER, params)
 
-    # 取消子订单
-    def cancel_sub_order(self, algoId='', instId='', signalOrdId='', ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'instId': instId, 'signalOrdId': signalOrdId, }
-        # 发送 POST 请求取消子订单
+    def cancel_sub_order(self, algoId='',instId='',signalOrdId='',):
+        params = {'algoId': algoId, 'instId': instId,'signalOrdId': signalOrdId,}
         return self._request_with_params(POST, CANCEL_SUB_ORDER, params)
 
-    # 获取子订单列表
-    def sub_orders(self, algoId='', algoOrdType='', signalOrdId='', state='', after='', before='', limit='',
-                   begin='', end='', type='', clOrdId=''):
-        # 构建请求参数
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, 'state': state, 'after': after, 'before': before,
-                  'limit': limit,
-                  'begin': begin, 'end': end, 'type': type, 'clOrdId': clOrdId, 'signalOrdId': signalOrdId, }
-        # 发送 GET 请求获取子订单列表
+    def sub_orders(self, algoId='',algoOrdType='',signalOrdId='',state='',after='',before='',limit='',
+                   begin='',end='',type='',clOrdId=''):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType,'state': state,'after': after, 'before': before,'limit': limit,
+                  'begin': begin, 'end': end,'type': type,'clOrdId': clOrdId, 'signalOrdId': signalOrdId, }
         return self._request_with_params(GET, SUB_ORDERS, params)
 
-    # 获取事件历史
-    def event_history(self, algoId='', after='', before='', limit='',
-                      ):
-        # 构建请求参数
-        params = {'algoId': algoId, 'after': after, 'before': before, 'limit': limit,
-                  }
-        # 发送 GET 请求获取事件历史
+    def event_history(self, algoId='',after='',before='',limit='',
+                  ):
+        params = {'algoId': algoId, 'after': after, 'before': before,'limit': limit,
+                 }
         return self._request_with_params(GET, EVENT_HISTORY, params)
+
+

okxv5/SprdApi_api.py

@@ -4,90 +4,36 @@ from .consts import *
 
 class SprdAPI(Client):
     def __init__(self, api_key, api_secret_key, passphrase, use_server_time=False, flag='1'):
-        # 调用父类Client的构造函数
         Client.__init__(self, api_key, api_secret_key, passphrase, use_server_time, flag)
 
     # 下单 POST /api/v5/sprd/order
-    # Place Order
     def place(self,sprdId,side,ordType,sz,px='',clOrdId='',tag='',):
-        """
-        下单
-        :param sprdId: Spread ID，交易对，如 BTC-USD
-        :param side: 订单方向，买或卖（buy, sell）
-        :param ordType: 订单类型，如 limit（限价单），market（市价单）
-        :param sz: 订单数量
-        :param px: 价格，仅限限价单
-        :param clOrdId: 客户自定义订单ID
-        :param tag: 订单标签
-        :return: 请求结果
-        """
         params = {'sprdId':sprdId,'clOrdId':clOrdId,'tag':tag,'side':side,'ordType':ordType,
                   'sz':sz,'px':px,}
         return self._request_with_params(POST, SPRD_PLACE_ORDER, params)
 
     # 撤单 POST /api/v5/sprd/cancel-order
-    # Cancel Order
     def cancel_order(self,ordId='',clOrdId=''):
-        """
-        撤销订单
-        :param ordId: 订单ID
-        :param clOrdId: 客户自定义订单ID
-        :return: 请求结果
-        """
         params = {'ordId':ordId,'clOrdId':clOrdId}
         return self._request_with_params(POST, SPRD_CANCEL_ORDER, params)
 
     # 全部撤单 POST /api/v5/sprd/mass-cancel
-    # Mass Cancel Orders
     def mass_cancel(self,sprdId):
-        """
-        批量撤销订单
-        :param sprdId: Spread ID，交易对
-        :return: 请求结果
-        """
         params = {'sprdId':sprdId}
         return self._request_with_params(POST, SPRD_MASS_CANCELS, params)
 
     # 修改订单 POST /api/v5/sprd/amend-order
-    # Amend Order
     def amend_cancel(self,reqId='',ordId='', clOrdId='', newSz='', newPx=''):
-        """
-        修改订单
-        :param reqId: 请求ID
-        :param ordId: 订单ID
-        :param clOrdId: 客户自定义订单ID
-        :param newSz: 新的订单数量
-        :param newPx: 新的订单价格
-        :return: 请求结果
-        """
         params = {'reqId':reqId, 'ordId':ordId, 'clOrdId':clOrdId, 'newSz':newSz, 'newPx':newPx, }
         return self._request_with_params(POST, SPRD_AMEND_CANCELS, params)
 
     # 获取订单信息 GET /api/v5/sprd/order
-    # Get Order Details
     def order(self, ordId='', clOrdId=''):
-        """
-        获取订单信息
-        :param ordId: 订单ID
-        :param clOrdId: 客户自定义订单ID
-        :return: 请求结果
-        """
         params = {'ordId': ordId, 'clOrdId': clOrdId}
         return self._request_with_params(GET, SPRD_ORDER, params)
 
     # 获取未成交订单列表 GET /api/v5/sprd/orders-pending
-    # Get Pending Orders List
     def orders_pending(self,sprdId='', ordType='', state='', beginId='', endId='', limit=''):
-        """
-        获取未成交订单列表
-        :param sprdId: Spread ID，交易对
-        :param ordType: 订单类型
-        :param state: 订单状态
-        :param beginId: 起始订单ID
-        :param endId: 结束订单ID
-        :param limit: 返回结果数量限制
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'ordType': ordType,
                   'state': state,
                   'endId': endId,
@@ -96,158 +42,66 @@ class SprdAPI(Client):
         return self._request_with_params(GET, SPRD_ORDERS_PENDING, params)
 
     # 获取历史订单记录（近21天) GET /api/v5/sprd/orders-history
-    # Get Order History (last 21 days)
     def orders_history(self,sprdId='',ordType='',state='',beginId='',endId='',limit='',
                        begin='',end='',):
-        """
-        获取历史订单记录（近21天）
-        :param sprdId: Spread ID，交易对
-        :param ordType: 订单类型
-        :param state: 订单状态
-        :param beginId: 起始订单ID
-        :param endId: 结束订单ID
-        :param limit: 返回结果数量限制
-        :param begin: 查询起始时间戳
-        :param end: 查询结束时间戳
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'ordType': ordType,
-                  'state': state,'begin': begin, # 注意: 原始代码此处'begin': state可能是个错误，应为'begin': begin
-                  'endId': endId,'end': end,     # 注意: 原始代码此处'end': endId可能是个错误，应为'end': end
+                  'state': state,'begin': state,
+                  'endId': endId,'end': endId,
                   'beginId': beginId, 'limit': limit,
                   }
         return self._request_with_params(GET, SPRD_ORDERS_HISTORY, params)
 
 
     # 获取历史订单记录（近3个月) GET /api/v5/sprd/orders-history-archive
-    # Get Order History Archive (last 3 months)
     def orders_history_archive(self, sprdId='', ordType='', state='', beginId='', endId='', limit='',
                        begin='', end='', ):
-        """
-        获取历史订单记录（近3个月）
-        :param sprdId: Spread ID，交易对
-        :param ordType: 订单类型
-        :param state: 订单状态
-        :param beginId: 起始订单ID
-        :param endId: 结束订单ID
-        :param limit: 返回结果数量限制
-        :param begin: 查询起始时间戳
-        :param end: 查询结束时间戳
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'ordType': ordType,
-                  'state': state, 'begin': begin, # 注意: 原始代码此处'begin': state可能是个错误，应为'begin': begin
-                  'endId': endId, 'end': end,     # 注意: 原始代码此处'end': endId可能是个错误，应为'end': end
+                  'state': state, 'begin': state,
+                  'endId': endId, 'end': endId,
                   'beginId': beginId, 'limit': limit,
                   }
         return self._request_with_params(GET, SPRD_ORDERS_HISTORY_ARCHIVE, params)
 
     # 获取历史成交数据（近七天）GET /api/v5/sprd/trades
-    # Get Trade History (last 7 days)
     def trades(self,sprdId='',tradeId='',ordId='',beginId='',endId='',limit='',begin='',end='',):
-        """
-        获取历史成交数据（近七天）
-        :param sprdId: Spread ID，交易对
-        :param tradeId: 成交ID
-        :param ordId: 订单ID
-        :param beginId: 起始成交ID
-        :param endId: 结束成交ID
-        :param limit: 返回结果数量限制
-        :param begin: 查询起始时间戳
-        :param end: 查询结束时间戳
-        :return: 请求结果
-        """
-        params = {'sprdId': sprdId, 'ordId': ordId,'tradeId': tradeId,'begin': begin, # 注意: 原始代码此处'begin': state可能是个错误，应为'begin': begin
-                  'endId': endId,'end': end, # 注意: 原始代码此处'end': endId可能是个错误，应为'end': end
+        params = {'sprdId': sprdId, 'ordId': ordId,'tradeId': tradeId,'begin': state,'endId': endId,'end': endId,
                   'beginId': beginId, 'limit': limit,}
         return self._request_with_params(GET, SPRD_TRADES, params)
 
     # 获取Spreads（公共）GET /api/v5/sprd/spreads
-    # Get Spreads (Public)
     def spreads(self,baseCcy='',instId='',sprdId='',state='',):
-        """
-        获取所有或指定Spread产品信息（公共）
-        :param baseCcy: 标的币种
-        :param instId: 乐器ID
-        :param sprdId: Spread ID，交易对
-        :param state: Spread产品状态
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'baseCcy': baseCcy, 'instId': instId,'state': state,}
         return self._request_with_params(GET, SPRD_SPREADS, params)
 
     # 获取Spread产品深度（公共）GET /api/v5/sprd/books
-    # Get Spread Product Depth (Public)
     def books(self,sprdId='',sz='',):
-        """
-        获取Spread产品深度信息（公共）
-        :param sprdId: Spread ID，交易对
-        :param sz: 深度档位数量
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'sz': sz,}
         return self._request_with_params(GET, SPRD_BOOKS, params)
 
     # 获取单个Spread产品行情信息（公共） GET /api/v5/sprd/ticker
-    # Get Single Spread Product Ticker (Public)
     def ticker(self,sprdId=''):
-        """
-        获取单个Spread产品行情信息（公共）
-        :param sprdId: Spread ID，交易对
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId}
         return self._request_with_params(GET, SPRD_TICKER, params)
 
     # 获取公共成交数据（公共）GET /api/v5/sprd/public-trades
-    # Get Public Trade Data (Public)
     def public_trades(self,sprdId=''):
-        """
-        获取公共成交数据（公共）
-        :param sprdId: Spread ID，交易对
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId}
         return self._request_with_params(GET, SPRD_PUBLIC_TRADES, params)
 
     # POST /api/v5/sprd/cancel-all-after
-    # Cancel All Orders After Timeout
     def sprd_cancel_all_after(self,timeOut=''):
-        """
-        设置自动撤销所有订单的倒计时
-        :param timeOut: 倒计时（毫秒）
-        :return: 请求结果
-        """
         params = {'timeOut':timeOut }
         return self._request_with_params(POST, SPRD_CANCEL_ALL_AFTER, params)
 
 
     # GET /api/v5/market/sprd-candles
-    # Get Spread Candlestick Data
     def get_sprd_candles(self,sprdId='', bar='', after='', before='', limit=''):
-        """
-        获取Spread产品K线数据
-        :param sprdId: Spread ID，交易对
-        :param bar: K线周期
-        :param after: 查询起始时间戳
-        :param before: 查询结束时间戳
-        :param limit: 返回结果数量限制
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'bar': bar, 'after': after, 'before': before, 'limit': limit}
         return self._request_with_params(GET, GET_SPRD_CANDLES, params)
 
     # GET /api/v5/market/sprd-history-candles
-    # Get Spread Historical Candlestick Data
     def get_sprd_history_candles(self,sprdId='', bar='', after='', before='', limit=''):
-        """
-        获取Spread产品历史K线数据
-        :param sprdId: Spread ID，交易对
-        :param bar: K线周期
-        :param after: 查询起始时间戳
-        :param before: 查询结束时间戳
-        :param limit: 返回结果数量限制
-        :return: 请求结果
-        """
         params = {'sprdId': sprdId, 'bar': bar, 'after': after, 'before': before, 'limit': limit}
-        return self._request_with_params(GET, GET_SPRD_HISTORY_CANDLES, params)
+        return self._request_with_params(GET, GET_SPRD_HISTORY_CANDLES, params)
+
+