372 lines
14 KiB
Python
372 lines
14 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
from datetime import timedelta
|
|
|
|
from homeassistant.config_entries import ConfigEntry
|
|
from homeassistant.const import Platform
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers import entity_registry as er
|
|
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
|
|
from homeassistant.util import slugify
|
|
|
|
from .api import SeaTemperatureAPI, SeaTemperatureError
|
|
from .const import (
|
|
CONF_AREA,
|
|
CONF_CONTINENT,
|
|
CONF_COUNTRY,
|
|
CONF_PATH,
|
|
CONF_PLACE,
|
|
CONF_PLACE_ID,
|
|
CONF_SCAN_INTERVAL_HOURS,
|
|
DEFAULT_SCAN_INTERVAL_HOURS,
|
|
DOMAIN,
|
|
MAX_SCAN_INTERVAL_HOURS,
|
|
MIN_SCAN_INTERVAL_HOURS,
|
|
)
|
|
|
|
PLATFORMS = [Platform.SENSOR]
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
CARD_FILENAME = "sea-temperatures-card.js"
|
|
CARD_URL_PREFIX = "/seatemperatures_frontend/"
|
|
|
|
|
|
async def _async_reconcile_card_resource(resources, new_url: str) -> None:
|
|
"""Leave exactly one Lovelace resource pointing at the bundled card.
|
|
|
|
The resource store is loaded lazily: until something awaits it, async_items()
|
|
returns an empty list. Registering off that empty list appended a second
|
|
resource on every restart, and the browser then loaded the bundle twice.
|
|
"""
|
|
# Default to False, not True: assuming a collection we cannot recognise is
|
|
# already loaded would let us register against an empty item list and save
|
|
# a store that has lost every other card's resource. Missing async_load
|
|
# raises instead, and the caller skips registration.
|
|
if not getattr(resources, "loaded", False):
|
|
await resources.async_load()
|
|
resources.loaded = True
|
|
|
|
own = [
|
|
item
|
|
for item in resources.async_items()
|
|
if item.get("url", "").startswith(CARD_URL_PREFIX)
|
|
]
|
|
|
|
if not own:
|
|
_LOGGER.info("Registering lovelace resource: %s", new_url)
|
|
await resources.async_create_item({"res_type": "module", "url": new_url})
|
|
return
|
|
|
|
for duplicate in own[1:]:
|
|
_LOGGER.info("Removing duplicate lovelace resource %s", duplicate.get("url"))
|
|
await resources.async_delete_item(duplicate.get("id"))
|
|
|
|
if own[0].get("url") != new_url:
|
|
_LOGGER.debug("Updating lovelace resource URL to %s", new_url)
|
|
await resources.async_update_item(own[0].get("id"), {"url": new_url})
|
|
|
|
|
|
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
|
|
"""Set up the Sea Temperatures component."""
|
|
from homeassistant.loader import async_get_integration
|
|
|
|
integration = await async_get_integration(hass, DOMAIN)
|
|
version = integration.version or "1.0.0"
|
|
|
|
# Register static path for the card
|
|
from homeassistant.components.http import StaticPathConfig
|
|
|
|
await hass.http.async_register_static_paths(
|
|
[
|
|
StaticPathConfig(
|
|
url_path=f"{CARD_URL_PREFIX}{CARD_FILENAME}",
|
|
path=hass.config.path(f"custom_components/{DOMAIN}/{CARD_FILENAME}"),
|
|
cache_headers=True,
|
|
)
|
|
]
|
|
)
|
|
new_url = f"{CARD_URL_PREFIX}{CARD_FILENAME}?v={version}"
|
|
|
|
async def _async_register_lovelace_resource(event=None):
|
|
_LOGGER.debug("Attempting to register lovelace resource")
|
|
if "lovelace" not in hass.data:
|
|
_LOGGER.warning("Lovelace not found in hass.data")
|
|
return
|
|
|
|
lovelace_data = hass.data["lovelace"]
|
|
mode = getattr(lovelace_data, "resource_mode", "storage")
|
|
resources = getattr(lovelace_data, "resources", None)
|
|
|
|
if not resources:
|
|
_LOGGER.warning("Lovelace data does not have resources")
|
|
return
|
|
|
|
if mode != "storage":
|
|
_LOGGER.warning(
|
|
"Lovelace is not in storage mode (mode is '%s'), cannot auto-register",
|
|
mode,
|
|
)
|
|
return
|
|
|
|
try:
|
|
await _async_reconcile_card_resource(resources, new_url)
|
|
except Exception as e: # noqa: BLE001 - resource registration must never break setup
|
|
_LOGGER.warning("Failed to register lovelace resource: %s", e)
|
|
|
|
from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
|
|
from homeassistant.core import CoreState
|
|
|
|
if hass.state == CoreState.running:
|
|
hass.async_create_task(_async_register_lovelace_resource())
|
|
else:
|
|
hass.bus.async_listen_once(
|
|
EVENT_HOMEASSISTANT_STARTED, _async_register_lovelace_resource
|
|
)
|
|
|
|
return True
|
|
|
|
|
|
def async_scan_interval(entry: ConfigEntry) -> timedelta:
|
|
"""Return the poll interval for an entry, honouring the options flow."""
|
|
hours = entry.options.get(CONF_SCAN_INTERVAL_HOURS, DEFAULT_SCAN_INTERVAL_HOURS)
|
|
try:
|
|
hours = int(hours)
|
|
except (TypeError, ValueError):
|
|
hours = DEFAULT_SCAN_INTERVAL_HOURS
|
|
if not MIN_SCAN_INTERVAL_HOURS <= hours <= MAX_SCAN_INTERVAL_HOURS:
|
|
# The options flow bounds the form, but a hand-edited or older stored
|
|
# value reaches this reader directly - clamp both ends, not just the
|
|
# one that would hammer the site.
|
|
hours = DEFAULT_SCAN_INTERVAL_HOURS
|
|
return timedelta(hours=hours)
|
|
|
|
|
|
def entry_location_key(entry: ConfigEntry) -> str:
|
|
"""Return the key an entry's entity unique_ids are built from.
|
|
|
|
The migration and the sensor both call this, so the id they arrive at is
|
|
the same one by construction rather than by two matching expressions.
|
|
"""
|
|
return str(
|
|
entry.data.get(CONF_PLACE_ID)
|
|
or entry.data.get(CONF_PATH)
|
|
or entry.data.get(CONF_PLACE)
|
|
or entry.entry_id
|
|
)
|
|
|
|
|
|
def slug_location_key(location_key: object) -> str:
|
|
"""Slugify a location key without folding "/" and "-" together.
|
|
|
|
``slugify`` maps both to "_", so ``/europe/greece/nea-plagia/`` and
|
|
``/europe/greece/nea/plagia/`` - two real, distinct locations - used to
|
|
produce the very same id. Each path segment is therefore slugified with "-"
|
|
as its separator and the segments are joined with "_": a "-" can then only
|
|
come from inside a segment and a "_" only from a segment boundary, which
|
|
makes the encoding injective instead of merely unlikely to clash. A legacy
|
|
numeric place_id has no separators at all and slugifies to itself.
|
|
"""
|
|
segments = [segment for segment in str(location_key).split("/") if segment]
|
|
return "_".join(slugify(segment, separator="-") for segment in segments)
|
|
|
|
|
|
def build_unique_id(location_key: object, sensor_key: str) -> str:
|
|
"""Return the slugified unique_id used from entry version 4 on."""
|
|
return f"{DOMAIN}_{slug_location_key(location_key)}_{sensor_key}"
|
|
|
|
|
|
async def _async_migrate_unique_ids(hass: HomeAssistant, entry: ConfigEntry) -> None:
|
|
"""Bring the registry unique_ids of an entry's entities up to date.
|
|
|
|
Path-based entries produced ids like
|
|
``seatemperatures_/europe/germany/island-of-sylt/_today``, and entry
|
|
version 3 slugified those with "_" for every separator - which folded two
|
|
distinct paths onto one id. The target id is derived from the *entry*, not
|
|
parsed back out of the old one, so it is the same id the sensor will claim.
|
|
Rewriting the registry entry rather than just the sensor keeps the
|
|
entity_id - and therefore the recorded history - exactly where it was. A
|
|
legacy numeric key slugifies to itself, so those entries are left
|
|
untouched.
|
|
"""
|
|
registry = er.async_get(hass)
|
|
location_key = entry_location_key(entry)
|
|
|
|
for registry_entry in er.async_entries_for_config_entry(registry, entry.entry_id):
|
|
old_unique_id = registry_entry.unique_id
|
|
if not old_unique_id.startswith(f"{DOMAIN}_"):
|
|
continue
|
|
|
|
middle, _, sensor_key = old_unique_id[len(DOMAIN) + 1 :].rpartition("_")
|
|
if not middle or not sensor_key:
|
|
continue
|
|
|
|
new_unique_id = build_unique_id(location_key, sensor_key)
|
|
if new_unique_id == old_unique_id:
|
|
continue
|
|
|
|
holder = registry.async_get_entity_id(
|
|
registry_entry.domain, registry_entry.platform, new_unique_id
|
|
)
|
|
if holder is not None and holder != registry_entry.entity_id:
|
|
# The sensor claims the new id unconditionally at setup, so leaving
|
|
# the old id in place would cost the user this entity: the platform
|
|
# would reject the duplicate and the stale row would be orphaned.
|
|
# Ids are collision-free by construction now, so a holder here is a
|
|
# leftover row - drop it and let the live entity keep its history.
|
|
conflicting = registry.async_get(holder)
|
|
owner = getattr(conflicting, "config_entry_id", None)
|
|
if owner not in (None, entry.entry_id):
|
|
_LOGGER.error(
|
|
"Cannot migrate unique_id %s to %s: %s of another config entry "
|
|
"holds it. Both entities keep the id they have.",
|
|
old_unique_id,
|
|
new_unique_id,
|
|
holder,
|
|
)
|
|
continue
|
|
|
|
_LOGGER.warning(
|
|
"Removing the stale registry entry %s so %s can take the id %s",
|
|
holder,
|
|
registry_entry.entity_id,
|
|
new_unique_id,
|
|
)
|
|
registry.async_remove(holder)
|
|
|
|
_LOGGER.debug("Migrating unique_id %s to %s", old_unique_id, new_unique_id)
|
|
registry.async_update_entity(
|
|
registry_entry.entity_id, new_unique_id=new_unique_id
|
|
)
|
|
|
|
|
|
async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
|
|
"""Migrate legacy config entries from place IDs to path-based locations."""
|
|
if entry.version > 4:
|
|
_LOGGER.error("Unsupported SeaTemperatures config entry version: %s", entry.version)
|
|
return False
|
|
|
|
if entry.version < 2:
|
|
_LOGGER.debug("Migrating SeaTemperatures entry %s from version %s", entry.entry_id, entry.version)
|
|
|
|
data = dict(entry.data)
|
|
location_path = data.get(CONF_PATH)
|
|
if not location_path:
|
|
place_id = data.get(CONF_PLACE_ID)
|
|
if not place_id:
|
|
_LOGGER.error(
|
|
"SeaTemperatures entry %s has no place_id to migrate. Remove and re-add the integration.",
|
|
entry.entry_id,
|
|
)
|
|
return False
|
|
|
|
location = await SeaTemperatureAPI(hass).get_location_by_place_id(place_id)
|
|
if location is None:
|
|
_LOGGER.error(
|
|
"SeaTemperatures place_id %s could not be mapped to a current location path. Remove and re-add the integration.",
|
|
place_id,
|
|
)
|
|
return False
|
|
|
|
data[CONF_PATH] = location[CONF_PATH]
|
|
data[CONF_PLACE] = location.get("name", data.get(CONF_PLACE, "Unknown"))
|
|
data[CONF_COUNTRY] = location.get(CONF_COUNTRY, data.get(CONF_COUNTRY, ""))
|
|
data[CONF_AREA] = location.get(CONF_AREA, data.get(CONF_AREA, ""))
|
|
data.setdefault(CONF_CONTINENT, data.get(CONF_CONTINENT, ""))
|
|
|
|
hass.config_entries.async_update_entry(
|
|
entry,
|
|
data=data,
|
|
unique_id=data[CONF_PATH],
|
|
version=2,
|
|
)
|
|
|
|
if entry.version < 4:
|
|
# Version 3 slugified these ids already, but with a scheme that could
|
|
# fold two paths onto one id; re-deriving them from the entry fixes a
|
|
# v3 install as well as a v2 one.
|
|
await _async_migrate_unique_ids(hass, entry)
|
|
hass.config_entries.async_update_entry(entry, version=4)
|
|
|
|
return True
|
|
|
|
|
|
async def _async_fetch(
|
|
api: SeaTemperatureAPI, location_path: str | None, place_name: str
|
|
) -> dict:
|
|
"""Fetch one refresh, turning an API failure into a single logged one.
|
|
|
|
The coordinator logs an UpdateFailed once and stays quiet while the failure
|
|
persists, so the API layer deliberately reports nothing of its own.
|
|
"""
|
|
if not location_path:
|
|
raise UpdateFailed(
|
|
"No location path configured. Remove and re-add the integration."
|
|
)
|
|
|
|
try:
|
|
data = await api.get_temperatures(location_path)
|
|
except SeaTemperatureError as err:
|
|
raise UpdateFailed(str(err)) from err
|
|
|
|
if not data:
|
|
raise UpdateFailed(f"Failed to fetch data for place {place_name}")
|
|
|
|
return data
|
|
|
|
|
|
async def _async_options_updated(hass: HomeAssistant, entry: ConfigEntry) -> None:
|
|
"""Reload the entry after the options flow saved a new poll interval.
|
|
|
|
The coordinator is built with ``update_interval`` once, at setup, so a saved
|
|
interval is inert until the entry is set up again. Core offers
|
|
``OptionsFlowWithReload`` for this, but only from 2025.8 on; an explicit
|
|
listener works on every version the integration supports and keeps the
|
|
minimum where hacs.json puts it.
|
|
"""
|
|
await hass.config_entries.async_reload(entry.entry_id)
|
|
|
|
|
|
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
|
|
"""Set up Sea Temperature from a config entry."""
|
|
hass.data.setdefault(DOMAIN, {})
|
|
|
|
# Registered before the first refresh so an options save during a slow or
|
|
# failing setup is not silently dropped; async_on_unload drops the
|
|
# subscription with the entry rather than stacking one per reload.
|
|
entry.async_on_unload(entry.add_update_listener(_async_options_updated))
|
|
|
|
place_name = entry.data.get(CONF_PLACE, "Unknown")
|
|
location_path = entry.data.get(CONF_PATH)
|
|
location_key = entry_location_key(entry)
|
|
|
|
api = SeaTemperatureAPI(hass)
|
|
|
|
async def async_update_data():
|
|
"""Fetch data from API."""
|
|
return await _async_fetch(api, location_path, place_name)
|
|
|
|
coordinator = DataUpdateCoordinator(
|
|
hass,
|
|
_LOGGER,
|
|
name=f"seatemperatures_{location_key}",
|
|
update_method=async_update_data,
|
|
update_interval=async_scan_interval(entry),
|
|
)
|
|
|
|
await coordinator.async_config_entry_first_refresh()
|
|
|
|
hass.data[DOMAIN][entry.entry_id] = coordinator
|
|
|
|
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
|
|
|
|
return True
|
|
|
|
|
|
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
|
|
"""Unload a config entry."""
|
|
if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
|
|
hass.data[DOMAIN].pop(entry.entry_id)
|
|
|
|
return unload_ok
|