Updated apps

custom_components/powercalc/configuration/config_entry_conversion.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import copy
 from datetime import timedelta
-from typing import Any
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ENTITY_ID, CONF_NAME
@@ -35,96 +33,57 @@ from custom_components.powercalc.const import (
 )
 
 
-def convert_config_entry_to_sensor_config(config_entry: ConfigEntry, hass: HomeAssistant) -> ConfigType:  # noqa: C901
+def _convert_template(config: ConfigType, source_key: str, target_key: str, hass: HomeAssistant) -> None:
+    if source_key in config:
+        config[target_key] = Template(config.pop(source_key), hass)
+
+
+def convert_config_entry_to_sensor_config(config_entry: ConfigEntry, hass: HomeAssistant) -> ConfigType:
     """Convert the config entry structure to the sensor config used to create the entities."""
-    sensor_config = dict(config_entry.data.copy())
+    sensor_config = dict(config_entry.data)
     sensor_type = sensor_config.get(CONF_SENSOR_TYPE)
+    if sensor_type == SensorType.GROUP:
+        sensor_config[CONF_CREATE_GROUP] = sensor_config.get(CONF_NAME)
+    elif sensor_type == SensorType.REAL_POWER:
+        sensor_config[CONF_POWER_SENSOR_ID] = sensor_config.get(CONF_ENTITY_ID)
+        sensor_config[CONF_FORCE_ENERGY_SENSOR_CREATION] = True
 
-    def handle_sensor_type() -> None:
-        """Handle sensor type-specific configuration."""
-        if sensor_type == SensorType.GROUP:
-            sensor_config[CONF_CREATE_GROUP] = sensor_config.get(CONF_NAME)
-        elif sensor_type == SensorType.REAL_POWER:
-            sensor_config[CONF_POWER_SENSOR_ID] = sensor_config.get(CONF_ENTITY_ID)
-            sensor_config[CONF_FORCE_ENERGY_SENSOR_CREATION] = True
-
-    def process_template(config: dict[str, Any], template_key: str, target_key: str) -> None:
-        """Convert a template key in the config to a Template object."""
-        if template_key in config:
-            config[target_key] = Template(config[template_key], hass)
-            del config[template_key]
-
-    def process_on_time(config: dict[str, Any]) -> None:
-        """Convert on_time dictionary to timedelta."""
-        on_time = config.get(CONF_ON_TIME)
-        config[CONF_ON_TIME] = (
+    if CONF_DAILY_FIXED_ENERGY in sensor_config:
+        daily_fixed_config = dict(sensor_config[CONF_DAILY_FIXED_ENERGY])
+        _convert_template(daily_fixed_config, CONF_VALUE_TEMPLATE, CONF_VALUE, hass)
+        on_time = daily_fixed_config.get(CONF_ON_TIME)
+        daily_fixed_config[CONF_ON_TIME] = (
             timedelta(hours=on_time["hours"], minutes=on_time["minutes"], seconds=on_time["seconds"])
             if on_time
             else timedelta(days=1)
         )
-
-    def process_states_power(states_power: dict[str, Any] | list[dict[str, Any]]) -> dict[str, Any]:
-        """Convert state power values to Template objects where necessary."""
-        return {
-            key: Template(value, hass) if isinstance(value, str) and "{{" in value else value
-            for key, value in normalize_states_power(states_power).items()
-        }
-
-    def process_daily_fixed_energy() -> None:
-        """Process daily fixed energy configuration."""
-        if CONF_DAILY_FIXED_ENERGY not in sensor_config:
-            return
-
-        daily_fixed_config = copy.copy(sensor_config[CONF_DAILY_FIXED_ENERGY])
-        process_template(daily_fixed_config, CONF_VALUE_TEMPLATE, CONF_VALUE)
-        process_on_time(daily_fixed_config)
         sensor_config[CONF_DAILY_FIXED_ENERGY] = daily_fixed_config
 
-    def process_fixed_config() -> None:
-        """Process fixed energy configuration."""
-        if CONF_FIXED not in sensor_config:
-            return
-
-        fixed_config = copy.copy(sensor_config[CONF_FIXED])
-        process_template(fixed_config, CONF_POWER_TEMPLATE, CONF_POWER)
+    if CONF_FIXED in sensor_config:
+        fixed_config = dict(sensor_config[CONF_FIXED])
+        _convert_template(fixed_config, CONF_POWER_TEMPLATE, CONF_POWER, hass)
         if CONF_STATES_POWER in fixed_config:
-            fixed_config[CONF_STATES_POWER] = process_states_power(fixed_config[CONF_STATES_POWER])
+            fixed_config[CONF_STATES_POWER] = {
+                key: Template(value, hass) if isinstance(value, str) and "{{" in value else value
+                for key, value in normalize_states_power(fixed_config[CONF_STATES_POWER]).items()
+            }
         sensor_config[CONF_FIXED] = fixed_config
 
-    def process_linear_config() -> None:
-        """Process linear energy configuration."""
-        if CONF_LINEAR not in sensor_config:
-            return
+    if CONF_LINEAR in sensor_config:
+        sensor_config[CONF_LINEAR] = dict(sensor_config[CONF_LINEAR])
 
-        linear_config = copy.copy(sensor_config[CONF_LINEAR])
-        sensor_config[CONF_LINEAR] = linear_config
-
-    def process_calculation_enabled_condition() -> None:
-        """Process calculation enabled condition template."""
-        if CONF_CALCULATION_ENABLED_CONDITION in sensor_config:
-            sensor_config[CONF_CALCULATION_ENABLED_CONDITION] = Template(
-                sensor_config[CONF_CALCULATION_ENABLED_CONDITION],
-                hass,
-            )
-
-    def process_utility_meter_offset() -> None:
-        if CONF_UTILITY_METER_OFFSET in sensor_config:
-            sensor_config[CONF_UTILITY_METER_OFFSET] = timedelta(days=sensor_config[CONF_UTILITY_METER_OFFSET])
-
-    def process_playbook_config() -> None:
-        if CONF_PLAYBOOK not in sensor_config:
-            return
-        playbook_config = copy.copy(sensor_config[CONF_PLAYBOOK])
+    if CONF_PLAYBOOK in sensor_config:
+        playbook_config = dict(sensor_config[CONF_PLAYBOOK])
         playbook_config[CONF_PLAYBOOKS] = normalize_playbooks(playbook_config[CONF_PLAYBOOKS])
         sensor_config[CONF_PLAYBOOK] = playbook_config
 
-    handle_sensor_type()
+    if CONF_CALCULATION_ENABLED_CONDITION in sensor_config:
+        sensor_config[CONF_CALCULATION_ENABLED_CONDITION] = Template(
+            sensor_config[CONF_CALCULATION_ENABLED_CONDITION],
+            hass,
+        )
 
-    process_daily_fixed_energy()
-    process_fixed_config()
-    process_linear_config()
-    process_playbook_config()
-    process_calculation_enabled_condition()
-    process_utility_meter_offset()
+    if CONF_UTILITY_METER_OFFSET in sensor_config:
+        sensor_config[CONF_UTILITY_METER_OFFSET] = timedelta(days=sensor_config[CONF_UTILITY_METER_OFFSET])
 
     return sensor_config