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

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

@@ -4,6 +4,42 @@ 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.3] - 2026-08-18
+
+### Fixed
+- TUI: the 12VHPWR tab's Voltage section was cut off with no way to
+  scroll, since `MIN_TERMINAL_ROWS` (35) was well under the ~48 rows
+  the stacked Power/Current/Voltage layout plus status bar actually
+  needs. Raised to 48.
+- `mqtt`, `service_http`, and `named_pipe` data sources never surfaced
+  `vendor_id`/`product_id`/`firmware_version`, so the Fleet TUI's
+  Model column (BL1 vs BL2 detection) was always wrong for these
+  sources:
+  - `mqtt`: the publisher's retained info payload only sent
+    `uid`/`com_port`/`firmware`; it now also reads
+    `ProductId`/`VendorId`/`FwVersion` via `read_device()` and
+    computes `variant`.
+  - `named_pipe`: the C# service's camelCase `productId` is now
+    mapped to the PascalCase keys the TUI expects
+    (`vendorId`/`firmwareVersion` also mapped), with `variant`
+    computed — field names verified against the
+    `BENCHLAB.BENCHLAB_Service` source.
+  - `service_http`: added a device-info normalization step (the C#
+    HTTP API only ever sends `productId`, confirmed against source —
+    vendor/firmware are unavailable there and default to unknown).
+
+## [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 +91,7 @@ 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.3]: https://github.com/BenchLab-io/benchlab-pytools/compare/v3.0.2...v3.0.3
+[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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchlab-pytools
-Version: 3.0.1
+Version: 3.0.3
 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.3}/benchlab/__init__.py

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

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.3}/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.3}/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.3}/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}")
 
@@ -596,7 +595,15 @@ class MQTTDataSource(DataSource):
 
         with self._lock:
             return [
-                {'uid': uid, 'port': info.get('com_port', 'unknown')}
+                {
+                    'uid': uid,
+                    'port': info.get('com_port', 'unknown'),
+                    'firmware': info.get('firmware', '?'),
+                    'variant': info.get('variant'),
+                    'VendorId': info.get('VendorId', 0),
+                    'ProductId': info.get('ProductId', 0),
+                    'FwVersion': info.get('FwVersion', 0),
+                }
                 for uid, info in self._device_info.items()
             ]
 
@@ -730,6 +737,34 @@ def _normalise_cs_telemetry(sensors_raw: list) -> Dict[str, Any]:
     return result
 
 
+def _normalise_cs_device_info(d: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalise a C# service device dict into the shape the TUI expects.
+
+    The C# service's /devices, /device/{uid}/info, and discovery-pipe
+    responses use camelCase keys (productId, vendorId, firmwareVersion —
+    confirmed against BenchlabSensorWorker.cs/HttpApiServer.cs in the
+    BENCHLAB_Service repo). Note the HTTP API's /devices and
+    /device/{uid}/info endpoints only send productId — no vendorId or
+    firmwareVersion — so those default to 0 there; only the named-pipe
+    discovery/GetServiceInfo responses include all three.
+    DirectDataSource/FastAPIDataSource populate PascalCase keys
+    (ProductId, VendorId, FwVersion) plus a computed 'variant' — this
+    adds those same keys without discarding what the C# service sent.
+    """
+    result = dict(d)
+    product_id = d.get("ProductId", d.get("productId", 0))
+    vendor_id = d.get("VendorId", d.get("vendorId", 0))
+    fw_version = d.get("FwVersion", d.get("firmwareVersion", 0))
+    result["ProductId"] = product_id
+    result["VendorId"] = vendor_id
+    result["FwVersion"] = fw_version
+    result.setdefault("firmware", d.get("firmware", fw_version))
+    # 0x11 = BENCHLAB_BL2_PRODUCT_ID (see DirectDataSource/tui_core.py).
+    result.setdefault(
+        "variant", "BL2" if product_id == 0x11 else "ORIGINAL")
+    return result
+
+
 class NamedPipeDataSource(DataSource):
     """Data source that connects to the C# BenchLab Windows service via
     named pipes.
@@ -793,14 +828,31 @@ class NamedPipeDataSource(DataSource):
             self._pipe_names.clear()
             for d in devices:
                 uid = d.get("guid") or d.get("deviceName", "unknown")
+                # Field names confirmed against BenchlabSensorWorker.cs's
+                # ListDevices response in the BENCHLAB_Service repo.
+                product_id = d.get("productId", 0)
+                vendor_id = d.get("vendorId", 0)
+                fw_version = d.get("firmwareVersion", 0)
+                # 0x11 = BENCHLAB_BL2_PRODUCT_ID (see
+                # DirectDataSource/tui_core.py); hardcoded rather than
+                # importing benchlab_pycore, which named_pipe consumers
+                # of the C# service don't necessarily have installed.
+                variant = "BL2" if product_id == 0x11 else "ORIGINAL"
                 self._devices[uid] = {
                     "uid": uid,
                     "port": d.get("port", "unknown"),
                     "name": d.get("deviceName", "unknown"),
-                    "productId": d.get("productId", 0),
+                    "productId": product_id,
                     "status": d.get("status", "unknown"),
                     "sensorCount": d.get("sensorCount", 0),
                     "pipeName": d.get("pipeName", ""),
+                    # PascalCase aliases matching DirectDataSource's shape,
+                    # so consumers (e.g. the TUI) can detect BL1/BL2.
+                    "firmware": fw_version,
+                    "variant": variant,
+                    "VendorId": vendor_id,
+                    "ProductId": product_id,
+                    "FwVersion": fw_version,
                 }
                 self._pipe_names[uid] = d.get("pipeName", "")
 
@@ -1025,9 +1077,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
@@ -1043,7 +1094,7 @@ class ServiceHttpDataSource(DataSource):
                 for d in devices:
                     uid = d.get("uid", "")
                     if uid:
-                        self._devices[uid] = d
+                        self._devices[uid] = _normalise_cs_device_info(d)
 
         self._connected = True
         self._stop_event.clear()
@@ -1051,8 +1102,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:
@@ -1149,7 +1199,8 @@ class ServiceHttpDataSource(DataSource):
                         for d in devices:
                             uid = d.get("uid", "")
                             if uid:
-                                self._devices[uid] = d
+                                self._devices[uid] = (
+                                    _normalise_cs_device_info(d))
 
                 # Poll telemetry for each device
                 with self._lock:

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/benchlab/mqtt/mqtt_publisher.py

@@ -17,6 +17,11 @@ from benchlab_pycore.core import (
     read_device,
     BENCHLAB_ORIGINAL_PRODUCT_ID,
 )
+try:
+    from benchlab_pycore.core import BENCHLAB_BL2_PRODUCT_ID
+except ImportError:
+    from benchlab_pycore.core import (
+        BENCHLAB_CFE_PRODUCT_ID as BENCHLAB_BL2_PRODUCT_ID)
 from benchlab_pycore.core.serial_io import get_fleet_info
 
 # Import DeviceRegistry so the MQTT publisher publishes device lifecycle events
@@ -340,12 +345,36 @@ def device_thread(device, cfg, publish_interval=1):
                     time.sleep(1)
                     continue
 
+                # Read device info (ProductId/VendorId/FwVersion) so the
+                # info payload lets consumers (e.g. the TUI) detect the
+                # BL1/BL2 variant, matching DirectDataSource's shape.
+                vendor_id = 0
+                product_id = BENCHLAB_ORIGINAL_PRODUCT_ID
+                fw_version = device.get("firmware")
+                try:
+                    dev_info = read_device(ser)
+                    if dev_info:
+                        vendor_id = dev_info.get('VendorId', 0)
+                        product_id = dev_info.get(
+                            'ProductId', BENCHLAB_ORIGINAL_PRODUCT_ID)
+                        fw_version = dev_info.get('FwVersion', fw_version)
+                except Exception:
+                    pass
+                variant = (
+                    "BL2" if product_id == BENCHLAB_BL2_PRODUCT_ID
+                    else "ORIGINAL")
+
                 # Send initial info payload (retain=True so late subscribers
                 # like the TUI can discover this device)
                 info_payload = {
                     "uid": uid,
                     "com_port": port,
-                    "firmware": device.get("firmware")}
+                    "firmware": device.get("firmware"),
+                    "VendorId": vendor_id,
+                    "ProductId": product_id,
+                    "FwVersion": fw_version,
+                    "variant": variant,
+                }
                 topic_info = f"{cfg['topic_prefix']}/{uid}/info"
                 mqtt_publish(
                     client,

{benchlab_pytools-3.0.1 → benchlab_pytools-3.0.3}/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.3}/benchlab/tui/config.py

@@ -14,7 +14,10 @@ from typing import Tuple
 # ═══════════════════════════════════════════════════════════════════════════════
 
 # Minimum terminal size requirements
-MIN_TERMINAL_ROWS = 35
+# The 12VHPWR tab's stacked Power/Current/Voltage sections (12 channels
+# each) need rows through ~45 for the last Voltage bar, plus 2 rows for
+# the status bar at the bottom (drawn at height-2/height-1).
+MIN_TERMINAL_ROWS = 48
 MIN_TERMINAL_COLS = 100
 
 # Tab configuration