homeassistant 2025.11.0b5__py3-none-any.whl → 2025.12.0__py3-none-any.whl

homeassistant/components/statistics/translations/sr-Latn.json

@@ -1,12 +1,128 @@
 {
     "config": {
+        "abort": {
+            "already_configured": "Nalog je ve\u0107 konfigurisan"
+        },
+        "error": {
+            "missing_keep_last_sample": "Konfiguracija senzora mora da obezbedi 'Maksimalnu starost' ako je 'Zadr\u017ei poslednji uzorak' postavljeno na ta\u010dno.",
+            "missing_max_age_or_sampling_size": "Konfiguracija senzora mora da obezbedi 'Maksimalno vreme \u010duvanja' i/ili 'Veli\u010dinu uzorka'."
+        },
         "step": {
+            "options": {
+                "data": {
+                    "entity_id": "Entitet",
+                    "keep_last_sample": "Zadr\u017ei poslednji uzorak",
+                    "max_age": "Maksimalna starost",
+                    "percentile": "Percentil",
+                    "precision": "Preciznost",
+                    "sampling_size": "Veli\u010dina uzorka",
+                    "state_characteristic": "Statisti\u010dka karakteristika"
+                },
+                "data_description": {
+                    "entity_id": "Entitet iz kog se preuzimaju statistike.",
+                    "keep_last_sample": "Odre\u0111uje da li najnovija uzorkovana vrednost treba da se sa\u010duva bez obzira na pode\u0161avanje 'Maksimalna starost'.",
+                    "max_age": "Maksimalno vreme \u010duvanja merenja izvornog senzora.",
+                    "percentile": "Va\u017ei samo u kombinaciji sa karakteristikom \u2018Percentile\u2019. Mora biti vrednost izme\u0111u 1 i 99.",
+                    "precision": "Defini\u0161e broj decimalnih mesta izra\u010dunate vrednosti senzora.",
+                    "sampling_size": "Maksimalan broj sa\u010duvanih merenja izvornog senzora.",
+                    "state_characteristic": "Statisti\u010dka karakteristika koja treba da se koristi kao stanje senzora."
+                },
+                "description": "Pro\u010ditaj dokumentaciju za dodatne detalje o tome kako da konfiguri\u0161e\u0161 statisti\u010dke senzore koriste\u0107i ove opcije."
+            },
+            "state_characteristic": {
+                "data": {
+                    "state_characteristic": "Statisti\u010dka karakteristika"
+                },
+                "data_description": {
+                    "state_characteristic": "Statisti\u010dka karakteristika koja treba da se koristi kao stanje senzora."
+                },
+                "description": "Pro\u010ditaj dokumentaciju za dodatne detalje o dostupnim opcijama i na\u010dinu njihove upotrebe."
+            },
             "user": {
                 "data": {
                     "entity_id": "Entitet",
                     "name": "Naziv"
-                }
+                },
+                "data_description": {
+                    "entity_id": "Entitet iz kog se preuzimaju statistike.",
+                    "name": "Naziv za kreirani entitet."
+                },
+                "description": "Kreiraj statisti\u010dki senzor"
             }
         }
-    }
+    },
+    "options": {
+        "abort": {
+            "already_configured": "Nalog je ve\u0107 konfigurisan"
+        },
+        "error": {
+            "missing_keep_last_sample": "Konfiguracija senzora mora da obezbedi 'Maksimalnu starost' ako je 'Zadr\u017ei poslednji uzorak' postavljeno na ta\u010dno.",
+            "missing_max_age_or_sampling_size": "Konfiguracija senzora mora da obezbedi 'Maksimalno vreme \u010duvanja' i/ili 'Veli\u010dinu uzorka'."
+        },
+        "step": {
+            "init": {
+                "data": {
+                    "entity_id": "Entitet",
+                    "keep_last_sample": "Zadr\u017ei poslednji uzorak",
+                    "max_age": "Maksimalna starost",
+                    "percentile": "Percentil",
+                    "precision": "Preciznost",
+                    "sampling_size": "Veli\u010dina uzorka",
+                    "state_characteristic": "Statisti\u010dka karakteristika"
+                },
+                "data_description": {
+                    "entity_id": "Entitet iz kog se preuzimaju statistike.",
+                    "keep_last_sample": "Odre\u0111uje da li najnovija uzorkovana vrednost treba da se sa\u010duva bez obzira na pode\u0161avanje 'Maksimalna starost'.",
+                    "max_age": "Maksimalno vreme \u010duvanja merenja izvornog senzora.",
+                    "percentile": "Va\u017ei samo u kombinaciji sa karakteristikom \u2018Percentile\u2019. Mora biti vrednost izme\u0111u 1 i 99.",
+                    "precision": "Defini\u0161e broj decimalnih mesta izra\u010dunate vrednosti senzora.",
+                    "sampling_size": "Maksimalan broj sa\u010duvanih merenja izvornog senzora.",
+                    "state_characteristic": "Statisti\u010dka karakteristika koja treba da se koristi kao stanje senzora."
+                },
+                "description": "Pro\u010ditaj dokumentaciju za dodatne detalje o tome kako da konfiguri\u0161e\u0161 statisti\u010dke senzore koriste\u0107i ove opcije."
+            }
+        }
+    },
+    "selector": {
+        "state_characteristic": {
+            "options": {
+                "average_linear": "Linearni prosek",
+                "average_step": "Prose\u010dan korak",
+                "average_timeless": "Bezvremenski prosek",
+                "change": "Promeni",
+                "change_sample": "Promeni uzorak",
+                "change_second": "Change second",
+                "count": "Broj",
+                "count_off": "Broj isklju\u010denih",
+                "count_on": "Broj uklju\u010denih",
+                "datetime_newest": "Najnoviji datum/vreme",
+                "datetime_oldest": "Najstariji datum/vreme",
+                "datetime_value_max": "Datum/vreme maksimalne vrednosti",
+                "datetime_value_min": "Datum/vreme minimalne vrednosti",
+                "distance_95_percent_of_values": "Rastojanje za 95% vrednosti",
+                "distance_99_percent_of_values": "Rastojanje za 99% vrednosti",
+                "distance_absolute": "Apsolutno rastojanje",
+                "mean": "Sredina",
+                "mean_circular": "Cirkularna sredina",
+                "median": "Medijana",
+                "noisiness": "Nivo \u0161uma",
+                "percentile": "Percentil",
+                "standard_deviation": "Standardna devijacija",
+                "sum": "Suma",
+                "sum_differences": "Zbir razlika",
+                "sum_differences_nonnegative": "Zbir razlika nije negativan",
+                "total": "Ukupno",
+                "value_max": "Maksimalna vrednost",
+                "value_min": "Minimalna vrednost",
+                "variance": "Varijansa"
+            }
+        }
+    },
+    "services": {
+        "reload": {
+            "description": "Ponovo u\u010ditava statisti\u010dke senzore iz YAML konfiguracije.",
+            "name": "Ponovo u\u010ditaj"
+        }
+    },
+    "title": "Statistika"
 }

homeassistant/components/steam_online/translations/it.json

@@ -2,7 +2,7 @@
     "config": {
         "abort": {
             "already_configured": "Il servizio \u00e8 gi\u00e0 configurato",
-            "reauth_successful": "L'autenticazione ha avuto successo"
+            "reauth_successful": "La riautenticazione \u00e8 avvenuta con successo"
         },
         "error": {
             "cannot_connect": "Impossibile connettersi",

homeassistant/components/steamist/config_flow.py

@@ -137,7 +137,7 @@ class SteamistConfigFlow(ConfigFlow, domain=DOMAIN):
             device = self._discovered_devices[mac]
             return self._async_create_entry_from_device(device)
 
-        current_unique_ids = self._async_current_ids()
+        current_unique_ids = self._async_current_ids(include_ignore=False)
         current_hosts = {
             entry.data[CONF_HOST]
             for entry in self._async_current_entries(include_ignore=False)

homeassistant/components/stookwijzer/__init__.py

@@ -17,7 +17,7 @@ from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, LOGGER
 from .coordinator import StookwijzerConfigEntry, StookwijzerCoordinator
-from .services import setup_services
+from .services import async_setup_services
 
 PLATFORMS = [Platform.SENSOR]
 
@@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Stookwijzer component."""
-    setup_services(hass)
+    async_setup_services(hass)
     return True
 
 

homeassistant/components/stookwijzer/services.py

@@ -11,6 +11,7 @@ from homeassistant.core import (
     ServiceCall,
     ServiceResponse,
     SupportsResponse,
+    callback,
 )
 from homeassistant.exceptions import ServiceValidationError
 
@@ -51,7 +52,8 @@ def async_get_entry(
     return cast(StookwijzerConfigEntry, entry)
 
 
-def setup_services(hass: HomeAssistant) -> None:
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Stookwijzer integration."""
 
     async def async_get_forecast(call: ServiceCall) -> ServiceResponse | None:

homeassistant/components/stream/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "system",
   "iot_class": "local_push",
   "quality_scale": "internal",
-  "requirements": ["PyTurboJPEG==1.8.0", "av==13.1.0", "numpy==2.3.2"]
+  "requirements": ["PyTurboJPEG==1.8.0", "av==16.0.1", "numpy==2.3.2"]
 }

homeassistant/components/stream/recorder.py

@@ -121,11 +121,9 @@ class RecorderOutput(StreamOutput):
 
             # Add output streams if necessary
             if not output_v:
-                output_v = output.add_stream(template=source_v)
-                context = output_v.codec_context
-                context.global_header = True
+                output_v = output.add_stream_from_template(source_v)
             if source_a and not output_a:
-                output_a = output.add_stream(template=source_a)
+                output_a = output.add_stream_from_template(source_a)
 
             # Recalculate pts adjustments on first segment and on any discontinuity
             # We are assuming time base is the same across all discontinuities

homeassistant/components/stream/worker.py

@@ -52,7 +52,7 @@ NEGATIVE_INF = -math.inf
 
 def redact_av_error_string(err: av.FFmpegError) -> str:
     """Return an error string with credentials redacted from the url."""
-    parts = [str(err.type), err.strerror]  # type: ignore[attr-defined]
+    parts = [err.strerror or ""]
     if err.filename:
         parts.append(redact_credentials(err.filename))
     return ", ".join(parts)
@@ -223,7 +223,7 @@ class StreamMuxer:
             format=SEGMENT_CONTAINER_FORMAT,
             container_options=container_options,
         )
-        output_vstream = container.add_stream(template=input_vstream)
+        output_vstream = container.add_stream_from_template(input_vstream)
         # Check if audio is requested
         output_astream = None
         if input_astream:
@@ -231,8 +231,8 @@ class StreamMuxer:
                 self._audio_bsf_context = av.BitStreamFilterContext(
                     self._audio_bsf, input_astream
                 )
-            output_astream = container.add_stream(template=input_astream)
-        return container, output_vstream, output_astream  # type: ignore[return-value]
+            output_astream = container.add_stream_from_template(input_astream)
+        return container, output_vstream, output_astream
 
     def reset(self, video_dts: int) -> None:
         """Initialize a new stream segment."""
@@ -260,6 +260,7 @@ class StreamMuxer:
         if packet.stream == self._input_video_stream:
             if (
                 packet.is_keyframe
+                and packet.dts
                 and (packet.dts - self._segment_start_dts) * packet.time_base
                 >= self._stream_settings.min_segment_duration
             ):
@@ -331,6 +332,7 @@ class StreamMuxer:
         playback issues in some clients.
         """
         # Part durations should not exceed the part target duration
+        assert packet.dts is not None
         adjusted_dts = min(
             packet.dts,
             self._part_start_dts
@@ -459,7 +461,7 @@ class TimestampValidator:
         """Validate the packet timestamp based on ordering within the stream."""
         # Discard packets missing DTS. Terminate if too many are missing.
         if packet.dts is None:
-            if self._missing_dts >= MAX_MISSING_DTS:  # type: ignore[unreachable]
+            if self._missing_dts >= MAX_MISSING_DTS:
                 raise StreamWorkerError(
                     f"No dts in {MAX_MISSING_DTS + 1} consecutive packets"
                 )
@@ -577,7 +579,7 @@ def stream_worker(
         audio_stream = None
     # Some audio streams do not have a profile and throw errors when remuxing
     if audio_stream and audio_stream.profile is None:
-        audio_stream = None  # type: ignore[unreachable]
+        audio_stream = None
     # Disable ll-hls for hls inputs
     if container.format.name == "hls":
         for field in fields(StreamSettings):
@@ -626,6 +628,7 @@ def stream_worker(
         # adjustment, it does not filter out the case where the duration below is
         # 0 and both the first_keyframe and next_video_packet end up with the same
         # dts. Use "or 1" to deal with this.
+        assert next_video_packet.dts is not None
         start_dts = next_video_packet.dts - (next_video_packet.duration or 1)
         first_keyframe.dts = first_keyframe.pts = start_dts
     except StreamWorkerError:

homeassistant/components/subaru/translations/sv.json

@@ -101,8 +101,10 @@
     },
     "services": {
         "unlock_specific_door": {
+            "description": "L\u00e5ser upp specifik(a) d\u00f6rr(ar).",
             "fields": {
                 "door": {
+                    "description": "Vilken/vilka d\u00f6rrar som ska \u00f6ppnas.",
                     "name": "D\u00f6rr"
                 }
             },

homeassistant/components/sunricher_dali/__init__.py

@@ -0,0 +1,81 @@
+"""The Sunricher DALI integration."""
+
+from __future__ import annotations
+
+import logging
+
+from PySrDaliGateway import DaliGateway
+from PySrDaliGateway.exceptions import DaliGatewayError
+
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_USERNAME,
+    Platform,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import device_registry as dr
+
+from .const import CONF_SERIAL_NUMBER, DOMAIN, MANUFACTURER
+from .types import DaliCenterConfigEntry, DaliCenterData
+
+_PLATFORMS: list[Platform] = [Platform.LIGHT]
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DaliCenterConfigEntry) -> bool:
+    """Set up Sunricher DALI from a config entry."""
+
+    gateway = DaliGateway(
+        entry.data[CONF_SERIAL_NUMBER],
+        entry.data[CONF_HOST],
+        entry.data[CONF_PORT],
+        entry.data[CONF_USERNAME],
+        entry.data[CONF_PASSWORD],
+        name=entry.data[CONF_NAME],
+    )
+    gw_sn = gateway.gw_sn
+
+    try:
+        await gateway.connect()
+    except DaliGatewayError as exc:
+        raise ConfigEntryNotReady(
+            "You can try to delete the gateway and add it again"
+        ) from exc
+
+    try:
+        devices = await gateway.discover_devices()
+    except DaliGatewayError as exc:
+        raise ConfigEntryNotReady(
+            "Unable to discover devices from the gateway"
+        ) from exc
+
+    _LOGGER.debug("Discovered %d devices on gateway %s", len(devices), gw_sn)
+
+    dev_reg = dr.async_get(hass)
+    dev_reg.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        identifiers={(DOMAIN, gw_sn)},
+        manufacturer=MANUFACTURER,
+        name=gateway.name,
+        model="SR-GW-EDA",
+        serial_number=gw_sn,
+    )
+
+    entry.runtime_data = DaliCenterData(
+        gateway=gateway,
+        devices=devices,
+    )
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DaliCenterConfigEntry) -> bool:
+    """Unload a config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, _PLATFORMS):
+        await entry.runtime_data.gateway.disconnect()
+    return unload_ok

homeassistant/components/sunricher_dali/config_flow.py

@@ -0,0 +1,134 @@
+"""Config flow for the Sunricher DALI integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from PySrDaliGateway import DaliGateway
+from PySrDaliGateway.discovery import DaliGatewayDiscovery
+from PySrDaliGateway.exceptions import DaliGatewayError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_USERNAME,
+)
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+)
+
+from .const import CONF_SERIAL_NUMBER, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DaliCenterConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Sunricher DALI."""
+
+    VERSION = 1
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovered_gateways: dict[str, DaliGateway] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        if user_input is not None:
+            return await self.async_step_select_gateway()
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({}),
+        )
+
+    async def async_step_select_gateway(
+        self, discovery_info: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle gateway discovery."""
+        errors: dict[str, str] = {}
+
+        if discovery_info and "selected_gateway" in discovery_info:
+            selected_sn = discovery_info["selected_gateway"]
+            selected_gateway = self._discovered_gateways[selected_sn]
+
+            await self.async_set_unique_id(selected_gateway.gw_sn)
+            self._abort_if_unique_id_configured()
+
+            try:
+                await selected_gateway.connect()
+            except DaliGatewayError as err:
+                _LOGGER.debug(
+                    "Failed to connect to gateway %s during config flow",
+                    selected_gateway.gw_sn,
+                    exc_info=err,
+                )
+                errors["base"] = "cannot_connect"
+            else:
+                await selected_gateway.disconnect()
+                return self.async_create_entry(
+                    title=selected_gateway.name,
+                    data={
+                        CONF_SERIAL_NUMBER: selected_gateway.gw_sn,
+                        CONF_HOST: selected_gateway.gw_ip,
+                        CONF_PORT: selected_gateway.port,
+                        CONF_NAME: selected_gateway.name,
+                        CONF_USERNAME: selected_gateway.username,
+                        CONF_PASSWORD: selected_gateway.passwd,
+                    },
+                )
+
+        if not self._discovered_gateways:
+            _LOGGER.debug("Starting gateway discovery")
+            discovery = DaliGatewayDiscovery()
+            try:
+                discovered = await discovery.discover_gateways()
+            except DaliGatewayError as err:
+                _LOGGER.debug("Gateway discovery failed", exc_info=err)
+                errors["base"] = "discovery_failed"
+            else:
+                configured_gateways = {
+                    entry.data[CONF_SERIAL_NUMBER]
+                    for entry in self.hass.config_entries.async_entries(DOMAIN)
+                }
+
+                self._discovered_gateways = {
+                    gw.gw_sn: gw
+                    for gw in discovered
+                    if gw.gw_sn not in configured_gateways
+                }
+
+        if not self._discovered_gateways:
+            return self.async_show_form(
+                step_id="select_gateway",
+                errors=errors if errors else {"base": "no_devices_found"},
+                data_schema=vol.Schema({}),
+            )
+
+        gateway_options = [
+            SelectOptionDict(
+                value=sn,
+                label=f"{gateway.name} [SN {sn}, IP {gateway.gw_ip}]",
+            )
+            for sn, gateway in self._discovered_gateways.items()
+        ]
+
+        return self.async_show_form(
+            step_id="select_gateway",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional("selected_gateway"): SelectSelector(
+                        SelectSelectorConfig(options=gateway_options, sort=True)
+                    ),
+                }
+            ),
+            errors=errors,
+        )

homeassistant/components/sunricher_dali/const.py

@@ -0,0 +1,5 @@
+"""Constants for the Sunricher DALI integration."""
+
+DOMAIN = "sunricher_dali"
+MANUFACTURER = "Sunricher"
+CONF_SERIAL_NUMBER = "serial_number"