homeassistant 2025.8.3__py3-none-any.whl → 2025.9.0__py3-none-any.whl

homeassistant/components/plex/translations/ga.json

@@ -1,4 +1,44 @@
 {
+    "config": {
+        "abort": {
+            "all_configured": "Gach freastala\u00ed nasctha cumraithe cheana f\u00e9in",
+            "already_configured": "T\u00e1 an freastala\u00ed Plex seo cumraithe cheana f\u00e9in",
+            "already_in_progress": "T\u00e1 sreabhadh cumra\u00edochta ar si\u00fal cheana f\u00e9in",
+            "reauth_successful": "D'\u00e9irigh leis an athfh\u00edordheimhni\u00fa",
+            "token_request_timeout": "Chuaigh an t-am amach agus an comhartha \u00e1 fh\u00e1il",
+            "unknown": "Earr\u00e1id gan choinne"
+        },
+        "error": {
+            "faulty_credentials": "Theip ar \u00fadar\u00fa, f\u00edoraigh an comhartha",
+            "host_or_token": "N\u00ed m\u00f3r ceann amh\u00e1in ar a laghad den chine\u00e1l \u00f3stach n\u00f3 comhartha a shol\u00e1thar",
+            "no_servers": "N\u00edl aon fhreastalaithe nasctha le cuntas Plex",
+            "not_found": "N\u00edor aims\u00edodh an freastala\u00ed Plex",
+            "ssl_error": "Fadhb le deimhni\u00fa SSL"
+        },
+        "flow_title": "{name} ({host})",
+        "step": {
+            "manual_setup": {
+                "data": {
+                    "host": "\u00d3stach",
+                    "port": "Port",
+                    "ssl": "\u00das\u00e1ideann teastas SSL",
+                    "token": "Comhartha (roghnach)",
+                    "verify_ssl": "F\u00edoraigh teastas SSL"
+                },
+                "title": "Cumra\u00edocht Plex de l\u00e1imh"
+            },
+            "select_server": {
+                "data": {
+                    "server": "Freastala\u00ed"
+                },
+                "description": "T\u00e1 roinnt freastalaithe ar f\u00e1il, roghnaigh ceann amh\u00e1in:",
+                "title": "Roghnaigh freastala\u00ed Plex"
+            },
+            "user": {
+                "description": "Lean ar aghaidh go [plex.tv](https://plex.tv) chun freastala\u00ed Plex a nascadh."
+            }
+        }
+    },
     "services": {
         "refresh_library": {
             "description": "Athnuachana\u00edonn s\u00e9 leabharlann Plex chun scanadh a dh\u00e9anamh le haghaidh me\u00e1in nua agus nuashonraithe.",

homeassistant/components/plex/translations/it.json

@@ -9,6 +9,7 @@
             "unknown": "Errore imprevisto"
         },
         "error": {
+            "faulty_credentials": "Non \u00e8 stato possibile autorizzare, controlla il token.",
             "no_servers": "Nessun server collegato all'account Plex",
             "not_found": "Server Plex non trovato",
             "ssl_error": "Problema con il certificato SSL"
@@ -48,7 +49,8 @@
                     "ignore_new_shared_users": "Ignora nuovi utenti gestiti/condivisi",
                     "monitored_users": "Utenti monitorati",
                     "use_episode_art": "Usa la grafica dell'episodio"
-                }
+                },
+                "description": "Opzioni per i lettori multimediali Plex"
             }
         }
     },

homeassistant/components/plugwise/translations/cs.json

@@ -291,7 +291,7 @@
                 "name": "Re\u017eim Komfort TUV"
             },
             "lock": {
-                "name": "Zamknout"
+                "name": "Z\u00e1mek"
             },
             "relay": {
                 "name": "Rel\u00e9"

homeassistant/components/plugwise/translations/ga.json

@@ -28,6 +28,12 @@
     },
     "entity": {
         "binary_sensor": {
+            "heating_state": {
+                "name": "T\u00e9amh"
+            },
+            "plugwise_notification": {
+                "name": "F\u00f3gra Plugwise"
+            },
             "secondary_boiler_state": {
                 "name": "St\u00e1das coire t\u00e1naisteach"
             }
@@ -37,15 +43,48 @@
                 "name": "Atosaigh"
             }
         },
+        "climate": {
+            "plugwise": {
+                "state_attributes": {
+                    "available_schemas": {
+                        "name": "Sc\u00e9imeanna at\u00e1 ar f\u00e1il"
+                    },
+                    "preset_mode": {
+                        "state": {
+                            "asleep": "O\u00edche",
+                            "away": "Ar shi\u00fal",
+                            "home": "Baile",
+                            "no_frost": "Frith-sioc",
+                            "vacation": "Laethanta Saoire"
+                        }
+                    },
+                    "selected_schema": {
+                        "name": "Sc\u00e9im roghnaithe"
+                    }
+                }
+            }
+        },
         "number": {
             "max_dhw_temperature": {
                 "name": "Socr\u00fa pointe uisce te t\u00ed"
             },
+            "maximum_boiler_temperature": {
+                "name": "Socr\u00fa uasta teochta coire"
+            },
             "temperature_offset": {
                 "name": "Frith\u00e1ireamh teochta"
             }
         },
         "select": {
+            "dhw_mode": {
+                "name": "M\u00f3d uisce te",
+                "state": {
+                    "auto": "Uath",
+                    "boost": "Borradh",
+                    "comfort": "Chompord",
+                    "off": "As"
+                }
+            },
             "gateway_mode": {
                 "name": "M\u00f3d geata",
                 "state": {
@@ -54,11 +93,77 @@
                     "vacation": "Laethanta Saoire"
                 }
             },
+            "regulation_mode": {
+                "name": "M\u00f3d rial\u00e1la",
+                "state": {
+                    "bleeding_cold": "Fuacht fuilteach",
+                    "bleeding_hot": "Teas fuilteach",
+                    "cooling": "Fuar\u00fa",
+                    "heating": "T\u00e9amh",
+                    "off": "As"
+                }
+            },
             "select_schedule": {
+                "name": "Sceideal teirmeastait",
                 "state": {
                     "off": "As"
                 }
             }
+        },
+        "sensor": {
+            "cooling_setpoint": {
+                "name": "Socr\u00fa pointe fuaraithe"
+            },
+            "dhw_temperature": {
+                "name": "Teocht an uisce te"
+            },
+            "domestic_hot_water_setpoint": {
+                "name": "Pointe socraithe DHW"
+            },
+            "electricity_consumed": {
+                "name": "Leictreachas a \u00edd\u00edtear"
+            },
+            "electricity_consumed_interval": {
+                "name": "Eatramh leictreachais a \u00eddithe"
+            },
+            "electricity_consumed_off_peak_cumulative": {
+                "name": "Leictreachas a \u00edd\u00edtear lasmuigh de bhuaic carnach"
+            },
+            "electricity_consumed_off_peak_interval": {
+                "name": "Leictreachas a chaitear lasmuigh de bhuaicthr\u00e1cht"
+            },
+            "electricity_consumed_off_peak_point": {
+                "name": "Leictreachas a \u00edd\u00edtear lasmuigh de bhuaicphointe"
+            },
+            "voltage_phase_one": {
+                "name": "Voltas c\u00e9im a haon"
+            },
+            "voltage_phase_three": {
+                "name": "Voltas c\u00e9im a tr\u00ed"
+            },
+            "voltage_phase_two": {
+                "name": "Voltas c\u00e9im a d\u00f3"
+            },
+            "water_pressure": {
+                "name": "Br\u00fa uisce"
+            },
+            "water_temperature": {
+                "name": "Teocht an uisce"
+            }
+        },
+        "switch": {
+            "cooling_ena_switch": {
+                "name": "Fuar\u00fa"
+            },
+            "dhw_cm_switch": {
+                "name": "M\u00f3d chompord DHW"
+            },
+            "lock": {
+                "name": "Glas\u00e1il"
+            },
+            "relay": {
+                "name": "Athsheoladh"
+            }
         }
     },
     "exceptions": {

homeassistant/components/plugwise/translations/select.ga.json

@@ -0,0 +1,17 @@
+{
+    "state": {
+        "plugwise__dhw_mode": {
+            "auto": "Uathoibr\u00edoch",
+            "boost": "Borradh",
+            "comfort": "Chompord",
+            "off": "As"
+        },
+        "plugwise__regulation_mode": {
+            "bleeding_cold": "Fuacht fuilteach",
+            "bleeding_hot": "Teas fuilteach",
+            "cooling": "Fuar\u00fa",
+            "heating": "T\u00e9amh",
+            "off": "As"
+        }
+    }
+}

homeassistant/components/plum_lightpad/translations/ga.json

@@ -0,0 +1,18 @@
+{
+    "config": {
+        "abort": {
+            "already_configured": "T\u00e1 an cuntas cumraithe cheana f\u00e9in"
+        },
+        "error": {
+            "cannot_connect": "Theip ar an nascadh"
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "password": "Pasfhocal",
+                    "username": "R\u00edomhphost"
+                }
+            }
+        }
+    }
+}

homeassistant/components/point/entity.py

@@ -28,8 +28,9 @@ class MinutPointEntity(CoordinatorEntity[PointDataUpdateCoordinator]):
             connections={(dr.CONNECTION_NETWORK_MAC, device["device_mac"])},
             identifiers={(DOMAIN, device["device_id"])},
             manufacturer="Minut",
-            model=f"Point v{device['hardware_version']}",
+            model="Point",
             name=device["description"],
+            hw_version=device["hardware_version"],
             sw_version=device["firmware"]["installed"],
             via_device=(DOMAIN, device["home"]),
         )

homeassistant/components/point/translations/ga.json

@@ -3,6 +3,7 @@
         "abort": {
             "already_configured": "T\u00e1 an cuntas cumraithe cheana f\u00e9in",
             "already_in_progress": "T\u00e1 sreabhadh cumra\u00edochta ar si\u00fal cheana f\u00e9in",
+            "authorize_url_timeout": "Am cr\u00edochnaithe ag gini\u00faint URL \u00fadaraithe.",
             "missing_configuration": "N\u00edl an chomhph\u00e1irt cumraithe. Lean an doicim\u00e9ad\u00fa le do thoil.",
             "no_url_available": "N\u00edl aon URL ar f\u00e1il. Chun eolas a fh\u00e1il faoin earr\u00e1id seo, [f\u00e9ach ar an rann\u00f3g chabhrach]({docs_url})",
             "oauth_error": "Fuarthas sonra\u00ed comhartha neamhbhail\u00ed.",
@@ -14,6 +15,9 @@
             "user_rejected_authorize": "Di\u00falta\u00edodh nascadh cuntais: {error}",
             "wrong_account": "N\u00ed f\u00e9idir leat an cuntas seo a athfh\u00edordheimhni\u00fa ach leis an \u00fas\u00e1ideoir c\u00e9anna."
         },
+        "create_entry": {
+            "default": "F\u00edordheimhnithe go rath\u00fail"
+        },
         "step": {
             "pick_implementation": {
                 "data": {

homeassistant/components/pooldose/__init__.py

@@ -0,0 +1,58 @@
+"""The Seko Pooldose integration."""
+
+from __future__ import annotations
+
+import logging
+
+from pooldose.client import PooldoseClient
+from pooldose.request_status import RequestStatus
+
+from homeassistant.const import CONF_HOST, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from .coordinator import PooldoseConfigEntry, PooldoseCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: PooldoseConfigEntry) -> bool:
+    """Set up Seko PoolDose from a config entry."""
+    # Get host from config entry data (connection-critical configuration)
+    host = entry.data[CONF_HOST]
+
+    # Create the PoolDose API client and connect
+    client = PooldoseClient(host)
+    try:
+        client_status = await client.connect()
+    except TimeoutError as err:
+        raise ConfigEntryNotReady(
+            f"Timeout connecting to PoolDose device: {err}"
+        ) from err
+    except (ConnectionError, OSError) as err:
+        raise ConfigEntryNotReady(
+            f"Failed to connect to PoolDose device: {err}"
+        ) from err
+
+    if client_status != RequestStatus.SUCCESS:
+        raise ConfigEntryNotReady(
+            f"Failed to create PoolDose client while initialization: {client_status}"
+        )
+
+    # Create coordinator and perform first refresh
+    coordinator = PooldoseCoordinator(hass, client, entry)
+    await coordinator.async_config_entry_first_refresh()
+
+    # Store runtime data
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: PooldoseConfigEntry) -> bool:
+    """Unload the Seko PoolDose entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/pooldose/config_flow.py

@@ -0,0 +1,99 @@
+"""Config flow for the Seko PoolDose integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pooldose.client import PooldoseClient
+from pooldose.request_status import RequestStatus
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST
+from homeassistant.helpers import config_validation as cv
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+SCHEMA_DEVICE = vol.Schema(
+    {
+        vol.Required(CONF_HOST): cv.string,
+    }
+)
+
+
+class PooldoseConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Seko Pooldose."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        if not user_input:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+            )
+
+        host = user_input[CONF_HOST]
+        client = PooldoseClient(host)
+        client_status = await client.connect()
+        if client_status == RequestStatus.HOST_UNREACHABLE:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "cannot_connect"},
+            )
+        if client_status == RequestStatus.PARAMS_FETCH_FAILED:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "params_fetch_failed"},
+            )
+        if client_status != RequestStatus.SUCCESS:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "cannot_connect"},
+            )
+
+        api_status, api_versions = client.check_apiversion_supported()
+        if api_status == RequestStatus.NO_DATA:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "api_not_set"},
+            )
+        if api_status == RequestStatus.API_VERSION_UNSUPPORTED:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "api_not_supported"},
+                description_placeholders=api_versions,
+            )
+
+        device_info = client.device_info
+        if not device_info:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "no_device_info"},
+            )
+        serial_number = device_info.get("SERIAL_NUMBER")
+        if not serial_number:
+            return self.async_show_form(
+                step_id="user",
+                data_schema=SCHEMA_DEVICE,
+                errors={"base": "no_serial_number"},
+            )
+
+        await self.async_set_unique_id(serial_number)
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(
+            title=f"PoolDose {serial_number}",
+            data={CONF_HOST: host},
+        )

homeassistant/components/pooldose/const.py

@@ -0,0 +1,6 @@
+"""Constants for the Seko Pooldose integration."""
+
+from __future__ import annotations
+
+DOMAIN = "pooldose"
+MANUFACTURER = "SEKO"

homeassistant/components/pooldose/coordinator.py

@@ -0,0 +1,68 @@
+"""Data update coordinator for the PoolDose integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+from typing import Any
+
+from pooldose.client import PooldoseClient
+from pooldose.request_status import RequestStatus
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+_LOGGER = logging.getLogger(__name__)
+
+type PooldoseConfigEntry = ConfigEntry[PooldoseCoordinator]
+
+
+class PooldoseCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Coordinator for PoolDose integration."""
+
+    device_info: dict[str, Any]
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        client: PooldoseClient,
+        config_entry: PooldoseConfigEntry,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Pooldose",
+            update_interval=timedelta(seconds=600),  # Default update interval
+            config_entry=config_entry,
+        )
+        self.client = client
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator."""
+        # Update device info after successful connection
+        self.device_info = self.client.device_info
+        _LOGGER.debug("Device info: %s", self.device_info)
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Fetch data from the PoolDose API."""
+        try:
+            status, instant_values = await self.client.instant_values_structured()
+        except TimeoutError as err:
+            raise UpdateFailed(
+                f"Timeout fetching data from PoolDose device: {err}"
+            ) from err
+        except (ConnectionError, OSError) as err:
+            raise UpdateFailed(
+                f"Failed to connect to PoolDose device while fetching data: {err}"
+            ) from err
+
+        if status != RequestStatus.SUCCESS:
+            raise UpdateFailed(f"API returned status: {status}")
+
+        if instant_values is None:
+            raise UpdateFailed("No data received from API")
+
+        _LOGGER.debug("Instant values structured: %s", instant_values)
+        return instant_values

homeassistant/components/pooldose/entity.py

@@ -0,0 +1,75 @@
+"""Base entity for Seko Pooldose integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, MANUFACTURER
+from .coordinator import PooldoseCoordinator
+
+
+def device_info(info: dict | None, unique_id: str) -> DeviceInfo:
+    """Create device info for PoolDose devices."""
+    if info is None:
+        info = {}
+
+    api_version = info.get("API_VERSION", "").removesuffix("/")
+
+    return DeviceInfo(
+        identifiers={(DOMAIN, unique_id)},
+        manufacturer=MANUFACTURER,
+        model=info.get("MODEL") or None,
+        model_id=info.get("MODEL_ID") or None,
+        name=info.get("NAME") or None,
+        serial_number=unique_id,
+        sw_version=(
+            f"{info.get('FW_VERSION')} (SW v{info.get('SW_VERSION')}, API {api_version})"
+            if info.get("FW_VERSION") and info.get("SW_VERSION") and api_version
+            else None
+        ),
+        hw_version=info.get("FW_CODE") or None,
+        configuration_url=(
+            f"http://{info['IP']}/index.html" if info.get("IP") else None
+        ),
+    )
+
+
+class PooldoseEntity(CoordinatorEntity[PooldoseCoordinator]):
+    """Base class for all PoolDose entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: PooldoseCoordinator,
+        serial_number: str,
+        device_properties: dict[str, Any],
+        entity_description: EntityDescription,
+        platform_name: str,
+    ) -> None:
+        """Initialize PoolDose entity."""
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self.platform_name = platform_name
+        self._attr_unique_id = f"{serial_number}_{entity_description.key}"
+        self._attr_device_info = device_info(device_properties, serial_number)
+
+    @property
+    def available(self) -> bool:
+        """Return True if the entity is available."""
+        if not super().available or self.coordinator.data is None:
+            return False
+        # Check if the entity type exists in coordinator data
+        platform_data = self.coordinator.data.get(self.platform_name, {})
+        return self.entity_description.key in platform_data
+
+    def get_data(self) -> dict | None:
+        """Get data for this entity, only if available."""
+        if not self.available:
+            return None
+        platform_data = self.coordinator.data.get(self.platform_name, {})
+        return platform_data.get(self.entity_description.key)

homeassistant/components/pooldose/icons.json

@@ -0,0 +1,45 @@
+{
+  "entity": {
+    "sensor": {
+      "orp": {
+        "default": "mdi:water-check"
+      },
+      "ph_type_dosing": {
+        "default": "mdi:flask"
+      },
+      "peristaltic_ph_dosing": {
+        "default": "mdi:pump"
+      },
+      "ofa_ph_value": {
+        "default": "mdi:clock"
+      },
+      "orp_type_dosing": {
+        "default": "mdi:flask"
+      },
+      "peristaltic_orp_dosing": {
+        "default": "mdi:pump"
+      },
+      "ofa_orp_value": {
+        "default": "mdi:clock"
+      },
+      "ph_calibration_type": {
+        "default": "mdi:form-select"
+      },
+      "ph_calibration_offset": {
+        "default": "mdi:tune"
+      },
+      "ph_calibration_slope": {
+        "default": "mdi:slope-downhill"
+      },
+      "orp_calibration_type": {
+        "default": "mdi:form-select"
+      },
+      "orp_calibration_offset": {
+        "default": "mdi:tune"
+      },
+      "orp_calibration_slope": {
+        "default": "mdi:slope-downhill"
+      }
+    }
+  }
+}

homeassistant/components/pooldose/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "pooldose",
+  "name": "SEKO PoolDose",
+  "codeowners": ["@lmaertin"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/pooldose",
+  "iot_class": "local_polling",
+  "quality_scale": "bronze",
+  "requirements": ["python-pooldose==0.5.0"]
+}