unicex 0.13.17__py3-none-any.whl → 0.16.5__py3-none-any.whl

unicex/kucoin/uni_websocket_manager.py

@@ -0,0 +1,273 @@
+__all__ = ["IUniWebsocketManager"]
+
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Any, overload
+
+from unicex._abc import IUniWebsocketManager
+from unicex._base import Websocket
+from unicex.enums import 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):
+    """Реализация менеджера асинхронных унифицированных вебсокетов."""
+
+    def __init__(
+        self,
+        client: Client | UniClient | None = None,
+        logger: LoggerLike | None = None,
+        **ws_kwargs: Any,
+    ) -> None:
+        """Инициализирует унифицированный менеджер вебсокетов.
+
+        Параметры:
+            client (`Client | UniClient | None`): Клиент Kucoin или унифицированный клиент. Нужен для подключения к приватным топикам.
+            logger (`LoggerLike | None`): Логгер для записи логов.
+            ws_kwargs (`dict[str, Any]`): Дополнительные параметры инициализации, которые будут переданы WebsocketManager/Websocket.
+        """
+        super().__init__(client=client, logger=logger)
+        self._websocket_manager = WebsocketManager(self._client, **ws_kwargs)  # type: ignore
+        self._adapter = Adapter()
+
+    @overload
+    def klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим свечей (spot) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            timeframe (`Timeframe`): Временной интервал свечей.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета для управления соединением.
+        """
+        raise NotImplementedError()
+
+    @overload
+    def futures_klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def futures_klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def futures_klines(
+        self,
+        callback: CallbackType,
+        timeframe: Timeframe,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим свечей (futures) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            timeframe (`Timeframe`): Временной интервал свечей.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета.
+        """
+        raise NotImplementedError()
+
+    @overload
+    def trades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def trades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def trades(
+        self,
+        callback: CallbackType,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим сделок (spot) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета.
+        """
+        raise NotImplementedError()
+
+    @overload
+    def aggtrades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def aggtrades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def aggtrades(
+        self,
+        callback: CallbackType,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим агрегированных сделок (spot) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета.
+        """
+        raise NotImplementedError()
+
+    @overload
+    def futures_trades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def futures_trades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def futures_trades(
+        self,
+        callback: CallbackType,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим сделок (futures) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета.
+        """
+        raise NotImplementedError()
+
+    @overload
+    def futures_aggtrades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: str,
+        symbols: None = None,
+    ) -> Websocket: ...
+
+    @overload
+    def futures_aggtrades(
+        self,
+        callback: CallbackType,
+        *,
+        symbol: None = None,
+        symbols: Sequence[str],
+    ) -> Websocket: ...
+
+    def futures_aggtrades(
+        self,
+        callback: CallbackType,
+        symbol: str | None = None,
+        symbols: Sequence[str] | None = None,
+    ) -> Websocket:
+        """Открывает стрим агрегированных сделок (futures) с унификацией сообщений.
+
+        Параметры:
+            callback (`CallbackType`): Асинхронная функция обратного вызова для обработки сообщений.
+            symbol (`str | None`): Один символ для подписки.
+            symbols (`Sequence[str] | None`): Список символов для мультиплекс‑подключения.
+
+        Должен быть указан либо `symbol`, либо `symbols`.
+
+        Возвращает:
+            `Websocket`: Экземпляр вебсокета.
+        """
+        raise NotImplementedError()

unicex/kucoin/user_websocket.py

@@ -0,0 +1,7 @@
+__all__ = ["UserWebsocket"]
+
+
+class UserWebsocket:
+    """Пользовательский вебсокет Kucoin."""
+
+    pass

unicex/kucoin/websocket_manager.py

@@ -0,0 +1,11 @@
+__all__ = ["WebsocketManager"]
+
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+type CallbackType = Callable[[Any], Awaitable[None]]
+
+
+class WebsocketManager:
+    """Менеджер асинхронных вебсокетов для Kucoin."""

unicex/mapper.py

@@ -6,31 +6,66 @@ __all__ = [
     "get_exchange_info",
 ]
 
+# ruff: noqa
 
 from ._abc import IExchangeInfo, IUniClient, IUniWebsocketManager
-from .binance import ExchangeInfo as BinanceExchangeInfo
-from .binance import UniClient as BinanceUniClient
-from .binance import UniWebsocketManager as BinanceUniWebsocketManager
-from .bitget import ExchangeInfo as BitgetExchangeInfo
-from .bitget import UniClient as BitgetUniClient
-from .bitget import UniWebsocketManager as BitgetUniWebsocketManager
-from .bybit import ExchangeInfo as BybitExchangeInfo
-from .bybit import UniClient as BybitUniClient
-from .bybit import UniWebsocketManager as BybitUniWebsocketManager
 from .enums import Exchange
 from .exceptions import NotSupported
-from .gate import ExchangeInfo as GateioExchangeInfo
-from .gate import UniClient as GateioUniClient
-from .gate import UniWebsocketManager as GateioUniWebsocketManager
-from .hyperliquid import ExchangeInfo as HyperliquidExchangeInfo
-from .hyperliquid import UniClient as HyperliquidUniClient
-from .hyperliquid import UniWebsocketManager as HyperliquidUniWebsocketManager
-from .mexc import ExchangeInfo as MexcExchangeInfo
-from .mexc import UniClient as MexcUniClient
-from .mexc import UniWebsocketManager as MexcUniWebsocketManager
-from .okx import ExchangeInfo as OkxExchangeInfo
-from .okx import UniClient as OkxUniClient
-from .okx import UniWebsocketManager as OkxUniWebsocketManager
+
+from .binance import (
+    UniClient as BinanceUniClient,
+    UniWebsocketManager as BinanceUniWebsocketManager,
+    ExchangeInfo as BinanceExchangeInfo,
+)
+
+from .bitget import (
+    UniClient as BitgetUniClient,
+    UniWebsocketManager as BitgetUniWebsocketManager,
+    ExchangeInfo as BitgetExchangeInfo,
+)
+
+from .bybit import (
+    UniClient as BybitUniClient,
+    UniWebsocketManager as BybitUniWebsocketManager,
+    ExchangeInfo as BybitExchangeInfo,
+)
+
+from .gate import (
+    UniClient as GateioUniClient,
+    UniWebsocketManager as GateioUniWebsocketManager,
+    ExchangeInfo as GateioExchangeInfo,
+)
+
+from .hyperliquid import (
+    UniClient as HyperliquidUniClient,
+    UniWebsocketManager as HyperliquidUniWebsocketManager,
+    ExchangeInfo as HyperliquidExchangeInfo,
+)
+
+from .mexc import (
+    UniClient as MexcUniClient,
+    UniWebsocketManager as MexcUniWebsocketManager,
+    ExchangeInfo as MexcExchangeInfo,
+)
+
+from .okx import (
+    UniClient as OkxUniClient,
+    UniWebsocketManager as OkxUniWebsocketManager,
+    ExchangeInfo as OkxExchangeInfo,
+)
+
+from .kucoin import (
+    UniClient as KucoinUniClient,
+    UniWebsocketManager as KucoinUniWebsocketManager,
+    ExchangeInfo as KucoinExchangeInfo,
+)
+
+from .bingx import (
+    UniClient as BingXUniClient,
+    UniWebsocketManager as BingXUniWebsocketManager,
+    ExchangeInfo as BingXExchangeInfo,
+)
+
 
 _UNI_CLIENT_MAPPER: dict[Exchange, type[IUniClient]] = {
     Exchange.BINANCE: BinanceUniClient,
@@ -40,6 +75,8 @@ _UNI_CLIENT_MAPPER: dict[Exchange, type[IUniClient]] = {
     Exchange.HYPERLIQUID: HyperliquidUniClient,
     Exchange.MEXC: MexcUniClient,
     Exchange.OKX: OkxUniClient,
+    Exchange.KUCOIN: KucoinUniClient,
+    Exchange.BINGX: BingXUniClient,
 }
 """Маппер, который связывает биржу и реализацию унифицированного клиента."""
 
@@ -51,6 +88,8 @@ _UNI_WS_MANAGER_MAPPER: dict[Exchange, type[IUniWebsocketManager]] = {
     Exchange.HYPERLIQUID: HyperliquidUniWebsocketManager,
     Exchange.MEXC: MexcUniWebsocketManager,
     Exchange.OKX: OkxUniWebsocketManager,
+    Exchange.KUCOIN: KucoinUniWebsocketManager,
+    Exchange.BINGX: BingXUniWebsocketManager,
 }
 """Маппер, который связывает биржу и реализацию унифицированного вебсокет-менеджера."""
 
@@ -62,6 +101,8 @@ _EXCHANGE_INFO_MAPPER: dict[Exchange, type[IExchangeInfo]] = {
     Exchange.HYPERLIQUID: HyperliquidExchangeInfo,
     Exchange.MEXC: MexcExchangeInfo,
     Exchange.OKX: OkxExchangeInfo,
+    Exchange.KUCOIN: KucoinExchangeInfo,
+    Exchange.BINGX: BingXExchangeInfo,
 }
 """Маппер, который связывает биржу и реализацию сборщика информации о тикерах на бирже."""
 

unicex/mexc/adapter.py

@@ -1,11 +1,14 @@
 __all__ = ["Adapter"]
 
+from typing import Any
+
 from unicex.types import (
     KlineDict,
     OpenInterestDict,
     OpenInterestItem,
     TickerDailyDict,
     TickerDailyItem,
+    TradeDict,
 )
 from unicex.utils import catch_adapter_errors, decorate_all_methods
 
@@ -127,6 +130,7 @@ class Adapter:
             result[symbol] = OpenInterestItem(
                 t=item["timestamp"],
                 v=float(item["holdVol"]) * Adapter._get_contract_size(symbol),
+                u="coins",
             )
         return result
 
@@ -230,6 +234,106 @@ class Adapter:
 
         return sorted(klines, key=lambda kline_item: kline_item["t"])
 
+    @staticmethod
+    def klines_message(raw_msg: Any) -> list[KlineDict]:
+        """Преобразует вебсокет-сообщение со свечами в унифицированный формат.
+
+        Параметры:
+            raw_msg (Any): Сырое сообщение с вебсокета.
+
+        Возвращает:
+            list[KlineDict]: Список свечей в унифицированном формате.
+        """
+        kline = raw_msg["publicSpotKline"]
+        return [
+            KlineDict(
+                s=raw_msg["symbol"],
+                t=int(kline["windowStart"]) * 1000,
+                o=float(kline["openingPrice"]),
+                h=float(kline["highestPrice"]),
+                l=float(kline["lowestPrice"]),
+                c=float(kline["closingPrice"]),
+                v=float(kline["volume"]),
+                T=int(kline["windowEnd"]) * 1000,
+                x=None,
+                q=float(kline["amount"]),
+            )
+        ]
+
+    @staticmethod
+    def futures_klines_message(raw_msg: Any) -> list[KlineDict]:
+        """Преобразует вебсокет-сообщение со свечами в унифицированный формат.
+
+        Параметры:
+            raw_msg (Any): Сырое сообщение с вебсокета.
+
+        Возвращает:
+            list[KlineDict]: Список свечей в унифицированном формате.
+        """
+        data = raw_msg["data"]
+        return [
+            KlineDict(
+                s=data["symbol"],
+                t=data["t"] * 1000,
+                o=data["o"],
+                h=data["h"],
+                l=data["l"],
+                c=data["c"],
+                v=data["q"],  # Контракты
+                q=data["a"],
+                T=None,
+                x=None,
+            )
+        ]
+
+    @staticmethod
+    def trades_message(raw_msg: Any) -> list[TradeDict]:
+        """Преобразует вебсокет-сообщение со сделками в унифицированный формат.
+
+        Параметры:
+            raw_msg (Any): Сырое сообщение с вебсокета.
+
+        Возвращает:
+            list[TradeDict]: Список сделок в унифицированном формате.
+        """
+        return [
+            TradeDict(
+                t=trade["time"],
+                s=raw_msg["symbol"],
+                S="BUY" if trade["tradeType"] == 1 else "SELL",
+                p=float(trade["price"]),
+                v=float(trade["quantity"]),
+            )
+            for trade in sorted(
+                raw_msg["publicAggreDeals"]["deals"],
+                key=lambda item: item["time"],
+            )
+        ]
+
+    @staticmethod
+    def futures_trades_message(raw_msg: Any) -> list[TradeDict]:
+        """Преобразует вебсокет-сообщение со сделками в унифицированный формат.
+
+        Параметры:
+            raw_msg (Any): Сырое сообщение с вебсокета.
+
+        Возвращает:
+            list[TradeDict]: Список сделок в унифицированном формате.
+        """
+        return [
+            TradeDict(
+                t=item["t"],
+                s=raw_msg["symbol"],
+                S="BUY" if item["T"] == 1 else "SELL",
+                p=item["p"],
+                v=item["v"] * Adapter._get_contract_size(raw_msg["symbol"]),
+            )
+            for item in sorted(
+                raw_msg["data"],
+                key=lambda item: item["t"],
+            )
+        ]
+
     @staticmethod
     def _get_contract_size(symbol: str) -> float:
         """Возвращает размер контракта для указанного символа тикера."""

unicex/mexc/client.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from unicex._base import BaseClient
 from unicex.exceptions import NotAuthorized
-from unicex.types import RequestMethod
+from unicex.types import NumberLike, RequestMethod
 from unicex.utils import dict_to_query_string, filter_params, generate_hmac_sha256_signature
 
 
@@ -289,9 +289,9 @@ class Client(BaseClient):
         symbol: str,
         side: str,
         type: str,
-        quantity: str | None = None,
-        quote_order_quantity: str | None = None,
-        price: str | None = None,
+        quantity: NumberLike | None = None,
+        quote_order_quantity: NumberLike | None = None,
+        price: NumberLike | None = None,
         new_client_order_id: str | None = None,
         stp_mode: str | None = None,
     ) -> dict:
@@ -319,9 +319,9 @@ class Client(BaseClient):
         symbol: str,
         side: str,
         type: str,
-        quantity: str | None = None,
-        quote_order_quantity: str | None = None,
-        price: str | None = None,
+        quantity: NumberLike | None = None,
+        quote_order_quantity: NumberLike | None = None,
+        price: NumberLike | None = None,
         new_client_order_id: str | None = None,
         stp_mode: str | None = None,
     ) -> dict:

unicex/mexc/uni_client.py

@@ -180,9 +180,7 @@ class UniClient(IUniClient[Client]):
         """
         raw_data = await self._client.futures_ticker()
         adapted_data = Adapter.funding_rate(raw_data=raw_data)  # type: ignore[reportArgumentType]
-        if symbol:
-            return adapted_data[symbol]
-        return adapted_data
+        return adapted_data[symbol] if symbol else adapted_data
 
     @overload
     async def open_interest(self, symbol: str) -> OpenInterestItem: ...

unicex/mexc/uni_websocket_manager.py

@@ -5,7 +5,7 @@ from typing import Any, overload
 
 from unicex._abc import IUniWebsocketManager
 from unicex._base import Websocket
-from unicex.enums import Timeframe
+from unicex.enums import Exchange, MarketType, Timeframe
 from unicex.types import LoggerLike
 
 from .adapter import Adapter
@@ -20,16 +20,20 @@ class UniWebsocketManager(IUniWebsocketManager):
     """Реализация менеджера асинхронных унифицированных вебсокетов."""
 
     def __init__(
-        self, client: Client | UniClient | None = None, logger: LoggerLike | None = None
+        self,
+        client: Client | UniClient | None = None,
+        logger: LoggerLike | None = None,
+        **ws_kwargs: Any,
     ) -> None:
         """Инициализирует унифицированный менеджер вебсокетов.
 
         Параметры:
             client (`Client | UniClient | None`): Клиент Mexc или унифицированный клиент. Нужен для подключения к приватным топикам.
             logger (`LoggerLike | None`): Логгер для записи логов.
+            ws_kwargs (`dict[str, Any]`): Дополнительные параметры инициализации, которые будут переданы WebsocketManager/Websocket.
         """
         super().__init__(client=client, logger=logger)
-        self._websocket_manager = WebsocketManager(self._client)  # type: ignore
+        self._websocket_manager = WebsocketManager(self._client, **ws_kwargs)  # type: ignore
         self._adapter = Adapter()
 
     @overload
@@ -72,7 +76,15 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета для управления соединением.
         """
-        raise NotImplementedError()
+        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.MEXC, MarketType.FUTURES
+            ),  # Тут фьючерсный интервал, потому что для вебсокета MEXC решили что сделают так (идиоты)
+        )
 
     @overload
     def futures_klines(
@@ -114,7 +126,13 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета.
         """
-        raise NotImplementedError()
+        wrapper = self._make_wrapper(self._adapter.futures_klines_message, callback)
+        return self._websocket_manager.futures_kline(
+            callback=wrapper,
+            symbol=symbol,
+            symbols=symbols,
+            interval=timeframe.to_exchange_format(Exchange.MEXC, MarketType.FUTURES),
+        )
 
     @overload
     def trades(
@@ -152,7 +170,8 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета.
         """
-        raise NotImplementedError()
+        wrapper = self._make_wrapper(self._adapter.trades_message, callback)
+        return self._websocket_manager.trade(callback=wrapper, symbol=symbol, symbols=symbols)
 
     @overload
     def aggtrades(
@@ -190,7 +209,7 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета.
         """
-        raise NotImplementedError()
+        return self.trades(callback=callback, symbol=symbol, symbols=symbols)  # type: ignore[reportCallIssue]
 
     @overload
     def futures_trades(
@@ -228,7 +247,10 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета.
         """
-        raise NotImplementedError()
+        wrapper = self._make_wrapper(self._adapter.futures_trades_message, callback)
+        return self._websocket_manager.futures_trade(
+            callback=wrapper, symbol=symbol, symbols=symbols
+        )
 
     @overload
     def futures_aggtrades(
@@ -266,4 +288,4 @@ class UniWebsocketManager(IUniWebsocketManager):
         Возвращает:
             `Websocket`: Экземпляр вебсокета.
         """
-        raise NotImplementedError()
+        return self.futures_trades(callback=callback, symbol=symbol, symbols=symbols)  # type: ignore[reportCallIssue]