Reconfigure improvements, custom translation strings

Author: jmattsson

custom_components/powersensor/PowersensorSensorEntity.py

@@ -7,12 +7,14 @@
 from .PowersensorEntity import PowersensorEntity
 from .SensorMeasurements import SensorMeasurements
 from .const import DOMAIN
+from .custom_translations import translate
 
 import logging
 _LOGGER = logging.getLogger(__name__)
 
 
 _config = {
+    # TODO: change names to translation keys
     SensorMeasurements.Battery: {
         "name": "Battery Level",
         "device_class": SensorDeviceClass.BATTERY,
@@ -77,20 +79,12 @@ def _ensure_matching_prefix(self):
 
     def _rename_based_on_role(self):
         if self._device_name == self._default_device_name():
-            if self.role =='house-net':
-                self._device_name = "Powersensor Mains Sensor ⚡"
-                self._ensure_matching_prefix()
-                return True
-            elif self.role == 'water':
-                self._device_name = "Powersensor Water Sensor ⚡"
-                self._ensure_matching_prefix()
-                return True
-            elif self.role == 'solar':
-                self._device_name = "Powersensor Solar Sensor ⚡"
+            if self.role =='house-net' or self.role == "water" or self.role == "solar":
+                self._device_name = translate(f"sensor_types.{self.role}")
                 self._ensure_matching_prefix()
                 return True
         return False
 
     def _default_device_name(self):
-        return f'Powersensor Sensor (ID: {self._mac}) ⚡'
+        return translate("formats.sensor") % self._mac
 

custom_components/powersensor/config_flow.py

@@ -7,17 +7,18 @@
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.service_info import zeroconf
-from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.helpers.selector import selector
 
 from .const import DEFAULT_PORT, DOMAIN
+from .custom_translations import translate
 
 def _extract_device_name(discovery_info) -> str:
     """Extract a user-friendly device name from zeroconf info."""
     properties = discovery_info.properties or {}
 
     if "id" in properties:
-        return f'🔌 Mac({properties["id"].strip()})'
+        return translate("formats.discovery_name") % properties["id"].strip()
+
     # Fall back to cleaning up the service name
     name = discovery_info.name or ""
 
@@ -42,13 +43,6 @@ def _extract_device_name(discovery_info) -> str:
 
 _LOGGER = logging.getLogger(__name__)
 
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): str,
-        vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
-    }
-)
-
 
 class PowersensorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow."""
@@ -58,69 +52,36 @@ class PowersensorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     def __init__(self):
         """Initialize the config flow."""
 
-    # async def async_step_user(self, user_input=None) -> ConfigFlowResult:
-    #     """Handle manual user setup."""
-    #     errors = {}
-    #
-    #     if user_input is not None:
-    #         # Validate the host/connection here if needed
-    #         try:
-    #             # Set unique ID based on host to prevent duplicates
-    #             await self.async_set_unique_id(user_input[CONF_HOST])
-    #             self._abort_if_unique_id_configured()
-    #
-    #             return self.async_create_entry(
-    #                 title=user_input[CONF_NAME],
-    #                 data=user_input
-    #             )
-    #         except Exception as ex:
-    #             _LOGGER.error("Error validating configuration: %s", ex)
-    #             errors["base"] = "cannot_connect"
-    #
-    #     data_schema = vol.Schema(
-    #         {
-    #             vol.Required(CONF_NAME): cv.string,
-    #             vol.Required(CONF_HOST): cv.string,
-    #             vol.Optional(CONF_PORT, default=80): cv.port,
-    #         }
-    #     )
-    #
-    #     return self.async_show_form(
-    #         step_id="user",
-    #         data_schema=data_schema,
-    #         errors=errors
-    #     )
     async def async_step_reconfigure(self, user_input: dict | None = None)->FlowResult:
         entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
+        dispatcher = entry.runtime_data["dispatcher"]
 
+        mac2name = { mac: translate("formats.sensor") % mac for mac in dispatcher.sensors }
+
+        unknown = "<unknown>"
         if user_input is not None:
-            # @todo: better handling of mac association
-            for key, role in user_input.items():
-                mac= key[33:-2]
-                _LOGGER.debug(f"Sending {mac}, {role} to {DOMAIN}_update_role")
-                async_dispatcher_send(self.hass, f"{DOMAIN}_update_role",
-                                      mac, role)  # default role
-            await self.hass.config_entries.async_reload(entry.entry_id)
-            return self.async_abort(reason="Powersensor role updates successful!")
+            name2mac = { name: mac for mac, name in mac2name.items() }
+            for name, role in user_input.items():
+                mac = name2mac.get(name)
+                if role == unknown:
+                    role = None
+                _LOGGER.debug(f"Applying {role} to {mac}")
+                async_dispatcher_send(self.hass, f"{DOMAIN}_update_role", mac, role)
+            return self.async_abort(reason="Roles successfully applied!")
 
-        dispatcher = entry.runtime_data["dispatcher"]
         sensor_roles = {}
         for sensor_mac in dispatcher.sensors:
-            role = entry.data.get('roles', {}).get(sensor_mac, None)
-            if not role:
-                sensor_roles[vol.Optional(f"Powersensor Sensor [Mac Address: {sensor_mac}]")] =  vol.In(
-                    ["house-net", "solar", "water", "appliance", "none"]
-                )
-            else:
-                sensor_roles[vol.Optional(f"Powersensor Sensor [Mac Address: {sensor_mac}]", description={"suggested_value": role})] = selector({
-                    "select" : {
-                    "options" : ["house-net", "solar", "water", "appliance", "none"] ,
-                        "mode" : "dropdown"
-                    }
-                })
-
-        # if not sensor_roles:
-        #     return self.async_abort(reason="no_sensors_found_without_roles")
+            role = entry.data.get('roles', {}).get(sensor_mac, unknown)
+            sel = selector({
+                "select": {
+                    "options": [
+                        # Note: these strings are NOT subject to translation
+                        "house-net", "solar", "water", "appliance", unknown
+                    ],
+                    "mode": "dropdown",
+                }
+            })
+            sensor_roles[vol.Optional(mac2name[sensor_mac], description={"suggested_value": role})] = sel
 
         return self.async_show_form(
             step_id="reconfigure",

custom_components/powersensor/custom_translations.py

@@ -0,0 +1,13 @@
+import logging
+
+from homeassistant.core import async_get_hass
+from homeassistant.helpers.translation import async_get_cached_translations
+
+from .const import DOMAIN
+
+
+def translate(key: str) -> str:
+    hass = async_get_hass()
+    translations = async_get_cached_translations(hass, hass.config.language, "custom", DOMAIN)
+    key = f"component.{DOMAIN}.custom.{key}"
+    return translations.get(key, f"🚨 UNTRANSLATED:{key} 🚨")

custom_components/powersensor/translations/en.json

@@ -26,8 +26,18 @@
       "no_devices_found": "No devices found on the network",
       "single_instance_allowed": "Already configured. Only a single configuration possible.",
       "already_configured": "Device is already configured",
-      "cannot_connect": "Failed to connect",
-      "no_sensors_found_without_roles": "All sensors have roles provided!"
+      "cannot_connect": "Failed to connect"
+    }
+  },
+  "custom": {
+    "formats": {
+      "sensor": "Powersensor Sensor (ID: %s) ⚡",
+      "discovery_name": "🔌 Mac(%s)"
+    },
+    "sensor_types": {
+      "house-net": "Powersensor Mains Sensor ⚡",
+      "solar": "Powersensor Solar Sensor ⚡",
+      "water": "Powersensor Water Sensor 💧"
     }
   }
 }