Resync with ha-core

benjamin-dcs · benjamin-dcs · commit f5e16441662d · 2024-11-19T20:56:26.000+01:00
diff --git a/custom_components/file_plusplus/__init__.py b/custom_components/file_plusplus/__init__.py
@@ -3,88 +3,16 @@
 from copy import deepcopy
 from typing import Any
 
-from homeassistant.components.notify import migrate_notify_issue
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
-from homeassistant.const import (
-    CONF_FILE_PATH,
-    CONF_NAME,
-    CONF_PLATFORM,
-    CONF_SCAN_INTERVAL,
-    Platform,
-)
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_FILE_PATH, CONF_NAME, CONF_PLATFORM, Platform
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import (
-    config_validation as cv,
-    discovery,
-    issue_registry as ir,
-)
-from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
-from .notify import PLATFORM_SCHEMA as NOTIFY_PLATFORM_SCHEMA
-from .sensor import PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA
-
-IMPORT_SCHEMA = {
-    Platform.SENSOR: SENSOR_PLATFORM_SCHEMA,
-    Platform.NOTIFY: NOTIFY_PLATFORM_SCHEMA,
-}
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 PLATFORMS = [Platform.NOTIFY, Platform.SENSOR]
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the file integration."""
-
-    hass.data[DOMAIN] = config
-    if hass.config_entries.async_entries(DOMAIN):
-        # We skip import in case we already have config entries
-        return True
-    # The use of the legacy notify service was deprecated with HA Core 2024.6.0
-    # and will be removed with HA Core 2024.12
-    migrate_notify_issue(hass, DOMAIN, "File++", "2024.12.0")
-    # The YAML config was imported with HA Core 2024.6.0 and will be removed with
-    # HA Core 2024.12
-    ir.async_create_issue(
-        hass,
-        HOMEASSISTANT_DOMAIN,
-        f"deprecated_yaml_{DOMAIN}",
-        breaks_in_ha_version="2024.12.0",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        learn_more_url="https://www.home-assistant.io/integrations/file/",
-        severity=ir.IssueSeverity.WARNING,
-        translation_key="deprecated_yaml",
-        translation_placeholders={
-            "domain": DOMAIN,
-            "integration_title": "File++",
-        },
-    )
-
-    # Import the YAML config into separate config entries
-    platforms_config: dict[Platform, list[ConfigType]] = {
-        domain: config[domain] for domain in PLATFORMS if domain in config
-    }
-    for domain, items in platforms_config.items():
-        for item in items:
-            if item[CONF_PLATFORM] == DOMAIN:
-                file_config_item = IMPORT_SCHEMA[domain](item)
-                file_config_item[CONF_PLATFORM] = domain
-                if CONF_SCAN_INTERVAL in file_config_item:
-                    del file_config_item[CONF_SCAN_INTERVAL]
-                hass.async_create_task(
-                    hass.config_entries.flow.async_init(
-                        DOMAIN,
-                        context={"source": SOURCE_IMPORT},
-                        data=file_config_item,
-                    )
-                )
-
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a file component entry."""
     config = {**entry.data, **entry.options}
@@ -102,20 +30,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         entry, [Platform(entry.data[CONF_PLATFORM])]
     )
     entry.async_on_unload(entry.add_update_listener(update_listener))
-    if entry.data[CONF_PLATFORM] == Platform.NOTIFY and CONF_NAME in entry.data:
-        # New notify entities are being setup through the config entry,
-        # but during the deprecation period we want to keep the legacy notify platform,
-        # so we forward the setup config through discovery.
-        # Only the entities from yaml will still be available as legacy service.
-        hass.async_create_task(
-            discovery.async_load_platform(
-                hass,
-                Platform.NOTIFY,
-                DOMAIN,
-                config,
-                hass.data[DOMAIN],
-            )
-        )
 
     return True
 
@@ -150,4 +64,4 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         hass.config_entries.async_update_entry(
             config_entry, version=2, data=data, options=options
         )
-    return True
+    return True
diff --git a/custom_components/file_plusplus/config_flow.py b/custom_components/file_plusplus/config_flow.py
@@ -1,8 +1,8 @@
 """Config flow for file++ integration."""
 
+from __future__ import annotations
+
 from copy import deepcopy
-import logging
-import os
 from typing import Any
 
 import voluptuous as vol
@@ -12,11 +12,9 @@
     ConfigFlow,
     ConfigFlowResult,
     OptionsFlow,
-    OptionsFlowWithConfigEntry,
 )
 from homeassistant.const import (
     CONF_FILE_PATH,
-    CONF_FILENAME,
     CONF_NAME,
     CONF_PLATFORM,
     CONF_UNIT_OF_MEASUREMENT,
@@ -36,8 +34,6 @@
 
 from .const import CONF_TIMESTAMP, DEFAULT_NAME, DOMAIN
 
-_LOGGER = logging.getLogger(__name__)
-
 BOOLEAN_SELECTOR = BooleanSelector(BooleanSelectorConfig())
 TEMPLATE_SELECTOR = TemplateSelector(TemplateSelectorConfig())
 TEXT_SELECTOR = TextSelector(TextSelectorConfig(type=TextSelectorType.TEXT))
@@ -77,9 +73,11 @@ class FileConfigFlowHandler(ConfigFlow, domain=DOMAIN):
 
     @staticmethod
     @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> FileOptionsFlowHandler:
         """Get the options flow for this handler."""
-        return FileOptionsFlowHandler(config_entry)
+        return FileOptionsFlowHandler()
 
     async def validate_file_path(self, file_path: str) -> bool:
         """Ensure the file path is valid."""
@@ -99,15 +97,15 @@ async def async_step_user(
     async def _async_handle_step(
         self, platform: str, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle file config flow step."""
+        """Handle file++ config flow step."""
         errors: dict[str, str] = {}
         if user_input:
             user_input[CONF_PLATFORM] = platform
             self._async_abort_entries_match(user_input)
             if not await self.validate_file_path(user_input[CONF_FILE_PATH]):
                 errors[CONF_FILE_PATH] = "not_allowed"
             else:
-                title = f"{platform.capitalize()} [{user_input[CONF_FILE_PATH]}]"
+                title = f"{DEFAULT_NAME} [{user_input[CONF_FILE_PATH]}]"
                 data = deepcopy(user_input)
                 options = {}
                 for key, value in user_input.items():
@@ -123,38 +121,17 @@ async def _async_handle_step(
     async def async_step_notify(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle file notifier config flow."""
+        """Handle file++ notifier config flow."""
         return await self._async_handle_step(Platform.NOTIFY.value, user_input)
 
     async def async_step_sensor(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle file sensor config flow."""
+        """Handle file++ sensor config flow."""
         return await self._async_handle_step(Platform.SENSOR.value, user_input)
 
-    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
-        """Import `file`` config from configuration.yaml."""
-        self._async_abort_entries_match(import_data)
-        platform = import_data[CONF_PLATFORM]
-        name: str = import_data.get(CONF_NAME, DEFAULT_NAME)
-        file_name: str
-        if platform == Platform.NOTIFY:
-            file_name = import_data.pop(CONF_FILENAME)
-            file_path: str = os.path.join(self.hass.config.config_dir, file_name)
-            import_data[CONF_FILE_PATH] = file_path
-        else:
-            file_path = import_data[CONF_FILE_PATH]
-        title = f"{name} [{file_path}]"
-        data = deepcopy(import_data)
-        options = {}
-        for key, value in import_data.items():
-            if key not in (CONF_FILE_PATH, CONF_PLATFORM, CONF_NAME):
-                data.pop(key)
-                options[key] = value
-        return self.async_create_entry(title=title, data=data, options=options)
-
-
-class FileOptionsFlowHandler(OptionsFlowWithConfigEntry):
+
+class FileOptionsFlowHandler(OptionsFlow):
     """Handle File++ options."""
 
     async def async_step_init(
@@ -170,4 +147,4 @@ async def async_step_init(
             data_schema=self.add_suggested_values_to_schema(
                 FILE_OPTIONS_SCHEMAS[platform], self.config_entry.options or {}
             ),
-        )
+        )
diff --git a/custom_components/file_plusplus/const.py b/custom_components/file_plusplus/const.py
@@ -4,5 +4,5 @@
 
 CONF_TIMESTAMP = "timestamp"
 
-DEFAULT_NAME = "file_plusplus"
-FILE_ICON = "mdi:file"
+DEFAULT_NAME = "file_plusplus" # File++
+FILE_ICON = "mdi:file"
diff --git a/custom_components/file_plusplus/notify.py b/custom_components/file_plusplus/notify.py
@@ -1,98 +1,24 @@
-"""Support for file++ notification."""
+"""Support for File++ notification."""
 
 from __future__ import annotations
 
-from functools import partial
-import logging
 import os
 from typing import Any, TextIO
 
-import voluptuous as vol
-
 from homeassistant.components.notify import (
-    ATTR_TITLE,
     ATTR_TITLE_DEFAULT,
-    PLATFORM_SCHEMA as NOTIFY_PLATFORM_SCHEMA,
-    BaseNotificationService,
     NotifyEntity,
     NotifyEntityFeature,
-    migrate_notify_issue,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_FILE_PATH, CONF_FILENAME, CONF_NAME
+from homeassistant.const import CONF_FILE_PATH, CONF_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 import homeassistant.util.dt as dt_util
 
 from .const import CONF_TIMESTAMP, DEFAULT_NAME, DOMAIN, FILE_ICON
 
-_LOGGER = logging.getLogger(__name__)
-
-# The legacy platform schema uses a filename, after import
-# The full file path is stored in the config entry
-PLATFORM_SCHEMA = NOTIFY_PLATFORM_SCHEMA.extend(
-    {
-        vol.Required(CONF_FILENAME): cv.string,
-        vol.Optional(CONF_TIMESTAMP, default=False): cv.boolean,
-    }
-)
-
-
-async def async_get_service(
-    hass: HomeAssistant,
-    config: ConfigType,
-    discovery_info: DiscoveryInfoType | None = None,
-) -> FileNotificationService | None:
-    """Get the file notification service."""
-    if discovery_info is None:
-        # We only set up through discovery
-        return None
-    file_path: str = discovery_info[CONF_FILE_PATH]
-    timestamp: bool = discovery_info[CONF_TIMESTAMP]
-
-    return FileNotificationService(file_path, timestamp)
-
-
-class FileNotificationService(BaseNotificationService):
-    """Implement the notification service for the File++ service."""
-
-    def __init__(self, file_path: str, add_timestamp: bool) -> None:
-        """Initialize the service."""
-        self._file_path = file_path
-        self.add_timestamp = add_timestamp
-
-    async def async_send_message(self, message: str = "", **kwargs: Any) -> None:
-        """Send a message to a file."""
-        # The use of the legacy notify service was deprecated with HA Core 2024.6.0
-        # and will be removed with HA Core 2024.12
-        migrate_notify_issue(
-            self.hass, DOMAIN, "File", "2024.12.0", service_name=self._service_name
-        )
-        await self.hass.async_add_executor_job(
-            partial(self.send_message, message, **kwargs)
-        )
-
-    def send_message(self, message: str = "", **kwargs: Any) -> None:
-        """Send a message to a file."""
-        file: TextIO
-        filepath = self._file_path
-        try:
-            with open(filepath, "a", encoding="utf8") as file:
-                if self.add_timestamp:
-                    text = f"{dt_util.utcnow().isoformat()} {message}\n"
-                else:
-                    text = f"{message}\n"
-                file.write(text)
-        except OSError as exc:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="write_access_failed",
-                translation_placeholders={"filename": filepath, "exc": f"{exc!r}"},
-            ) from exc
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -105,7 +31,7 @@ async def async_setup_entry(
 
 
 class FileNotifyEntity(NotifyEntity):
-    """Implement the notification entity platform for the File service."""
+    """Implement the notification entity platform for the File++ service."""
 
     _attr_icon = FILE_ICON
     _attr_supported_features = NotifyEntityFeature.TITLE
@@ -115,16 +41,16 @@ def __init__(self, unique_id: str, config: dict[str, Any]) -> None:
         self._file_path: str = config[CONF_FILE_PATH]
         self._add_timestamp: bool = config.get(CONF_TIMESTAMP, False)
         # Only import a name from an imported entity
-        self._attr_name = config.get(CONF_NAME, DEFAULT_NAME) + "_" + self._file_path.split("/")[-1].replace(".", "_")
+        self._attr_name = config.get(CONF_NAME, DEFAULT_NAME)
         self._attr_unique_id = unique_id
 
     def send_message(self, message: str, title: str | None = None) -> None:
         """Send a message to a file."""
         file: TextIO
         filepath = self._file_path
-        message = message.strip()
         try:
-            with open(filepath, "w", encoding="utf8") as file:
+            with open(filepath, "a", encoding="utf8") as file:
+                # File++ - Delete header
                 if self._add_timestamp:
                     text = f"{dt_util.utcnow().isoformat()} {message}\n"
                 else:
@@ -135,4 +61,4 @@ def send_message(self, message: str, title: str | None = None) -> None:
                 translation_domain=DOMAIN,
                 translation_key="write_access_failed",
                 translation_placeholders={"filename": filepath, "exc": f"{exc!r}"},
-            ) from exc
+            ) from exc
diff --git a/custom_components/file_plusplus/sensor.py b/custom_components/file_plusplus/sensor.py
