Update snapshots

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.claude/skills/integrations/SKILL.md

@@ -0,0 +1,784 @@
+---
+name: Home Assistant Integration knowledge
+description: Everything you need to know to build, test and review Home Assistant Integrations. If you're looking at an integration, you must use this as your primary reference.
+---
+
+### File Locations
+- **Integration code**: `./homeassistant/components/<integration_domain>/`
+- **Integration tests**: `./tests/components/<integration_domain>/`
+
+## Integration Templates
+
+### Standard Integration Structure
+```
+homeassistant/components/my_integration/
+├── __init__.py          # Entry point with async_setup_entry
+├── manifest.json        # Integration metadata and dependencies
+├── const.py            # Domain and constants
+├── config_flow.py      # UI configuration flow
+├── coordinator.py      # Data update coordinator (if needed)
+├── entity.py          # Base entity class (if shared patterns)
+├── sensor.py          # Sensor platform
+├── strings.json        # User-facing text and translations
+├── services.yaml       # Service definitions (if applicable)
+└── quality_scale.yaml  # Quality scale rule status
+```
+
+An integration can have platforms as needed (e.g., `sensor.py`, `switch.py`, etc.). The following platforms have extra guidelines:
+- **Diagnostics**: [`platform-diagnostics.md`](platform-diagnostics.md) for diagnostic data collection
+- **Repairs**: [`platform-repairs.md`](platform-repairs.md) for user-actionable repair issues
+
+### Minimal Integration Checklist
+- [ ] `manifest.json` with required fields (domain, name, codeowners, etc.)
+- [ ] `__init__.py` with `async_setup_entry` and `async_unload_entry`
+- [ ] `config_flow.py` with UI configuration support
+- [ ] `const.py` with `DOMAIN` constant
+- [ ] `strings.json` with at least config flow text
+- [ ] Platform files (`sensor.py`, etc.) as needed
+- [ ] `quality_scale.yaml` with rule status tracking
+
+## Integration Quality Scale
+
+Home Assistant uses an Integration Quality Scale to ensure code quality and consistency. The quality level determines which rules apply:
+
+### Quality Scale Levels
+- **Bronze**: Basic requirements (ALL Bronze rules are mandatory)
+- **Silver**: Enhanced functionality
+- **Gold**: Advanced features
+- **Platinum**: Highest quality standards
+
+### Quality Scale Progression
+- **Bronze → Silver**: Add entity unavailability, parallel updates, auth flows
+- **Silver → Gold**: Add device management, diagnostics, translations
+- **Gold → Platinum**: Add strict typing, async dependencies, websession injection
+
+### How Rules Apply
+1. **Check `manifest.json`**: Look for `"quality_scale"` key to determine integration level
+2. **Bronze Rules**: Always required for any integration with quality scale
+3. **Higher Tier Rules**: Only apply if integration targets that tier or higher
+4. **Rule Status**: Check `quality_scale.yaml` in integration folder for:
+   - `done`: Rule implemented
+   - `exempt`: Rule doesn't apply (with reason in comment)
+   - `todo`: Rule needs implementation
+
+### Example `quality_scale.yaml` Structure
+```yaml
+rules:
+  # Bronze (mandatory)
+  config-flow: done
+  entity-unique-id: done
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+
+  # Silver (if targeting Silver+)
+  entity-unavailable: done
+  parallel-updates: done
+
+  # Gold (if targeting Gold+)
+  devices: done
+  diagnostics: done
+
+  # Platinum (if targeting Platinum)
+  strict-typing: done
+```
+
+**When Reviewing/Creating Code**: Always check the integration's quality scale level and exemption status before applying rules.
+
+## Code Organization
+
+### Core Locations
+- Shared constants: `homeassistant/const.py` (use these instead of hardcoding)
+- Integration structure:
+  - `homeassistant/components/{domain}/const.py` - Constants
+  - `homeassistant/components/{domain}/models.py` - Data models
+  - `homeassistant/components/{domain}/coordinator.py` - Update coordinator
+  - `homeassistant/components/{domain}/config_flow.py` - Configuration flow
+  - `homeassistant/components/{domain}/{platform}.py` - Platform implementations
+
+### Common Modules
+- **coordinator.py**: Centralize data fetching logic
+  ```python
+  class MyCoordinator(DataUpdateCoordinator[MyData]):
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass,
+              logger=LOGGER,
+              name=DOMAIN,
+              update_interval=timedelta(minutes=1),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
+  ```
+- **entity.py**: Base entity definitions to reduce duplication
+  ```python
+  class MyEntity(CoordinatorEntity[MyCoordinator]):
+      _attr_has_entity_name = True
+  ```
+
+### Runtime Data Storage
+- **Use ConfigEntry.runtime_data**: Store non-persistent runtime data
+  ```python
+  type MyIntegrationConfigEntry = ConfigEntry[MyClient]
+
+  async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
+      client = MyClient(entry.data[CONF_HOST])
+      entry.runtime_data = client
+  ```
+
+### Manifest Requirements
+- **Required Fields**: `domain`, `name`, `codeowners`, `integration_type`, `documentation`, `requirements`
+- **Integration Types**: `device`, `hub`, `service`, `system`, `helper`
+- **IoT Class**: Always specify connectivity method (e.g., `cloud_polling`, `local_polling`, `local_push`)
+- **Discovery Methods**: Add when applicable: `zeroconf`, `dhcp`, `bluetooth`, `ssdp`, `usb`
+- **Dependencies**: Include platform dependencies (e.g., `application_credentials`, `bluetooth_adapters`)
+
+### Config Flow Patterns
+- **Version Control**: Always set `VERSION = 1` and `MINOR_VERSION = 1`
+- **Unique ID Management**:
+  ```python
+  await self.async_set_unique_id(device_unique_id)
+  self._abort_if_unique_id_configured()
+  ```
+- **Error Handling**: Define errors in `strings.json` under `config.error`
+- **Step Methods**: Use standard naming (`async_step_user`, `async_step_discovery`, etc.)
+
+### Integration Ownership
+- **manifest.json**: Add GitHub usernames to `codeowners`:
+  ```json
+  {
+    "domain": "my_integration",
+    "name": "My Integration",
+    "codeowners": ["@me"]
+  }
+  ```
+
+### Async Dependencies (Platinum)
+- **Requirement**: All dependencies must use asyncio
+- Ensures efficient task handling without thread context switching
+
+### WebSession Injection (Platinum)
+- **Pass WebSession**: Support passing web sessions to dependencies
+  ```python
+  async def async_setup_entry(hass: HomeAssistant, entry: MyConfigEntry) -> bool:
+      """Set up integration from config entry."""
+      client = MyClient(entry.data[CONF_HOST], async_get_clientsession(hass))
+  ```
+- For cookies: Use `async_create_clientsession` (aiohttp) or `create_async_httpx_client` (httpx)
+
+### Data Update Coordinator
+- **Standard Pattern**: Use for efficient data management
+  ```python
+  class MyCoordinator(DataUpdateCoordinator):
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass,
+              logger=LOGGER,
+              name=DOMAIN,
+              update_interval=timedelta(minutes=5),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
+          self.client = client
+
+      async def _async_update_data(self):
+          try:
+              return await self.client.fetch_data()
+          except ApiError as err:
+              raise UpdateFailed(f"API communication error: {err}")
+  ```
+- **Error Types**: Use `UpdateFailed` for API errors, `ConfigEntryAuthFailed` for auth issues
+- **Config Entry**: Always pass `config_entry` parameter to coordinator - it's accepted and recommended
+
+## Integration Guidelines
+
+### Configuration Flow
+- **UI Setup Required**: All integrations must support configuration via UI
+- **Manifest**: Set `"config_flow": true` in `manifest.json`
+- **Data Storage**:
+  - Connection-critical config: Store in `ConfigEntry.data`
+  - Non-critical settings: Store in `ConfigEntry.options`
+- **Validation**: Always validate user input before creating entries
+- **Config Entry Naming**:
+  - ❌ Do NOT allow users to set config entry names in config flows
+  - Names are automatically generated or can be customized later in UI
+  - ✅ Exception: Helper integrations MAY allow custom names in config flow
+- **Connection Testing**: Test device/service connection during config flow:
+  ```python
+  try:
+      await client.get_data()
+  except MyException:
+      errors["base"] = "cannot_connect"
+  ```
+- **Duplicate Prevention**: Prevent duplicate configurations:
+  ```python
+  # Using unique ID
+  await self.async_set_unique_id(identifier)
+  self._abort_if_unique_id_configured()
+
+  # Using unique data
+  self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
+  ```
+
+### Reauthentication Support
+- **Required Method**: Implement `async_step_reauth` in config flow
+- **Credential Updates**: Allow users to update credentials without re-adding
+- **Validation**: Verify account matches existing unique ID:
+  ```python
+  await self.async_set_unique_id(user_id)
+  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: user_input[CONF_API_TOKEN]}
+  )
+  ```
+
+### Reconfiguration Flow
+- **Purpose**: Allow configuration updates without removing device
+- **Implementation**: Add `async_step_reconfigure` method
+- **Validation**: Prevent changing underlying account with `_abort_if_unique_id_mismatch`
+
+### Device Discovery
+- **Manifest Configuration**: Add discovery method (zeroconf, dhcp, etc.)
+  ```json
+  {
+    "zeroconf": ["_mydevice._tcp.local."]
+  }
+  ```
+- **Discovery Handler**: Implement appropriate `async_step_*` method:
+  ```python
+  async def async_step_zeroconf(self, discovery_info):
+      """Handle zeroconf discovery."""
+      await self.async_set_unique_id(discovery_info.properties["serialno"])
+      self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.host})
+  ```
+- **Network Updates**: Use discovery to update dynamic IP addresses
+
+### Network Discovery Implementation
+- **Zeroconf/mDNS**: Use async instances
+  ```python
+  aiozc = await zeroconf.async_get_async_instance(hass)
+  ```
+- **SSDP Discovery**: Register callbacks with cleanup
+  ```python
+  entry.async_on_unload(
+      ssdp.async_register_callback(
+          hass, _async_discovered_device,
+          {"st": "urn:schemas-upnp-org:device:ZonePlayer:1"}
+      )
+  )
+  ```
+
+### Bluetooth Integration
+- **Manifest Dependencies**: Add `bluetooth_adapters` to dependencies
+- **Connectable**: Set `"connectable": true` for connection-required devices
+- **Scanner Usage**: Always use shared scanner instance
+  ```python
+  scanner = bluetooth.async_get_scanner()
+  entry.async_on_unload(
+      bluetooth.async_register_callback(
+          hass, _async_discovered_device,
+          {"service_uuid": "example_uuid"},
+          bluetooth.BluetoothScanningMode.ACTIVE
+      )
+  )
+  ```
+- **Connection Handling**: Never reuse `BleakClient` instances, use 10+ second timeouts
+
+### Setup Validation
+- **Test Before Setup**: Verify integration can be set up in `async_setup_entry`
+- **Exception Handling**:
+  - `ConfigEntryNotReady`: Device offline or temporary failure
+  - `ConfigEntryAuthFailed`: Authentication issues
+  - `ConfigEntryError`: Unresolvable setup problems
+
+### Config Entry Unloading
+- **Required**: Implement `async_unload_entry` for runtime removal/reload
+- **Platform Unloading**: Use `hass.config_entries.async_unload_platforms`
+- **Cleanup**: Register callbacks with `entry.async_on_unload`:
+  ```python
+  async def async_unload_entry(hass: HomeAssistant, entry: MyConfigEntry) -> bool:
+      """Unload a config entry."""
+      if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+          entry.runtime_data.listener()  # Clean up resources
+      return unload_ok
+  ```
+
+### Service Actions
+- **Registration**: Register all service actions in `async_setup`, NOT in `async_setup_entry`
+- **Validation**: Check config entry existence and loaded state:
+  ```python
+  async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+      async def service_action(call: ServiceCall) -> ServiceResponse:
+          if not (entry := hass.config_entries.async_get_entry(call.data[ATTR_CONFIG_ENTRY_ID])):
+              raise ServiceValidationError("Entry not found")
+          if entry.state is not ConfigEntryState.LOADED:
+              raise ServiceValidationError("Entry not loaded")
+  ```
+- **Exception Handling**: Raise appropriate exceptions:
+  ```python
+  # For invalid input
+  if end_date < start_date:
+      raise ServiceValidationError("End date must be after start date")
+
+  # For service errors
+  try:
+      await client.set_schedule(start_date, end_date)
+  except MyConnectionError as err:
+      raise HomeAssistantError("Could not connect to the schedule") from err
+  ```
+
+### Service Registration Patterns
+- **Entity Services**: Register on platform setup
+  ```python
+  platform.async_register_entity_service(
+      "my_entity_service",
+      {vol.Required("parameter"): cv.string},
+      "handle_service_method"
+  )
+  ```
+- **Service Schema**: Always validate input
+  ```python
+  SERVICE_SCHEMA = vol.Schema({
+      vol.Required("entity_id"): cv.entity_ids,
+      vol.Required("parameter"): cv.string,
+      vol.Optional("timeout", default=30): cv.positive_int,
+  })
+  ```
+- **Services File**: Create `services.yaml` with descriptions and field definitions
+
+### Polling
+- Use update coordinator pattern when possible
+- **Polling intervals are NOT user-configurable**: Never add scan_interval, update_interval, or polling frequency options to config flows or config entries
+- **Integration determines intervals**: Set `update_interval` programmatically based on integration logic, not user input
+- **Minimum Intervals**:
+  - Local network: 5 seconds
+  - Cloud services: 60 seconds
+- **Parallel Updates**: Specify number of concurrent updates:
+  ```python
+  PARALLEL_UPDATES = 1  # Serialize updates to prevent overwhelming device
+  # OR
+  PARALLEL_UPDATES = 0  # Unlimited (for coordinator-based or read-only)
+  ```
+
+## Entity Development
+
+### Unique IDs
+- **Required**: Every entity must have a unique ID for registry tracking
+- Must be unique per platform (not per integration)
+- Don't include integration domain or platform in ID
+- **Implementation**:
+  ```python
+  class MySensor(SensorEntity):
+      def __init__(self, device_id: str) -> None:
+          self._attr_unique_id = f"{device_id}_temperature"
+  ```
+
+**Acceptable ID Sources**:
+- Device serial numbers
+- MAC addresses (formatted using `format_mac` from device registry)
+- Physical identifiers (printed/EEPROM)
+- Config entry ID as last resort: `f"{entry.entry_id}-battery"`
+
+**Never Use**:
+- IP addresses, hostnames, URLs
+- Device names
+- Email addresses, usernames
+
+### Entity Descriptions
+- **Lambda/Anonymous Functions**: Often used in EntityDescription for value transformation
+- **Multiline Lambdas**: When lambdas exceed line length, wrap in parentheses for readability
+- **Bad pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature",
+      name="Temperature",
+      value_fn=lambda data: round(data["temp_value"] * 1.8 + 32, 1) if data.get("temp_value") is not None else None,  # ❌ Too long
+  )
+  ```
+- **Good pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature",
+      name="Temperature",
+      value_fn=lambda data: (  # ✅ Parenthesis on same line as lambda
+          round(data["temp_value"] * 1.8 + 32, 1)
+          if data.get("temp_value") is not None
+          else None
+      ),
+  )
+  ```
+
+### Entity Naming
+- **Use has_entity_name**: Set `_attr_has_entity_name = True`
+- **For specific fields**:
+  ```python
+  class MySensor(SensorEntity):
+      _attr_has_entity_name = True
+      def __init__(self, device: Device, field: str) -> None:
+          self._attr_device_info = DeviceInfo(
+              identifiers={(DOMAIN, device.id)},
+              name=device.name,
+          )
+          self._attr_name = field  # e.g., "temperature", "humidity"
+  ```
+- **For device itself**: Set `_attr_name = None`
+
+### Event Lifecycle Management
+- **Subscribe in `async_added_to_hass`**:
+  ```python
+  async def async_added_to_hass(self) -> None:
+      """Subscribe to events."""
+      self.async_on_remove(
+          self.client.events.subscribe("my_event", self._handle_event)
+      )
+  ```
+- **Unsubscribe in `async_will_remove_from_hass`** if not using `async_on_remove`
+- Never subscribe in `__init__` or other methods
+
+### State Handling
+- Unknown values: Use `None` (not "unknown" or "unavailable")
+- Availability: Implement `available()` property instead of using "unavailable" state
+
+### Entity Availability
+- **Mark Unavailable**: When data cannot be fetched from device/service
+- **Coordinator Pattern**:
+  ```python
+  @property
+  def available(self) -> bool:
+      """Return if entity is available."""
+      return super().available and self.identifier in self.coordinator.data
+  ```
+- **Direct Update Pattern**:
+  ```python
+  async def async_update(self) -> None:
+      """Update entity."""
+      try:
+          data = await self.client.get_data()
+      except MyException:
+          self._attr_available = False
+      else:
+          self._attr_available = True
+          self._attr_native_value = data.value
+  ```
+
+### Extra State Attributes
+- All attribute keys must always be present
+- Unknown values: Use `None`
+- Provide descriptive attributes
+
+## Device Management
+
+### Device Registry
+- **Create Devices**: Group related entities under devices
+- **Device Info**: Provide comprehensive metadata:
+  ```python
+  _attr_device_info = DeviceInfo(
+      connections={(CONNECTION_NETWORK_MAC, device.mac)},
+      identifiers={(DOMAIN, device.id)},
+      name=device.name,
+      manufacturer="My Company",
+      model="My Sensor",
+      sw_version=device.version,
+  )
+  ```
+- For services: Add `entry_type=DeviceEntryType.SERVICE`
+
+### Dynamic Device Addition
+- **Auto-detect New Devices**: After initial setup
+- **Implementation Pattern**:
+  ```python
+  def _check_device() -> None:
+      current_devices = set(coordinator.data)
+      new_devices = current_devices - known_devices
+      if new_devices:
+          known_devices.update(new_devices)
+          async_add_entities([MySensor(coordinator, device_id) for device_id in new_devices])
+
+  entry.async_on_unload(coordinator.async_add_listener(_check_device))
+  ```
+
+### Stale Device Removal
+- **Auto-remove**: When devices disappear from hub/account
+- **Device Registry Update**:
+  ```python
+  device_registry.async_update_device(
+      device_id=device.id,
+      remove_config_entry_id=self.config_entry.entry_id,
+  )
+  ```
+- **Manual Deletion**: Implement `async_remove_config_entry_device` when needed
+
+### Entity Categories
+- **Required**: Assign appropriate category to entities
+- **Implementation**: Set `_attr_entity_category`
+  ```python
+  class MySensor(SensorEntity):
+      _attr_entity_category = EntityCategory.DIAGNOSTIC
+  ```
+- Categories include: `DIAGNOSTIC` for system/technical information
+
+### Device Classes
+- **Use When Available**: Set appropriate device class for entity type
+  ```python
+  class MyTemperatureSensor(SensorEntity):
+      _attr_device_class = SensorDeviceClass.TEMPERATURE
+  ```
+- Provides context for: unit conversion, voice control, UI representation
+
+### Disabled by Default
+- **Disable Noisy/Less Popular Entities**: Reduce resource usage
+  ```python
+  class MySignalStrengthSensor(SensorEntity):
+      _attr_entity_registry_enabled_default = False
+  ```
+- Target: frequently changing states, technical diagnostics
+
+### Entity Translations
+- **Required with has_entity_name**: Support international users
+- **Implementation**:
+  ```python
+  class MySensor(SensorEntity):
+      _attr_has_entity_name = True
+      _attr_translation_key = "phase_voltage"
+  ```
+- Create `strings.json` with translations:
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "phase_voltage": {
+          "name": "Phase voltage"
+        }
+      }
+    }
+  }
+  ```
+
+### Exception Translations (Gold)
+- **Translatable Errors**: Use translation keys for user-facing exceptions
+- **Implementation**:
+  ```python
+  raise ServiceValidationError(
+      translation_domain=DOMAIN,
+      translation_key="end_date_before_start_date",
+  )
+  ```
+- Add to `strings.json`:
+  ```json
+  {
+    "exceptions": {
+      "end_date_before_start_date": {
+        "message": "The end date cannot be before the start date."
+      }
+    }
+  }
+  ```
+
+### Icon Translations (Gold)
+- **Dynamic Icons**: Support state and range-based icon selection
+- **State-based Icons**:
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "tree_pollen": {
+          "default": "mdi:tree",
+          "state": {
+            "high": "mdi:tree-outline"
+          }
+        }
+      }
+    }
+  }
+  ```
+- **Range-based Icons** (for numeric values):
+  ```json
+  {
+    "entity": {
+      "sensor": {
+        "battery_level": {
+          "default": "mdi:battery-unknown",
+          "range": {
+            "0": "mdi:battery-outline",
+            "90": "mdi:battery-90",
+            "100": "mdi:battery"
+          }
+        }
+      }
+    }
+  }
+  ```
+
+## Testing Requirements
+
+- **Location**: `tests/components/{domain}/`
+- **Coverage Requirement**: Above 95% test coverage for all modules
+- **Best Practices**:
+  - Use pytest fixtures from `tests.common`
+  - Mock all external dependencies
+  - Use snapshots for complex data structures
+  - Follow existing test patterns
+
+### Config Flow Testing
+- **100% Coverage Required**: All config flow paths must be tested
+- **Test Scenarios**:
+  - All flow initiation methods (user, discovery, import)
+  - Successful configuration paths
+  - Error recovery scenarios
+  - Prevention of duplicate entries
+  - Flow completion after errors
+
+### Testing
+- **Integration-specific tests** (recommended):
+  ```bash
+  pytest ./tests/components/<integration_domain> \
+    --cov=homeassistant.components.<integration_domain> \
+    --cov-report term-missing \
+    --durations-min=1 \
+    --durations=0 \
+    --numprocesses=auto
+  ```
+
+### Testing Best Practices
+- **Never access `hass.data` directly** - Use fixtures and proper integration setup instead
+- **Use snapshot testing** - For verifying entity states and attributes
+- **Test through integration setup** - Don't test entities in isolation
+- **Mock external APIs** - Use fixtures with realistic JSON data
+- **Verify registries** - Ensure entities are properly registered with devices
+
+### Config Flow Testing Template
+```python
+async def test_user_flow_success(hass, mock_api):
+    """Test successful user flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    # Test form submission
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.CREATE_ENTRY
+    assert result["title"] == "My Device"
+    assert result["data"] == TEST_USER_INPUT
+
+async def test_flow_connection_error(hass, mock_api_error):
+    """Test connection error handling."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+```
+
+### Entity Testing Patterns
+```python
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Overridden fixture to specify platforms to test."""
+    return [Platform.SENSOR]  # Or another specific platform as needed.
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
+async def test_entities(
+    hass: HomeAssistant,
+    snapshot: SnapshotAssertion,
+    entity_registry: er.EntityRegistry,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the sensor entities."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+    # Ensure entities are correctly assigned to device
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, "device_unique_id")}
+    )
+    assert device_entry
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, mock_config_entry.entry_id
+    )
+    for entity_entry in entity_entries:
+        assert entity_entry.device_id == device_entry.id
+```
+
+### Mock Patterns
+```python
+# Modern integration fixture setup
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Return the default mocked config entry."""
+    return MockConfigEntry(
+        title="My Integration",
+        domain=DOMAIN,
+        data={CONF_HOST: "127.0.0.1", CONF_API_KEY: "test_key"},
+        unique_id="device_unique_id",
+    )
+
+@pytest.fixture
+def mock_device_api() -> Generator[MagicMock]:
+    """Return a mocked device API."""
+    with patch("homeassistant.components.my_integration.MyDeviceAPI", autospec=True) as api_mock:
+        api = api_mock.return_value
+        api.get_data.return_value = MyDeviceData.from_json(
+            load_fixture("device_data.json", DOMAIN)
+        )
+        yield api
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Fixture to specify platforms to test."""
+    return PLATFORMS
+
+@pytest.fixture
+async def init_integration(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_device_api: MagicMock,
+    platforms: list[Platform],
+) -> MockConfigEntry:
+    """Set up the integration for testing."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    return mock_config_entry
+```
+
+## Debugging & Troubleshooting
+
+### Common Issues & Solutions
+- **Integration won't load**: Check `manifest.json` syntax and required fields
+- **Entities not appearing**: Verify `unique_id` and `has_entity_name` implementation
+- **Config flow errors**: Check `strings.json` entries and error handling
+- **Discovery not working**: Verify manifest discovery configuration and callbacks
+- **Tests failing**: Check mock setup and async context
+
+### Debug Logging Setup
+```python
+# Enable debug logging in tests
+caplog.set_level(logging.DEBUG, logger="my_integration")
+
+# In integration code - use proper logging
+_LOGGER = logging.getLogger(__name__)
+_LOGGER.debug("Processing data: %s", data)  # Use lazy logging
+```
+
+### Validation Commands
+```bash
+# Check specific integration
+python -m script.hassfest --integration-path homeassistant/components/my_integration
+
+# Validate quality scale
+# Check quality_scale.yaml against current rules
+
+# Run integration tests with coverage
+pytest ./tests/components/my_integration \
+  --cov=homeassistant.components.my_integration \
+  --cov-report term-missing
+```

.claude/skills/integrations/platform-diagnostics.md

@@ -0,0 +1,19 @@
+# Integration Diagnostics
+
+Platform exists as `homeassistant/components/<domain>/diagnostics.py`.
+
+- **Required**: Implement diagnostic data collection
+- **Implementation**:
+  ```python
+  TO_REDACT = [CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE]
+
+  async def async_get_config_entry_diagnostics(
+      hass: HomeAssistant, entry: MyConfigEntry
+  ) -> dict[str, Any]:
+      """Return diagnostics for a config entry."""
+      return {
+          "entry_data": async_redact_data(entry.data, TO_REDACT),
+          "data": entry.runtime_data.data,
+      }
+  ```
+- **Security**: Never expose passwords, tokens, or sensitive coordinates

.claude/skills/integrations/platform-repairs.md

@@ -0,0 +1,55 @@
+# Repairs platform
+
+Platform exists as `homeassistant/components/<domain>/repairs.py`.
+
+- **Actionable Issues Required**: All repair issues must be actionable for end users
+- **Issue Content Requirements**:
+  - Clearly explain what is happening
+  - Provide specific steps users need to take to resolve the issue
+  - Use friendly, helpful language
+  - Include relevant context (device names, error details, etc.)
+- **Implementation**:
+  ```python
+  ir.async_create_issue(
+      hass,
+      DOMAIN,
+      "outdated_version",
+      is_fixable=False,
+      issue_domain=DOMAIN,
+      severity=ir.IssueSeverity.ERROR,
+      translation_key="outdated_version",
+  )
+  ```
+- **Translation Strings Requirements**: Must contain user-actionable text in `strings.json`:
+  ```json
+  {
+    "issues": {
+      "outdated_version": {
+        "title": "Device firmware is outdated",
+        "description": "Your device firmware version {current_version} is below the minimum required version {min_version}. To fix this issue: 1) Open the manufacturer's mobile app, 2) Navigate to device settings, 3) Select 'Update Firmware', 4) Wait for the update to complete, then 5) Restart Home Assistant."
+      }
+    }
+  }
+  ```
+- **String Content Must Include**:
+  - What the problem is
+  - Why it matters
+  - Exact steps to resolve (numbered list when multiple steps)
+  - What to expect after following the steps
+- **Avoid Vague Instructions**: Don't just say "update firmware" - provide specific steps
+- **Severity Guidelines**:
+  - `CRITICAL`: Reserved for extreme scenarios only
+  - `ERROR`: Requires immediate user attention
+  - `WARNING`: Indicates future potential breakage
+- **Additional Attributes**:
+  ```python
+  ir.async_create_issue(
+      hass, DOMAIN, "issue_id",
+      breaks_in_ha_version="2024.1.0",
+      is_fixable=True,
+      is_persistent=True,
+      severity=ir.IssueSeverity.ERROR,
+      translation_key="issue_description",
+  )
+  ```
+- Only create issues for problems users can potentially resolve

.core_files.yaml

@@ -91,6 +91,7 @@ components: &components
   - homeassistant/components/input_number/**
   - homeassistant/components/input_select/**
   - homeassistant/components/input_text/**
+  - homeassistant/components/labs/**
   - homeassistant/components/logbook/**
   - homeassistant/components/logger/**
   - homeassistant/components/lovelace/**

.devcontainer/devcontainer.json

@@ -8,9 +8,6 @@
     "PYTHONASYNCIODEBUG": "1"
   },
   "features": {
-    // Node feature required for Claude Code until fixed https://github.com/anthropics/devcontainer-features/issues/28
-    "ghcr.io/devcontainers/features/node:1": {},
-    "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
   // Port 5683 udp is used by Shelly integration
@@ -40,7 +37,8 @@
         "python.terminal.activateEnvInCurrentTerminal": true,
         "python.testing.pytestArgs": ["--no-cov"],
         "pylint.importStrategy": "fromEnvironment",
-        "python.analysis.typeCheckingMode": "basic",
+        // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+        "python.analysis.typeCheckingMode": "off",
         "editor.formatOnPaste": false,
         "editor.formatOnSave": true,
         "editor.formatOnType": true,

.github/PULL_REQUEST_TEMPLATE.md

@@ -80,7 +80,7 @@ If the code communicates with devices, web services, or third-party tools:
       Updated and included derived files by running: `python3 -m script.hassfest`.
 - [ ] New or updated dependencies have been added to `requirements_all.txt`.  
       Updated by running `python3 -m script.gen_requirements_all`.
-- [ ] For the updated dependencies - a link to the changelog, or at minimum a diff between library versions is added to the PR description.
+- [ ] For the updated dependencies a diff between library versions and ideally a link to the changelog/release notes is added to the PR description.
 
 <!--
   This project is very active and we have a high turnover of pull requests.

.github/workflows/builder.yml

@@ -10,12 +10,12 @@ on:
 
 env:
   BUILD_TYPE: core
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
   PIP_TIMEOUT: 60
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
   # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2025.12.0"
+  BASE_IMAGE_VERSION: "2026.01.0"
   ARCHITECTURES: '["amd64", "aarch64"]'
 
 jobs:
@@ -30,10 +30,10 @@ jobs:
       architectures: ${{ env.ARCHITECTURES }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -96,11 +96,11 @@ jobs:
             os: ubuntu-24.04-arm
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@5c98f0b039f36ef966fdb7dfa9779262785ecb05 # v14
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -111,7 +111,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@5c98f0b039f36ef966fdb7dfa9779262785ecb05 # v14
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -122,7 +122,7 @@ jobs:
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -184,7 +184,7 @@ jobs:
           echo "${{ github.sha }};${{ github.ref }};${{ github.event_name }};${{ github.actor }}" > rootfs/OFFICIAL_IMAGE
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -273,7 +273,7 @@ jobs:
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set build additional args
         run: |
@@ -287,7 +287,7 @@ jobs:
           fi
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -311,7 +311,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -358,13 +358,13 @@ jobs:
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -474,10 +474,10 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -519,10 +519,10 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -551,7 +551,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@00014ed6ed5efc5b1ab7f7f34a39eb55d41aa4f8 # v3.1.0
+        uses: actions/attest-build-provenance@96278af6caaf10aea03fd8d33a09a777ca52d62f # v3.2.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/ci.yaml

@@ -40,9 +40,9 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.2"
-  DEFAULT_PYTHON: "3.13.11"
-  ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
+  HA_SHORT_VERSION: "2026.3"
+  DEFAULT_PYTHON: "3.14.2"
+  ALL_PYTHON_VERSIONS: "['3.14.2']"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
   # 10.6 is the current long-term-support
@@ -59,7 +59,6 @@ env:
   # 15 is the latest version
   # - 15.2 is the latest (as of 9 Feb 2023)
   POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
-  PRE_COMMIT_CACHE: ~/.cache/pre-commit
   UV_CACHE_DIR: /tmp/uv-cache
   APT_CACHE_BASE: /home/runner/work/apt
   APT_CACHE_DIR: /home/runner/work/apt/cache
@@ -83,7 +82,6 @@ jobs:
       integrations_glob: ${{ steps.info.outputs.integrations_glob }}
       integrations: ${{ steps.integrations.outputs.changes }}
       apt_cache_key: ${{ steps.generate_apt_cache_key.outputs.key }}
-      pre-commit_cache_key: ${{ steps.generate_pre-commit_cache_key.outputs.key }}
       python_cache_key: ${{ steps.generate_python_cache_key.outputs.key }}
       requirements: ${{ steps.core.outputs.requirements }}
       mariadb_groups: ${{ steps.info.outputs.mariadb_groups }}
@@ -99,7 +97,7 @@ jobs:
     steps:
       - &checkout
         name: Check out code from GitHub
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |
@@ -111,11 +109,6 @@ jobs:
             hashFiles('requirements_all.txt') }}-${{
             hashFiles('homeassistant/package_constraints.txt') }}-${{
             hashFiles('script/gen_requirements_all.py') }}" >> $GITHUB_OUTPUT
-      - name: Generate partial pre-commit restore key
-        id: generate_pre-commit_cache_key
-        run: >-
-          echo "key=pre-commit-${{ env.CACHE_VERSION }}-${{
-            hashFiles('.pre-commit-config.yaml') }}"  >> $GITHUB_OUTPUT
       - name: Generate partial apt restore key
         id: generate_apt_cache_key
         run: |
@@ -244,8 +237,8 @@ jobs:
           echo "skip_coverage: ${skip_coverage}"
           echo "skip_coverage=${skip_coverage}" >> $GITHUB_OUTPUT
 
-  pre-commit:
-    name: Prepare pre-commit base
+  prek:
+    name: Run prek checks
     runs-on: *runs-on-ubuntu
     needs: [info]
     if: |
@@ -254,147 +247,17 @@ jobs:
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
       - *checkout
-      - &setup-python-default
-        name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        id: python
-        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          check-latest: true
-      - name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          key: &key-pre-commit-venv >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-venv-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Create Python virtual environment
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        run: |
-          python -m venv venv
-          . venv/bin/activate
-          python --version
-          pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install "$(cat requirements_test.txt | grep pre-commit)"
-      - name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          lookup-only: true
-          key: &key-pre-commit-env >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Install pre-commit dependencies
-        if: steps.cache-precommit.outputs.cache-hit != 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit install-hooks
-
-  lint-ruff-format:
-    name: Check ruff-format
-    runs-on: *runs-on-ubuntu
-    needs: &needs-pre-commit
-      - info
-      - pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - &cache-restore-pre-commit-venv
-        name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache-restore actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          fail-on-cache-miss: true
-          key: *key-pre-commit-venv
-      - &cache-restore-pre-commit-env
-        name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache-restore
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          fail-on-cache-miss: true
-          key: *key-pre-commit-env
-      - name: Run ruff-format
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-format --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-ruff:
-    name: Check ruff
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-      - name: Run ruff
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-check --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-other:
-    name: Check other linters
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-
-      - name: Register yamllint problem matcher
+      - name: Register problem matchers
         run: |
           echo "::add-matcher::.github/workflows/matchers/yamllint.json"
-      - name: Run yamllint
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual yamllint --all-files --show-diff-on-failure
-
-      - name: Register check-json problem matcher
-        run: |
           echo "::add-matcher::.github/workflows/matchers/check-json.json"
-      - name: Run check-json
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-json --all-files --show-diff-on-failure
-
-      - name: Run prettier (fully)
-        if: needs.info.outputs.test_full_suite == 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual prettier --all-files --show-diff-on-failure
-
-      - name: Run prettier (partially)
-        if: needs.info.outputs.test_full_suite == 'false'
-        shell: bash
-        run: |
-          . venv/bin/activate
-          shopt -s globstar
-          pre-commit run --hook-stage manual prettier --show-diff-on-failure --files {homeassistant,tests}/components/${{ needs.info.outputs.integrations_glob }}/{*,**/*}
-
-      - name: Register check executables problem matcher
-        run: |
           echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
-      - name: Run executables check
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files --show-diff-on-failure
-
-      - name: Register codespell problem matcher
-        run: |
           echo "::add-matcher::.github/workflows/matchers/codespell.json"
-      - name: Run codespell
-        run: |
-          . venv/bin/activate
-          pre-commit run --show-diff-on-failure --hook-stage manual codespell --all-files
+      - name: Run prek
+        uses: j178/prek-action@564dda4cfa5e96aafdc4a5696c4bf7b46baae5ac # v1.1.0
+        env:
+          PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config
+          RUFF_OUTPUT_FORMAT: github
 
   lint-hadolint:
     name: Check ${{ matrix.file }}
@@ -434,7 +297,7 @@ jobs:
       - &setup-python-matrix
         name: Set up Python ${{ matrix.python-version }}
         id: python
-        uses: *actions-setup-python
+        uses: &actions-setup-python actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
           check-latest: true
@@ -447,7 +310,7 @@ jobs:
             env.HA_SHORT_VERSION }}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: *actions-cache
+        uses: &actions-cache actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: venv
           key: &key-python-venv >-
@@ -511,7 +374,7 @@ jobs:
           fi
       - name: Save apt cache
         if: steps.cache-apt-check.outputs.cache-hit != 'true'
-        uses: &actions-cache-save actions/cache/save@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
+        uses: &actions-cache-save actions/cache/save@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: *path-apt-cache
           key: *key-apt-cache
@@ -562,7 +425,7 @@ jobs:
     steps:
       - &cache-restore-apt
         name: Restore apt cache
-        uses: *actions-cache-restore
+        uses: &actions-cache-restore actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: *path-apt-cache
           fail-on-cache-miss: true
@@ -579,7 +442,13 @@ jobs:
             -o Dir::State::Lists=${{ env.APT_LIST_CACHE_DIR }} \
             libturbojpeg
       - *checkout
-      - *setup-python-default
+      - &setup-python-default
+        name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        id: python
+        uses: *actions-setup-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          check-latest: true
       - &cache-restore-python-default
         name: Restore full Python ${{ env.DEFAULT_PYTHON }} virtual environment
         id: cache-venv
@@ -610,6 +479,22 @@ jobs:
           . venv/bin/activate
           python -m script.gen_requirements_all validate
 
+  gen-copilot-instructions:
+    name: Check copilot instructions
+    runs-on: *runs-on-ubuntu
+    needs:
+      - info
+    if: |
+      github.event.inputs.pylint-only != 'true'
+      && github.event.inputs.mypy-only != 'true'
+      && github.event.inputs.audit-licenses-only != 'true'
+    steps:
+      - *checkout
+      - *setup-python-default
+      - name: Run gen_copilot_instructions.py
+        run: |
+          python -m script.gen_copilot_instructions validate
+
   dependency-review:
     name: Dependency review
     runs-on: *runs-on-ubuntu
@@ -782,9 +667,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     steps:
       - *cache-restore-apt
@@ -823,9 +706,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
       - prepare-pytest-full
     if: |
@@ -949,9 +830,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1066,9 +945,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1202,9 +1079,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1328,6 +1203,8 @@ jobs:
       - pytest-postgres
       - pytest-mariadb
     timeout-minutes: 10
+    permissions:
+      id-token: write
     # codecov/test-results-action currently doesn't support tokenless uploads
     # therefore we can't run it on forks
     if: |
@@ -1339,8 +1216,9 @@ jobs:
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov
-        uses: codecov/test-results-action@47f89e9acb64b76debcd5ea40642d25a4adced9f # v1.1.1
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
+          report_type: test_results
           fail_ci_if_error: true
           verbose: true
-          token: ${{ secrets.CODECOV_TOKEN }}
+          use_oidc: true

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           category: "/language:python"

.github/workflows/detect-duplicate-issues.yml

@@ -231,7 +231,7 @@ jobs:
       - name: Detect duplicates using AI
         id: ai_detection
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@334892bb203895caaed82ec52d23c1ed9385151e # v2.0.4
+        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
         with:
           model: openai/gpt-4o
           system-prompt: |

.github/workflows/detect-non-english-issues.yml

@@ -57,7 +57,7 @@ jobs:
       - name: Detect language using AI
         id: ai_language_detection
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@334892bb203895caaed82ec52d23c1ed9385151e # v2.0.4
+        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
         with:
           model: openai/gpt-4o-mini
           system-prompt: |

.github/workflows/matchers/check-executables-have-shebangs.json

@@ -4,7 +4,7 @@
       "owner": "check-executables-have-shebangs",
       "pattern": [
         {
-          "regexp": "^(.+):\\s(.+)$",
+          "regexp": "^(.+):\\s(marked executable but has no \\(or invalid\\) shebang!.*)$",
           "file": 1,
           "message": 2
         }

.github/workflows/translations.yml

@@ -10,7 +10,7 @@ on:
       - "**strings.json"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
 
 jobs:
   upload:
@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 

.github/workflows/wheels.yml

@@ -17,7 +17,7 @@ on:
       - "script/gen_requirements_all.py"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name}}
@@ -31,11 +31,11 @@ jobs:
     steps:
       - &checkout
         name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           check-latest: true

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.0
+    rev: v0.14.13
     hooks:
       - id: ruff-check
         args:
@@ -39,14 +39,14 @@ repos:
       - id: prettier
         additional_dependencies:
           - prettier@3.6.2
-          - prettier-plugin-sort-json@4.1.1
+          - prettier-plugin-sort-json@4.2.0
   - repo: https://github.com/cdce8p/python-typing-update
     rev: v0.6.0
     hooks:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # pre-commit run --hook-stage manual python-typing-update --all-files
+      # prek run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:

.python-version

@@ -1 +1 @@
-3.13
+3.14

.strict-typing

@@ -53,6 +53,7 @@ homeassistant.components.air_quality.*
 homeassistant.components.airgradient.*
 homeassistant.components.airly.*
 homeassistant.components.airnow.*
+homeassistant.components.airobot.*
 homeassistant.components.airos.*
 homeassistant.components.airq.*
 homeassistant.components.airthings.*
@@ -375,6 +376,7 @@ homeassistant.components.no_ip.*
 homeassistant.components.nordpool.*
 homeassistant.components.notify.*
 homeassistant.components.notion.*
+homeassistant.components.nrgkick.*
 homeassistant.components.ntfy.*
 homeassistant.components.number.*
 homeassistant.components.nut.*
@@ -387,6 +389,7 @@ homeassistant.components.onkyo.*
 homeassistant.components.open_meteo.*
 homeassistant.components.open_router.*
 homeassistant.components.openai_conversation.*
+homeassistant.components.openevse.*
 homeassistant.components.openexchangerates.*
 homeassistant.components.opensky.*
 homeassistant.components.openuv.*
@@ -407,6 +410,7 @@ homeassistant.components.person.*
 homeassistant.components.pi_hole.*
 homeassistant.components.ping.*
 homeassistant.components.plugwise.*
+homeassistant.components.pooldose.*
 homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
 homeassistant.components.powerwall.*
@@ -454,6 +458,7 @@ homeassistant.components.russound_rio.*
 homeassistant.components.ruuvi_gateway.*
 homeassistant.components.ruuvitag_ble.*
 homeassistant.components.samsungtv.*
+homeassistant.components.saunum.*
 homeassistant.components.scene.*
 homeassistant.components.schedule.*
 homeassistant.components.schlage.*

.vscode/settings.default.jsonc

@@ -7,8 +7,8 @@
   "python.testing.pytestEnabled": false,
   // https://code.visualstudio.com/docs/python/linting#_general-settings
   "pylint.importStrategy": "fromEnvironment",
-  // Pyright is too pedantic for Home Assistant
-  "python.analysis.typeCheckingMode": "basic",
+  // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+  "python.analysis.typeCheckingMode": "off",
   "[python]": {
     "editor.defaultFormatter": "charliermarsh.ruff",
   },

.vscode/tasks.json

@@ -45,7 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "pre-commit run ruff-check --all-files",
+      "command": "prek run ruff-check --all-files",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -57,9 +57,9 @@
       "problemMatcher": []
     },
     {
-      "label": "Pre-commit",
+      "label": "Prek",
       "type": "shell",
-      "command": "pre-commit run --show-diff-on-failure",
+      "command": "prek run --show-diff-on-failure",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -120,7 +120,7 @@
     {
       "label": "Generate Requirements",
       "type": "shell",
-      "command": "./script/gen_requirements_all.py",
+      "command": "${command:python.interpreterPath} -m script.gen_requirements_all",
       "group": {
         "kind": "build",
         "isDefault": true

AGENTS.md

@@ -1 +0,0 @@
-.github/copilot-instructions.md

AGENTS.md

@@ -0,0 +1,328 @@
+# GitHub Copilot & Claude Code Instructions
+
+This repository contains the core of Home Assistant, a Python 3 based home automation application.
+
+## Code Review Guidelines
+
+**When reviewing code, do NOT comment on:**
+- **Missing imports** - We use static analysis tooling to catch that
+- **Code formatting** - We have ruff as a formatting tool that will catch those if needed (unless specifically instructed otherwise in these instructions)
+
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
+
+## Python Requirements
+
+- **Compatibility**: Python 3.13+
+- **Language Features**: Use the newest features when possible:
+  - Pattern matching
+  - Type hints
+  - f-strings (preferred over `%` or `.format()`)
+  - Dataclasses
+  - Walrus operator
+
+### Strict Typing (Platinum)
+- **Comprehensive Type Hints**: Add type hints to all functions, methods, and variables
+- **Custom Config Entry Types**: When using runtime_data:
+  ```python
+  type MyIntegrationConfigEntry = ConfigEntry[MyClient]
+  ```
+- **Library Requirements**: Include `py.typed` file for PEP-561 compliance
+
+## Code Quality Standards
+
+- **Formatting**: Ruff
+- **Linting**: PyLint and Ruff
+- **Type Checking**: MyPy
+- **Lint/Type/Format Fixes**: Always prefer addressing the underlying issue (e.g., import the typed source, update shared stubs, align with Ruff expectations, or correct formatting at the source) before disabling a rule, adding `# type: ignore`, or skipping a formatter. Treat suppressions and `noqa` comments as a last resort once no compliant fix exists
+- **Testing**: pytest with plain functions and fixtures
+- **Language**: American English for all code, comments, and documentation (use sentence case, including titles)
+
+### Writing Style Guidelines
+- **Tone**: Friendly and informative
+- **Perspective**: Use second-person ("you" and "your") for user-facing messages
+- **Inclusivity**: Use objective, non-discriminatory language
+- **Clarity**: Write for non-native English speakers
+- **Formatting in Messages**:
+  - Use backticks for: file paths, filenames, variable names, field entries
+  - Use sentence case for titles and messages (capitalize only the first word and proper nouns)
+  - Avoid abbreviations when possible
+
+### Documentation Standards
+- **File Headers**: Short and concise
+  ```python
+  """Integration for Peblar EV chargers."""
+  ```
+- **Method/Function Docstrings**: Required for all
+  ```python
+  async def async_setup_entry(hass: HomeAssistant, entry: PeblarConfigEntry) -> bool:
+      """Set up Peblar from a config entry."""
+  ```
+- **Comment Style**:
+  - Use clear, descriptive comments
+  - Explain the "why" not just the "what"
+  - Keep code block lines under 80 characters when possible
+  - Use progressive disclosure (simple explanation first, complex details later)
+
+## Async Programming
+
+- All external I/O operations must be async
+- **Best Practices**:
+  - Avoid sleeping in loops
+  - Avoid awaiting in loops - use `gather` instead
+  - No blocking calls
+  - Group executor jobs when possible - switching between event loop and executor is expensive
+
+### Blocking Operations
+- **Use Executor**: For blocking I/O operations
+  ```python
+  result = await hass.async_add_executor_job(blocking_function, args)
+  ```
+- **Never Block Event Loop**: Avoid file operations, `time.sleep()`, blocking HTTP calls
+- **Replace with Async**: Use `asyncio.sleep()` instead of `time.sleep()`
+
+### Thread Safety
+- **@callback Decorator**: For event loop safe functions
+  ```python
+  @callback
+  def async_update_callback(self, event):
+      """Safe to run in event loop."""
+      self.async_write_ha_state()
+  ```
+- **Sync APIs from Threads**: Use sync versions when calling from non-event loop threads
+- **Registry Changes**: Must be done in event loop thread
+
+### Error Handling
+- **Exception Types**: Choose most specific exception available
+  - `ServiceValidationError`: User input errors (preferred over `ValueError`)
+  - `HomeAssistantError`: Device communication failures
+  - `ConfigEntryNotReady`: Temporary setup issues (device offline)
+  - `ConfigEntryAuthFailed`: Authentication problems
+  - `ConfigEntryError`: Permanent setup issues
+- **Try/Catch Best Practices**:
+  - Only wrap code that can throw exceptions
+  - Keep try blocks minimal - process data after the try/catch
+  - **Avoid bare exceptions** except in specific cases:
+    - ❌ Generally not allowed: `except:` or `except Exception:`
+    - ✅ Allowed in config flows to ensure robustness
+    - ✅ Allowed in functions/methods that run in background tasks
+  - Bad pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+        # ❌ Don't process data inside try block
+        processed = data.get("value", 0) * 100
+        self._attr_native_value = processed
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+    ```
+  - Good pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+        return
+
+    # ✅ Process data outside try block
+    processed = data.get("value", 0) * 100
+    self._attr_native_value = processed
+    ```
+- **Bare Exception Usage**:
+  ```python
+  # ❌ Not allowed in regular code
+  try:
+      data = await device.get_data()
+  except Exception:  # Too broad
+      _LOGGER.error("Failed")
+
+  # ✅ Allowed in config flow for robustness
+  async def async_step_user(self, user_input=None):
+      try:
+          await self._test_connection(user_input)
+      except Exception:  # Allowed here
+          errors["base"] = "unknown"
+
+  # ✅ Allowed in background tasks
+  async def _background_refresh():
+      try:
+          await coordinator.async_refresh()
+      except Exception:  # Allowed in task
+          _LOGGER.exception("Unexpected error in background task")
+  ```
+- **Setup Failure Patterns**:
+  ```python
+  try:
+      await device.async_setup()
+  except (asyncio.TimeoutError, TimeoutException) as ex:
+      raise ConfigEntryNotReady(f"Timeout connecting to {device.host}") from ex
+  except AuthFailed as ex:
+      raise ConfigEntryAuthFailed(f"Credentials expired for {device.name}") from ex
+  ```
+
+### Logging
+- **Format Guidelines**:
+  - No periods at end of messages
+  - No integration names/domains (added automatically)
+  - No sensitive data (keys, tokens, passwords)
+- Use debug level for non-user-facing messages
+- **Use Lazy Logging**:
+  ```python
+  _LOGGER.debug("This is a log message with %s", variable)
+  ```
+
+### Unavailability Logging
+- **Log Once**: When device/service becomes unavailable (info level)
+- **Log Recovery**: When device/service comes back online
+- **Implementation Pattern**:
+  ```python
+  _unavailable_logged: bool = False
+
+  if not self._unavailable_logged:
+      _LOGGER.info("The sensor is unavailable: %s", ex)
+      self._unavailable_logged = True
+  # On recovery:
+  if self._unavailable_logged:
+      _LOGGER.info("The sensor is back online")
+      self._unavailable_logged = False
+  ```
+
+## Development Commands
+
+### Environment
+- **Local development (non-container)**: Activate the project venv before running commands: `source .venv/bin/activate`
+- **Dev container**: No activation needed, the environment is pre-configured
+
+### Code Quality & Linting
+- **Run all linters on all files**: `prek run --all-files`
+- **Run linters on staged files only**: `prek run`
+- **PyLint on everything** (slow): `pylint homeassistant`
+- **PyLint on specific folder**: `pylint homeassistant/components/my_integration`
+- **MyPy type checking (whole project)**: `mypy homeassistant/`
+- **MyPy on specific integration**: `mypy homeassistant/components/my_integration`
+
+### Testing
+- **Quick test of changed files**: `pytest --timeout=10 --picked`
+- **Update test snapshots**: Add `--snapshot-update` to pytest command
+  - ⚠️ Omit test results after using `--snapshot-update`
+  - Always run tests again without the flag to verify snapshots
+- **Full test suite** (AVOID - very slow): `pytest ./tests`
+
+### Dependencies & Requirements
+- **Update generated files after dependency changes**: `python -m script.gen_requirements_all`
+- **Install all Python requirements**:
+  ```bash
+  uv pip install -r requirements_all.txt -r requirements.txt -r requirements_test.txt
+  ```
+- **Install test requirements only**:
+  ```bash
+  uv pip install -r requirements_test_all.txt -r requirements.txt
+  ```
+
+### Translations
+- **Update translations after strings.json changes**:
+  ```bash
+  python -m script.translations develop --all
+  ```
+
+### Project Validation
+- **Run hassfest** (checks project structure and updates generated files):
+  ```bash
+  python -m script.hassfest
+  ```
+
+## Common Anti-Patterns & Best Practices
+
+### ❌ **Avoid These Patterns**
+```python
+# Blocking operations in event loop
+data = requests.get(url)  # ❌ Blocks event loop
+time.sleep(5)  # ❌ Blocks event loop
+
+# Reusing BleakClient instances
+self.client = BleakClient(address)
+await self.client.connect()
+# Later...
+await self.client.connect()  # ❌ Don't reuse
+
+# Hardcoded strings in code
+self._attr_name = "Temperature Sensor"  # ❌ Not translatable
+
+# Missing error handling
+data = await self.api.get_data()  # ❌ No exception handling
+
+# Storing sensitive data in diagnostics
+return {"api_key": entry.data[CONF_API_KEY]}  # ❌ Exposes secrets
+
+# Accessing hass.data directly in tests
+coordinator = hass.data[DOMAIN][entry.entry_id]  # ❌ Don't access hass.data
+
+# User-configurable polling intervals
+# In config flow
+vol.Optional("scan_interval", default=60): cv.positive_int  # ❌ Not allowed
+# In coordinator
+update_interval = timedelta(minutes=entry.data.get("scan_interval", 1))  # ❌ Not allowed
+
+# User-configurable config entry names (non-helper integrations)
+vol.Optional("name", default="My Device"): cv.string  # ❌ Not allowed in regular integrations
+
+# Too much code in try block
+try:
+    response = await client.get_data()  # Can throw
+    # ❌ Data processing should be outside try block
+    temperature = response["temperature"] / 10
+    humidity = response["humidity"]
+    self._attr_native_value = temperature
+except ClientError:
+    _LOGGER.error("Failed to fetch data")
+
+# Bare exceptions in regular code
+try:
+    value = await sensor.read_value()
+except Exception:  # ❌ Too broad - catch specific exceptions
+    _LOGGER.error("Failed to read sensor")
+```
+
+### ✅ **Use These Patterns Instead**
+```python
+# Async operations with executor
+data = await hass.async_add_executor_job(requests.get, url)
+await asyncio.sleep(5)  # ✅ Non-blocking
+
+# Fresh BleakClient instances
+client = BleakClient(address)  # ✅ New instance each time
+await client.connect()
+
+# Translatable entity names
+_attr_translation_key = "temperature_sensor"  # ✅ Translatable
+
+# Proper error handling
+try:
+    data = await self.api.get_data()
+except ApiException as err:
+    raise UpdateFailed(f"API error: {err}") from err
+
+# Redacted diagnostics data
+return async_redact_data(data, {"api_key", "password"})  # ✅ Safe
+
+# Test through proper integration setup and fixtures
+@pytest.fixture
+async def init_integration(hass, mock_config_entry, mock_api):
+    mock_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)  # ✅ Proper setup
+
+# Integration-determined polling intervals (not user-configurable)
+SCAN_INTERVAL = timedelta(minutes=5)  # ✅ Common pattern: constant in const.py
+
+class MyCoordinator(DataUpdateCoordinator[MyData]):
+    def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+        # ✅ Integration determines interval based on device capabilities, connection type, etc.
+        interval = timedelta(minutes=1) if client.is_local else SCAN_INTERVAL
+        super().__init__(
+            hass,
+            logger=LOGGER,
+            name=DOMAIN,
+            update_interval=interval,
+            config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+        )
+```

CLAUDE.md

@@ -1 +1 @@
-.github/copilot-instructions.md
+AGENTS.md

CODEOWNERS

@@ -288,6 +288,8 @@ build.json @home-assistant/supervisor
 /tests/components/cloud/ @home-assistant/cloud
 /homeassistant/components/cloudflare/ @ludeeus @ctalkington
 /tests/components/cloudflare/ @ludeeus @ctalkington
+/homeassistant/components/cloudflare_r2/ @corrreia
+/tests/components/cloudflare_r2/ @corrreia
 /homeassistant/components/co2signal/ @jpbede @VIKTORVAV99
 /tests/components/co2signal/ @jpbede @VIKTORVAV99
 /homeassistant/components/coinbase/ @tombrien
@@ -641,6 +643,8 @@ build.json @home-assistant/supervisor
 /tests/components/gpsd/ @fabaff @jrieger
 /homeassistant/components/gree/ @cmroche
 /tests/components/gree/ @cmroche
+/homeassistant/components/green_planet_energy/ @petschni
+/tests/components/green_planet_energy/ @petschni
 /homeassistant/components/greeneye_monitor/ @jkeljo
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
@@ -661,6 +665,8 @@ build.json @home-assistant/supervisor
 /tests/components/harmony/ @ehendrix23 @bdraco @mkeesey @Aohzan
 /homeassistant/components/hassio/ @home-assistant/supervisor
 /tests/components/hassio/ @home-assistant/supervisor
+/homeassistant/components/hdfury/ @glenndehaan
+/tests/components/hdfury/ @glenndehaan
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
@@ -915,6 +921,8 @@ build.json @home-assistant/supervisor
 /tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lidarr/ @tkdrob
 /tests/components/lidarr/ @tkdrob
+/homeassistant/components/liebherr/ @mettolen
+/tests/components/liebherr/ @mettolen
 /homeassistant/components/lifx/ @Djelibeybi
 /tests/components/lifx/ @Djelibeybi
 /homeassistant/components/light/ @home-assistant/core
@@ -1015,8 +1023,8 @@ build.json @home-assistant/supervisor
 /tests/components/mill/ @danielhiversen
 /homeassistant/components/min_max/ @gjohansson-ST
 /tests/components/min_max/ @gjohansson-ST
-/homeassistant/components/minecraft_server/ @elmurato
-/tests/components/minecraft_server/ @elmurato
+/homeassistant/components/minecraft_server/ @elmurato @zachdeibert
+/tests/components/minecraft_server/ @elmurato @zachdeibert
 /homeassistant/components/minio/ @tkislan
 /tests/components/minio/ @tkislan
 /homeassistant/components/moat/ @bdraco
@@ -1066,6 +1074,8 @@ build.json @home-assistant/supervisor
 /tests/components/myuplink/ @pajzo @astrandb
 /homeassistant/components/nam/ @bieniu
 /tests/components/nam/ @bieniu
+/homeassistant/components/namecheapdns/ @tr4nt0r
+/tests/components/namecheapdns/ @tr4nt0r
 /homeassistant/components/nanoleaf/ @milanmeu @joostlek
 /tests/components/nanoleaf/ @milanmeu @joostlek
 /homeassistant/components/nasweb/ @nasWebio
@@ -1120,6 +1130,8 @@ build.json @home-assistant/supervisor
 /tests/components/notify_events/ @matrozov @papajojo
 /homeassistant/components/notion/ @bachya
 /tests/components/notion/ @bachya
+/homeassistant/components/nrgkick/ @andijakl
+/tests/components/nrgkick/ @andijakl
 /homeassistant/components/nsw_fuel_station/ @nickw444
 /tests/components/nsw_fuel_station/ @nickw444
 /homeassistant/components/nsw_rural_fire_service_feed/ @exxamalte
@@ -1170,6 +1182,8 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
+/homeassistant/components/openevse/ @c00w @firstof9
+/tests/components/openevse/ @c00w @firstof9
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen
@@ -1253,6 +1267,8 @@ build.json @home-assistant/supervisor
 /tests/components/powerfox/ @klaasnicolaas
 /homeassistant/components/powerwall/ @bdraco @jrester @daniel-simpson
 /tests/components/powerwall/ @bdraco @jrester @daniel-simpson
+/homeassistant/components/prana/ @prana-dev-official
+/tests/components/prana/ @prana-dev-official
 /homeassistant/components/private_ble_device/ @Jc2k
 /tests/components/private_ble_device/ @Jc2k
 /homeassistant/components/probe_plus/ @pantherale0
@@ -1267,7 +1283,8 @@ build.json @home-assistant/supervisor
 /tests/components/prosegur/ @dgomes
 /homeassistant/components/proximity/ @mib1185
 /tests/components/proximity/ @mib1185
-/homeassistant/components/proxmoxve/ @jhollowe @Corbeno
+/homeassistant/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
+/tests/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
 /homeassistant/components/ps4/ @ktnrg45
 /tests/components/ps4/ @ktnrg45
 /homeassistant/components/pterodactyl/ @elmurato
@@ -1715,6 +1732,8 @@ build.json @home-assistant/supervisor
 /tests/components/twinkly/ @dr1rrb @Robbie1221 @Olen
 /homeassistant/components/twitch/ @joostlek
 /tests/components/twitch/ @joostlek
+/homeassistant/components/uhoo/ @getuhoo @joshsmonta
+/tests/components/uhoo/ @getuhoo @joshsmonta
 /homeassistant/components/ukraine_alarm/ @PaulAnnekov
 /tests/components/ukraine_alarm/ @PaulAnnekov
 /homeassistant/components/unifi/ @Kane610
@@ -1801,6 +1820,8 @@ build.json @home-assistant/supervisor
 /tests/components/waqi/ @joostlek
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
+/homeassistant/components/waterfurnace/ @sdague @masterkoppa
+/tests/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai
@@ -1859,6 +1880,8 @@ build.json @home-assistant/supervisor
 /tests/components/worldclock/ @fabaff
 /homeassistant/components/ws66i/ @ssaenger
 /tests/components/ws66i/ @ssaenger
+/homeassistant/components/wsdot/ @ucodery
+/tests/components/wsdot/ @ucodery
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
 /homeassistant/components/xbox/ @hunterjm @tr4nt0r

Dockerfile

@@ -24,13 +24,13 @@ ENV \
 COPY rootfs /
 
 # Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
+COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc
 
 RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
     # Install uv
-    && pip3 install uv==0.9.17
+    && pip3 install uv==0.9.26
 
 WORKDIR /usr/src
 

Dockerfile.dev

@@ -52,6 +52,9 @@ RUN --mount=type=bind,source=requirements.txt,target=requirements.txt \
     --mount=type=bind,source=requirements_test_pre_commit.txt,target=requirements_test_pre_commit.txt \
     uv pip install -r requirements.txt -r requirements_test.txt
 
+# Claude Code native install
+RUN curl -fsSL https://claude.ai/install.sh | bash
+
 WORKDIR /workspaces
 
 # Set the default shell to bash instead of sh

homeassistant/bootstrap.py

@@ -67,8 +67,6 @@ from .const import (
     BASE_PLATFORMS,
     FORMAT_DATETIME,
     KEY_DATA_LOGGING as DATA_LOGGING,
-    REQUIRED_NEXT_PYTHON_HA_RELEASE,
-    REQUIRED_NEXT_PYTHON_VER,
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
@@ -516,38 +514,6 @@ async def async_from_config_dict(
 
     stop = monotonic()
     _LOGGER.info("Home Assistant initialized in %.2fs", stop - start)
-
-    if (
-        REQUIRED_NEXT_PYTHON_HA_RELEASE
-        and sys.version_info[:3] < REQUIRED_NEXT_PYTHON_VER
-    ):
-        current_python_version = ".".join(str(x) for x in sys.version_info[:3])
-        required_python_version = ".".join(str(x) for x in REQUIRED_NEXT_PYTHON_VER[:2])
-        _LOGGER.warning(
-            (
-                "Support for the running Python version %s is deprecated and "
-                "will be removed in Home Assistant %s; "
-                "Please upgrade Python to %s"
-            ),
-            current_python_version,
-            REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            required_python_version,
-        )
-        issue_registry.async_create_issue(
-            hass,
-            core.DOMAIN,
-            f"python_version_{required_python_version}",
-            is_fixable=False,
-            severity=issue_registry.IssueSeverity.WARNING,
-            breaks_in_ha_version=REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            translation_key="python_version",
-            translation_placeholders={
-                "current_python_version": current_python_version,
-                "required_python_version": required_python_version,
-                "breaks_in_ha_version": REQUIRED_NEXT_PYTHON_HA_RELEASE,
-            },
-        )
-
     return hass
 
 

homeassistant/brands/cloudflare.json

@@ -0,0 +1,5 @@
+{
+  "domain": "cloudflare",
+  "name": "Cloudflare",
+  "integrations": ["cloudflare", "cloudflare_r2"]
+}

homeassistant/brands/leviton.json

@@ -1,5 +1,6 @@
 {
   "domain": "leviton",
   "name": "Leviton",
+  "integrations": ["decora_wifi"],
   "iot_standards": ["zwave"]
 }

homeassistant/components/abode/__init__.py

@@ -30,7 +30,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_POLLING, DOMAIN, LOGGER
+from .const import CONF_POLLING, DOMAIN, DOMAIN_DATA, LOGGER
 from .services import async_setup_services
 
 ATTR_DEVICE_NAME = "device_name"
@@ -99,7 +99,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     except (AbodeException, ConnectTimeout, HTTPError) as ex:
         raise ConfigEntryNotReady(f"Unable to connect to Abode: {ex}") from ex
 
-    hass.data[DOMAIN] = AbodeSystem(abode, polling)
+    hass.data[DOMAIN_DATA] = AbodeSystem(abode, polling)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -113,11 +113,12 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
-    await hass.async_add_executor_job(hass.data[DOMAIN].abode.events.stop)
-    await hass.async_add_executor_job(hass.data[DOMAIN].abode.logout)
+    await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.events.stop)
+    await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.logout)
 
-    hass.data[DOMAIN].logout_listener()
-    hass.data.pop(DOMAIN)
+    if logout_listener := hass.data[DOMAIN_DATA].logout_listener:
+        logout_listener()
+    hass.data.pop(DOMAIN_DATA)
 
     return unload_ok
 
@@ -127,16 +128,16 @@ async def setup_hass_events(hass: HomeAssistant) -> None:
 
     def logout(event: Event) -> None:
         """Logout of Abode."""
-        if not hass.data[DOMAIN].polling:
-            hass.data[DOMAIN].abode.events.stop()
+        if not hass.data[DOMAIN_DATA].polling:
+            hass.data[DOMAIN_DATA].abode.events.stop()
 
-        hass.data[DOMAIN].abode.logout()
+        hass.data[DOMAIN_DATA].abode.logout()
         LOGGER.info("Logged out of Abode")
 
-    if not hass.data[DOMAIN].polling:
-        await hass.async_add_executor_job(hass.data[DOMAIN].abode.events.start)
+    if not hass.data[DOMAIN_DATA].polling:
+        await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.events.start)
 
-    hass.data[DOMAIN].logout_listener = hass.bus.async_listen_once(
+    hass.data[DOMAIN_DATA].logout_listener = hass.bus.async_listen_once(
         EVENT_HOMEASSISTANT_STOP, logout
     )
 
@@ -178,6 +179,6 @@ def setup_abode_events(hass: HomeAssistant) -> None:
     ]
 
     for event in events:
-        hass.data[DOMAIN].abode.events.add_event_callback(
+        hass.data[DOMAIN_DATA].abode.events.add_event_callback(
             event, partial(event_callback, event)
         )

homeassistant/components/abode/alarm_control_panel.py

@@ -13,8 +13,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
@@ -24,7 +23,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode alarm control panel device."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
     async_add_entities(
         [AbodeAlarm(data, await hass.async_add_executor_job(data.abode.get_alarm))]
     )

homeassistant/components/abode/binary_sensor.py

@@ -15,8 +15,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.enum import try_parse_enum
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
@@ -26,7 +25,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode binary sensor devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     device_types = [
         "connectivity",

homeassistant/components/abode/camera.py

@@ -19,7 +19,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import Throttle
 
 from . import AbodeSystem
-from .const import DOMAIN, LOGGER
+from .const import DOMAIN_DATA, LOGGER
 from .entity import AbodeDevice
 
 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
@@ -31,7 +31,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode camera devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeCamera(data, device, timeline.CAPTURE_IMAGE)

homeassistant/components/abode/const.py

@@ -1,10 +1,19 @@
 """Constants for the Abode Security System component."""
 
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
+
+from homeassistant.util.hass_dict import HassKey
+
+if TYPE_CHECKING:
+    from . import AbodeSystem
 
 LOGGER = logging.getLogger(__package__)
 
 DOMAIN = "abode"
+DOMAIN_DATA: HassKey[AbodeSystem] = HassKey(DOMAIN)
 ATTRIBUTION = "Data provided by goabode.com"
 
 CONF_POLLING = "polling"

homeassistant/components/abode/cover.py

@@ -9,8 +9,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
@@ -20,7 +19,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode cover devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeCover(data, device)

homeassistant/components/abode/entity.py

@@ -7,7 +7,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
 from . import AbodeSystem
-from .const import ATTRIBUTION, DOMAIN
+from .const import ATTRIBUTION, DOMAIN, DOMAIN_DATA
 
 
 class AbodeEntity(Entity):
@@ -29,7 +29,7 @@ class AbodeEntity(Entity):
             self._update_connection_status,
         )
 
-        self.hass.data[DOMAIN].entity_ids.add(self.entity_id)
+        self.hass.data[DOMAIN_DATA].entity_ids.add(self.entity_id)
 
     async def async_will_remove_from_hass(self) -> None:
         """Unsubscribe from Abode connection status updates."""

homeassistant/components/abode/light.py

@@ -20,8 +20,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
@@ -31,7 +30,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode light devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeLight(data, device)
@@ -100,7 +99,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return _hs
 
     @property
-    def color_mode(self) -> str | None:
+    def color_mode(self) -> ColorMode | None:
         """Return the color mode of the light."""
         if self._device.is_dimmable and self._device.is_color_capable:
             if self.hs_color is not None:
@@ -111,7 +110,7 @@ class AbodeLight(AbodeDevice, LightEntity):
         return ColorMode.ONOFF
 
     @property
-    def supported_color_modes(self) -> set[str] | None:
+    def supported_color_modes(self) -> set[ColorMode] | None:
         """Flag supported color modes."""
         if self._device.is_dimmable and self._device.is_color_capable:
             return {ColorMode.COLOR_TEMP, ColorMode.HS}

homeassistant/components/abode/lock.py

@@ -9,8 +9,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
@@ -20,7 +19,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode lock devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeLock(data, device)

homeassistant/components/abode/sensor.py

@@ -19,7 +19,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 ABODE_TEMPERATURE_UNIT_HA_UNIT = {
@@ -66,7 +66,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode sensor devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeSensor(data, device, description)

homeassistant/components/abode/services.py

@@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import dispatcher_send
 
-from .const import DOMAIN, LOGGER
+from .const import DOMAIN, DOMAIN_DATA, LOGGER
 
 SERVICE_SETTINGS = "change_setting"
 SERVICE_CAPTURE_IMAGE = "capture_image"
@@ -35,7 +35,7 @@ def _change_setting(call: ServiceCall) -> None:
     value = call.data[ATTR_VALUE]
 
     try:
-        call.hass.data[DOMAIN].abode.set_setting(setting, value)
+        call.hass.data[DOMAIN_DATA].abode.set_setting(setting, value)
     except AbodeException as ex:
         LOGGER.warning(ex)
 
@@ -46,7 +46,7 @@ def _capture_image(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in call.hass.data[DOMAIN].entity_ids
+        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
         if entity_id in entity_ids
     ]
 
@@ -61,7 +61,7 @@ def _trigger_automation(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in call.hass.data[DOMAIN].entity_ids
+        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
         if entity_id in entity_ids
     ]
 

homeassistant/components/abode/switch.py

@@ -12,8 +12,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeSystem
-from .const import DOMAIN
+from .const import DOMAIN_DATA
 from .entity import AbodeAutomation, AbodeDevice
 
 DEVICE_TYPES = ["switch", "valve"]
@@ -25,7 +24,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode switch devices."""
-    data: AbodeSystem = hass.data[DOMAIN]
+    data = hass.data[DOMAIN_DATA]
 
     entities: list[SwitchEntity] = [
         AbodeSwitch(data, device)

homeassistant/components/adax/config_flow.py

@@ -87,7 +87,7 @@ class AdaxConfigFlow(ConfigFlow, domain=DOMAIN):
                 data_schema=data_schema,
             )
 
-        wifi_ssid = user_input[WIFI_SSID].replace(" ", "")
+        wifi_ssid = user_input[WIFI_SSID]
         wifi_pswd = user_input[WIFI_PSWD].replace(" ", "")
         configurator = adax_local.AdaxConfig(wifi_ssid, wifi_pswd)
 

homeassistant/components/adguard/config_flow.py

@@ -107,7 +107,7 @@ class AdGuardHomeFlowHandler(ConfigFlow, domain=DOMAIN):
     async def async_step_hassio(
         self, discovery_info: HassioServiceInfo
     ) -> ConfigFlowResult:
-        """Prepare configuration for a Hass.io AdGuard Home add-on.
+        """Prepare configuration for a Hass.io AdGuard Home app.
 
         This flow is triggered by the discovery component.
         """

homeassistant/components/adguard/entity.py

@@ -52,7 +52,7 @@ class AdGuardHomeEntity(Entity):
     def device_info(self) -> DeviceInfo:
         """Return device information about this AdGuard Home instance."""
         if self._entry.source == SOURCE_HASSIO:
-            config_url = "homeassistant://hassio/ingress/a0d7b954_adguard"
+            config_url = "homeassistant://app/a0d7b954_adguard"
         elif self.adguard.tls:
             config_url = f"https://{self.adguard.host}:{self.adguard.port}"
         else:

homeassistant/components/adguard/strings.json

@@ -9,8 +9,8 @@
     },
     "step": {
       "hassio_confirm": {
-        "description": "Do you want to configure Home Assistant to connect to the AdGuard Home provided by the add-on: {addon}?",
-        "title": "AdGuard Home via Home Assistant add-on"
+        "description": "Do you want to configure Home Assistant to connect to the AdGuard Home provided by the app: {addon}?",
+        "title": "AdGuard Home via Home Assistant app"
       },
       "user": {
         "data": {

homeassistant/components/advantage_air/__init__.py

@@ -8,12 +8,15 @@ from advantage_air import ApiError, advantage_air
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.debounce import Debouncer
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import ADVANTAGE_AIR_RETRY
+from .const import ADVANTAGE_AIR_RETRY, DOMAIN
 from .models import AdvantageAirData
+from .services import async_setup_services
 
 type AdvantageAirDataConfigEntry = ConfigEntry[AdvantageAirData]
 
@@ -32,6 +35,14 @@ PLATFORMS = [
 _LOGGER = logging.getLogger(__name__)
 REQUEST_REFRESH_DELAY = 0.5
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: AdvantageAirDataConfigEntry

homeassistant/components/advantage_air/sensor.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from decimal import Decimal
 from typing import Any
 
-import voluptuous as vol
-
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -14,7 +12,6 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AdvantageAirDataConfigEntry
@@ -24,7 +21,6 @@ from .models import AdvantageAirData
 
 ADVANTAGE_AIR_SET_COUNTDOWN_VALUE = "minutes"
 ADVANTAGE_AIR_SET_COUNTDOWN_UNIT = "min"
-ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
 
 PARALLEL_UPDATES = 0
 
@@ -53,13 +49,6 @@ async def async_setup_entry(
                     entities.append(AdvantageAirZoneSignal(instance, ac_key, zone_key))
     async_add_entities(entities)
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
-        {vol.Required("minutes"): cv.positive_int},
-        "set_time_to",
-    )
-
 
 class AdvantageAirTimeTo(AdvantageAirAcEntity, SensorEntity):
     """Representation of Advantage Air timer control."""

homeassistant/components/advantage_air/services.py

@@ -0,0 +1,27 @@
+"""Services for Advantage Air integration."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
+        entity_domain=SENSOR_DOMAIN,
+        schema={vol.Required("minutes"): cv.positive_int},
+        func="set_time_to",
+    )

homeassistant/components/agent_dvr/__init__.py

@@ -7,10 +7,12 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, SERVER_URL
+from .services import async_setup_services
 
 ATTRIBUTION = "ispyconnect.com"
 DEFAULT_BRAND = "Agent DVR by ispyconnect.com"
@@ -19,6 +21,14 @@ PLATFORMS = [Platform.ALARM_CONTROL_PANEL, Platform.CAMERA]
 
 AgentDVRConfigEntry = ConfigEntry[Agent]
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(
     hass: HomeAssistant, config_entry: AgentDVRConfigEntry

homeassistant/components/agent_dvr/camera.py

@@ -9,10 +9,7 @@ from homeassistant.components.camera import CameraEntityFeature
 from homeassistant.components.mjpeg import MjpegCamera, filter_urllib3_logging
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    async_get_current_platform,
-)
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AgentDVRConfigEntry
 from .const import ATTRIBUTION, CAMERA_SCAN_INTERVAL_SECS, DOMAIN
@@ -21,20 +18,6 @@ SCAN_INTERVAL = timedelta(seconds=CAMERA_SCAN_INTERVAL_SECS)
 
 _LOGGER = logging.getLogger(__name__)
 
-_DEV_EN_ALT = "enable_alerts"
-_DEV_DS_ALT = "disable_alerts"
-_DEV_EN_REC = "start_recording"
-_DEV_DS_REC = "stop_recording"
-_DEV_SNAP = "snapshot"
-
-CAMERA_SERVICES = {
-    _DEV_EN_ALT: "async_enable_alerts",
-    _DEV_DS_ALT: "async_disable_alerts",
-    _DEV_EN_REC: "async_start_recording",
-    _DEV_DS_REC: "async_stop_recording",
-    _DEV_SNAP: "async_snapshot",
-}
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -57,10 +40,6 @@ async def async_setup_entry(
 
     async_add_entities(cameras)
 
-    platform = async_get_current_platform()
-    for service, method in CAMERA_SERVICES.items():
-        platform.async_register_entity_service(service, None, method)
-
 
 class AgentCamera(MjpegCamera):
     """Representation of an Agent Device Stream."""

homeassistant/components/agent_dvr/services.py

@@ -0,0 +1,38 @@
+"""Services for Agent DVR."""
+
+from __future__ import annotations
+
+from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import service
+
+from .const import DOMAIN
+
+_DEV_EN_ALT = "enable_alerts"
+_DEV_DS_ALT = "disable_alerts"
+_DEV_EN_REC = "start_recording"
+_DEV_DS_REC = "stop_recording"
+_DEV_SNAP = "snapshot"
+
+CAMERA_SERVICES = {
+    _DEV_EN_ALT: "async_enable_alerts",
+    _DEV_DS_ALT: "async_disable_alerts",
+    _DEV_EN_REC: "async_start_recording",
+    _DEV_DS_REC: "async_stop_recording",
+    _DEV_SNAP: "async_snapshot",
+}
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    for service_name, method in CAMERA_SERVICES.items():
+        service.async_register_platform_entity_service(
+            hass,
+            DOMAIN,
+            service_name,
+            entity_domain=CAMERA_DOMAIN,
+            schema=None,
+            func=method,
+        )

homeassistant/components/airobot/__init__.py

@@ -7,7 +7,13 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.NUMBER, Platform.SENSOR]
+PLATFORMS: list[Platform] = [
+    Platform.BUTTON,
+    Platform.CLIMATE,
+    Platform.NUMBER,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:

homeassistant/components/airobot/button.py

@@ -0,0 +1,96 @@
+"""Button platform for Airobot integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from pyairobotrest.exceptions import (
+    AirobotConnectionError,
+    AirobotError,
+    AirobotTimeoutError,
+)
+
+from homeassistant.components.button import (
+    ButtonDeviceClass,
+    ButtonEntity,
+    ButtonEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotButtonEntityDescription(ButtonEntityDescription):
+    """Describes Airobot button entity."""
+
+    press_fn: Callable[[AirobotDataUpdateCoordinator], Coroutine[Any, Any, None]]
+
+
+BUTTON_TYPES: tuple[AirobotButtonEntityDescription, ...] = (
+    AirobotButtonEntityDescription(
+        key="restart",
+        device_class=ButtonDeviceClass.RESTART,
+        entity_category=EntityCategory.CONFIG,
+        press_fn=lambda coordinator: coordinator.client.reboot_thermostat(),
+    ),
+    AirobotButtonEntityDescription(
+        key="recalibrate_co2",
+        translation_key="recalibrate_co2",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        press_fn=lambda coordinator: coordinator.client.recalibrate_co2_sensor(),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot button entities."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AirobotButton(coordinator, description) for description in BUTTON_TYPES
+    )
+
+
+class AirobotButton(AirobotEntity, ButtonEntity):
+    """Representation of an Airobot button."""
+
+    entity_description: AirobotButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirobotDataUpdateCoordinator,
+        description: AirobotButtonEntityDescription,
+    ) -> None:
+        """Initialize the button."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        try:
+            await self.entity_description.press_fn(self.coordinator)
+        except (AirobotConnectionError, AirobotTimeoutError):
+            # Connection errors during reboot are expected as device restarts
+            pass
+        except AirobotError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="button_press_failed",
+                translation_placeholders={"button": self.entity_description.key},
+            ) from err

homeassistant/components/airobot/climate.py

@@ -29,6 +29,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AirobotConfigEntry
 from .const import DOMAIN
+from .coordinator import AirobotDataUpdateCoordinator
 from .entity import AirobotEntity
 
 PARALLEL_UPDATES = 1
@@ -63,6 +64,11 @@ class AirobotClimate(AirobotEntity, ClimateEntity):
     _attr_min_temp = SETPOINT_TEMP_MIN
     _attr_max_temp = SETPOINT_TEMP_MAX
 
+    def __init__(self, coordinator: AirobotDataUpdateCoordinator) -> None:
+        """Initialize the climate entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = coordinator.data.status.device_id
+
     @property
     def _status(self) -> ThermostatStatus:
         """Get status from coordinator data."""

homeassistant/components/airobot/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import Mapping
 from dataclasses import dataclass
 import logging
@@ -60,11 +61,17 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> DeviceInf
 
     try:
         # Try to fetch data to validate connection and authentication
-        status = await client.get_statuses()
-        settings = await client.get_settings()
+        status, settings = await asyncio.gather(
+            client.get_statuses(), client.get_settings()
+        )
     except AirobotAuthError as err:
         raise InvalidAuth from err
-    except (AirobotConnectionError, AirobotTimeoutError, AirobotError) as err:
+    except (
+        AirobotConnectionError,
+        AirobotTimeoutError,
+        AirobotError,
+        TimeoutError,
+    ) as err:
         raise CannotConnect from err
 
     # Use device name or device ID as title

homeassistant/components/airobot/coordinator.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import timedelta
 import logging
 
@@ -52,8 +53,10 @@ class AirobotDataUpdateCoordinator(DataUpdateCoordinator[AirobotData]):
     async def _async_update_data(self) -> AirobotData:
         """Fetch data from API endpoint."""
         try:
-            status = await self.client.get_statuses()
-            settings = await self.client.get_settings()
+            status, settings = await asyncio.gather(
+                self.client.get_statuses(),
+                self.client.get_settings(),
+            )
         except AirobotAuthError as err:
             raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,

homeassistant/components/airobot/entity.py

@@ -24,8 +24,6 @@ class AirobotEntity(CoordinatorEntity[AirobotDataUpdateCoordinator]):
         status = coordinator.data.status
         settings = coordinator.data.settings
 
-        self._attr_unique_id = status.device_id
-
         connections = set()
         if (mac := coordinator.config_entry.data.get(CONF_MAC)) is not None:
             connections.add((CONNECTION_NETWORK_MAC, mac))
@@ -37,6 +35,6 @@ class AirobotEntity(CoordinatorEntity[AirobotDataUpdateCoordinator]):
             manufacturer="Airobot",
             model="Thermostat",
             model_id="TE1",
-            sw_version=str(status.fw_version),
-            hw_version=str(status.hw_version),
+            sw_version=status.fw_version_string,
+            hw_version=status.hw_version_string,
         )

homeassistant/components/airobot/icons.json

@@ -1,9 +1,22 @@
 {
   "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "default": "mdi:molecule-co2"
+      }
+    },
     "number": {
       "hysteresis_band": {
         "default": "mdi:delta"
       }
+    },
+    "switch": {
+      "actuator_exercise_disabled": {
+        "default": "mdi:valve"
+      },
+      "child_lock": {
+        "default": "mdi:lock"
+      }
     }
   }
 }

homeassistant/components/airobot/manifest.json

@@ -12,6 +12,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyairobotrest"],
-  "quality_scale": "silver",
-  "requirements": ["pyairobotrest==0.2.0"]
+  "quality_scale": "platinum",
+  "requirements": ["pyairobotrest==0.3.0"]
 }

homeassistant/components/airobot/quality_scale.yaml

@@ -43,7 +43,7 @@ rules:
   discovery-update-info: done
   discovery: done
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
@@ -69,4 +69,4 @@ rules:
   # Platinum
   async-dependency: done
   inject-websession: done
-  strict-typing: todo
+  strict-typing: done

homeassistant/components/airobot/sensor.py

@@ -28,6 +28,7 @@ from homeassistant.util.dt import utcnow
 from homeassistant.util.variance import ignore_variance
 
 from . import AirobotConfigEntry
+from .coordinator import AirobotDataUpdateCoordinator
 from .entity import AirobotEntity
 
 PARALLEL_UPDATES = 0
@@ -53,6 +54,7 @@ SENSOR_TYPES: tuple[AirobotSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
         value_fn=lambda status: status.temp_air,
     ),
     AirobotSensorEntityDescription(
@@ -136,7 +138,7 @@ class AirobotSensor(AirobotEntity, SensorEntity):
 
     def __init__(
         self,
-        coordinator,
+        coordinator: AirobotDataUpdateCoordinator,
         description: AirobotSensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""

homeassistant/components/airobot/strings.json

@@ -59,6 +59,11 @@
     }
   },
   "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "name": "Recalibrate CO2 sensor"
+      }
+    },
     "number": {
       "hysteresis_band": {
         "name": "Hysteresis band"
@@ -80,12 +85,23 @@
       "heating_uptime": {
         "name": "Heating uptime"
       }
+    },
+    "switch": {
+      "actuator_exercise_disabled": {
+        "name": "Actuator exercise disabled"
+      },
+      "child_lock": {
+        "name": "Child lock"
+      }
     }
   },
   "exceptions": {
     "authentication_failed": {
       "message": "Authentication failed, please reauthenticate."
     },
+    "button_press_failed": {
+      "message": "Failed to press {button} button."
+    },
     "connection_failed": {
       "message": "Failed to communicate with device."
     },
@@ -97,6 +113,12 @@
     },
     "set_value_failed": {
       "message": "Failed to set value: {error}"
+    },
+    "switch_turn_off_failed": {
+      "message": "Failed to turn off {switch}."
+    },
+    "switch_turn_on_failed": {
+      "message": "Failed to turn on {switch}."
     }
   }
 }

homeassistant/components/airobot/switch.py

@@ -0,0 +1,118 @@
+"""Switch platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from pyairobotrest.exceptions import AirobotError
+
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirobotConfigEntry
+from .const import DOMAIN
+from .coordinator import AirobotDataUpdateCoordinator
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotSwitchEntityDescription(SwitchEntityDescription):
+    """Describes Airobot switch entity."""
+
+    is_on_fn: Callable[[AirobotDataUpdateCoordinator], bool]
+    turn_on_fn: Callable[[AirobotDataUpdateCoordinator], Coroutine[Any, Any, None]]
+    turn_off_fn: Callable[[AirobotDataUpdateCoordinator], Coroutine[Any, Any, None]]
+
+
+SWITCH_TYPES: tuple[AirobotSwitchEntityDescription, ...] = (
+    AirobotSwitchEntityDescription(
+        key="child_lock",
+        translation_key="child_lock",
+        entity_category=EntityCategory.CONFIG,
+        is_on_fn=lambda coordinator: (
+            coordinator.data.settings.setting_flags.childlock_enabled
+        ),
+        turn_on_fn=lambda coordinator: coordinator.client.set_child_lock(True),
+        turn_off_fn=lambda coordinator: coordinator.client.set_child_lock(False),
+    ),
+    AirobotSwitchEntityDescription(
+        key="actuator_exercise_disabled",
+        translation_key="actuator_exercise_disabled",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        is_on_fn=lambda coordinator: (
+            coordinator.data.settings.setting_flags.actuator_exercise_disabled
+        ),
+        turn_on_fn=lambda coordinator: coordinator.client.toggle_actuator_exercise(
+            True
+        ),
+        turn_off_fn=lambda coordinator: coordinator.client.toggle_actuator_exercise(
+            False
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot switch entities."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AirobotSwitch(coordinator, description) for description in SWITCH_TYPES
+    )
+
+
+class AirobotSwitch(AirobotEntity, SwitchEntity):
+    """Representation of an Airobot switch."""
+
+    entity_description: AirobotSwitchEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirobotDataUpdateCoordinator,
+        description: AirobotSwitchEntityDescription,
+    ) -> None:
+        """Initialize the switch."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if the switch is on."""
+        return self.entity_description.is_on_fn(self.coordinator)
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the switch on."""
+        try:
+            await self.entity_description.turn_on_fn(self.coordinator)
+        except AirobotError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="switch_turn_on_failed",
+                translation_placeholders={"switch": self.entity_description.key},
+            ) from err
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the switch off."""
+        try:
+            await self.entity_description.turn_off_fn(self.coordinator)
+        except AirobotError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="switch_turn_off_failed",
+                translation_placeholders={"switch": self.entity_description.key},
+            ) from err
+        await self.coordinator.async_request_refresh()

homeassistant/components/airos/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["airos==0.6.1"]
+  "requirements": ["airos==0.6.3"]
 }

homeassistant/components/airq/icons.json

@@ -4,12 +4,24 @@
       "health_index": {
         "default": "mdi:heart-pulse"
       },
+      "mold": {
+        "default": "mdi:water-check"
+      },
       "oxygen": {
         "default": "mdi:leaf"
       },
       "performance_index": {
         "default": "mdi:head-check"
       },
+      "r32": {
+        "default": "mdi:hvac"
+      },
+      "r454b": {
+        "default": "mdi:hvac"
+      },
+      "r454c": {
+        "default": "mdi:hvac"
+      },
       "radon": {
         "default": "mdi:radioactive"
       },

homeassistant/components/airq/sensor.py

@@ -219,6 +219,13 @@ SENSOR_TYPES: list[AirQEntityDescription] = [
         state_class=SensorStateClass.MEASUREMENT,
         value=lambda data: data.get("ch4_MIPEX"),
     ),
+    AirQEntityDescription(
+        key="mold",
+        translation_key="mold",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value=lambda data: data.get("mold"),
+    ),
     AirQEntityDescription(
         key="n2o",
         device_class=SensorDeviceClass.NITROUS_OXIDE,
@@ -319,11 +326,25 @@ SENSOR_TYPES: list[AirQEntityDescription] = [
         value=lambda data: data.get("c3h8_MIPEX"),
     ),
     AirQEntityDescription(
-        key="refigerant",
-        translation_key="refigerant",
-        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        key="r32",
+        translation_key="r32",
+        native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        value=lambda data: data.get("refigerant"),
+        value=lambda data: data.get("r32"),
+    ),
+    AirQEntityDescription(
+        key="r454b",
+        translation_key="r454b",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value=lambda data: data.get("r454b"),
+    ),
+    AirQEntityDescription(
+        key="r454c",
+        translation_key="r454c",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value=lambda data: data.get("r454c"),
     ),
     AirQEntityDescription(
         key="sih4",

homeassistant/components/airq/strings.json

@@ -101,6 +101,9 @@
       "methanethiol": {
         "name": "Methanethiol"
       },
+      "mold": {
+        "name": "Mold index"
+      },
       "noise": {
         "name": "Noise"
       },
@@ -116,12 +119,18 @@
       "propane": {
         "name": "Propane"
       },
+      "r32": {
+        "name": "Refrigerant R-32"
+      },
+      "r454b": {
+        "name": "Refrigerant R-454B"
+      },
+      "r454c": {
+        "name": "Refrigerant R-454C"
+      },
       "radon": {
         "name": "Radon"
       },
-      "refigerant": {
-        "name": "Refrigerant"
-      },
       "relative_pressure": {
         "name": "Relative pressure"
       },

homeassistant/components/airthings_ble/icons.json

@@ -1,6 +1,14 @@
 {
   "entity": {
     "sensor": {
+      "connectivity_mode": {
+        "default": "mdi:bluetooth-off",
+        "state": {
+          "bluetooth": "mdi:bluetooth",
+          "not_configured": "mdi:alert-circle",
+          "smartlink": "mdi:hub"
+        }
+      },
       "radon_1day_avg": {
         "default": "mdi:radioactive"
       },

homeassistant/components/airthings_ble/sensor.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import dataclasses
 import logging
 
-from airthings_ble import AirthingsDevice
+from airthings_ble import AirthingsConnectivityMode, AirthingsDevice
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -41,6 +41,12 @@ from .coordinator import AirthingsBLEConfigEntry, AirthingsBLEDataUpdateCoordina
 
 _LOGGER = logging.getLogger(__name__)
 
+CONNECTIVITY_MODE_MAP = {
+    AirthingsConnectivityMode.BLE.value: "bluetooth",
+    AirthingsConnectivityMode.SMARTLINK.value: "smartlink",
+    AirthingsConnectivityMode.NOT_CONFIGURED.value: "not_configured",
+}
+
 SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
     "radon_1day_avg": SensorEntityDescription(
         key="radon_1day_avg",
@@ -129,6 +135,14 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
         state_class=SensorStateClass.MEASUREMENT,
         suggested_display_precision=0,
     ),
+    "connectivity_mode": SensorEntityDescription(
+        key="connectivity_mode",
+        translation_key="connectivity_mode",
+        device_class=SensorDeviceClass.ENUM,
+        options=list(CONNECTIVITY_MODE_MAP.values()),
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
 }
 
 PARALLEL_UPDATES = 0
@@ -256,4 +270,12 @@ class AirthingsSensor(
     @property
     def native_value(self) -> StateType:
         """Return the value reported by the sensor."""
-        return self.coordinator.data.sensors[self.entity_description.key]
+        value = self.coordinator.data.sensors[self.entity_description.key]
+
+        # Map connectivity mode to enum values
+        if self.entity_description.key == "connectivity_mode":
+            if not isinstance(value, str):
+                return None
+            return CONNECTIVITY_MODE_MAP.get(value)
+
+        return value

homeassistant/components/airthings_ble/strings.json

@@ -30,6 +30,14 @@
       "ambient_noise": {
         "name": "Ambient noise"
       },
+      "connectivity_mode": {
+        "name": "Connectivity mode",
+        "state": {
+          "bluetooth": "Bluetooth",
+          "not_configured": "Not configured",
+          "smartlink": "SmartLink"
+        }
+      },
       "illuminance": {
         "name": "[%key:component::sensor::entity_component::illuminance::name%]"
       },

homeassistant/components/airzone/entity.py

@@ -85,6 +85,22 @@ class AirzoneSystemEntity(AirzoneEntity):
                 value = system[key]
         return value
 
+    async def _async_update_sys_params(self, params: dict[str, Any]) -> None:
+        """Send system parameters to API."""
+        _params = {
+            API_SYSTEM_ID: self.system_id,
+            **params,
+        }
+        _LOGGER.debug("update_sys_params=%s", _params)
+        try:
+            await self.coordinator.airzone.set_sys_parameters(_params)
+        except AirzoneError as error:
+            raise HomeAssistantError(
+                f"Failed to set system {self.entity_id}: {error}"
+            ) from error
+
+        self.coordinator.async_set_updated_data(self.coordinator.airzone.data())
+
 
 class AirzoneHotWaterEntity(AirzoneEntity):
     """Define an Airzone Hot Water entity."""

homeassistant/components/airzone/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==1.0.4"]
+  "requirements": ["aioairzone==1.0.5"]
 }

homeassistant/components/airzone/select.py

@@ -20,6 +20,7 @@ from aioairzone.const import (
     AZD_MODES,
     AZD_Q_ADAPT,
     AZD_SLEEP,
+    AZD_SYSTEMS,
     AZD_ZONES,
 )
 
@@ -30,7 +31,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AirzoneConfigEntry, AirzoneUpdateCoordinator
-from .entity import AirzoneEntity, AirzoneZoneEntity
+from .entity import AirzoneEntity, AirzoneSystemEntity, AirzoneZoneEntity
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -85,14 +86,7 @@ def main_zone_options(
     return [k for k, v in options.items() if v in modes]
 
 
-MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
-    AirzoneSelectDescription(
-        api_param=API_MODE,
-        key=AZD_MODE,
-        options_dict=MODE_DICT,
-        options_fn=main_zone_options,
-        translation_key="modes",
-    ),
+SYSTEM_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_Q_ADAPT,
         entity_category=EntityCategory.CONFIG,
@@ -104,6 +98,17 @@ MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
 )
 
 
+MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
+    AirzoneSelectDescription(
+        api_param=API_MODE,
+        key=AZD_MODE,
+        options_dict=MODE_DICT,
+        options_fn=main_zone_options,
+        translation_key="modes",
+    ),
+)
+
+
 ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_COLD_ANGLE,
@@ -140,16 +145,37 @@ async def async_setup_entry(
     """Add Airzone select from a config_entry."""
     coordinator = entry.runtime_data
 
+    added_systems: set[str] = set()
     added_zones: set[str] = set()
 
     def _async_entity_listener() -> None:
         """Handle additions of select."""
 
+        entities: list[AirzoneBaseSelect] = []
+
+        systems_data = coordinator.data.get(AZD_SYSTEMS, {})
+        received_systems = set(systems_data)
+        new_systems = received_systems - added_systems
+        if new_systems:
+            entities.extend(
+                AirzoneSystemSelect(
+                    coordinator,
+                    description,
+                    entry,
+                    system_id,
+                    systems_data.get(system_id),
+                )
+                for system_id in new_systems
+                for description in SYSTEM_SELECT_TYPES
+                if description.key in systems_data.get(system_id)
+            )
+            added_systems.update(new_systems)
+
         zones_data = coordinator.data.get(AZD_ZONES, {})
         received_zones = set(zones_data)
         new_zones = received_zones - added_zones
         if new_zones:
-            entities: list[AirzoneZoneSelect] = [
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -161,8 +187,8 @@ async def async_setup_entry(
                 for description in MAIN_ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
                 and zones_data.get(system_zone_id).get(AZD_MASTER) is True
-            ]
-            entities += [
+            )
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -173,10 +199,11 @@ async def async_setup_entry(
                 for system_zone_id in new_zones
                 for description in ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
-            ]
-            async_add_entities(entities)
+            )
             added_zones.update(new_zones)
 
+        async_add_entities(entities)
+
     entry.async_on_unload(coordinator.async_add_listener(_async_entity_listener))
     _async_entity_listener()
 
@@ -203,6 +230,38 @@ class AirzoneBaseSelect(AirzoneEntity, SelectEntity):
         self._attr_current_option = self._get_current_option()
 
 
+class AirzoneSystemSelect(AirzoneSystemEntity, AirzoneBaseSelect):
+    """Define an Airzone System select."""
+
+    def __init__(
+        self,
+        coordinator: AirzoneUpdateCoordinator,
+        description: AirzoneSelectDescription,
+        entry: ConfigEntry,
+        system_id: str,
+        system_data: dict[str, Any],
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator, entry, system_data)
+
+        self._attr_unique_id = f"{self._attr_unique_id}_{system_id}_{description.key}"
+        self.entity_description = description
+
+        self._attr_options = self.entity_description.options_fn(
+            system_data, description.options_dict
+        )
+
+        self.values_dict = {v: k for k, v in description.options_dict.items()}
+
+        self._async_update_attrs()
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        param = self.entity_description.api_param
+        value = self.entity_description.options_dict[option]
+        await self._async_update_sys_params({param: value})
+
+
 class AirzoneZoneSelect(AirzoneZoneEntity, AirzoneBaseSelect):
     """Define an Airzone Zone select."""
 

homeassistant/components/aladdin_connect/strings.json

@@ -9,6 +9,7 @@
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
       "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
       "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "oauth_implementation_unavailable": "[%key:common::config_flow::abort::oauth2_implementation_unavailable%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
       "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",

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 EntityStateRequiredFeaturesCondition(EntityStateConditionBase):
+    """State condition."""
+
+    _required_features: int
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain with the required features."""
+        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_required_features_condition(
+    domain: str, to_state: str, required_features: int
+) -> type[EntityStateRequiredFeaturesCondition]:
+    """Create an entity state condition class with required feature filtering."""
+
+    class CustomCondition(EntityStateRequiredFeaturesCondition):
+        """Condition 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_required_features_condition(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_AWAY,
+        AlarmControlPanelEntityFeature.ARM_AWAY,
+    ),
+    "is_armed_home": make_entity_state_required_features_condition(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_HOME,
+        AlarmControlPanelEntityFeature.ARM_HOME,
+    ),
+    "is_armed_night": make_entity_state_required_features_condition(
+        DOMAIN,
+        AlarmControlPanelState.ARMED_NIGHT,
+        AlarmControlPanelEntityFeature.ARM_NIGHT,
+    ),
+    "is_armed_vacation": make_entity_state_required_features_condition(
+        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": "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": "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": "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": "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": "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": "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": "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",
@@ -86,7 +166,7 @@
   },
   "services": {
     "alarm_arm_away": {
-      "description": "Arms the alarm in the away mode.",
+      "description": "Arms an alarm in the away mode.",
       "fields": {
         "code": {
           "description": "[%key:component::alarm_control_panel::services::alarm_arm_custom_bypass::fields::code::description%]",
@@ -96,7 +176,7 @@
       "name": "Arm away"
     },
     "alarm_arm_custom_bypass": {
-      "description": "Arms the alarm while allowing to bypass a custom area.",
+      "description": "Arms an alarm while allowing to bypass a custom area.",
       "fields": {
         "code": {
           "description": "Code to arm the alarm.",
@@ -106,7 +186,7 @@
       "name": "Arm with custom bypass"
     },
     "alarm_arm_home": {
-      "description": "Arms the alarm in the home mode.",
+      "description": "Arms an alarm in the home mode.",
       "fields": {
         "code": {
           "description": "[%key:component::alarm_control_panel::services::alarm_arm_custom_bypass::fields::code::description%]",
@@ -116,7 +196,7 @@
       "name": "Arm home"
     },
     "alarm_arm_night": {
-      "description": "Arms the alarm in the night mode.",
+      "description": "Arms an alarm in the night mode.",
       "fields": {
         "code": {
           "description": "[%key:component::alarm_control_panel::services::alarm_arm_custom_bypass::fields::code::description%]",
@@ -126,7 +206,7 @@
       "name": "Arm night"
     },
     "alarm_arm_vacation": {
-      "description": "Arms the alarm in the vacation mode.",
+      "description": "Arms an alarm in the vacation mode.",
       "fields": {
         "code": {
           "description": "[%key:component::alarm_control_panel::services::alarm_arm_custom_bypass::fields::code::description%]",
@@ -136,7 +216,7 @@
       "name": "Arm vacation"
     },
     "alarm_disarm": {
-      "description": "Disarms the alarm.",
+      "description": "Disarms an alarm.",
       "fields": {
         "code": {
           "description": "Code to disarm the alarm.",
@@ -146,7 +226,7 @@
       "name": "Disarm"
     },
     "alarm_trigger": {
-      "description": "Triggers the alarm manually.",
+      "description": "Triggers an alarm manually.",
       "fields": {
         "code": {
           "description": "[%key:component::alarm_control_panel::services::alarm_arm_custom_bypass::fields::code::description%]",

homeassistant/components/alarm_control_panel/trigger.py

@@ -14,7 +14,7 @@ from .const import DOMAIN, AlarmControlPanelEntityFeature, AlarmControlPanelStat
 
 
 def supports_feature(hass: HomeAssistant, entity_id: str, features: int) -> bool:
-    """Get the device class of an entity or UNDEFINED if not found."""
+    """Test if an entity supports the specified features."""
     try:
         return bool(get_supported_features(hass, entity_id) & features)
     except HomeAssistantError:
@@ -39,7 +39,7 @@ class EntityStateTriggerRequiredFeatures(EntityTargetStateTriggerBase):
 def make_entity_state_trigger_required_features(
     domain: str, to_state: str, required_features: int
 ) -> type[EntityTargetStateTriggerBase]:
-    """Create an entity state trigger class."""
+    """Create an entity state trigger class with required feature filtering."""
 
     class CustomTrigger(EntityStateTriggerRequiredFeatures):
         """Trigger for entity state changes."""

homeassistant/components/alarmdecoder/__init__.py

@@ -18,12 +18,15 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.event import async_call_later
+from homeassistant.helpers.typing import ConfigType
 
 from .const import (
     CONF_DEVICE_BAUD,
     CONF_DEVICE_PATH,
+    DOMAIN,
     PROTOCOL_SERIAL,
     PROTOCOL_SOCKET,
     SIGNAL_PANEL_MESSAGE,
@@ -32,9 +35,11 @@ from .const import (
     SIGNAL_ZONE_FAULT,
     SIGNAL_ZONE_RESTORE,
 )
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [
     Platform.ALARM_CONTROL_PANEL,
     Platform.BINARY_SENSOR,
@@ -54,6 +59,12 @@ class AlarmDecoderData:
     restart: bool
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(
     hass: HomeAssistant, entry: AlarmDecoderConfigEntry
 ) -> bool:

homeassistant/components/alarmdecoder/alarm_control_panel.py

@@ -2,17 +2,13 @@
 
 from __future__ import annotations
 
-import voluptuous as vol
-
 from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntity,
     AlarmControlPanelEntityFeature,
     AlarmControlPanelState,
     CodeFormat,
 )
-from homeassistant.const import ATTR_CODE
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -27,11 +23,6 @@ from .const import (
 )
 from .entity import AlarmDecoderEntity
 
-SERVICE_ALARM_TOGGLE_CHIME = "alarm_toggle_chime"
-
-SERVICE_ALARM_KEYPRESS = "alarm_keypress"
-ATTR_KEYPRESS = "keypress"
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -50,23 +41,6 @@ async def async_setup_entry(
     )
     async_add_entities([entity])
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_ALARM_TOGGLE_CHIME,
-        {
-            vol.Required(ATTR_CODE): cv.string,
-        },
-        "alarm_toggle_chime",
-    )
-
-    platform.async_register_entity_service(
-        SERVICE_ALARM_KEYPRESS,
-        {
-            vol.Required(ATTR_KEYPRESS): cv.string,
-        },
-        "alarm_keypress",
-    )
-
 
 class AlarmDecoderAlarmPanel(AlarmDecoderEntity, AlarmControlPanelEntity):
     """Representation of an AlarmDecoder-based alarm panel."""

homeassistant/components/alarmdecoder/services.py

@@ -0,0 +1,46 @@
+"""Support for AlarmDecoder-based alarm control panels (Honeywell/DSC)."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.alarm_control_panel import (
+    DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
+)
+from homeassistant.const import ATTR_CODE
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SERVICE_ALARM_TOGGLE_CHIME = "alarm_toggle_chime"
+
+SERVICE_ALARM_KEYPRESS = "alarm_keypress"
+ATTR_KEYPRESS = "keypress"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_ALARM_TOGGLE_CHIME,
+        entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
+        schema={
+            vol.Required(ATTR_CODE): cv.string,
+        },
+        func="alarm_toggle_chime",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_ALARM_KEYPRESS,
+        entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
+        schema={
+            vol.Required(ATTR_KEYPRESS): cv.string,
+        },
+        func="alarm_keypress",
+    )

homeassistant/components/analytics/__init__.py

@@ -4,7 +4,7 @@ from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.components import websocket_api
+from homeassistant.components import labs, websocket_api
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.helpers.typing import ConfigType
@@ -18,7 +18,13 @@ from .analytics import (
     EntityAnalyticsModifications,
     async_devices_payload,
 )
-from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, PREFERENCE_SCHEMA
+from .const import (
+    ATTR_ONBOARDED,
+    ATTR_PREFERENCES,
+    ATTR_SNAPSHOTS,
+    DOMAIN,
+    PREFERENCE_SCHEMA,
+)
 from .http import AnalyticsDevicesView
 
 __all__ = [
@@ -44,29 +50,55 @@ CONFIG_SCHEMA = vol.Schema(
 
 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)
 
+LABS_SNAPSHOT_FEATURE = "snapshots"
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the analytics integration."""
     analytics_config = config.get(DOMAIN, {})
 
-    # For now we want to enable device analytics only if the url option
-    # is explicitly listed in YAML.
     if CONF_SNAPSHOTS_URL in analytics_config:
-        disable_snapshots = False
+        await labs.async_update_preview_feature(
+            hass, DOMAIN, LABS_SNAPSHOT_FEATURE, enabled=True
+        )
         snapshots_url = analytics_config[CONF_SNAPSHOTS_URL]
     else:
-        disable_snapshots = True
         snapshots_url = None
 
-    analytics = Analytics(hass, snapshots_url, disable_snapshots)
+    analytics = Analytics(hass, snapshots_url)
 
     # Load stored data
     await analytics.load()
 
+    started = False
+
+    async def _async_handle_labs_update(
+        event: Event[labs.EventLabsUpdatedData],
+    ) -> None:
+        """Handle labs feature toggle."""
+        await analytics.save_preferences({ATTR_SNAPSHOTS: event.data["enabled"]})
+        if started:
+            await analytics.async_schedule()
+
+    @callback
+    def _async_labs_event_filter(event_data: labs.EventLabsUpdatedData) -> bool:
+        """Filter labs events for this integration's snapshot feature."""
+        return (
+            event_data["domain"] == DOMAIN
+            and event_data["preview_feature"] == LABS_SNAPSHOT_FEATURE
+        )
+
     async def start_schedule(_event: Event) -> None:
         """Start the send schedule after the started event."""
+        nonlocal started
+        started = True
         await analytics.async_schedule()
 
+    hass.bus.async_listen(
+        labs.EVENT_LABS_UPDATED,
+        _async_handle_labs_update,
+        event_filter=_async_labs_event_filter,
+    )
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, start_schedule)
 
     websocket_api.async_register_command(hass, websocket_analytics)

homeassistant/components/analytics/analytics.py

@@ -22,6 +22,7 @@ from homeassistant.components.energy import (
     DOMAIN as ENERGY_DOMAIN,
     is_configured as energy_is_configured,
 )
+from homeassistant.components.labs import async_is_preview_feature_enabled
 from homeassistant.components.recorder import (
     DOMAIN as RECORDER_DOMAIN,
     get_instance as get_recorder_instance,
@@ -241,12 +242,10 @@ class Analytics:
         self,
         hass: HomeAssistant,
         snapshots_url: str | None = None,
-        disable_snapshots: bool = False,
     ) -> None:
         """Initialize the Analytics class."""
         self._hass: HomeAssistant = hass
         self._snapshots_url = snapshots_url
-        self._disable_snapshots = disable_snapshots
 
         self._session = async_get_clientsession(hass)
         self._data = AnalyticsData(False, {})
@@ -258,15 +257,13 @@ class Analytics:
     def preferences(self) -> dict:
         """Return the current active preferences."""
         preferences = self._data.preferences
-        result = {
+        return {
             ATTR_BASE: preferences.get(ATTR_BASE, False),
             ATTR_DIAGNOSTICS: preferences.get(ATTR_DIAGNOSTICS, False),
             ATTR_USAGE: preferences.get(ATTR_USAGE, False),
             ATTR_STATISTICS: preferences.get(ATTR_STATISTICS, False),
+            ATTR_SNAPSHOTS: preferences.get(ATTR_SNAPSHOTS, False),
         }
-        if not self._disable_snapshots:
-            result[ATTR_SNAPSHOTS] = preferences.get(ATTR_SNAPSHOTS, False)
-        return result
 
     @property
     def onboarded(self) -> bool:
@@ -291,6 +288,11 @@ class Analytics:
         """Return bool if a supervisor is present."""
         return is_hassio(self._hass)
 
+    @property
+    def _snapshots_enabled(self) -> bool:
+        """Check if snapshots feature is enabled via labs."""
+        return async_is_preview_feature_enabled(self._hass, DOMAIN, "snapshots")
+
     async def load(self) -> None:
         """Load preferences."""
         stored = await self._store.async_load()
@@ -645,7 +647,10 @@ class Analytics:
                 ),
             )
 
-        if not self.preferences.get(ATTR_SNAPSHOTS, False) or self._disable_snapshots:
+        if (
+            not self.preferences.get(ATTR_SNAPSHOTS, False)
+            or not self._snapshots_enabled
+        ):
             LOGGER.debug("Snapshot analytics not scheduled")
             if self._snapshot_scheduled:
                 self._snapshot_scheduled()

homeassistant/components/analytics/manifest.json

@@ -7,5 +7,11 @@
   "documentation": "https://www.home-assistant.io/integrations/analytics",
   "integration_type": "system",
   "iot_class": "cloud_push",
+  "preview_features": {
+    "snapshots": {
+      "feedback_url": "https://forms.gle/GqvRmgmghSDco8M46",
+      "report_issue_url": "https://github.com/OHF-Device-Database/device-database/issues/new"
+    }
+  },
   "quality_scale": "internal"
 }

homeassistant/components/analytics/strings.json

@@ -0,0 +1,10 @@
+{
+  "preview_features": {
+    "snapshots": {
+      "description": "This free, open source device database of the Open Home Foundation helps users find useful information about smart home devices used in real installations.\n\nYou can help build it by anonymously sharing data about your devices. Only device-specific details (like model or manufacturer) are shared — never personally identifying information (like the names you assign).\n\nLearn more about the device database and how we process your data in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement), which you accept by opting in.",
+      "disable_confirmation": "Your data will no longer be shared with the Open Home Foundation's device database.",
+      "enable_confirmation": "This feature is still in development and may change. The device database is being refined based on user feedback and is not yet complete.",
+      "name": "Device database"
+    }
+  }
+}

homeassistant/components/analytics_insights/__init__.py

@@ -13,9 +13,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import CONF_TRACKED_INTEGRATIONS
+from .const import CONF_TRACKED_APPS, CONF_TRACKED_INTEGRATIONS
 from .coordinator import HomeassistantAnalyticsDataUpdateCoordinator
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
@@ -59,6 +60,30 @@ async def async_setup_entry(
     return True
 
 
+async def async_migrate_entry(
+    hass: HomeAssistant, entry: AnalyticsInsightsConfigEntry
+) -> bool:
+    """Migrate to a new version."""
+    # Migration for switching add-ons to apps
+    if entry.version < 2:
+        ent_reg = er.async_get(hass)
+        for entity_entry in er.async_entries_for_config_entry(ent_reg, entry.entry_id):
+            if not entity_entry.unique_id.startswith("addon_"):
+                continue
+
+            ent_reg.async_update_entity(
+                entity_entry.entity_id,
+                new_unique_id=entity_entry.unique_id.replace("addon_", "app_"),
+            )
+
+        options = dict(entry.options)
+        options[CONF_TRACKED_APPS] = options.pop("tracked_addons", [])
+
+        hass.config_entries.async_update_entry(entry, version=2, options=options)
+
+    return True
+
+
 async def async_unload_entry(
     hass: HomeAssistant, entry: AnalyticsInsightsConfigEntry
 ) -> bool:

homeassistant/components/analytics_insights/config_flow.py

@@ -26,7 +26,7 @@ from homeassistant.helpers.selector import (
 
 from . import AnalyticsInsightsConfigEntry
 from .const import (
-    CONF_TRACKED_ADDONS,
+    CONF_TRACKED_APPS,
     CONF_TRACKED_CUSTOM_INTEGRATIONS,
     CONF_TRACKED_INTEGRATIONS,
     DOMAIN,
@@ -43,6 +43,8 @@ INTEGRATION_TYPES_WITHOUT_ANALYTICS = (
 class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Homeassistant Analytics."""
 
+    VERSION = 2
+
     @staticmethod
     @callback
     def async_get_options_flow(
@@ -59,7 +61,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             if all(
                 [
-                    not user_input.get(CONF_TRACKED_ADDONS),
+                    not user_input.get(CONF_TRACKED_APPS),
                     not user_input.get(CONF_TRACKED_INTEGRATIONS),
                     not user_input.get(CONF_TRACKED_CUSTOM_INTEGRATIONS),
                 ]
@@ -70,7 +72,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
                     title="Home Assistant Analytics Insights",
                     data={},
                     options={
-                        CONF_TRACKED_ADDONS: user_input.get(CONF_TRACKED_ADDONS, []),
+                        CONF_TRACKED_APPS: user_input.get(CONF_TRACKED_APPS, []),
                         CONF_TRACKED_INTEGRATIONS: user_input.get(
                             CONF_TRACKED_INTEGRATIONS, []
                         ),
@@ -84,7 +86,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
             session=async_get_clientsession(self.hass)
         )
         try:
-            addons = await client.get_addons()
+            apps = await client.get_addons()
             integrations = await client.get_integrations(Environment.NEXT)
             custom_integrations = await client.get_custom_integrations()
         except HomeassistantAnalyticsConnectionError:
@@ -107,9 +109,9 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
             data_schema=vol.Schema(
                 {
-                    vol.Optional(CONF_TRACKED_ADDONS): SelectSelector(
+                    vol.Optional(CONF_TRACKED_APPS): SelectSelector(
                         SelectSelectorConfig(
-                            options=list(addons),
+                            options=list(apps),
                             multiple=True,
                             sort=True,
                         )
@@ -144,7 +146,7 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithReload):
         if user_input is not None:
             if all(
                 [
-                    not user_input.get(CONF_TRACKED_ADDONS),
+                    not user_input.get(CONF_TRACKED_APPS),
                     not user_input.get(CONF_TRACKED_INTEGRATIONS),
                     not user_input.get(CONF_TRACKED_CUSTOM_INTEGRATIONS),
                 ]
@@ -154,7 +156,7 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithReload):
                 return self.async_create_entry(
                     title="",
                     data={
-                        CONF_TRACKED_ADDONS: user_input.get(CONF_TRACKED_ADDONS, []),
+                        CONF_TRACKED_APPS: user_input.get(CONF_TRACKED_APPS, []),
                         CONF_TRACKED_INTEGRATIONS: user_input.get(
                             CONF_TRACKED_INTEGRATIONS, []
                         ),
@@ -168,7 +170,7 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithReload):
             session=async_get_clientsession(self.hass)
         )
         try:
-            addons = await client.get_addons()
+            apps = await client.get_addons()
             integrations = await client.get_integrations(Environment.NEXT)
             custom_integrations = await client.get_custom_integrations()
         except HomeassistantAnalyticsConnectionError:
@@ -189,9 +191,9 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithReload):
             data_schema=self.add_suggested_values_to_schema(
                 vol.Schema(
                     {
-                        vol.Optional(CONF_TRACKED_ADDONS): SelectSelector(
+                        vol.Optional(CONF_TRACKED_APPS): SelectSelector(
                             SelectSelectorConfig(
-                                options=list(addons),
+                                options=list(apps),
                                 multiple=True,
                                 sort=True,
                             )

homeassistant/components/analytics_insights/const.py

@@ -4,7 +4,7 @@ import logging
 
 DOMAIN = "analytics_insights"
 
-CONF_TRACKED_ADDONS = "tracked_addons"
+CONF_TRACKED_APPS = "tracked_apps"
 CONF_TRACKED_INTEGRATIONS = "tracked_integrations"
 CONF_TRACKED_CUSTOM_INTEGRATIONS = "tracked_custom_integrations"
 

homeassistant/components/analytics_insights/coordinator.py

@@ -18,7 +18,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import (
-    CONF_TRACKED_ADDONS,
+    CONF_TRACKED_APPS,
     CONF_TRACKED_CUSTOM_INTEGRATIONS,
     CONF_TRACKED_INTEGRATIONS,
     DOMAIN,
@@ -35,7 +35,7 @@ class AnalyticsData:
 
     active_installations: int
     reports_integrations: int
-    addons: dict[str, int]
+    apps: dict[str, int]
     core_integrations: dict[str, int]
     custom_integrations: dict[str, int]
 
@@ -60,7 +60,7 @@ class HomeassistantAnalyticsDataUpdateCoordinator(DataUpdateCoordinator[Analytic
             update_interval=timedelta(hours=12),
         )
         self._client = client
-        self._tracked_addons = self.config_entry.options.get(CONF_TRACKED_ADDONS, [])
+        self._tracked_apps = self.config_entry.options.get(CONF_TRACKED_APPS, [])
         self._tracked_integrations = self.config_entry.options[
             CONF_TRACKED_INTEGRATIONS
         ]
@@ -70,7 +70,9 @@ class HomeassistantAnalyticsDataUpdateCoordinator(DataUpdateCoordinator[Analytic
 
     async def _async_update_data(self) -> AnalyticsData:
         try:
-            addons_data = await self._client.get_addons()
+            apps_data = (
+                await self._client.get_addons()
+            )  # Still add method name. Needs library update
             data = await self._client.get_current_analytics()
             custom_data = await self._client.get_custom_integrations()
         except HomeassistantAnalyticsConnectionError as err:
@@ -79,9 +81,7 @@ class HomeassistantAnalyticsDataUpdateCoordinator(DataUpdateCoordinator[Analytic
             ) from err
         except HomeassistantAnalyticsNotModifiedError:
             return self.data
-        addons = {
-            addon: get_addon_value(addons_data, addon) for addon in self._tracked_addons
-        }
+        apps = {app: get_app_value(apps_data, app) for app in self._tracked_apps}
         core_integrations = {
             integration: data.integrations.get(integration, 0)
             for integration in self._tracked_integrations
@@ -93,14 +93,14 @@ class HomeassistantAnalyticsDataUpdateCoordinator(DataUpdateCoordinator[Analytic
         return AnalyticsData(
             data.active_installations,
             data.reports_integrations,
-            addons,
+            apps,
             core_integrations,
             custom_integrations,
         )
 
 
-def get_addon_value(data: dict[str, Addon], name_slug: str) -> int:
-    """Get addon value."""
+def get_app_value(data: dict[str, Addon], name_slug: str) -> int:
+    """Get app value."""
     if name_slug in data:
         return data[name_slug].total
     return 0

homeassistant/components/analytics_insights/sensor.py

@@ -29,17 +29,17 @@ class AnalyticsSensorEntityDescription(SensorEntityDescription):
     value_fn: Callable[[AnalyticsData], StateType]
 
 
-def get_addon_entity_description(
+def get_app_entity_description(
     name_slug: str,
 ) -> AnalyticsSensorEntityDescription:
-    """Get addon entity description."""
+    """Get app entity description."""
     return AnalyticsSensorEntityDescription(
-        key=f"addon_{name_slug}_active_installations",
-        translation_key="addons",
+        key=f"app_{name_slug}_active_installations",
+        translation_key="apps",
         name=name_slug,
         state_class=SensorStateClass.TOTAL,
         native_unit_of_measurement="active installations",
-        value_fn=lambda data: data.addons.get(name_slug),
+        value_fn=lambda data: data.apps.get(name_slug),
     )
 
 
@@ -106,9 +106,9 @@ async def async_setup_entry(
     entities.extend(
         HomeassistantAnalyticsSensor(
             coordinator,
-            get_addon_entity_description(addon_name_slug),
+            get_app_entity_description(app_name_slug),
         )
-        for addon_name_slug in coordinator.data.addons
+        for app_name_slug in coordinator.data.apps
     )
     entities.extend(
         HomeassistantAnalyticsSensor(

homeassistant/components/analytics_insights/strings.json

@@ -10,12 +10,12 @@
     "step": {
       "user": {
         "data": {
-          "tracked_addons": "Add-ons",
+          "tracked_apps": "Apps",
           "tracked_custom_integrations": "Custom integrations",
           "tracked_integrations": "Integrations"
         },
         "data_description": {
-          "tracked_addons": "Select the add-ons you want to track",
+          "tracked_apps": "Select the apps you want to track",
           "tracked_custom_integrations": "Select the custom integrations you want to track",
           "tracked_integrations": "Select the integrations you want to track"
         }
@@ -45,12 +45,12 @@
     "step": {
       "init": {
         "data": {
-          "tracked_addons": "[%key:component::analytics_insights::config::step::user::data::tracked_addons%]",
+          "tracked_apps": "[%key:component::analytics_insights::config::step::user::data::tracked_apps%]",
           "tracked_custom_integrations": "[%key:component::analytics_insights::config::step::user::data::tracked_custom_integrations%]",
           "tracked_integrations": "[%key:component::analytics_insights::config::step::user::data::tracked_integrations%]"
         },
         "data_description": {
-          "tracked_addons": "[%key:component::analytics_insights::config::step::user::data_description::tracked_addons%]",
+          "tracked_apps": "[%key:component::analytics_insights::config::step::user::data_description::tracked_apps%]",
           "tracked_custom_integrations": "[%key:component::analytics_insights::config::step::user::data_description::tracked_custom_integrations%]",
           "tracked_integrations": "[%key:component::analytics_insights::config::step::user::data_description::tracked_integrations%]"
         }

homeassistant/components/anthropic/config_flow.py

@@ -201,10 +201,13 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             )
             for api in llm.async_get_apis(self.hass)
         ]
-        if (suggested_llm_apis := self.options.get(CONF_LLM_HASS_API)) and isinstance(
-            suggested_llm_apis, str
-        ):
-            self.options[CONF_LLM_HASS_API] = [suggested_llm_apis]
+        if suggested_llm_apis := self.options.get(CONF_LLM_HASS_API):
+            if isinstance(suggested_llm_apis, str):
+                suggested_llm_apis = [suggested_llm_apis]
+            known_apis = {api.id for api in llm.async_get_apis(self.hass)}
+            self.options[CONF_LLM_HASS_API] = [
+                api for api in suggested_llm_apis if api in known_apis
+            ]
 
         step_schema: VolDictType = {}
         errors: dict[str, str] = {}

homeassistant/components/anthropic/entity.py

@@ -69,6 +69,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.json import json_dumps
 from homeassistant.util import slugify
 
 from . import AnthropicConfigEntry
@@ -193,7 +194,7 @@ def _convert_content(
                 tool_result_block = ToolResultBlockParam(
                     type="tool_result",
                     tool_use_id=content.tool_call_id,
-                    content=json.dumps(content.tool_result),
+                    content=json_dumps(content.tool_result),
                 )
                 external_tool = False
             if not messages or messages[-1]["role"] != (
@@ -599,6 +600,16 @@ class AnthropicBaseLLMEntity(Entity):
         system = chat_log.content[0]
         if not isinstance(system, conversation.SystemContent):
             raise TypeError("First message must be a system message")
+
+        # System prompt with caching enabled
+        system_prompt: list[TextBlockParam] = [
+            TextBlockParam(
+                type="text",
+                text=system.content,
+                cache_control={"type": "ephemeral"},
+            )
+        ]
+
         messages = _convert_content(chat_log.content[1:])
 
         model = options.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
@@ -607,7 +618,7 @@ class AnthropicBaseLLMEntity(Entity):
             model=model,
             messages=messages,
             max_tokens=options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
-            system=system.content,
+            system=system_prompt,
             stream=True,
         )
 
@@ -694,10 +705,6 @@ class AnthropicBaseLLMEntity(Entity):
                     type="auto",
                 )
 
-                if isinstance(model_args["system"], str):
-                    model_args["system"] = [
-                        TextBlockParam(type="text", text=model_args["system"])
-                    ]
                 model_args["system"].append(  # type: ignore[union-attr]
                     TextBlockParam(
                         type="text",

homeassistant/components/apcupsd/sensor.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import logging
 
+import dateutil
+
 from homeassistant.components.automation import automations_with_entity
 from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
@@ -179,6 +181,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     LAST_S_TEST: SensorEntityDescription(
         key=LAST_S_TEST,
         translation_key="last_self_test",
+        device_class=SensorDeviceClass.TIMESTAMP,
     ),
     "lastxfer": SensorEntityDescription(
         key="lastxfer",
@@ -232,6 +235,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "masterupd": SensorEntityDescription(
         key="masterupd",
         translation_key="master_update",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "maxlinev": SensorEntityDescription(
@@ -365,6 +369,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "statflag": SensorEntityDescription(
@@ -416,16 +421,19 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbatt": SensorEntityDescription(
         key="xoffbatt",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xonbatt": SensorEntityDescription(
         key="xonbatt",
         translation_key="transfer_to_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
 }
@@ -529,7 +537,23 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
             self._attr_native_value = None
             return
 
-        self._attr_native_value, inferred_unit = infer_unit(self.coordinator.data[key])
+        data = self.coordinator.data[key]
+
+        if self.entity_description.device_class == SensorDeviceClass.TIMESTAMP:
+            # The date could be "N/A" for certain fields (e.g., XOFFBATT), indicating there is no value yet.
+            if data == "N/A":
+                self._attr_native_value = None
+                return
+
+            try:
+                self._attr_native_value = dateutil.parser.parse(data)
+            except (dateutil.parser.ParserError, OverflowError):
+                # If parsing fails we should mark it as unknown, with a log for further debugging.
+                _LOGGER.warning('Failed to parse date for %s: "%s"', key, data)
+                self._attr_native_value = None
+            return
+
+        self._attr_native_value, inferred_unit = infer_unit(data)
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
 

homeassistant/components/apple_tv/__init__.py

@@ -5,9 +5,14 @@ from __future__ import annotations
 import asyncio
 import logging
 from random import randrange
-import sys
 from typing import Any, cast
 
+from pyatv import connect, exceptions, scan
+from pyatv.conf import AppleTV
+from pyatv.const import DeviceModel, Protocol
+from pyatv.convert import model_str
+from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
+
 from homeassistant.components import zeroconf
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -24,11 +29,7 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    HomeAssistantError,
-)
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -42,18 +43,6 @@ from .const import (
     SIGNAL_DISCONNECTED,
 )
 
-if sys.version_info < (3, 14):
-    from pyatv import connect, exceptions, scan
-    from pyatv.conf import AppleTV
-    from pyatv.const import DeviceModel, Protocol
-    from pyatv.convert import model_str
-    from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
-else:
-
-    class DeviceListener:
-        """Dummy class."""
-
-
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME_TV = "Apple TV"
@@ -62,32 +51,27 @@ DEFAULT_NAME_HP = "HomePod"
 BACKOFF_TIME_LOWER_LIMIT = 15  # seconds
 BACKOFF_TIME_UPPER_LIMIT = 300  # Five minutes
 
-PLATFORMS = [Platform.MEDIA_PLAYER, Platform.REMOTE]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.MEDIA_PLAYER, Platform.REMOTE]
 
-if sys.version_info < (3, 14):
-    AUTH_EXCEPTIONS = (
-        exceptions.AuthenticationError,
-        exceptions.InvalidCredentialsError,
-        exceptions.NoCredentialsError,
-    )
-    CONNECTION_TIMEOUT_EXCEPTIONS = (
-        OSError,
-        asyncio.CancelledError,
-        TimeoutError,
-        exceptions.ConnectionLostError,
-        exceptions.ConnectionFailedError,
-    )
-    DEVICE_EXCEPTIONS = (
-        exceptions.ProtocolError,
-        exceptions.NoServiceError,
-        exceptions.PairingError,
-        exceptions.BackOffError,
-        exceptions.DeviceIdMissingError,
-    )
-else:
-    AUTH_EXCEPTIONS = ()
-    CONNECTION_TIMEOUT_EXCEPTIONS = ()
-    DEVICE_EXCEPTIONS = ()
+AUTH_EXCEPTIONS = (
+    exceptions.AuthenticationError,
+    exceptions.InvalidCredentialsError,
+    exceptions.NoCredentialsError,
+)
+CONNECTION_TIMEOUT_EXCEPTIONS = (
+    OSError,
+    asyncio.CancelledError,
+    TimeoutError,
+    exceptions.ConnectionLostError,
+    exceptions.ConnectionFailedError,
+)
+DEVICE_EXCEPTIONS = (
+    exceptions.ProtocolError,
+    exceptions.NoServiceError,
+    exceptions.PairingError,
+    exceptions.BackOffError,
+    exceptions.DeviceIdMissingError,
+)
 
 
 type AppleTvConfigEntry = ConfigEntry[AppleTVManager]
@@ -95,10 +79,6 @@ type AppleTvConfigEntry = ConfigEntry[AppleTVManager]
 
 async def async_setup_entry(hass: HomeAssistant, entry: AppleTvConfigEntry) -> bool:
     """Set up a config entry for Apple TV."""
-    if sys.version_info >= (3, 14):
-        raise HomeAssistantError(
-            "Apple TV is not supported on Python 3.14. Please use Python 3.13."
-        )
     manager = AppleTVManager(hass, entry)
 
     if manager.is_on:

homeassistant/components/apple_tv/binary_sensor.py

@@ -0,0 +1,63 @@
+"""Binary sensor support for Apple TV."""
+
+from __future__ import annotations
+
+from pyatv.const import KeyboardFocusState
+from pyatv.interface import AppleTV, KeyboardListener
+
+from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.const import CONF_NAME
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AppleTvConfigEntry
+from .entity import AppleTVEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AppleTvConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Load Apple TV binary sensor based on a config entry."""
+    # apple_tv config entries always have a unique id
+    assert config_entry.unique_id is not None
+    name: str = config_entry.data[CONF_NAME]
+    manager = config_entry.runtime_data
+    async_add_entities([AppleTVKeyboardFocused(name, config_entry.unique_id, manager)])
+
+
+class AppleTVKeyboardFocused(AppleTVEntity, BinarySensorEntity, KeyboardListener):
+    """Binary sensor for Text input focused."""
+
+    _attr_translation_key = "keyboard_focused"
+    _attr_available = True
+
+    @callback
+    def async_device_connected(self, atv: AppleTV) -> None:
+        """Handle when connection is made to device."""
+        self._attr_available = True
+        # Listen to keyboard updates
+        atv.keyboard.listener = self
+        # Set initial state based on current focus state
+        self._update_state(atv.keyboard.text_focus_state == KeyboardFocusState.Focused)
+
+    @callback
+    def async_device_disconnected(self) -> None:
+        """Handle when connection was lost to device."""
+        self._attr_available = False
+        self._update_state(False)
+
+    def focusstate_update(
+        self, old_state: KeyboardFocusState, new_state: KeyboardFocusState
+    ) -> None:
+        """Update keyboard state when it changes.
+
+        This is a callback function from pyatv.interface.KeyboardListener.
+        """
+        self._update_state(new_state == KeyboardFocusState.Focused)
+
+    def _update_state(self, new_state: bool) -> None:
+        """Update and report."""
+        self._attr_is_on = new_state
+        self.async_write_ha_state()

homeassistant/components/apple_tv/entity.py

@@ -18,7 +18,6 @@ class AppleTVEntity(Entity):
 
     _attr_should_poll = False
     _attr_has_entity_name = True
-    _attr_name = None
     atv: AppleTVInterface | None = None
 
     def __init__(self, name: str, identifier: str, manager: AppleTVManager) -> None:

homeassistant/components/apple_tv/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "binary_sensor": {
+      "keyboard_focused": {
+        "default": "mdi:keyboard",
+        "state": {
+          "off": "mdi:keyboard-off"
+        }
+      }
+    }
+  }
+}

homeassistant/components/apple_tv/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyatv", "srptools"],
-  "requirements": ["pyatv==0.16.1;python_version<'3.14'"],
+  "requirements": ["pyatv==0.17.0"],
   "zeroconf": [
     "_mediaremotetv._tcp.local.",
     "_companion-link._tcp.local.",