Add to CI

Co-authored-by: Copilot <175728472+Copilot@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

.github/workflows/ci.yaml

@@ -479,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
@@ -1187,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: |
@@ -1198,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

.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:

AGENTS.md

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

AGENTS.md

@@ -0,0 +1,324 @@
+# 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
+
+### 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

homeassistant/components/alarm_control_panel/strings.json

@@ -14,7 +14,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is armed"
+      "name": "Alarm is armed"
     },
     "is_armed_away": {
       "description": "Tests if one or more alarms are armed in away mode.",
@@ -24,7 +24,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is armed away"
+      "name": "Alarm is armed away"
     },
     "is_armed_home": {
       "description": "Tests if one or more alarms are armed in home mode.",
@@ -34,7 +34,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is armed home"
+      "name": "Alarm is armed home"
     },
     "is_armed_night": {
       "description": "Tests if one or more alarms are armed in night mode.",
@@ -44,7 +44,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is armed night"
+      "name": "Alarm is armed night"
     },
     "is_armed_vacation": {
       "description": "Tests if one or more alarms are armed in vacation mode.",
@@ -54,7 +54,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is armed vacation"
+      "name": "Alarm is armed vacation"
     },
     "is_disarmed": {
       "description": "Tests if one or more alarms are disarmed.",
@@ -64,7 +64,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is disarmed"
+      "name": "Alarm is disarmed"
     },
     "is_triggered": {
       "description": "Tests if one or more alarms are triggered.",
@@ -74,7 +74,7 @@
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
-      "name": "If an alarm is triggered"
+      "name": "Alarm is triggered"
     }
   },
   "device_automation": {

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"
@@ -64,30 +53,25 @@ BACKOFF_TIME_UPPER_LIMIT = 300  # Five minutes
 
 PLATFORMS = [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/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.",

homeassistant/components/apple_tv/media_player.py

@@ -239,6 +239,15 @@ class AppleTvMediaPlayer(
         """
         self.async_write_ha_state()
 
+    @callback
+    def volume_device_update(
+        self, output_device: OutputDevice, old_level: float, new_level: float
+    ) -> None:
+        """Output device volume was updated.
+
+        This is a callback function from pyatv.interface.AudioListener.
+        """
+
     @callback
     def outputdevices_update(
         self, old_devices: list[OutputDevice], new_devices: list[OutputDevice]

homeassistant/components/assist_satellite/strings.json

@@ -14,7 +14,7 @@
           "name": "[%key:component::assist_satellite::common::condition_behavior_name%]"
         }
       },
-      "name": "If a satellite is idle"
+      "name": "Satellite is idle"
     },
     "is_listening": {
       "description": "Tests if one or more Assist satellites are listening.",
@@ -24,7 +24,7 @@
           "name": "[%key:component::assist_satellite::common::condition_behavior_name%]"
         }
       },
-      "name": "If a satellite is listening"
+      "name": "Satellite is listening"
     },
     "is_processing": {
       "description": "Tests if one or more Assist satellites are processing.",
@@ -34,7 +34,7 @@
           "name": "[%key:component::assist_satellite::common::condition_behavior_name%]"
         }
       },
-      "name": "If a satellite is processing"
+      "name": "Satellite is processing"
     },
     "is_responding": {
       "description": "Tests if one or more Assist satellites are responding.",
@@ -44,7 +44,7 @@
           "name": "[%key:component::assist_satellite::common::condition_behavior_name%]"
         }
       },
-      "name": "If a satellite is responding"
+      "name": "Satellite is responding"
     }
   },
   "entity_component": {

homeassistant/components/automation/__init__.py

@@ -56,7 +56,7 @@ from homeassistant.core import (
     valid_entity_id,
 )
 from homeassistant.exceptions import HomeAssistantError, ServiceNotFound, TemplateError
-from homeassistant.helpers import condition, config_validation as cv
+from homeassistant.helpers import condition as condition_helper, config_validation as cv
 from homeassistant.helpers.entity import ToggleEntity
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.issue_registry import (
@@ -554,7 +554,7 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         automation_id: str | None,
         name: str,
         trigger_config: list[ConfigType],
-        cond_func: IfAction | None,
+        condition: IfAction | None,
         action_script: Script,
         initial_state: bool | None,
         variables: ScriptVariables | None,
@@ -567,7 +567,7 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         self._attr_name = name
         self._trigger_config = trigger_config
         self._async_detach_triggers: CALLBACK_TYPE | None = None
-        self._cond_func = cond_func
+        self._condition = condition
         self.action_script = action_script
         self.action_script.change_listener = self.async_write_ha_state
         self._initial_state = initial_state
@@ -602,6 +602,12 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return a set of referenced labels."""
         referenced = self.action_script.referenced_labels
 
+        if self._condition is not None:
+            for conf in self._condition.config:
+                referenced |= condition_helper.async_extract_targets(
+                    conf, ATTR_LABEL_ID
+                )
+
         for conf in self._trigger_config:
             referenced |= set(_get_targets_from_trigger_config(conf, ATTR_LABEL_ID))
         return referenced
@@ -611,6 +617,12 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return a set of referenced floors."""
         referenced = self.action_script.referenced_floors
 
+        if self._condition is not None:
+            for conf in self._condition.config:
+                referenced |= condition_helper.async_extract_targets(
+                    conf, ATTR_FLOOR_ID
+                )
+
         for conf in self._trigger_config:
             referenced |= set(_get_targets_from_trigger_config(conf, ATTR_FLOOR_ID))
         return referenced
@@ -620,6 +632,10 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return a set of referenced areas."""
         referenced = self.action_script.referenced_areas
 
+        if self._condition is not None:
+            for conf in self._condition.config:
+                referenced |= condition_helper.async_extract_targets(conf, ATTR_AREA_ID)
+
         for conf in self._trigger_config:
             referenced |= set(_get_targets_from_trigger_config(conf, ATTR_AREA_ID))
         return referenced
@@ -636,9 +652,9 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return a set of referenced devices."""
         referenced = self.action_script.referenced_devices
 
-        if self._cond_func is not None:
-            for conf in self._cond_func.config:
-                referenced |= condition.async_extract_devices(conf)
+        if self._condition is not None:
+            for conf in self._condition.config:
+                referenced |= condition_helper.async_extract_devices(conf)
 
         for conf in self._trigger_config:
             referenced |= set(_trigger_extract_devices(conf))
@@ -650,9 +666,9 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return a set of referenced entities."""
         referenced = self.action_script.referenced_entities
 
-        if self._cond_func is not None:
-            for conf in self._cond_func.config:
-                referenced |= condition.async_extract_entities(conf)
+        if self._condition is not None:
+            for conf in self._condition.config:
+                referenced |= condition_helper.async_extract_entities(conf)
 
         for conf in self._trigger_config:
             for entity_id in _trigger_extract_entities(conf):
@@ -772,8 +788,8 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
 
             if (
                 not skip_condition
-                and self._cond_func is not None
-                and not self._cond_func(variables)
+                and self._condition is not None
+                and not self._condition(variables)
             ):
                 self._logger.debug(
                     "Conditions not met, aborting automation. Condition summary: %s",
@@ -1035,12 +1051,12 @@ async def _create_automation_entities(
         )
 
         if CONF_CONDITIONS in config_block:
-            cond_func = await _async_process_if(hass, name, config_block)
+            condition = await _async_process_if(hass, name, config_block)
 
-            if cond_func is None:
+            if condition is None:
                 continue
         else:
-            cond_func = None
+            condition = None
 
         # Add trigger variables to variables
         variables = None
@@ -1058,7 +1074,7 @@ async def _create_automation_entities(
             automation_id,
             name,
             config_block[CONF_TRIGGERS],
-            cond_func,
+            condition,
             action_script,
             initial_state,
             variables,
@@ -1200,7 +1216,7 @@ async def _async_process_if(
     if_configs = config[CONF_CONDITIONS]
 
     try:
-        if_action = await condition.async_conditions_from_config(
+        if_action = await condition_helper.async_conditions_from_config(
             hass, if_configs, LOGGER, name
         )
     except HomeAssistantError as ex:

homeassistant/components/fan/strings.json

@@ -14,7 +14,7 @@
           "name": "[%key:component::fan::common::condition_behavior_name%]"
         }
       },
-      "name": "If a fan is off"
+      "name": "Fan is off"
     },
     "is_on": {
       "description": "Tests if one or more fans are on.",
@@ -24,7 +24,7 @@
           "name": "[%key:component::fan::common::condition_behavior_name%]"
         }
       },
-      "name": "If a fan is on"
+      "name": "Fan is on"
     }
   },
   "device_automation": {

homeassistant/components/google_air_quality/icons.json

@@ -7,20 +7,11 @@
       "benzene": {
         "default": "mdi:molecule"
       },
-      "nitrogen_dioxide": {
-        "default": "mdi:molecule"
-      },
       "nitrogen_monoxide": {
         "default": "mdi:molecule"
       },
       "non_methane_hydrocarbons": {
         "default": "mdi:molecule"
-      },
-      "ozone": {
-        "default": "mdi:molecule"
-      },
-      "sulphur_dioxide": {
-        "default": "mdi:molecule"
       }
     }
   }

homeassistant/components/google_air_quality/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["google_air_quality_api"],
   "quality_scale": "bronze",
-  "requirements": ["google_air_quality_api==2.1.2"]
+  "requirements": ["google_air_quality_api==3.0.0"]
 }

homeassistant/components/google_air_quality/sensor.py

@@ -13,7 +13,11 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.const import (
+    CONCENTRATION_PARTS_PER_MILLION,
+    CONF_LATITUDE,
+    CONF_LONGITUDE,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -114,6 +118,7 @@ AIR_QUALITY_SENSOR_TYPES: tuple[AirQualitySensorEntityDescription, ...] = (
         native_unit_of_measurement_fn=lambda x: x.pollutants.co.concentration.units,
         exists_fn=lambda x: "co" in {p.code for p in x.pollutants},
         value_fn=lambda x: x.pollutants.co.concentration.value,
+        suggested_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
     ),
     AirQualitySensorEntityDescription(
         key="nh3",
@@ -141,16 +146,16 @@ AIR_QUALITY_SENSOR_TYPES: tuple[AirQualitySensorEntityDescription, ...] = (
     ),
     AirQualitySensorEntityDescription(
         key="no2",
-        translation_key="nitrogen_dioxide",
         state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.NITROGEN_DIOXIDE,
         native_unit_of_measurement_fn=lambda x: x.pollutants.no2.concentration.units,
         exists_fn=lambda x: "no2" in {p.code for p in x.pollutants},
         value_fn=lambda x: x.pollutants.no2.concentration.value,
     ),
     AirQualitySensorEntityDescription(
         key="o3",
-        translation_key="ozone",
         state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.OZONE,
         native_unit_of_measurement_fn=lambda x: x.pollutants.o3.concentration.units,
         exists_fn=lambda x: "o3" in {p.code for p in x.pollutants},
         value_fn=lambda x: x.pollutants.o3.concentration.value,
@@ -173,8 +178,8 @@ AIR_QUALITY_SENSOR_TYPES: tuple[AirQualitySensorEntityDescription, ...] = (
     ),
     AirQualitySensorEntityDescription(
         key="so2",
-        translation_key="sulphur_dioxide",
         state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.SULPHUR_DIOXIDE,
         native_unit_of_measurement_fn=lambda x: x.pollutants.so2.concentration.units,
         exists_fn=lambda x: "so2" in {p.code for p in x.pollutants},
         value_fn=lambda x: x.pollutants.so2.concentration.value,

homeassistant/components/google_air_quality/strings.json

@@ -205,21 +205,12 @@
           "so2": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]"
         }
       },
-      "nitrogen_dioxide": {
-        "name": "[%key:component::sensor::entity_component::nitrogen_dioxide::name%]"
-      },
       "nitrogen_monoxide": {
         "name": "[%key:component::sensor::entity_component::nitrogen_monoxide::name%]"
       },
       "non_methane_hydrocarbons": {
         "name": "Non-methane hydrocarbons"
       },
-      "ozone": {
-        "name": "[%key:component::sensor::entity_component::ozone::name%]"
-      },
-      "sulphur_dioxide": {
-        "name": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]"
-      },
       "uaqi": {
         "name": "Universal Air Quality Index"
       },

homeassistant/components/habitica/strings.json

@@ -83,6 +83,9 @@
       "invalid_credentials": "Input is incomplete. You must provide either your login details or an API token",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "advanced": {
         "data": {

homeassistant/components/hassio/addon_panel.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from aiohttp import web
 
-from homeassistant.components import frontend, panel_custom
+from homeassistant.components import frontend
 from homeassistant.components.http import HomeAssistantView
 from homeassistant.const import ATTR_ICON
 from homeassistant.core import HomeAssistant
@@ -33,7 +33,7 @@ async def async_setup_addon_panel(hass: HomeAssistant, hassio: HassIO) -> None:
         # _register_panel never suspends and is only
         # a coroutine because it would be a breaking change
         # to make it a normal function
-        await _register_panel(hass, addon, data)
+        _register_panel(hass, addon, data)
 
 
 class HassIOAddonPanel(HomeAssistantView):
@@ -58,7 +58,7 @@ class HassIOAddonPanel(HomeAssistantView):
         data = panels[addon]
 
         # Register panel
-        await _register_panel(self.hass, addon, data)
+        _register_panel(self.hass, addon, data)
         return web.Response()
 
     async def delete(self, request: web.Request, addon: str) -> web.Response:
@@ -76,18 +76,14 @@ class HassIOAddonPanel(HomeAssistantView):
         return {}
 
 
-async def _register_panel(
-    hass: HomeAssistant, addon: str, data: dict[str, Any]
-) -> None:
+def _register_panel(hass: HomeAssistant, addon: str, data: dict[str, Any]):
     """Init coroutine to register the panel."""
-    await panel_custom.async_register_panel(
+    frontend.async_register_built_in_panel(
         hass,
+        "app",
         frontend_url_path=addon,
-        webcomponent_name="hassio-main",
         sidebar_title=data[ATTR_TITLE],
         sidebar_icon=data[ATTR_ICON],
-        js_url="/api/hassio/app/entrypoint.js",
-        embed_iframe=True,
         require_admin=data[ATTR_ADMIN],
-        config={"ingress": addon},
+        config={"addon": addon},
     )

homeassistant/components/hdfury/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["hdfury==1.3.1"]
+  "requirements": ["hdfury==1.4.2"]
 }

homeassistant/components/iaqualink/__init__.py

@@ -28,6 +28,7 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.util.ssl import SSL_ALPN_HTTP11_HTTP2
 
 from .const import DOMAIN, UPDATE_INTERVAL
 from .entity import AqualinkEntity
@@ -66,7 +67,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: AqualinkConfigEntry) ->
     username = entry.data[CONF_USERNAME]
     password = entry.data[CONF_PASSWORD]
 
-    aqualink = AqualinkClient(username, password, httpx_client=get_async_client(hass))
+    aqualink = AqualinkClient(
+        username,
+        password,
+        httpx_client=get_async_client(hass, alpn_protocols=SSL_ALPN_HTTP11_HTTP2),
+    )
     try:
         await aqualink.login()
     except AqualinkServiceException as login_exception:

homeassistant/components/iaqualink/config_flow.py

@@ -15,6 +15,7 @@ import voluptuous as vol
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.util.ssl import SSL_ALPN_HTTP11_HTTP2
 
 from .const import DOMAIN
 
@@ -36,7 +37,11 @@ class AqualinkFlowHandler(ConfigFlow, domain=DOMAIN):
 
             try:
                 async with AqualinkClient(
-                    username, password, httpx_client=get_async_client(self.hass)
+                    username,
+                    password,
+                    httpx_client=get_async_client(
+                        self.hass, alpn_protocols=SSL_ALPN_HTTP11_HTTP2
+                    ),
                 ):
                     pass
             except AqualinkServiceUnauthorizedException:

homeassistant/components/imgw_pib/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["imgw_pib==1.6.0"]
+  "requirements": ["imgw_pib==2.0.1"]
 }

homeassistant/components/kostal_plenticore/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["kostal"],
-  "requirements": ["pykoplenti==1.3.0"]
+  "requirements": ["pykoplenti==1.5.0"]
 }

homeassistant/components/light/strings.json

@@ -49,7 +49,7 @@
           "name": "[%key:component::light::common::condition_behavior_name%]"
         }
       },
-      "name": "If a light is off"
+      "name": "Light is off"
     },
     "is_on": {
       "description": "Tests if one or more lights are on.",
@@ -59,7 +59,7 @@
           "name": "[%key:component::light::common::condition_behavior_name%]"
         }
       },
-      "name": "If a light is on"
+      "name": "Light is on"
     }
   },
   "device_automation": {

homeassistant/components/light/trigger.py

@@ -1,24 +1,47 @@
 """Provides triggers for lights."""
 
+from typing import Any
+
 from homeassistant.const import STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.trigger import (
+    EntityNumericalStateAttributeChangedTriggerBase,
+    EntityNumericalStateAttributeCrossedThresholdTriggerBase,
     Trigger,
-    make_entity_numerical_state_attribute_changed_trigger,
-    make_entity_numerical_state_attribute_crossed_threshold_trigger,
     make_entity_target_state_trigger,
 )
 
 from . import ATTR_BRIGHTNESS
 from .const import DOMAIN
 
+
+def _convert_uint8_to_percentage(value: Any) -> float:
+    """Convert a uint8 value (0-255) to a percentage (0-100)."""
+    return (float(value) / 255.0) * 100.0
+
+
+class BrightnessChangedTrigger(EntityNumericalStateAttributeChangedTriggerBase):
+    """Trigger for brightness changed."""
+
+    _domain = DOMAIN
+    _attribute = ATTR_BRIGHTNESS
+
+    _converter = staticmethod(_convert_uint8_to_percentage)
+
+
+class BrightnessCrossedThresholdTrigger(
+    EntityNumericalStateAttributeCrossedThresholdTriggerBase
+):
+    """Trigger for brightness crossed threshold."""
+
+    _domain = DOMAIN
+    _attribute = ATTR_BRIGHTNESS
+    _converter = staticmethod(_convert_uint8_to_percentage)
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
-    "brightness_changed": make_entity_numerical_state_attribute_changed_trigger(
-        DOMAIN, ATTR_BRIGHTNESS
-    ),
-    "brightness_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
-        DOMAIN, ATTR_BRIGHTNESS
-    ),
+    "brightness_changed": BrightnessChangedTrigger,
+    "brightness_crossed_threshold": BrightnessCrossedThresholdTrigger,
     "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
     "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
 }

homeassistant/components/light/triggers.yaml

@@ -22,7 +22,10 @@
         number:
           selector:
             number:
+              max: 100
+              min: 0
               mode: box
+              unit_of_measurement: "%"
         entity:
           selector:
             entity:

homeassistant/components/ntfy/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aionfty"],
   "quality_scale": "platinum",
-  "requirements": ["aiontfy==0.6.1"]
+  "requirements": ["aiontfy==0.7.0"]
 }

homeassistant/components/ntfy/notify.py

@@ -43,6 +43,7 @@ ATTR_ICON = "icon"
 ATTR_MARKDOWN = "markdown"
 ATTR_PRIORITY = "priority"
 ATTR_TAGS = "tags"
+ATTR_SEQUENCE_ID = "sequence_id"
 
 SERVICE_PUBLISH_SCHEMA = cv.make_entity_service_schema(
     {
@@ -60,6 +61,7 @@ SERVICE_PUBLISH_SCHEMA = cv.make_entity_service_schema(
         vol.Optional(ATTR_EMAIL): vol.Email(),
         vol.Optional(ATTR_CALL): cv.string,
         vol.Optional(ATTR_ICON): vol.All(vol.Url(), vol.Coerce(URL)),
+        vol.Optional(ATTR_SEQUENCE_ID): cv.string,
     }
 )
 

homeassistant/components/ntfy/services.yaml

@@ -88,3 +88,8 @@ publish:
           type: url
           autocomplete: url
       example: https://example.org/logo.png
+    sequence_id:
+      required: false
+      selector:
+        text:
+      example: "Mc3otamDNcpJ"

homeassistant/components/ntfy/strings.json

@@ -1,6 +1,7 @@
 {
   "common": {
     "add_topic_description": "Set up a topic for notifications.",
+    "sequence_id": "Sequence ID",
     "topic": "Topic"
   },
   "config": {
@@ -171,6 +172,9 @@
           "icon": { "name": "Icon" },
           "message": { "name": "Message" },
           "priority": { "name": "Priority" },
+          "sequence_id": {
+            "name": "[%key:component::ntfy::common::sequence_id%]"
+          },
           "tags": { "name": "Tags" },
           "time": { "name": "Time" },
           "title": { "name": "Title" },
@@ -356,6 +360,10 @@
           "description": "All messages have a priority that defines how urgently your phone notifies you, depending on the configured vibration patterns, notification sounds, and visibility in the notification drawer or pop-over.",
           "name": "Message priority"
         },
+        "sequence_id": {
+          "description": "Enter a message or sequence ID to update an existing notification, or specify a sequence ID to reference later when updating, clearing (mark as read and dismiss), or deleting a notification.",
+          "name": "[%key:component::ntfy::common::sequence_id%]"
+        },
         "tags": {
           "description": "Add tags or emojis to the notification. Emojis (using shortcodes like smile) will appear in the notification title or message. Other tags will be displayed below the notification content.",
           "name": "Tags/Emojis"

homeassistant/components/number/const.py

@@ -247,7 +247,7 @@ class NumberDeviceClass(StrEnum):
     NITROGEN_DIOXIDE = "nitrogen_dioxide"
     """Amount of NO2.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion), `μg/m³`
     """
 
     NITROGEN_MONOXIDE = "nitrogen_monoxide"
@@ -265,7 +265,7 @@ class NumberDeviceClass(StrEnum):
     OZONE = "ozone"
     """Amount of O3.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion), `μg/m³`
     """
 
     PH = "ph"
@@ -517,10 +517,16 @@ DEVICE_CLASS_UNITS: dict[NumberDeviceClass, set[type[StrEnum] | str | None]] = {
     NumberDeviceClass.ILLUMINANCE: {LIGHT_LUX},
     NumberDeviceClass.IRRADIANCE: set(UnitOfIrradiance),
     NumberDeviceClass.MOISTURE: {PERCENTAGE},
-    NumberDeviceClass.NITROGEN_DIOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    NumberDeviceClass.NITROGEN_DIOXIDE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     NumberDeviceClass.NITROGEN_MONOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     NumberDeviceClass.NITROUS_OXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
-    NumberDeviceClass.OZONE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    NumberDeviceClass.OZONE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     NumberDeviceClass.PH: {None},
     NumberDeviceClass.PM1: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     NumberDeviceClass.PM10: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},

homeassistant/components/nyt_games/strings.json

@@ -8,6 +8,9 @@
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "user": {
         "data": {

homeassistant/components/onedrive/backup.py

@@ -178,6 +178,7 @@ class OneDriveBackupAgent(BackupAgent):
                 file,
                 upload_chunk_size=upload_chunk_size,
                 session=async_get_clientsession(self._hass),
+                smart_chunk_size=True,
             )
         except HashMismatchError as err:
             raise BackupAgentError(

homeassistant/components/onedrive/manifest.json

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

homeassistant/components/onedrive/strings.json

@@ -25,6 +25,9 @@
       "folder_creation_error": "Failed to create folder",
       "folder_rename_error": "Failed to rename folder"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "folder_name": {
         "data": {

homeassistant/components/playstation_network/strings.json

@@ -13,6 +13,9 @@
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "reauth_confirm": {
         "data": {

homeassistant/components/qnap_qsw/manifest.json

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

homeassistant/components/rabbitair/manifest.json

@@ -5,6 +5,7 @@
   "codeowners": ["@rabbit-air"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/rabbitair",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["python-rabbitair==0.0.8"],
   "zeroconf": ["_rabbitair._udp.local."]

homeassistant/components/radiotherm/manifest.json

@@ -13,6 +13,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/radiotherm",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["radiotherm"],
   "requirements": ["radiotherm==2.1.0"]

homeassistant/components/rainbird/manifest.json

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

homeassistant/components/rainforest_raven/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["usb"],
   "documentation": "https://www.home-assistant.io/integrations/rainforest_raven",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "requirements": ["aioraven==0.7.1"],
   "usb": [

homeassistant/components/rapt_ble/manifest.json

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

homeassistant/components/rdw/strings.json

@@ -7,6 +7,9 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "unknown_license_plate": "Unknown license plate"
     },
+    "initiate_flow": {
+      "user": "Add vehicle"
+    },
     "step": {
       "user": {
         "data": {

homeassistant/components/recorder/statistics.py

@@ -59,6 +59,8 @@ from homeassistant.util.unit_conversion import (
     InformationConverter,
     MassConverter,
     MassVolumeConcentrationConverter,
+    NitrogenDioxideConcentrationConverter,
+    OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
     ReactiveEnergyConverter,
@@ -225,8 +227,10 @@ _PRIMARY_UNIT_CONVERTERS: list[type[BaseUnitConverter]] = [
 
 _SECONDARY_UNIT_CONVERTERS: list[type[BaseUnitConverter]] = [
     CarbonMonoxideConcentrationConverter,
-    TemperatureDeltaConverter,
+    NitrogenDioxideConcentrationConverter,
+    OzoneConcentrationConverter,
     SulphurDioxideConcentrationConverter,
+    TemperatureDeltaConverter,
 ]
 
 STATISTIC_UNIT_TO_UNIT_CONVERTER: dict[str | None, type[BaseUnitConverter]] = {

homeassistant/components/recorder/websocket_api.py

@@ -33,6 +33,8 @@ from homeassistant.util.unit_conversion import (
     InformationConverter,
     MassConverter,
     MassVolumeConcentrationConverter,
+    NitrogenDioxideConcentrationConverter,
+    OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
     ReactiveEnergyConverter,
@@ -85,11 +87,14 @@ UNIT_SCHEMA = vol.Schema(
         vol.Optional("distance"): vol.In(DistanceConverter.VALID_UNITS),
         vol.Optional("duration"): vol.In(DurationConverter.VALID_UNITS),
         vol.Optional("electric_current"): vol.In(ElectricCurrentConverter.VALID_UNITS),
-        vol.Optional("voltage"): vol.In(ElectricPotentialConverter.VALID_UNITS),
         vol.Optional("energy"): vol.In(EnergyConverter.VALID_UNITS),
         vol.Optional("energy_distance"): vol.In(EnergyDistanceConverter.VALID_UNITS),
         vol.Optional("information"): vol.In(InformationConverter.VALID_UNITS),
         vol.Optional("mass"): vol.In(MassConverter.VALID_UNITS),
+        vol.Optional("nitrogen_dioxide"): vol.In(
+            NitrogenDioxideConcentrationConverter.VALID_UNITS
+        ),
+        vol.Optional("ozone"): vol.In(OzoneConcentrationConverter.VALID_UNITS),
         vol.Optional("power"): vol.In(PowerConverter.VALID_UNITS),
         vol.Optional("pressure"): vol.In(PressureConverter.VALID_UNITS),
         vol.Optional("reactive_energy"): vol.In(ReactiveEnergyConverter.VALID_UNITS),
@@ -103,6 +108,7 @@ UNIT_SCHEMA = vol.Schema(
             TemperatureDeltaConverter.VALID_UNITS
         ),
         vol.Optional("unitless"): vol.In(UnitlessRatioConverter.VALID_UNITS),
+        vol.Optional("voltage"): vol.In(ElectricPotentialConverter.VALID_UNITS),
         vol.Optional("volume"): vol.In(VolumeConverter.VALID_UNITS),
         vol.Optional("volume_flow_rate"): vol.In(VolumeFlowRateConverter.VALID_UNITS),
     }

homeassistant/components/refoss/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@ashionky"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/refoss",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "requirements": ["refoss-ha==1.2.5"],
   "single_config_entry": true

homeassistant/components/rehlko/manifest.json

@@ -10,6 +10,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/rehlko",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["aiokem"],
   "quality_scale": "silver",

homeassistant/components/renault/strings.json

@@ -12,6 +12,9 @@
       "invalid_credentials": "[%key:common::config_flow::error::invalid_auth%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "kamereon": {
         "data": {

homeassistant/components/renson/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@jimmyd-be"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/renson",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["renson-endura-delta==1.7.2"]
 }

homeassistant/components/rfxtrx/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@danielhiversen", "@elupus", "@RobBie1221"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/rfxtrx",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["RFXtrx"],
   "requirements": ["pyRFXtrx==0.31.1"]

homeassistant/components/rituals_perfume_genie/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@milanmeu", "@frenck", "@quebulm"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/rituals_perfume_genie",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pyrituals"],
   "requirements": ["pyrituals==0.0.7"]

homeassistant/components/romy/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@xeniter"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/romy",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["romy==0.0.10"],
   "zeroconf": ["_aicu-http._tcp.local."]

homeassistant/components/roomba/manifest.json

@@ -22,6 +22,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/roomba",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["paho_mqtt", "roombapy"],
   "requirements": ["roombapy==1.9.0"],

homeassistant/components/roon/manifest.json

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

homeassistant/components/rova/manifest.json

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

homeassistant/components/russound_rio/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@noahhusby"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/russound_rio",
+  "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["aiorussound"],
   "quality_scale": "silver",

homeassistant/components/ruuvi_gateway/manifest.json

@@ -10,6 +10,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/ruuvi_gateway",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "requirements": ["aioruuvigateway==0.1.0"]
 }

homeassistant/components/ruuvitag_ble/manifest.json

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

homeassistant/components/rympro/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@OnFreund", "@elad-bar", "@maorcc"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/rympro",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "requirements": ["pyrympro==0.0.9"]
 }

homeassistant/components/sabnzbd/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@shaiu", "@jpbede"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/sabnzbd",
+  "integration_type": "service",
   "iot_class": "local_polling",
   "loggers": ["pysabnzbd"],
   "quality_scale": "bronze",

homeassistant/components/sanix/manifest.json

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

homeassistant/components/schlage/manifest.json

@@ -4,6 +4,7 @@
   "codeowners": ["@dknowles2"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/schlage",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "requirements": ["pyschlage==2025.9.0"]
 }

homeassistant/components/sense/manifest.json

@@ -18,6 +18,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/sense",
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["sense_energy"],
   "requirements": ["sense-energy==0.13.8"]

homeassistant/components/sensibo/manifest.json

@@ -12,6 +12,7 @@
   "homekit": {
     "models": ["Sensibo"]
   },
+  "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pysensibo"],
   "quality_scale": "platinum",

homeassistant/components/sensor/const.py

@@ -63,6 +63,8 @@ from homeassistant.util.unit_conversion import (
     InformationConverter,
     MassConverter,
     MassVolumeConcentrationConverter,
+    NitrogenDioxideConcentrationConverter,
+    OzoneConcentrationConverter,
     PowerConverter,
     PressureConverter,
     ReactiveEnergyConverter,
@@ -283,7 +285,7 @@ class SensorDeviceClass(StrEnum):
     NITROGEN_DIOXIDE = "nitrogen_dioxide"
     """Amount of NO2.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion), `μg/m³`
     """
 
     NITROGEN_MONOXIDE = "nitrogen_monoxide"
@@ -301,7 +303,7 @@ class SensorDeviceClass(StrEnum):
     OZONE = "ozone"
     """Amount of O3.
 
-    Unit of measurement: `μg/m³`
+    Unit of measurement: `ppb` (parts per billion),`μg/m³`
     """
 
     PH = "ph"
@@ -563,6 +565,8 @@ UNIT_CONVERTERS: dict[SensorDeviceClass | str | None, type[BaseUnitConverter]] =
     SensorDeviceClass.ENERGY_DISTANCE: EnergyDistanceConverter,
     SensorDeviceClass.ENERGY_STORAGE: EnergyConverter,
     SensorDeviceClass.GAS: VolumeConverter,
+    SensorDeviceClass.NITROGEN_DIOXIDE: NitrogenDioxideConcentrationConverter,
+    SensorDeviceClass.OZONE: OzoneConcentrationConverter,
     SensorDeviceClass.POWER: PowerConverter,
     SensorDeviceClass.POWER_FACTOR: UnitlessRatioConverter,
     SensorDeviceClass.PRECIPITATION: DistanceConverter,
@@ -631,10 +635,16 @@ DEVICE_CLASS_UNITS: dict[SensorDeviceClass, set[type[StrEnum] | str | None]] = {
     SensorDeviceClass.ILLUMINANCE: {LIGHT_LUX},
     SensorDeviceClass.IRRADIANCE: set(UnitOfIrradiance),
     SensorDeviceClass.MOISTURE: {PERCENTAGE},
-    SensorDeviceClass.NITROGEN_DIOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    SensorDeviceClass.NITROGEN_DIOXIDE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     SensorDeviceClass.NITROGEN_MONOXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     SensorDeviceClass.NITROUS_OXIDE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
-    SensorDeviceClass.OZONE: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
+    SensorDeviceClass.OZONE: {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    },
     SensorDeviceClass.PH: {None},
     SensorDeviceClass.PM1: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},
     SensorDeviceClass.PM10: {CONCENTRATION_MICROGRAMS_PER_CUBIC_METER},

homeassistant/components/smartthings/strings.json

@@ -18,6 +18,9 @@
     "error": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "pick_implementation": {
         "data": {

homeassistant/components/template/select.py

@@ -49,8 +49,8 @@ DEFAULT_NAME = "Template Select"
 
 SELECT_COMMON_SCHEMA = vol.Schema(
     {
-        vol.Optional(ATTR_OPTIONS): cv.template,
-        vol.Optional(CONF_SELECT_OPTION): cv.SCRIPT_SCHEMA,
+        vol.Required(ATTR_OPTIONS): cv.template,
+        vol.Required(CONF_SELECT_OPTION): cv.SCRIPT_SCHEMA,
         vol.Optional(CONF_STATE): cv.template,
     }
 )

homeassistant/components/tibber/__init__.py

@@ -8,7 +8,6 @@ import logging
 import aiohttp
 from aiohttp.client_exceptions import ClientError, ClientResponseError
 import tibber
-from tibber import data_api as tibber_data_api
 
 from homeassistant.const import CONF_ACCESS_TOKEN, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import Event, HomeAssistant
@@ -23,13 +22,7 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util, ssl as ssl_util
 
-from .const import (
-    AUTH_IMPLEMENTATION,
-    CONF_LEGACY_ACCESS_TOKEN,
-    DATA_HASS_CONFIG,
-    DOMAIN,
-    TibberConfigEntry,
-)
+from .const import AUTH_IMPLEMENTATION, DATA_HASS_CONFIG, DOMAIN, TibberConfigEntry
 from .coordinator import TibberDataAPICoordinator
 from .services import async_setup_services
 
@@ -44,24 +37,23 @@ _LOGGER = logging.getLogger(__name__)
 class TibberRuntimeData:
     """Runtime data for Tibber API entries."""
 
-    tibber_connection: tibber.Tibber
     session: OAuth2Session
     data_api_coordinator: TibberDataAPICoordinator | None = field(default=None)
-    _client: tibber_data_api.TibberDataAPI | None = None
+    _client: tibber.Tibber | None = None
 
-    async def async_get_client(
-        self, hass: HomeAssistant
-    ) -> tibber_data_api.TibberDataAPI:
-        """Return an authenticated Tibber Data API client."""
+    async def async_get_client(self, hass: HomeAssistant) -> tibber.Tibber:
+        """Return an authenticated Tibber client."""
         await self.session.async_ensure_token_valid()
         token = self.session.token
         access_token = token.get(CONF_ACCESS_TOKEN)
         if not access_token:
             raise ConfigEntryAuthFailed("Access token missing from OAuth session")
         if self._client is None:
-            self._client = tibber_data_api.TibberDataAPI(
-                access_token,
+            self._client = tibber.Tibber(
+                access_token=access_token,
                 websession=async_get_clientsession(hass),
+                time_zone=dt_util.get_default_time_zone(),
+                ssl=ssl_util.get_default_context(),
             )
         self._client.set_access_token(access_token)
         return self._client
@@ -88,32 +80,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: TibberConfigEntry) -> bo
             translation_key="data_api_reauth_required",
         )
 
-    tibber_connection = tibber.Tibber(
-        access_token=entry.data[CONF_LEGACY_ACCESS_TOKEN],
-        websession=async_get_clientsession(hass),
-        time_zone=dt_util.get_default_time_zone(),
-        ssl=ssl_util.get_default_context(),
-    )
-
-    async def _close(event: Event) -> None:
-        await tibber_connection.rt_disconnect()
-
-    entry.async_on_unload(hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close))
-
-    try:
-        await tibber_connection.update_info()
-    except (
-        TimeoutError,
-        aiohttp.ClientError,
-        tibber.RetryableHttpExceptionError,
-    ) as err:
-        raise ConfigEntryNotReady("Unable to connect") from err
-    except tibber.InvalidLoginError as exp:
-        _LOGGER.error("Failed to login. %s", exp)
-        return False
-    except tibber.FatalHttpExceptionError:
-        return False
-
     try:
         implementation = await async_get_config_entry_implementation(hass, entry)
     except ImplementationUnavailableError as err:
@@ -135,10 +101,29 @@ async def async_setup_entry(hass: HomeAssistant, entry: TibberConfigEntry) -> bo
         raise ConfigEntryNotReady from err
 
     entry.runtime_data = TibberRuntimeData(
-        tibber_connection=tibber_connection,
         session=session,
     )
 
+    tibber_connection = await entry.runtime_data.async_get_client(hass)
+
+    async def _close(event: Event) -> None:
+        await tibber_connection.rt_disconnect()
+
+    entry.async_on_unload(hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _close))
+
+    try:
+        await tibber_connection.update_info()
+    except (
+        TimeoutError,
+        aiohttp.ClientError,
+        tibber.RetryableHttpExceptionError,
+    ) as err:
+        raise ConfigEntryNotReady("Unable to connect") from err
+    except tibber.InvalidLoginError as err:
+        raise ConfigEntryAuthFailed("Invalid login credentials") from err
+    except tibber.FatalHttpExceptionError as err:
+        raise ConfigEntryNotReady("Fatal HTTP error from Tibber API") from err
+
     coordinator = TibberDataAPICoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data.data_api_coordinator = coordinator
@@ -154,5 +139,6 @@ async def async_unload_entry(
     if unload_ok := await hass.config_entries.async_unload_platforms(
         config_entry, PLATFORMS
     ):
-        await config_entry.runtime_data.tibber_connection.rt_disconnect()
+        tibber_connection = await config_entry.runtime_data.async_get_client(hass)
+        await tibber_connection.rt_disconnect()
     return unload_ok

homeassistant/components/tibber/config_flow.py

@@ -8,21 +8,16 @@ from typing import Any
 
 import aiohttp
 import tibber
-from tibber import data_api as tibber_data_api
-import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER, ConfigFlowResult
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
 
-from .const import CONF_LEGACY_ACCESS_TOKEN, DATA_API_DEFAULT_SCOPES, DOMAIN
+from .const import DATA_API_DEFAULT_SCOPES, DOMAIN
 
-DATA_SCHEMA = vol.Schema({vol.Required(CONF_LEGACY_ACCESS_TOKEN): str})
-ERR_TIMEOUT = "timeout"
 ERR_CLIENT = "cannot_connect"
 ERR_TOKEN = "invalid_access_token"
-TOKEN_URL = "https://developer.tibber.com/settings/access-token"
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,8 +31,7 @@ class TibberConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
     def __init__(self) -> None:
         """Initialize the config flow."""
         super().__init__()
-        self._access_token: str | None = None
-        self._title = ""
+        self._oauth_data: dict[str, Any] | None = None
 
     @property
     def logger(self) -> logging.Logger:
@@ -52,114 +46,70 @@ class TibberConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
             "scope": " ".join(DATA_API_DEFAULT_SCOPES),
         }
 
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        if user_input is None:
-            data_schema = self.add_suggested_values_to_schema(
-                DATA_SCHEMA, {CONF_LEGACY_ACCESS_TOKEN: self._access_token or ""}
-            )
-
-            return self.async_show_form(
-                step_id=SOURCE_USER,
-                data_schema=data_schema,
-                description_placeholders={"url": TOKEN_URL},
-                errors={},
-            )
-
-        self._access_token = user_input[CONF_LEGACY_ACCESS_TOKEN].replace(" ", "")
-        tibber_connection = tibber.Tibber(
-            access_token=self._access_token,
-            websession=async_get_clientsession(self.hass),
-        )
-        self._title = tibber_connection.name or "Tibber"
-
-        errors: dict[str, str] = {}
-        try:
-            await tibber_connection.update_info()
-        except TimeoutError:
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_TIMEOUT
-        except tibber.InvalidLoginError:
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_TOKEN
-        except (
-            aiohttp.ClientError,
-            tibber.RetryableHttpExceptionError,
-            tibber.FatalHttpExceptionError,
-        ):
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_CLIENT
-
-        if errors:
-            data_schema = self.add_suggested_values_to_schema(
-                DATA_SCHEMA, {CONF_LEGACY_ACCESS_TOKEN: self._access_token or ""}
-            )
-
-            return self.async_show_form(
-                step_id=SOURCE_USER,
-                data_schema=data_schema,
-                description_placeholders={"url": TOKEN_URL},
-                errors=errors,
-            )
-
-        await self.async_set_unique_id(tibber_connection.user_id)
-
-        if self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
-            self._abort_if_unique_id_mismatch(
-                reason="wrong_account",
-                description_placeholders={"title": reauth_entry.title},
-            )
-        else:
-            self._abort_if_unique_id_configured()
-
-        return await self.async_step_pick_implementation()
-
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
         """Handle a reauth flow."""
-        reauth_entry = self._get_reauth_entry()
-        self._access_token = reauth_entry.data.get(CONF_LEGACY_ACCESS_TOKEN)
-        self._title = reauth_entry.title
         return await self.async_step_reauth_confirm()
 
     async def async_step_reauth_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Confirm reauthentication by reusing the user step."""
-        reauth_entry = self._get_reauth_entry()
-        self._access_token = reauth_entry.data.get(CONF_LEGACY_ACCESS_TOKEN)
-        self._title = reauth_entry.title
         if user_input is None:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-            )
+            return self.async_show_form(step_id="reauth_confirm")
         return await self.async_step_user()
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Finalize the OAuth flow and create the config entry."""
-        if self._access_token is None:
-            return self.async_abort(reason="missing_configuration")
+        self._oauth_data = data
+        return await self._async_validate_and_create()
 
-        data[CONF_LEGACY_ACCESS_TOKEN] = self._access_token
+    async def async_step_connection_error(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle connection error retry."""
+        if user_input is not None:
+            return await self._async_validate_and_create()
+        return self.async_show_form(step_id="connection_error")
 
-        access_token = data[CONF_TOKEN][CONF_ACCESS_TOKEN]
-        data_api_client = tibber_data_api.TibberDataAPI(
-            access_token,
+    async def _async_validate_and_create(self) -> ConfigFlowResult:
+        """Validate the OAuth token and create the config entry."""
+        assert self._oauth_data is not None
+        access_token = self._oauth_data[CONF_TOKEN][CONF_ACCESS_TOKEN]
+        tibber_connection = tibber.Tibber(
+            access_token=access_token,
             websession=async_get_clientsession(self.hass),
         )
 
         try:
-            await data_api_client.get_userinfo()
-        except (aiohttp.ClientError, TimeoutError):
-            return self.async_abort(reason="cannot_connect")
+            await tibber_connection.update_info()
+        except TimeoutError:
+            return await self.async_step_connection_error()
+        except tibber.InvalidLoginError:
+            return self.async_abort(reason=ERR_TOKEN)
+        except (
+            aiohttp.ClientError,
+            tibber.RetryableHttpExceptionError,
+        ):
+            return await self.async_step_connection_error()
+        except tibber.FatalHttpExceptionError:
+            return self.async_abort(reason=ERR_CLIENT)
 
+        await self.async_set_unique_id(tibber_connection.user_id)
+
+        title = tibber_connection.name or "Tibber"
         if self.source == SOURCE_REAUTH:
             reauth_entry = self._get_reauth_entry()
+            self._abort_if_unique_id_mismatch(
+                reason="wrong_account",
+                description_placeholders={"title": reauth_entry.title},
+            )
             return self.async_update_reload_and_abort(
                 reauth_entry,
-                data=data,
-                title=self._title,
+                data=self._oauth_data,
+                title=title,
             )
 
-        return self.async_create_entry(title=self._title, data=data)
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(title=title, data=self._oauth_data)

homeassistant/components/tibber/const.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ACCESS_TOKEN
 
 if TYPE_CHECKING:
     from . import TibberRuntimeData
@@ -13,8 +12,6 @@ if TYPE_CHECKING:
 type TibberConfigEntry = ConfigEntry[TibberRuntimeData]
 
 
-CONF_LEGACY_ACCESS_TOKEN = CONF_ACCESS_TOKEN
-
 AUTH_IMPLEMENTATION = "auth_implementation"
 DATA_HASS_CONFIG = "tibber_hass_config"
 DOMAIN = "tibber"

homeassistant/components/tibber/coordinator.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, cast
 
 from aiohttp.client_exceptions import ClientError
 import tibber
-from tibber.data_api import TibberDataAPI, TibberDevice
+from tibber.data_api import TibberDevice
 
 from homeassistant.components.recorder import get_instance
 from homeassistant.components.recorder.models import (
@@ -230,28 +230,26 @@ class TibberDataAPICoordinator(DataUpdateCoordinator[dict[str, TibberDevice]]):
             return device_sensors.get(sensor_id)
         return None
 
-    async def _async_get_client(self) -> TibberDataAPI:
-        """Get the Tibber Data API client with error handling."""
+    async def _async_get_client(self) -> tibber.Tibber:
+        """Get the Tibber client with error handling."""
         try:
             return await self._runtime_data.async_get_client(self.hass)
         except ConfigEntryAuthFailed:
             raise
         except (ClientError, TimeoutError, tibber.UserAgentMissingError) as err:
-            raise UpdateFailed(
-                f"Unable to create Tibber Data API client: {err}"
-            ) from err
+            raise UpdateFailed(f"Unable to create Tibber client: {err}") from err
 
     async def _async_setup(self) -> None:
         """Initial load of Tibber Data API devices."""
         client = await self._async_get_client()
-        devices = await client.get_all_devices()
+        devices = await client.data_api.get_all_devices()
         self._build_sensor_lookup(devices)
 
     async def _async_update_data(self) -> dict[str, TibberDevice]:
         """Fetch the latest device capabilities from the Tibber Data API."""
         client = await self._async_get_client()
         try:
-            devices: dict[str, TibberDevice] = await client.update_devices()
+            devices: dict[str, TibberDevice] = await client.data_api.update_devices()
         except tibber.exceptions.RateLimitExceededError as err:
             raise UpdateFailed(
                 f"Rate limit exceeded, retry after {err.retry_after} seconds",

homeassistant/components/tibber/diagnostics.py

@@ -15,6 +15,7 @@ async def async_get_config_entry_diagnostics(
     """Return diagnostics for a config entry."""
 
     runtime = config_entry.runtime_data
+    tibber_connection = await runtime.async_get_client(hass)
     result: dict[str, Any] = {
         "homes": [
             {
@@ -24,7 +25,7 @@ async def async_get_config_entry_diagnostics(
                 "last_cons_data_timestamp": home.last_cons_data_timestamp,
                 "country": home.country,
             }
-            for home in runtime.tibber_connection.get_homes(only_active=False)
+            for home in tibber_connection.get_homes(only_active=False)
         ]
     }
 

homeassistant/components/tibber/notify.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import tibber
+
 from homeassistant.components.notify import (
     ATTR_TITLE_DEFAULT,
     NotifyEntity,
@@ -37,7 +39,9 @@ class TibberNotificationEntity(NotifyEntity):
 
     async def async_send_message(self, message: str, title: str | None = None) -> None:
         """Send a message to Tibber devices."""
-        tibber_connection = self._entry.runtime_data.tibber_connection
+        tibber_connection: tibber.Tibber = (
+            await self._entry.runtime_data.async_get_client(self.hass)
+        )
         try:
             await tibber_connection.send_notification(
                 title or ATTR_TITLE_DEFAULT, message

homeassistant/components/tibber/sensor.py

@@ -605,7 +605,7 @@ async def _async_setup_graphql_sensors(
 ) -> None:
     """Set up the Tibber sensor."""
 
-    tibber_connection = entry.runtime_data.tibber_connection
+    tibber_connection = await entry.runtime_data.async_get_client(hass)
 
     entity_registry = er.async_get(hass)
 

homeassistant/components/tibber/services.py

@@ -42,7 +42,7 @@ async def __get_prices(call: ServiceCall) -> ServiceResponse:
             translation_domain=DOMAIN,
             translation_key="no_config_entry",
         )
-    tibber_connection = entries[0].runtime_data.tibber_connection
+    tibber_connection = await entries[0].runtime_data.async_get_client(call.hass)
 
     start = __get_date(call.data.get(ATTR_START), "start")
     end = __get_date(call.data.get(ATTR_END), "end")

homeassistant/components/tibber/strings.json

@@ -2,26 +2,21 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_access_token": "[%key:common::config_flow::error::invalid_access_token%]",
       "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
       "missing_credentials": "[%key:common::config_flow::abort::oauth2_missing_credentials%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "wrong_account": "The connected account does not match {title}. Sign in with the same Tibber account and try again."
     },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_access_token": "[%key:common::config_flow::error::invalid_access_token%]",
-      "timeout": "[%key:common::config_flow::error::timeout_connect%]"
-    },
     "step": {
+      "connection_error": {
+        "description": "Could not connect to Tibber. Check your internet connection and try again.",
+        "title": "Connection failed"
+      },
       "reauth_confirm": {
         "description": "Reconnect your Tibber account to refresh access.",
         "title": "[%key:common::config_flow::title::reauth%]"
-      },
-      "user": {
-        "data": {
-          "access_token": "[%key:common::config_flow::data::access_token%]"
-        },
-        "description": "Enter your access token from {url}"
       }
     }
   },

homeassistant/components/twitch/strings.json

@@ -10,6 +10,9 @@
       "unknown": "[%key:common::config_flow::error::unknown%]",
       "wrong_account": "Wrong account: Please authenticate with {username}."
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "reauth_confirm": {
         "description": "The Twitch integration needs to re-authenticate your account",

homeassistant/components/unifiprotect/binary_sensor.py

@@ -8,6 +8,7 @@ import dataclasses
 from uiprotect.data import (
     NVR,
     Camera,
+    Event,
     ModelType,
     MountType,
     ProtectAdoptableDeviceModel,
@@ -644,6 +645,31 @@ class ProtectEventBinarySensor(EventEntityMixin, BinarySensorEntity):
         self._attr_is_on = False
         self._attr_extra_state_attributes = {}
 
+    @callback
+    def _find_active_event_with_object_type(
+        self, device: ProtectDeviceType
+    ) -> Event | None:
+        """Find an active event containing this sensor's object type.
+
+        Fallback for issue #152133: last_smart_detect_event_ids may not update
+        immediately when a new detection type is added to an ongoing event.
+        """
+        obj_type = self.entity_description.ufp_obj_type
+        if obj_type is None or not isinstance(device, Camera):
+            return None
+
+        # Check known active event IDs from camera first (fast path)
+        for event_id in device.last_smart_detect_event_ids.values():
+            if (
+                event_id
+                and (event := self.data.api.bootstrap.events.get(event_id))
+                and event.end is None
+                and obj_type in event.smart_detect_types
+            ):
+                return event
+
+        return None
+
     @callback
     def _async_update_device_from_protect(self, device: ProtectDeviceType) -> None:
         description = self.entity_description
@@ -651,9 +677,15 @@ class ProtectEventBinarySensor(EventEntityMixin, BinarySensorEntity):
         prev_event = self._event
         prev_event_end = self._event_end
         super()._async_update_device_from_protect(device)
-        if event := description.get_event_obj(device):
+
+        event = description.get_event_obj(device)
+        if event is None:
+            # Fallback for #152133: check active events directly
+            event = self._find_active_event_with_object_type(device)
+
+        if event:
             self._event = event
-            self._event_end = event.end if event else None
+            self._event_end = event.end
 
         if not (
             event

homeassistant/components/unifiprotect/manifest.json

@@ -41,7 +41,7 @@
   "iot_class": "local_push",
   "loggers": ["uiprotect", "unifi_discovery"],
   "quality_scale": "platinum",
-  "requirements": ["uiprotect==8.1.1", "unifi-discovery==1.2.0"],
+  "requirements": ["uiprotect==10.0.1", "unifi-discovery==1.2.0"],
   "ssdp": [
     {
       "manufacturer": "Ubiquiti Networks",

homeassistant/components/withings/strings.json

@@ -21,6 +21,9 @@
     "error": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "oauth_discovery": {
         "description": "Home Assistant has found a Withings device on your network. Be aware that the setup of Withings is more complicated than many other integrations. Press **Submit** to continue setting up Withings."

homeassistant/components/xbox/strings.json

@@ -15,6 +15,9 @@
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "oauth_discovery": {
         "description": "Home Assistant has found an Xbox device on your network. Press **Submit** to continue setting up the Xbox integration.",

homeassistant/components/youtube/strings.json

@@ -17,6 +17,9 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
     },
+    "initiate_flow": {
+      "user": "[%key:common::config_flow::initiate_flow::account%]"
+    },
     "step": {
       "channels": {
         "data": { "channels": "YouTube channels" },

homeassistant/generated/integrations.json

@@ -5375,7 +5375,7 @@
           "name": "QNAP"
         },
         "qnap_qsw": {
-          "integration_type": "hub",
+          "integration_type": "device",
           "config_flow": true,
           "iot_class": "local_polling",
           "name": "QNAP QSW"
@@ -5413,7 +5413,7 @@
     },
     "rabbitair": {
       "name": "Rabbit Air",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_polling"
     },
@@ -5438,7 +5438,7 @@
     },
     "radiotherm": {
       "name": "Radio Thermostat",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_polling"
     },
@@ -5473,7 +5473,7 @@
     },
     "rapt_ble": {
       "name": "RAPT Bluetooth",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_push"
     },
@@ -5571,7 +5571,7 @@
     },
     "renson": {
       "name": "Renson",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_polling"
     },
@@ -5679,13 +5679,13 @@
     },
     "romy": {
       "name": "ROMY Vacuum Cleaner",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_polling"
     },
     "roomba": {
       "name": "iRobot Roomba and Braava",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "local_push"
     },
@@ -5720,7 +5720,7 @@
     },
     "rova": {
       "name": "ROVA",
-      "integration_type": "hub",
+      "integration_type": "service",
       "config_flow": true,
       "iot_class": "cloud_polling"
     },
@@ -5763,13 +5763,13 @@
       "name": "Ruuvi",
       "integrations": {
         "ruuvi_gateway": {
-          "integration_type": "hub",
+          "integration_type": "device",
           "config_flow": true,
           "iot_class": "local_polling",
           "name": "Ruuvi Gateway"
         },
         "ruuvitag_ble": {
-          "integration_type": "hub",
+          "integration_type": "device",
           "config_flow": true,
           "iot_class": "local_push",
           "name": "Ruuvi BLE"
@@ -5784,7 +5784,7 @@
     },
     "sabnzbd": {
       "name": "SABnzbd",
-      "integration_type": "hub",
+      "integration_type": "service",
       "config_flow": true,
       "iot_class": "local_polling"
     },
@@ -5824,7 +5824,7 @@
     },
     "sanix": {
       "name": "Sanix",
-      "integration_type": "hub",
+      "integration_type": "device",
       "config_flow": true,
       "iot_class": "cloud_polling"
     },

homeassistant/helpers/aiohttp_client.py

@@ -370,9 +370,13 @@ def _async_get_connector(
         return connectors[connector_key]
 
     if verify_ssl:
-        ssl_context: SSLContext = ssl_util.client_context(ssl_cipher)
+        ssl_context: SSLContext = ssl_util.client_context(
+            ssl_cipher, ssl_util.SSL_ALPN_HTTP11
+        )
     else:
-        ssl_context = ssl_util.client_context_no_verify(ssl_cipher)
+        ssl_context = ssl_util.client_context_no_verify(
+            ssl_cipher, ssl_util.SSL_ALPN_HTTP11
+        )
 
     connector = HomeAssistantTCPConnector(
         family=family,

homeassistant/helpers/condition.py

@@ -17,6 +17,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Final,
+    Literal,
     Protocol,
     TypedDict,
     Unpack,
@@ -1346,13 +1347,18 @@ def async_extract_entities(config: ConfigType | Template) -> set[str]:
         if entity_ids is not None:
             referenced.update(entity_ids)
 
+        if target_entities := _get_targets_from_condition_config(
+            config, CONF_ENTITY_ID
+        ):
+            referenced.update(target_entities)
+
     return referenced
 
 
 @callback
 def async_extract_devices(config: ConfigType | Template) -> set[str]:
     """Extract devices from a condition."""
-    referenced = set()
+    referenced: set[str] = set()
     to_process = deque([config])
 
     while to_process:
@@ -1366,15 +1372,57 @@ def async_extract_devices(config: ConfigType | Template) -> set[str]:
             to_process.extend(config["conditions"])
             continue
 
-        if condition != "device":
+        if condition == "device":
+            if (device_id := config.get(CONF_DEVICE_ID)) is not None:
+                referenced.add(device_id)
             continue
 
-        if (device_id := config.get(CONF_DEVICE_ID)) is not None:
-            referenced.add(device_id)
+        if target_devices := _get_targets_from_condition_config(config, CONF_DEVICE_ID):
+            referenced.update(target_devices)
 
     return referenced
 
 
+@callback
+def async_extract_targets(
+    config: ConfigType | Template,
+    target_type: Literal["area_id", "floor_id", "label_id"],
+) -> set[str]:
+    """Extract targets from a condition."""
+    referenced: set[str] = set()
+    to_process = deque([config])
+
+    while to_process:
+        config = to_process.popleft()
+        if isinstance(config, Template):
+            continue
+
+        condition = config[CONF_CONDITION]
+
+        if condition in ("and", "not", "or"):
+            to_process.extend(config["conditions"])
+            continue
+
+        if targets := _get_targets_from_condition_config(config, target_type):
+            referenced.update(targets)
+
+    return referenced
+
+
+@callback
+def _get_targets_from_condition_config(
+    config: ConfigType,
+    target: Literal["entity_id", "device_id", "area_id", "floor_id", "label_id"],
+) -> list[str]:
+    """Extract targets from a condition target config."""
+    if not (target_conf := config.get(CONF_TARGET)):
+        return []
+    if not (targets := target_conf.get(target)):
+        return []
+
+    return [targets] if isinstance(targets, str) else targets
+
+
 def _load_conditions_file(integration: Integration) -> dict[str, Any]:
     """Load conditions file for an integration."""
     try:

homeassistant/helpers/httpx_client.py

@@ -17,6 +17,9 @@ from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.ssl import (
+    SSL_ALPN_HTTP11,
+    SSL_ALPN_HTTP11_HTTP2,
+    SSLALPNProtocols,
     SSLCipherList,
     client_context,
     create_no_verify_ssl_context,
@@ -28,9 +31,9 @@ from .frame import warn_use
 # and we want to keep the connection open for a while so we
 # don't have to reconnect every time so we use 15s to match aiohttp.
 KEEP_ALIVE_TIMEOUT = 15
-DATA_ASYNC_CLIENT: HassKey[httpx.AsyncClient] = HassKey("httpx_async_client")
-DATA_ASYNC_CLIENT_NOVERIFY: HassKey[httpx.AsyncClient] = HassKey(
-    "httpx_async_client_noverify"
+# Shared httpx clients keyed by (verify_ssl, alpn_protocols)
+DATA_ASYNC_CLIENT: HassKey[dict[tuple[bool, SSLALPNProtocols], httpx.AsyncClient]] = (
+    HassKey("httpx_async_client")
 )
 DEFAULT_LIMITS = limits = httpx.Limits(keepalive_expiry=KEEP_ALIVE_TIMEOUT)
 SERVER_SOFTWARE = (
@@ -42,15 +45,26 @@ USER_AGENT = "User-Agent"
 
 @callback
 @bind_hass
-def get_async_client(hass: HomeAssistant, verify_ssl: bool = True) -> httpx.AsyncClient:
+def get_async_client(
+    hass: HomeAssistant,
+    verify_ssl: bool = True,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_HTTP11,
+) -> httpx.AsyncClient:
     """Return default httpx AsyncClient.
 
     This method must be run in the event loop.
-    """
-    key = DATA_ASYNC_CLIENT if verify_ssl else DATA_ASYNC_CLIENT_NOVERIFY
 
-    if (client := hass.data.get(key)) is None:
-        client = hass.data[key] = create_async_httpx_client(hass, verify_ssl)
+    Pass alpn_protocols=SSL_ALPN_HTTP11_HTTP2 to get a client configured for HTTP/2.
+    Clients are cached separately by ALPN protocol to ensure proper SSL context
+    configuration (ALPN protocols differ between HTTP versions).
+    """
+    client_key = (verify_ssl, alpn_protocols)
+    clients = hass.data.setdefault(DATA_ASYNC_CLIENT, {})
+
+    if (client := clients.get(client_key)) is None:
+        client = clients[client_key] = create_async_httpx_client(
+            hass, verify_ssl, alpn_protocols=alpn_protocols
+        )
 
     return client
 
@@ -77,6 +91,7 @@ def create_async_httpx_client(
     verify_ssl: bool = True,
     auto_cleanup: bool = True,
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_HTTP11,
     **kwargs: Any,
 ) -> httpx.AsyncClient:
     """Create a new httpx.AsyncClient with kwargs, i.e. for cookies.
@@ -84,13 +99,22 @@ def create_async_httpx_client(
     If auto_cleanup is False, the client will be
     automatically closed on homeassistant_stop.
 
+    Pass alpn_protocols=SSL_ALPN_HTTP11_HTTP2 for HTTP/2 support (automatically
+    enables httpx http2 mode).
+
     This method must be run in the event loop.
     """
+    # Use the requested ALPN protocols directly to ensure proper SSL context
+    # bucketing. httpx/httpcore mutates SSL contexts by calling set_alpn_protocols(),
+    # so we pre-set the correct protocols to prevent shared context corruption.
     ssl_context = (
-        client_context(ssl_cipher_list)
+        client_context(ssl_cipher_list, alpn_protocols)
         if verify_ssl
-        else create_no_verify_ssl_context(ssl_cipher_list)
+        else create_no_verify_ssl_context(ssl_cipher_list, alpn_protocols)
     )
+    # Enable httpx HTTP/2 mode when HTTP/2 protocol is requested
+    if alpn_protocols == SSL_ALPN_HTTP11_HTTP2:
+        kwargs.setdefault("http2", True)
     client = HassHttpXAsyncClient(
         verify=ssl_context,
         headers={USER_AGENT: SERVER_SOFTWARE},

homeassistant/helpers/script.py

@@ -1601,8 +1601,13 @@ class Script:
                 ):
                     _referenced_extract_ids(data, target, referenced)
 
+            elif action == cv.SCRIPT_ACTION_CHECK_CONDITION:
+                referenced |= condition.async_extract_targets(step, target)
+
             elif action == cv.SCRIPT_ACTION_CHOOSE:
                 for choice in step[CONF_CHOOSE]:
+                    for cond in choice[CONF_CONDITIONS]:
+                        referenced |= condition.async_extract_targets(cond, target)
                     Script._find_referenced_target(
                         target, referenced, choice[CONF_SEQUENCE]
                     )
@@ -1612,6 +1617,8 @@ class Script:
                     )
 
             elif action == cv.SCRIPT_ACTION_IF:
+                for cond in step[CONF_IF]:
+                    referenced |= condition.async_extract_targets(cond, target)
                 Script._find_referenced_target(target, referenced, step[CONF_THEN])
                 if CONF_ELSE in step:
                     Script._find_referenced_target(target, referenced, step[CONF_ELSE])

homeassistant/helpers/trigger.py

@@ -594,6 +594,8 @@ class EntityNumericalStateAttributeChangedTriggerBase(EntityTriggerBase):
     _above: None | float | str
     _below: None | float | str
 
+    _converter: Callable[[Any], float] = float
+
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
         """Initialize the state trigger."""
         super().__init__(hass, config)
@@ -616,7 +618,7 @@ class EntityNumericalStateAttributeChangedTriggerBase(EntityTriggerBase):
             return False
 
         try:
-            current_value = float(_attribute_value)
+            current_value = self._converter(_attribute_value)
         except (TypeError, ValueError):
             # Attribute is not a valid number, don't trigger
             return False
@@ -706,6 +708,8 @@ class EntityNumericalStateAttributeCrossedThresholdTriggerBase(EntityTriggerBase
     _upper_limit: float | str | None = None
     _threshold_type: ThresholdType
 
+    _converter: Callable[[Any], float] = float
+
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
         """Initialize the state trigger."""
         super().__init__(hass, config)
@@ -741,7 +745,7 @@ class EntityNumericalStateAttributeCrossedThresholdTriggerBase(EntityTriggerBase
             return False
 
         try:
-            current_value = float(_attribute_value)
+            current_value = self._converter(_attribute_value)
         except (TypeError, ValueError):
             # Attribute is not a valid number, don't trigger
             return False

homeassistant/util/ssl.py

@@ -8,6 +8,17 @@ import ssl
 
 import certifi
 
+# Type alias for ALPN protocols tuple (None means no ALPN protocols set)
+type SSLALPNProtocols = tuple[str, ...] | None
+
+# ALPN protocol configurations
+# No ALPN protocols - used for libraries that don't support/need ALPN (e.g., aioimap)
+SSL_ALPN_NONE: SSLALPNProtocols = None
+# HTTP/1.1 only - used by default and for aiohttp (which doesn't support HTTP/2)
+SSL_ALPN_HTTP11: SSLALPNProtocols = ("http/1.1",)
+# HTTP/1.1 with HTTP/2 support - used when httpx http2=True
+SSL_ALPN_HTTP11_HTTP2: SSLALPNProtocols = ("http/1.1", "h2")
+
 
 class SSLCipherList(StrEnum):
     """SSL cipher lists."""
@@ -64,7 +75,10 @@ SSL_CIPHER_LISTS = {
 
 
 @cache
-def _client_context_no_verify(ssl_cipher_list: SSLCipherList) -> ssl.SSLContext:
+def _client_context_no_verify(
+    ssl_cipher_list: SSLCipherList,
+    alpn_protocols: SSLALPNProtocols,
+) -> ssl.SSLContext:
     # This is a copy of aiohttp's create_default_context() function, with the
     # ssl verify turned off.
     # https://github.com/aio-libs/aiohttp/blob/33953f110e97eecc707e1402daa8d543f38a189b/aiohttp/connector.py#L911
@@ -78,12 +92,18 @@ def _client_context_no_verify(ssl_cipher_list: SSLCipherList) -> ssl.SSLContext:
     sslcontext.set_default_verify_paths()
     if ssl_cipher_list != SSLCipherList.PYTHON_DEFAULT:
         sslcontext.set_ciphers(SSL_CIPHER_LISTS[ssl_cipher_list])
+    # Set ALPN protocols to prevent downstream libraries (e.g., httpx/httpcore)
+    # from mutating the shared SSL context with different protocol settings.
+    # If alpn_protocols is None, don't set ALPN (for libraries like aioimap).
+    if alpn_protocols is not None:
+        sslcontext.set_alpn_protocols(list(alpn_protocols))
 
     return sslcontext
 
 
 def _create_client_context(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     """Return an independent SSL context for making requests."""
     # Reuse environment variable definition from requests, since it's already a
@@ -96,6 +116,11 @@ def _create_client_context(
     )
     if ssl_cipher_list != SSLCipherList.PYTHON_DEFAULT:
         sslcontext.set_ciphers(SSL_CIPHER_LISTS[ssl_cipher_list])
+    # Set ALPN protocols to prevent downstream libraries (e.g., httpx/httpcore)
+    # from mutating the shared SSL context with different protocol settings.
+    # If alpn_protocols is None, don't set ALPN (for libraries like aioimap).
+    if alpn_protocols is not None:
+        sslcontext.set_alpn_protocols(list(alpn_protocols))
 
     return sslcontext
 
@@ -103,63 +128,63 @@ def _create_client_context(
 @cache
 def _client_context(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     # Cached version of _create_client_context
-    return _create_client_context(ssl_cipher_list)
+    return _create_client_context(ssl_cipher_list, alpn_protocols)
 
 
-# Create this only once and reuse it
-_DEFAULT_SSL_CONTEXT = _client_context(SSLCipherList.PYTHON_DEFAULT)
-_DEFAULT_NO_VERIFY_SSL_CONTEXT = _client_context_no_verify(SSLCipherList.PYTHON_DEFAULT)
-_NO_VERIFY_SSL_CONTEXTS = {
-    SSLCipherList.INTERMEDIATE: _client_context_no_verify(SSLCipherList.INTERMEDIATE),
-    SSLCipherList.MODERN: _client_context_no_verify(SSLCipherList.MODERN),
-    SSLCipherList.INSECURE: _client_context_no_verify(SSLCipherList.INSECURE),
-}
-_SSL_CONTEXTS = {
-    SSLCipherList.INTERMEDIATE: _client_context(SSLCipherList.INTERMEDIATE),
-    SSLCipherList.MODERN: _client_context(SSLCipherList.MODERN),
-    SSLCipherList.INSECURE: _client_context(SSLCipherList.INSECURE),
-}
+# Pre-warm the cache for ALL SSL context configurations at module load time.
+# This is critical because creating SSL contexts loads certificates from disk,
+# which is blocking I/O that must not happen in the event loop.
+_SSL_ALPN_PROTOCOLS = (SSL_ALPN_NONE, SSL_ALPN_HTTP11, SSL_ALPN_HTTP11_HTTP2)
+for _cipher in SSLCipherList:
+    for _alpn in _SSL_ALPN_PROTOCOLS:
+        _client_context(_cipher, _alpn)
+        _client_context_no_verify(_cipher, _alpn)
 
 
 def get_default_context() -> ssl.SSLContext:
     """Return the default SSL context."""
-    return _DEFAULT_SSL_CONTEXT
+    return _client_context(SSLCipherList.PYTHON_DEFAULT, SSL_ALPN_HTTP11)
 
 
 def get_default_no_verify_context() -> ssl.SSLContext:
     """Return the default SSL context that does not verify the server certificate."""
-    return _DEFAULT_NO_VERIFY_SSL_CONTEXT
+    return _client_context_no_verify(SSLCipherList.PYTHON_DEFAULT, SSL_ALPN_HTTP11)
 
 
 def client_context_no_verify(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     """Return a SSL context with no verification with a specific ssl cipher."""
-    return _NO_VERIFY_SSL_CONTEXTS.get(ssl_cipher_list, _DEFAULT_NO_VERIFY_SSL_CONTEXT)
+    return _client_context_no_verify(ssl_cipher_list, alpn_protocols)
 
 
 def client_context(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     """Return an SSL context for making requests."""
-    return _SSL_CONTEXTS.get(ssl_cipher_list, _DEFAULT_SSL_CONTEXT)
+    return _client_context(ssl_cipher_list, alpn_protocols)
 
 
 def create_client_context(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     """Return an independent SSL context for making requests."""
     # This explicitly uses the non-cached version to create a client context
-    return _create_client_context(ssl_cipher_list)
+    return _create_client_context(ssl_cipher_list, alpn_protocols)
 
 
 def create_no_verify_ssl_context(
     ssl_cipher_list: SSLCipherList = SSLCipherList.PYTHON_DEFAULT,
+    alpn_protocols: SSLALPNProtocols = SSL_ALPN_NONE,
 ) -> ssl.SSLContext:
     """Return an SSL context that does not verify the server certificate."""
-    return _client_context_no_verify(ssl_cipher_list)
+    return _client_context_no_verify(ssl_cipher_list, alpn_protocols)
 
 
 def server_context_modern() -> ssl.SSLContext:

homeassistant/util/unit_conversion.py

@@ -103,6 +103,8 @@ _AMBIENT_IDEAL_GAS_MOLAR_VOLUME = (  # m3⋅mol⁻¹
 )
 # Molar masses in g⋅mol⁻¹
 _CARBON_MONOXIDE_MOLAR_MASS = 28.01
+_NITROGEN_DIOXIDE_MOLAR_MASS = 46.0055
+_OZONE_MOLAR_MASS = 48.00
 _SULPHUR_DIOXIDE_MOLAR_MASS = 64.066
 
 
@@ -186,6 +188,52 @@ class BaseUnitConverter:
         return (from_unit in cls._UNIT_INVERSES) != (to_unit in cls._UNIT_INVERSES)
 
 
+class ApparentPowerConverter(BaseUnitConverter):
+    """Utility to convert apparent power values."""
+
+    UNIT_CLASS = "apparent_power"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        UnitOfApparentPower.MILLIVOLT_AMPERE: 1 * 1000,
+        UnitOfApparentPower.VOLT_AMPERE: 1,
+        UnitOfApparentPower.KILO_VOLT_AMPERE: 1 / 1000,
+    }
+    VALID_UNITS = {
+        UnitOfApparentPower.MILLIVOLT_AMPERE,
+        UnitOfApparentPower.VOLT_AMPERE,
+        UnitOfApparentPower.KILO_VOLT_AMPERE,
+    }
+
+
+class AreaConverter(BaseUnitConverter):
+    """Utility to convert area values."""
+
+    UNIT_CLASS = "area"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        UnitOfArea.SQUARE_METERS: 1,
+        UnitOfArea.SQUARE_CENTIMETERS: 1 / _CM2_TO_M2,
+        UnitOfArea.SQUARE_MILLIMETERS: 1 / _MM2_TO_M2,
+        UnitOfArea.SQUARE_KILOMETERS: 1 / _KM2_TO_M2,
+        UnitOfArea.SQUARE_INCHES: 1 / _IN2_TO_M2,
+        UnitOfArea.SQUARE_FEET: 1 / _FT2_TO_M2,
+        UnitOfArea.SQUARE_YARDS: 1 / _YD2_TO_M2,
+        UnitOfArea.SQUARE_MILES: 1 / _MI2_TO_M2,
+        UnitOfArea.ACRES: 1 / _ACRE_TO_M2,
+        UnitOfArea.HECTARES: 1 / _HECTARE_TO_M2,
+    }
+    VALID_UNITS = set(UnitOfArea)
+
+
+class BloodGlucoseConcentrationConverter(BaseUnitConverter):
+    """Utility to convert blood glucose concentration values."""
+
+    UNIT_CLASS = "blood_glucose_concentration"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER: 18,
+        UnitOfBloodGlucoseConcentration.MILLIMOLE_PER_LITER: 1,
+    }
+    VALID_UNITS = set(UnitOfBloodGlucoseConcentration)
+
+
 class CarbonMonoxideConcentrationConverter(BaseUnitConverter):
     """Convert carbon monoxide ratio to mass per volume.
 
@@ -211,20 +259,16 @@ class CarbonMonoxideConcentrationConverter(BaseUnitConverter):
     }
 
 
-class SulphurDioxideConcentrationConverter(BaseUnitConverter):
-    """Convert sulphur dioxide ratio to mass per volume."""
+class ConductivityConverter(BaseUnitConverter):
+    """Utility to convert electric current values."""
 
-    UNIT_CLASS = "sulphur_dioxide"
+    UNIT_CLASS = "conductivity"
     _UNIT_CONVERSION: dict[str | None, float] = {
-        CONCENTRATION_PARTS_PER_BILLION: 1e9,
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: (
-            _SULPHUR_DIOXIDE_MOLAR_MASS / _AMBIENT_IDEAL_GAS_MOLAR_VOLUME * 1e6
-        ),
-    }
-    VALID_UNITS = {
-        CONCENTRATION_PARTS_PER_BILLION,
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        UnitOfConductivity.MICROSIEMENS_PER_CM: 1,
+        UnitOfConductivity.MILLISIEMENS_PER_CM: 1e-3,
+        UnitOfConductivity.SIEMENS_PER_CM: 1e-6,
     }
+    VALID_UNITS = set(UnitOfConductivity)
 
 
 class DataRateConverter(BaseUnitConverter):
@@ -248,25 +292,6 @@ class DataRateConverter(BaseUnitConverter):
     VALID_UNITS = set(UnitOfDataRate)
 
 
-class AreaConverter(BaseUnitConverter):
-    """Utility to convert area values."""
-
-    UNIT_CLASS = "area"
-    _UNIT_CONVERSION: dict[str | None, float] = {
-        UnitOfArea.SQUARE_METERS: 1,
-        UnitOfArea.SQUARE_CENTIMETERS: 1 / _CM2_TO_M2,
-        UnitOfArea.SQUARE_MILLIMETERS: 1 / _MM2_TO_M2,
-        UnitOfArea.SQUARE_KILOMETERS: 1 / _KM2_TO_M2,
-        UnitOfArea.SQUARE_INCHES: 1 / _IN2_TO_M2,
-        UnitOfArea.SQUARE_FEET: 1 / _FT2_TO_M2,
-        UnitOfArea.SQUARE_YARDS: 1 / _YD2_TO_M2,
-        UnitOfArea.SQUARE_MILES: 1 / _MI2_TO_M2,
-        UnitOfArea.ACRES: 1 / _ACRE_TO_M2,
-        UnitOfArea.HECTARES: 1 / _HECTARE_TO_M2,
-    }
-    VALID_UNITS = set(UnitOfArea)
-
-
 class DistanceConverter(BaseUnitConverter):
     """Utility to convert distance values."""
 
@@ -295,27 +320,28 @@ class DistanceConverter(BaseUnitConverter):
     }
 
 
-class BloodGlucoseConcentrationConverter(BaseUnitConverter):
-    """Utility to convert blood glucose concentration values."""
+class DurationConverter(BaseUnitConverter):
+    """Utility to convert duration values."""
 
-    UNIT_CLASS = "blood_glucose_concentration"
+    UNIT_CLASS = "duration"
     _UNIT_CONVERSION: dict[str | None, float] = {
-        UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER: 18,
-        UnitOfBloodGlucoseConcentration.MILLIMOLE_PER_LITER: 1,
+        UnitOfTime.MICROSECONDS: 1000000,
+        UnitOfTime.MILLISECONDS: 1000,
+        UnitOfTime.SECONDS: 1,
+        UnitOfTime.MINUTES: 1 / _MIN_TO_SEC,
+        UnitOfTime.HOURS: 1 / _HRS_TO_SECS,
+        UnitOfTime.DAYS: 1 / _DAYS_TO_SECS,
+        UnitOfTime.WEEKS: 1 / (7 * _DAYS_TO_SECS),
     }
-    VALID_UNITS = set(UnitOfBloodGlucoseConcentration)
-
-
-class ConductivityConverter(BaseUnitConverter):
-    """Utility to convert electric current values."""
-
-    UNIT_CLASS = "conductivity"
-    _UNIT_CONVERSION: dict[str | None, float] = {
-        UnitOfConductivity.MICROSIEMENS_PER_CM: 1,
-        UnitOfConductivity.MILLISIEMENS_PER_CM: 1e-3,
-        UnitOfConductivity.SIEMENS_PER_CM: 1e-6,
+    VALID_UNITS = {
+        UnitOfTime.MICROSECONDS,
+        UnitOfTime.MILLISECONDS,
+        UnitOfTime.SECONDS,
+        UnitOfTime.MINUTES,
+        UnitOfTime.HOURS,
+        UnitOfTime.DAYS,
+        UnitOfTime.WEEKS,
     }
-    VALID_UNITS = set(UnitOfConductivity)
 
 
 class ElectricCurrentConverter(BaseUnitConverter):
@@ -444,19 +470,51 @@ class MassConverter(BaseUnitConverter):
     }
 
 
-class ApparentPowerConverter(BaseUnitConverter):
-    """Utility to convert apparent power values."""
+class MassVolumeConcentrationConverter(BaseUnitConverter):
+    """Utility to convert mass volume concentration values."""
 
-    UNIT_CLASS = "apparent_power"
+    UNIT_CLASS = "concentration"
     _UNIT_CONVERSION: dict[str | None, float] = {
-        UnitOfApparentPower.MILLIVOLT_AMPERE: 1 * 1000,
-        UnitOfApparentPower.VOLT_AMPERE: 1,
-        UnitOfApparentPower.KILO_VOLT_AMPERE: 1 / 1000,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: 1000000.0,  # 1000 µg/m³ = 1 mg/m³
+        CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER: 1000.0,  # 1000 mg/m³ = 1 g/m³
+        CONCENTRATION_GRAMS_PER_CUBIC_METER: 1.0,
     }
     VALID_UNITS = {
-        UnitOfApparentPower.MILLIVOLT_AMPERE,
-        UnitOfApparentPower.VOLT_AMPERE,
-        UnitOfApparentPower.KILO_VOLT_AMPERE,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER,
+        CONCENTRATION_GRAMS_PER_CUBIC_METER,
+    }
+
+
+class NitrogenDioxideConcentrationConverter(BaseUnitConverter):
+    """Convert nitrogen dioxide ratio to mass per volume."""
+
+    UNIT_CLASS = "nitrogen_dioxide"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        CONCENTRATION_PARTS_PER_BILLION: 1e9,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: (
+            _NITROGEN_DIOXIDE_MOLAR_MASS / _AMBIENT_IDEAL_GAS_MOLAR_VOLUME * 1e6
+        ),
+    }
+    VALID_UNITS = {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    }
+
+
+class OzoneConcentrationConverter(BaseUnitConverter):
+    """Convert ozone ratio to mass per volume."""
+
+    UNIT_CLASS = "ozone"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        CONCENTRATION_PARTS_PER_BILLION: 1e9,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: (
+            _OZONE_MOLAR_MASS / _AMBIENT_IDEAL_GAS_MOLAR_VOLUME * 1e6
+        ),
+    }
+    VALID_UNITS = {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     }
 
 
@@ -645,6 +703,22 @@ class SpeedConverter(BaseUnitConverter):
         return float(0.836 * beaufort ** (3 / 2))
 
 
+class SulphurDioxideConcentrationConverter(BaseUnitConverter):
+    """Convert sulphur dioxide ratio to mass per volume."""
+
+    UNIT_CLASS = "sulphur_dioxide"
+    _UNIT_CONVERSION: dict[str | None, float] = {
+        CONCENTRATION_PARTS_PER_BILLION: 1e9,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: (
+            _SULPHUR_DIOXIDE_MOLAR_MASS / _AMBIENT_IDEAL_GAS_MOLAR_VOLUME * 1e6
+        ),
+    }
+    VALID_UNITS = {
+        CONCENTRATION_PARTS_PER_BILLION,
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    }
+
+
 class TemperatureConverter(BaseUnitConverter):
     """Utility to convert temperature values."""
 
@@ -815,22 +889,6 @@ class UnitlessRatioConverter(BaseUnitConverter):
     }
 
 
-class MassVolumeConcentrationConverter(BaseUnitConverter):
-    """Utility to convert mass volume concentration values."""
-
-    UNIT_CLASS = "concentration"
-    _UNIT_CONVERSION: dict[str | None, float] = {
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: 1000000.0,  # 1000 µg/m³ = 1 mg/m³
-        CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER: 1000.0,  # 1000 mg/m³ = 1 g/m³
-        CONCENTRATION_GRAMS_PER_CUBIC_METER: 1.0,
-    }
-    VALID_UNITS = {
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER,
-        CONCENTRATION_GRAMS_PER_CUBIC_METER,
-    }
-
-
 class VolumeConverter(BaseUnitConverter):
     """Utility to convert volume values."""
 
@@ -893,27 +951,3 @@ class VolumeFlowRateConverter(BaseUnitConverter):
         UnitOfVolumeFlowRate.GALLONS_PER_DAY,
         UnitOfVolumeFlowRate.MILLILITERS_PER_SECOND,
     }
-
-
-class DurationConverter(BaseUnitConverter):
-    """Utility to convert duration values."""
-
-    UNIT_CLASS = "duration"
-    _UNIT_CONVERSION: dict[str | None, float] = {
-        UnitOfTime.MICROSECONDS: 1000000,
-        UnitOfTime.MILLISECONDS: 1000,
-        UnitOfTime.SECONDS: 1,
-        UnitOfTime.MINUTES: 1 / _MIN_TO_SEC,
-        UnitOfTime.HOURS: 1 / _HRS_TO_SECS,
-        UnitOfTime.DAYS: 1 / _DAYS_TO_SECS,
-        UnitOfTime.WEEKS: 1 / (7 * _DAYS_TO_SECS),
-    }
-    VALID_UNITS = {
-        UnitOfTime.MICROSECONDS,
-        UnitOfTime.MILLISECONDS,
-        UnitOfTime.SECONDS,
-        UnitOfTime.MINUTES,
-        UnitOfTime.HOURS,
-        UnitOfTime.DAYS,
-        UnitOfTime.WEEKS,
-    }

pyproject.toml

@@ -676,7 +676,7 @@ exclude_lines = [
 ]
 
 [tool.ruff]
-required-version = ">=0.13.0"
+required-version = ">=0.14.13"
 
 [tool.ruff.lint]
 select = [

requirements_all.txt

@@ -334,7 +334,7 @@ aionanoleaf==0.2.1
 aionotion==2024.03.0
 
 # homeassistant.components.ntfy
-aiontfy==0.6.1
+aiontfy==0.7.0
 
 # homeassistant.components.nut
 aionut==4.3.4
@@ -1104,7 +1104,7 @@ google-nest-sdm==9.1.2
 google-photos-library-api==0.12.1
 
 # homeassistant.components.google_air_quality
-google_air_quality_api==2.1.2
+google_air_quality_api==3.0.0
 
 # homeassistant.components.slide
 # homeassistant.components.slide_local
@@ -1184,7 +1184,7 @@ hassil==3.5.0
 hdate[astral]==1.1.2
 
 # homeassistant.components.hdfury
-hdfury==1.3.1
+hdfury==1.4.2
 
 # homeassistant.components.heatmiser
 heatmiserV3==2.0.4
@@ -1281,7 +1281,7 @@ ihcsdk==2.8.5
 imeon_inverter_api==0.4.0
 
 # homeassistant.components.imgw_pib
-imgw_pib==1.6.0
+imgw_pib==2.0.1
 
 # homeassistant.components.incomfort
 incomfort-client==0.6.11
@@ -1646,7 +1646,7 @@ omnilogic==0.4.5
 ondilo==0.5.0
 
 # homeassistant.components.onedrive
-onedrive-personal-sdk==0.1.0
+onedrive-personal-sdk==0.1.1
 
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4
@@ -1909,7 +1909,7 @@ pyatag==0.3.5.3
 pyatmo==9.2.3
 
 # homeassistant.components.apple_tv
-pyatv==0.16.1;python_version<'3.14'
+pyatv==0.17.0
 
 # homeassistant.components.aussie_broadband
 pyaussiebb==0.1.5
@@ -2147,7 +2147,7 @@ pykmtronic==0.3.0
 pykodi==0.2.7
 
 # homeassistant.components.kostal_plenticore
-pykoplenti==1.3.0
+pykoplenti==1.5.0
 
 # homeassistant.components.kraken
 pykrakenapi==0.1.8
@@ -3080,7 +3080,7 @@ typedmonarchmoney==0.4.4
 uasiren==0.0.1
 
 # homeassistant.components.unifiprotect
-uiprotect==8.1.1
+uiprotect==10.0.1
 
 # homeassistant.components.landisgyr_heat_meter
 ultraheat-api==0.5.7

requirements_test_all.txt

@@ -319,7 +319,7 @@ aionanoleaf==0.2.1
 aionotion==2024.03.0
 
 # homeassistant.components.ntfy
-aiontfy==0.6.1
+aiontfy==0.7.0
 
 # homeassistant.components.nut
 aionut==4.3.4
@@ -980,7 +980,7 @@ google-nest-sdm==9.1.2
 google-photos-library-api==0.12.1
 
 # homeassistant.components.google_air_quality
-google_air_quality_api==2.1.2
+google_air_quality_api==3.0.0
 
 # homeassistant.components.slide
 # homeassistant.components.slide_local
@@ -1051,7 +1051,7 @@ hassil==3.5.0
 hdate[astral]==1.1.2
 
 # homeassistant.components.hdfury
-hdfury==1.3.1
+hdfury==1.4.2
 
 # homeassistant.components.here_travel_time
 here-routing==1.2.0
@@ -1127,7 +1127,7 @@ igloohome-api==0.1.1
 imeon_inverter_api==0.4.0
 
 # homeassistant.components.imgw_pib
-imgw_pib==1.6.0
+imgw_pib==2.0.1
 
 # homeassistant.components.incomfort
 incomfort-client==0.6.11
@@ -1429,7 +1429,7 @@ omnilogic==0.4.5
 ondilo==0.5.0
 
 # homeassistant.components.onedrive
-onedrive-personal-sdk==0.1.0
+onedrive-personal-sdk==0.1.1
 
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4
@@ -1637,7 +1637,7 @@ pyatag==0.3.5.3
 pyatmo==9.2.3
 
 # homeassistant.components.apple_tv
-pyatv==0.16.1;python_version<'3.14'
+pyatv==0.17.0
 
 # homeassistant.components.aussie_broadband
 pyaussiebb==0.1.5
@@ -1821,7 +1821,7 @@ pykmtronic==0.3.0
 pykodi==0.2.7
 
 # homeassistant.components.kostal_plenticore
-pykoplenti==1.3.0
+pykoplenti==1.5.0
 
 # homeassistant.components.kraken
 pykrakenapi==0.1.8
@@ -2577,7 +2577,7 @@ typedmonarchmoney==0.4.4
 uasiren==0.0.1
 
 # homeassistant.components.unifiprotect
-uiprotect==8.1.1
+uiprotect==10.0.1
 
 # homeassistant.components.landisgyr_heat_meter
 ultraheat-api==0.5.7

requirements_test_pre_commit.txt

@@ -1,5 +1,5 @@
 # Automatically generated from .pre-commit-config.yaml by gen_requirements_all.py, do not edit
 
 codespell==2.4.1
-ruff==0.13.0
+ruff==0.14.13
 yamllint==1.37.1

script/gen_copilot_instructions.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Generate .github/copilot-instructions.md from AGENTS.md and skills.
+
+Necessary until copilot can handle skills.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+import re
+import sys
+
+GENERATED_MESSAGE = (
+    f"<!-- Automatically generated by {Path(__file__).name}, do not edit -->\n\n"
+)
+
+SKILLS_DIR = Path(".claude/skills")
+AGENTS_FILE = Path("AGENTS.md")
+OUTPUT_FILE = Path(".github/copilot-instructions.md")
+
+# Pattern to match markdown links to local files: [text](filename)
+# Excludes URLs (http://, https://) and anchors (#)
+LOCAL_LINK_PATTERN = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+
+
+def expand_file_references(content: str, skill_dir: Path) -> str:
+    """Expand file references in skill content.
+
+    Finds markdown links to local files and replaces them with the file content
+    wrapped in reference tags.
+    """
+    lines = content.split("\n")
+    result_lines: list[str] = []
+
+    for line in lines:
+        result_lines.append(line)
+        matches = list(LOCAL_LINK_PATTERN.finditer(line))
+        if not matches:
+            continue
+
+        # Check if any match is a local file reference
+        expanded = False
+        for match in matches:
+            link_path = match.group(2)
+
+            # Skip URLs and anchors
+            if link_path.startswith(("http://", "https://", "#", "/")):
+                continue
+
+            # Try to find the referenced file
+            ref_file = skill_dir / link_path
+
+            if ref_file.exists():
+                ref_content = ref_file.read_text().strip()
+                result_lines.append(f"<REFERENCE {ref_file.name}>")
+                result_lines.append(ref_content)
+                result_lines.append(f"<END REFERENCE {ref_file.name}>")
+                result_lines.append("")
+                expanded = True
+                break
+
+        if not expanded:
+            result_lines.append(line)
+
+    return "\n".join(result_lines)
+
+
+def gather_skills() -> list[tuple[str, str]]:
+    """Gather all skills from the skills directory.
+
+    Returns a list of tuples (skill_name, skill_content).
+    """
+    skills: list[tuple[str, str]] = []
+
+    if not SKILLS_DIR.exists():
+        return skills
+
+    for skill_dir in sorted(SKILLS_DIR.iterdir()):
+        if not skill_dir.is_dir():
+            continue
+
+        skill_file = skill_dir / "SKILL.md"
+        if not skill_file.exists():
+            continue
+
+        skill_content = skill_file.read_text()
+
+        # Extract skill name from frontmatter if present
+        skill_name = skill_dir.name
+        if skill_content.startswith("---"):
+            # Parse YAML frontmatter
+            end_idx = skill_content.find("---", 3)
+            if end_idx != -1:
+                frontmatter = skill_content[3:end_idx]
+                for line in frontmatter.split("\n"):
+                    if line.startswith("name:"):
+                        skill_name = line[5:].strip()
+                        break
+                # Remove frontmatter from content
+                skill_content = skill_content[end_idx + 3 :].strip()
+
+        # Expand file references in the skill content
+        skill_content = expand_file_references(skill_content, skill_dir)
+
+        skills.append((skill_name, skill_content))
+
+    return skills
+
+
+def generate_output() -> str:
+    """Generate the copilot-instructions.md content."""
+    if not AGENTS_FILE.exists():
+        print(f"Error: {AGENTS_FILE} not found")
+        sys.exit(1)
+
+    output_parts: list[str] = [GENERATED_MESSAGE]
+
+    # Add AGENTS.md content
+    agents_content = AGENTS_FILE.read_text()
+    output_parts.append(agents_content.strip())
+    output_parts.append("")
+
+    # Add each skill
+    skills = gather_skills()
+    for skill_name, skill_content in skills:
+        output_parts.append("")
+        output_parts.append(f"# Skill: {skill_name}")
+        output_parts.append("")
+        output_parts.append(skill_content)
+        output_parts.append("")
+
+    return "\n".join(output_parts)
+
+
+def main(validate: bool = False) -> int:
+    """Run the script."""
+    if not Path("homeassistant").is_dir():
+        print("Run this from HA root dir")
+        return 1
+
+    content = generate_output()
+
+    if validate:
+        if not OUTPUT_FILE.exists():
+            print(f"Error: {OUTPUT_FILE} does not exist")
+            return 1
+
+        existing = OUTPUT_FILE.read_text()
+        if existing != content:
+            print(f"Error: {OUTPUT_FILE} is out of date")
+            print("Please run: python -m script.gen_copilot_instructions")
+            return 1
+
+        print(f"{OUTPUT_FILE} is up to date")
+        return 0
+
+    OUTPUT_FILE.write_text(content)
+    print(f"Generated {OUTPUT_FILE}")
+    return 0
+
+
+if __name__ == "__main__":
+    _validate = len(sys.argv) > 1 and sys.argv[1] == "validate"
+    sys.exit(main(_validate))

script/hassfest/docker/Dockerfile

@@ -26,7 +26,7 @@ RUN --mount=from=ghcr.io/astral-sh/uv:0.9.17,source=/uv,target=/bin/uv \
         -r /usr/src/homeassistant/requirements.txt \
         pipdeptree==2.26.1 \
         tqdm==4.67.1 \
-        ruff==0.13.0
+        ruff==0.14.13
 
 LABEL "name"="hassfest"
 LABEL "maintainer"="Home Assistant <hello@home-assistant.io>"