walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/okx/error.py

@@ -0,0 +1,66 @@
+from typing import Any, Mapping
+
+
+class OkxHttpError(Exception):
+    """
+    Define the class for all OKX http specific errors.
+    """
+
+    def __init__(
+        self, status_code: int, message: str, headers: Mapping[str, Any]
+    ) -> None:
+        """
+        Define the base class for all OKX http specific errors.
+        """
+        super().__init__(message)
+        self.status = status_code
+        self.message = message
+        self.headers = headers
+
+
+class OkxRequestError(Exception):
+    """
+    The base class for all OKX specific errors.
+
+    References
+    ----------
+    https://www.okx.com/docs-v5/en/?python#error-code
+
+    """
+
+    def __init__(self, error_code: int, status_code: int | None, message: str | None):
+        super().__init__(message)
+        self.code = error_code
+        self.status_code = status_code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(code={self.code}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+def retry_check(exc: BaseException) -> bool:
+    if isinstance(exc, OkxRequestError):
+        return exc.code in [50001, 50013, 50026, 51054, 51149, 51412]
+    return False
+
+
+class OkxRateLimitError(Exception):
+    """
+    Raised when OKX API rate limit is exceeded.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        retry_after: float = 0.0,
+        scope: str | None = None,
+        endpoint: str | None = None,
+        code: int | None = None,
+    ):
+        super().__init__(message)
+        self.retry_after = retry_after
+        self.scope = scope
+        self.endpoint = endpoint
+        self.code = code

walrasquant/exchange/okx/exchange.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, List
+from walrasquant.base import ExchangeManager
+import ccxt
+import msgspec
+from walrasquant.config import BasicConfig
+from walrasquant.exchange.okx.schema import OkxMarket
+from walrasquant.exchange.okx.constants import OkxAccountType
+from walrasquant.constants import AccountType, ConfigType
+from walrasquant.schema import InstrumentId
+from walrasquant.error import EngineBuildError
+
+
+class OkxExchangeManager(ExchangeManager):
+    api: ccxt.okx
+    market: Dict[str, OkxMarket]  # symbol -> okx market
+    market_id: Dict[str, str]  # symbol -> exchange symbol id
+
+    def __init__(self, config: ConfigType | None = None):
+        resolved_config: ConfigType = {
+            "apiKey": config.get("apiKey", "") if config else "",
+            "secret": config.get("secret", "") if config else "",
+            "exchange_id": config.get("exchange_id", "okx") if config else "okx",
+            "sandbox": config.get("sandbox", False) if config else False,
+        }
+        if config and "password" in config:
+            resolved_config["password"] = config["password"]
+        super().__init__(resolved_config)
+        self.passphrase = resolved_config.get("password")
+        self._public_conn_account_type: OkxAccountType | None = None
+
+    def load_markets(self, reload: bool = False) -> None:
+        market = self.api.load_markets(reload=reload)
+        for symbol, mkt in market.items():
+            try:
+                mkt_json = msgspec.json.encode(mkt)
+                mkt = msgspec.json.decode(mkt_json, type=OkxMarket)
+
+                if (
+                    mkt.spot or mkt.linear or mkt.inverse or mkt.future
+                ) and not mkt.option:
+                    symbol = self._parse_symbol(mkt, exchange_suffix="OKX")
+                    mkt.symbol = symbol
+                    self.market[symbol] = mkt
+                    self.market_id[mkt.id] = (
+                        symbol  # since okx symbol id is identical, no need to distinguish spot, linear, inverse
+                    )
+            except msgspec.ValidationError as ve:
+                self._log.warning(f"Symbol Format Error: {ve}, {symbol}, {mkt}")
+                continue
+
+    def option(
+        self,
+        base: str | None = None,
+        quote: str | None = None,
+        exclude: List[str] | None = None,
+    ) -> List[str]:
+        raise NotImplementedError("Option is not supported for OKX")
+
+    def validate_public_connector_config(
+        self, account_type: AccountType, basic_config: BasicConfig | None = None
+    ) -> None:
+        """Validate public connector configuration for OKX exchange"""
+        if basic_config is None:
+            raise EngineBuildError("basic_config is required for OKX")
+        if not isinstance(account_type, OkxAccountType):
+            raise EngineBuildError(f"Expected OkxAccountType, got {type(account_type)}")
+
+        if basic_config.testnet != account_type.is_testnet:
+            raise EngineBuildError(
+                f"The `testnet` setting of OKX is not consistent with the public connector's account type `{account_type}`."
+            )
+
+    def validate_public_connector_limits(
+        self, existing_connectors: Dict[AccountType, Any]
+    ) -> None:
+        """Validate public connector limits for OKX exchange"""
+        okx_connectors = [
+            c
+            for c in existing_connectors.values()
+            if hasattr(c, "account_type") and isinstance(c.account_type, OkxAccountType)
+        ]
+        if len(okx_connectors) > 1:
+            raise EngineBuildError(
+                "Only one public connector is supported for OKX, please remove the extra public connector config."
+            )
+
+    def set_public_connector_account_type(self, account_type: OkxAccountType) -> None:
+        """Set the account type for public connector configuration"""
+        self._public_conn_account_type = account_type
+
+    def instrument_id_to_account_type(self, instrument_id: InstrumentId) -> AccountType:
+        """Convert an instrument ID to the appropriate account type for OKX exchange"""
+        if self._public_conn_account_type is None:
+            raise EngineBuildError(
+                "Public connector account type not set for OKX. Please add OKX in public_conn_config."
+            )
+        return self._public_conn_account_type
+
+
+if __name__ == "__main__":
+    okx = OkxExchangeManager()
+    # print(okx.market)

walrasquant/exchange/okx/factory.py

@@ -0,0 +1,138 @@
+"""
+OKX exchange factory implementation.
+"""
+
+from typing import cast
+
+from walrasquant.constants import ExchangeType, AccountType, ConfigType
+from walrasquant.config import (
+    PublicConnectorConfig,
+    PrivateConnectorConfig,
+    BasicConfig,
+)
+from walrasquant.exchange.base_factory import ExchangeFactory, BuildContext
+from walrasquant.base import (
+    ExchangeManager,
+    PublicConnector,
+    PrivateConnector,
+    ExecutionManagementSystem,
+)
+
+from walrasquant.exchange.okx.exchange import OkxExchangeManager
+from walrasquant.exchange.okx.connector import OkxPublicConnector, OkxPrivateConnector
+from walrasquant.exchange.okx.ems import OkxExecutionManagementSystem
+from walrasquant.exchange.okx.constants import OkxAccountType
+from walrasquant.exchange.okx.schema import OkxMarket
+
+
+class OkxFactory(ExchangeFactory):
+    """Factory for creating OKX exchange components."""
+
+    @property
+    def exchange_type(self) -> ExchangeType:
+        return ExchangeType.OKX
+
+    def create_manager(self, basic_config: BasicConfig) -> ExchangeManager:
+        """Create OkxExchangeManager."""
+        ccxt_config: ConfigType = {
+            "apiKey": basic_config.api_key or "",
+            "secret": basic_config.secret or "",
+            "exchange_id": "okx",
+            "sandbox": basic_config.testnet,
+        }
+        if basic_config.passphrase:
+            ccxt_config["password"] = basic_config.passphrase
+
+        return OkxExchangeManager(ccxt_config)
+
+    def create_public_connector(
+        self,
+        config: PublicConnectorConfig,
+        exchange: ExchangeManager,
+        context: BuildContext,
+    ) -> PublicConnector:
+        """Create OkxPublicConnector."""
+        if not isinstance(config.account_type, OkxAccountType):
+            raise TypeError("OKX public connector requires OkxAccountType")
+        connector = OkxPublicConnector(
+            account_type=config.account_type,
+            exchange=cast(OkxExchangeManager, exchange),
+            msgbus=context.msgbus,
+            clock=context.clock,
+            task_manager=context.task_manager,
+            enable_rate_limit=config.enable_rate_limit,
+            custom_url=config.custom_url,
+            max_subscriptions_per_client=config.max_subscriptions_per_client,
+            max_clients=config.max_clients,
+        )
+
+        # OKX needs post-creation setup
+        self.setup_public_connector(exchange, connector, config.account_type)
+        return connector
+
+    def create_private_connector(
+        self,
+        config: PrivateConnectorConfig,
+        exchange: ExchangeManager,
+        context: BuildContext,
+        account_type: AccountType | None = None,
+    ) -> PrivateConnector:
+        """Create OkxPrivateConnector."""
+        # Use provided account_type or determine from exchange testnet status
+        if account_type:
+            final_account_type = account_type
+        else:
+            final_account_type = self.get_private_account_type(exchange, config)
+
+        if not isinstance(final_account_type, OkxAccountType):
+            raise TypeError("OKX private connector requires OkxAccountType")
+        return OkxPrivateConnector(
+            exchange=cast(OkxExchangeManager, exchange),
+            account_type=final_account_type,
+            cache=context.cache,
+            clock=context.clock,
+            msgbus=context.msgbus,
+            registry=context.registry,
+            enable_rate_limit=config.enable_rate_limit,
+            task_manager=context.task_manager,
+            max_retries=config.max_retries,
+            delay_initial_ms=config.delay_initial_ms,
+            delay_max_ms=config.delay_max_ms,
+            backoff_factor=config.backoff_factor,
+            max_subscriptions_per_client=config.max_subscriptions_per_client,
+            max_clients=config.max_clients,
+            order_query_config=context.order_query_config,
+        )
+
+    def create_ems(
+        self, exchange: ExchangeManager, context: BuildContext
+    ) -> ExecutionManagementSystem:
+        """Create OkxExecutionManagementSystem."""
+        return OkxExecutionManagementSystem(
+            market=cast(dict[str, OkxMarket], exchange.market),
+            cache=context.cache,
+            msgbus=context.msgbus,
+            clock=context.clock,
+            task_manager=context.task_manager,
+            registry=context.registry,
+            queue_maxsize=context.queue_maxsize,
+        )
+
+    def get_private_account_type(
+        self, exchange: ExchangeManager, config: PrivateConnectorConfig
+    ) -> AccountType:
+        """Determine account type based on testnet status."""
+        return OkxAccountType.DEMO if exchange.is_testnet else OkxAccountType.LIVE
+
+    def setup_public_connector(
+        self,
+        exchange: ExchangeManager,
+        connector: PublicConnector,
+        account_type: AccountType,
+    ) -> None:
+        """Setup public connector account type."""
+        if not isinstance(account_type, OkxAccountType):
+            raise TypeError("OKX public connector requires OkxAccountType")
+        cast(OkxExchangeManager, exchange).set_public_connector_account_type(
+            account_type
+        )