hyperquant 0.21__tar.gz → 0.23__tar.gz

{hyperquant-0.21 → hyperquant-0.23}/.gitignore

@@ -10,7 +10,6 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
 lib64/
 parts/
 sdist/

{hyperquant-0.21 → hyperquant-0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.21
+Version: 0.23
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-0.21 → hyperquant-0.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "0.21"
+version = "0.23"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-0.21 → hyperquant-0.23}/src/hyperquant/__init__.py

@@ -2,4 +2,5 @@ from .core import *
 from .draw import *
 from .logkit import *
 from .datavison import *
+from .notikit import *
 __version__ = "0.1.0"

hyperquant-0.23/src/hyperquant/broker/lib/hpstore.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import time
+from aiohttp import ClientWebSocketResponse
+import aiohttp
+
+from pybotters.store import DataStore
+from pybotters.models.hyperliquid import HyperliquidDataStore
+from typing import TYPE_CHECKING, Awaitable
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+
+# {'channel': 'orderUpdates', 'data': [{'order': {'coin': 'HYPE', 'side': 'A', 'limitPx': '22.887', 'sz': '1.12', 'oid': 29641480516, 'timestamp': 1746766108031, 'origSz': '1.12', 'reduceOnly': True}, 'status': 'rejected', 'statusTimestamp': 1746766108031}]}
+class OrderStore(DataStore):
+    _KEYS = ["oid"]
+
+    def _onmessage(self, msg: Item) -> None:
+
+        for rec in msg:
+            order = rec["order"]
+            item = {
+                **order,
+                "status": rec.get("status"),
+                "px": None,
+                'fee': None,
+                "statusTimestamp": rec.get("statusTimestamp"),
+            }
+
+            if item["status"] == "open":
+                self._update([item])
+            else:
+                self._delete([item])
+
+class FillStore(DataStore):
+    _KEYS = ["oid"]
+
+    def _onmessage(self, msg: Item) -> None:
+        for fill in msg:
+            self._update([fill])
+
+
+
+class Account(DataStore):
+    _KEYS = ["marginCoin", "value"]
+     
+    def _onmessage(self, data: list[Item]) -> None:
+            self._update(
+                [
+                    {
+                        "marginCoin": 'USDC',
+                        'value': float(item['accountValue']),
+                        'frozen': float(item['totalMarginUsed']),
+                        'available': float(item['accountValue']) - float(item['totalMarginUsed']),
+                    }
+                    for item in data
+                ]
+            )
+
+class SpotAccount(DataStore):
+
+    _KEYS = ["coin"]
+
+    def _onmessage(self, data: list[Item]) -> None:
+        self._update(
+            [
+                {
+                    "coin": item['coin'],
+                    "total": float(item['total']),
+                    "frozen": float(item['hold']),
+                    "available": float(item['total']) - float(item['hold']),
+                    "entryNtl": float(item['entryNtl']),
+                }
+                for item in data
+            ]
+        )
+
+class PositionStore(DataStore):
+    _KEYS = ["coin"]
+
+    def _onmessage(self, data: list[Item]) -> None:
+      
+        if len(data) == 0 and self.__len__() > 0:
+            self._clear()
+        elif len(data) > 0:
+            self._update([
+
+                {
+                    "coin": item['position']['coin'],
+                    "sz": float(item['position']['szi']),
+                    "px": float(item['position']['entryPx']),
+                    'unpnl': float(item['position']['unrealizedPnl']),
+                    'rt': float(item['position']['returnOnEquity']),
+                    'lv': int(item['position']['leverage']['value']),
+                }
+                for item in data
+            ])
+
+        
+class MyHyperStore(HyperliquidDataStore):
+    ORDER_TYPE = 'orderUpdates'
+    WEBDATA2_TYPE = 'webData2'
+    ORDER_FILL_TYPE = 'userFills'
+
+    def _init(self) -> None:
+        self._create("orders", datastore_class=OrderStore)
+        self._create("account", datastore_class=Account)
+        self._create("positions", datastore_class=PositionStore)
+        self._create("spot_account", datastore_class=SpotAccount)
+        self._create("fills", datastore_class=FillStore)
+        super()._init()
+
+    def _onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+
+        if msg.get("channel") == self.ORDER_TYPE:
+            self.orders._onmessage(msg.get('data', []))
+        elif msg.get("channel") == self.WEBDATA2_TYPE:
+            # print(msg.get('data', {}).get('clearinghouseState', {}))
+            act_data = msg.get('data', {}).get('clearinghouseState', {}).get('crossMarginSummary', [])
+            if act_data:
+                self.account._onmessage([act_data])
+
+            pos_data = msg.get('data', {}).get('clearinghouseState', {}).get('assetPositions', [])
+            self.positions._onmessage(pos_data)
+
+            spot_act_data = msg.get('data', {}).get('spotState', {}).get('balances', [])
+            self.spot_account._onmessage(spot_act_data)
+
+        elif msg.get("channel") == self.ORDER_FILL_TYPE:
+            fills = msg.get('data', {}).get('fills', [])
+            is_snap = msg.get('data', {}).get('isSnapshot', False)
+            if not is_snap:
+                self.fills._onmessage(fills)
+  
+        super()._onmessage(msg, ws)
+            
+    async def initialize(self, *aws: tuple[str, Awaitable[aiohttp.ClientResponse]]) -> None:
+
+        for a in aws:
+            method, f = a
+            resp = await f
+            data = await resp.json()
+            if method == "orders":
+
+                self.orders._onmessage(
+                    [
+                        {
+                            'order': o,
+                            'status': "open",
+                            'statusTimestamp': int(time.time() * 1000)
+                        } for o in data
+                    ]
+                )
+            
+        pass
+
+    @property
+    def orders(self) -> OrderStore:
+        """``orders`` data stream.
+
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+
+        Data structure:
+
+        .. code:: python
+            [
+                {
+                    "coin": "HYPE",
+                    "side": "A",
+                    "limitPx": "22.887",
+                    "sz": "1.12",
+                    "oid": 29641480516,
+                    "timestamp": 1746766108031,
+                    "origSz": "1.12",
+                    "reduceOnly": True
+                    "status": "open",
+                    "statusTimestamp": 1746766108031
+                }...
+            ]
+        """
+        return self._get("orders", OrderStore)
+    @property
+    def account(self) -> Account:
+        """``account`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "marginCoin": 'USDC',
+                    'value': float(item['accountValue']),
+                    'frozen': float(item['totalMarginUsed']),
+                    'available': float(item['accountValue']) - float(item['totalMarginUsed']),
+                }...
+            ]
+        """
+        return self._get("account", Account)
+    
+    @property
+    def positions(self) -> PositionStore:
+        return self._get("positions", PositionStore)
+    
+    @property
+    def spot_account(self) -> SpotAccount:
+        """``spot_account`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "coin": 'FEUSD',
+                    "sz": "21.0",
+                    "px": "0.9719",
+                    "unpnl": "0.0",
+                    "rt": "0.0",
+                    "lv": 1,
+                }...
+            ]
+        """
+        return self._get("spot_account", SpotAccount)
+   
+    @property
+    def fills(self) -> FillStore:
+        """``fills`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "coin": 'FEUSD',
+                    "px": "0.9719",
+                    "sz": "21.0",
+                    "side": 'buy',
+                    "time": 1679999999999,
+                    "startPosition": '0.0',
+                    "dir": 'buy',
+                    "closedPnl": '0.0',
+                    "hash": '0x123456789abcdef',
+                    "oid": 123456789,
+                    "crossed": True,
+                    "fee": '-0.0001',
+                    "tid": 987654321,
+                    "liquidation": None,
+                    "feeToken": 'USDC',
+                }...
+            ]
+        """
+        return self._get("fills", FillStore)
+

hyperquant-0.23/src/hyperquant/broker/lib/hyper_types.py

@@ -0,0 +1,48 @@
+from typing import TypedDict, Dict
+
+class Leverage(TypedDict):
+    rawUsd: str
+    type: str
+    value: int
+
+class CumFunding(TypedDict):
+    allTime: str
+    sinceChange: str
+    sinceOpen: str
+
+class Position(TypedDict):
+    coin: str
+    cumFunding: CumFunding
+    entryPx: str
+    leverage: Leverage
+    liquidationPx: str
+    marginUsed: str
+    maxLeverage: int
+    positionValue: str
+    returnOnEquity: str
+    szi: str
+    unrealizedPnl: str
+
+class AssetPosition(TypedDict):
+    position: Position
+    type: str
+
+class CrossMarginSummary(TypedDict):
+    accountValue: str
+    totalMarginUsed: str
+    totalNtlPos: str
+    totalRawUsd: str
+
+class MarginSummary(TypedDict):
+    accountValue: str
+    totalMarginUsed: str
+    totalNtlPos: str
+    totalRawUsd: str
+
+class AccountBalance(TypedDict):
+    assetPositions: list[AssetPosition]
+    crossMaintenanceMarginUsed: str
+    crossMarginSummary: CrossMarginSummary
+    marginSummary: MarginSummary
+    time: int
+    withdrawable: str

hyperquant-0.23/src/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))

hyperquant-0.23/src/hyperquant/notikit.py

@@ -0,0 +1,104 @@
+"""
+通知类的功能简单封装，非必要别修改 :)
+只要知道怎么使用以下函数：
+- send_wecom_msg
+- send_wecom_img
+
+Binance期现套利 | 邢不行 | 2024分享会
+author: 邢不行
+微信: xbx6660
+"""
+import base64
+import hashlib
+import os.path
+import requests
+import json
+import traceback
+from datetime import datetime
+
+from hyperquant.logkit import get_logger
+logger = get_logger('notikit', './data/logs/notikit.log', show_time=True)
+
+
+
+proxy = {}
+
+
+def handle_exception(e: Exception, msg: str = '') -> None:
+    logger.error(f"{msg}:{e}")
+    logger.error(e)
+    logger.error(traceback.format_exc())
+
+
+# 企业微信通知
+def send_wecom_msg(content, webhook_url):
+    if not webhook_url:
+        logger.warning('未配置wecom_webhook_url，不发送信息')
+        return
+    if not content:
+        logger.warning('未配置content，不发送信息')
+        return
+    try:
+        data = {
+            "msgtype": "text",
+            "text": {
+                "content": content + '\n' + datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            }
+        }
+        r = requests.post(webhook_url, data=json.dumps(data), timeout=10, proxies=proxy)
+        logger.info(f'调用企业微信接口返回： {r.text}')
+        logger.ok('成功发送企业微信')
+    except Exception as e:
+        handle_exception(e, '发送企业微信失败')
+
+
+# 上传图片，解析bytes
+class MyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        """
+        只要检查到了是bytes类型的数据就把它转为str类型
+        :param obj:
+        :return:
+        """
+        if isinstance(obj, bytes):
+            return str(obj, encoding='utf-8')
+        return json.JSONEncoder.default(self, obj)
+
+
+# 企业微信发送图片
+def send_wecom_img(file_path, webhook_url):
+    """
+    企业微信发送图片
+    :param file_path: 图片地址
+    :param webhook_url: 企业微信webhook网址
+    :return:
+    """
+    if not os.path.exists(file_path):
+        logger.warning('找不到图片')
+        return
+    if not webhook_url:
+        logger.warning('未配置wecom_webhook_url，不发送信息')
+        return
+    try:
+        with open(file_path, 'rb') as f:
+            image_content = f.read()
+        image_base64 = base64.b64encode(image_content).decode('utf-8')
+        md5 = hashlib.md5()
+        md5.update(image_content)
+        image_md5 = md5.hexdigest()
+        data = {
+            'msgtype': 'image',
+            'image': {
+                'base64': image_base64,
+                'md5': image_md5
+            }
+        }
+        # 服务器上传bytes图片的时候，json.dumps解析会出错，需要自己手动去转一下
+        r = requests.post(webhook_url, data=json.dumps(data, cls=MyEncoder, indent=4), timeout=10, proxies=proxy)
+        logger.info(f'调用企业微信接口返回： {r.text}')
+        logger.ok('成功发送企业微信图片')
+    except Exception as e:
+        handle_exception(e, '发送企业微信图片失败')
+    finally:
+        if os.path.exists(file_path):
+            os.remove(file_path)

{hyperquant-0.21 → hyperquant-0.23}/uv.lock

@@ -530,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "0.21"
+version = "0.22"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },