hyperquant 1.48__py3-none-any.whl

hyperquant/datavison/binance.py

@@ -0,0 +1,111 @@
+import aiohttp
+import asyncio
+from datetime import datetime, date, timedelta
+# from _util import _to_milliseconds
+from ._util import _to_milliseconds
+import pandas as pd
+
+class BinanceSwap:
+    def __init__(self) -> None:
+        self.session = aiohttp.ClientSession()
+
+    async def get_klines(self, symbol: str, interval: str, start_time, end_time = None, limit: int = 1500):
+        """
+        获取U本位合约K线数据，支持获取任意长度（自动分批）
+
+        :param symbol: 交易对, 如 'BTCUSDT'
+        :param interval: K线间隔, 如 '1m', '5m', '1h', '1d'
+        :param start_time: 开始时间, 毫秒时间戳或datetime/date类型
+        :param end_time: 结束时间, 毫秒时间戳或datetime/date类型, 默认为None表示最新
+        :param limit: 每次请求最大K线数量, 最大1500
+        :return: K线数据DataFrame
+        """
+        url = "https://fapi.binance.com/fapi/v1/klines"
+        all_klines = []
+        fetch_start = _to_milliseconds(start_time)
+        ms_end_time = _to_milliseconds(end_time) if end_time else None
+        while True:
+            params = {
+                "symbol": symbol.upper(),
+                "interval": interval,
+                "startTime": fetch_start,
+                "limit": limit
+            }
+            if ms_end_time:
+                params["endTime"] = ms_end_time
+            async with self.session.get(url, params=params) as resp:
+                resp.raise_for_status()
+                data = await resp.json()
+                if not data:
+                    break
+                all_klines.extend(data)
+                if len(data) < limit:
+                    break
+                last_open_time = data[-1][0]
+                fetch_start = last_open_time + 1
+                if ms_end_time and fetch_start >= ms_end_time:
+                    break
+        # 转为DataFrame
+        columns = [
+            "open_time", "open", "high", "low", "close", "volume",
+            "close_time", "quote_asset_volume", "number_of_trades",
+            "taker_buy_base_asset_volume", "taker_buy_quote_asset_volume", "ignore"
+        ]
+        df = pd.DataFrame(all_klines, columns=columns)
+        # 类型转换
+        df["open_time"] = pd.to_datetime(df["open_time"], unit="ms")
+        df["close_time"] = pd.to_datetime(df["close_time"], unit="ms")
+        for col in ["open", "high", "low", "close", "volume", "quote_asset_volume", "taker_buy_base_asset_volume", "taker_buy_quote_asset_volume"]:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+        df["number_of_trades"] = df["number_of_trades"].astype(int)
+        return df
+
+    async def get_index_klines(self, pair: str, interval: str, start_time, end_time=None, limit: int = 1500):
+        """
+        获取U本位合约指数K线数据，支持获取任意长度（自动分批）
+
+        :param pair: 指数对, 如 'BTCUSDT'
+        :param interval: K线间隔, 如 '1m', '5m', '1h', '1d'
+        :param start_time: 开始时间, 毫秒时间戳或datetime/date类型
+        :param end_time: 结束时间, 毫秒时间戳或datetime/date类型, 默认为None表示最新
+        :param limit: 每次请求最大K线数量, 最大1500
+        :return: 指数K线数据DataFrame
+        """
+        url = "https://fapi.binance.com/fapi/v1/indexPriceKlines"
+        all_klines = []
+        fetch_start = _to_milliseconds(start_time)
+        ms_end_time = _to_milliseconds(end_time) if end_time else None
+        while True:
+            params = {
+                "pair": pair.upper(),
+                "interval": interval,
+                "startTime": fetch_start,
+                "limit": limit
+            }
+            if ms_end_time:
+                params["endTime"] = ms_end_time
+            async with self.session.get(url, params=params) as resp:
+                resp.raise_for_status()
+                data = await resp.json()
+                if not data:
+                    break
+                all_klines.extend(data)
+                if len(data) < limit:
+                    break
+                last_open_time = data[-1][0]
+                fetch_start = last_open_time + 1
+                if ms_end_time and fetch_start >= ms_end_time:
+                    break
+        columns = [
+            "open_time", "open", "high", "low", "close", "volume",
+            "close_time", "quote_asset_volume", "number_of_trades",
+            "taker_buy_base_asset_volume", "taker_buy_quote_asset_volume", "ignore"
+        ]
+        df = pd.DataFrame(all_klines, columns=columns)
+        df["open_time"] = pd.to_datetime(df["open_time"], unit="ms")
+        df["close_time"] = pd.to_datetime(df["close_time"], unit="ms")
+        for col in ["open", "high", "low", "close", "volume", "quote_asset_volume", "taker_buy_base_asset_volume", "taker_buy_quote_asset_volume"]:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+        df["number_of_trades"] = df["number_of_trades"].astype(int)
+        return df
+

hyperquant/datavison/coinglass.py

@@ -0,0 +1,237 @@
+"""
+Coinglass API 数据解密与数据获取模块
+优化：
+- 只保留必要依赖，整理import顺序
+- 增加类型注解和文档
+- 统一异常处理和日志输出
+- 精简冗余代码
+"""
+import asyncio
+import base64
+import json
+import struct
+import time
+import zlib
+import hmac
+import hashlib
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Union
+import pandas as pd # type: ignore
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding as crypto_padding
+from cryptography.hazmat.backends import default_backend
+import aiohttp
+
+# ------------------ 工具函数 ------------------
+class CustomParser:
+    @staticmethod
+    def parse(data: str) -> Dict[str, Union[List[int], int]]:
+        """
+        将字符串转换为数字数组，兼容原始加密逻辑。
+        """
+        length = len(data)
+        n = [0] * ((length + 3) // 4)
+        for r in range(length):
+            n[r >> 2] |= (ord(data[r]) & 255) << (24 - (r % 4) * 8)
+        return {"n": n, "e": length}
+
+def convert_words_to_bytes(words: List[int]) -> bytes:
+    """
+    将整数数组转换为字节数组。
+    """
+    return b"".join(struct.pack(">I", word) for word in words)
+
+def decrypt_and_clean(t: str, e: Dict[str, Any]) -> str:
+    """
+    解密、解压缩并清理输入字符串。
+    """
+    aes_key = convert_words_to_bytes(e['n'])
+    cipher = Cipher(algorithms.AES(aes_key), modes.ECB(), backend=default_backend())
+    decryptor = cipher.decryptor()
+    encrypted_data = base64.b64decode(t)
+    decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
+    unpadder = crypto_padding.PKCS7(128).unpadder()
+    unpadded_data = unpadder.update(decrypted_data) + unpadder.finalize()
+    decompressed_data = zlib.decompress(unpadded_data, wbits=16 + zlib.MAX_WBITS).decode('utf-8')
+    return decompressed_data
+
+def generate_totp(secret: str, for_time: int, interval: int = 30, digits: int = 6, digest=hashlib.sha1) -> str:
+    """
+    基于标准库的TOTP实现。
+    """
+    key = base64.b32decode(secret, casefold=True)
+    counter = int(for_time // interval)
+    msg = counter.to_bytes(8, 'big')
+    h = hmac.new(key, msg, digest).digest()
+    o = h[-1] & 0x0F
+    code = (struct.unpack('>I', h[o:o+4])[0] & 0x7fffffff) % (10 ** digits)
+    return str(code).zfill(digits)
+
+def generate_encrypted_token() -> str:
+    """
+    生成加密token，用于API请求。
+    """
+    current_time = int(time.time())
+    secret_key = "I65VU7K5ZQL7WB4E"
+    otp = generate_totp(secret_key, current_time)
+    combined_string = f"{current_time},{otp}"
+    aes_key = "1f68efd73f8d4921acc0dead41dd39bc"
+    aes_key_bytes = CustomParser.parse(aes_key)
+    final_key = convert_words_to_bytes(aes_key_bytes['n'])
+    cipher = Cipher(algorithms.AES(final_key), modes.ECB(), backend=default_backend())
+    encryptor = cipher.encryptor()
+    padder = crypto_padding.PKCS7(128).padder()
+    padded_data = padder.update(combined_string.encode('utf-8')) + padder.finalize()
+    encrypted_bytes = encryptor.update(padded_data) + encryptor.finalize()
+    return base64.b64encode(encrypted_bytes).decode('utf-8')
+
+def decrypt_coinglass(data: str, user_header: str, url: str) -> str:
+    """
+    解密 Coinglass API 的响应数据。
+    """
+    base_key = base64.b64encode(f"coinglass{url}coinglass".encode("utf-8")).decode("utf-8")[:16]
+    processed_key = CustomParser.parse(base_key)
+    decrypted_key = decrypt_and_clean(user_header, processed_key)
+    session_key = decrypt_and_clean(data, CustomParser.parse(decrypted_key))
+    return session_key
+
+# ------------------ API类 ------------------
+HEADERS = {
+    'accept': 'application/json',
+    'accept-language': 'en-US,en;q=0.9',
+    'cache-ts': str(int(time.time() * 1000)),
+    'dnt': '1',
+    'encryption': 'true',
+    'language': 'en',
+    'origin': 'https://www.coinglass.com',
+    'priority': 'u=1, i',
+    'referer': 'https://www.coinglass.com/',
+    'sec-ch-ua': '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+    'sec-fetch-dest': 'empty',
+    'sec-fetch-mode': 'cors',
+    'sec-fetch-site': 'same-site',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+}
+
+class CoinglassApi:
+    def __init__(self) -> None:
+        self.session = aiohttp.ClientSession()
+
+    async def connect(self):
+        pass
+
+    async def dec_data(self, response: aiohttp.ClientResponse) -> Optional[Any]:
+        try:
+            encrypted_data = (await response.json())['data']
+            requests_url = response.url.path
+            encrypted_user_header = response.headers.get("user", "HEADERNOTFOUND")
+            decrypted = decrypt_coinglass(encrypted_data, encrypted_user_header, requests_url)
+            return json.loads(decrypted)
+        except Exception as e:
+            print(f"解密失败: {e}")
+            return None
+
+    async def fetch_base_klines(self, symbol: str, start_time: datetime, end_time: Optional[datetime] = None, ktype: str = '#coin#oi_kline', interval: str = 'm1') -> Any:
+        start_ts = int(start_time.timestamp())
+        end_ts = int(end_time.timestamp()) if end_time else int(time.time())
+        url = 'https://fapi.coinglass.com/api/v2/kline'
+        params = {
+            'symbol': f'{symbol}{ktype}',
+            'interval': interval,
+            'endTime': end_ts,
+            'startTime': start_ts,
+            'minLimit': 'false',
+        }
+        async with self.session.get(url, params=params, headers=HEADERS) as response:
+            if response.status == 200:
+                return await self.dec_data(response)
+            print(f"请求失败，状态码: {response.status}: {await response.text()}")
+            return pd.DataFrame()
+
+    async def fetch_price_klines(self, symbol: str, start_time: datetime, end_time: Optional[datetime] = None, interval: str = 'm5') -> pd.DataFrame:
+        data = await self.fetch_base_klines(symbol, start_time, end_time, '#kline', interval)
+        df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        df[['open', 'high', 'low', 'close', 'volume']] = df[['open', 'high', 'low', 'close', 'volume']].astype(float)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit="s", utc=True)
+        df['symbol'] = symbol
+        return df
+
+    async def fetch_top_account_klines(self, symbol: str, start_time: datetime, end_time: Optional[datetime] = None, interval: str = 'm5') -> Optional[pd.DataFrame]:
+        end_ts = int(end_time.timestamp()) if end_time else int(time.time())
+        start_ts = int(start_time.timestamp())
+        url = 'https://fapi.coinglass.com/api/v2/kline'
+        params = {
+            'symbol': f'{symbol}#top_account_kline',
+            'interval': interval,
+            'endTime': end_ts,
+            'startTime': start_ts,
+            'minLimit': 'false',
+        }
+        async with self.session.get(url, params=params, headers=HEADERS) as response:
+            if response.status == 200:
+                data = await self.dec_data(response)
+                columns = ['timestamp', 'ratio', 'long_ratio', 'short_ratio']
+                df = pd.DataFrame(data, columns=columns)
+                df['timestamp'] = pd.to_datetime(df['timestamp'], unit="s", utc=True)
+                df[['ratio', 'long_ratio', 'short_ratio']] = df[['ratio', 'long_ratio', 'short_ratio']].astype(float)
+                df['symbol'] = symbol
+                return df
+            print(f"请求失败，状态码: {response.status}: {await response.text()}")
+            return None
+
+    async def fetch_oi_klines(self, symbol: str, start_time: datetime, end_time: Optional[datetime] = None, interval: str = 'm5') -> pd.DataFrame:
+        data = await self.fetch_base_klines(symbol, start_time, end_time, '#coin#oi_kline', interval)
+        df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close'])
+        df[['open', 'high', 'low', 'close']] = df[['open', 'high', 'low', 'close']].astype(float)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit="s", utc=True)
+        df['symbol'] = symbol
+        return df
+
+    async def fetch_liq_klines(self, symbol: str, start_time: datetime, end_time: Optional[datetime] = None, interval: str = 'm5') -> pd.DataFrame:
+        data = await self.fetch_base_klines(symbol, start_time, end_time, '#aggregated_liq_kline', interval)
+        df = pd.DataFrame(data, columns=['timestamp', 'short_amount', 'long_amount'])
+        df[['short_amount', 'long_amount']] = df[['short_amount', 'long_amount']].astype(float)
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit="s", utc=True)
+        df['symbol'] = symbol
+        return df
+
+    async def fetch_hyperliquid_top_positions(self) -> Optional[Any]:
+        url = 'https://capi.coinglass.com/api/hyperliquid/topPosition'
+        async with self.session.get(url, headers=HEADERS) as response:
+            if response.status == 200:
+                return await self.dec_data(response)
+            print(f"请求失败，状态码: {response.status}: {await response.text()}")
+            return None
+
+    async def fetch_tickers(self) -> Optional[Any]:
+        url = 'https://fapi.coinglass.com/api/select/coins/tickers'
+        params = {'exName': 'Binance'}
+        async with self.session.get(url, params=params, headers=HEADERS) as response:
+            if response.status == 200:
+                return await self.dec_data(response)
+            print(f"请求失败，状态码: {response.status}: {await response.text()}")
+            return None
+
+    async def fetch_symbols(self, only_usdt: bool = True) -> List[str]:
+        tickers = await self.fetch_tickers()
+        if tickers:
+            symbols = [ticker['instrument']['instrumentId'] for ticker in tickers]
+            if only_usdt:
+                symbols = [symbol for symbol in symbols if symbol.endswith('USDT')]
+            return symbols
+        return []
+
+    async def stop(self):
+        await self.session.close()
+
+# ------------------ 主程序 ------------------
+async def main():
+    api = CoinglassApi()
+    df = await api.fetch_price_klines('Binance_BTCUSDT', datetime.now() - timedelta(days=1))
+    print(df)
+    await api.stop()
+
+if __name__ == '__main__':
+    asyncio.run(main())

hyperquant/datavison/okx.py

@@ -0,0 +1,177 @@
+import aiohttp
+import asyncio
+import pandas as pd
+import time
+from datetime import datetime, timezone
+from ._util import _to_milliseconds  # 确保时间转换函数可用
+
+class OKX:
+    def __init__(self) -> None:
+        self.session = aiohttp.ClientSession()
+        self.base_url = "https://www.okx.com/api/v5/market"
+
+    async def get_klines(self, symbol: str, interval: str, start_time, end_time=None, limit: int = 100):
+        """
+        获取 OKX 永续合约 K 线数据，带时间过滤，从 end_time 向 start_time 方向翻页。
+
+        :param symbol: 交易对, 如 'BTC-USDT'
+        :param interval: K 线间隔, 如 '1m', '15m', '1H', '4H', '1D'
+        :param start_time: 开始时间(datetime 或 毫秒)
+        :param end_time: 结束时间(datetime 或 毫秒), 可选
+        :param limit: 每次请求最大数量(OKX 最大 300)
+        :return: DataFrame 格式的 K 线数据，按时间升序
+        """
+        if 'h' in interval or 'd' in interval:
+            interval = interval.upper()  # 确保间隔是大写格式
+
+        url = f"{self.base_url}/history-candles"
+        all_rows = []
+        # 转换 start_time 和 end_time 到毫秒时间戳
+        if isinstance(start_time, (int, float)):
+            start_ts = int(start_time)
+        else:
+            # 处理 datetime 对象
+            start_ts = int(start_time.timestamp() * 1000)
+        if end_time:
+            if isinstance(end_time, (int, float)):
+                end_ts = int(end_time)
+            else:
+                end_ts = int(end_time.timestamp() * 1000)
+        else:
+            # 如果没有指定结束时间，就用当前时间戳
+            end_ts = int(time.time() * 1000)
+
+        # 每次请求最多返回 limit=300
+        batch_limit = min(limit, 300)
+        # 初始 after 参数为 end_ts，向过去翻页
+        current_after = end_ts
+
+        while True:
+            params = {
+                "instId": symbol,
+                "bar": interval,
+                "limit": str(batch_limit),
+                "after": str(current_after)
+            }
+            # 发送请求
+            async with self.session.get(url, params=params) as resp:
+                data = await resp.json()
+                if not data or data.get("code") != "0" or not data.get("data"):
+                    # 返回错误或无数据，结束循环
+                    break
+                buf = data["data"]  # 每条是 [ts, o, h, l, c, vol, volCcy, volCcyQuote, confirm]
+
+            # 本批数据按时间从新到旧排列, 最后一条是最旧的
+            rows_this_batch = []
+            for item in buf:
+                ts = int(item[0])
+                # 如果已经早于 start_ts，就跳过，并认为后面更旧，也可以结束循环
+                if ts < start_ts:
+                    continue
+                # 如果某些条目时间超出 end_ts，也跳过
+                if ts > end_ts:
+                    continue
+                # 解析数值字段
+                dt = pd.to_datetime(ts, unit='ms', utc=True)
+                o = float(item[1]); h = float(item[2]); l = float(item[3]); c = float(item[4]); vol = float(item[5])
+                # 按需把每个 K 线封装为字典，后续转换为 DataFrame
+                rows_this_batch.append({
+                    "symbol": symbol,
+                    "open_time": dt,
+                    "open": o,
+                    "high": h,
+                    "low": l,
+                    "close": c,
+                    "volume": vol,
+                    "interval": interval,
+                    "confirm": item[8]
+                })
+
+            if not rows_this_batch:
+                # 本批没有符合时间范围的数据，直接结束
+                break
+
+            # 累积本批符合条件的行
+            all_rows.extend(rows_this_batch)
+
+            # 检查是否到达 start_ts 之前：buf 最后一项是最旧
+            oldest_ts = int(buf[-1][0])
+            if oldest_ts < start_ts:
+                # 已经翻到 start_time 范围之前，结束循环
+                break
+
+            # 否则，更新 after = oldest_ts，继续向过去翻页
+            current_after = oldest_ts
+            # 为了不触发速率限制，稍做休眠（根据需要可以调整或删除）
+
+        # 如果累积到数据，则转换为 DataFrame；否则返回空 DataFrame
+        if all_rows:
+            df = pd.DataFrame(all_rows)
+            # 去重、按时间排序
+            df.drop_duplicates(subset=["open_time"], inplace=True)
+            df.sort_values("open_time", inplace=True)
+            df.reset_index(drop=True, inplace=True)
+            return df
+        else:
+            return pd.DataFrame()
+
+    async def get_index_klines(self, pair: str, interval: str, start_time, end_time=None, limit: int = 100):
+        """
+        获取OKX指数K线数据（自动分批）
+
+        :param pair: 指数名称, 如 'BTC-USD'
+        :param interval: K线间隔, 如 '1m', '1H', '1D'
+        :param start_time: 开始时间(毫秒时间戳/datetime/date)
+        :param end_time: 结束时间(毫秒时间戳/datetime/date)
+        :param limit: 每次请求最大数量(OKX最大300)
+        :return: DataFrame格式的指数K线
+        """
+        url = f"{self.base_url}/index-candles"
+        all_klines = []
+        ms_start = _to_milliseconds(start_time)
+        ms_end = _to_milliseconds(end_time) if end_time else None
+
+        params = {
+            "instId": pair,
+            "bar": interval,
+            "limit": min(limit, 300),
+            "after": ms_start
+        }
+        if ms_end:
+            params["before"] = ms_end
+
+        while True:
+            async with self.session.get(url, params=params) as resp:
+                data = await resp.json()
+                if data['code'] != "0":
+                    raise Exception(f"OKX API Error: {data['msg']} (Code {data['code']})")
+
+                klines = data['data']
+                if not klines:
+                    break
+
+                all_klines.extend(klines)
+
+                if len(klines) < params["limit"]:
+                    break
+
+                last_ts = int(klines[-1][0])
+                params["after"] = last_ts
+
+        # 数据转换
+        columns = ["open_time", "open", "high", "low", "close", "confirm"]
+        df = pd.DataFrame(all_klines, columns=columns)
+
+        df["open_time"] = pd.to_datetime(df["open_time"].astype(int), unit="ms")
+        num_cols = ["open", "high", "low", "close"]
+        df[num_cols] = df[num_cols].apply(pd.to_numeric, errors="coerce")
+
+        return df.sort_values("open_time").reset_index(drop=True)
+
+    async def close(self):
+        """关闭会话"""
+        await self.session.close()
+
+    # 使用示例
+    # async with OKXSwap() as okx:
+    #     df = await okx.get_klines("BTC-USDT", "1H", datetime(2023,1,1))