unicex 0.5.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

unicex/bybit/exchange_info.py

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

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/enums.py

@@ -26,18 +26,13 @@ class Exchange(StrEnum):
 
     BINANCE = "BINANCE"
     BITGET = "BITGET"
-    BITRUE = "BITRUE"
     BITUNIX = "BITUNIX"
-    BTSE = "BTSE"
     BYBIT = "BYBIT"
     GATEIO = "GATEIO"
     HYPERLIQUID = "HYPERLIQUID"
     KCEX = "KCEX"
-    KRAKEN = "KRAKEN"
-    KUCOIN = "KUCOIN"
     MEXC = "MEXC"
     OKX = "OKX"
-    WEEX = "WEEX"
     XT = "XT"
 
     def __add__(self, market_type: "MarketType") -> tuple["Exchange", "MarketType"]:
@@ -227,6 +222,22 @@ class Timeframe(StrEnum):
                 Timeframe.WEEK_1: "7d",
                 Timeframe.MONTH_1: "30d",
             },
+            Exchange.HYPERLIQUID: {
+                Timeframe.MIN_1: "1m",
+                Timeframe.MIN_3: "3m",
+                Timeframe.MIN_5: "5m",
+                Timeframe.MIN_15: "15m",
+                Timeframe.MIN_30: "30m",
+                Timeframe.HOUR_1: "1h",
+                Timeframe.HOUR_2: "2h",
+                Timeframe.HOUR_4: "4h",
+                Timeframe.HOUR_8: "8h",
+                Timeframe.HOUR_12: "12h",
+                Timeframe.DAY_1: "1d",
+                Timeframe.DAY_3: "3d",
+                Timeframe.WEEK_1: "1w",
+                Timeframe.MONTH_1: "1M",
+            },
         }
 
     def to_exchange_format(self, exchange: Exchange, market_type: MarketType | None = None) -> str:

unicex/extra.py

@@ -8,6 +8,8 @@ __all__ = [
     "generate_tv_link",
     "generate_cg_link",
     "make_humanreadable",
+    "normalize_ticker",
+    "normalize_symbol",
 ]
 
 import time
@@ -32,7 +34,7 @@ def percent_greater(higher: float, lower: float) -> float:
         `float`: На сколько процентов `higher` больше `lower`.
     """
     if lower == 0:
-        return float("inf")
+        return 0.0  # Не будем возвращать float('inf'), чтобы не ломать логику приложения
     return (higher / lower - 1) * 100
 
 
@@ -51,7 +53,7 @@ def percent_less(higher: float, lower: float) -> float:
         `float`: На сколько процентов `lower` меньше `higher`.
     """
     if lower == 0:
-        return float("inf")
+        return 0.0  # Не будем возвращать float('inf'), чтобы не ломать логику приложения
     return (1 - lower / higher) * 100
 
 
@@ -91,6 +93,76 @@ class TimeoutTracker[T]:
         self._blocked_items[item] = time.time() + duration
 
 
+def normalize_ticker(raw_ticker: str) -> str:
+    """Нормализует тикер и возвращает базовую валюту (например, `BTC`).
+
+    Эта функция принимает тикер в различных форматах (с разделителями, постфиксом SWAP,
+    в верхнем или нижнем регистре) и приводит его к стандартному виду — только базовый актив.
+
+    Примеры:
+        ```python
+        normalize_ticker("BTC-USDT")  # "BTC"
+        normalize_ticker("BTC-USDT-SWAP")  # "BTC"
+        normalize_ticker("btc_usdt")  # "BTC"
+        normalize_ticker("BTCUSDT")  # "BTC"
+        normalize_ticker("BTC")  # "BTC"
+        ```
+
+    Параметры:
+        raw_ticker (`str`): Исходный тикер в любом из распространённых форматов.
+
+    Возвращает:
+        `str`: Базовый актив в верхнем регистре (например, `"BTC"`).
+    """
+    ticker = raw_ticker.upper()
+
+    # Удаляем постфиксы SWAP
+    if ticker.endswith(("SWAP", "-SWAP", "_SWAP", ".SWAP")):
+        ticker = (
+            ticker.removesuffix("-SWAP")
+            .removesuffix("_SWAP")
+            .removesuffix(".SWAP")
+            .removesuffix("SWAP")
+        )
+
+    # Удаляем разделители
+    ticker = ticker.translate(str.maketrans("", "", "-_."))
+
+    # Убираем суффикс валюты котировки
+    for quote in ("USDT", "USDC"):
+        if ticker.endswith(quote):
+            ticker = ticker.removesuffix(quote)
+            break
+
+    return ticker
+
+
+def normalize_symbol(raw_ticker: str, quote: Literal["USDT", "USDC"] = "USDT") -> str:
+    """Нормализует тикер до унифицированного символа (например, `BTCUSDT`).
+
+    Функция принимает тикер в любом из популярных форматов и возвращает полный символ,
+    состоящий из базовой валюты и указанной валюты котировки (`USDT` или `USDC`).
+
+    Примеры:
+        ```python
+        normalize_symbol("BTC-USDT")  # "BTCUSDT"
+        normalize_symbol("BTC")  # "BTCUSDT"
+        normalize_symbol("btc_usdt_swap")  # "BTCUSDT"
+        normalize_symbol("ETH", "USDC")  # "ETHUSDC"
+        ```
+
+    Параметры:
+        raw_ticker (`str`): Исходный тикер в любом из распространённых форматов.
+        quote (`Literal["USDT", "USDC"]`, optional): Валюта котировки.
+            По умолчанию `"USDT"`.
+
+    Возвращает:
+        `str`: Символ в унифицированном формате, например `"BTCUSDT"`.
+    """
+    base = normalize_ticker(raw_ticker)
+    return f"{base}{quote}"
+
+
 def generate_ex_link(exchange: Exchange, market_type: MarketType, symbol: str):
     """Генерирует ссылку на биржу.
 
@@ -102,7 +174,8 @@ def generate_ex_link(exchange: Exchange, market_type: MarketType, symbol: str):
     Возвращает:
         `str`: Ссылка на биржу.
     """
-    ticker = symbol.removesuffix("USDT").removesuffix("_USDT").removesuffix("-USDT")
+    symbol = normalize_symbol(symbol)
+    ticker = normalize_ticker(symbol)
     if exchange == Exchange.BINANCE:
         if market_type == MarketType.FUTURES:
             return f"https://www.binance.com/en/futures/{symbol}"
@@ -152,7 +225,7 @@ def generate_ex_link(exchange: Exchange, market_type: MarketType, symbol: str):
         if market_type == MarketType.FUTURES:
             return f"https://app.hyperliquid.xyz/trade/{ticker}"
         else:
-            return f"https://www.kcex.com/ru-RU/exchange/{ticker}/USDC"
+            return f"https://app.hyperliquid.xyz/trade/{ticker}/USDC"
     else:
         raise NotSupported(f"Exchange {exchange} is not supported")
 
@@ -168,6 +241,7 @@ def generate_tv_link(exchange: Exchange, market_type: MarketType, symbol: str) -
     Возвращает:
         `str`: Ссылка для TradingView.
     """
+    symbol = normalize_symbol(symbol)
     if market_type == MarketType.FUTURES:
         return f"https://www.tradingview.com/chart/?symbol={exchange}:{symbol}.P"
     else:
@@ -187,6 +261,8 @@ def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -
     """
     base_url = "https://www.coinglass.com/tv/ru"
 
+    symbol = normalize_symbol(symbol)
+
     if market_type == MarketType.FUTURES:
         match exchange:
             case Exchange.OKX:
@@ -196,9 +272,11 @@ def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -
             case Exchange.BITGET:
                 return f"{base_url}/{exchange.capitalize()}_{symbol}_UMCBL"
             case Exchange.GATEIO:
-                return f"{base_url}/{exchange.capitalize()}_{symbol.replace('USDT', '_USDT')}"
+                return f"{base_url}/Gate_{symbol.replace('USDT', '_USDT')}"
             case Exchange.BITUNIX:
                 return f"{base_url}/{exchange.capitalize()}_{symbol}"
+            case Exchange.HYPERLIQUID:
+                return f"{base_url}/{exchange.capitalize()}_{symbol.replace('USDT', '-USD')}"
             case _:
                 return f"{base_url}/{exchange.capitalize()}_{symbol}"
     else:
@@ -206,7 +284,7 @@ def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -
         if exchange == Exchange.OKX:
             return f"{base_url}/SPOT_{exchange.upper()}_{symbol.replace('USDT', '-USDT')}"
         # Для остальных бирж ссылки нет → возвращаем заглушку
-        return base_url
+        return generate_cg_link(exchange, MarketType.FUTURES, symbol)
 
 
 def make_humanreadable(value: float, locale: Literal["ru", "en"] = "ru") -> str:

unicex/gateio/__init__.py

@@ -6,10 +6,22 @@ __all__ = [
     "UserWebsocket",
     "WebsocketManager",
     "UniWebsocketManager",
+    "ExchangeInfo",
 ]
 
 from .client import Client
+from .exchange_info import ExchangeInfo
 from .uni_client import UniClient
 from .uni_websocket_manager import UniWebsocketManager
 from .user_websocket import UserWebsocket
 from .websocket_manager import WebsocketManager
+
+
+async def load_exchange_info() -> None:
+    """Загружает информацию о бирже Gateio."""
+    await ExchangeInfo.load_exchange_info()
+
+
+async def start_exchange_info(parse_interval_seconds: int = 60 * 60) -> None:
+    """Запускает процесс обновления информации о бирже Gateio."""
+    await ExchangeInfo.start(parse_interval_seconds)

unicex/gateio/adapter.py

@@ -19,7 +19,7 @@ class Adapter:
     """Адаптер для унификации данных с Gateio 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]:
         """Преобразует сырой ответ о тикерах в список символов.
 
         Параметры:
@@ -32,11 +32,11 @@ class Adapter:
         return [
             item["currency_pair"]
             for item in raw_data
-            if not only_usdt or item["currency_pair"].endswith("USDT")
+            if item["currency_pair"].endswith("USDT") or not only_usdt
         ]
 
     @staticmethod
-    def futures_tickers(raw_data: list[dict], only_usdt: bool = True) -> list[str]:
+    def futures_tickers(raw_data: list[dict], only_usdt: bool) -> list[str]:
         """Преобразует сырой ответ о фьючерсных тикерах в список символов.
 
         Параметры:
@@ -49,7 +49,7 @@ class Adapter:
         return [
             item["contract"]
             for item in raw_data
-            if not only_usdt or item["contract"].endswith("USDT")
+            if item["contract"].endswith("USDT") or not only_usdt
         ]
 
     @staticmethod

unicex/gateio/exchange_info.py

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

unicex/hyperliquid/__init__.py

@@ -6,10 +6,22 @@ __all__ = [
     "UserWebsocket",
     "WebsocketManager",
     "UniWebsocketManager",
+    "ExchangeInfo",
 ]
 
 from .client import Client
+from .exchange_info import ExchangeInfo
 from .uni_client import UniClient
 from .uni_websocket_manager import UniWebsocketManager
 from .user_websocket import UserWebsocket
 from .websocket_manager import WebsocketManager
+
+
+async def load_exchange_info() -> None:
+    """Загружает информацию о бирже Hyperliquid."""
+    await ExchangeInfo.load_exchange_info()
+
+
+async def start_exchange_info(parse_interval_seconds: int = 60 * 60) -> None:
+    """Запускает процесс обновления информации о бирже Hyperliquid."""
+    await ExchangeInfo.start(parse_interval_seconds)

unicex/hyperliquid/adapter.py

@@ -3,80 +3,130 @@ __all__ = ["Adapter"]
 import time
 
 from unicex.types import (
+    KlineDict,
     OpenInterestDict,
     OpenInterestItem,
     TickerDailyDict,
     TickerDailyItem,
 )
-from unicex.utils import catch_adapter_errors, decorate_all_methods
 
+# from unicex.utils import catch_adapter_errors, decorate_all_methods
+from .exchange_info import ExchangeInfo
 
-@decorate_all_methods(catch_adapter_errors)
+
+# @decorate_all_methods(catch_adapter_errors)
 class Adapter:
     """Адаптер для унификации данных с Hyperliquid API."""
 
     @staticmethod
-    def tickers(raw_data: list) -> list[str]:
+    def tickers(raw_data: dict, resolve_symbols: bool) -> list[str]:
         """Преобразует данные Hyperliquid в список спотовых тикеров.
 
         Параметры:
-            raw_data (list): Сырой ответ с биржи.
+            raw_data (dict): Сырой ответ с биржи.
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
 
         Возвращает:
-            list[str]: Список тикеров (например, "PURR/USDC").
+            list[str]: Список тикеров (например, "@123").
         """
-        raise NotImplementedError()
+        if resolve_symbols:
+            return [ExchangeInfo.resolve_spot_symbol(item["name"]) for item in raw_data["universe"]]
+        else:
+            return [item["name"] for item in raw_data["universe"]]
 
     @staticmethod
-    def futures_tickers(raw_data: list) -> list[str]:
+    def futures_tickers(raw_data: dict) -> list[str]:
         """Преобразует данные Hyperliquid в список фьючерсных тикеров.
 
         Параметры:
-            raw_data (list): Сырой ответ с биржи.
+            raw_data (dict): Сырой ответ с биржи.
 
         Возвращает:
-            list[str]: Список тикеров.
+            list[str]: Список тикеров (например, "@123").
         """
-        universe = raw_data[0]["universe"]
-        return [item["name"] for item in universe]
+        return [item["name"] for item in raw_data["universe"]]
 
     @staticmethod
-    def last_price(raw_data: list) -> dict[str, float]:
+    def last_price(raw_data: dict, resolve_symbols: bool) -> dict[str, float]:
         """Преобразует данные о последних ценах (spot) в унифицированный формат.
 
         Параметры:
-            raw_data (list): Сырой ответ с биржи.
+            raw_data (dict): Сырой ответ с биржи.
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
 
         Возвращает:
             dict[str, float]: Словарь тикеров и последних цен.
         """
-        raise NotImplementedError()
+        if resolve_symbols:
+            return {
+                ExchangeInfo.resolve_spot_symbol(token): float(price)
+                for token, price in raw_data.items()
+                if token.startswith("@")
+            }
+        else:
+            return {
+                token: float(price) for token, price in raw_data.items() if token.startswith("@")
+            }
 
     @staticmethod
-    def futures_last_price(raw_data: list) -> dict[str, float]:
+    def futures_last_price(raw_data: dict) -> dict[str, float]:
         """Преобразует данные о последних ценах (futures) в унифицированный формат.
 
         Параметры:
-            raw_data (list): Сырой ответ с биржи.
+            raw_data (dict): Сырой ответ с биржи.
 
         Возвращает:
             dict[str, float]: Словарь тикеров и последних цен.
         """
-        universe = raw_data[0]["universe"]
-        metrics = raw_data[1]
-        return {universe[i]["name"]: float(item["markPx"]) for i, item in enumerate(metrics)}
+        return {k: v for k, v in raw_data.items() if not k.startswith("@")}
 
     @staticmethod
-    def ticker_24hr(raw_data: list) -> TickerDailyDict:
+    def ticker_24hr(raw_data: list, resolve_symbols: bool) -> TickerDailyDict:
         """Преобразует 24-часовую статистику (spot) в унифицированный формат.
 
         Параметры:
             raw_data (list): Сырой ответ с биржи.
+            resolve_symbols (bool): Если True, тикеры маппятся из вида "@123" в "BTC".
 
         Возвращает:
             TickerDailyDict: Словарь тикеров и их статистики.
         """
-        raise NotImplementedError()
+        metrics = raw_data[1]
+        result: TickerDailyDict = {}
+
+        for item in metrics:
+            try:
+                coin = item["coin"]
+
+                if resolve_symbols:
+                    coin = ExchangeInfo.resolve_spot_symbol(coin) or coin
+
+                prev_day_px = float(item.get("prevDayPx") or "0")
+                mid_px = float(item.get("midPx") or "0")
+                mark_px = float(item.get("markPx") or "0")
+                day_ntl_vlm = float(item.get("dayNtlVlm") or "0")
+
+                p = ((mark_px - prev_day_px) / prev_day_px * 100) if prev_day_px else 0.0
+                v = (day_ntl_vlm / mid_px) if mid_px else 0.0
+                q = day_ntl_vlm
+
+                if coin in result:
+                    # В случае с конфликтом оставляем ту монету, в которой больше дневного объема, т.к
+                    # для 6 монет (на 07.10.2025) встречаются пары к USDH, которые повторяют идентификатор.
+                    # Проблема не критичная - т.к. флаг resolve_symbols по идее использовать должен редко.
+                    prev_ticker_daily = result[coin]
+                    curr_ticker_daily = TickerDailyItem(p=p, v=v, q=q)
+                    if prev_ticker_daily["q"] > curr_ticker_daily["q"]:
+                        result[coin] = prev_ticker_daily
+                    else:
+                        result[coin] = curr_ticker_daily
+                else:
+                    result[coin] = TickerDailyItem(p=p, v=v, q=q)
+
+            except (KeyError, TypeError, ValueError):
+                continue
+
+        return result
 
     @staticmethod
     def futures_ticker_24hr(raw_data: list) -> TickerDailyDict:
@@ -90,16 +140,87 @@ class Adapter:
         """
         universe = raw_data[0]["universe"]
         metrics = raw_data[1]
-        return {
-            universe[i]["name"]: TickerDailyItem(
-                p=(float(item["markPx"]) - float(item["prevDayPx"]))
-                / float(item["prevDayPx"])
-                * 100,
-                v=float(item["dayNtlVlm"]) / float(item["oraclePx"]),
-                q=float(item["dayNtlVlm"]),
+
+        result: TickerDailyDict = {}
+
+        for i, item in enumerate(metrics):
+            try:
+                prev_day_px = float(item.get("prevDayPx", 0) or "0")
+                oracle_px = float(item.get("oraclePx", 0) or "0")
+                mark_px = float(item.get("markPx", 0) or "0")
+                day_ntl_vlm = float(item.get("dayNtlVlm", 0) or "0")
+
+                p = ((mark_px - prev_day_px) / prev_day_px * 100) if prev_day_px else 0.0
+                v = (day_ntl_vlm / oracle_px) if oracle_px else 0.0
+                q = day_ntl_vlm
+
+                result[universe[i]["name"]] = TickerDailyItem(p=p, v=v, q=q)
+            except (KeyError, TypeError, ValueError):
+                continue
+
+        return result
+
+    @staticmethod
+    def klines(raw_data: list[dict], resolve_symbols: bool) -> list[KlineDict]:
+        """Преобразует сырой ответ, в котором содержатся данные о свечах, в унифицированный формат.
+
+        Параметры:
+            raw_data (list[dict]): Сырой ответ с биржи.
+            resolve_symbols (bool): Если True, тикер маппится из вида "@123" в "BTC".
+
+        Возвращает:
+            list[KlineDict]: Список словарей, где каждый словарь содержит данные о свече.
+        """
+        return [
+            KlineDict(
+                s=kline["s"]
+                if not resolve_symbols
+                else ExchangeInfo.resolve_spot_symbol(kline["s"]),
+                t=kline["t"],
+                o=float(kline["o"]),
+                h=float(kline["h"]),
+                l=float(kline["l"]),
+                c=float(kline["c"]),
+                v=float(kline["v"]),
+                q=float(kline["v"]) * float(kline["c"]),
+                T=kline["T"],
+                x=None,
             )
-            for i, item in enumerate(metrics)
-        }
+            for kline in sorted(
+                raw_data,
+                key=lambda x: int(x["t"]),
+            )
+        ]
+
+    @staticmethod
+    def futures_klines(raw_data: list[dict]) -> list[KlineDict]:
+        """Преобразует сырой ответ, в котором содержатся данные о свечах, в унифицированный формат.
+
+        Параметры:
+            raw_data (list[dict]): Сырой ответ с биржи.
+            symbol (str): Символ тикера.
+
+        Возвращает:
+            list[KlineDict]: Список словарей, где каждый словарь содержит данные о свече.
+        """
+        return [
+            KlineDict(
+                s=kline["s"],
+                t=kline["t"],
+                o=float(kline["o"]),
+                h=float(kline["h"]),
+                l=float(kline["l"]),
+                c=float(kline["c"]),
+                v=float(kline["v"]),
+                q=float(kline["v"]) * float(kline["c"]),
+                T=kline["T"],
+                x=None,
+            )
+            for kline in sorted(
+                raw_data,
+                key=lambda x: int(x["t"]),
+            )
+        ]
 
     @staticmethod
     def funding_rate(raw_data: list) -> dict[str, float]: