unicex 0.13.17__py3-none-any.whl

unicex/binance/exchange_info.py

@@ -0,0 +1,62 @@
+__all__ = ["ExchangeInfo"]
+
+
+import aiohttp
+
+from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
+
+from .client import Client
+
+
+class ExchangeInfo(IExchangeInfo):
+    """Предзагружает информацию о тикерах для биржи Binance."""
+
+    exchange_name = "Binance"
+    """Название биржи, на которой работает класс."""
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        exchange_info = await Client(session).exchange_info()
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in exchange_info["symbols"]:
+            filters = {
+                flt["filterType"]: flt
+                for flt in symbol_info.get("filters", [])
+                if "filterType" in flt
+            }
+            price_filter = filters["PRICE_FILTER"]
+            lot_size_filter = filters["LOT_SIZE"]
+            tickers_info[symbol_info["symbol"]] = TickerInfoItem(
+                tick_step=float(price_filter["tickSize"]),
+                tick_precision=None,
+                size_step=float(lot_size_filter["stepSize"]),
+                size_precision=None,
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
+    @classmethod
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        exchange_info = await Client(session).futures_exchange_info()
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in exchange_info["symbols"]:
+            filters = {
+                flt["filterType"]: flt
+                for flt in symbol_info.get("filters", [])
+                if "filterType" in flt
+            }
+            price_filter = filters["PRICE_FILTER"]
+            lot_size_filter = filters["LOT_SIZE"]
+            tickers_info[symbol_info["symbol"]] = TickerInfoItem(
+                tick_step=float(price_filter["tickSize"]),
+                tick_precision=None,
+                size_step=float(lot_size_filter["stepSize"]),
+                size_precision=None,
+                contract_size=1,
+            )
+
+        cls._futures_tickers_info = tickers_info

unicex/binance/uni_client.py

@@ -0,0 +1,188 @@
+__all__ = ["UniClient"]
+
+
+from typing import overload
+
+from unicex._abc import IUniClient
+from unicex.enums import Exchange, MarketType, Timeframe
+from unicex.types import KlineDict, OpenInterestItem, TickerDailyDict
+
+from .adapter import Adapter
+from .client import Client
+
+
+class UniClient(IUniClient[Client]):
+    """Унифицированный клиент для работы с Binance API."""
+
+    @property
+    def _client_cls(self) -> type[Client]:
+        """Возвращает класс клиента для Binance.
+
+        Возвращает:
+            type[Client]: Класс клиента для Binance.
+        """
+        return Client
+
+    async def tickers(self, only_usdt: bool = True) -> list[str]:
+        """Возвращает список тикеров.
+
+        Параметры:
+            only_usdt (bool): Если True, возвращает только тикеры в паре к USDT.
+
+        Возвращает:
+            list[str]: Список тикеров.
+        """
+        raw_data = await self._client.ticker_price()
+        return Adapter.tickers(raw_data=raw_data, only_usdt=only_usdt)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def futures_tickers(self, only_usdt: bool = True) -> list[str]:
+        """Возвращает список тикеров.
+
+        Параметры:
+            only_usdt (bool): Если True, возвращает только тикеры в паре к USDT.
+
+        Возвращает:
+            list[str]: Список тикеров.
+        """
+        raw_data = await self._client.futures_ticker_price()
+        return Adapter.tickers(raw_data=raw_data, only_usdt=only_usdt)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def last_price(self) -> dict[str, float]:
+        """Возвращает последнюю цену для каждого тикера.
+
+        Возвращает:
+            dict[str, float]: Словарь с последними ценами для каждого тикера.
+        """
+        raw_data = await self._client.ticker_price()
+        return Adapter.last_price(raw_data)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def futures_last_price(self) -> dict[str, float]:
+        """Возвращает последнюю цену для каждого тикера.
+
+        Возвращает:
+            dict[str, float]: Словарь с последними ценами для каждого тикера.
+        """
+        raw_data = await self._client.futures_ticker_price()
+        return Adapter.last_price(raw_data)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def ticker_24hr(self) -> TickerDailyDict:
+        """Возвращает статистику за последние 24 часа для каждого тикера.
+
+        Возвращает:
+            TickerDailyDict: Словарь с статистикой за последние 24 часа для каждого тикера.
+        """
+        raw_data = await self._client.ticker_24hr()
+        return Adapter.ticker_24hr(raw_data=raw_data)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def futures_ticker_24hr(self) -> TickerDailyDict:
+        """Возвращает статистику за последние 24 часа для каждого тикера.
+
+        Возвращает:
+            TickerDailyDict: Словарь с статистикой за последние 24 часа для каждого тикера.
+        """
+        raw_data = await self._client.futures_ticker_24hr()
+        return Adapter.ticker_24hr(raw_data=raw_data)  # type: ignore | raw_data is list[dict] if symbol param is not ommited
+
+    async def klines(
+        self,
+        symbol: str,
+        interval: Timeframe | str,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> list[KlineDict]:
+        """Возвращает список свечей для тикера.
+
+        Параметры:
+            symbol (str): Название тикера.
+            limit (int | None): Количество свечей.
+            interval (Timeframe | str): Таймфрейм свечей.
+            start_time (int | None): Время начала периода в миллисекундах.
+            end_time (int | None): Время окончания периода в миллисекундах.
+
+        Возвращает:
+            list[KlineDict]: Список свечей для тикера.
+        """
+        interval = (
+            interval.to_exchange_format(Exchange.BINANCE, MarketType.SPOT)
+            if isinstance(interval, Timeframe)
+            else interval
+        )
+        raw_data = await self._client.klines(
+            symbol=symbol,
+            interval=interval,
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        return Adapter.klines(raw_data=raw_data, symbol=symbol)
+
+    async def futures_klines(
+        self,
+        symbol: str,
+        interval: Timeframe | str,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> list[KlineDict]:
+        """Возвращает список свечей для тикера.
+
+        Параметры:
+            symbol (str): Название тикера.
+            limit (int | None): Количество свечей.
+            interval (Timeframe | str): Таймфрейм свечей.
+            start_time (int | None): Время начала периода в миллисекундах.
+            end_time (int | None): Время окончания периода в миллисекундах.
+
+        Возвращает:
+            list[KlineDict]: Список свечей для тикера.
+        """
+        interval = (
+            interval.to_exchange_format(Exchange.BINANCE, MarketType.FUTURES)
+            if isinstance(interval, Timeframe)
+            else interval
+        )
+        raw_data = await self._client.futures_klines(
+            symbol=symbol,
+            interval=interval,
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        return Adapter.klines(raw_data=raw_data, symbol=symbol)
+
+    @overload
+    async def funding_rate(self, symbol: str) -> float: ...
+
+    @overload
+    async def funding_rate(self, symbol: None) -> dict[str, float]: ...
+
+    @overload
+    async def funding_rate(self) -> dict[str, float]: ...
+
+    async def funding_rate(self, symbol: str | None = None) -> dict[str, float] | float:
+        """Возвращает ставку финансирования для тикера или всех тикеров, если тикер не указан.
+
+        - Параметры:
+        symbol (`str | None`): Название тикера (Опционально).
+
+        Возвращает:
+          `dict[str, float] | float`: Ставка финансирования для тикера или словарь со ставками для всех тикеров.
+        """
+        raw_data = await self._client.futures_mark_price(symbol=symbol)
+        adapted_data = Adapter.funding_rate(raw_data if isinstance(raw_data, list) else [raw_data])  # type: ignore[arg-type]
+        return adapted_data[symbol] if symbol else adapted_data
+
+    async def open_interest(self, symbol: str = None) -> OpenInterestItem:  # type: ignore[reportArgumentType] | We should provide our exception message
+        """Возвращает объем открытого интереса для тикера.
+
+        Параметры:
+            symbol (`str`): Название тикера.
+
+        Возвращает:
+            `OpenInterestItem`: Словарь со временем и объемом открытого интереса в монетах.
+        """
+        if not symbol:
+            raise ValueError("Symbol is required for binance open interest")
+        raw_data = await self._client.open_interest(symbol=symbol)
+        return Adapter.open_interest(raw_data)

unicex/binance/uni_websocket_manager.py

@@ -0,0 +1,166 @@
+__all__ = ["UniWebsocketManager"]
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from unicex._abc import IUniWebsocketManager
+from unicex._base import Websocket
+from unicex.enums import Exchange, MarketType, Timeframe
+from unicex.types import LoggerLike
+
+from .adapter import Adapter
+from .client import Client
+from .uni_client import UniClient
+from .websocket_manager import WebsocketManager
+
+type CallbackType = Callable[[Any], Awaitable[None]]
+
+
+class UniWebsocketManager(IUniWebsocketManager):
+    """Реализация менеджера асинхронных унифицированных вебсокетов для биржи Binance."""
+
+    def __init__(
+        self, client: Client | UniClient | None = None, logger: LoggerLike | None = None
+    ) -> None:
+        """Инициализирует унифицированный менеджер вебсокетов.
+
+        Параметры:
+            client (`Client | UniClient | None`): Клиент Binance или унифицированный клиент. Нужен для подключения к приватным топикам.
+            logger (`LoggerLike | None`): Логгер для записи логов.
+        """
+        super().__init__(client=client, logger=logger)
+        self._websocket_manager = WebsocketManager(self._client)  # type: ignore
+        self._adapter = Adapter()
+
+    def klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        symbol: str | None = None,
+        symbols: list[str] | None = None,
+    ) -> Websocket:
+        """Создаёт вебсокет для получения свечей на споте с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки адаптированных сообщений.
+            timeframe (`Timeframe`): Временной интервал свечей (унифицированный).
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.klines_message, callback)
+        return self._websocket_manager.klines(
+            callback=wrapper,
+            symbol=symbol,
+            symbols=symbols,
+            interval=timeframe.to_exchange_format(Exchange.BINANCE, MarketType.SPOT),
+        )
+
+    def futures_klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        symbol: str | None = None,
+        symbols: list[str] | None = None,
+    ) -> Websocket:
+        """Создаёт вебсокет для получения свечей на фьючерсах с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки адаптированных сообщений.
+            timeframe (`Timeframe`): Временной интервал свечей (унифицированный).
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.klines_message, callback)
+        return self._websocket_manager.futures_klines(
+            callback=wrapper,
+            symbol=symbol,
+            symbols=symbols,
+            interval=timeframe.to_exchange_format(Exchange.BINANCE, MarketType.FUTURES),
+        )
+
+    def trades(
+        self, callback: CallbackType, symbol: str | None = None, symbols: list[str] | None = None
+    ) -> Websocket:
+        """Создаёт вебсокет для получения сделок на споте с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки адаптированных сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.trades_message, callback)
+        return self._websocket_manager.trade(callback=wrapper, symbol=symbol, symbols=symbols)
+
+    def aggtrades(
+        self, callback: CallbackType, symbol: str | None = None, symbols: list[str] | None = None
+    ) -> Websocket:
+        """Создаёт вебсокет для получения агрегированных сделок на споте с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки адаптированных сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.aggtrades_message, callback)
+        return self._websocket_manager.agg_trade(callback=wrapper, symbol=symbol, symbols=symbols)
+
+    def futures_trades(
+        self, callback: CallbackType, symbol: str | None = None, symbols: list[str] | None = None
+    ) -> Websocket:
+        """Создаёт вебсокет для получения сделок на фьючерсах с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки
+                адаптированных сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.trades_message, callback)
+        return self._websocket_manager.futures_trade(
+            callback=wrapper, symbol=symbol, symbols=symbols
+        )
+
+    def futures_aggtrades(
+        self, callback: CallbackType, symbol: str | None = None, symbols: list[str] | None = None
+    ) -> Websocket:
+        """Создаёт вебсокет для получения агрегированных сделок на фьючерсах с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обработки адаптированных сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`list[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        wrapper = self._make_wrapper(self._adapter.aggtrades_message, callback)
+        return self._websocket_manager.futures_agg_trade(
+            callback=wrapper, symbol=symbol, symbols=symbols
+        )

unicex/binance/user_websocket.py

@@ -0,0 +1,186 @@
+__all__ = ["UserWebsocket"]
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Any, Literal
+
+from loguru import logger as _logger
+
+from unicex._base import Websocket
+from unicex.exceptions import NotSupported
+from unicex.types import LoggerLike
+
+from .client import Client
+
+
+class UserWebsocket:
+    """Пользовательский вебсокет Binance с авто‑продлением listenKey.
+
+    Поддержка типов аккаунта: "SPOT" и "FUTURES" (USDT‑M фьючерсы).
+    """
+
+    _BASE_SPOT_URL: str = "wss://stream.binance.com:9443"
+    """Базовый URL для вебсокета на спот."""
+
+    _BASE_FUTURES_URL: str = "wss://fstream.binance.com"
+    """Базовый URL для вебсокета на фьючерсы."""
+
+    _RENEW_INTERVAL: int = 30 * 60
+    """Интервал продления listenKey (сек.)"""
+
+    def __init__(
+        self,
+        callback: Callable[[Any], Awaitable[None]],
+        client: Client,
+        type: Literal["SPOT", "FUTURES"],
+        logger: LoggerLike | None = None,
+        **kwargs: Any,  # Не дадим сломаться, если юзер передал ненужные аргументы
+    ) -> None:
+        """Инициализирует пользовательский вебсокет для работы с биржей Binance.
+
+        Параметры:
+            callback (`Callable`): Асинхронная функция обратного вызова, которая принимает сообщение с вебсокета.
+            client (`Client`): Авторизованный клиент Binance.
+            type (`str`): Тип аккаунта ("SPOT" | "FUTURES").
+            logger (`LoggerLike | None`): Логгер для записи логов.
+        """
+        self._callback = callback
+        self._client = client
+        self._type = type
+
+        self._listen_key: str | None = None
+        self._ws: Websocket | None = None
+        self._keepalive_task: asyncio.Task | None = None
+
+        self._logger = logger or _logger
+
+        self._running = False
+
+    @classmethod
+    def _create_ws_url(cls, type: Literal["SPOT", "FUTURES"], listen_key: str) -> str:
+        """Создает URL для подключения к WebSocket."""
+        if type == "FUTURES":
+            return f"{cls._BASE_FUTURES_URL}/ws/{listen_key}"
+        if type == "SPOT":
+            return f"{cls._BASE_SPOT_URL}/ws/{listen_key}"
+        raise NotSupported(f"Account type '{type}' not supported")
+
+    async def start(self) -> None:
+        """Запускает пользовательский стрим с автопродлением listenKey."""
+        self._running = True
+        self._listen_key = await self._create_listen_key()
+        await self._start_ws(self._create_ws_url(self._type, self._listen_key))  # type: ignore
+
+        # Фоновое продление ключа прослушивания
+        self._keepalive_task = asyncio.create_task(self._keepalive_loop())
+
+    async def stop(self) -> None:
+        """Останавливает стрим и закрывает listenKey."""
+        self._running = False
+
+        # Останавливаем вебсокет
+        try:
+            if isinstance(self._ws, Websocket):
+                await self._ws.stop()
+        except Exception as e:
+            self._logger.error(f"Error stopping WebSocket: {e}")
+
+        # Ожидаем завершения фонового продления ключа прослушивания
+        if isinstance(self._keepalive_task, asyncio.Task):
+            try:
+                self._keepalive_task.cancel()
+                await self._keepalive_task
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                self._logger.error(f"Error stopping keepalive task: {e}")
+
+        # Закрываем ключ прослушивания
+        try:
+            if self._listen_key:
+                await self._close_listen_key(self._listen_key)
+        except Exception as e:
+            self._logger.error(f"Error closing listenKey: {e}")
+        finally:
+            self._listen_key = None
+
+        self._logger.info("User websocket stopped")
+
+    async def restart(self) -> None:
+        """Перезапускает WebSocket для User Data Stream."""
+        await self.stop()
+        await self.start()
+
+    async def _start_ws(self, ws_url: str) -> None:
+        """Запускает WebSocket для User Data Stream."""
+        self._ws = Websocket(callback=self._callback, url=ws_url, no_message_reconnect_timeout=None)
+        await self._ws.start()
+        self._logger.info(f"User websocket started: ...{ws_url[-5:]}")
+
+    async def _keepalive_loop(self) -> None:
+        """Фоновый цикл продления listenKey и восстановления сессии при необходимости."""
+        while self._running:
+            try:
+                if self._type == "FUTURES":
+                    response = await self._renew_listen_key()
+                    listen_key = response.get("listenKey") if isinstance(response, dict) else None
+                    if not listen_key:
+                        raise RuntimeError(f"Can not renew listenKey: {response}")
+
+                    if listen_key != self._listen_key:
+                        self._logger.info(
+                            f"Listen key changed: {self._listen_key} -> {listen_key}. Restarting websocket"
+                        )
+                        await self.restart()
+                        return
+
+                elif self._type == "SPOT":
+                    await self._renew_listen_key()
+
+                else:
+                    raise NotSupported(f"Account type '{self._type}' not supported")
+
+            except Exception as e:
+                self._logger.error(f"Error while keeping alive: {e}")
+                await self.restart()
+                return
+
+            # Ждём до следующего продления
+            for _ in range(self._RENEW_INTERVAL):
+                if not self._running:
+                    return
+                await asyncio.sleep(1)
+
+    async def _create_listen_key(self) -> str:
+        """Создает новый listenKey для User Data Stream в зависимости от типа аккаунта."""
+        if self._type == "FUTURES":
+            resp = await self._client.futures_listen_key()
+        elif self._type == "SPOT":
+            resp = await self._client.listen_key()
+        else:
+            raise NotSupported(f"Account type '{self._type}' not supported")
+
+        key = resp.get("listenKey") if isinstance(resp, dict) else None
+        if not key:
+            raise RuntimeError(f"Can not create listenKey: {resp}")
+        return key
+
+    async def _renew_listen_key(self) -> dict:
+        """Продлевает listenKey. Возвращает новый ключ, если сервер его выдал."""
+        if not isinstance(self._listen_key, str):
+            raise RuntimeError("listenKey is not a string")
+        if self._type == "FUTURES":
+            return await self._client.futures_renew_listen_key()
+        elif self._type == "SPOT":
+            return await self._client.renew_listen_key(self._listen_key)
+        else:
+            raise NotSupported(f"Account type '{self._type}' not supported")
+
+    async def _close_listen_key(self, listen_key: str) -> None:
+        """Закрывает listenKey."""
+        if self._type == "FUTURES":
+            await self._client.futures_close_listen_key()
+        elif self._type == "SPOT":
+            await self._client.close_listen_key(listen_key)
+        else:
+            raise NotSupported(f"Account type '{self._type}' not supported")