dcex 0.7.0__py3-none-any.whl

dcex/__init__.py

@@ -0,0 +1,59 @@
+"""
+dcex - dex & cex trading library.
+
+A comprehensive library for cryptocurrency exchange interactions with both sync and async support.
+Automatically handles Jupyter Notebook compatibility with nest_asyncio.
+"""
+
+from typing import Any
+
+from .binance.client import Client as BinanceClient
+from .bitmart.client import Client as BitmartClient
+from .bitmex.client import Client as BitmexClient
+from .bybit.client import Client as BybitClient
+from .gateio.client import Client as GateioClient
+from .okx.client import Client as OKXClient
+from .utils.jupyter_helper import auto_apply_nest_asyncio
+
+auto_apply_nest_asyncio(verbose=False)
+
+
+# Create callable functions for each exchange (synchronous clients)
+def binance(**kwargs: Any) -> BinanceClient:  # noqa: ANN401
+    """Create a Binance client instance."""
+    return BinanceClient(**kwargs)
+
+
+def bitmart(**kwargs: Any) -> BitmartClient:  # noqa: ANN401
+    """Create a BitMart client instance."""
+    return BitmartClient(**kwargs)
+
+
+def bitmex(**kwargs: Any) -> BitmexClient:  # noqa: ANN401
+    """Create a BitMEX client instance."""
+    return BitmexClient(**kwargs)
+
+
+def bybit(**kwargs: Any) -> BybitClient:  # noqa: ANN401
+    """Create a Bybit client instance."""
+    return BybitClient(**kwargs)
+
+
+def gateio(**kwargs: Any) -> GateioClient:  # noqa: ANN401
+    """Create a Gate.io client instance."""
+    return GateioClient(**kwargs)
+
+
+def okx(**kwargs: Any) -> OKXClient:  # noqa: ANN401
+    """Create an OKX client instance."""
+    return OKXClient(**kwargs)
+
+
+__all__ = [
+    "binance",
+    "bitmart",
+    "bitmex",
+    "bybit",
+    "gateio",
+    "okx",
+]

dcex/async_support/__init__.py

@@ -0,0 +1,104 @@
+"""
+Async exchange entry points.
+
+This module exposes coroutine factory functions for each supported exchange,
+which return an initialized async client (after awaiting `async_init`).
+"""
+
+# Import exchange client classes and create callable functions
+from typing import Any, cast
+
+from .binance.client import Client as BinanceClient
+from .bingx.client import Client as BingXClient
+from .bitmart.client import Client as BitmartClient
+from .bitmex.client import Client as BitmexClient
+from .bybit.client import Client as BybitClient
+from .gateio.client import Client as GateioClient
+from .hyperliquid.client import Client as HyperliquidClient
+from .kucoin.client import Client as KuCoinClient
+from .okx.client import Client as OKXClient
+from .zoomex.client import Client as ZoomexClient
+
+
+async def binance(
+    **kwargs: Any,  # noqa: ANN401
+) -> BinanceClient:
+    """Create and initialize a Binance client instance."""
+    return cast(BinanceClient, await BinanceClient(**kwargs).async_init())
+
+
+async def bingx(
+    **kwargs: Any,  # noqa: ANN401
+) -> BingXClient:
+    """Create and initialize a BingX client instance."""
+    return cast(BingXClient, await BingXClient(**kwargs).async_init())
+
+
+async def bitmart(
+    **kwargs: Any,  # noqa: ANN401
+) -> BitmartClient:
+    """Create and initialize a BitMart client instance."""
+    return cast(BitmartClient, await BitmartClient(**kwargs).async_init())
+
+
+async def bitmex(
+    **kwargs: Any,  # noqa: ANN401
+) -> BitmexClient:
+    """Create and initialize a BitMEX client instance."""
+    return cast(BitmexClient, await BitmexClient(**kwargs).async_init())
+
+
+async def bybit(
+    **kwargs: Any,  # noqa: ANN401
+) -> BybitClient:
+    """Create and initialize a Bybit client instance."""
+    return cast(BybitClient, await BybitClient(**kwargs).async_init())
+
+
+async def gateio(
+    **kwargs: Any,  # noqa: ANN401
+) -> GateioClient:
+    """Create and initialize a Gate.io client instance."""
+    return cast(GateioClient, await GateioClient(**kwargs).async_init())
+
+
+async def hyperliquid(
+    **kwargs: Any,  # noqa: ANN401
+) -> HyperliquidClient:
+    """Create and initialize a Hyperliquid client instance."""
+    return cast(HyperliquidClient, await HyperliquidClient(**kwargs).async_init())
+
+
+async def kucoin(
+    **kwargs: Any,  # noqa: ANN401
+) -> KuCoinClient:
+    """Create and initialize a KuCoin client instance."""
+    return cast(KuCoinClient, await KuCoinClient(**kwargs).async_init())
+
+
+async def okx(
+    **kwargs: Any,  # noqa: ANN401
+) -> OKXClient:
+    """Create and initialize an OKX client instance."""
+    return cast(OKXClient, await OKXClient(**kwargs).async_init())
+
+
+async def zoomex(
+    **kwargs: Any,  # noqa: ANN401
+) -> ZoomexClient:
+    """Create and initialize a Zoomex client instance."""
+    return cast(ZoomexClient, await ZoomexClient(**kwargs).async_init())
+
+
+__all__ = [
+    "binance",
+    "bingx",
+    "bitmart",
+    "bitmex",
+    "bybit",
+    "gateio",
+    "hyperliquid",
+    "kucoin",
+    "okx",
+    "zoomex",
+]

dcex/async_support/binance/__init__.py

@@ -0,0 +1,3 @@
+from .client import Client
+
+__all__ = ["Client"]

dcex/async_support/binance/_account_http.py

@@ -0,0 +1,74 @@
+from ...utils.common import Common
+from ._http_manager import HTTPManager
+from .endpoints.account import FuturesAccount, SpotAccount
+from .enums import BinanceProductType
+
+
+class AccountHTTP(HTTPManager):
+    """HTTP client for Binance account-related API endpoints."""
+
+    async def get_account_balance(
+        self,
+        market_type: str,
+    ) -> dict:
+        """
+        Get account balance.
+
+        Args:
+            market_type: Market type ("spot" or "swap")
+
+        Returns:
+            dict: Account balance information
+        """
+        res = await self._request(
+            method="GET",
+            path=SpotAccount.ACCOUNT_BALANCE
+            if market_type == BinanceProductType.SPOT
+            else FuturesAccount.ACCOUNT_BALANCE,
+            query={},
+        )
+        return res
+
+    async def get_income_history(
+        self,
+        product_symbol: str | None = None,
+        incomeType: str | None = None,
+        startTime: int | None = None,
+        endTime: int | None = None,
+        page: int | None = None,
+        limit: int | None = None,
+    ) -> dict:
+        """
+        Get futures income history.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+            incomeType: Income type (TRANSFER, WELCOME_BONUS, REALIZED_PNL, FUNDING_FEE, etc.)
+            startTime: Start time in milliseconds
+            endTime: End time in milliseconds
+            page: Page number for pagination
+            limit: Number of records per page
+
+        Returns:
+            dict: Income history data
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+        if incomeType is not None:
+            payload["incomeType"] = incomeType
+        if startTime is not None:
+            payload["startTime"] = startTime
+        if endTime is not None:
+            payload["endTime"] = endTime
+        if page is not None:
+            payload["page"] = page
+        if limit is not None:
+            payload["limit"] = limit
+
+        res = await self._request(
+            method="GET",
+            path=FuturesAccount.INCOME_HISTORY,
+            query=payload,
+        )
+        return res

dcex/async_support/binance/_http_manager.py

@@ -0,0 +1,141 @@
+import hashlib
+import hmac
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Self
+from urllib.parse import urlencode
+
+import httpx
+
+from ...utils.common import Common
+from ...utils.errors import FailedRequestError
+from ...utils.helpers import generate_timestamp
+from ..product_table.manager import ProductTableManager
+from .endpoints.account import FuturesAccount, SpotAccount
+from .endpoints.market import FuturesMarket, SpotMarket
+from .endpoints.trade import FuturesTrade, SpotTrade
+
+
+@dataclass
+class HTTPManager:
+    api_key: str | None = field(default=None)
+    api_secret: str | None = field(default=None)
+    timeout: int = field(default=10)
+    logger: logging.Logger | None = field(default=None)
+    session: httpx.AsyncClient | None = field(default=None, init=False)
+    ptm: ProductTableManager = field(init=False)
+    preload_product_table: bool = field(default=True)
+
+    api_map = {
+        "https://fapi.binance.com": {
+            FuturesTrade,
+            FuturesMarket,
+            FuturesAccount,
+        },
+        "https://api.binance.com": {
+            SpotMarket,
+            SpotTrade,
+            SpotAccount,
+        },
+    }
+
+    async def async_init(self) -> Self:
+        self.session = httpx.AsyncClient(timeout=self.timeout)
+        self._logger = self.logger or logging.getLogger(__name__)
+        if self.preload_product_table:
+            self.ptm = await ProductTableManager.get_instance(Common.BINANCE)
+        return self
+
+    def _get_base_url(
+        self,
+        path: SpotAccount | FuturesAccount | SpotMarket | FuturesMarket | SpotTrade | FuturesTrade,
+    ) -> str:
+        for base_url, enums in self.api_map.items():
+            if type(path) in enums:
+                return base_url
+        raise ValueError(f"Unknown API path: {path} (type={type(path)})")
+
+    def _sign(self, params: dict) -> str:
+        if self.api_secret is None:
+            raise ValueError("API secret is required for signing")
+        query_string = urlencode(params)
+        return hmac.new(self.api_secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()
+
+    def _headers(self) -> dict[str, str]:
+        return {"X-MBX-APIKEY": self.api_key} if self.api_key else {}
+
+    async def _request(
+        self,
+        method: str,
+        path: SpotAccount | FuturesAccount | SpotMarket | FuturesMarket | SpotTrade | FuturesTrade,
+        query: dict | None = None,
+        signed: bool = True,
+    ) -> dict:
+        if self.session is None or self.session.is_closed:
+            await self.async_init()
+
+        if query is None:
+            query = {}
+
+        if signed:
+            if not (self.api_key and self.api_secret):
+                raise ValueError("Signed request requires API Key and Secret.")
+            query["timestamp"] = int(time.time() * 1000)
+            query["recvWindow"] = 5000
+            query["signature"] = self._sign(query)
+
+        response = None
+        try:
+            if self.session is None:
+                raise ValueError("Session is not initialized")
+            base_url = self._get_base_url(path)
+            url = f"{base_url}{path}"
+            if method.upper() == "GET":
+                url += f"?{urlencode(query)}" if query else ""
+                response = await self.session.get(url, headers=self._headers())
+            elif method.upper() == "POST":
+                response = await self.session.post(url, headers=self._headers(), data=query)
+            elif method.upper() == "DELETE":
+                url += f"?{urlencode(query)}" if query else ""
+                response = await self.session.delete(url, headers=self._headers())
+            else:
+                raise ValueError(f"Unsupported method: {method}")
+
+        except httpx.RequestError as e:
+            raise FailedRequestError(
+                request=f"{method.upper()} {url} | Params: {query}",
+                message=f"Request failed: {str(e)}",
+                status_code=response.status_code if response else "Unknown",
+                time=str(query.get("timestamp", "Unknown")),
+                resp_headers=dict(response.headers) if response else None,
+            ) from e
+        else:
+            try:
+                data = response.json()
+            except Exception:
+                data = {}
+
+            timestamp = generate_timestamp(iso_format=True)
+
+            if isinstance(data, dict) and "code" in data and str(data["code"]) != "200":
+                code = data.get("code", "Unknown")
+                error_message = data.get("msg", "Unknown error")
+                raise FailedRequestError(
+                    request=f"{method} {url} | Body: {query}",
+                    message=f"BINANCE API Error: [{code}] {error_message}",
+                    status_code=response.status_code,
+                    time=str(timestamp),
+                    resp_headers=dict(response.headers),
+                )
+
+            if not response.status_code // 100 == 2:
+                raise FailedRequestError(
+                    request=f"{method.upper()} {url} | Body: {query}",
+                    message=f"HTTP Error {response.status_code}: {response.text}",
+                    status_code=response.status_code,
+                    time=str(timestamp),
+                    resp_headers=dict(response.headers),
+                )
+
+            return data

dcex/async_support/binance/_market_http.py

@@ -0,0 +1,276 @@
+from ...utils.common import Common
+from ._http_manager import HTTPManager
+from .endpoints.market import FuturesMarket, SpotMarket
+from .enums import BinanceProductType
+
+
+class MarketHTTP(HTTPManager):
+    """HTTP client for Binance market data API endpoints."""
+
+    async def get_spot_exchange_info(
+        self,
+        product_symbol: str | None = None,
+        product_symbols: list | None = None,
+        symbolStatus: str | None = None,
+    ) -> dict:
+        """
+        Get spot exchange information.
+
+        Args:
+            product_symbol: Single trading pair symbol (e.g., 'BTCUSDT')
+            product_symbols: List of trading pair symbols
+            symbolStatus: Symbol status filter (TRADING, HALT, BREAK)
+
+        Returns:
+            dict: Exchange information including symbols, filters, and trading rules
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+        if product_symbols is not None:
+            formatted_symbols = [
+                self.ptm.get_exchange_symbol(Common.BINANCE, symbol) for symbol in product_symbols
+            ]
+            payload["symbols"] = str(formatted_symbols).replace("'", '"')
+        if symbolStatus is not None:
+            payload["symbolStatus"] = symbolStatus
+
+        res = await self._request(
+            method="GET",
+            path=SpotMarket.EXCHANGE_INFO,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_spot_orderbook(
+        self,
+        product_symbol: str,
+        limit: int | None = None,
+    ) -> dict:
+        """
+        Get spot order book data.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+            limit: Number of orders to return (5, 10, 20, 50, 100, 500, 1000, 5000)
+
+        Returns:
+            dict: Order book data including bids and asks
+        """
+        payload = {
+            "symbol": self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol),
+        }
+        if limit is not None:
+            payload["limit"] = str(limit)
+        res = await self._request(
+            method="GET",
+            path=SpotMarket.ORDERBOOK,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_spot_trades(
+        self,
+        product_symbol: str,
+        limit: int | None = None,
+    ) -> dict:
+        """
+        Get recent spot trades.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+            limit: Number of trades to return (max 1000)
+
+        Returns:
+            dict: Recent trade data
+        """
+        payload = {
+            "symbol": self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol),
+        }
+        if limit is not None:
+            payload["limit"] = str(limit)
+
+        res = await self._request(
+            method="GET",
+            path=SpotMarket.TRADES,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_spot_price(
+        self,
+        product_symbol: str | None = None,
+        product_symbols: list | None = None,
+    ) -> dict:
+        """
+        Get spot price information.
+
+        Args:
+            product_symbol: Single trading pair symbol (e.g., 'BTCUSDT')
+            product_symbols: List of trading pair symbols
+
+        Returns:
+            dict: Price information
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+        if product_symbols is not None:
+            formatted_symbols = [
+                self.ptm.get_exchange_symbol(Common.BINANCE, symbol) for symbol in product_symbols
+            ]
+            payload["symbols"] = str(formatted_symbols).replace("'", '"')
+
+        res = await self._request(
+            method="GET",
+            path=SpotMarket.PRICE,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_klines(
+        self,
+        product_symbol: str,
+        interval: str,
+        start_time: int | None = None,
+        limit: int | None = None,
+    ) -> dict:
+        """
+        Get kline/candlestick data.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+            interval: Time interval (1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M)
+            start_time: Start time in milliseconds
+            limit: Number of klines to return (max 1000)
+
+        Returns:
+            dict: Kline data including OHLCV
+        """
+        payload = {
+            "symbol": self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol),
+            "interval": interval,
+        }
+        if start_time is not None:
+            payload["startTime"] = str(start_time)
+        if limit is not None:
+            payload["limit"] = str(limit)
+
+        res = await self._request(
+            method="GET",
+            path=SpotMarket.KLINES
+            if self.ptm.get_exchange_type(Common.BINANCE, product_symbol=product_symbol)
+            == BinanceProductType.SPOT
+            else FuturesMarket.KLINES,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_futures_exchange_info(
+        self,
+    ) -> dict:
+        """
+        Get futures exchange information.
+
+        Returns:
+            dict: Futures exchange information including symbols and trading rules
+        """
+        res = await self._request(
+            method="GET",
+            path=FuturesMarket.EXCHANGE_INFO,
+            query={},
+            signed=False,
+        )
+        return res
+
+    async def get_futures_ticker(
+        self,
+        product_symbol: str | None = None,
+    ) -> dict:
+        """
+        Get futures ticker information.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+
+        Returns:
+            dict: Futures ticker data including price and volume
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+
+        res = await self._request(
+            method="GET",
+            path=FuturesMarket.BOOK_TICKER,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_futures_premium_index(
+        self,
+        product_symbol: str | None = None,
+    ) -> dict:
+        """
+        Get futures premium index.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+
+        Returns:
+            dict: Premium index data
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+
+        res = await self._request(
+            method="GET",
+            path=FuturesMarket.PREMIUM_INDEX,
+            query=payload,
+            signed=False,
+        )
+        return res
+
+    async def get_futures_funding_rate(
+        self,
+        product_symbol: str | None = None,
+        startTime: int | None = None,
+        endTime: int | None = None,
+        limit: int | None = None,
+    ) -> dict:
+        """
+        Get futures funding rate history.
+
+        Args:
+            product_symbol: Trading pair symbol (e.g., 'BTCUSDT')
+            startTime: Start time in milliseconds
+            endTime: End time in milliseconds
+            limit: Number of records to return (max 1000)
+
+        Returns:
+            dict: Funding rate history data
+        """
+        payload = {}
+        if product_symbol is not None:
+            payload["symbol"] = self.ptm.get_exchange_symbol(Common.BINANCE, product_symbol)
+        if startTime is not None:
+            payload["startTime"] = startTime
+        if endTime is not None:
+            payload["endTime"] = endTime
+        if limit is not None:
+            payload["limit"] = limit
+
+        res = await self._request(
+            method="GET",
+            path=FuturesMarket.FUNDING_RATE_HISTORY,
+            query=payload,
+            signed=False,
+        )
+        return res