unicex 0.1.16__tar.gz → 0.2.0__tar.gz

unicex-0.2.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: unicex
+Version: 0.2.0
+Summary: Unified Crypto Exchange API 
+Author-email: LoveBloodAndDiamonds <ayazshakirzyanov27@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, LoveBloodAndDiamonds
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Github, https://github.com/LoveBloodAndDiamonds/uni-cex-api
+Project-URL: Author, https://t.me/LoveBloodAndDiamonds
+Project-URL: Readthedocs, https://unicex.readthedocs.io/ru/latest/
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.12.15
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: orjson>=3.11.3
+Requires-Dist: websockets>=15.0.1
+Dynamic: license-file
+
+# Unified Crypto Exchange API
+
+`unicex` — асинхронная библиотека для работы с криптовалютными биржами, реализующая унифицированный интерфейс поверх «сырых» REST и WebSocket API разных бирж.
+
+## ✅ Статус реализации
+
+| Exchange | Client | UniClient | Adapter | WebsocketManager | UniWebsocketManager | UserWebsocket |
+|----------|--------|-----------|---------|------------------|---------------------|---------------|
+| Binance  | [x]    | [x]       | [x]     | [x]              | [x]                 | [x]           |
+| Bybit    | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Bitget   | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Okx      | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Mexc     | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Gate     | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+
+---
+
+## 🚀 Быстрый старт
+
+- Установка: `pip install unicex` или из исходников: `pip install -e .`
+- Библиотека полностью асинхронная. Примеры импорта:
+  - Сырые клиенты: `from unicex.binance import Client`
+  - Унифицированные клиенты: `from unicex.binance import UniClient`
+  - Менеджеры WS: `from unicex.binance import WebsocketManager, UniWebsocketManager`
+
+Пример: получить последние цены через унифицированный клиент Binance
+
+```
+import asyncio
+from unicex.binance import UniClient
+
+
+async def main():
+    client = await UniClient.create()
+    prices = await client.last_price()
+    print(prices["BTCUSDT"])
+    await client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Пример: подписаться на трейды через унифицированный WS‑менеджер Bitget
+
+```
+import asyncio
+from unicex.bitget import UniWebsocketManager
+from unicex import TradeDict
+
+
+async def on_trade(msg: TradeDict):
+    print(msg)
+
+
+async def main():
+    uwm = UniWebsocketManager()
+    socket = uwm.trades(callback=on_trade, symbol="BTCUSDT")
+    await socket.start()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## 🧑‍💻 Блок для разработчика
+
+### 📋 Todo
+- Добавить веса и рейт‑лимиты в документацию клиентов
+- Пересмотреть вопрос: должен ли быть адаптер интерфейсом?
+- Доделать BitgetClient и проверить типы
+- Добавить overload к методам с `None, None`
+- Определить порядок полей, возвращаемых адаптером
+- Написать 1–2 примера

unicex-0.2.0/README.md

@@ -0,0 +1,76 @@
+# Unified Crypto Exchange API
+
+`unicex` — асинхронная библиотека для работы с криптовалютными биржами, реализующая унифицированный интерфейс поверх «сырых» REST и WebSocket API разных бирж.
+
+## ✅ Статус реализации
+
+| Exchange | Client | UniClient | Adapter | WebsocketManager | UniWebsocketManager | UserWebsocket |
+|----------|--------|-----------|---------|------------------|---------------------|---------------|
+| Binance  | [x]    | [x]       | [x]     | [x]              | [x]                 | [x]           |
+| Bybit    | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Bitget   | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Okx      | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Mexc     | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+| Gate     | [ ]    | [ ]       | [ ]     | [ ]              | [ ]                 | [ ]           |
+
+---
+
+## 🚀 Быстрый старт
+
+- Установка: `pip install unicex` или из исходников: `pip install -e .`
+- Библиотека полностью асинхронная. Примеры импорта:
+  - Сырые клиенты: `from unicex.binance import Client`
+  - Унифицированные клиенты: `from unicex.binance import UniClient`
+  - Менеджеры WS: `from unicex.binance import WebsocketManager, UniWebsocketManager`
+
+Пример: получить последние цены через унифицированный клиент Binance
+
+```
+import asyncio
+from unicex.binance import UniClient
+
+
+async def main():
+    client = await UniClient.create()
+    prices = await client.last_price()
+    print(prices["BTCUSDT"])
+    await client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Пример: подписаться на трейды через унифицированный WS‑менеджер Bitget
+
+```
+import asyncio
+from unicex.bitget import UniWebsocketManager
+from unicex import TradeDict
+
+
+async def on_trade(msg: TradeDict):
+    print(msg)
+
+
+async def main():
+    uwm = UniWebsocketManager()
+    socket = uwm.trades(callback=on_trade, symbol="BTCUSDT")
+    await socket.start()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## 🧑‍💻 Блок для разработчика
+
+### 📋 Todo
+- Добавить веса и рейт‑лимиты в документацию клиентов
+- Пересмотреть вопрос: должен ли быть адаптер интерфейсом?
+- Доделать BitgetClient и проверить типы
+- Добавить overload к методам с `None, None`
+- Определить порядок полей, возвращаемых адаптером
+- Написать 1–2 примера

{unicex-0.1.16 → unicex-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ name = "unicex"
 # •	PATCH (x.y.Z) → увеличивается при багфиксе, который не ломает совместимость.
 # •	MINOR (x.Y.z) → увеличивается при добавлении новой функциональности, но без ломающих изменений (backward-compatible).
 # •	MAJOR (X.y.z) → увеличивается при изменениях, которые ломают обратную совместимость.
-version = "0.1.16"
+version = "0.2.0"
 
 description = "Unified Crypto Exchange API "
 readme = "README.md"
@@ -17,18 +17,19 @@ dependencies = [
     "aiohttp>=3.12.15",
     "loguru>=0.7.3",
     "orjson>=3.11.3",
-    "requests>=2.32.5",
-    "websocket-client>=1.8.0",
     "websockets>=15.0.1",
 ]
 
 [project.urls]
 Github = "https://github.com/LoveBloodAndDiamonds/uni-cex-api"
 Author = "https://t.me/LoveBloodAndDiamonds"
+Readthedocs = "https://unicex.readthedocs.io/ru/latest/"
 
 [dependency-groups]
 dev = [
     "build>=1.3.0",
     "pre-commit>=4.3.0",
+    "sphinx>=8.2.3",
+    "sphinx-rtd-theme>=3.0.2",
     "twine>=6.2.0",
 ]

{unicex-0.1.16 → unicex-0.2.0}/unicex/__init__.py

@@ -20,21 +20,31 @@ __all__ = [
     "IUniClient",
     "IUniWebsocketManager",
     "IAdapter",
-    "IUniAsyncClient",
-    "IUniAsyncWebsocketManager",
     # Base clients and websockets
     "Websocket",
     "BaseClient",
-    "AsyncWebsocket",
-    "BaseAsyncClient",
+    # Binance
+    "BinanceClient",
+    "BinanceUniClient",
+    "BinanceWebsocketManager",
+    "BinanceUniWebsocketManager",
+    # Bitget
+    "BitgetClient",
+    "BitgetUniClient",
+    "BitgetUniWebsocketManager",
+    "BitgetWebsocketManager",
 ]
 
 from ._abc import IAdapter, IUniClient, IUniWebsocketManager
-from ._abc.asyncio import IUniClient as IUniAsyncClient
-from ._abc.asyncio import IUniWebsocketManager as IUniAsyncWebsocketManager
 from ._base import BaseClient, Websocket
-from ._base.asyncio import BaseClient as BaseAsyncClient
-from ._base.asyncio import Websocket as AsyncWebsocket
+from .binance import Client as BinanceClient
+from .binance import UniClient as BinanceUniClient
+from .binance import UniWebsocketManager as BinanceUniWebsocketManager
+from .binance import WebsocketManager as BinanceWebsocketManager
+from .bitget import Client as BitgetClient
+from .bitget import UniClient as BitgetUniClient
+from .bitget import UniWebsocketManager as BitgetUniWebsocketManager
+from .bitget import WebsocketManager as BitgetWebsocketManager
 from .enums import Exchange, MarketType, Side, Timeframe
 from .mapper import get_uni_client, get_uni_websocket_manager
 from .types import AggTradeDict, KlineDict, LoggerLike, RequestMethod, TickerDailyDict, TradeDict

{unicex-0.1.16 → unicex-0.2.0}/unicex/_abc/__init__.py

@@ -5,4 +5,5 @@ __all__ = [
 ]
 
 from .adapter import IAdapter
-from .sync import IUniClient, IUniWebsocketManager
+from .uni_client import IUniClient
+from .uni_websocket_manager import IUniWebsocketManager

{unicex-0.1.16 → unicex-0.2.0}/unicex/_abc/adapter.py

@@ -1,3 +1,5 @@
+__all__ = ["IAdapter"]
+
 from abc import ABC, abstractmethod
 from typing import Any
 

{unicex-0.1.16/unicex/_abc/asyncio → unicex-0.2.0/unicex/_abc}/uni_client.py

@@ -6,12 +6,12 @@ from typing import Generic, Self, TypeVar, overload
 
 import aiohttp
 
-from unicex._base.asyncio import BaseClient
+from unicex._base import BaseClient
 from unicex.enums import Timeframe
 from unicex.types import KlineDict, LoggerLike, TickerDailyDict
 from unicex.utils import batched_list
 
-from ..adapter import IAdapter
+from .adapter import IAdapter
 
 TClient = TypeVar("TClient", bound="BaseClient")
 

{unicex-0.1.16/unicex/_abc/asyncio → unicex-0.2.0/unicex/_abc}/uni_websocket_manager.py

@@ -6,7 +6,7 @@ from typing import Any, overload
 
 from loguru import logger as _logger
 
-from unicex._base.asyncio import BaseClient, Websocket
+from unicex._base import BaseClient, Websocket
 from unicex.enums import Timeframe
 from unicex.types import LoggerLike
 

{unicex-0.1.16/unicex/_base/asyncio → unicex-0.2.0/unicex/_base}/websocket.py

@@ -183,7 +183,12 @@ class Websocket:
                 break
             except Exception as e:
                 self._logger.error(f"{self} Error({type(e)}) while processing message: {e}")
-            self._queue.task_done()
+
+            try:
+                self._queue.task_done()
+            except Exception as e:
+                if self._running:
+                    self._logger.error(f"{self} Error({type(e)}) while marking task done: {e}")
 
     def _generate_ws_kwargs(self) -> dict:
         """Генерирует аргументы для запуска вебсокета."""

{unicex-0.1.16/unicex/binance/asyncio → unicex-0.2.0/unicex/binance}/__init__.py

@@ -1,4 +1,4 @@
-"""Пакет содержит асинхронные клиенты и менеджеры для работы с биржей Binance."""
+"""Пакет, содержащий реализации клиентов и менеджеров для работы с биржей Binance."""
 
 __all__ = ["Client", "UniClient", "UserWebsocket", "WebsocketManager", "UniWebsocketManager"]
 

{unicex-0.1.16 → unicex-0.2.0}/unicex/binance/adapter.py

@@ -2,14 +2,15 @@ __all__ = ["Adapter"]
 
 
 from unicex._abc import IAdapter
-from unicex.exceptions import AdapterError
 from unicex.types import AggTradeDict, KlineDict, TickerDailyDict, TradeDict
+from unicex.utils import catch_adapter_errors
 
 
 class Adapter(IAdapter):
     """Адаптер для унификации данных с Binance API."""
 
     @staticmethod
+    @catch_adapter_errors
     def tickers(raw_data: list[dict], only_usdt: bool = True) -> list[str]:
         """Преобразует сырой ответ, в котором содержатся данные о тикерах в список тикеров.
 
@@ -20,18 +21,12 @@ class Adapter(IAdapter):
         Возвращает:
             list[str]: Список тикеров.
         """
-        try:
-            return [
-                item["symbol"]
-                for item in raw_data
-                if not only_usdt or item["symbol"].endswith("USDT")
-            ]
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_data} to unified tickers."
-            ) from e
+        return [
+            item["symbol"] for item in raw_data if not only_usdt or item["symbol"].endswith("USDT")
+        ]
 
     @staticmethod
+    @catch_adapter_errors
     def futures_tickers(raw_data: list[dict], only_usdt: bool = True) -> list[str]:
         """Преобразует сырой ответ, в котором содержатся данные о тикерах в список тикеров.
 
@@ -45,6 +40,7 @@ class Adapter(IAdapter):
         return Adapter.tickers(raw_data, only_usdt)
 
     @staticmethod
+    @catch_adapter_errors
     def ticker_24h(raw_data: list[dict]) -> dict[str, TickerDailyDict]:
         """Преобразует сырой ответ, в котором содержатся данные о тикере за последние 24 часа в унифицированный формат.
 
@@ -54,21 +50,17 @@ class Adapter(IAdapter):
         Возвращает:
             dict[str, TickerDailyDict]: Словарь, где ключ - тикер, а значение - статистика за последние 24 часа.
         """
-        try:
-            return {
-                item["symbol"]: TickerDailyDict(
-                    p=float(item["priceChangePercent"]),
-                    q=float(item["quoteVolume"]),  # объём в долларах
-                    v=float(item["volume"]),  # объём в монетах
-                )
-                for item in raw_data
-            }
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_data} to unified ticker 24h."
-            ) from e
+        return {
+            item["symbol"]: TickerDailyDict(
+                p=float(item["priceChangePercent"]),
+                q=float(item["quoteVolume"]),  # объём в долларах
+                v=float(item["volume"]),  # объём в монетах
+            )
+            for item in raw_data
+        }
 
     @staticmethod
+    @catch_adapter_errors
     def futures_ticker_24h(raw_data: list[dict]) -> dict[str, TickerDailyDict]:
         """Преобразует сырой ответ, в котором содержатся данные о тикере за последние 24 часа в унифицированный формат.
 
@@ -81,6 +73,7 @@ class Adapter(IAdapter):
         return Adapter.ticker_24h(raw_data)
 
     @staticmethod
+    @catch_adapter_errors
     def last_price(raw_data: list[dict]) -> dict[str, float]:
         """Преобразует сырой ответ, в котором содержатся данные о тикере за последние 24 часа в унифицированный формат.
 
@@ -90,14 +83,10 @@ class Adapter(IAdapter):
         Возвращает:
             dict[str, float]: Словарь, где ключ - тикер, а значение - последняя цена.
         """
-        try:
-            return {item["symbol"]: float(item["price"]) for item in raw_data}
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_data} to unified last price."
-            ) from e
+        return {item["symbol"]: float(item["price"]) for item in raw_data}
 
     @staticmethod
+    @catch_adapter_errors
     def futures_last_price(raw_data: list[dict]) -> dict[str, float]:
         """Преобразует сырой ответ, в котором содержатся данные о тикере за последние 24 часа в унифицированный формат.
 
@@ -110,6 +99,7 @@ class Adapter(IAdapter):
         return Adapter.last_price(raw_data)
 
     @staticmethod
+    @catch_adapter_errors
     def klines(raw_data: list[list]) -> list[KlineDict]:
         """Преобразует сырой ответ, в котором содержатся данные о котировках тикеров в унифицированный формат.
 
@@ -119,28 +109,24 @@ class Adapter(IAdapter):
         Возвращает:
             list[KlineDict]: Список словарей, где каждый словарь содержит данные о свече.
         """
-        try:
-            return [
-                KlineDict(
-                    s="",
-                    t=item[0],
-                    o=float(item[1]),
-                    h=float(item[2]),
-                    l=float(item[3]),
-                    c=float(item[4]),
-                    v=float(item[5]),
-                    q=float(item[7]),
-                    T=item[6],
-                    x=None,
-                )
-                for item in raw_data
-            ]
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_data} to unified kline."
-            ) from e
+        return [
+            KlineDict(
+                s="",
+                t=item[0],
+                o=float(item[1]),
+                h=float(item[2]),
+                l=float(item[3]),
+                c=float(item[4]),
+                v=float(item[5]),
+                q=float(item[7]),
+                T=item[6],
+                x=None,
+            )
+            for item in raw_data
+        ]
 
     @staticmethod
+    @catch_adapter_errors
     def futures_klines(raw_data: list[list]) -> list[KlineDict]:
         """Преобразует сырой ответ, в котором содержатся данные о котировках тикеров в унифицированный формат.
 
@@ -153,6 +139,7 @@ class Adapter(IAdapter):
         return Adapter.klines(raw_data)
 
     @staticmethod
+    @catch_adapter_errors
     def funding_rate(raw_data: list[dict]) -> dict[str, float]:
         """Преобразует сырой ответ, в котором содержатся данные о ставках финансирования тикеров в унифицированный формат.
 
@@ -162,14 +149,10 @@ class Adapter(IAdapter):
         Возвращает:
             dict[str, float]: Словарь, где ключ - тикер, а значение - ставка финансирования.
         """
-        try:
-            return {item["symbol"]: float(item["lastFundingRate"]) * 100 for item in raw_data}
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_data} to unified funding rate."
-            ) from e
+        return {item["symbol"]: float(item["lastFundingRate"]) * 100 for item in raw_data}
 
     @staticmethod
+    @catch_adapter_errors
     def klines_message(raw_msg: dict) -> list[KlineDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         свече/свечах в унифицированный вид.
@@ -180,29 +163,25 @@ class Adapter(IAdapter):
         Возвращает:
             list[KlineDict]: Список словарей, где каждый словарь содержит данные о свече.
         """
-        try:
-            # Обрабатываем обертку в случае с multiplex stream
-            kline = raw_msg.get("data", raw_msg)["k"]
-            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"]),  # Используем quote volume (в USDT)
-                    q=float(kline["q"]),  # Используем quote volume (в USDT)
-                    T=kline["T"],
-                    x=kline["x"],
-                )
-            ]
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_msg} to unified kline."
-            ) from e
+        # Обрабатываем обертку в случае с multiplex stream
+        kline = raw_msg.get("data", raw_msg)["k"]
+        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"]),  # Используем quote volume (в USDT)
+                q=float(kline["q"]),  # Используем quote volume (в USDT)
+                T=kline["T"],
+                x=kline["x"],
+            )
+        ]
 
     @staticmethod
+    @catch_adapter_errors
     def futures_klines_message(raw_msg: dict) -> list[KlineDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         свече/свечах в унифицированный вид.
@@ -216,6 +195,7 @@ class Adapter(IAdapter):
         return Adapter.klines_message(raw_msg)
 
     @staticmethod
+    @catch_adapter_errors
     def aggtrades_message(raw_msg: dict) -> list[AggTradeDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         аггрегированных сделке/сделках в унифицированный вид.
@@ -226,23 +206,19 @@ class Adapter(IAdapter):
         Возвращает:
             list[KlineDict]: Список словарей, где каждый словарь содержит данные о сделке.
         """
-        try:
-            msg = raw_msg.get("data", raw_msg)
-            return [
-                AggTradeDict(
-                    t=int(msg["T"]),
-                    s=str(msg["s"]),
-                    S="SELL" if bool(msg["m"]) else "BUY",
-                    p=float(msg["p"]),
-                    v=float(msg["q"]),
-                )
-            ]
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_msg} to unified aggtrade."
-            ) from e
+        msg = raw_msg.get("data", raw_msg)
+        return [
+            AggTradeDict(
+                t=int(msg["T"]),
+                s=str(msg["s"]),
+                S="SELL" if bool(msg["m"]) else "BUY",
+                p=float(msg["p"]),
+                v=float(msg["q"]),
+            )
+        ]
 
     @staticmethod
+    @catch_adapter_errors
     def futures_aggtrades_message(raw_msg: dict) -> list[AggTradeDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         аггрегированных сделке/сделках в унифицированный вид.
@@ -256,6 +232,7 @@ class Adapter(IAdapter):
         return Adapter.aggtrades_message(raw_msg)
 
     @staticmethod
+    @catch_adapter_errors
     def trades_message(raw_msg: dict) -> list[TradeDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         сделке/сделках в унифицированный вид.
@@ -266,23 +243,19 @@ class Adapter(IAdapter):
         Возвращает:
             list[KlineDict]: Список словарей, где каждый словарь содержит данные о сделке.
         """
-        try:
-            msg = raw_msg.get("data", raw_msg)
-            return [
-                TradeDict(
-                    t=int(msg["T"]),
-                    s=str(msg["s"]),
-                    S="SELL" if bool(msg["m"]) else "BUY",
-                    p=float(msg["p"]),
-                    v=float(msg["q"]),
-                )
-            ]
-        except Exception as e:
-            raise AdapterError(
-                f"({type(e)}): {e}. Can not convert {raw_msg} to unified trade."
-            ) from e
+        msg = raw_msg.get("data", raw_msg)
+        return [
+            TradeDict(
+                t=int(msg["T"]),
+                s=str(msg["s"]),
+                S="SELL" if bool(msg["m"]) else "BUY",
+                p=float(msg["p"]),
+                v=float(msg["q"]),
+            )
+        ]
 
     @staticmethod
+    @catch_adapter_errors
     def futures_trades_message(raw_msg: dict) -> list[TradeDict]:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         сделке/сделках в унифицированный вид.
@@ -296,6 +269,7 @@ class Adapter(IAdapter):
         return Adapter.trades_message(raw_msg)
 
     @staticmethod
+    @catch_adapter_errors
     def open_interest(raw_data: dict) -> float:
         """Преобразует сырое сообщение с вебсокета, в котором содержится информация о
         объеме открытых позиций в унифицированный вид.
@@ -306,9 +280,4 @@ class Adapter(IAdapter):
         Возвращает:
             float: Объем открытых позиций в монетах.
         """
-        try:
-            return float(raw_data["openInterest"])
-        except Exception as e:
-            raise AdapterError(
-                f"{type(e)}: {e}. Can not convert {raw_data} to unified open interest."
-            ) from e
+        return float(raw_data["openInterest"])