Qubx 0.6.71__tar.gz → 0.6.72__tar.gz

{qubx-0.6.71 → qubx-0.6.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.71
+Version: 0.6.72
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.71 → qubx-0.6.72}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.71"
+version = "0.6.72"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.71 → qubx-0.6.72}/src/qubx/backtester/runner.py

@@ -4,10 +4,9 @@ import numpy as np
 import pandas as pd
 from tqdm.auto import tqdm
 
-from qubx import logger
+from qubx import QubxLogConfig, logger
 from qubx.backtester.sentinels import NoDataContinue
 from qubx.backtester.simulated_data import IterableSimulationData
-from qubx.backtester.utils import SimulationDataConfig, TimeGuardedWrapper
 from qubx.core.account import CompositeAccountProcessor
 from qubx.core.basics import SW, DataType, Instrument, TransactionCostsCalculator
 from qubx.core.context import StrategyContext
@@ -41,6 +40,7 @@ from .utils import (
     SimulatedTimeProvider,
     SimulationDataConfig,
     SimulationSetup,
+    TimeGuardedWrapper,
 )
 
 
@@ -356,8 +356,9 @@ class SimulationRunner:
         return False  # No scheduled events, stop simulation
 
     def print_latency_report(self) -> None:
-        _l_r = SW.latency_report()
-        if _l_r is not None:
+        if (_l_r := SW.latency_report()) is not None:
+            _llvl = QubxLogConfig.get_log_level()
+            QubxLogConfig.set_log_level("INFO")
             logger.info(
                 "<BLUE>   Time spent in simulation report   </BLUE>\n<r>"
                 + _frame_to_str(
@@ -365,6 +366,7 @@ class SimulationRunner:
                 )
                 + "</r>"
             )
+            QubxLogConfig.set_log_level(_llvl)
 
     def _create_backtest_context(self) -> IStrategyContext:
         logger.debug(

qubx-0.6.72/src/qubx/connectors/ccxt/adapters/polling_adapter.py

@@ -0,0 +1,250 @@
+"""
+Simplified polling adapter to convert CCXT fetch_* methods into watch_* behavior.
+
+This adapter provides a much simpler approach:
+- No background tasks or queues
+- get_next_data() waits until it's time to poll, then polls synchronously
+- Time-aligned polling (e.g., 11:30, 11:35, 11:40 for 5-minute intervals)
+- Immediate polling when symbols change
+"""
+
+import asyncio
+import math
+import time
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Set
+
+from qubx import logger
+
+# Constants
+DEFAULT_POLL_INTERVAL = 300  # 5 minutes
+MIN_POLL_INTERVAL = 1  # 1 second minimum
+MAX_POLL_INTERVAL = 3600  # 1 hour maximum
+
+
+@dataclass
+class PollingConfig:
+    """Configuration for polling adapter."""
+
+    poll_interval_seconds: float = DEFAULT_POLL_INTERVAL
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not MIN_POLL_INTERVAL <= self.poll_interval_seconds <= MAX_POLL_INTERVAL:
+            raise ValueError(
+                f"poll_interval_seconds must be between {MIN_POLL_INTERVAL} and {MAX_POLL_INTERVAL}, "
+                f"got {self.poll_interval_seconds}"
+            )
+
+
+class PollingToWebSocketAdapter:
+    """
+    Simplified polling adapter that polls synchronously when data is requested.
+
+    Key features:
+    - No background tasks or queues
+    - Time-aligned polling (respects clock boundaries)
+    - Immediate polling when symbols change
+    - Thread-safe symbol management
+    """
+
+    def __init__(
+        self,
+        fetch_method: Callable,
+        symbols: Optional[List[str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        config: Optional[PollingConfig] = None,
+    ):
+        """
+        Initialize the simplified polling adapter.
+
+        Args:
+            fetch_method: The CCXT fetch_* method to call
+            symbols: Initial list of symbols to watch
+            params: Additional parameters for fetch_method
+            config: PollingConfig instance (uses default if None)
+        """
+        self.config = config if config is not None else PollingConfig()
+        self.fetch_method = fetch_method
+        self.params = params or {}
+        self.adapter_id = f"polling_adapter_{id(self)}"
+
+        # Thread-safe symbol management
+        self._symbols_lock = asyncio.Lock()
+        self._symbols: Set[str] = set(symbols or [])
+
+        # Polling state
+        self._last_poll_time: Optional[float] = None
+        self._symbols_changed = False  # Flag to trigger immediate poll
+
+        # Statistics
+        self._poll_count = 0
+        self._error_count = 0
+
+    async def get_next_data(self) -> Dict[str, Any]:
+        """
+        Get the next available data by waiting until it's time to poll, then polling.
+
+        This method:
+        1. Checks if symbols changed (immediate poll)
+        2. Calculates when next poll should happen based on time alignment
+        3. Waits until that time
+        4. Polls and returns fresh data
+
+        Returns:
+            Dictionary containing fetched data for symbols
+        """
+        async with self._symbols_lock:
+            current_symbols = list(self._symbols)
+            symbols_changed = self._symbols_changed
+
+        if not current_symbols:
+            raise ValueError(f"No symbols configured for adapter {self.adapter_id}")
+
+        # If symbols changed, poll immediately
+        if symbols_changed:
+            logger.debug(f"Symbols changed, polling immediately for adapter {self.adapter_id}")
+            async with self._symbols_lock:
+                self._symbols_changed = False
+            return await self._poll_now(current_symbols)
+
+        # Calculate wait time for next aligned poll
+        wait_time = self._calculate_wait_time()
+
+        if wait_time > 0:
+            logger.debug(f"Waiting {wait_time:.1f}s for next poll cycle for adapter {self.adapter_id}")
+            await asyncio.sleep(wait_time)
+
+        # Time to poll
+        logger.debug(f"Polling now for adapter {self.adapter_id}")
+        return await self._poll_now(current_symbols)
+
+    def _calculate_wait_time(self) -> float:
+        """
+        Calculate how long to wait until the next aligned poll time.
+
+        For intervals >= 1 minute: aligns to clock boundaries (11:30, 11:35, 11:40)
+        For intervals < 1 minute: uses simple interval-based timing
+
+        Returns:
+            Number of seconds to wait (0 if should poll now)
+        """
+        current_time = time.time()
+        interval_seconds = self.config.poll_interval_seconds
+
+        # First poll is always immediate
+        if self._last_poll_time is None:
+            return 0
+
+        if interval_seconds >= 60:
+            # Time-aligned polling for intervals >= 1 minute using UTC
+            # Calculate next boundary based on seconds since epoch
+            next_boundary = math.ceil(current_time / interval_seconds) * interval_seconds
+            wait_time = next_boundary - current_time
+            return max(0, wait_time)
+        else:
+            # Simple interval-based polling for sub-minute intervals
+            next_poll_time = self._last_poll_time + interval_seconds
+            wait_time = next_poll_time - current_time
+            return max(0, wait_time)
+
+    async def _poll_now(self, symbols: List[str]) -> Dict[str, Any]:
+        """
+        Perform a poll operation immediately.
+
+        Args:
+            symbols: List of symbols to poll for
+
+        Returns:
+            Dictionary containing fetched data for symbols
+        """
+        self._poll_count += 1
+        self._last_poll_time = time.time()
+
+        logger.debug(f"Polling {len(symbols)} symbols for adapter {self.adapter_id}")
+
+        try:
+            # Filter out adapter-specific parameters
+            adapter_params = {"pollInterval", "interval", "updateInterval", "poll_interval_minutes"}
+            fetch_params = {k: v for k, v in self.params.items() if k not in adapter_params}
+
+            # Call the fetch method
+            result = await self.fetch_method(symbols, **fetch_params)
+
+            logger.debug(f"Poll completed successfully for adapter {self.adapter_id}")
+            return result
+
+        except Exception as e:
+            self._error_count += 1
+            logger.error(f"Poll failed for adapter {self.adapter_id}: {e}")
+            raise
+
+    async def update_symbols(self, new_symbols: List[str]) -> None:
+        """
+        Update the symbol list.
+
+        If symbols changed, the next call to get_next_data() will poll immediately.
+
+        Args:
+            new_symbols: New complete list of symbols to watch
+        """
+        async with self._symbols_lock:
+            old_symbols = self._symbols.copy()
+            self._symbols = set(new_symbols or [])
+            symbols_changed = old_symbols != self._symbols
+
+            if symbols_changed:
+                self._symbols_changed = True
+                logger.debug(
+                    f"Symbols updated for adapter {self.adapter_id}: {len(old_symbols)} -> {len(self._symbols)}"
+                )
+
+    async def add_symbols(self, new_symbols: List[str]) -> None:
+        """Add symbols to the existing watch list."""
+        if not new_symbols:
+            return
+
+        async with self._symbols_lock:
+            before_count = len(self._symbols)
+            self._symbols.update(new_symbols)
+            after_count = len(self._symbols)
+
+            if after_count > before_count:
+                self._symbols_changed = True
+                logger.debug(f"Added {after_count - before_count} symbols to adapter {self.adapter_id}")
+
+    async def remove_symbols(self, symbols_to_remove: List[str]) -> None:
+        """Remove symbols from the watch list."""
+        if not symbols_to_remove:
+            return
+
+        async with self._symbols_lock:
+            before_count = len(self._symbols)
+            self._symbols.difference_update(symbols_to_remove)
+            after_count = len(self._symbols)
+
+            if after_count < before_count:
+                self._symbols_changed = True
+                logger.debug(f"Removed {before_count - after_count} symbols from adapter {self.adapter_id}")
+
+    def is_watching(self, symbol: Optional[str] = None) -> bool:
+        """Check if adapter has symbols configured to watch."""
+        if symbol is None:
+            return len(self._symbols) > 0
+        else:
+            return symbol in self._symbols
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get adapter statistics for monitoring."""
+        return {
+            "adapter_id": self.adapter_id,
+            "symbol_count": len(self._symbols),
+            "poll_count": self._poll_count,
+            "error_count": self._error_count,
+            "last_poll_time": self._last_poll_time,
+            "poll_interval_seconds": self.config.poll_interval_seconds,
+        }
+
+    async def stop(self) -> None:
+        """Stop the adapter (cleanup method for compatibility)."""
+        logger.debug(f"Adapter {self.adapter_id} stopped (polled {self._poll_count} times, {self._error_count} errors)")

{qubx-0.6.71 → qubx-0.6.72}/src/qubx/connectors/ccxt/exchanges/__init__.py

@@ -2,6 +2,7 @@
 This module contains the CCXT connectors for the exchanges.
 """
 
+from dataclasses import dataclass
 from functools import partial
 
 import ccxt.pro as cxp
@@ -11,9 +12,21 @@ from .binance.broker import BinanceCcxtBroker
 from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
 from .bitfinex.bitfinex import BitfinexF
 from .bitfinex.bitfinex_account import BitfinexAccountProcessor
+from .hyperliquid.broker import HyperliquidCcxtBroker
 from .hyperliquid.hyperliquid import Hyperliquid, HyperliquidF
 from .kraken.kraken import CustomKrakenFutures
 
+
+@dataclass
+class ReaderCapabilities:
+    """Configuration for exchange-specific reader capabilities."""
+
+    supports_bulk_funding: bool = True
+    supports_bulk_ohlcv: bool = True
+    max_symbols_per_request: int = 1000
+    default_funding_interval_hours: float = 8.0  # Default for most exchanges (Binance, etc.)
+
+
 EXCHANGE_ALIASES = {
     "binance": "binanceqv",
     "binance.um": "binanceqv_usdm",
@@ -32,12 +45,25 @@ CUSTOM_BROKERS = {
     "binance.cm": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
     "bitfinex.f": partial(CcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=True),
+    "hyperliquid": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "hyperliquid.f": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
 }
 
 CUSTOM_ACCOUNTS = {
     "bitfinex.f": BitfinexAccountProcessor,
 }
 
+READER_CAPABILITIES = {
+    "hyperliquid": ReaderCapabilities(
+        supports_bulk_funding=False,
+        default_funding_interval_hours=1.0  # Hyperliquid uses 1-hour funding
+    ),
+    "hyperliquid.f": ReaderCapabilities(
+        supports_bulk_funding=False,
+        default_funding_interval_hours=1.0  # Hyperliquid uses 1-hour funding
+    ),
+}
+
 cxp.binanceqv = BinanceQV  # type: ignore
 cxp.binanceqv_usdm = BinanceQVUSDM  # type: ignore
 cxp.binancepm = BinancePortfolioMargin  # type: ignore

{qubx-0.6.71 → qubx-0.6.72}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, cast
 
 import ccxt.pro as cxp
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
@@ -33,7 +33,7 @@ class BinanceQV(cxp.binance):
                     "watchTrades": {
                         "name": "aggTrade",
                     },
-                    "localOrderBookLimit": 10_000,  # set a large limit to avoid cutting off the orderbook
+                    "localOrderBookLimit": 50_000,  # set a large limit to avoid cutting off the orderbook
                 },
                 "exceptions": {
                     "exact": {
@@ -243,23 +243,23 @@ class BinanceQV(cxp.binance):
     def clean_stream_state(self, subscription: dict):
         """
         Clean up stream state mappings during unsubscription to prevent UnsubscribeError.
-        
+
         This fixes the root cause of bulk unsubscription failures by properly cleaning up
         stale stream mappings that cause state conflicts in CCXT.
         """
-        symbols = self.safe_list(subscription, 'symbols', [])
-        topic = self.safe_string(subscription, 'topic', '')
-        
+        symbols = self.safe_list(subscription, "symbols", [])
+        topic = self.safe_string(subscription, "topic", "")
+
         if topic and len(symbols) > 1:
             # Clean up bulk subscription stream mappings
             subscription_hash = f"multiple{topic.upper()}"
-            streamBySubscriptionsHash = self.safe_dict(self.options, 'streamBySubscriptionsHash', {})
+            streamBySubscriptionsHash = self.safe_dict(self.options, "streamBySubscriptionsHash", {})
             if subscription_hash in streamBySubscriptionsHash:
                 stream = streamBySubscriptionsHash[subscription_hash]
                 del streamBySubscriptionsHash[subscription_hash]
-                
+
                 # Clean up subscription counts to maintain accurate state
-                numSubscriptionsByStream = self.safe_dict(self.options, 'numSubscriptionsByStream', {})
+                numSubscriptionsByStream = self.safe_dict(self.options, "numSubscriptionsByStream", {})
                 if stream in numSubscriptionsByStream:
                     current_count = numSubscriptionsByStream[stream]
                     new_count = max(0, current_count - len(symbols))
@@ -267,11 +267,11 @@ class BinanceQV(cxp.binance):
                         del numSubscriptionsByStream[stream]
                     else:
                         numSubscriptionsByStream[stream] = new_count
-    
+
     def clean_cache(self, subscription: dict):
         """
         Override clean_cache to include stream state cleanup.
-        
+
         This ensures proper cleanup during unsubscription operations.
         """
         super().clean_cache(subscription)
@@ -280,94 +280,100 @@ class BinanceQV(cxp.binance):
     async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}):
         """
         Enhanced bulk OHLCV unsubscription with proper state validation and cleanup.
-        
+
         This override fixes UnsubscribeError issues by:
         1. Validating subscription state before attempting unsubscription
-        2. Filtering to only valid subscriptions  
+        2. Filtering to only valid subscriptions
         3. Implementing graceful error handling for state conflicts
         4. Forcing cleanup of remaining state on errors
         """
         await self.load_markets()
-        
+
         # Standard setup from parent class
-        type = 'spot'
+        type = "spot"
         marketType = None
         firstMarket = None
-        
+
         # Handle futures market detection
         if len(symbolsAndTimeframes) > 0:
             firstSymbol = symbolsAndTimeframes[0][0]
             firstMarket = self.market(firstSymbol)
-            marketType, params = self.handle_market_type_and_params('unWatchOHLCVForSymbols', firstMarket, params)
-            if marketType != 'spot':
-                type = 'future'
-        
+            marketType, params = self.handle_market_type_and_params("unWatchOHLCVForSymbols", firstMarket, params)
+            if marketType != "spot":
+                type = "future"
+
         # Build subscription hashes
         messageHashes = []
         subMessageHashes = []
         rawHashes = []
-        
+
         for symbolAndTimeframe in symbolsAndTimeframes:
             symbol = symbolAndTimeframe[0]
             timeframe = symbolAndTimeframe[1]
             market = self.market(symbol)
-            lowercaseId = market['lowercaseId']
+            lowercaseId = market["lowercaseId"]
             interval = self.timeframes[timeframe]
-            rawHash = lowercaseId + '@kline_' + interval
+            rawHash = lowercaseId + "@kline_" + interval
             rawHashes.append(rawHash)
-            messageHash = 'ohlcv:' + symbol + ':' + timeframe
+            messageHash = "ohlcv:" + symbol + ":" + timeframe
             messageHashes.append(messageHash)
             subMessageHashes.append(rawHash)
-        
+
         # Get client and validate subscription state BEFORE attempting unsubscription
-        url = self.urls['api']['ws'][type] + '/' + self.stream(type, 'multipleOHLCV')
+        url = self.urls["api"]["ws"][type] + "/" + self.stream(type, "multipleOHLCV")
         client = self.client(url)
-        
+
         # Filter to only valid subscriptions to prevent state conflicts
         valid_messageHashes = []
         valid_subMessageHashes = []
         valid_rawHashes = []
-        
+
         for i, subHash in enumerate(subMessageHashes):
             if subHash in client.subscriptions:
                 valid_messageHashes.append(messageHashes[i])
                 valid_subMessageHashes.append(subHash)
                 valid_rawHashes.append(rawHashes[i])
-        
+
         if not valid_messageHashes:
             # Nothing to unsubscribe - return success
             return True
-        
+
         # Build unsubscription request with only valid subscriptions
         requestId = self.request_id(url)
         request = {
-            'method': 'UNSUBSCRIBE',
-            'params': valid_rawHashes,
-            'id': requestId,
+            "method": "UNSUBSCRIBE",
+            "params": valid_rawHashes,
+            "id": requestId,
         }
-        
+
         subscription = {
-            'unsubscribe': True,
-            'id': str(requestId),
-            'subMessageHashes': valid_subMessageHashes,
-            'messageHashes': valid_messageHashes,
-            'symbols': [st[0] for st in symbolsAndTimeframes if st[0] in [sh.split('@')[0].upper() for sh in valid_subMessageHashes]],
-            'topic': 'ohlcv',
+            "unsubscribe": True,
+            "id": str(requestId),
+            "subMessageHashes": valid_subMessageHashes,
+            "messageHashes": valid_messageHashes,
+            "symbols": [
+                st[0]
+                for st in symbolsAndTimeframes
+                if st[0] in [sh.split("@")[0].upper() for sh in valid_subMessageHashes]
+            ],
+            "topic": "ohlcv",
         }
-        
+
         try:
             # Attempt unsubscription with validated state
-            return await self.watch_multiple(url, valid_messageHashes, self.extend(request, params), valid_messageHashes, subscription)
-            
+            return await self.watch_multiple(
+                url, valid_messageHashes, self.extend(request, params), valid_messageHashes, subscription
+            )
+
         except Exception as e:
             # Handle UnsubscribeError and other state conflicts gracefully
             from ccxt.base.errors import UnsubscribeError
-            
-            if isinstance(e, UnsubscribeError) or 'UnsubscribeError' in str(type(e)):
+
+            if isinstance(e, UnsubscribeError) or "UnsubscribeError" in str(type(e)):
                 # Log the issue but don't crash - force cleanup instead
-                if hasattr(self, 'logger'):
+                if hasattr(self, "logger"):
                     self.logger.warning(f"Bulk OHLCV unsubscription state conflict, forcing cleanup: {e}")
-                
+
                 # Force cleanup of remaining subscription state
                 for subHash in valid_subMessageHashes:
                     if subHash in client.subscriptions:
@@ -378,10 +384,10 @@ class BinanceQV(cxp.binance):
                         except:
                             pass
                         del client.futures[subHash]
-                
+
                 # Clean up our stream state as well
                 self.clean_stream_state(subscription)
-                
+
                 return True  # Return success after cleanup
             else:
                 # Re-raise other errors
@@ -418,32 +424,40 @@ class BinanceQVUSDM(cxp.binanceusdm, BinanceQV):
             },
         )
 
+    async def get_funding_interval_hours_for_symbol(self, symbol: str) -> float:
+        await self._update_funding_intervals()
+        return cast(float, self._funding_intervals.get(symbol, 8.0))
+
+    async def get_funding_interval_hours(self) -> dict[str, float]:
+        await self._update_funding_intervals()
+        return cast(dict[str, float], self._funding_intervals)
+
     async def watch_funding_rates(self, symbols: List[str] | None = None):
         symbol_count = len(symbols) if symbols else 0
-        
+
         try:
             await self.load_markets()
             await self._update_funding_intervals()
-            
+
             # Use watch_mark_prices which streams one symbol per WebSocket message
             # This is normal behavior - WebSocket messages contain one symbol at a time
             mark_prices = await self.watch_mark_prices(symbols)
-            
+
             if not mark_prices:
                 raise Exception("No mark price data received")
-            
+
             # Process whatever symbol(s) we received (usually 1 per WebSocket message)
             funding_rates = {}
             processed_count = 0
-            
+
             for symbol, info in mark_prices.items():
                 try:
                     interval = self._funding_intervals.get(symbol, "8h")
-                    
+
                     # Ensure we have the required fields for funding rate
                     if "info" not in info or "r" not in info["info"]:
                         continue
-                        
+
                     funding_rates[symbol] = {
                         "timestamp": info["timestamp"],
                         "interval": interval,
@@ -453,15 +467,15 @@ class BinanceQVUSDM(cxp.binanceusdm, BinanceQV):
                         "indexPrice": info["indexPrice"],
                     }
                     processed_count += 1
-                    
+
                 except Exception as e:
                     continue
-            
+
             if processed_count == 0:
                 raise Exception("No funding rates could be processed from mark price data")
-            
+
             return funding_rates
-            
+
         except Exception as e:
             raise
 
@@ -568,20 +582,21 @@ class BinanceQVUSDM(cxp.binanceusdm, BinanceQV):
     async def un_watch_funding_rates(self):
         """Unwatch funding rates to ensure fresh connections"""
         from qubx import logger
+
         logger.debug("un_watch_funding_rates called - resetting connection")
-        
+
         # Try to unwatch mark prices if possible
-        if hasattr(self, 'un_watch_mark_prices'):
+        if hasattr(self, "un_watch_mark_prices"):
             try:
                 await self.un_watch_mark_prices()
             except Exception as e:
                 logger.debug(f"Error unwatching mark prices: {e}")
-        
+
         # Clear any internal caches that might exist
-        if hasattr(self, 'markPrices') and self.markPrices:
+        if hasattr(self, "markPrices") and self.markPrices:
             self.markPrices.clear()
             logger.debug("Cleared mark prices cache")
-            
+
         return None
 
 

qubx-0.6.72/src/qubx/connectors/ccxt/exchanges/hyperliquid/__init__.py

@@ -0,0 +1,3 @@
+# Hyperliquid exchange overrides
+
+from .broker import HyperliquidCcxtBroker