unicex 0.11.0__py3-none-any.whl → 0.13.1__py3-none-any.whl

unicex/__init__.py

@@ -139,7 +139,7 @@ from .bybit import (
     ExchangeInfo as BybitExchangeInfo,
 )
 
-from .gateio import (
+from .gate import (
     Client as GateioClient,
     UniClient as GateioUniClient,
     UniWebsocketManager as GateioUniWebsocketManager,

unicex/_abc/exchange_info.py

@@ -1,10 +1,12 @@
 __all__ = ["IExchangeInfo"]
 
 import asyncio
+import math
 from abc import ABC, abstractmethod
 from decimal import Decimal
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
+import aiohttp
 from loguru import logger
 
 from unicex.enums import MarketType
@@ -32,6 +34,9 @@ class IExchangeInfo(ABC):
     _logger: "loguru.Logger"
     """Логгер для записи сообщений о работе с биржей."""
 
+    exchange_name: ClassVar[str] = "not_defined_exchange"
+    """Название биржи, на которой работает класс."""
+
     def __init_subclass__(cls, **kwargs):
         """Инициализация подкласса. Функция нужна, чтобы у каждого наследника была своя копия атрибутов."""
         super().__init_subclass__(**kwargs)
@@ -63,7 +68,7 @@ class IExchangeInfo(ABC):
             try:
                 await cls.load_exchange_info()
             except Exception as e:
-                cls._logger.error(f"Error loading exchange data: {e}")
+                cls._logger.error(f"Error loading exchange data for {cls.exchange_name}: {e}")
             for _ in range(update_interval_seconds):
                 if not cls._running:
                     break
@@ -72,9 +77,33 @@ class IExchangeInfo(ABC):
     @classmethod
     async def load_exchange_info(cls) -> None:
         """Принудительно вызывает загрузку информации о бирже."""
-        await cls._load_exchange_info()
+        async with aiohttp.ClientSession() as session:
+            try:
+                await cls._load_spot_exchange_info(session)
+                cls._logger.debug(f"Loaded spot exchange data for {cls.exchange_name} ")
+            except Exception as e:
+                cls._logger.error(f"Error loading spot exchange data for {cls.exchange_name}: {e}")
+            try:
+                await cls._load_futures_exchange_info(session)
+                cls._logger.debug(f"Loaded futures exchange data for {cls.exchange_name} ")
+            except Exception as e:
+                cls._logger.error(
+                    f"Error loading futures exchange data for {cls.exchange_name}: {e}"
+                )
         cls._loaded = True
 
+    @classmethod
+    @abstractmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        ...
+
+    @classmethod
+    @abstractmethod
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        ...
+
     @classmethod
     def get_ticker_info(
         cls, symbol: str, market_type: MarketType = MarketType.SPOT
@@ -92,39 +121,41 @@ class IExchangeInfo(ABC):
         """Возвращает информацию о тикере фьючерсов по его символу."""
         return cls.get_ticker_info(symbol, MarketType.FUTURES)
 
-    @classmethod
-    @abstractmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        ...
-
     @classmethod
     def round_price(
         cls, symbol: str, price: float, market_type: MarketType = MarketType.SPOT
-    ) -> float:
+    ) -> float:  # type: ignore
         """Округляет цену до ближайшего возможного значения."""
         try:
             if market_type == MarketType.SPOT:
                 precision = cls._tickers_info[symbol]["tick_precision"]
+                step = cls._tickers_info[symbol]["tick_step"]
             else:
                 precision = cls._futures_tickers_info[symbol]["tick_precision"]
+                step = cls._futures_tickers_info[symbol]["tick_step"]
+            if precision:
+                return cls._floor_round(price, precision)
+            return cls._floor_to_step(price, step)  # type: ignore
         except KeyError as e:
             cls._handle_key_error(e, symbol)
-        return round(price, precision)
 
     @classmethod
     def round_quantity(
         cls, symbol: str, quantity: float, market_type: MarketType = MarketType.SPOT
-    ) -> float:
+    ) -> float:  # type: ignore
         """Округляет объем до ближайшего возможного значения."""
         try:
             if market_type == MarketType.SPOT:
                 precision = cls._tickers_info[symbol]["size_precision"]
+                step = cls._tickers_info[symbol]["size_step"]
             else:
                 precision = cls._futures_tickers_info[symbol]["size_precision"]
+                step = cls._futures_tickers_info[symbol]["size_step"]
+            if precision:
+                return cls._floor_round(quantity, precision)
+            return cls._floor_to_step(quantity, step)  # type: ignore
         except KeyError as e:
             cls._handle_key_error(e, symbol)
-        return round(quantity, precision)
 
     @classmethod
     def round_futures_price(cls, symbol: str, price: float) -> float:
@@ -137,31 +168,40 @@ class IExchangeInfo(ABC):
         return cls.round_quantity(symbol, quantity, MarketType.FUTURES)
 
     @staticmethod
-    def _step_size_to_precision(tick_size: str | int | float) -> int:
-        """Возвращает precision для round(x, precision) по шагу цены/объёма.
+    def _floor_to_step(value: float, step: float) -> float:
+        """Округляет число вниз до ближайшего кратного шага.
+
+        Принимает:
+            value (float): Исходное число.
+            step: (float): Шаг округления (> 0).
+
+        Возвращает:
+            Число, округлённое вниз до кратного step.
 
-        Работает только для шагов — степеней 10.
         Примеры:
-            "0.0001" ->  4
-            "0.01"   ->  2
-            "0.1"    ->  1
-            "1"      ->  0
-            "10"     -> -1
-            "100"    -> -2
+            >>> floor_to_step(0.16, 0.05)
+            0.15
+            >>> floor_to_step(16, 5)
+            15
+            >>> floor_to_step(1.2345, 0.01)
+            1.23
+            >>> floor_to_step(-1.23, 0.1)
+            -1.3
+            >>> floor_to_step(100, 25)
+            100
+
         """
-        d = Decimal(str(tick_size)).normalize()
-        if d <= 0:
-            raise ValueError("tick_size must be > 0")
-
-        t = d.as_tuple()
-        # Степень десяти даёт один значащий разряд = 1 (1eN)
-        if t.digits == (1,):
-            return -t.exponent  # type: ignore
-
-        # Иначе это не степень 10 (например, 0.5, 5 и т.п.)
-        raise ValueError(
-            f"tick_size={tick_size} is not a power of 10; cannot map to round() precision."
-        )
+        if step <= 0:
+            raise ValueError("step must be > 0")
+        result = math.floor(value / step) * step
+        digits = abs(Decimal(str(step)).as_tuple().exponent)  # type: ignore
+        return round(result, digits)
+
+    @staticmethod
+    def _floor_round(value: float, digits: int) -> float:
+        """Округляет число вниз до указанного количества знаков после запятой."""
+        factor = 10**digits
+        return math.floor(value * factor) / factor
 
     @classmethod
     def _handle_key_error(cls, exception: KeyError, symbol: str) -> None:

unicex/binance/exchange_info.py

@@ -1,12 +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_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        ...
+    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/bitget/exchange_info.py

@@ -1,12 +1,48 @@
 __all__ = ["ExchangeInfo"]
 
+import aiohttp
+
 from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
+
+from .client import Client
 
 
 class ExchangeInfo(IExchangeInfo):
     """Предзагружает информацию о тикерах для биржи Bitget."""
 
+    exchange_name = "Bitget"
+    """Название биржи, на которой работает класс."""
+
     @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        ...
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        exchange_info = await Client(session).get_symbol_info()
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in exchange_info["data"]:
+            tickers_info[symbol_info["symbol"]] = TickerInfoItem(
+                tick_precision=int(symbol_info["pricePrecision"]),
+                tick_step=None,
+                size_precision=int(symbol_info["quantityPrecision"]),
+                size_step=None,
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
+    @classmethod
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        tickers_info: dict[str, TickerInfoItem] = {}
+        exchange_info = await Client(session).futures_get_contracts("USDT-FUTURES")
+        for symbol_info in exchange_info["data"]:
+            symbol = symbol_info["symbol"]
+            tickers_info[symbol] = TickerInfoItem(
+                tick_precision=int(symbol_info["pricePlace"]),
+                tick_step=None,
+                size_precision=int(symbol_info["volumePlace"]),
+                size_step=None,
+                contract_size=float(symbol_info["sizeMultiplier"]),
+            )
+
+        cls._futures_tickers_info = tickers_info

unicex/bybit/exchange_info.py

@@ -1,12 +1,51 @@
 __all__ = ["ExchangeInfo"]
 
+import aiohttp
+
 from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
+
+from .client import Client
 
 
 class ExchangeInfo(IExchangeInfo):
     """Предзагружает информацию о тикерах для биржи Bybit."""
 
+    exchange_name = "Bybit"
+    """Название биржи, на которой работает класс."""
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        exchange_info = await Client(session).instruments_info("spot")
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in exchange_info["result"]["list"]:
+            tickers_info[symbol_info["symbol"]] = TickerInfoItem(
+                tick_step=float(symbol_info["priceFilter"]["tickSize"]),
+                tick_precision=None,
+                size_step=float(symbol_info["lotSizeFilter"]["basePrecision"]),
+                size_precision=None,
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
     @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        ...
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        exchange_info = await Client(session).instruments_info("linear", limit=1000)
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in exchange_info["result"]["list"]:
+            try:
+                tickers_info[symbol_info["symbol"]] = TickerInfoItem(
+                    tick_step=float(symbol_info["priceFilter"]["tickSize"]),
+                    tick_precision=None,
+                    size_step=float(symbol_info["lotSizeFilter"]["qtyStep"]),
+                    size_precision=None,
+                    contract_size=1,
+                )
+            except ValueError as e:
+                cls._logger.trace(
+                    f"ValueError on {cls.exchange_name} by {symbol_info['symbol']}: {e}"
+                )
+        cls._futures_tickers_info = tickers_info

unicex/enums.py

@@ -28,7 +28,7 @@ class Exchange(StrEnum):
     BITGET = "BITGET"
     BITUNIX = "BITUNIX"
     BYBIT = "BYBIT"
-    GATEIO = "GATEIO"
+    GATE = "GATE"
     HYPERLIQUID = "HYPERLIQUID"
     KCEX = "KCEX"
     MEXC = "MEXC"
@@ -194,7 +194,7 @@ class Timeframe(StrEnum):
                 Timeframe.WEEK_1: "1W",
                 Timeframe.MONTH_1: "1M",
             },
-            (Exchange.GATEIO, MarketType.FUTURES): {
+            (Exchange.GATE, MarketType.FUTURES): {
                 Timeframe.SECOND_1: "1s",
                 Timeframe.MIN_1: "1m",
                 Timeframe.MIN_5: "5m",
@@ -210,7 +210,7 @@ class Timeframe(StrEnum):
                 Timeframe.WEEK_1: "1w",
                 Timeframe.MONTH_1: "30d",
             },
-            (Exchange.GATEIO, MarketType.SPOT): {
+            (Exchange.GATE, MarketType.SPOT): {
                 Timeframe.MIN_1: "1m",
                 Timeframe.MIN_5: "5m",
                 Timeframe.MIN_15: "15m",

unicex/extra.py

@@ -201,7 +201,7 @@ def generate_ex_link(exchange: Exchange, market_type: MarketType, symbol: str):
             return f"https://www.mexc.com/ru-RU/futures/{ticker}_USDT?type=linear_swap"
         else:
             return f"https://www.mexc.com/ru-RU/exchange/{ticker}_USDT"
-    elif exchange == Exchange.GATEIO:
+    elif exchange == Exchange.GATE:
         if market_type == MarketType.FUTURES:
             return f"https://www.gate.com/ru/futures/USDT/{ticker}_USDT"
         else:
@@ -242,10 +242,11 @@ def generate_tv_link(exchange: Exchange, market_type: MarketType, symbol: str) -
         `str`: Ссылка для TradingView.
     """
     symbol = normalize_symbol(symbol)
+    exchange_str = "GATEIO" if exchange == Exchange.GATE else str(exchange)
     if market_type == MarketType.FUTURES:
-        return f"https://www.tradingview.com/chart/?symbol={exchange}:{symbol}.P"
+        return f"https://www.tradingview.com/chart/?symbol={exchange_str}:{symbol}.P"
     else:
-        return f"https://www.tradingview.com/chart/?symbol={exchange}:{symbol}"
+        return f"https://www.tradingview.com/chart/?symbol={exchange_str}:{symbol}"
 
 
 def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -> str:
@@ -266,17 +267,17 @@ def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -
     if market_type == MarketType.FUTURES:
         match exchange:
             case Exchange.OKX:
-                return f"{base_url}/{exchange.upper()}_{symbol.replace('USDT', '-USDT')}-SWAP"
+                return f"{base_url}/OKX_{symbol.replace('USDT', '-USDT')}-SWAP"
             case Exchange.MEXC:
-                return f"{base_url}/{exchange.upper()}_{symbol.replace('USDT', '_USDT')}"
+                return f"{base_url}/MEXC_{symbol.replace('USDT', '_USDT')}"
             case Exchange.BITGET:
-                return f"{base_url}/{exchange.capitalize()}_{symbol}_UMCBL"
-            case Exchange.GATEIO:
+                return f"{base_url}/Bitget_{symbol}_UMCBL"
+            case Exchange.GATE:
                 return f"{base_url}/Gate_{symbol.replace('USDT', '_USDT')}"
             case Exchange.BITUNIX:
-                return f"{base_url}/{exchange.capitalize()}_{symbol}"
+                return f"{base_url}/Bitunix_{symbol}"
             case Exchange.HYPERLIQUID:
-                return f"{base_url}/{exchange.capitalize()}_{symbol.replace('USDT', '-USD')}"
+                return f"{base_url}/Hyperliquid_{symbol.replace('USDT', '-USD')}"
             case _:
                 return f"{base_url}/{exchange.capitalize()}_{symbol}"
     else:

unicex/{gateio → gate}/client.py

@@ -4,7 +4,7 @@ import hashlib
 import hmac
 import json
 import time
-from typing import Any
+from typing import Any, Literal
 
 from unicex._base import BaseClient
 from unicex.exceptions import NotAuthorized
@@ -691,7 +691,7 @@ class Client(BaseClient):
 
     async def futures_contracts(
         self,
-        settle: str,
+        settle: Literal["usdt", "btc"],
         limit: int | None = None,
         offset: int | None = None,
     ) -> dict:

unicex/gate/exchange_info.py

@@ -0,0 +1,55 @@
+__all__ = ["ExchangeInfo"]
+
+import aiohttp
+
+from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
+
+from .client import Client
+
+
+class ExchangeInfo(IExchangeInfo):
+    """Предзагружает информацию о тикерах для биржи Gateio."""
+
+    exchange_name = "Gateio"
+    """Название биржи, на которой работает класс."""
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        currency_pairs = await Client(session).currency_pairs()
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in currency_pairs:
+            try:
+                tickers_info[symbol_info.get("id")] = TickerInfoItem(
+                    tick_precision=int(symbol_info["precision"]),
+                    tick_step=None,
+                    size_precision=int(symbol_info["amount_precision"]),
+                    size_step=None,
+                    contract_size=1,
+                )
+            except ValueError as e:
+                cls._logger.trace(
+                    f"ValueError on {cls.exchange_name} by {symbol_info['symbol']}: {e}"
+                )
+
+        cls._tickers_info = tickers_info
+
+    @classmethod
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        contracts = await Client(session).futures_contracts("usdt")
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for contract in contracts:
+            try:
+                tickers_info[contract.get("name")] = TickerInfoItem(
+                    tick_precision=None,
+                    tick_step=float(contract["order_price_round"]),
+                    size_precision=None,
+                    size_step=float(contract["quanto_multiplier"]),
+                    contract_size=float(contract["quanto_multiplier"]),
+                )
+            except ValueError as e:
+                cls._logger.trace(f"ValueError on {cls.exchange_name} by {contract['name']}: {e}")
+
+        cls._futures_tickers_info = tickers_info

unicex/{gateio → gate}/uni_client.py

@@ -104,7 +104,7 @@ class UniClient(IUniClient[Client]):
             list[KlineDict]: Список свечей для тикера.
         """
         interval = (
-            interval.to_exchange_format(Exchange.GATEIO, MarketType.SPOT)
+            interval.to_exchange_format(Exchange.GATE, MarketType.SPOT)
             if isinstance(interval, Timeframe)
             else interval
         )
@@ -138,7 +138,7 @@ class UniClient(IUniClient[Client]):
             list[KlineDict]: Список свечей для тикера.
         """
         interval = (
-            interval.to_exchange_format(Exchange.GATEIO, MarketType.FUTURES)
+            interval.to_exchange_format(Exchange.GATE, MarketType.FUTURES)
             if isinstance(interval, Timeframe)
             else interval
         )

unicex/hyperliquid/exchange_info.py

@@ -1,6 +1,9 @@
 __all__ = ["ExchangeInfo"]
 
+import aiohttp
+
 from unicex._abc import IExchangeInfo
+from unicex.types import TickerInfoItem
 
 from .client import Client
 
@@ -8,6 +11,9 @@ from .client import Client
 class ExchangeInfo(IExchangeInfo):
     """Предзагружает информацию о тикерах для биржи Hyperliquid."""
 
+    exchange_name = "Hyperliquid"
+    """Название биржи, на которой работает класс."""
+
     _spot_meta: dict = {}
     """Словарь с метаинформацией о спотовом рынке."""
 
@@ -20,17 +26,30 @@ class ExchangeInfo(IExchangeInfo):
     _futures_meta: dict = {}
     """Словарь с метаинформацией о фьючерсном рынке."""
 
+    # DOCS: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/tick-and-lot-size
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        cls._spot_meta = await Client(session).spot_metadata()
+        cls._build_spot_mappings(cls._spot_meta)
+
+        tickers_info: dict[str, TickerInfoItem] = {}
+        for symbol_info in cls._spot_meta["tokens"]:
+            tickers_info[symbol_info["name"]] = TickerInfoItem(
+                tick_step=None,
+                tick_precision=int(symbol_info["weiDecimals"]),
+                size_step=None,
+                size_precision=int(symbol_info["szDecimals"]),
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
     @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        client = await Client.create()
-        async with client as conn:
-            cls._spot_meta = await conn.spot_metadata()
-            cls._build_spot_mappings(cls._spot_meta)
-            cls._logger.debug("Hyperliquid spot exchange info loaded")
-
-            cls._futures_meta = await conn.perp_metadata()
-            cls._logger.debug("Hyperliquid futures exchange info loaded")
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        cls._futures_meta = await Client(session).perp_metadata()
 
     @classmethod
     def _build_spot_mappings(cls, spot_meta: dict) -> None:

unicex/mapper.py

@@ -19,9 +19,9 @@ from .bybit import UniClient as BybitUniClient
 from .bybit import UniWebsocketManager as BybitUniWebsocketManager
 from .enums import Exchange
 from .exceptions import NotSupported
-from .gateio import ExchangeInfo as GateioExchangeInfo
-from .gateio import UniClient as GateioUniClient
-from .gateio import UniWebsocketManager as GateioUniWebsocketManager
+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
@@ -36,7 +36,7 @@ _UNI_CLIENT_MAPPER: dict[Exchange, type[IUniClient]] = {
     Exchange.BINANCE: BinanceUniClient,
     Exchange.BITGET: BitgetUniClient,
     Exchange.BYBIT: BybitUniClient,
-    Exchange.GATEIO: GateioUniClient,
+    Exchange.GATE: GateioUniClient,
     Exchange.HYPERLIQUID: HyperliquidUniClient,
     Exchange.MEXC: MexcUniClient,
     Exchange.OKX: OkxUniClient,
@@ -47,7 +47,7 @@ _UNI_WS_MANAGER_MAPPER: dict[Exchange, type[IUniWebsocketManager]] = {
     Exchange.BINANCE: BinanceUniWebsocketManager,
     Exchange.BITGET: BitgetUniWebsocketManager,
     Exchange.BYBIT: BybitUniWebsocketManager,
-    Exchange.GATEIO: GateioUniWebsocketManager,
+    Exchange.GATE: GateioUniWebsocketManager,
     Exchange.HYPERLIQUID: HyperliquidUniWebsocketManager,
     Exchange.MEXC: MexcUniWebsocketManager,
     Exchange.OKX: OkxUniWebsocketManager,
@@ -58,7 +58,7 @@ _EXCHANGE_INFO_MAPPER: dict[Exchange, type[IExchangeInfo]] = {
     Exchange.BINANCE: BinanceExchangeInfo,
     Exchange.BITGET: BitgetExchangeInfo,
     Exchange.BYBIT: BybitExchangeInfo,
-    Exchange.GATEIO: GateioExchangeInfo,
+    Exchange.GATE: GateioExchangeInfo,
     Exchange.HYPERLIQUID: HyperliquidExchangeInfo,
     Exchange.MEXC: MexcExchangeInfo,
     Exchange.OKX: OkxExchangeInfo,

unicex/mexc/exchange_info.py

@@ -5,28 +5,43 @@ import aiohttp
 from unicex._abc import IExchangeInfo
 from unicex.types import TickerInfoItem
 
+from .client import Client
+
 
 class ExchangeInfo(IExchangeInfo):
     """Предзагружает информацию о тикерах для биржи Mexc."""
 
+    exchange_name = "Mexc"
+    """Название биржи, на которой работает класс."""
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        exchange_info = await Client(session).exchange_info()
+        tickers_info = {}
+        for el in exchange_info["symbols"]:
+            tickers_info[el["symbol"]] = TickerInfoItem(
+                tick_precision=int(el["quotePrecision"]),
+                tick_step=None,
+                size_precision=int(el["baseAssetPrecision"]),
+                size_step=None,
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
     @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        futures_tickers_info = {}
-        async with aiohttp.ClientSession() as session:
-            url = "https://contract.mexc.com/api/v1/contract/detail"
-            async with session.get(url) as response:
-                data = await response.json()
-                for el in data["data"]:
-                    futures_tickers_info[el["symbol"]] = TickerInfoItem(
-                        tick_precision=cls._step_size_to_precision(el["priceUnit"]),
-                        size_precision=el["amountScale"],
-                        contract_size=el["contractSize"],
-                        min_market_size=el["minVol"],
-                        max_market_size=el["maxVol"],
-                        min_limit_size=el["minVol"],
-                        max_limit_size=el["maxVol"],
-                    )
-
-            cls._futures_tickers_info = futures_tickers_info
-            cls._logger.debug("Mexc futures exchange info loaded")
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        exchange_info = await Client(session).futures_contract_detail()
+        tickers_info = {}
+        for el in exchange_info["data"]:
+            tickers_info[el["symbol"]] = TickerInfoItem(
+                tick_precision=None,
+                tick_step=el["priceUnit"],
+                size_precision=None,
+                size_step=el["contractSize"],
+                contract_size=el["contractSize"],
+            )
+
+        cls._futures_tickers_info = tickers_info

unicex/okx/adapter.py

@@ -57,16 +57,22 @@ class Adapter:
 
         # NOTE: Обратите внимание, изменение цены в случае с OKX возвращается относительно открытия 1 day свечи.
         """
-        return {
-            item["instId"]: TickerDailyItem(
-                p=round(
-                    (float(item["last"]) - float(item["open24h"])) / float(item["open24h"]) * 100, 2
-                ),
-                v=float(item["vol24h"]),
-                q=float(item["volCcy24h"]),
-            )
-            for item in raw_data["data"]
-        }
+        result = {}
+        for item in raw_data["data"]:
+            try:
+                result[item["instId"]] = TickerDailyItem(
+                    p=round(
+                        (float(item["last"]) - float(item["open24h"]))
+                        / float(item["open24h"])
+                        * 100,
+                        2,
+                    ),
+                    v=float(item["vol24h"]),
+                    q=float(item["volCcy24h"]),
+                )
+            except (ValueError, TypeError, KeyError):
+                continue
+        return result
 
     @staticmethod
     def futures_ticker_24hr(raw_data: dict) -> TickerDailyDict:
@@ -88,7 +94,13 @@ class Adapter:
     @staticmethod
     def last_price(raw_data: dict) -> dict[str, float]:
         """Преобразует данные о последней цене в унифицированный формат."""
-        return {item["instId"]: float(item["last"]) for item in raw_data["data"]}
+        result = {}
+        for item in raw_data["data"]:
+            try:
+                result[item["instId"]] = float(item["last"])
+            except (ValueError, TypeError, KeyError):
+                continue
+        return result
 
     @staticmethod
     def klines(raw_data: dict, symbol: str) -> list[KlineDict]:

unicex/okx/exchange_info.py

@@ -5,46 +5,43 @@ import aiohttp
 from unicex._abc import IExchangeInfo
 from unicex.types import TickerInfoItem
 
+from .client import Client
+
 
 class ExchangeInfo(IExchangeInfo):
     """Предзагружает информацию о тикерах для биржи Okx."""
 
+    exchange_name = "Okx"
+    """Название биржи, на которой работает класс."""
+
+    @classmethod
+    async def _load_spot_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для спотового рынка."""
+        tickers_info = {}
+        exchange_info = await Client(session).get_instruments("SPOT")
+        for el in exchange_info["data"]:
+            tickers_info[el["instId"]] = TickerInfoItem(
+                tick_precision=None,
+                tick_step=float(el["tickSz"]),
+                size_precision=None,
+                size_step=float(el["lotSz"]),
+                contract_size=1,
+            )
+
+        cls._tickers_info = tickers_info
+
     @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        async with aiohttp.ClientSession() as session:
-            tickers_info = {}
-            url = "https://www.okx.com/api/v5/public/instruments?instType=SPOT"
-            async with session.get(url) as response:
-                data = await response.json()
-                for el in data["data"]:
-                    tickers_info[el["instId"]] = TickerInfoItem(
-                        tick_precision=cls._step_size_to_precision(el["tickSz"]),
-                        size_precision=cls._step_size_to_precision(el["lotSz"]),
-                        contract_size=1,
-                        min_market_size=float(el["minSz"]),
-                        max_market_size=float(el["maxMktSz"]),
-                        min_limit_size=float(el["minSz"]),
-                        max_limit_size=float(el["maxLmtSz"]),
-                    )
-
-            cls._tickers_info = tickers_info
-            cls._logger.debug("Okx spot exchange info loaded")
-
-            futures_tickers_info = {}
-            url = "https://www.okx.com/api/v5/public/instruments?instType=SWAP"
-            async with session.get(url) as response:
-                data = await response.json()
-                for el in data["data"]:
-                    futures_tickers_info[el["instId"]] = TickerInfoItem(
-                        tick_precision=cls._step_size_to_precision(el["tickSz"]),
-                        size_precision=cls._step_size_to_precision(el["lotSz"]),
-                        contract_size=float(el["ctVal"]),
-                        min_market_size=el["minSz"],
-                        max_market_size=el["maxMktSz"],
-                        min_limit_size=el["minSz"],
-                        max_limit_size=el["maxLmtSz"],
-                    )
-
-            cls._futures_tickers_info = futures_tickers_info
-            cls._logger.debug("Okx futures exchange info loaded")
+    async def _load_futures_exchange_info(cls, session: aiohttp.ClientSession) -> None:
+        """Загружает информацию о бирже для фьючерсного рынка."""
+        tickers_info = {}
+        exchange_info = await Client(session).get_instruments("SWAP")
+        for el in exchange_info["data"]:
+            tickers_info[el["instId"]] = TickerInfoItem(
+                tick_precision=None,
+                tick_step=float(el["tickSz"]),
+                size_precision=None,
+                size_step=float(el["lotSz"]) * float(el["ctVal"]),
+                contract_size=float(el["ctVal"]),
+            )
+
+        cls._futures_tickers_info = tickers_info

unicex/types.py

@@ -119,6 +119,8 @@ type OpenInterestDict = dict[str, OpenInterestItem]
 
 
 class LiquidationDict(TypedDict):
+    """Модель ликвидации."""
+
     t: int
     """Время. В миллисекундах."""
 
@@ -140,29 +142,28 @@ type AccountType = Literal["SPOT", "FUTURES"]
 
 
 class TickerInfoItem(TypedDict):
-    """Информация о размерах тиков, ступеней цены и множителя контракта (если есть) для тикера."""
+    """Информация о размерах тиков, ступеней цены и множителя контракта (если есть) для тикера.
+
+    На некоторых биржах удобнее делать округление через precisions, на некоторых через step,
+    потому что иногда встречаются шаги, которые не являются степенью 10. Поэтому обязательно
+    должны быть определены tick_precision ИЛИ tick_step, а так же size_precision ИЛИ size_step.
+    """
 
-    tick_precision: int
+    tick_precision: int | None
     """Количество знаков после запятой для цены."""
 
-    size_precision: int
+    tick_step: float | None
+    """Шаг одного деления для цены."""
+
+    size_precision: int | None
     """Количество знаков после запятой для объема."""
 
+    size_step: float | None
+    """Шаг одного деления для объема."""
+
     contract_size: float | None
     """Множитель контракта (если есть)."""
 
-    min_market_size: float | None
-    """Минимальный размер рыночного ордера в монетах (если есть)."""
-
-    max_market_size: float | None
-    """Максимальный размер рыночного ордера в монетах (если есть)."""
-
-    min_limit_size: float | None
-    """Минимальный размер лимитного ордера в монетах (если есть)."""
-
-    max_limit_size: float | None
-    """Максимальный размер лимитного ордера в монетах (если есть)."""
-
 
 type TickersInfoDict = dict[str, TickerInfoItem]
 """Информация о размерах тиков, ступеней цены и множителя контракта (если есть) для всех тикеров."""

unicex/utils.py

@@ -208,7 +208,7 @@ def symbol_to_exchange_format(
             return symbol_upper.replace("USDT", "-USDT-SWAP")
         elif market_type == MarketType.SPOT:
             return symbol_upper.replace("USDT", "-USDT")
-    elif exchange == Exchange.GATEIO:
+    elif exchange == Exchange.GATE:
         return symbol_upper.replace("USDT", "_USDT")
     elif exchange == Exchange.HYPERLIQUID:
         if market_type == MarketType.FUTURES:

{unicex-0.11.0.dist-info → unicex-0.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unicex
-Version: 0.11.0
+Version: 0.13.1
 Summary: Unified Crypto Exchange API 
 Author-email: LoveBloodAndDiamonds <ayazshakirzyanov27@gmail.com>
 License: BSD 3-Clause License
@@ -49,18 +49,18 @@ Dynamic: license-file
 
 # Unified Crypto Exchange API
 
-`unicex` — асинхронная библиотека для работы с криптовалютными биржами, реализующая унифицированный интерфейс поверх «сырых» REST и WebSocket API разных бирж.
+`unicex` — асинхронная библиотека для работы с криптовалютными биржами, реализующая унифицированный интерфейс поверх «сырых» REST и WebSocket API разных бирж. Поддерживает спотовый и USDT-фьючерсный рынки.
 
 ## ✅ Статус реализации
 
 | Exchange        | Client | Auth | WS Manager | User WS | Uni Client | Uni WS Manager | ExchangeInfo |
 |-----------------|--------|------|------------|---------|------------|----------------|--------------|
-| **Binance**     | ✓      | ✓    | ✓          | ✓       | ✓          | ✓              |              |
-| **Bitget**      | ✓      | ✓    | ✓          |         | ✓          |                |              |
-| **Bybit**       | ✓      | ✓    | ✓          |         | ✓          | ✓              |              |
-| **Gateio**      | ✓      | ✓    | ✓          |         | ✓          |                |              |
+| **Binance**     | ✓      | ✓    | ✓          | ✓       | ✓          | ✓              | ✓            |
+| **Bitget**      | ✓      | ✓    | ✓          |         | ✓          |                | ✓            |
+| **Bybit**       | ✓      | ✓    | ✓          |         | ✓          | ✓              | ✓            |
+| **Gateio**      | ✓      | ✓    | ✓          |         | ✓          |                | ✓            |
 | **Hyperliquid** | ✓      | ✓    | ✓          | ✓       | ✓          |                |              |
-| **Mexc**        | ✓      | ✓    | ✓          |         | ✓          |                |              |
+| **Mexc**        | ✓      | ✓    | ✓          |         | ✓          |                | ✓            |
 | **Okx**         | ✓      | ✓    | ✓          |         | ✓          |                | ✓            |
 ---
 
@@ -191,3 +191,53 @@ async def callback(trade: TradeDict) -> None:
 if __name__ == "__main__":
     asyncio.run(main())
 ```
+
+
+### Пример: Округление цен используя фоновый класс ExchangeInfo
+
+
+```python
+import asyncio
+from unicex import start_exchanges_info, get_exchange_info, Exchange
+
+
+async def main() -> None:
+    # ⏳ Запускаем фоновые процессы, которые собирают рыночные параметры всех бирж:
+    #  - количество знаков после точки для цены и объема
+    #  - множители контрактов для фьючерсов
+    await start_exchanges_info()
+
+    # Небольшая пауза, чтобы данные успели подгрузиться
+    await asyncio.sleep(1)
+
+    # 1️⃣ Пример 1: Округление цены для фьючерсов OKX
+    okx_exchange_info = get_exchange_info(Exchange.OKX)
+    okx_rounded_price = okx_exchange_info.round_futures_price("BTC-USDT-SWAP", 123456.1234567890)
+    print(okx_rounded_price)  # >> 123456.1
+
+    # 2️⃣ Пример 2: Округление объема для спота Binance
+    binance_exchange_info = get_exchange_info(Exchange.BINANCE)
+    binance_rounded_quantity = binance_exchange_info.round_quantity("BTCUSDT", 1.123456789)
+    print(binance_rounded_quantity)  # >> 1.12345
+
+    # 3️⃣ Пример 3: Получение множителя контракта (например, Mexc Futures)
+    mexc_exchange_info = get_exchange_info(Exchange.MEXC)
+    mexc_contract_multiplier = mexc_exchange_info.get_futures_ticker_info("BTC_USDT")["contract_size"]
+    print(mexc_contract_multiplier)  # >> 0.0001
+
+    # 4️⃣ Пример 4: Реальное применение — вычисляем тейк-профит вручную
+    # Допустим, позиция открыта по 123123.1 USDT, хотим +3.5% тейк-профит:
+    take_profit_raw = 123123.1 * 1.035
+    print("До округления:", take_profit_raw)  # >> 127432.40849999999
+
+    # Биржа требует цену в допустимом формате — округляем:
+    take_profit = okx_exchange_info.round_futures_price("BTC-USDT-SWAP", take_profit_raw)
+    print("После округления:", take_profit)  # >> 127432.4
+
+    # Теперь это число можно безопасно передать в API без ошибок:
+    # await client.create_order(symbol="BTC-USDT-SWAP", price=take_profit, ...)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

{unicex-0.11.0.dist-info → unicex-0.13.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-unicex/__init__.py,sha256=v3yO0P9GqC88cV4L-YSJ6h2YzlyOTnt1NPNLSJwhIRE,5806
-unicex/enums.py,sha256=8E_Nb57kriOif57XSLnW8joFufbthZTJ7tcExKWf1Wg,9633
+unicex/__init__.py,sha256=fnJ6Z68MRZKLY3SSz8Q2yhraq5t22QDagIvZKbVq3Uk,5804
+unicex/enums.py,sha256=8S72iJvD1Hd8i9EmF8KshJEEfAYe9dITVcIxBLREjn0,9625
 unicex/exceptions.py,sha256=r-xZzX78VuxVnI5pe99AM8FIiGcdIUDcF5CaTkQ4NE0,2213
-unicex/extra.py,sha256=MZRSsDRok05KZCqKur-hjOexZuoZ-tC9J6e-EIZr_lw,13824
-unicex/mapper.py,sha256=zOuInRQGJnSnwRI5yJ_axx-0svGn-nOqgLr7XXSlq14,4915
-unicex/types.py,sha256=cfuS07QVOgAhZsdME6CeY4lqO8KBBfrf_CJMN9DMB_s,4638
-unicex/utils.py,sha256=dwU1VYuP2xcMpzaETtNQerL1V8Y_JH8H8EsLJ__-M4s,8050
+unicex/extra.py,sha256=bU88Oh4-9Cvc2vuuf2fDGksUR7gvdluDh99O0m-vDFo,13830
+unicex/mapper.py,sha256=PPMC5E8smjmhXwiOCQG3WIc_-8wZ3iZGey6HiLiN7TQ,4903
+unicex/types.py,sha256=quGNpQm-_lSkijRKz04A5lPVxQ2PYrFzggYSPiJGzXI,4728
+unicex/utils.py,sha256=xzeP8E2bBoie8GvxW97FPEu_QPYMxiNgc9zX7yrdsfk,8048
 unicex/_abc/__init__.py,sha256=fxZjNFJFeFwWTXz8iSDe7eCWwE6xfFwFwAuG6l-TI8A,289
-unicex/_abc/exchange_info.py,sha256=j0nbTeF9-_LwHGDZLBHYF2Dd1DYBCQ-DlUO5N5tZgEY,7541
+unicex/_abc/exchange_info.py,sha256=NHBQAjknIRebyjl3musrvneN5u9vKYXjAca5PmTvJTw,9545
 unicex/_abc/uni_client.py,sha256=ZjxK8aqCGLUUYy1UQTM9EvWn1IXwMkH2Db8sZrs1e_I,13728
 unicex/_abc/uni_websocket_manager.py,sha256=yYKypPkIe3rKfWBuTsS8rkwIPljpd1588CYDkeTOYqE,9905
 unicex/_base/__init__.py,sha256=0TmevATGnRB3qow6tkCR8dQKNZCWKeib6YQjNJ4a1b0,236
@@ -15,7 +15,7 @@ unicex/_base/websocket.py,sha256=7IUIO2-KyjTswK3nTkRI7uQkNq6NYS_EhaG7tJQCPeg,114
 unicex/binance/__init__.py,sha256=sDk4ZjakRdpFMaMSpOCfqjf6ZPfAS9tlrt4WlDHtDkw,932
 unicex/binance/adapter.py,sha256=JbUFyjnDAFtyuYYrh90YeOvQOZQ6faim0nWS6U0NxXw,8799
 unicex/binance/client.py,sha256=1qPx0uRT4prC6saLBQ55pXDWcWTCKhYEwVIysiihPgU,60984
-unicex/binance/exchange_info.py,sha256=_1AEa9B8Id4aj4-0VPDBL3rWE0yqwj0KFwT9N97OSeA,353
+unicex/binance/exchange_info.py,sha256=LNDkgBC5HB3JxtIBi39puqDg6LIVWqIWjT-6akDxtMs,2437
 unicex/binance/uni_client.py,sha256=W4yxiU0kkJKPJjimhv4KAWreuEBwt7GgrWXefcw5BEA,8365
 unicex/binance/uni_websocket_manager.py,sha256=FywEuUt3CiDcAQPo3ItdW2pPgbLDvVpVYFM2D_QscPU,8679
 unicex/binance/user_websocket.py,sha256=HJ_3VZV0Bil0vfsdLrZElXm-gUqd8mGzXzfQ0_sHjFc,7861
@@ -23,7 +23,7 @@ unicex/binance/websocket_manager.py,sha256=Idrq0Qzi14QgpIG5d77S-r1h_BvRXphcxY2BT
 unicex/bitget/__init__.py,sha256=8govSOEyWjA62js-ZTQIiSYWSmcEUFSC9hVTpS8eosk,929
 unicex/bitget/adapter.py,sha256=frQBOKFsIB8mXc_Ime2-Iby_nRQlSpzXjshC5AxoDTA,7741
 unicex/bitget/client.py,sha256=RbOrW8Q21OwYFac2xrKQURdYSAkVQ0jj18cDoLj5Edk,90155
-unicex/bitget/exchange_info.py,sha256=oR0L60Ew4QDkNle5-e7CBmWBwTj-5IbW57CkEeTGDMw,352
+unicex/bitget/exchange_info.py,sha256=_UMvAqP0zcpmv9dkovkFxrXLlol6q8_v7-0sy6FSfrE,1959
 unicex/bitget/uni_client.py,sha256=MrXAmthTDTEQZ1ZY3LuqkCKL1bw_mKHMdiV4XiRFO-M,8641
 unicex/bitget/uni_websocket_manager.py,sha256=y-HXrREy_ruNeUzdRv5nHwBZQgbupxzp1UV-IFOpN_8,9793
 unicex/bitget/user_websocket.py,sha256=tlkv7Rmsw_FSfCJnEMOK_9jRsXRk2Ah_slqG8C-uhuo,129
@@ -31,23 +31,23 @@ unicex/bitget/websocket_manager.py,sha256=2OhH2gKy2gN03oYeCFvf3_l6RA29dDOvpajGhb
 unicex/bybit/__init__.py,sha256=SrMBh6K5zUt4JheWUpNUYNb1NCDr2ujTFv4IDguaGZI,926
 unicex/bybit/adapter.py,sha256=U6QP2eGefZqfXq7H4P1G9M23HieAjmylb5FnrHISn5s,8147
 unicex/bybit/client.py,sha256=U1mCcF-Mg2spiKlp0ucIA-kDOisYLO0edRS6XC16iNo,61014
-unicex/bybit/exchange_info.py,sha256=36WiJ49TxpSdZpeMwZdjQIkRdf2wJXahdkNxVaNjNRE,351
+unicex/bybit/exchange_info.py,sha256=6DySi-61kyU1Wpfp7G-5Zu7G1bFfcR4qo2oO5d0YutI,2200
 unicex/bybit/uni_client.py,sha256=0wmIRRgofuJXWvZMB1gHwuIEfoWuPhLJXthmK1f9w40,8382
 unicex/bybit/uni_websocket_manager.py,sha256=OpnvWD0xZ8T_By0HZCSg3jWoZqScRATAsku4IIBqhlw,10252
 unicex/bybit/user_websocket.py,sha256=IGGEnwyWs5jOppgK_R7SisBDvsiF1_piTswBrdQOgDg,128
 unicex/bybit/websocket_manager.py,sha256=ePHvngoqoVPr6p-BayoEGhCuRK-cJ69CAPzF94qTalQ,15404
-unicex/gateio/__init__.py,sha256=dsKvhQhDcw4_w0S4c9IjKkCoOg4DCUtSecEUOlfstug,929
-unicex/gateio/adapter.py,sha256=PE5lXQORAKLhzFZBtxcarNIt2xEcDrPrphxWS0k0wEk,6842
-unicex/gateio/client.py,sha256=LS-g44vSY8FHCnDjFKzM8gIoPwWpKv15JxQIgwSietI,53732
-unicex/gateio/exchange_info.py,sha256=x_jZT14vMt2Cv4AtGhkFiAuCv43t4hwqQ4tiEjJ-HPY,352
-unicex/gateio/uni_client.py,sha256=btfI-dozBRsbjEMvSlUX8zp6SOvIS1xDxk_5hNqRfz4,9648
-unicex/gateio/uni_websocket_manager.py,sha256=3KAHhgJNISTOZRBTwbZPigc8iq_IHS19NwnuAsnfeXg,9329
-unicex/gateio/user_websocket.py,sha256=4qZX9N2RjlJ-e25Eszz12OeCM17j5DdXVimBVaLj53w,129
-unicex/gateio/websocket_manager.py,sha256=phtHbvAGQD3mtewCUxBuuD1Nj0FXN6oZrd7tnmT7c2c,25832
+unicex/gate/__init__.py,sha256=dsKvhQhDcw4_w0S4c9IjKkCoOg4DCUtSecEUOlfstug,929
+unicex/gate/adapter.py,sha256=PE5lXQORAKLhzFZBtxcarNIt2xEcDrPrphxWS0k0wEk,6842
+unicex/gate/client.py,sha256=bhWkYBn5B4JKpLRfQERTVzisiCSg7mMi6mM0kh4Hes4,53760
+unicex/gate/exchange_info.py,sha256=ANzfe4mqxtLnj2TBJJxoc31KUosvxdApp1_xYrRNQDs,2300
+unicex/gate/uni_client.py,sha256=zJrxzWqp0g4hYV0kUKQRfWxMHcWoAnhgB4B5t_MfOng,9644
+unicex/gate/uni_websocket_manager.py,sha256=3KAHhgJNISTOZRBTwbZPigc8iq_IHS19NwnuAsnfeXg,9329
+unicex/gate/user_websocket.py,sha256=4qZX9N2RjlJ-e25Eszz12OeCM17j5DdXVimBVaLj53w,129
+unicex/gate/websocket_manager.py,sha256=phtHbvAGQD3mtewCUxBuuD1Nj0FXN6oZrd7tnmT7c2c,25832
 unicex/hyperliquid/__init__.py,sha256=qGTAkwfXLvknvHET_iA7Qml3jkxxxA0moU_98nGTcVU,944
 unicex/hyperliquid/adapter.py,sha256=0aULPGDhppjbRvShbR49GNt6qmw4o_CmrFi_xGVRLHg,10612
 unicex/hyperliquid/client.py,sha256=8YnPh_6Hj8vFYcPbMaPae6OfroFzn28VI6iL3FQfa84,84255
-unicex/hyperliquid/exchange_info.py,sha256=OBaBpAEij2Fv6q10rbQwGzBEU-5xGkCze_slEo9Q2N0,4128
+unicex/hyperliquid/exchange_info.py,sha256=D1h1fvH9DycRq-xDTZ_-Y1NC2JCp165IyWMXs39VjFI,4936
 unicex/hyperliquid/uni_client.py,sha256=4jv2uC076PBeq-EzCKvwaEEMk_M3HpsWA6iwNepJg7E,15674
 unicex/hyperliquid/uni_websocket_manager.py,sha256=AzR_8Aq98NkCA1oc2IiH02ysMOYLaisEmcuuaafeaJw,9334
 unicex/hyperliquid/user_websocket.py,sha256=BKD9ap2bx5DwpkkwwecfOTVedrZBR9eMAITgCBgg02w,134
@@ -55,7 +55,7 @@ unicex/hyperliquid/websocket_manager.py,sha256=GNBQT4ihk1XsTAaas8lxAfo3ASBGs_8EV
 unicex/mexc/__init__.py,sha256=lltANqM_2P-fmF5j8o5-pjmORPuK6C5sVjcQhuUU_R0,923
 unicex/mexc/adapter.py,sha256=uaJ6157wTrMuf72thIggDJHiaeRVYyH0qMIn1x5Mrp8,9820
 unicex/mexc/client.py,sha256=oJSpz-8hvA1WMCN2B7oqI2lXEx1_VJLAn8jbzhW8mF0,30950
-unicex/mexc/exchange_info.py,sha256=Nqzn4b791H3DLXsI6YZiY34VOZgHTG7evfRNWQnd9Nk,1329
+unicex/mexc/exchange_info.py,sha256=z2bQsVU0ciXV2_DFkueZHo1X35KIK2alD-7ZZjNg5Kc,1763
 unicex/mexc/uni_client.py,sha256=0unhbU3WfqrMsV_y15VnIFjwUzQLVtp1tx6spV6cHKI,9477
 unicex/mexc/uni_websocket_manager.py,sha256=MAKyGyit8Ve4doM7y8cTQbVVbpzlJx2HcHaSkLG4Jp4,9327
 unicex/mexc/user_websocket.py,sha256=l77-e6i0B2btd7a5IcCytbgswnV171NqOhunTcbaq48,127
@@ -79,15 +79,15 @@ unicex/mexc/_spot_ws_proto/PublicSpotKlineV3Api_pb2.py,sha256=0FOMsSO4jzMQ6446yZ
 unicex/mexc/_spot_ws_proto/PushDataV3ApiWrapper_pb2.py,sha256=_V0StMrDE7-bsdRPQdTC2XLGDGqJ5U_scx8ZjcyCGgk,3735
 unicex/mexc/_spot_ws_proto/__init__.py,sha256=L8Jft1713_M8CLR9drgSjLBdY_46sPT3O9zDFlxYvgc,11431
 unicex/okx/__init__.py,sha256=Ljbw3AP0YrPF5bIPJi_3JP3B_czR9xurYHI24rgWk9M,920
-unicex/okx/adapter.py,sha256=zXSLieRC80KY56ey1X-ss51uQ0QzouDxXppjcofLNRQ,5351
+unicex/okx/adapter.py,sha256=0sQ_7pYdUEBfXMUtNj8wJ9ECt-DJQ9ozUXi0WPAYevU,5724
 unicex/okx/client.py,sha256=2XL4YWPdRZYRMfLF1vSpkmwSd8Dxn8uyw5vCwDJab48,90969
-unicex/okx/exchange_info.py,sha256=q2DSVDq-JYN72LA5d_RX0C73Ha_xAxjeOobX8IxjpkM,2257
+unicex/okx/exchange_info.py,sha256=gkTwYnXgswa1FGLXdKo9qLYqZA0BS9VefpALhR4_t-Q,1772
 unicex/okx/uni_client.py,sha256=E_Wod0JSGt1K6k1mAIWnOv350pELbv-nic7g1KgOuos,8694
 unicex/okx/uni_websocket_manager.py,sha256=b4f_QjA64DJmENQdIGb5IOVc7kvit7KMCdWeCmRbxGY,9326
 unicex/okx/user_websocket.py,sha256=8c9kpm-xVa729pW93OKUGLHaE9MY0uzEpjIgNIFRF80,126
 unicex/okx/websocket_manager.py,sha256=wROXTUDqKzOE-wDnCtXso_MC4SzfPuPols5aPg_Z3y4,26027
-unicex-0.11.0.dist-info/licenses/LICENSE,sha256=lNNK4Vqak9cXm6qVJLhbqS7iR_BMj6k7fd7XQ6l1k54,1507
-unicex-0.11.0.dist-info/METADATA,sha256=w8bEftaxRniVPd4owyacH8aW6_usW0XoFA7k8oIbxRA,9148
-unicex-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-unicex-0.11.0.dist-info/top_level.txt,sha256=_7rar-0OENIg4KRy6cgjWiebFYAJhjKEcMggAocGWG4,7
-unicex-0.11.0.dist-info/RECORD,,
+unicex-0.13.1.dist-info/licenses/LICENSE,sha256=lNNK4Vqak9cXm6qVJLhbqS7iR_BMj6k7fd7XQ6l1k54,1507
+unicex-0.13.1.dist-info/METADATA,sha256=POGdHm6PX4PV12dOa5GmLlDSQ9W9-WxPI1unqjm0itY,11752
+unicex-0.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+unicex-0.13.1.dist-info/top_level.txt,sha256=_7rar-0OENIg4KRy6cgjWiebFYAJhjKEcMggAocGWG4,7
+unicex-0.13.1.dist-info/RECORD,,

unicex/gateio/exchange_info.py

@@ -1,12 +0,0 @@
-__all__ = ["ExchangeInfo"]
-
-from unicex._abc import IExchangeInfo
-
-
-class ExchangeInfo(IExchangeInfo):
-    """Предзагружает информацию о тикерах для биржи Gateio."""
-
-    @classmethod
-    async def _load_exchange_info(cls) -> None:
-        """Загружает информацию о бирже."""
-        ...