walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/base/ws_client.py

@@ -0,0 +1,408 @@
+import asyncio
+import msgspec
+from abc import ABC, abstractmethod
+from typing import Any
+from typing import Callable, Literal
+import nexuslog as logging
+
+
+from walrasquant.core.entity import TaskManager
+from picows import (
+    ws_connect,
+    WSFrame,
+    WSTransport,
+    WSListener,
+    WSMsgType,
+    WSAutoPingStrategy,
+    # PICOWS_DEBUG_LL,
+)
+from walrasquant.core.nautilius_core import LiveClock
+
+# import logging
+
+# file_handler = logging.FileHandler('.log/picows.log')
+# file_handler.setLevel(PICOWS_DEBUG_LL)
+
+# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+# file_handler.setFormatter(formatter)
+
+# picows_logger = logging.getLogger("picows")
+# picows_logger.setLevel(PICOWS_DEBUG_LL)
+# picows_logger.addHandler(file_handler)
+
+
+class Listener(WSListener):
+    """WebSocket listener implementation that handles connection events and message frames.
+
+    Inherits from picows.WSListener to provide WebSocket event handling functionality.
+    """
+
+    def __init__(
+        self,
+        callback,
+        logger,
+        specific_ping_msg: bytes | None = None,
+        user_pong_callback: Callable[["Listener", WSFrame], bool] | None = None,
+        *args,
+        **kwargs,
+    ):
+        """Initialize the WebSocket listener.
+
+        Args:
+            logger: Logger instance for logging events
+            specific_ping_msg: Optional custom ping message
+        """
+        super().__init__(*args, **kwargs)
+        self._log = logger
+        self._specific_ping_msg: bytes | None = specific_ping_msg
+        self._callback = callback
+        self._user_pong_callback = user_pong_callback
+
+    def send_user_specific_ping(self, transport: WSTransport) -> None:
+        """Send a custom ping message or default ping frame.
+
+        Args:
+            transport (picows.WSTransport): WebSocket transport instance
+        """
+        if self._specific_ping_msg:
+            transport.send(WSMsgType.TEXT, self._specific_ping_msg)
+            self._log.debug(
+                f"Sent user specific ping: `{self._specific_ping_msg.decode()}`."
+            )
+        else:
+            transport.send_ping()
+            self._log.debug("Sent default ping.")
+
+    def on_ws_connected(self, transport: WSTransport) -> None:
+        """Called when WebSocket connection is established.
+
+        Args:
+            transport (picows.WSTransport): WebSocket transport instance
+        """
+        self._log.debug("Connected to Websocket...")
+
+    def on_ws_disconnected(self, transport: WSTransport) -> None:
+        """Called when WebSocket connection is closed.
+
+        Args:
+            transport (picows.WSTransport): WebSocket transport instance
+        """
+        self._log.debug("Disconnected from Websocket.")
+
+    def is_user_specific_pong(self, frame: WSFrame) -> bool:
+        if self._user_pong_callback is None:
+            return False
+        return self._user_pong_callback(self, frame)
+
+    def _decode_frame(self, frame: WSFrame) -> str:
+        """Decode the payload of a WebSocket frame safely.
+
+        Args:
+            frame (picows.WSFrame): Received WebSocket frame
+
+        Returns:
+            str: Decoded payload as UTF-8 text or a placeholder for binary data
+        """
+        try:
+            return frame.get_payload_as_utf8_text()
+        except Exception:
+            return f"<binary data: {len(frame.get_payload_as_bytes())} bytes>"
+
+    def on_ws_frame(self, transport: WSTransport, frame: WSFrame) -> None:
+        """Handle incoming WebSocket frames.
+
+        Args:
+            transport (picows.WSTransport): WebSocket transport instance
+            frame (picows.WSFrame): Received WebSocket frame
+        """
+        try:
+            match frame.msg_type:
+                case WSMsgType.TEXT:
+                    # Queue raw bytes for handler to decode
+                    self._callback(frame.get_payload_as_bytes())
+                    return
+                case WSMsgType.CLOSE:
+                    close_code = frame.get_close_code()
+                    self._log.warning(
+                        f"Received close frame. Close code: {str(close_code)}"
+                    )
+                    return
+        except Exception as e:
+            import traceback
+
+            self._log.error(
+                f"Error processing message: {str(e)}\nTraceback: {traceback.format_exc()}\nws_frame: {self._decode_frame(frame)}"
+            )
+
+
+class WSClient(ABC):
+    def __init__(
+        self,
+        url: str,
+        handler: Callable[..., Any],
+        task_manager: TaskManager,
+        clock: LiveClock,
+        specific_ping_msg: bytes | None = None,
+        reconnect_interval: int = 1,
+        ping_idle_timeout: int = 2,
+        ping_reply_timeout: int = 1,
+        auto_ping_strategy: Literal[
+            "ping_when_idle", "ping_periodically"
+        ] = "ping_when_idle",
+        enable_auto_ping: bool = True,
+        enable_auto_pong: bool = True,
+        user_pong_callback: Callable[["Listener", WSFrame], bool] | None = None,
+        max_subscriptions_per_client: int | None = None,
+        max_clients: int | None = None,
+    ):
+        self._clock = clock
+        self._url = url
+        self._specific_ping_msg = specific_ping_msg
+        self._reconnect_interval = reconnect_interval
+        self._ping_idle_timeout = ping_idle_timeout
+        self._ping_reply_timeout = ping_reply_timeout
+        self._enable_auto_pong = enable_auto_pong
+        self._enable_auto_ping = enable_auto_ping
+        self._user_pong_callback = user_pong_callback
+        self._listeners: dict[int, WSListener | None] = {}
+        self._transports: dict[int, WSTransport | None] = {}
+        self._subscriptions: list[Any] = []
+        self._client_subscriptions: dict[int, list[Any]] = {}
+        self._wait_tasks: dict[int, asyncio.Task] = {}
+        self._next_client_id = 0
+        self._started = False
+        self._max_subscriptions_per_client = max_subscriptions_per_client
+        self._max_clients = max_clients
+        self._callback = handler
+        if auto_ping_strategy == "ping_when_idle":
+            self._auto_ping_strategy = WSAutoPingStrategy.PING_WHEN_IDLE
+        elif auto_ping_strategy == "ping_periodically":
+            self._auto_ping_strategy = WSAutoPingStrategy.PING_PERIODICALLY
+        self._task_manager = task_manager
+        self._log = logging.getLogger(name=type(self).__name__)
+        self._ready = asyncio.Event()  # Only set once on initial connection
+        self._connection_change_callback: Callable[[int, bool], None] | None = None
+        if self._max_subscriptions_per_client is not None:
+            if self._max_subscriptions_per_client <= 0:
+                raise ValueError("max_subscriptions_per_client must be positive")
+        if self._max_clients is not None:
+            if self._max_clients <= 0:
+                raise ValueError("max_clients must be positive")
+
+    @property
+    def connected(self) -> bool:
+        return any(transport is not None for transport in self._transports.values())
+
+    def set_connection_change_callback(
+        self, callback: Callable[[int, bool], None] | None
+    ) -> None:
+        self._connection_change_callback = callback
+
+    def _notify_connection_change(self, client_id: int, connected: bool) -> None:
+        if self._connection_change_callback is None:
+            return
+        try:
+            self._connection_change_callback(client_id, connected)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            self._log.warning(f"Connection change callback error: {exc}")
+
+    def _is_client_connected(self, client_id: int) -> bool:
+        return self._transports.get(client_id) is not None
+
+    def _primary_client_id(self) -> int | None:
+        if 0 in self._client_subscriptions or 0 in self._transports:
+            return 0
+        if self._client_subscriptions:
+            return next(iter(self._client_subscriptions))
+        if self._transports:
+            return next(iter(self._transports))
+        return None
+
+    def _ensure_client(self, client_id: int) -> None:
+        is_new_client = client_id not in self._client_subscriptions
+        if client_id not in self._client_subscriptions:
+            self._client_subscriptions[client_id] = []
+        if client_id not in self._transports:
+            self._transports[client_id] = None
+        if client_id not in self._listeners:
+            self._listeners[client_id] = None
+        if client_id >= self._next_client_id:
+            self._next_client_id = client_id + 1
+        if is_new_client:
+            self._notify_connection_change(client_id, False)
+        if self._started:
+            self._start_client_tasks(client_id)
+
+    def _multi_client_enabled(self) -> bool:
+        return self._max_subscriptions_per_client is not None
+
+    def _get_client_id_for_new_subscription(self) -> int:
+        if not self._multi_client_enabled():
+            client_id = 0
+            self._ensure_client(client_id)
+            return client_id
+
+        for client_id, subs in self._client_subscriptions.items():
+            if len(subs) < self._max_subscriptions_per_client:  # type: ignore[operator]
+                return client_id
+
+        if (
+            self._max_clients is not None
+            and len(self._client_subscriptions) >= self._max_clients
+        ):
+            raise RuntimeError("Maximum number of websocket clients reached")
+
+        client_id = self._next_client_id
+        self._ensure_client(client_id)
+        return client_id
+
+    def _find_client_for_subscription(self, subscription: Any) -> int | None:
+        for client_id, subs in self._client_subscriptions.items():
+            if subscription in subs:
+                return client_id
+        return None
+
+    def _register_subscriptions(self, subscriptions: list[Any]) -> dict[int, list[Any]]:
+        assigned: dict[int, list[Any]] = {}
+        for subscription in subscriptions:
+            if subscription in self._subscriptions:
+                continue
+            client_id = self._get_client_id_for_new_subscription()
+            self._subscriptions.append(subscription)
+            self._client_subscriptions[client_id].append(subscription)
+            assigned.setdefault(client_id, []).append(subscription)
+        return assigned
+
+    def _unregister_subscriptions(
+        self, subscriptions: list[Any]
+    ) -> dict[int, list[Any]]:
+        removed: dict[int, list[Any]] = {}
+        for subscription in subscriptions:
+            if subscription not in self._subscriptions:
+                continue
+            client_id = self._find_client_for_subscription(subscription)
+            if client_id is not None:
+                self._client_subscriptions[client_id].remove(subscription)
+                removed.setdefault(client_id, []).append(subscription)
+            self._subscriptions.remove(subscription)
+        return removed
+
+    async def _connect(self, client_id: int):
+        self._log.debug(
+            f"Connecting to Websocket at {self._url} (client {client_id})..."
+        )
+        WSListenerFactory = lambda: Listener(  # noqa: E731
+            self._callback,
+            self._log,
+            self._specific_ping_msg,
+            self._user_pong_callback,
+        )
+        transport, listener = await ws_connect(
+            WSListenerFactory,
+            self._url,
+            enable_auto_ping=self._enable_auto_ping,
+            auto_ping_idle_timeout=self._ping_idle_timeout,
+            auto_ping_reply_timeout=self._ping_reply_timeout,
+            auto_ping_strategy=self._auto_ping_strategy,
+            enable_auto_pong=self._enable_auto_pong,
+        )
+        self._transports[client_id] = transport
+        self._listeners[client_id] = listener
+        self._log.debug(
+            f"Websocket connected successfully to {self._url} (client {client_id})."
+        )
+        self._notify_connection_change(client_id, True)
+
+    async def connect(self):
+        if not self._client_subscriptions:
+            self._ensure_client(0)
+        if self._started:
+            primary_id = self._primary_client_id()
+            if primary_id is not None:
+                task = self._wait_tasks.get(primary_id)
+                if task and not task.done():
+                    self._log.debug("Websocket wait loop already running.")
+                    return
+        self._started = True
+        for client_id in list(self._client_subscriptions.keys()):
+            self._start_client_tasks(client_id)
+
+    async def wait_ready(self):
+        """Wait for the initial connection to be established.
+
+        This method only waits for the first successful connection.
+        Subsequent reconnections will not affect this event.
+        """
+        await self._ready.wait()
+
+    async def _connection_handler(self, client_id: int):
+        while True:
+            try:
+                await self._connect(client_id)
+                await self._resubscribe_for_client(
+                    client_id, self._client_subscriptions.get(client_id, [])
+                )
+                # Set ready event only on first successful connection
+                if not self._ready.is_set():
+                    self._ready.set()
+                    self._log.debug("Initial connection ready.")
+                transport = self._transports.get(client_id)
+                if transport is None:
+                    break
+                await transport.wait_disconnected()
+                self._log.debug(f"Websocket disconnected (client {client_id}).")
+                self._notify_connection_change(client_id, False)
+            except asyncio.CancelledError:
+                self._log.debug(
+                    f"Websocket connection loop cancelled (client {client_id})."
+                )
+                break
+            except Exception as e:
+                self._log.error(f"Connection error: {e}")
+            # finally:
+            #     self._clean_up_client(client_id)
+
+            self._log.warning(
+                f"Websocket reconnecting in {self._reconnect_interval} seconds (client {client_id})..."
+            )
+            await asyncio.sleep(self._reconnect_interval)
+
+    def _start_client_tasks(self, client_id: int) -> None:
+        wait_task = self._wait_tasks.get(client_id)
+        if wait_task and not wait_task.done():
+            return
+        self._wait_tasks[client_id] = self._task_manager.create_task(
+            self._connection_handler(client_id)
+        )
+
+    def _clean_up_client(self, client_id: int) -> None:
+        self._transports[client_id] = None
+        self._listeners[client_id] = None
+
+    def send(self, payload: dict, client_id: int | None = None):
+        target_id = client_id
+        if target_id is None:
+            target_id = self._primary_client_id()
+            if target_id is None:
+                self._log.warning(f"Websocket not connected. drop msg: {str(payload)}")
+                return
+        transport = self._transports.get(target_id)
+        if transport is None:
+            self._log.warning(f"Websocket not connected. drop msg: {str(payload)}")
+            return
+        transport.send(WSMsgType.TEXT, msgspec.json.encode(payload))
+
+    def disconnect(self, client_id: int | None = None):
+        if client_id is None:
+            client_ids = list(self._transports.keys())
+        else:
+            client_ids = [client_id]
+
+        for target_id in client_ids:
+            transport = self._transports.get(target_id)
+            if transport:
+                transport.disconnect()
+
+    @abstractmethod
+    async def _resubscribe_for_client(self, client_id: int, subscriptions: list[Any]):
+        pass

walrasquant/config.py

@@ -0,0 +1,284 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal
+from walrasquant.constants import AccountType, ExchangeType, OrderStatus, StorageType
+from walrasquant.strategy import Strategy
+from zmq.asyncio import Socket
+
+LOG_LEVELS = Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"]
+
+
+@dataclass
+class LogConfig:
+    """LogConfig for NexusTrader logging system using nexuslog.
+
+    Maps directly to nexuslog.basicConfig() parameters.
+
+    Attributes:
+        filename: Optional file path for log output. If None, logs to stdout.
+        level: Minimum log level to record. Options: TRACE, DEBUG, INFO, WARNING, ERROR
+        unix_ts: If True, emit unix timestamps instead of formatted local time.
+    """
+
+    filename: str | None = None
+    level: LOG_LEVELS = "INFO"
+    name_levels: dict[str | None, LOG_LEVELS] | None = None
+    unix_ts: bool = False
+    batch_size: int = 1
+
+    def __post_init__(self):
+        if self.level not in ["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"]:
+            raise ValueError(
+                f"Invalid level: {self.level}. Must be one of TRACE, DEBUG, INFO, WARNING, ERROR."
+            )
+
+        if self.name_levels:
+            for name, level in self.name_levels.items():
+                if level not in ["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"]:
+                    raise ValueError(
+                        f"Invalid level: {level} for logger name: {name}. Must be one of TRACE, DEBUG, INFO, WARNING, ERROR."
+                    )
+
+
+@dataclass
+class BasicConfig:
+    """
+    Basic configuration for the trading system.
+
+    Attributes:
+        api_key (str): API key for the exchange. For HyperLiquid, this is the real wallet address, not the address generated by the Agent.
+        secret (str): Secret key for the exchange. For HyperLiquid, this is the Agent private key, you can get it at https://app.hyperliquid-testnet.xyz/API
+        testnet (bool): Whether to use the testnet environment. Defaults to False.
+        passphrase (str | None): Passphrase for the exchange, if required. Defaults to None.
+    """
+
+    api_key: str | None = None
+    secret: str | None = None
+    testnet: bool = False
+    passphrase: str | None = None
+
+
+@dataclass
+class PublicConnectorConfig:
+    account_type: AccountType
+    enable_rate_limit: bool = True
+    custom_url: str | None = None
+    max_subscriptions_per_client: int | None = None
+    max_clients: int | None = None
+
+
+@dataclass
+class PrivateConnectorConfig:
+    """
+    Configuration for private connector settings.
+
+    Attributes
+    ----------
+    account_type : AccountType
+        The type of account for the private connector.
+    enable_rate_limit : bool, default=True
+        Whether to enable rate limiting for API requests.
+    max_retries for failed order request : int, default=0
+    delay_initial_ms : int, default=100
+    delay_max_ms : int, default=800
+    backoff_factor : int, default=2
+    max_slippage : float, default=0.02
+        Maximum slippage allowed for market orders, expressed as a percentage (e.g., 0.02 for 2%). Only applicable for Bitget and HyperLiquid exchanges.
+    """
+
+    account_type: AccountType
+    enable_rate_limit: bool = True
+    max_retries: int = 0
+    delay_initial_ms: int = 100
+    delay_max_ms: int = 800
+    backoff_factor: int = 2
+    max_slippage: float = 0.02  # 2% slippage
+    max_subscriptions_per_client: int | None = None
+    max_clients: int | None = None
+
+
+@dataclass
+class ZeroMQSignalConfig:
+    """ZeroMQ Signal Configuration Class.
+
+    Used to configure the ZeroMQ subscriber socket to receive custom trade signals.
+
+    Attributes:
+        socket (`zmq.asyncio.Socket`): ZeroMQ asynchronous socket object
+
+    Example:
+        >>> from zmq.asyncio import Context
+        >>> context = Context()
+        >>> socket = context.socket(zmq.SUB)
+        >>> socket.connect("ipc:///tmp/zmq_custom_signal")
+        >>> socket.setsockopt(zmq.SUBSCRIBE, b"")
+        >>> config = ZeroMQSignalConfig(socket=socket)
+    """
+
+    socket: Socket
+
+
+@dataclass
+class WebConfig:
+    """Configuration for the optional FastAPI web server."""
+
+    enabled: bool = False
+    host: str = "0.0.0.0"
+    port: int = 8000
+    log_level: Literal["critical", "error", "warning", "info", "debug"] = "info"
+
+    def __post_init__(self):
+        if not (0 < self.port <= 65535):
+            raise ValueError("port must be between 1 and 65535")
+
+
+@dataclass
+class QueueConfig:
+    ems_maxsize: int = 100_000
+    sms_maxsize: int = 100_000
+
+
+@dataclass
+class MarketReloadConfig:
+    """
+    Configuration for automatically reloading exchange market metadata.
+
+    Args:
+        enabled: Whether to schedule automatic market reloads.
+        trigger: APScheduler trigger type. Supports ``interval`` and ``cron``.
+        kwargs: Trigger keyword arguments. Defaults to ``{"hours": 1}`` for
+            interval reloads, and ``{"hour": "*"}`` when cron is selected
+            without explicit kwargs.
+    """
+
+    enabled: bool = False
+    trigger: Literal["interval", "cron"] = "interval"
+    kwargs: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if self.trigger not in ("interval", "cron"):
+            raise ValueError("market reload trigger must be 'interval' or 'cron'")
+        if not isinstance(self.kwargs, dict):
+            raise TypeError("market reload kwargs must be a dict")
+
+        if self.trigger == "cron":
+            plural_fields = {"weeks", "days", "hours", "minutes", "seconds"}
+            invalid = plural_fields.intersection(self.kwargs)
+            if invalid:
+                fields = ", ".join(sorted(invalid))
+                raise ValueError(
+                    f"cron market reload kwargs use singular field names; invalid: {fields}"
+                )
+
+    def scheduler_kwargs(self) -> dict[str, Any]:
+        kwargs = dict(self.kwargs)
+        if self.trigger == "interval":
+            if not kwargs:
+                kwargs["hours"] = 1
+            return kwargs
+
+        if not kwargs:
+            kwargs["hour"] = "*"
+        return kwargs
+
+
+DEFAULT_ORDER_QUERY_TIMEOUTS: dict[OrderStatus, float] = {
+    OrderStatus.PENDING: 2.0,
+    OrderStatus.CANCELING: 2.0,
+    OrderStatus.ACCEPTED: 600.0,
+    OrderStatus.PARTIALLY_FILLED: 600.0,
+}
+
+
+@dataclass
+class OrderQueryConfig:
+    enabled: bool = True
+    check_interval_seconds: float = -1
+    timeout_seconds: dict[OrderStatus | str, float] = field(
+        default_factory=lambda: dict(DEFAULT_ORDER_QUERY_TIMEOUTS)
+    )
+
+    def __post_init__(self):
+        if self.check_interval_seconds != -1 and self.check_interval_seconds <= 0:
+            raise ValueError(
+                "order query check_interval_seconds must be positive or -1"
+            )
+
+        normalized = dict(DEFAULT_ORDER_QUERY_TIMEOUTS)
+        for status, timeout in self.timeout_seconds.items():
+            order_status = self._parse_status(status)
+            if timeout <= 0:
+                raise ValueError(
+                    f"order query timeout_seconds[{order_status.value}] must be positive"
+                )
+            normalized[order_status] = float(timeout)
+        self.timeout_seconds = normalized
+
+    @staticmethod
+    def _parse_status(status: OrderStatus | str) -> OrderStatus:
+        if isinstance(status, OrderStatus):
+            return status
+        try:
+            return OrderStatus(status)
+        except ValueError:
+            return OrderStatus[status]
+
+
+@dataclass
+class Config:
+    """
+    Represents the configuration for a trading system.
+
+    This class holds all necessary configuration information including strategy details,
+    exchange configurations, connector setups, database settings, and logging preferences.
+
+    Attributes:
+        strategy_id (str): Unique identifier for the strategy.
+        user_id (str): Identifier for the user running the strategy.
+        strategy (Strategy): The trading strategy to be executed.
+        basic_config (Dict[ExchangeType, BasicConfig]): Basic configuration for each exchange.
+        public_conn_config (Dict[ExchangeType, List[PublicConnectorConfig]]): Public connector configurations by exchange.
+        private_conn_config (Dict[ExchangeType, List[PrivateConnectorConfig]]):
+            Private connector configurations by exchange.
+        zero_mq_signal_config (ZeroMQSignalConfig | None): Configuration for ZeroMQ signal, if used.
+        db_path (str): Path to the database file. Defaults to ".keys/cache.db".
+        storage_backend (StorageType): Type of storage backend to use. Defaults to SQLITE.
+        cache_sync_interval (int): Interval in seconds for cache synchronization. Defaults to 60.
+        cache_expired_time (int): Time in seconds after which cache entries expire. Defaults to 3600.
+        log_config (LogConfig): Configuration for logging. Defaults to a new LogConfig instance.
+        web_config (WebConfig): Settings for the optional FastAPI web interface.
+        flashduty_integration_key (str | None): FlashDuty integration key for push alerts. Defaults to None.
+        exit_after_cancel (bool): Whether to cancel all open orders when the engine is disposed (e.g., on Ctrl+C). Defaults to True.
+        market_reload_config (MarketReloadConfig): Optional automatic market metadata reload configuration.
+        order_query_config (OrderQueryConfig): Optional recovery query configuration for stale open/canceling orders.
+    """
+
+    strategy_id: str
+    user_id: str
+    strategy: Strategy
+    basic_config: Dict[ExchangeType, BasicConfig]
+    public_conn_config: Dict[ExchangeType, List[PublicConnectorConfig]]
+    private_conn_config: Dict[ExchangeType, List[PrivateConnectorConfig]] = field(
+        default_factory=dict
+    )
+    zero_mq_signal_config: ZeroMQSignalConfig | None = None
+    db_path: str = ".keys/cache.db"
+    storage_backend: StorageType = StorageType.SQLITE
+    cache_sync_interval: int = 60
+    cache_expired_time: int = 3600
+    log_config: LogConfig = field(default_factory=LogConfig)
+    web_config: WebConfig = field(default_factory=WebConfig)
+    exit_after_cancel: bool = True
+    flashduty_integration_key: str | None = None
+    queue_config: QueueConfig = field(default_factory=QueueConfig)
+    market_reload_config: MarketReloadConfig = field(default_factory=MarketReloadConfig)
+    order_query_config: OrderQueryConfig = field(default_factory=OrderQueryConfig)
+
+    def __post_init__(self):
+        if self.log_config.filename is None:
+            import os
+
+            log_folder = "logs"
+            os.makedirs(log_folder, exist_ok=True)
+            self.log_config.filename = (
+                f"{log_folder}/{self.strategy_id}_{self.user_id}.log"
+            )