Merge branch 'dev' into add_alarm_conditions

homeassistant/components/alarm_control_panel/condition.py

@@ -0,0 +1,93 @@
+"""Provides conditions for alarm control panels."""
+
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.condition import (
+    Condition,
+    EntityStateConditionBase,
+    make_entity_state_condition,
+)
+from homeassistant.helpers.entity import get_supported_features
+
+from .const import DOMAIN, AlarmControlPanelEntityFeature, AlarmControlPanelState
+
+
+def supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool:
+    """Test if an entity supports the specified features."""
+    try:
+        return bool(get_supported_features(hass, entity_id) & features)
+    except HomeAssistantError:
+        return False
+
+
+class EntityStateConditionRequiredFeatures(EntityStateConditionBase):
+    """State condition."""
+
+    _required_features: int
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if supports_feature(self._hass, entity_id, self._required_features)
+        }
+
+
+def make_entity_state_condition_required_features(
+    domain: str, to_state: str, required_features: int
+) -> type[EntityStateConditionRequiredFeatures]:
+    """Create an entity state condition class with required feature filtering."""
+
+    class CustomCondition(EntityStateConditionRequiredFeatures):
+        """Trigger for entity state changes."""
+
+        _domain = domain
+        _states = {to_state}
+        _required_features = required_features
+
+    return CustomCondition
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_armed": make_entity_state_condition(
+        DOMAIN,
+        {
+            AlarmControlPanelState.ARMED_AWAY,
+            AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+            AlarmControlPanelState.ARMED_HOME,
+            AlarmControlPanelState.ARMED_NIGHT,
+            AlarmControlPanelState.ARMED_VACATION,
+        },
+    ),
+    "is_armed_away": make_entity_state_condition_required_features(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_AWAY,
+        AlarmControlPanelEntityFeature.ARM_AWAY,
+    ),
+    "is_armed_home": make_entity_state_condition_required_features(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_HOME,
+        AlarmControlPanelEntityFeature.ARM_HOME,
+    ),
+    "is_armed_night": make_entity_state_condition_required_features(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_NIGHT,
+        AlarmControlPanelEntityFeature.ARM_NIGHT,
+    ),
+    "is_armed_vacation": make_entity_state_condition_required_features(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_VACATION,
+        AlarmControlPanelEntityFeature.ARM_VACATION,
+    ),
+    "is_disarmed": make_entity_state_condition(DOMAIN, AlarmControlPanelState.DISARMED),
+    "is_triggered": make_entity_state_condition(
+        DOMAIN, AlarmControlPanelState.TRIGGERED
+    ),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the alarm control panel conditions."""
+    return CONDITIONS

homeassistant/components/alarm_control_panel/conditions.yaml

@@ -0,0 +1,52 @@
+.condition_common: &condition_common
+  target:
+    entity:
+      domain: alarm_control_panel
+  fields: &condition_common_fields
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: condition_behavior
+          options:
+            - all
+            - any
+
+is_armed: *condition_common
+
+is_armed_away:
+  fields: *condition_common_fields
+  target:
+    entity:
+      domain: alarm_control_panel
+      supported_features:
+        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_AWAY
+
+is_armed_home:
+  fields: *condition_common_fields
+  target:
+    entity:
+      domain: alarm_control_panel
+      supported_features:
+        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_HOME
+
+is_armed_night:
+  fields: *condition_common_fields
+  target:
+    entity:
+      domain: alarm_control_panel
+      supported_features:
+        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_NIGHT
+
+is_armed_vacation:
+  fields: *condition_common_fields
+  target:
+    entity:
+      domain: alarm_control_panel
+      supported_features:
+        - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_VACATION
+
+is_disarmed: *condition_common
+
+is_triggered: *condition_common

homeassistant/components/alarm_control_panel/icons.json

@@ -1,4 +1,27 @@
 {
+  "conditions": {
+    "is_armed": {
+      "condition": "mdi:shield"
+    },
+    "is_armed_away": {
+      "condition": "mdi:shield-lock"
+    },
+    "is_armed_home": {
+      "condition": "mdi:shield-home"
+    },
+    "is_armed_night": {
+      "condition": "mdi:shield-moon"
+    },
+    "is_armed_vacation": {
+      "condition": "mdi:shield-airplane"
+    },
+    "is_disarmed": {
+      "condition": "mdi:shield-off"
+    },
+    "is_triggered": {
+      "condition": "mdi:bell-ring"
+    }
+  },
   "entity_component": {
     "_": {
       "default": "mdi:shield",

homeassistant/components/alarm_control_panel/strings.json

@@ -1,8 +1,82 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted alarms.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted alarms to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_armed": {
+      "description": "Tests if one or more alarms are armed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is armed"
+    },
+    "is_armed_away": {
+      "description": "Tests if one or more alarms are armed in away mode.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is armed away"
+    },
+    "is_armed_home": {
+      "description": "Tests if one or more alarms are armed in home mode.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is armed home"
+    },
+    "is_armed_night": {
+      "description": "Tests if one or more alarms are armed in night mode.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is armed night"
+    },
+    "is_armed_vacation": {
+      "description": "Tests if one or more alarms are armed in vacation mode.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is armed vacation"
+    },
+    "is_disarmed": {
+      "description": "Tests if one or more alarms are disarmed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is disarmed"
+    },
+    "is_triggered": {
+      "description": "Tests if one or more alarms are triggered.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
+          "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If an alarm is triggered"
+    }
+  },
   "device_automation": {
     "action_type": {
       "arm_away": "Arm {entity_name} away",
@@ -76,6 +150,12 @@
     }
   },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/automation/__init__.py

@@ -123,6 +123,7 @@ SERVICE_TRIGGER = "trigger"
 NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
 
 _EXPERIMENTAL_CONDITION_PLATFORMS = {
+    "alarm_control_panel",
     "fan",
     "light",
 }

homeassistant/components/blebox/sensor.py

@@ -1,7 +1,5 @@
 """BleBox sensor entities."""
 
-from datetime import datetime
-
 import blebox_uniapi.sensor
 
 from homeassistant.components.sensor import (
@@ -148,7 +146,7 @@ class BleBoxSensorEntity(BleBoxEntity[blebox_uniapi.sensor.BaseSensor], SensorEn
         return self._feature.native_value
 
     @property
-    def last_reset(self) -> datetime | None:
+    def last_reset(self):
         """Return the time when the sensor was last reset, if implemented."""
         native_implementation = getattr(self._feature, "last_reset", None)
 

homeassistant/components/ebusd/__init__.py

@@ -1,7 +1,6 @@
 """Support for Ebusd daemon for communication with eBUS heating systems."""
 
 import logging
-from typing import Any
 
 import ebusdpy
 import voluptuous as vol
@@ -18,7 +17,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.discovery import load_platform
 from homeassistant.helpers.typing import ConfigType
 
-from .const import DOMAIN, EBUSD_DATA, SENSOR_TYPES
+from .const import DOMAIN, SENSOR_TYPES
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,9 +28,9 @@ CACHE_TTL = 900
 SERVICE_EBUSD_WRITE = "ebusd_write"
 
 
-def verify_ebusd_config(config: ConfigType) -> ConfigType:
+def verify_ebusd_config(config):
     """Verify eBusd config."""
-    circuit: str = config[CONF_CIRCUIT]
+    circuit = config[CONF_CIRCUIT]
     for condition in config[CONF_MONITORED_CONDITIONS]:
         if condition not in SENSOR_TYPES[circuit]:
             raise vol.Invalid(f"Condition '{condition}' not in '{circuit}'.")
@@ -60,17 +59,17 @@ CONFIG_SCHEMA = vol.Schema(
 def setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the eBusd component."""
     _LOGGER.debug("Integration setup started")
-    conf: ConfigType = config[DOMAIN]
-    name: str = conf[CONF_NAME]
-    circuit: str = conf[CONF_CIRCUIT]
-    monitored_conditions: list[str] = conf[CONF_MONITORED_CONDITIONS]
-    server_address: tuple[str, int] = (conf[CONF_HOST], conf[CONF_PORT])
+    conf = config[DOMAIN]
+    name = conf[CONF_NAME]
+    circuit = conf[CONF_CIRCUIT]
+    monitored_conditions = conf.get(CONF_MONITORED_CONDITIONS)
+    server_address = (conf.get(CONF_HOST), conf.get(CONF_PORT))
 
     try:
         ebusdpy.init(server_address)
     except (TimeoutError, OSError):
         return False
-    hass.data[EBUSD_DATA] = EbusdData(server_address, circuit)
+    hass.data[DOMAIN] = EbusdData(server_address, circuit)
     sensor_config = {
         CONF_MONITORED_CONDITIONS: monitored_conditions,
         "client_name": name,
@@ -78,7 +77,7 @@ def setup(hass: HomeAssistant, config: ConfigType) -> bool:
     }
     load_platform(hass, Platform.SENSOR, DOMAIN, sensor_config, config)
 
-    hass.services.register(DOMAIN, SERVICE_EBUSD_WRITE, hass.data[EBUSD_DATA].write)
+    hass.services.register(DOMAIN, SERVICE_EBUSD_WRITE, hass.data[DOMAIN].write)
 
     _LOGGER.debug("Ebusd integration setup completed")
     return True
@@ -87,13 +86,13 @@ def setup(hass: HomeAssistant, config: ConfigType) -> bool:
 class EbusdData:
     """Get the latest data from Ebusd."""
 
-    def __init__(self, address: tuple[str, int], circuit: str) -> None:
+    def __init__(self, address, circuit):
         """Initialize the data object."""
         self._circuit = circuit
         self._address = address
-        self.value: dict[str, Any] = {}
+        self.value = {}
 
-    def update(self, name: str, stype: int) -> None:
+    def update(self, name, stype):
         """Call the Ebusd API to update the data."""
         try:
             _LOGGER.debug("Opening socket to ebusd %s", name)

homeassistant/components/ebusd/const.py

@@ -1,9 +1,5 @@
 """Constants for ebus component."""
 
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
 from homeassistant.components.sensor import SensorDeviceClass
 from homeassistant.const import (
     PERCENTAGE,
@@ -12,283 +8,277 @@ from homeassistant.const import (
     UnitOfTemperature,
     UnitOfTime,
 )
-from homeassistant.util.hass_dict import HassKey
-
-if TYPE_CHECKING:
-    from . import EbusdData
 
 DOMAIN = "ebusd"
-EBUSD_DATA: HassKey[EbusdData] = HassKey(DOMAIN)
 
 #  SensorTypes from ebusdpy module :
 #  0='decimal', 1='time-schedule', 2='switch', 3='string', 4='value;status'
 
-type SensorSpecs = tuple[str, str | None, str | None, int, SensorDeviceClass | None]
-SENSOR_TYPES: dict[str, dict[str, SensorSpecs]] = {
+SENSOR_TYPES = {
     "700": {
-        "ActualFlowTemperatureDesired": (
+        "ActualFlowTemperatureDesired": [
             "Hc1ActualFlowTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "MaxFlowTemperatureDesired": (
+        ],
+        "MaxFlowTemperatureDesired": [
             "Hc1MaxFlowTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "MinFlowTemperatureDesired": (
+        ],
+        "MinFlowTemperatureDesired": [
             "Hc1MinFlowTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "PumpStatus": ("Hc1PumpStatus", None, "mdi:toggle-switch", 2, None),
-        "HCSummerTemperatureLimit": (
+        ],
+        "PumpStatus": ["Hc1PumpStatus", None, "mdi:toggle-switch", 2, None],
+        "HCSummerTemperatureLimit": [
             "Hc1SummerTempLimit",
             UnitOfTemperature.CELSIUS,
             "mdi:weather-sunny",
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "HolidayTemperature": (
+        ],
+        "HolidayTemperature": [
             "HolidayTemp",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "HWTemperatureDesired": (
+        ],
+        "HWTemperatureDesired": [
             "HwcTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "HWActualTemperature": (
+        ],
+        "HWActualTemperature": [
             "HwcStorageTemp",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "HWTimerMonday": ("hwcTimer.Monday", None, "mdi:timer-outline", 1, None),
-        "HWTimerTuesday": ("hwcTimer.Tuesday", None, "mdi:timer-outline", 1, None),
-        "HWTimerWednesday": ("hwcTimer.Wednesday", None, "mdi:timer-outline", 1, None),
-        "HWTimerThursday": ("hwcTimer.Thursday", None, "mdi:timer-outline", 1, None),
-        "HWTimerFriday": ("hwcTimer.Friday", None, "mdi:timer-outline", 1, None),
-        "HWTimerSaturday": ("hwcTimer.Saturday", None, "mdi:timer-outline", 1, None),
-        "HWTimerSunday": ("hwcTimer.Sunday", None, "mdi:timer-outline", 1, None),
-        "HWOperativeMode": ("HwcOpMode", None, "mdi:math-compass", 3, None),
-        "WaterPressure": (
+        ],
+        "HWTimerMonday": ["hwcTimer.Monday", None, "mdi:timer-outline", 1, None],
+        "HWTimerTuesday": ["hwcTimer.Tuesday", None, "mdi:timer-outline", 1, None],
+        "HWTimerWednesday": ["hwcTimer.Wednesday", None, "mdi:timer-outline", 1, None],
+        "HWTimerThursday": ["hwcTimer.Thursday", None, "mdi:timer-outline", 1, None],
+        "HWTimerFriday": ["hwcTimer.Friday", None, "mdi:timer-outline", 1, None],
+        "HWTimerSaturday": ["hwcTimer.Saturday", None, "mdi:timer-outline", 1, None],
+        "HWTimerSunday": ["hwcTimer.Sunday", None, "mdi:timer-outline", 1, None],
+        "HWOperativeMode": ["HwcOpMode", None, "mdi:math-compass", 3, None],
+        "WaterPressure": [
             "WaterPressure",
             UnitOfPressure.BAR,
             "mdi:water-pump",
             0,
             SensorDeviceClass.PRESSURE,
-        ),
-        "Zone1RoomZoneMapping": ("z1RoomZoneMapping", None, "mdi:label", 0, None),
-        "Zone1NightTemperature": (
+        ],
+        "Zone1RoomZoneMapping": ["z1RoomZoneMapping", None, "mdi:label", 0, None],
+        "Zone1NightTemperature": [
             "z1NightTemp",
             UnitOfTemperature.CELSIUS,
             "mdi:weather-night",
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Zone1DayTemperature": (
+        ],
+        "Zone1DayTemperature": [
             "z1DayTemp",
             UnitOfTemperature.CELSIUS,
             "mdi:weather-sunny",
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Zone1HolidayTemperature": (
+        ],
+        "Zone1HolidayTemperature": [
             "z1HolidayTemp",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Zone1RoomTemperature": (
+        ],
+        "Zone1RoomTemperature": [
             "z1RoomTemp",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Zone1ActualRoomTemperatureDesired": (
+        ],
+        "Zone1ActualRoomTemperatureDesired": [
             "z1ActualRoomTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Zone1TimerMonday": ("z1Timer.Monday", None, "mdi:timer-outline", 1, None),
-        "Zone1TimerTuesday": ("z1Timer.Tuesday", None, "mdi:timer-outline", 1, None),
-        "Zone1TimerWednesday": (
+        ],
+        "Zone1TimerMonday": ["z1Timer.Monday", None, "mdi:timer-outline", 1, None],
+        "Zone1TimerTuesday": ["z1Timer.Tuesday", None, "mdi:timer-outline", 1, None],
+        "Zone1TimerWednesday": [
             "z1Timer.Wednesday",
             None,
             "mdi:timer-outline",
             1,
             None,
-        ),
-        "Zone1TimerThursday": ("z1Timer.Thursday", None, "mdi:timer-outline", 1, None),
-        "Zone1TimerFriday": ("z1Timer.Friday", None, "mdi:timer-outline", 1, None),
-        "Zone1TimerSaturday": ("z1Timer.Saturday", None, "mdi:timer-outline", 1, None),
-        "Zone1TimerSunday": ("z1Timer.Sunday", None, "mdi:timer-outline", 1, None),
-        "Zone1OperativeMode": ("z1OpMode", None, "mdi:math-compass", 3, None),
-        "ContinuosHeating": (
+        ],
+        "Zone1TimerThursday": ["z1Timer.Thursday", None, "mdi:timer-outline", 1, None],
+        "Zone1TimerFriday": ["z1Timer.Friday", None, "mdi:timer-outline", 1, None],
+        "Zone1TimerSaturday": ["z1Timer.Saturday", None, "mdi:timer-outline", 1, None],
+        "Zone1TimerSunday": ["z1Timer.Sunday", None, "mdi:timer-outline", 1, None],
+        "Zone1OperativeMode": ["z1OpMode", None, "mdi:math-compass", 3, None],
+        "ContinuosHeating": [
             "ContinuosHeating",
             UnitOfTemperature.CELSIUS,
             "mdi:weather-snowy",
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "PowerEnergyConsumptionLastMonth": (
+        ],
+        "PowerEnergyConsumptionLastMonth": [
             "PrEnergySumHcLastMonth",
             UnitOfEnergy.KILO_WATT_HOUR,
             "mdi:flash",
             0,
             SensorDeviceClass.ENERGY,
-        ),
-        "PowerEnergyConsumptionThisMonth": (
+        ],
+        "PowerEnergyConsumptionThisMonth": [
             "PrEnergySumHcThisMonth",
             UnitOfEnergy.KILO_WATT_HOUR,
             "mdi:flash",
             0,
             SensorDeviceClass.ENERGY,
-        ),
+        ],
     },
     "ehp": {
-        "HWTemperature": (
+        "HWTemperature": [
             "HwcTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "OutsideTemp": (
+        ],
+        "OutsideTemp": [
             "OutsideTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
+        ],
     },
     "bai": {
-        "HotWaterTemperature": (
+        "HotWaterTemperature": [
             "HwcTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "StorageTemperature": (
+        ],
+        "StorageTemperature": [
             "StorageTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "DesiredStorageTemperature": (
+        ],
+        "DesiredStorageTemperature": [
             "StorageTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "OutdoorsTemperature": (
+        ],
+        "OutdoorsTemperature": [
             "OutdoorstempSensor",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "WaterPressure": (
+        ],
+        "WaterPressure": [
             "WaterPressure",
             UnitOfPressure.BAR,
             "mdi:pipe",
             4,
             SensorDeviceClass.PRESSURE,
-        ),
-        "AverageIgnitionTime": (
+        ],
+        "AverageIgnitionTime": [
             "averageIgnitiontime",
             UnitOfTime.SECONDS,
             "mdi:av-timer",
             0,
             SensorDeviceClass.DURATION,
-        ),
-        "MaximumIgnitionTime": (
+        ],
+        "MaximumIgnitionTime": [
             "maxIgnitiontime",
             UnitOfTime.SECONDS,
             "mdi:av-timer",
             0,
             SensorDeviceClass.DURATION,
-        ),
-        "MinimumIgnitionTime": (
+        ],
+        "MinimumIgnitionTime": [
             "minIgnitiontime",
             UnitOfTime.SECONDS,
             "mdi:av-timer",
             0,
             SensorDeviceClass.DURATION,
-        ),
-        "ReturnTemperature": (
+        ],
+        "ReturnTemperature": [
             "ReturnTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "CentralHeatingPump": ("WP", None, "mdi:toggle-switch", 2, None),
-        "HeatingSwitch": ("HeatingSwitch", None, "mdi:toggle-switch", 2, None),
-        "DesiredFlowTemperature": (
+        ],
+        "CentralHeatingPump": ["WP", None, "mdi:toggle-switch", 2, None],
+        "HeatingSwitch": ["HeatingSwitch", None, "mdi:toggle-switch", 2, None],
+        "DesiredFlowTemperature": [
             "FlowTempDesired",
             UnitOfTemperature.CELSIUS,
             None,
             0,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "FlowTemperature": (
+        ],
+        "FlowTemperature": [
             "FlowTemp",
             UnitOfTemperature.CELSIUS,
             None,
             4,
             SensorDeviceClass.TEMPERATURE,
-        ),
-        "Flame": ("Flame", None, "mdi:toggle-switch", 2, None),
-        "PowerEnergyConsumptionHeatingCircuit": (
+        ],
+        "Flame": ["Flame", None, "mdi:toggle-switch", 2, None],
+        "PowerEnergyConsumptionHeatingCircuit": [
             "PrEnergySumHc1",
             UnitOfEnergy.KILO_WATT_HOUR,
             "mdi:flash",
             0,
             SensorDeviceClass.ENERGY,
-        ),
-        "PowerEnergyConsumptionHotWaterCircuit": (
+        ],
+        "PowerEnergyConsumptionHotWaterCircuit": [
             "PrEnergySumHwc1",
             UnitOfEnergy.KILO_WATT_HOUR,
             "mdi:flash",
             0,
             SensorDeviceClass.ENERGY,
-        ),
-        "RoomThermostat": ("DCRoomthermostat", None, "mdi:toggle-switch", 2, None),
-        "HeatingPartLoad": (
+        ],
+        "RoomThermostat": ["DCRoomthermostat", None, "mdi:toggle-switch", 2, None],
+        "HeatingPartLoad": [
             "PartloadHcKW",
             UnitOfEnergy.KILO_WATT_HOUR,
             "mdi:flash",
             0,
             SensorDeviceClass.ENERGY,
-        ),
-        "StateNumber": ("StateNumber", None, "mdi:fire", 3, None),
-        "ModulationPercentage": (
+        ],
+        "StateNumber": ["StateNumber", None, "mdi:fire", 3, None],
+        "ModulationPercentage": [
             "ModulationTempDesired",
             PERCENTAGE,
             "mdi:percent",
             0,
             None,
-        ),
+        ],
     },
 }

homeassistant/components/ebusd/sensor.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import datetime
 import logging
-from typing import Any, cast
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
 from homeassistant.core import HomeAssistant
@@ -12,8 +11,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import Throttle, dt as dt_util
 
-from . import EbusdData
-from .const import EBUSD_DATA, SensorSpecs
+from .const import DOMAIN
 
 TIME_FRAME1_BEGIN = "time_frame1_begin"
 TIME_FRAME1_END = "time_frame1_end"
@@ -35,9 +33,9 @@ def setup_platform(
     """Set up the Ebus sensor."""
     if not discovery_info:
         return
-    ebusd_api = hass.data[EBUSD_DATA]
-    monitored_conditions: list[str] = discovery_info["monitored_conditions"]
-    name: str = discovery_info["client_name"]
+    ebusd_api = hass.data[DOMAIN]
+    monitored_conditions = discovery_info["monitored_conditions"]
+    name = discovery_info["client_name"]
 
     add_entities(
         (
@@ -51,8 +49,9 @@ def setup_platform(
 class EbusdSensor(SensorEntity):
     """Ebusd component sensor methods definition."""
 
-    def __init__(self, data: EbusdData, sensor: SensorSpecs, name: str) -> None:
+    def __init__(self, data, sensor, name):
         """Initialize the sensor."""
+        self._state = None
         self._client_name = name
         (
             self._name,
@@ -64,15 +63,20 @@ class EbusdSensor(SensorEntity):
         self.data = data
 
     @property
-    def name(self) -> str:
+    def name(self):
         """Return the name of the sensor."""
         return f"{self._client_name} {self._name}"
 
     @property
-    def extra_state_attributes(self) -> dict[str, Any] | None:
+    def native_value(self):
+        """Return the state of the sensor."""
+        return self._state
+
+    @property
+    def extra_state_attributes(self):
         """Return the device state attributes."""
-        if self._type == 1 and (native_value := self.native_value) is not None:
-            schedule: dict[str, str | None] = {
+        if self._type == 1 and self._state is not None:
+            schedule = {
                 TIME_FRAME1_BEGIN: None,
                 TIME_FRAME1_END: None,
                 TIME_FRAME2_BEGIN: None,
@@ -80,7 +84,7 @@ class EbusdSensor(SensorEntity):
                 TIME_FRAME3_BEGIN: None,
                 TIME_FRAME3_END: None,
             }
-            time_frame = cast(str, native_value).split(";")
+            time_frame = self._state.split(";")
             for index, item in enumerate(sorted(schedule.items())):
                 if index < len(time_frame):
                     parsed = datetime.datetime.strptime(time_frame[index], "%H:%M")
@@ -97,12 +101,12 @@ class EbusdSensor(SensorEntity):
         return self._device_class
 
     @property
-    def icon(self) -> str | None:
+    def icon(self):
         """Icon to use in the frontend, if any."""
         return self._icon
 
     @property
-    def native_unit_of_measurement(self) -> str | None:
+    def native_unit_of_measurement(self):
         """Return the unit of measurement."""
         return self._unit_of_measurement
 
@@ -114,6 +118,6 @@ class EbusdSensor(SensorEntity):
             if self._name not in self.data.value:
                 return
 
-            self._attr_native_value = self.data.value[self._name]
+            self._state = self.data.value[self._name]
         except RuntimeError:
             _LOGGER.debug("EbusdData.update exception")

homeassistant/components/hue/v1/sensor_base.py

@@ -181,7 +181,7 @@ class GenericHueSensor(GenericHueDevice, entity.Entity):  # pylint: disable=hass
         )
 
     @property
-    def state_class(self) -> SensorStateClass:
+    def state_class(self):
         """Return the state class of this entity, from STATE_CLASSES, if any."""
         return SensorStateClass.MEASUREMENT
 

homeassistant/components/mfi/sensor.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 
-from mficlient.client import FailedToLogin, MFiClient, Port as MFiPort
+from mficlient.client import FailedToLogin, MFiClient
 import requests
 import voluptuous as vol
 
@@ -12,7 +12,6 @@ from homeassistant.components.sensor import (
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorDeviceClass,
     SensorEntity,
-    StateType,
 )
 from homeassistant.const import (
     CONF_HOST,
@@ -65,29 +64,24 @@ def setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up mFi sensors."""
-    host: str = config[CONF_HOST]
-    username: str = config[CONF_USERNAME]
-    password: str = config[CONF_PASSWORD]
-    use_tls: bool = config[CONF_SSL]
-    verify_tls: bool = config[CONF_VERIFY_SSL]
+    host = config.get(CONF_HOST)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    use_tls = config.get(CONF_SSL)
+    verify_tls = config.get(CONF_VERIFY_SSL)
     default_port = 6443 if use_tls else 6080
-    network_port: int = config.get(CONF_PORT, default_port)
+    port = int(config.get(CONF_PORT, default_port))
 
     try:
         client = MFiClient(
-            host,
-            username,
-            password,
-            port=network_port,
-            use_tls=use_tls,
-            verify=verify_tls,
+            host, username, password, port=port, use_tls=use_tls, verify=verify_tls
         )
     except (FailedToLogin, requests.exceptions.ConnectionError) as ex:
         _LOGGER.error("Unable to connect to mFi: %s", str(ex))
         return
 
     add_entities(
-        MfiSensor(port)
+        MfiSensor(port, hass)
         for device in client.get_devices()
         for port in device.ports.values()
         if port.model in SENSOR_MODELS
@@ -97,17 +91,18 @@ def setup_platform(
 class MfiSensor(SensorEntity):
     """Representation of a mFi sensor."""
 
-    def __init__(self, port: MFiPort) -> None:
+    def __init__(self, port, hass):
         """Initialize the sensor."""
         self._port = port
+        self._hass = hass
 
     @property
-    def name(self) -> str:
+    def name(self):
         """Return the name of the sensor."""
         return self._port.label
 
     @property
-    def native_value(self) -> StateType:
+    def native_value(self):
         """Return the state of the sensor."""
         try:
             tag = self._port.tag
@@ -134,7 +129,7 @@ class MfiSensor(SensorEntity):
         return None
 
     @property
-    def native_unit_of_measurement(self) -> str | None:
+    def native_unit_of_measurement(self):
         """Return the unit of measurement of this entity, if any."""
         try:
             tag = self._port.tag

homeassistant/components/mfi/switch.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from mficlient.client import FailedToLogin, MFiClient, Port as MFiPort
+from mficlient.client import FailedToLogin, MFiClient
 import requests
 import voluptuous as vol
 
@@ -51,23 +51,18 @@ def setup_platform(
     add_entities: AddEntitiesCallback,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up mFi switches."""
-    host: str = config[CONF_HOST]
-    username: str = config[CONF_USERNAME]
-    password: str = config[CONF_PASSWORD]
-    use_tls: bool = config[CONF_SSL]
-    verify_tls: bool = config[CONF_VERIFY_SSL]
+    """Set up mFi sensors."""
+    host = config.get(CONF_HOST)
+    username = config.get(CONF_USERNAME)
+    password = config.get(CONF_PASSWORD)
+    use_tls = config[CONF_SSL]
+    verify_tls = config.get(CONF_VERIFY_SSL)
     default_port = 6443 if use_tls else 6080
-    network_port: int = config.get(CONF_PORT, default_port)
+    port = int(config.get(CONF_PORT, default_port))
 
     try:
         client = MFiClient(
-            host,
-            username,
-            password,
-            port=network_port,
-            use_tls=use_tls,
-            verify=verify_tls,
+            host, username, password, port=port, use_tls=use_tls, verify=verify_tls
         )
     except (FailedToLogin, requests.exceptions.ConnectionError) as ex:
         _LOGGER.error("Unable to connect to mFi: %s", str(ex))
@@ -84,23 +79,23 @@ def setup_platform(
 class MfiSwitch(SwitchEntity):
     """Representation of an mFi switch-able device."""
 
-    def __init__(self, port: MFiPort) -> None:
+    def __init__(self, port):
         """Initialize the mFi device."""
         self._port = port
-        self._target_state: bool | None = None
+        self._target_state = None
 
     @property
-    def unique_id(self) -> str:
+    def unique_id(self):
         """Return the unique ID of the device."""
         return self._port.ident
 
     @property
-    def name(self) -> str:
+    def name(self):
         """Return the name of the device."""
         return self._port.label
 
     @property
-    def is_on(self) -> bool | None:
+    def is_on(self):
         """Return true if the device is on."""
         return self._port.output
 

homeassistant/components/onedrive/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["onedrive_personal_sdk"],
   "quality_scale": "platinum",
-  "requirements": ["onedrive-personal-sdk==0.1.0"]
+  "requirements": ["onedrive-personal-sdk==0.0.17"]
 }

homeassistant/components/openai_conversation/config_flow.py

@@ -112,49 +112,45 @@ class OpenAIConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="user", data_schema=STEP_USER_DATA_SCHEMA
+            )
 
         errors: dict[str, str] = {}
 
-        if user_input is not None:
-            self._async_abort_entries_match(user_input)
-            try:
-                await validate_input(self.hass, user_input)
-            except openai.APIConnectionError:
-                errors["base"] = "cannot_connect"
-            except openai.AuthenticationError:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                return self.async_create_entry(
-                    title="ChatGPT",
-                    data=user_input,
-                    subentries=[
-                        {
-                            "subentry_type": "conversation",
-                            "data": RECOMMENDED_CONVERSATION_OPTIONS,
-                            "title": DEFAULT_CONVERSATION_NAME,
-                            "unique_id": None,
-                        },
-                        {
-                            "subentry_type": "ai_task_data",
-                            "data": RECOMMENDED_AI_TASK_OPTIONS,
-                            "title": DEFAULT_AI_TASK_NAME,
-                            "unique_id": None,
-                        },
-                    ],
-                )
+        self._async_abort_entries_match(user_input)
+        try:
+            await validate_input(self.hass, user_input)
+        except openai.APIConnectionError:
+            errors["base"] = "cannot_connect"
+        except openai.AuthenticationError:
+            errors["base"] = "invalid_auth"
+        except Exception:
+            _LOGGER.exception("Unexpected exception")
+            errors["base"] = "unknown"
+        else:
+            return self.async_create_entry(
+                title="ChatGPT",
+                data=user_input,
+                subentries=[
+                    {
+                        "subentry_type": "conversation",
+                        "data": RECOMMENDED_CONVERSATION_OPTIONS,
+                        "title": DEFAULT_CONVERSATION_NAME,
+                        "unique_id": None,
+                    },
+                    {
+                        "subentry_type": "ai_task_data",
+                        "data": RECOMMENDED_AI_TASK_OPTIONS,
+                        "title": DEFAULT_AI_TASK_NAME,
+                        "unique_id": None,
+                    },
+                ],
+            )
 
         return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, user_input
-            ),
-            errors=errors,
-            description_placeholders={
-                "instructions_url": "https://www.home-assistant.io/integrations/openai_conversation/#generate-an-api-key",
-            },
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
     @classmethod

homeassistant/components/openai_conversation/strings.json

@@ -12,11 +12,7 @@
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "Your OpenAI API key."
-        },
-        "description": "Set up OpenAI Conversation integration by providing your OpenAI API key. Instructions to obtain an API key can be found [here]({instructions_url})."
+        }
       }
     }
   },

homeassistant/components/teslemetry/__init__.py

@@ -2,10 +2,10 @@
 
 import asyncio
 from collections.abc import Callable
-from functools import partial
 from typing import Final
 
-from aiohttp import ClientError, ClientResponseError
+from aiohttp import ClientResponseError
+from aiohttp.client_exceptions import ClientError
 from tesla_fleet_api.const import Scope
 from tesla_fleet_api.exceptions import (
     Forbidden,
@@ -27,7 +27,6 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
     OAuth2Session,
     async_get_config_entry_implementation,
 )
@@ -76,48 +75,28 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-async def _get_access_token(oauth_session: OAuth2Session) -> str:
-    """Get a valid access token, refreshing if necessary."""
-    LOGGER.debug(
-        "Token valid: %s, expires_at: %s",
-        oauth_session.valid_token,
-        oauth_session.token.get("expires_at"),
-    )
-    try:
-        await oauth_session.async_ensure_token_valid()
-    except ClientResponseError as err:
-        if err.status == 401:
-            raise ConfigEntryAuthFailed from err
-        raise ConfigEntryNotReady from err
-    except (KeyError, TypeError) as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="token_data_malformed",
-        ) from err
-    except ClientError as err:
-        raise ConfigEntryNotReady from err
-    return oauth_session.token[CONF_ACCESS_TOKEN]
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: TeslemetryConfigEntry) -> bool:
     """Set up Teslemetry config."""
 
     session = async_get_clientsession(hass)
 
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="oauth_implementation_not_available",
-        ) from err
+    implementation = await async_get_config_entry_implementation(hass, entry)
     oauth_session = OAuth2Session(hass, entry, implementation)
 
+    async def _get_access_token() -> str:
+        try:
+            await oauth_session.async_ensure_token_valid()
+        except ClientResponseError as e:
+            if e.status == 401:
+                raise ConfigEntryAuthFailed from e
+            raise ConfigEntryNotReady from e
+        token: str = oauth_session.token[CONF_ACCESS_TOKEN]
+        return token
+
     # Create API connection
-    access_token = partial(_get_access_token, oauth_session)
     teslemetry = Teslemetry(
         session=session,
-        access_token=access_token,
+        access_token=_get_access_token,
     )
     try:
         calls = await asyncio.gather(
@@ -175,7 +154,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: TeslemetryConfigEntry) -
             if not stream:
                 stream = TeslemetryStream(
                     session,
-                    access_token,
+                    _get_access_token,
                     server=f"{region.lower()}.teslemetry.com",
                     parse_timestamp=True,
                     manual=True,

homeassistant/components/teslemetry/strings.json

@@ -997,6 +997,7 @@
       "total_grid_energy_exported": {
         "name": "Grid exported"
       },
+
       "total_home_usage": {
         "name": "Home usage"
       },
@@ -1126,9 +1127,6 @@
     "no_vehicle_data_for_device": {
       "message": "No vehicle data for device ID: {device_id}"
     },
-    "oauth_implementation_not_available": {
-      "message": "OAuth implementation not available, try reauthenticating"
-    },
     "set_scheduled_charging_time": {
       "message": "Scheduled charging time is required when enabling"
     },
@@ -1138,9 +1136,6 @@
     "set_scheduled_departure_preconditioning": {
       "message": "Preconditioning departure time is required when enabling"
     },
-    "token_data_malformed": {
-      "message": "Token data malformed, try reauthenticating"
-    },
     "wake_up_failed": {
       "message": "Failed to wake up vehicle: {message}"
     },

homeassistant/components/utility_meter/sensor.py

@@ -700,7 +700,7 @@ class UtilityMeterSensor(RestoreSensor):
         return None
 
     @property
-    def state_class(self) -> SensorStateClass:
+    def state_class(self):
         """Return the device class of the sensor."""
         return (
             SensorStateClass.TOTAL

pylint/plugins/hass_enforce_type_hints.py

@@ -700,7 +700,6 @@ _ENTITY_MATCH: list[TypeHintMatch] = [
     TypeHintMatch(
         function_name="device_class",
         return_type=["str", None],
-        mandatory=True,
     ),
     TypeHintMatch(
         function_name="unit_of_measurement",
@@ -2519,12 +2518,10 @@ _INHERITANCE_MATCH: dict[str, list[ClassTypeHintMatch]] = {
                 TypeHintMatch(
                     function_name="state_class",
                     return_type=["SensorStateClass", "str", None],
-                    mandatory=True,
                 ),
                 TypeHintMatch(
                     function_name="last_reset",
                     return_type=["datetime", None],
-                    mandatory=True,
                 ),
                 TypeHintMatch(
                     function_name="native_value",

requirements_all.txt

@@ -1646,7 +1646,7 @@ omnilogic==0.4.5
 ondilo==0.5.0
 
 # homeassistant.components.onedrive
-onedrive-personal-sdk==0.1.0
+onedrive-personal-sdk==0.0.17
 
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4

requirements_test_all.txt

@@ -1429,7 +1429,7 @@ omnilogic==0.4.5
 ondilo==0.5.0
 
 # homeassistant.components.onedrive
-onedrive-personal-sdk==0.1.0
+onedrive-personal-sdk==0.0.17
 
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4

tests/components/__init__.py

@@ -254,13 +254,21 @@ def parametrize_condition_states(
                         state_with_attributes(other_state, False, True)
                         for other_state in other_states
                     ),
-                    (
-                        state_with_attributes(target_state, True, True)
-                        for target_state in target_states
-                    ),
-                )
+                ),
             ),
         ),
+        # Test each target state individually to isolate condition_true expectations
+        *(
+            (
+                condition,
+                condition_options,
+                [
+                    state_with_attributes(other_states[0], False, True),
+                    state_with_attributes(target_state, True, True),
+                ],
+            )
+            for target_state in target_states
+        ),
     ]
 
 

tests/components/alarm_control_panel/test_condition.py

@@ -0,0 +1,275 @@
+"""Test alarm_control_panel conditions."""
+
+from typing import Any
+
+import pytest
+
+from homeassistant.components.alarm_control_panel import (
+    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
+)
+from homeassistant.const import ATTR_SUPPORTED_FEATURES
+from homeassistant.core import HomeAssistant
+
+from tests.components import (
+    ConditionStateDescription,
+    assert_condition_gated_by_labs_flag,
+    create_target_condition,
+    other_states,
+    parametrize_condition_states,
+    parametrize_target_entities,
+    set_or_remove_state,
+    target_entities,
+)
+
+
+@pytest.fixture(autouse=True, name="stub_blueprint_populate")
+def stub_blueprint_populate_autouse(stub_blueprint_populate: None) -> None:
+    """Stub copying the blueprints to the config folder."""
+
+
+@pytest.fixture
+async def target_alarm_control_panels(hass: HomeAssistant) -> list[str]:
+    """Create multiple alarm_control_panel entities associated with different targets."""
+    return (await target_entities(hass, "alarm_control_panel"))["included"]
+
+
+@pytest.mark.parametrize(
+    "condition",
+    [
+        "alarm_control_panel.is_armed",
+        "alarm_control_panel.is_armed_away",
+        "alarm_control_panel.is_armed_home",
+        "alarm_control_panel.is_armed_night",
+        "alarm_control_panel.is_armed_vacation",
+        "alarm_control_panel.is_disarmed",
+        "alarm_control_panel.is_triggered",
+    ],
+)
+async def test_alarm_control_panel_conditions_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, condition: str
+) -> None:
+    """Test the alarm_control_panel conditions are gated by the labs flag."""
+    await assert_condition_gated_by_labs_flag(hass, caplog, condition)
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("condition_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("alarm_control_panel"),
+)
+@pytest.mark.parametrize(
+    ("condition", "condition_options", "states"),
+    [
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed",
+            target_states=[
+                AlarmControlPanelState.ARMED_AWAY,
+                AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+                AlarmControlPanelState.ARMED_HOME,
+                AlarmControlPanelState.ARMED_NIGHT,
+                AlarmControlPanelState.ARMED_VACATION,
+            ],
+            other_states=[
+                AlarmControlPanelState.ARMING,
+                AlarmControlPanelState.DISARMED,
+                AlarmControlPanelState.DISARMING,
+                AlarmControlPanelState.PENDING,
+                AlarmControlPanelState.TRIGGERED,
+            ],
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_away",
+            target_states=[AlarmControlPanelState.ARMED_AWAY],
+            other_states=other_states(AlarmControlPanelState.ARMED_AWAY),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_AWAY
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_home",
+            target_states=[AlarmControlPanelState.ARMED_HOME],
+            other_states=other_states(AlarmControlPanelState.ARMED_HOME),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_HOME
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_night",
+            target_states=[AlarmControlPanelState.ARMED_NIGHT],
+            other_states=other_states(AlarmControlPanelState.ARMED_NIGHT),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_NIGHT
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_vacation",
+            target_states=[AlarmControlPanelState.ARMED_VACATION],
+            other_states=other_states(AlarmControlPanelState.ARMED_VACATION),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_VACATION
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_disarmed",
+            target_states=[AlarmControlPanelState.DISARMED],
+            other_states=other_states(AlarmControlPanelState.DISARMED),
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_triggered",
+            target_states=[AlarmControlPanelState.TRIGGERED],
+            other_states=other_states(AlarmControlPanelState.TRIGGERED),
+        ),
+    ],
+)
+async def test_alarm_control_panel_state_condition_behavior_any(
+    hass: HomeAssistant,
+    target_alarm_control_panels: list[str],
+    condition_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    condition: str,
+    condition_options: dict[str, Any],
+    states: list[ConditionStateDescription],
+) -> None:
+    """Test the alarm_control_panel state condition with the 'any' behavior."""
+    other_entity_ids = set(target_alarm_control_panels) - {entity_id}
+
+    # Set all alarm_control_panels, including the tested alarm_control_panel, to the initial state
+    for eid in target_alarm_control_panels:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
+        hass,
+        condition=condition,
+        target=condition_target_config,
+        behavior="any",
+    )
+
+    for state in states:
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+        # Check if changing other alarm_control_panels also passes the condition
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        assert condition(hass) == state["condition_true"]
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("condition_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("alarm_control_panel"),
+)
+@pytest.mark.parametrize(
+    ("condition", "condition_options", "states"),
+    [
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed",
+            target_states=[
+                AlarmControlPanelState.ARMED_AWAY,
+                AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+                AlarmControlPanelState.ARMED_HOME,
+                AlarmControlPanelState.ARMED_NIGHT,
+                AlarmControlPanelState.ARMED_VACATION,
+            ],
+            other_states=[
+                AlarmControlPanelState.ARMING,
+                AlarmControlPanelState.DISARMED,
+                AlarmControlPanelState.DISARMING,
+                AlarmControlPanelState.PENDING,
+                AlarmControlPanelState.TRIGGERED,
+            ],
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_away",
+            target_states=[AlarmControlPanelState.ARMED_AWAY],
+            other_states=other_states(AlarmControlPanelState.ARMED_AWAY),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_AWAY
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_home",
+            target_states=[AlarmControlPanelState.ARMED_HOME],
+            other_states=other_states(AlarmControlPanelState.ARMED_HOME),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_HOME
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_night",
+            target_states=[AlarmControlPanelState.ARMED_NIGHT],
+            other_states=other_states(AlarmControlPanelState.ARMED_NIGHT),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_NIGHT
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_armed_vacation",
+            target_states=[AlarmControlPanelState.ARMED_VACATION],
+            other_states=other_states(AlarmControlPanelState.ARMED_VACATION),
+            additional_attributes={
+                ATTR_SUPPORTED_FEATURES: AlarmControlPanelEntityFeature.ARM_VACATION
+            },
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_disarmed",
+            target_states=[AlarmControlPanelState.DISARMED],
+            other_states=other_states(AlarmControlPanelState.DISARMED),
+        ),
+        *parametrize_condition_states(
+            condition="alarm_control_panel.is_triggered",
+            target_states=[AlarmControlPanelState.TRIGGERED],
+            other_states=other_states(AlarmControlPanelState.TRIGGERED),
+        ),
+    ],
+)
+async def test_alarm_control_panel_state_condition_behavior_all(
+    hass: HomeAssistant,
+    target_alarm_control_panels: list[str],
+    condition_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    condition: str,
+    condition_options: dict[str, Any],
+    states: list[ConditionStateDescription],
+) -> None:
+    """Test the alarm_control_panel state condition with the 'all' behavior."""
+    other_entity_ids = set(target_alarm_control_panels) - {entity_id}
+
+    # Set all alarm_control_panels, including the tested alarm_control_panel, to the initial state
+    for eid in target_alarm_control_panels:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+
+    condition = await create_target_condition(
+        hass,
+        condition=condition,
+        target=condition_target_config,
+        behavior="all",
+    )
+
+    for state in states:
+        included_state = state["included"]
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        # The condition passes if all entities are either in a target state or invalid
+        assert condition(hass) == (
+            (not state["state_valid"])
+            or (state["condition_true"] and entities_in_target == 1)
+        )
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+
+        # The condition passes if all entities are either in a target state or invalid
+        assert condition(hass) == (
+            (not state["state_valid"]) or state["condition_true"]
+        )

tests/components/mfi/test_sensor.py

@@ -34,7 +34,7 @@ async def test_setup_missing_config(hass: HomeAssistant) -> None:
     """Test setup with missing configuration."""
     with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         config = {"sensor": {"platform": "mfi"}}
-        assert await async_setup_component(hass, COMPONENT.DOMAIN, config)
+        assert await async_setup_component(hass, "sensor", config)
         assert not mock_client.called
 
 
@@ -42,14 +42,14 @@ async def test_setup_failed_login(hass: HomeAssistant) -> None:
     """Test setup with login failure."""
     with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         mock_client.side_effect = FailedToLogin
-        assert not PLATFORM.setup_platform(hass, GOOD_CONFIG[COMPONENT.DOMAIN], None)
+        assert not PLATFORM.setup_platform(hass, GOOD_CONFIG, None)
 
 
 async def test_setup_failed_connect(hass: HomeAssistant) -> None:
     """Test setup with connection failure."""
     with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         mock_client.side_effect = requests.exceptions.ConnectionError
-        assert not PLATFORM.setup_platform(hass, GOOD_CONFIG[COMPONENT.DOMAIN], None)
+        assert not PLATFORM.setup_platform(hass, GOOD_CONFIG, None)
 
 
 async def test_setup_minimum(hass: HomeAssistant) -> None:
@@ -111,7 +111,7 @@ async def test_setup_adds_proper_devices(hass: HomeAssistant) -> None:
         await hass.async_block_till_done()
         for ident, port in ports.items():
             if ident != "bad":
-                mock_sensor.assert_any_call(port)
+                mock_sensor.assert_any_call(port, hass)
         assert mock.call(ports["bad"], hass) not in mock_sensor.mock_calls
 
 
@@ -124,7 +124,7 @@ def port_fixture() -> mock.MagicMock:
 @pytest.fixture(name="sensor")
 def sensor_fixture(hass: HomeAssistant, port: mock.MagicMock) -> mfi.MfiSensor:
     """Sensor fixture."""
-    sensor = mfi.MfiSensor(port)
+    sensor = mfi.MfiSensor(port, hass)
     sensor.hass = hass
     return sensor
 

tests/components/openai_conversation/test_config_flow.py

@@ -58,7 +58,7 @@ async def test_form(hass: HomeAssistant) -> None:
         DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
-    assert result["errors"] == {}
+    assert result["errors"] is None
 
     with (
         patch(

tests/components/teslemetry/test_init.py

@@ -443,37 +443,6 @@ async def test_migrate_from_future_version_fails(hass: HomeAssistant) -> None:
     assert entry.version == 3  # Version should remain unchanged
 
 
-async def test_oauth_implementation_not_available(hass: HomeAssistant) -> None:
-    """Test that missing OAuth implementation triggers reauth."""
-    mock_entry = MockConfigEntry(
-        domain=DOMAIN,
-        version=2,
-        unique_id=UNIQUE_ID,
-        data={
-            "auth_implementation": DOMAIN,
-            "token": {
-                "access_token": "test_access_token",
-                "refresh_token": "test_refresh_token",
-                "expires_at": int(time.time()) + 3600,
-            },
-        },
-    )
-    mock_entry.add_to_hass(hass)
-
-    # Mock the implementation lookup to raise ValueError
-    with patch(
-        "homeassistant.components.teslemetry.async_get_config_entry_implementation",
-        side_effect=ValueError("Implementation not available"),
-    ):
-        await hass.config_entries.async_setup(mock_entry.entry_id)
-        await hass.async_block_till_done()
-
-    entry = hass.config_entries.async_get_entry(mock_entry.entry_id)
-    assert entry is not None
-    # Should trigger reauth, not just fail silently
-    assert entry.state is ConfigEntryState.SETUP_ERROR
-
-
 RETRY_EXCEPTIONS = [
     (RateLimited(data={"after": 5}), 5.0),
     (InvalidResponse(), 10.0),