Enable disabled Ollama config entries after entry migration (home-assistant#150105)

Author: joostlek

homeassistant/components/ollama/__init__.py

@@ -92,11 +92,15 @@ async def async_update_options(hass: HomeAssistant, entry: OllamaConfigEntry) ->
 async def async_migrate_integration(hass: HomeAssistant) -> None:
     """Migrate integration entry structure."""
 
-    entries = hass.config_entries.async_entries(DOMAIN)
+    # Make sure we get enabled config entries first
+    entries = sorted(
+        hass.config_entries.async_entries(DOMAIN),
+        key=lambda e: e.disabled_by is not None,
+    )
     if not any(entry.version == 1 for entry in entries):
         return
 
-    api_keys_entries: dict[str, ConfigEntry] = {}
+    url_entries: dict[str, tuple[ConfigEntry, bool]] = {}
     entity_registry = er.async_get(hass)
     device_registry = dr.async_get(hass)
 
@@ -112,33 +116,64 @@ async def async_migrate_integration(hass: HomeAssistant) -> None:
             title=entry.title,
             unique_id=None,
         )
-        if entry.data[CONF_URL] not in api_keys_entries:
+        if entry.data[CONF_URL] not in url_entries:
             use_existing = True
-            api_keys_entries[entry.data[CONF_URL]] = entry
+            all_disabled = all(
+                e.disabled_by is not None
+                for e in entries
+                if e.data[CONF_URL] == entry.data[CONF_URL]
+            )
+            url_entries[entry.data[CONF_URL]] = (entry, all_disabled)
 
-        parent_entry = api_keys_entries[entry.data[CONF_URL]]
+        parent_entry, all_disabled = url_entries[entry.data[CONF_URL]]
 
         hass.config_entries.async_add_subentry(parent_entry, subentry)
 
-        conversation_entity = entity_registry.async_get_entity_id(
+        conversation_entity_id = entity_registry.async_get_entity_id(
             "conversation",
             DOMAIN,
             entry.entry_id,
         )
-        if conversation_entity is not None:
+        device = device_registry.async_get_device(
+            identifiers={(DOMAIN, entry.entry_id)}
+        )
+
+        if conversation_entity_id is not None:
+            conversation_entity_entry = entity_registry.entities[conversation_entity_id]
+            entity_disabled_by = conversation_entity_entry.disabled_by
+            if (
+                entity_disabled_by is er.RegistryEntryDisabler.CONFIG_ENTRY
+                and not all_disabled
+            ):
+                # Device and entity registries don't update the disabled_by flag
+                # when moving a device or entity from one config entry to another,
+                # so we need to do it manually.
+                entity_disabled_by = (
+                    er.RegistryEntryDisabler.DEVICE
+                    if device
+                    else er.RegistryEntryDisabler.USER
+                )
             entity_registry.async_update_entity(
-                conversation_entity,
+                conversation_entity_id,
                 config_entry_id=parent_entry.entry_id,
                 config_subentry_id=subentry.subentry_id,
+                disabled_by=entity_disabled_by,
                 new_unique_id=subentry.subentry_id,
             )
 
-        device = device_registry.async_get_device(
-            identifiers={(DOMAIN, entry.entry_id)}
-        )
         if device is not None:
+            # Device and entity registries don't update the disabled_by flag when
+            # moving a device or entity from one config entry to another, so we
+            # need to do it manually.
+            device_disabled_by = device.disabled_by
+            if (
+                device.disabled_by is dr.DeviceEntryDisabler.CONFIG_ENTRY
+                and not all_disabled
+            ):
+                device_disabled_by = dr.DeviceEntryDisabler.USER
             device_registry.async_update_device(
                 device.id,
+                disabled_by=device_disabled_by,
                 new_identifiers={(DOMAIN, subentry.subentry_id)},
                 add_config_subentry_id=subentry.subentry_id,
                 add_config_entry_id=parent_entry.entry_id,
@@ -158,14 +193,15 @@ async def async_migrate_integration(hass: HomeAssistant) -> None:
         if not use_existing:
             await hass.config_entries.async_remove(entry.entry_id)
         else:
+            _add_ai_task_subentry(hass, entry)
             hass.config_entries.async_update_entry(
                 entry,
                 title=DEFAULT_NAME,
                 # Update parent entry to only keep URL, remove model
                 data={CONF_URL: entry.data[CONF_URL]},
                 options={},
                 version=3,
-                minor_version=1,
+                minor_version=3,
             )
 
 
@@ -211,32 +247,69 @@ async def async_migrate_entry(hass: HomeAssistant, entry: OllamaConfigEntry) ->
         )
 
     if entry.version == 3 and entry.minor_version == 1:
-        # Add AI Task subentry with default options. We can only create a new
-        # subentry if we can find an existing model in the entry. The model
-        # was removed in the previous migration step, so we need to
-        # check the subentries for an existing model.
-        existing_model = next(
-            iter(
-                model
-                for subentry in entry.subentries.values()
-                if (model := subentry.data.get(CONF_MODEL)) is not None
-            ),
-            None,
-        )
-        if existing_model:
-            hass.config_entries.async_add_subentry(
-                entry,
-                ConfigSubentry(
-                    data=MappingProxyType({CONF_MODEL: existing_model}),
-                    subentry_type="ai_task_data",
-                    title=DEFAULT_AI_TASK_NAME,
-                    unique_id=None,
-                ),
-            )
+        _add_ai_task_subentry(hass, entry)
         hass.config_entries.async_update_entry(entry, minor_version=2)
 
+    if entry.version == 3 and entry.minor_version == 2:
+        # Fix migration where the disabled_by flag was not set correctly.
+        # We can currently only correct this for enabled config entries,
+        # because migration does not run for disabled config entries. This
+        # is asserted in tests, and if that behavior is changed, we should
+        # correct also disabled config entries.
+        device_registry = dr.async_get(hass)
+        entity_registry = er.async_get(hass)
+        devices = dr.async_entries_for_config_entry(device_registry, entry.entry_id)
+        entity_entries = er.async_entries_for_config_entry(
+            entity_registry, entry.entry_id
+        )
+        if entry.disabled_by is None:
+            # If the config entry is not disabled, we need to set the disabled_by
+            # flag on devices to USER, and on entities to DEVICE, if they are set
+            # to CONFIG_ENTRY.
+            for device in devices:
+                if device.disabled_by is not dr.DeviceEntryDisabler.CONFIG_ENTRY:
+                    continue
+                device_registry.async_update_device(
+                    device.id,
+                    disabled_by=dr.DeviceEntryDisabler.USER,
+                )
+            for entity in entity_entries:
+                if entity.disabled_by is not er.RegistryEntryDisabler.CONFIG_ENTRY:
+                    continue
+                entity_registry.async_update_entity(
+                    entity.entity_id,
+                    disabled_by=er.RegistryEntryDisabler.DEVICE,
+                )
+        hass.config_entries.async_update_entry(entry, minor_version=3)
+
     _LOGGER.debug(
         "Migration to version %s:%s successful", entry.version, entry.minor_version
     )
 
     return True
+
+
+def _add_ai_task_subentry(hass: HomeAssistant, entry: OllamaConfigEntry) -> None:
+    """Add AI Task subentry to the config entry."""
+    # Add AI Task subentry with default options. We can only create a new
+    # subentry if we can find an existing model in the entry. The model
+    # was removed in the previous migration step, so we need to
+    # check the subentries for an existing model.
+    existing_model = next(
+        iter(
+            model
+            for subentry in entry.subentries.values()
+            if (model := subentry.data.get(CONF_MODEL)) is not None
+        ),
+        None,
+    )
+    if existing_model:
+        hass.config_entries.async_add_subentry(
+            entry,
+            ConfigSubentry(
+                data=MappingProxyType({CONF_MODEL: existing_model}),
+                subentry_type="ai_task_data",
+                title=DEFAULT_AI_TASK_NAME,
+                unique_id=None,
+            ),
+        )

homeassistant/components/ollama/config_flow.py

@@ -76,7 +76,7 @@ class OllamaConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ollama."""
 
     VERSION = 3
-    MINOR_VERSION = 2
+    MINOR_VERSION = 3
 
     def __init__(self) -> None:
         """Initialize config flow."""