unicex 0.7.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

unicex/_abc/__init__.py

@@ -1,9 +1,13 @@
+"""Пакет с абстракциями и интерфейсами."""
+
 __all__ = [
     "IUniClient",
     "IUniWebsocketManager",
     "IExchangeInfo",
+    "IDecoder",
 ]
 
+from .decoder import IDecoder
 from .exchange_info import IExchangeInfo
 from .uni_client import IUniClient
 from .uni_websocket_manager import IUniWebsocketManager

unicex/_abc/decoder.py

@@ -0,0 +1,18 @@
+__all__ = ["IDecoder"]
+
+from typing import Protocol
+
+
+class IDecoder(Protocol):
+    """Протокол для декодеров сообщений c вебсокета."""
+
+    def decode(self, message: bytes | str) -> dict:
+        """Декодирует сообщение.
+
+        Параметры:
+            message (`Any`): Сообщение для декодирования.
+
+        Возвращает:
+            `Any`: Декодированное сообщение.
+        """
+        ...

unicex/_abc/uni_client.py

@@ -115,7 +115,7 @@ class IUniClient(ABC, Generic[TClient]):
         Возвращает:
             `bool`: True, если апи ключи присутствуют, иначе False.
         """
-        return self._client._api_key is not None and self._client._api_secret is not None
+        return self._client.is_authorized()
 
     async def close_connection(self) -> None:
         """Закрывает сессию клиента."""

unicex/_base/__init__.py

@@ -1,3 +1,5 @@
+"""Пакет с базовым клиентом для HTTP запросов и базовым вебсокетом."""
+
 __all__ = [
     "BaseClient",
     "Websocket",

unicex/_base/websocket.py

@@ -3,7 +3,7 @@ __all__ = ["Websocket"]
 import asyncio
 import time
 from collections.abc import Awaitable, Callable
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import orjson
 import websockets
@@ -13,6 +13,9 @@ from websockets.asyncio.client import ClientConnection
 from unicex.exceptions import QueueOverflowError
 from unicex.types import LoggerLike
 
+if TYPE_CHECKING:
+    from unicex._abc import IDecoder
+
 
 class Websocket:
     """Базовый класс асинхронного вебсокета."""
@@ -20,6 +23,12 @@ class Websocket:
     MAX_QUEUE_SIZE: int = 100
     """Максимальная длина очереди."""
 
+    class _JsonDecoder:
+        """Базовый JSON декодер для WebSocket сообщений."""
+
+        def decode(self, message: bytes | str) -> dict:
+            return orjson.loads(message)
+
     def __init__(
         self,
         callback: Callable[[Any], Awaitable[None]],
@@ -32,6 +41,7 @@ class Websocket:
         reconnect_timeout: int | float | None = 5,
         worker_count: int = 2,
         logger: LoggerLike | None = None,
+        decoder: type["IDecoder"] = _JsonDecoder,
         **kwargs: Any,  # Не дадим сломаться, если юзер передал ненужные аргументы
     ) -> None:
         """Инициализация вебсокета.
@@ -47,6 +57,7 @@ class Websocket:
             reconnect_timeout (`int | float | None`): Пауза перед переподключением, сек.
             worker_count (`int`): Количество рабочих задач для обработки сообщений.
             logger (`LoggerLike | None`): Логгер для записи логов.
+            decoder (`IDecoder | None`): Декодер для обработки входящих сообщений.
         """
         self._callback = callback
         self._url = url
@@ -59,6 +70,7 @@ class Websocket:
         self._last_message_time = time.monotonic()
         self._worker_count = worker_count
         self._logger = logger or _logger
+        self._decoder = decoder()
         self._tasks: list[asyncio.Task] = []
         self._queue = asyncio.Queue()
         self._running = False
@@ -114,14 +126,14 @@ class Websocket:
                 await asyncio.sleep(self._reconnect_timeout)
                 await self._after_disconnect()
 
-    async def _handle_message(self, message: str) -> None:
+    async def _handle_message(self, message: str | bytes) -> None:
         """Обрабатывает входящее сообщение вебсокета."""
         try:
             # Обновленяем время последнего сообщения
             self._last_message_time = time.monotonic()
 
             # Ложим сообщение в очередь, предварительно его сериализуя
-            await self._queue.put(orjson.loads(message))
+            await self._queue.put(self._decoder.decode(message))
 
             # Проверяем размер очереди сообщений и выбрасываем ошибку, если он превышает максимальный размер
             self._check_queue_size()
@@ -139,7 +151,7 @@ class Websocket:
         """Проверяет размер очереди и выбрасывает ошибку при переполнении."""
         qsize = self._queue.qsize()
         if qsize >= self.MAX_QUEUE_SIZE:
-            raise QueueOverflowError("Message queue is overflow")
+            raise QueueOverflowError(f"Message queue is overflow: {qsize}")
 
     async def _after_connect(self, conn: ClientConnection) -> None:
         """Вызывается после установки соединения."""

unicex/binance/adapter.py

@@ -17,7 +17,7 @@ class Adapter:
     """Адаптер для унификации данных с Binance API."""
 
     @staticmethod
-    def tickers(raw_data: list[dict], only_usdt: bool = True) -> list[str]:
+    def tickers(raw_data: list[dict], only_usdt: bool) -> list[str]:
         """Преобразует сырой ответ, в котором содержатся данные о тикерах в список тикеров.
 
         Параметры:

unicex/binance/client.py

@@ -62,8 +62,8 @@ class Client(BaseClient):
         if not signed:
             return {"params": params, "data": data}, None
 
-        if not self._api_key or not self._api_secret:  # type: ignore[attr-defined]
-            raise NotAuthorized("Api key is required to private endpoints")
+        if not self.is_authorized():
+            raise NotAuthorized("Api key and api secret is required to private endpoints")
 
         # Объединяем все параметры в payload
         payload = {**params, **data}

unicex/bitget/client.py

@@ -5,6 +5,7 @@ import time
 from typing import Any, Literal
 
 from unicex._base import BaseClient
+from unicex.exceptions import NotAuthorized
 from unicex.types import RequestMethod
 from unicex.utils import (
     dict_to_query_string,
@@ -20,6 +21,18 @@ class Client(BaseClient):
     _BASE_URL: str = "https://api.bitget.com"
     """Базовый URL для REST API Bitget."""
 
+    def is_authorized(self) -> bool:
+        """Проверяет наличие API‑ключей у клиента.
+
+        Возвращает:
+            `bool`: Признак наличия ключей.
+        """
+        return (
+            self._api_key is not None
+            and self._api_secret is not None
+            and self._api_passphrase is not None
+        )
+
     def _sign_message(
         self,
         method: RequestMethod,
@@ -45,6 +58,9 @@ class Client(BaseClient):
                 - `timestamp (str)`: Временная метка в миллисекундах.
                 - `signature (str)`: Подпись в формате base64.
         """
+        if not self.is_authorized():
+            raise NotAuthorized("Api key and api secret is required to private endpoints")
+
         timestamp = str(int(time.time() * 1000))
 
         path = f"{endpoint}?{dict_to_query_string(params)}" if params else endpoint
@@ -68,16 +84,15 @@ class Client(BaseClient):
             `dict[str, str]`: Словарь заголовков запроса.
         """
         headers = {"Content-Type": "application/json", "Accept": "application/json"}
-        if self._api_key:  # type: ignore[attr-defined]
-            headers.update(
-                {
-                    "ACCESS-KEY": self._api_key,  # type: ignore[attr-defined]
-                    "ACCESS-PASSPHRASE": self._api_passphrase,  # type: ignore[attr-defined]
-                    "ACCESS-TIMESTAMP": timestamp,
-                    "ACCESS-SIGN": signature,
-                    "locale": "en-US",
-                }
-            )
+        headers.update(
+            {
+                "ACCESS-KEY": self._api_key,  # type: ignore[attr-defined]
+                "ACCESS-PASSPHRASE": self._api_passphrase,  # type: ignore[attr-defined]
+                "ACCESS-TIMESTAMP": timestamp,
+                "ACCESS-SIGN": signature,
+                "locale": "en-US",
+            }
+        )
         return headers
 
     def _prepare_request_params(

unicex/bybit/adapter.py

@@ -16,7 +16,7 @@ class Adapter:
     """Адаптер для унификации данных с Bybit API."""
 
     @staticmethod
-    def tickers(raw_data: dict, only_usdt: bool = True) -> list[str]:
+    def tickers(raw_data: dict, only_usdt: bool) -> list[str]:
         """Преобразует сырой ответ, в котором содержатся данные о тикерах в список тикеров.
 
         Параметры:

unicex/bybit/client.py

@@ -41,12 +41,12 @@ class Client(BaseClient):
         Источник: https://github.com/bybit-exchange/api-usage-examples/blob/master/V5_demo/api_demo/Encryption_HMAC.py
         """
         # Проверяем наличие апи ключей для подписи запроса
-        if not self._api_key or not self._api_secret:
-            raise NotAuthorized("API key and secret are required to private endpoints.")
+        if not self.is_authorized():
+            raise NotAuthorized("Api key and api secret is required to private endpoints")
 
         dumped_payload = json.dumps(payload)
-        prepared_query_string = timestamp + self._api_key + self._RECV_WINDOW + dumped_payload
-        return generate_hmac_sha256_signature(self._api_secret, prepared_query_string)
+        prepared_query_string = timestamp + self._api_key + self._RECV_WINDOW + dumped_payload  # type: ignore[attrDefined]
+        return generate_hmac_sha256_signature(self._api_secret, prepared_query_string)  # type: ignore[attrDefined]
 
     async def _make_request(
         self,

unicex/bybit/uni_client.py

@@ -33,7 +33,7 @@ class UniClient(IUniClient[Client]):
             list[str]: Список тикеров.
         """
         raw_data = await self._client.tickers("spot")
-        return Adapter.tickers(raw_data)
+        return Adapter.tickers(raw_data, only_usdt)
 
     async def futures_tickers(self, only_usdt: bool = True) -> list[str]:
         """Возвращает список тикеров.
@@ -45,7 +45,7 @@ class UniClient(IUniClient[Client]):
             list[str]: Список тикеров.
         """
         raw_data = await self._client.tickers("linear")
-        return Adapter.tickers(raw_data)
+        return Adapter.tickers(raw_data, only_usdt)
 
     async def last_price(self) -> dict[str, float]:
         """Возвращает последнюю цену для каждого тикера.

unicex/bybit/websocket_manager.py

@@ -1,11 +1,339 @@
 __all__ = ["WebsocketManager"]
 
+import json
+import warnings
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Any, Literal
 
-from collections.abc import Awaitable, Callable
-from typing import Any
+from unicex._base import Websocket
+
+from .client import Client
 
 type CallbackType = Callable[[Any], Awaitable[None]]
 
 
 class WebsocketManager:
     """Менеджер асинхронных вебсокетов для Bybit."""
+
+    _BASE_SPOT_URL: str = "wss://stream.bybit.com/v5/public/spot"
+    """Базовый URL для вебсокета на спот."""
+
+    _BASE_LINEAR_URL: str = "wss://stream.bybit.com/v5/public/linear"
+    """Базовый URL для вебсокета на USDT/USDC перпетуалы и фьючерсы."""
+
+    _BASE_INVERSE_URL: str = "wss://stream.bybit.com/v5/public/inverse"
+    """Базовый URL для вебсокета на инверсные контракты."""
+
+    _BASE_OPTION_URL: str = "wss://stream.bybit.com/v5/public/option"
+    """Базовый URL для вебсокета на опционы."""
+
+    _BASE_PRIVATE_URL: str = "wss://stream.bybit.com/v5/private"
+    """Базовый URL для приватных вебсокетов."""
+
+    def __init__(self, client: Client | None = None, **ws_kwargs: Any) -> None:
+        """Инициализирует менеджер вебсокетов для Bybit.
+
+        Параметры:
+            client (`Client | None`): Клиент для выполнения запросов. Нужен, чтобы открыть приватные вебсокеты.
+            ws_kwargs (`dict[str, Any]`): Дополнительные аргументы, которые прокидываются в `Websocket`.
+        """
+        self.client = client
+        self._ws_kwargs = ws_kwargs
+
+    def _generate_subscription_message(
+        self,
+        topics: Sequence[str],
+        req_id: str | None = None,
+    ) -> list[str]:
+        """Сформировать сообщение для подписки на вебсокет.
+
+        Параметры:
+            topics (`Sequence[str]`): Список топиков для подписки.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `list[str]`: Список JSON строк для отправки.
+        """
+        message = {"op": "subscribe", "args": list(topics)}
+        if req_id:
+            message["req_id"] = req_id
+
+        return [json.dumps(message)]
+
+    def _get_url_for_category(
+        self, category: Literal["spot", "linear", "inverse", "option", "private"]
+    ) -> str:
+        """Получить URL для категории.
+
+        Параметры:
+            category (`Literal["spot", "linear", "inverse", "option", "private"]`): Категория рынка.
+
+        Возвращает:
+            `str`: URL для вебсокета.
+        """
+        if category == "spot":
+            return self._BASE_SPOT_URL
+        elif category == "linear":
+            return self._BASE_LINEAR_URL
+        elif category == "inverse":
+            return self._BASE_INVERSE_URL
+        elif category == "option":
+            return self._BASE_OPTION_URL
+        elif category == "private":
+            return self._BASE_PRIVATE_URL
+        else:
+            raise ValueError(f"Unsupported category: {category}")
+
+    def orderbook(
+        self,
+        callback: CallbackType,
+        category: Literal["spot", "linear", "inverse", "option"],
+        depth: Literal[1, 25, 50, 100, 200, 500, 1000] = 1,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения данных order book.
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/orderbook
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["spot", "linear", "inverse", "option"]`): Категория рынка.
+            depth (`Literal[1, 25, 50, 100, 200, 500, 1000]`): Глубина order book.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"orderbook.{depth}.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )
+
+    def klines(
+        self,
+        callback: CallbackType,
+        category: Literal["spot", "linear", "inverse", "option"],
+        interval: Literal[
+            "1", "3", "5", "15", "30", "60", "120", "240", "360", "720", "D", "W", "M"
+        ],
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения данных klines (свечей).
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/kline
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["spot", "linear", "inverse", "option"]`): Категория рынка.
+            interval (`Literal["1", "3", "5", "15", "30", "60", "120", "240", "360", "720", "D", "W", "M"]`): Интервал свечи.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"kline.{interval}.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )
+
+    def public_trade(
+        self,
+        callback: CallbackType,
+        category: Literal["spot", "linear", "inverse", "option"],
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения публичных сделок.
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/trade
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["spot", "linear", "inverse", "option"]`): Категория рынка.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"publicTrade.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )
+
+    def ticker(
+        self,
+        callback: CallbackType,
+        category: Literal["spot", "linear", "inverse", "option"],
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения тикеров.
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/ticker
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["spot", "linear", "inverse", "option"]`): Категория рынка.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"tickers.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )
+
+    def liquidation(
+        self,
+        callback: CallbackType,
+        category: Literal["linear", "inverse"],
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения данных ликвидаций.
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/liquidation
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["linear", "inverse"]`): Категория рынка (только для деривативов).
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        warnings.warn(
+            "TDepreicated liquidation stream, please move to All Liquidation Subscribe"
+            "to the liquidation stream. Pushes at most one order per second per symbol."
+            "As such, this feed does not push all liquidations that occur on Bybit.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"liquidation.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )
+
+    def all_liquidation(
+        self,
+        callback: CallbackType,
+        category: Literal["linear", "inverse"],
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+        req_id: str | None = None,
+    ) -> Websocket:
+        """Создает вебсокет для получения данных ликвидаций.
+
+        https://bybit-exchange.github.io/docs/v5/websocket/public/all-liquidation
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            category (`Literal["linear", "inverse"]`): Категория рынка (только для деривативов).
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+            req_id (`str | None`): Опциональный идентификатор запроса.
+
+        Возвращает:
+            `Websocket`: Объект для управления вебсокет соединением.
+        """
+        if symbol and symbols:
+            raise ValueError("Parameters symbol and symbols cannot be used together")
+        if not (symbol or symbols):
+            raise ValueError("Either symbol or symbols must be provided")
+
+        tickers = [symbol] if symbol else symbols
+        topics = [f"allLiquidation.{ticker.upper()}" for ticker in tickers]  # type: ignore
+
+        subscription_messages = self._generate_subscription_message(topics, req_id)
+        url = self._get_url_for_category(category)
+
+        return Websocket(
+            callback=callback,
+            url=url,
+            subscription_messages=subscription_messages,
+            **self._ws_kwargs,
+        )