hyperquant 0.55__tar.gz → 0.57__tar.gz

{hyperquant-0.55 → hyperquant-0.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.55
+Version: 0.57
 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.55 → hyperquant-0.57}/pyproject.toml

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

{hyperquant-0.55 → hyperquant-0.57}/src/hyperquant/broker/models/ourbit.py

@@ -134,6 +134,7 @@ class Orders(DataStore):
     def _fmt(self, order:dict):
         return {
             "order_id": order.get("orderId"),
+            "position_id": order.get("positionId"),
             "symbol": order.get("symbol"),
             "price": order.get("price"),
             "vol": order.get("vol"),
@@ -213,6 +214,7 @@ class Detail(DataStore):
                         "contract_sz": detail.get("cs"),
                         "minv": detail.get("minV"),
                         "maxv": detail.get("maxV")
+                        "online_time": detail.get("tcd")
                     }
                 )
         self._update(data_to_insert)
@@ -403,8 +405,8 @@ class OurbitSwapDataStore(DataStoreCollection):
                 "io": ["binance", "mexc"],  # 交易所列表
                 "contract_sz": 1,
                 "minv": 1,
-                "maxv": 10000
-
+                "maxv": 10000,
+                "online_time": 1625247600000  # 上线时间
             }
         ]
         """

{hyperquant-0.55 → hyperquant-0.57}/tests/test_ourbit.py

@@ -173,11 +173,38 @@ async def test_order_sync_swap():
         # await ob.sub_orderbook(["SOL_USDT"])  # 订单簿频道
         # # 示例：市价
         # now= time.time()
-        result = await order_sync( ob, symbol="SOL_USDT", side="buy", order_type="limit_IOC", usdt_amount=8, price=200, window_sec=3)
+        result = await order_sync( ob, symbol="SOL_USDT", side="buy", order_type="market", usdt_amount=8, price=200, window_sec=3)
         print(result)
+
+
+async def test_order_close_swap():
+    async with pybotters.Client(
+        apis={
+            "ourbit": [
+                "WEBb401428e69af1815808e470be0a4f4e8a70a5c5cc0b0df0a33220f689167c629"
+            ]
+        }
+    ) as client:
+        ob = OurbitSwap(client)
+        await ob.__aenter__()
+        # await ob.sub_personal()  # 私有频道
+        # result = await order_sync( ob, symbol="SOL_USDT", side="buy", order_type="market", usdt_amount=8, price=200, window_sec=3)
+        # print(result)
+        # oid = await ob.place_order(
+        #     "SOL_USDT",
+        #     "buy",
+        #     order_type="market",
+        #     size=1
+        # )
+
+        # print(oid)
+        # await ob.update('position')
+        # print(ob.store.position.find())
+
+        await ob.place_order('SOL_USDT', 'close_sell', 1, position_id=6062178)
         
 
 
 if __name__ == "__main__":
     import asyncio
-    asyncio.run(test_order_sync_swap())
+    asyncio.run(test_order_close_swap())

{hyperquant-0.55 → hyperquant-0.57}/uv.lock

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

hyperquant-0.55/tests/test.py

@@ -1,183 +0,0 @@
-import asyncio
-import time
-from typing import Optional, TypedDict, Literal
-
-import pybotters
-from hyperquant.broker.ourbit import OurbitSpot
-from hyperquant.logkit import get_logger
-
-logger = get_logger("alpine_test", "./data/alpine_smoke.log", True)
-
-
-class Hold(TypedDict, total=False):
-    symbol: str
-    status: Literal["pending", "filled", "closing"]
-    oid: str
-    ts: float
-    p: float
-    q: float
-    filled_ts: float
-
-
-class AlpineSmokeTest:
-    """
-    仅针对 ALPINE_USDT：市价开仓 -> 持有 5 秒 -> 市价平仓。
-    - 目的：测试 WS 事件链路与下单路径稳定性（不依赖价差/策略信号）。
-    - 仅订阅 Ourbit 订单簿(可选) 和私有频道，验证参数与心跳。
-    """
-
-    SYMBOL = "SOL_USDT"
-
-    def __init__(self, hold_seconds: float = 5.0, open_timeout_ms: int = 2000, close_timeout_ms: int = 3000):
-        self.hold_seconds = hold_seconds
-        self.open_timeout_ms = open_timeout_ms
-        self.close_timeout_ms = close_timeout_ms
-        self.client: Optional[pybotters.Client] = None
-        self.ourbit: Optional[OurbitSpot] = None
-        self.ob_store = None
-
-    def _msg_debug(self,msg: dict, ws):
-
-        if 'spot@private.orders' in msg.get("c", ""):
-            logger.info(f"orders消息: {msg}")
-
-    async def _msg_debug2(self):
-        with self.ob_store.orders.watch() as stream:
-            async for change in stream:
-                print(change)
-
-    async def __aenter__(self):
-        self.client = pybotters.Client(apis="./apis.json")
-        await self.client.__aenter__()
-
-        self.ourbit = OurbitSpot(self.client)
-        await self.ourbit.__aenter__()
-        self.ob_store = self.ourbit.store
-
-        # 仅订阅 ALPINE 订单簿与私有频道（用于测试 WS 参数与心跳）
-        await self.ourbit.sub_orderbook([self.SYMBOL])
-        await self.ourbit.sub_personal()
-        logger.info("已就绪：仅订阅 Ourbit ALPINE 订单簿/私有频道")
-        asyncio.create_task(self._msg_debug2())
-        return self
-
-    async def __aexit__(self, et, ev, tb):
-        if self.client:
-            await self.client.__aexit__(et, ev, tb)
-
-    # ============ helpers ============
-    async def _open_market_and_wait(self, symbol: str, usdt_amount: float, timeout_ms: int) -> Optional[Hold]:
-        """以市价开仓并在本地流中等待终态。成功返回 Hold；失败/超时返回 None。"""
-        start = time.time() * 1000
-        with self.ob_store.orders.watch() as stream:
-            try:
-                oid = await self.ourbit.place_order(symbol, "buy", order_type="market", usdt_amount=usdt_amount)
-                logger.info(f"准备开仓: {symbol} oid={oid}")
-            except Exception as e:
-                logger.error(f"开仓下单失败 {symbol}: {e}")
-                return None
-
-            while True:
-                remain = timeout_ms - (time.time() * 1000 - start)
-                if remain <= 0:
-                    logger.warning(f"开仓超时: {symbol} oid={oid}")
-                    return None
-                try:
-                    change = await asyncio.wait_for(stream.__anext__(), timeout=remain / 1000)
-                except asyncio.TimeoutError:
-                    logger.warning(f"开仓超时: {symbol} oid={oid}")
-                    return None
-
-                if change.operation != "delete":
-                    continue
-                data = change.data
-                if data.get("order_id") != oid:
-                    continue
-
-                state = data.get("state")
-                if state == "filled":
-                    p = float(data["avg_price"]) ; q = float(data["deal_quantity"]) ; ts = time.time() * 1000
-                    logger.ok(f"建仓成交: {symbol} p={p} q={q}")
-                    return {"symbol": symbol, "status": "filled", "oid": oid, "p": p, "q": q, "filled_ts": ts}
-                if state in ("canceled", "expired", "rejected", "failed"):
-                    logger.warning(f"开仓失败: {symbol} state={state}")
-                    return None
-
-    async def _close_market_and_wait(self, symbol: str, qty: float, timeout_ms: int) -> bool:
-        """以市价平仓并等待终态。成功返回 True。"""
-        start = time.time() * 1000
-        with self.ob_store.orders.watch() as stream:
-            try:
-                oid = await self.ourbit.place_order(symbol, "sell", order_type="market", quantity=qty)
-                logger.info(f"触发平仓: {symbol} qty={qty} oid={oid}")
-            except Exception as e:
-                logger.error(f"平仓下单失败 {symbol}: {e}")
-                return False
-
-        
-            while True:
-                remain = timeout_ms - (time.time() * 1000 - start)
-                if remain <= 0:
-                    logger.error(f"平仓超时: {symbol} oid={oid}")
-                    return False
-                try:
-                    change = await asyncio.wait_for(stream.__anext__(), timeout=remain / 1000)
-                except asyncio.TimeoutError:
-                    logger.error(f"平仓超时: {symbol} oid={oid}")
-                    return False
-
-                if change.operation != "delete":
-                    continue
-                data = change.data
-                if data.get("order_id") != oid:
-                    continue
-
-                state = data.get("state")
-                if state == "filled":
-                    logger.ok(f"平仓完成: {symbol} close_p={data.get('avg_price')}")
-                    return True
-                if state in ("canceled", "expired", "rejected", "failed"):
-                    logger.error(f"平仓失败: {symbol} state={state}")
-                    return False
-
-    # ============ one-shot test flow ============
-    async def run_once(self, usdt_amount: float = 10.0):
-        """一次性流程：开仓 -> 持有 N 秒 -> 平仓。"""
-        # 1) 开仓
-        hold = await self._open_market_and_wait(self.SYMBOL, usdt_amount, timeout_ms=self.open_timeout_ms)
-        if not hold:
-            logger.warning("开仓未成功，终止本次测试")
-            return
-
-        # 2) 持有 N 秒
-        logger.info(f"开始持有 {self.hold_seconds}s: {self.SYMBOL} q={hold['q']} p={hold['p']}")
-        await asyncio.sleep(self.hold_seconds)
-
-        # 3) 平仓
-        ok = await self._close_market_and_wait(self.SYMBOL, float(hold["q"]), timeout_ms=self.close_timeout_ms)
-        if ok:
-            logger.info("本次测试完成 ✅")
-        else:
-            logger.error("本次测试失败 ❌")
-
-    async def run_loop(self, usdt_amount: float = 10.0, interval_seconds: float = 60.0):
-        """循环执行 run_once，间隔 N 秒。"""
-        while True:
-            await self.run_once(usdt_amount)
-            logger.info(f"等待 {interval_seconds}s 后进行下一轮测试")
-            await asyncio.sleep(interval_seconds)
-
-
-async def main():
-    async with AlpineSmokeTest(hold_seconds=5.0) as test:
-        # await test.run_once(usdt_amount=10.0)
-        await test.run_loop(usdt_amount=10.0, interval_seconds=5)
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        print("\n👋 程序已退出")
-    except Exception as e:
-        print(f"❌ 程序异常: {e}")

hyperquant-0.55/tests/test_order_sync.py

@@ -1,82 +0,0 @@
-import asyncio
-import time
-from hyperquant.broker.ourbit import OurbitSpot
-import pybotters
-from hyperquant.logkit import get_logger
-
-logger = get_logger('test_order_sync', './data/logs/test_order_sync.log', show_time=True)
-
-
-# 等待指定 oid 的最终 delete，超时抛 TimeoutError
-async def wait_delete(stream: pybotters.StoreStream, oid: str, seconds: float):
-    async with asyncio.timeout(seconds):
-        while True:
-            change = await stream.__anext__()
-            if change.operation == "delete" and change.data.get("order_id") == oid:
-                return change.data  # 内含 state / avg_price / deal_quantity 等累计字段
-
-
-async def order_sync(
-    ob: OurbitSpot,
-    symbol: str = "SOL_USDT",
-    side: str = "buy",
-    order_type: str = "market",  # "market" / "limit"
-    usdt_amount: float | None = None,  # 市价可填
-    quantity: float | None = None,  # 市价可填
-    price: float | None = None,  # 限价必填
-    window_sec: float = 2.0,  # 主等待窗口（限价可设为 5.0）
-    grace_sec: float = 2,  # 撤单后宽限
-):
-    with ob.store.orders.watch() as stream:
-        # 下单（只保留最简两种入参形态）
-        try:
-            oid = await ob.place_order(
-                symbol,
-                side,
-                order_type=order_type,
-                usdt_amount=usdt_amount,
-                quantity=quantity,
-                price=price,
-            )
-        except Exception as e:
-            return {"symbol": symbol, "state": "error", "error": str(e)}
-
-        # 步骤1：主窗口内等待这单的最终 delete
-        try:
-            return await wait_delete(stream, oid, window_sec)
-        except TimeoutError:
-            # 步骤2：到点撤单（市价通常用不到；限价才有意义）
-            for i in range(3):
-                try:
-                    await ob.cancel_order(oid)
-                    break
-                except Exception:
-                    pass
-                await asyncio.sleep(0.1)
-            # 固定宽限内再等“迟到”的最终 delete
-            try:
-                return await wait_delete(stream, oid, grace_sec)
-            except TimeoutError:
-                return {"order_id": oid, "symbol": symbol, "state": "timeout"}
-
-
-async def test_order_sync():
-    async with pybotters.Client(
-        apis={
-            "ourbit": [
-                "WEB3bf088f8b2f2fae07592fe1a6240e2d798100a9cb2a91f8fda1056b6865ab3ee"
-            ]
-        }
-    ) as client:
-        ob = OurbitSpot(client)
-        await ob.__aenter__()
-        await ob.sub_personal()  # 私有频道
-        ob.store.book.limit = 3
-        await ob.sub_orderbook(["SOL_USDT"])  # 订单簿频道
-        # # 示例：市价
-        # now= time.time()
-        result = await order_sync( ob, symbol="SOL_USDT", side="buy", order_type="market", usdt_amount=8, price=200, window_sec=2)
-        print(result)
-        
-
-

hyperquant-0.55/tests/test_store.py

@@ -1,16 +0,0 @@
-import asyncio
-import pybotters
-
-
-async def main():
-    ds = pybotters.store.DataStore(keys=["id"])
-    loop = asyncio.get_running_loop()
-
-    wait_task = loop.create_task(ds.wait())
-    loop.call_soon(
-        ds._insert, [{"id": 1, "val": 1}, {"id": 2, "val": 2}, {"id": 3, "val": 3}]
-    )
-    await asyncio.wait_for(wait_task, timeout=5.0)
-
-    ds._insert, [{"id": 1, "val": 1}, {"id": 2, "val": 2}, {"id": 3, "val": 3}]
-