walrasquant-lib 0.4.28__tar.gz → 0.5.0__tar.gz

{walrasquant_lib-0.4.28 → walrasquant_lib-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.4.28
+Version: 0.5.0
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>

{walrasquant_lib-0.4.28 → walrasquant_lib-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.4.28"
+version = "0.5.0"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}

walrasquant_lib-0.5.0/src/walrasquant/base/connector.py

@@ -0,0 +1,448 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Literal, Mapping
+import inspect
+import nexuslog as logging
+
+from walrasquant.base.oms import OrderManagementSystem
+from walrasquant.base.ws_client import WSClient
+from walrasquant.base.api_client import ApiClient
+from walrasquant.aggregation import (
+    KlineAggregator,
+    TimeKlineAggregator,
+    VolumeKlineAggregator,
+)
+from walrasquant.schema import (
+    BaseMarket,
+    KlineList,
+    Ticker,
+    Trade,
+)
+from walrasquant.constants import ExchangeType, AccountType
+from walrasquant.core.entity import TaskManager
+from walrasquant.constants import (
+    KlineInterval,
+    BookLevel,
+)
+from walrasquant.core.nautilius_core import LiveClock, MessageBus
+
+
+class ApiProxy:
+    def __init__(self, api_client: ApiClient, task_manager: TaskManager):
+        self._api_client = api_client
+        self._task_manager = task_manager
+
+    def __getattr__(self, name):
+        if not hasattr(self._api_client, name):
+            raise AttributeError(f"ApiClient has no attribute '{name}'")
+
+        api_method = getattr(self._api_client, name)
+        if not callable(api_method):
+            return api_method
+
+        # check whether the method is async
+        if not inspect.iscoroutinefunction(api_method):
+            return api_method
+
+        def sync_wrapper(*args, **kwargs):
+            return self._task_manager.run_sync(api_method(*args, **kwargs))
+
+        return sync_wrapper
+
+
+class FireApiProxy:
+    """Fire-and-forget proxy: submits async REST calls as background tasks, no return value."""
+
+    def __init__(self, api_client: ApiClient, task_manager: TaskManager):
+        self._api_client = api_client
+        self._task_manager = task_manager
+
+    def __getattr__(self, name):
+        if not hasattr(self._api_client, name):
+            raise AttributeError(f"ApiClient has no attribute '{name}'")
+
+        api_method = getattr(self._api_client, name)
+        if not inspect.iscoroutinefunction(api_method):
+            return api_method
+
+        def fire_wrapper(*args, **kwargs):
+            self._task_manager.create_task(api_method(*args, **kwargs))
+
+        return fire_wrapper
+
+
+class PublicConnector(ABC):
+    def __init__(
+        self,
+        account_type: AccountType,
+        market: Mapping[str, BaseMarket],
+        market_id: Dict[str, str],
+        exchange_id: ExchangeType,
+        ws_client: WSClient,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        api_client: ApiClient,
+        task_manager: TaskManager,
+    ):
+        self._log = logging.getLogger(name=type(self).__name__)
+        self._account_type = account_type
+        self._market = market
+        self._market_id = market_id
+        self._exchange_id = exchange_id
+        self._ws_client = ws_client
+        self._msgbus = msgbus
+        self._api_client = api_client
+        self._clock = clock
+        self._task_manager = task_manager
+
+        # Aggregator management - key: symbol, value: list of aggregators
+        self._aggregators: Dict[str, List[KlineAggregator]] = {}
+        self._msgbus.subscribe(
+            topic="trade", handler=self._handle_trade_for_aggregators
+        )
+
+    @property
+    def account_type(self):
+        return self._account_type
+
+    @abstractmethod
+    async def request_klines(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> KlineList:
+        """Request klines"""
+        pass
+
+    @abstractmethod
+    async def request_ticker(
+        self,
+        symbol: str,
+    ) -> Ticker:
+        """Request 24hr ticker data"""
+        pass
+
+    @abstractmethod
+    async def request_all_tickers(
+        self,
+    ) -> Dict[str, Ticker]:
+        """Request 24hr ticker data for multiple symbols"""
+        pass
+
+    @abstractmethod
+    async def request_index_klines(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> KlineList:
+        """Request index klines"""
+        pass
+
+    @abstractmethod
+    def subscribe_trade(self, symbol: str | List[str]):
+        """Subscribe to the trade data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_trade(self, symbol: str | List[str]):
+        """Unsubscribe from the trade data"""
+        pass
+
+    @abstractmethod
+    def subscribe_bookl1(self, symbol: str | List[str]):
+        """Subscribe to the bookl1 data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_bookl1(self, symbol: str | List[str]):
+        """Unsubscribe from the bookl1 data"""
+        pass
+
+    @abstractmethod
+    def subscribe_kline(
+        self,
+        symbol: str | List[str],
+        interval: KlineInterval,
+    ):
+        """Subscribe to the kline data
+
+        Args:
+            symbol: Symbol(s) to subscribe to
+            interval: Kline interval
+            use_aggregator: If True, use TimeKlineAggregator instead of exchange native klines
+        """
+        pass
+
+    @abstractmethod
+    def unsubscribe_kline(
+        self,
+        symbol: str | List[str],
+        interval: KlineInterval,
+    ):
+        """Unsubscribe from the kline data"""
+        pass
+
+    def subscribe_kline_aggregator(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        build_with_no_updates: bool,
+    ):
+        """Subscribe to time-based kline data using TimeKlineAggregator
+
+        Args:
+            symbol: Symbol to subscribe to
+            interval: Kline interval
+        """
+        # Ensure trade subscription for the symbol
+        self.subscribe_trade(symbol)
+
+        # Create and register time kline aggregator
+        aggregator = self._create_time_kline_aggregator(
+            symbol, interval, build_with_no_updates
+        )
+        self._add_aggregator(symbol, aggregator)
+
+        self._log.info(
+            "Time kline aggregator created for %s with interval %s", symbol, interval
+        )
+
+    def unsubscribe_kline_aggregator(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+    ):
+        """Unsubscribe from time-based kline data using TimeKlineAggregator
+
+        Args:
+            symbol: Symbol to unsubscribe from
+            interval: Kline interval
+        """
+        aggregators = self._aggregators.get(symbol, [])
+        # Create a copy to avoid "list changed size during iteration" error
+        for aggregator in aggregators.copy():
+            if (
+                isinstance(aggregator, TimeKlineAggregator)
+                and aggregator.interval == interval
+            ):
+                aggregator.stop()
+                aggregators.remove(aggregator)
+                self._log.info(
+                    "Time kline aggregator stopped for %s with interval %s",
+                    symbol,
+                    interval,
+                )
+        if not aggregators:
+            self._aggregators.pop(symbol, None)
+            self.unsubscribe_trade(symbol)
+
+    def subscribe_volume_kline_aggregator(
+        self,
+        symbol: str,
+        volume_threshold: float,
+        volume_type: Literal["BUY", "SELL", "DEFAULT"],
+    ):
+        """Subscribe to volume-based kline data using VolumeKlineAggregator
+
+        Args:
+            symbol: Symbol to subscribe to
+            volume_threshold: Volume threshold for creating new klines
+        """
+        # Ensure trade subscription for the symbol
+        self.subscribe_trade(symbol)
+
+        # Create and register volume kline aggregator
+        aggregator = self._create_volume_kline_aggregator(
+            symbol, volume_threshold, volume_type
+        )
+        self._add_aggregator(symbol, aggregator)
+
+        self._log.info(
+            "Volume kline aggregator created for %s with threshold %s and type %s",
+            symbol,
+            volume_threshold,
+            volume_type,
+        )
+
+    def unsubscribe_volume_kline_aggregator(
+        self, symbol: str, volume_threshold: float, volume_type: str
+    ):
+        """Unsubscribe from volume-based kline data using VolumeKlineAggregator
+
+        Args:
+            symbol: Symbol to unsubscribe from
+            volume_threshold: Volume threshold for the kline aggregator
+        """
+        aggregators = self._aggregators.get(symbol, [])
+        # Create a copy to avoid "list changed size during iteration" error
+        for aggregator in aggregators.copy():
+            if (
+                isinstance(aggregator, VolumeKlineAggregator)
+                and aggregator.volume_threshold == volume_threshold
+            ):
+                aggregators.remove(aggregator)
+                self._log.info(
+                    "Volume kline aggregator stopped for %s with threshold %s and type %s",
+                    symbol,
+                    volume_threshold,
+                    volume_type,
+                )
+        if not aggregators:
+            self._aggregators.pop(symbol, None)
+            self.unsubscribe_trade(symbol)
+
+    @abstractmethod
+    def subscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
+        """Subscribe to the bookl2 data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
+        """Unsubscribe from the bookl2 data"""
+        pass
+
+    @abstractmethod
+    def subscribe_funding_rate(self, symbol: str | List[str]):
+        """Subscribe to the funding rate data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_funding_rate(self, symbol: str | List[str]):
+        """Unsubscribe from the funding rate data"""
+        pass
+
+    @abstractmethod
+    def subscribe_index_price(self, symbol: str | List[str]):
+        """Subscribe to the index price data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_index_price(self, symbol: str | List[str]):
+        """Unsubscribe from the index price data"""
+        pass
+
+    @abstractmethod
+    def subscribe_mark_price(self, symbol: str | List[str]):
+        """Subscribe to the mark price data"""
+        pass
+
+    @abstractmethod
+    def unsubscribe_mark_price(self, symbol: str | List[str]):
+        """Unsubscribe from the mark price data"""
+        pass
+
+    def _create_time_kline_aggregator(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        build_with_no_updates: bool,
+    ) -> TimeKlineAggregator:
+        """Create a time-based kline aggregator."""
+        return TimeKlineAggregator(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            interval=interval,
+            msgbus=self._msgbus,
+            clock=self._clock,
+            build_with_no_updates=build_with_no_updates,
+        )
+
+    def _create_volume_kline_aggregator(
+        self,
+        symbol: str,
+        volume_threshold: float,
+        volume_type: Literal["BUY", "SELL", "DEFAULT"],
+    ) -> VolumeKlineAggregator:
+        """Create a volume-based kline aggregator."""
+
+        return VolumeKlineAggregator(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            msgbus=self._msgbus,
+            volume_threshold=volume_threshold,
+            volume_type=volume_type,
+        )
+
+    def _add_aggregator(self, symbol: str, aggregator) -> None:
+        """Add an aggregator for a symbol."""
+        if symbol not in self._aggregators:
+            self._aggregators[symbol] = []
+        self._aggregators[symbol].append(aggregator)
+
+    def _handle_trade_for_aggregators(self, trade: Trade) -> None:
+        """Route trade data to all aggregators for this symbol."""
+        aggregators = self._aggregators.get(trade.symbol)
+        if aggregators:
+            for aggregator in aggregators:
+                aggregator.handle_trade(trade)
+
+    async def connect(self):
+        """Connect to the exchange"""
+        await self._ws_client.connect()
+
+    async def wait_ready(self):
+        """Wait for the initial WebSocket connection to be established"""
+        await self._ws_client.wait_ready()
+
+    async def disconnect(self):
+        """Disconnect from the exchange"""
+        # Stop all aggregators
+        for aggregators in self._aggregators.values():
+            for aggregator in aggregators:
+                if hasattr(aggregator, "stop"):
+                    aggregator.stop()  # type: ignore
+        self._aggregators.clear()
+
+        # NOTE: no need to manually disconnect ws_client here
+        # self._ws_client.disconnect()  # not needed to await
+        await self._api_client.close_session()
+
+
+class PrivateConnector(ABC):
+    def __init__(
+        self,
+        account_type: AccountType,
+        market: Mapping[str, BaseMarket],
+        api_client: ApiClient,
+        task_manager: TaskManager,
+        oms: OrderManagementSystem,
+    ):
+        self._log = logging.getLogger(name=type(self).__name__)
+        self._account_type = account_type
+        self._market = market
+        self._api_client = api_client
+        self._oms = oms
+        self._task_manager = task_manager
+        self._api_proxy = ApiProxy(self._api_client, self._task_manager)
+        self._api_fire_proxy = FireApiProxy(self._api_client, self._task_manager)
+
+    @property
+    def account_type(self):
+        return self._account_type
+
+    @property
+    def api(self):
+        return self._api_proxy
+
+    @property
+    def api_fire(self):
+        return self._api_fire_proxy
+
+    @abstractmethod
+    async def connect(self):
+        """Connect to the exchange"""
+        pass
+
+    async def wait_ready(self):
+        """Wait for the OMS WebSocket client(s) to be ready"""
+        await self._oms.wait_ready()
+
+    async def disconnect(self):
+        """Disconnect from the exchange"""
+        # self._oms._ws_client.disconnect() # not needed to await
+        await self._api_client.close_session()