homeassistant 2025.9.4__py3-none-any.whl → 2025.10.0b0__py3-none-any.whl

homeassistant/components/pushover/notify.py

@@ -27,6 +27,7 @@ from .const import (
     ATTR_RETRY,
     ATTR_SOUND,
     ATTR_TIMESTAMP,
+    ATTR_TTL,
     ATTR_URL,
     ATTR_URL_TITLE,
     CONF_USER_KEY,
@@ -66,12 +67,13 @@ class PushoverNotificationService(BaseNotificationService):
 
         # Extract params from data dict
         title = kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT)
-        data = dict(kwargs.get(ATTR_DATA) or {})
+        data = kwargs.get(ATTR_DATA, {})
         url = data.get(ATTR_URL)
         url_title = data.get(ATTR_URL_TITLE)
         priority = data.get(ATTR_PRIORITY)
         retry = data.get(ATTR_RETRY)
         expire = data.get(ATTR_EXPIRE)
+        ttl = data.get(ATTR_TTL)
         callback_url = data.get(ATTR_CALLBACK_URL)
         timestamp = data.get(ATTR_TIMESTAMP)
         sound = data.get(ATTR_SOUND)
@@ -98,20 +100,21 @@ class PushoverNotificationService(BaseNotificationService):
 
         try:
             self.pushover.send_message(
-                self._user_key,
-                message,
-                ",".join(kwargs.get(ATTR_TARGET, [])),
-                title,
-                url,
-                url_title,
-                image,
-                priority,
-                retry,
-                expire,
-                callback_url,
-                timestamp,
-                sound,
-                html,
+                user=self._user_key,
+                message=message,
+                device=",".join(kwargs.get(ATTR_TARGET, [])),
+                title=title,
+                url=url,
+                url_title=url_title,
+                image=image,
+                priority=priority,
+                retry=retry,
+                expire=expire,
+                callback_url=callback_url,
+                timestamp=timestamp,
+                sound=sound,
+                html=html,
+                ttl=ttl,
             )
         except BadAPIRequestError as err:
             raise HomeAssistantError(str(err)) from err

homeassistant/components/pvoutput/translations/de.json

@@ -13,14 +13,14 @@
                 "data": {
                     "api_key": "API-Schl\u00fcssel"
                 },
-                "description": "Um sich erneut bei PVOutput zu authentifizieren, ben\u00f6tigst du den API-Code unter {account_url}."
+                "description": "Um dich erneut bei PVOutput zu authentifizieren, musst du den API-Schl\u00fcssel unter {account_url} abrufen."
             },
             "user": {
                 "data": {
                     "api_key": "API-Schl\u00fcssel",
                     "system_id": "System-ID"
                 },
-                "description": "Um sich bei PVOutput zu authentifizieren, musst du den API-Code unter {account_url} abrufen.\n\nDie System-IDs der registrierten Systeme sind auf der gleichen Seite aufgef\u00fchrt."
+                "description": "Um dich bei PVOutput zu authentifizieren, musst du den API-Schl\u00fcssel unter {account_url} abrufen.\n\nDie System-IDs der registrierten Systeme sind auf derselben Seite aufgef\u00fchrt."
             }
         }
     },

homeassistant/components/pvpc_hourly_pricing/__init__.py

@@ -4,7 +4,6 @@ from homeassistant.const import CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from .const import ATTR_POWER, ATTR_POWER_P3
 from .coordinator import ElecPricesDataUpdateCoordinator, PVPCConfigEntry
 from .helpers import get_enabled_sensor_keys
 
@@ -23,23 +22,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: PVPCConfigEntry) -> bool
 
     entry.runtime_data = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(async_update_options))
     return True
 
 
-async def async_update_options(hass: HomeAssistant, entry: PVPCConfigEntry) -> None:
-    """Handle options update."""
-    if any(
-        entry.data.get(attrib) != entry.options.get(attrib)
-        for attrib in (ATTR_POWER, ATTR_POWER_P3, CONF_API_TOKEN)
-    ):
-        # update entry replacing data with new options
-        hass.config_entries.async_update_entry(
-            entry, data={**entry.data, **entry.options}
-        )
-        await hass.config_entries.async_reload(entry.entry_id)
-
-
 async def async_unload_entry(hass: HomeAssistant, entry: PVPCConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/pvpc_hourly_pricing/config_flow.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_API_TOKEN, CONF_NAME
 from homeassistant.core import callback
@@ -178,7 +178,7 @@ class TariffSelectorConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(step_id="reauth_confirm", data_schema=data_schema)
 
 
-class PVPCOptionsFlowHandler(OptionsFlow):
+class PVPCOptionsFlowHandler(OptionsFlowWithReload):
     """Handle PVPC options."""
 
     _power: float | None = None

homeassistant/components/pvpc_hourly_pricing/coordinator.py

@@ -29,13 +29,16 @@ class ElecPricesDataUpdateCoordinator(DataUpdateCoordinator[EsiosApiData]):
         self, hass: HomeAssistant, entry: PVPCConfigEntry, sensor_keys: set[str]
     ) -> None:
         """Initialize."""
+        config = entry.data.copy()
+        config.update({attr: value for attr, value in entry.options.items() if value})
+
         self.api = PVPCData(
             session=async_get_clientsession(hass),
-            tariff=entry.data[ATTR_TARIFF],
+            tariff=config[ATTR_TARIFF],
             local_timezone=hass.config.time_zone,
-            power=entry.data[ATTR_POWER],
-            power_valley=entry.data[ATTR_POWER_P3],
-            api_token=entry.data.get(CONF_API_TOKEN),
+            power=config[ATTR_POWER],
+            power_valley=config[ATTR_POWER_P3],
+            api_token=config.get(CONF_API_TOKEN),
             sensor_keys=tuple(sensor_keys),
         )
         super().__init__(

homeassistant/components/qbus/entity.py

@@ -78,7 +78,7 @@ def create_unique_id(serial_number: str, suffix: str) -> str:
     return f"ctd_{serial_number}_{suffix}"
 
 
-class QbusEntity(Entity, Generic[StateT], ABC):
+class QbusEntity(Entity, ABC, Generic[StateT]):
     """Representation of a Qbus entity."""
 
     _state_cls: type[StateT] = cast(type[StateT], QbusMqttState)

homeassistant/components/radarr/coordinator.py

@@ -57,7 +57,7 @@ class RadarrEvent(CalendarEvent, RadarrEventMixIn):
     """A class to describe a Radarr calendar event."""
 
 
-class RadarrDataUpdateCoordinator(DataUpdateCoordinator[T], Generic[T], ABC):
+class RadarrDataUpdateCoordinator(DataUpdateCoordinator[T], ABC, Generic[T]):
     """Data update coordinator for the Radarr integration."""
 
     config_entry: RadarrConfigEntry

homeassistant/components/radio_browser/media_source.py

@@ -16,6 +16,7 @@ from homeassistant.components.media_source import (
     Unresolvable,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.util.location import vincenty
 
 from . import RadioBrowserConfigEntry
 from .const import DOMAIN
@@ -66,7 +67,7 @@ class RadioMediaSource(MediaSource):
         # Register "click" with Radio Browser
         await radios.station_click(uuid=station.uuid)
 
-        return PlayMedia(station.url, mime_type)
+        return PlayMedia(station.url_resolved, mime_type)
 
     async def async_browse_media(
         self,
@@ -88,6 +89,7 @@ class RadioMediaSource(MediaSource):
                 *await self._async_build_popular(radios, item),
                 *await self._async_build_by_tag(radios, item),
                 *await self._async_build_by_language(radios, item),
+                *await self._async_build_local(radios, item),
                 *await self._async_build_by_country(radios, item),
             ],
         )
@@ -134,7 +136,7 @@ class RadioMediaSource(MediaSource):
     ) -> list[BrowseMediaSource]:
         """Handle browsing radio stations by country."""
         category, _, country_code = (item.identifier or "").partition("/")
-        if country_code:
+        if category == "country" and country_code:
             stations = await radios.stations(
                 filter_by=FilterBy.COUNTRY_CODE_EXACT,
                 filter_term=country_code,
@@ -185,7 +187,7 @@ class RadioMediaSource(MediaSource):
             return [
                 BrowseMediaSource(
                     domain=DOMAIN,
-                    identifier=f"language/{language.code}",
+                    identifier=f"language/{language.name.lower()}",
                     media_class=MediaClass.DIRECTORY,
                     media_content_type=MediaType.MUSIC,
                     title=language.name,
@@ -292,3 +294,63 @@ class RadioMediaSource(MediaSource):
             ]
 
         return []
+
+    def _filter_local_stations(
+        self, stations: list[Station], latitude: float, longitude: float
+    ) -> list[Station]:
+        return [
+            station
+            for station in stations
+            if station.latitude is not None
+            and station.longitude is not None
+            and (
+                (
+                    dist := vincenty(
+                        (latitude, longitude),
+                        (station.latitude, station.longitude),
+                        False,
+                    )
+                )
+                is not None
+            )
+            and dist < 100
+        ]
+
+    async def _async_build_local(
+        self, radios: RadioBrowser, item: MediaSourceItem
+    ) -> list[BrowseMediaSource]:
+        """Handle browsing local radio stations."""
+
+        if item.identifier == "local":
+            country = self.hass.config.country
+            stations = await radios.stations(
+                filter_by=FilterBy.COUNTRY_CODE_EXACT,
+                filter_term=country,
+                hide_broken=True,
+                order=Order.NAME,
+                reverse=False,
+            )
+
+            local_stations = await self.hass.async_add_executor_job(
+                self._filter_local_stations,
+                stations,
+                self.hass.config.latitude,
+                self.hass.config.longitude,
+            )
+
+            return self._async_build_stations(radios, local_stations)
+
+        if not item.identifier:
+            return [
+                BrowseMediaSource(
+                    domain=DOMAIN,
+                    identifier="local",
+                    media_class=MediaClass.DIRECTORY,
+                    media_content_type=MediaType.MUSIC,
+                    title="Local stations",
+                    can_play=False,
+                    can_expand=True,
+                )
+            ]
+
+        return []

homeassistant/components/rainbird/translations/fr.json

@@ -53,7 +53,8 @@
             "description": "D\u00e9finit la dur\u00e9e pendant laquelle l\u2019irrigation automatique est d\u00e9sactiv\u00e9e.",
             "fields": {
                 "config_entry_id": {
-                    "description": "L'entr\u00e9e de configuration du contr\u00f4leur pour lequel ajuster le param\u00e8tre."
+                    "description": "L'entr\u00e9e de configuration du contr\u00f4leur pour lequel ajuster le param\u00e8tre.",
+                    "name": "Contr\u00f4leur Rain Bird"
                 },
                 "duration": {
                     "description": "Dur\u00e9e pour que ce syst\u00e8me soit \u00e9teint.",

homeassistant/components/recorder/models/statistics.py

@@ -78,6 +78,7 @@ class CalendarStatisticPeriod(TypedDict, total=False):
 
     period: Literal["hour", "day", "week", "month", "year"]
     offset: int
+    first_weekday: Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
 
 
 class FixedStatisticPeriod(TypedDict, total=False):

homeassistant/components/recorder/services.py

@@ -89,8 +89,7 @@ SERVICE_GET_STATISTICS_SCHEMA = vol.Schema(
 
 async def _async_handle_purge_service(service: ServiceCall) -> None:
     """Handle calls to the purge service."""
-    hass = service.hass
-    instance = hass.data[DATA_INSTANCE]
+    instance = service.hass.data[DATA_INSTANCE]
     kwargs = service.data
     keep_days = kwargs.get(ATTR_KEEP_DAYS, instance.keep_days)
     repack = cast(bool, kwargs[ATTR_REPACK])
@@ -101,14 +100,15 @@ async def _async_handle_purge_service(service: ServiceCall) -> None:
 
 async def _async_handle_purge_entities_service(service: ServiceCall) -> None:
     """Handle calls to the purge entities service."""
-    hass = service.hass
-    entity_ids = await async_extract_entity_ids(hass, service)
+    entity_ids = await async_extract_entity_ids(service)
     domains = service.data.get(ATTR_DOMAINS, [])
     keep_days = service.data.get(ATTR_KEEP_DAYS, 0)
     entity_globs = service.data.get(ATTR_ENTITY_GLOBS, [])
     entity_filter = generate_filter(domains, list(entity_ids), [], [], entity_globs)
     purge_before = dt_util.utcnow() - timedelta(days=keep_days)
-    hass.data[DATA_INSTANCE].queue_task(PurgeEntitiesTask(entity_filter, purge_before))
+    service.hass.data[DATA_INSTANCE].queue_task(
+        PurgeEntitiesTask(entity_filter, purge_before)
+    )
 
 
 async def _async_handle_enable_service(service: ServiceCall) -> None:

homeassistant/components/recorder/statistics.py

@@ -46,6 +46,7 @@ from homeassistant.util.unit_conversion import (
     AreaConverter,
     BaseUnitConverter,
     BloodGlucoseConcentrationConverter,
+    CarbonMonoxideConcentrationConverter,
     ConductivityConverter,
     DataRateConverter,
     DistanceConverter,
@@ -204,6 +205,10 @@ STATISTIC_UNIT_TO_UNIT_CONVERTER: dict[str | None, type[BaseUnitConverter]] = {
     **dict.fromkeys(
         MassVolumeConcentrationConverter.VALID_UNITS, MassVolumeConcentrationConverter
     ),
+    **dict.fromkeys(
+        CarbonMonoxideConcentrationConverter.VALID_UNITS,
+        CarbonMonoxideConcentrationConverter,
+    ),
     **dict.fromkeys(ConductivityConverter.VALID_UNITS, ConductivityConverter),
     **dict.fromkeys(DataRateConverter.VALID_UNITS, DataRateConverter),
     **dict.fromkeys(DistanceConverter.VALID_UNITS, DistanceConverter),

homeassistant/components/recorder/util.py

@@ -27,6 +27,7 @@ from sqlalchemy.orm.session import Session
 from sqlalchemy.sql.lambdas import StatementLambdaElement
 import voluptuous as vol
 
+from homeassistant.const import WEEKDAYS
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
 from homeassistant.helpers.recorder import (  # noqa: F401
@@ -802,6 +803,7 @@ PERIOD_SCHEMA = vol.Schema(
             {
                 vol.Required("period"): vol.Any("hour", "day", "week", "month", "year"),
                 vol.Optional("offset"): int,
+                vol.Optional("first_weekday"): vol.Any(*WEEKDAYS),
             }
         ),
         vol.Exclusive("fixed_period", "period"): vol.Schema(
@@ -840,7 +842,12 @@ def resolve_period(
             start_time += timedelta(days=cal_offset)
             end_time = start_time + timedelta(days=1)
         elif calendar_period == "week":
-            start_time = start_of_day - timedelta(days=start_of_day.weekday())
+            first_weekday = WEEKDAYS.index(
+                period_def["calendar"].get("first_weekday", WEEKDAYS[0])
+            )
+            start_time = start_of_day - timedelta(
+                days=(start_of_day.weekday() - first_weekday) % 7
+            )
             start_time += timedelta(days=cal_offset * 7)
             end_time = start_time + timedelta(weeks=1)
         elif calendar_period == "month":

homeassistant/components/recorder/websocket_api.py

@@ -19,6 +19,7 @@ from homeassistant.util.unit_conversion import (
     ApparentPowerConverter,
     AreaConverter,
     BloodGlucoseConcentrationConverter,
+    CarbonMonoxideConcentrationConverter,
     ConductivityConverter,
     DataRateConverter,
     DistanceConverter,
@@ -66,6 +67,9 @@ UNIT_SCHEMA = vol.Schema(
         vol.Optional("blood_glucose_concentration"): vol.In(
             BloodGlucoseConcentrationConverter.VALID_UNITS
         ),
+        vol.Optional("carbon_monoxide"): vol.In(
+            CarbonMonoxideConcentrationConverter.VALID_UNITS
+        ),
         vol.Optional("concentration"): vol.In(
             MassVolumeConcentrationConverter.VALID_UNITS
         ),

homeassistant/components/renault/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["renault_api"],
   "quality_scale": "silver",
-  "requirements": ["renault-api==0.4.0"]
+  "requirements": ["renault-api==0.4.1"]
 }

homeassistant/components/reolink/__init__.py

@@ -322,7 +322,7 @@ async def async_remove_config_entry_device(
 ) -> bool:
     """Remove a device from a config entry."""
     host: ReolinkHost = config_entry.runtime_data.host
-    (device_uid, ch, is_chime) = get_device_uid_and_ch(device, host)
+    (_device_uid, ch, is_chime) = get_device_uid_and_ch(device, host)
 
     if is_chime:
         await host.api.get_state(cmd="GetDingDongList")
@@ -431,7 +431,9 @@ def migrate_entity_ids(
         if (DOMAIN, host.unique_id) in device.identifiers:
             remove_ids = True  # NVR/Hub in identifiers, keep that one, remove others
         for old_id in device.identifiers:
-            (old_device_uid, old_ch, old_is_chime) = get_device_uid_and_ch(old_id, host)
+            (old_device_uid, _old_ch, _old_is_chime) = get_device_uid_and_ch(
+                old_id, host
+            )
             if (
                 not old_device_uid
                 or old_device_uid[0] != host.unique_id

homeassistant/components/reolink/binary_sensor.py

@@ -74,21 +74,21 @@ BINARY_PUSH_SENSORS = (
     ),
     ReolinkBinarySensorEntityDescription(
         key=PERSON_DETECTION_TYPE,
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="person",
         value=lambda api, ch: api.ai_detected(ch, PERSON_DETECTION_TYPE),
         supported=lambda api, ch: api.ai_supported(ch, PERSON_DETECTION_TYPE),
     ),
     ReolinkBinarySensorEntityDescription(
         key=VEHICLE_DETECTION_TYPE,
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="vehicle",
         value=lambda api, ch: api.ai_detected(ch, VEHICLE_DETECTION_TYPE),
         supported=lambda api, ch: api.ai_supported(ch, VEHICLE_DETECTION_TYPE),
     ),
     ReolinkBinarySensorEntityDescription(
         key=PET_DETECTION_TYPE,
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="pet",
         value=lambda api, ch: api.ai_detected(ch, PET_DETECTION_TYPE),
         supported=lambda api, ch: (
@@ -98,14 +98,14 @@ BINARY_PUSH_SENSORS = (
     ),
     ReolinkBinarySensorEntityDescription(
         key=PET_DETECTION_TYPE,
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="animal",
         value=lambda api, ch: api.ai_detected(ch, PET_DETECTION_TYPE),
         supported=lambda api, ch: api.supported(ch, "ai_animal"),
     ),
     ReolinkBinarySensorEntityDescription(
         key=PACKAGE_DETECTION_TYPE,
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="package",
         value=lambda api, ch: api.ai_detected(ch, PACKAGE_DETECTION_TYPE),
         supported=lambda api, ch: api.ai_supported(ch, PACKAGE_DETECTION_TYPE),
@@ -120,7 +120,7 @@ BINARY_PUSH_SENSORS = (
     ),
     ReolinkBinarySensorEntityDescription(
         key="cry",
-        cmd_id=33,
+        cmd_id=[33, 600],
         translation_key="cry",
         value=lambda api, ch: api.ai_detected(ch, "cry"),
         supported=lambda api, ch: api.ai_supported(ch, "cry"),

homeassistant/components/reolink/entity.py

@@ -243,8 +243,45 @@ class ReolinkChannelCoordinatorEntity(ReolinkHostCoordinatorEntity):
         await super().async_will_remove_from_hass()
 
 
+class ReolinkHostChimeCoordinatorEntity(ReolinkHostCoordinatorEntity):
+    """Parent class for Reolink chime entities connected to a Host."""
+
+    def __init__(
+        self,
+        reolink_data: ReolinkData,
+        chime: Chime,
+        coordinator: DataUpdateCoordinator[None] | None = None,
+    ) -> None:
+        """Initialize ReolinkChimeCoordinatorEntity for a chime."""
+        super().__init__(reolink_data, coordinator)
+        self._channel = chime.channel
+        self._chime = chime
+
+        self._attr_unique_id = (
+            f"{self._host.unique_id}_chime{chime.dev_id}_{self.entity_description.key}"
+        )
+        via_dev_id = self._host.unique_id
+        self._dev_id = f"{self._host.unique_id}_chime{chime.dev_id}"
+
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._dev_id)},
+            via_device=(DOMAIN, via_dev_id),
+            name=chime.name,
+            model="Reolink Chime",
+            manufacturer=self._host.api.manufacturer,
+            sw_version=chime.sw_version,
+            serial_number=str(chime.dev_id),
+            configuration_url=self._conf_url,
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and self._chime.online
+
+
 class ReolinkChimeCoordinatorEntity(ReolinkChannelCoordinatorEntity):
-    """Parent class for Reolink chime entities connected."""
+    """Parent class for Reolink chime entities connected through a camera."""
 
     def __init__(
         self,
@@ -255,21 +292,21 @@ class ReolinkChimeCoordinatorEntity(ReolinkChannelCoordinatorEntity):
         """Initialize ReolinkChimeCoordinatorEntity for a chime."""
         assert chime.channel is not None
         super().__init__(reolink_data, chime.channel, coordinator)
-
         self._chime = chime
 
         self._attr_unique_id = (
             f"{self._host.unique_id}_chime{chime.dev_id}_{self.entity_description.key}"
         )
-        cam_dev_id = self._dev_id
+        via_dev_id = self._dev_id
         self._dev_id = f"{self._host.unique_id}_chime{chime.dev_id}"
 
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, self._dev_id)},
-            via_device=(DOMAIN, cam_dev_id),
+            via_device=(DOMAIN, via_dev_id),
             name=chime.name,
             model="Reolink Chime",
             manufacturer=self._host.api.manufacturer,
+            sw_version=chime.sw_version,
             serial_number=str(chime.dev_id),
             configuration_url=self._conf_url,
         )

homeassistant/components/reolink/icons.json

@@ -405,6 +405,12 @@
       "sub_bit_rate": {
         "default": "mdi:play-speed"
       },
+      "main_encoding": {
+        "default": "mdi:video-image"
+      },
+      "sub_encoding": {
+        "default": "mdi:video-image"
+      },
       "scene_mode": {
         "default": "mdi:view-list"
       },

homeassistant/components/reolink/light.py

@@ -7,9 +7,11 @@ from dataclasses import dataclass
 from typing import Any
 
 from reolink_aio.api import Host
+from reolink_aio.const import MAX_COLOR_TEMP, MIN_COLOR_TEMP
 
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS,
+    ATTR_COLOR_TEMP_KELVIN,
     ColorMode,
     LightEntity,
     LightEntityDescription,
@@ -37,8 +39,10 @@ class ReolinkLightEntityDescription(
     """A class that describes light entities."""
 
     get_brightness_fn: Callable[[Host, int], int | None] | None = None
+    get_color_temp_fn: Callable[[Host, int], int | None] | None = None
     is_on_fn: Callable[[Host, int], bool]
     set_brightness_fn: Callable[[Host, int, int], Any] | None = None
+    set_color_temp_fn: Callable[[Host, int, int], Any] | None = None
     turn_on_off_fn: Callable[[Host, int, bool], Any]
 
 
@@ -64,6 +68,10 @@ LIGHT_ENTITIES = (
         turn_on_off_fn=lambda api, ch, value: api.set_whiteled(ch, state=value),
         get_brightness_fn=lambda api, ch: api.whiteled_brightness(ch),
         set_brightness_fn=lambda api, ch, value: api.set_whiteled(ch, brightness=value),
+        get_color_temp_fn=lambda api, ch: api.whiteled_color_temperature(ch),
+        set_color_temp_fn=lambda api, ch, value: (
+            api.baichuan.set_floodlight(ch, color_temp=value)
+        ),
     ),
     ReolinkLightEntityDescription(
         key="status_led",
@@ -127,12 +135,20 @@ class ReolinkLightEntity(ReolinkChannelCoordinatorEntity, LightEntity):
         self.entity_description = entity_description
         super().__init__(reolink_data, channel)
 
-        if entity_description.set_brightness_fn is None:
-            self._attr_supported_color_modes = {ColorMode.ONOFF}
-            self._attr_color_mode = ColorMode.ONOFF
-        else:
+        if (
+            entity_description.set_color_temp_fn is not None
+            and self._host.api.supported(self._channel, "color_temp")
+        ):
+            self._attr_supported_color_modes = {ColorMode.COLOR_TEMP}
+            self._attr_color_mode = ColorMode.COLOR_TEMP
+            self._attr_min_color_temp_kelvin = MIN_COLOR_TEMP
+            self._attr_max_color_temp_kelvin = MAX_COLOR_TEMP
+        elif entity_description.set_brightness_fn is not None:
             self._attr_supported_color_modes = {ColorMode.BRIGHTNESS}
             self._attr_color_mode = ColorMode.BRIGHTNESS
+        else:
+            self._attr_supported_color_modes = {ColorMode.ONOFF}
+            self._attr_color_mode = ColorMode.ONOFF
 
     @property
     def is_on(self) -> bool:
@@ -152,6 +168,13 @@ class ReolinkLightEntity(ReolinkChannelCoordinatorEntity, LightEntity):
 
         return round(255 * bright_pct / 100.0)
 
+    @property
+    def color_temp_kelvin(self) -> int | None:
+        """Return the color temperature of this light in kelvin."""
+        assert self.entity_description.get_color_temp_fn is not None
+
+        return self.entity_description.get_color_temp_fn(self._host.api, self._channel)
+
     @raise_translated_error
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn light off."""
@@ -171,6 +194,13 @@ class ReolinkLightEntity(ReolinkChannelCoordinatorEntity, LightEntity):
                 self._host.api, self._channel, brightness_pct
             )
 
+        if (
+            color_temp := kwargs.get(ATTR_COLOR_TEMP_KELVIN)
+        ) is not None and self.entity_description.set_color_temp_fn is not None:
+            await self.entity_description.set_color_temp_fn(
+                self._host.api, self._channel, color_temp
+            )
+
         await self.entity_description.turn_on_off_fn(
             self._host.api, self._channel, True
         )

homeassistant/components/reolink/manifest.json

@@ -19,5 +19,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.15.0"]
+  "requirements": ["reolink-aio==0.15.2"]
 }