cexy 0.1.0.dev1__py3-none-any.whl

cexy/__init__.py

@@ -0,0 +1,56 @@
+"""CEXY.io Python SDK.
+
+>>> import cexy
+>>> client = cexy.Client()                       # public market data
+>>> client.markets.orderbook("BTC/USDT", depth=10)
+
+Private endpoints need an API key pair: ``cexy.Client(api_key=..., api_secret=...)``.
+"""
+
+from cexy._async.client import AsyncClient
+from cexy._async.pagination import AsyncPage
+from cexy._common import DEFAULT_BASE_URL, USER_AGENT
+from cexy._sync.client import Client
+from cexy._sync.pagination import Page
+from cexy._version import __version__
+from cexy.auth import Authenticator, HeaderKeyAuth
+from cexy.errors import (
+    AuthenticationError,
+    CexyApiError,
+    CexyConnectionError,
+    CexyError,
+    ConfigurationError,
+    ConflictError,
+    ForbiddenError,
+    MissingCredentialsError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    UnprocessableError,
+    ValidationError,
+)
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "USER_AGENT",
+    "AsyncClient",
+    "AsyncPage",
+    "AuthenticationError",
+    "Authenticator",
+    "CexyApiError",
+    "CexyConnectionError",
+    "CexyError",
+    "Client",
+    "ConfigurationError",
+    "ConflictError",
+    "ForbiddenError",
+    "HeaderKeyAuth",
+    "MissingCredentialsError",
+    "NotFoundError",
+    "Page",
+    "RateLimitError",
+    "ServerError",
+    "UnprocessableError",
+    "ValidationError",
+    "__version__",
+]

cexy/_async/client.py

@@ -0,0 +1,144 @@
+"""The async client (``AsyncClient``).
+
+Async source; the synchronous ``cexy/_sync/client.py`` is generated from it by ``scripts/unasync.py``.
+"""
+
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Optional, Type
+
+import httpx
+
+from cexy._async.resources import (
+    AsyncAccount,
+    AsyncAssets,
+    AsyncExports,
+    AsyncFees,
+    AsyncMarkets,
+    AsyncNetworks,
+    AsyncPools,
+    AsyncTrading,
+    AsyncWallet,
+)
+from cexy._async.transport import AsyncTransport
+from cexy._common import (
+    DEFAULT_BASE_URL,
+    DEFAULT_RATE_LIMIT_ANONYMOUS,
+    DEFAULT_RATE_LIMIT_WITH_KEY,
+    user_agent,
+    validate_base_url,
+)
+from cexy._generated import models as m
+from cexy._opmap import operation
+from cexy.auth import REDACTED, Authenticator, build_authenticator
+from cexy.errors import ConfigurationError
+
+
+class AsyncClient:
+    """CEXY.io REST client (asyncio).
+
+    Public market data needs no credentials. For account and trading endpoints pass an
+    API key pair; both values are required together. Keys are sent only on endpoints that
+    need them, only as ``X-API-Key``/``X-API-Secret`` headers, and are redacted from
+    ``repr``, logs and exceptions.
+
+    The client-side rate limiter defaults to 100 requests/minute without a key and 300 with
+    one (``rate_limit_per_minute`` overrides it); it adapts to ``X-RateLimit-*`` headers.
+
+    ``base_url`` must be ``https://``. ``allow_insecure=True`` permits ``http://`` for a
+    loopback host only (local testing).
+
+    Use as ``async with AsyncClient() as client: ...`` or call ``await client.aclose()``.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_secret: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 10,
+        max_retries: int = 3,
+        user_agent_suffix: Optional[str] = None,
+        *,
+        rate_limit_per_minute: Optional[float] = None,
+        authenticator: Optional[Authenticator] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+        allow_insecure: bool = False,
+    ) -> None:
+        auth: Optional[Authenticator]
+        try:
+            auth = build_authenticator(api_key, api_secret)
+        except ValueError as exc:
+            raise ConfigurationError(str(exc)) from None
+        if authenticator is not None:
+            if auth is not None:
+                raise ConfigurationError("pass either api_key/api_secret or authenticator, not both")
+            if not isinstance(authenticator, Authenticator):
+                raise ConfigurationError("authenticator must implement cexy.auth.Authenticator")
+            auth = authenticator
+        self._auth = auth
+        if rate_limit_per_minute is None:
+            # Server limits: ~120/min per IP for anonymous requests, ~600/min per key.
+            rate_limit_per_minute = DEFAULT_RATE_LIMIT_WITH_KEY if auth is not None else DEFAULT_RATE_LIMIT_ANONYMOUS
+        self._transport = AsyncTransport(
+            base_url=validate_base_url(base_url, allow_insecure),
+            auth=auth,
+            timeout=timeout,
+            max_retries=max_retries,
+            user_agent=user_agent(user_agent_suffix),
+            rate_limit_per_minute=rate_limit_per_minute,
+            http_client=http_client,
+        )
+        self.markets = AsyncMarkets(self._transport)
+        self.assets = AsyncAssets(self._transport)
+        self.networks = AsyncNetworks(self._transport)
+        self.fees = AsyncFees(self._transport)
+        self.pools = AsyncPools(self._transport)
+        self.account = AsyncAccount(self._transport)
+        self.exports = AsyncExports(self._transport)
+        self.wallet = AsyncWallet(self._transport)
+        self.trading = AsyncTrading(self._transport)
+
+    @property
+    def base_url(self) -> str:
+        return self._transport.base_url
+
+    @property
+    def has_credentials(self) -> bool:
+        return self._auth is not None
+
+    @operation("server_time")
+    async def time(self) -> m.ServerTimeResponse:
+        """The server clock (public)."""
+        payload = await self._transport.request("server_time")
+        return m.ServerTimeResponse.model_validate(payload["data"])
+
+    @operation("exchange_config")
+    async def config(self) -> m.ExchangeConfigResponse:
+        """Public exchange configuration: maintenance mode, page sizes, intervals (public)."""
+        payload = await self._transport.request("exchange_config")
+        return m.ExchangeConfigResponse.model_validate(payload["data"])
+
+    async def aclose(self) -> None:
+        await self._transport.aclose()
+
+    async def __aenter__(self) -> AsyncClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        auth = REDACTED if self._auth is not None else None
+        return f"{type(self).__name__}(base_url={self.base_url!r}, credentials={auth!r})"
+
+    __str__ = __repr__
+
+    def __reduce__(self) -> str:
+        raise TypeError(f"{type(self).__name__} cannot be pickled (it may hold a secret)")

cexy/_async/pagination.py

@@ -0,0 +1,58 @@
+"""Cursor pagination: ``items`` + ``next_cursor`` + ``has_more``.
+
+Async source; the synchronous ``cexy/_sync/pagination.py`` is generated from it by ``scripts/unasync.py``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Callable, Generic, List, Optional, Type, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class AsyncPage(Generic[T]):
+    """One page of results.
+
+    ``async for item in page.auto_paging_iter()`` walks this page and every later one,
+    fetching lazily. ``await page.next_page()`` fetches just the next page.
+    """
+
+    def __init__(
+        self,
+        items: List[T],
+        next_cursor: Optional[str],
+        has_more: bool,
+        fetch: Callable[[str], Any],
+    ) -> None:
+        self.items = items
+        self.next_cursor = next_cursor
+        self.has_more = has_more
+        self._fetch = fetch
+
+    @classmethod
+    def parse(cls, payload: Any, model: Type[T], fetch: Callable[[str], Any]) -> AsyncPage[T]:
+        items = [model.model_validate(x) for x in payload.get("items", [])]
+        cursor = payload.get("next_cursor")
+        has_more = bool(payload.get("has_more", False)) and bool(cursor)
+        return cls(items, cursor, has_more, fetch)
+
+    async def next_page(self) -> Optional[AsyncPage[T]]:
+        if not self.has_more or not self.next_cursor:
+            return None
+        page: AsyncPage[T] = await self._fetch(self.next_cursor)
+        return page
+
+    async def auto_paging_iter(self) -> AsyncIterator[T]:
+        page: Optional[AsyncPage[T]] = self
+        while page is not None:
+            for item in page.items:
+                yield item
+            page = await page.next_page()
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(items={len(self.items)}, has_more={self.has_more})"