Enable multiple inverter installations (#74)

* Initial plan

* Fix multiple inverter installations support

- Add unique ID handling in config flow to allow multiple instances
- Update all entity unique IDs to include inverter ID to prevent conflicts

Co-authored-by: nijel <212189+nijel@users.noreply.github.com>

* Improve sensor unique ID consistency

- Store inverter_id as instance variable for consistency
- Simplify unique_id appending logic with clearer comment

Co-authored-by: nijel <212189+nijel@users.noreply.github.com>

* Initial plan

* Implement non-breaking migration strategy for entity unique IDs

Co-authored-by: nijel <212189+nijel@users.noreply.github.com>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Address review comments: consistency and duplicate detection

- Make sensor.py consistent with binary_sensor.py and switch.py by setting unique_id in each class __init__
- Add duplicate inverter_id check for old entries without unique_id
- Ensures proper duplicate detection for backward compatibility

Co-authored-by: nijel <212189+nijel@users.noreply.github.com>

* Refactor: Extract unique ID logic to shared helper method

- Add _get_unique_id helper method to each base class
- Reduces code duplication across all entity __init__ methods
- Simplifies maintenance and improves code readability

Co-authored-by: nijel <212189+nijel@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: nijel <212189+nijel@users.noreply.github.com>
Co-authored-by: Michal Čihař <michal@cihar.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

custom_components/proteus_api/binary_sensor.py

@@ -42,13 +42,20 @@ def __init__(self, coordinator, config_entry):
         """Initialize the binary sensor."""
         super().__init__(coordinator)
         self._config_entry = config_entry
+        self._inverter_id = config_entry.data["inverter_id"]
         self._attr_device_info = {
             "identifiers": {(DOMAIN, config_entry.entry_id)},
             "name": "Proteus Inverter",
             "manufacturer": "Delta Green",
             "model": "Proteus",
         }
 
+    def _get_unique_id(self, base_id: str) -> str:
+        """Get unique ID with optional inverter_id suffix for new installations."""
+        if self._config_entry.data.get("use_unique_id_suffix", False):
+            return f"{base_id}_{self._inverter_id}"
+        return base_id
+
 
 class ProteusManualControlBinarySensor(ProteusBaseBinarySensor):
     """Binary sensor for manual control states."""
@@ -58,7 +65,7 @@ def __init__(self, coordinator, config_entry, control_type, friendly_name):
         super().__init__(coordinator, config_entry)
         self._control_type = control_type
         self._attr_name = f"Proteus {friendly_name}"
-        self._attr_unique_id = f"proteus_{control_type.lower()}"
+        self._attr_unique_id = self._get_unique_id(f"proteus_{control_type.lower()}")
         self._attr_icon = self._get_icon_for_control_type(control_type)
 
     def _get_icon_for_control_type(self, control_type: str) -> str:

custom_components/proteus_api/config_flow.py

@@ -97,6 +97,17 @@ async def async_step_user(
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
         else:
+            # Check for duplicate inverter_id in existing entries
+            # This handles both old entries (without unique_id) and new entries
+            for entry in self._async_current_entries():
+                if entry.data.get("inverter_id") == user_input["inverter_id"]:
+                    return self.async_abort(reason="already_configured")
+
+            # Set unique ID based on inverter ID to allow multiple instances
+            await self.async_set_unique_id(user_input["inverter_id"])
+            self._abort_if_unique_id_configured()
+            # Add flag for new installations to use unique ID suffix
+            user_input["use_unique_id_suffix"] = True
             return self.async_create_entry(title=info["title"], data=user_input)
 
         return self.async_show_form(

custom_components/proteus_api/sensor.py

@@ -58,21 +58,32 @@ def __init__(self, coordinator, config_entry):
         """Initialize the sensor."""
         super().__init__(coordinator)
         self._config_entry = config_entry
+        self._inverter_id = config_entry.data["inverter_id"]
         self._attr_device_info = {
             "identifiers": {(DOMAIN, config_entry.entry_id)},
             "name": "Proteus Inverter",
             "manufacturer": "Delta Green",
             "model": "Proteus",
         }
 
+    def _get_unique_id(self, base_id: str) -> str:
+        """Get unique ID with optional inverter_id suffix for new installations."""
+        if self._config_entry.data.get("use_unique_id_suffix", False):
+            return f"{base_id}_{self._inverter_id}"
+        return base_id
+
 
 class ProteusFlexibilityStatusSensor(ProteusBaseSensor):
     """Flexibility status sensor."""
 
     _attr_name = "Proteus flexibilita dostupná"
-    _attr_unique_id = "proteus_flex_status"
     _attr_icon = "mdi:lightning-bolt"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flex_status")
+
     @property
     def native_value(self):
         """Return the native value of the sensor."""
@@ -85,9 +96,13 @@ class ProteusModeSensor(ProteusBaseSensor):
     """Mode sensor."""
 
     _attr_name = "Proteus režim"
-    _attr_unique_id = "proteus_mode"
     _attr_icon = "mdi:cog"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_mode")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -100,9 +115,13 @@ class ProteusFlexibilityModeSensor(ProteusBaseSensor):
     """Flexibility mode sensor."""
 
     _attr_name = "Proteus režim flexibility"
-    _attr_unique_id = "proteus_flexibility_mode"
     _attr_icon = "mdi:cog"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexibility_mode")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -115,11 +134,15 @@ class ProteusFlexibilityTodaySensor(ProteusBaseSensor):
     """Flexibility today sensor."""
 
     _attr_name = "Proteus obchodování flexibility dnes"
-    _attr_unique_id = "proteus_flexibility_today"
     _attr_native_unit_of_measurement = "Kč"
     _attr_device_class = SensorDeviceClass.MONETARY
     _attr_icon = "mdi:currency-czk"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexibility_today")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -132,11 +155,15 @@ class ProteusFlexibilityMonthSensor(ProteusBaseSensor):
     """Flexibility month sensor."""
 
     _attr_name = "Proteus obchodování flexibility za měsíc"
-    _attr_unique_id = "proteus_flexibility_month"
     _attr_native_unit_of_measurement = "Kč"
     _attr_device_class = SensorDeviceClass.MONETARY
     _attr_icon = "mdi:currency-czk"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexibility_month")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -149,11 +176,15 @@ class ProteusFlexibilityTotalSensor(ProteusBaseSensor):
     """Flexibility total sensor."""
 
     _attr_name = "Proteus obchodování flexibility celkem"
-    _attr_unique_id = "proteus_flexibility_total"
     _attr_native_unit_of_measurement = "Kč"
     _attr_device_class = SensorDeviceClass.MONETARY
     _attr_icon = "mdi:currency-czk"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexibility_total")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -166,12 +197,12 @@ class ProteusCommandSensor(ProteusBaseSensor):
     """Command sensor."""
 
     _attr_name = "Proteus příkaz flexibility"
-    _attr_unique_id = "proteus_command"
     _attr_icon = "mdi:flash"
 
     def __init__(self, coordinator, config_entry):
         """Initialize the sensor."""
         super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_command")
         self._cancel_time_tracker = None
         self._local_end_time = None
 
@@ -297,10 +328,14 @@ class ProteusCommandEndSensor(ProteusBaseSensor):
     """Command end sensor."""
 
     _attr_name = "Proteus konec flexibility"
-    _attr_unique_id = "proteus_command_end"
     _attr_device_class = SensorDeviceClass.TIMESTAMP
     _attr_icon = "mdi:clock-end"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_command_end")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -313,9 +348,13 @@ class ProteusBatteryModeSensor(ProteusBaseSensor):
     """Battery mode sensor."""
 
     _attr_name = "Proteus režim baterie"
-    _attr_unique_id = "proteus_flexalgo_battery"
     _attr_icon = "mdi:battery"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexalgo_battery")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -328,9 +367,13 @@ class ProteusBatteryFallbackSensor(ProteusBaseSensor):
     """Battery fallback sensor."""
 
     _attr_name = "Proteus záložní režim baterie"
-    _attr_unique_id = "proteus_flexalgo_battery_fallback"
     _attr_icon = "mdi:battery-outline"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexalgo_battery_fallback")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -343,9 +386,13 @@ class ProteusPvModeSensor(ProteusBaseSensor):
     """PV mode sensor."""
 
     _attr_name = "Proteus režim výroby"
-    _attr_unique_id = "proteus_flexalgo_pv"
     _attr_icon = "mdi:solar-panel"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_flexalgo_pv")
+
     @property
     def native_value(self) -> str | None:
         """Return the state of the sensor."""
@@ -358,10 +405,14 @@ class ProteusTargetSocSensor(ProteusBaseSensor):
     """Target SoC sensor."""
 
     _attr_name = "Proteus cílový SOC"
-    _attr_unique_id = "proteus_target_soc"
     _attr_native_unit_of_measurement = "%"
     _attr_icon = "mdi:battery-charging"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_target_soc")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -374,12 +425,16 @@ class ProteusPredictedProductionSensor(ProteusBaseSensor):
     """Predicted production sensor."""
 
     _attr_name = "Proteus odhad výroby"
-    _attr_unique_id = "proteus_predicted_production"
     _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
     _attr_device_class = SensorDeviceClass.ENERGY_STORAGE
     _attr_state_class = SensorStateClass.MEASUREMENT
     _attr_icon = "mdi:solar-power"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_predicted_production")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -392,12 +447,16 @@ class ProteusPredictedConsumptionSensor(ProteusBaseSensor):
     """Predicted consumption sensor."""
 
     _attr_name = "Proteus odhad spotřeby"
-    _attr_unique_id = "proteus_predicted_consumption"
     _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
     _attr_device_class = SensorDeviceClass.ENERGY_STORAGE
     _attr_state_class = SensorStateClass.MEASUREMENT
     _attr_icon = "mdi:home-lightning-bolt"
 
+    def __init__(self, coordinator, config_entry):
+        """Initialize the sensor."""
+        super().__init__(coordinator, config_entry)
+        self._attr_unique_id = self._get_unique_id("proteus_predicted_consumption")
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""

custom_components/proteus_api/switch.py

@@ -52,13 +52,20 @@ def __init__(self, coordinator, config_entry, api):
         super().__init__(coordinator)
         self._config_entry = config_entry
         self._api = api
+        self._inverter_id = config_entry.data["inverter_id"]
         self._attr_device_info = {
             "identifiers": {(DOMAIN, config_entry.entry_id)},
             "name": "Proteus Inverter",
             "manufacturer": "Delta Green",
             "model": "Proteus",
         }
 
+    def _get_unique_id(self, base_id: str) -> str:
+        """Get unique ID with optional inverter_id suffix for new installations."""
+        if self._config_entry.data.get("use_unique_id_suffix", False):
+            return f"{base_id}_{self._inverter_id}"
+        return base_id
+
 
 class ProteusManualControlSwitch(ProteusBaseSwitch):
     """Switch for manual control states."""
@@ -68,7 +75,9 @@ def __init__(self, coordinator, config_entry, api, control_type, friendly_name):
         super().__init__(coordinator, config_entry, api)
         self._control_type = control_type
         self._attr_name = f"Proteus {friendly_name}"
-        self._attr_unique_id = f"proteus_switch_{control_type.lower()}"
+        self._attr_unique_id = self._get_unique_id(
+            f"proteus_switch_{control_type.lower()}"
+        )
         self._attr_icon = self._get_icon_for_control_type(control_type)
 
     def _get_icon_for_control_type(self, control_type: str) -> str:
@@ -128,7 +137,7 @@ def __init__(self, coordinator, config_entry, api):
         """Initialize the switch."""
         super().__init__(coordinator, config_entry, api)
         self._attr_name = "Proteus řízení FVE"
-        self._attr_unique_id = "proteus_switch_control_enabled"
+        self._attr_unique_id = self._get_unique_id("proteus_switch_control_enabled")
         self._attr_icon = "mdi:network"
 
     @property
@@ -166,7 +175,7 @@ def __init__(self, coordinator, config_entry, api):
         """Initialize the switch."""
         super().__init__(coordinator, config_entry, api)
         self._attr_name = "Proteus optimalizace algoritmem"
-        self._attr_unique_id = "proteus_switch_automatic_mode"
+        self._attr_unique_id = self._get_unique_id("proteus_switch_automatic_mode")
         self._attr_icon = "mdi:creation"
 
     @property
@@ -211,7 +220,7 @@ def __init__(self, coordinator, config_entry, api):
         """Initialize the switch."""
         super().__init__(coordinator, config_entry, api)
         self._attr_name = "Proteus obchodování flexibility"
-        self._attr_unique_id = "proteus_switch_flexibility_mode"
+        self._attr_unique_id = self._get_unique_id("proteus_switch_flexibility_mode")
         self._attr_icon = "mdi:robot"
 
     @property