hypertrader 0.1.1__tar.gz → 0.1.3__tar.gz

{hypertrader-0.1.1 → hypertrader-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.1
+Version: 0.1.3
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: eth-account
 Requires-Dist: hyperliquid-python-sdk-async
 Requires-Dist: python-dotenv
 Requires-Dist: uvloop
+Requires-Dist: colored
 Provides-Extra: auto
 Requires-Dist: numpy; extra == "auto"
 Requires-Dist: TA-Lib; extra == "auto"

{hypertrader-0.1.1 → hypertrader-0.1.3}/hypertrader.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.1.1
+Version: 0.1.3
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: eth-account
 Requires-Dist: hyperliquid-python-sdk-async
 Requires-Dist: python-dotenv
 Requires-Dist: uvloop
+Requires-Dist: colored
 Provides-Extra: auto
 Requires-Dist: numpy; extra == "auto"
 Requires-Dist: TA-Lib; extra == "auto"

{hypertrader-0.1.1 → hypertrader-0.1.3}/hypertrader.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+ht = hypertrader:main
 hypertrader = hypertrader:main

{hypertrader-0.1.1 → hypertrader-0.1.3}/hypertrader.egg-info/requires.txt

@@ -2,6 +2,7 @@ eth-account
 hyperliquid-python-sdk-async
 python-dotenv
 uvloop
+colored
 
 [auto]
 numpy

{hypertrader-0.1.1 → hypertrader-0.1.3}/hypertrader.py

@@ -145,6 +145,7 @@ def build_arg_parser() -> argparse.ArgumentParser:
             "  market_maker  Event-driven MM: build a pyramiding ladder around recent volatility."
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
+        usage="Full documentation located at https://github.com/darkerego/hypertrader.",
     )
     subparsers = parser.add_subparsers(dest="command", required=True)
 

{hypertrader-0.1.1 → hypertrader-0.1.3}/modes/auto_trader.py

@@ -18,7 +18,7 @@ from utils.constants import AUTO_TRADES_LOG_FILE, INTERVAL_TO_MS, cp
 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, \
-    extract_closed_pnl_from_fill
+    extract_closed_pnl_from_fill, is_rate_limit_error
 
 logger = logging.getLogger(__name__)
 _AUTO_TRADES_LOGGER: Optional[logging.Logger] = None
@@ -202,6 +202,142 @@ class AutoManagedTradeResult:
     closed_ms: int
 
 
+@dataclass
+class AutoStartupBackfillState:
+    """Track startup candle backfill progress and block entries until it completes."""
+    enabled: bool
+    pause_seconds: float = 3.0
+    pause_between_batches: bool = False
+    complete: bool = False
+    saw_rate_limit_this_iteration: bool = False
+    pending_pairs: set[Tuple[str, str]] | None = None
+    expected_pairs: set[Tuple[str, str]] | None = None
+    successful_pairs: set[Tuple[str, str]] | None = None
+    ignored_pairs: set[Tuple[str, str]] | None = None
+    excluded_coins: set[str] | None = None
+
+    def __post_init__(self) -> None:
+        if self.pending_pairs is None:
+            self.pending_pairs = set()
+        if self.expected_pairs is None:
+            self.expected_pairs = set()
+        if self.successful_pairs is None:
+            self.successful_pairs = set()
+        if self.ignored_pairs is None:
+            self.ignored_pairs = set()
+        if self.excluded_coins is None:
+            self.excluded_coins = set()
+
+    def _refresh_completion(self) -> None:
+        if not self.enabled or self.complete or not self.expected_pairs:
+            return
+        completed_pairs = (self.successful_pairs or set()) | (self.ignored_pairs or set())
+        if completed_pairs >= self.expected_pairs:
+            self.complete = True
+            if self.pause_between_batches:
+                print("[AUTO] Initial REST candle backfill completed; resuming normal scan cadence.")
+            else:
+                print("[AUTO] Startup candle backfill completed; auto entries are now enabled.")
+
+    def set_expected_pairs(self, coins: List[str], intervals: List[str]) -> None:
+        if not self.enabled or self.complete or self.expected_pairs:
+            return
+        normalized_coins = [str(coin).upper() for coin in coins if str(coin).strip()]
+        normalized_intervals = [str(interval) for interval in intervals if str(interval).strip()]
+        self.expected_pairs = {
+            (coin, interval)
+            for coin in normalized_coins
+            for interval in normalized_intervals
+        }
+        if self.expected_pairs:
+            print(
+                f"[AUTO] Startup candle backfill tracking {len(self.expected_pairs)} "
+                f"coin/interval pair(s) before auto entries are allowed."
+            )
+
+    def begin_iteration(self) -> None:
+        if not self.enabled or self.complete:
+            return
+        self.saw_rate_limit_this_iteration = False
+
+    def finish_iteration(self) -> None:
+        if (
+            not self.enabled
+            or self.complete
+            or self.saw_rate_limit_this_iteration
+            or not self.pause_between_batches
+        ):
+            return
+        self.complete = True
+        print(
+            "[AUTO] Startup candle backfill gating cleared after a full scan iteration "
+            "completed without rate limits; auto entries are now enabled."
+        )
+
+    def register_pending(self, coin: str, interval: str) -> None:
+        if not self.enabled or self.complete:
+            return
+        pair = (str(coin).upper(), str(interval))
+        if self.expected_pairs and pair not in self.expected_pairs:
+            return
+        self.pending_pairs.add(pair)
+
+    def mark_success(self, coin: str, interval: str) -> None:
+        if not self.enabled or self.complete:
+            return
+        pair = (str(coin).upper(), str(interval))
+        self.pending_pairs.discard(pair)
+        if self.expected_pairs and pair in self.expected_pairs:
+            self.successful_pairs.add(pair)
+        self._refresh_completion()
+
+    def mark_non_rate_limit_failure(self, coin: str, interval: str) -> None:
+        if not self.enabled or self.complete:
+            return
+        pair = (str(coin).upper(), str(interval))
+        self.pending_pairs.discard(pair)
+
+    def mark_market_unusable(self, coin: str, reason: str = "") -> None:
+        if not self.enabled or self.complete:
+            return
+        normalized_coin = str(coin).upper()
+        first_exclusion = normalized_coin not in self.excluded_coins
+        self.excluded_coins.add(normalized_coin)
+
+        if self.expected_pairs:
+            matching_pairs = {pair for pair in self.expected_pairs if pair[0] == normalized_coin}
+            self.pending_pairs.difference_update(matching_pairs)
+            self.ignored_pairs.update(matching_pairs)
+
+        if first_exclusion:
+            suffix = f": {reason}" if reason else ""
+            print(
+                f"[AUTO] Excluding {normalized_coin} from auto scans after non-rate-limit candle failure{suffix}"
+            )
+        self._refresh_completion()
+
+    def is_coin_excluded(self, coin: str) -> bool:
+        return str(coin).upper() in (self.excluded_coins or set())
+
+    def mark_rate_limit(self) -> None:
+        if not self.enabled or self.complete:
+            return
+        self.saw_rate_limit_this_iteration = True
+        if not self.pause_between_batches:
+            print(
+                f"[AUTO] Initial REST candle backfill hit rate limits; pausing "
+                f"{self.pause_seconds:.1f}s between scan batches until startup backfill finishes."
+            )
+        self.pause_between_batches = True
+
+    @property
+    def remaining_pairs(self) -> int:
+        if not self.enabled or self.complete:
+            return 0
+        completed_pairs = (self.successful_pairs or set()) | (self.ignored_pairs or set())
+        return max(0, len(self.expected_pairs or set()) - len(completed_pairs))
+
+
 def now_ms() -> int:
     return int(time.time() * 1000)
 
@@ -1228,6 +1364,19 @@ def last_finite_index(*arrays: Any) -> int:
     raise RuntimeError("No finite TA-Lib indicator row is available yet; fetch more candles.")
 
 
+def is_unknown_market_error(exc: BaseException, coin: str) -> bool:
+    """Return True when the candle fetch failed because the market key does not exist."""
+    normalized_coin = str(coin).upper()
+    if isinstance(exc, KeyError):
+        return str(exc).strip("'").upper() == normalized_coin
+    for arg in getattr(exc, "args", ()):
+        if isinstance(arg, KeyError) and str(arg).strip("'").upper() == normalized_coin:
+            return True
+        if isinstance(arg, str) and arg.strip("'").upper() == normalized_coin:
+            return True
+    return False
+
+
 async def compute_auto_interval_signal(
     info: Info,
     coin: str,
@@ -1244,6 +1393,7 @@ async def compute_auto_interval_signal(
     bb_dev: float,
     use_last_closed_candle: bool,
     use_websocket_candles: bool = False,
+    startup_backfill_state: Optional[AutoStartupBackfillState] = None,
 ) -> AutoIntervalSignal:
     """Fetch candles for one interval and compute MACD/SAR/ADX/Bollinger signal state."""
     require_talib_available()
@@ -1252,13 +1402,26 @@ async def compute_auto_interval_signal(
         raise RuntimeError(f"--auto-periods must be at least {minimum_periods} for the chosen indicator settings.")
     # TODO: Determine - is it possible to retrieve candles for multiple coins with one API call? Or is this data \
     # TODO: that is available over the websocket?
-    candles = await fetch_recent_candles(
-        info,
-        coin,
-        interval,
-        periods,
-        use_websocket_candles=use_websocket_candles,
-    )
+    if startup_backfill_state is not None:
+        startup_backfill_state.register_pending(coin, interval)
+    try:
+        candles = await fetch_recent_candles(
+            info,
+            coin,
+            interval,
+            periods,
+            use_websocket_candles=use_websocket_candles,
+        )
+    except Exception as exc:
+        if startup_backfill_state is not None:
+            if is_rate_limit_error(exc):
+                startup_backfill_state.mark_rate_limit()
+            else:
+                startup_backfill_state.mark_non_rate_limit_failure(coin, interval)
+        raise
+    else:
+        if startup_backfill_state is not None:
+            startup_backfill_state.mark_success(coin, interval)
     usable_candles = candles[:-1] if use_last_closed_candle and len(candles) > 1 else candles
 
     highs: List[float] = []
@@ -1391,6 +1554,7 @@ async def evaluate_auto_trade_decision(
     use_sar_stop_on_shortest_interval: bool,
     use_websocket_candles: bool = False,
     current_px: Optional[float] = None,
+    startup_backfill_state: Optional[AutoStartupBackfillState] = None,
 ) -> AutoTradeDecision:
     """Evaluate all configured intervals and return an aggregated trade decision."""
     snapshots: List[AutoIntervalSignal] = []
@@ -1414,11 +1578,18 @@ async def evaluate_auto_trade_decision(
                     bb_dev=bb_dev,
                     use_last_closed_candle=use_last_closed_candle,
                     use_websocket_candles=use_websocket_candles,
+                    startup_backfill_state=startup_backfill_state,
                 )
             )
         except Exception as exc:
             errors.append(f"{interval}: {exc}")
             cp.warning(f"[AUTO-WARN] Failed to compute signal for {coin} {interval}: {exc}")
+            if startup_backfill_state is not None and is_unknown_market_error(exc, coin):
+                startup_backfill_state.mark_market_unusable(coin, str(exc))
+                break
+            if startup_backfill_state is not None and is_rate_limit_error(exc):
+                await asyncio.sleep(startup_backfill_state.pause_seconds)
+
 
     if not snapshots:
         return AutoTradeDecision(
@@ -1585,6 +1756,7 @@ async def scan_auto_trade_candidate(
     use_sar_stop_on_shortest_interval: bool,
     snapshot: AutoScanLoopSnapshot,
     use_websocket_candles: bool = False,
+    startup_backfill_state: Optional[AutoStartupBackfillState] = None,
 ) -> AutoScanCandidate:
     """Scan one market using shared loop snapshots to avoid redundant REST calls."""
     existing_pos = snapshot.positions_by_coin.get(scan_coin.upper())
@@ -1614,6 +1786,7 @@ async def scan_auto_trade_candidate(
         use_sar_stop_on_shortest_interval=use_sar_stop_on_shortest_interval,
         use_websocket_candles=use_websocket_candles,
         current_px=snapshot.mids.get(scan_coin.upper()),
+        startup_backfill_state=startup_backfill_state,
     )
     print_auto_decision(decision, scan_coin)
 
@@ -1785,7 +1958,9 @@ async def run_auto_trader(
     if not owns_clients and (account_address is None or info is None or exchange is None):
         raise RuntimeError("Pass account_address, info, and exchange together when reusing initialized clients.")
     completed_trades = 0
+    _iter = 0
     auto_trades_logger = get_auto_trades_logger()
+    startup_backfill_state = AutoStartupBackfillState(enabled=True)
 
     try:
         if owns_clients:
@@ -2044,7 +2219,18 @@ async def run_auto_trader(
                     stop_requested = True
                     stop_reason = f"completed {completed_trades} trade(s) and auto looping is disabled"
 
+        async def _sleep_until_next_scan_batch() -> None:
+            if startup_backfill_state.enabled and startup_backfill_state.pause_between_batches and not startup_backfill_state.complete:
+                print(
+                    f"[AUTO] Startup REST candle backfill still in progress; "
+                    f"sleeping {startup_backfill_state.pause_seconds:.1f}s before the normal scan interval."
+                )
+                await asyncio.sleep(startup_backfill_state.pause_seconds)
+            else:
+                await asyncio.sleep(scan_interval)
+
         while True:
+            _iter +=1
             await _drain_completed_trade_tasks()
             if stop_requested:
                 if active_trade_tasks:
@@ -2115,6 +2301,20 @@ async def run_auto_trader(
                 await asyncio.sleep(scan_interval)
                 continue
 
+            if startup_backfill_state.enabled:
+                eligible_scan_coins = [
+                    scan_coin
+                    for scan_coin in eligible_scan_coins
+                    if not startup_backfill_state.is_coin_excluded(scan_coin)
+                ]
+                if not eligible_scan_coins:
+                    print("[AUTO] All scan candidates were excluded after non-rate-limit candle backfill failures.")
+                    await asyncio.sleep(scan_interval)
+                    continue
+
+            startup_backfill_state.set_expected_pairs(eligible_scan_coins, intervals)
+            startup_backfill_state.begin_iteration()
+
             shared_snapshot = await build_auto_scan_loop_snapshot(
                 info=info,
                 account_address=account_address,
@@ -2130,7 +2330,8 @@ async def run_auto_trader(
                 await asyncio.sleep(scan_interval)
                 continue
 
-            scan_concurrency = min(max_concurrent_scans, max(1, len(eligible_scan_coins)))
+            #scan_concurrency = min(max_concurrent_scans, max(1, len(eligible_scan_coins)))
+            scan_concurrency = max(1, max_concurrent_scans)
             scan_semaphore = asyncio.Semaphore(scan_concurrency)
 
             async def _scan_with_limit(scan_coin: str) -> AutoScanCandidate:
@@ -2159,6 +2360,7 @@ async def run_auto_trader(
                         use_sar_stop_on_shortest_interval=use_sar_stop_on_shortest_interval,
                         snapshot=shared_snapshot,
                         use_websocket_candles=use_websocket_candles,
+                        startup_backfill_state=startup_backfill_state,
                     )
 
             scan_tasks = [asyncio.create_task(_scan_with_limit(scan_coin)) for scan_coin in eligible_scan_coins]
@@ -2213,16 +2415,26 @@ async def run_auto_trader(
                 logger.error(exc)
 
             await asyncio.gather(*scan_tasks, return_exceptions=True)
+            startup_backfill_state.finish_iteration()
+
+            if startup_backfill_state.enabled and not startup_backfill_state.complete:
+                print(
+                    f"[AUTO] Startup candle backfill still in progress; "
+                    f"blocking entries until {startup_backfill_state.remaining_pairs} "
+                    f"coin/interval pair(s) finish loading."
+                )
+                await _sleep_until_next_scan_batch()
+                continue
 
             if not launch_specs:
-                print('=' * 40 + f'Sleeping {scan_interval} seconds .. ' + '=' * 40)
-                await asyncio.sleep(scan_interval)
+                print('=' * 40 + f'Iteration: {_iter}, sleeping {scan_interval} seconds (--scan-interval).' + '=' * 40)
+                await _sleep_until_next_scan_batch()
                 continue
 
             if dry_run:
                 for launch_coin, _launch_decision, _launch_size in launch_specs:
                     print(f"[AUTO] Dry run enabled; {launch_coin} signal will not be traded.")
-                await asyncio.sleep(scan_interval)
+                await _sleep_until_next_scan_batch()
                 continue
 
             for launch_coin, launch_decision, launch_size in launch_specs:
@@ -2256,7 +2468,7 @@ async def run_auto_trader(
                 )
 
             metrics_start_time_ms = int(time.time() * 1000)
-            await asyncio.sleep(scan_interval)
+            await _sleep_until_next_scan_batch()
     except KeyboardInterrupt:
         print("\n[!] Caught Ctrl+C, stopping auto trader.")
     finally:

{hypertrader-0.1.1 → hypertrader-0.1.3}/setup.py

@@ -9,7 +9,7 @@ README = ROOT / "README.md"
 
 setup(
     name="hypertrader",
-    version="0.1.1",
+    version="0.1.3",
     description="Async Hyperliquid trading helper built on the async SDK.",
     long_description=README.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
@@ -26,6 +26,7 @@ setup(
         "hyperliquid-python-sdk-async",
         "python-dotenv",
         "uvloop",
+        "colored",
     ],
     extras_require={
         "auto": [
@@ -36,6 +37,7 @@ setup(
     entry_points={
         "console_scripts": [
             "hypertrader=hypertrader:main",
+            "ht=hypertrader:main",
         ],
     },
     classifiers=[

{hypertrader-0.1.1 → hypertrader-0.1.3}/utils/helpers.py

@@ -611,7 +611,7 @@ async def get_open_orders_for_coin(info: Info, account_address: str, coin: str)
 def is_rate_limit_error(exc: BaseException) -> bool:
     """Return True when the SDK surfaced a 429/rate-limit style response."""
     for arg in getattr(exc, "args", ()):
-        if arg == 429:
+        if str(arg) == '429':
             return True
         if isinstance(arg, str) and "429" in arg:
             return True