benchlab-pytools 3.0.1__tar.gz → 3.0.2__tar.gz

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to BENCHLAB PyTools are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [SemVer](https://semver.org/).
 
+## [3.0.2] - 2026-08-18
+
+### Fixed
+- Several f-strings had their `{...}` expression split across a line
+  break, which is [PEP 701](https://peps.python.org/pep-0701/) syntax
+  only valid on Python 3.12+. Despite `requires-python = ">=3.10"`, this
+  raised `SyntaxError` immediately on 3.10/3.11 (e.g. `benchlab -tui`
+  failing with `SyntaxError: unterminated string literal` in
+  `benchlab/core/datasource.py`) — invisible in CI since every workflow
+  pins Python 3.13. Collapsed all such f-strings back onto single lines
+  across 27 files.
+
 ## [3.0.1] - 2026-08-18
 
 ### Fixed
@@ -55,5 +67,6 @@ export, MQTT publisher, VU dials, WigiDash, and config import/export tools,
 sharing a common data-source layer (direct serial, FastAPI, MQTT, named
 pipe, service HTTP).
 
+[3.0.2]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.0.1...v3.0.2
 [3.0.1]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.0.0...v3.0.1
 [3.0.0]: https://github.com/BenchLab-io/benchlab-pytools/compare/v0.8.2...v3.0.0

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchlab-pytools
-Version: 3.0.1
+Version: 3.0.2
 Summary: Python control suite for BENCHLAB telemetry devices
 Project-URL: Homepage, https://benchlab.io/
 Project-URL: Repository, https://github.com/BenchLab-io/benchlab-pytools

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/__init__.py

@@ -2,4 +2,4 @@
 BENCHLAB Telemetry Package
 """
 
-__version__ = "3.0.1"
+__version__ = "3.0.2"

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/config/config_client.py

@@ -177,8 +177,8 @@ class DirectConfigClient(ConfigClient):
 
         self.product_id = info.get('ProductId')
         logger.info(
-            f"Connected to device on {port}, Product ID: 0x{
-                self.product_id:02X}")
+            f"Connected to device on {port}, "
+            f"Product ID: 0x{self.product_id:02X}")
 
     def get_device_info(self) -> Optional[Dict[str, Any]]:
         """Get device information."""
@@ -465,8 +465,7 @@ class NamedPipeConfigClient(ConfigClient):
             win32pipe.WaitNamedPipe(path, 5000)
         except pywintypes.error as e:
             raise ConnectionError(
-                f"Pipe '{
-                    self.pipe_name}' not available: {e}") from e
+                f"Pipe '{self.pipe_name}' not available: {e}") from e
 
         self.handle = win32file.CreateFile(
             path,

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/config/config_manager.py

@@ -55,8 +55,7 @@ class ConfigManager:
             from benchlab_pycore.core import get_fleet_info
             devices = get_fleet_info()
             logger.info(
-                f"Discovered {
-                    len(devices)} device(s) via direct serial")
+                f"Discovered {len(devices)} device(s) via direct serial")
             return devices
         except Exception as e:
             logger.error(f"Failed to discover direct devices: {e}")
@@ -357,8 +356,8 @@ class ConfigManager:
                     device_config.selector.model_dump(), devices)
                 if not identifier:
                     logger.error(
-                        f"Device not found matching selector: {
-                            device_config.selector}")
+                        "Device not found matching selector: "
+                        f"{device_config.selector}")
                     continue
 
                 logger.info(f"Selected: {identifier}")
@@ -453,8 +452,8 @@ class ConfigManager:
                         if not client.write_fan_config(
                                 profile.profileId, fan_id, fan_dict):
                             logger.error(
-                                f"Failed to write fan config {
-                                    profile.profileId}/{fan_id}")
+                                "Failed to write fan config "
+                                f"{profile.profileId}/{fan_id}")
                             success = False
 
             # Apply RGB profiles

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/core/datasource.py

@@ -372,8 +372,7 @@ class FastAPIDataSource(DataSource):
                 return True
             else:
                 logger.error(
-                    f"FastAPI health check returned {
-                        response.status_code}")
+                    f"FastAPI health check returned {response.status_code}")
         except Exception as e:
             logger.error(f"Failed to connect to FastAPI server: {e}")
 
@@ -1025,9 +1024,8 @@ class ServiceHttpDataSource(DataSource):
 
         if resp.status_code != 200:
             logger.error(
-                f"BenchLab service health check failed (HTTP {
-                    resp.status_code}) " f"at {
-                    self.base_url}/health")
+                f"BenchLab service health check failed "
+                f"(HTTP {resp.status_code}) at {self.base_url}/health")
             return False
 
         # Fetch initial device list
@@ -1051,8 +1049,7 @@ class ServiceHttpDataSource(DataSource):
             target=self._worker_loop, daemon=True)
         self._worker_thread.start()
         logger.info(
-            f"Connected to BenchLab service HTTP API at {
-                self.base_url}")
+            f"Connected to BenchLab service HTTP API at {self.base_url}")
         return True
 
     def disconnect(self) -> None:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/core/datasource_manager.py

@@ -109,14 +109,14 @@ class DataSourceManager:
             self._datasource = create_datasource(self.source_type, **kwargs)
 
             if not self._datasource.connect():
-                self._last_error = f"Failed to connect to {
-                    self.source_type} datasource"
+                self._last_error = (
+                    f"Failed to connect to {self.source_type} datasource")
                 return False
 
             devices = self._datasource.list_devices()
             if not devices:
-                self._last_error = f"No devices available via {
-                    self.source_type}"
+                self._last_error = (
+                    f"No devices available via {self.source_type}")
                 return False
 
             if uid and any(d.get('uid') == uid for d in devices):
@@ -153,9 +153,8 @@ class DataSourceManager:
             self._worker_thread.start()
 
             logger.info(
-                f"Connected to {
-                    self.source_type} datasource, selected device: {
-                    self._selected_uid}")
+                f"Connected to {self.source_type} datasource, "
+                f"selected device: {self._selected_uid}")
             return True
 
         except Exception as e:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/core/infrastructure.py

@@ -80,9 +80,8 @@ class InfrastructureManager:
                 return True
 
             logger.info(
-                f"Starting FastAPI server on {
-                    self.fastapi_host}:{
-                    self.fastapi_port}")
+                f"Starting FastAPI server on "
+                f"{self.fastapi_host}:{self.fastapi_port}")
 
             try:
                 # Start FastAPI server as subprocess
@@ -107,8 +106,8 @@ class InfrastructureManager:
                     if self._wait_for_port(
                             self.fastapi_host, self.fastapi_port, timeout):
                         logger.info(
-                            f"FastAPI server started on port {
-                                self.fastapi_port}")
+                            "FastAPI server started on port "
+                            f"{self.fastapi_port}")
                         return True
                     else:
                         logger.error("FastAPI server failed to start")
@@ -171,9 +170,8 @@ class InfrastructureManager:
                 return True
 
             logger.info(
-                f"Starting MQTT publisher to {
-                    self.mqtt_broker}:{
-                    self.mqtt_port}")
+                f"Starting MQTT publisher to "
+                f"{self.mqtt_broker}:{self.mqtt_port}")
 
             try:
                 self._stop_event.clear()

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/core/process_manager.py

@@ -248,8 +248,7 @@ class ProcessManager:
                             os.path.abspath(__file__)),
                         "..",
                         "logs",
-                        f"svc_{
-                            mp.name}")
+                        f"svc_{mp.name}")
                     with open(f"{log_base}_stderr.log", "r",
                               encoding="utf-8") as f:
                         mp.stderr_log = f.read()

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/core/statistics.py

@@ -202,10 +202,9 @@ class StatsFormatter:
         if min_val is None or max_val is None or avg_val is None:
             return ""
 
-        return f"{
-            min_val:.{decimals}f}-{
-            max_val:.{decimals}f} ~{
-            avg_val:.{decimals}f}{unit}"
+        return (
+            f"{min_val:.{decimals}f}-{max_val:.{decimals}f} "
+            f"~{avg_val:.{decimals}f}{unit}")
 
 
 # Convenience function for creating a stats callback

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/csv_log/csv_logger_enhanced.py

@@ -141,10 +141,8 @@ class EnhancedCSVLogger:
         print("\n--- Available Devices ---")
         for i, dev in enumerate(devices, 1):
             print(
-                f"  {i}: Port: {
-                    dev.port:<12} UID: {
-                    dev.uid}  FW: {
-                    dev.firmware}")
+                f"  {i}: Port: {dev.port:<12} UID: {dev.uid}  "
+                f"FW: {dev.firmware}")
 
         selection = input(
             "\nEnter device numbers (comma-separated), 'all', "

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/csv_log/message_batcher.py

@@ -95,9 +95,7 @@ class MessageBatcher:
                     (self.metrics.avg_flush_time * (n - 1) + elapsed) / n
                 )
             self.logger.debug(
-                f"Flushed {
-                    len(messages_to_flush)} messages in {
-                    elapsed:.3f}s")
+                f"Flushed {len(messages_to_flush)} messages in {elapsed:.3f}s")
             return True
 
         except Exception as e:
@@ -222,8 +220,7 @@ class CSVBatchWriter:
                 elif self.format == "json":
                     self._write_json_batch(file_info, messages_to_write)
                 self.logger.debug(
-                    f"Wrote {
-                        len(messages_to_write)} rows for {uid}")
+                    f"Wrote {len(messages_to_write)} rows for {uid}")
             except Exception as e:
                 self.logger.error(f"Failed to write batch for {uid}: {e}")
                 buf.extend(messages_to_write)  # restore on failure

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/csv_log/smart_retry.py

@@ -104,8 +104,8 @@ class CircuitBreaker:
         if (self.config.circuit_breaker_enabled and
                 self.failure_count >= self.config.circuit_failure_threshold):
             self.logger.warning(
-                f"Circuit breaker: opening after {
-                    self.failure_count} failures")
+                "Circuit breaker: opening after "
+                f"{self.failure_count} failures")
             self.state = CircuitState.OPEN
 
 
@@ -144,9 +144,8 @@ class SmartRetryManager:
 
                 if attempt == self.config.max_retries:
                     self.logger.error(
-                        f"Max retries ({
-                            self.config.max_retries}) exceeded for {
-                            func.__name__}")
+                        f"Max retries ({self.config.max_retries}) "
+                        f"exceeded for {func.__name__}")
                     raise e
 
                 # Calculate delay
@@ -242,9 +241,8 @@ class AdaptiveRetryManager:
 
                 if attempt == self.config.max_retries:
                     self.logger.error(
-                        f"Max retries ({
-                            self.config.max_retries}) exceeded for {
-                            func.__name__}")
+                        f"Max retries ({self.config.max_retries}) "
+                        f"exceeded for {func.__name__}")
                     raise e
 
                 # Calculate adaptive delay

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/graph/app.py

@@ -263,12 +263,15 @@ class GraphApp:
                                             min_y - margin, max_y + margin)
 
                     s = self.session_stats
-                    min_text = f"Min: {
-                        s['min']:.2f}" if s["min"] is not None else "Min: --"
-                    max_text = f"Max: {
-                        s['max']:.2f}" if s["max"] is not None else "Max: --"
-                    avg_text = f"Avg: {
-                        s['avg']:.2f}" if s["avg"] is not None else "Avg: --"
+                    min_text = (
+                        f"Min: {s['min']:.2f}"
+                        if s["min"] is not None else "Min: --")
+                    max_text = (
+                        f"Max: {s['max']:.2f}"
+                        if s["max"] is not None else "Max: --")
+                    avg_text = (
+                        f"Avg: {s['avg']:.2f}"
+                        if s["avg"] is not None else "Avg: --")
                     for tag, text in (
                             ("graph_min", min_text),
                             ("graph_min_float", min_text),

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/hwinfo/hwinfo_export.py

@@ -71,8 +71,7 @@ def write_hwinfo_sensor(device_name, sensor_type, idx, name, value, unit=None):
             # Write Value
             if isinstance(value, float):
                 winreg.SetValueEx(
-                    key, "Value", 0, winreg.REG_SZ, f"{
-                        value:.3f}")
+                    key, "Value", 0, winreg.REG_SZ, f"{value:.3f}")
             else:
                 winreg.SetValueEx(key, "Value", 0, winreg.REG_SZ, str(value))
 
@@ -156,8 +155,7 @@ def _export_grouped(device_name: str, grouped_sensors: dict):
             write_hwinfo_sensor(device_name, group, idx, key, value, unit)
 
     summary = ", ".join(
-        f"{k}: {
-            len(v)}" for k,
+        f"{k}: {len(v)}" for k,
         v in grouped_sensors.items() if v)
     logger.debug("Device %s export summary: %s", device_name, summary)
 
@@ -308,8 +306,8 @@ def export_all_devices(update_interval=1, datasource=None):
             "HWiNFO export is only supported on Windows. "
             "Please run on a Windows system.")
         raise RuntimeError(
-            f"HWiNFO export requires Windows. Current platform: {
-                sys.platform}")
+            "HWiNFO export requires Windows. "
+            f"Current platform: {sys.platform}")
 
     # Remove only old BenchLab entries, not user-created sensors
     try:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/link/link_main.py

@@ -217,8 +217,7 @@ class CloudMQTTClient:
                 time.sleep(0.1)
             if not self._connected:
                 logger.error(
-                    f"Timed out connecting to {host}:{
-                        self.cfg['port']}")
+                    f"Timed out connecting to {host}:{self.cfg['port']}")
                 return False
             logger.info(f"Connected to cloud broker {host}:{self.cfg['port']}")
             return True
@@ -229,9 +228,8 @@ class CloudMQTTClient:
     def reconnect(self) -> bool:
         """Attempt to reconnect using a fresh client."""
         logger.info(
-            f"Reconnecting to cloud broker {
-                self.cfg['host']}:{
-                self.cfg['port']}...")
+            f"Reconnecting to cloud broker "
+            f"{self.cfg['host']}:{self.cfg['port']}...")
         try:
             self._client.loop_stop()
         except Exception:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/sources.py

@@ -145,12 +145,7 @@ import asyncio
 from amqtt.broker import Broker
 
 config = {{
-    "listeners": {{
-        "default": {{
-            "type": "tcp",
-            "bind": "0.0.0.0:{port}",
-        }},
-    }},
+    "listeners": {{"default": {{"type": "tcp", "bind": "0.0.0.0:{port}"}}}},
     "auth": {{"allow-anonymous": True}},
     "topic-check": {{"enabled": False}},
 }}

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/tui/tui_core.py

@@ -210,9 +210,9 @@ class TUICore:
 
     def _render_size_warning(self, width: int, height: int):
         msg = (
-            f" Terminal too small ({width}x{height})" f" — resize to {
-                Config.MIN_TERMINAL_COLS}x{
-                Config.MIN_TERMINAL_ROWS} ")
+            f" Terminal too small ({width}x{height})"
+            f" — resize to "
+            f"{Config.MIN_TERMINAL_COLS}x{Config.MIN_TERMINAL_ROWS} ")
         try:
             self.stdscr.addstr(
                 0, 0, msg[:width],   # ← truncate, don't center
@@ -428,25 +428,17 @@ class TUICore:
         try:
             self.stdscr.addstr(6, cols['SEL'], f"{'':2}", hdr_attr)
             self.stdscr.addstr(
-                6, cols['MODEL'], f"{
-                    'Model':<{
-                        widths['MODEL']}}", hdr_attr)
+                6, cols['MODEL'],
+                f"{'Model':<{widths['MODEL']}}", hdr_attr)
             self.stdscr.addstr(
-                6, cols['PORT'], f"{
-                    'Port':<{
-                        widths['PORT']}}", hdr_attr)
+                6, cols['PORT'], f"{'Port':<{widths['PORT']}}", hdr_attr)
             self.stdscr.addstr(
-                6, cols['FW'], f"{
-                    'Firmware':<{
-                        widths['FW']}}", hdr_attr)
+                6, cols['FW'], f"{'Firmware':<{widths['FW']}}", hdr_attr)
             self.stdscr.addstr(
-                6, cols['UID'], f"{
-                    'UID':<{
-                        widths['UID']}}", hdr_attr)
+                6, cols['UID'], f"{'UID':<{widths['UID']}}", hdr_attr)
             self.stdscr.addstr(
-                6, cols['STATUS'], f"{
-                    'Status':<{
-                        widths['STATUS']}}", hdr_attr)
+                6, cols['STATUS'],
+                f"{'Status':<{widths['STATUS']}}", hdr_attr)
             self.stdscr.addstr(6, cols['ACTIVE'], "Active", hdr_attr)
         except curses.error:
             pass
@@ -490,21 +482,19 @@ class TUICore:
             try:
                 self.stdscr.addstr(row, cols['SEL'], cursor, row_color)
                 self.stdscr.addstr(
-                    row, cols['MODEL'], f"{
-                        model_str:<{
-                            widths['MODEL']}}", row_color)
+                    row, cols['MODEL'],
+                    f"{model_str:<{widths['MODEL']}}", row_color)
                 self.stdscr.addstr(
-                    row, cols['PORT'], f"{
-                        port:<{
-                            widths['PORT']}}", row_color)
+                    row, cols['PORT'],
+                    f"{port:<{widths['PORT']}}", row_color)
 
                 if is_busy:
                     self.stdscr.addstr(
-                        row, cols['FW'], f"{'N/A':<{widths['FW']}}", row_color)
+                        row, cols['FW'],
+                        f"{'N/A':<{widths['FW']}}", row_color)
                     self.stdscr.addstr(
-                        row, cols['UID'], f"{
-                            dev_uid:<{
-                                widths['UID']}}", curses.color_pair(
+                        row, cols['UID'], f"{dev_uid:<{widths['UID']}}",
+                        curses.color_pair(
                             Config.COLOR_PAIRS['caution']) | curses.A_BOLD)
                 else:
                     try:
@@ -513,18 +503,15 @@ class TUICore:
                     except (TypeError, ValueError):
                         fw_str = "0x????????"
                     self.stdscr.addstr(
-                        row, cols['FW'], f"{
-                            fw_str:<{
-                                widths['FW']}}", row_color)
+                        row, cols['FW'],
+                        f"{fw_str:<{widths['FW']}}", row_color)
                     self.stdscr.addstr(
-                        row, cols['UID'], f"{
-                            dev_uid:<{
-                                widths['UID']}}", row_color)
+                        row, cols['UID'],
+                        f"{dev_uid:<{widths['UID']}}", row_color)
 
                 self.stdscr.addstr(
-                    row, cols['STATUS'], f"{
-                        status:<{
-                            widths['STATUS']}}", status_color)
+                    row, cols['STATUS'],
+                    f"{status:<{widths['STATUS']}}", status_color)
 
                 if is_active:
                     self.stdscr.addstr(
@@ -616,8 +603,7 @@ class TUICore:
 
             self._draw_section(16, 2, "TUI")
             self.stdscr.addstr(
-                17, 4, f"{
-                    'Refresh Interval':<22} {refresh_interval} s")
+                17, 4, f"{'Refresh Interval':<22} {refresh_interval} s")
 
         except curses.error:
             pass
@@ -1145,8 +1131,7 @@ class TUICore:
                 self.stdscr.addstr(
                     row,
                     cols['NAME'] + 2,
-                    f"Fan{
-                        i:<5}",
+                    f"Fan{i:<5}",
                     fan_color)
                 self.stdscr.addstr(
                     row, cols['DUTY'] + 2, f"{duty:>5}%", fan_color)
@@ -1282,9 +1267,7 @@ class TUICore:
 
         try:
             self.stdscr.addstr(
-                y, x, f"{
-                    label:<14} {val_str} {
-                    unit:<3} ", color)
+                y, x, f"{label:<14} {val_str} {unit:<3} ", color)
             self.stdscr.addstr(bar, color)
 
             if stat and stat[0] is not None:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/tui/tui_main.py

@@ -118,8 +118,8 @@ class TUIApplication:
 
         if self.source_type == 'fastapi':
             if hasattr(args, 'api_port'):
-                datasource_kwargs['base_url'] = f"http://127.0.0.1:{
-                    args.api_port}"
+                datasource_kwargs['base_url'] = (
+                    f"http://127.0.0.1:{args.api_port}")
             else:
                 datasource_kwargs['base_url'] = "http://127.0.0.1:8000"
             datasource_kwargs['timeout'] = 5.0
@@ -234,26 +234,22 @@ class TUIApplication:
             if self.datasource_manager.connect():
                 uid = self.datasource_manager.get_selected_uid()
                 self.tui_core.set_status(
-                    f"Connected via {
-                        self.source_type.upper()}")
+                    f"Connected via {self.source_type.upper()}")
                 logger.info(
-                    f"Connected to {
-                        self.source_type} datasource, selected: {uid}")
+                    f"Connected to {self.source_type} datasource, "
+                    f"selected: {uid}")
             else:
                 snapshot = self.datasource_manager.snapshot()
                 error_msg = snapshot.get(
-                    'last_error', f"Failed to connect to {
-                        self.source_type}")
+                    'last_error', f"Failed to connect to {self.source_type}")
                 self.tui_core.set_status(
                     f"Connection failed: {error_msg}", 5.0)
                 logger.error(
-                    f"Failed to connect to {
-                        self.source_type}: {error_msg}")
+                    f"Failed to connect to {self.source_type}: {error_msg}")
         except Exception as e:
             self.tui_core.set_status(f"Connection error: {str(e)}", 5.0)
             logger.error(
-                f"Exception during {
-                    self.source_type} connection: {e}")
+                f"Exception during {self.source_type} connection: {e}")
 
     def _connect_to_device(self, device: Dict[str, Any]):
         port = device.get('port')
@@ -280,8 +276,7 @@ class TUIApplication:
                 if self.datasource_manager.select_device(uid):
                     self.tui_core.set_status(f"Selected device {uid}")
                     logger.info(
-                        f"Selected device {uid} via {
-                            self.source_type}")
+                        f"Selected device {uid} via {self.source_type}")
                 else:
                     self.tui_core.set_status("Failed to select device", 3.0)
                     logger.warning(f"Failed to select device {uid}")

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.2}/benchlab/vu/vu_server_manager.py

@@ -147,8 +147,7 @@ def start_vu_server() -> subprocess.Popen | None:
         time.sleep(1)
         if check_vu_server(new_cfg["vu_server_url"], new_cfg["api_key"]):
             logger.info(
-                f"VU server is now running at {
-                    new_cfg['vu_server_url']}")
+                f"VU server is now running at {new_cfg['vu_server_url']}")
             break
     else:
         logger.error("Failed to verify VU server after startup.")
@@ -159,8 +158,7 @@ def start_vu_server() -> subprocess.Popen | None:
     try:
         VU_SERVER_CONFIG.write_text(json.dumps(new_cfg, indent=2))
         logger.info(
-            f"Updated {VU_SERVER_CONFIG} with {
-                new_cfg['vu_server_url']}")
+            f"Updated {VU_SERVER_CONFIG} with {new_cfg['vu_server_url']}")
     except Exception as e:
         logger.warning(f"Failed to write {VU_SERVER_CONFIG}: {e}")