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

okxv5/TradingBot_api.py

@@ -1,127 +1,67 @@
-# 从.client模块导入Client类
 from .client import Client
-# 从.consts模块导入所有常量
 from .consts import *
 
 
-# 定义TradingBotAPI类，它继承自Client类
 class TradingBotAPI(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 grid_order_algo(self, instId='', algoOrdType='', maxPx='', minPx='', gridNum='', runType='', tpTriggerPx='',
-                        slTriggerPx='', tag='', quoteSz='', algoClOrdId='',
-                        baseSz='', sz='', direction='', lever='', basePos='', tpRatio='', slRatio='',
-                        profitSharingRatio='', triggerParams=[]):
-        # 构建请求参数字典
-        params = {'instId': instId, 'algoOrdType': algoOrdType, 'maxPx': maxPx, 'minPx': minPx, 'gridNum': gridNum,
-                  'runType': runType, 'tpTriggerPx': tpTriggerPx, 'slTriggerPx': slTriggerPx, 'tag': tag,
-                  'quoteSz': quoteSz, 'baseSz': baseSz, 'sz': sz, 'direction': direction, 'lever': lever,
-                  'basePos': basePos,
-                  'tpRatio': tpRatio, 'slRatio': slRatio, 'algoClOrdId': algoClOrdId,
-                  'profitSharingRatio': profitSharingRatio, 'triggerParams': triggerParams}
-        # 发送POST请求，创建网格策略订单
+    def grid_order_algo(self, instId = '', algoOrdType = '', maxPx= '', minPx = '', gridNum ='', runType = '', tpTriggerPx = '', slTriggerPx = '', tag = '', quoteSz = '',algoClOrdId='',
+                        baseSz = '', sz = '', direction = '', lever = '', basePos = '',tpRatio = '',slRatio='',profitSharingRatio='',triggerParams =[]):
+        params = {'instId': instId, 'algoOrdType': algoOrdType, 'maxPx': maxPx, 'minPx': minPx, 'gridNum': gridNum, 'runType': runType, 'tpTriggerPx': tpTriggerPx, 'slTriggerPx': slTriggerPx, 'tag': tag, 'quoteSz': quoteSz, 'baseSz': baseSz, 'sz': sz, 'direction': direction, 'lever': lever, 'basePos':basePos,
+                  'tpRatio': tpRatio,'slRatio': slRatio,'algoClOrdId':algoClOrdId,'profitSharingRatio':profitSharingRatio,'triggerParams':triggerParams}
         return self._request_with_params(POST, GRID_ORDER_ALGO, params)
 
-    # 修改网格策略订单
-    def grid_amend_order_algo(self, algoId='', instId='', slTriggerPx='', tpTriggerPx='', tpRatio='', slRatio=''):
-        # 构建请求参数字典
-        params = {'algoId': algoId, 'instId': instId, 'slTriggerPx': slTriggerPx, 'tpTriggerPx': tpTriggerPx,
-                  'tpRatio': tpRatio, 'slRatio': slRatio, }
-        # 发送POST请求，修改网格策略订单
+    def grid_amend_order_algo(self, algoId = '', instId = '', slTriggerPx= '', tpTriggerPx ='',tpRatio = '',slRatio=''):
+        params = {'algoId': algoId, 'instId': instId, 'slTriggerPx': slTriggerPx, 'tpTriggerPx': tpTriggerPx,'tpRatio': tpRatio,'slRatio': slRatio,}
         return self._request_with_params(POST, GRID_AMEND_ORDER_ALGO, params)
 
-    # 停止网格策略订单
-    def grid_stop_order_algo(self, algoId='', instId='', algoOrdType='', stopType=''):
-        # 构建请求参数列表（注意这里是一个包含字典的列表）
+    def grid_stop_order_algo(self, algoId = '', instId = '', algoOrdType= '', stopType =''):
         params = [{'algoId': algoId, 'instId': instId, 'algoOrdType': algoOrdType, 'stopType': stopType}]
-        # 发送POST请求，停止网格策略订单
         return self._request_with_params(POST, GRID_STOP_ORDER_ALGO, params)
-
-    # 获取网格策略待处理订单列表
-    def grid_orders_algo_pending(self, algoOrdType='', algoId='', instId='', instType='', after='', before='',
-                                 limit=''):
-        # 构建请求参数字典
-        params = {'algoOrdType': algoOrdType, 'algoId': algoId, 'instId': instId, 'instType': instType,
-                  'after': after, 'before': before, 'limit': limit}
-        # 发送GET请求，获取网格策略待处理订单
+    
+    def grid_orders_algo_pending(self, algoOrdType = '', algoId = '', instId = '', instType = '', after = '', before = '', limit = ''):
+        params = {'algoOrdType': algoOrdType, 'algoId': algoId, 'instId': instId, 'instType': instType, 'after': after, 'before': before, 'limit': limit}
         return self._request_with_params(GET, GRID_ORDERS_ALGO_PENDING, params)
 
-    # 获取网格策略历史订单列表
-    def grid_orders_algo_history(self, algoOrdType='', algoId='', instId='', instType='', after='', before='',
-                                 limit=''):
-        # 构建请求参数字典
-        params = {'algoOrdType': algoOrdType, 'algoId': algoId, 'instId': instId, 'instType': instType,
-                  'after': after, 'before': before, 'limit': limit}
-        # 发送GET请求，获取网格策略历史订单
+    def grid_orders_algo_history(self, algoOrdType = '', algoId = '', instId = '', instType = '', after = '', before = '', limit = ''):
+        params = {'algoOrdType': algoOrdType, 'algoId': algoId, 'instId': instId, 'instType': instType, 'after': after, 'before': before, 'limit': limit}
         return self._request_with_params(GET, GRID_ORDERS_ALGO_HISTORY, params)
 
-    # 获取网格策略订单详情
-    def grid_orders_algo_details(self, algoOrdType='', algoId=''):
-        # 构建请求参数字典
+    def grid_orders_algo_details(self, algoOrdType = '', algoId = ''):
         params = {'algoOrdType': algoOrdType, 'algoId': algoId}
-        # 发送GET请求，获取网格策略订单详情
         return self._request_with_params(GET, GRID_ORDERS_ALGO_DETAILS, params)
 
-    # 获取网格子订单列表
-    def grid_sub_orders(self, algoId='', algoOrdType='', type='', groupId='', after='', before='', limit=''):
-        # 构建请求参数字典
-        params = {'algoId': algoId, 'algoOrdType': algoOrdType, 'type': type, 'groupId': groupId, 'after': after,
-                  'before': before, 'limit': limit}
-        # 发送GET请求，获取网格子订单
+    def grid_sub_orders(self, algoId = '', algoOrdType = '', type = '', groupId = '', after = '', before = '', limit = ''):
+        params = {'algoId': algoId, 'algoOrdType': algoOrdType, 'type': type, 'groupId': groupId, 'after': after, 'before': before, 'limit': limit}
         return self._request_with_params(GET, GRID_SUB_ORDERS, params)
 
-    # 获取网格策略持仓信息
-    def grid_positions(self, algoOrdType='', algoId=''):
-        # 构建请求参数字典
+    def grid_positions(self, algoOrdType = '', algoId = ''):
         params = {'algoOrdType': algoOrdType, 'algoId': algoId}
-        # 发送GET请求，获取网格策略持仓
         return self._request_with_params(GET, GRID_POSITIONS, params)
 
-    # 提取网格策略收益
-    def grid_withdraw_income(self, algoId=''):
-        # 构建请求参数字典
+    def grid_withdraw_income(self, algoId = ''):
         params = {'algoId': algoId}
-        # 发送POST请求，提取网格策略收益
         return self._request_with_params(POST, GRID_WITHDRAW_INCOME, params)
 
-    # 计算网格策略的保证金余额
-    def grid_compute_margin_balance(self, algoId='', type='', amt=''):
-        # 构建请求参数字典
-        params = {'algoId': algoId, 'type': type, 'amt': amt}
-        # 发送POST请求，计算网格策略保证金余额
+    def grid_compute_margin_balance(self, algoId = '', type = '', amt = ''):
+        params = {'algoId': algoId, 'type':type, 'amt':amt}
         return self._request_with_params(POST, GRID_COMPUTE_MARGIN_BALANCE, params)
 
-    # 调整网格策略的保证金
-    def grid_margin_balance(self, algoId='', type='', amt='', percent=''):
-        # 构建请求参数字典
-        params = {'algoId': algoId, 'type': type, 'amt': amt, 'percent': percent}
-        # 发送POST请求，调整网格策略保证金
+    def grid_margin_balance(self, algoId = '', type = '', amt = '', percent = ''):
+        params = {'algoId': algoId, 'type':type, 'amt':amt, 'percent':percent}
         return self._request_with_params(POST, GRID_MARGIN_BALANCE, params)
 
-    # 获取网格策略AI参数
-    def grid_ai_param(self, algoOrdType='', instId='', direction='', duration=''):
-        # 构建请求参数字典
-        params = {'algoOrdType': algoOrdType, 'instId': instId, 'direction': direction, 'duration': duration}
-        # 发送GET请求，获取网格策略AI参数
+    def grid_ai_param(self, algoOrdType = '', instId = '', direction = '', duration = ''):
+        params = {'algoOrdType': algoOrdType, 'instId':instId, 'direction':direction, 'duration':duration}
         return self._request_with_params(GET, GRID_AI_PARAM, params)
 
     # POST /api/v5/tradingBot/grid/adjust-investment
-    # 调整网格策略的投入资金
-    def grid_adjust_investment(self, algoId='', amt=''):
-        # 构建请求参数字典
-        params = {'algoId': algoId, 'amt': amt}
-        # 发送POST请求，调整网格策略投入资金
+    def grid_adjust_investment(self, algoId = '', amt = ''):
+        params = {'algoId': algoId, 'amt':amt}
         return self._request_with_params(POST, GRID_ADJUST_INVESTMETN, params)
 
     # GET /api/v5/tradingBot/grid/grid-quantity
-    # 获取网格策略的网格数量
-    def grid_quantity(self, instId='', runType='', algoOrdType='', maxPx='', minPx='', lever=''):
-        # 构建请求参数字典
-        params = {'instId': instId, 'runType': runType, 'algoOrdType': algoOrdType, 'maxPx': maxPx, 'minPx': minPx,
-                  'lever': lever}
-        # 发送GET请求，获取网格策略网格数量
+    def grid_quantity(self, instId = '', runType = '', algoOrdType = '', maxPx = '', minPx = '', lever = ''):
+        params = {'instId': instId, 'runType': runType, 'algoOrdType': algoOrdType, 'maxPx': maxPx, 'minPx': minPx, 'lever': lever}
         return self._request_with_params(GET, GRID_QUANTITY, params)

okxv5/TradingData_api.py

@@ -1,120 +1,77 @@
-# 从.client模块导入Client类
 from .client import Client
-# 从.consts模块导入所有常量
 from .consts import *
 
 
-# 交易数据API类，继承自Client
 class TradingDataAPI(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 get_support_coin(self):
         return self._request_without_params(GET, SUPPORT_COIN)
 
     # GET /api/v5/rubik/stat/contracts/open-interest-history    
-    # 获取合约持仓量历史
     def get_open_interest_history(self, instId = '', period = '', end = '', begin = '', limit = ''):
-        # 构建请求参数
         params = {'instId': instId, 'period': period, 'end': end, 'begin': begin, 'limit': limit}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, GET_OPEN_INTEREST_HISTORY, params)
 
-    # 获取Taker成交量
     def get_taker_volume(self, ccy, instType, begin='', end='', period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'instType': instType, 'begin': begin, 'end': end, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, TAKER_VOLUME, params)
 
     # GET /api/v5/rubik/stat/taker-volume-contract
-    # 获取合约Taker成交量
     def get_taker_volume_contract(self, instId, period = '', unit='', end='', begin='', limit = ''):
-        # 构建请求参数
         params = {'instId': instId, 'period': period, 'unit': unit, 'end': end, 'begin': begin,'limit':limit}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, GET_TAKER_VOLUME_CONTRACT, params)
 
-    # 获取杠杆借贷比率
     def get_margin_lending_ratio(self, ccy, begin='', end='', period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'begin': begin, 'end': end, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, MARGIN_LENDING_RATIO, params)
 
     # GET /api/v5/rubik/stat/contracts/long-short-account-ratio-contract-top-trader
-    # 获取合约多空账户比率-顶尖交易员
     def get_long_short_account_ratio_contract_top_trader(self, instId = '', period = '', end = '', begin = '', limit = ''):
-        # 构建请求参数
         params = {'instId': instId, 'period': period, 'end': end, 'begin': begin,'limit':limit}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, GET_LONG_SHORT_ACCOUNT_RADIO_CONTRACT_TOP_TRADER, params)
 
     # GET /api/v5/rubik/stat/contracts/long-short-position-ratio-contract-top-trader
-    # 获取合约多空持仓比率-顶尖交易员
     def get_long_short_position_ratio_contract_top_trader(self, instId = '', period = '', end = '', begin = '', limit = ''):
-        # 构建请求参数
         params = {'instId': instId, 'period': period, 'end': end, 'begin': begin,'limit':limit}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, GET_LONG_SHORT_POSTION_RADIO_CONTRACT_TOP_TRADER, params)
 
     # GET /api/v5/rubik/stat/contracts/long-short-account-ratio-contract
-    # 获取合约多空账户比率
     def get_long_short_account_ratio_contract(self, instId = '', period = '', end = '', begin = '', limit = ''):
-        # 构建请求参数
         params = {'instId': instId, 'period': period, 'end': end, 'begin': begin,'limit':limit}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, GET_LONG_SHORT_ACCOUNT_RADIO_CONTRACT, params)
 
-    # 获取多空比率
     def get_long_short_ratio(self, ccy, begin='', end='', period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'begin': begin, 'end': end, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, LONG_SHORT_RATIO, params)
 
-    # 获取合约持仓量和交易量
     def get_contracts_interest_volume(self, ccy, begin='', end='', period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'begin': begin, 'end': end, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, CONTRACTS_INTEREST_VOLUME, params)
 
-    # 获取期权持仓量和交易量
     def get_options_interest_volume(self, ccy, period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, OPTIONS_INTEREST_VOLUME, params)
 
-    # 获取看跌/看涨比率
     def get_put_call_ratio(self, ccy, period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, PUT_CALL_RATIO, params)
 
-    # 获取按到期日划分的持仓量和交易量
     def get_interest_volume_expiry(self, ccy, period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, OPEN_INTEREST_VOLUME_EXPIRY, params)
 
-    # 获取按行权价划分的持仓量和交易量
     def get_interest_volume_strike(self, ccy, expTime, period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'expTime': expTime, 'period': period}
-        # 发送带参数的GET请求
         return self._request_with_params(GET, INTEREST_VOLUME_STRIKE, params)
 
-    # 获取Taker资金流
     def get_taker_flow(self, ccy, period=''):
-        # 构建请求参数
         params = {'ccy': ccy, 'period': period}
-        # 发送带参数的GET请求
-        return self._request_with_params(GET, TAKER_FLOW, params)
+        return self._request_with_params(GET, TAKER_FLOW, params)
+
+
+
+
+

okxv5/client.py

@@ -1,120 +1,66 @@
-import requests # 导入requests库，用于发送HTTP请求
-import json # 导入json库，用于处理JSON数据
-import datetime # 导入datetime库，用于时间戳处理
-import time # 导入time库，用于获取本地时间戳
-from . import consts as c, utils, exceptions # 从当前包导入consts模块（别名为c）、utils模块和exceptions模块
+import requests
+import json
+from . import consts as c, utils, exceptions
+
 
 class Client(object):
-    """
-    API客户端类，用于与API进行交互
-    """
-
-    def __init__(self, api_key, api_secret_key, passphrase, use_server_time=False, flag='0'):     # 1为实盘，0为模拟盘
-        """
-        构造函数，初始化客户端
-        :param api_key: API密钥
-        :param api_secret_key: API私钥
-        :param passphrase: 交易密码
-        :param use_server_time: 是否使用服务器时间，默认为False
-        :param flag: 请求标记，默认为'0'
-        """
-        self.API_KEY = api_key # 设置API密钥
-        self.API_SECRET_KEY = api_secret_key # 设置API私钥
-        self.PASSPHRASE = passphrase # 设置交易密码
-        self.use_server_time = use_server_time # 设置是否使用服务器时间
-        self.flag = flag # 设置请求标记
+
+    def __init__(self, api_key, api_secret_key, passphrase, use_server_time=False, flag='1'):
+
+        self.API_KEY = api_key
+        self.API_SECRET_KEY = api_secret_key
+        self.PASSPHRASE = passphrase
+        self.use_server_time = use_server_time
+        self.flag = flag
 
     def _request(self, method, request_path, params):
-        """
-        私有方法，用于发送HTTP请求
-        :param method: HTTP请求方法（GET或POST）
-        :param request_path: 请求路径
-        :param params: 请求参数
-        :return: API响应的JSON数据
-        :raise exceptions.OkxAPIException: 如果API返回非2xx状态码
-        """
+
         if method == c.GET:
-            # 如果是GET请求，将参数解析为字符串并附加到请求路径
             request_path = request_path + utils.parse_params_to_str(params)
-        # 拼接完整的URL
+        # url
         url = c.API_URL + request_path
 
-        # 确定最终用于请求头和签名的 ISO 8601 格式时间戳
-        final_iso8601_timestamp = ""
+        timestamp = utils.get_timestamp()
 
+        # sign & header
         if self.use_server_time:
-            # 获取服务器时间（返回 Unix 毫秒字符串）
-            server_ts_ms_str = self._get_timestamp()
-            if server_ts_ms_str:
-                try:
-                    ms = int(server_ts_ms_str)
-                    dt_object = datetime.datetime.fromtimestamp(ms / 1000, tz=datetime.timezone.utc)
-                    final_iso8601_timestamp = dt_object.isoformat(timespec='milliseconds').replace('+00:00', 'Z')
-                except ValueError:
-                    print(f"Error: Could not convert server timestamp '{server_ts_ms_str}' to ISO 8601. Using raw for signing/header.")
-                    final_iso8601_timestamp = server_ts_ms_str # 转换失败时，回退使用原始值
-            else:
-                # 如果获取服务器时间失败，则回退到本地 UTC 时间
-                print("Warning: Failed to get server time. Falling back to local UTC time for timestamp.")
-                final_iso8601_timestamp = utils.get_timestamp() # utils.get_timestamp() 已经返回 ISO 8601 格式
-        else:
-            # 使用本地时间（utils.get_timestamp() 已经返回 ISO 8601 格式）
-            final_iso8601_timestamp = utils.get_timestamp()
+            timestamp = self._get_timestamp()
 
-        # 根据请求方法决定请求体
         body = json.dumps(params) if method == c.POST else ""
 
-        # 生成签名，使用ISO 8601格式的时间戳
-        sign = utils.sign(utils.pre_hash(final_iso8601_timestamp, method, request_path, str(body)), self.API_SECRET_KEY)
-        # 获取请求头，使用ISO 8601格式的时间戳
-        header = utils.get_header(self.API_KEY, sign, final_iso8601_timestamp, self.PASSPHRASE, self.flag)
+        sign = utils.sign(utils.pre_hash(timestamp, method, request_path, str(body)), self.API_SECRET_KEY)
+        header = utils.get_header(self.API_KEY, sign, timestamp, self.PASSPHRASE, self.flag)
 
-        # 发送请求
+        # send request
         response = None
 
+        print("url:", url)
+        # print("headers:", header)
+        print("body:", body)
+
         if method == c.GET:
-            # 发送GET请求
             response = requests.get(url, headers=header)
         elif method == c.POST:
-            # 发送POST请求
             response = requests.post(url, data=body, headers=header)
 
+        # exception handle
+        # print(response.headers)
+
         if not str(response.status_code).startswith('2'):
-            # 如果响应状态码不是2xx，则抛出API异常
             raise exceptions.OkxAPIException(response)
 
-        # 返回JSON格式的响应数据
         return response.json()
 
     def _request_without_params(self, method, request_path):
-        """
-        私有方法，发送不带参数的HTTP请求
-        :param method: HTTP请求方法
-        :param request_path: 请求路径
-        :return: API响应的JSON数据
-        """
         return self._request(method, request_path, {})
 
     def _request_with_params(self, method, request_path, params):
-        """
-        私有方法，发送带参数的HTTP请求
-        :param method: HTTP请求方法
-        :param request_path: 请求路径
-        :param params: 请求参数
-        :return: API响应的JSON数据
-        """
         return self._request(method, request_path, params)
 
     def _get_timestamp(self):
-        """
-        私有方法，获取服务器时间戳
-        :return: 服务器时间戳字符串 (Unix毫秒)
-        """
-        url = c.API_URL + c.SERVER_TIMESTAMP_URL # 拼接获取服务器时间戳的URL
-        response = requests.get(url) # 发送GET请求获取服务器时间
+        url = c.API_URL + c.SERVER_TIMESTAMP_URL
+        response = requests.get(url)
         if response.status_code == 200:
-            # 如果请求成功，返回时间戳
             return response.json()['data'][0]['ts']
         else:
-            # 如果请求失败，返回空字符串
-            return ""
+            return ""