v0.2.3 fixes #16, #18

Author: 0xAHA

README.md

@@ -1,14 +1,20 @@
 """The Midea Heat Pump Water Heater integration."""
 from __future__ import annotations
 
+import json
 import logging
+from datetime import datetime
+from pathlib import Path
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.helpers import config_validation as cv
+import voluptuous as vol
 
 from .const import DOMAIN
 from .coordinator import MideaModbusCoordinator
+from .profile_manager import ProfileManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,6 +26,20 @@
     Platform.SELECT,
 ]
 
+# Service schemas
+SERVICE_EXPORT_PROFILE = "export_profile"
+SERVICE_IMPORT_PROFILE = "import_profile"
+
+EXPORT_PROFILE_SCHEMA = vol.Schema({
+    vol.Optional("entry_id"): cv.string,
+    vol.Optional("name", default="My Profile"): cv.string,
+    vol.Optional("model", default="Custom"): cv.string,
+})
+
+IMPORT_PROFILE_SCHEMA = vol.Schema({
+    vol.Required("profile_json"): cv.string,
+})
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Midea Heat Pump Water Heater from a config entry."""
@@ -43,6 +63,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     # Setup update listener for options flow
     entry.async_on_unload(entry.add_update_listener(update_listener))
 
+    # Register services (only once, not per entry)
+    if not hass.services.has_service(DOMAIN, SERVICE_EXPORT_PROFILE):
+        await _register_services(hass)
+
     return True
 
 
@@ -58,11 +82,182 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
         # Remove from data
         hass.data[DOMAIN].pop(entry.entry_id)
+        
+        # Remove services if no more entries
+        if not hass.data[DOMAIN]:
+            hass.services.async_remove(DOMAIN, SERVICE_EXPORT_PROFILE)
+            hass.services.async_remove(DOMAIN, SERVICE_IMPORT_PROFILE)
 
     return unload_ok
 
 
 async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Handle options update."""
     # Reload the integration
-    await hass.config_entries.async_reload(entry.entry_id)
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
+async def _register_services(hass: HomeAssistant) -> None:
+    """Register integration services."""
+    
+    async def handle_export_profile(call: ServiceCall) -> None:
+        """Handle profile export service call."""
+        # Get the entry to export
+        entry_id = call.data.get("entry_id")
+        if entry_id:
+            if entry_id not in hass.data[DOMAIN]:
+                _LOGGER.error("Invalid entry_id: %s", entry_id)
+                return
+        else:
+            # Use first entry if not specified
+            if not hass.data[DOMAIN]:
+                _LOGGER.error("No configured entries to export")
+                return
+            entry_id = list(hass.data[DOMAIN].keys())[0]
+        
+        config = hass.data[DOMAIN][entry_id]["config"]
+        
+        # Create profile
+        profile_manager = ProfileManager(hass)
+        profile_data = {
+            "name": call.data.get("name", config.get("name", "My Profile")),
+            "model": call.data.get("model", "Custom"),
+            "exported": datetime.now().isoformat(),
+            "version": "0.2.2",
+            "integration": "midea_heatpump_hws",
+            "connection": {
+                "port": config.get("port", 502),
+                "modbus_unit": config.get("modbus_unit", 1),
+                "scan_interval": config.get("scan_interval", 60)
+            },
+            "registers": {
+                "power": config.get("power_register", 0),
+                "mode": config.get("mode_register", 1),
+                "current_temp": config.get("temp_register", 102),
+                "target_temp": config.get("target_temp_register", 2),
+                "tank_top_temp": config.get("tank_top_temp_register", 101),
+                "tank_bottom_temp": config.get("tank_bottom_temp_register", 102),
+                "condensor_temp": config.get("condensor_temp_register", 103),
+                "outdoor_temp": config.get("outdoor_temp_register", 104),
+                "exhaust_temp": config.get("exhaust_temp_register", 105),
+                "suction_temp": config.get("suction_temp_register", 106)
+            },
+            "mode_values": {
+                "eco": config.get("eco_mode_value", 1),
+                "performance": config.get("performance_mode_value", 2),
+                "electric": config.get("electric_mode_value", 4)
+            },
+            "scaling": {
+                "current_temp": {
+                    "offset": config.get("temp_offset", -15.0),
+                    "scale": config.get("temp_scale", 0.5)
+                },
+                "target_temp": {
+                    "offset": config.get("target_temp_offset", 0.0),
+                    "scale": config.get("target_temp_scale", 1.0)
+                },
+                "sensors": {
+                    "offset": config.get("sensors_temp_offset", -15.0),
+                    "scale": config.get("sensors_temp_scale", 0.5)
+                }
+            },
+            "temp_limits": {
+                "eco": {
+                    "min": config.get("eco_min_temp", 60),
+                    "max": config.get("eco_max_temp", 65)
+                },
+                "performance": {
+                    "min": config.get("performance_min_temp", 60),
+                    "max": config.get("performance_max_temp", 70)
+                },
+                "electric": {
+                    "min": config.get("electric_min_temp", 60),
+                    "max": config.get("electric_max_temp", 70)
+                }
+            },
+            "defaults": {
+                "target_temperature": config.get("target_temperature", 65),
+                "enable_additional_sensors": config.get("enable_additional_sensors", True)
+            }
+        }
+        
+        # Save to www folder for download
+        www_path = hass.config.path("www")
+        if not Path(www_path).exists():
+            Path(www_path).mkdir()
+        
+        # Create filename
+        safe_name = call.data.get("name", "profile").lower().replace(" ", "_")
+        safe_name = "".join(c for c in safe_name if c.isalnum() or c == "_")
+        filename = f"midea_profile_{safe_name}_{datetime.now():%Y%m%d_%H%M%S}.json"
+        file_path = Path(www_path) / filename
+        
+        # Write file
+        with open(file_path, 'w') as f:
+            json.dump(profile_data, f, indent=2)
+        
+        # Create persistent notification with download link
+        await hass.services.async_call(
+            "persistent_notification",
+            "create",
+            {
+                "title": "🎉 Profile Exported Successfully!",
+                "message": (
+                    f"Your water heater configuration has been exported.\n\n"
+                    f"**[📥 Download Profile](/local/{filename})**\n\n"
+                    f"**→ Right-click the link above and select 'Save Link As...' to download**\n\n"
+                    f"Share this profile with others using the same model, "
+                    f"or keep it as a backup of your configuration."
+                ),
+                "notification_id": f"midea_profile_export_{datetime.now():%Y%m%d%H%M%S}"
+            }
+        )
+        
+        _LOGGER.info("Profile exported to %s", file_path)
+    
+    async def handle_import_profile(call: ServiceCall) -> None:
+        """Handle profile import service call."""
+        try:
+            profile_json = call.data.get("profile_json")
+            profile_data = json.loads(profile_json)
+            
+            # Save as custom profile
+            profile_manager = ProfileManager(hass)
+            saved_path = profile_manager.import_profile(profile_data)
+            
+            if saved_path:
+                await hass.services.async_call(
+                    "persistent_notification",
+                    "create",
+                    {
+                        "title": "✅ Profile Imported",
+                        "message": (
+                            f"Profile '{profile_data.get('name', 'Imported')}' has been imported successfully.\n\n"
+                            f"You can now use it when adding a new water heater."
+                        ),
+                        "notification_id": f"midea_profile_import_{datetime.now():%Y%m%d%H%M%S}"
+                    }
+                )
+                _LOGGER.info("Profile imported successfully: %s", saved_path)
+            else:
+                _LOGGER.error("Failed to import profile")
+                
+        except json.JSONDecodeError as e:
+            _LOGGER.error("Invalid JSON in profile import: %s", e)
+        except Exception as e:
+            _LOGGER.error("Error importing profile: %s", e)
+    
+    # Register services
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_EXPORT_PROFILE,
+        handle_export_profile,
+        schema=EXPORT_PROFILE_SCHEMA,
+    )
+    
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_IMPORT_PROFILE,
+        handle_import_profile,
+        schema=IMPORT_PROFILE_SCHEMA,
+    )

custom_components/midea_heatpump_hws/__init__.py

@@ -221,22 +221,26 @@ async def async_step_load_profile(
                 # No profiles available, go to manual setup
                 return await self.async_step_connection()
 
-            # Create display names for profiles
+            # Create display names for profiles - SIMPLE VERSION
             profile_options = {}
             for profile_id, profile_info in profiles.items():
                 display_name = f"{profile_info['name']} ({profile_info['model']}) - {profile_info['type']}"
                 profile_options[profile_id] = display_name
 
             return self.async_show_form(
                 step_id="load_profile",
-                data_schema=STEP_PROFILE_SELECT_SCHEMA(profile_options),
+                data_schema=vol.Schema({
+                    vol.Required("profile"): vol.In(profile_options),
+                    vol.Required(CONF_HOST): str,
+                    vol.Optional(CONF_NAME, default="Hot Water System"): str,
+                }),
                 description_placeholders={
                     "title": "Select Profile",
                     "description": "Choose a profile and enter your connection details"
                 },
             )
 
-        # Load the selected profile
+        # Load the selected profile - SIMPLE VERSION
         profile_data = self.profile_manager.load_profile(user_input["profile"])
         if profile_data:
             # Apply profile to configuration

custom_components/midea_heatpump_hws/config_flow.py

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/0xAHA/Midea-Heat-Pump-HA/issues",
   "requirements": ["pymodbus>=3.11.0"],
-  "version": "0.2.2" 
+  "version": "0.2.3" 
 }

custom_components/midea_heatpump_hws/manifest.json

@@ -22,7 +22,10 @@ async def async_setup_entry(
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     config = hass.data[DOMAIN][config_entry.entry_id]["config"]
 
-    entities = [MideaModeSelect(coordinator, config)]
+    # Include host in entity name to make it unique
+    host_suffix = f" ({config['host']})"
+    
+    entities = [MideaModeSelect(coordinator, config, host_suffix)]
     async_add_entities(entities)
 
 
@@ -32,14 +35,15 @@ class MideaModeSelect(CoordinatorEntity, SelectEntity):
     def __init__(
         self,
         coordinator: MideaModbusCoordinator,
-        config: dict
+        config: dict,
+        host_suffix: str
     ):
         """Initialize the mode selector."""
         super().__init__(coordinator)
         self._config = config
 
-        # Entity attributes
-        self._attr_name = "Operation Mode"
+        # Entity attributes - include host for uniqueness
+        self._attr_name = f"Operation Mode{host_suffix}"
         self._attr_unique_id = f"midea_{config['host']}_{config[CONF_MODBUS_UNIT]}_mode_select"
         self._attr_icon = "mdi:cog"
         self._attr_options = ["eco", "performance", "electric"]
@@ -50,16 +54,16 @@ def device_info(self):
         return {
             "identifiers": {(DOMAIN, f"{self._config['host']}_{self._config[CONF_MODBUS_UNIT]}")},
             "name": f"Midea Heat Pump ({self._config['host']})",
-            "manufacturer": "0xAHA",
+            "manufacturer": "Midea",
             "model": "Heat Pump Water Heater",
         }
 
     @property
     def current_option(self):
         """Return the selected entity option."""
         if self.coordinator.data:
-            return self.coordinator.data.get("mode", "Eco")
-        return "Eco"
+            return self.coordinator.data.get("mode", "eco")
+        return "eco"
 
     @property
     def available(self) -> bool:

custom_components/midea_heatpump_hws/select.py

@@ -42,13 +42,16 @@ async def async_setup_entry(
 
     entities = []
 
+    # Include host in entity names to make them unique
+    host_suffix = f" ({config['host']})"
+    
     # Main temperature sensor
     entities.append(
         MideaTemperatureSensor(
             coordinator,
             config,
             "current_temp",
-            "Current Temperature",
+            f"Current Temperature{host_suffix}",
             config[CONF_TEMP_REGISTER],
             use_scaling=True
         )
@@ -60,7 +63,7 @@ async def async_setup_entry(
             coordinator,
             config,
             "target_temp",
-            "Target Temperature",
+            f"Target Temperature{host_suffix}",
             config[CONF_TARGET_TEMP_REGISTER],
             use_scaling=False
         )
@@ -69,12 +72,12 @@ async def async_setup_entry(
     # Additional temperature sensors if enabled
     if config.get(CONF_ENABLE_ADDITIONAL_SENSORS, True):
         sensor_configs = [
-            ("tank_top_temp", "Tank Top Temperature", config.get(CONF_TANK_TOP_TEMP_REGISTER), True),
-            ("tank_bottom_temp", "Tank Bottom Temperature", config.get(CONF_TANK_BOTTOM_TEMP_REGISTER), True),
-            ("condensor_temp", "Condensor Temperature", config.get(CONF_CONDENSOR_TEMP_REGISTER), False),
-            ("outdoor_temp", "Outdoor Temperature", config.get(CONF_OUTDOOR_TEMP_REGISTER), False),
-            ("exhaust_temp", "Exhaust Gas Temperature", config.get(CONF_EXHAUST_TEMP_REGISTER), False),
-            ("suction_temp", "Suction Temperature", config.get(CONF_SUCTION_TEMP_REGISTER), False),
+            ("tank_top_temp", f"Tank Top Temperature{host_suffix}", config.get(CONF_TANK_TOP_TEMP_REGISTER), True),
+            ("tank_bottom_temp", f"Tank Bottom Temperature{host_suffix}", config.get(CONF_TANK_BOTTOM_TEMP_REGISTER), True),
+            ("condensor_temp", f"Condensor Temperature{host_suffix}", config.get(CONF_CONDENSOR_TEMP_REGISTER), False),
+            ("outdoor_temp", f"Outdoor Temperature{host_suffix}", config.get(CONF_OUTDOOR_TEMP_REGISTER), False),
+            ("exhaust_temp", f"Exhaust Gas Temperature{host_suffix}", config.get(CONF_EXHAUST_TEMP_REGISTER), False),
+            ("suction_temp", f"Suction Temperature{host_suffix}", config.get(CONF_SUCTION_TEMP_REGISTER), False),
         ]
 
         for sensor_id, name, register, use_scaling in sensor_configs:
@@ -112,7 +115,7 @@ def __init__(
         self._register = register
         self._use_scaling = use_scaling
 
-        # Entity attributes
+        # Entity attributes - name already includes host for uniqueness
         self._attr_name = name
         self._attr_unique_id = f"midea_{config['host']}_{config[CONF_MODBUS_UNIT]}_{sensor_id}"
         self._attr_device_class = SensorDeviceClass.TEMPERATURE
@@ -125,7 +128,7 @@ def device_info(self):
         return {
             "identifiers": {(DOMAIN, f"{self._config['host']}_{self._config[CONF_MODBUS_UNIT]}")},
             "name": f"Midea Heat Pump ({self._config['host']})",
-            "manufacturer": "0xAHA",
+            "manufacturer": "Midea",
             "model": "Heat Pump Water Heater",
         }