reauth if for example device version is missing (#58)

Author: ViperRNMC

CHANGELOG.md

@@ -2,80 +2,95 @@
 
 ## [2025.10.1] - 2025-10-15
 
-### Added
+### Added 
+
 - Config flow now asks for device version (v1/v2 or v3) during setup so the integration can load the correct register map at runtime.
 - Per-version register modules: `registers_v12.py` (v1/v2) and `registers_v3.py` (v3). The integration selects the right definitions based on the chosen version.
 
 ### Fixed
+
 - Options flow: removed deprecated explicit `config_entry` assignment (compatibility with HA 2025.12).
 - Modbus client: properly handle CancelledError during shutdown; guard reconnection and client recreation to avoid NoneType errors and noisy ERROR logs on stop/reload.
 - Efficiency sensors: skip calculations when denominators are zero or required inputs are missing to avoid division-by-zero errors.
 - Energy sensors: ensure `state_class` is set to `total` or `total_increasing` for sensors with `device_class: energy`.
 
 ### Notes
-- `registers_v3.py` was generated from a CSV mapping but the registers are UNTESTED for v3 devices. Manual verification on actual hardware is REQUIRED before using v3 definitions in production.
+
+- `registers_v3.py` is generated from CSV mapping; entries are untested and require manual verification on v3 hardware before production use.
 
 ## [2025.9.4] - 2025-09-22
 
 ### Added
+
 - Configurable scan intervals (high, medium, low, very_low) through integration options.
 - Options flow with translated titles and descriptions.
 
 ### Changed
+
 - Coordinator now dynamically adjusts polling interval based on the lowest configured scan interval.
 
 ### Fixed
+
 - Corrected calculation of Actual Conversion Efficiency to properly handle charging vs discharging, avoiding efficiencies above 100%.
 - Properly handle Modbus client closing when disabling the integration.
 - Correctly apply updated polling intervals after options are changed.
 
 ## [2025.9.3] - 2025-09-16
 
 ### Added
+
 - New `Actual Conversion Efficiency` calculated sensor to display the real-time charging/discharging efficiency as a percentage.  
 
 ### Fixed
+
 - Fixed proper closing of Modbus connections when disabling and enabling entities, preventing multiple open sessions.
 - Corrected state class for stored energy sensors to match energy device class requirements.
 - Corrected calculation of Actual Conversion Efficiency to properly handle charging vs discharging, avoiding efficiencies above 100%.
 
 ## [2025.9.2] - 2025-09-07
 
 ### Fixed
+
 - Corrected scaling for `Number` entities, ensuring `min`, `max`, and current values reflect the defined scale.
 - Updated logging to include scale and unit when values are updated in Home Assistant.
 
 ## [2025.9.1] - 2025-09-05
 
 ### Fixed
+
 - Switch writing fixed and now implemented with optimistic mode to handle delayed device response.
 - Fixed PyModbus 3.x / Python 3.9 compatibility: replaced slave with device_id.
 
 ## [2025.9.0] - 2025-09-03
 
 ### Added
+
 - Dependency keys registration so required values are always fetched even if disabled in Home Assistant.
 - Polling now handled centrally via the DataUpdateCoordinator.
 - Dynamic polling intervals based on sensor definitions and dependencies.
 
 ### Changed
+
 - Calculated sensors (Round-Trip Efficiency Total, Round-Trip Efficiency Monthly, Stored Energy) with dependency handling
 - Improved logging for dependency mapping, calculation, and skipping disabled entities.
 - Cleaned up and refactored sensor calculation logic to be reusable and PEP8 compliant.
 
 ## [2025.8.1] - 2025-08-12
 
 ### Added
+
 - New Min Cell Voltage sensor (register 35043) to monitor minimum battery cell voltage
 - New Max Cell Voltage sensor (register 36943) to monitor maximum battery cell voltage
 - New Reset Device button (register 41000) to allow resetting the battery management system via Home Assistant
 
 ### Changed
+
 - Clean up code and improve overall code quality
 
 ## [2025.8.0] - 2025-08-09
 
 ### Fixed
+
 - WiFi strength sensor now reports correct negative dBm values
 - Corrected cell temperature reading after BMS firmware version 213
 

custom_components/marstek_modbus/config_flow.py

@@ -111,6 +111,50 @@ async def async_step_user(self, user_input=None):
             description_placeholders=description_placeholders,
         )
 
+    async def async_step_reauth(self, data=None):
+        """
+        Re-authentication step triggered when a config entry is missing required
+        information (like device_version). This shows a popup asking the user to
+        select the correct device version.
+        """
+        errors = {}
+
+        # Load translations for the current language to present friendly labels
+        language = self.context.get("language", self.hass.config.language)
+        translations = await async_get_translations(
+            self.hass, language, category="config", integrations=DOMAIN
+        )
+
+        if data is not None:
+            # Persist the chosen device version into the existing config entry
+            entry = self._async_current_entries()[0] if self._async_current_entries() else None
+            if entry:
+                try:
+                    new_data = dict(entry.data)
+                    new_data[CONF_DEVICE_VERSION] = data.get(CONF_DEVICE_VERSION)
+                    await self.hass.config_entries.async_update_entry(entry, data=new_data)
+                    return self.async_create_entry(title=entry.title or DOMAIN, data={})
+                except Exception as exc:
+                    _LOGGER.error("Failed to update config entry during reauth: %s", exc)
+                    errors["base"] = "unknown"
+
+        description_placeholders = {
+            "device_version_choices": ", ".join(
+                [f"{v}: {translations.get(f'config.step.user.data.device_version|{v}', v)}" for v in SUPPORTED_VERSIONS]
+            )
+        }
+
+        return self.async_show_form(
+            step_id="reauth",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_DEVICE_VERSION, default=SUPPORTED_VERSIONS[0]): vol.In(SUPPORTED_VERSIONS)
+                }
+            ),
+            errors=errors,
+            description_placeholders=description_placeholders,
+        )
+    
     @staticmethod
     # @callback
     def async_get_options_flow(config_entry):

custom_components/marstek_modbus/coordinator.py

@@ -47,7 +47,31 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry):
         self._scales: dict[str, float] = {} 
 
         # Load register/entity definitions for the device version selected in the config entry
-        registers = get_registers(entry.data.get("device_version"))
+        # If device_version is missing (older installs), schedule a reauth flow so the user
+        # can pick the correct device version via a popup in the UI. Use a safe default
+        # to initialize the coordinator so the integration does not crash while waiting
+        # for the user to respond.
+        raw_device_version = entry.data.get("device_version", "") or ""
+        if not str(raw_device_version).strip():
+            # Start a reauth flow so Home Assistant prompts the user to provide the missing value
+            try:
+                _LOGGER.info(
+                    "Config entry %s missing device_version; starting reauth flow",
+                    entry.entry_id,
+                )
+                # Use async_create_task to avoid awaiting in __init__
+                self.hass.async_create_task(
+                    self.hass.config_entries.async_start_reauth(entry.entry_id)
+                )
+            except Exception:
+                _LOGGER.debug("Failed to start reauth for entry %s", entry.entry_id)
+
+            # Fallback to the first supported version to allow initialization to proceed
+            used_version = SUPPORTED_VERSIONS[0]
+        else:
+            used_version = raw_device_version
+
+        registers = get_registers(used_version)
         self.SENSOR_DEFINITIONS = registers.get("SENSOR_DEFINITIONS", [])
         self.BINARY_SENSOR_DEFINITIONS = registers.get("BINARY_SENSOR_DEFINITIONS", [])
         self.SELECT_DEFINITIONS = registers.get("SELECT_DEFINITIONS", [])