hypertrader 0.1.9__tar.gz → 0.2.0__tar.gz

{hypertrader-0.1.9 → hypertrader-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.9
+Version: 0.2.0
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -69,6 +69,7 @@ The canonical bot file in this repo is [`hypertrader.py`](/media/anon/developmen
 Install from pip: https://pypi.org/project/hypertrader
 
 <pre>
+pip install --upgrade pip setuptools wheel
 pip install hypertrader[auto] --upgrade
 </pre>
 

{hypertrader-0.1.9 → hypertrader-0.2.0}/README.md

@@ -38,6 +38,7 @@ The canonical bot file in this repo is [`hypertrader.py`](/media/anon/developmen
 Install from pip: https://pypi.org/project/hypertrader
 
 <pre>
+pip install --upgrade pip setuptools wheel
 pip install hypertrader[auto] --upgrade
 </pre>
 

{hypertrader-0.1.9 → hypertrader-0.2.0}/hypertrader.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.9
+Version: 0.2.0
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -69,6 +69,7 @@ The canonical bot file in this repo is [`hypertrader.py`](/media/anon/developmen
 Install from pip: https://pypi.org/project/hypertrader
 
 <pre>
+pip install --upgrade pip setuptools wheel
 pip install hypertrader[auto] --upgrade
 </pre>
 

{hypertrader-0.1.9 → hypertrader-0.2.0}/hypertrader.egg-info/SOURCES.txt

@@ -21,10 +21,12 @@ strategies/orderflow_models.py
 strategies/orderflow_pullback.py
 strategies/registry.py
 strategies/reversal.py
+tests/test_api_retry.py
 tests/test_async_hyperliquid.py
 tests/test_auto_dry_run.py
 tests/test_auto_strategy_registry.py
 tests/test_auto_trader_logging.py
+tests/test_cli_shutdown.py
 tests/test_fib_reversal_strategy.py
 tests/test_market_ids.py
 tests/test_orderflow_metrics.py
@@ -34,6 +36,7 @@ tests/test_simulated_logging.py
 tests/test_trailing_stop.py
 utils/constants.py
 utils/helpers.py
+utils/retry.py
 utils/simulated_logging.py
 utils/style.py
 utils/timer.py

{hypertrader-0.1.9 → hypertrader-0.2.0}/hypertrader.py

@@ -1033,45 +1033,40 @@ async def async_main(argv: Optional[List[str]] = None) -> None:
 
 def main(argv: Optional[List[str]] = None) -> None:
     from utils.simulated_logging import LoggedConsole
-    def start():
-        _loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(_loop)
-        install_asyncio_exception_logging(_loop)
+
+    async def start() -> None:
+        install_asyncio_exception_logging(asyncio.get_running_loop())
         print(f"[LOG] Writing runtime logs to {log_path}")
         print(f"[START] argv={argv if argv is not None else sys.argv[1:]}")
-        _loop.run_until_complete(async_main(argv))
+        await async_main(argv)
 
     args = argv if argv is not None else sys.argv[1:]
     dry_run = "--dry-run" in args
     log_path = configure_runtime_logging(SIMULATED_LOG_FILE if dry_run else None)
     original_stdout, original_stderr = sys.stdout, sys.stderr
-    restart = False
     if dry_run:
         sys.stdout = LoggedConsole(original_stdout)
         # sys.stderr = LoggedConsole(original_stderr)
     try:
-        start()
-    except KeyboardInterrupt:
-        print("\n[!] Interrupted.")
-    except Exception as err:
-        logging.getLogger("hypertrader").exception("[FATAL] Unhandled main() exception: %s" % err)
-        restart = True
-
-
+        # Give both the initial run and the single retry a complete lifecycle:
+        # cancellation, awaited cleanup, then event-loop shutdown.
+        for attempt in range(2):
+            try:
+                asyncio.run(start())
+                break
+            except KeyboardInterrupt:
+                print("\n[!] Interrupted.")
+                break
+            except Exception as err:
+                logging.getLogger("hypertrader").exception("[FATAL] Unhandled main() exception: %s", err)
+                if attempt == 1:
+                    raise
+                print('[!] Restarting ... ')
     finally:
         if dry_run:
             sys.stdout.flush()
             sys.stderr.flush()
             sys.stdout, sys.stderr = original_stdout, original_stderr
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = None
-        if loop is not None and not loop.is_closed():
-            loop.close()
-        if restart:
-            print('[!] Restarting ... ')
-            start()
 
 
 if __name__ == "__main__":

{hypertrader-0.1.9 → hypertrader-0.2.0}/modes/auto_trader.py

@@ -18,6 +18,7 @@ from strategies.base import AutoStrategy, StrategyContext, StrategySignal
 from strategies.registry import create_strategy
 from strategies.reversal import normalize_signal_prices
 from utils.constants import AUTO_TRADES_LOG_FILE, SIMULATED_LOG_FILE, INTERVAL_TO_MS, PRICE_EPS, cp
+from utils.retry import retry_api_read
 from utils.helpers import parse_interval_list, init_clients, _try_float, parse_fractional_pct, \
     extract_account_balance_from_user_state, round_size_for_hyperliquid, get_user_state_with_retry, get_all_mids, \
     fetch_recent_candles, compute_position_unrealized_pnl, close_clients, compute_default_stop_loss_pct, \
@@ -105,7 +106,9 @@ async def get_top_perp_markets_by_volume(info: Info, limit: int) -> List[Tuple[s
     if limit <= 0:
         raise RuntimeError("--top-markets must be > 0.")
 
-    meta_and_ctxs = await info.meta_and_asset_ctxs()
+    meta_and_ctxs = await retry_api_read(
+        info.meta_and_asset_ctxs, context="auto market ranking"
+    )
     if not isinstance(meta_and_ctxs, (list, tuple)) or len(meta_and_ctxs) < 2:
         raise RuntimeError(f"Unexpected metaAndAssetCtxs response shape: {type(meta_and_ctxs).__name__}")
 
@@ -2883,11 +2886,14 @@ async def run_auto_trader(
             startup_backfill_state.begin_iteration()
 
             try:
-                shared_snapshot = await build_auto_scan_loop_snapshot(
-                    info=info,
-                    account_address=account_address,
-                    metrics_start_time_ms=metrics_start_time_ms,
-                    dry_run=dry_run,
+                shared_snapshot = await retry_api_read(
+                    lambda: build_auto_scan_loop_snapshot(
+                        info=info,
+                        account_address=account_address,
+                        metrics_start_time_ms=metrics_start_time_ms,
+                        dry_run=dry_run,
+                    ),
+                    context="auto shared snapshot",
                 )
             except Exception as exc:
                 if is_rate_limit_error(exc):

{hypertrader-0.1.9 → hypertrader-0.2.0}/setup.py

@@ -9,7 +9,7 @@ README = ROOT / "README.md"
 
 setup(
     name="hypertrader",
-    version="0.1.9",
+    version="0.2.0",
     description="Async Hyperliquid trading helper built on the async SDK.",
     long_description=README.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",

hypertrader-0.2.0/tests/test_api_retry.py

@@ -0,0 +1,127 @@
+import asyncio
+import unittest
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock, call, patch
+
+import aiohttp
+from hyperliquid.utils.error import ClientError, ServerError
+
+from modes.auto_trader import get_top_perp_markets_by_volume
+from utils import helpers, retry
+
+
+class ApiRetryTests(unittest.IsolatedAsyncioTestCase):
+    async def test_repeated_gateway_errors_back_off_until_recovery(self):
+        read = AsyncMock(side_effect=[ServerError(502, "Bad Gateway")] * 7 + ["ok"])
+        with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep:
+            result = await retry.retry_api_read(read, context="test read")
+        self.assertEqual(result, "ok")
+        self.assertEqual(read.await_count, 8)
+        self.assertEqual(sleep.await_args_list, [call(n) for n in (5, 10, 20, 40, 60, 60, 60)])
+
+    async def test_backoff_resets_for_next_operation(self):
+        read = AsyncMock(side_effect=[ServerError(503, "unavailable"), 1] * 2)
+        with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep:
+            await retry.retry_api_read(read, context="first")
+            await retry.retry_api_read(read, context="second")
+        self.assertEqual(sleep.await_args_list, [call(5), call(5)])
+
+    async def test_non_transient_errors_propagate_without_retry(self):
+        for error in (ClientError(400, None, "bad request", None), ValueError("bad data")):
+            with self.subTest(error=error):
+                read = AsyncMock(side_effect=error)
+                with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep:
+                    with self.assertRaises(type(error)):
+                        await retry.retry_api_read(read, context="test read")
+                read.assert_awaited_once()
+                sleep.assert_not_awaited()
+
+    async def test_rate_limit_connection_and_timeout_errors_retry(self):
+        for error in (
+            ClientError(429, None, "rate limited", None),
+            aiohttp.ClientConnectionError("disconnected"),
+            asyncio.TimeoutError(),
+        ):
+            with self.subTest(error=error):
+                read = AsyncMock(side_effect=[error, "ok"])
+                with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep:
+                    self.assertEqual(await retry.retry_api_read(read, context="read"), "ok")
+                sleep.assert_awaited_once_with(5)
+
+    async def test_cancellation_during_request_or_backoff_propagates(self):
+        read = AsyncMock(side_effect=asyncio.CancelledError())
+        with self.assertRaises(asyncio.CancelledError):
+            await retry.retry_api_read(read, context="cancelled read")
+        read.assert_awaited_once()
+
+        read = AsyncMock(side_effect=ServerError(502, "Bad Gateway"))
+        with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock,
+                          side_effect=asyncio.CancelledError()):
+            with self.assertRaises(asyncio.CancelledError):
+                await retry.retry_api_read(read, context="cancelled backoff")
+        read.assert_awaited_once()
+
+    async def test_market_ranking_recovers_from_logged_502(self):
+        info = SimpleNamespace(meta_and_asset_ctxs=AsyncMock(side_effect=[
+            ServerError(502, "<html>502 Bad Gateway</html>"),
+            [{"universe": [{"name": "BTC"}, {"name": "ETH"}]},
+             [{"dayNtlVlm": "100"}, {"dayNtlVlm": "200"}]],
+        ]))
+        with patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep:
+            result = await get_top_perp_markets_by_volume(info, 1)
+        self.assertEqual(result, [("ETH", 200.0)])
+        sleep.assert_awaited_once_with(5)
+        self.assertEqual(info.meta_and_asset_ctxs.await_count, 2)
+
+    async def test_startup_closes_failed_clients_before_backoff_then_recovers(self):
+        for stage in ("info", "exchange", "cache"):
+            with self.subTest(stage=stage):
+                infos = [SimpleNamespace(initialize=AsyncMock(), aclose=AsyncMock()) for _ in range(2)]
+                exchanges = [SimpleNamespace(initialize=AsyncMock(), aclose=AsyncMock()) for _ in range(2)]
+                caches = [SimpleNamespace(start=AsyncMock(), stop=AsyncMock()) for _ in range(2)]
+                failure = ServerError(502, "Bad Gateway")
+                if stage == "info":
+                    infos[0].initialize.side_effect = failure
+                elif stage == "exchange":
+                    exchanges[0].initialize.side_effect = failure
+                else:
+                    caches[0].start.side_effect = failure
+
+                async def check_cleanup(delay):
+                    self.assertEqual(delay, 5)
+                    infos[0].aclose.assert_awaited_once()
+                    if stage != "info":
+                        exchanges[0].aclose.assert_awaited_once()
+                    if stage == "cache":
+                        caches[0].stop.assert_awaited_once()
+
+                with (
+                    patch.object(helpers, "load_credentials", return_value=("secret", "0xabc")),
+                    patch.object(helpers.eth_account.Account, "from_key", return_value=object()),
+                    patch.object(helpers, "Info", side_effect=infos),
+                    patch.object(helpers, "Exchange", side_effect=exchanges),
+                    patch.object(helpers, "HyperliquidWebsocketCache", side_effect=caches),
+                    patch.object(helpers, "get_ws_cache", side_effect=lambda info: getattr(info, "ws_cache", None)),
+                    patch.object(retry.asyncio, "sleep", new_callable=AsyncMock, side_effect=check_cleanup),
+                ):
+                    address, info, exchange = await helpers.init_clients(False, use_websocket=False)
+                self.assertEqual(address, "0xabc")
+                self.assertIs(info, infos[1])
+                self.assertIs(exchange, exchanges[0 if stage == "info" else 1])
+                info.aclose.assert_not_awaited()
+                exchange.aclose.assert_not_awaited()
+
+    async def test_startup_cancellation_closes_partial_client(self):
+        info = SimpleNamespace(initialize=AsyncMock(side_effect=asyncio.CancelledError()), aclose=AsyncMock())
+        with (
+            patch.object(helpers, "load_credentials", return_value=("secret", "0xabc")),
+            patch.object(helpers.eth_account.Account, "from_key", return_value=object()),
+            patch.object(helpers, "Info", return_value=info),
+            patch.object(helpers, "Exchange", new_callable=Mock) as exchange,
+            patch.object(retry.asyncio, "sleep", new_callable=AsyncMock) as sleep,
+        ):
+            with self.assertRaises(asyncio.CancelledError):
+                await helpers.init_clients(False)
+        info.aclose.assert_awaited_once()
+        exchange.assert_not_called()
+        sleep.assert_not_awaited()

hypertrader-0.2.0/tests/test_cli_shutdown.py

@@ -0,0 +1,86 @@
+import subprocess
+import sys
+import textwrap
+import unittest
+
+
+# Run SIGINT in a child process so it cannot interrupt the test runner.
+SHUTDOWN_SCRIPT = textwrap.dedent("""\
+    import asyncio
+    import gc
+    import signal
+    import sys
+    from unittest.mock import patch
+
+    import aiohttp
+    import hypertrader
+
+    backend, scenario = sys.argv[1:]
+    if backend == "uvloop":
+        import uvloop
+        uvloop.install()
+
+    loops = []
+    sessions = []
+    tasks = []
+    events = []
+    errors = []
+
+    async def background(attempt):
+        try:
+            await asyncio.Event().wait()
+        finally:
+            await asyncio.sleep(0)
+            events.append((attempt, "background closed"))
+
+    async def application(argv):
+        attempt = len(loops)
+        loop = asyncio.get_running_loop()
+        loops.append(loop)
+        loop.set_exception_handler(lambda loop, context: errors.append(context))
+        session = aiohttp.ClientSession()
+        sessions.append(session)
+        tasks.append(asyncio.create_task(background(attempt)))
+        try:
+            await asyncio.sleep(0)
+            if scenario.startswith("restart") and attempt == 0:
+                raise RuntimeError("trigger restart")
+            if scenario.endswith("interrupt"):
+                loop.call_soon(signal.raise_signal, signal.SIGINT)
+                await asyncio.Event().wait()
+        finally:
+            await asyncio.sleep(0)
+            await session.close()
+            events.append((attempt, "session closed"))
+
+    with patch.object(hypertrader, "async_main", application), patch.object(
+        hypertrader, "configure_runtime_logging", return_value="unused.log"
+    ):
+        hypertrader.main([])
+
+    gc.collect()
+    assert len(loops) == (2 if scenario.startswith("restart") else 1), events
+    assert all(loop.is_closed() for loop in loops), "event loop left open"
+    assert all(session.closed for session in sessions), "HTTP session left open"
+    assert all(task.done() for task in tasks), "background task left pending"
+    for attempt in range(len(loops)):
+        assert (attempt, "session closed") in events, events
+        assert (attempt, "background closed") in events, events
+    assert not errors, errors
+    print("shutdown verified")
+""")
+
+
+class CliShutdownTests(unittest.TestCase):
+    def test_shutdown_and_restart_release_async_resources(self):
+        for backend in ("asyncio", "uvloop"):
+            for scenario in ("normal", "interrupt", "restart", "restart_interrupt"):
+                with self.subTest(backend=backend, scenario=scenario):
+                    result = subprocess.run(
+                        [sys.executable, "-c", SHUTDOWN_SCRIPT, backend, scenario],
+                        capture_output=True, text=True, timeout=20,
+                    )
+                    self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+                    self.assertIn("shutdown verified", result.stdout)
+                    self.assertNotIn("Unclosed", result.stderr)
+                    self.assertNotIn("Task was destroyed", result.stderr)

{hypertrader-0.1.9 → hypertrader-0.2.0}/utils/helpers.py

@@ -15,6 +15,7 @@ from hyperliquid.utils import constants
 
 from utils.constants import INTERVAL_TO_MS, WATCH_RETRY_SLEEP_SECONDS
 from utils.worker import AsyncTaskQueue
+from utils.retry import retry_api_read
 
 decimal.getcontext().prec = 4
 
@@ -698,13 +699,24 @@ async def init_clients(use_testnet: bool, use_websocket: bool = True) -> Tuple[s
     api_url = constants.TESTNET_API_URL if use_testnet else constants.MAINNET_API_URL
     account: LocalAccount = eth_account.Account.from_key(secret_key)
 
-    info = await Info.create(api_url, skip_ws=(not use_websocket))
-    exchange = await Exchange.create(account, api_url, account_address=account_address)
+    async def initialize() -> Tuple[str, Info, Exchange]:
+        # Keep references before initialization so failed SDK requests cannot
+        # strand HTTP sessions or websockets inside the SDK's create() methods.
+        info = Info(api_url, skip_ws=(not use_websocket))
+        exchange = None
+        try:
+            await info.initialize()
+            exchange = Exchange(account, api_url, account_address=account_address)
+            await exchange.initialize()
+            ws_cache = HyperliquidWebsocketCache(info, account_address, enabled=use_websocket)
+            setattr(info, "ws_cache", ws_cache)
+            await ws_cache.start()
+            return account_address, info, exchange
+        except BaseException:
+            await close_clients(info, exchange)
+            raise
 
-    ws_cache = HyperliquidWebsocketCache(info, account_address, enabled=use_websocket)
-    setattr(info, "ws_cache", ws_cache)
-    await ws_cache.start()
-    return account_address, info, exchange
+    return await retry_api_read(initialize, context="Hyperliquid client initialization")
 
 
 async def close_clients(info: Optional[Info], exchange: Optional[Exchange]) -> None:

hypertrader-0.2.0/utils/retry.py

@@ -0,0 +1,41 @@
+"""Backoff for read-only requests and client initialization."""
+
+import asyncio
+import logging
+from typing import Awaitable, Callable, TypeVar
+
+import aiohttp
+from hyperliquid.utils.error import ClientError, ServerError
+
+
+T = TypeVar("T")
+logger = logging.getLogger(__name__)
+
+
+def is_transient_api_error(exc: Exception) -> bool:
+    if isinstance(exc, (ClientError, ServerError)):
+        return exc.status_code == 429 or 500 <= exc.status_code < 600
+    if isinstance(exc, aiohttp.ClientResponseError):
+        return exc.status == 429 or 500 <= exc.status < 600
+    return isinstance(exc, (aiohttp.ClientConnectionError, asyncio.TimeoutError))
+
+
+async def retry_api_read(operation: Callable[[], Awaitable[T]], *, context: str) -> T:
+    """Retry transient failures until recovery or cancellation; never use for orders."""
+    delay = 5.0
+    while True:
+        try:
+            return await operation()
+        except Exception as exc:
+            if not is_transient_api_error(exc):
+                raise
+            status = getattr(exc, "status_code", getattr(exc, "status", None))
+            message = (
+                f"[API-RETRY] {context}: {type(exc).__name__}"
+                f"{f' HTTP {status}' if status is not None else ''}. "
+                f"Sleeping {delay:.1f}s before retry."
+            )
+            print(message)
+            logger.warning(message)
+            await asyncio.sleep(delay)
+            delay = min(delay * 2, 60.0)