hyperquant 0.1.9__py3-none-any.whl → 0.3__py3-none-any.whl

hyperquant/broker/ourbit.py

@@ -0,0 +1,234 @@
+from typing import Literal, Optional
+import pybotters
+from .models.ourbit import OurbitSwapDataStore
+
+
+class OurbitSwap:
+
+    def __init__(self, client: pybotters.Client):
+        """
+        ✅ 完成:
+            下单, 撤单, 查询资金, 查询持有订单, 查询历史订单
+
+        """
+        self.client = client
+        self.store = OurbitSwapDataStore()
+        self.api_url = "https://futures.ourbit.com"
+        self.ws_url = "wss://futures.ourbit.com/edge"
+
+    async def __aenter__(self) -> "OurbitSwap":
+        client = self.client
+        await self.store.initialize(
+            client.get(f"{self.api_url}/api/v1/contract/detailV2?client=web")
+        )
+        return self
+
+    async def update(
+        self, update_type: Literal["position", "orders", "balance", "ticker", "all"] = "all"
+    ):
+        """由于交易所很多不支持ws推送，这里使用Rest"""
+        all_urls = [
+            f"{self.api_url}/api/v1/private/position/open_positions",
+            f"{self.api_url}/api/v1/private/order/list/open_orders?page_size=200",
+            f"{self.api_url}/api/v1/private/account/assets",
+            f"{self.api_url}/api/v1/contract/ticker",
+        ]
+
+        url_map = {
+            "position": [all_urls[0]],
+            "orders": [all_urls[1]],
+            "balance": [all_urls[2]],
+            "ticker": [all_urls[3]],
+            "all": all_urls,
+        }
+
+        try:
+            urls = url_map[update_type]
+        except KeyError:
+            raise ValueError(f"update_type err: {update_type}")
+
+        # 直接传协程进去，initialize 会自己 await
+        await self.store.initialize(*(self.client.get(url) for url in urls))
+
+    async def sub_tickers(self):
+        self.client.ws_connect(
+            self.ws_url,
+            send_json={
+                "method": "sub.tickers",
+                "param": {
+                    "timezone": "UTC+8"
+                }
+            },
+            hdlr_json=self.store.onmessage
+        )
+
+    async def sub_order_book(self, symbols: str | list[str]):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        send_jsons = []
+        # send_json={"method":"sub.depth.step","param":{"symbol":"BTC_USDT","step":"0.1"}},
+
+        for symbol in symbols:
+            step = self.store.detail.find({"symbol": symbol})[0].get("tick_size")
+            
+            send_jsons.append({
+                "method": "sub.depth.step",
+                "param": {
+                    "symbol": symbol,
+                    "step": str(step)
+                }
+            })
+
+        await self.client.ws_connect(
+            self.ws_url,
+            send_json=send_jsons,
+            hdlr_json=self.store.onmessage
+        )
+
+    def ret_content(self, res: pybotters.FetchResult):
+        match res.data:
+            case {"success": True}:
+                return res.data["data"]
+            case _:
+                raise Exception(f"Failed api {res.response.url}: {res.data}")
+            
+
+    async def place_order(
+        self,
+        symbol: str,
+        side: Literal["buy", "sell", "close"],
+        size: float = None,
+        price: float = None,
+        order_type: Literal["market", "limit_GTC", "limit_IOC"] = "market",
+        usdt_amount: Optional[float] = None,
+        leverage: Optional[int] = 20,
+        position_id: Optional[int] = None,
+    ):
+        """size为合约张数"""
+        if (size is None) == (usdt_amount is None):
+            raise ValueError("params err")
+
+        max_lev = self.store.detail.find({"symbol": symbol})[0].get("max_lev")
+        
+        if usdt_amount is not None:
+            cs = self.store.detail.find({"symbol": symbol})[0].get("contract_sz")
+            size = max(int(usdt_amount / cs / price), 1)
+            
+
+        leverage = max(max_lev, leverage)
+
+        data = {
+            "symbol": symbol,
+            "side": 1 if side == "buy" else 3,
+            "openType": 1,
+            "type": "5",
+            "vol": size,
+            "leverage": leverage,
+            "marketCeiling": False,
+            "priceProtect": "0",
+        }
+
+        if order_type == "limit_IOC":
+            data["type"] = 3
+            data["price"] = str(price)
+        if order_type == "limit_GTC":
+            data["type"] = "1"
+            data["price"] = str(price)
+
+        if side == "close":
+            data["side"] = 4
+            if position_id is None:
+                raise ValueError("position_id is required for closing position")
+            data["positionId"] = position_id
+
+        res =  await self.client.fetch(
+            "POST", f"{self.api_url}/api/v1/private/order/create", data=data
+        )
+        return self.ret_content(res)
+
+    async def cancel_orders(self, order_ids: list[str]):
+        res = await self.client.fetch(
+            "POST",
+            f"{self.api_url}/api/v1/private/order/cancel",
+            data=order_ids,
+        )
+        return self.ret_content(res)
+
+    async def query_orders(
+        self,
+        symbol: str,
+        states: list[Literal["filled", "canceled"]],  # filled:已成交, canceled:已撤销
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
+        page_size: int = 200,
+        page_num: int = 1,
+    ):
+        """查询历史订单
+
+        Args:
+            symbol: 交易对
+            states: 订单状态列表 ["filled":已成交, "canceled":已撤销]
+            start_time: 开始时间戳(毫秒), 可选
+            end_time: 结束时间戳(毫秒), 可选
+            page_size: 每页数量, 默认200
+            page_num: 页码, 默认1
+        """
+        state_map = {"filled": 3, "canceled": 4}
+
+        params = {
+            "symbol": symbol,
+            "states": ",".join(str(state_map[state]) for state in states),
+            "page_size": page_size,
+            "page_num": page_num,
+            "category": 1,
+        }
+
+        if start_time:
+            params["start_time"] = start_time
+        if end_time:
+            params["end_time"] = end_time
+
+        res = await self.client.fetch(
+            "GET",
+            f"{self.api_url}/api/v1/private/order/list/history_orders",
+            params=params,
+        )
+
+        return self.ret_content(res)
+
+    async def query_order(self, order_id: str):
+        """查询单个订单的详细信息
+
+        Args:
+            order_id: 订单ID
+
+        Returns:
+            ..code:python
+
+            订单详情数据，例如:
+            [
+                    {
+                        "id": "38600506",          # 成交ID
+                        "symbol": "SOL_USDT",      # 交易对
+                        "side": 4,                 # 方向(1:买入, 3:卖出, 4:平仓)
+                        "vol": 1,                  # 成交数量
+                        "price": 204.11,          # 成交价格
+                        "fee": 0.00081644,        # 手续费
+                        "feeCurrency": "USDT",    # 手续费币种
+                        "profit": -0.0034,        # 盈亏
+                        "category": 1,            # 品类
+                        "orderId": "219079365441409152",  # 订单ID
+                        "timestamp": 1756270991000,       # 时间戳
+                        "positionMode": 1,        # 持仓模式
+                        "voucher": false,         # 是否使用代金券
+                        "taker": true            # 是否是taker
+                    }
+            ]
+        """
+        res = await self.client.fetch(
+            "GET",
+            f"{self.api_url}/api/v1/private/order/deal_details/{order_id}",
+        )
+
+        return self.ret_content(res)

hyperquant/broker/ws.py

@@ -0,0 +1,12 @@
+import asyncio
+import pybotters
+
+
+class Heartbeat:
+    @staticmethod
+    async def ourbit(ws: pybotters.ws.ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_str('{"method":"ping"}')
+            await asyncio.sleep(10.0)
+
+pybotters.ws.HeartbeatHosts.items['futures.ourbit.com'] = Heartbeat.ourbit

hyperquant/core.py

@@ -350,7 +350,7 @@ class Exchange(ExchangeBase):
             self.record_history(time)
 
         # 自动更新账户状态
-        self.Update({symbol: price}, time=time)
+        self.Update({symbol: price},  time=time)
 
         return trade
 
@@ -377,41 +377,92 @@ class Exchange(ExchangeBase):
             trades.append(trade)
         return trades
 
-    def Update(self, close_price, symbols=None, **kwargs):
+    def _recalc_aggregates(self):
+        """基于 self.account 中已保存的各 symbol 状态，重算聚合字段。"""
+        usdt = self.account['USDT']
+        usdt['unrealised_profit'] = 0
+        usdt['hold'] = 0
+        usdt['long'] = 0
+        usdt['short'] = 0
+
+        for symbol in self.trade_symbols:
+            if symbol not in self.account:
+                continue
+            sym = self.account[symbol]
+            px = sym.get('price', 0)
+            amt = sym.get('amount', 0)
+            hp = sym.get('hold_price', 0)
+
+            # 仅当价格有效时计入聚合
+            if px is not None and not np.isnan(px) and px != 0:
+                sym['unrealised_profit'] = (px - hp) * amt
+                sym['value'] = amt * px
+
+                if amt > 0:
+                    usdt['long'] += sym['value']
+                elif amt < 0:
+                    usdt['short'] += sym['value']
+
+                usdt['hold'] += abs(sym['value'])
+                usdt['unrealised_profit'] += sym['unrealised_profit']
+
+        usdt['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + usdt['unrealised_profit'], 6)
+        usdt['leverage'] = round(usdt['hold'] / usdt['total'] if usdt['total'] != 0 else 0.0, 3)
+
+    def Update(self, close_price=None, symbols=None, partial=True, **kwargs):
+        """
+        更新账户状态。
+        - partial=True：只更新给定 symbols 的逐符号状态，然后对所有符号做一次聚合重算（推荐）。
+        - partial=False：与原逻辑兼容；当提供一部分 symbol 时，也会聚合重算，不会清空未提供符号的信息。
+        
+        支持三种入参形式：
+        1) close_price 为 dict/Series：symbols 自动取其键/索引
+        2) close_price 为标量 + symbols 为单个字符串
+        3) 显式传 symbols=list[...]，close_price 为 dict/Series（从中取价）
+        如果既不传 close_price 也不传 symbols，则只做一次聚合重算（例如你先前已经手动修改了某些 symbol 的 price）。
+        """
         if self.recorded and 'time' not in kwargs:
             raise ValueError("Time parameter is required in recorded mode.")
 
         time = kwargs.get('time', pd.Timestamp.now())
-        self.account['USDT']['unrealised_profit'] = 0
-        self.account['USDT']['hold'] = 0
-        self.account['USDT']['long'] = 0
-        self.account['USDT']['short'] = 0
+
+        # 解析 symbols & 价格获取器
         if symbols is None:
-            # symbols = self.trade_symbols
-            # 如果symbols是dict类型, 则取出所有的key, 如果是Series类型, 则取出所有的index
             if isinstance(close_price, dict):
                 symbols = list(close_price.keys())
             elif isinstance(close_price, pd.Series):
-                symbols = close_price.index
+                symbols = list(close_price.index)
             else:
-                raise ValueError("Symbols should be a list, dict or Series.")
-            
-        for symbol in symbols:
-            if symbol not in self.trade_symbols:
+                symbols = []
+        elif isinstance(symbols, str):
+            symbols = [symbols]
+
+        def get_px(sym):
+            if isinstance(close_price, (int, float, np.floating)) and len(symbols) == 1:
+                return float(close_price)
+            if isinstance(close_price, dict):
+                return close_price.get(sym, np.nan)
+            if isinstance(close_price, pd.Series):
+                return close_price.get(sym, np.nan)
+            return np.nan
+
+        # 仅更新传入的 symbols（部分更新，不动其它符号已保存信息）
+        for sym in symbols:
+            if sym not in self.trade_symbols or sym not in self.account:
+                # 未登记的交易对直接跳过（或可选择自动登记，但此处保持严格）
+                continue
+            px = get_px(sym)
+            if px is None or np.isnan(px):
+                # 价格无效则不覆盖旧价格
                 continue
-            if not np.isnan(close_price[symbol]):
-                self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price']) * self.account[symbol]['amount']
-                self.account[symbol]['price'] = close_price[symbol]
-                self.account[symbol]['value'] = self.account[symbol]['amount'] * close_price[symbol]
-                if self.account[symbol]['amount'] > 0:
-                    self.account['USDT']['long'] += self.account[symbol]['value']
-                if self.account[symbol]['amount'] < 0:
-                    self.account['USDT']['short'] += self.account[symbol]['value']
-                self.account['USDT']['hold'] += abs(self.account[symbol]['value'])
-                self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
-
-        self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'], 6)
-        self.account['USDT']['leverage'] = round(self.account['USDT']['hold'] / self.account['USDT']['total'], 3)
+
+            self.account[sym]['price'] = float(px)
+            amt = self.account[sym]['amount']
+            self.account[sym]['value'] = amt * float(px)
+            # 不在这里算 unrealised_profit，聚合阶段统一算
+
+        # 无论 partial 与否，最后都用“账户中保存的所有 symbol 当前状态”做一次聚合重算
+        self._recalc_aggregates()
 
         # 记录账户总资产到 history
         if self.recorded:

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/db.py

@@ -2,7 +2,6 @@ from dataclasses import dataclass
 import duckdb
 import pandas as pd
 from typing import Dict, Optional, Union
-from enum import Enum
 import os
 
 

hyperquant/notikit.py

@@ -0,0 +1,124 @@
+"""
+通知类的功能简单封装，非必要别修改 :)
+只要知道怎么使用以下函数：
+- send_wecom_msg
+- send_wecom_img
+
+Binance期现套利 | 邢不行 | 2024分享会
+author: 邢不行
+微信: xbx6660
+"""
+import base64
+import hashlib
+import os.path
+import json
+import traceback
+import aiohttp
+import asyncio
+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())
+
+
+# 企业微信通知
+async def send_wecom_msg(content: str, webhook_url: str) -> None:
+    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")
+            }
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                webhook_url,
+                json=data,
+                proxy=proxy.get('http') if proxy else None,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                result = await response.text()
+                logger.info(f'调用企业微信接口返回： {result}')
+                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)
+
+
+# 企业微信发送图片
+async def send_wecom_img(file_path: str, webhook_url: str) -> None:
+    """
+    企业微信发送图片
+    :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
+            }
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                webhook_url,
+                json=data,
+                proxy=proxy.get('http') if proxy else None,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                result = await response.text()
+                logger.info(f'调用企业微信接口返回： {result}')
+                logger.ok('成功发送企业微信图片')
+    except Exception as e:
+        handle_exception(e, '发送企业微信图片失败')
+    finally:
+        if os.path.exists(file_path):
+            os.remove(file_path)