walrasquant-lib 0.4.24__tar.gz → 0.4.26__tar.gz

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.4.24
+Version: 0.4.26
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>
@@ -23,9 +23,9 @@ Requires-Dist: dynaconf[redis]>=3.2.12
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: rich>=14.0.0
 Requires-Dist: picows>=2.1.1
-Requires-Dist: nexuscore-lib>=0.2.0
+Requires-Dist: nexuscore-lib>=0.2.1
 Requires-Dist: flashduty-lib>=0.2.0
-Requires-Dist: nexuslog-lib>=0.5.0
+Requires-Dist: nexuslog-lib>=0.8.0
 Requires-Dist: msgspec>=0.21.1
 Requires-Dist: pandas<3.0.0
 Requires-Dist: numpy>=2.2.0

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.4.24"
+version = "0.4.26"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}
@@ -27,9 +27,9 @@ dependencies = [
     "aiohttp>=3.13.3",
     "rich>=14.0.0",
     "picows>=2.1.1",
-    "nexuscore-lib>=0.2.0",
+    "nexuscore-lib>=0.2.1",
     "flashduty-lib>=0.2.0",
-    "nexuslog-lib>=0.5.0",
+    "nexuslog-lib>=0.8.0",
     "msgspec>=0.21.1",
     "pandas<3.0.0",
     "numpy>=2.2.0",

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/aggregation.py

@@ -396,7 +396,10 @@ class TimeKlineAggregator(KlineAggregator):
             callback=self._build_bar,
         )
         self._log.debug(
-            f"Timer set: {self._timer_name}, start={start_time}, interval={interval_td}"
+            "Timer set: %s, start=%s, interval=%s",
+            self._timer_name,
+            start_time,
+            interval_td,
         )
 
     def _get_start_time(self):
@@ -446,4 +449,4 @@ class TimeKlineAggregator(KlineAggregator):
 
         # # Build and send kline (only if trades were received)
         self._build_and_send(ts_event, ts_init)
-        self._log.debug(f"Kline built: ts_event={ts_event}, ts_init={ts_init}")
+        self._log.debug("Kline built: ts_event=%s, ts_init=%s", ts_event, ts_init)

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/backends/db_postgresql.py

@@ -139,7 +139,8 @@ class PostgreSQLBackend(StorageBackend):
                         str(symbol),
                     )
                 self._log.debug(
-                    f"Deleted {len(positions_to_delete)} stale positions from database"
+                    "Deleted %s stale positions from database",
+                    len(positions_to_delete),
                 )
 
             for symbol, position in mem_positions.copy().items():
@@ -219,7 +220,7 @@ class PostgreSQLBackend(StorageBackend):
                     return order
                 return None
         except psycopg2.DatabaseError as error:
-            self._log.error(f"Error getting order from PostgreSQL: {error}")
+            self._log.error("Error getting order from PostgreSQL: %s", error)
             return None
 
     def get_symbol_orders(self, symbol: str) -> Set[str]:
@@ -277,9 +278,9 @@ class PostgreSQLBackend(StorageBackend):
                         serialized_value,
                     )
                 except msgspec.EncodeError as e:
-                    self._log.error(f"Error serializing parameter {key}: {e}")
+                    self._log.error("Error serializing parameter %s: %s", key, e)
                 except Exception as e:
-                    self._log.error(f"Error storing parameter {key}: {e}")
+                    self._log.error("Error storing parameter %s: %s", key, e)
 
     def get_param(self, key: str, default: Any = None) -> Any:
         import msgspec
@@ -296,11 +297,11 @@ class PostgreSQLBackend(StorageBackend):
                 try:
                     return self._decode_param(row[0])
                 except msgspec.DecodeError as e:
-                    self._log.error(f"Error deserializing parameter {key}: {e}")
+                    self._log.error("Error deserializing parameter %s: %s", key, e)
                     return default
             return default
         except Exception as e:
-            self._log.error(f"Error getting parameter {key}: {e}")
+            self._log.error("Error getting parameter %s: %s", key, e)
             return default
 
     def get_all_params(self) -> Dict[str, Any]:
@@ -314,8 +315,8 @@ class PostgreSQLBackend(StorageBackend):
                 try:
                     params[row[0]] = self._decode_param(row[1])
                 except msgspec.DecodeError as e:
-                    self._log.error(f"Error deserializing parameter {row[0]}: {e}")
+                    self._log.error("Error deserializing parameter %s: %s", row[0], e)
             cursor.close()
         except Exception as e:
-            self._log.error(f"Error getting all parameters: {e}")
+            self._log.error("Error getting all parameters: %s", e)
         return params

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/backends/db_sqlite.py

@@ -142,7 +142,8 @@ class SQLiteBackend(StorageBackend):
                     [(symbol,) for symbol in positions_to_delete],
                 )
                 self._log.debug(
-                    f"Deleted {len(positions_to_delete)} stale positions from database"
+                    "Deleted %s stale positions from database",
+                    len(positions_to_delete),
                 )
 
             for symbol, position in mem_positions.copy().items():
@@ -217,7 +218,7 @@ class SQLiteBackend(StorageBackend):
             return None
 
         except sqlite3.Error as e:
-            self._log.error(f"Error getting order from SQLite: {e}")
+            self._log.error("Error getting order from SQLite: %s", e)
             return None
 
     def get_symbol_orders(self, symbol: str) -> Set[str]:
@@ -269,9 +270,9 @@ class SQLiteBackend(StorageBackend):
                         (key, serialized_value),
                     )
                 except msgspec.EncodeError as e:
-                    self._log.error(f"Error serializing parameter {key}: {e}")
+                    self._log.error("Error serializing parameter %s: %s", key, e)
                 except sqlite3.Error as e:
-                    self._log.error(f"Error storing parameter {key}: {e}")
+                    self._log.error("Error storing parameter %s: %s", key, e)
             await self._async_conn.commit()
 
     def get_param(self, key: str, default: Any = None) -> Any:
@@ -286,11 +287,11 @@ class SQLiteBackend(StorageBackend):
                 try:
                     return self._decode_param(row[0])
                 except msgspec.DecodeError as e:
-                    self._log.error(f"Error deserializing parameter {key}: {e}")
+                    self._log.error("Error deserializing parameter %s: %s", key, e)
                     return default
             return default
         except sqlite3.Error as e:
-            self._log.error(f"Error getting parameter {key}: {e}")
+            self._log.error("Error getting parameter %s: %s", key, e)
             return default
 
     def get_all_params(self) -> Dict[str, Any]:
@@ -304,7 +305,7 @@ class SQLiteBackend(StorageBackend):
                 try:
                     params[row[0]] = self._decode_param(row[1])
                 except msgspec.DecodeError as e:
-                    self._log.error(f"Error deserializing parameter {row[0]}: {e}")
+                    self._log.error("Error deserializing parameter %s: %s", row[0], e)
         except sqlite3.Error as e:
-            self._log.error(f"Error getting all parameters: {e}")
+            self._log.error("Error getting all parameters: %s", e)
         return params

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/connector.py

@@ -223,7 +223,7 @@ class PublicConnector(ABC):
         self._add_aggregator(symbol, aggregator)
 
         self._log.info(
-            f"Time kline aggregator created for {symbol} with interval {interval}"
+            "Time kline aggregator created for %s with interval %s", symbol, interval
         )
 
     def unsubscribe_kline_aggregator(
@@ -247,7 +247,9 @@ class PublicConnector(ABC):
                 aggregator.stop()
                 aggregators.remove(aggregator)
                 self._log.info(
-                    f"Time kline aggregator stopped for {symbol} with interval {interval}"
+                    "Time kline aggregator stopped for %s with interval %s",
+                    symbol,
+                    interval,
                 )
         if not aggregators:
             self._aggregators.pop(symbol, None)
@@ -275,7 +277,10 @@ class PublicConnector(ABC):
         self._add_aggregator(symbol, aggregator)
 
         self._log.info(
-            f"Volume kline aggregator created for {symbol} with threshold {volume_threshold} and type {volume_type}"
+            "Volume kline aggregator created for %s with threshold %s and type %s",
+            symbol,
+            volume_threshold,
+            volume_type,
         )
 
     def unsubscribe_volume_kline_aggregator(
@@ -296,7 +301,10 @@ class PublicConnector(ABC):
             ):
                 aggregators.remove(aggregator)
                 self._log.info(
-                    f"Volume kline aggregator stopped for {symbol} with threshold {volume_threshold} and type {volume_type}"
+                    "Volume kline aggregator stopped for %s with threshold %s and type %s",
+                    symbol,
+                    volume_threshold,
+                    volume_type,
                 )
         if not aggregators:
             self._aggregators.pop(symbol, None)
@@ -690,7 +698,7 @@ class MockLinearConnector:
             )
             return order
         except OrderError as e:
-            self._log.error(f"Error creating order: {e}")
+            self._log.error("Error creating order: %s", e)
             return Order(
                 exchange=self._exchange_id,
                 timestamp=self._clock.timestamp_ms(),
@@ -726,7 +734,8 @@ class MockLinearConnector:
             book = self._cache.bookl1(symbol)
             if not book:
                 self._log.warning(
-                    f"Please subscribe to the `bookl1` data for {symbol} or data not ready"
+                    "Please subscribe to the `bookl1` data for %s or data not ready",
+                    symbol,
                 )
                 continue
             notional += float(position.amount) * book.mid
@@ -739,7 +748,8 @@ class MockLinearConnector:
             book = self._cache.bookl1(symbol)
             if not book:
                 self._log.warning(
-                    f"Please subscribe to the `bookl1` data for {symbol} or data not ready"
+                    "Please subscribe to the `bookl1` data for %s or data not ready",
+                    symbol,
                 )
                 return
 
@@ -851,7 +861,7 @@ class MockLinearConnector:
         self._apply_fee(order)
 
     async def connect(self):
-        self._log.debug(f"Starting mock connector for {self._account_type}")
+        self._log.debug("Starting mock connector for %s", self._account_type)
         await self._init_position()
         await self._init_balance()
 

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/ems.py

@@ -138,7 +138,7 @@ class ExecutionManagementSystem(ABC):
     def _do_put(self, queue: PriorityOrderQueue, item: Any) -> None:
         # Always runs on the loop thread: queue access + bookkeeping are serialized.
         if self._shutdown:
-            self._log.warning(f"EMS is shutting down; order submit rejected: {item}")
+            self._log.warning("EMS is shutting down; order submit rejected: %s", item)
             return
         priority = _item_priority(item)
 
@@ -161,7 +161,7 @@ class ExecutionManagementSystem(ABC):
             return
         exc = task.exception()
         if exc:
-            self._log.error(f"Queue put failed: {exc!r}")
+            self._log.error("Queue put failed: %r", exc)
 
     def _build(self, private_connectors: Dict[AccountType, PrivateConnector]):
         self._private_connectors = private_connectors
@@ -440,7 +440,7 @@ class ExecutionManagementSystem(ABC):
             SubmitType.CANCEL_BATCH: self._cancel_batch_orders,
         }
 
-        self._log.debug(f"Handling orders for account type: {account_type}")
+        self._log.debug("Handling orders for account type: %s", account_type)
         # Each dequeued item runs as its own task so one in-flight REST round
         # trip does not block the rest of the queue. The semaphore throttles
         # the dequeue itself: excess items stay in the priority queue (where
@@ -452,7 +452,7 @@ class ExecutionManagementSystem(ABC):
             queue_item = await queue.get()
             await semaphore.acquire()
             (order_submit, submit_type) = queue_item
-            self._log.debug(f"[ORDER SUBMIT]: {order_submit}")
+            self._log.debug("[ORDER SUBMIT]: %s", order_submit)
             self._task_manager.create_task(
                 self._run_submit(
                     submit_handlers[submit_type],
@@ -476,9 +476,12 @@ class ExecutionManagementSystem(ABC):
         except Exception:
             self._log.error(
                 "Order submit handler failed, "
-                f"account_type={account_type}, submit_type={submit_type}, "
-                f"order_submit={order_submit}\n"
-                f"Traceback: {traceback.format_exc()}"
+                "account_type=%s, submit_type=%s, order_submit=%s\n"
+                "Traceback: %s",
+                account_type,
+                submit_type,
+                order_submit,
+                traceback.format_exc(),
             )
         finally:
             semaphore.release()

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/oms.py

@@ -81,31 +81,31 @@ class OrderManagementSystem(ABC):
         valid = self._cache._order_status_update(order)  # INITIALIZED -> PENDING
         match order.status:
             case OrderStatus.PENDING:
-                self._log.debug(f"ORDER STATUS PENDING: {str(order)}")
+                self._log.debug("ORDER STATUS PENDING: %s", order)
                 self._msgbus.send(endpoint="pending", msg=order)
             case OrderStatus.FAILED:
-                self._log.debug(f"ORDER STATUS FAILED: {str(order)}")
+                self._log.debug("ORDER STATUS FAILED: %s", order)
                 self._msgbus.send(endpoint="failed", msg=order)
             case OrderStatus.ACCEPTED:
-                self._log.debug(f"ORDER STATUS ACCEPTED: {str(order)}")
+                self._log.debug("ORDER STATUS ACCEPTED: %s", order)
                 self._msgbus.send(endpoint="accepted", msg=order)
             case OrderStatus.PARTIALLY_FILLED:
-                self._log.debug(f"ORDER STATUS PARTIALLY FILLED: {str(order)}")
+                self._log.debug("ORDER STATUS PARTIALLY FILLED: %s", order)
                 self._msgbus.send(endpoint="partially_filled", msg=order)
             case OrderStatus.CANCELED:
-                self._log.debug(f"ORDER STATUS CANCELED: {str(order)}")
+                self._log.debug("ORDER STATUS CANCELED: %s", order)
                 self._msgbus.send(endpoint="canceled", msg=order)
             case OrderStatus.CANCELING:
-                self._log.debug(f"ORDER STATUS CANCELING: {str(order)}")
+                self._log.debug("ORDER STATUS CANCELING: %s", order)
                 self._msgbus.send(endpoint="canceling", msg=order)
             case OrderStatus.CANCEL_FAILED:
-                self._log.debug(f"ORDER STATUS CANCEL FAILED: {str(order)}")
+                self._log.debug("ORDER STATUS CANCEL FAILED: %s", order)
                 self._msgbus.send(endpoint="cancel_failed", msg=order)
             case OrderStatus.FILLED:
-                self._log.debug(f"ORDER STATUS FILLED: {str(order)}")
+                self._log.debug("ORDER STATUS FILLED: %s", order)
                 self._msgbus.send(endpoint="filled", msg=order)
             case OrderStatus.EXPIRED:
-                self._log.debug(f"ORDER STATUS EXPIRED: {str(order)}")
+                self._log.debug("ORDER STATUS EXPIRED: %s", order)
                 self._msgbus.send(endpoint="expired", msg=order)
 
         if valid and order.status == OrderStatus.CANCEL_FAILED:
@@ -139,7 +139,7 @@ class OrderManagementSystem(ABC):
         except asyncio.CancelledError:
             raise
         except Exception as exc:
-            self._log.error(f"Order query scan loop stopped unexpectedly: {exc}")
+            self._log.error("Order query scan loop stopped unexpectedly: %s", exc)
             raise
 
     def _scan_timed_out_orders(self) -> None:
@@ -209,19 +209,25 @@ class OrderManagementSystem(ABC):
 
         try:
             self._log.debug(
-                f"Querying order status: reason={reason} symbol={order.symbol} oid={oid}"
+                "Querying order status: reason=%s symbol=%s oid=%s",
+                reason,
+                order.symbol,
+                oid,
             )
             queried_order = await self.query_order(oid=oid, symbol=order.symbol)
             if queried_order is None:
                 self._log.warning(
-                    f"Order status query returned no order: reason={reason} "
-                    f"symbol={order.symbol} oid={oid}"
+                    "Order status query returned no order: reason=%s symbol=%s oid=%s",
+                    reason,
+                    order.symbol,
+                    oid,
                 )
                 return
             if queried_order.oid is None:
                 self._log.error(
-                    f"Order status query returned order without oid: "
-                    f"symbol={order.symbol} oid={oid}"
+                    "Order status query returned order without oid: symbol=%s oid=%s",
+                    order.symbol,
+                    oid,
                 )
                 return
             self.order_status_update(queried_order)
@@ -229,8 +235,11 @@ class OrderManagementSystem(ABC):
             raise
         except Exception as exc:
             self._log.error(
-                f"Order status query failed: reason={reason} "
-                f"symbol={order.symbol} oid={oid}: {exc}"
+                "Order status query failed: reason=%s symbol=%s oid=%s: %s",
+                reason,
+                order.symbol,
+                oid,
+                exc,
             )
         finally:
             self._querying_oids.discard(oid)

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/retry.py

@@ -181,7 +181,7 @@ class RetryManager(Generic[T]):
         """
         Cancel the retry operation.
         """
-        self._log.debug(f"Canceling {self!r}")
+        self._log.debug("Canceling %r", self)
         self.cancel_event.set()
 
     def clear(self) -> None:
@@ -195,19 +195,25 @@ class RetryManager(Generic[T]):
         self.message = None
 
     def _cancel(self) -> None:
-        self._log.warning(f"Canceled retry for '{self.name}'")
+        self._log.warning("Canceled retry for '%s'", self.name)
         self.result = False
         self.message = "Canceled retry"
 
     def _log_retry(self, retry: int, retry_delay_ms: int) -> None:
         self._log.warning(
-            f"Retrying {retry}/{self.max_retries} for '{self.name}' "
-            f"in {retry_delay_ms / 1000}s{self._details_str()}",
+            "Retrying %s/%s for '%s' in %ss%s",
+            retry,
+            self.max_retries,
+            self.name,
+            retry_delay_ms / 1000,
+            self._details_str(),
         )
 
     def _log_error(self) -> None:
         self._log.error(
-            f"Failed on '{self.name}'{self._details_str()}",
+            "Failed on '%s'%s",
+            self.name,
+            self._details_str(),
         )
 
     def _details_str(self) -> str:

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/sms.py

@@ -73,7 +73,7 @@ class SubscriptionManagementSystem:
             return
         exc = task.exception()
         if exc:
-            self._log.error(f"Queue put failed: {exc!r}")
+            self._log.error("Queue put failed: %r", exc)
 
     def _infer_account_type(self, symbol: str) -> AccountType:
         """Infer account type from symbol"""
@@ -143,7 +143,7 @@ class SubscriptionManagementSystem:
         )
 
         self._safe_put(self._subscribe_queue, subscription)
-        self._log.debug(f"Subscription queued: {data_type} for {symbols}")
+        self._log.debug("Subscription queued: %s for %s", data_type, symbols)
 
     def unsubscribe(
         self,
@@ -172,7 +172,7 @@ class SubscriptionManagementSystem:
         )
 
         self._safe_put(self._unsubscribe_queue, unsubscription)
-        self._log.debug(f"Unsubscription queued: {data_type} for {symbols}")
+        self._log.debug("Unsubscription queued: %s for %s", data_type, symbols)
 
     def _subscribe_trade(
         self, subscription: SubscriptionSubmit, account_type: AccountType
@@ -448,7 +448,7 @@ class SubscriptionManagementSystem:
 
         while True:
             subscription = await self._subscribe_queue.get()
-            self._log.debug(f"[SUBSCRIPTION]: {subscription}")
+            self._log.debug("[SUBSCRIPTION]: %s", subscription)
 
             grouped = self._group_symbols_by_account_type(subscription.symbols)
 
@@ -494,7 +494,7 @@ class SubscriptionManagementSystem:
 
         while True:
             unsubscription = await self._unsubscribe_queue.get()
-            self._log.debug(f"[UNSUBSCRIPTION]: {unsubscription}")
+            self._log.debug("[UNSUBSCRIPTION]: %s", unsubscription)
 
             grouped = self._group_symbols_by_account_type(unsubscription.symbols)
             # Process each account type group

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/base/ws_client.py

@@ -67,7 +67,7 @@ class Listener(WSListener):
         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()}`."
+                "Sent user specific ping: `%s`.", self._specific_ping_msg.decode()
             )
         else:
             transport.send_ping()
@@ -124,14 +124,17 @@ class Listener(WSListener):
                 case WSMsgType.CLOSE:
                     close_code = frame.get_close_code()
                     self._log.warning(
-                        f"Received close frame. Close code: {str(close_code)}"
+                        "Received close frame. Close code: %s", 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)}"
+                "Error processing message: %s\nTraceback: %s\nws_frame: %s",
+                e,
+                traceback.format_exc(),
+                self._decode_frame(frame),
             )
 
 
@@ -204,7 +207,7 @@ class WSClient(ABC):
         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}")
+            self._log.warning("Connection change callback error: %s", exc)
 
     def _is_client_connected(self, client_id: int) -> bool:
         return self._transports.get(client_id) is not None
@@ -289,7 +292,7 @@ class WSClient(ABC):
 
     async def _connect(self, client_id: int):
         self._log.debug(
-            f"Connecting to Websocket at {self._url} (client {client_id})..."
+            "Connecting to Websocket at %s (client %s)...", self._url, client_id
         )
         WSListenerFactory = lambda: Listener(  # noqa: E731
             self._callback,
@@ -309,7 +312,9 @@ class WSClient(ABC):
         self._transports[client_id] = transport
         self._listeners[client_id] = listener
         self._log.debug(
-            f"Websocket connected successfully to {self._url} (client {client_id})."
+            "Websocket connected successfully to %s (client %s).",
+            self._url,
+            client_id,
         )
         self._notify_connection_change(client_id, True)
 
@@ -350,20 +355,22 @@ class WSClient(ABC):
                 if transport is None:
                     break
                 await transport.wait_disconnected()
-                self._log.debug(f"Websocket disconnected (client {client_id}).")
+                self._log.debug("Websocket disconnected (client %s).", client_id)
                 self._notify_connection_change(client_id, False)
             except asyncio.CancelledError:
                 self._log.debug(
-                    f"Websocket connection loop cancelled (client {client_id})."
+                    "Websocket connection loop cancelled (client %s).", client_id
                 )
                 break
             except Exception as e:
-                self._log.error(f"Connection error: {e}")
+                self._log.error("Connection error: %s", e)
             # finally:
             #     self._clean_up_client(client_id)
 
             self._log.warning(
-                f"Websocket reconnecting in {self._reconnect_interval} seconds (client {client_id})..."
+                "Websocket reconnecting in %s seconds (client %s)...",
+                self._reconnect_interval,
+                client_id,
             )
             await asyncio.sleep(self._reconnect_interval)
 
@@ -384,11 +391,11 @@ class WSClient(ABC):
         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)}")
+                self._log.warning("Websocket not connected. drop msg: %s", payload)
                 return
         transport = self._transports.get(target_id)
         if transport is None:
-            self._log.warning(f"Websocket not connected. drop msg: {str(payload)}")
+            self._log.warning("Websocket not connected. drop msg: %s", payload)
             return
         transport.send(WSMsgType.TEXT, msgspec.json.encode(payload))
 

{walrasquant_lib-0.4.24 → walrasquant_lib-0.4.26}/src/walrasquant/config.py

@@ -14,16 +14,21 @@ class LogConfig:
     Maps directly to nexuslog.basicConfig() parameters.
 
     Attributes:
-        filename: Optional file path for log output. If None, logs to stdout.
+        filename: Optional file path for log output. If "auto", writes to
+            logs/{strategy_id}_{user_id}.log. 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.
+        color: ANSI colorization of log output. "auto" colors only when writing
+            to a color-capable terminal, "off" disables it, "always" forces it
+            even for files and pipes.
     """
 
-    filename: str | None = None
+    filename: Literal["auto"] | str | None = None
     level: LOG_LEVELS = "INFO"
     name_levels: dict[str | None, LOG_LEVELS] | None = None
     unix_ts: bool = False
     batch_size: int = 1
+    color: Literal["auto", "off", "always"] = "auto"
 
     def __post_init__(self):
         if self.level not in ["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"]:
@@ -38,6 +43,11 @@ class LogConfig:
                         f"Invalid level: {level} for logger name: {name}. Must be one of TRACE, DEBUG, INFO, WARNING, ERROR."
                     )
 
+        if self.color not in ["auto", "off", "always"]:
+            raise ValueError(
+                f"Invalid color: {self.color}. Must be one of auto, off, always."
+            )
+
 
 @dataclass
 class BasicConfig:
@@ -265,7 +275,7 @@ class Config:
     )
     zero_mq_signal_config: ZeroMQSignalConfig | None = None
     db_path: str = ".keys/cache.db"
-    storage_backend: StorageType = StorageType.SQLITE
+    storage_backend: StorageType = StorageType.MEMORY
     cache_sync_interval: int = 60
     cache_expired_time: int = 3600
     log_config: LogConfig = field(default_factory=LogConfig)
@@ -277,7 +287,7 @@ class Config:
     order_query_config: OrderQueryConfig = field(default_factory=OrderQueryConfig)
 
     def __post_init__(self):
-        if self.log_config.filename is None:
+        if self.log_config.filename == "auto":
             import os
 
             log_folder = "logs"