Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/builder.yml

@@ -15,7 +15,7 @@ env:
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
   # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2025.11.3"
+  BASE_IMAGE_VERSION: "2025.12.0"
   ARCHITECTURES: '["amd64", "aarch64"]'
 
 jobs:
@@ -70,7 +70,7 @@ jobs:
         run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
 
       - name: Upload translations
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: translations
           path: translations.tar.gz

.github/workflows/ci.yaml

@@ -534,7 +534,7 @@ jobs:
           python --version
           uv pip freeze >> pip_freeze.txt
       - name: Upload pip_freeze artifact
-        uses: &actions-upload-artifact actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: &actions-upload-artifact actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: pip-freeze-${{ matrix.python-version }}
           path: pip_freeze.txt

.github/workflows/wheels.yml

@@ -74,7 +74,7 @@ jobs:
           ) > .env_file
 
       - name: Upload env_file
-        uses: &actions-upload-artifact actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: &actions-upload-artifact actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
           name: env_file
           path: ./.env_file

CODEOWNERS

@@ -665,6 +665,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/here_travel_time/ @eifinger
 /tests/components/here_travel_time/ @eifinger
 /homeassistant/components/hikvision/ @mezz64
+/tests/components/hikvision/ @mezz64
 /homeassistant/components/hikvisioncam/ @fbradyirl
 /homeassistant/components/hisense_aehw4a1/ @bannhead
 /tests/components/hisense_aehw4a1/ @bannhead

Dockerfile

@@ -30,7 +30,7 @@ RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
     # Install uv
-    && pip3 install uv==0.9.6
+    && pip3 install uv==0.9.17
 
 WORKDIR /usr/src
 

homeassistant/bootstrap.py

@@ -624,13 +624,16 @@ async def async_enable_logging(
 
     if log_file is None:
         default_log_path = hass.config.path(ERROR_LOG_FILENAME)
-        if "SUPERVISOR" in os.environ:
-            _LOGGER.info("Running in Supervisor, not logging to file")
+        if "SUPERVISOR" in os.environ and "HA_DUPLICATE_LOG_FILE" not in os.environ:
             # Rename the default log file if it exists, since previous versions created
             # it even on Supervisor
-            if os.path.isfile(default_log_path):
-                with contextlib.suppress(OSError):
-                    os.rename(default_log_path, f"{default_log_path}.old")
+            def rename_old_file() -> None:
+                """Rename old log file in executor."""
+                if os.path.isfile(default_log_path):
+                    with contextlib.suppress(OSError):
+                        os.rename(default_log_path, f"{default_log_path}.old")
+
+            await hass.async_add_executor_job(rename_old_file)
             err_log_path = None
         else:
             err_log_path = default_log_path

homeassistant/components/actron_air/__init__.py

@@ -9,8 +9,9 @@ from actron_neo_api import (
 
 from homeassistant.const import CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
-from .const import _LOGGER
+from .const import _LOGGER, DOMAIN
 from .coordinator import (
     ActronAirConfigEntry,
     ActronAirRuntimeData,
@@ -29,12 +30,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
     try:
         systems = await api.get_ac_systems()
         await api.update_status()
-    except ActronAirAuthError:
-        _LOGGER.error("Authentication error while setting up Actron Air integration")
-        raise
+    except ActronAirAuthError as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="auth_error",
+        ) from err
     except ActronAirAPIError as err:
-        _LOGGER.error("API error while setting up Actron Air integration: %s", err)
-        raise
+        raise ConfigEntryNotReady from err
 
     system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
     for system in systems:

homeassistant/components/actron_air/config_flow.py

@@ -1,11 +1,12 @@
 """Setup config flow for Actron Air integration."""
 
 import asyncio
+from collections.abc import Mapping
 from typing import Any
 
 from actron_neo_api import ActronAirAPI, ActronAirAuthError
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_API_TOKEN
 from homeassistant.exceptions import HomeAssistantError
 
@@ -95,8 +96,16 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
 
         unique_id = str(user_data["id"])
         await self.async_set_unique_id(unique_id)
-        self._abort_if_unique_id_configured()
 
+        # Check if this is a reauth flow
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch(reason="wrong_account")
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(),
+                data_updates={CONF_API_TOKEN: self._api.refresh_token_value},
+            )
+
+        self._abort_if_unique_id_configured()
         return self.async_create_entry(
             title=user_data["email"],
             data={CONF_API_TOKEN: self._api.refresh_token_value},
@@ -114,6 +123,21 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
         del self.login_task
         return await self.async_step_user()
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication request."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm reauth dialog."""
+        if user_input is not None:
+            return await self.async_step_user()
+
+        return self.async_show_form(step_id="reauth_confirm")
+
     async def async_step_connection_error(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/actron_air/coordinator.py

@@ -5,16 +5,23 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import timedelta
 
-from actron_neo_api import ActronAirACSystem, ActronAirAPI, ActronAirStatus
+from actron_neo_api import (
+    ActronAirACSystem,
+    ActronAirAPI,
+    ActronAirAuthError,
+    ActronAirStatus,
+)
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
 
-from .const import _LOGGER
+from .const import _LOGGER, DOMAIN
 
-STALE_DEVICE_TIMEOUT = timedelta(hours=24)
+SCAN_INTERVAL = timedelta(seconds=30)
+STALE_DEVICE_TIMEOUT = timedelta(minutes=5)
 ERROR_NO_SYSTEMS_FOUND = "no_systems_found"
 ERROR_UNKNOWN = "unknown_error"
 
@@ -29,9 +36,6 @@ class ActronAirRuntimeData:
 
 type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
 
-AUTH_ERROR_THRESHOLD = 3
-SCAN_INTERVAL = timedelta(seconds=30)
-
 
 class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
     """System coordinator for Actron Air integration."""
@@ -59,7 +63,14 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
 
     async def _async_update_data(self) -> ActronAirStatus:
         """Fetch updates and merge incremental changes into the full state."""
-        await self.api.update_status()
+        try:
+            await self.api.update_status()
+        except ActronAirAuthError as err:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="auth_error",
+            ) from err
+
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
         return self.status

homeassistant/components/actron_air/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.1.87"]
+  "requirements": ["actron-neo-api==0.2.0"]
 }

homeassistant/components/actron_air/quality_scale.yaml

@@ -36,7 +36,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: todo
 
   # Gold

homeassistant/components/actron_air/strings.json

@@ -2,10 +2,12 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
-      "oauth2_error": "Failed to start OAuth2 flow"
+      "oauth2_error": "Failed to start authentication flow",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "wrong_account": "You must reauthenticate with the same Actron Air account that was originally configured."
     },
     "error": {
-      "oauth2_error": "Failed to start OAuth2 flow. Please try again later."
+      "oauth2_error": "Failed to start authentication flow. Please try again later."
     },
     "progress": {
       "wait_for_authorization": "To authenticate, open the following URL and login at Actron Air:\n{verification_uri}\nIf the code is not automatically copied, paste the following code to authorize the integration:\n\n```{user_code}```\n\n\nThe login attempt will time out after {expires_minutes} minutes."
@@ -16,14 +18,23 @@
         "description": "Failed to connect to Actron Air. Please check your internet connection and try again.",
         "title": "Connection error"
       },
+      "reauth_confirm": {
+        "description": "Your Actron Air authentication has expired. Select continue to reauthenticate with your Actron Air account. You will be prompted to log in again to restore the connection.",
+        "title": "Authentication expired"
+      },
       "timeout": {
         "data": {},
-        "description": "The authorization process timed out. Please try again.",
-        "title": "Authorization timeout"
+        "description": "The authentication process timed out. Please try again.",
+        "title": "Authentication timeout"
       },
       "user": {
-        "title": "Actron Air OAuth2 Authorization"
+        "title": "Actron Air Authentication"
       }
     }
+  },
+  "exceptions": {
+    "auth_error": {
+      "message": "Authentication failed, please reauthenticate"
+    }
   }
 }

homeassistant/components/alarm_control_panel/trigger.py

@@ -4,10 +4,10 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.trigger import (
-    EntityStateTriggerBase,
+    EntityTargetStateTriggerBase,
     Trigger,
-    make_conditional_entity_state_trigger,
-    make_entity_state_trigger,
+    make_entity_target_state_trigger,
+    make_entity_transition_trigger,
 )
 
 from .const import DOMAIN, AlarmControlPanelEntityFeature, AlarmControlPanelState
@@ -21,7 +21,7 @@ def supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool
         return False
 
 
-class EntityStateTriggerRequiredFeatures(EntityStateTriggerBase):
+class EntityStateTriggerRequiredFeatures(EntityTargetStateTriggerBase):
     """Trigger for entity state changes."""
 
     _required_features: int
@@ -38,7 +38,7 @@ class EntityStateTriggerRequiredFeatures(EntityStateTriggerBase):
 
 def make_entity_state_trigger_required_features(
     domain: str, to_state: str, required_features: int
-) -> type[EntityStateTriggerBase]:
+) -> type[EntityTargetStateTriggerBase]:
     """Create an entity state trigger class."""
 
     class CustomTrigger(EntityStateTriggerRequiredFeatures):
@@ -52,7 +52,7 @@ def make_entity_state_trigger_required_features(
 
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "armed": make_conditional_entity_state_trigger(
+    "armed": make_entity_transition_trigger(
         DOMAIN,
         from_states={
             AlarmControlPanelState.ARMING,
@@ -89,8 +89,12 @@ TRIGGERS: dict[str, type[Trigger]] = {
         AlarmControlPanelState.ARMED_VACATION,
         AlarmControlPanelEntityFeature.ARM_VACATION,
     ),
-    "disarmed": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.DISARMED),
-    "triggered": make_entity_state_trigger(DOMAIN, AlarmControlPanelState.TRIGGERED),
+    "disarmed": make_entity_target_state_trigger(
+        DOMAIN, AlarmControlPanelState.DISARMED
+    ),
+    "triggered": make_entity_target_state_trigger(
+        DOMAIN, AlarmControlPanelState.TRIGGERED
+    ),
 }
 
 

homeassistant/components/apcupsd/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@yuxincs"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/apcupsd",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["apcaccess"],
   "quality_scale": "platinum",

homeassistant/components/assist_satellite/trigger.py

@@ -1,16 +1,22 @@
 """Provides triggers for assist satellites."""
 
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
 
 from .const import DOMAIN
 from .entity import AssistSatelliteState
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "idle": make_entity_state_trigger(DOMAIN, AssistSatelliteState.IDLE),
-    "listening": make_entity_state_trigger(DOMAIN, AssistSatelliteState.LISTENING),
-    "processing": make_entity_state_trigger(DOMAIN, AssistSatelliteState.PROCESSING),
-    "responding": make_entity_state_trigger(DOMAIN, AssistSatelliteState.RESPONDING),
+    "idle": make_entity_target_state_trigger(DOMAIN, AssistSatelliteState.IDLE),
+    "listening": make_entity_target_state_trigger(
+        DOMAIN, AssistSatelliteState.LISTENING
+    ),
+    "processing": make_entity_target_state_trigger(
+        DOMAIN, AssistSatelliteState.PROCESSING
+    ),
+    "responding": make_entity_target_state_trigger(
+        DOMAIN, AssistSatelliteState.RESPONDING
+    ),
 }
 
 

homeassistant/components/autarco/manifest.json

@@ -4,6 +4,8 @@
   "codeowners": ["@klaasnicolaas"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/autarco",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
+  "quality_scale": "silver",
   "requirements": ["autarco==3.2.0"]
 }

homeassistant/components/automation/__init__.py

@@ -125,14 +125,18 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
     "binary_sensor",
+    "button",
     "climate",
     "cover",
+    "device_tracker",
     "fan",
     "lawn_mower",
     "light",
+    "lock",
     "media_player",
     "switch",
     "text",
+    "update",
     "vacuum",
 }
 

homeassistant/components/binary_sensor/trigger.py

@@ -4,7 +4,7 @@ from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity import get_device_class
-from homeassistant.helpers.trigger import EntityStateTriggerBase, Trigger
+from homeassistant.helpers.trigger import EntityTargetStateTriggerBase, Trigger
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 
 from . import DOMAIN, BinarySensorDeviceClass
@@ -20,7 +20,7 @@ def get_device_class_or_undefined(
         return UNDEFINED
 
 
-class BinarySensorOnOffTrigger(EntityStateTriggerBase):
+class BinarySensorOnOffTrigger(EntityTargetStateTriggerBase):
     """Class for binary sensor on/off triggers."""
 
     _device_class: BinarySensorDeviceClass | None

homeassistant/components/button/icons.json

@@ -17,5 +17,10 @@
     "press": {
       "service": "mdi:gesture-tap-button"
     }
+  },
+  "triggers": {
+    "pressed": {
+      "trigger": "mdi:gesture-tap-button"
+    }
   }
 }

homeassistant/components/button/strings.json

@@ -27,5 +27,11 @@
       "name": "Press"
     }
   },
-  "title": "Button"
+  "title": "Button",
+  "triggers": {
+    "pressed": {
+      "description": "Triggers when a button was pressed",
+      "name": "Button pressed"
+    }
+  }
 }

homeassistant/components/button/trigger.py

@@ -0,0 +1,42 @@
+"""Provides triggers for buttons."""
+
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+)
+
+from . import DOMAIN
+
+
+class ButtonPressedTrigger(EntityTriggerBase):
+    """Trigger for button entity presses."""
+
+    _domain = DOMAIN
+    _schema = ENTITY_STATE_TRIGGER_SCHEMA
+
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and different from the current state."""
+
+        # UNKNOWN is a valid from_state, otherwise the first time the button is pressed
+        # would not trigger
+        if from_state.state == STATE_UNAVAILABLE:
+            return False
+
+        return from_state.state != to_state.state
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the new state is not invalid."""
+        return state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "pressed": ButtonPressedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for buttons."""
+    return TRIGGERS

homeassistant/components/button/triggers.yaml

@@ -0,0 +1,4 @@
+pressed:
+  target:
+    entity:
+      domain: button

homeassistant/components/climate/trigger.py

@@ -3,22 +3,22 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.trigger import (
     Trigger,
-    make_conditional_entity_state_trigger,
-    make_entity_state_attribute_trigger,
-    make_entity_state_trigger,
+    make_entity_target_state_attribute_trigger,
+    make_entity_target_state_trigger,
+    make_entity_transition_trigger,
 )
 
 from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "started_cooling": make_entity_state_attribute_trigger(
+    "started_cooling": make_entity_target_state_attribute_trigger(
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
     ),
-    "started_drying": make_entity_state_attribute_trigger(
+    "started_drying": make_entity_target_state_attribute_trigger(
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
     ),
-    "turned_off": make_entity_state_trigger(DOMAIN, HVACMode.OFF),
-    "turned_on": make_conditional_entity_state_trigger(
+    "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
+    "turned_on": make_entity_transition_trigger(
         DOMAIN,
         from_states={
             HVACMode.OFF,
@@ -32,7 +32,7 @@ TRIGGERS: dict[str, type[Trigger]] = {
             HVACMode.HEAT_COOL,
         },
     ),
-    "started_heating": make_entity_state_attribute_trigger(
+    "started_heating": make_entity_target_state_attribute_trigger(
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
     ),
 }

homeassistant/components/compit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["compit"],
   "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.3.1"]
+  "requirements": ["compit-inext-api==0.3.4"]
 }

homeassistant/components/config/area_registry.py

@@ -65,8 +65,10 @@ def websocket_create_area(
     data.pop("id")
 
     if "aliases" in data:
-        # Convert aliases to a set
-        data["aliases"] = set(data["aliases"])
+        # Create a set for the aliases without:
+        #   - Empty strings
+        #   - Trailing and leading whitespace characters in the individual aliases
+        data["aliases"] = {s_strip for s in data["aliases"] if (s_strip := s.strip())}
 
     if "labels" in data:
         # Convert labels to a set
@@ -133,8 +135,10 @@ def websocket_update_area(
     data.pop("id")
 
     if "aliases" in data:
-        # Convert aliases to a set
-        data["aliases"] = set(data["aliases"])
+        # Create a set for the aliases without:
+        #   - Empty strings
+        #   - Trailing and leading whitespace characters in the individual aliases
+        data["aliases"] = {s_strip for s in data["aliases"] if (s_strip := s.strip())}
 
     if "labels" in data:
         # Convert labels to a set

homeassistant/components/config/entity_registry.py

@@ -227,8 +227,10 @@ def websocket_update_entity(
             changes[key] = msg[key]
 
     if "aliases" in msg:
-        # Convert aliases to a set
-        changes["aliases"] = set(msg["aliases"])
+        # Create a set for the aliases without:
+        #   - Empty strings
+        #   - Trailing and leading whitespace characters in the individual aliases
+        changes["aliases"] = {s_strip for s in msg["aliases"] if (s_strip := s.strip())}
 
     if "labels" in msg:
         # Convert labels to a set

homeassistant/components/config/floor_registry.py

@@ -61,8 +61,10 @@ def websocket_create_floor(
     data.pop("id")
 
     if "aliases" in data:
-        # Convert aliases to a set
-        data["aliases"] = set(data["aliases"])
+        # Create a set for the aliases without:
+        #   - Empty strings
+        #   - Trailing and leading whitespace characters in the individual aliases
+        data["aliases"] = {s_strip for s in data["aliases"] if (s_strip := s.strip())}
 
     try:
         entry = registry.async_create(**data)
@@ -117,8 +119,10 @@ def websocket_update_floor(
     data.pop("id")
 
     if "aliases" in data:
-        # Convert aliases to a set
-        data["aliases"] = set(data["aliases"])
+        # Create a set for the aliases without:
+        #   - Empty strings
+        #   - Trailing and leading whitespace characters in the individual aliases
+        data["aliases"] = {s_strip for s in data["aliases"] if (s_strip := s.strip())}
 
     try:
         entry = registry.async_update(**data)

homeassistant/components/coolmaster/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@OnFreund"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/coolmaster",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["pycoolmasternet_async"],
   "requirements": ["pycoolmasternet-async==0.2.2"]

homeassistant/components/device_automation/condition.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Protocol
+from typing import Any, Protocol
 
 import voluptuous as vol
 
@@ -11,18 +11,15 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.condition import (
     Condition,
+    ConditionChecker,
     ConditionCheckerType,
     ConditionConfig,
-    trace_condition_function,
 )
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
 from . import DeviceAutomationType, async_get_device_automation_platform
 from .helpers import async_validate_device_automation_config
 
-if TYPE_CHECKING:
-    from homeassistant.helpers import condition
-
 
 class DeviceAutomationConditionProtocol(Protocol):
     """Define the format of device_condition modules.
@@ -90,15 +87,21 @@ class DeviceCondition(Condition):
         assert config.options is not None
         self._config = config.options
 
-    async def async_get_checker(self) -> condition.ConditionCheckerType:
+    async def async_get_checker(self) -> ConditionChecker:
         """Test a device condition."""
         platform = await async_get_device_automation_platform(
             self._hass, self._config[CONF_DOMAIN], DeviceAutomationType.CONDITION
         )
-        return trace_condition_function(
-            platform.async_condition_from_config(self._hass, self._config)
+        platform_checker = platform.async_condition_from_config(
+            self._hass, self._config
         )
 
+        def checker(variables: TemplateVarsType = None, **kwargs: Any) -> bool:
+            result = platform_checker(self._hass, variables)
+            return result is not False
+
+        return checker
+
 
 CONDITIONS: dict[str, type[Condition]] = {
     "_device": DeviceCondition,

homeassistant/components/device_tracker/icons.json

@@ -11,5 +11,13 @@
     "see": {
       "service": "mdi:account-eye"
     }
+  },
+  "triggers": {
+    "entered_home": {
+      "trigger": "mdi:account-arrow-left"
+    },
+    "left_home": {
+      "trigger": "mdi:account-arrow-right"
+    }
   }
 }

homeassistant/components/device_tracker/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted device trackers to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "device_automation": {
     "condition_type": {
       "is_home": "{entity_name} is home",
@@ -44,6 +48,15 @@
       }
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "see": {
       "description": "Manually update the records of a seen legacy device tracker in the known_devices.yaml file.",
@@ -80,5 +93,27 @@
       "name": "See"
     }
   },
-  "title": "Device tracker"
+  "title": "Device tracker",
+  "triggers": {
+    "entered_home": {
+      "description": "Triggers when one or more device trackers enter home.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::device_tracker::common::trigger_behavior_description%]",
+          "name": "[%key:component::device_tracker::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Entered home"
+    },
+    "left_home": {
+      "description": "Triggers when one or more device trackers leave home.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::device_tracker::common::trigger_behavior_description%]",
+          "name": "[%key:component::device_tracker::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Left home"
+    }
+  }
 }

homeassistant/components/device_tracker/trigger.py

@@ -0,0 +1,21 @@
+"""Provides triggers for device_trackers."""
+
+from homeassistant.const import STATE_HOME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import (
+    Trigger,
+    make_entity_origin_state_trigger,
+    make_entity_target_state_trigger,
+)
+
+from .const import DOMAIN
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "entered_home": make_entity_target_state_trigger(DOMAIN, STATE_HOME),
+    "left_home": make_entity_origin_state_trigger(DOMAIN, from_state=STATE_HOME),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for device trackers."""
+    return TRIGGERS

homeassistant/components/device_tracker/triggers.yaml

@@ -0,0 +1,18 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: device_tracker
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+entered_home: *trigger_common
+left_home: *trigger_common

homeassistant/components/directv/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/directv",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["directv"],
   "requirements": ["directv==0.4.0"],

homeassistant/components/dnsip/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/dnsip",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["aiodns==3.6.0"]
+  "requirements": ["aiodns==3.6.1"]
 }

homeassistant/components/duke_energy/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["recorder"],
   "documentation": "https://www.home-assistant.io/integrations/duke_energy",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "requirements": ["aiodukeenergy==0.3.0"]
 }

homeassistant/components/ekeybionyx/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["ekey-bionyxpy==1.0.0"]
+  "requirements": ["ekey-bionyxpy==1.0.1"]
 }

homeassistant/components/enphase_envoy/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bdraco", "@cgarwood", "@catsmanac"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/enphase_envoy",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",

homeassistant/components/fan/trigger.py

@@ -2,13 +2,13 @@
 
 from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.trigger import Trigger, make_entity_state_trigger
+from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
 
 from . import DOMAIN
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "turned_off": make_entity_state_trigger(DOMAIN, STATE_OFF),
-    "turned_on": make_entity_state_trigger(DOMAIN, STATE_ON),
+    "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
+    "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
 }
 
 

homeassistant/components/fjaraskupan/manifest.json

@@ -12,6 +12,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/fjaraskupan",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["bleak", "fjaraskupan"],
   "requirements": ["fjaraskupan==2.3.3"]

homeassistant/components/fully_kiosk/number.py

@@ -17,7 +17,7 @@ ENTITY_TYPES: tuple[NumberEntityDescription, ...] = (
     NumberEntityDescription(
         key="timeToScreensaverV2",
         translation_key="screensaver_time",
-        native_max_value=9999,
+        native_max_value=86400,
         native_step=1,
         native_min_value=0,
         native_unit_of_measurement=UnitOfTime.SECONDS,
@@ -34,7 +34,7 @@ ENTITY_TYPES: tuple[NumberEntityDescription, ...] = (
     NumberEntityDescription(
         key="timeToScreenOffV2",
         translation_key="screen_off_time",
-        native_max_value=9999,
+        native_max_value=86400,
         native_step=1,
         native_min_value=0,
         native_unit_of_measurement=UnitOfTime.SECONDS,

homeassistant/components/gentex_homelink/config_flow.py

@@ -5,6 +5,7 @@ from typing import Any
 
 import botocore.exceptions
 from homelink.auth.srp_auth import SRPAuth
+import jwt
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlowResult
@@ -38,8 +39,6 @@ class SRPFlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
         """Ask for username and password."""
         errors: dict[str, str] = {}
         if user_input is not None:
-            self._async_abort_entries_match({CONF_EMAIL: user_input[CONF_EMAIL]})
-
             srp_auth = SRPAuth()
             try:
                 tokens = await self.hass.async_add_executor_job(
@@ -48,12 +47,17 @@ class SRPFlowHandler(AbstractOAuth2FlowHandler, domain=DOMAIN):
                     user_input[CONF_PASSWORD],
                 )
             except botocore.exceptions.ClientError:
-                _LOGGER.exception("Error authenticating homelink account")
                 errors["base"] = "srp_auth_failed"
             except Exception:
                 _LOGGER.exception("An unexpected error occurred")
                 errors["base"] = "unknown"
             else:
+                access_token = jwt.decode(
+                    tokens["AuthenticationResult"]["AccessToken"],
+                    options={"verify_signature": False},
+                )
+                await self.async_set_unique_id(access_token["sub"])
+                self._abort_if_unique_id_configured()
                 self.external_data = {"tokens": tokens}
                 return await self.async_step_creation()
 

homeassistant/components/gentex_homelink/coordinator.py

@@ -1,10 +1,9 @@
-"""Makes requests to the state server and stores the resulting data so that the buttons can access it."""
+"""Establish MQTT connection and listen for event data."""
 
 from __future__ import annotations
 
 from collections.abc import Callable
 from functools import partial
-import logging
 from typing import TypedDict
 
 from homelink.model.device import Device
@@ -14,8 +13,6 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.util.ssl import get_default_context
 
-_LOGGER = logging.getLogger(__name__)
-
 type HomeLinkConfigEntry = ConfigEntry[HomeLinkCoordinator]
 type EventCallback = Callable[[HomeLinkEventData], None]
 

homeassistant/components/gios/config_flow.py

@@ -54,7 +54,11 @@ class GiosFlowHandler(ConfigFlow, domain=DOMAIN):
 
                 return self.async_create_entry(
                     title=gios.station_name,
-                    data=user_input,
+                    # CONF_NAME is still used, but its value is preserved
+                    # primarily for backward compatibility. This allows older
+                    # versions of the software to read the entry data without
+                    # raising errors.
+                    data={**user_input, CONF_NAME: gios.station_name},
                 )
             except (ApiError, ClientConnectorError, TimeoutError):
                 errors["base"] = "cannot_connect"
@@ -79,8 +83,7 @@ class GiosFlowHandler(ConfigFlow, domain=DOMAIN):
                         sort=True,
                         mode=SelectSelectorMode.DROPDOWN,
                     ),
-                ),
-                vol.Optional(CONF_NAME, default=self.hass.config.location_name): str,
+                )
             }
         )
 

homeassistant/components/gios/coordinator.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 from dataclasses import dataclass
 import logging
+from typing import TYPE_CHECKING
 
 from aiohttp.client_exceptions import ClientConnectorError
 from gios import Gios
@@ -12,10 +13,12 @@ from gios.exceptions import GiosError
 from gios.model import GiosSensors
 
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import API_TIMEOUT, DOMAIN, SCAN_INTERVAL
+from .const import API_TIMEOUT, DOMAIN, MANUFACTURER, SCAN_INTERVAL, URL
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,6 +54,21 @@ class GiosDataUpdateCoordinator(DataUpdateCoordinator[GiosSensors]):
             update_interval=SCAN_INTERVAL,
         )
 
+        station_id = gios.station_id
+        if TYPE_CHECKING:
+            # Station ID is Optional in the library, but here we know it is set for sure
+            # so we can safely assert it is not None for type checking purposes
+            # Gios instance is created only with a valid station ID in the async_setup_entry.
+            assert station_id is not None
+
+        self.device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={(DOMAIN, str(station_id))},
+            manufacturer=MANUFACTURER,
+            name=config_entry.data[CONF_NAME],
+            configuration_url=URL.format(station_id=station_id),
+        )
+
     async def _async_update_data(self) -> GiosSensors:
         """Update data via library."""
         try:

homeassistant/components/gios/sensor.py

@@ -15,10 +15,9 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import CONCENTRATION_MICROGRAMS_PER_CUBIC_METER, CONF_NAME
+from homeassistant.const import CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -36,8 +35,6 @@ from .const import (
     ATTR_SO2,
     ATTRIBUTION,
     DOMAIN,
-    MANUFACTURER,
-    URL,
 )
 from .coordinator import GiosConfigEntry, GiosDataUpdateCoordinator
 
@@ -184,8 +181,6 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Add a GIOS entities from a config_entry."""
-    name = entry.data[CONF_NAME]
-
     coordinator = entry.runtime_data.coordinator
     # Due to the change of the attribute name of one sensor, it is necessary to migrate
     # the unique_id to the new name.
@@ -208,7 +203,7 @@ async def async_setup_entry(
     for description in SENSOR_TYPES:
         if getattr(coordinator.data, description.key) is None:
             continue
-        sensors.append(GiosSensor(name, coordinator, description))
+        sensors.append(GiosSensor(coordinator, description))
 
     async_add_entities(sensors)
 
@@ -222,19 +217,13 @@ class GiosSensor(CoordinatorEntity[GiosDataUpdateCoordinator], SensorEntity):
 
     def __init__(
         self,
-        name: str,
         coordinator: GiosDataUpdateCoordinator,
         description: GiosSensorEntityDescription,
     ) -> None:
         """Initialize."""
         super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, str(coordinator.gios.station_id))},
-            manufacturer=MANUFACTURER,
-            name=name,
-            configuration_url=URL.format(station_id=coordinator.gios.station_id),
-        )
+
+        self._attr_device_info = coordinator.device_info
         if description.subkey:
             self._attr_unique_id = (
                 f"{coordinator.gios.station_id}-{description.key}-{description.subkey}"

homeassistant/components/gios/strings.json

@@ -11,11 +11,9 @@
     "step": {
       "user": {
         "data": {
-          "name": "[%key:common::config_flow::data::name%]",
           "station_id": "Measuring station"
         },
         "data_description": {
-          "name": "Config entry name, by default, this is the name of your Home Assistant instance.",
           "station_id": "The name of the measuring station where the environmental data is collected."
         },
         "title": "GIO\u015a (Polish Chief Inspectorate Of Environmental Protection)"

homeassistant/components/goodwe/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@mletenay", "@starkillerOG"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/goodwe",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["goodwe"],
   "requirements": ["goodwe==0.4.8"]

homeassistant/components/google_photos/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["application_credentials"],
   "documentation": "https://www.home-assistant.io/integrations/google_photos",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["google_photos_library_api"],
   "requirements": ["google-photos-library-api==0.12.1"]

homeassistant/components/google_tasks/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["application_credentials"],
   "documentation": "https://www.home-assistant.io/integrations/google_tasks",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "requirements": ["google-api-python-client==2.71.0"]
 }

homeassistant/components/google_travel_time/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@eifinger"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/google_travel_time",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["google", "homeassistant.helpers.location"],
   "requirements": ["google-maps-routing==0.6.15"]

homeassistant/components/govee_ble/manifest.json

@@ -138,6 +138,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/govee_ble",
+  "integration_type": "device",
   "iot_class": "local_push",
   "requirements": ["govee-ble==0.44.0"]
 }

homeassistant/components/growatt_server/__init__.py

@@ -10,6 +10,8 @@ from requests import RequestException
 from homeassistant.const import CONF_PASSWORD, CONF_TOKEN, CONF_URL, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryError
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
 from .const import (
     AUTH_API_TOKEN,
@@ -19,14 +21,25 @@ from .const import (
     DEFAULT_PLANT_ID,
     DEFAULT_URL,
     DEPRECATED_URLS,
+    DOMAIN,
     LOGIN_INVALID_AUTH_CODE,
     PLATFORMS,
 )
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
 from .models import GrowattRuntimeData
+from .services import async_register_services
 
 _LOGGER = logging.getLogger(__name__)
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Growatt Server component."""
+    # Register services
+    await async_register_services(hass)
+    return True
+
 
 def get_device_list_classic(
     api: growattServer.GrowattApi, config: Mapping[str, str]

homeassistant/components/growatt_server/const.py

@@ -46,3 +46,8 @@ ERROR_INVALID_AUTH = "invalid_auth"
 
 # Config flow abort reasons
 ABORT_NO_PLANTS = "no_plants"
+
+# Battery modes for TOU (Time of Use) settings
+BATT_MODE_LOAD_FIRST = 0
+BATT_MODE_BATTERY_FIRST = 1
+BATT_MODE_GRID_FIRST = 2

homeassistant/components/growatt_server/coordinator.py

@@ -12,10 +12,17 @@ import growattServer
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
-from .const import DEFAULT_URL, DOMAIN
+from .const import (
+    BATT_MODE_BATTERY_FIRST,
+    BATT_MODE_GRID_FIRST,
+    BATT_MODE_LOAD_FIRST,
+    DEFAULT_URL,
+    DOMAIN,
+)
 from .models import GrowattRuntimeData
 
 if TYPE_CHECKING:
@@ -247,3 +254,134 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self.previous_values[variable] = return_value
 
         return return_value
+
+    async def update_time_segment(
+        self, segment_id: int, batt_mode: int, start_time, end_time, enabled: bool
+    ) -> None:
+        """Update an inverter time segment.
+
+        Args:
+            segment_id: Time segment ID (1-9)
+            batt_mode: Battery mode (0=load first, 1=battery first, 2=grid first)
+            start_time: Start time (datetime.time object)
+            end_time: End time (datetime.time object)
+            enabled: Whether the segment is enabled
+        """
+        _LOGGER.debug(
+            "Updating time segment %d for device %s (mode=%d, %s-%s, enabled=%s)",
+            segment_id,
+            self.device_id,
+            batt_mode,
+            start_time,
+            end_time,
+            enabled,
+        )
+
+        if self.api_version != "v1":
+            raise ServiceValidationError(
+                "Updating time segments requires token authentication"
+            )
+
+        try:
+            # Use V1 API for token authentication
+            # The library's _process_response will raise GrowattV1ApiError if error_code != 0
+            await self.hass.async_add_executor_job(
+                self.api.min_write_time_segment,
+                self.device_id,
+                segment_id,
+                batt_mode,
+                start_time,
+                end_time,
+                enabled,
+            )
+        except growattServer.GrowattV1ApiError as err:
+            raise HomeAssistantError(f"API error updating time segment: {err}") from err
+
+        # Update coordinator's cached data without making an API call (avoids rate limit)
+        if self.data:
+            # Update the time segment data in the cache
+            self.data[f"forcedTimeStart{segment_id}"] = start_time.strftime("%H:%M")
+            self.data[f"forcedTimeStop{segment_id}"] = end_time.strftime("%H:%M")
+            self.data[f"time{segment_id}Mode"] = batt_mode
+            self.data[f"forcedStopSwitch{segment_id}"] = 1 if enabled else 0
+
+            # Notify entities of the updated data (no API call)
+            self.async_set_updated_data(self.data)
+
+    async def read_time_segments(self) -> list[dict]:
+        """Read time segments from an inverter.
+
+        Returns:
+            List of dictionaries containing segment information
+        """
+        _LOGGER.debug("Reading time segments for device %s", self.device_id)
+
+        if self.api_version != "v1":
+            raise ServiceValidationError(
+                "Reading time segments requires token authentication"
+            )
+
+        # Ensure we have current data
+        if not self.data:
+            _LOGGER.debug("Coordinator data not available, triggering refresh")
+            await self.async_refresh()
+
+        time_segments = []
+
+        # Extract time segments from coordinator data
+        for i in range(1, 10):  # Segments 1-9
+            segment = self._parse_time_segment(i)
+            time_segments.append(segment)
+
+        return time_segments
+
+    def _parse_time_segment(self, segment_id: int) -> dict:
+        """Parse a single time segment from coordinator data."""
+        # Get raw time values - these should always be present from the API
+        start_time_raw = self.data.get(f"forcedTimeStart{segment_id}")
+        end_time_raw = self.data.get(f"forcedTimeStop{segment_id}")
+
+        # Handle 'null' or empty values from API
+        if start_time_raw in ("null", None, ""):
+            start_time_raw = "0:0"
+        if end_time_raw in ("null", None, ""):
+            end_time_raw = "0:0"
+
+        # Format times with leading zeros (HH:MM)
+        start_time = self._format_time(str(start_time_raw))
+        end_time = self._format_time(str(end_time_raw))
+
+        # Get battery mode
+        batt_mode_int = int(
+            self.data.get(f"time{segment_id}Mode", BATT_MODE_LOAD_FIRST)
+        )
+
+        # Map numeric mode to string key (matches update_time_segment input format)
+        mode_map = {
+            BATT_MODE_LOAD_FIRST: "load_first",
+            BATT_MODE_BATTERY_FIRST: "battery_first",
+            BATT_MODE_GRID_FIRST: "grid_first",
+        }
+        batt_mode = mode_map.get(batt_mode_int, "load_first")
+
+        # Get enabled status
+        enabled = bool(int(self.data.get(f"forcedStopSwitch{segment_id}", 0)))
+
+        return {
+            "segment_id": segment_id,
+            "start_time": start_time,
+            "end_time": end_time,
+            "batt_mode": batt_mode,
+            "enabled": enabled,
+        }
+
+    def _format_time(self, time_raw: str) -> str:
+        """Format time string to HH:MM format."""
+        try:
+            parts = str(time_raw).split(":")
+            hour = int(parts[0])
+            minute = int(parts[1])
+        except (ValueError, IndexError):
+            return "00:00"
+        else:
+            return f"{hour:02d}:{minute:02d}"

homeassistant/components/growatt_server/icons.json

@@ -0,0 +1,10 @@
+{
+  "services": {
+    "read_time_segments": {
+      "service": "mdi:clock-outline"
+    },
+    "update_time_segment": {
+      "service": "mdi:clock-edit"
+    }
+  }
+}

homeassistant/components/growatt_server/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@johanzander"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/growatt_server",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["growattServer"],
   "requirements": ["growattServer==1.7.1"]

homeassistant/components/growatt_server/services.py

@@ -0,0 +1,169 @@
+"""Service handlers for Growatt Server integration."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers import device_registry as dr
+
+from .const import (
+    BATT_MODE_BATTERY_FIRST,
+    BATT_MODE_GRID_FIRST,
+    BATT_MODE_LOAD_FIRST,
+    DOMAIN,
+)
+
+if TYPE_CHECKING:
+    from .coordinator import GrowattCoordinator
+
+
+async def async_register_services(hass: HomeAssistant) -> None:
+    """Register services for Growatt Server integration."""
+
+    def get_min_coordinators() -> dict[str, GrowattCoordinator]:
+        """Get all MIN coordinators with V1 API from loaded config entries."""
+        min_coordinators: dict[str, GrowattCoordinator] = {}
+
+        for entry in hass.config_entries.async_entries(DOMAIN):
+            if entry.state != ConfigEntryState.LOADED:
+                continue
+
+            # Add MIN coordinators from this entry
+            for coord in entry.runtime_data.devices.values():
+                if coord.device_type == "min" and coord.api_version == "v1":
+                    min_coordinators[coord.device_id] = coord
+
+        return min_coordinators
+
+    def get_coordinator(device_id: str) -> GrowattCoordinator:
+        """Get coordinator by device_id.
+
+        Args:
+            device_id: Device registry ID (not serial number)
+        """
+        # Get current coordinators (they may have changed since service registration)
+        min_coordinators = get_min_coordinators()
+
+        if not min_coordinators:
+            raise ServiceValidationError(
+                "No MIN devices with token authentication are configured. "
+                "Services require MIN devices with V1 API access."
+            )
+
+        # Device registry ID provided - map to serial number
+        device_registry = dr.async_get(hass)
+        device_entry = device_registry.async_get(device_id)
+
+        if not device_entry:
+            raise ServiceValidationError(f"Device '{device_id}' not found")
+
+        # Extract serial number from device identifiers
+        serial_number = None
+        for identifier in device_entry.identifiers:
+            if identifier[0] == DOMAIN:
+                serial_number = identifier[1]
+                break
+
+        if not serial_number:
+            raise ServiceValidationError(
+                f"Device '{device_id}' is not a Growatt device"
+            )
+
+        # Find coordinator by serial number
+        if serial_number not in min_coordinators:
+            raise ServiceValidationError(
+                f"MIN device '{serial_number}' not found or not configured for services"
+            )
+
+        return min_coordinators[serial_number]
+
+    async def handle_update_time_segment(call: ServiceCall) -> None:
+        """Handle update_time_segment service call."""
+        segment_id: int = int(call.data["segment_id"])
+        batt_mode_str: str = call.data["batt_mode"]
+        start_time_str: str = call.data["start_time"]
+        end_time_str: str = call.data["end_time"]
+        enabled: bool = call.data["enabled"]
+        device_id: str = call.data["device_id"]
+
+        # Validate segment_id range
+        if not 1 <= segment_id <= 9:
+            raise ServiceValidationError(
+                f"segment_id must be between 1 and 9, got {segment_id}"
+            )
+
+        # Validate and convert batt_mode string to integer
+        valid_modes = {
+            "load_first": BATT_MODE_LOAD_FIRST,
+            "battery_first": BATT_MODE_BATTERY_FIRST,
+            "grid_first": BATT_MODE_GRID_FIRST,
+        }
+        if batt_mode_str not in valid_modes:
+            raise ServiceValidationError(
+                f"batt_mode must be one of {list(valid_modes.keys())}, got '{batt_mode_str}'"
+            )
+        batt_mode: int = valid_modes[batt_mode_str]
+
+        # Convert time strings to datetime.time objects
+        # UI time selector sends HH:MM:SS, but we only need HH:MM (strip seconds)
+        try:
+            # Take only HH:MM part (ignore seconds if present)
+            start_parts = start_time_str.split(":")
+            start_time_hhmm = f"{start_parts[0]}:{start_parts[1]}"
+            start_time = datetime.strptime(start_time_hhmm, "%H:%M").time()
+        except (ValueError, IndexError) as err:
+            raise ServiceValidationError(
+                "start_time must be in HH:MM or HH:MM:SS format"
+            ) from err
+
+        try:
+            # Take only HH:MM part (ignore seconds if present)
+            end_parts = end_time_str.split(":")
+            end_time_hhmm = f"{end_parts[0]}:{end_parts[1]}"
+            end_time = datetime.strptime(end_time_hhmm, "%H:%M").time()
+        except (ValueError, IndexError) as err:
+            raise ServiceValidationError(
+                "end_time must be in HH:MM or HH:MM:SS format"
+            ) from err
+
+        # Get the appropriate MIN coordinator
+        coordinator: GrowattCoordinator = get_coordinator(device_id)
+
+        await coordinator.update_time_segment(
+            segment_id,
+            batt_mode,
+            start_time,
+            end_time,
+            enabled,
+        )
+
+    async def handle_read_time_segments(call: ServiceCall) -> dict[str, Any]:
+        """Handle read_time_segments service call."""
+        device_id: str = call.data["device_id"]
+
+        # Get the appropriate MIN coordinator
+        coordinator: GrowattCoordinator = get_coordinator(device_id)
+
+        time_segments: list[dict[str, Any]] = await coordinator.read_time_segments()
+
+        return {"time_segments": time_segments}
+
+    # Register services without schema - services.yaml will provide UI definition
+    # Schema validation happens in the handler functions
+    hass.services.async_register(
+        DOMAIN,
+        "update_time_segment",
+        handle_update_time_segment,
+        supports_response=SupportsResponse.NONE,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "read_time_segments",
+        handle_read_time_segments,
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/growatt_server/services.yaml

@@ -0,0 +1,50 @@
+# Service definitions for Growatt Server integration
+
+update_time_segment:
+  fields:
+    segment_id:
+      required: true
+      example: 1
+      selector:
+        number:
+          min: 1
+          max: 9
+          mode: box
+    batt_mode:
+      required: true
+      example: "load_first"
+      selector:
+        select:
+          options:
+            - "load_first"
+            - "battery_first"
+            - "grid_first"
+          translation_key: batt_mode
+    start_time:
+      required: true
+      example: "08:00"
+      selector:
+        time:
+    end_time:
+      required: true
+      example: "12:00"
+      selector:
+        time:
+    enabled:
+      required: true
+      example: true
+      selector:
+        boolean:
+    device_id:
+      required: true
+      selector:
+        device:
+          integration: growatt_server
+
+read_time_segments:
+  fields:
+    device_id:
+      required: true
+      selector:
+        device:
+          integration: growatt_server

homeassistant/components/growatt_server/strings.json

@@ -523,5 +523,56 @@
       }
     }
   },
+  "selector": {
+    "batt_mode": {
+      "options": {
+        "battery_first": "Battery first",
+        "grid_first": "Grid first",
+        "load_first": "Load first"
+      }
+    }
+  },
+  "services": {
+    "read_time_segments": {
+      "description": "Read all time segments from a supported inverter.",
+      "fields": {
+        "device_id": {
+          "description": "The Growatt device to perform the action on.",
+          "name": "Device"
+        }
+      },
+      "name": "Read time segments"
+    },
+    "update_time_segment": {
+      "description": "Update a time segment for supported inverters.",
+      "fields": {
+        "batt_mode": {
+          "description": "Battery operation mode for this time segment.",
+          "name": "Battery mode"
+        },
+        "device_id": {
+          "description": "[%key:component::growatt_server::services::read_time_segments::fields::device_id::description%]",
+          "name": "[%key:component::growatt_server::services::read_time_segments::fields::device_id::name%]"
+        },
+        "enabled": {
+          "description": "Whether this time segment is active.",
+          "name": "Enabled"
+        },
+        "end_time": {
+          "description": "End time for the segment (HH:MM format).",
+          "name": "End time"
+        },
+        "segment_id": {
+          "description": "Time segment ID (1-9).",
+          "name": "Segment ID"
+        },
+        "start_time": {
+          "description": "Start time for the segment (HH:MM format).",
+          "name": "Start time"
+        }
+      },
+      "name": "Update time segment"
+    }
+  },
   "title": "Growatt Server"
 }

homeassistant/components/hanna/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bestycame"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hanna",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
   "requirements": ["hanna-cloud==0.0.7"]

homeassistant/components/harmony/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["remote"],
   "documentation": "https://www.home-assistant.io/integrations/harmony",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["aioharmony", "slixmpp"],
   "requirements": ["aioharmony==0.5.3"],

homeassistant/components/here_travel_time/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@eifinger"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/here_travel_time",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["here_routing", "here_transit", "homeassistant.helpers.location"],
   "requirements": ["here-routing==1.2.0", "here-transit==1.2.1"]

homeassistant/components/hikvision/__init__.py

@@ -1 +1,87 @@
-"""The hikvision component."""
+"""The Hikvision integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+
+from pyhik.hikvision import HikCamera
+import requests
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_SSL,
+    CONF_USERNAME,
+    Platform,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS = [Platform.BINARY_SENSOR]
+
+
+@dataclass
+class HikvisionData:
+    """Data class for Hikvision runtime data."""
+
+    camera: HikCamera
+    device_id: str
+    device_name: str
+    device_type: str
+
+
+type HikvisionConfigEntry = ConfigEntry[HikvisionData]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: HikvisionConfigEntry) -> bool:
+    """Set up Hikvision from a config entry."""
+    host = entry.data[CONF_HOST]
+    port = entry.data[CONF_PORT]
+    username = entry.data[CONF_USERNAME]
+    password = entry.data[CONF_PASSWORD]
+    ssl = entry.data[CONF_SSL]
+
+    protocol = "https" if ssl else "http"
+    url = f"{protocol}://{host}"
+
+    try:
+        camera = await hass.async_add_executor_job(
+            HikCamera, url, port, username, password
+        )
+    except requests.exceptions.RequestException as err:
+        raise ConfigEntryNotReady(f"Unable to connect to {host}") from err
+
+    device_id = camera.get_id()
+    if device_id is None:
+        raise ConfigEntryNotReady(f"Unable to get device ID from {host}")
+
+    device_name = camera.get_name or host
+    device_type = camera.get_type or "Camera"
+
+    entry.runtime_data = HikvisionData(
+        camera=camera,
+        device_id=device_id,
+        device_name=device_name,
+        device_type=device_type,
+    )
+
+    # Start the event stream
+    await hass.async_add_executor_job(camera.start_stream)
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: HikvisionConfigEntry) -> bool:
+    """Unload a config entry."""
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        # Stop the event stream
+        await hass.async_add_executor_job(entry.runtime_data.camera.disconnect)
+
+    return unload_ok

homeassistant/components/hikvision/binary_sensor.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
 import logging
+from typing import Any
 
-from pyhik.hikvision import HikCamera
 import voluptuous as vol
 
 from homeassistant.components.binary_sensor import (
@@ -13,6 +12,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import (
     ATTR_LAST_TRIP_TIME,
     CONF_CUSTOMIZE,
@@ -23,27 +23,27 @@ from homeassistant.const import (
     CONF_PORT,
     CONF_SSL,
     CONF_USERNAME,
-    EVENT_HOMEASSISTANT_START,
-    EVENT_HOMEASSISTANT_STOP,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.event import track_point_in_utc_time
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
+from homeassistant.data_entry_flow import FlowResultType
+from homeassistant.helpers import config_validation as cv, issue_registry as ir
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    AddEntitiesCallback,
+)
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.util.dt import utcnow
 
-_LOGGER = logging.getLogger(__name__)
+from . import HikvisionConfigEntry
+from .const import DEFAULT_PORT, DOMAIN
 
 CONF_IGNORED = "ignored"
 
-DEFAULT_PORT = 80
-DEFAULT_IGNORED = False
 DEFAULT_DELAY = 0
+DEFAULT_IGNORED = False
 
-ATTR_DELAY = "delay"
-
-DEVICE_CLASS_MAP = {
+# Device class mapping for Hikvision event types
+DEVICE_CLASS_MAP: dict[str, BinarySensorDeviceClass | None] = {
     "Motion": BinarySensorDeviceClass.MOTION,
     "Line Crossing": BinarySensorDeviceClass.MOTION,
     "Field Detection": BinarySensorDeviceClass.MOTION,
@@ -67,6 +67,8 @@ DEVICE_CLASS_MAP = {
     "Entering Region": BinarySensorDeviceClass.MOTION,
 }
 
+_LOGGER = logging.getLogger(__name__)
+
 CUSTOMIZE_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_IGNORED, default=DEFAULT_IGNORED): cv.boolean,
@@ -88,214 +90,144 @@ PLATFORM_SCHEMA = BINARY_SENSOR_PLATFORM_SCHEMA.extend(
     }
 )
 
+PARALLEL_UPDATES = 0
 
-def setup_platform(
+
+async def async_setup_platform(
     hass: HomeAssistant,
     config: ConfigType,
-    add_entities: AddEntitiesCallback,
+    async_add_entities: AddEntitiesCallback,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up the Hikvision binary sensor devices."""
-    name = config.get(CONF_NAME)
-    host = config[CONF_HOST]
-    port = config[CONF_PORT]
-    username = config[CONF_USERNAME]
-    password = config[CONF_PASSWORD]
+    """Set up the Hikvision binary sensor platform from YAML."""
+    # Trigger the import flow to migrate YAML config to config entry
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_IMPORT}, data=config
+    )
 
-    customize = config[CONF_CUSTOMIZE]
-
-    protocol = "https" if config[CONF_SSL] else "http"
-
-    url = f"{protocol}://{host}"
-
-    data = HikvisionData(hass, url, port, name, username, password)
-
-    if data.sensors is None:
-        _LOGGER.error("Hikvision event stream has no data, unable to set up")
+    if (
+        result.get("type") is FlowResultType.ABORT
+        and result.get("reason") != "already_configured"
+    ):
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            f"deprecated_yaml_import_issue_{result.get('reason')}",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="deprecated_yaml_import_issue",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "Hikvision",
+            },
+        )
         return
 
-    entities = []
-
-    for sensor, channel_list in data.sensors.items():
-        for channel in channel_list:
-            # Build sensor name, then parse customize config.
-            if data.type == "NVR":
-                sensor_name = f"{sensor.replace(' ', '_')}_{channel[1]}"
-            else:
-                sensor_name = sensor.replace(" ", "_")
-
-            custom = customize.get(sensor_name.lower(), {})
-            ignore = custom.get(CONF_IGNORED)
-            delay = custom.get(CONF_DELAY)
-
-            _LOGGER.debug(
-                "Entity: %s - %s, Options - Ignore: %s, Delay: %s",
-                data.name,
-                sensor_name,
-                ignore,
-                delay,
-            )
-            if not ignore:
-                entities.append(
-                    HikvisionBinarySensor(hass, sensor, channel[1], data, delay)
-                )
-
-    add_entities(entities)
+    ir.async_create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_yaml_{DOMAIN}",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="deprecated_yaml",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Hikvision",
+        },
+    )
 
 
-class HikvisionData:
-    """Hikvision device event stream object."""
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HikvisionConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Hikvision binary sensors from a config entry."""
+    data = entry.runtime_data
+    camera = data.camera
 
-    def __init__(self, hass, url, port, name, username, password):
-        """Initialize the data object."""
-        self._url = url
-        self._port = port
-        self._name = name
-        self._username = username
-        self._password = password
+    sensors = camera.current_event_states
+    if sensors is None or not sensors:
+        _LOGGER.warning("Hikvision device has no sensors available")
+        return
 
-        # Establish camera
-        self.camdata = HikCamera(self._url, self._port, self._username, self._password)
-
-        if self._name is None:
-            self._name = self.camdata.get_name
-
-        hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, self.stop_hik)
-        hass.bus.listen_once(EVENT_HOMEASSISTANT_START, self.start_hik)
-
-    def stop_hik(self, event):
-        """Shutdown Hikvision subscriptions and subscription thread on exit."""
-        self.camdata.disconnect()
-
-    def start_hik(self, event):
-        """Start Hikvision event stream thread."""
-        self.camdata.start_stream()
-
-    @property
-    def sensors(self):
-        """Return list of available sensors and their states."""
-        return self.camdata.current_event_states
-
-    @property
-    def cam_id(self):
-        """Return device id."""
-        return self.camdata.get_id
-
-    @property
-    def name(self):
-        """Return device name."""
-        return self._name
-
-    @property
-    def type(self):
-        """Return device type."""
-        return self.camdata.get_type
-
-    def get_attributes(self, sensor, channel):
-        """Return attribute list for sensor/channel."""
-        return self.camdata.fetch_attributes(sensor, channel)
+    async_add_entities(
+        HikvisionBinarySensor(
+            entry=entry,
+            sensor_type=sensor_type,
+            channel=channel_info[1],
+        )
+        for sensor_type, channel_list in sensors.items()
+        for channel_info in channel_list
+    )
 
 
 class HikvisionBinarySensor(BinarySensorEntity):
     """Representation of a Hikvision binary sensor."""
 
+    _attr_has_entity_name = True
     _attr_should_poll = False
 
-    def __init__(self, hass, sensor, channel, cam, delay):
-        """Initialize the binary_sensor."""
-        self._hass = hass
-        self._cam = cam
-        self._sensor = sensor
+    def __init__(
+        self,
+        entry: HikvisionConfigEntry,
+        sensor_type: str,
+        channel: int,
+    ) -> None:
+        """Initialize the binary sensor."""
+        self._data = entry.runtime_data
+        self._camera = self._data.camera
+        self._sensor_type = sensor_type
         self._channel = channel
 
-        if self._cam.type == "NVR":
-            self._name = f"{self._cam.name} {sensor} {channel}"
+        # Build unique ID
+        self._attr_unique_id = f"{self._data.device_id}_{sensor_type}_{channel}"
+
+        # Build entity name based on device type
+        if self._data.device_type == "NVR":
+            self._attr_name = f"{sensor_type} {channel}"
         else:
-            self._name = f"{self._cam.name} {sensor}"
+            self._attr_name = sensor_type
 
-        self._id = f"{self._cam.cam_id}.{sensor}.{channel}"
+        # Device info for device registry
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._data.device_id)},
+            name=self._data.device_name,
+            manufacturer="Hikvision",
+            model=self._data.device_type,
+        )
 
-        if delay is None:
-            self._delay = 0
-        else:
-            self._delay = delay
+        # Set device class
+        self._attr_device_class = DEVICE_CLASS_MAP.get(sensor_type)
 
-        self._timer = None
+        # Callback ID for pyhik
+        self._callback_id = f"{self._data.device_id}.{sensor_type}.{channel}"
 
-        # Register callback function with pyHik
-        self._cam.camdata.add_update_callback(self._update_callback, self._id)
-
-    def _sensor_state(self):
-        """Extract sensor state."""
-        return self._cam.get_attributes(self._sensor, self._channel)[0]
-
-    def _sensor_last_update(self):
-        """Extract sensor last update time."""
-        return self._cam.get_attributes(self._sensor, self._channel)[3]
+    def _get_sensor_attributes(self) -> tuple[bool, Any, Any, Any]:
+        """Get sensor attributes from camera."""
+        return self._camera.fetch_attributes(self._sensor_type, self._channel)
 
     @property
-    def name(self):
-        """Return the name of the Hikvision sensor."""
-        return self._name
-
-    @property
-    def unique_id(self):
-        """Return a unique ID."""
-        return self._id
-
-    @property
-    def is_on(self):
+    def is_on(self) -> bool:
         """Return true if sensor is on."""
-        return self._sensor_state()
+        return self._get_sensor_attributes()[0]
 
     @property
-    def device_class(self):
-        """Return the class of this sensor, from DEVICE_CLASSES."""
-        try:
-            return DEVICE_CLASS_MAP[self._sensor]
-        except KeyError:
-            # Sensor must be unknown to us, add as generic
-            return None
-
-    @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> dict[str, Any]:
         """Return the state attributes."""
-        attr = {ATTR_LAST_TRIP_TIME: self._sensor_last_update()}
+        attrs = self._get_sensor_attributes()
+        return {ATTR_LAST_TRIP_TIME: attrs[3]}
 
-        if self._delay != 0:
-            attr[ATTR_DELAY] = self._delay
+    async def async_added_to_hass(self) -> None:
+        """Register callback when entity is added."""
+        await super().async_added_to_hass()
 
-        return attr
+        # Register callback with pyhik
+        self._camera.add_update_callback(self._update_callback, self._callback_id)
 
-    def _update_callback(self, msg):
-        """Update the sensor's state, if needed."""
-        _LOGGER.debug("Callback signal from: %s", msg)
-
-        if self._delay > 0 and not self.is_on:
-            # Set timer to wait until updating the state
-            def _delay_update(now):
-                """Timer callback for sensor update."""
-                _LOGGER.debug(
-                    "%s Called delayed (%ssec) update", self._name, self._delay
-                )
-                self.schedule_update_ha_state()
-                self._timer = None
-
-            if self._timer is not None:
-                self._timer()
-                self._timer = None
-
-            self._timer = track_point_in_utc_time(
-                self._hass, _delay_update, utcnow() + timedelta(seconds=self._delay)
-            )
-
-        elif self._delay > 0 and self.is_on:
-            # For delayed sensors kill any callbacks on true events and update
-            if self._timer is not None:
-                self._timer()
-                self._timer = None
-
-            self.schedule_update_ha_state()
-
-        else:
-            self.schedule_update_ha_state()
+    @callback
+    def _update_callback(self, msg: str) -> None:
+        """Update the sensor's state when callback is triggered."""
+        self.async_write_ha_state()

homeassistant/components/hikvision/config_flow.py

@@ -0,0 +1,134 @@
+"""Config flow for Hikvision integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pyhik.hikvision import HikCamera
+import requests
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_SSL,
+    CONF_USERNAME,
+)
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DEFAULT_PORT, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HikvisionConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Hikvision."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            host = user_input[CONF_HOST]
+            port = user_input[CONF_PORT]
+            username = user_input[CONF_USERNAME]
+            password = user_input[CONF_PASSWORD]
+            ssl = user_input[CONF_SSL]
+
+            protocol = "https" if ssl else "http"
+            url = f"{protocol}://{host}"
+
+            try:
+                camera = await self.hass.async_add_executor_job(
+                    HikCamera, url, port, username, password
+                )
+                device_id = camera.get_id()
+                device_name = camera.get_name
+            except requests.exceptions.RequestException:
+                _LOGGER.exception("Error connecting to Hikvision device")
+                errors["base"] = "cannot_connect"
+            else:
+                if device_id is None:
+                    errors["base"] = "cannot_connect"
+                else:
+                    await self.async_set_unique_id(device_id)
+                    self._abort_if_unique_id_configured()
+
+                    return self.async_create_entry(
+                        title=device_name or host,
+                        data={
+                            CONF_HOST: host,
+                            CONF_PORT: port,
+                            CONF_USERNAME: username,
+                            CONF_PASSWORD: password,
+                            CONF_SSL: ssl,
+                        },
+                    )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_HOST): str,
+                    vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
+                    vol.Required(CONF_USERNAME): str,
+                    vol.Required(CONF_PASSWORD): str,
+                    vol.Required(CONF_SSL, default=False): bool,
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_import(self, import_data: ConfigType) -> ConfigFlowResult:
+        """Handle import from configuration.yaml."""
+        host = import_data[CONF_HOST]
+        port = import_data.get(CONF_PORT, DEFAULT_PORT)
+        username = import_data[CONF_USERNAME]
+        password = import_data[CONF_PASSWORD]
+        ssl = import_data.get(CONF_SSL, False)
+        name = import_data.get(CONF_NAME)
+
+        protocol = "https" if ssl else "http"
+        url = f"{protocol}://{host}"
+
+        try:
+            camera = await self.hass.async_add_executor_job(
+                HikCamera, url, port, username, password
+            )
+            device_id = camera.get_id()
+            device_name = camera.get_name
+        except requests.exceptions.RequestException:
+            _LOGGER.exception(
+                "Error connecting to Hikvision device during import, aborting"
+            )
+            return self.async_abort(reason="cannot_connect")
+
+        if device_id is None:
+            return self.async_abort(reason="cannot_connect")
+
+        await self.async_set_unique_id(device_id)
+        self._abort_if_unique_id_configured()
+
+        _LOGGER.warning(
+            "Importing Hikvision config from configuration.yaml for %s", host
+        )
+
+        return self.async_create_entry(
+            title=name or device_name or host,
+            data={
+                CONF_HOST: host,
+                CONF_PORT: port,
+                CONF_USERNAME: username,
+                CONF_PASSWORD: password,
+                CONF_SSL: ssl,
+            },
+        )

homeassistant/components/hikvision/const.py

@@ -0,0 +1,6 @@
+"""Constants for the Hikvision integration."""
+
+DOMAIN = "hikvision"
+
+# Default values
+DEFAULT_PORT = 80

homeassistant/components/hikvision/manifest.json

@@ -2,7 +2,9 @@
   "domain": "hikvision",
   "name": "Hikvision",
   "codeowners": ["@mezz64"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hikvision",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyhik"],
   "quality_scale": "legacy",

homeassistant/components/hikvision/strings.json

@@ -0,0 +1,36 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "port": "[%key:common::config_flow::data::port%]",
+          "ssl": "Use SSL",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "host": "The hostname or IP address of your Hikvision device",
+          "password": "The password for your Hikvision device",
+          "port": "The port number for the device (default is 80)",
+          "ssl": "Enable if your device uses HTTPS",
+          "username": "The username for your Hikvision device"
+        },
+        "description": "Enter your Hikvision device connection details.",
+        "title": "Set up Hikvision device"
+      }
+    }
+  },
+  "issues": {
+    "deprecated_yaml_import_issue": {
+      "description": "Configuring {integration_title} using YAML is deprecated and the import failed. Please remove the `{domain}` entry from your `configuration.yaml` file and set up the integration manually.",
+      "title": "YAML import failed"
+    }
+  }
+}

homeassistant/components/hive/manifest.json

@@ -7,6 +7,7 @@
   "homekit": {
     "models": ["HHKBridge*"]
   },
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
   "requirements": ["pyhive-integration==1.0.7"]

homeassistant/components/hko/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@MisterCommand"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hko",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "requirements": ["hko==0.3.2"]
 }

homeassistant/components/hlk_sw16/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@jameshilliard"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hlk_sw16",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["hlk_sw16"],
   "requirements": ["hlk-sw16==0.0.9"]

homeassistant/components/homeassistant/__init__.py

@@ -49,7 +49,7 @@ from homeassistant.helpers.service import (
 from homeassistant.helpers.signal import KEY_HA_STOP
 from homeassistant.helpers.system_info import async_get_system_info
 from homeassistant.helpers.target import (
-    TargetSelectorData,
+    TargetSelection,
     async_extract_referenced_entity_ids,
 )
 from homeassistant.helpers.template import async_load_custom_templates
@@ -115,7 +115,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
     async def async_handle_turn_service(service: ServiceCall) -> None:
         """Handle calls to homeassistant.turn_on/off."""
         referenced = async_extract_referenced_entity_ids(
-            hass, TargetSelectorData(service.data)
+            hass, TargetSelection(service.data)
         )
         all_referenced = referenced.referenced | referenced.indirectly_referenced
 

homeassistant/components/homekit/__init__.py

@@ -78,7 +78,7 @@ from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.helpers.start import async_at_started
 from homeassistant.helpers.target import (
-    TargetSelectorData,
+    TargetSelection,
     async_extract_referenced_entity_ids,
 )
 from homeassistant.helpers.typing import ConfigType
@@ -483,7 +483,7 @@ def _async_register_events_and_services(hass: HomeAssistant) -> None:
     async def async_handle_homekit_unpair(service: ServiceCall) -> None:
         """Handle unpair HomeKit service call."""
         referenced = async_extract_referenced_entity_ids(
-            hass, TargetSelectorData(service.data)
+            hass, TargetSelection(service.data)
         )
         dev_reg = dr.async_get(hass)
         for device_id in referenced.referenced_devices:

homeassistant/components/homematicip_cloud/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@hahn-th"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/homematicip_cloud",
+  "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["homematicip"],
   "requirements": ["homematicip==2.4.0"]

homeassistant/components/homeworks/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/homeworks",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["pyhomeworks"],
   "requirements": ["pyhomeworks==1.1.2"]

homeassistant/components/honeywell/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@rdfurman", "@mkmer"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/honeywell",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["somecomfort"],
   "requirements": ["AIOSomecomfort==0.0.35"]

homeassistant/components/huawei_lte/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@scop", "@fphammerle"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/huawei_lte",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["huawei_lte_api.Session"],
   "requirements": ["huawei-lte-api==1.11.0", "url-normalize==2.2.1"],

homeassistant/components/hunterdouglas_powerview/manifest.json

@@ -16,6 +16,7 @@
   "homekit": {
     "models": ["PowerView"]
   },
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aiopvapi"],
   "requirements": ["aiopvapi==3.3.0"],

homeassistant/components/husqvarna_automower_ble/manifest.json

@@ -11,6 +11,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==1.6.0"]
 }

homeassistant/components/huum/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@frwickst", "@vincentwolsink"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/huum",
+  "integration_type": "device",
   "iot_class": "cloud_polling",
   "requirements": ["huum==0.8.1"]
 }

homeassistant/components/hvv_departures/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@vigonotion"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hvv_departures",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["pygti"],
   "requirements": ["pygti==0.9.4"]

homeassistant/components/hydrawise/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@dknowles2", "@thomaskistler", "@ptcryan"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/hydrawise",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pydrawise"],
   "requirements": ["pydrawise==2025.9.0"]

homeassistant/components/ialarm/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@RyuzakiKK"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/ialarm",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyialarm"],
   "requirements": ["pyialarm==2.2.0"]

homeassistant/components/iaqualink/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@flz"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/iaqualink",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["iaqualink"],
   "requirements": ["iaqualink==0.6.0", "h2==4.3.0"],

homeassistant/components/icloud/account.py

@@ -108,7 +108,7 @@ class IcloudAccount:
 
             if self.api.requires_2fa:
                 # Trigger a new log in to ensure the user enters the 2FA code again.
-                raise PyiCloudFailedLoginException  # noqa: TRY301
+                raise PyiCloudFailedLoginException("2FA Required")  # noqa: TRY301
 
         except PyiCloudFailedLoginException:
             self.api = None

homeassistant/components/icloud/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@Quentame", "@nzapponi"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/icloud",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["keyrings.alt", "pyicloud"],
   "requirements": ["pyicloud==2.2.0"]

homeassistant/components/igloohome/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@keithle888"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/igloohome",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
   "requirements": ["igloohome-api==0.1.1"]

homeassistant/components/imap/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["repairs"],
   "documentation": "https://www.home-assistant.io/integrations/imap",
+  "integration_type": "service",
   "iot_class": "cloud_push",
   "loggers": ["aioimaplib"],
   "requirements": ["aioimaplib==2.0.1"]

homeassistant/components/imgw_pib/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@bieniu"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/imgw_pib",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
   "requirements": ["imgw_pib==1.6.0"]

homeassistant/components/improv_ble/config_flow.py

@@ -261,7 +261,8 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
 
         if self._can_identify is None:
             try:
-                self._can_identify = await self._try_call(device.can_identify())
+                await self._try_call(device.ensure_connected())
+                self._can_identify = device.can_identify
             except AbortFlow as err:
                 return self.async_abort(reason=err.reason)
         if self._can_identify:

homeassistant/components/improv_ble/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/improv_ble",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["py-improv-ble-client==1.0.3"]
+  "requirements": ["py-improv-ble-client==2.0.1"]
 }

homeassistant/components/inels/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["mqtt"],
   "documentation": "https://www.home-assistant.io/integrations/inels",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "mqtt": ["inels/status/#"],
   "quality_scale": "bronze",

homeassistant/components/inkbird/manifest.json

@@ -61,6 +61,7 @@
   "config_flow": true,
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/inkbird",
+  "integration_type": "device",
   "iot_class": "local_push",
   "requirements": ["inkbird-ble==1.1.1"]
 }

homeassistant/components/insteon/manifest.json

@@ -14,10 +14,11 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/insteon",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["pyinsteon", "pypubsub"],
   "requirements": [
-    "pyinsteon==1.6.3",
+    "pyinsteon==1.6.4",
     "insteon-frontend-home-assistant==0.5.0"
   ],
   "single_config_entry": true,

homeassistant/components/intellifire/manifest.json

@@ -9,6 +9,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/intellifire",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["intellifire4py"],
   "requirements": ["intellifire4py==4.2.1"]

homeassistant/components/iotawatt/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@gtdiehl", "@jyavenard"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/iotawatt",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["iotawattpy"],
   "requirements": ["ha-iotawattpy==0.1.2"]

homeassistant/components/ipma/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@dgomes"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/ipma",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["geopy", "pyipma"],
   "requirements": ["pyipma==3.0.9"]

homeassistant/components/islamic_prayer_times/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@engrbm87", "@cpfair"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/islamic_prayer_times",
+  "integration_type": "service",
   "iot_class": "calculated",
   "loggers": ["prayer_times_calculator"],
   "requirements": ["prayer-times-calculator-offline==1.0.3"]

homeassistant/components/israel_rail/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@shaiu"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/israel_rail",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["israelrailapi"],
   "requirements": ["israel-rail-api==0.1.4"]