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

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

@@ -7,9 +7,11 @@ __all__ = [
     "generate_ex_link",
     "generate_tv_link",
     "generate_cg_link",
+    "make_humanreadable",
 ]
 
 import time
+from typing import Literal
 
 from .enums import Exchange, MarketType
 from .exceptions import NotSupported
@@ -205,3 +207,50 @@ def generate_cg_link(exchange: Exchange, market_type: MarketType, symbol: str) -
             return f"{base_url}/SPOT_{exchange.upper()}_{symbol.replace('USDT', '-USDT')}"
         # Для остальных бирж ссылки нет → возвращаем заглушку
         return base_url
+
+
+def make_humanreadable(value: float, locale: Literal["ru", "en"] = "ru") -> str:
+    """Функция превращает большие числа в удобочитаемый вид.
+
+    Принимает:
+        value (float): число для преобразования
+        locale (Literal["ru", "en"]): язык для форматирования числа
+
+    Возвращает:
+        str: Человеческое представление числа
+    """
+    suffixes = {
+        "ru": {
+            1_000: "тыс.",
+            1_000_000: "млн.",
+            1_000_000_000: "млрд.",
+            1_000_000_000_000: "трлн.",
+            1_000_000_000_000_000: "квдрлн.",
+            1_000_000_000_000_000_000: "квнтлн.",
+        },
+        "en": {
+            1_000: "K",
+            1_000_000: "M",
+            1_000_000_000: "B",
+            1_000_000_000_000: "T",
+            1_000_000_000_000_000: "Qa",  # Quadrillion
+            1_000_000_000_000_000_000: "Qi",  # Quintillion
+        },
+    }
+
+    selected_suffixes = suffixes[locale]
+
+    for divisor in sorted(selected_suffixes.keys(), reverse=True):
+        if abs(value) >= divisor:
+            number = value / divisor
+            if locale == "ru":
+                return (
+                    f"{number:,.2f}".replace(",", " ").replace(".", ",")
+                    + f" {selected_suffixes[divisor]}"
+                )
+            return f"{number:,.2f} {selected_suffixes[divisor]}"
+
+    # Форматирование "малых" чисел
+    if locale == "ru":
+        return f"{value:,.2f}".replace(",", " ").replace(".", ",")
+    return f"{value:,.2f}"

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

@@ -32,7 +32,7 @@ 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
@@ -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,119 @@ __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
+
+                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 +129,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]: