Fix KeyError in hydrawise

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>

.claude/skills/github-pr-reviewer/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: github-pr-reviewer
+description: Review a GitHub pull request and provide feedback comments. Use when the user says "review the current PR" or asks to review a specific PR.
+---
+
+# Review GitHub Pull Request
+
+## Preparation:
+- Check if the local commit matches the last one in the PR. If not, checkout the PR locally using 'gh pr checkout'. 
+- CRITICAL: If 'gh pr checkout' fails for ANY reason, you MUST immediately STOP.
+    - Do NOT attempt any workarounds. 
+    - Do NOT proceed with the review.
+    - ALERT about the failure and WAIT for instructions.
+    - This is a hard requirement - no exceptions.
+
+## Follow these steps:
+1. Use 'gh pr view' to get the PR details and description.
+2. Use 'gh pr diff' to see all the changes in the PR.
+3. Analyze the code changes for:
+   - Code quality and style consistency
+   - Potential bugs or issues
+   - Performance implications
+   - Security concerns
+   - Test coverage
+   - Documentation updates if needed
+4. Ensure any existing review comments have been addressed.
+5. Generate constructive review comments in the CONSOLE. DO NOT POST TO GITHUB YOURSELF.
+
+## IMPORTANT:
+- Just review. DO NOT make any changes
+- Be constructive and specific in your comments
+- Suggest improvements where appropriate
+- Only provide review feedback in the CONSOLE. DO NOT ACT ON GITHUB.
+- No need to run tests or linters, just review the code changes.
+- No need to highlight things that are already good.
+
+## Output format:
+- List specific comments for each file/line that needs attention
+- In the end, summarize with an overall assessment (approve, request changes, or comment) and bullet point list of changes suggested, if any.
+  - Example output:
+    ```
+    Overall assessment: request changes.
+    - [CRITICAL] Memory leak in homeassistant/components/sensor/my_sensor.py:143
+    - [PROBLEM] Inefficient algorithm in homeassistant/helpers/data_processing.py:87
+    - [SUGGESTION] Improve variable naming in homeassistant/helpers/config_validation.py:45
+    ```

.core_files.yaml

@@ -34,6 +34,7 @@ base_platforms: &base_platforms
   - homeassistant/components/humidifier/**
   - homeassistant/components/image/**
   - homeassistant/components/image_processing/**
+  - homeassistant/components/infrared/**
   - homeassistant/components/lawn_mower/**
   - homeassistant/components/light/**
   - homeassistant/components/lock/**

.github/copilot-instructions.md

@@ -331,864 +331,6 @@ class MyCoordinator(DataUpdateCoordinator[MyData]):
 ```
 
 
-# Skill: Home Assistant Integration knowledge
+# Skills
 
-### 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
-<REFERENCE platform-diagnostics.md>
-# 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
-<END REFERENCE platform-diagnostics.md>
-
-- **Repairs**: [`platform-repairs.md`](platform-repairs.md) for user-actionable repair issues
-<REFERENCE platform-repairs.md>
-# 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
-<END REFERENCE platform-repairs.md>
-
-
-### 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
-```
+- Home Assistant Integration knowledge: .claude/skills/integrations/SKILL.md

.github/workflows/builder.yml

@@ -182,7 +182,7 @@ jobs:
           fi
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: translations
 
@@ -544,7 +544,7 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: translations
 

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 3
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.3"
+  HA_SHORT_VERSION: "2026.4"
   DEFAULT_PYTHON: "3.14.2"
   ALL_PYTHON_VERSIONS: "['3.14.2']"
   # 10.3 is the oldest supported version
@@ -605,7 +605,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Dependency review
-        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261 # v4.8.2
+        uses: actions/dependency-review-action@05fe4576374b728f0c523d6a13d64c25081e0803 # v4.8.3
         with:
           license-check: false # We use our own license audit checks
 
@@ -978,7 +978,7 @@ jobs:
         run: |
           echo "::add-matcher::.github/workflows/matchers/pytest-slow.json"
       - name: Download pytest_buckets
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: pytest_buckets
       - name: Compile English translations
@@ -1387,7 +1387,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1558,7 +1558,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1587,7 +1587,7 @@ jobs:
       && needs.info.outputs.skip_coverage != 'true' && !cancelled()
     steps:
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov

.github/workflows/codeql.yml

@@ -28,11 +28,11 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@9e907b5e64f6b83e7804b09294d44122997950d6 # v4.32.3
+        uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@9e907b5e64f6b83e7804b09294d44122997950d6 # v4.32.3
+        uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           category: "/language:python"

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

@@ -236,7 +236,7 @@ jobs:
       - name: Detect duplicates using AI
         id: ai_detection
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@a380166897b5408b8fb7dddd148142794cb5624a # v2.0.6
+        uses: actions/ai-inference@e09e65981758de8b2fdab13c2bfb7c7d5493b0b6 # v2.0.7
         with:
           model: openai/gpt-4o
           system-prompt: |

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

@@ -62,7 +62,7 @@ jobs:
       - name: Detect language using AI
         id: ai_language_detection
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@a380166897b5408b8fb7dddd148142794cb5624a # v2.0.6
+        uses: actions/ai-inference@e09e65981758de8b2fdab13c2bfb7c7d5493b0b6 # v2.0.7
         with:
           model: openai/gpt-4o-mini
           system-prompt: |

.github/workflows/wheels.yml

@@ -124,12 +124,12 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_diff
 
@@ -175,17 +175,17 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_diff
 
       - name: Download requirements_all_wheels
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:
           name: requirements_all_wheels
 
@@ -209,4 +209,4 @@ jobs:
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all.txt"
+          requirements: "requirements_all_wheels_${{ matrix.arch }}.txt"

.strict-typing

@@ -289,6 +289,7 @@ homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.inels.*
+homeassistant.components.infrared.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*
@@ -544,6 +545,7 @@ homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
+homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
 homeassistant.components.threshold.*

CODEOWNERS

@@ -401,8 +401,6 @@ build.json @home-assistant/supervisor
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /homeassistant/components/duckdns/ @tr4nt0r
 /tests/components/duckdns/ @tr4nt0r
-/homeassistant/components/duke_energy/ @hunterjm
-/tests/components/duke_energy/ @hunterjm
 /homeassistant/components/duotecno/ @cereal2nd
 /tests/components/duotecno/ @cereal2nd
 /homeassistant/components/dwd_weather_warnings/ @runningman84 @stephan192
@@ -794,6 +792,8 @@ build.json @home-assistant/supervisor
 /tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01 @Robbie1221
 /tests/components/influxdb/ @mdegat01 @Robbie1221
+/homeassistant/components/infrared/ @home-assistant/core
+/tests/components/infrared/ @home-assistant/core
 /homeassistant/components/inkbird/ @bdraco
 /tests/components/inkbird/ @bdraco
 /homeassistant/components/input_boolean/ @home-assistant/core
@@ -1899,8 +1899,8 @@ build.json @home-assistant/supervisor
 /tests/components/withings/ @joostlek
 /homeassistant/components/wiz/ @sbidy @arturpragacz
 /tests/components/wiz/ @sbidy @arturpragacz
-/homeassistant/components/wled/ @frenck
-/tests/components/wled/ @frenck
+/homeassistant/components/wled/ @frenck @mik-laj
+/tests/components/wled/ @frenck @mik-laj
 /homeassistant/components/wmspro/ @mback2k
 /tests/components/wmspro/ @mback2k
 /homeassistant/components/wolflink/ @adamkrol93 @mtielen

codecov.yml

@@ -10,6 +10,7 @@ coverage:
         target: auto
         threshold: 1
         paths:
+          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py
@@ -28,6 +29,7 @@ coverage:
         target: 100
         threshold: 0
         paths:
+          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py

homeassistant/bootstrap.py

@@ -70,7 +70,7 @@ from .const import (
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
-from .exceptions import HomeAssistantError
+from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
 from .helpers import (
     area_registry,
     category_registry,
@@ -433,32 +433,56 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
-    """Load the registries and modules that will do blocking I/O."""
+async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
+    """Load the registries and modules that will do blocking I/O.
+
+    Return whether loading succeeded.
+    """
     if DATA_REGISTRIES_LOADED in hass.data:
-        return
+        return True
+
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-    await asyncio.gather(
-        create_eager_task(get_internal_store_manager(hass).async_initialize()),
-        create_eager_task(area_registry.async_load(hass)),
-        create_eager_task(category_registry.async_load(hass)),
-        create_eager_task(device_registry.async_load(hass)),
-        create_eager_task(entity_registry.async_load(hass)),
-        create_eager_task(floor_registry.async_load(hass)),
-        create_eager_task(issue_registry.async_load(hass)),
-        create_eager_task(label_registry.async_load(hass)),
-        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-        create_eager_task(template.async_load_custom_templates(hass)),
-        create_eager_task(restore_state.async_load(hass)),
-        create_eager_task(hass.config_entries.async_initialize()),
-        create_eager_task(async_get_system_info(hass)),
-        create_eager_task(condition.async_setup(hass)),
-        create_eager_task(trigger.async_setup(hass)),
-    )
+
+    recovery = hass.config.recovery_mode
+    try:
+        await asyncio.gather(
+            create_eager_task(get_internal_store_manager(hass).async_initialize()),
+            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
+            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+            create_eager_task(template.async_load_custom_templates(hass)),
+            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
+            create_eager_task(hass.config_entries.async_initialize()),
+            create_eager_task(async_get_system_info(hass)),
+            create_eager_task(condition.async_setup(hass)),
+            create_eager_task(trigger.async_setup(hass)),
+        )
+    except UnsupportedStorageVersionError as err:
+        # If we're already in recovery mode, we don't want to handle the exception
+        # and activate recovery mode again, as that would lead to an infinite loop.
+        if recovery:
+            raise
+
+        _LOGGER.error(
+            "Storage file %s was created by a newer version of Home Assistant"
+            " (storage version %s > %s); activating recovery mode; on-disk data"
+            " is preserved; upgrade Home Assistant or restore from a backup",
+            err.storage_key,
+            err.found_version,
+            err.max_supported_version,
+        )
+        return False
+
+    return True
 
 
 async def async_from_config_dict(
@@ -475,7 +499,9 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-    await async_load_base_functionality(hass)
+
+    if not await async_load_base_functionality(hass):
+        return None
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)

homeassistant/brands/ubisys.json

@@ -0,0 +1,5 @@
+{
+  "domain": "ubisys",
+  "name": "Ubisys",
+  "iot_standards": ["zigbee"]
+}

homeassistant/components/abode/services.py

@@ -12,10 +12,6 @@ from homeassistant.helpers.dispatcher import dispatcher_send
 
 from .const import DOMAIN, DOMAIN_DATA, LOGGER
 
-SERVICE_SETTINGS = "change_setting"
-SERVICE_CAPTURE_IMAGE = "capture_image"
-SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
-
 ATTR_SETTING = "setting"
 ATTR_VALUE = "value"
 
@@ -75,16 +71,13 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Home Assistant services."""
 
     hass.services.async_register(
-        DOMAIN, SERVICE_SETTINGS, _change_setting, schema=CHANGE_SETTING_SCHEMA
+        DOMAIN, "change_setting", _change_setting, schema=CHANGE_SETTING_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, SERVICE_CAPTURE_IMAGE, _capture_image, schema=CAPTURE_IMAGE_SCHEMA
+        DOMAIN, "capture_image", _capture_image, schema=CAPTURE_IMAGE_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN,
-        SERVICE_TRIGGER_AUTOMATION,
-        _trigger_automation,
-        schema=AUTOMATION_SCHEMA,
+        DOMAIN, "trigger_automation", _trigger_automation, schema=AUTOMATION_SCHEMA
     )

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.0.0"]
+  "requirements": ["accuweather==5.1.0"]
 }

homeassistant/components/accuweather/system_health.py

@@ -30,6 +30,8 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     return {
-        "can_reach_server": system_health.async_check_can_reach_url(hass, ENDPOINT),
+        "can_reach_server": system_health.async_check_can_reach_url(
+            hass, str(ENDPOINT)
+        ),
         "remaining_requests": remaining_requests,
     }

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/advantage_air/services.py

@@ -10,8 +10,6 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
-ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
-
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -20,7 +18,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
+        "set_time_to",
         entity_domain=SENSOR_DOMAIN,
         schema={vol.Required("minutes"): cv.positive_int},
         func="set_time_to",

homeassistant/components/agent_dvr/services.py

@@ -8,18 +8,12 @@ from homeassistant.helpers import service
 
 from .const import DOMAIN
 
-_DEV_EN_ALT = "enable_alerts"
-_DEV_DS_ALT = "disable_alerts"
-_DEV_EN_REC = "start_recording"
-_DEV_DS_REC = "stop_recording"
-_DEV_SNAP = "snapshot"
-
 CAMERA_SERVICES = {
-    _DEV_EN_ALT: "async_enable_alerts",
-    _DEV_DS_ALT: "async_disable_alerts",
-    _DEV_EN_REC: "async_start_recording",
-    _DEV_DS_REC: "async_stop_recording",
-    _DEV_SNAP: "async_snapshot",
+    "enable_alerts": "async_enable_alerts",
+    "disable_alerts": "async_disable_alerts",
+    "start_recording": "async_start_recording",
+    "stop_recording": "async_stop_recording",
+    "snapshot": "async_snapshot",
 }
 
 

homeassistant/components/airobot/number.py

@@ -93,7 +93,6 @@ class AirobotNumber(AirobotEntity, NumberEntity):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="set_value_failed",
-                translation_placeholders={"error": str(err)},
             ) from err
         else:
             await self.coordinator.async_request_refresh()

homeassistant/components/airobot/strings.json

@@ -112,7 +112,7 @@
       "message": "Failed to set temperature to {temperature}."
     },
     "set_value_failed": {
-      "message": "Failed to set value: {error}"
+      "message": "Failed to set value."
     },
     "switch_turn_off_failed": {
       "message": "Failed to turn off {switch}."

homeassistant/components/aladdin_connect/diagnostics.py

@@ -0,0 +1,32 @@
+"""Diagnostics support for Aladdin Connect."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AladdinConnectConfigEntry
+
+TO_REDACT = {"access_token", "refresh_token"}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, config_entry: AladdinConnectConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    return {
+        "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
+        "doors": {
+            uid: {
+                "device_id": coordinator.data.device_id,
+                "door_number": coordinator.data.door_number,
+                "name": coordinator.data.name,
+                "status": coordinator.data.status,
+                "link_status": coordinator.data.link_status,
+                "battery_level": coordinator.data.battery_level,
+            }
+            for uid, coordinator in config_entry.runtime_data.items()
+        },
+    }

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -45,7 +45,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery: done
   discovery-update-info:
     status: exempt

homeassistant/components/alarm_control_panel/trigger.py

@@ -44,7 +44,7 @@ def make_entity_state_trigger_required_features(
     class CustomTrigger(EntityStateTriggerRequiredFeatures):
         """Trigger for entity state changes."""
 
-        _domain = domain
+        _domains = {domain}
         _to_states = {to_state}
         _required_features = required_features
 

homeassistant/components/alarmdecoder/services.py

@@ -13,9 +13,6 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
-SERVICE_ALARM_TOGGLE_CHIME = "alarm_toggle_chime"
-
-SERVICE_ALARM_KEYPRESS = "alarm_keypress"
 ATTR_KEYPRESS = "keypress"
 
 
@@ -26,7 +23,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_ALARM_TOGGLE_CHIME,
+        "alarm_toggle_chime",
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_CODE): cv.string,
@@ -37,7 +34,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_ALARM_KEYPRESS,
+        "alarm_keypress",
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_KEYPRESS): cv.string,

homeassistant/components/alexa_devices/entity.py

@@ -1,6 +1,6 @@
 """Defines a base Alexa Devices entity."""
 
-from aioamazondevices.const.devices import SPEAKER_GROUP_MODEL
+from aioamazondevices.const.devices import SPEAKER_GROUP_DEVICE_TYPE
 from aioamazondevices.structures import AmazonDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -25,19 +25,20 @@ class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
         """Initialize the entity."""
         super().__init__(coordinator)
         self._serial_num = serial_num
-        model_details = coordinator.api.get_model_details(self.device) or {}
-        model = model_details.get("model")
+        model = self.device.model
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_num)},
             name=self.device.account_name,
             model=model,
             model_id=self.device.device_type,
-            manufacturer=model_details.get("manufacturer", "Amazon"),
-            hw_version=model_details.get("hw_version"),
+            manufacturer=self.device.manufacturer or "Amazon",
+            hw_version=self.device.hardware_version,
             sw_version=(
-                self.device.software_version if model != SPEAKER_GROUP_MODEL else None
+                self.device.software_version
+                if model != SPEAKER_GROUP_DEVICE_TYPE
+                else None
             ),
-            serial_number=serial_num if model != SPEAKER_GROUP_MODEL else None,
+            serial_number=serial_num if model != SPEAKER_GROUP_DEVICE_TYPE else None,
         )
         self.entity_description = description
         self._attr_unique_id = f"{serial_num}-{description.key}"

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==12.0.0"]
+  "requirements": ["aioamazondevices==13.0.0"]
 }

homeassistant/components/alexa_devices/services.py

@@ -16,9 +16,6 @@ from .coordinator import AmazonConfigEntry
 ATTR_TEXT_COMMAND = "text_command"
 ATTR_SOUND = "sound"
 ATTR_INFO_SKILL = "info_skill"
-SERVICE_TEXT_COMMAND = "send_text_command"
-SERVICE_SOUND_NOTIFICATION = "send_sound"
-SERVICE_INFO_SKILL = "send_info_skill"
 
 SCHEMA_SOUND_SERVICE = vol.Schema(
     {
@@ -128,17 +125,17 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Amazon Devices integration."""
     for service_name, method, schema in (
         (
-            SERVICE_SOUND_NOTIFICATION,
+            "send_sound",
             async_send_sound_notification,
             SCHEMA_SOUND_SERVICE,
         ),
         (
-            SERVICE_TEXT_COMMAND,
+            "send_text_command",
             async_send_text_command,
             SCHEMA_CUSTOM_COMMAND,
         ),
         (
-            SERVICE_INFO_SKILL,
+            "send_info_skill",
             async_send_info_skill,
             SCHEMA_INFO_SKILL,
         ),

homeassistant/components/amberelectric/const.py

@@ -16,8 +16,6 @@ ATTRIBUTION = "Data provided by Amber Electric"
 LOGGER = logging.getLogger(__package__)
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 
-SERVICE_GET_FORECASTS = "get_forecasts"
-
 GENERAL_CHANNEL = "general"
 CONTROLLED_LOAD_CHANNEL = "controlled_load"
 FEED_IN_CHANNEL = "feed_in"

homeassistant/components/amberelectric/services.py

@@ -22,7 +22,6 @@ from .const import (
     DOMAIN,
     FEED_IN_CHANNEL,
     GENERAL_CHANNEL,
-    SERVICE_GET_FORECASTS,
 )
 from .coordinator import AmberConfigEntry
 from .helpers import format_cents_to_dollars, normalize_descriptor
@@ -101,7 +100,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
     hass.services.async_register(
         DOMAIN,
-        SERVICE_GET_FORECASTS,
+        "get_forecasts",
         handle_get_forecasts,
         GET_FORECASTS_SCHEMA,
         supports_response=SupportsResponse.ONLY,

homeassistant/components/amcrest/camera.py

@@ -49,18 +49,6 @@ SCAN_INTERVAL = timedelta(seconds=15)
 
 STREAM_SOURCE_LIST = ["snapshot", "mjpeg", "rtsp"]
 
-_SRV_EN_REC = "enable_recording"
-_SRV_DS_REC = "disable_recording"
-_SRV_EN_AUD = "enable_audio"
-_SRV_DS_AUD = "disable_audio"
-_SRV_EN_MOT_REC = "enable_motion_recording"
-_SRV_DS_MOT_REC = "disable_motion_recording"
-_SRV_GOTO = "goto_preset"
-_SRV_CBW = "set_color_bw"
-_SRV_TOUR_ON = "start_tour"
-_SRV_TOUR_OFF = "stop_tour"
-
-_SRV_PTZ_CTRL = "ptz_control"
 _ATTR_PTZ_TT = "travel_time"
 _ATTR_PTZ_MOV = "movement"
 _MOV = [
@@ -103,17 +91,17 @@ _SRV_PTZ_SCHEMA = _SRV_SCHEMA.extend(
 )
 
 CAMERA_SERVICES = {
-    _SRV_EN_REC: (_SRV_SCHEMA, "async_enable_recording", ()),
-    _SRV_DS_REC: (_SRV_SCHEMA, "async_disable_recording", ()),
-    _SRV_EN_AUD: (_SRV_SCHEMA, "async_enable_audio", ()),
-    _SRV_DS_AUD: (_SRV_SCHEMA, "async_disable_audio", ()),
-    _SRV_EN_MOT_REC: (_SRV_SCHEMA, "async_enable_motion_recording", ()),
-    _SRV_DS_MOT_REC: (_SRV_SCHEMA, "async_disable_motion_recording", ()),
-    _SRV_GOTO: (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
-    _SRV_CBW: (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
-    _SRV_TOUR_ON: (_SRV_SCHEMA, "async_start_tour", ()),
-    _SRV_TOUR_OFF: (_SRV_SCHEMA, "async_stop_tour", ()),
-    _SRV_PTZ_CTRL: (
+    "enable_recording": (_SRV_SCHEMA, "async_enable_recording", ()),
+    "disable_recording": (_SRV_SCHEMA, "async_disable_recording", ()),
+    "enable_audio": (_SRV_SCHEMA, "async_enable_audio", ()),
+    "disable_audio": (_SRV_SCHEMA, "async_disable_audio", ()),
+    "enable_motion_recording": (_SRV_SCHEMA, "async_enable_motion_recording", ()),
+    "disable_motion_recording": (_SRV_SCHEMA, "async_disable_motion_recording", ()),
+    "goto_preset": (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
+    "set_color_bw": (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
+    "start_tour": (_SRV_SCHEMA, "async_start_tour", ()),
+    "stop_tour": (_SRV_SCHEMA, "async_stop_tour", ()),
+    "ptz_control": (
         _SRV_PTZ_SCHEMA,
         "async_ptz_control",
         (_ATTR_PTZ_MOV, _ATTR_PTZ_TT),

homeassistant/components/androidtv/media_player.py

@@ -36,7 +36,7 @@ from .const import (
     SIGNAL_CONFIG_ENTITY,
 )
 from .entity import AndroidTVEntity, adb_decorator
-from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT, SERVICE_LEARN_SENDEVENT
+from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -271,7 +271,7 @@ class ADBDevice(AndroidTVEntity, MediaPlayerEntity):
             self.async_write_ha_state()
 
             msg = (
-                f"Output from service '{SERVICE_LEARN_SENDEVENT}' from"
+                f"Output from service 'learn_sendevent' from"
                 f" {self.entity_id}: '{output}'"
             )
             persistent_notification.async_create(

homeassistant/components/androidtv/services.py

@@ -16,11 +16,6 @@ ATTR_DEVICE_PATH = "device_path"
 ATTR_HDMI_INPUT = "hdmi_input"
 ATTR_LOCAL_PATH = "local_path"
 
-SERVICE_ADB_COMMAND = "adb_command"
-SERVICE_DOWNLOAD = "download"
-SERVICE_LEARN_SENDEVENT = "learn_sendevent"
-SERVICE_UPLOAD = "upload"
-
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -29,7 +24,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_ADB_COMMAND,
+        "adb_command",
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={vol.Required(ATTR_COMMAND): cv.string},
         func="adb_command",
@@ -37,7 +32,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_LEARN_SENDEVENT,
+        "learn_sendevent",
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema=None,
         func="learn_sendevent",
@@ -45,7 +40,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_DOWNLOAD,
+        "download",
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,
@@ -56,7 +51,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        SERVICE_UPLOAD,
+        "upload",
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,

homeassistant/components/anthropic/entity.py

@@ -400,8 +400,8 @@ def _convert_content(
                 # If there is only one text block, simplify the content to a string
                 messages[-1]["content"] = messages[-1]["content"][0]["text"]
         else:
-            # Note: We don't pass SystemContent here as its passed to the API as the prompt
-            raise TypeError(f"Unexpected content type: {type(content)}")
+            # Note: We don't pass SystemContent here as it's passed to the API as the prompt
+            raise HomeAssistantError("Unexpected content type in chat log")
 
     return messages, container_id
 
@@ -442,8 +442,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
 
     Each message could contain multiple blocks of the same type.
     """
-    if stream is None:
-        raise TypeError("Expected a stream of messages")
+    if stream is None or not hasattr(stream, "__aiter__"):
+        raise HomeAssistantError("Expected a stream of messages")
 
     current_tool_block: ToolUseBlockParam | ServerToolUseBlockParam | None = None
     current_tool_args: str
@@ -456,8 +456,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
         LOGGER.debug("Received response: %s", response)
 
         if isinstance(response, RawMessageStartEvent):
-            if response.message.role != "assistant":
-                raise ValueError("Unexpected message role")
             input_usage = response.message.usage
             first_block = True
         elif isinstance(response, RawContentBlockStartEvent):
@@ -666,7 +664,7 @@ class AnthropicBaseLLMEntity(Entity):
 
         system = chat_log.content[0]
         if not isinstance(system, conversation.SystemContent):
-            raise TypeError("First message must be a system message")
+            raise HomeAssistantError("First message must be a system message")
 
         # System prompt with caching enabled
         system_prompt: list[TextBlockParam] = [
@@ -858,6 +856,11 @@ class AnthropicBaseLLMEntity(Entity):
                     ]
                 )
                 messages.extend(new_messages)
+            except anthropic.AuthenticationError as err:
+                self.entry.async_start_reauth(self.hass)
+                raise HomeAssistantError(
+                    "Authentication error with Anthropic API, reauthentication required"
+                ) from err
             except anthropic.AnthropicError as err:
                 raise HomeAssistantError(
                     f"Sorry, I had a problem talking to Anthropic: {err}"

homeassistant/components/anthropic/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "anthropic",
-  "name": "Anthropic Conversation",
+  "name": "Anthropic",
   "after_dependencies": ["assist_pipeline", "intent"],
   "codeowners": ["@Shulyaka"],
   "config_flow": true,

homeassistant/components/anthropic/quality_scale.yaml

@@ -31,10 +31,7 @@ rules:
   test-before-setup: done
   unique-config-entry: done
   # Silver
-  action-exceptions:
-    status: todo
-    comment: |
-      Reevaluate exceptions for entity services.
+  action-exceptions: done
   config-entry-unloading: done
   docs-configuration-parameters: done
   docs-installation-parameters: done

homeassistant/components/aquostv/media_player.py

@@ -117,6 +117,7 @@ class SharpAquosTVDevice(MediaPlayerEntity):
         | MediaPlayerEntityFeature.VOLUME_SET
         | MediaPlayerEntityFeature.PLAY
     )
+    _attr_volume_step = 2 / 60
 
     def __init__(
         self, name: str, remote: sharp_aquos_rc.TV, power_on_enabled: bool = False
@@ -161,22 +162,6 @@ class SharpAquosTVDevice(MediaPlayerEntity):
         """Turn off tvplayer."""
         self._remote.power(0)
 
-    @_retry
-    def volume_up(self) -> None:
-        """Volume up the media player."""
-        if self.volume_level is None:
-            _LOGGER.debug("Unknown volume in volume_up")
-            return
-        self._remote.volume(int(self.volume_level * 60) + 2)
-
-    @_retry
-    def volume_down(self) -> None:
-        """Volume down media player."""
-        if self.volume_level is None:
-            _LOGGER.debug("Unknown volume in volume_down")
-            return
-        self._remote.volume(int(self.volume_level * 60) - 2)
-
     @_retry
     def set_volume_level(self, volume: float) -> None:
         """Set Volume media player."""

homeassistant/components/august/manifest.json

@@ -30,5 +30,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.4"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
 }

homeassistant/components/aurora_abb_powerone/coordinator.py

@@ -61,7 +61,13 @@ class AuroraAbbDataUpdateCoordinator(DataUpdateCoordinator[dict[str, float]]):
                 frequency = self.client.measure(4)
                 i_leak_dcdc = self.client.measure(6)
                 i_leak_inverter = self.client.measure(7)
+                power_in_1 = self.client.measure(8)
+                power_in_2 = self.client.measure(9)
                 temperature_c = self.client.measure(21)
+                voltage_in_1 = self.client.measure(23)
+                current_in_1 = self.client.measure(25)
+                voltage_in_2 = self.client.measure(26)
+                current_in_2 = self.client.measure(27)
                 r_iso = self.client.measure(30)
                 energy_wh = self.client.cumulated_energy(5)
                 [alarm, *_] = self.client.alarms()
@@ -87,7 +93,13 @@ class AuroraAbbDataUpdateCoordinator(DataUpdateCoordinator[dict[str, float]]):
                 data["grid_frequency"] = round(frequency, 1)
                 data["i_leak_dcdc"] = i_leak_dcdc
                 data["i_leak_inverter"] = i_leak_inverter
+                data["power_in_1"] = round(power_in_1, 1)
+                data["power_in_2"] = round(power_in_2, 1)
                 data["temp"] = round(temperature_c, 1)
+                data["voltage_in_1"] = round(voltage_in_1, 1)
+                data["current_in_1"] = round(current_in_1, 1)
+                data["voltage_in_2"] = round(voltage_in_2, 1)
+                data["current_in_2"] = round(current_in_2, 1)
                 data["r_iso"] = r_iso
                 data["totalenergy"] = round(energy_wh / 1000, 2)
                 data["alarm"] = alarm

homeassistant/components/aurora_abb_powerone/sensor.py

@@ -68,6 +68,7 @@ SENSOR_TYPES = [
         entity_category=EntityCategory.DIAGNOSTIC,
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         state_class=SensorStateClass.MEASUREMENT,
+        translation_key="grid_frequency",
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -88,6 +89,60 @@ SENSOR_TYPES = [
         translation_key="i_leak_inverter",
         entity_registry_enabled_default=False,
     ),
+    SensorEntityDescription(
+        key="power_in_1",
+        device_class=SensorDeviceClass.POWER,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="power_in_1",
+        entity_registry_enabled_default=False,
+    ),
+    SensorEntityDescription(
+        key="power_in_2",
+        device_class=SensorDeviceClass.POWER,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="power_in_2",
+        entity_registry_enabled_default=False,
+    ),
+    SensorEntityDescription(
+        key="voltage_in_1",
+        device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="voltage_in_1",
+        entity_registry_enabled_default=False,
+    ),
+    SensorEntityDescription(
+        key="current_in_1",
+        device_class=SensorDeviceClass.CURRENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="current_in_1",
+        entity_registry_enabled_default=False,
+    ),
+    SensorEntityDescription(
+        key="voltage_in_2",
+        device_class=SensorDeviceClass.VOLTAGE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="voltage_in_2",
+        entity_registry_enabled_default=False,
+    ),
+    SensorEntityDescription(
+        key="current_in_2",
+        device_class=SensorDeviceClass.CURRENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="current_in_2",
+        entity_registry_enabled_default=False,
+    ),
     SensorEntityDescription(
         key="alarm",
         device_class=SensorDeviceClass.ENUM,

homeassistant/components/aurora_abb_powerone/strings.json

@@ -24,9 +24,18 @@
       "alarm": {
         "name": "Alarm status"
       },
+      "current_in_1": {
+        "name": "String 1 current"
+      },
+      "current_in_2": {
+        "name": "String 2 current"
+      },
       "grid_current": {
         "name": "Grid current"
       },
+      "grid_frequency": {
+        "name": "Grid frequency"
+      },
       "grid_voltage": {
         "name": "Grid voltage"
       },
@@ -36,6 +45,12 @@
       "i_leak_inverter": {
         "name": "Inverter leak current"
       },
+      "power_in_1": {
+        "name": "String 1 power"
+      },
+      "power_in_2": {
+        "name": "String 2 power"
+      },
       "power_output": {
         "name": "Power output"
       },
@@ -44,6 +59,12 @@
       },
       "total_energy": {
         "name": "Total energy"
+      },
+      "voltage_in_1": {
+        "name": "String 1 voltage"
+      },
+      "voltage_in_2": {
+        "name": "String 2 voltage"
       }
     }
   }

homeassistant/components/aws_s3/backup.py

@@ -19,7 +19,7 @@ from homeassistant.components.backup import (
 from homeassistant.core import HomeAssistant, callback
 
 from . import S3ConfigEntry
-from .const import CONF_BUCKET, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import CONF_BUCKET, CONF_PREFIX, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 _LOGGER = logging.getLogger(__name__)
@@ -100,6 +100,13 @@ class S3BackupAgent(BackupAgent):
         self.unique_id = entry.entry_id
         self._backup_cache: dict[str, AgentBackup] = {}
         self._cache_expiration = time()
+        self._prefix: str = entry.data.get(CONF_PREFIX, "")
+
+    def _with_prefix(self, key: str) -> str:
+        """Add prefix to a key if configured."""
+        if not self._prefix:
+            return key
+        return f"{self._prefix}/{key}"
 
     @handle_boto_errors
     async def async_download_backup(
@@ -115,7 +122,9 @@ class S3BackupAgent(BackupAgent):
         backup = await self._find_backup_by_id(backup_id)
         tar_filename, _ = suggested_filenames(backup)
 
-        response = await self._client.get_object(Bucket=self._bucket, Key=tar_filename)
+        response = await self._client.get_object(
+            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
+        )
         return response["Body"].iter_chunks()
 
     async def async_upload_backup(
@@ -142,7 +151,7 @@ class S3BackupAgent(BackupAgent):
             metadata_content = json.dumps(backup.as_dict())
             await self._client.put_object(
                 Bucket=self._bucket,
-                Key=metadata_filename,
+                Key=self._with_prefix(metadata_filename),
                 Body=metadata_content,
             )
         except BotoCoreError as err:
@@ -169,7 +178,7 @@ class S3BackupAgent(BackupAgent):
 
         await self._client.put_object(
             Bucket=self._bucket,
-            Key=tar_filename,
+            Key=self._with_prefix(tar_filename),
             Body=bytes(file_data),
         )
 
@@ -186,7 +195,7 @@ class S3BackupAgent(BackupAgent):
         _LOGGER.debug("Starting multipart upload for %s", tar_filename)
         multipart_upload = await self._client.create_multipart_upload(
             Bucket=self._bucket,
-            Key=tar_filename,
+            Key=self._with_prefix(tar_filename),
         )
         upload_id = multipart_upload["UploadId"]
         try:
@@ -216,7 +225,7 @@ class S3BackupAgent(BackupAgent):
                         )
                         part = await cast(Any, self._client).upload_part(
                             Bucket=self._bucket,
-                            Key=tar_filename,
+                            Key=self._with_prefix(tar_filename),
                             PartNumber=part_number,
                             UploadId=upload_id,
                             Body=part_data.tobytes(),
@@ -244,7 +253,7 @@ class S3BackupAgent(BackupAgent):
                 )
                 part = await cast(Any, self._client).upload_part(
                     Bucket=self._bucket,
-                    Key=tar_filename,
+                    Key=self._with_prefix(tar_filename),
                     PartNumber=part_number,
                     UploadId=upload_id,
                     Body=remaining_data.tobytes(),
@@ -253,7 +262,7 @@ class S3BackupAgent(BackupAgent):
 
             await cast(Any, self._client).complete_multipart_upload(
                 Bucket=self._bucket,
-                Key=tar_filename,
+                Key=self._with_prefix(tar_filename),
                 UploadId=upload_id,
                 MultipartUpload={"Parts": parts},
             )
@@ -262,7 +271,7 @@ class S3BackupAgent(BackupAgent):
             try:
                 await self._client.abort_multipart_upload(
                     Bucket=self._bucket,
-                    Key=tar_filename,
+                    Key=self._with_prefix(tar_filename),
                     UploadId=upload_id,
                 )
             except BotoCoreError:
@@ -283,8 +292,12 @@ class S3BackupAgent(BackupAgent):
         tar_filename, metadata_filename = suggested_filenames(backup)
 
         # Delete both the backup file and its metadata file
-        await self._client.delete_object(Bucket=self._bucket, Key=tar_filename)
-        await self._client.delete_object(Bucket=self._bucket, Key=metadata_filename)
+        await self._client.delete_object(
+            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
+        )
+        await self._client.delete_object(
+            Bucket=self._bucket, Key=self._with_prefix(metadata_filename)
+        )
 
         # Reset cache after successful deletion
         self._cache_expiration = time()
@@ -317,7 +330,9 @@ class S3BackupAgent(BackupAgent):
         if time() <= self._cache_expiration:
             return self._backup_cache
 
-        backups_list = await async_list_backups_from_s3(self._client, self._bucket)
+        backups_list = await async_list_backups_from_s3(
+            self._client, self._bucket, self._prefix
+        )
         self._backup_cache = {b.backup_id: b for b in backups_list}
         self._cache_expiration = time() + CACHE_TTL
 

homeassistant/components/aws_s3/config_flow.py

@@ -22,6 +22,7 @@ from .const import (
     CONF_ACCESS_KEY_ID,
     CONF_BUCKET,
     CONF_ENDPOINT_URL,
+    CONF_PREFIX,
     CONF_SECRET_ACCESS_KEY,
     DEFAULT_ENDPOINT_URL,
     DESCRIPTION_AWS_S3_DOCS_URL,
@@ -39,6 +40,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_ENDPOINT_URL, default=DEFAULT_ENDPOINT_URL): TextSelector(
             config=TextSelectorConfig(type=TextSelectorType.URL)
         ),
+        vol.Optional(CONF_PREFIX, default=""): cv.string,
     }
 )
 
@@ -53,12 +55,17 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
 
         if user_input is not None:
-            self._async_abort_entries_match(
-                {
-                    CONF_BUCKET: user_input[CONF_BUCKET],
-                    CONF_ENDPOINT_URL: user_input[CONF_ENDPOINT_URL],
-                }
-            )
+            normalized_prefix = user_input.get(CONF_PREFIX, "").strip("/")
+            # Check for existing entries, treating missing prefix as empty
+            for entry in self._async_current_entries(include_ignore=False):
+                entry_prefix = (entry.data.get(CONF_PREFIX) or "").strip("/")
+                if (
+                    entry.data.get(CONF_BUCKET) == user_input[CONF_BUCKET]
+                    and entry.data.get(CONF_ENDPOINT_URL)
+                    == user_input[CONF_ENDPOINT_URL]
+                    and entry_prefix == normalized_prefix
+                ):
+                    return self.async_abort(reason="already_configured")
 
             hostname = urlparse(user_input[CONF_ENDPOINT_URL]).hostname
             if not hostname or not hostname.endswith(AWS_DOMAIN):
@@ -83,9 +90,18 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
                 except ConnectionError:
                     errors[CONF_ENDPOINT_URL] = "cannot_connect"
                 else:
-                    return self.async_create_entry(
-                        title=user_input[CONF_BUCKET], data=user_input
-                    )
+                    data = dict(user_input)
+                    if not normalized_prefix:
+                        # Do not persist empty optional values
+                        data.pop(CONF_PREFIX, None)
+                    else:
+                        data[CONF_PREFIX] = normalized_prefix
+
+                    title = user_input[CONF_BUCKET]
+                    if normalized_prefix:
+                        title = f"{title} - {normalized_prefix}"
+
+                    return self.async_create_entry(title=title, data=data)
 
         return self.async_show_form(
             step_id="user",

homeassistant/components/aws_s3/const.py

@@ -11,6 +11,7 @@ CONF_ACCESS_KEY_ID = "access_key_id"
 CONF_SECRET_ACCESS_KEY = "secret_access_key"
 CONF_ENDPOINT_URL = "endpoint_url"
 CONF_BUCKET = "bucket"
+CONF_PREFIX = "prefix"
 
 AWS_DOMAIN = "amazonaws.com"
 DEFAULT_ENDPOINT_URL = f"https://s3.eu-central-1.{AWS_DOMAIN}/"

homeassistant/components/aws_s3/coordinator.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_BUCKET, DOMAIN
+from .const import CONF_BUCKET, CONF_PREFIX, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 SCAN_INTERVAL = timedelta(hours=6)
@@ -53,11 +53,14 @@ class S3DataUpdateCoordinator(DataUpdateCoordinator[SensorData]):
         )
         self.client = client
         self._bucket: str = entry.data[CONF_BUCKET]
+        self._prefix: str = entry.data.get(CONF_PREFIX, "")
 
     async def _async_update_data(self) -> SensorData:
         """Fetch data from AWS S3."""
         try:
-            backups = await async_list_backups_from_s3(self.client, self._bucket)
+            backups = await async_list_backups_from_s3(
+                self.client, self._bucket, self._prefix
+            )
         except BotoCoreError as error:
             raise UpdateFailed(
                 translation_domain=DOMAIN,

homeassistant/components/aws_s3/diagnostics.py

@@ -0,0 +1,55 @@
+"""Diagnostics support for AWS S3."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+from homeassistant.components.backup import (
+    DATA_MANAGER as BACKUP_DATA_MANAGER,
+    BackupManager,
+)
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.core import HomeAssistant
+
+from .const import (
+    CONF_ACCESS_KEY_ID,
+    CONF_BUCKET,
+    CONF_PREFIX,
+    CONF_SECRET_ACCESS_KEY,
+    DOMAIN,
+)
+from .coordinator import S3ConfigEntry
+from .helpers import async_list_backups_from_s3
+
+TO_REDACT = (CONF_ACCESS_KEY_ID, CONF_SECRET_ACCESS_KEY)
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant,
+    entry: S3ConfigEntry,
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+    backup_manager: BackupManager = hass.data[BACKUP_DATA_MANAGER]
+    backups = await async_list_backups_from_s3(
+        coordinator.client,
+        bucket=entry.data[CONF_BUCKET],
+        prefix=entry.data.get(CONF_PREFIX, ""),
+    )
+
+    data = {
+        "coordinator_data": dataclasses.asdict(coordinator.data),
+        "config": {
+            **entry.data,
+            **entry.options,
+        },
+        "backup_agents": [
+            {"name": agent.name}
+            for agent in backup_manager.backup_agents.values()
+            if agent.domain == DOMAIN
+        ],
+        "backup": [backup.as_dict() for backup in backups],
+    }
+
+    return async_redact_data(data, TO_REDACT)

homeassistant/components/aws_s3/helpers.py

@@ -17,11 +17,17 @@ _LOGGER = logging.getLogger(__name__)
 async def async_list_backups_from_s3(
     client: S3Client,
     bucket: str,
+    prefix: str,
 ) -> list[AgentBackup]:
     """List backups from an S3 bucket by reading metadata files."""
     paginator = client.get_paginator("list_objects_v2")
     metadata_files: list[dict[str, Any]] = []
-    async for page in paginator.paginate(Bucket=bucket):
+
+    list_kwargs: dict[str, Any] = {"Bucket": bucket}
+    if prefix:
+        list_kwargs["Prefix"] = prefix + "/"
+
+    async for page in paginator.paginate(**list_kwargs):
         metadata_files.extend(
             obj
             for obj in page.get("Contents", [])

homeassistant/components/aws_s3/quality_scale.yaml

@@ -23,7 +23,9 @@ rules:
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
-  unique-config-entry: done
+  unique-config-entry:
+    status: exempt
+    comment: Hassfest does not recognize the duplicate prevention logic. Duplicate entries are prevented by checking bucket, endpoint URL, and prefix in the config flow.
 
   # Silver
   action-exceptions:
@@ -36,14 +38,14 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: todo
+  log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: todo
   test-coverage: done
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info:
     status: exempt
     comment: S3 is a cloud service that is not discovered on the network.

homeassistant/components/aws_s3/strings.json

@@ -15,12 +15,14 @@
           "access_key_id": "Access key ID",
           "bucket": "Bucket name",
           "endpoint_url": "Endpoint URL",
+          "prefix": "Prefix",
           "secret_access_key": "Secret access key"
         },
         "data_description": {
           "access_key_id": "Access key ID to connect to AWS S3 API",
           "bucket": "Bucket must already exist and be writable by the provided credentials.",
           "endpoint_url": "Endpoint URL provided to [Boto3 Session]({boto3_docs_url}). Region-specific [AWS S3 endpoints]({aws_s3_docs_url}) are available in their docs.",
+          "prefix": "Folder or prefix to store backups in, for example `backups`",
           "secret_access_key": "Secret access key to connect to AWS S3 API"
         },
         "title": "Add AWS S3 bucket"

homeassistant/components/backup/store.py

@@ -29,12 +29,17 @@ class StoredBackupData(TypedDict):
 class _BackupStore(Store[StoredBackupData]):
     """Class to help storing backup data."""
 
+    # Maximum version we support reading for forward compatibility.
+    # This allows reading data written by a newer HA version after downgrade.
+    _MAX_READABLE_VERSION = 2
+
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize storage class."""
         super().__init__(
             hass,
             STORAGE_VERSION,
             STORAGE_KEY,
+            max_readable_version=self._MAX_READABLE_VERSION,
             minor_version=STORAGE_VERSION_MINOR,
         )
 
@@ -86,8 +91,8 @@ class _BackupStore(Store[StoredBackupData]):
         # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
         # planned to happen after a 6 month quiet period with no minor version
         # changes.
-        # Reject if major version is higher than 2.
-        if old_major_version > 2:
+        # Reject if major version is higher than _MAX_READABLE_VERSION.
+        if old_major_version > self._MAX_READABLE_VERSION:
             raise NotImplementedError
         return data
 

homeassistant/components/backup/strings.json

@@ -43,11 +43,11 @@
       "title": "The backup location {agent_id} is unavailable"
     },
     "automatic_backup_failed_addons": {
-      "description": "Add-ons {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
-      "title": "Not all add-ons could be included in automatic backup"
+      "description": "Apps {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "title": "Not all apps could be included in automatic backup"
     },
     "automatic_backup_failed_agents_addons_folders": {
-      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Add-ons which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Apps which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
       "title": "Automatic backup was created with errors"
     },
     "automatic_backup_failed_create": {

homeassistant/components/binary_sensor/trigger.py

@@ -24,7 +24,7 @@ class BinarySensorOnOffTrigger(EntityTargetStateTriggerBase):
     """Class for binary sensor on/off triggers."""
 
     _device_class: BinarySensorDeviceClass | None
-    _domain: str = DOMAIN
+    _domains = {DOMAIN}
 
     def entity_filter(self, entities: set[str]) -> set[str]:
         """Filter entities of this domain."""

homeassistant/components/bitcoin/sensor.py

@@ -190,7 +190,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "miners_revenue_usd":
             self._attr_native_value = f"{stats.miners_revenue_usd:.0f}"
         elif sensor_type == "btc_mined":
-            self._attr_native_value = str(stats.btc_mined * 0.00000001)
+            self._attr_native_value = str(stats.btc_mined * 1e-8)
         elif sensor_type == "trade_volume_usd":
             self._attr_native_value = f"{stats.trade_volume_usd:.1f}"
         elif sensor_type == "difficulty":
@@ -208,13 +208,13 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "blocks_size":
             self._attr_native_value = f"{stats.blocks_size:.1f}"
         elif sensor_type == "total_fees_btc":
-            self._attr_native_value = f"{stats.total_fees_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_fees_btc * 1e-8:.2f}"
         elif sensor_type == "total_btc_sent":
-            self._attr_native_value = f"{stats.total_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc_sent * 1e-8:.2f}"
         elif sensor_type == "estimated_btc_sent":
-            self._attr_native_value = f"{stats.estimated_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.estimated_btc_sent * 1e-8:.2f}"
         elif sensor_type == "total_btc":
-            self._attr_native_value = f"{stats.total_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc * 1e-8:.2f}"
         elif sensor_type == "total_blocks":
             self._attr_native_value = f"{stats.total_blocks:.0f}"
         elif sensor_type == "next_retarget":
@@ -222,7 +222,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "estimated_transaction_volume_usd":
             self._attr_native_value = f"{stats.estimated_transaction_volume_usd:.2f}"
         elif sensor_type == "miners_revenue_btc":
-            self._attr_native_value = f"{stats.miners_revenue_btc * 0.00000001:.1f}"
+            self._attr_native_value = f"{stats.miners_revenue_btc * 1e-8:.1f}"
         elif sensor_type == "market_price_usd":
             self._attr_native_value = f"{stats.market_price_usd:.2f}"
 

homeassistant/components/bluesound/media_player.py

@@ -85,6 +85,7 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
     _attr_media_content_type = MediaType.MUSIC
     _attr_has_entity_name = True
     _attr_name = None
+    _attr_volume_step = 0.01
 
     def __init__(
         self,
@@ -688,24 +689,6 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
 
         await self._player.play_url(url)
 
-    async def async_volume_up(self) -> None:
-        """Volume up the media player."""
-        if self.volume_level is None:
-            return
-
-        new_volume = self.volume_level + 0.01
-        new_volume = min(1, new_volume)
-        await self.async_set_volume_level(new_volume)
-
-    async def async_volume_down(self) -> None:
-        """Volume down the media player."""
-        if self.volume_level is None:
-            return
-
-        new_volume = self.volume_level - 0.01
-        new_volume = max(0, new_volume)
-        await self.async_set_volume_level(new_volume)
-
     async def async_set_volume_level(self, volume: float) -> None:
         """Send volume_up command to media player."""
         volume = int(round(volume * 100))

homeassistant/components/bsblan/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
   "quality_scale": "silver",
-  "requirements": ["python-bsblan==5.1.0"],
+  "requirements": ["python-bsblan==5.1.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/sensor.py

@@ -64,6 +64,8 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         state_class=SensorStateClass.TOTAL_INCREASING,
+        suggested_display_precision=0,
+        entity_registry_enabled_default=False,
         value_fn=lambda data: (
             data.sensor.total_energy.value
             if data.sensor.total_energy is not None

homeassistant/components/bsblan/services.py

@@ -31,10 +31,6 @@ ATTR_FRIDAY_SLOTS = "friday_slots"
 ATTR_SATURDAY_SLOTS = "saturday_slots"
 ATTR_SUNDAY_SLOTS = "sunday_slots"
 
-# Service names
-SERVICE_SET_HOT_WATER_SCHEDULE = "set_hot_water_schedule"
-SERVICE_SYNC_TIME = "sync_time"
-
 
 # Schema for a single time slot
 _SLOT_SCHEMA = vol.Schema(
@@ -260,14 +256,14 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Register the BSB-LAN services."""
     hass.services.async_register(
         DOMAIN,
-        SERVICE_SET_HOT_WATER_SCHEDULE,
+        "set_hot_water_schedule",
         set_hot_water_schedule,
         schema=SERVICE_SET_HOT_WATER_SCHEDULE_SCHEMA,
     )
 
     hass.services.async_register(
         DOMAIN,
-        SERVICE_SYNC_TIME,
+        "sync_time",
         async_sync_time,
         schema=SYNC_TIME_SCHEMA,
     )

homeassistant/components/button/trigger.py

@@ -14,7 +14,7 @@ from . import DOMAIN
 class ButtonPressedTrigger(EntityTriggerBase):
     """Trigger for button entity presses."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _schema = ENTITY_STATE_TRIGGER_SCHEMA
 
     def is_valid_transition(self, from_state: State, to_state: State) -> bool:

homeassistant/components/cambridge_audio/icons.json

@@ -29,6 +29,12 @@
       "early_update": {
         "default": "mdi:update"
       },
+      "equalizer": {
+        "default": "mdi:equalizer",
+        "state": {
+          "off": "mdi:equalizer-outline"
+        }
+      },
       "pre_amp": {
         "default": "mdi:volume-high",
         "state": {

homeassistant/components/cambridge_audio/strings.json

@@ -65,6 +65,9 @@
       "early_update": {
         "name": "Early update"
       },
+      "equalizer": {
+        "name": "Equalizer"
+      },
       "pre_amp": {
         "name": "Pre-Amp"
       },

homeassistant/components/cambridge_audio/switch.py

@@ -33,6 +33,13 @@ def room_correction_enabled(client: StreamMagicClient) -> bool:
     return client.audio.tilt_eq.enabled
 
 
+def equalizer_enabled(client: StreamMagicClient) -> bool:
+    """Check if equalizer is enabled."""
+    if TYPE_CHECKING:
+        assert client.audio.user_eq is not None
+    return client.audio.user_eq.enabled
+
+
 CONTROL_ENTITIES: tuple[CambridgeAudioSwitchEntityDescription, ...] = (
     CambridgeAudioSwitchEntityDescription(
         key="pre_amp",
@@ -56,6 +63,14 @@ CONTROL_ENTITIES: tuple[CambridgeAudioSwitchEntityDescription, ...] = (
         value_fn=room_correction_enabled,
         set_value_fn=lambda client, value: client.set_room_correction_mode(value),
     ),
+    CambridgeAudioSwitchEntityDescription(
+        key="equalizer",
+        translation_key="equalizer",
+        entity_category=EntityCategory.CONFIG,
+        load_fn=lambda client: client.audio.user_eq is not None,
+        value_fn=equalizer_enabled,
+        set_value_fn=lambda client, value: client.set_equalizer_mode(value),
+    ),
 )
 
 

homeassistant/components/cast/media_player.py

@@ -807,6 +807,7 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
         # The lovelace app loops media to prevent timing out, don't show that
         if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:
             return MediaPlayerState.PLAYING
+
         if (media_status := self._media_status()[0]) is not None:
             if media_status.player_state == MEDIA_PLAYER_STATE_PLAYING:
                 return MediaPlayerState.PLAYING
@@ -817,19 +818,19 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
             if media_status.player_is_idle:
                 return MediaPlayerState.IDLE
 
-        if self._chromecast is not None and self._chromecast.is_idle:
-            # If library consider us idle, that is our off state
-            # it takes HDMI status into account for cast devices.
-            return MediaPlayerState.OFF
-
         if self.app_id in APP_IDS_UNRELIABLE_MEDIA_INFO:
             # Some apps don't report media status, show the player as playing
             return MediaPlayerState.PLAYING
 
-        if self.app_id is not None:
+        if self.app_id is not None and self.app_id != pychromecast.config.APP_BACKDROP:
             # We have an active app
             return MediaPlayerState.IDLE
 
+        if self._chromecast is not None and self._chromecast.is_idle:
+            # If library consider us idle, that is our off state
+            # it takes HDMI status into account for cast devices.
+            return MediaPlayerState.OFF
+
         return None
 
     @property

homeassistant/components/climate/trigger.py

@@ -43,7 +43,7 @@ HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend
 class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
     """Trigger for entity state changes."""
 
-    _domain = DOMAIN
+    _domains = {DOMAIN}
     _schema = HVAC_MODE_CHANGED_TRIGGER_SCHEMA
 
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:

homeassistant/components/compit/__init__.py

@@ -12,6 +12,7 @@ from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
+    Platform.FAN,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,

homeassistant/components/compit/fan.py

@@ -0,0 +1,172 @@
+"""Fan platform for Compit integration."""
+
+from typing import Any
+
+from compit_inext_api import PARAM_VALUES
+from compit_inext_api.consts import CompitParameter
+
+from homeassistant.components.fan import (
+    FanEntity,
+    FanEntityDescription,
+    FanEntityFeature,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util.percentage import (
+    ordered_list_item_to_percentage,
+    percentage_to_ordered_list_item,
+)
+
+from .const import DOMAIN, MANUFACTURER_NAME
+from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
+
+PARALLEL_UPDATES = 0
+
+COMPIT_GEAR_TO_HA = PARAM_VALUES[CompitParameter.VENTILATION_GEAR_TARGET]
+HA_STATE_TO_COMPIT = {value: key for key, value in COMPIT_GEAR_TO_HA.items()}
+
+
+DEVICE_DEFINITIONS: dict[int, FanEntityDescription] = {
+    223: FanEntityDescription(
+        key="Nano Color 2",
+        translation_key="ventilation",
+    ),
+    12: FanEntityDescription(
+        key="Nano Color",
+        translation_key="ventilation",
+    ),
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CompitConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Compit fan entities from a config entry."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        CompitFan(
+            coordinator,
+            device_id,
+            device_definition,
+        )
+        for device_id, device in coordinator.connector.all_devices.items()
+        if (device_definition := DEVICE_DEFINITIONS.get(device.definition.code))
+    )
+
+
+class CompitFan(CoordinatorEntity[CompitDataUpdateCoordinator], FanEntity):
+    """Representation of a Compit fan entity."""
+
+    _attr_speed_count = len(COMPIT_GEAR_TO_HA)
+    _attr_has_entity_name = True
+    _attr_name = None
+    _attr_supported_features = (
+        FanEntityFeature.TURN_ON
+        | FanEntityFeature.TURN_OFF
+        | FanEntityFeature.SET_SPEED
+    )
+
+    def __init__(
+        self,
+        coordinator: CompitDataUpdateCoordinator,
+        device_id: int,
+        entity_description: FanEntityDescription,
+    ) -> None:
+        """Initialize the fan entity."""
+        super().__init__(coordinator)
+        self.device_id = device_id
+        self.entity_description = entity_description
+        self._attr_unique_id = f"{device_id}_{entity_description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, str(device_id))},
+            name=entity_description.key,
+            manufacturer=MANUFACTURER_NAME,
+            model=entity_description.key,
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return (
+            super().available
+            and self.coordinator.connector.get_device(self.device_id) is not None
+        )
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the fan is on."""
+        value = self.coordinator.connector.get_current_option(
+            self.device_id, CompitParameter.VENTILATION_ON_OFF
+        )
+
+        return True if value == STATE_ON else False if value == STATE_OFF else None
+
+    async def async_turn_on(
+        self,
+        percentage: int | None = None,
+        preset_mode: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Turn on the fan."""
+        await self.coordinator.connector.select_device_option(
+            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_ON
+        )
+
+        if percentage is None:
+            self.async_write_ha_state()
+            return
+
+        await self.async_set_percentage(percentage)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the fan."""
+        await self.coordinator.connector.select_device_option(
+            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_OFF
+        )
+        self.async_write_ha_state()
+
+    @property
+    def percentage(self) -> int | None:
+        """Return the current fan speed as a percentage."""
+        if self.is_on is False:
+            return 0
+        mode = self.coordinator.connector.get_current_option(
+            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET
+        )
+        if mode is None:
+            return None
+        gear = COMPIT_GEAR_TO_HA.get(mode)
+        return (
+            None
+            if gear is None
+            else ordered_list_item_to_percentage(
+                list(COMPIT_GEAR_TO_HA.values()),
+                gear,
+            )
+        )
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        """Set the fan speed."""
+        if percentage == 0:
+            await self.async_turn_off()
+            return
+
+        gear = int(
+            percentage_to_ordered_list_item(
+                list(COMPIT_GEAR_TO_HA.values()),
+                percentage,
+            )
+        )
+        mode = HA_STATE_TO_COMPIT.get(gear)
+        if mode is None:
+            return
+
+        await self.coordinator.connector.select_device_option(
+            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET, mode
+        )
+        self.async_write_ha_state()

homeassistant/components/compit/icons.json

@@ -20,6 +20,14 @@
         "default": "mdi:alert"
       }
     },
+    "fan": {
+      "ventilation": {
+        "default": "mdi:fan",
+        "state": {
+          "off": "mdi:fan-off"
+        }
+      }
+    },
     "number": {
       "boiler_target_temperature": {
         "default": "mdi:water-boiler"

homeassistant/components/compit/strings.json

@@ -53,6 +53,11 @@
         "name": "Temperature alert"
       }
     },
+    "fan": {
+      "ventilation": {
+        "name": "[%key:component::fan::title%]"
+      }
+    },
     "number": {
       "boiler_target_temperature": {
         "name": "Boiler target temperature"
@@ -324,8 +329,8 @@
           "nano_nr_3": "Nano 3",
           "nano_nr_4": "Nano 4",
           "nano_nr_5": "Nano 5",
-          "off": "Off",
-          "on": "On",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]",
           "summer": "Summer",
           "winter": "Winter"
         }
@@ -363,8 +368,8 @@
       "pump_status": {
         "name": "Pump status",
         "state": {
-          "off": "Off",
-          "on": "On"
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
         }
       },
       "return_circuit_temperature": {

homeassistant/components/conversation/http.py

@@ -48,6 +48,8 @@ def async_setup(hass: HomeAssistant) -> None:
         vol.Optional("conversation_id"): vol.Any(str, None),
         vol.Optional("language"): str,
         vol.Optional("agent_id"): agent_id_validator,
+        vol.Optional("device_id"): vol.Any(str, None),
+        vol.Optional("satellite_id"): vol.Any(str, None),
     }
 )
 @websocket_api.async_response
@@ -64,6 +66,8 @@ async def websocket_process(
         context=connection.context(msg),
         language=msg.get("language"),
         agent_id=msg.get("agent_id"),
+        device_id=msg.get("device_id"),
+        satellite_id=msg.get("satellite_id"),
     )
     connection.send_result(msg["id"], result.as_dict())
 
@@ -248,6 +252,8 @@ class ConversationProcessView(http.HomeAssistantView):
                 vol.Optional("conversation_id"): str,
                 vol.Optional("language"): str,
                 vol.Optional("agent_id"): agent_id_validator,
+                vol.Optional("device_id"): vol.Any(str, None),
+                vol.Optional("satellite_id"): vol.Any(str, None),
             }
         )
     )
@@ -262,6 +268,8 @@ class ConversationProcessView(http.HomeAssistantView):
             context=self.context(request),
             language=data.get("language"),
             agent_id=data.get("agent_id"),
+            device_id=data.get("device_id"),
+            satellite_id=data.get("satellite_id"),
         )
 
         return self.json(result.as_dict())

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.2.13"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.3.3"]
 }

homeassistant/components/daikin/climate.py

@@ -112,11 +112,12 @@ def _zone_is_configured(zone: DaikinZone) -> bool:
 
 def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     """Return the decoded zone temperature lists."""
-    try:
-        heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
-        cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError:
+    values = device.values
+    if DAIKIN_ZONE_TEMP_HEAT not in values or DAIKIN_ZONE_TEMP_COOL not in values:
         return ([], [])
+
+    heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
+    cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
     return (list(heating or []), list(cooling or []))
 
 

homeassistant/components/demo/media_player.py

@@ -139,18 +139,6 @@ class AbstractDemoPlayer(MediaPlayerEntity):
         self._attr_is_volume_muted = mute
         self.schedule_update_ha_state()
 
-    def volume_up(self) -> None:
-        """Increase volume."""
-        assert self.volume_level is not None
-        self._attr_volume_level = min(1.0, self.volume_level + 0.1)
-        self.schedule_update_ha_state()
-
-    def volume_down(self) -> None:
-        """Decrease volume."""
-        assert self.volume_level is not None
-        self._attr_volume_level = max(0.0, self.volume_level - 0.1)
-        self.schedule_update_ha_state()
-
     def set_volume_level(self, volume: float) -> None:
         """Set the volume level, range 0..1."""
         self._attr_volume_level = volume

homeassistant/components/dsmr/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["dsmr_parser"],
-  "requirements": ["dsmr-parser==1.4.3"]
+  "requirements": ["dsmr-parser==1.5.0"]
 }

homeassistant/components/duke_energy/__init__.py

@@ -1,22 +0,0 @@
-"""The Duke Energy integration."""
-
-from __future__ import annotations
-
-from homeassistant.core import HomeAssistant
-
-from .coordinator import DukeEnergyConfigEntry, DukeEnergyCoordinator
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: DukeEnergyConfigEntry) -> bool:
-    """Set up Duke Energy from a config entry."""
-
-    coordinator = DukeEnergyCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: DukeEnergyConfigEntry) -> bool:
-    """Unload a config entry."""
-    return True

homeassistant/components/duke_energy/config_flow.py

@@ -1,67 +0,0 @@
-"""Config flow for Duke Energy integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from aiodukeenergy import DukeEnergy
-from aiohttp import ClientError, ClientResponseError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_USERNAME): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-
-class DukeEnergyConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Duke Energy."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            session = async_get_clientsession(self.hass)
-            api = DukeEnergy(
-                user_input[CONF_USERNAME], user_input[CONF_PASSWORD], session
-            )
-            try:
-                auth = await api.authenticate()
-            except ClientResponseError as e:
-                errors["base"] = "invalid_auth" if e.status == 404 else "cannot_connect"
-            except ClientError, TimeoutError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                username = auth["internalUserID"].lower()
-                await self.async_set_unique_id(username)
-                self._abort_if_unique_id_configured()
-                email = auth["loginEmailAddress"].lower()
-                data = {
-                    CONF_EMAIL: email,
-                    CONF_USERNAME: username,
-                    CONF_PASSWORD: user_input[CONF_PASSWORD],
-                }
-                self._async_abort_entries_match(data)
-                return self.async_create_entry(title=email, data=data)
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/duke_energy/const.py

@@ -1,3 +0,0 @@
-"""Constants for the Duke Energy integration."""
-
-DOMAIN = "duke_energy"

homeassistant/components/duke_energy/coordinator.py

@@ -1,222 +0,0 @@
-"""Coordinator to handle Duke Energy connections."""
-
-from datetime import datetime, timedelta
-import logging
-from typing import Any, cast
-
-from aiodukeenergy import DukeEnergy
-from aiohttp import ClientError
-
-from homeassistant.components.recorder import get_instance
-from homeassistant.components.recorder.models import (
-    StatisticData,
-    StatisticMeanType,
-    StatisticMetaData,
-)
-from homeassistant.components.recorder.statistics import (
-    async_add_external_statistics,
-    get_last_statistics,
-    statistics_during_period,
-)
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, UnitOfEnergy, UnitOfVolume
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from homeassistant.util import dt as dt_util
-from homeassistant.util.unit_conversion import EnergyConverter
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-_SUPPORTED_METER_TYPES = ("ELECTRIC",)
-
-type DukeEnergyConfigEntry = ConfigEntry[DukeEnergyCoordinator]
-
-
-class DukeEnergyCoordinator(DataUpdateCoordinator[None]):
-    """Handle inserting statistics."""
-
-    config_entry: DukeEnergyConfigEntry
-
-    def __init__(
-        self, hass: HomeAssistant, config_entry: DukeEnergyConfigEntry
-    ) -> None:
-        """Initialize the data handler."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name="Duke Energy",
-            # Data is updated daily on Duke Energy.
-            # Refresh every 12h to be at most 12h behind.
-            update_interval=timedelta(hours=12),
-        )
-        self.api = DukeEnergy(
-            config_entry.data[CONF_USERNAME],
-            config_entry.data[CONF_PASSWORD],
-            async_get_clientsession(hass),
-        )
-        self._statistic_ids: set = set()
-
-        @callback
-        def _dummy_listener() -> None:
-            pass
-
-        # Force the coordinator to periodically update by registering at least one listener.
-        # Duke Energy does not provide forecast data, so all information is historical.
-        # This makes _async_update_data get periodically called so we can insert statistics.
-        self.async_add_listener(_dummy_listener)
-
-        self.config_entry.async_on_unload(self._clear_statistics)
-
-    def _clear_statistics(self) -> None:
-        """Clear statistics."""
-        get_instance(self.hass).async_clear_statistics(list(self._statistic_ids))
-
-    async def _async_update_data(self) -> None:
-        """Insert Duke Energy statistics."""
-        meters: dict[str, dict[str, Any]] = await self.api.get_meters()
-        for serial_number, meter in meters.items():
-            if (
-                not isinstance(meter["serviceType"], str)
-                or meter["serviceType"] not in _SUPPORTED_METER_TYPES
-            ):
-                _LOGGER.debug(
-                    "Skipping unsupported meter type %s", meter["serviceType"]
-                )
-                continue
-
-            id_prefix = f"{meter['serviceType'].lower()}_{serial_number}"
-            consumption_statistic_id = f"{DOMAIN}:{id_prefix}_energy_consumption"
-            self._statistic_ids.add(consumption_statistic_id)
-            _LOGGER.debug(
-                "Updating Statistics for %s",
-                consumption_statistic_id,
-            )
-
-            last_stat = await get_instance(self.hass).async_add_executor_job(
-                get_last_statistics, self.hass, 1, consumption_statistic_id, True, set()
-            )
-            if not last_stat:
-                _LOGGER.debug("Updating statistic for the first time")
-                usage = await self._async_get_energy_usage(meter)
-                consumption_sum = 0.0
-                last_stats_time = None
-            else:
-                usage = await self._async_get_energy_usage(
-                    meter,
-                    last_stat[consumption_statistic_id][0]["start"],
-                )
-                if not usage:
-                    _LOGGER.debug("No recent usage data. Skipping update")
-                    continue
-                stats = await get_instance(self.hass).async_add_executor_job(
-                    statistics_during_period,
-                    self.hass,
-                    min(usage.keys()),
-                    None,
-                    {consumption_statistic_id},
-                    "hour",
-                    None,
-                    {"sum"},
-                )
-                consumption_sum = cast(float, stats[consumption_statistic_id][0]["sum"])
-                last_stats_time = stats[consumption_statistic_id][0]["start"]
-
-            consumption_statistics = []
-
-            for start, data in usage.items():
-                if last_stats_time is not None and start.timestamp() <= last_stats_time:
-                    continue
-                consumption_sum += data["energy"]
-
-                consumption_statistics.append(
-                    StatisticData(
-                        start=start, state=data["energy"], sum=consumption_sum
-                    )
-                )
-
-            name_prefix = (
-                f"Duke Energy {meter['serviceType'].capitalize()} {serial_number}"
-            )
-            consumption_metadata = StatisticMetaData(
-                mean_type=StatisticMeanType.NONE,
-                has_sum=True,
-                name=f"{name_prefix} Consumption",
-                source=DOMAIN,
-                statistic_id=consumption_statistic_id,
-                unit_class=EnergyConverter.UNIT_CLASS,
-                unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR
-                if meter["serviceType"] == "ELECTRIC"
-                else UnitOfVolume.CENTUM_CUBIC_FEET,
-            )
-
-            _LOGGER.debug(
-                "Adding %s statistics for %s",
-                len(consumption_statistics),
-                consumption_statistic_id,
-            )
-            async_add_external_statistics(
-                self.hass, consumption_metadata, consumption_statistics
-            )
-
-    async def _async_get_energy_usage(
-        self, meter: dict[str, Any], start_time: float | None = None
-    ) -> dict[datetime, dict[str, float | int]]:
-        """Get energy usage.
-
-        If start_time is None, get usage since account activation (or as far back as possible),
-        otherwise since start_time - 30 days to allow corrections in data.
-
-        Duke Energy provides hourly data all the way back to ~3 years.
-        """
-
-        # All of Duke Energy Service Areas are currently in America/New_York timezone
-        # May need to re-think this if that ever changes and determine timezone based
-        # on the service address somehow.
-        tz = await dt_util.async_get_time_zone("America/New_York")
-        lookback = timedelta(days=30)
-        one = timedelta(days=1)
-        if start_time is None:
-            # Max 3 years of data
-            start = dt_util.now(tz) - timedelta(days=3 * 365)
-        else:
-            start = datetime.fromtimestamp(start_time, tz=tz) - lookback
-        agreement_date = dt_util.parse_datetime(meter["agreementActiveDate"])
-        if agreement_date is not None:
-            start = max(agreement_date.replace(tzinfo=tz), start)
-
-        start = start.replace(hour=0, minute=0, second=0, microsecond=0)
-        end = dt_util.now(tz).replace(hour=0, minute=0, second=0, microsecond=0) - one
-        _LOGGER.debug("Data lookup range: %s - %s", start, end)
-
-        start_step = max(end - lookback, start)
-        end_step = end
-        usage: dict[datetime, dict[str, float | int]] = {}
-        while True:
-            _LOGGER.debug("Getting hourly usage: %s - %s", start_step, end_step)
-            try:
-                # Get data
-                results = await self.api.get_energy_usage(
-                    meter["serialNum"], "HOURLY", "DAY", start_step, end_step
-                )
-                usage = {**results["data"], **usage}
-
-                for missing in results["missing"]:
-                    _LOGGER.debug("Missing data: %s", missing)
-
-                # Set next range
-                end_step = start_step - one
-                start_step = max(start_step - lookback, start)
-
-                # Make sure we don't go back too far
-                if end_step < start:
-                    break
-            except TimeoutError, ClientError:
-                # ClientError is raised when there is no more data for the range
-                break
-
-        _LOGGER.debug("Got %s meter usage reads", len(usage))
-        return usage

homeassistant/components/duke_energy/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "duke_energy",
-  "name": "Duke Energy",
-  "codeowners": ["@hunterjm"],
-  "config_flow": true,
-  "dependencies": ["recorder"],
-  "documentation": "https://www.home-assistant.io/integrations/duke_energy",
-  "integration_type": "service",
-  "iot_class": "cloud_polling",
-  "requirements": ["aiodukeenergy==0.3.0"]
-}

homeassistant/components/duke_energy/strings.json

@@ -1,20 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        }
-      }
-    }
-  }
-}

homeassistant/components/dunehd/media_player.py

@@ -33,6 +33,8 @@ DUNEHD_PLAYER_SUPPORT: Final[MediaPlayerEntityFeature] = (
     | MediaPlayerEntityFeature.PLAY
     | MediaPlayerEntityFeature.PLAY_MEDIA
     | MediaPlayerEntityFeature.BROWSE_MEDIA
+    | MediaPlayerEntityFeature.VOLUME_STEP
+    | MediaPlayerEntityFeature.VOLUME_MUTE
 )
 
 

homeassistant/components/eafm/__init__.py

@@ -2,14 +2,39 @@
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
 
+from .const import DOMAIN
 from .coordinator import EafmConfigEntry, EafmCoordinator
 
 PLATFORMS = [Platform.SENSOR]
 
 
+def _fix_device_registry_identifiers(
+    hass: HomeAssistant, entry: EafmConfigEntry
+) -> None:
+    """Fix invalid identifiers in device registry.
+
+    Added in 2026.4, can be removed in 2026.10 or later.
+    """
+    device_registry = dr.async_get(hass)
+    for device_entry in dr.async_entries_for_config_entry(
+        device_registry, entry.entry_id
+    ):
+        old_identifier = (DOMAIN, "measure-id", entry.data["station"])
+        if old_identifier not in device_entry.identifiers:  # type: ignore[comparison-overlap]
+            continue
+        new_identifiers = device_entry.identifiers.copy()
+        new_identifiers.discard(old_identifier)  # type: ignore[arg-type]
+        new_identifiers.add((DOMAIN, entry.data["station"]))
+        device_registry.async_update_device(
+            device_entry.id, new_identifiers=new_identifiers
+        )
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: EafmConfigEntry) -> bool:
     """Set up flood monitoring sensors for this config entry."""
+    _fix_device_registry_identifiers(hass, entry)
     coordinator = EafmCoordinator(hass, entry=entry)
     await coordinator.async_config_entry_first_refresh()
     entry.runtime_data = coordinator

homeassistant/components/eafm/sensor.py

@@ -94,11 +94,11 @@ class Measurement(CoordinatorEntity, SensorEntity):
         return self.coordinator.data["measures"][self.key]["parameterName"]
 
     @property
-    def device_info(self):
+    def device_info(self) -> DeviceInfo:
         """Return the device info."""
         return DeviceInfo(
             entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, "measure-id", self.station_id)},
+            identifiers={(DOMAIN, self.station_id)},
             manufacturer="https://environment.data.gov.uk/",
             model=self.parameter_name,
             name=f"{self.station_name} {self.parameter_name} {self.qualifier}",

homeassistant/components/enphase_envoy/sensor.py

@@ -405,8 +405,13 @@ CT_SENSORS = (
         )
         for cttype, key in (
             (CtType.NET_CONSUMPTION, "lifetime_net_consumption"),
-            # Production CT energy_delivered is not used
+            (CtType.PRODUCTION, "production_ct_energy_delivered"),
             (CtType.STORAGE, "lifetime_battery_discharged"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_energy_delivered"),
+            (CtType.BACKFEED, "backfeed_ct_energy_delivered"),
+            (CtType.LOAD, "load_ct_energy_delivered"),
+            (CtType.EVSE, "evse_ct_energy_delivered"),
+            (CtType.PV3P, "pv3p_ct_energy_delivered"),
         )
     ]
     + [
@@ -423,8 +428,13 @@ CT_SENSORS = (
         )
         for cttype, key in (
             (CtType.NET_CONSUMPTION, "lifetime_net_production"),
-            # Production CT energy_received is not used
+            (CtType.PRODUCTION, "production_ct_energy_received"),
             (CtType.STORAGE, "lifetime_battery_charged"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_energy_received"),
+            (CtType.BACKFEED, "backfeed_ct_energy_received"),
+            (CtType.LOAD, "load_ct_energy_received"),
+            (CtType.EVSE, "evse_ct_energy_received"),
+            (CtType.PV3P, "pv3p_ct_energy_received"),
         )
     ]
     + [
@@ -441,8 +451,13 @@ CT_SENSORS = (
         )
         for cttype, key in (
             (CtType.NET_CONSUMPTION, "net_consumption"),
-            # Production CT active_power is not used
+            (CtType.PRODUCTION, "production_ct_power"),
             (CtType.STORAGE, "battery_discharge"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_power"),
+            (CtType.BACKFEED, "backfeed_ct_power"),
+            (CtType.LOAD, "load_ct_power"),
+            (CtType.EVSE, "evse_ct_power"),
+            (CtType.PV3P, "pv3p_ct_power"),
         )
     ]
     + [
@@ -461,6 +476,11 @@ CT_SENSORS = (
             (CtType.NET_CONSUMPTION, "frequency", "net_ct_frequency"),
             (CtType.PRODUCTION, "production_ct_frequency", ""),
             (CtType.STORAGE, "storage_ct_frequency", ""),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_frequency", ""),
+            (CtType.BACKFEED, "backfeed_ct_frequency", ""),
+            (CtType.LOAD, "load_ct_frequency", ""),
+            (CtType.EVSE, "evse_ct_frequency", ""),
+            (CtType.PV3P, "pv3p_ct_frequency", ""),
         )
     ]
     + [
@@ -480,6 +500,11 @@ CT_SENSORS = (
             (CtType.NET_CONSUMPTION, "voltage", "net_ct_voltage"),
             (CtType.PRODUCTION, "production_ct_voltage", ""),
             (CtType.STORAGE, "storage_voltage", "storage_ct_voltage"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_voltage", ""),
+            (CtType.BACKFEED, "backfeed_ct_voltage", ""),
+            (CtType.LOAD, "load_ct_voltage", ""),
+            (CtType.EVSE, "evse_ct_voltage", ""),
+            (CtType.PV3P, "pv3p_ct_voltage", ""),
         )
     ]
     + [
@@ -499,6 +524,11 @@ CT_SENSORS = (
             (CtType.NET_CONSUMPTION, "net_ct_current"),
             (CtType.PRODUCTION, "production_ct_current"),
             (CtType.STORAGE, "storage_ct_current"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_current"),
+            (CtType.BACKFEED, "backfeed_ct_current"),
+            (CtType.LOAD, "load_ct_current"),
+            (CtType.EVSE, "evse_ct_current"),
+            (CtType.PV3P, "pv3p_ct_current"),
         )
     ]
     + [
@@ -516,6 +546,11 @@ CT_SENSORS = (
             (CtType.NET_CONSUMPTION, "net_ct_powerfactor"),
             (CtType.PRODUCTION, "production_ct_powerfactor"),
             (CtType.STORAGE, "storage_ct_powerfactor"),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_powerfactor"),
+            (CtType.BACKFEED, "backfeed_ct_powerfactor"),
+            (CtType.LOAD, "load_ct_powerfactor"),
+            (CtType.EVSE, "evse_ct_powerfactor"),
+            (CtType.PV3P, "pv3p_ct_powerfactor"),
         )
     ]
     + [
@@ -537,6 +572,11 @@ CT_SENSORS = (
             ),
             (CtType.PRODUCTION, "production_ct_metering_status", ""),
             (CtType.STORAGE, "storage_ct_metering_status", ""),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_metering_status", ""),
+            (CtType.BACKFEED, "backfeed_ct_metering_status", ""),
+            (CtType.LOAD, "load_ct_metering_status", ""),
+            (CtType.EVSE, "evse_ct_metering_status", ""),
+            (CtType.PV3P, "pv3p_ct_metering_status", ""),
         )
     ]
     + [
@@ -557,6 +597,11 @@ CT_SENSORS = (
             ),
             (CtType.PRODUCTION, "production_ct_status_flags", ""),
             (CtType.STORAGE, "storage_ct_status_flags", ""),
+            (CtType.TOTAL_CONSUMPTION, "total_consumption_ct_status_flags", ""),
+            (CtType.BACKFEED, "backfeed_ct_status_flags", ""),
+            (CtType.LOAD, "load_ct_status_flags", ""),
+            (CtType.EVSE, "evse_ct_status_flags", ""),
+            (CtType.PV3P, "pv3p_ct_status_flags", ""),
         )
     ]
 )

homeassistant/components/enphase_envoy/strings.json

@@ -160,6 +160,60 @@
       "available_energy": {
         "name": "Available battery energy"
       },
+      "backfeed_ct_current": {
+        "name": "Backfeed CT current"
+      },
+      "backfeed_ct_current_phase": {
+        "name": "Backfeed CT current {phase_name}"
+      },
+      "backfeed_ct_energy_delivered": {
+        "name": "Backfeed CT energy delivered"
+      },
+      "backfeed_ct_energy_delivered_phase": {
+        "name": "Backfeed CT energy delivered {phase_name}"
+      },
+      "backfeed_ct_energy_received": {
+        "name": "Backfeed CT energy received"
+      },
+      "backfeed_ct_energy_received_phase": {
+        "name": "Backfeed CT energy received {phase_name}"
+      },
+      "backfeed_ct_frequency": {
+        "name": "Frequency backfeed CT"
+      },
+      "backfeed_ct_frequency_phase": {
+        "name": "Frequency backfeed CT {phase_name}"
+      },
+      "backfeed_ct_metering_status": {
+        "name": "Metering status backfeed CT"
+      },
+      "backfeed_ct_metering_status_phase": {
+        "name": "Metering status backfeed CT {phase_name}"
+      },
+      "backfeed_ct_power": {
+        "name": "Backfeed CT power"
+      },
+      "backfeed_ct_power_phase": {
+        "name": "Backfeed CT power {phase_name}"
+      },
+      "backfeed_ct_powerfactor": {
+        "name": "Power factor backfeed CT"
+      },
+      "backfeed_ct_powerfactor_phase": {
+        "name": "Power factor backfeed CT {phase_name}"
+      },
+      "backfeed_ct_status_flags": {
+        "name": "Meter status flags active backfeed CT"
+      },
+      "backfeed_ct_status_flags_phase": {
+        "name": "Meter status flags active backfeed CT {phase_name}"
+      },
+      "backfeed_ct_voltage": {
+        "name": "Voltage backfeed CT"
+      },
+      "backfeed_ct_voltage_phase": {
+        "name": "Voltage backfeed CT {phase_name}"
+      },
       "balanced_net_consumption": {
         "name": "Balanced net power consumption"
       },
@@ -211,6 +265,60 @@
       "energy_today": {
         "name": "[%key:component::enphase_envoy::entity::sensor::daily_production::name%]"
       },
+      "evse_ct_current": {
+        "name": "EVSE CT current"
+      },
+      "evse_ct_current_phase": {
+        "name": "EVSE CT current {phase_name}"
+      },
+      "evse_ct_energy_delivered": {
+        "name": "EVSE CT energy delivered"
+      },
+      "evse_ct_energy_delivered_phase": {
+        "name": "EVSE CT energy delivered {phase_name}"
+      },
+      "evse_ct_energy_received": {
+        "name": "EVSE CT energy received"
+      },
+      "evse_ct_energy_received_phase": {
+        "name": "EVSE CT energy received {phase_name}"
+      },
+      "evse_ct_frequency": {
+        "name": "Frequency EVSE CT"
+      },
+      "evse_ct_frequency_phase": {
+        "name": "Frequency EVSE CT {phase_name}"
+      },
+      "evse_ct_metering_status": {
+        "name": "Metering status EVSE CT"
+      },
+      "evse_ct_metering_status_phase": {
+        "name": "Metering status EVSE CT {phase_name}"
+      },
+      "evse_ct_power": {
+        "name": "EVSE CT power"
+      },
+      "evse_ct_power_phase": {
+        "name": "EVSE CT power {phase_name}"
+      },
+      "evse_ct_powerfactor": {
+        "name": "Power factor EVSE CT"
+      },
+      "evse_ct_powerfactor_phase": {
+        "name": "Power factor EVSE CT {phase_name}"
+      },
+      "evse_ct_status_flags": {
+        "name": "Meter status flags active EVSE CT"
+      },
+      "evse_ct_status_flags_phase": {
+        "name": "Meter status flags active EVSE CT {phase_name}"
+      },
+      "evse_ct_voltage": {
+        "name": "Voltage EVSE CT"
+      },
+      "evse_ct_voltage_phase": {
+        "name": "Voltage EVSE CT {phase_name}"
+      },
       "grid_status": {
         "name": "[%key:component::enphase_envoy::entity::binary_sensor::grid_status::name%]",
         "state": {
@@ -270,6 +378,60 @@
       "lifetime_production_phase": {
         "name": "Lifetime energy production {phase_name}"
       },
+      "load_ct_current": {
+        "name": "Load CT current"
+      },
+      "load_ct_current_phase": {
+        "name": "Load CT current {phase_name}"
+      },
+      "load_ct_energy_delivered": {
+        "name": "Load CT energy delivered"
+      },
+      "load_ct_energy_delivered_phase": {
+        "name": "Load CT energy delivered {phase_name}"
+      },
+      "load_ct_energy_received": {
+        "name": "Load CT energy received"
+      },
+      "load_ct_energy_received_phase": {
+        "name": "Load CT energy received {phase_name}"
+      },
+      "load_ct_frequency": {
+        "name": "Frequency load CT"
+      },
+      "load_ct_frequency_phase": {
+        "name": "Frequency load CT {phase_name}"
+      },
+      "load_ct_metering_status": {
+        "name": "Metering status load CT"
+      },
+      "load_ct_metering_status_phase": {
+        "name": "Metering status load CT {phase_name}"
+      },
+      "load_ct_power": {
+        "name": "Load CT power"
+      },
+      "load_ct_power_phase": {
+        "name": "Load CT power {phase_name}"
+      },
+      "load_ct_powerfactor": {
+        "name": "Power factor load CT"
+      },
+      "load_ct_powerfactor_phase": {
+        "name": "Power factor load CT {phase_name}"
+      },
+      "load_ct_status_flags": {
+        "name": "Meter status flags active load CT"
+      },
+      "load_ct_status_flags_phase": {
+        "name": "Meter status flags active load CT {phase_name}"
+      },
+      "load_ct_voltage": {
+        "name": "Voltage load CT"
+      },
+      "load_ct_voltage_phase": {
+        "name": "Voltage load CT {phase_name}"
+      },
       "max_capacity": {
         "name": "Battery capacity"
       },
@@ -331,6 +493,18 @@
       "production_ct_current_phase": {
         "name": "Production CT current {phase_name}"
       },
+      "production_ct_energy_delivered": {
+        "name": "Production CT energy delivered"
+      },
+      "production_ct_energy_delivered_phase": {
+        "name": "Production CT energy delivered {phase_name}"
+      },
+      "production_ct_energy_received": {
+        "name": "Production CT energy received"
+      },
+      "production_ct_energy_received_phase": {
+        "name": "Production CT energy received {phase_name}"
+      },
       "production_ct_frequency": {
         "name": "Frequency production CT"
       },
@@ -343,6 +517,12 @@
       "production_ct_metering_status_phase": {
         "name": "Metering status production CT {phase_name}"
       },
+      "production_ct_power": {
+        "name": "Production CT power"
+      },
+      "production_ct_power_phase": {
+        "name": "Production CT power {phase_name}"
+      },
       "production_ct_powerfactor": {
         "name": "Power factor production CT"
       },
@@ -361,6 +541,60 @@
       "production_ct_voltage_phase": {
         "name": "Voltage production CT {phase_name}"
       },
+      "pv3p_ct_current": {
+        "name": "PV3P CT current"
+      },
+      "pv3p_ct_current_phase": {
+        "name": "PV3P CT current {phase_name}"
+      },
+      "pv3p_ct_energy_delivered": {
+        "name": "PV3P CT energy delivered"
+      },
+      "pv3p_ct_energy_delivered_phase": {
+        "name": "PV3P CT energy delivered {phase_name}"
+      },
+      "pv3p_ct_energy_received": {
+        "name": "PV3P CT energy received"
+      },
+      "pv3p_ct_energy_received_phase": {
+        "name": "PV3P CT energy received {phase_name}"
+      },
+      "pv3p_ct_frequency": {
+        "name": "Frequency PV3P CT"
+      },
+      "pv3p_ct_frequency_phase": {
+        "name": "Frequency PV3P CT {phase_name}"
+      },
+      "pv3p_ct_metering_status": {
+        "name": "Metering status PV3P CT"
+      },
+      "pv3p_ct_metering_status_phase": {
+        "name": "Metering status PV3P CT {phase_name}"
+      },
+      "pv3p_ct_power": {
+        "name": "PV3P CT power"
+      },
+      "pv3p_ct_power_phase": {
+        "name": "PV3P CT power {phase_name}"
+      },
+      "pv3p_ct_powerfactor": {
+        "name": "Power factor PV3P CT"
+      },
+      "pv3p_ct_powerfactor_phase": {
+        "name": "Power factor PV3P CT {phase_name}"
+      },
+      "pv3p_ct_status_flags": {
+        "name": "Meter status flags active PV3P CT"
+      },
+      "pv3p_ct_status_flags_phase": {
+        "name": "Meter status flags active PV3P CT {phase_name}"
+      },
+      "pv3p_ct_voltage": {
+        "name": "Voltage PV3P CT"
+      },
+      "pv3p_ct_voltage_phase": {
+        "name": "Voltage PV3P CT {phase_name}"
+      },
       "reserve_energy": {
         "name": "Reserve battery energy"
       },
@@ -414,6 +648,60 @@
       },
       "storage_ct_voltage_phase": {
         "name": "Voltage storage CT {phase_name}"
+      },
+      "total_consumption_ct_current": {
+        "name": "Total consumption CT current"
+      },
+      "total_consumption_ct_current_phase": {
+        "name": "Total consumption CT current {phase_name}"
+      },
+      "total_consumption_ct_energy_delivered": {
+        "name": "Total consumption CT energy delivered"
+      },
+      "total_consumption_ct_energy_delivered_phase": {
+        "name": "Total consumption CT energy delivered {phase_name}"
+      },
+      "total_consumption_ct_energy_received": {
+        "name": "Total consumption CT energy received"
+      },
+      "total_consumption_ct_energy_received_phase": {
+        "name": "Total consumption CT energy received {phase_name}"
+      },
+      "total_consumption_ct_frequency": {
+        "name": "Frequency total consumption CT"
+      },
+      "total_consumption_ct_frequency_phase": {
+        "name": "Frequency total consumption CT {phase_name}"
+      },
+      "total_consumption_ct_metering_status": {
+        "name": "Metering status total consumption CT"
+      },
+      "total_consumption_ct_metering_status_phase": {
+        "name": "Metering status total consumption CT {phase_name}"
+      },
+      "total_consumption_ct_power": {
+        "name": "Total consumption CT power"
+      },
+      "total_consumption_ct_power_phase": {
+        "name": "Total consumption CT power {phase_name}"
+      },
+      "total_consumption_ct_powerfactor": {
+        "name": "Power factor total consumption CT"
+      },
+      "total_consumption_ct_powerfactor_phase": {
+        "name": "Power factor total consumption CT {phase_name}"
+      },
+      "total_consumption_ct_status_flags": {
+        "name": "Meter status flags active total consumption CT"
+      },
+      "total_consumption_ct_status_flags_phase": {
+        "name": "Meter status flags active total consumption CT {phase_name}"
+      },
+      "total_consumption_ct_voltage": {
+        "name": "Voltage total consumption CT"
+      },
+      "total_consumption_ct_voltage_phase": {
+        "name": "Voltage total consumption CT {phase_name}"
       }
     },
     "switch": {

homeassistant/components/environment_canada/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["env_canada"],
-  "requirements": ["env-canada==0.12.4"]
+  "requirements": ["env-canada==0.13.2"]
 }

homeassistant/components/esphome/assist_satellite.py

@@ -524,14 +524,10 @@ class EsphomeAssistSatellite(
         self._active_pipeline_index = 0
 
         maybe_pipeline_index = 0
-        while True:
-            if not (ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index)):
-                break
-
-            if not (ww_state := self.hass.states.get(ww_entity_id)):
-                continue
-
-            if ww_state.state == wake_word_phrase:
+        while ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index):
+            if (
+                ww_state := self.hass.states.get(ww_entity_id)
+            ) and ww_state.state == wake_word_phrase:
                 # First match
                 self._active_pipeline_index = maybe_pipeline_index
                 break

homeassistant/components/esphome/entity.py

@@ -189,6 +189,7 @@ async def platform_async_setup_entry(
     info_type: type[_InfoT],
     entity_type: type[_EntityT],
     state_type: type[_StateT],
+    info_filter: Callable[[_InfoT], bool] | None = None,
 ) -> None:
     """Set up an esphome platform.
 
@@ -208,10 +209,22 @@ async def platform_async_setup_entry(
         entity_type,
         state_type,
     )
+
+    if info_filter is not None:
+
+        def on_filtered_update(infos: list[EntityInfo]) -> None:
+            on_static_info_update(
+                [info for info in infos if info_filter(cast(_InfoT, info))]
+            )
+
+        info_callback = on_filtered_update
+    else:
+        info_callback = on_static_info_update
+
     entry_data.cleanup_callbacks.append(
         entry_data.async_register_static_info_callback(
             info_type,
-            on_static_info_update,
+            info_callback,
         )
     )
 

homeassistant/components/esphome/entry_data.py

@@ -29,6 +29,7 @@ from aioesphomeapi import (
     Event,
     EventInfo,
     FanInfo,
+    InfraredInfo,
     LightInfo,
     LockInfo,
     MediaPlayerInfo,
@@ -85,6 +86,7 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     DateTimeInfo: Platform.DATETIME,
     EventInfo: Platform.EVENT,
     FanInfo: Platform.FAN,
+    InfraredInfo: Platform.INFRARED,
     LightInfo: Platform.LIGHT,
     LockInfo: Platform.LOCK,
     MediaPlayerInfo: Platform.MEDIA_PLAYER,

homeassistant/components/esphome/infrared.py

@@ -0,0 +1,59 @@
+"""Infrared platform for ESPHome."""
+
+from __future__ import annotations
+
+from functools import partial
+import logging
+
+from aioesphomeapi import EntityState, InfraredCapability, InfraredInfo
+
+from homeassistant.components.infrared import InfraredCommand, InfraredEntity
+from homeassistant.core import callback
+
+from .entity import (
+    EsphomeEntity,
+    convert_api_error_ha_error,
+    platform_async_setup_entry,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 0
+
+
+class EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState], InfraredEntity):
+    """ESPHome infrared entity using native API."""
+
+    @callback
+    def _on_device_update(self) -> None:
+        """Call when device updates or entry data changes."""
+        super()._on_device_update()
+        if self._entry_data.available:
+            # Infrared entities should go available as soon as the device comes online
+            self.async_write_ha_state()
+
+    @convert_api_error_ha_error
+    async def async_send_command(self, command: InfraredCommand) -> None:
+        """Send an IR command."""
+        timings = [
+            interval
+            for timing in command.get_raw_timings()
+            for interval in (timing.high_us, -timing.low_us)
+        ]
+        _LOGGER.debug("Sending command: %s", timings)
+
+        self._client.infrared_rf_transmit_raw_timings(
+            self._static_info.key,
+            carrier_frequency=command.modulation,
+            timings=timings,
+            device_id=self._static_info.device_id,
+        )
+
+
+async_setup_entry = partial(
+    platform_async_setup_entry,
+    info_type=InfraredInfo,
+    entity_type=EsphomeInfraredEntity,
+    state_type=EntityState,
+    info_filter=lambda info: bool(info.capabilities & InfraredCapability.TRANSMITTER),
+)

homeassistant/components/esphome/light.py

@@ -241,7 +241,7 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
 
         if (color_temp_k := kwargs.get(ATTR_COLOR_TEMP_KELVIN)) is not None:
             # Do not use kelvin_to_mired here to prevent precision loss
-            data["color_temperature"] = 1000000.0 / color_temp_k
+            data["color_temperature"] = 1_000_000.0 / color_temp_k
             if color_temp_modes := _filter_color_modes(
                 color_modes, LightColorCapability.COLOR_TEMPERATURE
             ):

homeassistant/components/evohome/climate.py

@@ -36,19 +36,12 @@ from homeassistant.const import (
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
 
-from .const import (
-    ATTR_DURATION,
-    ATTR_DURATION_UNTIL,
-    ATTR_PERIOD,
-    ATTR_SETPOINT,
-    EVOHOME_DATA,
-    EvoService,
-)
+from .const import ATTR_DURATION, ATTR_PERIOD, DOMAIN, EVOHOME_DATA, EvoService
 from .coordinator import EvoDataUpdateCoordinator
 from .entity import EvoChild, EvoEntity
 
@@ -139,6 +132,24 @@ class EvoClimateEntity(EvoEntity, ClimateEntity):
     _attr_hvac_modes = [HVACMode.OFF, HVACMode.HEAT]
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
+    async def async_clear_zone_override(self) -> None:
+        """Clear the zone override; only supported by zones."""
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="zone_only_service",
+            translation_placeholders={"service": EvoService.CLEAR_ZONE_OVERRIDE},
+        )
+
+    async def async_set_zone_override(
+        self, setpoint: float, duration: timedelta | None = None
+    ) -> None:
+        """Set the zone override; only supported by zones."""
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="zone_only_service",
+            translation_placeholders={"service": EvoService.SET_ZONE_OVERRIDE},
+        )
+
 
 class EvoZone(EvoChild, EvoClimateEntity):
     """Base for any evohome-compatible heating zone."""
@@ -177,22 +188,22 @@ class EvoZone(EvoChild, EvoClimateEntity):
             | ClimateEntityFeature.TURN_ON
         )
 
-    async def async_zone_svc_request(self, service: str, data: dict[str, Any]) -> None:
-        """Process a service request (setpoint override) for a zone."""
-        if service == EvoService.RESET_ZONE_OVERRIDE:
-            await self.coordinator.call_client_api(self._evo_device.reset())
-            return
+    async def async_clear_zone_override(self) -> None:
+        """Clear the zone's override, if any."""
+        await self.coordinator.call_client_api(self._evo_device.reset())
 
-        # otherwise it is EvoService.SET_ZONE_OVERRIDE
-        temperature = max(min(data[ATTR_SETPOINT], self.max_temp), self.min_temp)
+    async def async_set_zone_override(
+        self, setpoint: float, duration: timedelta | None = None
+    ) -> None:
+        """Set the zone's override (mode/setpoint)."""
+        temperature = max(min(setpoint, self.max_temp), self.min_temp)
 
-        if ATTR_DURATION_UNTIL in data:
-            duration: timedelta = data[ATTR_DURATION_UNTIL]
+        if duration is not None:
             if duration.total_seconds() == 0:
                 await self._update_schedule()
                 until = self.setpoints.get("next_sp_from")
             else:
-                until = dt_util.now() + data[ATTR_DURATION_UNTIL]
+                until = dt_util.now() + duration
         else:
             until = None  # indefinitely
 

homeassistant/components/evohome/const.py

@@ -28,7 +28,6 @@ ATTR_PERIOD: Final = "period"  # number of days
 ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 
 ATTR_SETPOINT: Final = "setpoint"
-ATTR_DURATION_UNTIL: Final = "duration"
 
 
 @unique
@@ -39,4 +38,4 @@ class EvoService(StrEnum):
     SET_SYSTEM_MODE = "set_system_mode"
     RESET_SYSTEM = "reset_system"
     SET_ZONE_OVERRIDE = "set_zone_override"
-    RESET_ZONE_OVERRIDE = "clear_zone_override"
+    CLEAR_ZONE_OVERRIDE = "clear_zone_override"

homeassistant/components/evohome/entity.py

@@ -12,7 +12,7 @@ from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, EvoService
+from .const import DOMAIN
 from .coordinator import EvoDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -47,22 +47,12 @@ class EvoEntity(CoordinatorEntity[EvoDataUpdateCoordinator]):
             raise NotImplementedError
         if payload["unique_id"] != self._attr_unique_id:
             return
-        if payload["service"] in (
-            EvoService.SET_ZONE_OVERRIDE,
-            EvoService.RESET_ZONE_OVERRIDE,
-        ):
-            await self.async_zone_svc_request(payload["service"], payload["data"])
-            return
         await self.async_tcs_svc_request(payload["service"], payload["data"])
 
     async def async_tcs_svc_request(self, service: str, data: dict[str, Any]) -> None:
         """Process a service request (system mode) for a controller."""
         raise NotImplementedError
 
-    async def async_zone_svc_request(self, service: str, data: dict[str, Any]) -> None:
-        """Process a service request (setpoint override) for a zone."""
-        raise NotImplementedError
-
     @property
     def extra_state_attributes(self) -> Mapping[str, Any]:
         """Return the evohome-specific state attributes."""

homeassistant/components/evohome/services.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from typing import Final
+from typing import Any, Final
 
 from evohomeasync2.const import SZ_CAN_BE_TEMPORARY, SZ_SYSTEM_MODE, SZ_TIMING_MODE
 from evohomeasync2.schemas.const import (
@@ -13,40 +13,51 @@ from evohomeasync2.schemas.const import (
 )
 import voluptuous as vol
 
-from homeassistant.const import ATTR_ENTITY_ID, ATTR_MODE
+from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
+from homeassistant.const import ATTR_MODE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.service import verify_domain_control
 
-from .const import (
-    ATTR_DURATION,
-    ATTR_DURATION_UNTIL,
-    ATTR_PERIOD,
-    ATTR_SETPOINT,
-    DOMAIN,
-    EvoService,
-)
+from .const import ATTR_DURATION, ATTR_PERIOD, ATTR_SETPOINT, DOMAIN, EvoService
 from .coordinator import EvoDataUpdateCoordinator
 
 # system mode schemas are built dynamically when the services are registered
 # because supported modes can vary for edge-case systems
 
-RESET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
-    {vol.Required(ATTR_ENTITY_ID): cv.entity_id}
-)
-SET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
-    {
-        vol.Required(ATTR_ENTITY_ID): cv.entity_id,
-        vol.Required(ATTR_SETPOINT): vol.All(
-            vol.Coerce(float), vol.Range(min=4.0, max=35.0)
-        ),
-        vol.Optional(ATTR_DURATION_UNTIL): vol.All(
-            cv.time_period,
-            vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
-        ),
-    }
-)
+# Zone service schemas (registered as entity services)
+CLEAR_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {}
+SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
+    vol.Required(ATTR_SETPOINT): vol.All(
+        vol.Coerce(float), vol.Range(min=4.0, max=35.0)
+    ),
+    vol.Optional(ATTR_DURATION): vol.All(
+        cv.time_period,
+        vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
+    ),
+}
+
+
+def _register_zone_entity_services(hass: HomeAssistant) -> None:
+    """Register entity-level services for zones."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        EvoService.CLEAR_ZONE_OVERRIDE,
+        entity_domain=CLIMATE_DOMAIN,
+        schema=CLEAR_ZONE_OVERRIDE_SCHEMA,
+        func="async_clear_zone_override",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        EvoService.SET_ZONE_OVERRIDE,
+        entity_domain=CLIMATE_DOMAIN,
+        schema=SET_ZONE_OVERRIDE_SCHEMA,
+        func="async_set_zone_override",
+    )
 
 
 @callback
@@ -58,8 +69,6 @@ def setup_service_functions(
     Not all Honeywell TCC-compatible systems support all operating modes. In addition,
     each mode will require any of four distinct service schemas. This has to be
     enumerated before registering the appropriate handlers.
-
-    It appears that all TCC-compatible systems support the same three zones modes.
     """
 
     @verify_domain_control(DOMAIN)
@@ -79,28 +88,6 @@ def setup_service_functions(
         }
         async_dispatcher_send(hass, DOMAIN, payload)
 
-    @verify_domain_control(DOMAIN)
-    async def set_zone_override(call: ServiceCall) -> None:
-        """Set the zone override (setpoint)."""
-        entity_id = call.data[ATTR_ENTITY_ID]
-
-        registry = er.async_get(hass)
-        registry_entry = registry.async_get(entity_id)
-
-        if registry_entry is None or registry_entry.platform != DOMAIN:
-            raise ValueError(f"'{entity_id}' is not a known {DOMAIN} entity")
-
-        if registry_entry.domain != "climate":
-            raise ValueError(f"'{entity_id}' is not an {DOMAIN} controller/zone")
-
-        payload = {
-            "unique_id": registry_entry.unique_id,
-            "service": call.service,
-            "data": call.data,
-        }
-
-        async_dispatcher_send(hass, DOMAIN, payload)
-
     assert coordinator.tcs is not None  # mypy
 
     hass.services.async_register(DOMAIN, EvoService.REFRESH_SYSTEM, force_refresh)
@@ -163,16 +150,4 @@ def setup_service_functions(
             schema=vol.Schema(vol.Any(*system_mode_schemas)),
         )
 
-    # The zone modes are consistent across all systems and use the same schema
-    hass.services.async_register(
-        DOMAIN,
-        EvoService.RESET_ZONE_OVERRIDE,
-        set_zone_override,
-        schema=RESET_ZONE_OVERRIDE_SCHEMA,
-    )
-    hass.services.async_register(
-        DOMAIN,
-        EvoService.SET_ZONE_OVERRIDE,
-        set_zone_override,
-        schema=SET_ZONE_OVERRIDE_SCHEMA,
-    )
+    _register_zone_entity_services(hass)

homeassistant/components/evohome/services.yaml

@@ -28,14 +28,11 @@ reset_system:
 refresh_system:
 
 set_zone_override:
+  target:
+    entity:
+      integration: evohome
+      domain: climate
   fields:
-    entity_id:
-      required: true
-      example: climate.bathroom
-      selector:
-        entity:
-          integration: evohome
-          domain: climate
     setpoint:
       required: true
       selector:
@@ -49,10 +46,7 @@ set_zone_override:
         object:
 
 clear_zone_override:
-  fields:
-    entity_id:
-      required: true
-      selector:
-        entity:
-          integration: evohome
-          domain: climate
+  target:
+    entity:
+      integration: evohome
+      domain: climate

homeassistant/components/evohome/strings.json

@@ -1,13 +1,12 @@
 {
+  "exceptions": {
+    "zone_only_service": {
+      "message": "Only zones support the `{service}` action"
+    }
+  },
   "services": {
     "clear_zone_override": {
       "description": "Sets a zone to follow its schedule.",
-      "fields": {
-        "entity_id": {
-          "description": "[%key:component::evohome::services::set_zone_override::fields::entity_id::description%]",
-          "name": "[%key:component::evohome::services::set_zone_override::fields::entity_id::name%]"
-        }
-      },
       "name": "Clear zone override"
     },
     "refresh_system": {
@@ -43,10 +42,6 @@
           "description": "The zone will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
           "name": "Duration"
         },
-        "entity_id": {
-          "description": "The entity ID of the Evohome zone.",
-          "name": "Entity"
-        },
         "setpoint": {
           "description": "The temperature to be used instead of the scheduled setpoint.",
           "name": "Setpoint"

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260225.0"]
+  "requirements": ["home-assistant-frontend==20260302.0"]
 }

homeassistant/components/frontend/storage.py

@@ -45,6 +45,10 @@ async def async_user_store(hass: HomeAssistant, user_id: str) -> UserStore:
         except BaseException as ex:
             del stores[user_id]
             future.set_exception(ex)
+            # Ensure the future is marked as retrieved
+            # since if there is no concurrent call it
+            # will otherwise never be retrieved.
+            future.exception()
             raise
         future.set_result(store)
 

homeassistant/components/fully_kiosk/manifest.json

@@ -14,5 +14,5 @@
   "iot_class": "local_polling",
   "mqtt": ["fully/deviceInfo/+"],
   "quality_scale": "bronze",
-  "requirements": ["python-fullykiosk==0.0.14"]
+  "requirements": ["python-fullykiosk==0.0.15"]
 }

homeassistant/components/github/coordinator.py

@@ -78,6 +78,12 @@ query ($owner: String!, $repository: String!) {
         number
       }
     }
+    merged_pull_request: pullRequests(
+      first:1
+      states: MERGED
+    ) {
+      total: totalCount
+    }
     release: latestRelease {
       name
       url