homeassistant 2025.7.4__py3-none-any.whl → 2025.8.0b0__py3-none-any.whl

homeassistant/components/isy994/__init__.py

@@ -171,7 +171,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: IsyConfigEntry) -> bool:
     _LOGGER.debug("ISY Starting Event Stream and automatic updates")
     isy.websocket.start()
 
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
     entry.async_on_unload(
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_stop_auto_update)
     )
@@ -179,11 +178,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: IsyConfigEntry) -> bool:
     return True
 
 
-async def _async_update_listener(hass: HomeAssistant, entry: IsyConfigEntry) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 @callback
 def _async_get_or_create_isy_device_in_registry(
     hass: HomeAssistant, entry: IsyConfigEntry, isy: ISY

homeassistant/components/isy994/config_flow.py

@@ -18,7 +18,7 @@ from homeassistant.config_entries import (
     SOURCE_IGNORE,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant, callback
@@ -143,7 +143,7 @@ class Isy994ConfigFlow(ConfigFlow, domain=DOMAIN):
     @callback
     def async_get_options_flow(
         config_entry: IsyConfigEntry,
-    ) -> OptionsFlow:
+    ) -> OptionsFlowHandler:
         """Get the options flow for this handler."""
         return OptionsFlowHandler()
 
@@ -316,7 +316,7 @@ class Isy994ConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
 
-class OptionsFlowHandler(OptionsFlow):
+class OptionsFlowHandler(OptionsFlowWithReload):
     """Handle a option flow for ISY/IoX."""
 
     async def async_step_init(

homeassistant/components/ituran/__init__.py

@@ -8,6 +8,7 @@ from homeassistant.core import HomeAssistant
 from .coordinator import IturanConfigEntry, IturanDataUpdateCoordinator
 
 PLATFORMS: list[Platform] = [
+    Platform.BINARY_SENSOR,
     Platform.DEVICE_TRACKER,
     Platform.SENSOR,
 ]

homeassistant/components/ituran/binary_sensor.py

@@ -0,0 +1,75 @@
+"""Binary sensors for Ituran vehicles."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from propcache.api import cached_property
+from pyituran import Vehicle
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import IturanConfigEntry
+from .coordinator import IturanDataUpdateCoordinator
+from .entity import IturanBaseEntity
+
+
+@dataclass(frozen=True, kw_only=True)
+class IturanBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Describes Ituran binary sensor entity."""
+
+    value_fn: Callable[[Vehicle], bool]
+    supported_fn: Callable[[Vehicle], bool] = lambda _: True
+
+
+BINARY_SENSOR_TYPES: list[IturanBinarySensorEntityDescription] = [
+    IturanBinarySensorEntityDescription(
+        key="is_charging",
+        device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
+        value_fn=lambda vehicle: vehicle.is_charging,
+        supported_fn=lambda vehicle: vehicle.is_electric_vehicle,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: IturanConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Ituran binary sensors from config entry."""
+    coordinator = config_entry.runtime_data
+    async_add_entities(
+        IturanBinarySensor(coordinator, vehicle.license_plate, description)
+        for vehicle in coordinator.data.values()
+        for description in BINARY_SENSOR_TYPES
+        if description.supported_fn(vehicle)
+    )
+
+
+class IturanBinarySensor(IturanBaseEntity, BinarySensorEntity):
+    """Ituran binary sensor."""
+
+    entity_description: IturanBinarySensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: IturanDataUpdateCoordinator,
+        license_plate: str,
+        description: IturanBinarySensorEntityDescription,
+    ) -> None:
+        """Initialize the binary sensor."""
+        super().__init__(coordinator, license_plate, description.key)
+        self.entity_description = description
+
+    @cached_property
+    def is_on(self) -> bool:
+        """Return true if the binary sensor is on."""
+        return self.entity_description.value_fn(self.vehicle)

homeassistant/components/ituran/device_tracker.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from propcache.api import cached_property
+
 from homeassistant.components.device_tracker import TrackerEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -38,12 +40,12 @@ class IturanDeviceTracker(IturanBaseEntity, TrackerEntity):
         """Initialize the device tracker."""
         super().__init__(coordinator, license_plate, "device_tracker")
 
-    @property
+    @cached_property
     def latitude(self) -> float | None:
         """Return latitude value of the device."""
         return self.vehicle.gps_coordinates[0]
 
-    @property
+    @cached_property
     def longitude(self) -> float | None:
         """Return longitude value of the device."""
         return self.vehicle.gps_coordinates[1]

homeassistant/components/ituran/icons.json

@@ -9,6 +9,9 @@
       "address": {
         "default": "mdi:map-marker"
       },
+      "battery_range": {
+        "default": "mdi:ev-station"
+      },
       "battery_voltage": {
         "default": "mdi:car-battery"
       },

homeassistant/components/ituran/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "silver",
-  "requirements": ["pyituran==0.1.4"]
+  "requirements": ["pyituran==0.1.5"]
 }

homeassistant/components/ituran/sensor.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
 
+from propcache.api import cached_property
 from pyituran import Vehicle
 
 from homeassistant.components.sensor import (
@@ -15,6 +16,7 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import (
     DEGREE,
+    PERCENTAGE,
     UnitOfElectricPotential,
     UnitOfLength,
     UnitOfSpeed,
@@ -33,6 +35,7 @@ class IturanSensorEntityDescription(SensorEntityDescription):
     """Describes Ituran sensor entity."""
 
     value_fn: Callable[[Vehicle], StateType | datetime]
+    supported_fn: Callable[[Vehicle], bool] = lambda _: True
 
 
 SENSOR_TYPES: list[IturanSensorEntityDescription] = [
@@ -42,6 +45,22 @@ SENSOR_TYPES: list[IturanSensorEntityDescription] = [
         entity_registry_enabled_default=False,
         value_fn=lambda vehicle: vehicle.address,
     ),
+    IturanSensorEntityDescription(
+        key="battery_level",
+        device_class=SensorDeviceClass.BATTERY,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda vehicle: vehicle.battery_level,
+        supported_fn=lambda vehicle: vehicle.is_electric_vehicle,
+    ),
+    IturanSensorEntityDescription(
+        key="battery_range",
+        translation_key="battery_range",
+        device_class=SensorDeviceClass.DISTANCE,
+        native_unit_of_measurement=UnitOfLength.KILOMETERS,
+        suggested_display_precision=0,
+        value_fn=lambda vehicle: vehicle.battery_range,
+        supported_fn=lambda vehicle: vehicle.is_electric_vehicle,
+    ),
     IturanSensorEntityDescription(
         key="battery_voltage",
         translation_key="battery_voltage",
@@ -92,14 +111,15 @@ async def async_setup_entry(
     """Set up the Ituran sensors from config entry."""
     coordinator = config_entry.runtime_data
     async_add_entities(
-        IturanSensor(coordinator, license_plate, description)
+        IturanSensor(coordinator, vehicle.license_plate, description)
+        for vehicle in coordinator.data.values()
         for description in SENSOR_TYPES
-        for license_plate in coordinator.data
+        if description.supported_fn(vehicle)
     )
 
 
 class IturanSensor(IturanBaseEntity, SensorEntity):
-    """Ituran device tracker."""
+    """Ituran sensor."""
 
     entity_description: IturanSensorEntityDescription
 
@@ -113,7 +133,7 @@ class IturanSensor(IturanBaseEntity, SensorEntity):
         super().__init__(coordinator, license_plate, description.key)
         self.entity_description = description
 
-    @property
+    @cached_property
     def native_value(self) -> StateType | datetime:
         """Return the state of the device."""
         return self.entity_description.value_fn(self.vehicle)

homeassistant/components/ituran/strings.json

@@ -40,6 +40,9 @@
       "address": {
         "name": "Address"
       },
+      "battery_range": {
+        "name": "Remaining range"
+      },
       "battery_voltage": {
         "name": "Battery voltage"
       },

homeassistant/components/ituran/translations/cs.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Adresa"
             },
+            "battery_range": {
+                "name": "Zb\u00fdvaj\u00edc\u00ed rozsah"
+            },
             "battery_voltage": {
                 "name": "Nap\u011bt\u00ed baterie"
             },

homeassistant/components/ituran/translations/de.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Adresse"
             },
+            "battery_range": {
+                "name": "Verbleibende Reichweite"
+            },
             "battery_voltage": {
                 "name": "Batteriespannung"
             },

homeassistant/components/ituran/translations/en-GB.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Address"
             },
+            "battery_range": {
+                "name": "Remaining range"
+            },
             "battery_voltage": {
                 "name": "Battery voltage"
             },

homeassistant/components/ituran/translations/en.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Address"
             },
+            "battery_range": {
+                "name": "Remaining range"
+            },
             "battery_voltage": {
                 "name": "Battery voltage"
             },

homeassistant/components/ituran/translations/es.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Direcci\u00f3n"
             },
+            "battery_range": {
+                "name": "Autonom\u00eda restante"
+            },
             "battery_voltage": {
                 "name": "Tensi\u00f3n de la bater\u00eda"
             },

homeassistant/components/ituran/translations/et.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Aadress"
             },
+            "battery_range": {
+                "name": "J\u00e4\u00e4nud paagi t\u00fchjenemiseni"
+            },
             "battery_voltage": {
                 "name": "Aku pinge"
             },

homeassistant/components/ituran/translations/ga.json

@@ -32,6 +32,9 @@
             "address": {
                 "name": "Seoladh"
             },
+            "battery_range": {
+                "name": "Raon at\u00e1 f\u00e1gtha"
+            },
             "battery_voltage": {
                 "name": "Voltas ceallra\u00ed"
             },

homeassistant/components/ituran/translations/sk.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "Adresa"
             },
+            "battery_range": {
+                "name": "Zost\u00e1vaj\u00faci rozsah"
+            },
             "battery_voltage": {
                 "name": "Nap\u00e4tie bat\u00e9rie"
             },

homeassistant/components/ituran/translations/zh-Hans.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "\u5730\u5740"
             },
+            "battery_range": {
+                "name": "\u5269\u4f59\u8303\u56f4"
+            },
             "battery_voltage": {
                 "name": "\u7535\u6c60\u7535\u538b"
             },

homeassistant/components/ituran/translations/zh-Hant.json

@@ -40,6 +40,9 @@
             "address": {
                 "name": "\u5730\u5740"
             },
+            "battery_range": {
+                "name": "\u5269\u9918\u91cc\u7a0b"
+            },
             "battery_voltage": {
                 "name": "\u96fb\u6c60\u96fb\u58d3"
             },

homeassistant/components/jellyfin/browse_media.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from functools import partial
 from typing import Any
 
 from jellyfin_apiclient_python import JellyfinClient
@@ -12,6 +13,7 @@ from homeassistant.components.media_player import (
     BrowseMedia,
     MediaClass,
     MediaType,
+    SearchMediaQuery,
 )
 from homeassistant.core import HomeAssistant
 
@@ -156,6 +158,51 @@ def fetch_items(
     ]
 
 
+async def search_items(
+    hass: HomeAssistant, client: JellyfinClient, user_id: str, query: SearchMediaQuery
+) -> list[BrowseMedia]:
+    """Search items in Jellyfin server."""
+    search_result: list[BrowseMedia] = []
+
+    items: list[dict[str, Any]] = []
+    # Search for items based on media filter classes (or all if none specified)
+    media_types: list[MediaClass] | list[None] = []
+    if query.media_filter_classes:
+        media_types = query.media_filter_classes
+    else:
+        media_types = [None]
+
+    for media_type in media_types:
+        items_dict: dict[str, Any] = await hass.async_add_executor_job(
+            partial(
+                client.jellyfin.search_media_items,
+                term=query.search_query,
+                media=media_type,
+                parent_id=query.media_content_id,
+            )
+        )
+        items.extend(items_dict.get("Items", []))
+
+    for item in items:
+        content_type: str = item["MediaType"]
+
+        response = BrowseMedia(
+            media_class=CONTAINER_TYPES_SPECIFIC_MEDIA_CLASS.get(
+                content_type, MediaClass.DIRECTORY
+            ),
+            media_content_id=item["Id"],
+            media_content_type=content_type,
+            title=item["Name"],
+            thumbnail=get_artwork_url(client, item),
+            can_play=bool(content_type in PLAYABLE_MEDIA_TYPES),
+            can_expand=item.get("IsFolder", False),
+            children=None,
+        )
+        search_result.append(response)
+
+    return search_result
+
+
 async def get_media_info(
     hass: HomeAssistant,
     client: JellyfinClient,

homeassistant/components/jellyfin/media_player.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any
 
 from homeassistant.components.media_player import (
@@ -10,17 +11,21 @@ from homeassistant.components.media_player import (
     MediaPlayerEntityFeature,
     MediaPlayerState,
     MediaType,
+    SearchMedia,
+    SearchMediaQuery,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.dt import parse_datetime
 
-from .browse_media import build_item_response, build_root_response
+from .browse_media import build_item_response, build_root_response, search_items
 from .client_wrapper import get_artwork_url
 from .const import CONTENT_TYPE_MAP, LOGGER, MAX_IMAGE_WIDTH
 from .coordinator import JellyfinConfigEntry, JellyfinDataUpdateCoordinator
 from .entity import JellyfinClientEntity
 
+_LOGGER = logging.getLogger(__name__)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -177,10 +182,15 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
     def supported_features(self) -> MediaPlayerEntityFeature:
         """Flag media player features that are supported."""
         commands: list[str] = self.capabilities.get("SupportedCommands", [])
-        controllable = self.capabilities.get("SupportsMediaControl", False)
+        _LOGGER.debug(
+            "Supported commands for device %s, client %s, %s",
+            self.device_name,
+            self.client_name,
+            commands,
+        )
         features = MediaPlayerEntityFeature(0)
 
-        if controllable:
+        if "PlayMediaSource" in commands:
             features |= (
                 MediaPlayerEntityFeature.BROWSE_MEDIA
                 | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -188,6 +198,7 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
                 | MediaPlayerEntityFeature.PLAY
                 | MediaPlayerEntityFeature.STOP
                 | MediaPlayerEntityFeature.SEEK
+                | MediaPlayerEntityFeature.SEARCH_MEDIA
             )
 
             if "Mute" in commands:
@@ -266,3 +277,13 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
             media_content_type,
             media_content_id,
         )
+
+    async def async_search_media(
+        self,
+        query: SearchMediaQuery,
+    ) -> SearchMedia:
+        """Search the media player."""
+        result = await search_items(
+            self.hass, self.coordinator.api_client, self.coordinator.user_id, query
+        )
+        return SearchMedia(result=result)

homeassistant/components/jellyfin/translations/ga.json

@@ -6,5 +6,14 @@
                 "unit_of_measurement": "cliaint"
             }
         }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "data": {
+                    "audio_codec": "C\u00f3dac fuaime"
+                }
+            }
+        }
     }
 }

homeassistant/components/jewish_calendar/__init__.py

@@ -79,13 +79,6 @@ async def async_setup_entry(
 
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
-    async def update_listener(
-        hass: HomeAssistant, config_entry: JewishCalendarConfigEntry
-    ) -> None:
-        # Trigger update of states for all platforms
-        await hass.config_entries.async_reload(config_entry.entry_id)
-
-    config_entry.async_on_unload(config_entry.add_update_listener(update_listener))
     return True
 
 

homeassistant/components/jewish_calendar/binary_sensor.py

@@ -13,8 +13,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntityDescription,
 )
 from homeassistant.const import EntityCategory
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.helpers import event
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
@@ -23,36 +22,29 @@ from .entity import JewishCalendarConfigEntry, JewishCalendarEntity
 PARALLEL_UPDATES = 0
 
 
-@dataclass(frozen=True)
-class JewishCalendarBinarySensorMixIns(BinarySensorEntityDescription):
-    """Binary Sensor description mixin class for Jewish Calendar."""
-
-    is_on: Callable[[Zmanim, dt.datetime], bool] = lambda _, __: False
-
-
-@dataclass(frozen=True)
-class JewishCalendarBinarySensorEntityDescription(
-    JewishCalendarBinarySensorMixIns, BinarySensorEntityDescription
-):
+@dataclass(frozen=True, kw_only=True)
+class JewishCalendarBinarySensorEntityDescription(BinarySensorEntityDescription):
     """Binary Sensor Entity description for Jewish Calendar."""
 
+    is_on: Callable[[Zmanim], Callable[[dt.datetime], bool]]
+
 
 BINARY_SENSORS: tuple[JewishCalendarBinarySensorEntityDescription, ...] = (
     JewishCalendarBinarySensorEntityDescription(
         key="issur_melacha_in_effect",
         translation_key="issur_melacha_in_effect",
-        is_on=lambda state, now: bool(state.issur_melacha_in_effect(now)),
+        is_on=lambda state: state.issur_melacha_in_effect,
     ),
     JewishCalendarBinarySensorEntityDescription(
         key="erev_shabbat_hag",
         translation_key="erev_shabbat_hag",
-        is_on=lambda state, now: bool(state.erev_shabbat_chag(now)),
+        is_on=lambda state: state.erev_shabbat_chag,
         entity_registry_enabled_default=False,
     ),
     JewishCalendarBinarySensorEntityDescription(
         key="motzei_shabbat_hag",
         translation_key="motzei_shabbat_hag",
-        is_on=lambda state, now: bool(state.motzei_shabbat_chag(now)),
+        is_on=lambda state: state.motzei_shabbat_chag,
         entity_registry_enabled_default=False,
     ),
 )
@@ -73,9 +65,7 @@ async def async_setup_entry(
 class JewishCalendarBinarySensor(JewishCalendarEntity, BinarySensorEntity):
     """Representation of an Jewish Calendar binary sensor."""
 
-    _attr_should_poll = False
     _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _update_unsub: CALLBACK_TYPE | None = None
 
     entity_description: JewishCalendarBinarySensorEntityDescription
 
@@ -83,40 +73,12 @@ class JewishCalendarBinarySensor(JewishCalendarEntity, BinarySensorEntity):
     def is_on(self) -> bool:
         """Return true if sensor is on."""
         zmanim = self.make_zmanim(dt.date.today())
-        return self.entity_description.is_on(zmanim, dt_util.now())
-
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        self._schedule_update()
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        if self._update_unsub:
-            self._update_unsub()
-            self._update_unsub = None
-        return await super().async_will_remove_from_hass()
-
-    @callback
-    def _update(self, now: dt.datetime | None = None) -> None:
-        """Update the state of the sensor."""
-        self._update_unsub = None
-        self._schedule_update()
-        self.async_write_ha_state()
-
-    def _schedule_update(self) -> None:
-        """Schedule the next update of the sensor."""
-        now = dt_util.now()
-        zmanim = self.make_zmanim(dt.date.today())
-        update = zmanim.netz_hachama.local + dt.timedelta(days=1)
-        candle_lighting = zmanim.candle_lighting
-        if candle_lighting is not None and now < candle_lighting < update:
-            update = candle_lighting
-        havdalah = zmanim.havdalah
-        if havdalah is not None and now < havdalah < update:
-            update = havdalah
-        if self._update_unsub:
-            self._update_unsub()
-        self._update_unsub = event.async_track_point_in_time(
-            self.hass, self._update, update
-        )
+        return self.entity_description.is_on(zmanim)(dt_util.now())
+
+    def _update_times(self, zmanim: Zmanim) -> list[dt.datetime | None]:
+        """Return a list of times to update the sensor."""
+        return [
+            zmanim.netz_hachama.local + dt.timedelta(days=1),
+            zmanim.candle_lighting,
+            zmanim.havdalah,
+        ]